commit 7aeab42440a49fc085e2513f29a8aeaf32a7e5dd Author: narnosnes Date: Fri Jun 9 13:47:37 2017 +0200 Initial Commit diff --git a/.travis.yml b/.travis.yml new file mode 100644 index 0000000..85d44c4 --- /dev/null +++ b/.travis.yml @@ -0,0 +1,18 @@ +language: c + +before_script: +- ./configure --enable-cross + +script: make 816-tcc + +before_deploy: +- zip -9ry 816-tcc.zip 816-tcc 816-opt.py + +deploy: + provider: releases + api-key: + - secure: "wrFShOH6+/tRv/uBJJlITaSPRa1Wh4WT1Sax3TgoohMzCARWS+ly/FyUvOFqBYA0qdInzw3Qhajd+FJxHikI0huyDCzeII/aata7CkuCw8tvteG6ayc2zcFGYDsD1lZovTZ0ryzpv65vnGc+I87jJ15v4sanb7rV0wIsABZ9UrIC1g26qINzSCQpbcLL7Saw3h0jhTOoDzwcSsBT+yVfJhGBgGpNsHOVf/YcJyLx6H+B2HSwcI0GA32k7sGBSM8H7oW37+XtCOi6Yl2kLhOXBuzRcTLkZSnFqBMgZ+kC4hsbLsiBHkbaEur+VqdZ/zihQdDptmV0fW2kYtR9/jxfRsQ/vcLLs9a+fnhmCdruhzoKMJ8NwFDxm9wieQMAyGu0x6mEFq0tCGyn1UsgVMLfCoQOEVSQKB2QZ0XN8Wq3NL1vCWD02qGs/8Klxp8HrslXMOT5uqdddMsUHRA1UcBbKfkmONNy27X7pkXb1owT0d3Tulet3YBaYRGYXNsbECf/MAsV8GUGsbDnXWn4kzwL9B9Sep53jr4QqNRF1o762k8E2ZMRbwF87e2HxE3TEKHDENm813l7p1g3aBu4pakZRVScpNZxJEJ+oLP8nMV+RskwAFygor/VGI/db4o7Jz+boEyq/5gmTU8A1VSqEYwx9GME6I4cE3y6P9TyHAc/6Ls=" + file: 816-tcc.zip + skip_cleanup: true + on: + tags: true diff --git a/816-gen.c b/816-gen.c new file mode 100644 index 0000000..6894cac --- /dev/null +++ b/816-gen.c @@ -0,0 +1,1296 @@ +/* + * WDC 65816 code generator for TCC + * + * Copyright (c) 2007 Ulrich Hecht + * + * Based on arm-gen.c by Daniel Glöckner + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#define LDOUBLE_SIZE 12 // not actually supported +#define LDOUBLE_ALIGN 4 +#define MAX_ALIGN 8 + +#define NB_REGS 15 + +#define RC_INT 0x0001 +#define RC_FLOAT 0x0002 +#define RC_R0 0x0004 +#define RC_R1 0x0008 +#define RC_R2 0x0010 +#define RC_R3 0x0020 +#define RC_R4 0x0040 +#define RC_R5 0x0080 +#define RC_R9 0x0100 +#define RC_R10 0x0200 +#define RC_F0 0x0400 +#define RC_F1 0x0800 +#define RC_F2 0x1000 +#define RC_F3 0x2000 +#define RC_NONE 0x8000 + +#define RC_IRET RC_R0 +#define RC_LRET RC_R1 +#define RC_FRET RC_F0 + +enum { + TREG_R0 = 0, + TREG_R1, + TREG_R2, + TREG_R3, + TREG_R4, + TREG_R5, + TREG_R9 = 9, + TREG_R10, + TREG_F0, + TREG_F1, + TREG_F2, + TREG_F3, +}; + +int reg_classes[NB_REGS] = { + RC_INT | RC_R0, + RC_INT | RC_R1, + RC_INT | RC_R2, + RC_INT | RC_R3, + RC_INT | RC_R4, + RC_INT | RC_R5, + RC_NONE, + RC_NONE, + RC_NONE, + RC_R9, + RC_R10, + RC_FLOAT | RC_F0, + RC_FLOAT | RC_F1, + RC_FLOAT | RC_F2, + RC_FLOAT | RC_F3, +}; + +#define REG_IRET TREG_R0 +#define REG_LRET TREG_R1 +#define REG_FRET TREG_F0 + +#define R_DATA_32 1 // whatever +#define R_JMP_SLOT 2 // whatever +#define R_COPY 3 // whatever + +#define ELF_PAGE_SIZE 0x1000 // whatever +#define ELF_START_ADDR 0x400 // made up + +#define PTR_SIZE 4 + +#define EM_TCC_TARGET EM_W65 + +#define LOCAL_LABEL "__local_%d" + +char current_fn[256] = ""; + +/* yet another terrible workaround + WLA does not have file-local symbols, only section-local and global. + thus, everything that is file-local must be made global and given a + unique name. not knowing how to choose one deterministically (filename? + could be more than one file with the same name...), I chose to use a + random number, saved to static_prefix. */ +char* static_prefix = "__tccs_"; + +char* label_workaround = NULL; +struct labels_816 { + char* name; + int pos; +}; +struct labels_816 label[1000]; +int labels = 0; + +char* get_sym_str(Sym* sym) +{ + static char name[256]; + char* symname; + + symname = get_tok_str(sym->v, NULL); + + name[0] = 0; + /* if static, add prefix */ + if(sym->type.t & VT_STATIC) { + //fprintf(stderr,"sym %s type 0x%x current_fn %s token %d\n",symname,sym->type.t,current_fn,sym->v); + if((sym->type.t & VT_STATICLOCAL) && current_fn[0] != 0 && !((sym->type.t & VT_BTYPE) == VT_FUNC)) + sprintf(name, "%s_FUNC_%s_", static_prefix, current_fn); + else + strcpy(name, static_prefix); + } + + /* add symbol name */ + strcat(name, symname); + + //fprintf(stderr,"symbol %s type 0x%x\n", name, sym->type.t); + return name; +} + +/* XXX: make it faster ? */ +void g(int c) +{ + int ind1; + ind1 = ind + 1; + if (ind1 > cur_text_section->data_allocated) + section_realloc(cur_text_section, ind1); + cur_text_section->data[ind] = c; + ind = ind1; +} + +void s(char* str) +{ + for(;*str;str++) g(*str); +} + +char line[256]; +#define pr(x...) do { sprintf(line, x); s(line); } while(0) + +int jump[1000][2]; +int jumps = 0; + + +void gsym_addr(int t, int a) +{ + /* code at t wants to jump to a */ + //fprintf(stderr, "gsymming t 0x%x a 0x%x\n", t, a); + pr("; gsym_addr t %d a %d ind %d\n",t,a,ind); + /* the label generation code sets this for us so we know when a symbol + is a label and what its name is, so that we can remember its name + and position so the output code can insert it correctly */ + if(label_workaround) { + //fprintf("setting label %s to a %d (t %d)\n", label_workaround, a, t); + label[labels].name = label_workaround; + label[labels].pos = a; + labels++; + label_workaround = NULL; + } + int i; + // pair up the jump with the target address + // the tcc_output_... function will add a + // label __local_ at a when writing the output + int found = 0; + for(i = 0; i < jumps; i++) { + if(jump[i][0] == t) jump[i][1] = a; + found = 1; + } + if(!found) pr("; ERROR no jump found to patch\n"); +} + +void gsym(int t) +{ + gsym_addr(t,ind); +} + +int stack_back = 0; +int adjust_stack(int fc, int disp) +{ + pr("; stack adjust: fc + disp - loc %d\n", fc + disp - loc); + if(fc + disp - loc < 256) { stack_back = 0; return fc; } + stack_back = -loc + fc; + pr("tsc\nclc\nadc.w #%d\ntcs\n", stack_back); + return fc - stack_back; +} + +int restore_stack(int fc) +{ + if(!stack_back) return fc; + pr("tsc\nsec\nsbc.w #%d\ntcs\n", stack_back); + return fc + stack_back; +} + +// this used to be local to gfunc_call, but we need it to get the correct +// stack pointer displacement while building the argument stack for +// a function call +int args_size = 0; + +int ll_workaround = 0; + +void load(int r, SValue* sv) +{ + int fr,ft,fc; + int length; + int align; + int v,sign,t; + SValue v1; + pr("; load %d\n",r); + pr("; type %d reg 0x%x extra 0x%x\n",sv->type.t,sv->r,sv->type.extra); + fr = sv->r; + ft = sv->type.t; + fc = sv->c.ul; + + length = type_size(&sv->type, &align); + if((ft & VT_BTYPE) == VT_LLONG) length = 2; // long longs are handled word-wise + if(ll_workaround) length = 4; + + //pr("; load r 0x%x fr 0x%x ft 0x%x fc 0x%x\n",r,fr,ft,fc); + + int base = -1; + v = fr & VT_VALMASK; + if(fr & VT_LVAL) { + if(v == VT_LLOCAL) { + v1.type.t = VT_PTR; + v1.r = VT_LOCAL | VT_LVAL; + v1.c.ul = sv->c.ul; + load(base=10 /* lr */, &v1); + fc=sign=0; + v=VT_LOCAL; + } + else if(v == VT_CONST) { + if(fr & VT_SYM) { // deref symbol + displacement + char* sy = get_sym_str(sv->sym); + if(is_float(ft)) { + pr("; fld%d [%s + %d], tcc__f%d\n", length, sy, fc, r - TREG_F0); + switch(length) { + case 4: pr("lda.l %s + %d\nsta.b tcc__f%d\nlda.l %s + %d + 2\nsta.b tcc__f%dh\n", sy, fc, r - TREG_F0, sy, fc, r - TREG_F0); break; + default: error("ICE 1"); + } + } + else { + pr("; ld%d [%s + %d], tcc__r%d\n", length, sy, fc, r); + // FIXME: This implementation is moronic + if(fc > 65535) error("index too big"); + switch(length) { + case 1: + pr("lda.w #0\nsep #$20\nlda.l %s + %d\nrep #$20\n", sy, fc); + if(!(ft & VT_UNSIGNED)) pr("xba\nxba\nbpl +\nora.w #$ff00\n+\n"); + pr("sta.b tcc__r%d\n", r); + break; + case 2: pr("lda.l %s + %d\nsta.b tcc__r%d\n", sy, fc, r); break; + case 4: pr("lda.l %s + %d\nsta.b tcc__r%d\nlda.l %s + %d + 2\nsta.b tcc__r%dh\n", sy, fc, r, sy, fc, r); break; + default: error("ICE 1"); + } + } + } + else { // deref constant pointer + //error("ld [%d],tcc__r%d\n",fc,r); + pr("; deref constant ptr ld [%d],tcc__r%d\n", fc, r); + if(is_float(ft)) { + error("dereferencing constant float pointers unimplemented\n"); + } + else { + switch(length) { + case 1: + pr("lda.w #0\nsep #$20\nlda.l %d\nrep #$20\n", fc); + if(!(ft & VT_UNSIGNED)) pr("xba\nxba\nbpl +\nora.w #$ff00\n+\n"); + pr("sta.b tcc__r%d\n", r); + break; + case 2: pr("lda.l %d\nsta.b tcc__r%d\n", fc, r); break; + case 4: pr("lda.l %d\nsta.b tcc__r%d\nlda.l %d + 2\nsta.b tcc__r%dh\n", fc, r, fc, r); break; + default: error("ICE 1"); + } + } + } + return; + } + else if(v < VT_CONST) { // deref pointer in register + base = v; + fc = sign = 0; + v = VT_LOCAL; + } + + if(v == VT_LOCAL) { + if(is_float(ft)) { + if(base == -1) { + pr("; fld%d [sp,%d],tcc__f%d\n", length, fc, r - TREG_F0); + if(length != 4) error("ICE 2f"); + fc = adjust_stack(fc, args_size + 2); + pr("lda %d + __%s_locals + 1,s\nsta.b tcc__f%d\nlda %d + __%s_locals + 1,s\nsta.b tcc__f%dh\n", fc+args_size, current_fn, r - TREG_F0, fc+args_size+2, current_fn, r - TREG_F0); + fc = restore_stack(fc); + } + else { + pr("; fld%d [tcc__r%d,%d],tcc__f%d\n", length, base, fc, r - TREG_F0); + if(length != 4) error("ICE 3f"); + pr("ldy #%d\nlda.b [tcc__r%d],y\nsta.b tcc__f%d\niny\niny\nlda.b [tcc__r%d], y\nsta.b tcc__f%dh\n", fc, base, r - TREG_F0, base, r - TREG_F0); + } + } + else { + if(base == -1) { // value of local at fc + pr("; ld%d [sp,%d],tcc__r%d\n",length,fc,r); + fc = adjust_stack(fc, args_size + 2); + switch(length) { + case 1: + pr("lda.w #0\nsep #$20\nlda %d + __%s_locals + 1,s\nrep #$20\n", fc+args_size, current_fn); + if(!(ft & VT_UNSIGNED)) pr("xba\nxba\nbpl +\nora.w #$ff00\n+\n"); + pr("sta.b tcc__r%d\n", r); + break; + case 2: pr("lda %d + __%s_locals + 1,s\nsta.b tcc__r%d\n", fc+args_size, current_fn, r); break; + case 4: pr("lda %d + __%s_locals + 1,s\nsta.b tcc__r%d\nlda %d + __%s_locals + 1,s\nsta.b tcc__r%dh\n", fc+args_size, current_fn, r, fc+args_size + 2, current_fn, r); break; + default: error("ICE 2"); break; + } + fc = restore_stack(fc); + } + else { // value of array member r[fc] + pr("; ld%d [tcc__r%d,%d],tcc__r%d\n",length, base, fc, r); + switch(length) { + case 1: + pr("lda.w #0\n"); + if(!fc) pr("sep #$20\nlda.b [tcc__r%d]\nrep #$20\n", base); + else pr("ldy #%d\nsep #$20\nlda.b [tcc__r%d],y\nrep #$20\n", fc, base); + if(!(ft & VT_UNSIGNED)) pr("xba\nxba\nbpl +\nora.w #$ff00\n+\n"); + pr("sta.b tcc__r%d\n", r); + break; + case 2: + if(!fc) pr("lda.b [tcc__r%d]\nsta.b tcc__r%d\n", base, r); + else pr("ldy #%d\nlda.b [tcc__r%d],y\nsta.b tcc__r%d\n", fc, base, r); + break; + case 4: pr("ldy #%d\nlda.b [tcc__r%d],y\nsta.b tcc__r%d\niny\niny\nlda.b [tcc__r%d],y\nsta.b tcc__r%dh\n", fc, base, r, base, r); break; + default: error("ICE 3"); break; + } + } + } + return; + } + } else { // VT_LVAL + if(v == VT_CONST) { + if(fr & VT_SYM) { // symbolic constant + char* sy = get_sym_str(sv->sym); + pr("; ld%d #%s + %d, tcc__r%d (type 0x%x)\n", length,sy, fc, r, ft); + if(length != PTR_SIZE) pr("; FISHY! length <> PTR_SIZE! (may be an array)\n"); + pr("lda.w #:%s\nsta.b tcc__r%dh\nlda.w #%s + %d\nsta.b tcc__r%d\n", sy, r, sy, fc, r); + } + else { // numeric constant + pr("; ld%d #%d,tcc__r%d\n",length,sv->c.ul,r); + if((ft & VT_BTYPE) == VT_BOOL) { + sv->c.ul = sv->c.ul? 1: 0; + } + switch(length) { + case 1: + if (ft & VT_UNSIGNED) { + pr("lda.w #%d\n", sv->c.ul & 0xff); + } + else { + pr("lda.w #%d\n", ((short)((sv->c.ul & 0xff) << 8)) >> 8); + } + pr("sta.b tcc__r%d\n", r); + break; + case 2: pr("lda.w #%d\nsta.b tcc__r%d\n", sv->c.ul & 0xffff, r); break; + case 4: pr("lda.w #%d\nsta.b tcc__r%d\nlda.w #%d\nsta.b tcc__r%dh\n", sv->c.ul & 0xffff, r, sv->c.ul >> 16, r); break; + default: error("ICE 4"); + } + } + return; + } + else if(v == VT_LOCAL) { + if(fr & VT_SYM) { + error("symbol"); + char* sy = get_sym_str(sv->sym); + pr("; LOCAL ld%d #%s, tcc__r%d (type 0x%x)\n", length,sy, r, ft); + } + else { // local pointer + pr("; ld%d #(sp) + %d,tcc__r%d (fr 0x%x ft 0x%x fc 0x%x)\n",length,sv->c.ul,r,fr,ft,fc); + // pointer; have to ensure the upper word is correct (page 0) + pr("stz.b tcc__r%dh\ntsa\nclc\nadc #(%d + __%s_locals + 1)\nsta.b tcc__r%d\n", r, sv->c.ul + args_size, current_fn, r); + } + return; + } + else if(v == VT_CMP) { + error("cmp"); + return; + } + else if(v == VT_JMP || v == VT_JMPI) { + t = v & 1; // inverted or not + pr("; jmpr(i) v 0x%x r 0x%x fc 0x%x\n",v,r,fc); + pr("lda #%d\nbra +\n", t); + gsym(fc); + pr("lda #%d\n+\nsta.b tcc__r%d\n", t^1, r); // stz rXh seems to be unnecessary (we only look at the lower word) + return; + } + else if(v < VT_CONST) { // register value + if(is_float(ft)) { + v -= TREG_F0; + r -= TREG_F0; + pr("; fmov tcc__f%d, tcc__f%d\n", v, r); + pr("lda.b tcc__f%d\nsta.b tcc__f%d\nlda.b tcc__f%dh\nsta.b tcc__f%dh\n", v, r, v, r); + } + else { + pr("; mov tcc__r%d, tcc__r%d\n",v,r); + pr("lda.b tcc__r%d\nsta.b tcc__r%d\nlda.b tcc__r%dh\nsta.b tcc__r%dh\n", v, r, v, r); + } + return; + } + } + error("load unimplemented"); +} + +void store(int r, SValue* sv) +{ + int v, ft, fc, fr, sign; + int base; + int length, align; + SValue v1; + + fr = sv->r; + ft = sv->type.t; + fc = sv->c.i; + + length = type_size(&sv->type, &align); + if((ft & VT_BTYPE) == VT_LLONG) length = 2; // long longs are handled word-wise + + pr("; store r 0x%x fr 0x%x ft 0x%x fc 0x%x\n",r,fr,ft,fc); + + v = fr & VT_VALMASK; + base = -1; + if ((fr & VT_LVAL) || fr == VT_LOCAL) { + if(v < VT_CONST) { // deref register + base = v; + v=VT_LOCAL; + fc=sign=0; // no clue... + } + if(v == VT_CONST) { + if(fr & VT_SYM) { // deref symbol + char* sy = get_sym_str(sv->sym); + if(r >= TREG_F0) pr("; fst%d tcc__f%d, [%s,%d]\n", length, r - TREG_F0, sy, fc); + else pr("; st%d tcc__r%d, [%s,%d]\n", length, r, sy, fc); + if(r >= TREG_F0 && length != 4) error("illegal float store of length %d", length); + switch(length) { + case 1: pr("sep #$20\nlda.b tcc__r%d\nsta.l %s + %d\nrep #$20\n", r, sy, fc); break; + case 2: pr("lda.b tcc__r%d\nsta.l %s + %d\n", r, sy, fc); break; + case 4: + if(r >= TREG_F0) + pr("lda.b tcc__f%d\nsta.l %s + %d\nlda.b tcc__f%dh\nsta.l %s + %d + 2\n", r - TREG_F0, sy, fc, r - TREG_F0, sy, fc); + else + pr("lda.b tcc__r%d\nsta.l %s + %d\nlda.b tcc__r%dh\nsta.l %s + %d + 2\n", r, sy, fc, r, sy, fc); + break; + default: error("ICE 5"); break; + } + return; + } + else { + v1.type.t = VT_PTR; //ft; + v1.r = fr & ~VT_LVAL; + v1.c.ul = sv->c.ul; + v1.sym = sv->sym; + load(base=9,&v1); + fc = sign = 0; + v = VT_LOCAL; + } + } + if(v == VT_LOCAL) { + if(r >= TREG_F0) { + if(base < 0) { + pr("; fst%d tcc__f%d, [sp,%d]\n", length, r - TREG_F0, fc); + fc = adjust_stack(fc, args_size + 2); + switch(length) { + case 4: pr("lda.b tcc__f%d\nsta %d + __%s_locals + 1,s\nlda.b tcc__f%dh\nsta %d + __%s_locals + 1,s\n", r - TREG_F0, fc+args_size, current_fn, r - TREG_F0, fc+args_size + 2, current_fn); break; + default: error("ICE 6f"); break; + } + fc = restore_stack(fc); + } + else { + pr("; fst%d tcc__f%d, [tcc__r%d,%d]\n", length, r - TREG_F0, base, fc); + switch(length) { + case 4: pr("ldy.w #0\nlda.b tcc__f%d\nsta.b [tcc__r%d],y\niny\niny\nlda.b tcc__f%dh\nsta.b [tcc__r%d],y\n", r - TREG_F0, base, r - TREG_F0, base); break; + default: error("ICE 7f"); break; + } + } + return; + } else { + if(base < 0) { // write to local at fc + pr("; st%d tcc__r%d, [sp,%d]\n",length,r,fc); + fc = adjust_stack(fc, args_size + 2); + switch(length) { + case 1: pr("sep #$20\nlda.b tcc__r%d\nsta %d + __%s_locals + 1,s\nrep #$20\n", r, fc+args_size, current_fn); break; + case 2: pr("lda.b tcc__r%d\nsta %d + __%s_locals + 1,s\n", r, fc+args_size, current_fn); break; + case 4: pr("lda.b tcc__r%d\nsta %d + __%s_locals + 1,s\nlda.b tcc__r%dh\nsta %d + __%s_locals + 1,s\n", r, fc+args_size, current_fn, r, fc+args_size + 2, current_fn); break; + default: error("ICE 6"); break; + } + fc = restore_stack(fc); + } + else { // write to array member r[fc] + pr("; st%d tcc__r%d, [tcc__r%d,%d]\n",length,r,base,fc); + switch(length) { + case 1: + pr("sep #$20\nlda.b tcc__r%d\n", r); + if(!fc) pr("sta.b [tcc__r%d]\nrep #$20\n", base); + else pr("ldy #%d\nsta.b [tcc__r%d],y\nrep #$20\n", fc, base); + break; + case 2: + pr("lda.b tcc__r%d\n", r); + if(!fc) pr("sta.b [tcc__r%d]\n", base); + else pr("ldy #%d\nsta.b [tcc__r%d],y\n", fc, base); + break; + case 4: pr("lda.b tcc__r%d\nldy #%d\nsta.b [tcc__r%d],y\nlda.b tcc__r%dh\niny\niny\nsta.b [tcc__r%d],y\n", r, fc, base, r, base); break; + default: error("ICE 7"); break; + } + } + } + return; + } + } + error("store unimplemented"); + +} + +void gfunc_call(int nb_args) +{ + int align, r, i, func_call; + Sym *func_sym; + + int length; + + /* args_size is the size of the function call arguments already + pushed on the stack. needed so that loads and stores to + locals on the stack still work while building an argument + list. needs to be restored before returning to make + nested function calls work (passing structs by value causes + a memcpy call) */ + int restore_args_size = args_size; + + for(i = 0;i < nb_args; i++) { + + length = type_size(&vtop->type, &align); + if(vtop->type.t & VT_ARRAY) length = PTR_SIZE; + + if ((vtop->type.t & VT_BTYPE) == VT_STRUCT) { + /* allocate the necessary size on stack */ + pr("; sub sp, #%d\n",length); + pr("tsa\nsec\nsbc #%d\ntas\n", length); + args_size += length; + + /* generate structure store */ + r = get_reg(RC_INT); + /* put the pointer to struct store on the stack + always remember: the 65xxs are off-by-one processors + there is always something to increment or decrement to + get the value you actually want. (cf. mvn/mvp) */ + pr("stz.b tcc__r%dh\ntsa\nina\nsta.b tcc__r%d\n",r,r); + + /* here, TCC generates a memcpy call + this recursion makes the restore_args_size stuff necessary */ + vset(&vtop->type, r | VT_LVAL, 0); + vswap(); + vstore(); + } else if (is_float(vtop->type.t)) { + if(length != 4) error("unknown float size %d\n", length); + r = gv(RC_FLOAT); + pr("; fldpush%d (type 0x%x reg 0x%x) tcc__f%d\n", length, vtop->type.t, vtop->r, r - TREG_F0); + pr("pei (tcc__f%dh)\npei (tcc__f%d)\n", r - TREG_F0, r - TREG_F0); + args_size += length; + } else { + /* simple type (currently always same size) */ + /* XXX: implicit cast ? */ + if(((vtop->r & VT_VALMASK) == VT_CONST) && ((vtop->r & VT_LVAL) == 0)) { + // push immediate + pr("; push%d imm r 0x%x\n",length,vtop->r); + if(vtop->r & VT_SYM) { + char* sy = get_sym_str(vtop->sym); + if(length != PTR_SIZE) pr("; FISHY! length <> PTR_SIZE! (may be an array)\n"); + pr("pea.w :%s\npea.w %s %c %d\n", sy, sy, vtop->c.i < 0 ? '-' : '+', abs(vtop->c.i)); + length = PTR_SIZE; + } + else { + switch(length) { + case 1: pr("sep #$20\nlda #%d\npha\nrep #$20\n", vtop->c.ul & 0xff); break; + case 2: pr("pea.w %d\n", vtop->c.ul & 0xffff); break; + case 4: + pr("pea.w %d\npea.w %d\n", vtop->c.ul >> 16, vtop->c.ul & 0xffff); + break; + default: error("cannot push %d-byte immediate", length); break; + } + } + } + else { + // load to register, then push + pr("; ldpush before load type 0x%x reg 0x%x\n", vtop->type.t, vtop->r); + r = gv(RC_INT); + pr("; ldpush%d (type 0x%x reg 0x%x) tcc__r%d\n", length, vtop->type.t, vtop->r, r); + switch(length) { + case 1: pr("sep #$20\nlda.b tcc__r%d\npha\nrep #$20\n", r); break; + //case 2: pr("lda.b tcc__r%d\npha\n", r); break; + case 2: pr("pei (tcc__r%d)\n", r); break; + case 4: + if((vtop->type.t & VT_BTYPE) == VT_LLONG) { + //pr("lda.b tcc__r%d\npha\nlda.b tcc__r%d\npha\n", vtop->r2, r); + pr("pei (tcc__r%d)\npei (tcc__r%d)\n", vtop->r2, r); + } + //else pr("lda.b tcc__r%dh\npha\nlda.b tcc__r%d\npha\n", r, r); + else pr("pei (tcc__r%dh)\npei (tcc__r%d)\n", r, r); + break; + default: error("cannot push %d-byte from register", length); break; + } + } + args_size += length; + } + vtop--; + } + save_regs(0); /* save used temporary registers */ + func_sym = vtop->type.ref; + func_call = func_sym->r; + + /* fast call case */ + if (func_call >= FUNC_FASTCALL1 && func_call <= FUNC_FASTCALL3) { + error("fastcall"); + } + + pr("; call r 0x%x\n",vtop->r); + if(vtop->r & VT_LVAL) { + // call a function pointer + if((vtop->r & VT_VALMASK) == VT_LLOCAL) { + SValue v1; + v1.type.t = VT_PTR; + v1.r = VT_LOCAL | VT_LVAL; + v1.c.ul = vtop->c.ul; + load(9, &v1); + // the 65816 is two stoopid to do a jsl [r10], so we have to jump thru a hoop here + pr("; eins\njsr.l tcc__jsl_ind_r9\n"); + } + else { // call a symbolic function pointer + pr("; symfpcall vtop->sym %p vtop->r 0x%x vtop->type.t 0x%x c 0x%x\n", vtop->sym, vtop->r, vtop->type.t, vtop->c.ui); + gv(RC_R10); + pr("; zwei\njsr.l tcc__jsl_r10\n"); + } + } + else + pr("jsr.l %s\n", get_sym_str(vtop->sym)); + + if (args_size - restore_args_size && func_sym->r != FUNC_STDCALL) { + pr("; add sp, #%d\n",args_size - restore_args_size); + // pull the arguments off the stack + if(args_size - restore_args_size == 2) pr("pla\n"); + else pr("tsa\nclc\nadc #%d\ntas\n",args_size - restore_args_size); + } + args_size = restore_args_size; + vtop--; +} + +int gjmp(int t) +{ + int r; + int i; + // remember this jump so we can insert a label before the destination later + pr("; gjmp_addr %d at %d\n",t,ind); + pr("jmp.w " LOCAL_LABEL "\n",jumps); + r = ind; + jump[jumps][0] = r; + for(i = 0; i < jumps; i++) { + if(jump[i][0] == t) { // the jump target is a jump itself; make it go to same place as this one + jump[i][0] = r; + } + } + jumps++; + gsym_addr(r,t); + return r; +} + +void gjmp_addr(int a) +{ + gjmp(a); +} + +int gtst(int inv, int t) +{ + int v,r; + v = vtop->r & VT_VALMASK; + r = ind; + pr("; gtst inv %d t %d v %d r %d ind %d\n",inv,t,v,r,ind); + if(v == VT_CMP) { + pr("; cmp op 0x%x inv %d v %d r %d\n",vtop->c.i,inv,v,r); + //gsym(t); + switch(vtop->c.i) { + case TOK_NE: + // remember that we need a label to jump to + jump[jumps][0] = r; + pr("; cmp ne\n"); + // branches (too short) pr("b%s " LOCAL_LABEL "\n", inv?"eq":"ne", jumps++); + pr("b%s +\n", inv?"ne":"eq"); + gsym(t); + pr("brl " LOCAL_LABEL "\n+\n", jumps++); + break; + default: + error("unknown compare"); + break; + } + t = r; + } + else if(v == VT_JMP || v == VT_JMPI) { + pr("; VT_jmp r %d t %d ji %d inv %d vtop->c.i %d\n",r,t, v&1, inv, vtop->c.i); + if((v & 1) == inv) { + gsym(t); + t = vtop->c.i; + } + else { + t = gjmp(t); + gsym(vtop->c.i); + } + } + else { + if(is_float(vtop->type.t)) { + pr("; float 4\n"); + v = gv(RC_FLOAT); + gsym(t); + pr("lda.b tcc__f%d\nand.w #$ff00\nora.b tcc__f%dh\n", v - TREG_F0, v - TREG_F0); + vtop->r = VT_CMP; + vtop->c.i = TOK_NE; + return gtst(inv, t); + } + else if((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST) { + if((vtop->type.t & VT_BTYPE) == VT_LLONG) error("zweiundvierzig"); + if((vtop->c.i != 0) != inv) { + pr("; uncond jump: go! (vtop->c.i %d, inv %d)\n",vtop->c.i, inv); + /* set flags as if we had a false compare result */ + pr("lda.w #0\n"); + t = gjmp(t); + } + else pr("; uncond jump: nop\n"); + } + else { + v = gv(RC_INT); + gsym(t); + pr("; tcc__r%d to compare reg\n", v); + pr("lda.b tcc__r%d ; DON'T OPTIMIZE\n",v); + if((vtop->type.t & VT_BTYPE) == VT_LLONG) pr("ora.b tcc__r%d\n", vtop->r2); + vtop->r = VT_CMP; + vtop->c.i = TOK_NE; + return gtst(inv, t); + } + } + vtop--; + pr("; gtst finished; t %d\n",t); + return t; +} + +// generate an integer operation +void gen_opi(int op) +{ + int r, fr, fc, ft, c, r5; + char* opcrem = 0, *opcalc = 0, *opcarry = 0; + int optone; + int docarry; + int sign; + int div; + int length, align; + int isconst = 0; + int timesshift, i; + + length = type_size(&vtop[0].type, &align); + r = vtop[-1].r; + fr = vtop[0].r; + fc = vtop[0].c.ul; + + // get the actual values + if((fr & VT_VALMASK) == VT_CONST && op != TOK_UMULL && !(fr & VT_SYM)) { + // vtop is const, only need to load the other one + ft = vtop[0].type.t; + vtop--; + r = gv(RC_INT); + isconst = 1; + if(length <= 2 && (fc < -32768 || fc > 65535)) { + warning("large integer implicitly truncated"); + fc = (short)fc; + } + } + else { + // have to load both operands to registers + gv2(RC_INT,RC_INT); + r = vtop[-1].r; + fr = vtop[0].r; + ft = vtop[0].type.t; + vtop--; + } + + pr("; gen_opi len %d op %c\n",length,op); + switch(op) { + // multiplication + case '*': + if(isconst) { + pr("; mul #%d, tcc__r%d\n", fc, r); + pr("lda.w #%d\nsta.b tcc__r9\n", fc); + } + else { + pr("; mul tcc__r%d,tcc__r%d\n",fr,r); + pr("lda.b tcc__r%d\nsta.b tcc__r9\n", fr); + } + pr("lda.b tcc__r%d\nsta.b tcc__r10\n", r); + pr("jsr.l tcc__mul\n"); + pr("sta.b tcc__r%d\n", r); + break; + + case TOK_UMULL: + r = vtop[0].r2 = get_reg(RC_INT); + c = vtop[0].r; + vtop[0].r = get_reg(RC_INT); + pr("; umull tcc__r%d, tcc__r%d => tcc__r%d/tcc__r%d\n", c, vtop[1].r, vtop->r, r); + pr("lda.b tcc__r%d\nsta.b tcc__r9\nstz.b tcc__r9h\nlda.b tcc__r%d\nsta.b tcc__r10\nstz.b tcc__r10h\n", c, vtop[1].r); + pr("jsr.l tcc__mull\n"); + pr("stx.b tcc__r%d\nsty.b tcc__r%d\n", r, vtop->r); + break; + // division and friends + case TOK_PDIV: + op = TOK_UDIV; + case '/': + case TOK_UDIV: + case '%': + case TOK_UMOD: + if(op == '/' || op == '%') sign = 1; + else sign = 0; + if(op == '/' || op == TOK_UDIV) div = 1; + else div = 0; + + if(isconst) { + pr("; div #%d, tcc__r%d\n", fc, r); + pr("ldx.b tcc__r%d\n", r); + pr("lda.w #%d\n", fc); + } + else { + pr("; div tcc__r%d,tcc__r%d\n", fr, r); + + pr("ldx.b tcc__r%d\n", r); // dividend to x + pr("lda.b tcc__r%d\n", fr); // divisor to accu + } + pr("jsr.l tcc__%s\n",sign?"div":"udiv"); + + if(div) pr("lda.b tcc__r9\nsta.b tcc__r%d\n", r); // quotient in r9... + else pr("stx.b tcc__r%d\n", r); // ...remainder in x + + break; + + // intops the 65816 can do in hardware + case '+': + case TOK_ADDC1: + case TOK_ADDC2: + case '-': + case TOK_SUBC1: + case TOK_SUBC2: + case '&': + case TOK_LAND: + case '|': + case '^': + optone = 1; + docarry = 1; + if(isconst && fc < 0) { + if(op == '+') { op = '-'; fc = -fc; } + else if(op == '-') { op = '+'; fc = -fc; } + else if(op == TOK_ADDC1) { op = TOK_SUBC1; fc = -fc; } + else if(op == TOK_SUBC1) { op = TOK_ADDC1; fc = -fc; } + else if(op == TOK_ADDC2) { op = TOK_SUBC2; fc = -fc; } + else if(op == TOK_SUBC2) { op = TOK_ADDC2; fc = -fc; } + } + if(op == '+' || op == TOK_ADDC1 || op == TOK_ADDC2) { + opcalc = "adc"; // insn to use + opcrem = "inc"; // *crement to use when doing this op with *crements + opcarry = "clc"; // how to initialize the carry properly + if(op == TOK_ADDC2) docarry = 0; + } + else if(op == '-' || op == TOK_SUBC1 || op == TOK_SUBC2) { + opcalc = "sbc"; + opcrem = "dec"; + opcarry = "sec"; + if(op == TOK_SUBC2) docarry = 0; + } + else if(op == '&' || op == TOK_LAND) { + optone = 0; // optimize the "constant 1" operand case by using a *crement? + docarry = 0; // touch the carry? + opcalc = "and"; + } + else if(op == '|') { + optone = 0; + docarry = 0; + opcalc = "ora"; + } + else if(op == '^') { + optone = 0; + docarry = 0; + opcalc = "eor"; + } + else error("ICE 42"); + + pr("; %s tcc__r%d (0x%x), tcc__r%d (0x%x) (fr type 0x%x c %d r type 0x%x)\n",opcalc, fr, fr,r,r,vtop[0].type.t,vtop[0].c.ul, vtop[-1].type.t); + if(isconst) { + pr("; length xxy %d vtop->type 0x%x\n", type_size(&vtop->type, &align),vtop->type.t); + if (length == 4) { + /* probably pointer arithmetic... */ + pr("; assuming pointer arith\n"); + if ((fc >> 16) == 0) pr("stz.b tcc__r%dh\n", r); + else pr("lda.w #%d\nsta.b tcc__r%dh\n", fc >> 16, r); + } + if(fc == 1 && optone) pr("%s.b tcc__r%d\n", opcrem, r); + else if(fc == 2 && optone) pr("%s.b tcc__r%d\n%s.b tcc__r%d\n", opcrem, r, opcrem, r); + else pr("%s\nlda.b tcc__r%d\n%s.w #%d\nsta.b tcc__r%d\n", docarry?opcarry:"; nop", r, opcalc, fc & 0xffff, r); + } + else { + pr("; length xxy %d vtop->type 0x%x\n", type_size(&vtop->type, &align),vtop->type.t); + pr("%s\nlda.b tcc__r%d\n%s.b tcc__r%d\nsta.b tcc__r%d\n", docarry?opcarry:"; nop", r, opcalc, fr, r); + } + break; + + case TOK_EQ: + case TOK_NE: + r5 = get_reg(RC_R5); + if(isconst) { + pr("; cmpr(n)eq tcc__r%d, #%d\n", r, fc); + pr("ldx #1\nlda.b tcc__r%d\nsec\nsbc #%d\n", r, fc); + } + else { + pr("; cmpr(n)eq tcc__r%d, tcc__r%d\n", r, fr); + pr("ldx #1\nlda.b tcc__r%d\nsec\nsbc.b tcc__r%d\n", r, fr); + } + pr("tay\n"); // save for long long comparisons + if(op == TOK_EQ) pr("beq +\n"); + else pr("bne +\n"); + pr("dex\n+\nstx.b tcc__r%d\n", r5); // long long code does some wild branching and fucks up + // if the results of the compares it generates do not + // end up in the same register; unlikely to be a performance + // impediment: TCC does not usually use this register anyway + vtop->r = r5; + break; + + case TOK_GT: + case TOK_LE: + case TOK_LT: + case TOK_GE: + // 65xxx signed compare logic from here: http://www.6502.org/tutorials/compare_beyond.html#5 + r5 = get_reg(RC_R5); + if(isconst) { + pr("; cmpcd tcc__r%d, #%d\n", r, fc); + pr("ldx #1\nlda.b tcc__r%d\nsec\nsbc.w #%d\n",r,fc); + } + else { + pr("; cmpcd tcc__r%d, tcc__r%d\n", r, fr); + pr("ldx #1\nlda.b tcc__r%d\nsec\nsbc.b tcc__r%d\n", r, fr); + } + pr("tay\n"); // may need that later for long long + if(op == TOK_GT) pr("beq ++\n"); // greater than => equality not good, result 0 + else if(op == TOK_LE) pr("beq +++\n"); // less than or equal => equality good, result 1 + pr("bvc +\neor #$8000\n+\n"); + switch(op) { + case TOK_GT: pr("bpl +++\n"); break; + case TOK_LE: pr("bmi +++\n"); break; + case TOK_LT: pr("bmi +++\n"); break; + case TOK_GE: pr("bpl +++\n"); break; + default: error("don't know how to handle signed 0x%x\n", op); + } + pr("++\ndex\n+++\nstx.b tcc__r%d\n", r5); // see TOK_EQ/TOK_NE + vtop->r = r5; + break; + case TOK_UGT: + case TOK_ULE: + case TOK_ULT: + case TOK_UGE: + r5 = get_reg(RC_R5); + if(isconst) { + pr("; ucmpcd tcc__r%d, #%d\n", r, fc); + pr("ldx #1\nlda.b tcc__r%d\nsec\nsbc.w #%d\n", r, fc); + } + else { + pr("; ucmpcd tcc__r%d, tcc__r%d\n", r, fr); + pr("ldx #1\nlda.b tcc__r%d\nsec\nsbc.b tcc__r%d\n", r, fr); + } + pr("tay\n"); // needed for long long comparisons + switch(op) { + case TOK_UGT: pr("beq +\nbcs ++\n"); break; + case TOK_ULE: pr("beq ++\nbcc ++\n"); break; + case TOK_ULT: pr("bcc ++\n"); break; + case TOK_UGE: pr("bcs ++\n"); break; + default: error("don't know how to handle 0x%x\n", op); + } + pr("+ dex\n++\nstx.b tcc__r%d\n", r5); // see TOK_EQ/TOK_NE + vtop->r = r5; + break; + case TOK_SAR: + case TOK_SHR: + case TOK_SHL: + timesshift = 1; +#define UNROLL_SHIFT_MAX 4 +#define SHIFT_IN_PLACE_MAX 2 + if(isconst) { + pr("; %s tcc__r%d, #%d\n", op==TOK_SAR?"sar":op==TOK_SHR?"shr":"shl", r, fc); + if(!fc) return; // 0 -> nothing to do + if(fc == 8 && (op == TOK_SHR || op == TOK_SHL)) { + pr("lda.b tcc__r%d\nxba\n", r); + switch(op) { + case TOK_SHL: pr("and #$ff00\n"); break; + case TOK_SHR: pr("and #$00ff\n"); break; + default: error("ICE 43"); + } + pr("sta.b tcc__r%d\n", r); + return; + } + else if(fc > UNROLL_SHIFT_MAX) // too many shifts -> need a loop + pr("lda.b tcc__r%d\nldy.w #%d\n-\n", r, fc); + else if(fc > SHIFT_IN_PLACE_MAX) { + pr("lda.b tcc__r%d\n", r); + timesshift = fc; + } + else { + // very few shifts; don't bother loading the value to the accu + for(i = 0; i < fc; i++) { + switch(op) { + case TOK_SAR: + pr("cmp #$8000\n"); // carry <= number negative? + pr("ror.b tcc__r%d\n", r); + break; + case TOK_SHR: + pr("lsr.b tcc__r%d\n",r); break; + case TOK_SHL: + // for left shifts, signedness is irrelevant (in spite of what the mnemonic seems to suggest) + pr("asl.b tcc__r%d\n", r); break; + default: error("unknown shift"); + } + } + return; + } + } + else { + pr("; %s tcc__r%d, tcc__r%d\n", op==TOK_SAR?"sar":op==TOK_SHR?"shr":"shl", r, fr); + pr("lda.b tcc__r%d\nldy.b tcc__r%d\nbeq +\n-\n", r, fr); + } + for(i = 0; i < timesshift; i++) + switch(op) { + case TOK_SAR: + pr("cmp #$8000\n"); // carry <= number negative? + pr("ror a\n"); + break; + case TOK_SHR: + pr("lsr a\n"); break; + case TOK_SHL: + // for left shifts, signedness is irrelevant (in spite of what the mnemonic seems to suggest) + pr("asl a\n"); break; + default: error("unknown shift"); + } + if(isconst && fc <= UNROLL_SHIFT_MAX) pr("sta.b tcc__r%d\n", r); + else pr("dey\nbne -\n+\nsta.b tcc__r%d\n", r); + break; + default: + error("opi 0x%x (%c) unimplemented\n",op,op); + } +} + +void float_to_woz(float, unsigned char*); + +void gen_opf(int op) +{ + int r, fr, ft; + float fcf; + int length, align; + int ir; + + length = type_size(&vtop[0].type, &align); + r = vtop[-1].r; + fr = vtop[0].r; + fcf = vtop[0].c.f; + + // get the actual values + gv2(RC_F1,RC_F0); + r = vtop[-1].r; + fr = vtop[0].r; + ft = vtop[0].type.t; + vtop--; + + pr("; gen_opf len %d op 0x%x ('%c')\n",length,op,op); + + switch(op) { + case '*': + pr("jsr.l tcc__fmul\n"); + break; + + case '/': + pr("jsr.l tcc__fdiv\n"); + break; + + case '+': + pr("jsr.l tcc__fadd\n"); + break; + + case '-': + pr("jsr.l tcc__fsub\n"); + break; + + case TOK_EQ: + case TOK_NE: + ir = get_reg(RC_INT); + pr("jsr.l tcc__fcmp\n"); + pr("dec a\n"); + if(op == TOK_EQ) pr("beq +\n"); + else pr("bne +\n"); + pr("dex\n+\nstx.b tcc__r%d\n", ir); + vtop->r = ir; + return; + break; + + case TOK_GT: + case TOK_LE: + case TOK_LT: + case TOK_GE: + ir = get_reg(RC_INT); // register to store the result flag in + pr("jsr.l tcc__fcmp\n"); + // assuming tcc__fcmp returns signum + 1 in accu and inits X with 1 + // subtracting one to set overflow flag + pr("sec\nsbc.w #1\n"); + if(op == TOK_GT) pr("beq ++\n"); // greater than => equality not good, result 0 + else if(op == TOK_LE) pr("beq +++\n"); // less than or equal => equality good, result 1 + pr("bvc +\neor #$8000\n"); + switch(op) { + case TOK_GT: pr("+ bpl +++\n"); break; + case TOK_LE: pr("+ bmi +++\n"); break; + case TOK_LT: pr("+ bmi +++\n"); break; + case TOK_GE: pr("+ bpl +++\n"); break; + default: error("don't know how to handle signed 0x%x\n", op); + } + pr("++\ndex\n+++\nstx.b tcc__r%d\n", ir); + vtop->r = ir; + return; + break; + + default: + error("opf 0x%x (%c) unimplemented\n",op,op); + } + vtop->r = TREG_F0; +} + +void gen_cvt_itof(int t) +{ + int r, r2, it; + gv(RC_INT); // load integer to convert + r = vtop->r; // register with int + r2 = vtop->r2; // register with high word (for long longs) + it = vtop->type.t; // type of int + + pr("; itof tcc__r%d, f0\n", r); + if((vtop->type.t & VT_BTYPE) == VT_LLONG) { + pr("pei (tcc__r%d)\npei (tcc__r%d)\n", r2, r); + if(it & VT_UNSIGNED) error("jsr.l tcc__ulltof\n"); // this is probably dead code + else pr("jsr.l tcc__lltof\n"); + pr("pla\npla\n"); + } + else { + get_reg(RC_F0); // result will go to f0 + pr("lda.b tcc__r%d\n", r); + pr("xba\nsta.b tcc__f0 + 1\n"); // convert to big-endian and load to upper 2 bytes of mantissa + if(it & VT_UNSIGNED) pr("jsr.l tcc__ufloat\n"); + else pr("jsr.l tcc__float\n"); + } + vtop->r = TREG_F0; // tell TCC that the result is in f0 +} + +void gen_cvt_ftoi(int t) +{ + int r = 0; + gv(RC_F0); + if((t & VT_BTYPE) == VT_LLONG) { + get_reg(RC_R0); + get_reg(RC_R1); + } + else r = get_reg(RC_INT); + pr("; ftoi tcc__f0, tcc__r%d(type 0x%x)\n", r, t); + if(t & VT_UNSIGNED) pr("lda #0\nsta.b tcc__r9\n"); + else pr("lda #1\nsta.b tcc__r9\n"); + + // use llfix for any unsigned type to avoid overflow + if((t & VT_BTYPE) == VT_LLONG || (t & VT_UNSIGNED)) { + pr("jsr.l tcc__llfix\n"); + vtop->r2 = TREG_R1; + vtop->r = TREG_R0; + return; + } + else { + pr("jsr.l tcc__fix\n"); + pr("lda.b tcc__f0 + 1\nxba\nsta.b tcc__r%d\n", r); + } + + vtop->r = r; +} + +void gen_cvt_ftof(int t) +{ + error("gen_cvt_ftof 0x%x\n",t); +} + +void ggoto(void) +{ + int r = gv(RC_INT); + int t = vtop->type.t; + pr("; ggoto r 0x%x t 0x%x\n",r,t); + pr("lda.b tcc__r%d\nsta.b tcc__r9 + 1\nsep #$20\nlda.b tcc__r%dh\nsta.b tcc__r9h + 1\nlda.b #$5c\nsta.b tcc__r9\nrep #$20\n", r, r); + pr("jml.l tcc__r9\n"); +} + +int section_count = 0; +int ind_before_section = 0; +int section_closed = 1; + +void gfunc_prolog(CType* func_type) +{ + Sym* sym; //, *sym2; + Sym* symf; + int n,addr,size,align; + //fprintf(stderr,"gfunc_prolog t %d sym %p\n",func_type->t,func_type->ref); + + sym = func_type->ref; + func_vt = sym->type; + + n=0; + addr=3; // skip 24-bit return address + loc = 0; + if((func_vt.t & VT_BTYPE) == VT_STRUCT) { + func_vc = addr; + addr += PTR_SIZE; + n += PTR_SIZE; + } + + /* super-dirty hack to get the function name */ + symf = (Sym*) ( ((void*)func_type) - offsetof(Sym, type) ); + strcpy(current_fn, get_sym_str(symf)); + + /* wlalink does not cut up sections, so it is desirable to have a section + for each function to keep the amount of unused memory in the ROM banks + low. WLA DX barfs, however, if fed more than 255 sections, so we have + to be a bit economical: gfunc_epilog() only closes the section if more + than 50K of assembler code have been written */ + if(section_closed) { + ind_before_section = ind; + pr("\n.section \".text_0x%x\" superfree\n", section_count++); + section_closed = 0; + } + + pr("\n%s:\n",current_fn); + + while((sym = sym->next)) { + CType* type; + type = &sym->type; + sym_push(sym->v & ~SYM_FIELD, type, VT_LOCAL | VT_LVAL, addr); + size = type_size(type, &align); + //fprintf(stderr,"pushed sym type 0x%x size %d addr 0x%x\n",type->t,size,addr); + addr += size; + n += size; + } + pr("; sub sp,#__%s_locals\n",current_fn); + pr(".ifgr __%s_locals 0\ntsa\nsec\nsbc #__%s_locals\ntas\n.endif\n",current_fn,current_fn); + loc = 0; // huh squared? +} + +char locals[1000][80]; +int localnos[1000]; +int localno=0; + +void gfunc_epilog(void) +{ + pr("; add sp, #__%s_locals\n",current_fn); + pr(".ifgr __%s_locals 0\ntsa\nclc\nadc #__%s_locals\ntas\n.endif\n", current_fn, current_fn); + pr("rtl\n"); + + pr(".ends\n"); + section_closed = 1; + + if(-loc > 0x1f00) error("stack overflow"); + /* simply putting a ".define ___locals -" after the + function does not work in some cases for unknown reasons (wla-dx + complains about unresolved symbols); putting them before the reference + works, but this has to be done by the output code, so we have to save + the various locals sizes somewhere */ + strcpy(locals[localno], current_fn); + localnos[localno] = -loc; + localno++; + current_fn[0] = 0; +} diff --git a/816-opt.py b/816-opt.py new file mode 100644 index 0000000..abdb9fe --- /dev/null +++ b/816-opt.py @@ -0,0 +1,579 @@ +#!/usr/bin/python + +import sys +import re +import os + +#import hotshot +#prof = hotshot.Profile('816-opt.prof') +#prof.start() + +verbose = True +if os.getenv('OPT816_QUIET'): verbose = False + +# open the assembler file and put lines in array text +text_raw = open(sys.argv[1],'r').readlines() +text = [] +for l in text_raw: + if not l.startswith(';'): text += [l.strip()] + +# find .bss section symbols +bss = [] +bsson = False +for l in text: + if l == '.ramsection ".bss" bank $7e slot 2': + bsson = True + continue + if l == '.ends': + bsson = False + if bsson: + bss += [l.split(' ')[0]] +#print 'bss',bss + +# checks if the line alters the control flow +def is_control(line): + if len(line) > 0 and line[0] in 'jb+-' or line.endswith(':'): return True + return False + +def changes_accu(line): + if (line[2] == 'a' and not line[:3] in ['pha','sta']) or (len(line) == 5 and line.endswith(' a')): return True + else: return False + +totalopt = 0 # total number of optimizations performed +opted = -1 # have we optimized in this pass? +opass = 0 # optimization pass counter +storetopseudo = re.compile('st([axyz]).b tcc__([rf][0-9]*h?)$') +storexytopseudo = re.compile('st([xy]).b tcc__([rf][0-9]*h?)$') +storeatopseudo = re.compile('sta.b tcc__([rf][0-9]*h?)$') +while opted: + opass += 1 + if verbose: sys.stderr.write('optimization pass ' + str(opass) + ': ') + opted = 0 # no optimizations performed + text_opt = [] # optimized code array, will be filled in during this pass + i = 0 + while i < len(text): + if text[i].startswith('st'): + # stores (accu/x/y/zero) to pseudo-registers + r = storetopseudo.match(text[i]) + if r: + # eliminate redundant stores + doopt = False + for j in range(i+1, min(len(text),i+30)): + r1 = re.match('st([axyz]).b tcc__' + r.groups()[1] + '$', text[j]) + if r1: + doopt = True # another store to the same pregister + break + if text[j].startswith('jsr.l ') and not text[j].startswith('jsr.l tcc__'): + doopt = True # before function call (will be clobbered anyway) + break + # cases in which we don't pursue optimization further + if is_control(text[j]) or ('tcc__' + r.groups()[1]) in text[j]: break # branch or other use of the preg + if r.groups()[1].endswith('h') and ('[tcc__' + r.groups()[1].rstrip('h')) in text[j]: break # use as a pointer + if doopt: + i += 1 # skip redundant store + opted += 1 + continue + + # stores (x/y) to pseudo-registers + r = storexytopseudo.match(text[i]) + if r: + # store hwreg to preg, push preg, function call -> push hwreg, function call + if text[i+1] == 'pei (tcc__' + r.groups()[1] + ')' and text[i+2].startswith('jsr.l '): + text_opt += ['ph' + r.groups()[0]] + i += 2 + opted += 1 + continue + # store hwreg to preg, push preg -> store hwreg to preg, push hwreg (shorter) + if text[i+1] == 'pei (tcc__' + r.groups()[1] + ')': + text_opt += [text[i]] + text_opt += ['ph' + r.groups()[0]] + i += 2 + opted += 1 + continue + # store hwreg to preg, load hwreg from preg -> store hwreg to preg, transfer hwreg/hwreg (shorter) + if text[i+1] == 'lda.b tcc__' + r.groups()[1] or text[i+1] == 'lda.b tcc__' + r.groups()[1] + " ; DON'T OPTIMIZE": + text_opt += [text[i]] + text_opt += ['t' + r.groups()[0] + 'a'] # FIXME: shouldn't this be marked as DON'T OPTIMIZE again? + i += 2 + opted += 1 + continue + + # stores (accu only) to pseudo-registers + r = storeatopseudo.match(text[i]) + if r: + #sys.stderr.write('looking for lda.b tcc__r' + r.groups()[0] + ' in ' + text[i+1] + '\n') + # store preg followed by load preg + if text[i+1] == 'lda.b tcc__' + r.groups()[0]: + #sys.stderr.write('found!\n') + text_opt += [text[i]] # keep store + i += 2 # omit load + opted += 1 + continue + # store preg followed by load preg with ldx/ldy in between + if (text[i+1].startswith('ldx') or text[i+1].startswith('ldy')) and text[i+2] == 'lda.b tcc__' + r.groups()[0]: + text_opt += [text[i]] # keep store + text_opt += [text[i+1]] + i += 3 # omit load + opted += 1 + continue + # store accu to preg, push preg, function call -> push accu, function call + if text[i+1] == 'pei (tcc__' + r.groups()[0] + ')' and text[i+2].startswith('jsr.l '): + text_opt += ['pha'] + i += 2 + opted += 1 + continue + # store accu to preg, push preg -> store accu to preg, push accu (shorter) + if text[i+1] == 'pei (tcc__' + r.groups()[0] + ')': + text_opt += [text[i]] + text_opt += ['pha'] + i += 2 + opted += 1 + continue + # store accu to preg1, push preg2, push preg1 -> store accu to preg1, push preg2, push accu + elif text[i+1].startswith('pei ') and text[i+2] == 'pei (tcc__' + r.groups()[0] + ')': + text_opt += [text[i+1]] + text_opt += [text[i]] + text_opt += ['pha'] + i += 3 + opted += 1 + continue + + # convert incs/decs on pregs incs/decs on hwregs + cont = False + for crem in 'inc','dec': + if text[i+1] == crem + '.b tcc__' + r.groups()[0]: + # store to preg followed by crement on preg + if text[i+2] == crem + '.b tcc__' + r.groups()[0] and text[i+3].startswith('lda'): + # store to preg followed by two crements on preg + # increment the accu first, then store it to preg + text_opt += [crem + ' a',crem + ' a','sta.b tcc__' + r.groups()[0]] + # a subsequent load can be omitted (the right value is already in the accu) + if text[i+3] == 'lda.b tcc__' + r.groups()[0]: i += 4 + else: i += 3 + opted += 1 + cont = True + break + elif text[i+2].startswith('lda'): #text[i+2] == 'lda.b tcc__' + r.groups()[0]: + # same thing with only one crement (FIXME: there should be a more clever way to do this...) + text_opt += [crem + ' a','sta.b tcc__' + r.groups()[0]] + if text[i+2] == 'lda.b tcc__' + r.groups()[0]: i += 3 + else: i += 2 + opted += 1 + cont = True + break + if cont: continue + + r1 = re.match('lda.b tcc__([rf][0-9]*)',text[i+1]) + if r1: + #sys.stderr.write('t '+text[i+2][:3]+'\n') + if text[i+2][:3] in ['and','ora']: + # store to preg1, load from preg2, and/or preg1 -> store to preg1, and/or preg2 + #sys.stderr.write('found in line ' + str(i) + '!\n') + if text[i+2][3:] == '.b tcc__' + r.groups()[0]: + text_opt += [text[i]] # store + text_opt += [text[i+2][:3] + '.b tcc__' + r1.groups()[0]] + i += 3 + opted += 1 + continue + + # store to preg, switch to 8 bits, load from preg => skip the load + if text[i+1] == 'sep #$20' and text[i+2] == 'lda.b tcc__' + r.groups()[0]: + text_opt += [text[i]] + text_opt += [text[i+1]] + i += 3 # skip load + opted += 1 + continue + + # two stores to preg without control flow or other uses of preg => skip first store + if not is_control(text[i+1]) and not ('tcc__' + r.groups()[0]) in text[i+1]: + if text[i+2] == text[i]: + text_opt += [text[i+1]] + text_opt += [text[i+2]] + i += 3 # skip first store + opted += 1 + continue + + # store hwreg to preg, load hwreg from preg -> store hwreg to preg, transfer hwreg/hwreg (shorter) + r1 = re.match('ld([xy]).b tcc__' + r.groups()[0], text[i+1]) + if r1: + text_opt += [text[i]] + text_opt += ['ta' + r1.groups()[0]] + i += 2 + opted += 1 + continue + + # store accu to preg then load accu from preg, with something in-between that does not alter + # control flow or touch accu or preg => skip load + if not (is_control(text[i+1]) or changes_accu(text[i+1]) or 'tcc__' + r.groups()[0] in text[i+1]): + if text[i+2] == 'lda.b tcc__' + r.groups()[0]: + text_opt += [text[i]] + text_opt += [text[i+1]] + i += 3 # skip load + opted += 1 + continue + + # store preg1, clc, load preg2, add preg1 -> store preg1, clc, add preg2 + if text[i+1] == 'clc': + r1 = re.match('lda.b tcc__(r[0-9]*)', text[i+2]) + if r1 and text[i+3] == 'adc.b tcc__' + r.groups()[0]: + text_opt += [text[i]] + text_opt += [text[i+1]] + text_opt += ['adc.b tcc__' + r1.groups()[0]] + i += 4 # skip load + opted += 1 + continue + + # store accu to preg, asl preg => asl accu, store accu to preg + # FIXME: is this safe? can we rely on code not making assumptions about the contents of the accu + # after the shift? + if text[i+1] == 'asl.b tcc__' + r.groups()[0]: + text_opt += ['asl a'] + text_opt += [text[i]] + i += 2 + opted += 1 + continue + + r = re.match('sta (.*),s$', text[i]) + if r: + if text[i+1] == 'lda ' + r.groups()[0] + ',s': + text_opt += [text[i]] + i += 2 # omit load + opted += 1 + continue + # end startswith('st') + + if text[i].startswith('ld'): + r = re.match('ldx #0', text[i]) + if r: + r1 = re.match('lda.l (.*),x$', text[i+1]) + if r1 and not text[i+3].endswith(',x'): + text_opt += ['lda.l ' + r1.groups()[0]] + i += 2 + opted += 1 + continue + elif r1: + text_opt += ['lda.l ' + r1.groups()[0]] + text_opt += [text[i+2]] + text_opt += [text[i+3].replace(',x','')] + i += 4 + opted += 1 + continue + + if text[i].startswith('lda.w #') and \ + text[i+1] == 'sta.b tcc__r9' and \ + text[i+2].startswith('lda.w #') and \ + text[i+3] == 'sta.b tcc__r9h' and \ + text[i+4] == 'sep #$20' and \ + text[i+5].startswith('lda.b ') and \ + text[i+6] == 'sta.b [tcc__r9]' and \ + text[i+7] == 'rep #$20': + text_opt += ['sep #$20'] + text_opt += [text[i+5]] + text_opt += ['sta.l ' + str(int(text[i+2][7:]) * 65536 + int(text[i][7:]))] + text_opt += ['rep #$20'] + i += 8 + opted += 1 + #sys.stderr.write('7') + continue + + if text[i] == 'lda.w #0': + if text[i+1].startswith('sta.b ') and text[i+2].startswith('lda'): + text_opt += [text[i+1].replace('sta.','stz.')] + i += 2 + opted += 1 + continue + elif text[i].startswith('lda.w #'): + if text[i+1] == 'sep #$20' and text[i+2].startswith('sta ') and text[i+3] == 'rep #$20' and text[i+4].startswith('lda'): + text_opt += ['sep #$20', text[i].replace('lda.w', 'lda.b'), text[i+2], text[i+3]] + i += 4 + opted += 1 + continue + + if text[i].startswith('lda.b') and not is_control(text[i+1]) and not 'a' in text[i+1] and text[i+2].startswith('lda.b'): + text_opt += [text[i+1],text[i+2]] + i += 3 + opted += 1 + continue + + # don't write preg high back to stack if it hasn't been updated + if text[i+1].endswith('h') and text[i+1].startswith('sta.b tcc__r') and text[i].startswith('lda ') and text[i].endswith(',s'): + #sys.stderr.write('checking lines\n') + #sys.stderr.write(text[i] + '\n' + text[i+1] + '\n') + local = text[i][4:] + reg = text[i+1][6:] + # lda stack ; store high preg ; ... ; load high preg ; sta stack + j = i + 2 + while j < len(text) - 2 and not is_control(text[j]) and not reg in text[j]: + j += 1 + if text[j] == 'lda.b ' + reg and text[j+1] == 'sta ' + local: + while i < j: + text_opt += [text[i]] + i += 1 + i += 2 # skip load high preg ; sta stack + opted += 1 + continue + + # reorder copying of 32-bit value to preg if it looks as if that could + # allow further optimization + # looking for + # lda something + # sta.b tcc_rX + # lda something + # sta.b tcc_rYh + # ...tcc_rX... + if text[i].startswith('lda') and text[i+1].startswith('sta.b tcc__r'): + reg = text[i+1][6:] + if not reg.endswith('h') and \ + text[i+2].startswith('lda') and not text[i+2].endswith(reg) and \ + text[i+3].startswith('sta.b tcc__r') and text[i+3].endswith('h') and \ + text[i+4].endswith(reg): + text_opt += [text[i+2], text[i+3]] + text_opt += [text[i], text[i+1]] + i += 4 + # this is not an optimization per se, so we don't count it + continue + + # compare optimizations inspired by optimore + # These opts simplify compare operations, which are monstrous because + # they have to take the long long case into account. + # We try to detect those cases by checking if a tya follows the + # comparison (not sure if this is reliable, but it passes the test suite) + if text[i] == 'ldx #1' and \ + text[i+1].startswith('lda.b tcc__') and \ + text[i+2] == 'sec' and \ + text[i+3].startswith('sbc #') and \ + text[i+4] == 'tay' and \ + text[i+5] == 'beq +' and \ + text[i+6] == 'dex' and \ + text[i+7] == '+' and \ + text[i+8].startswith('stx.b tcc__') and \ + text[i+9] == 'txa' and \ + text[i+10] == 'bne +' and \ + text[i+11].startswith('brl ') and \ + text[i+12] == '+' and \ + text[i+13] != 'tya': + text_opt += [text[i+1]] + text_opt += ['cmp #' + text[i+3][5:]] + text_opt += [text[i+5]] + text_opt += [text[i+11]] # brl + text_opt += [text[i+12]] # + + i += 13 + opted += 1 + #sys.stderr.write('1') + continue + + if text[i] == 'ldx #1' and \ + text[i+1] == 'sec' and \ + text[i+2].startswith('sbc #') and \ + text[i+3] == 'tay' and \ + text[i+4] == 'beq +' and \ + text[i+5] == 'dex' and \ + text[i+6] == '+' and \ + text[i+7].startswith('stx.b tcc__') and \ + text[i+8] == 'txa' and \ + text[i+9] == 'bne +' and \ + text[i+10].startswith('brl ') and \ + text[i+11] == '+' and \ + text[i+12] != 'tya': + text_opt += ['cmp #' + text[i+2][5:]] + text_opt += [text[i+4]] + text_opt += [text[i+10]] # brl + text_opt += [text[i+11]] # + + i += 12 + opted += 1 + #sys.stderr.write('2') + continue + + if text[i] == 'ldx #1' and \ + text[i+1].startswith('lda.b tcc__r') and \ + text[i+2] == 'sec' and \ + text[i+3].startswith('sbc.b tcc__r') and \ + text[i+4] == 'tay' and \ + text[i+5] == 'beq +' and \ + text[i+6] == 'bcs ++' and \ + text[i+7] == '+ dex' and \ + text[i+8] == '++' and \ + text[i+9].startswith('stx.b tcc__r') and \ + text[i+10] == 'txa' and \ + text[i+11] == 'bne +' and \ + text[i+12].startswith('brl ') and \ + text[i+13] == '+' and \ + text[i+14] != 'tya': + text_opt += [text[i+1]] + text_opt += ['cmp.b ' + text[i+3][6:]] + text_opt += [text[i+5]] + text_opt += ['bcc +'] + text_opt += ['brl ++'] + text_opt += ['+'] + text_opt += [text[i+12]] + text_opt += ['++'] + i += 14 + opted += 1 + #sys.stderr.write('3') + continue + + if text[i] == 'ldx #1' and \ + text[i+1] == 'sec' and \ + text[i+2].startswith('sbc.w #') and \ + text[i+3] == 'tay' and \ + text[i+4] == 'bvc +' and \ + text[i+5] == 'eor #$8000' and \ + text[i+6] == '+' and \ + text[i+7] == 'bmi +++' and \ + text[i+8] == '++' and \ + text[i+9] == 'dex' and \ + text[i+10] == '+++' and \ + text[i+11].startswith('stx.b tcc__r') and \ + text[i+12] == 'txa' and \ + text[i+13] == 'bne +' and \ + text[i+14].startswith('brl ') and \ + text[i+15] == '+' and \ + text[i+16] != 'tya': + text_opt += [text[i+1]] + text_opt += [text[i+2]] + text_opt += [text[i+4]] + text_opt += ['eor #$8000'] + text_opt += ['+'] + text_opt += ['bmi +'] + text_opt += [text[i+14]] + text_opt += ['+'] + i += 16 + opted += 1 + #sys.stderr.write('4') + continue + + if text[i] == 'ldx #1' and \ + text[i+1].startswith('lda.b tcc__r') and \ + text[i+2] == 'sec' and \ + text[i+3].startswith('sbc.b tcc__r') and \ + text[i+4] == 'tay' and \ + text[i+5] == 'bvc +' and \ + text[i+6] == 'eor #$8000' and \ + text[i+7] == '+' and \ + text[i+8] == 'bmi +++' and \ + text[i+9] == '++' and \ + text[i+10] == 'dex' and \ + text[i+11] == '+++' and \ + text[i+12].startswith('stx.b tcc__r') and \ + text[i+13] == 'txa' and \ + text[i+14] == 'bne +' and \ + text[i+15].startswith('brl ') and \ + text[i+16] == '+' and \ + text[i+17] != 'tya': + text_opt += [text[i+1]] + text_opt += [text[i+2]] + text_opt += [text[i+3]] + text_opt += [text[i+5]] + text_opt += [text[i+6]] + text_opt += ['+'] + text_opt += ['bmi +'] + text_opt += [text[i+15]] + text_opt += ['+'] + i += 17 + opted += 1 + #sys.stderr.write('5') + continue + + if text[i] == 'ldx #1' and \ + text[i+1] == 'sec' and \ + text[i+2].startswith('sbc.b tcc__r') and \ + text[i+3] == 'tay' and \ + text[i+4] == 'bvc +' and \ + text[i+5] == 'eor #$8000' and \ + text[i+6] == '+' and \ + text[i+7] == 'bmi +++' and \ + text[i+8] == '++' and \ + text[i+9] == 'dex' and \ + text[i+10] == '+++' and \ + text[i+11].startswith('stx.b tcc__r') and \ + text[i+12] == 'txa' and \ + text[i+13] == 'bne +' and \ + text[i+14].startswith('brl ') and \ + text[i+15] == '+' and \ + text[i+16] != 'tya': + text_opt += [text[i+1]] + text_opt += [text[i+2]] + text_opt += [text[i+4]] + text_opt += [text[i+5]] + text_opt += ['+'] + text_opt += ['bmi +'] + text_opt += [text[i+14]] + text_opt += ['+'] + i += 16 + opted += 1 + #sys.stderr.write('6') + continue + + # end startswith('ld') + + if text[i] == 'rep #$20' and text[i+1] == 'sep #$20': + i += 2 + opted += 1 + continue + + if text[i] == 'sep #$20' and text[i+1].startswith('lda #') and text[i+2] == 'pha' and text[i+3].startswith('lda #') and text[i+4] == 'pha': + text_opt += ['pea.w (' + text[i+1].split('#')[1] + ' * 256 + ' + text[i+3].split('#')[1] + ')'] + text_opt += [text[i]] + i += 5 + opted += 1 + continue + + r = re.match('adc #(.*)$',text[i]) + if r: + r1 = re.match('sta.b (tcc__[fr][0-9]*)$', text[i+1]) + if r1: + if text[i+2] == 'inc.b ' + r1.groups()[0] and text[i+3] == 'inc.b ' + r1.groups()[0]: + text_opt += ['adc #' + r.groups()[0] + ' + 2'] + text_opt += [text[i+1]] + i += 4 + opted += 1 + continue + + if text[i][:6] in ['lda.l ','sta.l ']: + cont = False + for b in bss: + if text[i][2:].startswith('a.l ' + b + ' '): + text_opt += [text[i].replace('lda.l','lda.w').replace('sta.l','sta.w')] + i += 1 + opted += 1 + cont = True + break + if cont: continue + + if text[i].startswith('jmp.w ') or text[i].startswith('bra __'): + j = i + 1 + cont = False + while j < len(text) and text[j].endswith(':'): + if text[i].endswith(text[j][:-1]): + # redundant branch, discard it + i += 1 + opted += 1 + cont = True + break + j += 1 + if cont: continue + + if text[i].startswith('jmp.w '): + # worst case is a 4-byte instruction, so if the jump target is closer + # than 32 instructions, we can safely substitute a branch + label = text[i][6:] + ':' + cont = False + for lpos in range(max(0, i - 32), min(len(text), i + 32)): + if text[lpos] == label: + text_opt += [text[i].replace('jmp.w','bra')] + i += 1 + opted += 1 + cont = True + break + if cont: continue + + text_opt += [text[i]] + i += 1 + text = text_opt + if verbose: sys.stderr.write(str(opted) + ' optimizations performed\n') + totalopt += opted + +for l in text_opt: print l +if verbose: sys.stderr.write(str(totalopt) + ' optimizations performed in total\n') + +#prof.stop() diff --git a/COPYING b/COPYING new file mode 100644 index 0000000..223ede7 --- /dev/null +++ b/COPYING @@ -0,0 +1,504 @@ + GNU LESSER GENERAL PUBLIC LICENSE + Version 2.1, February 1999 + + Copyright (C) 1991, 1999 Free Software Foundation, Inc. + 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + +[This is the first released version of the Lesser GPL. It also counts + as the successor of the GNU Library Public License, version 2, hence + the version number 2.1.] + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +Licenses are intended to guarantee your freedom to share and change +free software--to make sure the software is free for all its users. + + This license, the Lesser General Public License, applies to some +specially designated software packages--typically libraries--of the +Free Software Foundation and other authors who decide to use it. You +can use it too, but we suggest you first think carefully about whether +this license or the ordinary General Public License is the better +strategy to use in any particular case, based on the explanations below. + + When we speak of free software, we are referring to freedom of use, +not price. Our General Public Licenses are designed to make sure that +you have the freedom to distribute copies of free software (and charge +for this service if you wish); that you receive source code or can get +it if you want it; that you can change the software and use pieces of +it in new free programs; and that you are informed that you can do +these things. + + To protect your rights, we need to make restrictions that forbid +distributors to deny you these rights or to ask you to surrender these +rights. These restrictions translate to certain responsibilities for +you if you distribute copies of the library or if you modify it. + + For example, if you distribute copies of the library, whether gratis +or for a fee, you must give the recipients all the rights that we gave +you. You must make sure that they, too, receive or can get the source +code. If you link other code with the library, you must provide +complete object files to the recipients, so that they can relink them +with the library after making changes to the library and recompiling +it. And you must show them these terms so they know their rights. + + We protect your rights with a two-step method: (1) we copyright the +library, and (2) we offer you this license, which gives you legal +permission to copy, distribute and/or modify the library. + + To protect each distributor, we want to make it very clear that +there is no warranty for the free library. Also, if the library is +modified by someone else and passed on, the recipients should know +that what they have is not the original version, so that the original +author's reputation will not be affected by problems that might be +introduced by others. + + Finally, software patents pose a constant threat to the existence of +any free program. We wish to make sure that a company cannot +effectively restrict the users of a free program by obtaining a +restrictive license from a patent holder. Therefore, we insist that +any patent license obtained for a version of the library must be +consistent with the full freedom of use specified in this license. + + Most GNU software, including some libraries, is covered by the +ordinary GNU General Public License. This license, the GNU Lesser +General Public License, applies to certain designated libraries, and +is quite different from the ordinary General Public License. We use +this license for certain libraries in order to permit linking those +libraries into non-free programs. + + When a program is linked with a library, whether statically or using +a shared library, the combination of the two is legally speaking a +combined work, a derivative of the original library. The ordinary +General Public License therefore permits such linking only if the +entire combination fits its criteria of freedom. The Lesser General +Public License permits more lax criteria for linking other code with +the library. + + We call this license the "Lesser" General Public License because it +does Less to protect the user's freedom than the ordinary General +Public License. It also provides other free software developers Less +of an advantage over competing non-free programs. These disadvantages +are the reason we use the ordinary General Public License for many +libraries. However, the Lesser license provides advantages in certain +special circumstances. + + For example, on rare occasions, there may be a special need to +encourage the widest possible use of a certain library, so that it becomes +a de-facto standard. To achieve this, non-free programs must be +allowed to use the library. A more frequent case is that a free +library does the same job as widely used non-free libraries. In this +case, there is little to gain by limiting the free library to free +software only, so we use the Lesser General Public License. + + In other cases, permission to use a particular library in non-free +programs enables a greater number of people to use a large body of +free software. For example, permission to use the GNU C Library in +non-free programs enables many more people to use the whole GNU +operating system, as well as its variant, the GNU/Linux operating +system. + + Although the Lesser General Public License is Less protective of the +users' freedom, it does ensure that the user of a program that is +linked with the Library has the freedom and the wherewithal to run +that program using a modified version of the Library. + + The precise terms and conditions for copying, distribution and +modification follow. Pay close attention to the difference between a +"work based on the library" and a "work that uses the library". The +former contains code derived from the library, whereas the latter must +be combined with the library in order to run. + + GNU LESSER GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License Agreement applies to any software library or other +program which contains a notice placed by the copyright holder or +other authorized party saying it may be distributed under the terms of +this Lesser General Public License (also called "this License"). +Each licensee is addressed as "you". + + A "library" means a collection of software functions and/or data +prepared so as to be conveniently linked with application programs +(which use some of those functions and data) to form executables. + + The "Library", below, refers to any such software library or work +which has been distributed under these terms. A "work based on the +Library" means either the Library or any derivative work under +copyright law: that is to say, a work containing the Library or a +portion of it, either verbatim or with modifications and/or translated +straightforwardly into another language. (Hereinafter, translation is +included without limitation in the term "modification".) + + "Source code" for a work means the preferred form of the work for +making modifications to it. For a library, complete source code means +all the source code for all modules it contains, plus any associated +interface definition files, plus the scripts used to control compilation +and installation of the library. + + Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running a program using the Library is not restricted, and output from +such a program is covered only if its contents constitute a work based +on the Library (independent of the use of the Library in a tool for +writing it). Whether that is true depends on what the Library does +and what the program that uses the Library does. + + 1. You may copy and distribute verbatim copies of the Library's +complete source code as you receive it, in any medium, provided that +you conspicuously and appropriately publish on each copy an +appropriate copyright notice and disclaimer of warranty; keep intact +all the notices that refer to this License and to the absence of any +warranty; and distribute a copy of this License along with the +Library. + + You may charge a fee for the physical act of transferring a copy, +and you may at your option offer warranty protection in exchange for a +fee. + + 2. You may modify your copy or copies of the Library or any portion +of it, thus forming a work based on the Library, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) The modified work must itself be a software library. + + b) You must cause the files modified to carry prominent notices + stating that you changed the files and the date of any change. + + c) You must cause the whole of the work to be licensed at no + charge to all third parties under the terms of this License. + + d) If a facility in the modified Library refers to a function or a + table of data to be supplied by an application program that uses + the facility, other than as an argument passed when the facility + is invoked, then you must make a good faith effort to ensure that, + in the event an application does not supply such function or + table, the facility still operates, and performs whatever part of + its purpose remains meaningful. + + (For example, a function in a library to compute square roots has + a purpose that is entirely well-defined independent of the + application. Therefore, Subsection 2d requires that any + application-supplied function or table used by this function must + be optional: if the application does not supply it, the square + root function must still compute square roots.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Library, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Library, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote +it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Library. + +In addition, mere aggregation of another work not based on the Library +with the Library (or with a work based on the Library) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may opt to apply the terms of the ordinary GNU General Public +License instead of this License to a given copy of the Library. To do +this, you must alter all the notices that refer to this License, so +that they refer to the ordinary GNU General Public License, version 2, +instead of to this License. (If a newer version than version 2 of the +ordinary GNU General Public License has appeared, then you can specify +that version instead if you wish.) Do not make any other change in +these notices. + + Once this change is made in a given copy, it is irreversible for +that copy, so the ordinary GNU General Public License applies to all +subsequent copies and derivative works made from that copy. + + This option is useful when you wish to copy part of the code of +the Library into a program that is not a library. + + 4. You may copy and distribute the Library (or a portion or +derivative of it, under Section 2) in object code or executable form +under the terms of Sections 1 and 2 above provided that you accompany +it with the complete corresponding machine-readable source code, which +must be distributed under the terms of Sections 1 and 2 above on a +medium customarily used for software interchange. + + If distribution of object code is made by offering access to copy +from a designated place, then offering equivalent access to copy the +source code from the same place satisfies the requirement to +distribute the source code, even though third parties are not +compelled to copy the source along with the object code. + + 5. A program that contains no derivative of any portion of the +Library, but is designed to work with the Library by being compiled or +linked with it, is called a "work that uses the Library". Such a +work, in isolation, is not a derivative work of the Library, and +therefore falls outside the scope of this License. + + However, linking a "work that uses the Library" with the Library +creates an executable that is a derivative of the Library (because it +contains portions of the Library), rather than a "work that uses the +library". The executable is therefore covered by this License. +Section 6 states terms for distribution of such executables. + + When a "work that uses the Library" uses material from a header file +that is part of the Library, the object code for the work may be a +derivative work of the Library even though the source code is not. +Whether this is true is especially significant if the work can be +linked without the Library, or if the work is itself a library. The +threshold for this to be true is not precisely defined by law. + + If such an object file uses only numerical parameters, data +structure layouts and accessors, and small macros and small inline +functions (ten lines or less in length), then the use of the object +file is unrestricted, regardless of whether it is legally a derivative +work. (Executables containing this object code plus portions of the +Library will still fall under Section 6.) + + Otherwise, if the work is a derivative of the Library, you may +distribute the object code for the work under the terms of Section 6. +Any executables containing that work also fall under Section 6, +whether or not they are linked directly with the Library itself. + + 6. As an exception to the Sections above, you may also combine or +link a "work that uses the Library" with the Library to produce a +work containing portions of the Library, and distribute that work +under terms of your choice, provided that the terms permit +modification of the work for the customer's own use and reverse +engineering for debugging such modifications. + + You must give prominent notice with each copy of the work that the +Library is used in it and that the Library and its use are covered by +this License. You must supply a copy of this License. If the work +during execution displays copyright notices, you must include the +copyright notice for the Library among them, as well as a reference +directing the user to the copy of this License. Also, you must do one +of these things: + + a) Accompany the work with the complete corresponding + machine-readable source code for the Library including whatever + changes were used in the work (which must be distributed under + Sections 1 and 2 above); and, if the work is an executable linked + with the Library, with the complete machine-readable "work that + uses the Library", as object code and/or source code, so that the + user can modify the Library and then relink to produce a modified + executable containing the modified Library. (It is understood + that the user who changes the contents of definitions files in the + Library will not necessarily be able to recompile the application + to use the modified definitions.) + + b) Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (1) uses at run time a + copy of the library already present on the user's computer system, + rather than copying library functions into the executable, and (2) + will operate properly with a modified version of the library, if + the user installs one, as long as the modified version is + interface-compatible with the version that the work was made with. + + c) Accompany the work with a written offer, valid for at + least three years, to give the same user the materials + specified in Subsection 6a, above, for a charge no more + than the cost of performing this distribution. + + d) If distribution of the work is made by offering access to copy + from a designated place, offer equivalent access to copy the above + specified materials from the same place. + + e) Verify that the user has already received a copy of these + materials or that you have already sent this user a copy. + + For an executable, the required form of the "work that uses the +Library" must include any data and utility programs needed for +reproducing the executable from it. However, as a special exception, +the materials to be distributed need not include anything that is +normally distributed (in either source or binary form) with the major +components (compiler, kernel, and so on) of the operating system on +which the executable runs, unless that component itself accompanies +the executable. + + It may happen that this requirement contradicts the license +restrictions of other proprietary libraries that do not normally +accompany the operating system. Such a contradiction means you cannot +use both them and the Library together in an executable that you +distribute. + + 7. You may place library facilities that are a work based on the +Library side-by-side in a single library together with other library +facilities not covered by this License, and distribute such a combined +library, provided that the separate distribution of the work based on +the Library and of the other library facilities is otherwise +permitted, and provided that you do these two things: + + a) Accompany the combined library with a copy of the same work + based on the Library, uncombined with any other library + facilities. This must be distributed under the terms of the + Sections above. + + b) Give prominent notice with the combined library of the fact + that part of it is a work based on the Library, and explaining + where to find the accompanying uncombined form of the same work. + + 8. You may not copy, modify, sublicense, link with, or distribute +the Library except as expressly provided under this License. Any +attempt otherwise to copy, modify, sublicense, link with, or +distribute the Library is void, and will automatically terminate your +rights under this License. However, parties who have received copies, +or rights, from you under this License will not have their licenses +terminated so long as such parties remain in full compliance. + + 9. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Library or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Library (or any work based on the +Library), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Library or works based on it. + + 10. Each time you redistribute the Library (or any work based on the +Library), the recipient automatically receives a license from the +original licensor to copy, distribute, link with or modify the Library +subject to these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties with +this License. + + 11. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Library at all. For example, if a patent +license would not permit royalty-free redistribution of the Library by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Library. + +If any portion of this section is held invalid or unenforceable under any +particular circumstance, the balance of the section is intended to apply, +and the section as a whole is intended to apply in other circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 12. If the distribution and/or use of the Library is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Library under this License may add +an explicit geographical distribution limitation excluding those countries, +so that distribution is permitted only in or among countries not thus +excluded. In such case, this License incorporates the limitation as if +written in the body of this License. + + 13. The Free Software Foundation may publish revised and/or new +versions of the Lesser General Public License from time to time. +Such new versions will be similar in spirit to the present version, +but may differ in detail to address new problems or concerns. + +Each version is given a distinguishing version number. If the Library +specifies a version number of this License which applies to it and +"any later version", you have the option of following the terms and +conditions either of that version or of any later version published by +the Free Software Foundation. If the Library does not specify a +license version number, you may choose any version ever published by +the Free Software Foundation. + + 14. If you wish to incorporate parts of the Library into other free +programs whose distribution conditions are incompatible with these, +write to the author to ask for permission. For software which is +copyrighted by the Free Software Foundation, write to the Free +Software Foundation; we sometimes make exceptions for this. Our +decision will be guided by the two goals of preserving the free status +of all derivatives of our free software and of promoting the sharing +and reuse of software generally. + + NO WARRANTY + + 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO +WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. +EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR +OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY +KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE +LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME +THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN +WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY +AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU +FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR +CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE +LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING +RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A +FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF +SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH +DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Libraries + + If you develop a new library, and you want it to be of the greatest +possible use to the public, we recommend making it free software that +everyone can redistribute and change. You can do so by permitting +redistribution under these terms (or, alternatively, under the terms of the +ordinary General Public License). + + To apply these terms, attach the following notices to the library. It is +safest to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least the +"copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + +Also add information on how to contact you by electronic and paper mail. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the library, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the + library `Frob' (a library for tweaking knobs) written by James Random Hacker. + + , 1 April 1990 + Ty Coon, President of Vice + +That's all there is to it! + + diff --git a/Changelog b/Changelog new file mode 100644 index 0000000..2caabda --- /dev/null +++ b/Changelog @@ -0,0 +1,281 @@ +version 0.9.23: + +- initial PE executable format for windows version (grischka) +- '#pragma pack' support (grischka) +- '#include_next' support (Bernhard Fischer) +- ignore '-pipe' option +- added -f[no-]leading-underscore +- preprocessor function macro parsing fix (grischka) + +version 0.9.22: + +- simple memory optimisations: kernel compilation is 30% faster +- linker symbol definitions fixes +- gcc 3.4 fixes +- fixed value stack full error +- 'packed' attribute support for variables and structure fields +- ignore 'const' and 'volatile' in function prototypes +- allow '_Bool' in bit fields + +version 0.9.21: + +- ARM target support (Daniel Glöckner) +- added '-funsigned-char, '-fsigned-char' and + '-Wimplicit-function-declaration' +- fixed assignment of const struct in struct +- line comment fix (reported by Bertram Felgenhauer) +- initial TMS320C67xx target support (TK) +- win32 configure +- regparm() attribute +- many built-in assembler fixes +- added '.org', '.fill' and '.previous' assembler directives +- '-fno-common' option +- '-Ttext' linker option +- section alignment fixes +- bit fields fixes +- do not generate code for unused inline functions +- '-oformat' linker option. +- added 'binary' output format. + +version 0.9.20: + +- added '-w' option +- added '.gnu.linkonce' ELF sections support +- fixed libc linking when running in memory (avoid 'stat' function + errors). +- extended '-run' option to be able to give several arguments to a C + script. + +version 0.9.19: + +- "alacarte" linking (Dave Long) +- simpler function call +- more strict type checks +- added 'const' and 'volatile' support and associated warnings +- added -Werror, -Wunsupported, -Wwrite-strings, -Wall. +- added __builtin_types_compatible_p() and __builtin_constant_p() +- chars support in assembler (Dave Long) +- .string, .globl, .section, .text, .data and .bss asm directive + support (Dave Long) +- man page generated from tcc-doc.texi +- fixed macro argument substitution +- fixed zero argument macro parsing +- changed license to LGPL +- added -rdynamic option support + +version 0.9.18: + +- header fix (time.h) +- fixed inline asm without operand case +- fixed 'default:' or 'case x:' with '}' after (incorrect C construct accepted + by gcc) +- added 'A' inline asm constraint. + +version 0.9.17: + +- PLT generation fix +- tcc doc fixes (Peter Lund) +- struct parse fix (signaled by Pedro A. Aranda Gutierrez) +- better _Bool lvalue support (signaled by Alex Measday) +- function parameters must be converted to pointers (signaled by Neil Brown) +- sanitized string and character constant parsing +- fixed comment parse (signaled by Damian M Gryski) +- fixed macro function bug (signaled by Philippe Ribet) +- added configure (initial patch by Mitchell N Charity) +- added '-run' and '-v' options (initial patch by vlindos) +- added real date report in __DATE__ and __TIME__ macros + +version 0.9.16: + +- added assembler language support +- added GCC inline asm() support +- fixed multiple variable definitions : uninitialized variables are + created as COMMON symbols. +- optimized macro processing +- added GCC statement expressions support +- added GCC local labels support +- fixed array declaration in old style function parameters +- support casts in static structure initializations +- added various __xxx[__] keywords for GCC compatibility +- ignore __extension__ GCC in an expression or in a type (still not perfect) +- added '? :' GCC extension support + +version 0.9.15: + +- compilation fixes for glibc 2.2, gcc 2.95.3 and gcc 3.2. +- FreeBSD compile fixes. Makefile patches still missing (Carl Drougge). +- fixed file type guessing if '.' is in the path. +- fixed tcc_compile_string() +- add a dummy page in ELF files to fix RX/RW accesses (pageexec at + freemail dot hu). + +version 0.9.14: + +- added #warning. error message if invalid preprocessing directive. +- added CType structure to ease typing (faster parse). +- suppressed secondary hash tables (faster parse). +- rewrote parser by optimizing common cases (faster parse). +- fixed signed long long comparisons. +- fixed 'int a(), b();' declaration case. +- fixed structure init without '{}'. +- correct alignment support in structures. +- empty structures support. +- gcc testsuite now supported. +- output only warning if implicit integer/pointer conversions. +- added static bitfield init. + +version 0.9.13: + +- correct preprocessing token pasting (## operator) in all cases (added + preprocessing number token). +- fixed long long register spill. +- fixed signed long long '>>'. +- removed memory leaks. +- better error handling : processing can continue on link errors. A + custom callback can be added to display error messages. Most + errors do not call exit() now. +- ignore -O, -W, -m and -f options +- added old style function declarations +- added GCC __alignof__ support. +- added GCC typeof support. +- added GCC computed gotos support. +- added stack backtrace in runtime error message. Improved runtime + error position display. + +version 0.9.12: + +- more fixes for || and && handling. +- improved '? :' type handling. +- fixed bound checking generation with structures +- force '#endif' to be in same file as matching '#if' +- #include file optimization with '#ifndef #endif' construct detection +- macro handling optimization +- added tcc_relocate() and tcc_get_symbol() in libtcc. + +version 0.9.11: + +- stdarg.h fix for double type (thanks to Philippe Ribet). +- correct white space characters and added MSDOS newline support. +- fixed invalid implicit function call type declaration. +- special macros such as __LINE__ are defined if tested with defined(). +- fixed '!' operator with relocated address. +- added symbol + offset relocation (fixes some static variable initializers) +- '-l' option can be specified anywhere. '-c' option yields default + output name. added '-r' option for relocatable output. +- fixed '\nnn' octal parsing. +- fixed local extern variables declarations. + +version 0.9.10: + +- fixed lvalue type when saved in local stack. +- fixed '#include' syntax when using macros. +- fixed '#line' bug. +- removed size limit on strings. Unified string constants handling + with variable declarations. +- added correct support for '\xX' in wchar_t strings. +- added support for bound checking in generated executables +- fixed -I include order. +- fixed incorrect function displayed in runtime error. + +version 0.9.9: + +- fixed preprocessor expression parsing for #if/#elif. +- relocated debug info (.stab section). +- relocated bounds info (.bounds section). +- fixed cast to char of char constants ('\377' is -1 instead of 255) +- fixed implicit cast for unary plus. +- strings and '__func__' have now 'char[]' type instead of 'char *' + (fixes sizeof() return value). +- added __start_xxx and __stop_xxx symbols in linker. +- better DLL creation support (option -shared begins to work). +- ELF sections and hash tables are resized dynamically. +- executables and DLLs are stripped by default. + +version 0.9.8: + +- First version of full ELF linking support (generate objects, static + executable, dynamic executable, dynamic libraries). Dynamic library + support is not finished (need PIC support in compiler and some + patches in symbol exporting). +- First version of ELF loader for object (.o) and archive (.a) files. +- Support of simple GNU ld scripts (GROUP and FILE commands) +- Separated runtime library and bound check code from TCC (smaller + compiler core). +- fixed register reload in float compare. +- fixed implicit char/short to int casting. +- allow array type for address of ('&') operator. +- fixed unused || or && result. +- added GCC style variadic macro support. +- optimized bound checking code for array access. +- tcc includes are now in $(prefix)/lib/tcc/include. +- more command line options - more consistent handling of multiple + input files. +- added tcc man page (thanks to Cyril Bouthors). +- uClibc Makefile update +- converted documentation to texinfo format. +- added developper's guide in documentation. + +version 0.9.7: + +- added library API for easy dynamic compilation (see libtcc.h - first + draft). +- fixed long long register spill bug. +- fixed '? :' register spill bug. + +version 0.9.6: + +- added floating point constant propagation (fixes negative floating + point constants bug). + +version 0.9.5: + + - uClibc patches (submitted by Alfonso Martone). + - error reporting fix + - added CONFIG_TCC_BCHECK to get smaller code if needed. + +version 0.9.4: + + - windows port (currently cannot use -g, -b and dll functions). + - faster and simpler I/O handling. + - '-D' option works in all cases. + - preprocessor fixes (#elif and empty macro args) + - floating point fixes + - first code for CIL generation (does not work yet) + +version 0.9.3: + + - better and smaller code generator. + - full ISOC99 64 bit 'long long' support. + - full 32 bit 'float', 64 bit 'double' and 96 bit 'long double' support. + - added '-U' option. + - added assembly sections support. + - even faster startup time by mmaping sections instead of mallocing them. + - added GNUC __attribute__ keyword support (currently supports + 'section' and 'aligned' attributes). + - added ELF file output (only usable for debugging now) + - added debug symbol generation (STAB format). + - added integrated runtime error analysis ('-g' option: print clear + run time error messages instead of "Segmentation fault"). + - added first version of tiny memory and bound checker ('-b' option). + +version 0.9.2: + + - even faster parsing. + - various syntax parsing fixes. + - fixed external relocation handling for variables or functions pointers. + - better function pointers type handling. + - can compile multiple files (-i option). + - ANSI C bit fields are supported. + - beginning of float/double/long double support. + - beginning of long long support. + +version 0.9.1: + + - full ISOC99 initializers handling. + - compound literals. + - structures handle in assignments and as function param or return value. + - wide chars and strings. + - macro bug fix + +version 0.9: + - initial version. diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..77724f1 --- /dev/null +++ b/Makefile @@ -0,0 +1,268 @@ +# +# Tiny C Compiler Makefile +# +include config.mak + +#CFLAGS=-pg -fprofile-arcs -ftest-coverage -O0 -g -Wall -Wno-pointer-sign +CFLAGS=-O2 -g -Wno-pointer-sign -Wno-sign-compare -Wno-unused-result +ifndef CONFIG_WIN32 +BCHECK_O=bcheck.o +endif +CFLAGS_P=$(CFLAGS) -pg -static -DCONFIG_TCC_STATIC +LIBS_P= + +CFLAGS+=-mpreferred-stack-boundary=4 +ifeq ($(GCC_MAJOR),2) +CFLAGS+=-m386 -malign-functions=0 +else +CFLAGS+=-falign-functions=0 -fno-strict-aliasing +endif + +DISAS=objdump -d +INSTALL=install + +ifdef CONFIG_CROSS +PROGS+=816-tcc$(EXESUF) +endif + +# run local version of tcc with local libraries and includes +TCC=./tcc -B. -I. + +all: $(PROGS) \ + tcc-doc.html tcc.1 + +Makefile: config.mak + +# auto test + +test: test.ref test.out + @if diff -u test.ref test.out ; then echo "Auto Test OK"; fi + +tcctest.ref: tcctest.c + $(CC) $(CFLAGS) -I. -o $@ $< + +test.ref: tcctest.ref + ./tcctest.ref > $@ + +test.out: tcc tcctest.c + $(TCC) -run tcctest.c > $@ + +run: tcc tcctest.c + $(TCC) -run tcctest.c + +# iterated test2 (compile tcc then compile tcctest.c !) +test2: tcc tcc.c tcctest.c test.ref + $(TCC) -run tcc.c -B. -I. -run tcctest.c > test.out2 + @if diff -u test.ref test.out2 ; then echo "Auto Test2 OK"; fi + +# iterated test3 (compile tcc then compile tcc then compile tcctest.c !) +test3: tcc tcc.c tcctest.c test.ref + $(TCC) -run tcc.c -B. -I. -run tcc.c -B. -I. -run tcctest.c > test.out3 + @if diff -u test.ref test.out3 ; then echo "Auto Test3 OK"; fi + +# binary output test +test4: tcc test.ref +# dynamic output + $(TCC) -o tcctest1 tcctest.c + ./tcctest1 > test1.out + @if diff -u test.ref test1.out ; then echo "Dynamic Auto Test OK"; fi +# static output + $(TCC) -static -o tcctest2 tcctest.c + ./tcctest2 > test2.out + @if diff -u test.ref test2.out ; then echo "Static Auto Test OK"; fi +# object + link output + $(TCC) -c -o tcctest3.o tcctest.c + $(TCC) -o tcctest3 tcctest3.o + ./tcctest3 > test3.out + @if diff -u test.ref test3.out ; then echo "Object Auto Test OK"; fi +# dynamic output + bound check + $(TCC) -b -o tcctest4 tcctest.c + ./tcctest4 > test4.out + @if diff -u test.ref test4.out ; then echo "BCheck Auto Test OK"; fi + +# memory and bound check auto test +BOUNDS_OK = 1 4 8 10 +BOUNDS_FAIL= 2 5 7 9 11 12 13 + +btest: boundtest.c tcc + @for i in $(BOUNDS_OK); do \ + if $(TCC) -b -run boundtest.c $$i ; then \ + /bin/true ; \ + else\ + echo Failed positive test $$i ; exit 1 ; \ + fi ;\ + done ;\ + for i in $(BOUNDS_FAIL); do \ + if $(TCC) -b -run boundtest.c $$i ; then \ + echo Failed negative test $$i ; exit 1 ;\ + else\ + /bin/true ; \ + fi\ + done ;\ + echo Bound test OK + +# speed test +speed: tcc ex2 ex3 + time ./ex2 1238 2 3 4 10 13 4 + time ./tcc -I. ./ex2.c 1238 2 3 4 10 13 4 + time ./ex3 35 + time ./tcc -I. ./ex3.c 35 + +ex2: ex2.c + $(CC) $(CFLAGS) -o $@ $< + +ex3: ex3.c + $(CC) $(CFLAGS) -o $@ $< + +# Host Tiny C Compiler +ifdef CONFIG_WIN32 +tcc$(EXESUF): tcc.c tccelf.c tccasm.c i386-asm.c tcctok.h libtcc.h i386-asm.h tccpe.c + $(CC) $(CFLAGS) -DTCC_TARGET_PE -o $@ $< $(LIBS) +else +ifeq ($(ARCH),i386) +tcc$(EXESUF): tcc.c tccelf.c tccasm.c i386-asm.c tcctok.h libtcc.h i386-asm.h + $(CC) $(CFLAGS) -o $@ $< $(LIBS) +endif +ifeq ($(ARCH),arm) +tcc$(EXESUF): tcc.c arm-gen.c tccelf.c tccasm.c tcctok.h libtcc.h + $(CC) $(CFLAGS) -DTCC_TARGET_ARM -o $@ $< $(LIBS) +endif +endif + +# Cross Tiny C Compilers +816-tcc$(EXESUF): tcc.c 816-gen.c tccelf.c tcctok.h + $(CC) $(CFLAGS) -DTCC_TARGET_816 -o $@ $< $(LIBS) + +# windows utilities +tiny_impdef$(EXESUF): tiny_impdef.c + $(CC) $(CFLAGS) -o $@ $< -lkernel32 + +# TinyCC runtime libraries +ifdef CONFIG_WIN32 +# for windows, we must use TCC because we generate ELF objects +LIBTCC1_OBJS=$(addprefix win32/lib/, crt1.o wincrt1.o dllcrt1.o dllmain.o chkstk.o) libtcc1.o +LIBTCC1_CC=./tcc.exe -Bwin32 +else +LIBTCC1_OBJS=libtcc1.o +LIBTCC1_CC=$(CC) +endif + +%.o: %.c + $(LIBTCC1_CC) -O2 -Wall -c -o $@ $< + +%.o: %.S + $(LIBTCC1_CC) -c -o $@ $< + +libtcc1.a: $(LIBTCC1_OBJS) + $(AR) rcs $@ $^ + +bcheck.o: bcheck.c + $(CC) -O2 -Wall -c -o $@ $< + +install: tcc_install libinstall + +tcc_install: $(PROGS) tcc.1 libtcc1.a $(BCHECK_O) tcc-doc.html tcc.1 + mkdir -p "$(bindir)" + $(INSTALL) -s -m755 $(PROGS) "$(bindir)" +ifndef CONFIG_WIN32 + mkdir -p "$(mandir)/man1" + $(INSTALL) tcc.1 "$(mandir)/man1" +endif + mkdir -p "$(tccdir)" + mkdir -p "$(tccdir)/include" +ifdef CONFIG_WIN32 + mkdir -p "$(tccdir)/lib" + $(INSTALL) -m644 libtcc1.a win32/lib/*.def "$(tccdir)/lib" + cp -r win32/include/. "$(tccdir)/include" + cp -r win32/examples/. "$(tccdir)/examples" +else + $(INSTALL) -m644 libtcc1.a $(BCHECK_O) "$(tccdir)" + $(INSTALL) -m644 stdarg.h stddef.h stdbool.h float.h varargs.h \ + tcclib.h "$(tccdir)/include" +endif + mkdir -p "$(docdir)" + $(INSTALL) -m644 tcc-doc.html "$(docdir)" +ifdef CONFIG_WIN32 + $(INSTALL) -m644 win32/readme.txt "$(docdir)" +endif + +clean: + rm -f *~ *.o *.a tcc tcc1 tcct tcc_g tcctest.ref *.bin *.i ex2 \ + core gmon.out test.out test.ref a.out tcc_p \ + *.exe *.lib tcc.pod libtcc_test \ + tcctest[1234] test[1234].out $(PROGS) win32/lib/*.o test/failtraces/* 816-tcc + +distclean: clean + rm -f config.h config.mak config.texi + +# profiling version +tcc_p: tcc.c Makefile + $(CC) $(CFLAGS_P) -o $@ $< $(LIBS_P) + +# libtcc generation and example +libinstall: libtcc.a + mkdir -p "$(libdir)" + $(INSTALL) -m644 libtcc.a "$(libdir)" + mkdir -p "$(includedir)" + $(INSTALL) -m644 libtcc.h "$(includedir)" + +libtcc.o: tcc.c Makefile + $(CC) $(CFLAGS) -DLIBTCC -c -o $@ $< + +libtcc.a: libtcc.o + $(AR) rcs $@ $^ + +libtcc_test$(EXESUF): libtcc_test.c libtcc.a + $(CC) $(CFLAGS) -o $@ $< libtcc.a $(LIBS) + +libtest: libtcc_test + ./libtcc_test + +# targets for development + +%.bin: %.c tcc + $(TCC) -g -o $@ $< + $(DISAS) $@ + +instr: instr.o + objdump -d instr.o + +# tiny assembler testing + +asmtest.ref: asmtest.S + $(CC) -c -o asmtest.ref.o asmtest.S + objdump -D asmtest.ref.o > $@ + +# XXX: we compute tcc.c to go faster during development ! +asmtest.out: asmtest.S tcc +# ./tcc tcc.c -c asmtest.S +#asmtest.out: asmtest.S tcc + ./tcc -c asmtest.S + objdump -D asmtest.o > $@ + +asmtest: asmtest.out asmtest.ref + @if diff -u --ignore-matching-lines="file format" asmtest.ref asmtest.out ; then echo "ASM Auto Test OK"; fi + +instr.o: instr.S + $(CC) -O2 -Wall -g -c -o $@ $< + +cache: tcc_g + cachegrind ./tcc_g -o /tmp/linpack -lm bench/linpack.c + vg_annotate tcc.c > /tmp/linpack.cache.log + +# documentation and man page +tcc-doc.html: tcc-doc.texi + texi2html -monolithic -number $< + +tcc.1: tcc-doc.texi + ./texi2pod.pl $< tcc.pod + pod2man --section=1 --center=" " --release=" " tcc.pod > $@ + +FILE=tcc-$(shell cat VERSION) + +# tar release (use 'make -k tar' on a checkouted tree) +tar: + rm -rf /tmp/$(FILE) + cp -r . /tmp/$(FILE) + ( cd /tmp ; tar zcvf ~/$(FILE).tar.gz $(FILE) --exclude CVS ) + rm -rf /tmp/$(FILE) diff --git a/README b/README new file mode 100644 index 0000000..abc3d26 --- /dev/null +++ b/README @@ -0,0 +1,91 @@ +Tiny C Compiler - C Scripting Everywhere - The Smallest ANSI C compiler +----------------------------------------------------------------------- + +Features: +-------- + +- SMALL! You can compile and execute C code everywhere, for example on + rescue disks. + +- FAST! tcc generates optimized x86 code. No byte code + overhead. Compile, assemble and link about 7 times faster than 'gcc + -O0'. + +- UNLIMITED! Any C dynamic library can be used directly. TCC is + heading torward full ISOC99 compliance. TCC can of course compile + itself. + +- SAFE! tcc includes an optional memory and bound checker. Bound + checked code can be mixed freely with standard code. + +- Compile and execute C source directly. No linking or assembly + necessary. Full C preprocessor included. + +- C script supported : just add '#!/usr/local/bin/tcc -run' at the first + line of your C source, and execute it directly from the command + line. + +Documentation: +------------- + +1) Installation on a i386 Linux host (for Windows read win32/readme.txt) + + ./configure + make + make test + make install + +By default, tcc is installed in /usr/local/bin. +./configure --help shows configuration options. + + +2) Introduction + +We assume here that you know ANSI C. Look at the example ex1.c to know +what the programs look like. + +The include file can be used if you want a small basic libc +include support (especially useful for floppy disks). Of course, you +can also use standard headers, although they are slower to compile. + +You can begin your C script with '#!/usr/local/bin/tcc -run' on the first +line and set its execute bits (chmod a+x your_script). Then, you can +launch the C code as a shell or perl script :-) The command line +arguments are put in 'argc' and 'argv' of the main functions, as in +ANSI C. + +3) Examples + +ex1.c: simplest example (hello world). Can also be launched directly +as a script: './ex1.c'. + +ex2.c: more complicated example: find a number with the four +operations given a list of numbers (benchmark). + +ex3.c: compute fibonacci numbers (benchmark). + +ex4.c: more complicated: X11 program. Very complicated test in fact +because standard headers are being used ! + +ex5.c: 'hello world' with standard glibc headers. + +tcc.c: TCC can of course compile itself. Used to check the code +generator. + +tcctest.c: auto test for TCC which tests many subtle possible bugs. Used +when doing 'make test'. + +4) Full Documentation + +Please read tcc-doc.html to have all the features of TCC. + +Additional information is available for the Windows port in +win32/readme.txt. + +License: +------- + +TCC is distributed under the GNU Lesser General Public License (see +COPYING file). + +Fabrice Bellard. diff --git a/TODO b/TODO new file mode 100644 index 0000000..cf22bc7 --- /dev/null +++ b/TODO @@ -0,0 +1,81 @@ +TODO list: + +- bug with defines: + #define spin_lock(lock) do { } while (0) + #define wq_spin_lock spin_lock + #define TEST() wq_spin_lock(a) +- typedefs can be structure fields +- see bugfixes.diff + improvement.diff from Daniel Glockner +- constructors +- cast bug (Peter Wang) +- define incomplete type if defined several times (Peter Wang). +- long long constant evaluation +- configure --cc=tcc (still one bug in libtcc1.c) +- disable-asm and disable-bcheck options +- test binutils/gcc compile +- add alloca(), __builtin_expect() +- gcc '-E' option. +- optimize VT_LOCAL + const +- tci patch + argument. +- '-b' bug. +- atexit (Nigel Horne) +- see -lxxx bug (Michael Charity). +- see transparent union pb in /urs/include/sys/socket.h +- precise behaviour of typeof with arrays ? (__put_user macro) +- #include_next support for /usr/include/limits ? + but should suffice for most cases) +- handle '? x, y : z' in unsized variable initialization (',' is + considered incorrectly as separator in preparser) +- function pointers/lvalues in ? : (linux kernel net/core/dev.c) +- transform functions to function pointers in function parameters (net/ipv4/ip_output.c) +- fix function pointer type display +- fix bound exit on RedHat 7.3 +- check lcc test suite -> fix bitfield binary operations +- check section alignment in C +- fix invalid cast in comparison 'if (v == (int8_t)v)' +- packed attribute +- finish varargs.h support (gcc 3.2 testsuite issue) +- fix static functions declared inside block +- C99: add variable size arrays (gcc 3.2 testsuite issue) +- C99: add complex types (gcc 3.2 testsuite issue) +- postfix compound literals (see 20010124-1.c) +- fix multiple unions init +- setjmp is not supported properly in bound checking. +- better local variables handling (needed for other targets) +- fix bound check code with '&' on local variables (currently done + only for local arrays). +- sizeof, alignof, typeof can still generate code in some cases. +- bound checking and float/long long/struct copy code. bound + checking and symbol + offset optimization +- Fix the remaining libtcc memory leaks. +- make libtcc fully reentrant (except for the compilation stage itself). +- '-MD' option + +Optimizations: + +- suppress specific anonymous symbol handling +- more parse optimizations (=even faster compilation) +- memory alloc optimizations (=even faster compilation) + +Not critical: + +- C99: fix multiple compound literals inits in blocks (ISOC99 + normative example - only relevant when using gotos! -> must add + boolean variable to tell if compound literal was already + initialized). +- add PowerPC or ARM code generator and improve codegen for RISC (need + to suppress VT_LOCAL and use a base register instead). +- interactive mode / integrated debugger +- fix preprocessor symbol redefinition +- better constant opt (&&, ||, ?:) +- add portable byte code generator and interpreter for other + unsupported architectures. +- C++: variable declaration in for, minimal 'class' support. +- win32: add __stdcall, __intxx. use resolve for bchecked malloc et + al. check GetModuleHandle for dlls. check exception code (exception + filter func). +- handle void (__attribute__() *ptr)() + + + + diff --git a/VERSION b/VERSION new file mode 100644 index 0000000..bfdccf3 --- /dev/null +++ b/VERSION @@ -0,0 +1 @@ +0.9.23 \ No newline at end of file diff --git a/bcheck.c b/bcheck.c new file mode 100644 index 0000000..7da8402 --- /dev/null +++ b/bcheck.c @@ -0,0 +1,867 @@ +/* + * Tiny C Memory and bounds checker + * + * Copyright (c) 2002 Fabrice Bellard + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ +#include +#include +#include +#include +#ifndef __FreeBSD__ +#include +#endif + +//#define BOUND_DEBUG + +/* define so that bound array is static (faster, but use memory if + bound checking not used) */ +//#define BOUND_STATIC + +/* use malloc hooks. Currently the code cannot be reliable if no hooks */ +#define CONFIG_TCC_MALLOC_HOOKS + +#define HAVE_MEMALIGN + +#if defined(__FreeBSD__) || defined(__dietlibc__) +#warning Bound checking not fully supported on FreeBSD +#undef CONFIG_TCC_MALLOC_HOOKS +#undef HAVE_MEMALIGN +#endif + +#define BOUND_T1_BITS 13 +#define BOUND_T2_BITS 11 +#define BOUND_T3_BITS (32 - BOUND_T1_BITS - BOUND_T2_BITS) + +#define BOUND_T1_SIZE (1 << BOUND_T1_BITS) +#define BOUND_T2_SIZE (1 << BOUND_T2_BITS) +#define BOUND_T3_SIZE (1 << BOUND_T3_BITS) +#define BOUND_E_BITS 4 + +#define BOUND_T23_BITS (BOUND_T2_BITS + BOUND_T3_BITS) +#define BOUND_T23_SIZE (1 << BOUND_T23_BITS) + + +/* this pointer is generated when bound check is incorrect */ +#define INVALID_POINTER ((void *)(-2)) +/* size of an empty region */ +#define EMPTY_SIZE 0xffffffff +/* size of an invalid region */ +#define INVALID_SIZE 0 + +typedef struct BoundEntry { + unsigned long start; + unsigned long size; + struct BoundEntry *next; + unsigned long is_invalid; /* true if pointers outside region are invalid */ +} BoundEntry; + +/* external interface */ +void __bound_init(void); +void __bound_new_region(void *p, unsigned long size); +int __bound_delete_region(void *p); + +#define FASTCALL __attribute__((regparm(3))) + +void *__bound_malloc(size_t size, const void *caller); +void *__bound_memalign(size_t size, size_t align, const void *caller); +void __bound_free(void *ptr, const void *caller); +void *__bound_realloc(void *ptr, size_t size, const void *caller); +static void *libc_malloc(size_t size); +static void libc_free(void *ptr); +static void install_malloc_hooks(void); +static void restore_malloc_hooks(void); + +#ifdef CONFIG_TCC_MALLOC_HOOKS +static void *saved_malloc_hook; +static void *saved_free_hook; +static void *saved_realloc_hook; +static void *saved_memalign_hook; +#endif + +/* linker definitions */ +extern char _end; + +/* TCC definitions */ +extern char __bounds_start; /* start of static bounds table */ +/* error message, just for TCC */ +const char *__bound_error_msg; + +/* runtime error output */ +extern void rt_error(unsigned long pc, const char *fmt, ...); + +#ifdef BOUND_STATIC +static BoundEntry *__bound_t1[BOUND_T1_SIZE]; /* page table */ +#else +static BoundEntry **__bound_t1; /* page table */ +#endif +static BoundEntry *__bound_empty_t2; /* empty page, for unused pages */ +static BoundEntry *__bound_invalid_t2; /* invalid page, for invalid pointers */ + +static BoundEntry *__bound_find_region(BoundEntry *e1, void *p) +{ + unsigned long addr, tmp; + BoundEntry *e; + + e = e1; + while (e != NULL) { + addr = (unsigned long)p; + addr -= e->start; + if (addr <= e->size) { + /* put region at the head */ + tmp = e1->start; + e1->start = e->start; + e->start = tmp; + tmp = e1->size; + e1->size = e->size; + e->size = tmp; + return e1; + } + e = e->next; + } + /* no entry found: return empty entry or invalid entry */ + if (e1->is_invalid) + return __bound_invalid_t2; + else + return __bound_empty_t2; +} + +/* print a bound error message */ +static void bound_error(const char *fmt, ...) +{ + __bound_error_msg = fmt; + *(int *)0 = 0; /* force a runtime error */ +} + +static void bound_alloc_error(void) +{ + bound_error("not enough memory for bound checking code"); +} + +/* currently, tcc cannot compile that because we use GNUC extensions */ +#if !defined(__TINYC__) + +/* return '(p + offset)' for pointer arithmetic (a pointer can reach + the end of a region in this case */ +void * FASTCALL __bound_ptr_add(void *p, int offset) +{ + unsigned long addr = (unsigned long)p; + BoundEntry *e; +#if defined(BOUND_DEBUG) + printf("add: 0x%x %d\n", (int)p, offset); +#endif + + e = __bound_t1[addr >> (BOUND_T2_BITS + BOUND_T3_BITS)]; + e = (BoundEntry *)((char *)e + + ((addr >> (BOUND_T3_BITS - BOUND_E_BITS)) & + ((BOUND_T2_SIZE - 1) << BOUND_E_BITS))); + addr -= e->start; + if (addr > e->size) { + e = __bound_find_region(e, p); + addr = (unsigned long)p - e->start; + } + addr += offset; + if (addr > e->size) + return INVALID_POINTER; /* return an invalid pointer */ + return p + offset; +} + +/* return '(p + offset)' for pointer indirection (the resulting must + be strictly inside the region */ +#define BOUND_PTR_INDIR(dsize) \ +void * FASTCALL __bound_ptr_indir ## dsize (void *p, int offset) \ +{ \ + unsigned long addr = (unsigned long)p; \ + BoundEntry *e; \ + \ + e = __bound_t1[addr >> (BOUND_T2_BITS + BOUND_T3_BITS)]; \ + e = (BoundEntry *)((char *)e + \ + ((addr >> (BOUND_T3_BITS - BOUND_E_BITS)) & \ + ((BOUND_T2_SIZE - 1) << BOUND_E_BITS))); \ + addr -= e->start; \ + if (addr > e->size) { \ + e = __bound_find_region(e, p); \ + addr = (unsigned long)p - e->start; \ + } \ + addr += offset + dsize; \ + if (addr > e->size) \ + return INVALID_POINTER; /* return an invalid pointer */ \ + return p + offset; \ +} + +#ifdef __i386__ +/* return the frame pointer of the caller */ +#define GET_CALLER_FP(fp)\ +{\ + unsigned long *fp1;\ + __asm__ __volatile__ ("movl %%ebp,%0" :"=g" (fp1));\ + fp = fp1[0];\ +} +#else +#error put code to extract the calling frame pointer +#endif + +/* called when entering a function to add all the local regions */ +void FASTCALL __bound_local_new(void *p1) +{ + unsigned long addr, size, fp, *p = p1; + GET_CALLER_FP(fp); + for(;;) { + addr = p[0]; + if (addr == 0) + break; + addr += fp; + size = p[1]; + p += 2; + __bound_new_region((void *)addr, size); + } +} + +/* called when leaving a function to delete all the local regions */ +void FASTCALL __bound_local_delete(void *p1) +{ + unsigned long addr, fp, *p = p1; + GET_CALLER_FP(fp); + for(;;) { + addr = p[0]; + if (addr == 0) + break; + addr += fp; + p += 2; + __bound_delete_region((void *)addr); + } +} + +#else + +void __bound_local_new(void *p) +{ +} +void __bound_local_delete(void *p) +{ +} + +void *__bound_ptr_add(void *p, int offset) +{ + return p + offset; +} + +#define BOUND_PTR_INDIR(dsize) \ +void *__bound_ptr_indir ## dsize (void *p, int offset) \ +{ \ + return p + offset; \ +} +#endif + +BOUND_PTR_INDIR(1) +BOUND_PTR_INDIR(2) +BOUND_PTR_INDIR(4) +BOUND_PTR_INDIR(8) +BOUND_PTR_INDIR(12) +BOUND_PTR_INDIR(16) + +static BoundEntry *__bound_new_page(void) +{ + BoundEntry *page; + int i; + + page = libc_malloc(sizeof(BoundEntry) * BOUND_T2_SIZE); + if (!page) + bound_alloc_error(); + for(i=0;i> BOUND_T3_BITS; + if (end != 0) + t2_end = end >> BOUND_T3_BITS; + else + t2_end = 1 << (BOUND_T1_BITS + BOUND_T2_BITS); + +#if 0 + printf("mark_invalid: start = %x %x\n", t2_start, t2_end); +#endif + + /* first we handle full pages */ + t1_start = (t2_start + BOUND_T2_SIZE - 1) >> BOUND_T2_BITS; + t1_end = t2_end >> BOUND_T2_BITS; + + i = t2_start & (BOUND_T2_SIZE - 1); + j = t2_end & (BOUND_T2_SIZE - 1); + + if (t1_start == t1_end) { + page = get_page(t2_start >> BOUND_T2_BITS); + for(; i < j; i++) { + page[i].size = INVALID_SIZE; + page[i].is_invalid = 1; + } + } else { + if (i > 0) { + page = get_page(t2_start >> BOUND_T2_BITS); + for(; i < BOUND_T2_SIZE; i++) { + page[i].size = INVALID_SIZE; + page[i].is_invalid = 1; + } + } + for(i = t1_start; i < t1_end; i++) { + __bound_t1[i] = __bound_invalid_t2; + } + if (j != 0) { + page = get_page(t1_end); + for(i = 0; i < j; i++) { + page[i].size = INVALID_SIZE; + page[i].is_invalid = 1; + } + } + } +} + +void __bound_init(void) +{ + int i; + BoundEntry *page; + unsigned long start, size; + int *p; + + /* save malloc hooks and install bound check hooks */ + install_malloc_hooks(); + +#ifndef BOUND_STATIC + __bound_t1 = libc_malloc(BOUND_T1_SIZE * sizeof(BoundEntry *)); + if (!__bound_t1) + bound_alloc_error(); +#endif + __bound_empty_t2 = __bound_new_page(); + for(i=0;istart == 0) { + /* no region : add it */ + e->start = start; + e->size = size; + } else { + /* already regions in the list: add it at the head */ + e1 = bound_new_entry(); + e1->start = e->start; + e1->size = e->size; + e1->next = e->next; + e->start = start; + e->size = size; + e->next = e1; + } +} + +/* create a new region. It should not already exist in the region list */ +void __bound_new_region(void *p, unsigned long size) +{ + unsigned long start, end; + BoundEntry *page, *e, *e2; + int t1_start, t1_end, i, t2_start, t2_end; + + start = (unsigned long)p; + end = start + size; + t1_start = start >> (BOUND_T2_BITS + BOUND_T3_BITS); + t1_end = end >> (BOUND_T2_BITS + BOUND_T3_BITS); + + /* start */ + page = get_page(t1_start); + t2_start = (start >> (BOUND_T3_BITS - BOUND_E_BITS)) & + ((BOUND_T2_SIZE - 1) << BOUND_E_BITS); + t2_end = (end >> (BOUND_T3_BITS - BOUND_E_BITS)) & + ((BOUND_T2_SIZE - 1) << BOUND_E_BITS); +#ifdef BOUND_DEBUG + printf("new %lx %lx %x %x %x %x\n", + start, end, t1_start, t1_end, t2_start, t2_end); +#endif + + e = (BoundEntry *)((char *)page + t2_start); + add_region(e, start, size); + + if (t1_end == t1_start) { + /* same ending page */ + e2 = (BoundEntry *)((char *)page + t2_end); + if (e2 > e) { + e++; + for(;estart = start; + e->size = size; + } + add_region(e, start, size); + } + } else { + /* mark until end of page */ + e2 = page + BOUND_T2_SIZE; + e++; + for(;estart = start; + e->size = size; + } + /* mark intermediate pages, if any */ + for(i=t1_start+1;istart = start; + e->size = size; + } + } + /* last page */ + page = get_page(t1_end); + e2 = (BoundEntry *)((char *)page + t2_end); + for(e=page;estart = start; + e->size = size; + } + add_region(e, start, size); + } +} + +/* delete a region */ +static inline void delete_region(BoundEntry *e, + void *p, unsigned long empty_size) +{ + unsigned long addr; + BoundEntry *e1; + + addr = (unsigned long)p; + addr -= e->start; + if (addr <= e->size) { + /* region found is first one */ + e1 = e->next; + if (e1 == NULL) { + /* no more region: mark it empty */ + e->start = 0; + e->size = empty_size; + } else { + /* copy next region in head */ + e->start = e1->start; + e->size = e1->size; + e->next = e1->next; + bound_free_entry(e1); + } + } else { + /* find the matching region */ + for(;;) { + e1 = e; + e = e->next; + /* region not found: do nothing */ + if (e == NULL) + break; + addr = (unsigned long)p - e->start; + if (addr <= e->size) { + /* found: remove entry */ + e1->next = e->next; + bound_free_entry(e); + break; + } + } + } +} + +/* WARNING: 'p' must be the starting point of the region. */ +/* return non zero if error */ +int __bound_delete_region(void *p) +{ + unsigned long start, end, addr, size, empty_size; + BoundEntry *page, *e, *e2; + int t1_start, t1_end, t2_start, t2_end, i; + + start = (unsigned long)p; + t1_start = start >> (BOUND_T2_BITS + BOUND_T3_BITS); + t2_start = (start >> (BOUND_T3_BITS - BOUND_E_BITS)) & + ((BOUND_T2_SIZE - 1) << BOUND_E_BITS); + + /* find region size */ + page = __bound_t1[t1_start]; + e = (BoundEntry *)((char *)page + t2_start); + addr = start - e->start; + if (addr > e->size) + e = __bound_find_region(e, p); + /* test if invalid region */ + if (e->size == EMPTY_SIZE || (unsigned long)p != e->start) + return -1; + /* compute the size we put in invalid regions */ + if (e->is_invalid) + empty_size = INVALID_SIZE; + else + empty_size = EMPTY_SIZE; + size = e->size; + end = start + size; + + /* now we can free each entry */ + t1_end = end >> (BOUND_T2_BITS + BOUND_T3_BITS); + t2_end = (end >> (BOUND_T3_BITS - BOUND_E_BITS)) & + ((BOUND_T2_SIZE - 1) << BOUND_E_BITS); + + delete_region(e, p, empty_size); + if (t1_end == t1_start) { + /* same ending page */ + e2 = (BoundEntry *)((char *)page + t2_end); + if (e2 > e) { + e++; + for(;estart = 0; + e->size = empty_size; + } + delete_region(e, p, empty_size); + } + } else { + /* mark until end of page */ + e2 = page + BOUND_T2_SIZE; + e++; + for(;estart = 0; + e->size = empty_size; + } + /* mark intermediate pages, if any */ + /* XXX: should free them */ + for(i=t1_start+1;istart = 0; + e->size = empty_size; + } + } + /* last page */ + page = get_page(t2_end); + e2 = (BoundEntry *)((char *)page + t2_end); + for(e=page;estart = 0; + e->size = empty_size; + } + delete_region(e, p, empty_size); + } + return 0; +} + +/* return the size of the region starting at p, or EMPTY_SIZE if non + existant region. */ +static unsigned long get_region_size(void *p) +{ + unsigned long addr = (unsigned long)p; + BoundEntry *e; + + e = __bound_t1[addr >> (BOUND_T2_BITS + BOUND_T3_BITS)]; + e = (BoundEntry *)((char *)e + + ((addr >> (BOUND_T3_BITS - BOUND_E_BITS)) & + ((BOUND_T2_SIZE - 1) << BOUND_E_BITS))); + addr -= e->start; + if (addr > e->size) + e = __bound_find_region(e, p); + if (e->start != (unsigned long)p) + return EMPTY_SIZE; + return e->size; +} + +/* patched memory functions */ + +static void install_malloc_hooks(void) +{ +#ifdef CONFIG_TCC_MALLOC_HOOKS + saved_malloc_hook = __malloc_hook; + saved_free_hook = __free_hook; + saved_realloc_hook = __realloc_hook; + saved_memalign_hook = __memalign_hook; + __malloc_hook = __bound_malloc; + __free_hook = __bound_free; + __realloc_hook = __bound_realloc; + __memalign_hook = __bound_memalign; +#endif +} + +static void restore_malloc_hooks(void) +{ +#ifdef CONFIG_TCC_MALLOC_HOOKS + __malloc_hook = saved_malloc_hook; + __free_hook = saved_free_hook; + __realloc_hook = saved_realloc_hook; + __memalign_hook = saved_memalign_hook; +#endif +} + +static void *libc_malloc(size_t size) +{ + void *ptr; + restore_malloc_hooks(); + ptr = malloc(size); + install_malloc_hooks(); + return ptr; +} + +static void libc_free(void *ptr) +{ + restore_malloc_hooks(); + free(ptr); + install_malloc_hooks(); +} + +/* XXX: we should use a malloc which ensure that it is unlikely that + two malloc'ed data have the same address if 'free' are made in + between. */ +void *__bound_malloc(size_t size, const void *caller) +{ + void *ptr; + + /* we allocate one more byte to ensure the regions will be + separated by at least one byte. With the glibc malloc, it may + be in fact not necessary */ + ptr = libc_malloc(size + 1); + + if (!ptr) + return NULL; + __bound_new_region(ptr, size); + return ptr; +} + +void *__bound_memalign(size_t size, size_t align, const void *caller) +{ + void *ptr; + + restore_malloc_hooks(); + +#ifndef HAVE_MEMALIGN + if (align > 4) { + /* XXX: handle it ? */ + ptr = NULL; + } else { + /* we suppose that malloc aligns to at least four bytes */ + ptr = malloc(size + 1); + } +#else + /* we allocate one more byte to ensure the regions will be + separated by at least one byte. With the glibc malloc, it may + be in fact not necessary */ + ptr = memalign(size + 1, align); +#endif + + install_malloc_hooks(); + + if (!ptr) + return NULL; + __bound_new_region(ptr, size); + return ptr; +} + +void __bound_free(void *ptr, const void *caller) +{ + if (ptr == NULL) + return; + if (__bound_delete_region(ptr) != 0) + bound_error("freeing invalid region"); + + libc_free(ptr); +} + +void *__bound_realloc(void *ptr, size_t size, const void *caller) +{ + void *ptr1; + int old_size; + + if (size == 0) { + __bound_free(ptr, caller); + return NULL; + } else { + ptr1 = __bound_malloc(size, caller); + if (ptr == NULL || ptr1 == NULL) + return ptr1; + old_size = get_region_size(ptr); + if (old_size == EMPTY_SIZE) + bound_error("realloc'ing invalid pointer"); + memcpy(ptr1, ptr, old_size); + __bound_free(ptr, caller); + return ptr1; + } +} + +#ifndef CONFIG_TCC_MALLOC_HOOKS +void *__bound_calloc(size_t nmemb, size_t size) +{ + void *ptr; + size = size * nmemb; + ptr = __bound_malloc(size, NULL); + if (!ptr) + return NULL; + memset(ptr, 0, size); + return ptr; +} +#endif + +#if 0 +static void bound_dump(void) +{ + BoundEntry *page, *e; + int i, j; + + printf("region dump:\n"); + for(i=0;isize != EMPTY_SIZE && e->start != 0) { + printf("%08x:", + (i << (BOUND_T2_BITS + BOUND_T3_BITS)) + + (j << BOUND_T3_BITS)); + do { + printf(" %08lx:%08lx", e->start, e->start + e->size); + e = e->next; + } while (e != NULL); + printf("\n"); + } + } + } +} +#endif + +/* some useful checked functions */ + +/* check that (p ... p + size - 1) lies inside 'p' region, if any */ +static void __bound_check(const void *p, size_t size) +{ + if (size == 0) + return; + p = __bound_ptr_add((void *)p, size); + if (p == INVALID_POINTER) + bound_error("invalid pointer"); +} + +void *__bound_memcpy(void *dst, const void *src, size_t size) +{ + __bound_check(dst, size); + __bound_check(src, size); + /* check also region overlap */ + if (src >= dst && src < dst + size) + bound_error("overlapping regions in memcpy()"); + return memcpy(dst, src, size); +} + +void *__bound_memmove(void *dst, const void *src, size_t size) +{ + __bound_check(dst, size); + __bound_check(src, size); + return memmove(dst, src, size); +} + +void *__bound_memset(void *dst, int c, size_t size) +{ + __bound_check(dst, size); + return memset(dst, c, size); +} + +/* XXX: could be optimized */ +int __bound_strlen(const char *s) +{ + const char *p; + int len; + + len = 0; + for(;;) { + p = __bound_ptr_indir1((char *)s, len); + if (p == INVALID_POINTER) + bound_error("bad pointer in strlen()"); + if (*p == '\0') + break; + len++; + } + return len; +} + +char *__bound_strcpy(char *dst, const char *src) +{ + int len; + len = __bound_strlen(src); + return __bound_memcpy(dst, src, len + 1); +} + diff --git a/boundtest.c b/boundtest.c new file mode 100644 index 0000000..9bc9828 --- /dev/null +++ b/boundtest.c @@ -0,0 +1,214 @@ +#include +#include + +#define NB_ITS 1000000 +//#define NB_ITS 1 +#define TAB_SIZE 100 + +int tab[TAB_SIZE]; +int ret_sum; +char tab3[256]; + +int test1(void) +{ + int i, sum = 0; + for(i=0;i= 2) + index = atoi(argv[1]); + /* well, we also use bounds on this ! */ + ftest = table_test[index]; + ftest(); + + return 0; +} + +/* + * without bound 0.77 s + * with bounds 4.73 + */ diff --git a/configure b/configure new file mode 100755 index 0000000..f021de3 --- /dev/null +++ b/configure @@ -0,0 +1,345 @@ +#!/bin/sh +# +# tcc configure script (c) 2003 Fabrice Bellard +# +# set temporary file name +if test ! -z "$TMPDIR" ; then + TMPDIR1="${TMPDIR}" +elif test ! -z "$TEMPDIR" ; then + TMPDIR1="${TEMPDIR}" +else + TMPDIR1="/tmp" +fi + +TMPC="${TMPDIR1}/tcc-conf-${RANDOM}-$$-${RANDOM}.c" +TMPO="${TMPDIR1}/tcc-conf-${RANDOM}-$$-${RANDOM}.o" +TMPE="${TMPDIR1}/tcc-conf-${RANDOM}-$$-${RANDOM}" +TMPS="${TMPDIR1}/tcc-conf-${RANDOM}-$$-${RANDOM}.S" +TMPH="${TMPDIR1}/tcc-conf-${RANDOM}-$$-${RANDOM}.h" + +# default parameters +build_cross="no" +prefix="" +execprefix="" +bindir="" +libdir="" +tccdir="" +includedir="" +mandir="" +cross_prefix="" +cc="gcc" +host_cc="gcc" +ar="ar" +make="make" +strip="strip" +cpu=`uname -m` +case "$cpu" in + i386|i486|i586|i686|i86pc|BePC|x86_64) + cpu="x86" + ;; + armv4l) + cpu="armv4l" + ;; + alpha) + cpu="alpha" + ;; + "Power Macintosh"|ppc|ppc64) + cpu="powerpc" + ;; + mips) + cpu="mips" + ;; + s390) + cpu="s390" + ;; + *) + cpu="unknown" + ;; +esac +gprof="no" +bigendian="no" +mingw32="no" +LIBSUF=".a" +EXESUF="" + +# OS specific +targetos=`uname -s` +case $targetos in +MINGW32*) +mingw32="yes" +;; +*) ;; +esac + +# find source path +# XXX: we assume an absolute path is given when launching configure, +# except in './configure' case. +source_path=${0%configure} +source_path=${source_path%/} +source_path_used="yes" +if test -z "$source_path" -o "$source_path" = "." ; then + source_path=`pwd` + source_path_used="no" +fi + +for opt do + case "$opt" in + --prefix=*) prefix=`echo $opt | cut -d '=' -f 2` + ;; + --exec-prefix=*) execprefix=`echo $opt | cut -d '=' -f 2` + ;; + --bindir=*) bindir=`echo $opt | cut -d '=' -f 2` + ;; + --libdir=*) libdir=`echo $opt | cut -d '=' -f 2` + ;; + --includedir=*) includedir=`echo $opt | cut -d '=' -f 2` + ;; + --mandir=*) mandir=`echo $opt | cut -d '=' -f 2` + ;; + --source-path=*) source_path=`echo $opt | cut -d '=' -f 2` + ;; + --cross-prefix=*) cross_prefix=`echo $opt | cut -d '=' -f 2` + ;; + --cc=*) cc=`echo $opt | cut -d '=' -f 2` + ;; + --make=*) make=`echo $opt | cut -d '=' -f 2` + ;; + --extra-cflags=*) CFLAGS="${opt#--extra-cflags=}" + ;; + --extra-ldflags=*) LDFLAGS="${opt#--extra-ldflags=}" + ;; + --extra-libs=*) extralibs=${opt#--extra-libs=} + ;; + --cpu=*) cpu=`echo $opt | cut -d '=' -f 2` + ;; + --enable-gprof) gprof="yes" + ;; + --enable-mingw32) mingw32="yes" ; cross_prefix="i386-mingw32-" + ;; + --enable-cross) build_cross="yes" + ;; + esac +done + +# Checking for CFLAGS +if test -z "$CFLAGS"; then + CFLAGS="-O2" +fi + +cc="${cross_prefix}${cc}" +ar="${cross_prefix}${ar}" +strip="${cross_prefix}${strip}" + +if test "$mingw32" = "yes" ; then + LIBSUF=".lib" + EXESUF=".exe" +fi + +if test -z "$cross_prefix" ; then + +# --- +# big/little endian test +cat > $TMPC << EOF +#include +int main(int argc, char ** argv){ + volatile uint32_t i=0x01234567; + return (*((uint8_t*)(&i))) == 0x67; +} +EOF + +if $cc -o $TMPE $TMPC 2>/dev/null ; then +$TMPE && bigendian="yes" +else +echo big/little test failed +fi + +else + +# if cross compiling, cannot launch a program, so make a static guess +if test "$cpu" = "powerpc" -o "$cpu" = "mips" -o "$cpu" = "s390" ; then + bigendian="yes" +fi + +fi + +# check gcc version +cat > $TMPC < 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 2) +return 0; +#else +#error gcc < 3.2 +#endif +} +EOF + +gcc_major="2" +if $cc -o $TMPO $TMPC 2> /dev/null ; then + gcc_major="3" +fi + +if test x"$1" = x"-h" -o x"$1" = x"--help" ; then +cat << EOF + +Usage: configure [options] +Options: [defaults in brackets after descriptions] + +EOF +echo "Standard options:" +echo " --help print this message" +echo " --prefix=PREFIX install in PREFIX [$prefix]" +echo " --exec-prefix=EPREFIX install architecture-dependent files in EPREFIX" +echo " [same as prefix]" +echo " --bindir=DIR user executables in DIR [EPREFIX/bin]" +echo " --libdir=DIR object code libraries in DIR [EPREFIX/lib]" +echo " --includedir=DIR C header files in DIR [PREFIX/include]" +echo " --mandir=DIR man documentation in DIR [PREFIX/man]" +echo " --enable-cross build cross compilers" +echo "" +echo "Advanced options (experts only):" +echo " --source-path=PATH path of source code [$source_path]" +echo " --cross-prefix=PREFIX use PREFIX for compile tools [$cross_prefix]" +echo " --cc=CC use C compiler CC [$cc]" +echo " --make=MAKE use specified make [$make]" +echo "" +#echo "NOTE: The object files are build at the place where configure is launched" +exit 1 +fi + +if test "$mingw32" = "yes" ; then + if test -z "$prefix" ; then + prefix="/c/Program Files/tcc" + fi + execprefix="$prefix" + bindir="$prefix" + tccdir="$prefix" + docdir="$prefix/doc" +else + if test -z "$prefix" ; then + prefix="/usr/local" + fi + if test x"$execprefix" = x""; then + execprefix="${prefix}" + fi + if test x"$bindir" = x""; then + bindir="${execprefix}/bin" + fi + if test x"$docdir" = x""; then + docdir="$prefix/share/doc/tcc" + fi +fi # mingw32 + +if test x"$libdir" = x""; then +libdir="${execprefix}/lib" +fi +if test x"$tccdir" = x""; then +tccdir="${execprefix}" +fi +if test x"$mandir" = x""; then +mandir="${prefix}/man" +fi +if test x"$includedir" = x""; then +includedir="${prefix}/include" +fi + +echo "Binary directory $bindir" +echo "TinyCC directory $tccdir" +echo "Library directory $libdir" +echo "Include directory $includedir" +echo "Manual directory $mandir" +echo "Doc directory $docdir" +echo "Source path $source_path" +echo "C compiler $cc" +echo "make $make" +echo "CPU $cpu" +echo "Big Endian $bigendian" +echo "gprof enabled $gprof" +echo "cross compilers $build_cross" + +echo "Creating config.mak and config.h" + +echo "# Automatically generated by configure - do not modify" > config.mak +echo "/* Automatically generated by configure - do not modify */" > $TMPH + +echo "prefix=$prefix" >> config.mak +echo "bindir=$bindir" >> config.mak +echo "tccdir=$tccdir" >> config.mak +echo "libdir=$libdir" >> config.mak +echo "includedir=$includedir" >> config.mak +echo "mandir=$mandir" >> config.mak +echo "docdir=$docdir" >> config.mak +echo "#define CONFIG_TCCDIR \"$tccdir\"" >> $TMPH +echo "MAKE=$make" >> config.mak +echo "CC=$cc" >> config.mak +echo "GCC_MAJOR=$gcc_major" >> config.mak +echo "#define GCC_MAJOR $gcc_major" >> $TMPH +echo "HOST_CC=$host_cc" >> config.mak +echo "AR=$ar" >> config.mak +echo "STRIP=$strip -s -R .comment -R .note" >> config.mak +echo "CFLAGS=$CFLAGS" >> config.mak +echo "LDFLAGS=$LDFLAGS" >> config.mak +echo "LIBSUF=$LIBSUF" >> config.mak +echo "EXESUF=$EXESUF" >> config.mak +if test "$cpu" = "x86" -o "$cpu" = "x86_64" ; then + echo "ARCH=i386" >> config.mak + echo "#define HOST_I386 1" >> $TMPH +elif test "$cpu" = "armv4l" ; then + echo "ARCH=arm" >> config.mak + echo "#define HOST_ARM 1" >> $TMPH +elif test "$cpu" = "powerpc" ; then + echo "ARCH=ppc" >> config.mak + echo "#define HOST_PPC 1" >> $TMPH +elif test "$cpu" = "mips" ; then + echo "ARCH=mips" >> config.mak + echo "#define HOST_MIPS 1" >> $TMPH +elif test "$cpu" = "s390" ; then + echo "ARCH=s390" >> config.mak + echo "#define HOST_S390 1" >> $TMPH +elif test "$cpu" = "alpha" ; then + echo "ARCH=alpha" >> config.mak + echo "#define HOST_ALPHA 1" >> $TMPH +else + echo "Unsupported CPU" + exit 1 +fi +if test "$mingw32" = "yes" ; then + echo "CONFIG_WIN32=yes" >> config.mak + echo "#define CONFIG_WIN32 1" >> $TMPH +fi +if test "$bigendian" = "yes" ; then + echo "WORDS_BIGENDIAN=yes" >> config.mak + echo "#define WORDS_BIGENDIAN 1" >> $TMPH +fi +if test "$gprof" = "yes" ; then + echo "TARGET_GPROF=yes" >> config.mak + echo "#define HAVE_GPROF 1" >> $TMPH +fi +if test "$build_cross" = "yes" ; then + echo "CONFIG_CROSS=yes" >> config.mak +fi +version=`head $source_path/VERSION` +echo "VERSION=$version" >>config.mak +echo "#define TCC_VERSION \"$version\"" >> $TMPH +echo "@set VERSION $version" > config.texi + +# build tree in object directory if source path is different from current one +if test "$source_path_used" = "yes" ; then + DIRS="tests" + FILES="Makefile tests/Makefile" + for dir in $DIRS ; do + mkdir -p $dir + done + for f in $FILES ; do + ln -sf $source_path/$f $f + done +fi +echo "SRC_PATH=$source_path" >> config.mak + +diff $TMPH config.h >/dev/null 2>&1 +if test $? -ne 0 ; then + mv -f $TMPH config.h +else + echo "config.h is unchanged" +fi + +rm -f $TMPO $TMPC $TMPE $TMPS $TMPH diff --git a/elf.h b/elf.h new file mode 100644 index 0000000..256f6c4 --- /dev/null +++ b/elf.h @@ -0,0 +1,1628 @@ +/* This file defines standard ELF types, structures, and macros. + Copyright (C) 1995, 1996, 1997, 1998, 1999 Free Software Foundation, Inc. + This file is part of the GNU C Library. + Contributed by Ian Lance Taylor . + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with the GNU C Library; see the file COPYING.LIB. If not, + write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +#ifndef _ELF_H +#define _ELF_H 1 + +#ifndef WIN32 +#include +#else +#ifndef __int8_t_defined +#define __int8_t_defined +typedef signed char int8_t; +typedef short int int16_t; +typedef int int32_t; +typedef long long int int64_t; +#endif + +typedef unsigned char uint8_t; +typedef unsigned short int uint16_t; +typedef unsigned int uint32_t; +typedef unsigned long long int uint64_t; +#endif + +/* Standard ELF types. */ + +/* Type for a 16-bit quantity. */ +typedef uint16_t Elf32_Half; +typedef uint16_t Elf64_Half; + +/* Types for signed and unsigned 32-bit quantities. */ +typedef uint32_t Elf32_Word; +typedef int32_t Elf32_Sword; +typedef uint32_t Elf64_Word; +typedef int32_t Elf64_Sword; + +/* Types for signed and unsigned 64-bit quantities. */ +typedef uint64_t Elf32_Xword; +typedef int64_t Elf32_Sxword; +typedef uint64_t Elf64_Xword; +typedef int64_t Elf64_Sxword; + +/* Type of addresses. */ +typedef uint32_t Elf32_Addr; +typedef uint64_t Elf64_Addr; + +/* Type of file offsets. */ +typedef uint32_t Elf32_Off; +typedef uint64_t Elf64_Off; + +/* Type for section indices, which are 16-bit quantities. */ +typedef uint16_t Elf32_Section; +typedef uint16_t Elf64_Section; + +/* Type of symbol indices. */ +typedef uint32_t Elf32_Symndx; +typedef uint64_t Elf64_Symndx; + + +/* The ELF file header. This appears at the start of every ELF file. */ + +#define EI_NIDENT (16) + +typedef struct +{ + unsigned char e_ident[EI_NIDENT]; /* Magic number and other info */ + Elf32_Half e_type; /* Object file type */ + Elf32_Half e_machine; /* Architecture */ + Elf32_Word e_version; /* Object file version */ + Elf32_Addr e_entry; /* Entry point virtual address */ + Elf32_Off e_phoff; /* Program header table file offset */ + Elf32_Off e_shoff; /* Section header table file offset */ + Elf32_Word e_flags; /* Processor-specific flags */ + Elf32_Half e_ehsize; /* ELF header size in bytes */ + Elf32_Half e_phentsize; /* Program header table entry size */ + Elf32_Half e_phnum; /* Program header table entry count */ + Elf32_Half e_shentsize; /* Section header table entry size */ + Elf32_Half e_shnum; /* Section header table entry count */ + Elf32_Half e_shstrndx; /* Section header string table index */ +} Elf32_Ehdr; + +typedef struct +{ + unsigned char e_ident[EI_NIDENT]; /* Magic number and other info */ + Elf64_Half e_type; /* Object file type */ + Elf64_Half e_machine; /* Architecture */ + Elf64_Word e_version; /* Object file version */ + Elf64_Addr e_entry; /* Entry point virtual address */ + Elf64_Off e_phoff; /* Program header table file offset */ + Elf64_Off e_shoff; /* Section header table file offset */ + Elf64_Word e_flags; /* Processor-specific flags */ + Elf64_Half e_ehsize; /* ELF header size in bytes */ + Elf64_Half e_phentsize; /* Program header table entry size */ + Elf64_Half e_phnum; /* Program header table entry count */ + Elf64_Half e_shentsize; /* Section header table entry size */ + Elf64_Half e_shnum; /* Section header table entry count */ + Elf64_Half e_shstrndx; /* Section header string table index */ +} Elf64_Ehdr; + +/* Fields in the e_ident array. The EI_* macros are indices into the + array. The macros under each EI_* macro are the values the byte + may have. */ + +#define EI_MAG0 0 /* File identification byte 0 index */ +#define ELFMAG0 0x7f /* Magic number byte 0 */ + +#define EI_MAG1 1 /* File identification byte 1 index */ +#define ELFMAG1 'E' /* Magic number byte 1 */ + +#define EI_MAG2 2 /* File identification byte 2 index */ +#define ELFMAG2 'L' /* Magic number byte 2 */ + +#define EI_MAG3 3 /* File identification byte 3 index */ +#define ELFMAG3 'F' /* Magic number byte 3 */ + +/* Conglomeration of the identification bytes, for easy testing as a word. */ +#define ELFMAG "\177ELF" +#define SELFMAG 4 + +#define EI_CLASS 4 /* File class byte index */ +#define ELFCLASSNONE 0 /* Invalid class */ +#define ELFCLASS32 1 /* 32-bit objects */ +#define ELFCLASS64 2 /* 64-bit objects */ +#define ELFCLASSNUM 3 + +#define EI_DATA 5 /* Data encoding byte index */ +#define ELFDATANONE 0 /* Invalid data encoding */ +#define ELFDATA2LSB 1 /* 2's complement, little endian */ +#define ELFDATA2MSB 2 /* 2's complement, big endian */ +#define ELFDATANUM 3 + +#define EI_VERSION 6 /* File version byte index */ + /* Value must be EV_CURRENT */ + +#define EI_OSABI 7 /* OS ABI identification */ +#define ELFOSABI_SYSV 0 /* UNIX System V ABI */ +#define ELFOSABI_HPUX 1 /* HP-UX */ +#define ELFOSABI_FREEBSD 9 /* Free BSD */ +#define ELFOSABI_ARM 97 /* ARM */ +#define ELFOSABI_STANDALONE 255 /* Standalone (embedded) application */ + +#define EI_ABIVERSION 8 /* ABI version */ + +#define EI_PAD 9 /* Byte index of padding bytes */ + +/* Legal values for e_type (object file type). */ + +#define ET_NONE 0 /* No file type */ +#define ET_REL 1 /* Relocatable file */ +#define ET_EXEC 2 /* Executable file */ +#define ET_DYN 3 /* Shared object file */ +#define ET_CORE 4 /* Core file */ +#define ET_NUM 5 /* Number of defined types */ +#define ET_LOPROC 0xff00 /* Processor-specific */ +#define ET_HIPROC 0xffff /* Processor-specific */ + +/* Legal values for e_machine (architecture). */ + +#define EM_NONE 0 /* No machine */ +#define EM_M32 1 /* AT&T WE 32100 */ +#define EM_SPARC 2 /* SUN SPARC */ +#define EM_386 3 /* Intel 80386 */ +#define EM_68K 4 /* Motorola m68k family */ +#define EM_88K 5 /* Motorola m88k family */ +#define EM_486 6 /* Intel 80486 */ +#define EM_860 7 /* Intel 80860 */ +#define EM_MIPS 8 /* MIPS R3000 big-endian */ +#define EM_S370 9 /* Amdahl */ +#define EM_MIPS_RS4_BE 10 /* MIPS R4000 big-endian */ +#define EM_RS6000 11 /* RS6000 */ + +#define EM_PARISC 15 /* HPPA */ +#define EM_nCUBE 16 /* nCUBE */ +#define EM_VPP500 17 /* Fujitsu VPP500 */ +#define EM_SPARC32PLUS 18 /* Sun's "v8plus" */ +#define EM_960 19 /* Intel 80960 */ +#define EM_PPC 20 /* PowerPC */ + +#define EM_V800 36 /* NEC V800 series */ +#define EM_FR20 37 /* Fujitsu FR20 */ +#define EM_RH32 38 /* TRW RH32 */ +#define EM_MMA 39 /* Fujitsu MMA */ +#define EM_ARM 40 /* ARM */ +#define EM_FAKE_ALPHA 41 /* Digital Alpha */ +#define EM_SH 42 /* Hitachi SH */ +#define EM_SPARCV9 43 /* SPARC v9 64-bit */ +#define EM_TRICORE 44 /* Siemens Tricore */ +#define EM_ARC 45 /* Argonaut RISC Core */ +#define EM_H8_300 46 /* Hitachi H8/300 */ +#define EM_H8_300H 47 /* Hitachi H8/300H */ +#define EM_H8S 48 /* Hitachi H8S */ +#define EM_H8_500 49 /* Hitachi H8/500 */ +#define EM_IA_64 50 /* Intel Merced */ +#define EM_MIPS_X 51 /* Stanford MIPS-X */ +#define EM_COLDFIRE 52 /* Motorola Coldfire */ +#define EM_68HC12 53 /* Motorola M68HC12 */ +#define EM_NUM 54 + +/* If it is necessary to assign new unofficial EM_* values, please + pick large random numbers (0x8523, 0xa7f2, etc.) to minimize the + chances of collision with official or non-GNU unofficial values. */ + +#define EM_ALPHA 0x9026 +#define EM_C60 0x9c60 +#define EM_W65 0x9816 + +/* Legal values for e_version (version). */ + +#define EV_NONE 0 /* Invalid ELF version */ +#define EV_CURRENT 1 /* Current version */ +#define EV_NUM 2 + +/* Section header. */ + +typedef struct +{ + Elf32_Word sh_name; /* Section name (string tbl index) */ + Elf32_Word sh_type; /* Section type */ + Elf32_Word sh_flags; /* Section flags */ + Elf32_Addr sh_addr; /* Section virtual addr at execution */ + Elf32_Off sh_offset; /* Section file offset */ + Elf32_Word sh_size; /* Section size in bytes */ + Elf32_Word sh_link; /* Link to another section */ + Elf32_Word sh_info; /* Additional section information */ + Elf32_Word sh_addralign; /* Section alignment */ + Elf32_Word sh_entsize; /* Entry size if section holds table */ +} Elf32_Shdr; + +typedef struct +{ + Elf64_Word sh_name; /* Section name (string tbl index) */ + Elf64_Word sh_type; /* Section type */ + Elf64_Xword sh_flags; /* Section flags */ + Elf64_Addr sh_addr; /* Section virtual addr at execution */ + Elf64_Off sh_offset; /* Section file offset */ + Elf64_Xword sh_size; /* Section size in bytes */ + Elf64_Word sh_link; /* Link to another section */ + Elf64_Word sh_info; /* Additional section information */ + Elf64_Xword sh_addralign; /* Section alignment */ + Elf64_Xword sh_entsize; /* Entry size if section holds table */ +} Elf64_Shdr; + +/* Special section indices. */ + +#define SHN_UNDEF 0 /* Undefined section */ +#define SHN_LORESERVE 0xff00 /* Start of reserved indices */ +#define SHN_LOPROC 0xff00 /* Start of processor-specific */ +#define SHN_HIPROC 0xff1f /* End of processor-specific */ +#define SHN_ABS 0xfff1 /* Associated symbol is absolute */ +#define SHN_COMMON 0xfff2 /* Associated symbol is common */ +#define SHN_HIRESERVE 0xffff /* End of reserved indices */ + +/* Legal values for sh_type (section type). */ + +#define SHT_NULL 0 /* Section header table entry unused */ +#define SHT_PROGBITS 1 /* Program data */ +#define SHT_SYMTAB 2 /* Symbol table */ +#define SHT_STRTAB 3 /* String table */ +#define SHT_RELA 4 /* Relocation entries with addends */ +#define SHT_HASH 5 /* Symbol hash table */ +#define SHT_DYNAMIC 6 /* Dynamic linking information */ +#define SHT_NOTE 7 /* Notes */ +#define SHT_NOBITS 8 /* Program space with no data (bss) */ +#define SHT_REL 9 /* Relocation entries, no addends */ +#define SHT_SHLIB 10 /* Reserved */ +#define SHT_DYNSYM 11 /* Dynamic linker symbol table */ +#define SHT_NUM 12 /* Number of defined types. */ +#define SHT_LOOS 0x60000000 /* Start OS-specific */ +#define SHT_LOSUNW 0x6ffffffb /* Sun-specific low bound. */ +#define SHT_SUNW_COMDAT 0x6ffffffb +#define SHT_SUNW_syminfo 0x6ffffffc +#define SHT_GNU_verdef 0x6ffffffd /* Version definition section. */ +#define SHT_GNU_verneed 0x6ffffffe /* Version needs section. */ +#define SHT_GNU_versym 0x6fffffff /* Version symbol table. */ +#define SHT_HISUNW 0x6fffffff /* Sun-specific high bound. */ +#define SHT_HIOS 0x6fffffff /* End OS-specific type */ +#define SHT_LOPROC 0x70000000 /* Start of processor-specific */ +#define SHT_HIPROC 0x7fffffff /* End of processor-specific */ +#define SHT_LOUSER 0x80000000 /* Start of application-specific */ +#define SHT_HIUSER 0x8fffffff /* End of application-specific */ + +/* Legal values for sh_flags (section flags). */ + +#define SHF_WRITE (1 << 0) /* Writable */ +#define SHF_ALLOC (1 << 1) /* Occupies memory during execution */ +#define SHF_EXECINSTR (1 << 2) /* Executable */ +#define SHF_MASKPROC 0xf0000000 /* Processor-specific */ + +/* Symbol table entry. */ + +typedef struct +{ + Elf32_Word st_name; /* Symbol name (string tbl index) */ + Elf32_Addr st_value; /* Symbol value */ + Elf32_Word st_size; /* Symbol size */ + unsigned char st_info; /* Symbol type and binding */ + unsigned char st_other; /* No defined meaning, 0 */ + Elf32_Section st_shndx; /* Section index */ +} Elf32_Sym; + +typedef struct +{ + Elf64_Word st_name; /* Symbol name (string tbl index) */ + unsigned char st_info; /* Symbol type and binding */ + unsigned char st_other; /* No defined meaning, 0 */ + Elf64_Section st_shndx; /* Section index */ + Elf64_Addr st_value; /* Symbol value */ + Elf64_Xword st_size; /* Symbol size */ +} Elf64_Sym; + +/* The syminfo section if available contains additional information about + every dynamic symbol. */ + +typedef struct +{ + Elf32_Half si_boundto; /* Direct bindings, symbol bound to */ + Elf32_Half si_flags; /* Per symbol flags */ +} Elf32_Syminfo; + +typedef struct +{ + Elf64_Half si_boundto; /* Direct bindings, symbol bound to */ + Elf64_Half si_flags; /* Per symbol flags */ +} Elf64_Syminfo; + +/* Possible values for si_boundto. */ +#define SYMINFO_BT_SELF 0xffff /* Symbol bound to self */ +#define SYMINFO_BT_PARENT 0xfffe /* Symbol bound to parent */ +#define SYMINFO_BT_LOWRESERVE 0xff00 /* Beginning of reserved entries */ + +/* Possible bitmasks for si_flags. */ +#define SYMINFO_FLG_DIRECT 0x0001 /* Direct bound symbol */ +#define SYMINFO_FLG_PASSTHRU 0x0002 /* Pass-thru symbol for translator */ +#define SYMINFO_FLG_COPY 0x0004 /* Symbol is a copy-reloc */ +#define SYMINFO_FLG_LAZYLOAD 0x0008 /* Symbol bound to object to be lazy + loaded */ +/* Syminfo version values. */ +#define SYMINFO_NONE 0 +#define SYMINFO_CURRENT 1 +#define SYMINFO_NUM 2 + + +/* Special section index. */ + +#define SHN_UNDEF 0 /* No section, undefined symbol. */ + +/* How to extract and insert information held in the st_info field. */ + +#define ELF32_ST_BIND(val) (((unsigned char) (val)) >> 4) +#define ELF32_ST_TYPE(val) ((val) & 0xf) +#define ELF32_ST_INFO(bind, type) (((bind) << 4) + ((type) & 0xf)) + +/* Both Elf32_Sym and Elf64_Sym use the same one-byte st_info field. */ +#define ELF64_ST_BIND(val) ELF32_ST_BIND (val) +#define ELF64_ST_TYPE(val) ELF32_ST_TYPE (val) +#define ELF64_ST_INFO(bind, type) ELF32_ST_INFO ((bind), (type)) + +/* Legal values for ST_BIND subfield of st_info (symbol binding). */ + +#define STB_LOCAL 0 /* Local symbol */ +#define STB_GLOBAL 1 /* Global symbol */ +#define STB_WEAK 2 /* Weak symbol */ +#define STB_NUM 3 /* Number of defined types. */ +#define STB_LOOS 10 /* Start of OS-specific */ +#define STB_HIOS 12 /* End of OS-specific */ +#define STB_LOPROC 13 /* Start of processor-specific */ +#define STB_HIPROC 15 /* End of processor-specific */ + +/* Legal values for ST_TYPE subfield of st_info (symbol type). */ + +#define STT_NOTYPE 0 /* Symbol type is unspecified */ +#define STT_OBJECT 1 /* Symbol is a data object */ +#define STT_FUNC 2 /* Symbol is a code object */ +#define STT_SECTION 3 /* Symbol associated with a section */ +#define STT_FILE 4 /* Symbol's name is file name */ +#define STT_NUM 5 /* Number of defined types. */ +#define STT_LOOS 11 /* Start of OS-specific */ +#define STT_HIOS 12 /* End of OS-specific */ +#define STT_LOPROC 13 /* Start of processor-specific */ +#define STT_HIPROC 15 /* End of processor-specific */ + + +/* Symbol table indices are found in the hash buckets and chain table + of a symbol hash table section. This special index value indicates + the end of a chain, meaning no further symbols are found in that bucket. */ + +#define STN_UNDEF 0 /* End of a chain. */ + + +/* How to extract and insert information held in the st_other field. */ + +#define ELF32_ST_VISIBILITY(o) ((o) & 0x03) + +/* For ELF64 the definitions are the same. */ +#define ELF64_ST_VISIBILITY(o) ELF32_ST_VISIBILITY (o) + +/* Symbol visibility specification encoded in the st_other field. */ +#define STV_DEFAULT 0 /* Default symbol visibility rules */ +#define STV_INTERNAL 1 /* Processor specific hidden class */ +#define STV_HIDDEN 2 /* Sym unavailable in other modules */ +#define STV_PROTECTED 3 /* Not preemptible, not exported */ + + +/* Relocation table entry without addend (in section of type SHT_REL). */ + +typedef struct +{ + Elf32_Addr r_offset; /* Address */ + Elf32_Word r_info; /* Relocation type and symbol index */ +} Elf32_Rel; + +/* I have seen two different definitions of the Elf64_Rel and + Elf64_Rela structures, so we'll leave them out until Novell (or + whoever) gets their act together. */ +/* The following, at least, is used on Sparc v9, MIPS, and Alpha. */ + +typedef struct +{ + Elf64_Addr r_offset; /* Address */ + Elf64_Xword r_info; /* Relocation type and symbol index */ +} Elf64_Rel; + +/* Relocation table entry with addend (in section of type SHT_RELA). */ + +typedef struct +{ + Elf32_Addr r_offset; /* Address */ + Elf32_Word r_info; /* Relocation type and symbol index */ + Elf32_Sword r_addend; /* Addend */ +} Elf32_Rela; + +typedef struct +{ + Elf64_Addr r_offset; /* Address */ + Elf64_Xword r_info; /* Relocation type and symbol index */ + Elf64_Sxword r_addend; /* Addend */ +} Elf64_Rela; + +/* How to extract and insert information held in the r_info field. */ + +#define ELF32_R_SYM(val) ((val) >> 8) +#define ELF32_R_TYPE(val) ((val) & 0xff) +#define ELF32_R_INFO(sym, type) (((sym) << 8) + ((type) & 0xff)) + +#define ELF64_R_SYM(i) ((i) >> 32) +#define ELF64_R_TYPE(i) ((i) & 0xffffffff) +#define ELF64_R_INFO(sym,type) (((sym) << 32) + (type)) + +/* Program segment header. */ + +typedef struct +{ + Elf32_Word p_type; /* Segment type */ + Elf32_Off p_offset; /* Segment file offset */ + Elf32_Addr p_vaddr; /* Segment virtual address */ + Elf32_Addr p_paddr; /* Segment physical address */ + Elf32_Word p_filesz; /* Segment size in file */ + Elf32_Word p_memsz; /* Segment size in memory */ + Elf32_Word p_flags; /* Segment flags */ + Elf32_Word p_align; /* Segment alignment */ +} Elf32_Phdr; + +typedef struct +{ + Elf64_Word p_type; /* Segment type */ + Elf64_Word p_flags; /* Segment flags */ + Elf64_Off p_offset; /* Segment file offset */ + Elf64_Addr p_vaddr; /* Segment virtual address */ + Elf64_Addr p_paddr; /* Segment physical address */ + Elf64_Xword p_filesz; /* Segment size in file */ + Elf64_Xword p_memsz; /* Segment size in memory */ + Elf64_Xword p_align; /* Segment alignment */ +} Elf64_Phdr; + +/* Legal values for p_type (segment type). */ + +#define PT_NULL 0 /* Program header table entry unused */ +#define PT_LOAD 1 /* Loadable program segment */ +#define PT_DYNAMIC 2 /* Dynamic linking information */ +#define PT_INTERP 3 /* Program interpreter */ +#define PT_NOTE 4 /* Auxiliary information */ +#define PT_SHLIB 5 /* Reserved */ +#define PT_PHDR 6 /* Entry for header table itself */ +#define PT_NUM 7 /* Number of defined types. */ +#define PT_LOOS 0x60000000 /* Start of OS-specific */ +#define PT_HIOS 0x6fffffff /* End of OS-specific */ +#define PT_LOPROC 0x70000000 /* Start of processor-specific */ +#define PT_HIPROC 0x7fffffff /* End of processor-specific */ + +/* Legal values for p_flags (segment flags). */ + +#define PF_X (1 << 0) /* Segment is executable */ +#define PF_W (1 << 1) /* Segment is writable */ +#define PF_R (1 << 2) /* Segment is readable */ +#define PF_MASKPROC 0xf0000000 /* Processor-specific */ + +/* Legal values for note segment descriptor types for core files. */ + +#define NT_PRSTATUS 1 /* Contains copy of prstatus struct */ +#define NT_FPREGSET 2 /* Contains copy of fpregset struct */ +#define NT_PRPSINFO 3 /* Contains copy of prpsinfo struct */ +#define NT_PRXREG 4 /* Contains copy of prxregset struct */ +#define NT_PLATFORM 5 /* String from sysinfo(SI_PLATFORM) */ +#define NT_AUXV 6 /* Contains copy of auxv array */ +#define NT_GWINDOWS 7 /* Contains copy of gwindows struct */ +#define NT_PSTATUS 10 /* Contains copy of pstatus struct */ +#define NT_PSINFO 13 /* Contains copy of psinfo struct */ +#define NT_PRCRED 14 /* Contains copy of prcred struct */ +#define NT_UTSNAME 15 /* Contains copy of utsname struct */ +#define NT_LWPSTATUS 16 /* Contains copy of lwpstatus struct */ +#define NT_LWPSINFO 17 /* Contains copy of lwpinfo struct */ + +/* Legal values for the note segment descriptor types for object files. */ + +#define NT_VERSION 1 /* Contains a version string. */ + + +/* Dynamic section entry. */ + +typedef struct +{ + Elf32_Sword d_tag; /* Dynamic entry type */ + union + { + Elf32_Word d_val; /* Integer value */ + Elf32_Addr d_ptr; /* Address value */ + } d_un; +} Elf32_Dyn; + +typedef struct +{ + Elf64_Sxword d_tag; /* Dynamic entry type */ + union + { + Elf64_Xword d_val; /* Integer value */ + Elf64_Addr d_ptr; /* Address value */ + } d_un; +} Elf64_Dyn; + +/* Legal values for d_tag (dynamic entry type). */ + +#define DT_NULL 0 /* Marks end of dynamic section */ +#define DT_NEEDED 1 /* Name of needed library */ +#define DT_PLTRELSZ 2 /* Size in bytes of PLT relocs */ +#define DT_PLTGOT 3 /* Processor defined value */ +#define DT_HASH 4 /* Address of symbol hash table */ +#define DT_STRTAB 5 /* Address of string table */ +#define DT_SYMTAB 6 /* Address of symbol table */ +#define DT_RELA 7 /* Address of Rela relocs */ +#define DT_RELASZ 8 /* Total size of Rela relocs */ +#define DT_RELAENT 9 /* Size of one Rela reloc */ +#define DT_STRSZ 10 /* Size of string table */ +#define DT_SYMENT 11 /* Size of one symbol table entry */ +#define DT_INIT 12 /* Address of init function */ +#define DT_FINI 13 /* Address of termination function */ +#define DT_SONAME 14 /* Name of shared object */ +#define DT_RPATH 15 /* Library search path */ +#define DT_SYMBOLIC 16 /* Start symbol search here */ +#define DT_REL 17 /* Address of Rel relocs */ +#define DT_RELSZ 18 /* Total size of Rel relocs */ +#define DT_RELENT 19 /* Size of one Rel reloc */ +#define DT_PLTREL 20 /* Type of reloc in PLT */ +#define DT_DEBUG 21 /* For debugging; unspecified */ +#define DT_TEXTREL 22 /* Reloc might modify .text */ +#define DT_JMPREL 23 /* Address of PLT relocs */ +#define DT_BIND_NOW 24 /* Process relocations of object */ +#define DT_INIT_ARRAY 25 /* Array with addresses of init fct */ +#define DT_FINI_ARRAY 26 /* Array with addresses of fini fct */ +#define DT_INIT_ARRAYSZ 27 /* Size in bytes of DT_INIT_ARRAY */ +#define DT_FINI_ARRAYSZ 28 /* Size in bytes of DT_FINI_ARRAY */ +#define DT_NUM 29 /* Number used */ +#define DT_LOOS 0x60000000 /* Start of OS-specific */ +#define DT_HIOS 0x6fffffff /* End of OS-specific */ +#define DT_LOPROC 0x70000000 /* Start of processor-specific */ +#define DT_HIPROC 0x7fffffff /* End of processor-specific */ +#define DT_PROCNUM DT_MIPS_NUM /* Most used by any processor */ + +/* DT_* entries which fall between DT_VALRNGHI & DT_VALRNGLO use the + Dyn.d_un.d_val field of the Elf*_Dyn structure. This follows Sun's + approach. */ +#define DT_VALRNGLO 0x6ffffd00 +#define DT_POSFLAG_1 0x6ffffdfd /* Flags for DT_* entries, effecting + the following DT_* entry. */ +#define DT_SYMINSZ 0x6ffffdfe /* Size of syminfo table (in bytes) */ +#define DT_SYMINENT 0x6ffffdff /* Entry size of syminfo */ +#define DT_VALRNGHI 0x6ffffdff + +/* DT_* entries which fall between DT_ADDRRNGHI & DT_ADDRRNGLO use the + Dyn.d_un.d_ptr field of the Elf*_Dyn structure. + + If any adjustment is made to the ELF object after it has been + built these entries will need to be adjusted. */ +#define DT_ADDRRNGLO 0x6ffffe00 +#define DT_SYMINFO 0x6ffffeff /* syminfo table */ +#define DT_ADDRRNGHI 0x6ffffeff + +/* The versioning entry types. The next are defined as part of the + GNU extension. */ +#define DT_VERSYM 0x6ffffff0 + +/* These were chosen by Sun. */ +#define DT_FLAGS_1 0x6ffffffb /* State flags, see DF_1_* below. */ +#define DT_VERDEF 0x6ffffffc /* Address of version definition + table */ +#define DT_VERDEFNUM 0x6ffffffd /* Number of version definitions */ +#define DT_VERNEED 0x6ffffffe /* Address of table with needed + versions */ +#define DT_VERNEEDNUM 0x6fffffff /* Number of needed versions */ +#define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */ +#define DT_VERSIONTAGNUM 16 + +/* Sun added these machine-independent extensions in the "processor-specific" + range. Be compatible. */ +#define DT_AUXILIARY 0x7ffffffd /* Shared object to load before self */ +#define DT_FILTER 0x7fffffff /* Shared object to get values from */ +#define DT_EXTRATAGIDX(tag) ((Elf32_Word)-((Elf32_Sword) (tag) <<1>>1)-1) +#define DT_EXTRANUM 3 + +/* State flags selectable in the `d_un.d_val' element of the DT_FLAGS_1 + entry in the dynamic section. */ +#define DF_1_NOW 0x00000001 /* Set RTLD_NOW for this object. */ +#define DF_1_GLOBAL 0x00000002 /* Set RTLD_GLOBAL for this object. */ +#define DF_1_GROUP 0x00000004 /* Set RTLD_GROUP for this object. */ +#define DF_1_NODELETE 0x00000008 /* Set RTLD_NODELETE for this object.*/ +#define DF_1_LOADFLTR 0x00000010 /* Trigger filtee loading at runtime.*/ +#define DF_1_INITFIRST 0x00000020 /* Set RTLD_INITFIRST for this object*/ +#define DF_1_NOOPEN 0x00000040 /* Set RTLD_NOOPEN for this object. */ + +/* Version definition sections. */ + +typedef struct +{ + Elf32_Half vd_version; /* Version revision */ + Elf32_Half vd_flags; /* Version information */ + Elf32_Half vd_ndx; /* Version Index */ + Elf32_Half vd_cnt; /* Number of associated aux entries */ + Elf32_Word vd_hash; /* Version name hash value */ + Elf32_Word vd_aux; /* Offset in bytes to verdaux array */ + Elf32_Word vd_next; /* Offset in bytes to next verdef + entry */ +} Elf32_Verdef; + +typedef struct +{ + Elf64_Half vd_version; /* Version revision */ + Elf64_Half vd_flags; /* Version information */ + Elf64_Half vd_ndx; /* Version Index */ + Elf64_Half vd_cnt; /* Number of associated aux entries */ + Elf64_Word vd_hash; /* Version name hash value */ + Elf64_Word vd_aux; /* Offset in bytes to verdaux array */ + Elf64_Word vd_next; /* Offset in bytes to next verdef + entry */ +} Elf64_Verdef; + + +/* Legal values for vd_version (version revision). */ +#define VER_DEF_NONE 0 /* No version */ +#define VER_DEF_CURRENT 1 /* Current version */ +#define VER_DEF_NUM 2 /* Given version number */ + +/* Legal values for vd_flags (version information flags). */ +#define VER_FLG_BASE 0x1 /* Version definition of file itself */ +#define VER_FLG_WEAK 0x2 /* Weak version identifier */ + +/* Auxialiary version information. */ + +typedef struct +{ + Elf32_Word vda_name; /* Version or dependency names */ + Elf32_Word vda_next; /* Offset in bytes to next verdaux + entry */ +} Elf32_Verdaux; + +typedef struct +{ + Elf64_Word vda_name; /* Version or dependency names */ + Elf64_Word vda_next; /* Offset in bytes to next verdaux + entry */ +} Elf64_Verdaux; + + +/* Version dependency section. */ + +typedef struct +{ + Elf32_Half vn_version; /* Version of structure */ + Elf32_Half vn_cnt; /* Number of associated aux entries */ + Elf32_Word vn_file; /* Offset of filename for this + dependency */ + Elf32_Word vn_aux; /* Offset in bytes to vernaux array */ + Elf32_Word vn_next; /* Offset in bytes to next verneed + entry */ +} Elf32_Verneed; + +typedef struct +{ + Elf64_Half vn_version; /* Version of structure */ + Elf64_Half vn_cnt; /* Number of associated aux entries */ + Elf64_Word vn_file; /* Offset of filename for this + dependency */ + Elf64_Word vn_aux; /* Offset in bytes to vernaux array */ + Elf64_Word vn_next; /* Offset in bytes to next verneed + entry */ +} Elf64_Verneed; + + +/* Legal values for vn_version (version revision). */ +#define VER_NEED_NONE 0 /* No version */ +#define VER_NEED_CURRENT 1 /* Current version */ +#define VER_NEED_NUM 2 /* Given version number */ + +/* Auxiliary needed version information. */ + +typedef struct +{ + Elf32_Word vna_hash; /* Hash value of dependency name */ + Elf32_Half vna_flags; /* Dependency specific information */ + Elf32_Half vna_other; /* Unused */ + Elf32_Word vna_name; /* Dependency name string offset */ + Elf32_Word vna_next; /* Offset in bytes to next vernaux + entry */ +} Elf32_Vernaux; + +typedef struct +{ + Elf64_Word vna_hash; /* Hash value of dependency name */ + Elf64_Half vna_flags; /* Dependency specific information */ + Elf64_Half vna_other; /* Unused */ + Elf64_Word vna_name; /* Dependency name string offset */ + Elf64_Word vna_next; /* Offset in bytes to next vernaux + entry */ +} Elf64_Vernaux; + + +/* Legal values for vna_flags. */ +#define VER_FLG_WEAK 0x2 /* Weak version identifier */ + + +/* Auxiliary vector. */ + +/* This vector is normally only used by the program interpreter. The + usual definition in an ABI supplement uses the name auxv_t. The + vector is not usually defined in a standard file, but it + can't hurt. We rename it to avoid conflicts. The sizes of these + types are an arrangement between the exec server and the program + interpreter, so we don't fully specify them here. */ + +typedef struct +{ + int a_type; /* Entry type */ + union + { + long int a_val; /* Integer value */ + void *a_ptr; /* Pointer value */ + void (*a_fcn) (void); /* Function pointer value */ + } a_un; +} Elf32_auxv_t; + +typedef struct +{ + long int a_type; /* Entry type */ + union + { + long int a_val; /* Integer value */ + void *a_ptr; /* Pointer value */ + void (*a_fcn) (void); /* Function pointer value */ + } a_un; +} Elf64_auxv_t; + +/* Legal values for a_type (entry type). */ + +#define AT_NULL 0 /* End of vector */ +#define AT_IGNORE 1 /* Entry should be ignored */ +#define AT_EXECFD 2 /* File descriptor of program */ +#define AT_PHDR 3 /* Program headers for program */ +#define AT_PHENT 4 /* Size of program header entry */ +#define AT_PHNUM 5 /* Number of program headers */ +#define AT_PAGESZ 6 /* System page size */ +#define AT_BASE 7 /* Base address of interpreter */ +#define AT_FLAGS 8 /* Flags */ +#define AT_ENTRY 9 /* Entry point of program */ +#define AT_NOTELF 10 /* Program is not ELF */ +#define AT_UID 11 /* Real uid */ +#define AT_EUID 12 /* Effective uid */ +#define AT_GID 13 /* Real gid */ +#define AT_EGID 14 /* Effective gid */ + +/* Some more special a_type values describing the hardware. */ +#define AT_PLATFORM 15 /* String identifying platform. */ +#define AT_HWCAP 16 /* Machine dependent hints about + processor capabilities. */ + +/* This entry gives some information about the FPU initialization + performed by the kernel. */ +#define AT_FPUCW 17 /* Used FPU control word. */ + + +/* Note section contents. Each entry in the note section begins with + a header of a fixed form. */ + +typedef struct +{ + Elf32_Word n_namesz; /* Length of the note's name. */ + Elf32_Word n_descsz; /* Length of the note's descriptor. */ + Elf32_Word n_type; /* Type of the note. */ +} Elf32_Nhdr; + +typedef struct +{ + Elf64_Word n_namesz; /* Length of the note's name. */ + Elf64_Word n_descsz; /* Length of the note's descriptor. */ + Elf64_Word n_type; /* Type of the note. */ +} Elf64_Nhdr; + +/* Known names of notes. */ + +/* Solaris entries in the note section have this name. */ +#define ELF_NOTE_SOLARIS "SUNW Solaris" + +/* Note entries for GNU systems have this name. */ +#define ELF_NOTE_GNU "GNU" + + +/* Defined types of notes for Solaris. */ + +/* Value of descriptor (one word) is desired pagesize for the binary. */ +#define ELF_NOTE_PAGESIZE_HINT 1 + + +/* Defined note types for GNU systems. */ + +/* ABI information. The descriptor consists of words: + word 0: OS descriptor + word 1: major version of the ABI + word 2: minor version of the ABI + word 3: subminor version of the ABI +*/ +#define ELF_NOTE_ABI 1 + +/* Known OSes. These value can appear in word 0 of an ELF_NOTE_ABI + note section entry. */ +#define ELF_NOTE_OS_LINUX 0 +#define ELF_NOTE_OS_GNU 1 +#define ELF_NOTE_OS_SOLARIS2 2 + + +/* Motorola 68k specific definitions. */ + +/* m68k relocs. */ + +#define R_68K_NONE 0 /* No reloc */ +#define R_68K_32 1 /* Direct 32 bit */ +#define R_68K_16 2 /* Direct 16 bit */ +#define R_68K_8 3 /* Direct 8 bit */ +#define R_68K_PC32 4 /* PC relative 32 bit */ +#define R_68K_PC16 5 /* PC relative 16 bit */ +#define R_68K_PC8 6 /* PC relative 8 bit */ +#define R_68K_GOT32 7 /* 32 bit PC relative GOT entry */ +#define R_68K_GOT16 8 /* 16 bit PC relative GOT entry */ +#define R_68K_GOT8 9 /* 8 bit PC relative GOT entry */ +#define R_68K_GOT32O 10 /* 32 bit GOT offset */ +#define R_68K_GOT16O 11 /* 16 bit GOT offset */ +#define R_68K_GOT8O 12 /* 8 bit GOT offset */ +#define R_68K_PLT32 13 /* 32 bit PC relative PLT address */ +#define R_68K_PLT16 14 /* 16 bit PC relative PLT address */ +#define R_68K_PLT8 15 /* 8 bit PC relative PLT address */ +#define R_68K_PLT32O 16 /* 32 bit PLT offset */ +#define R_68K_PLT16O 17 /* 16 bit PLT offset */ +#define R_68K_PLT8O 18 /* 8 bit PLT offset */ +#define R_68K_COPY 19 /* Copy symbol at runtime */ +#define R_68K_GLOB_DAT 20 /* Create GOT entry */ +#define R_68K_JMP_SLOT 21 /* Create PLT entry */ +#define R_68K_RELATIVE 22 /* Adjust by program base */ +/* Keep this the last entry. */ +#define R_68K_NUM 23 + +/* Intel 80386 specific definitions. */ + +/* i386 relocs. */ + +#define R_386_NONE 0 /* No reloc */ +#define R_386_32 1 /* Direct 32 bit */ +#define R_386_PC32 2 /* PC relative 32 bit */ +#define R_386_GOT32 3 /* 32 bit GOT entry */ +#define R_386_PLT32 4 /* 32 bit PLT address */ +#define R_386_COPY 5 /* Copy symbol at runtime */ +#define R_386_GLOB_DAT 6 /* Create GOT entry */ +#define R_386_JMP_SLOT 7 /* Create PLT entry */ +#define R_386_RELATIVE 8 /* Adjust by program base */ +#define R_386_GOTOFF 9 /* 32 bit offset to GOT */ +#define R_386_GOTPC 10 /* 32 bit PC relative offset to GOT */ +/* Keep this the last entry. */ +#define R_386_NUM 11 + +/* SUN SPARC specific definitions. */ + +/* Values for Elf64_Ehdr.e_flags. */ + +#define EF_SPARCV9_MM 3 +#define EF_SPARCV9_TSO 0 +#define EF_SPARCV9_PSO 1 +#define EF_SPARCV9_RMO 2 +#define EF_SPARC_EXT_MASK 0xFFFF00 +#define EF_SPARC_SUN_US1 0x000200 +#define EF_SPARC_HAL_R1 0x000400 + +/* SPARC relocs. */ + +#define R_SPARC_NONE 0 /* No reloc */ +#define R_SPARC_8 1 /* Direct 8 bit */ +#define R_SPARC_16 2 /* Direct 16 bit */ +#define R_SPARC_32 3 /* Direct 32 bit */ +#define R_SPARC_DISP8 4 /* PC relative 8 bit */ +#define R_SPARC_DISP16 5 /* PC relative 16 bit */ +#define R_SPARC_DISP32 6 /* PC relative 32 bit */ +#define R_SPARC_WDISP30 7 /* PC relative 30 bit shifted */ +#define R_SPARC_WDISP22 8 /* PC relative 22 bit shifted */ +#define R_SPARC_HI22 9 /* High 22 bit */ +#define R_SPARC_22 10 /* Direct 22 bit */ +#define R_SPARC_13 11 /* Direct 13 bit */ +#define R_SPARC_LO10 12 /* Truncated 10 bit */ +#define R_SPARC_GOT10 13 /* Truncated 10 bit GOT entry */ +#define R_SPARC_GOT13 14 /* 13 bit GOT entry */ +#define R_SPARC_GOT22 15 /* 22 bit GOT entry shifted */ +#define R_SPARC_PC10 16 /* PC relative 10 bit truncated */ +#define R_SPARC_PC22 17 /* PC relative 22 bit shifted */ +#define R_SPARC_WPLT30 18 /* 30 bit PC relative PLT address */ +#define R_SPARC_COPY 19 /* Copy symbol at runtime */ +#define R_SPARC_GLOB_DAT 20 /* Create GOT entry */ +#define R_SPARC_JMP_SLOT 21 /* Create PLT entry */ +#define R_SPARC_RELATIVE 22 /* Adjust by program base */ +#define R_SPARC_UA32 23 /* Direct 32 bit unaligned */ + +/* Additional Sparc64 relocs. */ + +#define R_SPARC_PLT32 24 /* Direct 32 bit ref to PLT entry */ +#define R_SPARC_HIPLT22 25 /* High 22 bit PLT entry */ +#define R_SPARC_LOPLT10 26 /* Truncated 10 bit PLT entry */ +#define R_SPARC_PCPLT32 27 /* PC rel 32 bit ref to PLT entry */ +#define R_SPARC_PCPLT22 28 /* PC rel high 22 bit PLT entry */ +#define R_SPARC_PCPLT10 29 /* PC rel trunc 10 bit PLT entry */ +#define R_SPARC_10 30 /* Direct 10 bit */ +#define R_SPARC_11 31 /* Direct 11 bit */ +#define R_SPARC_64 32 /* Direct 64 bit */ +#define R_SPARC_OLO10 33 /* ?? */ +#define R_SPARC_HH22 34 /* Top 22 bits of direct 64 bit */ +#define R_SPARC_HM10 35 /* High middle 10 bits of ... */ +#define R_SPARC_LM22 36 /* Low middle 22 bits of ... */ +#define R_SPARC_PC_HH22 37 /* Top 22 bits of pc rel 64 bit */ +#define R_SPARC_PC_HM10 38 /* High middle 10 bit of ... */ +#define R_SPARC_PC_LM22 39 /* Low miggle 22 bits of ... */ +#define R_SPARC_WDISP16 40 /* PC relative 16 bit shifted */ +#define R_SPARC_WDISP19 41 /* PC relative 19 bit shifted */ +#define R_SPARC_7 43 /* Direct 7 bit */ +#define R_SPARC_5 44 /* Direct 5 bit */ +#define R_SPARC_6 45 /* Direct 6 bit */ +#define R_SPARC_DISP64 46 /* PC relative 64 bit */ +#define R_SPARC_PLT64 47 /* Direct 64 bit ref to PLT entry */ +#define R_SPARC_HIX22 48 /* High 22 bit complemented */ +#define R_SPARC_LOX10 49 /* Truncated 11 bit complemented */ +#define R_SPARC_H44 50 /* Direct high 12 of 44 bit */ +#define R_SPARC_M44 51 /* Direct mid 22 of 44 bit */ +#define R_SPARC_L44 52 /* Direct low 10 of 44 bit */ +#define R_SPARC_REGISTER 53 /* Global register usage */ +#define R_SPARC_UA64 54 /* Direct 64 bit unaligned */ +#define R_SPARC_UA16 55 /* Direct 16 bit unaligned */ +/* Keep this the last entry. */ +#define R_SPARC_NUM 56 + +/* For Sparc64, legal values for d_tag of Elf64_Dyn. */ + +#define DT_SPARC_REGISTER 0x70000001 +#define DT_SPARC_NUM 2 + +/* Bits present in AT_HWCAP, primarily for Sparc32. */ + +#define HWCAP_SPARC_FLUSH 1 /* The cpu supports flush insn. */ +#define HWCAP_SPARC_STBAR 2 +#define HWCAP_SPARC_SWAP 4 +#define HWCAP_SPARC_MULDIV 8 +#define HWCAP_SPARC_V9 16 /* The cpu is v9, so v8plus is ok. */ + +/* MIPS R3000 specific definitions. */ + +/* Legal values for e_flags field of Elf32_Ehdr. */ + +#define EF_MIPS_NOREORDER 1 /* A .noreorder directive was used */ +#define EF_MIPS_PIC 2 /* Contains PIC code */ +#define EF_MIPS_CPIC 4 /* Uses PIC calling sequence */ +#define EF_MIPS_XGOT 8 +#define EF_MIPS_64BIT_WHIRL 16 +#define EF_MIPS_ABI2 32 +#define EF_MIPS_ABI_ON32 64 +#define EF_MIPS_ARCH 0xf0000000 /* MIPS architecture level */ + +/* Legal values for MIPS architecture level. */ + +#define EF_MIPS_ARCH_1 0x00000000 /* -mips1 code. */ +#define EF_MIPS_ARCH_2 0x10000000 /* -mips2 code. */ +#define EF_MIPS_ARCH_3 0x20000000 /* -mips3 code. */ +#define EF_MIPS_ARCH_4 0x30000000 /* -mips4 code. */ +#define EF_MIPS_ARCH_5 0x40000000 /* -mips5 code. */ + +/* The following are non-official names and should not be used. */ + +#define E_MIPS_ARCH_1 0x00000000 /* -mips1 code. */ +#define E_MIPS_ARCH_2 0x10000000 /* -mips2 code. */ +#define E_MIPS_ARCH_3 0x20000000 /* -mips3 code. */ +#define E_MIPS_ARCH_4 0x30000000 /* -mips4 code. */ +#define E_MIPS_ARCH_5 0x40000000 /* -mips5 code. */ + +/* Special section indices. */ + +#define SHN_MIPS_ACOMMON 0xff00 /* Allocated common symbols */ +#define SHN_MIPS_TEXT 0xff01 /* Allocated test symbols. */ +#define SHN_MIPS_DATA 0xff02 /* Allocated data symbols. */ +#define SHN_MIPS_SCOMMON 0xff03 /* Small common symbols */ +#define SHN_MIPS_SUNDEFINED 0xff04 /* Small undefined symbols */ + +/* Legal values for sh_type field of Elf32_Shdr. */ + +#define SHT_MIPS_LIBLIST 0x70000000 /* Shared objects used in link */ +#define SHT_MIPS_MSYM 0x70000001 +#define SHT_MIPS_CONFLICT 0x70000002 /* Conflicting symbols */ +#define SHT_MIPS_GPTAB 0x70000003 /* Global data area sizes */ +#define SHT_MIPS_UCODE 0x70000004 /* Reserved for SGI/MIPS compilers */ +#define SHT_MIPS_DEBUG 0x70000005 /* MIPS ECOFF debugging information*/ +#define SHT_MIPS_REGINFO 0x70000006 /* Register usage information */ +#define SHT_MIPS_PACKAGE 0x70000007 +#define SHT_MIPS_PACKSYM 0x70000008 +#define SHT_MIPS_RELD 0x70000009 +#define SHT_MIPS_IFACE 0x7000000b +#define SHT_MIPS_CONTENT 0x7000000c +#define SHT_MIPS_OPTIONS 0x7000000d /* Miscellaneous options. */ +#define SHT_MIPS_SHDR 0x70000010 +#define SHT_MIPS_FDESC 0x70000011 +#define SHT_MIPS_EXTSYM 0x70000012 +#define SHT_MIPS_DENSE 0x70000013 +#define SHT_MIPS_PDESC 0x70000014 +#define SHT_MIPS_LOCSYM 0x70000015 +#define SHT_MIPS_AUXSYM 0x70000016 +#define SHT_MIPS_OPTSYM 0x70000017 +#define SHT_MIPS_LOCSTR 0x70000018 +#define SHT_MIPS_LINE 0x70000019 +#define SHT_MIPS_RFDESC 0x7000001a +#define SHT_MIPS_DELTASYM 0x7000001b +#define SHT_MIPS_DELTAINST 0x7000001c +#define SHT_MIPS_DELTACLASS 0x7000001d +#define SHT_MIPS_DWARF 0x7000001e /* DWARF debugging information. */ +#define SHT_MIPS_DELTADECL 0x7000001f +#define SHT_MIPS_SYMBOL_LIB 0x70000020 +#define SHT_MIPS_EVENTS 0x70000021 /* Event section. */ +#define SHT_MIPS_TRANSLATE 0x70000022 +#define SHT_MIPS_PIXIE 0x70000023 +#define SHT_MIPS_XLATE 0x70000024 +#define SHT_MIPS_XLATE_DEBUG 0x70000025 +#define SHT_MIPS_WHIRL 0x70000026 +#define SHT_MIPS_EH_REGION 0x70000027 +#define SHT_MIPS_XLATE_OLD 0x70000028 +#define SHT_MIPS_PDR_EXCEPTION 0x70000029 + +/* Legal values for sh_flags field of Elf32_Shdr. */ + +#define SHF_MIPS_GPREL 0x10000000 /* Must be part of global data area */ +#define SHF_MIPS_MERGE 0x20000000 +#define SHF_MIPS_ADDR 0x40000000 +#define SHF_MIPS_STRINGS 0x80000000 +#define SHF_MIPS_NOSTRIP 0x08000000 +#define SHF_MIPS_LOCAL 0x04000000 +#define SHF_MIPS_NAMES 0x02000000 +#define SHF_MIPS_NODUPE 0x01000000 + + +/* Symbol tables. */ + +/* MIPS specific values for `st_other'. */ +#define STO_MIPS_DEFAULT 0x0 +#define STO_MIPS_INTERNAL 0x1 +#define STO_MIPS_HIDDEN 0x2 +#define STO_MIPS_PROTECTED 0x3 +#define STO_MIPS_SC_ALIGN_UNUSED 0xff + +/* MIPS specific values for `st_info'. */ +#define STB_MIPS_SPLIT_COMMON 13 + +/* Entries found in sections of type SHT_MIPS_GPTAB. */ + +typedef union +{ + struct + { + Elf32_Word gt_current_g_value; /* -G value used for compilation */ + Elf32_Word gt_unused; /* Not used */ + } gt_header; /* First entry in section */ + struct + { + Elf32_Word gt_g_value; /* If this value were used for -G */ + Elf32_Word gt_bytes; /* This many bytes would be used */ + } gt_entry; /* Subsequent entries in section */ +} Elf32_gptab; + +/* Entry found in sections of type SHT_MIPS_REGINFO. */ + +typedef struct +{ + Elf32_Word ri_gprmask; /* General registers used */ + Elf32_Word ri_cprmask[4]; /* Coprocessor registers used */ + Elf32_Sword ri_gp_value; /* $gp register value */ +} Elf32_RegInfo; + +/* Entries found in sections of type SHT_MIPS_OPTIONS. */ + +typedef struct +{ + unsigned char kind; /* Determines interpretation of the + variable part of descriptor. */ + unsigned char size; /* Size of descriptor, including header. */ + Elf32_Section section; /* Section header index of section affected, + 0 for global options. */ + Elf32_Word info; /* Kind-specific information. */ +} Elf_Options; + +/* Values for `kind' field in Elf_Options. */ + +#define ODK_NULL 0 /* Undefined. */ +#define ODK_REGINFO 1 /* Register usage information. */ +#define ODK_EXCEPTIONS 2 /* Exception processing options. */ +#define ODK_PAD 3 /* Section padding options. */ +#define ODK_HWPATCH 4 /* Hardware workarounds performed */ +#define ODK_FILL 5 /* record the fill value used by the linker. */ +#define ODK_TAGS 6 /* reserve space for desktop tools to write. */ +#define ODK_HWAND 7 /* HW workarounds. 'AND' bits when merging. */ +#define ODK_HWOR 8 /* HW workarounds. 'OR' bits when merging. */ + +/* Values for `info' in Elf_Options for ODK_EXCEPTIONS entries. */ + +#define OEX_FPU_MIN 0x1f /* FPE's which MUST be enabled. */ +#define OEX_FPU_MAX 0x1f00 /* FPE's which MAY be enabled. */ +#define OEX_PAGE0 0x10000 /* page zero must be mapped. */ +#define OEX_SMM 0x20000 /* Force sequential memory mode? */ +#define OEX_FPDBUG 0x40000 /* Force floating point debug mode? */ +#define OEX_PRECISEFP OEX_FPDBUG +#define OEX_DISMISS 0x80000 /* Dismiss invalid address faults? */ + +#define OEX_FPU_INVAL 0x10 +#define OEX_FPU_DIV0 0x08 +#define OEX_FPU_OFLO 0x04 +#define OEX_FPU_UFLO 0x02 +#define OEX_FPU_INEX 0x01 + +/* Masks for `info' in Elf_Options for an ODK_HWPATCH entry. */ + +#define OHW_R4KEOP 0x1 /* R4000 end-of-page patch. */ +#define OHW_R8KPFETCH 0x2 /* may need R8000 prefetch patch. */ +#define OHW_R5KEOP 0x4 /* R5000 end-of-page patch. */ +#define OHW_R5KCVTL 0x8 /* R5000 cvt.[ds].l bug. clean=1. */ + +#define OPAD_PREFIX 0x1 +#define OPAD_POSTFIX 0x2 +#define OPAD_SYMBOL 0x4 + +/* Entry found in `.options' section. */ + +typedef struct +{ + Elf32_Word hwp_flags1; /* Extra flags. */ + Elf32_Word hwp_flags2; /* Extra flags. */ +} Elf_Options_Hw; + +/* Masks for `info' in ElfOptions for ODK_HWAND and ODK_HWOR entries. */ + +#define OHWA0_R4KEOP_CHECKED 0x00000001 +#define OHWA1_R4KEOP_CLEAN 0x00000002 + +/* MIPS relocs. */ + +#define R_MIPS_NONE 0 /* No reloc */ +#define R_MIPS_16 1 /* Direct 16 bit */ +#define R_MIPS_32 2 /* Direct 32 bit */ +#define R_MIPS_REL32 3 /* PC relative 32 bit */ +#define R_MIPS_26 4 /* Direct 26 bit shifted */ +#define R_MIPS_HI16 5 /* High 16 bit */ +#define R_MIPS_LO16 6 /* Low 16 bit */ +#define R_MIPS_GPREL16 7 /* GP relative 16 bit */ +#define R_MIPS_LITERAL 8 /* 16 bit literal entry */ +#define R_MIPS_GOT16 9 /* 16 bit GOT entry */ +#define R_MIPS_PC16 10 /* PC relative 16 bit */ +#define R_MIPS_CALL16 11 /* 16 bit GOT entry for function */ +#define R_MIPS_GPREL32 12 /* GP relative 32 bit */ + +#define R_MIPS_SHIFT5 16 +#define R_MIPS_SHIFT6 17 +#define R_MIPS_64 18 +#define R_MIPS_GOT_DISP 19 +#define R_MIPS_GOT_PAGE 20 +#define R_MIPS_GOT_OFST 21 +#define R_MIPS_GOT_HI16 22 +#define R_MIPS_GOT_LO16 23 +#define R_MIPS_SUB 24 +#define R_MIPS_INSERT_A 25 +#define R_MIPS_INSERT_B 26 +#define R_MIPS_DELETE 27 +#define R_MIPS_HIGHER 28 +#define R_MIPS_HIGHEST 29 +#define R_MIPS_CALL_HI16 30 +#define R_MIPS_CALL_LO16 31 +#define R_MIPS_SCN_DISP 32 +#define R_MIPS_REL16 33 +#define R_MIPS_ADD_IMMEDIATE 34 +#define R_MIPS_PJUMP 35 +#define R_MIPS_RELGOT 36 +#define R_MIPS_JALR 37 +/* Keep this the last entry. */ +#define R_MIPS_NUM 38 + +/* Legal values for p_type field of Elf32_Phdr. */ + +#define PT_MIPS_REGINFO 0x70000000 /* Register usage information */ +#define PT_MIPS_RTPROC 0x70000001 /* Runtime procedure table. */ +#define PT_MIPS_OPTIONS 0x70000002 + +/* Special program header types. */ + +#define PF_MIPS_LOCAL 0x10000000 + +/* Legal values for d_tag field of Elf32_Dyn. */ + +#define DT_MIPS_RLD_VERSION 0x70000001 /* Runtime linker interface version */ +#define DT_MIPS_TIME_STAMP 0x70000002 /* Timestamp */ +#define DT_MIPS_ICHECKSUM 0x70000003 /* Checksum */ +#define DT_MIPS_IVERSION 0x70000004 /* Version string (string tbl index) */ +#define DT_MIPS_FLAGS 0x70000005 /* Flags */ +#define DT_MIPS_BASE_ADDRESS 0x70000006 /* Base address */ +#define DT_MIPS_MSYM 0x70000007 +#define DT_MIPS_CONFLICT 0x70000008 /* Address of CONFLICT section */ +#define DT_MIPS_LIBLIST 0x70000009 /* Address of LIBLIST section */ +#define DT_MIPS_LOCAL_GOTNO 0x7000000a /* Number of local GOT entries */ +#define DT_MIPS_CONFLICTNO 0x7000000b /* Number of CONFLICT entries */ +#define DT_MIPS_LIBLISTNO 0x70000010 /* Number of LIBLIST entries */ +#define DT_MIPS_SYMTABNO 0x70000011 /* Number of DYNSYM entries */ +#define DT_MIPS_UNREFEXTNO 0x70000012 /* First external DYNSYM */ +#define DT_MIPS_GOTSYM 0x70000013 /* First GOT entry in DYNSYM */ +#define DT_MIPS_HIPAGENO 0x70000014 /* Number of GOT page table entries */ +#define DT_MIPS_RLD_MAP 0x70000016 /* Address of run time loader map. */ +#define DT_MIPS_DELTA_CLASS 0x70000017 /* Delta C++ class definition. */ +#define DT_MIPS_DELTA_CLASS_NO 0x70000018 /* Number of entries in + DT_MIPS_DELTA_CLASS. */ +#define DT_MIPS_DELTA_INSTANCE 0x70000019 /* Delta C++ class instances. */ +#define DT_MIPS_DELTA_INSTANCE_NO 0x7000001a /* Number of entries in + DT_MIPS_DELTA_INSTANCE. */ +#define DT_MIPS_DELTA_RELOC 0x7000001b /* Delta relocations. */ +#define DT_MIPS_DELTA_RELOC_NO 0x7000001c /* Number of entries in + DT_MIPS_DELTA_RELOC. */ +#define DT_MIPS_DELTA_SYM 0x7000001d /* Delta symbols that Delta + relocations refer to. */ +#define DT_MIPS_DELTA_SYM_NO 0x7000001e /* Number of entries in + DT_MIPS_DELTA_SYM. */ +#define DT_MIPS_DELTA_CLASSSYM 0x70000020 /* Delta symbols that hold the + class declaration. */ +#define DT_MIPS_DELTA_CLASSSYM_NO 0x70000021 /* Number of entries in + DT_MIPS_DELTA_CLASSSYM. */ +#define DT_MIPS_CXX_FLAGS 0x70000022 /* Flags indicating for C++ flavor. */ +#define DT_MIPS_PIXIE_INIT 0x70000023 +#define DT_MIPS_SYMBOL_LIB 0x70000024 +#define DT_MIPS_LOCALPAGE_GOTIDX 0x70000025 +#define DT_MIPS_LOCAL_GOTIDX 0x70000026 +#define DT_MIPS_HIDDEN_GOTIDX 0x70000027 +#define DT_MIPS_PROTECTED_GOTIDX 0x70000028 +#define DT_MIPS_OPTIONS 0x70000029 /* Address of .options. */ +#define DT_MIPS_INTERFACE 0x7000002a /* Address of .interface. */ +#define DT_MIPS_DYNSTR_ALIGN 0x7000002b +#define DT_MIPS_INTERFACE_SIZE 0x7000002c /* Size of the .interface section. */ +#define DT_MIPS_RLD_TEXT_RESOLVE_ADDR 0x7000002d /* Address of rld_text_rsolve + function stored in GOT. */ +#define DT_MIPS_PERF_SUFFIX 0x7000002e /* Default suffix of dso to be added + by rld on dlopen() calls. */ +#define DT_MIPS_COMPACT_SIZE 0x7000002f /* (O32)Size of compact rel section. */ +#define DT_MIPS_GP_VALUE 0x70000030 /* GP value for aux GOTs. */ +#define DT_MIPS_AUX_DYNAMIC 0x70000031 /* Address of aux .dynamic. */ +#define DT_MIPS_NUM 0x32 + +/* Legal values for DT_MIPS_FLAGS Elf32_Dyn entry. */ + +#define RHF_NONE 0 /* No flags */ +#define RHF_QUICKSTART (1 << 0) /* Use quickstart */ +#define RHF_NOTPOT (1 << 1) /* Hash size not power of 2 */ +#define RHF_NO_LIBRARY_REPLACEMENT (1 << 2) /* Ignore LD_LIBRARY_PATH */ +#define RHF_NO_MOVE (1 << 3) +#define RHF_SGI_ONLY (1 << 4) +#define RHF_GUARANTEE_INIT (1 << 5) +#define RHF_DELTA_C_PLUS_PLUS (1 << 6) +#define RHF_GUARANTEE_START_INIT (1 << 7) +#define RHF_PIXIE (1 << 8) +#define RHF_DEFAULT_DELAY_LOAD (1 << 9) +#define RHF_REQUICKSTART (1 << 10) +#define RHF_REQUICKSTARTED (1 << 11) +#define RHF_CORD (1 << 12) +#define RHF_NO_UNRES_UNDEF (1 << 13) +#define RHF_RLD_ORDER_SAFE (1 << 14) + +/* Entries found in sections of type SHT_MIPS_LIBLIST. */ + +typedef struct +{ + Elf32_Word l_name; /* Name (string table index) */ + Elf32_Word l_time_stamp; /* Timestamp */ + Elf32_Word l_checksum; /* Checksum */ + Elf32_Word l_version; /* Interface version */ + Elf32_Word l_flags; /* Flags */ +} Elf32_Lib; + +typedef struct +{ + Elf64_Word l_name; /* Name (string table index) */ + Elf64_Word l_time_stamp; /* Timestamp */ + Elf64_Word l_checksum; /* Checksum */ + Elf64_Word l_version; /* Interface version */ + Elf64_Word l_flags; /* Flags */ +} Elf64_Lib; + + +/* Legal values for l_flags. */ + +#define LL_NONE 0 +#define LL_EXACT_MATCH (1 << 0) /* Require exact match */ +#define LL_IGNORE_INT_VER (1 << 1) /* Ignore interface version */ +#define LL_REQUIRE_MINOR (1 << 2) +#define LL_EXPORTS (1 << 3) +#define LL_DELAY_LOAD (1 << 4) +#define LL_DELTA (1 << 5) + +/* Entries found in sections of type SHT_MIPS_CONFLICT. */ + +typedef Elf32_Addr Elf32_Conflict; + + +/* HPPA specific definitions. */ + +/* Legal values for e_flags field of Elf32_Ehdr. */ + +#define EF_PARISC_TRAPNL 1 /* Trap nil pointer dereference. */ +#define EF_PARISC_EXT 2 /* Program uses arch. extensions. */ +#define EF_PARISC_ARCH 0xffff0000 /* Architecture version. */ +/* Defined values are: + 0x020b PA-RISC 1.0 big-endian + 0x0210 PA-RISC 1.1 big-endian + 0x028b PA-RISC 1.0 little-endian + 0x0290 PA-RISC 1.1 little-endian +*/ + +/* Legal values for sh_type field of Elf32_Shdr. */ + +#define SHT_PARISC_GOT 0x70000000 /* GOT for external data. */ +#define SHT_PARISC_ARCH 0x70000001 /* Architecture extensions. */ +#define SHT_PARISC_GLOBAL 0x70000002 /* Definition of $global$. */ +#define SHT_PARISC_MILLI 0x70000003 /* Millicode routines. */ +#define SHT_PARISC_UNWIND 0x70000004 /* Unwind information. */ +#define SHT_PARISC_PLT 0x70000005 /* Procedure linkage table. */ +#define SHT_PARISC_SDATA 0x70000006 /* Short initialized data. */ +#define SHT_PARISC_SBSS 0x70000007 /* Short uninitialized data. */ +#define SHT_PARISC_SYMEXTN 0x70000008 /* Argument/relocation info. */ +#define SHT_PARISC_STUBS 0x70000009 /* Linker stubs. */ + +/* Legal values for sh_flags field of Elf32_Shdr. */ + +#define SHF_PARISC_GLOBAL 0x10000000 /* Section defines dp. */ +#define SHF_PARISC_SHORT 0x20000000 /* Section with short addressing. */ + +/* Legal values for ST_TYPE subfield of st_info (symbol type). */ + +#define STT_PARISC_MILLICODE 13 /* Millicode function entry point. */ + +/* HPPA relocs. */ + +#define R_PARISC_NONE 0 /* No reloc. */ +#define R_PARISC_DIR32 1 /* Direct 32-bit reference. */ +#define R_PARISC_DIR21L 2 /* Left 21 bits of eff. address. */ +#define R_PARISC_DIR17R 3 /* Right 17 bits of eff. address. */ +#define R_PARISC_DIR14R 4 /* Right 14 bits of eff. address. */ +#define R_PARISC_PCREL21L 5 /* PC-relative, left 21 bits. */ +#define R_PARISC_PCREL14R 6 /* PC-relative, right 14 bits. */ +#define R_PARISC_PCREL17C 7 /* Conditional PC-relative, ignore + if displacement > 17bits. */ +#define R_PARISC_PCREL17F 8 /* Conditional PC-relative, must + fit in 17bits. */ +#define R_PARISC_DPREL21L 9 /* DP-relative, left 21 bits. */ +#define R_PARISC_DPREL14R 10 /* DP-relative, right 14 bits. */ +#define R_PARISC_DPREL14F 11 /* DP-relative, must bit in 14 bits. */ +#define R_PARISC_DLTREL21L 12 /* DLT-relative, left 21 bits. */ +#define R_PARISC_DLTREL14R 13 /* DLT-relative, right 14 bits. */ +#define R_PARISC_DLTREL14F 14 /* DLT-relative, must fit in 14 bits.*/ +#define R_PARISC_DLTIND21L 15 /* DLT-relative indirect, left + 21 bits. */ +#define R_PARISC_DLTIND14R 16 /* DLT-relative indirect, right + 14 bits. */ +#define R_PARISC_DLTIND14F 17 /* DLT-relative indirect, must fit + int 14 bits. */ +#define R_PARISC_PLABEL32 18 /* Direct 32-bit reference to proc. */ + +/* Alpha specific definitions. */ + +/* Legal values for e_flags field of Elf64_Ehdr. */ + +#define EF_ALPHA_32BIT 1 /* All addresses must be < 2GB. */ +#define EF_ALPHA_CANRELAX 2 /* Relocations for relaxing exist. */ + +/* Legal values for sh_type field of Elf64_Shdr. */ + +/* These two are primerily concerned with ECOFF debugging info. */ +#define SHT_ALPHA_DEBUG 0x70000001 +#define SHT_ALPHA_REGINFO 0x70000002 + +/* Legal values for sh_flags field of Elf64_Shdr. */ + +#define SHF_ALPHA_GPREL 0x10000000 + +/* Legal values for st_other field of Elf64_Sym. */ +#define STO_ALPHA_NOPV 0x80 /* No PV required. */ +#define STO_ALPHA_STD_GPLOAD 0x88 /* PV only used for initial ldgp. */ + +/* Alpha relocs. */ + +#define R_ALPHA_NONE 0 /* No reloc */ +#define R_ALPHA_REFLONG 1 /* Direct 32 bit */ +#define R_ALPHA_REFQUAD 2 /* Direct 64 bit */ +#define R_ALPHA_GPREL32 3 /* GP relative 32 bit */ +#define R_ALPHA_LITERAL 4 /* GP relative 16 bit w/optimization */ +#define R_ALPHA_LITUSE 5 /* Optimization hint for LITERAL */ +#define R_ALPHA_GPDISP 6 /* Add displacement to GP */ +#define R_ALPHA_BRADDR 7 /* PC+4 relative 23 bit shifted */ +#define R_ALPHA_HINT 8 /* PC+4 relative 16 bit shifted */ +#define R_ALPHA_SREL16 9 /* PC relative 16 bit */ +#define R_ALPHA_SREL32 10 /* PC relative 32 bit */ +#define R_ALPHA_SREL64 11 /* PC relative 64 bit */ +#define R_ALPHA_OP_PUSH 12 /* OP stack push */ +#define R_ALPHA_OP_STORE 13 /* OP stack pop and store */ +#define R_ALPHA_OP_PSUB 14 /* OP stack subtract */ +#define R_ALPHA_OP_PRSHIFT 15 /* OP stack right shift */ +#define R_ALPHA_GPVALUE 16 +#define R_ALPHA_GPRELHIGH 17 +#define R_ALPHA_GPRELLOW 18 +#define R_ALPHA_IMMED_GP_16 19 +#define R_ALPHA_IMMED_GP_HI32 20 +#define R_ALPHA_IMMED_SCN_HI32 21 +#define R_ALPHA_IMMED_BR_HI32 22 +#define R_ALPHA_IMMED_LO32 23 +#define R_ALPHA_COPY 24 /* Copy symbol at runtime */ +#define R_ALPHA_GLOB_DAT 25 /* Create GOT entry */ +#define R_ALPHA_JMP_SLOT 26 /* Create PLT entry */ +#define R_ALPHA_RELATIVE 27 /* Adjust by program base */ +/* Keep this the last entry. */ +#define R_ALPHA_NUM 28 + + +/* PowerPC specific declarations */ + +/* PowerPC relocations defined by the ABIs */ +#define R_PPC_NONE 0 +#define R_PPC_ADDR32 1 /* 32bit absolute address */ +#define R_PPC_ADDR24 2 /* 26bit address, 2 bits ignored. */ +#define R_PPC_ADDR16 3 /* 16bit absolute address */ +#define R_PPC_ADDR16_LO 4 /* lower 16bit of absolute address */ +#define R_PPC_ADDR16_HI 5 /* high 16bit of absolute address */ +#define R_PPC_ADDR16_HA 6 /* adjusted high 16bit */ +#define R_PPC_ADDR14 7 /* 16bit address, 2 bits ignored */ +#define R_PPC_ADDR14_BRTAKEN 8 +#define R_PPC_ADDR14_BRNTAKEN 9 +#define R_PPC_REL24 10 /* PC relative 26 bit */ +#define R_PPC_REL14 11 /* PC relative 16 bit */ +#define R_PPC_REL14_BRTAKEN 12 +#define R_PPC_REL14_BRNTAKEN 13 +#define R_PPC_GOT16 14 +#define R_PPC_GOT16_LO 15 +#define R_PPC_GOT16_HI 16 +#define R_PPC_GOT16_HA 17 +#define R_PPC_PLTREL24 18 +#define R_PPC_COPY 19 +#define R_PPC_GLOB_DAT 20 +#define R_PPC_JMP_SLOT 21 +#define R_PPC_RELATIVE 22 +#define R_PPC_LOCAL24PC 23 +#define R_PPC_UADDR32 24 +#define R_PPC_UADDR16 25 +#define R_PPC_REL32 26 +#define R_PPC_PLT32 27 +#define R_PPC_PLTREL32 28 +#define R_PPC_PLT16_LO 29 +#define R_PPC_PLT16_HI 30 +#define R_PPC_PLT16_HA 31 +#define R_PPC_SDAREL16 32 +#define R_PPC_SECTOFF 33 +#define R_PPC_SECTOFF_LO 34 +#define R_PPC_SECTOFF_HI 35 +#define R_PPC_SECTOFF_HA 36 +/* Keep this the last entry. */ +#define R_PPC_NUM 37 + +/* The remaining relocs are from the Embedded ELF ABI, and are not + in the SVR4 ELF ABI. */ +#define R_PPC_EMB_NADDR32 101 +#define R_PPC_EMB_NADDR16 102 +#define R_PPC_EMB_NADDR16_LO 103 +#define R_PPC_EMB_NADDR16_HI 104 +#define R_PPC_EMB_NADDR16_HA 105 +#define R_PPC_EMB_SDAI16 106 +#define R_PPC_EMB_SDA2I16 107 +#define R_PPC_EMB_SDA2REL 108 +#define R_PPC_EMB_SDA21 109 /* 16 bit offset in SDA */ +#define R_PPC_EMB_MRKREF 110 +#define R_PPC_EMB_RELSEC16 111 +#define R_PPC_EMB_RELST_LO 112 +#define R_PPC_EMB_RELST_HI 113 +#define R_PPC_EMB_RELST_HA 114 +#define R_PPC_EMB_BIT_FLD 115 +#define R_PPC_EMB_RELSDA 116 /* 16 bit relative offset in SDA */ + +/* Diab tool relocations. */ +#define R_PPC_DIAB_SDA21_LO 180 /* like EMB_SDA21, but lower 16 bit */ +#define R_PPC_DIAB_SDA21_HI 181 /* like EMB_SDA21, but high 16 bit */ +#define R_PPC_DIAB_SDA21_HA 182 /* like EMB_SDA21, adjusted high 16 */ +#define R_PPC_DIAB_RELSDA_LO 183 /* like EMB_RELSDA, but lower 16 bit */ +#define R_PPC_DIAB_RELSDA_HI 184 /* like EMB_RELSDA, but high 16 bit */ +#define R_PPC_DIAB_RELSDA_HA 185 /* like EMB_RELSDA, adjusted high 16 */ + +/* This is a phony reloc to handle any old fashioned TOC16 references + that may still be in object files. */ +#define R_PPC_TOC16 255 + + +/* ARM specific declarations */ + +/* Processor specific flags for the ELF header e_flags field. */ +#define EF_ARM_RELEXEC 0x01 +#define EF_ARM_HASENTRY 0x02 +#define EF_ARM_INTERWORK 0x04 +#define EF_ARM_APCS_26 0x08 +#define EF_ARM_APCS_FLOAT 0x10 +#define EF_ARM_PIC 0x20 +#define EF_ALIGN8 0x40 /* 8-bit structure alignment is in use */ +#define EF_NEW_ABI 0x80 +#define EF_OLD_ABI 0x100 + +/* Additional symbol types for Thumb */ +#define STT_ARM_TFUNC 0xd + +/* ARM-specific values for sh_flags */ +#define SHF_ARM_ENTRYSECT 0x10000000 /* Section contains an entry point */ +#define SHF_ARM_COMDEF 0x80000000 /* Section may be multiply defined + in the input to a link step */ + +/* ARM-specific program header flags */ +#define PF_ARM_SB 0x10000000 /* Segment contains the location + addressed by the static base */ + +/* ARM relocs. */ +#define R_ARM_NONE 0 /* No reloc */ +#define R_ARM_PC24 1 /* PC relative 26 bit branch */ +#define R_ARM_ABS32 2 /* Direct 32 bit */ +#define R_ARM_REL32 3 /* PC relative 32 bit */ +#define R_ARM_PC13 4 +#define R_ARM_ABS16 5 /* Direct 16 bit */ +#define R_ARM_ABS12 6 /* Direct 12 bit */ +#define R_ARM_THM_ABS5 7 +#define R_ARM_ABS8 8 /* Direct 8 bit */ +#define R_ARM_SBREL32 9 +#define R_ARM_THM_PC22 10 +#define R_ARM_THM_PC8 11 +#define R_ARM_AMP_VCALL9 12 +#define R_ARM_SWI24 13 +#define R_ARM_THM_SWI8 14 +#define R_ARM_XPC25 15 +#define R_ARM_THM_XPC22 16 +#define R_ARM_COPY 20 /* Copy symbol at runtime */ +#define R_ARM_GLOB_DAT 21 /* Create GOT entry */ +#define R_ARM_JUMP_SLOT 22 /* Create PLT entry */ +#define R_ARM_RELATIVE 23 /* Adjust by program base */ +#define R_ARM_GOTOFF 24 /* 32 bit offset to GOT */ +#define R_ARM_GOTPC 25 /* 32 bit PC relative offset to GOT */ +#define R_ARM_GOT32 26 /* 32 bit GOT entry */ +#define R_ARM_PLT32 27 /* 32 bit PLT address */ +#define R_ARM_GNU_VTENTRY 100 +#define R_ARM_GNU_VTINHERIT 101 +#define R_ARM_THM_PC11 102 /* thumb unconditional branch */ +#define R_ARM_THM_PC9 103 /* thumb conditional branch */ +#define R_ARM_RXPC25 249 +#define R_ARM_RSBREL32 250 +#define R_ARM_THM_RPC22 251 +#define R_ARM_RREL32 252 +#define R_ARM_RABS22 253 +#define R_ARM_RPC24 254 +#define R_ARM_RBASE 255 +/* Keep this the last entry. */ +#define R_ARM_NUM 256 + +/* TMS320C67xx specific declarations */ +/* XXX: no ELF standard yet */ + +/* TMS320C67xx relocs. */ +#define R_C60_32 1 +#define R_C60_GOT32 3 /* 32 bit GOT entry */ +#define R_C60_PLT32 4 /* 32 bit PLT address */ +#define R_C60_COPY 5 /* Copy symbol at runtime */ +#define R_C60_GLOB_DAT 6 /* Create GOT entry */ +#define R_C60_JMP_SLOT 7 /* Create PLT entry */ +#define R_C60_RELATIVE 8 /* Adjust by program base */ +#define R_C60_GOTOFF 9 /* 32 bit offset to GOT */ +#define R_C60_GOTPC 10 /* 32 bit PC relative offset to GOT */ + +#define R_C60HI16 0x55 // high 16 bit MVKH embedded +#define R_C60LO16 0x54 // low 16 bit MVKL embedded + +#endif /* elf.h */ diff --git a/examples/ex1.c b/examples/ex1.c new file mode 100755 index 0000000..2dcff7d --- /dev/null +++ b/examples/ex1.c @@ -0,0 +1,8 @@ +#! /usr/local/bin/tcc -run +#include + +int main() +{ + printf("Hello World\n"); + return 0; +} diff --git a/examples/ex2.c b/examples/ex2.c new file mode 100644 index 0000000..6368bee --- /dev/null +++ b/examples/ex2.c @@ -0,0 +1,97 @@ +#include "tcclib.h" + +#define N 20 + +int nb_num; +int tab[N]; +int stack_ptr; +int stack_op[N]; +int stack_res[60]; +int result; + +int find(int n, int i1, int a, int b, int op) +{ + int i, j; + int c; + + if (stack_ptr >= 0) { + stack_res[3*stack_ptr] = a; + stack_op[stack_ptr] = op; + stack_res[3*stack_ptr+1] = b; + stack_res[3*stack_ptr+2] = n; + if (n == result) + return 1; + tab[i1] = n; + } + + for(i=0;i + +int fib(n) +{ + if (n <= 2) + return 1; + else + return fib(n-1) + fib(n-2); +} + +int main(int argc, char **argv) +{ + int n; + if (argc < 2) { + printf("usage: fib n\n" + "Compute nth Fibonacci number\n"); + return 1; + } + + n = atoi(argv[1]); + printf("fib(%d) = %d\n", n, fib(n, 2)); + return 0; +} diff --git a/examples/ex4.c b/examples/ex4.c new file mode 100755 index 0000000..3a3fed7 --- /dev/null +++ b/examples/ex4.c @@ -0,0 +1,25 @@ +#!./tcc -run -L/usr/X11R6/lib -lX11 +#include +/* Yes, TCC can use X11 too ! */ +#include +#include + +int main(int argc, char **argv) +{ + Display *display; + Screen *screen; + + display = XOpenDisplay(""); + if (!display) { + fprintf(stderr, "Could not open X11 display\n"); + exit(1); + } + printf("X11 display opened.\n"); + screen = XScreenOfDisplay(display, 0); + printf("width = %d\nheight = %d\ndepth = %d\n", + screen->width, + screen->height, + screen->root_depth); + XCloseDisplay(display); + return 0; +} diff --git a/examples/ex5.c b/examples/ex5.c new file mode 100644 index 0000000..da625c5 --- /dev/null +++ b/examples/ex5.c @@ -0,0 +1,8 @@ +#include +#include + +int main() +{ + printf("Hello World\n"); + return 0; +} diff --git a/float.h b/float.h new file mode 100644 index 0000000..5f1c6f7 --- /dev/null +++ b/float.h @@ -0,0 +1,57 @@ +#ifndef _FLOAT_H_ +#define _FLOAT_H_ + +#define FLT_RADIX 2 + +/* IEEE float */ +#define FLT_MANT_DIG 24 +#define FLT_DIG 6 +#define FLT_ROUNDS 1 +#define FLT_EPSILON 1.19209290e-07F +#define FLT_MIN_EXP (-125) +#define FLT_MIN 1.17549435e-38F +#define FLT_MIN_10_EXP (-37) +#define FLT_MAX_EXP 128 +#define FLT_MAX 3.40282347e+38F +#define FLT_MAX_10_EXP 38 + +/* IEEE double */ +#define DBL_MANT_DIG 53 +#define DBL_DIG 15 +#define DBL_EPSILON 2.2204460492503131e-16 +#define DBL_MIN_EXP (-1021) +#define DBL_MIN 2.2250738585072014e-308 +#define DBL_MIN_10_EXP (-307) +#define DBL_MAX_EXP 1024 +#define DBL_MAX 1.7976931348623157e+308 +#define DBL_MAX_10_EXP 308 + +/* horrible intel long double */ +#ifdef __i386__ + +#define LDBL_MANT_DIG 64 +#define LDBL_DIG 18 +#define LDBL_EPSILON 1.08420217248550443401e-19L +#define LDBL_MIN_EXP (-16381) +#define LDBL_MIN 3.36210314311209350626e-4932L +#define LDBL_MIN_10_EXP (-4931) +#define LDBL_MAX_EXP 16384 +#define LDBL_MAX 1.18973149535723176502e+4932L +#define LDBL_MAX_10_EXP 4932 + +#else + +/* same as IEEE double */ +#define LDBL_MANT_DIG 53 +#define LDBL_DIG 15 +#define LDBL_EPSILON 2.2204460492503131e-16 +#define LDBL_MIN_EXP (-1021) +#define LDBL_MIN 2.2250738585072014e-308 +#define LDBL_MIN_10_EXP (-307) +#define LDBL_MAX_EXP 1024 +#define LDBL_MAX 1.7976931348623157e+308 +#define LDBL_MAX_10_EXP 308 + +#endif + +#endif /* _FLOAT_H_ */ diff --git a/gcctestsuite.sh b/gcctestsuite.sh new file mode 100755 index 0000000..bd9204b --- /dev/null +++ b/gcctestsuite.sh @@ -0,0 +1,33 @@ +#!/bin/sh + +TESTSUITE_PATH=$HOME/gcc/gcc-3.2/gcc/testsuite/gcc.c-torture +TCC="./tcc -B. -I. -DNO_TRAMPOLINES" +rm -f tcc.sum tcc.log +nb_failed="0" + +for src in $TESTSUITE_PATH/compile/*.c ; do + echo $TCC -o /tmp/test.o -c $src + $TCC -o /tmp/test.o -c $src >> tcc.log 2>&1 + if [ "$?" == "0" ] ; then + result="PASS" + else + result="FAIL" + nb_failed=$[ $nb_failed + 1 ] + fi + echo "$result: $src" >> tcc.sum +done + +for src in $TESTSUITE_PATH/execute/*.c ; do + echo $TCC $src + $TCC $src >> tcc.log 2>&1 + if [ "$?" == "0" ] ; then + result="PASS" + else + result="FAIL" + nb_failed=$[ $nb_failed + 1 ] + fi + echo "$result: $src" >> tcc.sum +done + +echo "$nb_failed test(s) failed." >> tcc.sum +echo "$nb_failed test(s) failed." diff --git a/include/ctype.h b/include/ctype.h new file mode 100644 index 0000000..c400918 --- /dev/null +++ b/include/ctype.h @@ -0,0 +1,6 @@ +int isdigit(int c); +int isxdigit(int c); +int islower(int c); +int toupper(int c); +int isspace(int c); +int isprint(int c); diff --git a/include/float.h b/include/float.h new file mode 100644 index 0000000..f6004ad --- /dev/null +++ b/include/float.h @@ -0,0 +1,4 @@ +#define FLT_MIN __FLT_MIN__ +#define FLT_MAX __FLT_MAX__ +#define DBL_MIN FLT_MIN +#define DBL_MAX FLT_MAX diff --git a/include/limits.h b/include/limits.h new file mode 100644 index 0000000..7ec6497 --- /dev/null +++ b/include/limits.h @@ -0,0 +1,13 @@ +#define INT_MAX 32767 +#define INT_MIN -32768 +#define UINT_MAX 65535 +#define LONG_MAX INT_MAX +#define LONG_MIN INT_MIN +#define SCHAR_MAX 127 +#define SCHAR_MIN -128 +#define UCHAR_MAX 255 +#define SHRT_MAX 32767 +#define SHRT_MIN -32768 +#define USHRT_MAX 65535 +#define ULONG_MAX UINT_MAX +#define CHAR_BIT __CHAR_BIT__ diff --git a/include/math.h b/include/math.h new file mode 100644 index 0000000..8939812 --- /dev/null +++ b/include/math.h @@ -0,0 +1,10 @@ +float modf(float x, float *fp); +float ldexp(float x, int exp); +float floor(float d); +float ceil(float d); +float exp(float arg); +float frexp(float x, int *exp); +float log(float arg); +float log10(float arg); +float pow(float arg1, float arg2); +float fabs(float); diff --git a/include/setjmp.h b/include/setjmp.h new file mode 100644 index 0000000..0e4da56 --- /dev/null +++ b/include/setjmp.h @@ -0,0 +1,4 @@ +typedef int jmp_buf[3]; + +int setjmp(jmp_buf env); +void longjmp(jmp_buf env, int val); diff --git a/include/stdarg.h b/include/stdarg.h new file mode 120000 index 0000000..8a8ae26 --- /dev/null +++ b/include/stdarg.h @@ -0,0 +1 @@ +../stdarg.h \ No newline at end of file diff --git a/include/stdbool.h b/include/stdbool.h new file mode 100644 index 0000000..b36e650 --- /dev/null +++ b/include/stdbool.h @@ -0,0 +1,53 @@ +/* Copyright (C) 1998, 1999, 2000 Free Software Foundation, Inc. + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GCC is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GCC; see the file COPYING. If not, write to +the Free Software Foundation, 51 Franklin Street, Fifth Floor, +Boston, MA 02110-1301, USA. */ + +/* As a special exception, if you include this header file into source + files compiled by GCC, this header file does not by itself cause + the resulting executable to be covered by the GNU General Public + License. This exception does not however invalidate any other + reasons why the executable file might be covered by the GNU General + Public License. */ + +/* + * ISO C Standard: 7.16 Boolean type and values + */ + +#ifndef _STDBOOL_H +#define _STDBOOL_H + +#ifndef __cplusplus + +#define bool _Bool +#define true 1 +#define false 0 + +#else /* __cplusplus */ + +/* Supporting in C++ is a GCC extension. */ +#define _Bool bool +#define bool bool +#define false false +#define true true + +#endif /* __cplusplus */ + +/* Signal that all the definitions are present. */ +#define __bool_true_false_are_defined 1 + +#endif /* stdbool.h */ diff --git a/include/stddef.h b/include/stddef.h new file mode 120000 index 0000000..eff8be4 --- /dev/null +++ b/include/stddef.h @@ -0,0 +1 @@ +../stddef.h \ No newline at end of file diff --git a/include/stdint.h b/include/stdint.h new file mode 100644 index 0000000..b6db89b --- /dev/null +++ b/include/stdint.h @@ -0,0 +1,7 @@ +typedef unsigned int uint16_t; +typedef unsigned long long uint32_t; +typedef unsigned char uint8_t; + +typedef signed int int16_t; +typedef signed long long int32_t; +typedef signed char int8_t; diff --git a/include/stdio.h b/include/stdio.h new file mode 100644 index 0000000..a64fa33 --- /dev/null +++ b/include/stdio.h @@ -0,0 +1,9 @@ +#include "stddef.h" +#include "stdarg.h" + +int vsnprintf(char *buf, size_t size, const char *fmt, va_list args); +int snprintf(char * buf, size_t size, const char *fmt, ...); +int vsprintf(char *buf, const char *fmt, va_list args); +int sprintf(char * buf, const char *fmt, ...); +int vsscanf(const char * buf, const char * fmt, va_list args); +int sscanf(const char * buf, const char * fmt, ...); diff --git a/include/stdlib.h b/include/stdlib.h new file mode 100644 index 0000000..4349eb3 --- /dev/null +++ b/include/stdlib.h @@ -0,0 +1,13 @@ +#include "stddef.h" + +void abort(void); +void exit(int status); + +void *malloc(size_t size); +void free(void *ptr); +void *realloc(void *ptr, size_t size); + +unsigned long strtoul(const char *cp,char **endp,unsigned int base); +long strtol(const char *cp,char **endp,unsigned int base); +unsigned long long strtoull(const char *cp,char **endp,unsigned int base); +long long strtoll(const char *cp,char **endp,unsigned int base); diff --git a/include/string.h b/include/string.h new file mode 100644 index 0000000..2460fd3 --- /dev/null +++ b/include/string.h @@ -0,0 +1,20 @@ +#include "stddef.h" + +void * memcpy(void *s1, const void *s2, size_t n); +void * mempcpy(void *s1, const void *s2, size_t n); +void * memmove(void *s1, const void *s2, size_t n); +void * memset(void *b, int c, size_t n); + +int memcmp(const void *s1, const void *s2, size_t n); + +int strcmp(const char *s1, const char *s2); +int strncmp(const char *s1, const char *s2, size_t n); + +char * strcpy(char *s1, const char *s2); +char * strncpy(char *s1, const char *s2, size_t n); + +size_t strlen(const char *); +char * strchr(const char *, int); +char * strrchr(const char *, int); + +char * strdup(const char *); diff --git a/include/strings.h b/include/strings.h new file mode 100644 index 0000000..e1fc3e4 --- /dev/null +++ b/include/strings.h @@ -0,0 +1,5 @@ +#include "stddef.h" + +void bzero(void *s, size_t n); + +int ffs(int i); diff --git a/libtcc.h b/libtcc.h new file mode 100644 index 0000000..db77000 --- /dev/null +++ b/libtcc.h @@ -0,0 +1,97 @@ +#ifndef LIBTCC_H +#define LIBTCC_H + +#ifdef __cplusplus +extern "C" { +#endif + +struct TCCState; + +typedef struct TCCState TCCState; + +/* create a new TCC compilation context */ +TCCState *tcc_new(void); + +/* free a TCC compilation context */ +void tcc_delete(TCCState *s); + +/* add debug information in the generated code */ +void tcc_enable_debug(TCCState *s); + +/* set error/warning display callback */ +void tcc_set_error_func(TCCState *s, void *error_opaque, + void (*error_func)(void *opaque, const char *msg)); + +/* set/reset a warning */ +int tcc_set_warning(TCCState *s, const char *warning_name, int value); + +/*****************************/ +/* preprocessor */ + +/* add include path */ +int tcc_add_include_path(TCCState *s, const char *pathname); + +/* add in system include path */ +int tcc_add_sysinclude_path(TCCState *s, const char *pathname); + +/* define preprocessor symbol 'sym'. Can put optional value */ +void tcc_define_symbol(TCCState *s, const char *sym, const char *value); + +/* undefine preprocess symbol 'sym' */ +void tcc_undefine_symbol(TCCState *s, const char *sym); + +/*****************************/ +/* compiling */ + +/* add a file (either a C file, dll, an object, a library or an ld + script). Return -1 if error. */ +int tcc_add_file(TCCState *s, const char *filename); + +/* compile a string containing a C source. Return non zero if + error. */ +int tcc_compile_string(TCCState *s, const char *buf); + +/*****************************/ +/* linking commands */ + +/* set output type. MUST BE CALLED before any compilation */ +#define TCC_OUTPUT_MEMORY 0 /* output will be ran in memory (no + output file) (default) */ +#define TCC_OUTPUT_EXE 1 /* executable file */ +#define TCC_OUTPUT_DLL 2 /* dynamic library */ +#define TCC_OUTPUT_OBJ 3 /* object file */ +int tcc_set_output_type(TCCState *s, int output_type); + +#define TCC_OUTPUT_FORMAT_ELF 0 /* default output format: ELF */ +#define TCC_OUTPUT_FORMAT_BINARY 1 /* binary image output */ +#define TCC_OUTPUT_FORMAT_COFF 2 /* COFF */ + +/* equivalent to -Lpath option */ +int tcc_add_library_path(TCCState *s, const char *pathname); + +/* the library name is the same as the argument of the '-l' option */ +int tcc_add_library(TCCState *s, const char *libraryname); + +/* add a symbol to the compiled program */ +int tcc_add_symbol(TCCState *s, const char *name, unsigned long val); + +/* output an executable, library or object file. DO NOT call + tcc_relocate() before. */ +int tcc_output_file(TCCState *s, const char *filename); + +/* link and run main() function and return its value. DO NOT call + tcc_relocate() before. */ +int tcc_run(TCCState *s, int argc, char **argv); + +/* do all relocations (needed before using tcc_get_symbol()). Return + non zero if link error. */ +int tcc_relocate(TCCState *s); + +/* return symbol value. return 0 if OK, -1 if symbol not found */ +int tcc_get_symbol(TCCState *s, unsigned long *pval, const char *name); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/stab.def b/stab.def new file mode 100644 index 0000000..48ea231 --- /dev/null +++ b/stab.def @@ -0,0 +1,234 @@ +/* Table of DBX symbol codes for the GNU system. + Copyright (C) 1988, 1997 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with the GNU C Library; see the file COPYING.LIB. If not, + write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +/* This contains contribution from Cygnus Support. */ + +/* Global variable. Only the name is significant. + To find the address, look in the corresponding external symbol. */ +__define_stab (N_GSYM, 0x20, "GSYM") + +/* Function name for BSD Fortran. Only the name is significant. + To find the address, look in the corresponding external symbol. */ +__define_stab (N_FNAME, 0x22, "FNAME") + +/* Function name or text-segment variable for C. Value is its address. + Desc is supposedly starting line number, but GCC doesn't set it + and DBX seems not to miss it. */ +__define_stab (N_FUN, 0x24, "FUN") + +/* Data-segment variable with internal linkage. Value is its address. + "Static Sym". */ +__define_stab (N_STSYM, 0x26, "STSYM") + +/* BSS-segment variable with internal linkage. Value is its address. */ +__define_stab (N_LCSYM, 0x28, "LCSYM") + +/* Name of main routine. Only the name is significant. + This is not used in C. */ +__define_stab (N_MAIN, 0x2a, "MAIN") + +/* Global symbol in Pascal. + Supposedly the value is its line number; I'm skeptical. */ +__define_stab (N_PC, 0x30, "PC") + +/* Number of symbols: 0, files,,funcs,lines according to Ultrix V4.0. */ +__define_stab (N_NSYMS, 0x32, "NSYMS") + +/* "No DST map for sym: name, ,0,type,ignored" according to Ultrix V4.0. */ +__define_stab (N_NOMAP, 0x34, "NOMAP") + +/* New stab from Solaris. I don't know what it means, but it + don't seem to contain useful information. */ +__define_stab (N_OBJ, 0x38, "OBJ") + +/* New stab from Solaris. I don't know what it means, but it + don't seem to contain useful information. Possibly related to the + optimization flags used in this module. */ +__define_stab (N_OPT, 0x3c, "OPT") + +/* Register variable. Value is number of register. */ +__define_stab (N_RSYM, 0x40, "RSYM") + +/* Modula-2 compilation unit. Can someone say what info it contains? */ +__define_stab (N_M2C, 0x42, "M2C") + +/* Line number in text segment. Desc is the line number; + value is corresponding address. */ +__define_stab (N_SLINE, 0x44, "SLINE") + +/* Similar, for data segment. */ +__define_stab (N_DSLINE, 0x46, "DSLINE") + +/* Similar, for bss segment. */ +__define_stab (N_BSLINE, 0x48, "BSLINE") + +/* Sun's source-code browser stabs. ?? Don't know what the fields are. + Supposedly the field is "path to associated .cb file". THIS VALUE + OVERLAPS WITH N_BSLINE! */ +__define_stab (N_BROWS, 0x48, "BROWS") + +/* GNU Modula-2 definition module dependency. Value is the modification time + of the definition file. Other is non-zero if it is imported with the + GNU M2 keyword %INITIALIZE. Perhaps N_M2C can be used if there + are enough empty fields? */ +__define_stab(N_DEFD, 0x4a, "DEFD") + +/* THE FOLLOWING TWO STAB VALUES CONFLICT. Happily, one is for Modula-2 + and one is for C++. Still,... */ +/* GNU C++ exception variable. Name is variable name. */ +__define_stab (N_EHDECL, 0x50, "EHDECL") +/* Modula2 info "for imc": name,,0,0,0 according to Ultrix V4.0. */ +__define_stab (N_MOD2, 0x50, "MOD2") + +/* GNU C++ `catch' clause. Value is its address. Desc is nonzero if + this entry is immediately followed by a CAUGHT stab saying what exception + was caught. Multiple CAUGHT stabs means that multiple exceptions + can be caught here. If Desc is 0, it means all exceptions are caught + here. */ +__define_stab (N_CATCH, 0x54, "CATCH") + +/* Structure or union element. Value is offset in the structure. */ +__define_stab (N_SSYM, 0x60, "SSYM") + +/* Name of main source file. + Value is starting text address of the compilation. */ +__define_stab (N_SO, 0x64, "SO") + +/* Automatic variable in the stack. Value is offset from frame pointer. + Also used for type descriptions. */ +__define_stab (N_LSYM, 0x80, "LSYM") + +/* Beginning of an include file. Only Sun uses this. + In an object file, only the name is significant. + The Sun linker puts data into some of the other fields. */ +__define_stab (N_BINCL, 0x82, "BINCL") + +/* Name of sub-source file (#include file). + Value is starting text address of the compilation. */ +__define_stab (N_SOL, 0x84, "SOL") + +/* Parameter variable. Value is offset from argument pointer. + (On most machines the argument pointer is the same as the frame pointer. */ +__define_stab (N_PSYM, 0xa0, "PSYM") + +/* End of an include file. No name. + This and N_BINCL act as brackets around the file's output. + In an object file, there is no significant data in this entry. + The Sun linker puts data into some of the fields. */ +__define_stab (N_EINCL, 0xa2, "EINCL") + +/* Alternate entry point. Value is its address. */ +__define_stab (N_ENTRY, 0xa4, "ENTRY") + +/* Beginning of lexical block. + The desc is the nesting level in lexical blocks. + The value is the address of the start of the text for the block. + The variables declared inside the block *precede* the N_LBRAC symbol. */ +__define_stab (N_LBRAC, 0xc0, "LBRAC") + +/* Place holder for deleted include file. Replaces a N_BINCL and everything + up to the corresponding N_EINCL. The Sun linker generates these when + it finds multiple identical copies of the symbols from an include file. + This appears only in output from the Sun linker. */ +__define_stab (N_EXCL, 0xc2, "EXCL") + +/* Modula-2 scope information. Can someone say what info it contains? */ +__define_stab (N_SCOPE, 0xc4, "SCOPE") + +/* End of a lexical block. Desc matches the N_LBRAC's desc. + The value is the address of the end of the text for the block. */ +__define_stab (N_RBRAC, 0xe0, "RBRAC") + +/* Begin named common block. Only the name is significant. */ +__define_stab (N_BCOMM, 0xe2, "BCOMM") + +/* End named common block. Only the name is significant + (and it should match the N_BCOMM). */ +__define_stab (N_ECOMM, 0xe4, "ECOMM") + +/* End common (local name): value is address. + I'm not sure how this is used. */ +__define_stab (N_ECOML, 0xe8, "ECOML") + +/* These STAB's are used on Gould systems for Non-Base register symbols + or something like that. FIXME. I have assigned the values at random + since I don't have a Gould here. Fixups from Gould folk welcome... */ +__define_stab (N_NBTEXT, 0xF0, "NBTEXT") +__define_stab (N_NBDATA, 0xF2, "NBDATA") +__define_stab (N_NBBSS, 0xF4, "NBBSS") +__define_stab (N_NBSTS, 0xF6, "NBSTS") +__define_stab (N_NBLCS, 0xF8, "NBLCS") + +/* Second symbol entry containing a length-value for the preceding entry. + The value is the length. */ +__define_stab (N_LENG, 0xfe, "LENG") + +/* The above information, in matrix format. + + STAB MATRIX + _________________________________________________ + | 00 - 1F are not dbx stab symbols | + | In most cases, the low bit is the EXTernal bit| + + | 00 UNDEF | 02 ABS | 04 TEXT | 06 DATA | + | 01 |EXT | 03 |EXT | 05 |EXT | 07 |EXT | + + | 08 BSS | 0A INDR | 0C FN_SEQ | 0E | + | 09 |EXT | 0B | 0D | 0F | + + | 10 | 12 COMM | 14 SETA | 16 SETT | + | 11 | 13 | 15 | 17 | + + | 18 SETD | 1A SETB | 1C SETV | 1E WARNING| + | 19 | 1B | 1D | 1F FN | + + |_______________________________________________| + | Debug entries with bit 01 set are unused. | + | 20 GSYM | 22 FNAME | 24 FUN | 26 STSYM | + | 28 LCSYM | 2A MAIN | 2C | 2E | + | 30 PC | 32 NSYMS | 34 NOMAP | 36 | + | 38 OBJ | 3A | 3C OPT | 3E | + | 40 RSYM | 42 M2C | 44 SLINE | 46 DSLINE | + | 48 BSLINE*| 4A DEFD | 4C | 4E | + | 50 EHDECL*| 52 | 54 CATCH | 56 | + | 58 | 5A | 5C | 5E | + | 60 SSYM | 62 | 64 SO | 66 | + | 68 | 6A | 6C | 6E | + | 70 | 72 | 74 | 76 | + | 78 | 7A | 7C | 7E | + | 80 LSYM | 82 BINCL | 84 SOL | 86 | + | 88 | 8A | 8C | 8E | + | 90 | 92 | 94 | 96 | + | 98 | 9A | 9C | 9E | + | A0 PSYM | A2 EINCL | A4 ENTRY | A6 | + | A8 | AA | AC | AE | + | B0 | B2 | B4 | B6 | + | B8 | BA | BC | BE | + | C0 LBRAC | C2 EXCL | C4 SCOPE | C6 | + | C8 | CA | CC | CE | + | D0 | D2 | D4 | D6 | + | D8 | DA | DC | DE | + | E0 RBRAC | E2 BCOMM | E4 ECOMM | E6 | + | E8 ECOML | EA | EC | EE | + | F0 | F2 | F4 | F6 | + | F8 | FA | FC | FE LENG | + +-----------------------------------------------+ + * 50 EHDECL is also MOD2. + * 48 BSLINE is also BROWS. + */ diff --git a/stab.h b/stab.h new file mode 100644 index 0000000..80bd594 --- /dev/null +++ b/stab.h @@ -0,0 +1,17 @@ +#ifndef __GNU_STAB__ + +/* Indicate the GNU stab.h is in use. */ + +#define __GNU_STAB__ + +#define __define_stab(NAME, CODE, STRING) NAME=CODE, + +enum __stab_debug_code +{ +#include "stab.def" +LAST_UNUSED_STAB_CODE +}; + +#undef __define_stab + +#endif /* __GNU_STAB_ */ diff --git a/stdarg.h b/stdarg.h new file mode 100644 index 0000000..83863f4 --- /dev/null +++ b/stdarg.h @@ -0,0 +1,28 @@ +#ifndef _STDARG_H +#define _STDARG_H + +typedef char *va_list; +typedef va_list __builtin_va_list; + +#ifdef __65816__ +#define va_start(ap, last) ap = ((char*)&(last)) + sizeof(last) +#define va_arg(ap, type) (ap += sizeof(type), *(type*)(ap - sizeof(type))) +#define va_end(ap) +#define va_copy(aq, ap) ((aq) = (ap)) +#else +/* only correct for i386 */ +#define va_start(ap,last) ap = ((char *)&(last)) + ((sizeof(last)+3)&~3) +#define va_arg(ap,type) (ap += (sizeof(type)+3)&~3, *(type *)(ap - ((sizeof(type)+3)&~3))) +#define va_end(ap) + +/* fix a buggy dependency on GCC in libio.h */ +typedef va_list __gnuc_va_list; +#endif + +#define __builtin_va_start va_start +#define __builtin_va_arg va_arg +#define __builtin_va_end va_end + +#define _VA_LIST_DEFINED + +#endif diff --git a/stdbool.h b/stdbool.h new file mode 100644 index 0000000..6ed13a6 --- /dev/null +++ b/stdbool.h @@ -0,0 +1,10 @@ +#ifndef _STDBOOL_H +#define _STDBOOL_H + +/* ISOC99 boolean */ + +#define bool _Bool +#define true 1 +#define false 0 + +#endif /* _STDBOOL_H */ diff --git a/stddef.h b/stddef.h new file mode 100644 index 0000000..c249a0e --- /dev/null +++ b/stddef.h @@ -0,0 +1,27 @@ +#ifndef _STDDEF_H +#define _STDDEF_H + +#define NULL ((void *)0) +typedef __SIZE_TYPE__ size_t; +typedef __WCHAR_TYPE__ wchar_t; +typedef __PTRDIFF_TYPE__ ptrdiff_t; +#define offsetof(type, field) ((size_t) &((type *)0)->field) +#define __builtin_offsetof offsetof + +/* need to do that because of glibc 2.1 bug (should have a way to test + presence of 'long long' without __GNUC__, or TCC should define + __GNUC__ ? */ +#if !defined(__int8_t_defined) && !defined(__dietlibc__) +#define __int8_t_defined +typedef char int8_t; +typedef short int int16_t; +#ifdef __65816__ +typedef int int16_t; +typedef long long int int32_t; +#else +typedef int int32_t; +typedef long long int int64_t; +#endif +#endif + +#endif diff --git a/tcc-doc.html b/tcc-doc.html new file mode 100644 index 0000000..503a427 --- /dev/null +++ b/tcc-doc.html @@ -0,0 +1,1809 @@ + + + + +Tiny C Compiler Reference Documentation + + +

Tiny C Compiler Reference Documentation

+

+

+

Table of Contents

+ +

+ + +

1. Introduction

+ +

+TinyCC (aka TCC) is a small but hyper fast C compiler. Unlike other C +compilers, it is meant to be self-relying: you do not need an +external assembler or linker because TCC does that for you. + + +

+TCC compiles so fast that even for big projects Makefiles may +not be necessary. + + +

+TCC not only supports ANSI C, but also most of the new ISO C99 +standard and many GNUC extensions including inline assembly. + + +

+TCC can also be used to make C scripts, i.e. pieces of C source +that you run as a Perl or Python script. Compilation is so fast that +your script will be as fast as if it was an executable. + + +

+TCC can also automatically generate memory and bound checks +(see section 6. TinyCC Memory and Bound checks) while allowing all C pointers operations. TCC can do +these checks even if non patched libraries are used. + + +

+With libtcc, you can use TCC as a backend for dynamic code +generation (see section 7. The libtcc library). + + +

+TCC mainly supports the i386 target on Linux and Windows. There are alpha +ports for the ARM (arm-tcc) and the TMS320C67xx targets +(c67-tcc). More information about the ARM port is available at +http://lists.gnu.org/archive/html/tinycc-devel/2003-10/msg00044.html. + + + + +

2. Command line invocation

+ +

+[This manual documents version 0.9.23 of the Tiny C Compiler] + + + + +

2.1 Quick start

+ + +
+usage: tcc [options] [infile1 infile2...] [`-run' infile args...]
+
+ +

+TCC options are a very much like gcc options. The main difference is that TCC +can also execute directly the resulting program and give it runtime +arguments. + + +

+Here are some examples to understand the logic: + + +

+ +
`tcc -run a.c' +
+Compile `a.c' and execute it directly + +
`tcc -run a.c arg1' +
+Compile a.c and execute it directly. arg1 is given as first argument to +the main() of a.c. + +
`tcc a.c -run b.c arg1' +
+Compile `a.c' and `b.c', link them together and execute them. arg1 is given +as first argument to the main() of the resulting program. Because +multiple C files are specified, `--' are necessary to clearly separate the +program arguments from the TCC options. + +
`tcc -o myprog a.c b.c' +
+Compile `a.c' and `b.c', link them and generate the executable `myprog'. + +
`tcc -o myprog a.o b.o' +
+link `a.o' and `b.o' together and generate the executable `myprog'. + +
`tcc -c a.c' +
+Compile `a.c' and generate object file `a.o'. + +
`tcc -c asmfile.S' +
+Preprocess with C preprocess and assemble `asmfile.S' and generate +object file `asmfile.o'. + +
`tcc -c asmfile.s' +
+Assemble (but not preprocess) `asmfile.s' and generate object file +`asmfile.o'. + +
`tcc -r -o ab.o a.c b.c' +
+Compile `a.c' and `b.c', link them together and generate the object file `ab.o'. + +
+ +

+Scripting: + + +

+TCC can be invoked from scripts, just as shell scripts. You just +need to add #!/usr/local/bin/tcc -run at the start of your C source: + + + +

+#!/usr/local/bin/tcc -run
+#include <stdio.h>
+
+int main() 
+{
+    printf("Hello World\n");
+    return 0;
+}
+
+ + + +

2.2 Option summary

+ +

+General Options: + + +

+ +
`-v' +
+Display current TCC version. + +
`-c' +
+Generate an object file (`-o' option must also be given). + +
`-o outfile' +
+Put object file, executable, or dll into output file `outfile'. + +
`-Bdir' +
+Set the path where the tcc internal libraries can be found (default is +`PREFIX/lib/tcc'). + +
`-bench' +
+Output compilation statistics. + +
`-run source [args...]' +
+Compile file source and run it with the command line arguments +args. In order to be able to give more than one argument to a +script, several TCC options can be given after the +`-run' option, separated by spaces. Example: + + +
+tcc "-run -L/usr/X11R6/lib -lX11" ex4.c
+
+ +In a script, it gives the following header: + + +
+#!/usr/local/bin/tcc -run -L/usr/X11R6/lib -lX11
+#include <stdlib.h>
+int main(int argc, char **argv)
+{
+    ...
+}
+
+ +
+ +

+Preprocessor options: + + +

+ +
`-Idir' +
+Specify an additional include path. Include paths are searched in the +order they are specified. + +System include paths are always searched after. The default system +include paths are: `/usr/local/include', `/usr/include' +and `PREFIX/lib/tcc/include'. (`PREFIX' is usually +`/usr' or `/usr/local'). + +
`-Dsym[=val]' +
+Define preprocessor symbol `sym' to +val. If val is not present, its value is `1'. Function-like macros can +also be defined: `-DF(a)=a+1' + +
`-Usym' +
+Undefine preprocessor symbol `sym'. +
+ +

+Compilation flags: + + +

+Note: each of the following warning options has a negative form beginning with +`-fno-'. + + +

+ +
`-funsigned-char' +
+Let the char type be unsigned. + +
`-fsigned-char' +
+Let the char type be signed. + +
`-fno-common' +
+Do not generate common symbols for uninitialized data. + +
`-fleading-underscore' +
+Add a leading underscore at the beginning of each C symbol. + +
+ +

+Warning options: + + +

+ +
`-w' +
+Disable all warnings. + +
+ +

+Note: each of the following warning options has a negative form beginning with +`-Wno-'. + + +

+ +
`-Wimplicit-function-declaration' +
+Warn about implicit function declaration. + +
`-Wunsupported' +
+Warn about unsupported GCC features that are ignored by TCC. + +
`-Wwrite-strings' +
+Make string constants be of type const char * instead of char +*. + +
`-Werror' +
+Abort compilation if warnings are issued. + +
`-Wall' +
+Activate all warnings, except `-Werror', `-Wunusupported' and +`-Wwrite-strings'. + +
+ +

+Linker options: + + +

+ +
`-Ldir' +
+Specify an additional static library path for the `-l' option. The +default library paths are `/usr/local/lib', `/usr/lib' and `/lib'. + +
`-lxxx' +
+Link your program with dynamic library libxxx.so or static library +libxxx.a. The library is searched in the paths specified by the +`-L' option. + +
`-shared' +
+Generate a shared library instead of an executable (`-o' option +must also be given). + +
`-static' +
+Generate a statically linked executable (default is a shared linked +executable) (`-o' option must also be given). + +
`-rdynamic' +
+Export global symbols to the dynamic linker. It is useful when a library +opened with dlopen() needs to access executable symbols. + +
`-r' +
+Generate an object file combining all input files (`-o' option must +also be given). + +
`-Wl,-Ttext,address' +
+Set the start of the .text section to address. + +
`-Wl,--oformat,fmt' +
+Use fmt as output format. The supported output formats are: +
+ +
elf32-i386 +
+ELF output format (default) +
binary +
+Binary image (only for executable output) +
coff +
+COFF output format (only for executable output for TMS320C67xx target) +
+ +
+ +

+Debugger options: + + +

+ +
`-g' +
+Generate run time debug information so that you get clear run time +error messages: test.c:68: in function 'test5()': dereferencing +invalid pointer instead of the laconic Segmentation +fault. + +
`-b' +
+Generate additional support code to check +memory allocations and array/pointer bounds. `-g' is implied. Note +that the generated code is slower and bigger in this case. + +
`-bt N' +
+Display N callers in stack traces. This is useful with `-g' or +`-b'. + +
+ +

+Note: GCC options `-Ox', `-fx' and `-mx' are +ignored. + + + + +

3. C language support

+ + + +

3.1 ANSI C

+ +

+TCC implements all the ANSI C standard, including structure bit fields +and floating point numbers (long double, double, and +float fully supported). + + + + +

3.2 ISOC99 extensions

+ +

+TCC implements many features of the new C standard: ISO C99. Currently +missing items are: complex and imaginary numbers and variable length +arrays. + + +

+Currently implemented ISOC99 features: + + + +

    + +
  • 64 bit long long types are fully supported. + +
  • The boolean type _Bool is supported. + +
  • __func__ is a string variable containing the current + +function name. + +
  • Variadic macros: __VA_ARGS__ can be used for + + function-like macros: + +
    +    #define dprintf(level, __VA_ARGS__) printf(__VA_ARGS__)
+
    + +dprintf can then be used with a variable number of parameters. + +
  • Declarations can appear anywhere in a block (as in C++). + +
  • Array and struct/union elements can be initialized in any order by + + using designators: + +
    +    struct { int x, y; } st[10] = { [0].x = 1, [0].y = 2 };
+
+    int tab[10] = { 1, 2, [5] = 5, [9] = 9};
+
    + + +
  • Compound initializers are supported: + + +
    +    int *p = (int []){ 1, 2, 3 };
+
    + +to initialize a pointer pointing to an initialized array. The same +works for structures and strings. + +
  • Hexadecimal floating point constants are supported: + + +
    +          double d = 0x1234p10;
+
    + +is the same as writing + +
    +          double d = 4771840.0;
+
    + +
  • inline keyword is ignored. + +
  • restrict keyword is ignored. + +
+ + + +

3.3 GNU C extensions

+

+ + + + + + + + + +

+TCC implements some GNU C extensions: + + + +

    + +
  • array designators can be used without '=': + + +
    +    int a[10] = { [0] 1, [5] 2, 3, 4 };
+
    + +
  • Structure field designators can be a label: + + +
    +    struct { int x, y; } st = { x: 1, y: 1};
+
    + +instead of + +
    +    struct { int x, y; } st = { .x = 1, .y = 1};
+
    + +
  • \e is ASCII character 27. + +
  • case ranges : ranges can be used in cases: + + +
    +    switch(a) {
+    case 1 ... 9:
+          printf("range 1 to 9\n");
+          break;
+    default:
+          printf("unexpected\n");
+          break;
+    }
+
    + +
  • The keyword __attribute__ is handled to specify variable or + +function attributes. The following attributes are supported: + +
      + +
    • aligned(n): align a variable or a structure field to n bytes + +(must be a power of two). + +
    • packed: force alignment of a variable or a structure field to + + 1. + +
    • section(name): generate function or data in assembly section + +name (name is a string containing the section name) instead of the default +section. + +
    • unused: specify that the variable or the function is unused. + +
    • cdecl: use standard C calling convention (default). + +
    • stdcall: use Pascal-like calling convention. + +
    • regparm(n): use fast i386 calling convention. n must be + +between 1 and 3. The first n function parameters are respectively put in +registers %eax, %edx and %ecx. + +
    + +Here are some examples: + +
    +    int a __attribute__ ((aligned(8), section(".mysection")));
+
    + +align variable a to 8 bytes and put it in section .mysection. + + +
    +    int my_add(int a, int b) __attribute__ ((section(".mycodesection"))) 
+    {
+        return a + b;
+    }
+
    + +generate function my_add in section .mycodesection. + +
  • GNU style variadic macros: + + +
    +    #define dprintf(fmt, args...) printf(fmt, ## args)
+
+    dprintf("no arg\n");
+    dprintf("one arg %d\n", 1);
+
    + +
  • __FUNCTION__ is interpreted as C99 __func__ + +(so it has not exactly the same semantics as string literal GNUC +where it is a string literal). + +
  • The __alignof__ keyword can be used as sizeof + +to get the alignment of a type or an expression. + +
  • The typeof(x) returns the type of x. + +x is an expression or a type. + +
  • Computed gotos: &&label returns a pointer of type + +void * on the goto label label. goto *expr can be +used to jump on the pointer resulting from expr. + +
  • Inline assembly with asm instruction: + + + + + +
    +static inline void * my_memcpy(void * to, const void * from, size_t n)
+{
+int d0, d1, d2;
+__asm__ __volatile__(
+        "rep ; movsl\n\t"
+        "testb $2,%b4\n\t"
+        "je 1f\n\t"
+        "movsw\n"
+        "1:\ttestb $1,%b4\n\t"
+        "je 2f\n\t"
+        "movsb\n"
+        "2:"
+        : "=&c" (d0), "=&D" (d1), "=&S" (d2)
+        :"0" (n/4), "q" (n),"1" ((long) to),"2" ((long) from)
+        : "memory");
+return (to);
+}
+
    + + +TCC includes its own x86 inline assembler with a gas-like (GNU +assembler) syntax. No intermediate files are generated. GCC 3.x named +operands are supported. + +
  • __builtin_types_compatible_p() and __builtin_constant_p() + +are supported. + +
  • #pragma pack is supported for win32 compatibility. + +
+ + + +

3.4 TinyCC extensions

+ + +
    + +
  • __TINYC__ is a predefined macro to 1 to + +indicate that you use TCC. + +
  • #! at the start of a line is ignored to allow scripting. + +
  • Binary digits can be entered (0b101 instead of + +5). + +
  • __BOUNDS_CHECKING_ON is defined if bound checking is activated. + +
+ + + +

4. TinyCC Assembler

+ +

+Since version 0.9.16, TinyCC integrates its own assembler. TinyCC +assembler supports a gas-like syntax (GNU assembler). You can +desactivate assembler support if you want a smaller TinyCC executable +(the C compiler does not rely on the assembler). + + +

+TinyCC Assembler is used to handle files with `.S' (C +preprocessed assembler) and `.s' extensions. It is also used to +handle the GNU inline assembler with the asm keyword. + + + + +

4.1 Syntax

+ +

+TinyCC Assembler supports most of the gas syntax. The tokens are the +same as C. + + + +

    + +
  • C and C++ comments are supported. + +
  • Identifiers are the same as C, so you cannot use '.' or '$'. + +
  • Only 32 bit integer numbers are supported. + +
+ + + +

4.2 Expressions

+ + +
    + +
  • Integers in decimal, octal and hexa are supported. + +
  • Unary operators: +, -, ~. + +
  • Binary operators in decreasing priority order: + + +
      +
    1. *, /, % + +
    2. &, |, ^ + +
    3. +, - + +
    + +
  • A value is either an absolute number or a label plus an offset. + +All operators accept absolute values except '+' and '-'. '+' or '-' can be +used to add an offset to a label. '-' supports two labels only if they +are the same or if they are both defined and in the same section. + +
+ + + +

4.3 Labels

+ + +
    + +
  • All labels are considered as local, except undefined ones. + +
  • Numeric labels can be used as local gas-like labels. + +They can be defined several times in the same source. Use 'b' +(backward) or 'f' (forward) as suffix to reference them: + + +
    + 1:
+      jmp 1b /* jump to '1' label before */
+      jmp 1f /* jump to '1' label after */
+ 1:
+
    + +
+ + + +

4.4 Directives

+

+ + + + + + + + + + + + + + + + + + + + + + + + + +

+All directives are preceeded by a '.'. The following directives are +supported: + + + +

    +
  • .align n[,value] + +
  • .skip n[,value] + +
  • .space n[,value] + +
  • .byte value1[,...] + +
  • .word value1[,...] + +
  • .short value1[,...] + +
  • .int value1[,...] + +
  • .long value1[,...] + +
  • .quad immediate_value1[,...] + +
  • .globl symbol + +
  • .global symbol + +
  • .section section + +
  • .text + +
  • .data + +
  • .bss + +
  • .fill repeat[,size[,value]] + +
  • .org n + +
  • .previous + +
  • .string string[,...] + +
  • .asciz string[,...] + +
  • .ascii string[,...] + +
+ + + +

4.5 X86 Assembler

+

+ + + +

+All X86 opcodes are supported. Only ATT syntax is supported (source +then destination operand order). If no size suffix is given, TinyCC +tries to guess it from the operand sizes. + + +

+Currently, MMX opcodes are supported but not SSE ones. + + + + +

5. TinyCC Linker

+

+ + + + + +

5.1 ELF file generation

+

+ + + +

+TCC can directly output relocatable ELF files (object files), +executable ELF files and dynamic ELF libraries without relying on an +external linker. + + +

+Dynamic ELF libraries can be output but the C compiler does not generate +position independent code (PIC). It means that the dynamic library +code generated by TCC cannot be factorized among processes yet. + + +

+TCC linker eliminates unreferenced object code in libraries. A single pass is +done on the object and library list, so the order in which object files and +libraries are specified is important (same constraint as GNU ld). No grouping +options (`--start-group' and `--end-group') are supported. + + + + +

5.2 ELF file loader

+ +

+TCC can load ELF object files, archives (.a files) and dynamic +libraries (.so). + + + + +

5.3 PE-i386 file generation

+

+ + + +

+TCC for Windows supports the native Win32 executable file format (PE-i386). It +generates both EXE and DLL files. DLL symbols can be imported thru DEF files +generated with the tiny_impdef tool. + + +

+Currently TCC for Windows cannot generate nor read PE object files, so ELF +object files are used for that purpose. It can be a problem if +interoperability with MSVC is needed. Moreover, no leading underscore is +currently generated in the ELF symbols. + + + + +

5.4 GNU Linker Scripts

+

+ + + + + + + + +

+Because on many Linux systems some dynamic libraries (such as +`/usr/lib/libc.so') are in fact GNU ld link scripts (horrible!), +the TCC linker also supports a subset of GNU ld scripts. + + +

+The GROUP and FILE commands are supported. OUTPUT_FORMAT +and TARGET are ignored. + + +

+Example from `/usr/lib/libc.so': + +

+/* GNU ld script
+   Use the shared library, but some functions are only in
+   the static library, so try that secondarily.  */
+GROUP ( /lib/libc.so.6 /usr/lib/libc_nonshared.a )
+
+ + + +

6. TinyCC Memory and Bound checks

+

+ + + + +

+This feature is activated with the `-b' (see section 2. Command line invocation). + + +

+Note that pointer size is unchanged and that code generated +with bound checks is fully compatible with unchecked +code. When a pointer comes from unchecked code, it is assumed to be +valid. Even very obscure C code with casts should work correctly. + + +

+For more information about the ideas behind this method, see +http://www.doc.ic.ac.uk/~phjk/BoundsChecking.html. + + +

+Here are some examples of caught errors: + + +

+ +
Invalid range with standard string function: +
+ +
+{
+    char tab[10];
+    memset(tab, 0, 11);
+}
+
+ +
Out of bounds-error in global or local arrays: +
+ +
+{
+    int tab[10];
+    for(i=0;i<11;i++) {
+        sum += tab[i];
+    }
+}
+
+ +
Out of bounds-error in malloc'ed data: +
+ +
+{
+    int *tab;
+    tab = malloc(20 * sizeof(int));
+    for(i=0;i<21;i++) {
+        sum += tab4[i];
+    }
+    free(tab);
+}
+
+ +
Access of freed memory: +
+ +
+{
+    int *tab;
+    tab = malloc(20 * sizeof(int));
+    free(tab);
+    for(i=0;i<20;i++) {
+        sum += tab4[i];
+    }
+}
+
+ +
Double free: +
+ +
+{
+    int *tab;
+    tab = malloc(20 * sizeof(int));
+    free(tab);
+    free(tab);
+}
+
+ +
+ + + +

7. The libtcc library

+ +

+The libtcc library enables you to use TCC as a backend for +dynamic code generation. + + +

+Read the `libtcc.h' to have an overview of the API. Read +`libtcc_test.c' to have a very simple example. + + +

+The idea consists in giving a C string containing the program you want +to compile directly to libtcc. Then you can access to any global +symbol (function or variable) defined. + + + + +

8. Developer's guide

+ +

+This chapter gives some hints to understand how TCC works. You can skip +it if you do not intend to modify the TCC code. + + + + +

8.1 File reading

+ +

+The BufferedFile structure contains the context needed to read a +file, including the current line number. tcc_open() opens a new +file and tcc_close() closes it. inp() returns the next +character. + + + + +

8.2 Lexer

+ +

+next() reads the next token in the current +file. next_nomacro() reads the next token without macro +expansion. + + +

+tok contains the current token (see TOK_xxx) +constants. Identifiers and keywords are also keywords. tokc +contains additional infos about the token (for example a constant value +if number or string token). + + + + +

8.3 Parser

+ +

+The parser is hardcoded (yacc is not necessary). It does only one pass, +except: + + + +

    + +
  • For initialized arrays with unknown size, a first pass + +is done to count the number of elements. + +
  • For architectures where arguments are evaluated in + +reverse order, a first pass is done to reverse the argument order. + +
+ + + +

8.4 Types

+ +

+The types are stored in a single 'int' variable. It was choosen in the +first stages of development when tcc was much simpler. Now, it may not +be the best solution. + + + +

+#define VT_INT        0  /* integer type */
+#define VT_BYTE       1  /* signed byte type */
+#define VT_SHORT      2  /* short type */
+#define VT_VOID       3  /* void type */
+#define VT_PTR        4  /* pointer */
+#define VT_ENUM       5  /* enum definition */
+#define VT_FUNC       6  /* function type */
+#define VT_STRUCT     7  /* struct/union definition */
+#define VT_FLOAT      8  /* IEEE float */
+#define VT_DOUBLE     9  /* IEEE double */
+#define VT_LDOUBLE   10  /* IEEE long double */
+#define VT_BOOL      11  /* ISOC99 boolean type */
+#define VT_LLONG     12  /* 64 bit integer */
+#define VT_LONG      13  /* long integer (NEVER USED as type, only
+                            during parsing) */
+#define VT_BTYPE      0x000f /* mask for basic type */
+#define VT_UNSIGNED   0x0010  /* unsigned type */
+#define VT_ARRAY      0x0020  /* array type (also has VT_PTR) */
+#define VT_BITFIELD   0x0040  /* bitfield modifier */
+
+#define VT_STRUCT_SHIFT 16   /* structure/enum name shift (16 bits left) */
+
+ +

+When a reference to another type is needed (for pointers, functions and +structures), the 32 - VT_STRUCT_SHIFT high order bits are used to +store an identifier reference. + + +

+The VT_UNSIGNED flag can be set for chars, shorts, ints and long +longs. + + +

+Arrays are considered as pointers VT_PTR with the flag +VT_ARRAY set. + + +

+The VT_BITFIELD flag can be set for chars, shorts, ints and long +longs. If it is set, then the bitfield position is stored from bits +VT_STRUCT_SHIFT to VT_STRUCT_SHIFT + 5 and the bit field size is stored +from bits VT_STRUCT_SHIFT + 6 to VT_STRUCT_SHIFT + 11. + + +

+VT_LONG is never used except during parsing. + + +

+During parsing, the storage of an object is also stored in the type +integer: + + + +

+#define VT_EXTERN  0x00000080  /* extern definition */
+#define VT_STATIC  0x00000100  /* static variable */
+#define VT_TYPEDEF 0x00000200  /* typedef definition */
+
+ + + +

8.5 Symbols

+ +

+All symbols are stored in hashed symbol stacks. Each symbol stack +contains Sym structures. + + +

+Sym.v contains the symbol name (remember +an idenfier is also a token, so a string is never necessary to store +it). Sym.t gives the type of the symbol. Sym.r is usually +the register in which the corresponding variable is stored. Sym.c is +usually a constant associated to the symbol. + + +

+Four main symbol stacks are defined: + + +

+ +
define_stack +
+for the macros (#defines). + +
global_stack +
+for the global variables, functions and types. + +
local_stack +
+for the local variables, functions and types. + +
global_label_stack +
+for the local labels (for goto). + +
label_stack +
+for GCC block local labels (see the __label__ keyword). + +
+ +

+sym_push() is used to add a new symbol in the local symbol +stack. If no local symbol stack is active, it is added in the global +symbol stack. + + +

+sym_pop(st,b) pops symbols from the symbol stack st until +the symbol b is on the top of stack. If b is NULL, the stack +is emptied. + + +

+sym_find(v) return the symbol associated to the identifier +v. The local stack is searched first from top to bottom, then the +global stack. + + + + +

8.6 Sections

+ +

+The generated code and datas are written in sections. The structure +Section contains all the necessary information for a given +section. new_section() creates a new section. ELF file semantics +is assumed for each section. + + +

+The following sections are predefined: + + +

+ +
text_section +
+is the section containing the generated code. ind contains the +current position in the code section. + +
data_section +
+contains initialized data + +
bss_section +
+contains uninitialized data + +
bounds_section +
+
lbounds_section +
+are used when bound checking is activated + +
stab_section +
+
stabstr_section +
+are used when debugging is actived to store debug information + +
symtab_section +
+
strtab_section +
+contain the exported symbols (currently only used for debugging). + +
+ + + +

8.7 Code generation

+

+ + + + + +

8.7.1 Introduction

+ +

+The TCC code generator directly generates linked binary code in one +pass. It is rather unusual these days (see gcc for example which +generates text assembly), but it can be very fast and surprisingly +little complicated. + + +

+The TCC code generator is register based. Optimization is only done at +the expression level. No intermediate representation of expression is +kept except the current values stored in the value stack. + + +

+On x86, three temporary registers are used. When more registers are +needed, one register is spilled into a new temporary variable on the stack. + + + + +

8.7.2 The value stack

+

+ + + +

+When an expression is parsed, its value is pushed on the value stack +(vstack). The top of the value stack is vtop. Each value +stack entry is the structure SValue. + + +

+SValue.t is the type. SValue.r indicates how the value is +currently stored in the generated code. It is usually a CPU register +index (REG_xxx constants), but additional values and flags are +defined: + + + +

+#define VT_CONST     0x00f0
+#define VT_LLOCAL    0x00f1
+#define VT_LOCAL     0x00f2
+#define VT_CMP       0x00f3
+#define VT_JMP       0x00f4
+#define VT_JMPI      0x00f5
+#define VT_LVAL      0x0100
+#define VT_SYM       0x0200
+#define VT_MUSTCAST  0x0400
+#define VT_MUSTBOUND 0x0800
+#define VT_BOUNDED   0x8000
+#define VT_LVAL_BYTE     0x1000
+#define VT_LVAL_SHORT    0x2000
+#define VT_LVAL_UNSIGNED 0x4000
+#define VT_LVAL_TYPE     (VT_LVAL_BYTE | VT_LVAL_SHORT | VT_LVAL_UNSIGNED)
+
+ +
+ +
VT_CONST +
+indicates that the value is a constant. It is stored in the union +SValue.c, depending on its type. + +
VT_LOCAL +
+indicates a local variable pointer at offset SValue.c.i in the +stack. + +
VT_CMP +
+indicates that the value is actually stored in the CPU flags (i.e. the +value is the consequence of a test). The value is either 0 or 1. The +actual CPU flags used is indicated in SValue.c.i. + +If any code is generated which destroys the CPU flags, this value MUST be +put in a normal register. + +
VT_JMP +
+
VT_JMPI +
+indicates that the value is the consequence of a conditional jump. For VT_JMP, +it is 1 if the jump is taken, 0 otherwise. For VT_JMPI it is inverted. + +These values are used to compile the || and && logical +operators. + +If any code is generated, this value MUST be put in a normal +register. Otherwise, the generated code won't be executed if the jump is +taken. + +
VT_LVAL +
+is a flag indicating that the value is actually an lvalue (left value of +an assignment). It means that the value stored is actually a pointer to +the wanted value. + +Understanding the use VT_LVAL is very important if you want to +understand how TCC works. + +
VT_LVAL_BYTE +
+
VT_LVAL_SHORT +
+
VT_LVAL_UNSIGNED +
+if the lvalue has an integer type, then these flags give its real +type. The type alone is not enough in case of cast optimisations. + +
VT_LLOCAL +
+is a saved lvalue on the stack. VT_LLOCAL should be eliminated +ASAP because its semantics are rather complicated. + +
VT_MUSTCAST +
+indicates that a cast to the value type must be performed if the value +is used (lazy casting). + +
VT_SYM +
+indicates that the symbol SValue.sym must be added to the constant. + +
VT_MUSTBOUND +
+
VT_BOUNDED +
+are only used for optional bound checking. + +
+ + + +

8.7.3 Manipulating the value stack

+

+ + + +

+vsetc() and vset() pushes a new value on the value +stack. If the previous vtop was stored in a very unsafe place(for +example in the CPU flags), then some code is generated to put the +previous vtop in a safe storage. + + +

+vpop() pops vtop. In some cases, it also generates cleanup +code (for example if stacked floating point registers are used as on +x86). + + +

+The gv(rc) function generates code to evaluate vtop (the +top value of the stack) into registers. rc selects in which +register class the value should be put. gv() is the most +important function of the code generator. + + +

+gv2() is the same as gv() but for the top two stack +entries. + + + + +

8.7.4 CPU dependent code generation

+

+ +See the `i386-gen.c' file to have an example. + + +

+ +
load() +
+must generate the code needed to load a stack value into a register. + +
store() +
+must generate the code needed to store a register into a stack value +lvalue. + +
gfunc_start() +
+
gfunc_param() +
+
gfunc_call() +
+should generate a function call + +
gfunc_prolog() +
+
gfunc_epilog() +
+should generate a function prolog/epilog. + +
gen_opi(op) +
+must generate the binary integer operation op on the two top +entries of the stack which are guaranted to contain integer types. + +The result value should be put on the stack. + +
gen_opf(op) +
+same as gen_opi() for floating point operations. The two top +entries of the stack are guaranted to contain floating point values of +same types. + +
gen_cvt_itof() +
+integer to floating point conversion. + +
gen_cvt_ftoi() +
+floating point to integer conversion. + +
gen_cvt_ftof() +
+floating point to floating point of different size conversion. + +
gen_bounded_ptr_add() +
+
gen_bounded_ptr_deref() +
+are only used for bounds checking. + +
+ + + +

8.8 Optimizations done

+

+ + + + + + + +Constant propagation is done for all operations. Multiplications and +divisions are optimized to shifts when appropriate. Comparison +operators are optimized by maintaining a special cache for the +processor flags. &&, || and ! are optimized by maintaining a special +'jump target' value. No other jump optimization is currently performed +because it would require to store the code in a more abstract fashion. + + + + +

Concept Index

+

+Jump to: +_ +- +a +- +b +- +c +- +d +- +e +- +f +- +g +- +i +- +j +- +l +- +m +- +o +- +p +- +q +- +r +- +s +- +t +- +u +- +v +- +w +

+

_

+ +
  • __asm__ +
    •  +

    a

    + +
  • align directive +
  • aligned attribute +
  • ascii directive +
  • asciz directive +
  • assembler +
  • assembler directives +
  • assembly, inline +
    •  +

    b

    + +
  • bound checks +
  • bss directive +
  • byte directive +
    •  +

    c

    + +
  • caching processor flags +
  • cdecl attribute +
  • code generation +
  • comparison operators +
  • constant propagation +
  • CPU dependent +
    •  +

    d

    + +
  • data directive +
  • directives, assembler +
    •  +

    e

    + +
  • ELF +
    •  +

    f

    + +
  • FILE, linker command +
  • fill directive +
  • flags, caching +
    •  +

    g

    + +
  • gas +
  • global directive +
  • globl directive +
  • GROUP, linker command +
    •  +

    i

    + +
  • inline assembly +
  • int directive +
    •  +

    j

    + +
  • jump optimization +
    •  +

    l

    + +
  • linker +
  • linker scripts +
  • long directive +
    •  +

    m

    + +
  • memory checks +
    •  +

    o

    + +
  • optimizations +
  • org directive +
  • OUTPUT_FORMAT, linker command +
    •  +

    p

    + +
  • packed attribute +
  • PE-i386 +
  • previous directive +
    •  +

    q

    + +
  • quad directive +
    •  +

    r

    + +
  • regparm attribute +
    •  +

    s

    + +
  • scripts, linker +
  • section attribute +
  • section directive +
  • short directive +
  • skip directive +
  • space directive +
  • stdcall attribute +
  • strength reduction +
  • string directive +
    •  +

    t

    + +
  • TARGET, linker command +
  • text directive +
    •  +

    u

    + +
  • unused attribute +
    •  +

    v

    + +
  • value stack +
  • value stack, introduction +
    •  +

    w

    + +
  • word directive +
    •  + + +

    +This document was generated on 18 June 2005 using +texi2html 1.56k. + + diff --git a/tcc-doc.texi b/tcc-doc.texi new file mode 100644 index 0000000..15fe604 --- /dev/null +++ b/tcc-doc.texi @@ -0,0 +1,1214 @@ +\input texinfo @c -*- texinfo -*- +@c %**start of header +@setfilename tcc-doc.info +@settitle Tiny C Compiler Reference Documentation +@c %**end of header + +@include config.texi + +@iftex +@titlepage +@afourpaper +@sp 7 +@center @titlefont{Tiny C Compiler Reference Documentation} +@sp 3 +@end titlepage +@headings double +@end iftex + +@c @ifhtml +@contents +@c @end ifhtml + +@ifnothtml +@node Top, Introduction, (dir), (dir) +@top Tiny C Compiler Reference Documentation + +This manual documents version @value{VERSION} of the Tiny C Compiler. + +@menu +* Introduction:: Introduction to tcc. +* Invoke:: Invocation of tcc (command line, options). +* Bounds:: Automatic bounds-checking of C code. +* Libtcc:: The libtcc library. +@end menu +@end ifnothtml + +@node Introduction +@chapter Introduction + +TinyCC (aka TCC) is a small but hyper fast C compiler. Unlike other C +compilers, it is meant to be self-relying: you do not need an +external assembler or linker because TCC does that for you. + +TCC compiles so @emph{fast} that even for big projects @code{Makefile}s may +not be necessary. + +TCC not only supports ANSI C, but also most of the new ISO C99 +standard and many GNUC extensions including inline assembly. + +TCC can also be used to make @emph{C scripts}, i.e. pieces of C source +that you run as a Perl or Python script. Compilation is so fast that +your script will be as fast as if it was an executable. + +TCC can also automatically generate memory and bound checks +(@pxref{Bounds}) while allowing all C pointers operations. TCC can do +these checks even if non patched libraries are used. + +With @code{libtcc}, you can use TCC as a backend for dynamic code +generation (@pxref{Libtcc}). + +TCC mainly supports the i386 target on Linux and Windows. There are alpha +ports for the ARM (@code{arm-tcc}) and the TMS320C67xx targets +(@code{c67-tcc}). More information about the ARM port is available at +@url{http://lists.gnu.org/archive/html/tinycc-devel/2003-10/msg00044.html}. + +@node Invoke +@chapter Command line invocation + +[This manual documents version @value{VERSION} of the Tiny C Compiler] + +@section Quick start + +@example +@c man begin SYNOPSIS +usage: tcc [options] [@var{infile1} @var{infile2}@dots{}] [@option{-run} @var{infile} @var{args}@dots{}] +@c man end +@end example + +@noindent +@c man begin DESCRIPTION +TCC options are a very much like gcc options. The main difference is that TCC +can also execute directly the resulting program and give it runtime +arguments. + +Here are some examples to understand the logic: + +@table @code +@item @samp{tcc -run a.c} +Compile @file{a.c} and execute it directly + +@item @samp{tcc -run a.c arg1} +Compile a.c and execute it directly. arg1 is given as first argument to +the @code{main()} of a.c. + +@item @samp{tcc a.c -run b.c arg1} +Compile @file{a.c} and @file{b.c}, link them together and execute them. arg1 is given +as first argument to the @code{main()} of the resulting program. Because +multiple C files are specified, @option{--} are necessary to clearly separate the +program arguments from the TCC options. + +@item @samp{tcc -o myprog a.c b.c} +Compile @file{a.c} and @file{b.c}, link them and generate the executable @file{myprog}. + +@item @samp{tcc -o myprog a.o b.o} +link @file{a.o} and @file{b.o} together and generate the executable @file{myprog}. + +@item @samp{tcc -c a.c} +Compile @file{a.c} and generate object file @file{a.o}. + +@item @samp{tcc -c asmfile.S} +Preprocess with C preprocess and assemble @file{asmfile.S} and generate +object file @file{asmfile.o}. + +@item @samp{tcc -c asmfile.s} +Assemble (but not preprocess) @file{asmfile.s} and generate object file +@file{asmfile.o}. + +@item @samp{tcc -r -o ab.o a.c b.c} +Compile @file{a.c} and @file{b.c}, link them together and generate the object file @file{ab.o}. + +@end table + +Scripting: + +TCC can be invoked from @emph{scripts}, just as shell scripts. You just +need to add @code{#!/usr/local/bin/tcc -run} at the start of your C source: + +@example +#!/usr/local/bin/tcc -run +#include + +int main() +@{ + printf("Hello World\n"); + return 0; +@} +@end example +@c man end + +@section Option summary + +General Options: + +@c man begin OPTIONS +@table @option +@item -v +Display current TCC version. + +@item -c +Generate an object file (@option{-o} option must also be given). + +@item -o outfile +Put object file, executable, or dll into output file @file{outfile}. + +@item -Bdir +Set the path where the tcc internal libraries can be found (default is +@file{PREFIX/lib/tcc}). + +@item -bench +Output compilation statistics. + +@item -run source [args...] + +Compile file @var{source} and run it with the command line arguments +@var{args}. In order to be able to give more than one argument to a +script, several TCC options can be given @emph{after} the +@option{-run} option, separated by spaces. Example: + +@example +tcc "-run -L/usr/X11R6/lib -lX11" ex4.c +@end example + +In a script, it gives the following header: + +@example +#!/usr/local/bin/tcc -run -L/usr/X11R6/lib -lX11 +#include +int main(int argc, char **argv) +@{ + ... +@} +@end example + +@end table + +Preprocessor options: + +@table @option +@item -Idir +Specify an additional include path. Include paths are searched in the +order they are specified. + +System include paths are always searched after. The default system +include paths are: @file{/usr/local/include}, @file{/usr/include} +and @file{PREFIX/lib/tcc/include}. (@file{PREFIX} is usually +@file{/usr} or @file{/usr/local}). + +@item -Dsym[=val] +Define preprocessor symbol @samp{sym} to +val. If val is not present, its value is @samp{1}. Function-like macros can +also be defined: @option{-DF(a)=a+1} + +@item -Usym +Undefine preprocessor symbol @samp{sym}. +@end table + +Compilation flags: + +Note: each of the following warning options has a negative form beginning with +@option{-fno-}. + +@table @option +@item -funsigned-char +Let the @code{char} type be unsigned. + +@item -fsigned-char +Let the @code{char} type be signed. + +@item -fno-common +Do not generate common symbols for uninitialized data. + +@item -fleading-underscore +Add a leading underscore at the beginning of each C symbol. + +@end table + +Warning options: + +@table @option +@item -w +Disable all warnings. + +@end table + +Note: each of the following warning options has a negative form beginning with +@option{-Wno-}. + +@table @option +@item -Wimplicit-function-declaration +Warn about implicit function declaration. + +@item -Wunsupported +Warn about unsupported GCC features that are ignored by TCC. + +@item -Wwrite-strings +Make string constants be of type @code{const char *} instead of @code{char +*}. + +@item -Werror +Abort compilation if warnings are issued. + +@item -Wall +Activate all warnings, except @option{-Werror}, @option{-Wunusupported} and +@option{-Wwrite-strings}. + +@end table + +Linker options: + +@table @option +@item -Ldir +Specify an additional static library path for the @option{-l} option. The +default library paths are @file{/usr/local/lib}, @file{/usr/lib} and @file{/lib}. + +@item -lxxx +Link your program with dynamic library libxxx.so or static library +libxxx.a. The library is searched in the paths specified by the +@option{-L} option. + +@item -shared +Generate a shared library instead of an executable (@option{-o} option +must also be given). + +@item -static +Generate a statically linked executable (default is a shared linked +executable) (@option{-o} option must also be given). + +@item -rdynamic +Export global symbols to the dynamic linker. It is useful when a library +opened with @code{dlopen()} needs to access executable symbols. + +@item -r +Generate an object file combining all input files (@option{-o} option must +also be given). + +@item -Wl,-Ttext,address +Set the start of the .text section to @var{address}. + +@item -Wl,--oformat,fmt +Use @var{fmt} as output format. The supported output formats are: +@table @code +@item elf32-i386 +ELF output format (default) +@item binary +Binary image (only for executable output) +@item coff +COFF output format (only for executable output for TMS320C67xx target) +@end table + +@end table + +Debugger options: + +@table @option +@item -g +Generate run time debug information so that you get clear run time +error messages: @code{ test.c:68: in function 'test5()': dereferencing +invalid pointer} instead of the laconic @code{Segmentation +fault}. + +@item -b +Generate additional support code to check +memory allocations and array/pointer bounds. @option{-g} is implied. Note +that the generated code is slower and bigger in this case. + +@item -bt N +Display N callers in stack traces. This is useful with @option{-g} or +@option{-b}. + +@end table + +Note: GCC options @option{-Ox}, @option{-fx} and @option{-mx} are +ignored. +@c man end + +@ignore + +@setfilename tcc +@settitle Tiny C Compiler + +@c man begin SEEALSO +gcc(1) +@c man end + +@c man begin AUTHOR +Fabrice Bellard +@c man end + +@end ignore + +@chapter C language support + +@section ANSI C + +TCC implements all the ANSI C standard, including structure bit fields +and floating point numbers (@code{long double}, @code{double}, and +@code{float} fully supported). + +@section ISOC99 extensions + +TCC implements many features of the new C standard: ISO C99. Currently +missing items are: complex and imaginary numbers and variable length +arrays. + +Currently implemented ISOC99 features: + +@itemize + +@item 64 bit @code{long long} types are fully supported. + +@item The boolean type @code{_Bool} is supported. + +@item @code{__func__} is a string variable containing the current +function name. + +@item Variadic macros: @code{__VA_ARGS__} can be used for + function-like macros: +@example + #define dprintf(level, __VA_ARGS__) printf(__VA_ARGS__) +@end example + +@noindent +@code{dprintf} can then be used with a variable number of parameters. + +@item Declarations can appear anywhere in a block (as in C++). + +@item Array and struct/union elements can be initialized in any order by + using designators: +@example + struct @{ int x, y; @} st[10] = @{ [0].x = 1, [0].y = 2 @}; + + int tab[10] = @{ 1, 2, [5] = 5, [9] = 9@}; +@end example + +@item Compound initializers are supported: +@example + int *p = (int [])@{ 1, 2, 3 @}; +@end example +to initialize a pointer pointing to an initialized array. The same +works for structures and strings. + +@item Hexadecimal floating point constants are supported: +@example + double d = 0x1234p10; +@end example + +@noindent +is the same as writing +@example + double d = 4771840.0; +@end example + +@item @code{inline} keyword is ignored. + +@item @code{restrict} keyword is ignored. +@end itemize + +@section GNU C extensions +@cindex aligned attribute +@cindex packed attribute +@cindex section attribute +@cindex unused attribute +@cindex cdecl attribute +@cindex stdcall attribute +@cindex regparm attribute + +TCC implements some GNU C extensions: + +@itemize + +@item array designators can be used without '=': +@example + int a[10] = @{ [0] 1, [5] 2, 3, 4 @}; +@end example + +@item Structure field designators can be a label: +@example + struct @{ int x, y; @} st = @{ x: 1, y: 1@}; +@end example +instead of +@example + struct @{ int x, y; @} st = @{ .x = 1, .y = 1@}; +@end example + +@item @code{\e} is ASCII character 27. + +@item case ranges : ranges can be used in @code{case}s: +@example + switch(a) @{ + case 1 @dots{} 9: + printf("range 1 to 9\n"); + break; + default: + printf("unexpected\n"); + break; + @} +@end example + +@item The keyword @code{__attribute__} is handled to specify variable or +function attributes. The following attributes are supported: + @itemize + + @item @code{aligned(n)}: align a variable or a structure field to n bytes +(must be a power of two). + + @item @code{packed}: force alignment of a variable or a structure field to + 1. + + @item @code{section(name)}: generate function or data in assembly section +name (name is a string containing the section name) instead of the default +section. + + @item @code{unused}: specify that the variable or the function is unused. + + @item @code{cdecl}: use standard C calling convention (default). + + @item @code{stdcall}: use Pascal-like calling convention. + + @item @code{regparm(n)}: use fast i386 calling convention. @var{n} must be +between 1 and 3. The first @var{n} function parameters are respectively put in +registers @code{%eax}, @code{%edx} and @code{%ecx}. + + @end itemize + +Here are some examples: +@example + int a __attribute__ ((aligned(8), section(".mysection"))); +@end example + +@noindent +align variable @code{a} to 8 bytes and put it in section @code{.mysection}. + +@example + int my_add(int a, int b) __attribute__ ((section(".mycodesection"))) + @{ + return a + b; + @} +@end example + +@noindent +generate function @code{my_add} in section @code{.mycodesection}. + +@item GNU style variadic macros: +@example + #define dprintf(fmt, args@dots{}) printf(fmt, ## args) + + dprintf("no arg\n"); + dprintf("one arg %d\n", 1); +@end example + +@item @code{__FUNCTION__} is interpreted as C99 @code{__func__} +(so it has not exactly the same semantics as string literal GNUC +where it is a string literal). + +@item The @code{__alignof__} keyword can be used as @code{sizeof} +to get the alignment of a type or an expression. + +@item The @code{typeof(x)} returns the type of @code{x}. +@code{x} is an expression or a type. + +@item Computed gotos: @code{&&label} returns a pointer of type +@code{void *} on the goto label @code{label}. @code{goto *expr} can be +used to jump on the pointer resulting from @code{expr}. + +@item Inline assembly with asm instruction: +@cindex inline assembly +@cindex assembly, inline +@cindex __asm__ +@example +static inline void * my_memcpy(void * to, const void * from, size_t n) +@{ +int d0, d1, d2; +__asm__ __volatile__( + "rep ; movsl\n\t" + "testb $2,%b4\n\t" + "je 1f\n\t" + "movsw\n" + "1:\ttestb $1,%b4\n\t" + "je 2f\n\t" + "movsb\n" + "2:" + : "=&c" (d0), "=&D" (d1), "=&S" (d2) + :"0" (n/4), "q" (n),"1" ((long) to),"2" ((long) from) + : "memory"); +return (to); +@} +@end example + +@noindent +@cindex gas +TCC includes its own x86 inline assembler with a @code{gas}-like (GNU +assembler) syntax. No intermediate files are generated. GCC 3.x named +operands are supported. + +@item @code{__builtin_types_compatible_p()} and @code{__builtin_constant_p()} +are supported. + +@item @code{#pragma pack} is supported for win32 compatibility. + +@end itemize + +@section TinyCC extensions + +@itemize + +@item @code{__TINYC__} is a predefined macro to @code{1} to +indicate that you use TCC. + +@item @code{#!} at the start of a line is ignored to allow scripting. + +@item Binary digits can be entered (@code{0b101} instead of +@code{5}). + +@item @code{__BOUNDS_CHECKING_ON} is defined if bound checking is activated. + +@end itemize + +@chapter TinyCC Assembler + +Since version 0.9.16, TinyCC integrates its own assembler. TinyCC +assembler supports a gas-like syntax (GNU assembler). You can +desactivate assembler support if you want a smaller TinyCC executable +(the C compiler does not rely on the assembler). + +TinyCC Assembler is used to handle files with @file{.S} (C +preprocessed assembler) and @file{.s} extensions. It is also used to +handle the GNU inline assembler with the @code{asm} keyword. + +@section Syntax + +TinyCC Assembler supports most of the gas syntax. The tokens are the +same as C. + +@itemize + +@item C and C++ comments are supported. + +@item Identifiers are the same as C, so you cannot use '.' or '$'. + +@item Only 32 bit integer numbers are supported. + +@end itemize + +@section Expressions + +@itemize + +@item Integers in decimal, octal and hexa are supported. + +@item Unary operators: +, -, ~. + +@item Binary operators in decreasing priority order: + +@enumerate +@item *, /, % +@item &, |, ^ +@item +, - +@end enumerate + +@item A value is either an absolute number or a label plus an offset. +All operators accept absolute values except '+' and '-'. '+' or '-' can be +used to add an offset to a label. '-' supports two labels only if they +are the same or if they are both defined and in the same section. + +@end itemize + +@section Labels + +@itemize + +@item All labels are considered as local, except undefined ones. + +@item Numeric labels can be used as local @code{gas}-like labels. +They can be defined several times in the same source. Use 'b' +(backward) or 'f' (forward) as suffix to reference them: + +@example + 1: + jmp 1b /* jump to '1' label before */ + jmp 1f /* jump to '1' label after */ + 1: +@end example + +@end itemize + +@section Directives +@cindex assembler directives +@cindex directives, assembler +@cindex align directive +@cindex skip directive +@cindex space directive +@cindex byte directive +@cindex word directive +@cindex short directive +@cindex int directive +@cindex long directive +@cindex quad directive +@cindex globl directive +@cindex global directive +@cindex section directive +@cindex text directive +@cindex data directive +@cindex bss directive +@cindex fill directive +@cindex org directive +@cindex previous directive +@cindex string directive +@cindex asciz directive +@cindex ascii directive + +All directives are preceeded by a '.'. The following directives are +supported: + +@itemize +@item .align n[,value] +@item .skip n[,value] +@item .space n[,value] +@item .byte value1[,...] +@item .word value1[,...] +@item .short value1[,...] +@item .int value1[,...] +@item .long value1[,...] +@item .quad immediate_value1[,...] +@item .globl symbol +@item .global symbol +@item .section section +@item .text +@item .data +@item .bss +@item .fill repeat[,size[,value]] +@item .org n +@item .previous +@item .string string[,...] +@item .asciz string[,...] +@item .ascii string[,...] +@end itemize + +@section X86 Assembler +@cindex assembler + +All X86 opcodes are supported. Only ATT syntax is supported (source +then destination operand order). If no size suffix is given, TinyCC +tries to guess it from the operand sizes. + +Currently, MMX opcodes are supported but not SSE ones. + +@chapter TinyCC Linker +@cindex linker + +@section ELF file generation +@cindex ELF + +TCC can directly output relocatable ELF files (object files), +executable ELF files and dynamic ELF libraries without relying on an +external linker. + +Dynamic ELF libraries can be output but the C compiler does not generate +position independent code (PIC). It means that the dynamic library +code generated by TCC cannot be factorized among processes yet. + +TCC linker eliminates unreferenced object code in libraries. A single pass is +done on the object and library list, so the order in which object files and +libraries are specified is important (same constraint as GNU ld). No grouping +options (@option{--start-group} and @option{--end-group}) are supported. + +@section ELF file loader + +TCC can load ELF object files, archives (.a files) and dynamic +libraries (.so). + +@section PE-i386 file generation +@cindex PE-i386 + +TCC for Windows supports the native Win32 executable file format (PE-i386). It +generates both EXE and DLL files. DLL symbols can be imported thru DEF files +generated with the @code{tiny_impdef} tool. + +Currently TCC for Windows cannot generate nor read PE object files, so ELF +object files are used for that purpose. It can be a problem if +interoperability with MSVC is needed. Moreover, no leading underscore is +currently generated in the ELF symbols. + +@section GNU Linker Scripts +@cindex scripts, linker +@cindex linker scripts +@cindex GROUP, linker command +@cindex FILE, linker command +@cindex OUTPUT_FORMAT, linker command +@cindex TARGET, linker command + +Because on many Linux systems some dynamic libraries (such as +@file{/usr/lib/libc.so}) are in fact GNU ld link scripts (horrible!), +the TCC linker also supports a subset of GNU ld scripts. + +The @code{GROUP} and @code{FILE} commands are supported. @code{OUTPUT_FORMAT} +and @code{TARGET} are ignored. + +Example from @file{/usr/lib/libc.so}: +@example +/* GNU ld script + Use the shared library, but some functions are only in + the static library, so try that secondarily. */ +GROUP ( /lib/libc.so.6 /usr/lib/libc_nonshared.a ) +@end example + +@node Bounds +@chapter TinyCC Memory and Bound checks +@cindex bound checks +@cindex memory checks + +This feature is activated with the @option{-b} (@pxref{Invoke}). + +Note that pointer size is @emph{unchanged} and that code generated +with bound checks is @emph{fully compatible} with unchecked +code. When a pointer comes from unchecked code, it is assumed to be +valid. Even very obscure C code with casts should work correctly. + +For more information about the ideas behind this method, see +@url{http://www.doc.ic.ac.uk/~phjk/BoundsChecking.html}. + +Here are some examples of caught errors: + +@table @asis + +@item Invalid range with standard string function: +@example +@{ + char tab[10]; + memset(tab, 0, 11); +@} +@end example + +@item Out of bounds-error in global or local arrays: +@example +@{ + int tab[10]; + for(i=0;i<11;i++) @{ + sum += tab[i]; + @} +@} +@end example + +@item Out of bounds-error in malloc'ed data: +@example +@{ + int *tab; + tab = malloc(20 * sizeof(int)); + for(i=0;i<21;i++) @{ + sum += tab4[i]; + @} + free(tab); +@} +@end example + +@item Access of freed memory: +@example +@{ + int *tab; + tab = malloc(20 * sizeof(int)); + free(tab); + for(i=0;i<20;i++) @{ + sum += tab4[i]; + @} +@} +@end example + +@item Double free: +@example +@{ + int *tab; + tab = malloc(20 * sizeof(int)); + free(tab); + free(tab); +@} +@end example + +@end table + +@node Libtcc +@chapter The @code{libtcc} library + +The @code{libtcc} library enables you to use TCC as a backend for +dynamic code generation. + +Read the @file{libtcc.h} to have an overview of the API. Read +@file{libtcc_test.c} to have a very simple example. + +The idea consists in giving a C string containing the program you want +to compile directly to @code{libtcc}. Then you can access to any global +symbol (function or variable) defined. + +@chapter Developer's guide + +This chapter gives some hints to understand how TCC works. You can skip +it if you do not intend to modify the TCC code. + +@section File reading + +The @code{BufferedFile} structure contains the context needed to read a +file, including the current line number. @code{tcc_open()} opens a new +file and @code{tcc_close()} closes it. @code{inp()} returns the next +character. + +@section Lexer + +@code{next()} reads the next token in the current +file. @code{next_nomacro()} reads the next token without macro +expansion. + +@code{tok} contains the current token (see @code{TOK_xxx}) +constants. Identifiers and keywords are also keywords. @code{tokc} +contains additional infos about the token (for example a constant value +if number or string token). + +@section Parser + +The parser is hardcoded (yacc is not necessary). It does only one pass, +except: + +@itemize + +@item For initialized arrays with unknown size, a first pass +is done to count the number of elements. + +@item For architectures where arguments are evaluated in +reverse order, a first pass is done to reverse the argument order. + +@end itemize + +@section Types + +The types are stored in a single 'int' variable. It was choosen in the +first stages of development when tcc was much simpler. Now, it may not +be the best solution. + +@example +#define VT_INT 0 /* integer type */ +#define VT_BYTE 1 /* signed byte type */ +#define VT_SHORT 2 /* short type */ +#define VT_VOID 3 /* void type */ +#define VT_PTR 4 /* pointer */ +#define VT_ENUM 5 /* enum definition */ +#define VT_FUNC 6 /* function type */ +#define VT_STRUCT 7 /* struct/union definition */ +#define VT_FLOAT 8 /* IEEE float */ +#define VT_DOUBLE 9 /* IEEE double */ +#define VT_LDOUBLE 10 /* IEEE long double */ +#define VT_BOOL 11 /* ISOC99 boolean type */ +#define VT_LLONG 12 /* 64 bit integer */ +#define VT_LONG 13 /* long integer (NEVER USED as type, only + during parsing) */ +#define VT_BTYPE 0x000f /* mask for basic type */ +#define VT_UNSIGNED 0x0010 /* unsigned type */ +#define VT_ARRAY 0x0020 /* array type (also has VT_PTR) */ +#define VT_BITFIELD 0x0040 /* bitfield modifier */ + +#define VT_STRUCT_SHIFT 16 /* structure/enum name shift (16 bits left) */ +@end example + +When a reference to another type is needed (for pointers, functions and +structures), the @code{32 - VT_STRUCT_SHIFT} high order bits are used to +store an identifier reference. + +The @code{VT_UNSIGNED} flag can be set for chars, shorts, ints and long +longs. + +Arrays are considered as pointers @code{VT_PTR} with the flag +@code{VT_ARRAY} set. + +The @code{VT_BITFIELD} flag can be set for chars, shorts, ints and long +longs. If it is set, then the bitfield position is stored from bits +VT_STRUCT_SHIFT to VT_STRUCT_SHIFT + 5 and the bit field size is stored +from bits VT_STRUCT_SHIFT + 6 to VT_STRUCT_SHIFT + 11. + +@code{VT_LONG} is never used except during parsing. + +During parsing, the storage of an object is also stored in the type +integer: + +@example +#define VT_EXTERN 0x00000080 /* extern definition */ +#define VT_STATIC 0x00000100 /* static variable */ +#define VT_TYPEDEF 0x00000200 /* typedef definition */ +@end example + +@section Symbols + +All symbols are stored in hashed symbol stacks. Each symbol stack +contains @code{Sym} structures. + +@code{Sym.v} contains the symbol name (remember +an idenfier is also a token, so a string is never necessary to store +it). @code{Sym.t} gives the type of the symbol. @code{Sym.r} is usually +the register in which the corresponding variable is stored. @code{Sym.c} is +usually a constant associated to the symbol. + +Four main symbol stacks are defined: + +@table @code + +@item define_stack +for the macros (@code{#define}s). + +@item global_stack +for the global variables, functions and types. + +@item local_stack +for the local variables, functions and types. + +@item global_label_stack +for the local labels (for @code{goto}). + +@item label_stack +for GCC block local labels (see the @code{__label__} keyword). + +@end table + +@code{sym_push()} is used to add a new symbol in the local symbol +stack. If no local symbol stack is active, it is added in the global +symbol stack. + +@code{sym_pop(st,b)} pops symbols from the symbol stack @var{st} until +the symbol @var{b} is on the top of stack. If @var{b} is NULL, the stack +is emptied. + +@code{sym_find(v)} return the symbol associated to the identifier +@var{v}. The local stack is searched first from top to bottom, then the +global stack. + +@section Sections + +The generated code and datas are written in sections. The structure +@code{Section} contains all the necessary information for a given +section. @code{new_section()} creates a new section. ELF file semantics +is assumed for each section. + +The following sections are predefined: + +@table @code + +@item text_section +is the section containing the generated code. @var{ind} contains the +current position in the code section. + +@item data_section +contains initialized data + +@item bss_section +contains uninitialized data + +@item bounds_section +@itemx lbounds_section +are used when bound checking is activated + +@item stab_section +@itemx stabstr_section +are used when debugging is actived to store debug information + +@item symtab_section +@itemx strtab_section +contain the exported symbols (currently only used for debugging). + +@end table + +@section Code generation +@cindex code generation + +@subsection Introduction + +The TCC code generator directly generates linked binary code in one +pass. It is rather unusual these days (see gcc for example which +generates text assembly), but it can be very fast and surprisingly +little complicated. + +The TCC code generator is register based. Optimization is only done at +the expression level. No intermediate representation of expression is +kept except the current values stored in the @emph{value stack}. + +On x86, three temporary registers are used. When more registers are +needed, one register is spilled into a new temporary variable on the stack. + +@subsection The value stack +@cindex value stack, introduction + +When an expression is parsed, its value is pushed on the value stack +(@var{vstack}). The top of the value stack is @var{vtop}. Each value +stack entry is the structure @code{SValue}. + +@code{SValue.t} is the type. @code{SValue.r} indicates how the value is +currently stored in the generated code. It is usually a CPU register +index (@code{REG_xxx} constants), but additional values and flags are +defined: + +@example +#define VT_CONST 0x00f0 +#define VT_LLOCAL 0x00f1 +#define VT_LOCAL 0x00f2 +#define VT_CMP 0x00f3 +#define VT_JMP 0x00f4 +#define VT_JMPI 0x00f5 +#define VT_LVAL 0x0100 +#define VT_SYM 0x0200 +#define VT_MUSTCAST 0x0400 +#define VT_MUSTBOUND 0x0800 +#define VT_BOUNDED 0x8000 +#define VT_LVAL_BYTE 0x1000 +#define VT_LVAL_SHORT 0x2000 +#define VT_LVAL_UNSIGNED 0x4000 +#define VT_LVAL_TYPE (VT_LVAL_BYTE | VT_LVAL_SHORT | VT_LVAL_UNSIGNED) +@end example + +@table @code + +@item VT_CONST +indicates that the value is a constant. It is stored in the union +@code{SValue.c}, depending on its type. + +@item VT_LOCAL +indicates a local variable pointer at offset @code{SValue.c.i} in the +stack. + +@item VT_CMP +indicates that the value is actually stored in the CPU flags (i.e. the +value is the consequence of a test). The value is either 0 or 1. The +actual CPU flags used is indicated in @code{SValue.c.i}. + +If any code is generated which destroys the CPU flags, this value MUST be +put in a normal register. + +@item VT_JMP +@itemx VT_JMPI +indicates that the value is the consequence of a conditional jump. For VT_JMP, +it is 1 if the jump is taken, 0 otherwise. For VT_JMPI it is inverted. + +These values are used to compile the @code{||} and @code{&&} logical +operators. + +If any code is generated, this value MUST be put in a normal +register. Otherwise, the generated code won't be executed if the jump is +taken. + +@item VT_LVAL +is a flag indicating that the value is actually an lvalue (left value of +an assignment). It means that the value stored is actually a pointer to +the wanted value. + +Understanding the use @code{VT_LVAL} is very important if you want to +understand how TCC works. + +@item VT_LVAL_BYTE +@itemx VT_LVAL_SHORT +@itemx VT_LVAL_UNSIGNED +if the lvalue has an integer type, then these flags give its real +type. The type alone is not enough in case of cast optimisations. + +@item VT_LLOCAL +is a saved lvalue on the stack. @code{VT_LLOCAL} should be eliminated +ASAP because its semantics are rather complicated. + +@item VT_MUSTCAST +indicates that a cast to the value type must be performed if the value +is used (lazy casting). + +@item VT_SYM +indicates that the symbol @code{SValue.sym} must be added to the constant. + +@item VT_MUSTBOUND +@itemx VT_BOUNDED +are only used for optional bound checking. + +@end table + +@subsection Manipulating the value stack +@cindex value stack + +@code{vsetc()} and @code{vset()} pushes a new value on the value +stack. If the previous @var{vtop} was stored in a very unsafe place(for +example in the CPU flags), then some code is generated to put the +previous @var{vtop} in a safe storage. + +@code{vpop()} pops @var{vtop}. In some cases, it also generates cleanup +code (for example if stacked floating point registers are used as on +x86). + +The @code{gv(rc)} function generates code to evaluate @var{vtop} (the +top value of the stack) into registers. @var{rc} selects in which +register class the value should be put. @code{gv()} is the @emph{most +important function} of the code generator. + +@code{gv2()} is the same as @code{gv()} but for the top two stack +entries. + +@subsection CPU dependent code generation +@cindex CPU dependent +See the @file{i386-gen.c} file to have an example. + +@table @code + +@item load() +must generate the code needed to load a stack value into a register. + +@item store() +must generate the code needed to store a register into a stack value +lvalue. + +@item gfunc_start() +@itemx gfunc_param() +@itemx gfunc_call() +should generate a function call + +@item gfunc_prolog() +@itemx gfunc_epilog() +should generate a function prolog/epilog. + +@item gen_opi(op) +must generate the binary integer operation @var{op} on the two top +entries of the stack which are guaranted to contain integer types. + +The result value should be put on the stack. + +@item gen_opf(op) +same as @code{gen_opi()} for floating point operations. The two top +entries of the stack are guaranted to contain floating point values of +same types. + +@item gen_cvt_itof() +integer to floating point conversion. + +@item gen_cvt_ftoi() +floating point to integer conversion. + +@item gen_cvt_ftof() +floating point to floating point of different size conversion. + +@item gen_bounded_ptr_add() +@item gen_bounded_ptr_deref() +are only used for bounds checking. + +@end table + +@section Optimizations done +@cindex optimizations +@cindex constant propagation +@cindex strength reduction +@cindex comparison operators +@cindex caching processor flags +@cindex flags, caching +@cindex jump optimization +Constant propagation is done for all operations. Multiplications and +divisions are optimized to shifts when appropriate. Comparison +operators are optimized by maintaining a special cache for the +processor flags. &&, || and ! are optimized by maintaining a special +'jump target' value. No other jump optimization is currently performed +because it would require to store the code in a more abstract fashion. + +@unnumbered Concept Index +@printindex cp + +@bye + +@c Local variables: +@c fill-column: 78 +@c texinfo-column-for-description: 32 +@c End: diff --git a/tcc.1 b/tcc.1 new file mode 100644 index 0000000..0d303a1 --- /dev/null +++ b/tcc.1 @@ -0,0 +1,379 @@ +.\" Automatically generated by Pod::Man v1.34, Pod::Parser v1.13 +.\" +.\" Standard preamble: +.\" ======================================================================== +.de Sh \" Subsection heading +.br +.if t .Sp +.ne 5 +.PP +\fB\\$1\fR +.PP +.. +.de Sp \" Vertical space (when we can't use .PP) +.if t .sp .5v +.if n .sp +.. +.de Vb \" Begin verbatim text +.ft CW +.nf +.ne \\$1 +.. +.de Ve \" End verbatim text +.ft R +.fi +.. +.\" Set up some character translations and predefined strings. \*(-- will +.\" give an unbreakable dash, \*(PI will give pi, \*(L" will give a left +.\" double quote, and \*(R" will give a right double quote. | will give a +.\" real vertical bar. \*(C+ will give a nicer C++. Capital omega is used to +.\" do unbreakable dashes and therefore won't be available. \*(C` and \*(C' +.\" expand to `' in nroff, nothing in troff, for use with C<>. +.tr \(*W-|\(bv\*(Tr +.ds C+ C\v'-.1v'\h'-1p'\s-2+\h'-1p'+\s0\v'.1v'\h'-1p' +.ie n \{\ +. ds -- \(*W- +. ds PI pi +. if (\n(.H=4u)&(1m=24u) .ds -- \(*W\h'-12u'\(*W\h'-12u'-\" diablo 10 pitch +. if (\n(.H=4u)&(1m=20u) .ds -- \(*W\h'-12u'\(*W\h'-8u'-\" diablo 12 pitch +. ds L" "" +. ds R" "" +. ds C` "" +. ds C' "" +'br\} +.el\{\ +. ds -- \|\(em\| +. ds PI \(*p +. ds L" `` +. ds R" '' +'br\} +.\" +.\" If the F register is turned on, we'll generate index entries on stderr for +.\" titles (.TH), headers (.SH), subsections (.Sh), items (.Ip), and index +.\" entries marked with X<> in POD. Of course, you'll have to process the +.\" output yourself in some meaningful fashion. +.if \nF \{\ +. de IX +. tm Index:\\$1\t\\n%\t"\\$2" +.. +. nr % 0 +. rr F +.\} +.\" +.\" For nroff, turn off justification. Always turn off hyphenation; it makes +.\" way too many mistakes in technical documents. +.hy 0 +.if n .na +.\" +.\" Accent mark definitions (@(#)ms.acc 1.5 88/02/08 SMI; from UCB 4.2). +.\" Fear. Run. Save yourself. No user-serviceable parts. +. \" fudge factors for nroff and troff +.if n \{\ +. ds #H 0 +. ds #V .8m +. ds #F .3m +. ds #[ \f1 +. ds #] \fP +.\} +.if t \{\ +. ds #H ((1u-(\\\\n(.fu%2u))*.13m) +. ds #V .6m +. ds #F 0 +. ds #[ \& +. ds #] \& +.\} +. \" simple accents for nroff and troff +.if n \{\ +. ds ' \& +. ds ` \& +. ds ^ \& +. ds , \& +. ds ~ ~ +. ds / +.\} +.if t \{\ +. ds ' \\k:\h'-(\\n(.wu*8/10-\*(#H)'\'\h"|\\n:u" +. ds ` \\k:\h'-(\\n(.wu*8/10-\*(#H)'\`\h'|\\n:u' +. ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'^\h'|\\n:u' +. ds , \\k:\h'-(\\n(.wu*8/10)',\h'|\\n:u' +. ds ~ \\k:\h'-(\\n(.wu-\*(#H-.1m)'~\h'|\\n:u' +. ds / \\k:\h'-(\\n(.wu*8/10-\*(#H)'\z\(sl\h'|\\n:u' +.\} +. \" troff and (daisy-wheel) nroff accents +.ds : \\k:\h'-(\\n(.wu*8/10-\*(#H+.1m+\*(#F)'\v'-\*(#V'\z.\h'.2m+\*(#F'.\h'|\\n:u'\v'\*(#V' +.ds 8 \h'\*(#H'\(*b\h'-\*(#H' +.ds o \\k:\h'-(\\n(.wu+\w'\(de'u-\*(#H)/2u'\v'-.3n'\*(#[\z\(de\v'.3n'\h'|\\n:u'\*(#] +.ds d- \h'\*(#H'\(pd\h'-\w'~'u'\v'-.25m'\f2\(hy\fP\v'.25m'\h'-\*(#H' +.ds D- D\\k:\h'-\w'D'u'\v'-.11m'\z\(hy\v'.11m'\h'|\\n:u' +.ds th \*(#[\v'.3m'\s+1I\s-1\v'-.3m'\h'-(\w'I'u*2/3)'\s-1o\s+1\*(#] +.ds Th \*(#[\s+2I\s-2\h'-\w'I'u*3/5'\v'-.3m'o\v'.3m'\*(#] +.ds ae a\h'-(\w'a'u*4/10)'e +.ds Ae A\h'-(\w'A'u*4/10)'E +. \" corrections for vroff +.if v .ds ~ \\k:\h'-(\\n(.wu*9/10-\*(#H)'\s-2\u~\d\s+2\h'|\\n:u' +.if v .ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'\v'-.4m'^\v'.4m'\h'|\\n:u' +. \" for low resolution devices (crt and lpr) +.if \n(.H>23 .if \n(.V>19 \ +\{\ +. ds : e +. ds 8 ss +. ds o a +. ds d- d\h'-1'\(ga +. ds D- D\h'-1'\(hy +. ds th \o'bp' +. ds Th \o'LP' +. ds ae ae +. ds Ae AE +.\} +.rm #[ #] #H #V #F C +.\" ======================================================================== +.\" +.IX Title "TCC 1" +.TH TCC 1 "2005-06-18" " " " " +.SH "NAME" +tcc \- Tiny C Compiler +.SH "SYNOPSIS" +.IX Header "SYNOPSIS" +usage: tcc [options] [\fIinfile1\fR \fIinfile2\fR...] [\fB\-run\fR \fIinfile\fR \fIargs\fR...] +.SH "DESCRIPTION" +.IX Header "DESCRIPTION" +\&\s-1TCC\s0 options are a very much like gcc options. The main difference is that \s-1TCC\s0 +can also execute directly the resulting program and give it runtime +arguments. +.PP +Here are some examples to understand the logic: +.ie n .IP """\f(CBtcc \-run a.c\f(CW""" 4 +.el .IP "\f(CW\f(CBtcc \-run a.c\f(CW\fR" 4 +.IX Item "tcc -run a.c" +Compile \fIa.c\fR and execute it directly +.ie n .IP """\f(CBtcc \-run a.c arg1\f(CW""" 4 +.el .IP "\f(CW\f(CBtcc \-run a.c arg1\f(CW\fR" 4 +.IX Item "tcc -run a.c arg1" +Compile a.c and execute it directly. arg1 is given as first argument to +the \f(CW\*(C`main()\*(C'\fR of a.c. +.ie n .IP """\f(CBtcc a.c \-run b.c arg1\f(CW""" 4 +.el .IP "\f(CW\f(CBtcc a.c \-run b.c arg1\f(CW\fR" 4 +.IX Item "tcc a.c -run b.c arg1" +Compile \fIa.c\fR and \fIb.c\fR, link them together and execute them. arg1 is given +as first argument to the \f(CW\*(C`main()\*(C'\fR of the resulting program. Because +multiple C files are specified, \fB\-\-\fR are necessary to clearly separate the +program arguments from the \s-1TCC\s0 options. +.ie n .IP """\f(CBtcc \-o myprog a.c b.c\f(CW""" 4 +.el .IP "\f(CW\f(CBtcc \-o myprog a.c b.c\f(CW\fR" 4 +.IX Item "tcc -o myprog a.c b.c" +Compile \fIa.c\fR and \fIb.c\fR, link them and generate the executable \fImyprog\fR. +.ie n .IP """\f(CBtcc \-o myprog a.o b.o\f(CW""" 4 +.el .IP "\f(CW\f(CBtcc \-o myprog a.o b.o\f(CW\fR" 4 +.IX Item "tcc -o myprog a.o b.o" +link \fIa.o\fR and \fIb.o\fR together and generate the executable \fImyprog\fR. +.ie n .IP """\f(CBtcc \-c a.c\f(CW""" 4 +.el .IP "\f(CW\f(CBtcc \-c a.c\f(CW\fR" 4 +.IX Item "tcc -c a.c" +Compile \fIa.c\fR and generate object file \fIa.o\fR. +.ie n .IP """\f(CBtcc \-c asmfile.S\f(CW""" 4 +.el .IP "\f(CW\f(CBtcc \-c asmfile.S\f(CW\fR" 4 +.IX Item "tcc -c asmfile.S" +Preprocess with C preprocess and assemble \fIasmfile.S\fR and generate +object file \fIasmfile.o\fR. +.ie n .IP """\f(CBtcc \-c asmfile.s\f(CW""" 4 +.el .IP "\f(CW\f(CBtcc \-c asmfile.s\f(CW\fR" 4 +.IX Item "tcc -c asmfile.s" +Assemble (but not preprocess) \fIasmfile.s\fR and generate object file +\&\fIasmfile.o\fR. +.ie n .IP """\f(CBtcc \-r \-o ab.o a.c b.c\f(CW""" 4 +.el .IP "\f(CW\f(CBtcc \-r \-o ab.o a.c b.c\f(CW\fR" 4 +.IX Item "tcc -r -o ab.o a.c b.c" +Compile \fIa.c\fR and \fIb.c\fR, link them together and generate the object file \fIab.o\fR. +.PP +Scripting: +.PP +\&\s-1TCC\s0 can be invoked from \fIscripts\fR, just as shell scripts. You just +need to add \f(CW\*(C`#!/usr/local/bin/tcc \-run\*(C'\fR at the start of your C source: +.PP +.Vb 2 +\& #!/usr/local/bin/tcc -run +\& #include +.Ve +.PP +.Vb 5 +\& int main() +\& { +\& printf("Hello World\en"); +\& return 0; +\& } +.Ve +.SH "OPTIONS" +.IX Header "OPTIONS" +.IP "\fB\-v\fR" 4 +.IX Item "-v" +Display current \s-1TCC\s0 version. +.IP "\fB\-c\fR" 4 +.IX Item "-c" +Generate an object file (\fB\-o\fR option must also be given). +.IP "\fB\-o outfile\fR" 4 +.IX Item "-o outfile" +Put object file, executable, or dll into output file \fIoutfile\fR. +.IP "\fB\-Bdir\fR" 4 +.IX Item "-Bdir" +Set the path where the tcc internal libraries can be found (default is +\&\fIPREFIX/lib/tcc\fR). +.IP "\fB\-bench\fR" 4 +.IX Item "-bench" +Output compilation statistics. +.IP "\fB\-run source [args...]\fR" 4 +.IX Item "-run source [args...]" +Compile file \fIsource\fR and run it with the command line arguments +\&\fIargs\fR. In order to be able to give more than one argument to a +script, several \s-1TCC\s0 options can be given \fIafter\fR the +\&\fB\-run\fR option, separated by spaces. Example: +.Sp +.Vb 1 +\& tcc "-run -L/usr/X11R6/lib -lX11" ex4.c +.Ve +.Sp +In a script, it gives the following header: +.Sp +.Vb 6 +\& #!/usr/local/bin/tcc -run -L/usr/X11R6/lib -lX11 +\& #include +\& int main(int argc, char **argv) +\& { +\& ... +\& } +.Ve +.PP +Preprocessor options: +.IP "\fB\-Idir\fR" 4 +.IX Item "-Idir" +Specify an additional include path. Include paths are searched in the +order they are specified. +.Sp +System include paths are always searched after. The default system +include paths are: \fI/usr/local/include\fR, \fI/usr/include\fR +and \fIPREFIX/lib/tcc/include\fR. (\fI\s-1PREFIX\s0\fR is usually +\&\fI/usr\fR or \fI/usr/local\fR). +.IP "\fB\-Dsym[=val]\fR" 4 +.IX Item "-Dsym[=val]" +Define preprocessor symbol \fBsym\fR to +val. If val is not present, its value is \fB1\fR. Function-like macros can +also be defined: \fB\-DF(a)=a+1\fR +.IP "\fB\-Usym\fR" 4 +.IX Item "-Usym" +Undefine preprocessor symbol \fBsym\fR. +.PP +Compilation flags: +.PP +Note: each of the following warning options has a negative form beginning with +\&\fB\-fno\-\fR. +.IP "\fB\-funsigned\-char\fR" 4 +.IX Item "-funsigned-char" +Let the \f(CW\*(C`char\*(C'\fR type be unsigned. +.IP "\fB\-fsigned\-char\fR" 4 +.IX Item "-fsigned-char" +Let the \f(CW\*(C`char\*(C'\fR type be signed. +.IP "\fB\-fno\-common\fR" 4 +.IX Item "-fno-common" +Do not generate common symbols for uninitialized data. +.IP "\fB\-fleading\-underscore\fR" 4 +.IX Item "-fleading-underscore" +Add a leading underscore at the beginning of each C symbol. +.PP +Warning options: +.IP "\fB\-w\fR" 4 +.IX Item "-w" +Disable all warnings. +.PP +Note: each of the following warning options has a negative form beginning with +\&\fB\-Wno\-\fR. +.IP "\fB\-Wimplicit\-function\-declaration\fR" 4 +.IX Item "-Wimplicit-function-declaration" +Warn about implicit function declaration. +.IP "\fB\-Wunsupported\fR" 4 +.IX Item "-Wunsupported" +Warn about unsupported \s-1GCC\s0 features that are ignored by \s-1TCC\s0. +.IP "\fB\-Wwrite\-strings\fR" 4 +.IX Item "-Wwrite-strings" +Make string constants be of type \f(CW\*(C`const char *\*(C'\fR instead of \f(CW\*(C`char +*\*(C'\fR. +.IP "\fB\-Werror\fR" 4 +.IX Item "-Werror" +Abort compilation if warnings are issued. +.IP "\fB\-Wall\fR" 4 +.IX Item "-Wall" +Activate all warnings, except \fB\-Werror\fR, \fB\-Wunusupported\fR and +\&\fB\-Wwrite\-strings\fR. +.PP +Linker options: +.IP "\fB\-Ldir\fR" 4 +.IX Item "-Ldir" +Specify an additional static library path for the \fB\-l\fR option. The +default library paths are \fI/usr/local/lib\fR, \fI/usr/lib\fR and \fI/lib\fR. +.IP "\fB\-lxxx\fR" 4 +.IX Item "-lxxx" +Link your program with dynamic library libxxx.so or static library +libxxx.a. The library is searched in the paths specified by the +\&\fB\-L\fR option. +.IP "\fB\-shared\fR" 4 +.IX Item "-shared" +Generate a shared library instead of an executable (\fB\-o\fR option +must also be given). +.IP "\fB\-static\fR" 4 +.IX Item "-static" +Generate a statically linked executable (default is a shared linked +executable) (\fB\-o\fR option must also be given). +.IP "\fB\-rdynamic\fR" 4 +.IX Item "-rdynamic" +Export global symbols to the dynamic linker. It is useful when a library +opened with \f(CW\*(C`dlopen()\*(C'\fR needs to access executable symbols. +.IP "\fB\-r\fR" 4 +.IX Item "-r" +Generate an object file combining all input files (\fB\-o\fR option must +also be given). +.IP "\fB\-Wl,\-Ttext,address\fR" 4 +.IX Item "-Wl,-Ttext,address" +Set the start of the .text section to \fIaddress\fR. +.IP "\fB\-Wl,\-\-oformat,fmt\fR" 4 +.IX Item "-Wl,--oformat,fmt" +Use \fIfmt\fR as output format. The supported output formats are: +.RS 4 +.ie n .IP """elf32\-i386""" 4 +.el .IP "\f(CWelf32\-i386\fR" 4 +.IX Item "elf32-i386" +\&\s-1ELF\s0 output format (default) +.ie n .IP """binary""" 4 +.el .IP "\f(CWbinary\fR" 4 +.IX Item "binary" +Binary image (only for executable output) +.ie n .IP """coff""" 4 +.el .IP "\f(CWcoff\fR" 4 +.IX Item "coff" +\&\s-1COFF\s0 output format (only for executable output for TMS320C67xx target) +.RE +.RS 4 +.RE +.PP +Debugger options: +.IP "\fB\-g\fR" 4 +.IX Item "-g" +Generate run time debug information so that you get clear run time +error messages: \f(CW\*(C` test.c:68: in function 'test5()': dereferencing +invalid pointer\*(C'\fR instead of the laconic \f(CW\*(C`Segmentation +fault\*(C'\fR. +.IP "\fB\-b\fR" 4 +.IX Item "-b" +Generate additional support code to check +memory allocations and array/pointer bounds. \fB\-g\fR is implied. Note +that the generated code is slower and bigger in this case. +.IP "\fB\-bt N\fR" 4 +.IX Item "-bt N" +Display N callers in stack traces. This is useful with \fB\-g\fR or +\&\fB\-b\fR. +.PP +Note: \s-1GCC\s0 options \fB\-Ox\fR, \fB\-fx\fR and \fB\-mx\fR are +ignored. +.SH "SEE ALSO" +.IX Header "SEE ALSO" +\&\fIgcc\fR\|(1) +.SH "AUTHOR" +.IX Header "AUTHOR" +Fabrice Bellard diff --git a/tcc.c b/tcc.c new file mode 100644 index 0000000..b35874a --- /dev/null +++ b/tcc.c @@ -0,0 +1,10672 @@ +/* + * TCC - Tiny C Compiler + * + * Copyright (c) 2001-2004 Fabrice Bellard + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ +#define _GNU_SOURCE +#include "config.h" + +#ifdef CONFIG_TCCBOOT + +#include "tccboot.h" +#define CONFIG_TCC_STATIC + +#else + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#ifdef WIN32 +#include +#endif +#ifndef WIN32 +#include +#include +#endif + +#endif /* !CONFIG_TCCBOOT */ + +#include "elf.h" +#include "stab.h" + +#ifndef O_BINARY +#define O_BINARY 0 +#endif + +#include "libtcc.h" + +/* parser debug */ +//#define PARSE_DEBUG +/* preprocessor debug */ +//#define PP_DEBUG +/* include file debug */ +//#define INC_DEBUG + +//#define MEM_DEBUG + +/* assembler debug */ +//#define ASM_DEBUG + +/* target selection */ +//#define TCC_TARGET_I386 /* i386 code generator */ +//#define TCC_TARGET_ARM /* ARMv4 code generator */ +//#define TCC_TARGET_C67 /* TMS320C67xx code generator */ + +/* default target is I386 */ +#if !defined(TCC_TARGET_I386) && !defined(TCC_TARGET_ARM) && \ + !defined(TCC_TARGET_C67) && !defined(TCC_TARGET_816) +#define TCC_TARGET_I386 +#endif + +#if !defined(WIN32) && !defined(TCC_UCLIBC) && !defined(TCC_TARGET_ARM) && \ + !defined(TCC_TARGET_C67) && !defined(TCC_TARGET_816) +#define CONFIG_TCC_BCHECK /* enable bound checking code */ +#endif + +#if defined(WIN32) && !defined(TCC_TARGET_PE) +#define CONFIG_TCC_STATIC +#endif + +/* define it to include assembler support */ +#if !defined(TCC_TARGET_ARM) && !defined(TCC_TARGET_C67) && !defined(TCC_TARGET_816) +#define CONFIG_TCC_ASM +#endif + +/* object format selection */ +#if defined(TCC_TARGET_C67) +#define TCC_TARGET_COFF +#endif + +#define FALSE 0 +#define false 0 +#define TRUE 1 +#define true 1 +typedef int BOOL; + +/* path to find crt1.o, crti.o and crtn.o. Only needed when generating + executables or dlls */ +#define CONFIG_TCC_CRT_PREFIX "/usr/lib" + +#define INCLUDE_STACK_SIZE 32 +#define IFDEF_STACK_SIZE 64 +#define VSTACK_SIZE 256 +#define STRING_MAX_SIZE 1024 +#define PACK_STACK_SIZE 8 + +#define TOK_HASH_SIZE 8192 /* must be a power of two */ +#define TOK_ALLOC_INCR 512 /* must be a power of two */ +#define TOK_MAX_SIZE 4 /* token max size in int unit when stored in string */ + +/* token symbol management */ +typedef struct TokenSym { + struct TokenSym *hash_next; + struct Sym *sym_define; /* direct pointer to define */ + struct Sym *sym_label; /* direct pointer to label */ + struct Sym *sym_struct; /* direct pointer to structure */ + struct Sym *sym_identifier; /* direct pointer to identifier */ + int tok; /* token number */ + int len; + char str[1]; +} TokenSym; + +typedef struct CString { + int size; /* size in bytes */ + void *data; /* either 'char *' or 'int *' */ + int size_allocated; + void *data_allocated; /* if non NULL, data has been malloced */ +} CString; + +/* type definition */ +typedef struct CType { + int t; + struct Sym *ref; + int extra; +} CType; + +/* constant value */ +typedef union CValue { + long double ld; + double d; + float f; + int i; + unsigned int ui; + unsigned int ul; /* address (should be unsigned long on 64 bit cpu) */ + long long ll; + unsigned long long ull; + struct CString *cstr; + void *ptr; + int tab[1]; +} CValue; + +/* value on stack */ +typedef struct SValue { + CType type; /* type */ + unsigned short r; /* register + flags */ + unsigned short r2; /* second register, used for 'long long' + type. If not used, set to VT_CONST */ + CValue c; /* constant, if VT_CONST */ + struct Sym *sym; /* symbol, if (VT_SYM | VT_CONST) */ +} SValue; + +/* symbol management */ +typedef struct Sym { + int v; /* symbol token */ + long r; /* associated register */ + long c; /* associated number */ + CType type; /* associated type */ + struct Sym *next; /* next related symbol */ + struct Sym *prev; /* prev symbol in stack */ + struct Sym *prev_tok; /* previous symbol for this token */ +} Sym; + +/* section definition */ +/* XXX: use directly ELF structure for parameters ? */ +/* special flag to indicate that the section should not be linked to + the other ones */ +#define SHF_PRIVATE 0x80000000 + +typedef struct Section { + unsigned long data_offset; /* current data offset */ + unsigned char *data; /* section data */ + unsigned long data_allocated; /* used for realloc() handling */ + int sh_name; /* elf section name (only used during output) */ + int sh_num; /* elf section number */ + int sh_type; /* elf section type */ + int sh_flags; /* elf section flags */ + int sh_info; /* elf section info */ + int sh_addralign; /* elf section alignment */ + int sh_entsize; /* elf entry size */ + unsigned long sh_size; /* section size (only used during output) */ + unsigned long sh_addr; /* address at which the section is relocated */ + unsigned long sh_offset; /* address at which the section is relocated */ + int nb_hashed_syms; /* used to resize the hash table */ + struct Section *link; /* link to another section */ + struct Section *reloc; /* corresponding section for relocation, if any */ + struct Section *hash; /* hash table for symbols */ + struct Section *next; + char name[1]; /* section name */ +} Section; + +typedef struct DLLReference { + int level; + char name[1]; +} DLLReference; + +/* GNUC attribute definition */ +typedef struct AttributeDef { + int aligned; + int packed; + Section *section; + unsigned char func_call; /* FUNC_CDECL, FUNC_STDCALL, FUNC_FASTCALLx */ + unsigned char dllexport; +} AttributeDef; + +#define SYM_STRUCT 0x40000000 /* struct/union/enum symbol space */ +#define SYM_FIELD 0x20000000 /* struct/union field symbol space */ +#define SYM_FIRST_ANOM 0x10000000 /* first anonymous sym */ + +/* stored in 'Sym.c' field */ +#define FUNC_NEW 1 /* ansi function prototype */ +#define FUNC_OLD 2 /* old function prototype */ +#define FUNC_ELLIPSIS 3 /* ansi function prototype with ... */ + +/* stored in 'Sym.r' field */ +#define FUNC_CDECL 0 /* standard c call */ +#define FUNC_STDCALL 1 /* pascal c call */ +#define FUNC_FASTCALL1 2 /* first param in %eax */ +#define FUNC_FASTCALL2 3 /* first parameters in %eax, %edx */ +#define FUNC_FASTCALL3 4 /* first parameter in %eax, %edx, %ecx */ + +/* field 'Sym.t' for macros */ +#define MACRO_OBJ 0 /* object like macro */ +#define MACRO_FUNC 1 /* function like macro */ + +/* field 'Sym.r' for C labels */ +#define LABEL_DEFINED 0 /* label is defined */ +#define LABEL_FORWARD 1 /* label is forward defined */ +#define LABEL_DECLARED 2 /* label is declared but never used */ + +/* type_decl() types */ +#define TYPE_ABSTRACT 1 /* type without variable */ +#define TYPE_DIRECT 2 /* type with variable */ + +#define IO_BUF_SIZE 8192 + +typedef struct BufferedFile { + uint8_t *buf_ptr; + uint8_t *buf_end; + int fd; + int line_num; /* current line number - here to simplify code */ + int ifndef_macro; /* #ifndef macro / #endif search */ + int ifndef_macro_saved; /* saved ifndef_macro */ + int *ifdef_stack_ptr; /* ifdef_stack value at the start of the file */ + char inc_type; /* type of include */ + char inc_filename[512]; /* filename specified by the user */ + char filename[1024]; /* current filename - here to simplify code */ + unsigned char buffer[IO_BUF_SIZE + 1]; /* extra size for CH_EOB char */ +} BufferedFile; + +#define CH_EOB '\\' /* end of buffer or '\0' char in file */ +#define CH_EOF (-1) /* end of file */ + +/* parsing state (used to save parser state to reparse part of the + source several times) */ +typedef struct ParseState { + int *macro_ptr; + int line_num; + int tok; + CValue tokc; +} ParseState; + +/* used to record tokens */ +typedef struct TokenString { + int *str; + int len; + int allocated_len; + int last_line_num; +} TokenString; + +/* include file cache, used to find files faster and also to eliminate + inclusion if the include file is protected by #ifndef ... #endif */ +typedef struct CachedInclude { + int ifndef_macro; + int hash_next; /* -1 if none */ + char type; /* '"' or '>' to give include type */ + char filename[1]; /* path specified in #include */ +} CachedInclude; + +#define CACHED_INCLUDES_HASH_SIZE 512 + +/* parser */ +static struct BufferedFile *file; +static int ch, tok; +static CValue tokc; +static CString tokcstr; /* current parsed string, if any */ +/* additional informations about token */ +static int tok_flags; +#define TOK_FLAG_BOL 0x0001 /* beginning of line before */ +#define TOK_FLAG_BOF 0x0002 /* beginning of file before */ +#define TOK_FLAG_ENDIF 0x0004 /* a endif was found matching starting #ifdef */ + +static int *macro_ptr, *macro_ptr_allocated; +static int *unget_saved_macro_ptr; +static int unget_saved_buffer[TOK_MAX_SIZE + 1]; +static int unget_buffer_enabled; +static int parse_flags; +#define PARSE_FLAG_PREPROCESS 0x0001 /* activate preprocessing */ +#define PARSE_FLAG_TOK_NUM 0x0002 /* return numbers instead of TOK_PPNUM */ +#define PARSE_FLAG_LINEFEED 0x0004 /* line feed is returned as a + token. line feed is also + returned at eof */ +#define PARSE_FLAG_ASM_COMMENTS 0x0008 /* '#' can be used for line comment */ + +static Section *text_section, *data_section, *rodata_section, *bss_section; /* predefined sections */ +static Section *cur_text_section; /* current section where function code is + generated */ +#ifdef CONFIG_TCC_ASM +static Section *last_text_section; /* to handle .previous asm directive */ +#endif +/* bound check related sections */ +static Section *bounds_section; /* contains global data bound description */ +static Section *lbounds_section; /* contains local data bound description */ +/* symbol sections */ +static Section *symtab_section, *strtab_section; + +/* debug sections */ +static Section *stab_section, *stabstr_section; + +/* loc : local variable index + ind : output code index + rsym: return symbol + anon_sym: anonymous symbol index +*/ +static int rsym, anon_sym, ind, loc; +/* expression generation modifiers */ +static int const_wanted; /* true if constant wanted */ +static int nocode_wanted; /* true if no code generation wanted for an expression */ +static int global_expr; /* true if compound literals must be allocated + globally (used during initializers parsing */ +static CType func_vt; /* current function return type (used by return + instruction) */ +static int func_vc; +static int last_line_num, last_ind, func_ind; /* debug last line number and pc */ +static int tok_ident; +static TokenSym **table_ident; +static TokenSym *hash_ident[TOK_HASH_SIZE]; +static char token_buf[STRING_MAX_SIZE + 1]; +static char *funcname; +static Sym *global_stack, *local_stack; +static Sym *define_stack; +static Sym *global_label_stack, *local_label_stack; +/* symbol allocator */ +#define SYM_POOL_NB (8192 / sizeof(Sym)) +static Sym *sym_free_first; + +static SValue vstack[VSTACK_SIZE], *vtop; +/* some predefined types */ +static CType char_pointer_type, func_old_type, int_type, ptr_type; +/* true if isid(c) || isnum(c) */ +static unsigned char isidnum_table[256]; + +/* compile with debug symbol (and use them if error during execution) */ +static int do_debug = 0; + +/* compile with built-in memory and bounds checker */ +static int do_bounds_check = 0; + +/* display benchmark infos */ +#if !defined(LIBTCC) +static int do_bench = 0; +#endif +static int total_lines; +static int total_bytes; + +/* use GNU C extensions */ +static int gnu_ext = 1; + +/* use Tiny C extensions */ +static int tcc_ext = 1; + +/* max number of callers shown if error */ +static int num_callers = 6; + +/* XXX: get rid of this ASAP */ +static struct TCCState *tcc_state; + +/* give the path of the tcc libraries */ +static const char *tcc_lib_path = CONFIG_TCCDIR; + +struct TCCState { + int output_type; + + BufferedFile **include_stack_ptr; + int *ifdef_stack_ptr; + + /* include file handling */ + char **include_paths; + int nb_include_paths; + char **sysinclude_paths; + int nb_sysinclude_paths; + CachedInclude **cached_includes; + int nb_cached_includes; + + char **library_paths; + int nb_library_paths; + + /* array of all loaded dlls (including those referenced by loaded + dlls) */ + DLLReference **loaded_dlls; + int nb_loaded_dlls; + + /* sections */ + Section **sections; + int nb_sections; /* number of sections, including first dummy section */ + + /* got handling */ + Section *got; + Section *plt; + unsigned long *got_offsets; + int nb_got_offsets; + /* give the correspondance from symtab indexes to dynsym indexes */ + int *symtab_to_dynsym; + + /* temporary dynamic symbol sections (for dll loading) */ + Section *dynsymtab_section; + /* exported dynamic symbol section */ + Section *dynsym; + + int nostdinc; /* if true, no standard headers are added */ + int nostdlib; /* if true, no standard libraries are added */ + + int nocommon; /* if true, do not use common symbols for .bss data */ + + /* if true, static linking is performed */ + int static_link; + + /* if true, all symbols are exported */ + int rdynamic; + + /* if true, only link in referenced objects from archive */ + int alacarte_link; + + /* address of text section */ + unsigned long text_addr; + int has_text_addr; + + /* output format, see TCC_OUTPUT_FORMAT_xxx */ + int output_format; + + /* C language options */ + int char_is_unsigned; + int leading_underscore; + + /* warning switches */ + int warn_write_strings; + int warn_unsupported; + int warn_error; + int warn_none; + int warn_implicit_function_declaration; + + /* error handling */ + void *error_opaque; + void (*error_func)(void *opaque, const char *msg); + int error_set_jmp_enabled; + jmp_buf error_jmp_buf; + int nb_errors; + + /* tiny assembler state */ + Sym *asm_labels; + + /* see include_stack_ptr */ + BufferedFile *include_stack[INCLUDE_STACK_SIZE]; + + /* see ifdef_stack_ptr */ + int ifdef_stack[IFDEF_STACK_SIZE]; + + /* see cached_includes */ + int cached_includes_hash[CACHED_INCLUDES_HASH_SIZE]; + + /* pack stack */ + int pack_stack[PACK_STACK_SIZE]; + int *pack_stack_ptr; + + int optimize; +}; + +/* The current value can be: */ +#define VT_VALMASK 0x00ff +#define VT_CONST 0x00f0 /* constant in vc + (must be first non register value) */ +#define VT_LLOCAL 0x00f1 /* lvalue, offset on stack */ +#define VT_LOCAL 0x00f2 /* offset on stack */ +#define VT_CMP 0x00f3 /* the value is stored in processor flags (in vc) */ +#define VT_JMP 0x00f4 /* value is the consequence of jmp true (even) */ +#define VT_JMPI 0x00f5 /* value is the consequence of jmp false (odd) */ +#define VT_LVAL 0x0100 /* var is an lvalue */ +#define VT_SYM 0x0200 /* a symbol value is added */ +#define VT_MUSTCAST 0x0400 /* value must be casted to be correct (used for + char/short stored in integer registers) */ +#define VT_MUSTBOUND 0x0800 /* bound checking must be done before + dereferencing value */ +#define VT_BOUNDED 0x8000 /* value is bounded. The address of the + bounding function call point is in vc */ +#define VT_LVAL_BYTE 0x1000 /* lvalue is a byte */ +#define VT_LVAL_SHORT 0x2000 /* lvalue is a short */ +#define VT_LVAL_UNSIGNED 0x4000 /* lvalue is unsigned */ +#define VT_LVAL_TYPE (VT_LVAL_BYTE | VT_LVAL_SHORT | VT_LVAL_UNSIGNED) + +/* types */ +#define VT_INT 0 /* integer type */ +#define VT_BYTE 1 /* signed byte type */ +#define VT_SHORT 2 /* short type */ +#define VT_VOID 3 /* void type */ +#define VT_PTR 4 /* pointer */ +#define VT_ENUM 5 /* enum definition */ +#define VT_FUNC 6 /* function type */ +#define VT_STRUCT 7 /* struct/union definition */ +#define VT_FLOAT 8 /* IEEE float */ +#define VT_DOUBLE 9 /* IEEE double */ +#define VT_LDOUBLE 10 /* IEEE long double */ +#define VT_BOOL 11 /* ISOC99 boolean type */ +#define VT_LLONG 12 /* 64 bit integer */ +#define VT_LONG 13 /* long integer (NEVER USED as type, only + during parsing) */ +#define VT_BTYPE 0x000f /* mask for basic type */ +#define VT_UNSIGNED 0x0010 /* unsigned type */ +#define VT_ARRAY 0x0020 /* array type (also has VT_PTR) */ +#define VT_BITFIELD 0x0040 /* bitfield modifier */ +#define VT_CONSTANT 0x0800 /* const modifier */ +#define VT_VOLATILE 0x1000 /* volatile modifier */ +#define VT_SIGNED 0x2000 /* signed type */ + +/* storage */ +#define VT_EXTERN 0x00000080 /* extern definition */ +#define VT_STATIC 0x00000100 /* static variable */ +#define VT_TYPEDEF 0x00000200 /* typedef definition */ +#define VT_INLINE 0x00000400 /* inline definition */ +#define VT_STATICLOCAL 0x00004000 + +#define VT_STRUCT_SHIFT 16 /* shift for bitfield shift values */ + +/* type mask (except storage) */ +#define VT_STORAGE (VT_EXTERN | VT_STATIC | VT_TYPEDEF | VT_INLINE) +#define VT_TYPE (~(VT_STORAGE) & ~(VT_STATICLOCAL)) + +/* token values */ + +/* warning: the following compare tokens depend on i386 asm code */ +#define TOK_ULT 0x92 +#define TOK_UGE 0x93 +#define TOK_EQ 0x94 +#define TOK_NE 0x95 +#define TOK_ULE 0x96 +#define TOK_UGT 0x97 +#define TOK_LT 0x9c +#define TOK_GE 0x9d +#define TOK_LE 0x9e +#define TOK_GT 0x9f + +#define TOK_LAND 0xa0 +#define TOK_LOR 0xa1 + +#define TOK_DEC 0xa2 +#define TOK_MID 0xa3 /* inc/dec, to void constant */ +#define TOK_INC 0xa4 +#define TOK_UDIV 0xb0 /* unsigned division */ +#define TOK_UMOD 0xb1 /* unsigned modulo */ +#define TOK_PDIV 0xb2 /* fast division with undefined rounding for pointers */ +#define TOK_CINT 0xb3 /* number in tokc */ +#define TOK_CCHAR 0xb4 /* char constant in tokc */ +#define TOK_STR 0xb5 /* pointer to string in tokc */ +#define TOK_TWOSHARPS 0xb6 /* ## preprocessing token */ +#define TOK_LCHAR 0xb7 +#define TOK_LSTR 0xb8 +#define TOK_CFLOAT 0xb9 /* float constant */ +#define TOK_LINENUM 0xba /* line number info */ +#define TOK_CDOUBLE 0xc0 /* double constant */ +#define TOK_CLDOUBLE 0xc1 /* long double constant */ +#define TOK_UMULL 0xc2 /* unsigned 32x32 -> 64 mul */ +#define TOK_ADDC1 0xc3 /* add with carry generation */ +#define TOK_ADDC2 0xc4 /* add with carry use */ +#define TOK_SUBC1 0xc5 /* add with carry generation */ +#define TOK_SUBC2 0xc6 /* add with carry use */ +#define TOK_CUINT 0xc8 /* unsigned int constant */ +#define TOK_CLLONG 0xc9 /* long long constant */ +#define TOK_CULLONG 0xca /* unsigned long long constant */ +#define TOK_ARROW 0xcb +#define TOK_DOTS 0xcc /* three dots */ +#define TOK_SHR 0xcd /* unsigned shift right */ +#define TOK_PPNUM 0xce /* preprocessor number */ + +#define TOK_SHL 0x01 /* shift left */ +#define TOK_SAR 0x02 /* signed shift right */ + +/* assignement operators : normal operator or 0x80 */ +#define TOK_A_MOD 0xa5 +#define TOK_A_AND 0xa6 +#define TOK_A_MUL 0xaa +#define TOK_A_ADD 0xab +#define TOK_A_SUB 0xad +#define TOK_A_DIV 0xaf +#define TOK_A_XOR 0xde +#define TOK_A_OR 0xfc +#define TOK_A_SHL 0x81 +#define TOK_A_SAR 0x82 + +#ifndef offsetof +#define offsetof(type, field) ((size_t) &((type *)0)->field) +#endif + +#ifndef countof +#define countof(tab) (sizeof(tab) / sizeof((tab)[0])) +#endif + +/* WARNING: the content of this string encodes token numbers */ +static char tok_two_chars[] = "<=\236>=\235!=\225&&\240||\241++\244--\242==\224<<\1>>\2+=\253-=\255*=\252/=\257%=\245&=\246^=\336|=\374->\313..\250##\266"; + +#define TOK_EOF (-1) /* end of file */ +#define TOK_LINEFEED 10 /* line feed */ + +/* all identificators and strings have token above that */ +#define TOK_IDENT 256 + +/* only used for i386 asm opcodes definitions */ +#define DEF_ASM(x) DEF(TOK_ASM_ ## x, #x) + +#define DEF_BWL(x) \ + DEF(TOK_ASM_ ## x ## b, #x "b") \ + DEF(TOK_ASM_ ## x ## w, #x "w") \ + DEF(TOK_ASM_ ## x ## l, #x "l") \ + DEF(TOK_ASM_ ## x, #x) + +#define DEF_WL(x) \ + DEF(TOK_ASM_ ## x ## w, #x "w") \ + DEF(TOK_ASM_ ## x ## l, #x "l") \ + DEF(TOK_ASM_ ## x, #x) + +#define DEF_FP1(x) \ + DEF(TOK_ASM_ ## f ## x ## s, "f" #x "s") \ + DEF(TOK_ASM_ ## fi ## x ## l, "fi" #x "l") \ + DEF(TOK_ASM_ ## f ## x ## l, "f" #x "l") \ + DEF(TOK_ASM_ ## fi ## x ## s, "fi" #x "s") + +#define DEF_FP(x) \ + DEF(TOK_ASM_ ## f ## x, "f" #x ) \ + DEF(TOK_ASM_ ## f ## x ## p, "f" #x "p") \ + DEF_FP1(x) + +#define DEF_ASMTEST(x) \ + DEF_ASM(x ## o) \ + DEF_ASM(x ## no) \ + DEF_ASM(x ## b) \ + DEF_ASM(x ## c) \ + DEF_ASM(x ## nae) \ + DEF_ASM(x ## nb) \ + DEF_ASM(x ## nc) \ + DEF_ASM(x ## ae) \ + DEF_ASM(x ## e) \ + DEF_ASM(x ## z) \ + DEF_ASM(x ## ne) \ + DEF_ASM(x ## nz) \ + DEF_ASM(x ## be) \ + DEF_ASM(x ## na) \ + DEF_ASM(x ## nbe) \ + DEF_ASM(x ## a) \ + DEF_ASM(x ## s) \ + DEF_ASM(x ## ns) \ + DEF_ASM(x ## p) \ + DEF_ASM(x ## pe) \ + DEF_ASM(x ## np) \ + DEF_ASM(x ## po) \ + DEF_ASM(x ## l) \ + DEF_ASM(x ## nge) \ + DEF_ASM(x ## nl) \ + DEF_ASM(x ## ge) \ + DEF_ASM(x ## le) \ + DEF_ASM(x ## ng) \ + DEF_ASM(x ## nle) \ + DEF_ASM(x ## g) + +#define TOK_ASM_int TOK_INT + +enum tcc_token { + TOK_LAST = TOK_IDENT - 1, +#define DEF(id, str) id, +#include "tcctok.h" +#undef DEF +}; + +static const char tcc_keywords[] = +#define DEF(id, str) str "\0" +#include "tcctok.h" +#undef DEF +; + +#define TOK_UIDENT TOK_DEFINE + +#ifdef WIN32 +int __stdcall GetModuleFileNameA(void *, char *, int); +void *__stdcall GetProcAddress(void *, const char *); +void *__stdcall GetModuleHandleA(const char *); +void *__stdcall LoadLibraryA(const char *); +int __stdcall FreeConsole(void); + +#define snprintf _snprintf +#define vsnprintf _vsnprintf +#ifndef __GNUC__ + #define strtold (long double)strtod + #define strtof (float)strtod + #define strtoll (long long)strtol +#endif +#elif defined(TCC_UCLIBC) || defined(__FreeBSD__) +/* currently incorrect */ +long double strtold(const char *nptr, char **endptr) +{ + return (long double)strtod(nptr, endptr); +} +float strtof(const char *nptr, char **endptr) +{ + return (float)strtod(nptr, endptr); +} +#else +/* XXX: need to define this to use them in non ISOC99 context */ +extern float strtof (const char *__nptr, char **__endptr); +extern long double strtold (const char *__nptr, char **__endptr); +#endif + +static char *pstrcpy(char *buf, int buf_size, const char *s); +static char *pstrcat(char *buf, int buf_size, const char *s); +static const char *tcc_basename(const char *name); + +static void next(void); +static void next_nomacro(void); +static void parse_expr_type(CType *type); +static void expr_type(CType *type); +static void unary_type(CType *type); +static void block(int *bsym, int *csym, int *case_sym, int *def_sym, + int case_reg, int is_expr); +static int expr_const(void); +static void expr_eq(void); +static void gexpr(void); +static void gen_inline_functions(void); +static void decl(int l); +static void decl_initializer(CType *type, Section *sec, unsigned long c, + int first, int size_only); +static void decl_initializer_alloc(CType *type, AttributeDef *ad, int r, + int has_init, int v, int scope); +int gv(int rc); +void gv2(int rc1, int rc2); +void move_reg(int r, int s); +void save_regs(int n); +void save_reg(int r); +void vpop(void); +void vswap(void); +void vdup(void); +int get_reg(int rc); +int get_reg_ex(int rc,int rc2); + +struct macro_level { + struct macro_level *prev; + int *p; +}; + +static void macro_subst(TokenString *tok_str, Sym **nested_list, + const int *macro_str, struct macro_level **can_read_stream); +void gen_op(int op); +void force_charshort_cast(int t); +static void gen_cast(CType *type); +void vstore(void); +static Sym *sym_find(int v); +static Sym *sym_push(int v, CType *type, int r, int c); + +/* type handling */ +static int type_size(CType *type, int *a); +static inline CType *pointed_type(CType *type); +static int pointed_size(CType *type); +static int lvalue_type(int t); +static int parse_btype(CType *type, AttributeDef *ad); +static void type_decl(CType *type, AttributeDef *ad, int *v, int td); +static int is_compatible_types(CType *type1, CType *type2); + +int ieee_finite(double d); +void error(const char *fmt, ...); +void vpushi(int v); +void vrott(int n); +void vnrott(int n); +void lexpand_nr(void); +static void vpush_global_sym(CType *type, int v); +void vset(CType *type, int r, int v); +void type_to_str(char *buf, int buf_size, + CType *type, const char *varstr); +char *get_tok_str(int v, CValue *cv); +static Sym *get_sym_ref(CType *type, Section *sec, + unsigned long offset, unsigned long size); +static Sym *external_global_sym(int v, CType *type, int r); + +/* section generation */ +static void section_realloc(Section *sec, unsigned long new_size); +static void *section_ptr_add(Section *sec, unsigned long size); +static void put_extern_sym(Sym *sym, Section *section, + unsigned long value, unsigned long size); +static void greloc(Section *s, Sym *sym, unsigned long addr, int type); +static int put_elf_str(Section *s, const char *sym); +static int put_elf_sym(Section *s, + unsigned long value, unsigned long size, + int info, int other, int shndx, const char *name); +static int add_elf_sym(Section *s, unsigned long value, unsigned long size, + int info, int other, int sh_num, const char *name); +static void put_elf_reloc(Section *symtab, Section *s, unsigned long offset, + int type, int symbol); +static void put_stabs(const char *str, int type, int other, int desc, + unsigned long value); +static void put_stabs_r(const char *str, int type, int other, int desc, + unsigned long value, Section *sec, int sym_index); +static void put_stabn(int type, int other, int desc, int value); +static void put_stabd(int type, int other, int desc); +static int tcc_add_dll(TCCState *s, const char *filename, int flags); + +#define AFF_PRINT_ERROR 0x0001 /* print error if file not found */ +#define AFF_REFERENCED_DLL 0x0002 /* load a referenced dll from another dll */ +static int tcc_add_file_internal(TCCState *s, const char *filename, int flags); + +/* tccasm.c */ + +#ifdef CONFIG_TCC_ASM + +typedef struct ExprValue { + uint32_t v; + Sym *sym; +} ExprValue; + +#define MAX_ASM_OPERANDS 30 + +typedef struct ASMOperand { + int id; /* GCC 3 optionnal identifier (0 if number only supported */ + char *constraint; + char asm_str[16]; /* computed asm string for operand */ + SValue *vt; /* C value of the expression */ + int ref_index; /* if >= 0, gives reference to a output constraint */ + int input_index; /* if >= 0, gives reference to an input constraint */ + int priority; /* priority, used to assign registers */ + int reg; /* if >= 0, register number used for this operand */ + int is_llong; /* true if double register value */ + int is_memory; /* true if memory operand */ + int is_rw; /* for '+' modifier */ +} ASMOperand; + +static void asm_expr(TCCState *s1, ExprValue *pe); +static int asm_int_expr(TCCState *s1); +static int find_constraint(ASMOperand *operands, int nb_operands, + const char *name, const char **pp); + +static int tcc_assemble(TCCState *s1, int do_preprocess); + +#endif + +static void asm_instr(void); +static void asm_global_instr(void); + +/* true if float/double/long double type */ +static inline int is_float(int t) +{ + int bt; + bt = t & VT_BTYPE; + return bt == VT_LDOUBLE || bt == VT_DOUBLE || bt == VT_FLOAT; +} + +void warning(const char *fmt, ...); + +#ifdef TCC_TARGET_I386 +#include "i386-gen.c" +#endif + +#ifdef TCC_TARGET_ARM +#include "arm-gen.c" +#endif + +#ifdef TCC_TARGET_C67 +#include "c67-gen.c" +#endif + +#ifdef TCC_TARGET_816 +#include "816-gen.c" +#endif + +/********************************************************/ + +/* we use our own 'finite' function to avoid potential problems with + non standard math libs */ +/* XXX: endianness dependent */ +int ieee_finite(double d) +{ + int *p = (int *)&d; + return ((unsigned)((p[1] | 0x800fffff) + 1)) >> 31; +} + +/* copy a string and truncate it. */ +static char *pstrcpy(char *buf, int buf_size, const char *s) +{ + char *q, *q_end; + int c; + + if (buf_size > 0) { + q = buf; + q_end = buf + buf_size - 1; + while (q < q_end) { + c = *s++; + if (c == '\0') + break; + *q++ = c; + } + *q = '\0'; + } + return buf; +} + +/* strcat and truncate. */ +static char *pstrcat(char *buf, int buf_size, const char *s) +{ + int len; + len = strlen(buf); + if (len < buf_size) + pstrcpy(buf + len, buf_size - len, s); + return buf; +} + +static int strstart(const char *str, const char *val, const char **ptr) +{ + const char *p, *q; + p = str; + q = val; + while (*q != '\0') { + if (*p != *q) + return 0; + p++; + q++; + } + if (ptr) + *ptr = p; + return 1; +} + +/* memory management */ +#ifdef MEM_DEBUG +int mem_cur_size; +int mem_max_size; +#endif + +static inline void tcc_free(void *ptr) +{ +#ifdef MEM_DEBUG + mem_cur_size -= malloc_usable_size(ptr); +#endif + free(ptr); +} + +static void *tcc_malloc(unsigned long size) +{ + void *ptr; + ptr = malloc(size); + if (!ptr && size) + error("memory full"); +#ifdef MEM_DEBUG + mem_cur_size += malloc_usable_size(ptr); + if (mem_cur_size > mem_max_size) + mem_max_size = mem_cur_size; +#endif + return ptr; +} + +static void *tcc_mallocz(unsigned long size) +{ + void *ptr; + ptr = tcc_malloc(size); + memset(ptr, 0, size); + return ptr; +} + +static inline void *tcc_realloc(void *ptr, unsigned long size) +{ + void *ptr1; +#ifdef MEM_DEBUG + mem_cur_size -= malloc_usable_size(ptr); +#endif + ptr1 = realloc(ptr, size); +#ifdef MEM_DEBUG + /* NOTE: count not correct if alloc error, but not critical */ + mem_cur_size += malloc_usable_size(ptr1); + if (mem_cur_size > mem_max_size) + mem_max_size = mem_cur_size; +#endif + return ptr1; +} + +static char *tcc_strdup(const char *str) +{ + char *ptr; + ptr = tcc_malloc(strlen(str) + 1); + strcpy(ptr, str); + return ptr; +} + +#define free(p) use_tcc_free(p) +#define malloc(s) use_tcc_malloc(s) +#define realloc(p, s) use_tcc_realloc(p, s) + +static void dynarray_add(void ***ptab, int *nb_ptr, void *data) +{ + int nb, nb_alloc; + void **pp; + + nb = *nb_ptr; + pp = *ptab; + /* every power of two we double array size */ + if ((nb & (nb - 1)) == 0) { + if (!nb) + nb_alloc = 1; + else + nb_alloc = nb * 2; + pp = tcc_realloc(pp, nb_alloc * sizeof(void *)); + if (!pp) + error("memory full"); + *ptab = pp; + } + pp[nb++] = data; + *nb_ptr = nb; +} + +/* symbol allocator */ +static Sym *__sym_malloc(void) +{ + Sym *sym_pool, *sym, *last_sym; + int i; + + sym_pool = tcc_malloc(SYM_POOL_NB * sizeof(Sym)); + + last_sym = sym_free_first; + sym = sym_pool; + for(i = 0; i < SYM_POOL_NB; i++) { + sym->next = last_sym; + last_sym = sym; + sym++; + } + sym_free_first = last_sym; + return last_sym; +} + +static inline Sym *sym_malloc(void) +{ + Sym *sym; + sym = sym_free_first; + if (!sym) + sym = __sym_malloc(); + sym_free_first = sym->next; + return sym; +} + +static inline void sym_free(Sym *sym) +{ + sym->next = sym_free_first; + sym_free_first = sym; +} + +Section *new_section(TCCState *s1, const char *name, int sh_type, int sh_flags) +{ + Section *sec; + + sec = tcc_mallocz(sizeof(Section) + strlen(name)); + strcpy(sec->name, name); + sec->sh_type = sh_type; + sec->sh_flags = sh_flags; + switch(sh_type) { + case SHT_HASH: + case SHT_REL: + case SHT_DYNSYM: + case SHT_SYMTAB: + case SHT_DYNAMIC: + sec->sh_addralign = 4; + break; + case SHT_STRTAB: + sec->sh_addralign = 1; + break; + default: + sec->sh_addralign = 32; /* default conservative alignment */ + break; + } + + /* only add section if not private */ + if (!(sh_flags & SHF_PRIVATE)) { + sec->sh_num = s1->nb_sections; + dynarray_add((void ***)&s1->sections, &s1->nb_sections, sec); + } + return sec; +} + +static void free_section(Section *s) +{ + tcc_free(s->data); + tcc_free(s); +} + +/* realloc section and set its content to zero */ +static void section_realloc(Section *sec, unsigned long new_size) +{ + unsigned long size; + unsigned char *data; + + size = sec->data_allocated; + if (size == 0) + size = 1; + while (size < new_size) + size = size * 2; + data = tcc_realloc(sec->data, size); + if (!data) + error("memory full"); + memset(data + sec->data_allocated, 0, size - sec->data_allocated); + sec->data = data; + sec->data_allocated = size; +} + +/* reserve at least 'size' bytes in section 'sec' from + sec->data_offset. */ +static void *section_ptr_add(Section *sec, unsigned long size) +{ + unsigned long offset, offset1; + + offset = sec->data_offset; + offset1 = offset + size; + //fprintf(stderr,"section_ptr_add sec %s data %p size %ld offset %ld offset1 %ld allocd %ld\n", sec->name, sec->data, size,offset,offset1,sec->data_allocated); + if (offset1 > sec->data_allocated) + section_realloc(sec, offset1); + sec->data_offset = offset1; + return sec->data + offset; +} + +/* return a reference to a section, and create it if it does not + exists */ +Section *find_section(TCCState *s1, const char *name) +{ + Section *sec; + int i; + for(i = 1; i < s1->nb_sections; i++) { + sec = s1->sections[i]; + if (!strcmp(name, sec->name)) + return sec; + } + /* sections are created as PROGBITS */ + return new_section(s1, name, SHT_PROGBITS, SHF_ALLOC); +} + +#define SECTION_ABS ((void *)1) + +/* update sym->c so that it points to an external symbol in section + 'section' with value 'value' */ +static void put_extern_sym2(Sym *sym, Section *section, + unsigned long value, unsigned long size, + int can_add_underscore) +{ + int sym_type, sym_bind, sh_num, info; + Elf32_Sym *esym; + const char *name; + char buf1[256]; + + if (section == NULL) + sh_num = SHN_UNDEF; + else if (section == SECTION_ABS) + sh_num = SHN_ABS; + else + sh_num = section->sh_num; + if (!sym->c) { + if ((sym->type.t & VT_BTYPE) == VT_FUNC) + sym_type = STT_FUNC; + else + sym_type = STT_OBJECT; + if (sym->type.t & VT_STATIC) + sym_bind = STB_LOCAL; + else + sym_bind = STB_GLOBAL; + + name = get_tok_str(sym->v, NULL); +#ifdef CONFIG_TCC_BCHECK + if (do_bounds_check) { + char buf[32]; + + /* XXX: avoid doing that for statics ? */ + /* if bound checking is activated, we change some function + names by adding the "__bound" prefix */ + switch(sym->v) { +#if 0 + /* XXX: we rely only on malloc hooks */ + case TOK_malloc: + case TOK_free: + case TOK_realloc: + case TOK_memalign: + case TOK_calloc: +#endif + case TOK_memcpy: + case TOK_memmove: + case TOK_memset: + case TOK_strlen: + case TOK_strcpy: + strcpy(buf, "__bound_"); + strcat(buf, name); + name = buf; + break; + } + } +#endif + if (tcc_state->leading_underscore && can_add_underscore) { + buf1[0] = '_'; + pstrcpy(buf1 + 1, sizeof(buf1) - 1, name); + name = buf1; + } + if (sym->type.t & VT_STATIC /* && name[0] != 'L' && name[1] != '.' */) { + //fprintf(stderr,"verstaticung von %s (current_fn %s)\n", name,current_fn); + if ((sym->type.t & VT_STATICLOCAL) && current_fn[0] != 0 /*&& !((sym->type.t & VT_BTYPE) == VT_FUNC)*/) + sprintf(buf1, "%s_FUNC_%s_", static_prefix, current_fn); + else + strcpy(buf1, static_prefix); + strcat(buf1, name); + name = buf1; + } + info = ELF32_ST_INFO(sym_bind, sym_type); + sym->c = add_elf_sym(symtab_section, value, size, info, 0, sh_num, name); + } else { + esym = &((Elf32_Sym *)symtab_section->data)[sym->c]; + esym->st_value = value; + esym->st_size = size; + esym->st_shndx = sh_num; + } +} + +static void put_extern_sym(Sym *sym, Section *section, + unsigned long value, unsigned long size) +{ + put_extern_sym2(sym, section, value, size, 1); +} + +/* add a new relocation entry to symbol 'sym' in section 's' */ +static void greloc(Section *s, Sym *sym, unsigned long offset, int type) +{ + //fprintf(stderr,"greloc section %p offset %d type %d name %s const %d\n",s,offset,type,get_tok_str(sym->v, NULL),sym->c); + if (!sym->c) + put_extern_sym(sym, NULL, 0, 0); + /* now we can add ELF relocation info */ + put_elf_reloc(symtab_section, s, offset, type, sym->c); +} + +static inline int isid(int c) +{ + return (c >= 'a' && c <= 'z') || + (c >= 'A' && c <= 'Z') || + c == '_'; +} + +static inline int isnum(int c) +{ + return c >= '0' && c <= '9'; +} + +static inline int isoct(int c) +{ + return c >= '0' && c <= '7'; +} + +static inline int toup(int c) +{ + if (c >= 'a' && c <= 'z') + return c - 'a' + 'A'; + else + return c; +} + +static void strcat_vprintf(char *buf, int buf_size, const char *fmt, va_list ap) +{ + int len; + len = strlen(buf); + vsnprintf(buf + len, buf_size - len, fmt, ap); +} + +static void strcat_printf(char *buf, int buf_size, const char *fmt, ...) +{ + va_list ap; + va_start(ap, fmt); + strcat_vprintf(buf, buf_size, fmt, ap); + va_end(ap); +} + +void error1(TCCState *s1, int is_warning, const char *fmt, va_list ap) +{ + char buf[2048]; + BufferedFile **f; + + buf[0] = '\0'; + if (file) { + for(f = s1->include_stack; f < s1->include_stack_ptr; f++) + strcat_printf(buf, sizeof(buf), "In file included from %s:%d:\n", + (*f)->filename, (*f)->line_num); + if (file->line_num > 0) { + strcat_printf(buf, sizeof(buf), + "%s:%d: ", file->filename, file->line_num); + } else { + strcat_printf(buf, sizeof(buf), + "%s: ", file->filename); + } + } else { + strcat_printf(buf, sizeof(buf), + "tcc: "); + } + if (is_warning) + strcat_printf(buf, sizeof(buf), "warning: "); + strcat_vprintf(buf, sizeof(buf), fmt, ap); + + if (!s1->error_func) { + /* default case: stderr */ + fprintf(stderr, "%s\n", buf); + } else { + s1->error_func(s1->error_opaque, buf); + } + if (!is_warning || s1->warn_error) + s1->nb_errors++; +} + +#ifdef LIBTCC +void tcc_set_error_func(TCCState *s, void *error_opaque, + void (*error_func)(void *opaque, const char *msg)) +{ + s->error_opaque = error_opaque; + s->error_func = error_func; +} +#endif + +/* error without aborting current compilation */ +void error_noabort(const char *fmt, ...) +{ + TCCState *s1 = tcc_state; + va_list ap; + + va_start(ap, fmt); + error1(s1, 0, fmt, ap); + va_end(ap); +} + +void error(const char *fmt, ...) +{ + TCCState *s1 = tcc_state; + va_list ap; + + va_start(ap, fmt); + error1(s1, 0, fmt, ap); + va_end(ap); + /* better than nothing: in some cases, we accept to handle errors */ + if (s1->error_set_jmp_enabled) { + longjmp(s1->error_jmp_buf, 1); + } else { + /* XXX: eliminate this someday */ + exit(1); + } +} + +void expect(const char *msg) +{ + error("%s expected", msg); +} + +void warning(const char *fmt, ...) +{ + TCCState *s1 = tcc_state; + va_list ap; + + if (s1->warn_none) + return; + + va_start(ap, fmt); + error1(s1, 1, fmt, ap); + va_end(ap); +} + +void skip(int c) +{ + if (tok != c) + error("'%c' expected", c); + next(); +} + +static void test_lvalue(void) +{ + if (!(vtop->r & VT_LVAL)) + expect("lvalue"); +} + +/* allocate a new token */ +static TokenSym *tok_alloc_new(TokenSym **pts, const char *str, int len) +{ + TokenSym *ts, **ptable; + int i; + + if (tok_ident >= SYM_FIRST_ANOM) + error("memory full"); + + /* expand token table if needed */ + i = tok_ident - TOK_IDENT; + if ((i % TOK_ALLOC_INCR) == 0) { + ptable = tcc_realloc(table_ident, (i + TOK_ALLOC_INCR) * sizeof(TokenSym *)); + if (!ptable) + error("memory full"); + table_ident = ptable; + } + + ts = tcc_malloc(sizeof(TokenSym) + len); + table_ident[i] = ts; + ts->tok = tok_ident++; + ts->sym_define = NULL; + ts->sym_label = NULL; + ts->sym_struct = NULL; + ts->sym_identifier = NULL; + ts->len = len; + ts->hash_next = NULL; + memcpy(ts->str, str, len); + ts->str[len] = '\0'; + *pts = ts; + return ts; +} + +#define TOK_HASH_INIT 1 +#define TOK_HASH_FUNC(h, c) ((h) * 263 + (c)) + +/* find a token and add it if not found */ +static TokenSym *tok_alloc(const char *str, int len) +{ + TokenSym *ts, **pts; + int i; + unsigned int h; + + h = TOK_HASH_INIT; + for(i=0;ilen == len && !memcmp(ts->str, str, len)) + return ts; + pts = &(ts->hash_next); + } + return tok_alloc_new(pts, str, len); +} + +/* CString handling */ + +static void cstr_realloc(CString *cstr, int new_size) +{ + int size; + void *data; + + size = cstr->size_allocated; + if (size == 0) + size = 8; /* no need to allocate a too small first string */ + while (size < new_size) + size = size * 2; + data = tcc_realloc(cstr->data_allocated, size); + if (!data) + error("memory full"); + cstr->data_allocated = data; + cstr->size_allocated = size; + cstr->data = data; +} + +/* add a byte */ +static inline void cstr_ccat(CString *cstr, int ch) +{ + int size; + size = cstr->size + 1; + if (size > cstr->size_allocated) + cstr_realloc(cstr, size); + ((unsigned char *)cstr->data)[size - 1] = ch; + cstr->size = size; +} + +static void cstr_cat(CString *cstr, const char *str) +{ + int c; + for(;;) { + c = *str; + if (c == '\0') + break; + cstr_ccat(cstr, c); + str++; + } +} + +/* add a wide char */ +static void cstr_wccat(CString *cstr, int ch) +{ + int size; + size = cstr->size + sizeof(int); + if (size > cstr->size_allocated) + cstr_realloc(cstr, size); + *(int *)(((unsigned char *)cstr->data) + size - sizeof(int)) = ch; + cstr->size = size; +} + +static void cstr_new(CString *cstr) +{ + memset(cstr, 0, sizeof(CString)); +} + +/* free string and reset it to NULL */ +static void cstr_free(CString *cstr) +{ + tcc_free(cstr->data_allocated); + cstr_new(cstr); +} + +#define cstr_reset(cstr) cstr_free(cstr) + +/* XXX: unicode ? */ +static void add_char(CString *cstr, int c) +{ + if (c == '\'' || c == '\"' || c == '\\') { + /* XXX: could be more precise if char or string */ + cstr_ccat(cstr, '\\'); + } + if (c >= 32 && c <= 126) { + cstr_ccat(cstr, c); + } else { + cstr_ccat(cstr, '\\'); + if (c == '\n') { + cstr_ccat(cstr, 'n'); + } else { + cstr_ccat(cstr, '0' + ((c >> 6) & 7)); + cstr_ccat(cstr, '0' + ((c >> 3) & 7)); + cstr_ccat(cstr, '0' + (c & 7)); + } + } +} + +/* XXX: buffer overflow */ +/* XXX: float tokens */ +char *get_tok_str(int v, CValue *cv) +{ + static char buf[STRING_MAX_SIZE + 1]; + static CString cstr_buf; + CString *cstr; + unsigned char *q; + char *p; + int i, len; + + /* NOTE: to go faster, we give a fixed buffer for small strings */ + cstr_reset(&cstr_buf); + cstr_buf.data = buf; + cstr_buf.size_allocated = sizeof(buf); + p = buf; + + switch(v) { + case TOK_CINT: + case TOK_CUINT: + /* XXX: not quite exact, but only useful for testing */ + sprintf(p, "%u", cv->ui); + break; + case TOK_CLLONG: + case TOK_CULLONG: + /* XXX: not quite exact, but only useful for testing */ + sprintf(p, "%Lu", cv->ull); + break; + case TOK_CCHAR: + case TOK_LCHAR: + cstr_ccat(&cstr_buf, '\''); + add_char(&cstr_buf, cv->i); + cstr_ccat(&cstr_buf, '\''); + cstr_ccat(&cstr_buf, '\0'); + break; + case TOK_PPNUM: + cstr = cv->cstr; + len = cstr->size - 1; + for(i=0;idata)[i]); + cstr_ccat(&cstr_buf, '\0'); + break; + case TOK_STR: + case TOK_LSTR: + cstr = cv->cstr; + cstr_ccat(&cstr_buf, '\"'); + if (v == TOK_STR) { + len = cstr->size - 1; + for(i=0;idata)[i]); + } else { + len = (cstr->size / sizeof(int)) - 1; + for(i=0;idata)[i]); + } + cstr_ccat(&cstr_buf, '\"'); + cstr_ccat(&cstr_buf, '\0'); + break; + case TOK_LT: + v = '<'; + goto addv; + case TOK_GT: + v = '>'; + goto addv; + case TOK_A_SHL: + return strcpy(p, "<<="); + case TOK_A_SAR: + return strcpy(p, ">>="); + default: + if (v < TOK_IDENT) { + /* search in two bytes table */ + q = tok_two_chars; + while (*q) { + if (q[2] == v) { + *p++ = q[0]; + *p++ = q[1]; + *p = '\0'; + return buf; + } + q += 3; + } + addv: + *p++ = v; + *p = '\0'; + } else if (v < tok_ident) { + return table_ident[v - TOK_IDENT]->str; + } else if (v >= SYM_FIRST_ANOM) { + /* special name for anonymous symbol */ + sprintf(p, "L.%d", v - SYM_FIRST_ANOM); + } else { + /* should never happen */ + return NULL; + } + break; + } + return cstr_buf.data; +} + +/* push, without hashing */ +static Sym *sym_push2(Sym **ps, int v, int t, int c) +{ + Sym *s; + s = sym_malloc(); + s->v = v; + s->type.t = t; + s->c = c; + s->next = NULL; + /* add in stack */ + s->prev = *ps; + *ps = s; + return s; +} + +/* find a symbol and return its associated structure. 's' is the top + of the symbol stack */ +static Sym *sym_find2(Sym *s, int v) +{ + while (s) { + if (s->v == v) + return s; + s = s->prev; + } + return NULL; +} + +/* structure lookup */ +static inline Sym *struct_find(int v) +{ + v -= TOK_IDENT; + if ((unsigned)v >= (unsigned)(tok_ident - TOK_IDENT)) + return NULL; + return table_ident[v]->sym_struct; +} + +/* find an identifier */ +static inline Sym *sym_find(int v) +{ + v -= TOK_IDENT; + if ((unsigned)v >= (unsigned)(tok_ident - TOK_IDENT)) + return NULL; + return table_ident[v]->sym_identifier; +} + +/* push a given symbol on the symbol stack */ +static Sym *sym_push(int v, CType *type, int r, int c) +{ + Sym *s, **ps; + TokenSym *ts; + + if (local_stack) + ps = &local_stack; + else + ps = &global_stack; + s = sym_push2(ps, v, type->t, c); + s->type.ref = type->ref; + s->r = r; + /* don't record fields or anonymous symbols */ + /* XXX: simplify */ + if (!(v & SYM_FIELD) && (v & ~SYM_STRUCT) < SYM_FIRST_ANOM) { + /* record symbol in token array */ + //fprintf(stderr,"table_ident index 0x%x\n",(v & ~(SYM_STRUCT)) - TOK_IDENT); + ts = table_ident[(v & ~(SYM_STRUCT)) - TOK_IDENT]; + if (v & SYM_STRUCT) + ps = &ts->sym_struct; + else + ps = &ts->sym_identifier; + s->prev_tok = *ps; + *ps = s; + } + return s; +} + +/* push a global identifier */ +static Sym *global_identifier_push(int v, int t, int c) +{ + Sym *s, **ps; + s = sym_push2(&global_stack, v, t, c); + /* don't record anonymous symbol */ + if (v < SYM_FIRST_ANOM) { + //fprintf(stderr,"table_ident index 0x%x\n",v - TOK_IDENT); + ps = &table_ident[v - TOK_IDENT]->sym_identifier; + /* modify the top most local identifier, so that + sym_identifier will point to 's' when popped */ + while (*ps != NULL) + ps = &(*ps)->prev_tok; + s->prev_tok = NULL; + *ps = s; + } + return s; +} + +/* pop symbols until top reaches 'b' */ +static void sym_pop(Sym **ptop, Sym *b) +{ + Sym *s, *ss, **ps; + TokenSym *ts; + int v; + + s = *ptop; + while(s != b) { + ss = s->prev; + v = s->v; + /* remove symbol in token array */ + /* XXX: simplify */ + if (!(v & SYM_FIELD) && (v & ~SYM_STRUCT) < SYM_FIRST_ANOM) { + ts = table_ident[(v & ~SYM_STRUCT) - TOK_IDENT]; + if (v & SYM_STRUCT) + ps = &ts->sym_struct; + else + ps = &ts->sym_identifier; + *ps = s->prev_tok; + } + sym_free(s); + s = ss; + } + *ptop = b; +} + +/* I/O layer */ + +BufferedFile *tcc_open(TCCState *s1, const char *filename) +{ + int fd; + BufferedFile *bf; + + fd = open(filename, O_RDONLY | O_BINARY); + if (fd < 0) + return NULL; + bf = tcc_malloc(sizeof(BufferedFile)); + if (!bf) { + close(fd); + return NULL; + } + bf->fd = fd; + bf->buf_ptr = bf->buffer; + bf->buf_end = bf->buffer; + bf->buffer[0] = CH_EOB; /* put eob symbol */ + pstrcpy(bf->filename, sizeof(bf->filename), filename); + bf->line_num = 1; + bf->ifndef_macro = 0; + bf->ifdef_stack_ptr = s1->ifdef_stack_ptr; + // printf("opening '%s'\n", filename); + return bf; +} + +void tcc_close(BufferedFile *bf) +{ + total_lines += bf->line_num; + close(bf->fd); + tcc_free(bf); +} + +/* fill input buffer and peek next char */ +static int tcc_peekc_slow(BufferedFile *bf) +{ + int len; + /* only tries to read if really end of buffer */ + if (bf->buf_ptr >= bf->buf_end) { + if (bf->fd != -1) { +#if defined(PARSE_DEBUG) + len = 8; +#else + len = IO_BUF_SIZE; +#endif + len = read(bf->fd, bf->buffer, len); + if (len < 0) + len = 0; + } else { + len = 0; + } + total_bytes += len; + bf->buf_ptr = bf->buffer; + bf->buf_end = bf->buffer + len; + *bf->buf_end = CH_EOB; + } + if (bf->buf_ptr < bf->buf_end) { + return bf->buf_ptr[0]; + } else { + bf->buf_ptr = bf->buf_end; + return CH_EOF; + } +} + +/* return the current character, handling end of block if necessary + (but not stray) */ +static int handle_eob(void) +{ + return tcc_peekc_slow(file); +} + +/* read next char from current input file and handle end of input buffer */ +static inline void inp(void) +{ + ch = *(++(file->buf_ptr)); + /* end of buffer/file handling */ + if (ch == CH_EOB) + ch = handle_eob(); +} + +/* handle '\[\r]\n' */ +static void handle_stray(void) +{ + while (ch == '\\') { + inp(); + if (ch == '\n') { + file->line_num++; + inp(); + } else if (ch == '\r') { + inp(); + if (ch != '\n') + goto fail; + file->line_num++; + inp(); + } else { + fail: + error("stray '\\' in program"); + } + } +} + +/* skip the stray and handle the \\n case. Output an error if + incorrect char after the stray */ +static int handle_stray1(uint8_t *p) +{ + int c; + + if (p >= file->buf_end) { + file->buf_ptr = p; + c = handle_eob(); + p = file->buf_ptr; + if (c == '\\') + goto parse_stray; + } else { + parse_stray: + file->buf_ptr = p; + ch = *p; + handle_stray(); + p = file->buf_ptr; + c = *p; + } + return c; +} + +/* handle just the EOB case, but not stray */ +#define PEEKC_EOB(c, p)\ +{\ + p++;\ + c = *p;\ + if (c == '\\') {\ + file->buf_ptr = p;\ + c = handle_eob();\ + p = file->buf_ptr;\ + }\ +} + +/* handle the complicated stray case */ +#define PEEKC(c, p)\ +{\ + p++;\ + c = *p;\ + if (c == '\\') {\ + c = handle_stray1(p);\ + p = file->buf_ptr;\ + }\ +} + +/* input with '\[\r]\n' handling. Note that this function cannot + handle other characters after '\', so you cannot call it inside + strings or comments */ +static void minp(void) +{ + inp(); + if (ch == '\\') + handle_stray(); +} + + +/* single line C++ comments */ +static uint8_t *parse_line_comment(uint8_t *p) +{ + int c; + + p++; + for(;;) { + c = *p; + redo: + if (c == '\n' || c == CH_EOF) { + break; + } else if (c == '\\') { + file->buf_ptr = p; + c = handle_eob(); + p = file->buf_ptr; + if (c == '\\') { + PEEKC_EOB(c, p); + if (c == '\n') { + file->line_num++; + PEEKC_EOB(c, p); + } else if (c == '\r') { + PEEKC_EOB(c, p); + if (c == '\n') { + file->line_num++; + PEEKC_EOB(c, p); + } + } + } else { + goto redo; + } + } else { + p++; + } + } + return p; +} + +/* C comments */ +static uint8_t *parse_comment(uint8_t *p) +{ + int c; + + p++; + for(;;) { + /* fast skip loop */ + for(;;) { + c = *p; + if (c == '\n' || c == '*' || c == '\\') + break; + p++; + c = *p; + if (c == '\n' || c == '*' || c == '\\') + break; + p++; + } + /* now we can handle all the cases */ + if (c == '\n') { + file->line_num++; + p++; + } else if (c == '*') { + p++; + for(;;) { + c = *p; + if (c == '*') { + p++; + } else if (c == '/') { + goto end_of_comment; + } else if (c == '\\') { + file->buf_ptr = p; + c = handle_eob(); + p = file->buf_ptr; + if (c == '\\') { + /* skip '\[\r]\n', otherwise just skip the stray */ + while (c == '\\') { + PEEKC_EOB(c, p); + if (c == '\n') { + file->line_num++; + PEEKC_EOB(c, p); + } else if (c == '\r') { + PEEKC_EOB(c, p); + if (c == '\n') { + file->line_num++; + PEEKC_EOB(c, p); + } + } else { + goto after_star; + } + } + } + } else { + break; + } + } + after_star: ; + } else { + /* stray, eob or eof */ + file->buf_ptr = p; + c = handle_eob(); + p = file->buf_ptr; + if (c == CH_EOF) { + error("unexpected end of file in comment"); + } else if (c == '\\') { + p++; + } + } + } + end_of_comment: + p++; + return p; +} + +#define cinp minp + +/* space exlcuding newline */ +static inline int is_space(int ch) +{ + return ch == ' ' || ch == '\t' || ch == '\v' || ch == '\f' || ch == '\r'; +} + +static inline void skip_spaces(void) +{ + while (is_space(ch)) + cinp(); +} + +/* parse a string without interpreting escapes */ +static uint8_t *parse_pp_string(uint8_t *p, + int sep, CString *str) +{ + int c; + p++; + for(;;) { + c = *p; + if (c == sep) { + break; + } else if (c == '\\') { + file->buf_ptr = p; + c = handle_eob(); + p = file->buf_ptr; + if (c == CH_EOF) { + unterminated_string: + /* XXX: indicate line number of start of string */ + error("missing terminating %c character", sep); + } else if (c == '\\') { + /* escape : just skip \[\r]\n */ + PEEKC_EOB(c, p); + if (c == '\n') { + file->line_num++; + p++; + } else if (c == '\r') { + PEEKC_EOB(c, p); + if (c != '\n') + expect("'\n' after '\r'"); + file->line_num++; + p++; + } else if (c == CH_EOF) { + goto unterminated_string; + } else { + if (str) { + cstr_ccat(str, '\\'); + cstr_ccat(str, c); + } + p++; + } + } + } else if (c == '\n') { + file->line_num++; + goto add_char; + } else if (c == '\r') { + PEEKC_EOB(c, p); + if (c != '\n') { + if (str) + cstr_ccat(str, '\r'); + } else { + file->line_num++; + goto add_char; + } + } else { + add_char: + if (str) + cstr_ccat(str, c); + p++; + } + } + p++; + return p; +} + +/* skip block of text until #else, #elif or #endif. skip also pairs of + #if/#endif */ +void preprocess_skip(void) +{ + int a, start_of_line, c; + uint8_t *p; + + p = file->buf_ptr; + start_of_line = 1; + a = 0; + for(;;) { + redo_no_start: + c = *p; + switch(c) { + case ' ': + case '\t': + case '\f': + case '\v': + case '\r': + p++; + goto redo_no_start; + case '\n': + start_of_line = 1; + file->line_num++; + p++; + goto redo_no_start; + case '\\': + file->buf_ptr = p; + c = handle_eob(); + if (c == CH_EOF) { + expect("#endif"); + } else if (c == '\\') { + /* XXX: incorrect: should not give an error */ + ch = file->buf_ptr[0]; + handle_stray(); + } + p = file->buf_ptr; + goto redo_no_start; + /* skip strings */ + case '\"': + case '\'': + p = parse_pp_string(p, c, NULL); + break; + /* skip comments */ + case '/': + file->buf_ptr = p; + ch = *p; + minp(); + p = file->buf_ptr; + if (ch == '*') { + p = parse_comment(p); + } else if (ch == '/') { + p = parse_line_comment(p); + } + break; + + case '#': + p++; + if (start_of_line) { + file->buf_ptr = p; + next_nomacro(); + p = file->buf_ptr; + if (a == 0 && + (tok == TOK_ELSE || tok == TOK_ELIF || tok == TOK_ENDIF)) + goto the_end; + if (tok == TOK_IF || tok == TOK_IFDEF || tok == TOK_IFNDEF) + a++; + else if (tok == TOK_ENDIF) + a--; + } + break; + default: + p++; + break; + } + start_of_line = 0; + } + the_end: ; + file->buf_ptr = p; +} + +/* ParseState handling */ + +/* XXX: currently, no include file info is stored. Thus, we cannot display + accurate messages if the function or data definition spans multiple + files */ + +/* save current parse state in 's' */ +void save_parse_state(ParseState *s) +{ + s->line_num = file->line_num; + s->macro_ptr = macro_ptr; + s->tok = tok; + s->tokc = tokc; +} + +/* restore parse state from 's' */ +void restore_parse_state(ParseState *s) +{ + file->line_num = s->line_num; + macro_ptr = s->macro_ptr; + tok = s->tok; + tokc = s->tokc; +} + +/* return the number of additional 'ints' necessary to store the + token */ +static inline int tok_ext_size(int t) +{ + switch(t) { + /* 4 bytes */ + case TOK_CINT: + case TOK_CUINT: + case TOK_CCHAR: + case TOK_LCHAR: + case TOK_CFLOAT: // FIXME: is that correct? +#ifdef TCC_TARGET_816 + case TOK_CDOUBLE: + case TOK_CLDOUBLE: +#endif + case TOK_LINENUM: + return 1; + case TOK_STR: + case TOK_LSTR: + case TOK_PPNUM: + error("unsupported token"); + return 1; +#ifndef TCC_TARGET_816 + case TOK_CLDOUBLE: + return LDOUBLE_SIZE / 4; + case TOK_CDOUBLE: +#endif + case TOK_CLLONG: + case TOK_CULLONG: + return 2; + default: + return 0; + } +} + +/* token string handling */ + +static inline void tok_str_new(TokenString *s) +{ + s->str = NULL; + s->len = 0; + s->allocated_len = 0; + s->last_line_num = -1; +} + +static void tok_str_free(int *str) +{ + tcc_free(str); +} + +static int *tok_str_realloc(TokenString *s) +{ + int *str, len; + + if (s->allocated_len == 0) { + len = 8; + } else { + len = s->allocated_len * 2; + } + str = tcc_realloc(s->str, len * sizeof(int)); + if (!str) + error("memory full"); + s->allocated_len = len; + s->str = str; + return str; +} + +static void tok_str_add(TokenString *s, int t) +{ + int len, *str; + + len = s->len; + str = s->str; + if (len >= s->allocated_len) + str = tok_str_realloc(s); + str[len++] = t; + s->len = len; +} + +static void tok_str_add2(TokenString *s, int t, CValue *cv) +{ + int len, *str; + + len = s->len; + str = s->str; + + /* allocate space for worst case */ + if (len + TOK_MAX_SIZE > s->allocated_len) + str = tok_str_realloc(s); + str[len++] = t; + switch(t) { + case TOK_CINT: + case TOK_CUINT: + case TOK_CCHAR: + case TOK_LCHAR: + case TOK_CFLOAT: +#ifdef TCC_TARGET_816 + case TOK_CDOUBLE: +#endif + case TOK_LINENUM: + str[len++] = cv->tab[0]; + break; + case TOK_PPNUM: + case TOK_STR: + case TOK_LSTR: + { + int nb_words; + CString *cstr; + + nb_words = (sizeof(CString) + cv->cstr->size + 3) >> 2; + while ((len + nb_words) > s->allocated_len) + str = tok_str_realloc(s); + cstr = (CString *)(str + len); + cstr->data = NULL; + cstr->size = cv->cstr->size; + cstr->data_allocated = NULL; + cstr->size_allocated = cstr->size; + memcpy((char *)cstr + sizeof(CString), + cv->cstr->data, cstr->size); + len += nb_words; + } + break; +#ifndef TCC_TARGET_816 + case TOK_CDOUBLE: +#endif + case TOK_CLLONG: + case TOK_CULLONG: +#if LDOUBLE_SIZE == 8 + case TOK_CLDOUBLE: +#endif + str[len++] = cv->tab[0]; + str[len++] = cv->tab[1]; + break; +#if LDOUBLE_SIZE == 12 + case TOK_CLDOUBLE: + str[len++] = cv->tab[0]; + str[len++] = cv->tab[1]; + str[len++] = cv->tab[2]; +#elif LDOUBLE_SIZE != 8 +#error add long double size support +#endif + break; + default: + break; + } + s->len = len; +} + +/* add the current parse token in token string 's' */ +static void tok_str_add_tok(TokenString *s) +{ + CValue cval; + + /* save line number info */ + if (file->line_num != s->last_line_num) { + s->last_line_num = file->line_num; + cval.i = s->last_line_num; + tok_str_add2(s, TOK_LINENUM, &cval); + } + tok_str_add2(s, tok, &tokc); +} + +#if LDOUBLE_SIZE == 12 +#define LDOUBLE_GET(p, cv) \ + cv.tab[0] = p[0]; \ + cv.tab[1] = p[1]; \ + cv.tab[2] = p[2]; +#elif LDOUBLE_SIZE == 8 +#define LDOUBLE_GET(p, cv) \ + cv.tab[0] = p[0]; \ + cv.tab[1] = p[1]; +#else +#error add long double size support +#endif + + +/* get a token from an integer array and increment pointer + accordingly. we code it as a macro to avoid pointer aliasing. */ +#define TOK_GET(t, p, cv) \ +{ \ + t = *p++; \ + switch(t) { \ + case TOK_CINT: \ + case TOK_CUINT: \ + case TOK_CCHAR: \ + case TOK_LCHAR: \ + case TOK_CFLOAT: /* this is correct (compiler ints array) */ \ + case TOK_CDOUBLE: /* FIXME: make portable */ \ + case TOK_LINENUM: \ + cv.tab[0] = *p++; \ + break; \ + case TOK_STR: \ + case TOK_LSTR: \ + case TOK_PPNUM: \ + cv.cstr = (CString *)p; \ + cv.cstr->data = (char *)p + sizeof(CString);\ + p += (sizeof(CString) + cv.cstr->size + 3) >> 2;\ + break; \ + /* case TOK_CDOUBLE: */ \ + case TOK_CLLONG: \ + case TOK_CULLONG: \ + cv.tab[0] = p[0]; \ + cv.tab[1] = p[1]; \ + p += 2; \ + break; \ + case TOK_CLDOUBLE: \ + LDOUBLE_GET(p, cv); \ + p += LDOUBLE_SIZE / 4; \ + break; \ + default: \ + break; \ + } \ +} + +/* defines handling */ +static inline void define_push(int v, int macro_type, int *str, Sym *first_arg) +{ + Sym *s; + + s = sym_push2(&define_stack, v, macro_type, (long)str); + s->next = first_arg; + table_ident[v - TOK_IDENT]->sym_define = s; +} + +/* undefined a define symbol. Its name is just set to zero */ +static void define_undef(Sym *s) +{ + int v; + v = s->v; + if (v >= TOK_IDENT && v < tok_ident) + table_ident[v - TOK_IDENT]->sym_define = NULL; + s->v = 0; +} + +static inline Sym *define_find(int v) +{ + v -= TOK_IDENT; + if ((unsigned)v >= (unsigned)(tok_ident - TOK_IDENT)) + return NULL; + return table_ident[v]->sym_define; +} + +/* free define stack until top reaches 'b' */ +static void free_defines(Sym *b) +{ + Sym *top, *top1; + int v; + + top = define_stack; + while (top != b) { + top1 = top->prev; + /* do not free args or predefined defines */ + if (top->c) + tok_str_free((int *)top->c); + v = top->v; + if (v >= TOK_IDENT && v < tok_ident) + table_ident[v - TOK_IDENT]->sym_define = NULL; + sym_free(top); + top = top1; + } + define_stack = b; +} + +/* label lookup */ +static Sym *label_find(int v) +{ + v -= TOK_IDENT; + if ((unsigned)v >= (unsigned)(tok_ident - TOK_IDENT)) + return NULL; + return table_ident[v]->sym_label; +} + +static Sym *label_push(Sym **ptop, int v, int flags) +{ + Sym *s, **ps; + s = sym_push2(ptop, v, 0, 0); + s->r = flags; + ps = &table_ident[v - TOK_IDENT]->sym_label; + if (ptop == &global_label_stack) { + /* modify the top most local identifier, so that + sym_identifier will point to 's' when popped */ + while (*ps != NULL) + ps = &(*ps)->prev_tok; + } + s->prev_tok = *ps; + *ps = s; + return s; +} + +/* pop labels until element last is reached. Look if any labels are + undefined. Define symbols if '&&label' was used. */ +static void label_pop(Sym **ptop, Sym *slast) +{ + Sym *s, *s1; + for(s = *ptop; s != slast; s = s1) { + s1 = s->prev; + if (s->r == LABEL_DECLARED) { + warning("label '%s' declared but not used", get_tok_str(s->v, NULL)); + } else if (s->r == LABEL_FORWARD) { + error("label '%s' used but not defined", + get_tok_str(s->v, NULL)); + } else { + if (s->c) { + /* define corresponding symbol. A size of + 1 is put. */ + put_extern_sym(s, cur_text_section, (long)s->next, 1); + } + } + /* remove label */ + table_ident[s->v - TOK_IDENT]->sym_label = s->prev_tok; + sym_free(s); + } + *ptop = slast; +} + +/* eval an expression for #if/#elif */ +static int expr_preprocess(void) +{ + int c, t; + TokenString str; + + tok_str_new(&str); + while (tok != TOK_LINEFEED && tok != TOK_EOF) { + next(); /* do macro subst */ + if (tok == TOK_DEFINED) { + next_nomacro(); + t = tok; + if (t == '(') + next_nomacro(); + c = define_find(tok) != 0; + if (t == '(') + next_nomacro(); + tok = TOK_CINT; + tokc.i = c; + } else if (tok >= TOK_IDENT) { + /* if undefined macro */ + tok = TOK_CINT; + tokc.i = 0; + } + tok_str_add_tok(&str); + } + tok_str_add(&str, -1); /* simulate end of file */ + tok_str_add(&str, 0); + /* now evaluate C constant expression */ + macro_ptr = str.str; + next(); + c = expr_const(); + macro_ptr = NULL; + tok_str_free(str.str); + return c != 0; +} + +#if defined(PARSE_DEBUG) || defined(PP_DEBUG) +static void tok_print(int *str) +{ + int t; + CValue cval; + + while (1) { + TOK_GET(t, str, cval); + if (!t) + break; + printf(" %s", get_tok_str(t, &cval)); + } + printf("\n"); +} +#endif + +/* parse after #define */ +static void parse_define(void) +{ + Sym *s, *first, **ps; + int v, t, varg, is_vaargs, c; + TokenString str; + + v = tok; + if (v < TOK_IDENT) + error("invalid macro name '%s'", get_tok_str(tok, &tokc)); + /* XXX: should check if same macro (ANSI) */ + first = NULL; + t = MACRO_OBJ; + /* '(' must be just after macro definition for MACRO_FUNC */ + c = file->buf_ptr[0]; + if (c == '\\') + c = handle_stray1(file->buf_ptr); + if (c == '(') { + next_nomacro(); + next_nomacro(); + ps = &first; + while (tok != ')') { + varg = tok; + next_nomacro(); + is_vaargs = 0; + if (varg == TOK_DOTS) { + varg = TOK___VA_ARGS__; + is_vaargs = 1; + } else if (tok == TOK_DOTS && gnu_ext) { + is_vaargs = 1; + next_nomacro(); + } + if (varg < TOK_IDENT) + error("badly punctuated parameter list"); + s = sym_push2(&define_stack, varg | SYM_FIELD, is_vaargs, 0); + *ps = s; + ps = &s->next; + if (tok != ',') + break; + next_nomacro(); + } + t = MACRO_FUNC; + } + tok_str_new(&str); + next_nomacro(); + /* EOF testing necessary for '-D' handling */ + while (tok != TOK_LINEFEED && tok != TOK_EOF) { + tok_str_add2(&str, tok, &tokc); + next_nomacro(); + } + tok_str_add(&str, 0); +#ifdef PP_DEBUG + printf("define %s %d: ", get_tok_str(v, NULL), t); + tok_print(str.str); +#endif + define_push(v, t, str.str, first); +} + +static inline int hash_cached_include(int type, const char *filename) +{ + const unsigned char *s; + unsigned int h; + + h = TOK_HASH_INIT; + h = TOK_HASH_FUNC(h, type); + s = filename; + while (*s) { + h = TOK_HASH_FUNC(h, *s); + s++; + } + h &= (CACHED_INCLUDES_HASH_SIZE - 1); + return h; +} + +/* XXX: use a token or a hash table to accelerate matching ? */ +static CachedInclude *search_cached_include(TCCState *s1, + int type, const char *filename) +{ + CachedInclude *e; + int i, h; + h = hash_cached_include(type, filename); + i = s1->cached_includes_hash[h]; + for(;;) { + if (i == 0) + break; + e = s1->cached_includes[i - 1]; + if (e->type == type && !strcmp(e->filename, filename)) + return e; + i = e->hash_next; + } + return NULL; +} + +static inline void add_cached_include(TCCState *s1, int type, + const char *filename, int ifndef_macro) +{ + CachedInclude *e; + int h; + + if (search_cached_include(s1, type, filename)) + return; +#ifdef INC_DEBUG + printf("adding cached '%s' %s\n", filename, get_tok_str(ifndef_macro, NULL)); +#endif + e = tcc_malloc(sizeof(CachedInclude) + strlen(filename)); + if (!e) + return; + e->type = type; + strcpy(e->filename, filename); + e->ifndef_macro = ifndef_macro; + dynarray_add((void ***)&s1->cached_includes, &s1->nb_cached_includes, e); + /* add in hash table */ + h = hash_cached_include(type, filename); + e->hash_next = s1->cached_includes_hash[h]; + s1->cached_includes_hash[h] = s1->nb_cached_includes; +} + +static void pragma_parse(TCCState *s1) +{ + int val; + + next(); + if (tok == TOK_pack) { + /* + This may be: + #pragma pack(1) // set + #pragma pack() // reset to default + #pragma pack(push,1) // push & set + #pragma pack(pop) // restore previous + */ + next(); + skip('('); + if (tok == TOK_ASM_pop) { + next(); + if (s1->pack_stack_ptr <= s1->pack_stack) { + stk_error: + error("out of pack stack"); + } + s1->pack_stack_ptr--; + } else { + val = 0; + if (tok != ')') { + if (tok == TOK_ASM_push) { + next(); + if (s1->pack_stack_ptr >= s1->pack_stack + PACK_STACK_SIZE - 1) + goto stk_error; + s1->pack_stack_ptr++; + skip(','); + } + if (tok != TOK_CINT) { + pack_error: + error("invalid pack pragma"); + } + val = tokc.i; + if (val < 1 || val > 16 || (val & (val - 1)) != 0) + goto pack_error; + next(); + } + *s1->pack_stack_ptr = val; + skip(')'); + } + } +} + +/* is_bof is true if first non space token at beginning of file */ +static void preprocess(int is_bof) +{ + TCCState *s1 = tcc_state; + int size, i, c, n, saved_parse_flags; + char buf[1024], *q, *p; + char buf1[1024]; + BufferedFile *f; + Sym *s; + CachedInclude *e; + + saved_parse_flags = parse_flags; + parse_flags = PARSE_FLAG_PREPROCESS | PARSE_FLAG_TOK_NUM | + PARSE_FLAG_LINEFEED; + next_nomacro(); + redo: + switch(tok) { + case TOK_DEFINE: + next_nomacro(); + parse_define(); + break; + case TOK_UNDEF: + next_nomacro(); + s = define_find(tok); + /* undefine symbol by putting an invalid name */ + if (s) + define_undef(s); + break; + case TOK_INCLUDE: + case TOK_INCLUDE_NEXT: + ch = file->buf_ptr[0]; + /* XXX: incorrect if comments : use next_nomacro with a special mode */ + skip_spaces(); + if (ch == '<') { + c = '>'; + goto read_name; + } else if (ch == '\"') { + c = ch; + read_name: + /* XXX: better stray handling */ + minp(); + q = buf; + while (ch != c && ch != '\n' && ch != CH_EOF) { + if ((q - buf) < sizeof(buf) - 1) + *q++ = ch; + minp(); + } + *q = '\0'; + minp(); +#if 0 + /* eat all spaces and comments after include */ + /* XXX: slightly incorrect */ + while (ch1 != '\n' && ch1 != CH_EOF) + inp(); +#endif + } else { + /* computed #include : either we have only strings or + we have anything enclosed in '<>' */ + next(); + buf[0] = '\0'; + if (tok == TOK_STR) { + while (tok != TOK_LINEFEED) { + if (tok != TOK_STR) { + include_syntax: + error("'#include' expects \"FILENAME\" or "); + } + pstrcat(buf, sizeof(buf), (char *)tokc.cstr->data); + next(); + } + c = '\"'; + } else { + int len; + while (tok != TOK_LINEFEED) { + pstrcat(buf, sizeof(buf), get_tok_str(tok, &tokc)); + next(); + } + len = strlen(buf); + /* check syntax and remove '<>' */ + if (len < 2 || buf[0] != '<' || buf[len - 1] != '>') + goto include_syntax; + memmove(buf, buf + 1, len - 2); + buf[len - 2] = '\0'; + c = '>'; + } + } + + e = search_cached_include(s1, c, buf); + if (e && define_find(e->ifndef_macro)) { + /* no need to parse the include because the 'ifndef macro' + is defined */ +#ifdef INC_DEBUG + printf("%s: skipping %s\n", file->filename, buf); +#endif + } else { + if (c == '\"') { + /* first search in current dir if "header.h" */ + size = 0; + p = strrchr(file->filename, '/'); + if (p) + size = p + 1 - file->filename; + if (size > sizeof(buf1) - 1) + size = sizeof(buf1) - 1; + memcpy(buf1, file->filename, size); + buf1[size] = '\0'; + pstrcat(buf1, sizeof(buf1), buf); + f = tcc_open(s1, buf1); + if (f) { + if (tok == TOK_INCLUDE_NEXT) + tok = TOK_INCLUDE; + else + goto found; + } + } + if (s1->include_stack_ptr >= s1->include_stack + INCLUDE_STACK_SIZE) + error("#include recursion too deep"); + /* now search in all the include paths */ + n = s1->nb_include_paths + s1->nb_sysinclude_paths; + for(i = 0; i < n; i++) { + const char *path; + if (i < s1->nb_include_paths) + path = s1->include_paths[i]; + else + path = s1->sysinclude_paths[i - s1->nb_include_paths]; + pstrcpy(buf1, sizeof(buf1), path); + pstrcat(buf1, sizeof(buf1), "/"); + pstrcat(buf1, sizeof(buf1), buf); + f = tcc_open(s1, buf1); + if (f) { + if (tok == TOK_INCLUDE_NEXT) + tok = TOK_INCLUDE; + else + goto found; + } + } + error("include file '%s' not found", buf); + f = NULL; + found: +#ifdef INC_DEBUG + printf("%s: including %s\n", file->filename, buf1); +#endif + f->inc_type = c; + pstrcpy(f->inc_filename, sizeof(f->inc_filename), buf); + /* push current file in stack */ + /* XXX: fix current line init */ + *s1->include_stack_ptr++ = file; + file = f; + /* add include file debug info */ + if (do_debug) { + put_stabs(file->filename, N_BINCL, 0, 0, 0); + } + tok_flags |= TOK_FLAG_BOF | TOK_FLAG_BOL; + ch = file->buf_ptr[0]; + goto the_end; + } + break; + case TOK_IFNDEF: + c = 1; + goto do_ifdef; + case TOK_IF: + c = expr_preprocess(); + goto do_if; + case TOK_IFDEF: + c = 0; + do_ifdef: + next_nomacro(); + if (tok < TOK_IDENT) + error("invalid argument for '#if%sdef'", c ? "n" : ""); + if (is_bof) { + if (c) { +#ifdef INC_DEBUG + printf("#ifndef %s\n", get_tok_str(tok, NULL)); +#endif + file->ifndef_macro = tok; + } + } + c = (define_find(tok) != 0) ^ c; + do_if: + if (s1->ifdef_stack_ptr >= s1->ifdef_stack + IFDEF_STACK_SIZE) + error("memory full"); + *s1->ifdef_stack_ptr++ = c; + goto test_skip; + case TOK_ELSE: + if (s1->ifdef_stack_ptr == s1->ifdef_stack) + error("#else without matching #if"); + if (s1->ifdef_stack_ptr[-1] & 2) + error("#else after #else"); + c = (s1->ifdef_stack_ptr[-1] ^= 3); + goto test_skip; + case TOK_ELIF: + if (s1->ifdef_stack_ptr == s1->ifdef_stack) + error("#elif without matching #if"); + c = s1->ifdef_stack_ptr[-1]; + if (c > 1) + error("#elif after #else"); + /* last #if/#elif expression was true: we skip */ + if (c == 1) + goto skip; + c = expr_preprocess(); + s1->ifdef_stack_ptr[-1] = c; + test_skip: + if (!(c & 1)) { + skip: + preprocess_skip(); + is_bof = 0; + goto redo; + } + break; + case TOK_ENDIF: + if (s1->ifdef_stack_ptr <= file->ifdef_stack_ptr) + error("#endif without matching #if"); + s1->ifdef_stack_ptr--; + /* '#ifndef macro' was at the start of file. Now we check if + an '#endif' is exactly at the end of file */ + if (file->ifndef_macro && + s1->ifdef_stack_ptr == file->ifdef_stack_ptr) { + file->ifndef_macro_saved = file->ifndef_macro; + /* need to set to zero to avoid false matches if another + #ifndef at middle of file */ + file->ifndef_macro = 0; + while (tok != TOK_LINEFEED) + next_nomacro(); + tok_flags |= TOK_FLAG_ENDIF; + goto the_end; + } + break; + case TOK_LINE: + next(); + if (tok != TOK_CINT) + error("#line"); + file->line_num = tokc.i - 1; /* the line number will be incremented after */ + next(); + if (tok != TOK_LINEFEED) { + if (tok != TOK_STR) + error("#line"); + pstrcpy(file->filename, sizeof(file->filename), + (char *)tokc.cstr->data); + } + break; + case TOK_ERROR: + case TOK_WARNING: + c = tok; + ch = file->buf_ptr[0]; + skip_spaces(); + q = buf; + while (ch != '\n' && ch != CH_EOF) { + if ((q - buf) < sizeof(buf) - 1) + *q++ = ch; + minp(); + } + *q = '\0'; + if (c == TOK_ERROR) + error("#error %s", buf); + else + warning("#warning %s", buf); + break; + case TOK_PRAGMA: + pragma_parse(s1); + break; + default: + if (tok == TOK_LINEFEED || tok == '!' || tok == TOK_CINT) { + /* '!' is ignored to allow C scripts. numbers are ignored + to emulate cpp behaviour */ + } else { + if (!(saved_parse_flags & PARSE_FLAG_ASM_COMMENTS)) + error("invalid preprocessing directive #%s", get_tok_str(tok, &tokc)); + } + break; + } + /* ignore other preprocess commands or #! for C scripts */ + while (tok != TOK_LINEFEED) + next_nomacro(); + the_end: + parse_flags = saved_parse_flags; +} + +/* evaluate escape codes in a string. */ +static void parse_escape_string(CString *outstr, const uint8_t *buf, int is_long) +{ + int c, n; + const uint8_t *p; + + p = buf; + for(;;) { + c = *p; + if (c == '\0') + break; + if (c == '\\') { + p++; + /* escape */ + c = *p; + switch(c) { + case '0': case '1': case '2': case '3': + case '4': case '5': case '6': case '7': + /* at most three octal digits */ + n = c - '0'; + p++; + c = *p; + if (isoct(c)) { + n = n * 8 + c - '0'; + p++; + c = *p; + if (isoct(c)) { + n = n * 8 + c - '0'; + p++; + } + } + c = n; + goto add_char_nonext; + case 'x': + p++; + n = 0; + for(;;) { + c = *p; + if (c >= 'a' && c <= 'f') + c = c - 'a' + 10; + else if (c >= 'A' && c <= 'F') + c = c - 'A' + 10; + else if (isnum(c)) + c = c - '0'; + else + break; + n = n * 16 + c; + p++; + } + c = n; + goto add_char_nonext; + case 'a': + c = '\a'; + break; + case 'b': + c = '\b'; + break; + case 'f': + c = '\f'; + break; + case 'n': + c = '\n'; + break; + case 'r': + c = '\r'; + break; + case 't': + c = '\t'; + break; + case 'v': + c = '\v'; + break; + case 'e': + if (!gnu_ext) + goto invalid_escape; + c = 27; + break; + case '\'': + case '\"': + case '\\': + case '?': + break; + default: + invalid_escape: + if (c >= '!' && c <= '~') + warning("unknown escape sequence: \'\\%c\'", c); + else + warning("unknown escape sequence: \'\\x%x\'", c); + break; + } + } + p++; + add_char_nonext: + if (!is_long) + cstr_ccat(outstr, c); + else + cstr_wccat(outstr, c); + } + /* add a trailing '\0' */ + if (!is_long) + cstr_ccat(outstr, '\0'); + else + cstr_wccat(outstr, '\0'); +} + +/* we use 64 bit numbers */ +#define BN_SIZE 2 + +/* bn = (bn << shift) | or_val */ +void bn_lshift(unsigned int *bn, int shift, int or_val) +{ + int i; + unsigned int v; + for(i=0;i> (32 - shift); + } +} + +void bn_zero(unsigned int *bn) +{ + int i; + for(i=0;i= 'a' && ch <= 'f') + t = ch - 'a' + 10; + else if (ch >= 'A' && ch <= 'F') + t = ch - 'A' + 10; + else if (isnum(ch)) + t = ch - '0'; + else + break; + if (t >= b) + break; + if (q >= token_buf + STRING_MAX_SIZE) { + num_too_long: + error("number too long"); + } + *q++ = ch; + ch = *p++; + } + if (ch == '.' || + ((ch == 'e' || ch == 'E') && b == 10) || + ((ch == 'p' || ch == 'P') && (b == 16 || b == 2))) { + if (b != 10) { + /* NOTE: strtox should support that for hexa numbers, but + non ISOC99 libcs do not support it, so we prefer to do + it by hand */ + /* hexadecimal or binary floats */ + /* XXX: handle overflows */ + *q = '\0'; + if (b == 16) + shift = 4; + else + shift = 2; + bn_zero(bn); + q = token_buf; + while (1) { + t = *q++; + if (t == '\0') { + break; + } else if (t >= 'a') { + t = t - 'a' + 10; + } else if (t >= 'A') { + t = t - 'A' + 10; + } else { + t = t - '0'; + } + bn_lshift(bn, shift, t); + } + frac_bits = 0; + if (ch == '.') { + ch = *p++; + while (1) { + t = ch; + if (t >= 'a' && t <= 'f') { + t = t - 'a' + 10; + } else if (t >= 'A' && t <= 'F') { + t = t - 'A' + 10; + } else if (t >= '0' && t <= '9') { + t = t - '0'; + } else { + break; + } + if (t >= b) + error("invalid digit"); + bn_lshift(bn, shift, t); + frac_bits += shift; + ch = *p++; + } + } + if (ch != 'p' && ch != 'P') + expect("exponent"); + ch = *p++; + s = 1; + exp_val = 0; + if (ch == '+') { + ch = *p++; + } else if (ch == '-') { + s = -1; + ch = *p++; + } + if (ch < '0' || ch > '9') + expect("exponent digits"); + while (ch >= '0' && ch <= '9') { + exp_val = exp_val * 10 + ch - '0'; + ch = *p++; + } + exp_val = exp_val * s; + + /* now we can generate the number */ + /* XXX: should patch directly float number */ + d = (double)bn[1] * 4294967296.0 + (double)bn[0]; + d = ldexp(d, exp_val - frac_bits); + t = toup(ch); + if (t == 'F') { + ch = *p++; + tok = TOK_CFLOAT; + /* float : should handle overflow */ + tokc.f = (float)d; + } else if (t == 'L') { + ch = *p++; +#ifdef TCC_TARGET_816 + tok = TOK_CFLOAT; + tokc.f = d; +#else + tok = TOK_CLDOUBLE; + /* XXX: not large enough */ + tokc.ld = (long double)d; +#endif + } else { +#ifdef TCC_TARGET_816 + tok = TOK_CFLOAT; + tokc.f = d; +#else + tok = TOK_CDOUBLE; + tokc.d = d; +#endif + } + } else { + /* decimal floats */ + if (ch == '.') { + if (q >= token_buf + STRING_MAX_SIZE) + goto num_too_long; + *q++ = ch; + ch = *p++; + float_frac_parse: + while (ch >= '0' && ch <= '9') { + if (q >= token_buf + STRING_MAX_SIZE) + goto num_too_long; + *q++ = ch; + ch = *p++; + } + } + if (ch == 'e' || ch == 'E') { + if (q >= token_buf + STRING_MAX_SIZE) + goto num_too_long; + *q++ = ch; + ch = *p++; + if (ch == '-' || ch == '+') { + if (q >= token_buf + STRING_MAX_SIZE) + goto num_too_long; + *q++ = ch; + ch = *p++; + } + if (ch < '0' || ch > '9') + expect("exponent digits"); + while (ch >= '0' && ch <= '9') { + if (q >= token_buf + STRING_MAX_SIZE) + goto num_too_long; + *q++ = ch; + ch = *p++; + } + } + *q = '\0'; + t = toup(ch); + errno = 0; + if (t == 'F') { + ch = *p++; + tok = TOK_CFLOAT; + tokc.f = strtof(token_buf, NULL); + } else if (t == 'L') { + ch = *p++; +#ifdef TCC_TARGET_816 + tok = TOK_CFLOAT; + tokc.f = strtof(token_buf, NULL); +#else + tok = TOK_CLDOUBLE; + tokc.ld = strtold(token_buf, NULL); +#endif + } else { +#ifdef TCC_TARGET_816 + tok = TOK_CFLOAT; + tokc.f = strtof(token_buf, NULL); +#else + tok = TOK_CDOUBLE; + tokc.d = strtod(token_buf, NULL); +#endif + } + } + } else { + unsigned long long n, n1; + int lcount, ucount; + + /* integer number */ + *q = '\0'; + q = token_buf; + if (b == 10 && *q == '0') { + b = 8; + q++; + } + n = 0; + while(1) { + t = *q++; + /* no need for checks except for base 10 / 8 errors */ + if (t == '\0') { + break; + } else if (t >= 'a') { + t = t - 'a' + 10; + } else if (t >= 'A') { + t = t - 'A' + 10; + } else { + t = t - '0'; + if (t >= b) + error("invalid digit"); + } + n1 = n; + n = n * b + t; + /* detect overflow */ + /* XXX: this test is not reliable */ + if (n < n1) + error("integer constant overflow"); + } + + /* XXX: not exactly ANSI compliant */ + if ((n & 0xffffffff00000000LL) != 0) { + if ((n >> 63) != 0) + tok = TOK_CULLONG; + else + tok = TOK_CLLONG; + } else if (n > 0x7fffffff) { + tok = TOK_CUINT; + } else { + tok = TOK_CINT; + } + lcount = 0; + ucount = 0; + for(;;) { + t = toup(ch); + if (t == 'L') { + if (lcount >= 2) + error("three 'l's in integer constant"); + lcount++; + if (lcount == 2) { + if (tok == TOK_CINT) + tok = TOK_CLLONG; + else if (tok == TOK_CUINT) + tok = TOK_CULLONG; + } + ch = *p++; + } else if (t == 'U') { + if (ucount >= 1) + error("two 'u's in integer constant"); + ucount++; + if (tok == TOK_CINT) + tok = TOK_CUINT; + else if (tok == TOK_CLLONG) + tok = TOK_CULLONG; + ch = *p++; + } else { + break; + } + } + if (tok == TOK_CINT || tok == TOK_CUINT) + tokc.ui = n; + else + tokc.ull = n; + } +} + + +#define PARSE2(c1, tok1, c2, tok2) \ + case c1: \ + PEEKC(c, p); \ + if (c == c2) { \ + p++; \ + tok = tok2; \ + } else { \ + tok = tok1; \ + } \ + break; + +/* return next token without macro substitution */ +static inline void next_nomacro1(void) +{ + int t, c, is_long; + TokenSym *ts; + uint8_t *p, *p1; + unsigned int h; + + p = file->buf_ptr; + redo_no_start: + c = *p; + switch(c) { + case ' ': + case '\t': + case '\f': + case '\v': + case '\r': + p++; + goto redo_no_start; + + case '\\': + /* first look if it is in fact an end of buffer */ + if (p >= file->buf_end) { + file->buf_ptr = p; + handle_eob(); + p = file->buf_ptr; + if (p >= file->buf_end) + goto parse_eof; + else + goto redo_no_start; + } else { + file->buf_ptr = p; + ch = *p; + handle_stray(); + p = file->buf_ptr; + goto redo_no_start; + } + parse_eof: + { + TCCState *s1 = tcc_state; + if (parse_flags & PARSE_FLAG_LINEFEED) { + tok = TOK_LINEFEED; + } else if (s1->include_stack_ptr == s1->include_stack || + !(parse_flags & PARSE_FLAG_PREPROCESS)) { + /* no include left : end of file. */ + tok = TOK_EOF; + } else { + /* pop include file */ + + /* test if previous '#endif' was after a #ifdef at + start of file */ + if (tok_flags & TOK_FLAG_ENDIF) { +#ifdef INC_DEBUG + printf("#endif %s\n", get_tok_str(file->ifndef_macro_saved, NULL)); +#endif + add_cached_include(s1, file->inc_type, file->inc_filename, + file->ifndef_macro_saved); + } + + /* add end of include file debug info */ + if (do_debug) { + put_stabd(N_EINCL, 0, 0); + } + /* pop include stack */ + tcc_close(file); + s1->include_stack_ptr--; + file = *s1->include_stack_ptr; + p = file->buf_ptr; + goto redo_no_start; + } + } + break; + + case '\n': + if (parse_flags & PARSE_FLAG_LINEFEED) { + tok = TOK_LINEFEED; + } else { + file->line_num++; + tok_flags |= TOK_FLAG_BOL; + p++; + goto redo_no_start; + } + break; + + case '#': + /* XXX: simplify */ + PEEKC(c, p); + if ((tok_flags & TOK_FLAG_BOL) && + (parse_flags & PARSE_FLAG_PREPROCESS)) { + file->buf_ptr = p; + preprocess(tok_flags & TOK_FLAG_BOF); + p = file->buf_ptr; + goto redo_no_start; + } else { + if (c == '#') { + p++; + tok = TOK_TWOSHARPS; + } else { + if (parse_flags & PARSE_FLAG_ASM_COMMENTS) { + p = parse_line_comment(p - 1); + goto redo_no_start; + } else { + tok = '#'; + } + } + } + break; + + case 'a': case 'b': case 'c': case 'd': + case 'e': case 'f': case 'g': case 'h': + case 'i': case 'j': case 'k': case 'l': + case 'm': case 'n': case 'o': case 'p': + case 'q': case 'r': case 's': case 't': + case 'u': case 'v': case 'w': case 'x': + case 'y': case 'z': + case 'A': case 'B': case 'C': case 'D': + case 'E': case 'F': case 'G': case 'H': + case 'I': case 'J': case 'K': + case 'M': case 'N': case 'O': case 'P': + case 'Q': case 'R': case 'S': case 'T': + case 'U': case 'V': case 'W': case 'X': + case 'Y': case 'Z': + case '_': + parse_ident_fast: + p1 = p; + h = TOK_HASH_INIT; + h = TOK_HASH_FUNC(h, c); + p++; + for(;;) { + c = *p; + if (!isidnum_table[c]) + break; + h = TOK_HASH_FUNC(h, c); + p++; + } + if (c != '\\') { + TokenSym **pts; + int len; + + /* fast case : no stray found, so we have the full token + and we have already hashed it */ + len = p - p1; + h &= (TOK_HASH_SIZE - 1); + pts = &hash_ident[h]; + for(;;) { + ts = *pts; + if (!ts) + break; + if (ts->len == len && !memcmp(ts->str, p1, len)) + goto token_found; + pts = &(ts->hash_next); + } + ts = tok_alloc_new(pts, p1, len); + token_found: ; + } else { + /* slower case */ + cstr_reset(&tokcstr); + + while (p1 < p) { + cstr_ccat(&tokcstr, *p1); + p1++; + } + p--; + PEEKC(c, p); + parse_ident_slow: + while (isidnum_table[c]) { + cstr_ccat(&tokcstr, c); + PEEKC(c, p); + } + ts = tok_alloc(tokcstr.data, tokcstr.size); + } + tok = ts->tok; + break; + case 'L': + t = p[1]; + if (t != '\\' && t != '\'' && t != '\"') { + /* fast case */ + goto parse_ident_fast; + } else { + PEEKC(c, p); + if (c == '\'' || c == '\"') { + is_long = 1; + goto str_const; + } else { + cstr_reset(&tokcstr); + cstr_ccat(&tokcstr, 'L'); + goto parse_ident_slow; + } + } + break; + case '0': case '1': case '2': case '3': + case '4': case '5': case '6': case '7': + case '8': case '9': + + cstr_reset(&tokcstr); + /* after the first digit, accept digits, alpha, '.' or sign if + prefixed by 'eEpP' */ + parse_num: + for(;;) { + t = c; + cstr_ccat(&tokcstr, c); + PEEKC(c, p); + if (!(isnum(c) || isid(c) || c == '.' || + ((c == '+' || c == '-') && + (t == 'e' || t == 'E' || t == 'p' || t == 'P')))) + break; + } + /* We add a trailing '\0' to ease parsing */ + cstr_ccat(&tokcstr, '\0'); + tokc.cstr = &tokcstr; + tok = TOK_PPNUM; + break; + case '.': + /* special dot handling because it can also start a number */ + PEEKC(c, p); + if (isnum(c)) { + cstr_reset(&tokcstr); + cstr_ccat(&tokcstr, '.'); + goto parse_num; + } else if (c == '.') { + PEEKC(c, p); + if (c != '.') + expect("'.'"); + PEEKC(c, p); + tok = TOK_DOTS; + } else { + tok = '.'; + } + break; + case '\'': + case '\"': + is_long = 0; + str_const: + { + CString str; + int sep; + + sep = c; + + /* parse the string */ + cstr_new(&str); + p = parse_pp_string(p, sep, &str); + cstr_ccat(&str, '\0'); + + /* eval the escape (should be done as TOK_PPNUM) */ + cstr_reset(&tokcstr); + parse_escape_string(&tokcstr, str.data, is_long); + cstr_free(&str); + + if (sep == '\'') { + int char_size; + /* XXX: make it portable */ + if (!is_long) + char_size = 1; + else + char_size = sizeof(int); + if (tokcstr.size <= char_size) + error("empty character constant"); + if (tokcstr.size > 2 * char_size) + warning("multi-character character constant"); + if (!is_long) { + tokc.i = *(int8_t *)tokcstr.data; + tok = TOK_CCHAR; + } else { + tokc.i = *(int *)tokcstr.data; + tok = TOK_LCHAR; + } + } else { + tokc.cstr = &tokcstr; + if (!is_long) + tok = TOK_STR; + else + tok = TOK_LSTR; + } + } + break; + + case '<': + PEEKC(c, p); + if (c == '=') { + p++; + tok = TOK_LE; + } else if (c == '<') { + PEEKC(c, p); + if (c == '=') { + p++; + tok = TOK_A_SHL; + } else { + tok = TOK_SHL; + } + } else { + tok = TOK_LT; + } + break; + + case '>': + PEEKC(c, p); + if (c == '=') { + p++; + tok = TOK_GE; + } else if (c == '>') { + PEEKC(c, p); + if (c == '=') { + p++; + tok = TOK_A_SAR; + } else { + tok = TOK_SAR; + } + } else { + tok = TOK_GT; + } + break; + + case '&': + PEEKC(c, p); + if (c == '&') { + p++; + tok = TOK_LAND; + } else if (c == '=') { + p++; + tok = TOK_A_AND; + } else { + tok = '&'; + } + break; + + case '|': + PEEKC(c, p); + if (c == '|') { + p++; + tok = TOK_LOR; + } else if (c == '=') { + p++; + tok = TOK_A_OR; + } else { + tok = '|'; + } + break; + + case '+': + PEEKC(c, p); + if (c == '+') { + p++; + tok = TOK_INC; + } else if (c == '=') { + p++; + tok = TOK_A_ADD; + } else { + tok = '+'; + } + break; + + case '-': + PEEKC(c, p); + if (c == '-') { + p++; + tok = TOK_DEC; + } else if (c == '=') { + p++; + tok = TOK_A_SUB; + } else if (c == '>') { + p++; + tok = TOK_ARROW; + } else { + tok = '-'; + } + break; + + PARSE2('!', '!', '=', TOK_NE) + PARSE2('=', '=', '=', TOK_EQ) + PARSE2('*', '*', '=', TOK_A_MUL) + PARSE2('%', '%', '=', TOK_A_MOD) + PARSE2('^', '^', '=', TOK_A_XOR) + + /* comments or operator */ + case '/': + PEEKC(c, p); + if (c == '*') { + p = parse_comment(p); + goto redo_no_start; + } else if (c == '/') { + p = parse_line_comment(p); + goto redo_no_start; + } else if (c == '=') { + p++; + tok = TOK_A_DIV; + } else { + tok = '/'; + } + break; + + /* simple tokens */ + case '(': + case ')': + case '[': + case ']': + case '{': + case '}': + case ',': + case ';': + case ':': + case '?': + case '~': + case '$': /* only used in assembler */ + case '@': /* dito */ + tok = c; + p++; + break; + default: + error("unrecognized character \\x%02x", c); + break; + } + file->buf_ptr = p; + tok_flags = 0; +#if defined(PARSE_DEBUG) + printf("token = %s\n", get_tok_str(tok, &tokc)); +#endif +} + +/* return next token without macro substitution. Can read input from + macro_ptr buffer */ +static void next_nomacro(void) +{ + if (macro_ptr) { + redo: + tok = *macro_ptr; + if (tok) { + TOK_GET(tok, macro_ptr, tokc); + if (tok == TOK_LINENUM) { + file->line_num = tokc.i; + goto redo; + } + } + } else { + next_nomacro1(); + } +} + +/* substitute args in macro_str and return allocated string */ +static int *macro_arg_subst(Sym **nested_list, int *macro_str, Sym *args) +{ + int *st, last_tok, t, notfirst; + Sym *s; + CValue cval; + TokenString str; + CString cstr; + + tok_str_new(&str); + last_tok = 0; + while(1) { + TOK_GET(t, macro_str, cval); + if (!t) + break; + if (t == '#') { + /* stringize */ + TOK_GET(t, macro_str, cval); + if (!t) + break; + s = sym_find2(args, t); + if (s) { + cstr_new(&cstr); + st = (int *)s->c; + notfirst = 0; + while (*st) { + if (notfirst) + cstr_ccat(&cstr, ' '); + TOK_GET(t, st, cval); + cstr_cat(&cstr, get_tok_str(t, &cval)); + notfirst = 1; + } + cstr_ccat(&cstr, '\0'); +#ifdef PP_DEBUG + printf("stringize: %s\n", (char *)cstr.data); +#endif + /* add string */ + cval.cstr = &cstr; + tok_str_add2(&str, TOK_STR, &cval); + cstr_free(&cstr); + } else { + tok_str_add2(&str, t, &cval); + } + } else if (t >= TOK_IDENT) { + s = sym_find2(args, t); + if (s) { + st = (int *)s->c; + /* if '##' is present before or after, no arg substitution */ + if (*macro_str == TOK_TWOSHARPS || last_tok == TOK_TWOSHARPS) { + /* special case for var arg macros : ## eats the + ',' if empty VA_ARGS variable. */ + /* XXX: test of the ',' is not 100% + reliable. should fix it to avoid security + problems */ + if (gnu_ext && s->type.t && + last_tok == TOK_TWOSHARPS && + str.len >= 2 && str.str[str.len - 2] == ',') { + if (*st == 0) { + /* suppress ',' '##' */ + str.len -= 2; + } else { + /* suppress '##' and add variable */ + str.len--; + goto add_var; + } + } else { + int t1; + add_var: + for(;;) { + TOK_GET(t1, st, cval); + if (!t1) + break; + tok_str_add2(&str, t1, &cval); + } + } + } else { + /* NOTE: the stream cannot be read when macro + substituing an argument */ + macro_subst(&str, nested_list, st, NULL); + } + } else { + tok_str_add(&str, t); + } + } else { + tok_str_add2(&str, t, &cval); + } + last_tok = t; + } + tok_str_add(&str, 0); + return str.str; +} + +static char const ab_month_name[12][4] = +{ + "Jan", "Feb", "Mar", "Apr", "May", "Jun", + "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" +}; + +/* do macro substitution of current token with macro 's' and add + result to (tok_str,tok_len). 'nested_list' is the list of all + macros we got inside to avoid recursing. Return non zero if no + substitution needs to be done */ +static int macro_subst_tok(TokenString *tok_str, + Sym **nested_list, Sym *s, struct macro_level **can_read_stream) +{ + Sym *args, *sa, *sa1; + int mstr_allocated, parlevel, *mstr, t, t1; + TokenString str; + char *cstrval; + CValue cval; + CString cstr; + char buf[32]; + + /* if symbol is a macro, prepare substitution */ + /* special macros */ + if (tok == TOK___LINE__) { + snprintf(buf, sizeof(buf), "%d", file->line_num); + cstrval = buf; + t1 = TOK_PPNUM; + goto add_cstr1; + } else if (tok == TOK___FILE__) { + cstrval = file->filename; + goto add_cstr; + } else if (tok == TOK___DATE__ || tok == TOK___TIME__) { + time_t ti; + struct tm *tm; + + time(&ti); + tm = localtime(&ti); + if (tok == TOK___DATE__) { + snprintf(buf, sizeof(buf), "%s %2d %d", + ab_month_name[tm->tm_mon], tm->tm_mday, tm->tm_year + 1900); + } else { + snprintf(buf, sizeof(buf), "%02d:%02d:%02d", + tm->tm_hour, tm->tm_min, tm->tm_sec); + } + cstrval = buf; + add_cstr: + t1 = TOK_STR; + add_cstr1: + cstr_new(&cstr); + cstr_cat(&cstr, cstrval); + cstr_ccat(&cstr, '\0'); + cval.cstr = &cstr; + tok_str_add2(tok_str, t1, &cval); + cstr_free(&cstr); + } else { + mstr = (int *)s->c; + mstr_allocated = 0; + if (s->type.t == MACRO_FUNC) { + /* NOTE: we do not use next_nomacro to avoid eating the + next token. XXX: find better solution */ + redo: + if (macro_ptr) { + t = *macro_ptr; + if (t == 0 && can_read_stream) { + /* end of macro stream: we must look at the token + after in the file */ + struct macro_level *ml = *can_read_stream; + macro_ptr = NULL; + if (ml) + { + macro_ptr = ml->p; + ml->p = NULL; + *can_read_stream = ml -> prev; + } + goto redo; + } + } else { + /* XXX: incorrect with comments */ + ch = file->buf_ptr[0]; + while (is_space(ch) || ch == '\n') + cinp(); + t = ch; + } + if (t != '(') /* no macro subst */ + return -1; + + /* argument macro */ + next_nomacro(); + next_nomacro(); + args = NULL; + sa = s->next; + /* NOTE: empty args are allowed, except if no args */ + for(;;) { + /* handle '()' case */ + if (!args && !sa && tok == ')') + break; + if (!sa) + error("macro '%s' used with too many args", + get_tok_str(s->v, 0)); + tok_str_new(&str); + parlevel = 0; + /* NOTE: non zero sa->t indicates VA_ARGS */ + while ((parlevel > 0 || + (tok != ')' && + (tok != ',' || sa->type.t))) && + tok != -1) { + if (tok == '(') + parlevel++; + else if (tok == ')') + parlevel--; + tok_str_add2(&str, tok, &tokc); + next_nomacro(); + } + tok_str_add(&str, 0); + sym_push2(&args, sa->v & ~SYM_FIELD, sa->type.t, (long)str.str); + sa = sa->next; + if (tok == ')') { + /* special case for gcc var args: add an empty + var arg argument if it is omitted */ + if (sa && sa->type.t && gnu_ext) + continue; + else + break; + } + if (tok != ',') + expect(","); + next_nomacro(); + } + if (sa) { + error("macro '%s' used with too few args", + get_tok_str(s->v, 0)); + } + + /* now subst each arg */ + mstr = macro_arg_subst(nested_list, mstr, args); + /* free memory */ + sa = args; + while (sa) { + sa1 = sa->prev; + tok_str_free((int *)sa->c); + sym_free(sa); + sa = sa1; + } + mstr_allocated = 1; + } + sym_push2(nested_list, s->v, 0, 0); + macro_subst(tok_str, nested_list, mstr, can_read_stream); + /* pop nested defined symbol */ + sa1 = *nested_list; + *nested_list = sa1->prev; + sym_free(sa1); + if (mstr_allocated) + tok_str_free(mstr); + } + return 0; +} + +/* handle the '##' operator. Return NULL if no '##' seen. Otherwise + return the resulting string (which must be freed). */ +static inline int *macro_twosharps(const int *macro_str) +{ + TokenSym *ts; + const int *macro_ptr1, *start_macro_ptr, *ptr, *saved_macro_ptr; + int t; + const char *p1, *p2; + CValue cval; + TokenString macro_str1; + CString cstr; + + start_macro_ptr = macro_str; + /* we search the first '##' */ + for(;;) { + macro_ptr1 = macro_str; + TOK_GET(t, macro_str, cval); + /* nothing more to do if end of string */ + if (t == 0) + return NULL; + if (*macro_str == TOK_TWOSHARPS) + break; + } + + /* we saw '##', so we need more processing to handle it */ + cstr_new(&cstr); + tok_str_new(¯o_str1); + tok = t; + tokc = cval; + + /* add all tokens seen so far */ + for(ptr = start_macro_ptr; ptr < macro_ptr1;) { + TOK_GET(t, ptr, cval); + tok_str_add2(¯o_str1, t, &cval); + } + saved_macro_ptr = macro_ptr; + /* XXX: get rid of the use of macro_ptr here */ + macro_ptr = (int *)macro_str; + for(;;) { + while (*macro_ptr == TOK_TWOSHARPS) { + macro_ptr++; + macro_ptr1 = macro_ptr; + t = *macro_ptr; + if (t) { + TOK_GET(t, macro_ptr, cval); + /* We concatenate the two tokens if we have an + identifier or a preprocessing number */ + cstr_reset(&cstr); + p1 = get_tok_str(tok, &tokc); + cstr_cat(&cstr, p1); + p2 = get_tok_str(t, &cval); + cstr_cat(&cstr, p2); + cstr_ccat(&cstr, '\0'); + + if ((tok >= TOK_IDENT || tok == TOK_PPNUM) && + (t >= TOK_IDENT || t == TOK_PPNUM)) { + if (tok == TOK_PPNUM) { + /* if number, then create a number token */ + /* NOTE: no need to allocate because + tok_str_add2() does it */ + tokc.cstr = &cstr; + } else { + /* if identifier, we must do a test to + validate we have a correct identifier */ + if (t == TOK_PPNUM) { + const char *p; + int c; + + p = p2; + for(;;) { + c = *p; + if (c == '\0') + break; + p++; + if (!isnum(c) && !isid(c)) + goto error_pasting; + } + } + ts = tok_alloc(cstr.data, strlen(cstr.data)); + tok = ts->tok; /* modify current token */ + } + } else { + const char *str = cstr.data; + const unsigned char *q; + + /* we look for a valid token */ + /* XXX: do more extensive checks */ + if (!strcmp(str, ">>=")) { + tok = TOK_A_SAR; + } else if (!strcmp(str, "<<=")) { + tok = TOK_A_SHL; + } else if (strlen(str) == 2) { + /* search in two bytes table */ + q = tok_two_chars; + for(;;) { + if (!*q) + goto error_pasting; + if (q[0] == str[0] && q[1] == str[1]) + break; + q += 3; + } + tok = q[2]; + } else { + error_pasting: + /* NOTE: because get_tok_str use a static buffer, + we must save it */ + cstr_reset(&cstr); + p1 = get_tok_str(tok, &tokc); + cstr_cat(&cstr, p1); + cstr_ccat(&cstr, '\0'); + p2 = get_tok_str(t, &cval); + warning("pasting \"%s\" and \"%s\" does not give a valid preprocessing token", cstr.data, p2); + /* cannot merge tokens: just add them separately */ + tok_str_add2(¯o_str1, tok, &tokc); + /* XXX: free associated memory ? */ + tok = t; + tokc = cval; + } + } + } + } + tok_str_add2(¯o_str1, tok, &tokc); + next_nomacro(); + if (tok == 0) + break; + } + macro_ptr = (int *)saved_macro_ptr; + cstr_free(&cstr); + tok_str_add(¯o_str1, 0); + return macro_str1.str; +} + + +/* do macro substitution of macro_str and add result to + (tok_str,tok_len). 'nested_list' is the list of all macros we got + inside to avoid recursing. */ +static void macro_subst(TokenString *tok_str, Sym **nested_list, + const int *macro_str, struct macro_level ** can_read_stream) +{ + Sym *s; + int *macro_str1; + const int *ptr; + int t, ret; + CValue cval; + struct macro_level ml; + + /* first scan for '##' operator handling */ + ptr = macro_str; + macro_str1 = macro_twosharps(ptr); + if (macro_str1) + ptr = macro_str1; + while (1) { + /* NOTE: ptr == NULL can only happen if tokens are read from + file stream due to a macro function call */ + if (ptr == NULL) + break; + TOK_GET(t, ptr, cval); + if (t == 0) + break; + s = define_find(t); + if (s != NULL) { + /* if nested substitution, do nothing */ + if (sym_find2(*nested_list, t)) + goto no_subst; + ml.p = macro_ptr; + if (can_read_stream) + ml.prev = *can_read_stream, *can_read_stream = &ml; + macro_ptr = (int *)ptr; + tok = t; + ret = macro_subst_tok(tok_str, nested_list, s, can_read_stream); + ptr = (int *)macro_ptr; + macro_ptr = ml.p; + if (can_read_stream && *can_read_stream == &ml) + *can_read_stream = ml.prev; + if (ret != 0) + goto no_subst; + } else { + no_subst: + tok_str_add2(tok_str, t, &cval); + } + } + if (macro_str1) + tok_str_free(macro_str1); +} + +/* return next token with macro substitution */ +static void next(void) +{ + Sym *nested_list, *s; + TokenString str; + struct macro_level *ml; + + redo: + next_nomacro(); + if (!macro_ptr) { + /* if not reading from macro substituted string, then try + to substitute macros */ + if (tok >= TOK_IDENT && + (parse_flags & PARSE_FLAG_PREPROCESS)) { + s = define_find(tok); + if (s) { + /* we have a macro: we try to substitute */ + tok_str_new(&str); + nested_list = NULL; + ml = NULL; + if (macro_subst_tok(&str, &nested_list, s, &ml) == 0) { + /* substitution done, NOTE: maybe empty */ + tok_str_add(&str, 0); + macro_ptr = str.str; + macro_ptr_allocated = str.str; + goto redo; + } + } + } + } else { + if (tok == 0) { + /* end of macro or end of unget buffer */ + if (unget_buffer_enabled) { + macro_ptr = unget_saved_macro_ptr; + unget_buffer_enabled = 0; + } else { + /* end of macro string: free it */ + tok_str_free(macro_ptr_allocated); + macro_ptr = NULL; + } + goto redo; + } + } + + /* convert preprocessor tokens into C tokens */ + if (tok == TOK_PPNUM && + (parse_flags & PARSE_FLAG_TOK_NUM)) { + parse_number((char *)tokc.cstr->data); + } +} + +/* push back current token and set current token to 'last_tok'. Only + identifier case handled for labels. */ +static inline void unget_tok(int last_tok) +{ + int i, n; + int *q; + unget_saved_macro_ptr = macro_ptr; + unget_buffer_enabled = 1; + q = unget_saved_buffer; + macro_ptr = q; + *q++ = tok; + n = tok_ext_size(tok) - 1; + for(i=0;i= vstack + (VSTACK_SIZE - 1)) + error("memory full"); + /* cannot let cpu flags if other instruction are generated. Also + avoid leaving VT_JMP anywhere except on the top of the stack + because it would complicate the code generator. */ + if (vtop >= vstack) { + v = vtop->r & VT_VALMASK; + if (v == VT_CMP || (v & ~1) == VT_JMP) + gv(RC_INT); + } + vtop++; + vtop->type = *type; + vtop->r = r; + vtop->r2 = VT_CONST; + vtop->c = *vc; +} + +/* push integer constant */ +void vpushi(int v) +{ + CValue cval; + cval.i = v; + vsetc(&int_type, VT_CONST, &cval); +} + +/* Return a static symbol pointing to a section */ +static Sym *get_sym_ref(CType *type, Section *sec, + unsigned long offset, unsigned long size) +{ + int v; + Sym *sym; + + v = anon_sym++; + sym = global_identifier_push(v, type->t | VT_STATIC, 0); + sym->type.ref = type->ref; + sym->r = VT_CONST | VT_SYM; + put_extern_sym(sym, sec, offset, size); + return sym; +} + +/* push a reference to a section offset by adding a dummy symbol */ +static void vpush_ref(CType *type, Section *sec, unsigned long offset, unsigned long size) +{ + CValue cval; + + cval.ul = 0; + vsetc(type, VT_CONST | VT_SYM, &cval); + vtop->sym = get_sym_ref(type, sec, offset, size); +} + +/* define a new external reference to a symbol 'v' of type 'u' */ +static Sym *external_global_sym(int v, CType *type, int r) +{ + Sym *s; + + s = sym_find(v); + if (!s) { + /* push forward reference */ + s = global_identifier_push(v, type->t | VT_EXTERN, 0); + s->type.ref = type->ref; + s->r = r | VT_CONST | VT_SYM; + } + return s; +} + +/* define a new external reference to a symbol 'v' of type 'u' */ +static Sym *external_sym(int v, CType *type, int r) +{ + Sym *s; + + s = sym_find(v); + if (!s) { + /* push forward reference */ + s = sym_push(v, type, r | VT_CONST | VT_SYM, 0); + s->type.t |= VT_EXTERN; + } else { + if (!is_compatible_types(&s->type, type)) + error("incompatible types for redefinition of '%s'", + get_tok_str(v, NULL)); + } + return s; +} + +/* push a reference to global symbol v */ +static void vpush_global_sym(CType *type, int v) +{ + Sym *sym; + CValue cval; + + sym = external_global_sym(v, type, 0); + cval.ul = 0; + vsetc(type, VT_CONST | VT_SYM, &cval); + vtop->sym = sym; +} + +void vset(CType *type, int r, int v) +{ + CValue cval; + + cval.i = v; + vsetc(type, r, &cval); +} + +void vseti(int r, int v) +{ + CType type; + type.t = VT_INT; + vset(&type, r, v); +} + +void vswap(void) +{ + SValue tmp; + + tmp = vtop[0]; + vtop[0] = vtop[-1]; + vtop[-1] = tmp; +} + +void vpushv(SValue *v) +{ + if (vtop >= vstack + (VSTACK_SIZE - 1)) + error("memory full"); + vtop++; + *vtop = *v; +} + +void vdup(void) +{ + vpushv(vtop); +} + +/* save r to the memory stack, and mark it as being free */ +void save_reg(int r) +{ + int l, saved, size, align; + SValue *p, sv; + CType *type; + + /* modify all stack values */ + saved = 0; + l = 0; + for(p=vstack;p<=vtop;p++) { + if ((p->r & VT_VALMASK) == r || + (p->r2 & VT_VALMASK) == r) { + /* must save value on stack if not already done */ + //fprintf(stderr,"p->r before 0x%x type 0x%x\n", p->r,p->type.t); + if (!saved) { + pr("; saveregging\n"); + /* NOTE: must reload 'r' because r might be equal to r2 */ + r = p->r & VT_VALMASK; + /* store register in the stack */ + type = &p->type; + //fprintf(stderr,"### type 0x%x r 0x%x\n", type->t, p->r); + if((type->t & VT_BTYPE) == VT_FUNC) { + //fprintf(stderr,"### funcptr type 0x%x r 0x%x\n",type->t,p->r); + } + else if ((p->r & VT_LVAL) || + (!is_float(type->t) && (type->t & VT_BTYPE) != VT_LLONG)) + type = &ptr_type; + size = type_size(type, &align); + //fprintf(stderr,"### size %d align %d\n", size, align); + loc = (loc - size) & -align; + sv.type.t = type->t; + sv.r = VT_LOCAL | VT_LVAL; + sv.c.ul = loc; + store(r, &sv); +#ifdef TCC_TARGET_I386 + /* x86 specific: need to pop fp register ST0 if saved */ + if (r == TREG_ST0) { + o(0xd9dd); /* fstp %st(1) */ + } +#endif + /* special long long case */ + if ((type->t & VT_BTYPE) == VT_LLONG) { +#ifdef TCC_TARGET_816 + sv.c.ul += 2; +#else + sv.c.ul += 4; +#endif + store(p->r2, &sv); + } + l = loc; + saved = 1; + } + // asdf + /* mark that stack entry as being saved on the stack */ + if (p->r & VT_LVAL) { + /* also clear the bounded flag because the + relocation address of the function was stored in + p->c.ul */ + p->r = (p->r & ~(VT_VALMASK | VT_BOUNDED)) | VT_LLOCAL; + } else { + p->r = lvalue_type(p->type.t) | VT_LOCAL; + } + p->r2 = VT_CONST; + p->c.ul = l; + //fprintf(stderr,"p->r after 0x%x type 0x%x\n", p->r, p->type.t); + } + } +} + +/* find a register of class 'rc2' with at most one reference on stack. + * If none, call get_reg(rc) */ +int get_reg_ex(int rc, int rc2) +{ + int r; + SValue *p; + + for(r=0;rr & VT_VALMASK) == r || + (p->r2 & VT_VALMASK) == r) + n++; + } + if (n <= 1) + return r; + } + } + return get_reg(rc); +} + +/* find a free register of class 'rc'. If none, save one register */ +int get_reg(int rc) +{ + int r; + SValue *p; + + /* find a free register */ + for(r=0;rr & VT_VALMASK) == r || + (p->r2 & VT_VALMASK) == r) + goto notfound; + } + return r; + } + notfound: ; + } + + /* no register left : free the first one on the stack (VERY + IMPORTANT to start from the bottom to ensure that we don't + spill registers used in gen_opi()) */ + for(p=vstack;p<=vtop;p++) { + r = p->r & VT_VALMASK; + if (r < VT_CONST && (reg_classes[r] & rc)) + goto save_found; + /* also look at second register (if long long) */ + r = p->r2 & VT_VALMASK; + if (r < VT_CONST && (reg_classes[r] & rc)) { + save_found: + save_reg(r); + return r; + } + } + /* Should never comes here */ + return -1; +} + +/* save registers up to (vtop - n) stack entry */ +void save_regs(int n) +{ + int r; + SValue *p, *p1; + p1 = vtop - n; + for(p = vstack;p <= p1; p++) { + r = p->r & VT_VALMASK; + if (r < VT_CONST) { + save_reg(r); + } + } +} + +/* move register 's' to 'r', and flush previous value of r to memory + if needed */ +void move_reg(int r, int s) +{ + SValue sv; + + if (r != s) { + save_reg(r); + sv.type.t = VT_INT; + sv.r = s; + sv.c.ul = 0; + load(r, &sv); + } +} + +/* get address of vtop (vtop MUST BE an lvalue) */ +void gaddrof(void) +{ + vtop->r &= ~VT_LVAL; + /* tricky: if saved lvalue, then we can go back to lvalue */ + if ((vtop->r & VT_VALMASK) == VT_LLOCAL) + vtop->r = (vtop->r & ~(VT_VALMASK | VT_LVAL_TYPE)) | VT_LOCAL | VT_LVAL; +} + +#ifdef CONFIG_TCC_BCHECK +/* generate lvalue bound code */ +void gbound(void) +{ + int lval_type; + CType type1; + + vtop->r &= ~VT_MUSTBOUND; + /* if lvalue, then use checking code before dereferencing */ + if (vtop->r & VT_LVAL) { + /* if not VT_BOUNDED value, then make one */ + if (!(vtop->r & VT_BOUNDED)) { + lval_type = vtop->r & (VT_LVAL_TYPE | VT_LVAL); + /* must save type because we must set it to int to get pointer */ + type1 = vtop->type; + vtop->type.t = VT_INT; + gaddrof(); + vpushi(0); + gen_bounded_ptr_add(); + vtop->r |= lval_type; + vtop->type = type1; + } + /* then check for dereferencing */ + gen_bounded_ptr_deref(); + } +} +#endif + +#ifdef TCC_TARGET_816 +// convert floats to Woz format +void float_to_woz(float f, unsigned char* w) +{ + unsigned int i,b; + // w[0] exponent + // w[1-3] mantissa (big-endian) + //fprintf(stderr,"wozzing out at %f\n",f); + //if(f == 1.0) + //asm("int $3"); + + w[0] = 0x8e + 16; // 0x8e is the exp for 16-bit integers; we have 32-bit ints here + + for(;w[0];w[0]--) { + i = (unsigned int)(int)f; + //fprintf(stderr,"i 0x%08x\n", i); + + // top bits different => normalized + b = i & 0xc0000000UL; + if(b == 0x80000000UL || b == 0x40000000UL) break; + + f *= 2; + } + w[1] = i >> 24; + w[2] = (i >> 16) & 0xff; + w[3] = (i >> 8) & 0xff; + + //fprintf(stderr,"wozzed 0x%02x%02x%02x%02x\n", w[0],w[1],w[2],w[3]); +} +#endif + +/* store vtop a register belonging to class 'rc'. lvalues are + converted to values. Cannot be used if cannot be converted to + register value (such as structures). */ +int gv(int rc) +{ + int r, r2, rc2, bit_pos, bit_size, size, align; +#ifndef TCC_TARGET_816 + int i; +#endif + unsigned long long ll; + + /* NOTE: get_reg can modify vstack[] */ + if (vtop->type.t & VT_BITFIELD) { + int usigned; + int cst; + bit_pos = (vtop->type.t >> VT_STRUCT_SHIFT) & 0x3f; + bit_size = (vtop->type.t >> (VT_STRUCT_SHIFT + 6)) & 0x3f; + pr("; bitfielding bit_pos %d bit_size %d vtop->type.t 0x%x vtop->r 0x%x\n", bit_pos, bit_size,vtop->type.t,vtop->r); + usigned = vtop->type.t & VT_UNSIGNED; + cst = ((vtop->r & VT_VALMASK) == VT_CONST) && !(vtop->r & VT_LVAL); + /* remove bit field info to avoid loops */ + vtop->type.t &= ~(VT_BITFIELD | (-1 << VT_STRUCT_SHIFT)); + /* generate shifts */ +#ifdef TCC_TARGET_816 + if(cst) vpushi(16 - bit_size); + else vpushi(16 - (bit_pos + bit_size)); + //vpushi(16 - bit_size); +#else + vpushi(32 - (bit_pos + bit_size)); +#endif + gen_op(TOK_SHL); +#ifdef TCC_TARGET_816 + vpushi(16 - bit_size); +#else + vpushi(32 - bit_size); +#endif + /* NOTE: transformed to SHR if unsigned */ + /* in theory. in practice, that doesn't work for some reason -- uli */ + if(usigned) gen_op(TOK_SHR); + else gen_op(TOK_SAR); + r = gv(rc); + } else { + if (is_float(vtop->type.t) && + (vtop->r & (VT_VALMASK | VT_LVAL)) == VT_CONST) { + Sym *sym; + int *ptr; + unsigned long offset; + + /* XXX: unify with initializers handling ? */ + /* CPUs usually cannot use float constants, so we store them + generically in data segment */ + size = type_size(&vtop->type, &align); + offset = (data_section->data_offset + align - 1) & -align; + data_section->data_offset = offset; + /* XXX: not portable yet */ + ptr = section_ptr_add(data_section, size); + size = size >> 2; +#ifdef TCC_TARGET_816 + float_to_woz(vtop->c.f, (unsigned char*)ptr); +#else + for(i=0;ic.tab[i]; +#endif + sym = get_sym_ref(&vtop->type, data_section, offset, size << 2); + vtop->r |= VT_LVAL | VT_SYM; + vtop->sym = sym; + vtop->c.ul = 0; + } +#ifdef CONFIG_TCC_BCHECK + if (vtop->r & VT_MUSTBOUND) + gbound(); +#endif + + r = vtop->r & VT_VALMASK; + /* need to reload if: + - constant + - lvalue (need to dereference pointer) + - already a register, but not in the right class */ + if (r >= VT_CONST || + (vtop->r & VT_LVAL) || + !(reg_classes[r] & rc) || + ((vtop->type.t & VT_BTYPE) == VT_LLONG && + !(reg_classes[vtop->r2] & rc))) { + r = get_reg(rc); + if ((vtop->type.t & VT_BTYPE) == VT_LLONG) { + /* two register type load : expand to two words + temporarily */ + if ((vtop->r & (VT_VALMASK | VT_LVAL)) == VT_CONST) { + /* load constant */ + ll = vtop->c.ull; + vtop->c.ui = ll; /* first word */ + load(r, vtop); + vtop->r = r; /* save register value */ +#ifdef TCC_TARGET_816 + vpushi(ll >> 16); +#else + vpushi(ll >> 32); /* second word */ +#endif + } else if (r >= VT_CONST || /* XXX: test to VT_CONST incorrect ? */ + (vtop->r & VT_LVAL)) { + /* We do not want to modifier the long long + pointer here, so the safest (and less + efficient) is to save all the other registers + in the stack. XXX: totally inefficient. */ + save_regs(1); + load(r, vtop); + vdup(); + vtop[-1].r = r; /* save register value */ + + /* A bug may hide here. + This shortcut did not work for 65816 until I found out + that the long long compare code seems to expect the + result of the comparisons to end up in the same register. + I do not think this is ascertained in the other code + path, it may just happen to work. */ +#if 0 /* breaks ashrdi-1.c */ + if((vtop->r & VT_LOCAL) /* && !(vtop->r & VT_LVAL) */) { + vtop->c.ul += 2; + } + else +#endif + { + /* increment pointer to get second word */ + pr("; pushit type 0x%x\n",vtop->type.t); + ll_workaround = 1; + vtop->type.t = VT_INT; + gaddrof(); +#ifdef TCC_TARGET_816 + vpushi(2); +#else + vpushi(4); +#endif + gen_op('+'); + vtop->r |= VT_LVAL; + ll_workaround = 0; + pr("; endpush\n"); + } + } else { + /* move registers */ + load(r, vtop); + vdup(); + vtop[-1].r = r; /* save register value */ + vtop->r = vtop[-1].r2; + } + /* allocate second register */ + rc2 = RC_INT; + if (rc == RC_IRET) + rc2 = RC_LRET; + r2 = get_reg(rc2); + load(r2, vtop); + vpop(); + /* write second register */ + vtop->r2 = r2; + } else if ((vtop->r & VT_LVAL) && !is_float(vtop->type.t)) { + int t1, t; + /* lvalue of scalar type : need to use lvalue type + because of possible cast */ + t = vtop->type.t; + t1 = t; + /* compute memory access type */ + if (vtop->r & VT_LVAL_BYTE) + t = VT_BYTE; + else if (vtop->r & VT_LVAL_SHORT) + t = VT_SHORT; + if (vtop->r & VT_LVAL_UNSIGNED) + t |= VT_UNSIGNED; + vtop->type.t = t; + load(r, vtop); + /* restore wanted type */ + vtop->type.t = t1; + } else { + /* one register type load */ + load(r, vtop); + } + } + vtop->r = r; +#ifdef TCC_TARGET_C67 + /* uses register pairs for doubles */ + if ((vtop->type.t & VT_BTYPE) == VT_DOUBLE) + vtop->r2 = r+1; +#endif + } + return r; +} + +/* generate vtop[-1] and vtop[0] in resp. classes rc1 and rc2 */ +void gv2(int rc1, int rc2) +{ + int v; + + /* generate more generic register first. But VT_JMP or VT_CMP + values must be generated first in all cases to avoid possible + reload errors */ + v = vtop[0].r & VT_VALMASK; + if (v != VT_CMP && (v & ~1) != VT_JMP && rc1 <= rc2) { + vswap(); + gv(rc1); + vswap(); + gv(rc2); + /* test if reload is needed for first register */ + if ((vtop[-1].r & VT_VALMASK) >= VT_CONST) { + vswap(); + gv(rc1); + vswap(); + } + } else { + gv(rc2); + vswap(); + gv(rc1); + vswap(); + /* test if reload is needed for first register */ + if ((vtop[0].r & VT_VALMASK) >= VT_CONST) { + gv(rc2); + } + } +} + +/* expand long long on stack in two int registers */ +void lexpand(void) +{ + int u; + + u = vtop->type.t & VT_UNSIGNED; + gv(RC_INT); + vdup(); + vtop[0].r = vtop[-1].r2; + vtop[0].r2 = VT_CONST; + vtop[-1].r2 = VT_CONST; + vtop[0].type.t = VT_INT | u; + vtop[-1].type.t = VT_INT | u; +} + +#ifdef TCC_TARGET_ARM +/* expand long long on stack */ +void lexpand_nr(void) +{ + int u,v; + + u = vtop->type.t & VT_UNSIGNED; + vdup(); + vtop->r2 = VT_CONST; + vtop->type.t = VT_INT | u; + v=vtop[-1].r & (VT_VALMASK | VT_LVAL); + if (v == VT_CONST) { + vtop[-1].c.ui = vtop->c.ull; +#ifdef TCC_TARGET_816 + vtop->c.ui = vtop->c.ull >> 16; +#else + vtop->c.ui = vtop->c.ull >> 32; +#endif + vtop->r = VT_CONST; + } else if (v == (VT_LVAL|VT_CONST) || v == (VT_LVAL|VT_LOCAL)) { +#ifdef TCC_TARGET_816 + vtop->c.ui += 2; +#else + vtop->c.ui += 4; +#endif + vtop->r = vtop[-1].r; + } else if (v > VT_CONST) { + vtop--; + lexpand(); + } else + vtop->r = vtop[-1].r2; + vtop[-1].r2 = VT_CONST; + vtop[-1].type.t = VT_INT | u; +} +#endif + +/* build a long long from two ints */ +void lbuild(int t) +{ + gv2(RC_INT, RC_INT); + vtop[-1].r2 = vtop[0].r; + vtop[-1].type.t = t; + vpop(); +} + +/* rotate n first stack elements to the bottom + I1 ... In -> I2 ... In I1 [top is right] +*/ +void vrotb(int n) +{ + int i; + SValue tmp; + + tmp = vtop[-n + 1]; + for(i=-n+1;i!=0;i++) + vtop[i] = vtop[i+1]; + vtop[0] = tmp; +} + +/* rotate n first stack elements to the top + I1 ... In -> In I1 ... I(n-1) [top is right] + */ +void vrott(int n) +{ + int i; + SValue tmp; + + tmp = vtop[0]; + for(i = 0;i < n - 1; i++) + vtop[-i] = vtop[-i - 1]; + vtop[-n + 1] = tmp; +} + +#ifdef TCC_TARGET_ARM +/* like vrott but in other direction + In ... I1 -> I(n-1) ... I1 In [top is right] + */ +void vnrott(int n) +{ + int i; + SValue tmp; + + tmp = vtop[-n + 1]; + for(i = n - 1; i > 0; i--) + vtop[-i] = vtop[-i + 1]; + vtop[0] = tmp; +} +#endif + +/* pop stack value */ +void vpop(void) +{ + int v; + v = vtop->r & VT_VALMASK; +#ifdef TCC_TARGET_I386 + /* for x86, we need to pop the FP stack */ + if (v == TREG_ST0 && !nocode_wanted) { + o(0xd9dd); /* fstp %st(1) */ + } else +#endif + if (v == VT_JMP || v == VT_JMPI) { + /* need to put correct jump if && or || without test */ + gsym(vtop->c.ul); + } + vtop--; +} + +/* convert stack entry to register and duplicate its value in another + register */ +void gv_dup(void) +{ + int rc, t, r, r1; + SValue sv; + + t = vtop->type.t; + if ((t & VT_BTYPE) == VT_LLONG) { + lexpand(); + gv_dup(); + vswap(); + vrotb(3); + gv_dup(); + vrotb(4); + /* stack: H L L1 H1 */ + lbuild(t); + vrotb(3); + vrotb(3); + vswap(); + lbuild(t); + vswap(); + } else { + /* duplicate value */ + rc = RC_INT; + sv.type.t = VT_INT; + if (is_float(t)) { + rc = RC_FLOAT; + sv.type.t = t; + } + r = gv(rc); + r1 = get_reg(rc); + sv.r = r; + sv.c.ul = 0; + load(r1, &sv); /* move r to r1 */ + vdup(); + /* duplicates value */ + vtop->r = r1; + } +} + +/* generate CPU independent (unsigned) long long operations */ +void gen_opl(int op) +{ + int t, a, b, op1, c, i; + int func; + SValue tmp; + + switch(op) { + case '/': + case TOK_PDIV: + func = TOK___divdi3; + goto gen_func; + case TOK_UDIV: + func = TOK___udivdi3; + goto gen_func; + case '%': + func = TOK___moddi3; + goto gen_func; + case TOK_UMOD: + func = TOK___umoddi3; + gen_func: + /* call generic long long function */ + vpush_global_sym(&func_old_type, func); + vrott(3); + gfunc_call(2); + vpushi(0); + vtop->r = REG_IRET; + vtop->r2 = REG_LRET; + break; + case '^': + case '&': + case '|': + case '*': + case '+': + case '-': + t = vtop->type.t; + vswap(); + lexpand(); + vrotb(3); + lexpand(); + /* stack: L1 H1 L2 H2 */ + tmp = vtop[0]; + vtop[0] = vtop[-3]; + vtop[-3] = tmp; + tmp = vtop[-2]; + vtop[-2] = vtop[-3]; + vtop[-3] = tmp; + vswap(); + /* stack: H1 H2 L1 L2 */ + if (op == '*') { + vpushv(vtop - 1); + vpushv(vtop - 1); + gen_op(TOK_UMULL); + lexpand(); + /* stack: H1 H2 L1 L2 ML MH */ + for(i=0;i<4;i++) + vrotb(6); + /* stack: ML MH H1 H2 L1 L2 */ + tmp = vtop[0]; + vtop[0] = vtop[-2]; + vtop[-2] = tmp; + /* stack: ML MH H1 L2 H2 L1 */ + gen_op('*'); + vrotb(3); + vrotb(3); + gen_op('*'); + /* stack: ML MH M1 M2 */ + gen_op('+'); + gen_op('+'); + } else if (op == '+' || op == '-') { + /* XXX: add non carry method too (for MIPS or alpha) */ + if (op == '+') + op1 = TOK_ADDC1; + else + op1 = TOK_SUBC1; + gen_op(op1); + /* stack: H1 H2 (L1 op L2) */ + vrotb(3); + vrotb(3); + gen_op(op1 + 1); /* TOK_xxxC2 */ + } else { + gen_op(op); + /* stack: H1 H2 (L1 op L2) */ + vrotb(3); + vrotb(3); + /* stack: (L1 op L2) H1 H2 */ + gen_op(op); + /* stack: (L1 op L2) (H1 op H2) */ + } + /* stack: L H */ + lbuild(t); + break; + case TOK_SAR: + case TOK_SHR: + case TOK_SHL: + if ((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST) { + t = vtop[-1].type.t; + vswap(); + lexpand(); + vrotb(3); + /* stack: L H shift */ + c = (int)vtop->c.i; + /* constant: simpler */ + /* NOTE: all comments are for SHL. the other cases are + done by swaping words */ + vpop(); + if (op != TOK_SHL) + vswap(); +#ifdef TCC_TARGET_816 + if (c >= 16) { +#else + if (c >= 32) { +#endif + /* stack: L H */ + vpop(); +#ifdef TCC_TARGET_816 + if (c > 16) { + vpushi(c - 16); +#else + if (c > 32) { + vpushi(c - 32); +#endif + gen_op(op); + } + if (op != TOK_SAR) { + vpushi(0); + } else { + gv_dup(); +#ifdef TCC_TARGET_816 + vpushi(15); +#else + vpushi(31); +#endif + gen_op(TOK_SAR); + } + vswap(); + } else { + vswap(); + gv_dup(); + /* stack: H L L */ + vpushi(c); + gen_op(op); + vswap(); +#ifdef TCC_TARGET_816 + vpushi(16 - c); +#else + vpushi(32 - c); +#endif + if (op == TOK_SHL) + gen_op(TOK_SHR); + else + gen_op(TOK_SHL); + vrotb(3); + /* stack: L L H */ + vpushi(c); + if (op == TOK_SHL) + gen_op(TOK_SHL); + else + gen_op(TOK_SHR); + gen_op('|'); + } + if (op != TOK_SHL) + vswap(); + lbuild(t); + } else { + /* XXX: should provide a faster fallback on x86 ? */ + switch(op) { + case TOK_SAR: + func = TOK___sardi3; + goto gen_func; + case TOK_SHR: + func = TOK___shrdi3; + goto gen_func; + case TOK_SHL: + func = TOK___shldi3; + goto gen_func; + } + } + break; + default: + /* compare operations */ + t = vtop->type.t; + vswap(); + lexpand(); + vrotb(3); + lexpand(); + /* stack: L1 H1 L2 H2 */ + tmp = vtop[-1]; + vtop[-1] = vtop[-2]; + vtop[-2] = tmp; + /* stack: L1 L2 H1 H2 */ + /* compare high */ + op1 = op; + /* when values are equal, we need to compare low words. since + the jump is inverted, we invert the test too. */ + if (op1 == TOK_LT) + op1 = TOK_LE; + else if (op1 == TOK_GT) + op1 = TOK_GE; + else if (op1 == TOK_ULT) + op1 = TOK_ULE; + else if (op1 == TOK_UGT) + op1 = TOK_UGE; + a = 0; + b = 0; + gen_op(op1); + if (op1 != TOK_NE) { + a = gtst(1, 0); + } + if (op != TOK_EQ) { + /* generate non equal test */ + /* XXX: NOT PORTABLE yet */ + if (a == 0) { + b = gtst(0, 0); + } else { +#if defined(TCC_TARGET_I386) + b = psym(0x850f, 0); +#elif defined(TCC_TARGET_ARM) + b = ind; + o(0x1A000000 | encbranch(ind, 0, 1)); +#elif defined(TCC_TARGET_C67) + error("not implemented (ind %d, a %d)", ind, a); +#elif defined(TCC_TARGET_816) +#if 0 + b = ind; + jump[jumps][0] = ind; + pr("; cmpll ne a %d b %d op 0x%x op1 0x%x\n", a, b, op, op1); + // branches (too short) p("b%s " LOCAL_LABEL "\n", inv?"eq":"ne", jumps++); + pr("beq +\nbrl " LOCAL_LABEL "\n+\n", jumps++); +#endif + pr("; cmpll high order word equal?\n"); + b = ind; + jump[jumps][0] = ind; + // flags from the compare are long gone, but the compare opi has saved the value for us in y + pr("tya\nbne " LOCAL_LABEL "\n", jumps++); +#else +#error not supported +#endif + } + } + /* compare low. Always unsigned */ + op1 = op; + if (op1 == TOK_LT) + op1 = TOK_ULT; + else if (op1 == TOK_LE) + op1 = TOK_ULE; + else if (op1 == TOK_GT) + op1 = TOK_UGT; + else if (op1 == TOK_GE) + op1 = TOK_UGE; + gen_op(op1); + a = gtst(1, a); + gsym(b); + vseti(VT_JMPI, a); + break; + } +} + +#ifdef TCC_TARGET_816 +#define UNSIGNED unsigned short +#define SIGNED short +#define UNSIGNEDLL unsigned int +#define SIGNEDLL int +#else +#define UNSIGNED unsigned int +#define SIGNED int +#define UNSIGNEDLL unsigned long long +#define SIGNEDLL long long +#endif + +/* handle integer constant optimizations and various machine + independent opt */ +void gen_opic(int op) +{ + int fc, c1, c2, n; + SValue *v1, *v2; + + v1 = vtop - 1; + v2 = vtop; + /* currently, we cannot do computations with forward symbols */ + c1 = (v1->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST; + c2 = (v2->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST; + if (c1 && c2) { + fc = v2->c.i; + switch(op) { + case '+': v1->c.i += fc; break; + case '-': v1->c.i -= fc; break; + case '&': v1->c.i &= fc; break; + case '^': v1->c.i ^= fc; break; + case '|': v1->c.i |= fc; break; + case '*': v1->c.i *= fc; break; + + case TOK_PDIV: + case '/': + case '%': + case TOK_UDIV: + case TOK_UMOD: + /* if division by zero, generate explicit division */ + if (fc == 0) { + if (const_wanted) + error("division by zero in constant"); + goto general_case; + } + switch(op) { + default: v1->c.i /= fc; break; + case '%': v1->c.i %= fc; break; + case TOK_UDIV: v1->c.i = (UNSIGNED)v1->c.i / fc; break; + case TOK_UMOD: v1->c.i = (UNSIGNED)v1->c.i % fc; break; + } + break; + case TOK_SHL: v1->c.i = (SIGNED)v1->c.i << fc; break; + case TOK_SHR: v1->c.i = (UNSIGNED)v1->c.i >> fc; break; + case TOK_SAR: v1->c.i = (SIGNED)v1->c.i >> fc; break; + /* tests */ + case TOK_ULT: v1->c.i = (UNSIGNED)v1->c.i < (UNSIGNED)fc; break; + case TOK_UGE: v1->c.i = (UNSIGNED)v1->c.i >= (UNSIGNED)fc; break; + case TOK_EQ: v1->c.i = v1->c.i == fc; break; + case TOK_NE: v1->c.i = v1->c.i != fc; break; + case TOK_ULE: v1->c.i = (UNSIGNED)v1->c.i <= (UNSIGNED)fc; break; + case TOK_UGT: v1->c.i = (UNSIGNED)v1->c.i > (UNSIGNED)fc; break; + case TOK_LT: v1->c.i = v1->c.i < fc; break; + case TOK_GE: v1->c.i = v1->c.i >= fc; break; + case TOK_LE: v1->c.i = v1->c.i <= fc; break; + case TOK_GT: v1->c.i = v1->c.i > fc; break; + /* logical */ + case TOK_LAND: v1->c.i = v1->c.i && fc; break; + case TOK_LOR: v1->c.i = v1->c.i || fc; break; + default: + goto general_case; + } + vtop--; + } else { + /* if commutative ops, put c2 as constant */ + if (c1 && (op == '+' || op == '&' || op == '^' || + op == '|' || op == '*')) { + vswap(); + swap(&c1, &c2); + } + fc = vtop->c.i; + if (c2 && (((op == '*' || op == '/' || op == TOK_UDIV || + op == TOK_PDIV) && + fc == 1) || + ((op == '+' || op == '-' || op == '|' || op == '^' || + op == TOK_SHL || op == TOK_SHR || op == TOK_SAR) && + fc == 0) || + (op == '&' && + fc == -1))) { + /* nothing to do */ + vtop--; + } else if (c2 && (op == '*' || op == TOK_PDIV || op == TOK_UDIV)) { + /* try to use shifts instead of muls or divs */ + if (fc > 0 && (fc & (fc - 1)) == 0) { + n = -1; + while (fc) { + fc >>= 1; + n++; + } + vtop->c.i = n; + if (op == '*') + op = TOK_SHL; + else if (op == TOK_PDIV) + op = TOK_SAR; + else + op = TOK_SHR; + } + goto general_case; + } else if (c2 && (op == '+' || op == '-') && + (vtop[-1].r & (VT_VALMASK | VT_LVAL | VT_SYM)) == + (VT_CONST | VT_SYM)) { + /* symbol + constant case */ + if (op == '-') + fc = -fc; + vtop--; + vtop->c.i += fc; + } else { + general_case: + if (!nocode_wanted) { + /* call low level op generator */ + gen_opi(op); + } else { + vtop--; + } + } + } +} + +/* generate a floating point operation with constant propagation */ +void gen_opif(int op) +{ + int c1, c2; + SValue *v1, *v2; + long double f1, f2; + + v1 = vtop - 1; + v2 = vtop; + /* currently, we cannot do computations with forward symbols */ + c1 = (v1->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST; + c2 = (v2->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST; + if (c1 && c2) { + if (v1->type.t == VT_FLOAT) { + f1 = v1->c.f; + f2 = v2->c.f; + } else if (v1->type.t == VT_DOUBLE) { + f1 = v1->c.d; + f2 = v2->c.d; + } else { + f1 = v1->c.ld; + f2 = v2->c.ld; + } + + /* NOTE: we only do constant propagation if finite number (not + NaN or infinity) (ANSI spec) */ + if (!ieee_finite(f1) || !ieee_finite(f2)) + goto general_case; + + switch(op) { + case '+': f1 += f2; break; + case '-': f1 -= f2; break; + case '*': f1 *= f2; break; + case '/': + if (f2 == 0.0) { + if (const_wanted) + error("division by zero in constant"); + goto general_case; + } + f1 /= f2; + break; + /* XXX: also handles tests ? */ + default: + goto general_case; + } + /* XXX: overflow test ? */ + if (v1->type.t == VT_FLOAT) { + v1->c.f = f1; + } else if (v1->type.t == VT_DOUBLE) { + v1->c.d = f1; + } else { + v1->c.ld = f1; + } + vtop--; + } else { + general_case: + if (!nocode_wanted) { + gen_opf(op); + } else { + vtop--; + } + } +} + +static int pointed_size(CType *type) +{ + int align; + return type_size(pointed_type(type), &align); +} + +static inline int is_null_pointer(SValue *p) +{ + if ((p->r & (VT_VALMASK | VT_LVAL | VT_SYM)) != VT_CONST) + return 0; + return ((p->type.t & VT_BTYPE) == VT_INT && p->c.i == 0) || + ((p->type.t & VT_BTYPE) == VT_LLONG && p->c.ll == 0); +} + +static inline int is_integer_btype(int bt) +{ + return (bt == VT_BYTE || bt == VT_SHORT || + bt == VT_INT || bt == VT_LLONG); +} + +/* check types for comparison or substraction of pointers */ +static void check_comparison_pointer_types(SValue *p1, SValue *p2, int op) +{ + CType *type1, *type2, tmp_type1, tmp_type2; + int bt1, bt2; + + /* null pointers are accepted for all comparisons as gcc */ + if (is_null_pointer(p1) || is_null_pointer(p2)) + return; + type1 = &p1->type; + type2 = &p2->type; + bt1 = type1->t & VT_BTYPE; + bt2 = type2->t & VT_BTYPE; + /* accept comparison between pointer and integer with a warning */ + if ((is_integer_btype(bt1) || is_integer_btype(bt2)) && op != '-') { + warning("comparison between pointer and integer"); + return; + } + + /* both must be pointers or implicit function pointers */ + if (bt1 == VT_PTR) { + type1 = pointed_type(type1); + } else if (bt1 != VT_FUNC) + goto invalid_operands; + + if (bt2 == VT_PTR) { + type2 = pointed_type(type2); + } else if (bt2 != VT_FUNC) { + invalid_operands: + error("invalid operands to binary %s", get_tok_str(op, NULL)); + } + if ((type1->t & VT_BTYPE) == VT_VOID || + (type2->t & VT_BTYPE) == VT_VOID) + return; + tmp_type1 = *type1; + tmp_type2 = *type2; + tmp_type1.t &= ~(VT_UNSIGNED | VT_CONSTANT | VT_VOLATILE); + tmp_type2.t &= ~(VT_UNSIGNED | VT_CONSTANT | VT_VOLATILE); + if (!is_compatible_types(&tmp_type1, &tmp_type2)) { + /* gcc-like error if '-' is used */ + if (op == '-') + goto invalid_operands; + else + warning("comparison of distinct pointer types lacks a cast"); + } +} + +/* generic gen_op: handles types problems */ +void gen_op(int op) +{ + int u, t1, t2, bt1, bt2, t; + CType type1; + + t1 = vtop[-1].type.t; + t2 = vtop[0].type.t; + bt1 = t1 & VT_BTYPE; + bt2 = t2 & VT_BTYPE; + + if (bt1 == VT_PTR || bt2 == VT_PTR) { + /* at least one operand is a pointer */ + /* relationnal op: must be both pointers */ + if (op >= TOK_ULT && op <= TOK_GT) { + check_comparison_pointer_types(vtop - 1, vtop, op); + /* pointers are handled are unsigned */ + t = VT_INT | VT_UNSIGNED; + goto std_op; + } + /* if both pointers, then it must be the '-' op */ + if (bt1 == VT_PTR && bt2 == VT_PTR) { + if (op != '-') + error("cannot use pointers here"); + check_comparison_pointer_types(vtop - 1, vtop, op); + /* XXX: check that types are compatible */ + u = pointed_size(&vtop[-1].type); + gen_opic(op); + /* set to integer type */ + vtop->type.t = VT_INT; + vpushi(u); + gen_op(TOK_PDIV); + } else { + /* exactly one pointer : must be '+' or '-'. */ + if (op != '-' && op != '+') + error("cannot use pointers here"); + /* Put pointer as first operand */ + if (bt2 == VT_PTR) { + vswap(); + swap(&t1, &t2); + } + type1 = vtop[-1].type; + /* XXX: cast to int ? (long long case) */ + vpushi(pointed_size(&vtop[-1].type)); + gen_op('*'); +#ifdef CONFIG_TCC_BCHECK + /* if evaluating constant expression, no code should be + generated, so no bound check */ + if (do_bounds_check && !const_wanted) { + /* if bounded pointers, we generate a special code to + test bounds */ + if (op == '-') { + vpushi(0); + vswap(); + gen_op('-'); + } + gen_bounded_ptr_add(); + } else +#endif + { + gen_opic(op); + } + /* put again type if gen_opic() swaped operands */ + vtop->type = type1; + } + } else if (is_float(bt1) || is_float(bt2)) { + /* compute bigger type and do implicit casts */ + if (bt1 == VT_LDOUBLE || bt2 == VT_LDOUBLE) { + t = VT_LDOUBLE; + } else if (bt1 == VT_DOUBLE || bt2 == VT_DOUBLE) { + t = VT_DOUBLE; + } else { + t = VT_FLOAT; + } + /* floats can only be used for a few operations */ + if (op != '+' && op != '-' && op != '*' && op != '/' && + (op < TOK_ULT || op > TOK_GT)) + error("invalid operands for binary operation"); + goto std_op; + } else if (bt1 == VT_LLONG || bt2 == VT_LLONG) { + /* cast to biggest op */ + t = VT_LLONG; + /* convert to unsigned if it does not fit in a long long */ + if ((t1 & (VT_BTYPE | VT_UNSIGNED)) == (VT_LLONG | VT_UNSIGNED) || + (t2 & (VT_BTYPE | VT_UNSIGNED)) == (VT_LLONG | VT_UNSIGNED)) + t |= VT_UNSIGNED; + goto std_op; + } else { + /* integer operations */ + t = VT_INT; + /* convert to unsigned if it does not fit in an integer */ + if ((t1 & (VT_BTYPE | VT_UNSIGNED)) == (VT_INT | VT_UNSIGNED) || + (t2 & (VT_BTYPE | VT_UNSIGNED)) == (VT_INT | VT_UNSIGNED)) + t |= VT_UNSIGNED; + std_op: + /* XXX: currently, some unsigned operations are explicit, so + we modify them here */ + if (t & VT_UNSIGNED) { + if (op == TOK_SAR && (t1 & VT_UNSIGNED)) + /* change to SAR only if the shiftee is unsigned (shiftopt-1.c) */ + op = TOK_SHR; + else if (op == '/') + op = TOK_UDIV; + else if (op == '%') + op = TOK_UMOD; + else if (op == TOK_LT) + op = TOK_ULT; + else if (op == TOK_GT) + op = TOK_UGT; + else if (op == TOK_LE) + op = TOK_ULE; + else if (op == TOK_GE) + op = TOK_UGE; + } + vswap(); + type1.t = t; + gen_cast(&type1); + vswap(); + /* special case for shifts and long long: we keep the shift as + an integer */ + if (op == TOK_SHR || op == TOK_SAR || op == TOK_SHL) + type1.t = VT_INT; + gen_cast(&type1); + if (is_float(t)) + gen_opif(op); + else if ((t & VT_BTYPE) == VT_LLONG) + gen_opl(op); + else + gen_opic(op); + if (op >= TOK_ULT && op <= TOK_GT) { + /* relationnal op: the result is an int */ + vtop->type.t = VT_INT; + } else { + vtop->type.t = t; + } + } +} + +/* generic itof for unsigned long long case */ +void gen_cvt_itof1(int t) +{ + if ((vtop->type.t & (VT_BTYPE | VT_UNSIGNED)) == + (VT_LLONG | VT_UNSIGNED)) { + + if (t == VT_FLOAT) + vpush_global_sym(&func_old_type, TOK___ulltof); + else if (t == VT_DOUBLE) + vpush_global_sym(&func_old_type, TOK___ulltod); + else + vpush_global_sym(&func_old_type, TOK___ulltold); + vrott(2); + gfunc_call(1); + vpushi(0); + vtop->r = REG_FRET; + } else { + gen_cvt_itof(t); + } +} + +/* generic ftoi for unsigned long long case */ +void gen_cvt_ftoi1(int t) +{ + int st; + + if (t == (VT_LLONG | VT_UNSIGNED)) { + /* not handled natively */ + st = vtop->type.t & VT_BTYPE; + if (st == VT_FLOAT) + vpush_global_sym(&func_old_type, TOK___fixunssfdi); + else if (st == VT_DOUBLE) + vpush_global_sym(&func_old_type, TOK___fixunsdfdi); + else + vpush_global_sym(&func_old_type, TOK___fixunsxfdi); + vrott(2); + gfunc_call(1); + vpushi(0); + vtop->r = REG_IRET; + vtop->r2 = REG_LRET; + } else { + gen_cvt_ftoi(t); + } +} + +/* force char or short cast */ +void force_charshort_cast(int t) +{ + int bits, dbt; + int tmpt; + dbt = t & VT_BTYPE; + /* XXX: add optimization if lvalue : just change type and offset */ + if (dbt == VT_BYTE) + bits = 8; + else + bits = 16; + + if (t & VT_UNSIGNED) { + vpushi((1 << bits) - 1); + gen_op('&'); + } else { +#ifdef TCC_TARGET_816 + bits = 16 - bits; + if((vtop->type.t & VT_BTYPE) == VT_LLONG) bits += 16; +#else + bits = 32 - bits; +#endif + tmpt = vtop->type.t; + vtop->type.t &= ~VT_UNSIGNED; + vpushi(bits); + gen_op(TOK_SHL); + vpushi(bits); + gen_op(TOK_SAR); + vtop->type.t = tmpt; + } +} + +/* cast 'vtop' to 'type'. Casting to bitfields is forbidden. */ +static void gen_cast(CType *type) +{ + int sbt, dbt, sf, df, c; + + //fprintf(stderr,"### casting type 0x%x (r 0x%x) to 0x%x\n", vtop->type.t, vtop->r, type->t); + /* special delayed cast for char/short */ + /* XXX: in some cases (multiple cascaded casts), it may still + be incorrect */ + if (vtop->r & VT_MUSTCAST) { + vtop->r &= ~VT_MUSTCAST; + force_charshort_cast(vtop->type.t); + } + + /* bitfields first get cast to ints */ + if (vtop->type.t & VT_BITFIELD) { + gv(RC_INT); + } + + dbt = type->t & (VT_BTYPE | VT_UNSIGNED); + sbt = vtop->type.t & (VT_BTYPE | VT_UNSIGNED); + + if (sbt != dbt && !nocode_wanted) { + sf = is_float(sbt); + df = is_float(dbt); + c = (vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST; + if (sf && df) { + /* convert from fp to fp */ + if (c) { + /* constant case: we can do it now */ + /* XXX: in ISOC, cannot do it if error in convert */ + if (dbt == VT_FLOAT && sbt == VT_DOUBLE) + vtop->c.f = (float)vtop->c.d; + else if (dbt == VT_FLOAT && sbt == VT_LDOUBLE) + vtop->c.f = (float)vtop->c.ld; + else if (dbt == VT_DOUBLE && sbt == VT_FLOAT) + vtop->c.d = (double)vtop->c.f; + else if (dbt == VT_DOUBLE && sbt == VT_LDOUBLE) + vtop->c.d = (double)vtop->c.ld; + else if (dbt == VT_LDOUBLE && sbt == VT_FLOAT) + vtop->c.ld = (long double)vtop->c.f; + else if (dbt == VT_LDOUBLE && sbt == VT_DOUBLE) + vtop->c.ld = (long double)vtop->c.d; + } else { + /* non constant case: generate code */ + gen_cvt_ftof(dbt); + } + } else if (df) { + /* convert int to fp */ + if (c) { + switch(sbt) { + case VT_LLONG | VT_UNSIGNED: + switch(dbt) { + case VT_FLOAT: vtop->c.f = (float)(UNSIGNEDLL)vtop->c.ull; break; + case VT_DOUBLE: vtop->c.d = (double)(UNSIGNEDLL)vtop->c.ull; break; + case VT_LDOUBLE: vtop->c.ld = (long double)(UNSIGNEDLL)vtop->c.ull; break; + } + break; + /* XXX: add const cases for long long */ + //goto do_itof; + case VT_LLONG: + switch(dbt) { + case VT_FLOAT: vtop->c.f = (float)(SIGNEDLL)vtop->c.ull; break; + case VT_DOUBLE: vtop->c.d = (double)(SIGNEDLL)vtop->c.ull; break; + case VT_LDOUBLE: vtop->c.ld = (long double)(SIGNEDLL)vtop->c.ull; break; + } + break; + case VT_INT | VT_UNSIGNED: + switch(dbt) { + case VT_FLOAT: vtop->c.f = (float)(UNSIGNED)vtop->c.ui; break; + case VT_DOUBLE: vtop->c.d = (double)(UNSIGNED)vtop->c.ui; break; + case VT_LDOUBLE: vtop->c.ld = (long double)(UNSIGNED)vtop->c.ui; break; + } + break; + default: + switch(dbt) { + case VT_FLOAT: vtop->c.f = (float)(SIGNED)vtop->c.i; break; + case VT_DOUBLE: vtop->c.d = (double)(SIGNED)vtop->c.i; break; + case VT_LDOUBLE: vtop->c.ld = (long double)(SIGNED)vtop->c.i; break; + } + break; + } + } else { + //do_itof: +#if !defined(TCC_TARGET_ARM) + gen_cvt_itof1(dbt); +#else + gen_cvt_itof(dbt); +#endif + } + } else if (sf) { + /* convert fp to int */ + /* we handle char/short/etc... with generic code */ + if (dbt != (VT_INT | VT_UNSIGNED) && + dbt != (VT_LLONG | VT_UNSIGNED) && + dbt != VT_LLONG && (dbt & VT_BTYPE) != VT_BOOL) + dbt = VT_INT; + if (c) { + switch(dbt) { + case VT_LLONG | VT_UNSIGNED: + case VT_LLONG: + /* XXX: add const cases for long long */ + goto do_ftoi; + case VT_INT | VT_UNSIGNED: + switch(sbt) { + case VT_FLOAT: vtop->c.ui = (UNSIGNED)vtop->c.d; break; + case VT_DOUBLE: vtop->c.ui = (UNSIGNED)vtop->c.d; break; + case VT_LDOUBLE: vtop->c.ui = (UNSIGNED)vtop->c.d; break; + } + break; + case VT_BOOL: + case VT_BOOL | VT_UNSIGNED: + vtop->c.ui = vtop->c.d != 0 ? 1: 0; + break; + default: + /* int case */ + switch(sbt) { + case VT_FLOAT: vtop->c.i = (SIGNED)vtop->c.d; break; + case VT_DOUBLE: vtop->c.i = (SIGNED)vtop->c.d; break; + case VT_LDOUBLE: vtop->c.i = (SIGNED)vtop->c.d; break; + } + break; + } + } else { + do_ftoi: + gen_cvt_ftoi1(dbt); + } + if (dbt == VT_INT && (type->t & (VT_BTYPE | VT_UNSIGNED)) != dbt) { + /* additional cast for char/short/bool... */ + vtop->type.t = dbt; + gen_cast(type); + } + } else if ((dbt & VT_BTYPE) == VT_LLONG) { + if ((sbt & VT_BTYPE) != VT_LLONG) { + /* scalar to long long */ + if (c) { + if (sbt == (VT_INT | VT_UNSIGNED)) + vtop->c.ll = vtop->c.ui; + else + vtop->c.ll = vtop->c.i; + } else { + /* machine independent conversion */ + gv(RC_INT); + /* generate high word */ + if (sbt == (VT_INT | VT_UNSIGNED)) { + vpushi(0); + gv(RC_INT); + } else { + gv_dup(); +#ifdef TCC_TARGET_816 + vpushi(15); +#else + vpushi(31); +#endif + gen_op(TOK_SAR); + } + /* patch second register */ + vtop[-1].r2 = vtop->r; + vpop(); + } + } + } else if ((dbt & VT_BTYPE) == VT_BOOL) { + if(c) { + //printf("const samma\n"); + vtop->c.ui = vtop->c.ui ? 1: 0; + } + else { + //printf("bool samma scho\n"); + /* scalar to bool */ + vpushi(0); + gen_op(TOK_NE); + } + //asm("int $3"); + } else if ((dbt & VT_BTYPE) == VT_BYTE || + (dbt & VT_BTYPE) == VT_SHORT) { + force_charshort_cast(dbt); + } else if ((dbt & VT_BTYPE) == VT_INT) { + /* scalar to int */ + +#ifdef TCC_TARGET_816 + /* fixes 960801-1.c */ + /* this is important if the value is cast back to a larger type + without going through a register first */ + if((dbt & VT_UNSIGNED) && c) vtop->c.ui &= 0xffff; +#endif + if (sbt == VT_LLONG) { + /* from long long: just take low order word */ + lexpand(); + vpop(); + } + /* if lvalue and single word type, nothing to do because + the lvalue already contains the real type size (see + VT_LVAL_xxx constants) */ +#ifdef TCC_TARGET_816 + /* Casting a byte to a word may not be necessary on other platforms + (I know it is not on ARM), but it is on the 65816, which does + not do any alignment and passes a single byte as a single byte. + If we do not do that here, the type is overwritten (see below), + and the code generator happily loads extra garbage bytes from + the stack or wherever. */ + if ((sbt & VT_BTYPE) == VT_BYTE || (sbt & VT_BTYPE) == VT_BOOL) { + //printf("geevau\n"); + gv(RC_INT); + } +#endif + } + } + vtop->type = *type; +} + +/* return type size. Put alignment at 'a' */ +static int type_size(CType *type, int *a) +{ + Sym *s; + int bt; + + bt = type->t & VT_BTYPE; + if (bt == VT_STRUCT) { + /* struct/union */ + s = type->ref; + *a = s->r; + return s->c; + } else if (bt == VT_PTR) { + if (type->t & VT_ARRAY) { + s = type->ref; + //if(s->c == -1) asm("int $3"); + return type_size(&s->type, a) * s->c; + } else { + *a = PTR_SIZE; + return PTR_SIZE; + } + } else if (bt == VT_LDOUBLE) { + *a = LDOUBLE_ALIGN; + return LDOUBLE_SIZE; + } else if (bt == VT_DOUBLE || bt == VT_LLONG) { +#ifdef TCC_TARGET_816 + *a = 4; + return 4; +#else +#ifdef TCC_TARGET_I386 + *a = 4; +#else + *a = 8; +#endif + return 8; +#endif + } else if (bt == VT_INT || bt == VT_ENUM || bt == VT_FLOAT) { +#ifdef TCC_TARGET_816 + if(bt == VT_FLOAT) { + *a = 4; + return 4; + } else { + *a = 2; + return 2; + } +#else + *a = 4; + return 4; +#endif + } else if (bt == VT_SHORT) { + *a = 2; + return 2; +#ifdef TCC_TARGET_816 + } else if (bt == VT_FUNC) { + *a = 4; + return 4; +#endif + } else { + /* char, void, function, _Bool */ + *a = 1; + return 1; + } +} + +/* return the pointed type of t */ +static inline CType *pointed_type(CType *type) +{ + return &type->ref->type; +} + +/* modify type so that its it is a pointer to type. */ +static void mk_pointer(CType *type) +{ + Sym *s; + s = sym_push(SYM_FIELD, type, 0, -1); + type->t = VT_PTR | (type->t & ~VT_TYPE); + type->ref = s; +} + +/* compare function types. OLD functions match any new functions */ +static int is_compatible_func(CType *type1, CType *type2) +{ + Sym *s1, *s2; + + s1 = type1->ref; + s2 = type2->ref; + if (!is_compatible_types(&s1->type, &s2->type)) + return 0; + /* check func_call */ + if (s1->r != s2->r) + return 0; + /* XXX: not complete */ + if (s1->c == FUNC_OLD || s2->c == FUNC_OLD) + return 1; + if (s1->c != s2->c) + return 0; + while (s1 != NULL) { + if (s2 == NULL) + return 0; + if (!is_compatible_types(&s1->type, &s2->type)) + return 0; + s1 = s1->next; + s2 = s2->next; + } + if (s2) + return 0; + return 1; +} + +/* return true if type1 and type2 are exactly the same (including + qualifiers). + + - enums are not checked as gcc __builtin_types_compatible_p () + */ +static int is_compatible_types(CType *type1, CType *type2) +{ + int bt1, t1, t2; + + t1 = type1->t & VT_TYPE; + t2 = type2->t & VT_TYPE; + /* XXX: bitfields ? */ + if (t1 != t2) + return 0; + /* test more complicated cases */ + bt1 = t1 & VT_BTYPE; + if (bt1 == VT_PTR) { + type1 = pointed_type(type1); + type2 = pointed_type(type2); + return is_compatible_types(type1, type2); + } else if (bt1 == VT_STRUCT) { + return (type1->ref == type2->ref); + } else if (bt1 == VT_FUNC) { + return is_compatible_func(type1, type2); + } else { + return 1; + } +} + +/* print a type. If 'varstr' is not NULL, then the variable is also + printed in the type */ +/* XXX: union */ +/* XXX: add array and function pointers */ +void type_to_str(char *buf, int buf_size, + CType *type, const char *varstr) +{ + int bt, v, t; + Sym *s, *sa; + char buf1[256]; + const char *tstr; + + t = type->t & VT_TYPE; + bt = t & VT_BTYPE; + buf[0] = '\0'; + if (t & VT_CONSTANT) + pstrcat(buf, buf_size, "const "); + if (t & VT_VOLATILE) + pstrcat(buf, buf_size, "volatile "); + if (t & VT_UNSIGNED) + pstrcat(buf, buf_size, "unsigned "); + switch(bt) { + case VT_VOID: + tstr = "void"; + goto add_tstr; + case VT_BOOL: + tstr = "_Bool"; + goto add_tstr; + case VT_BYTE: + tstr = "char"; + goto add_tstr; + case VT_SHORT: + tstr = "short"; + goto add_tstr; + case VT_INT: + tstr = "int"; + goto add_tstr; + case VT_LONG: + tstr = "long"; + goto add_tstr; + case VT_LLONG: + tstr = "long long"; + goto add_tstr; + case VT_FLOAT: + tstr = "float"; + goto add_tstr; + case VT_DOUBLE: + tstr = "double"; + goto add_tstr; + case VT_LDOUBLE: + tstr = "long double"; + add_tstr: + pstrcat(buf, buf_size, tstr); + break; + case VT_ENUM: + case VT_STRUCT: + if (bt == VT_STRUCT) + tstr = "struct "; + else + tstr = "enum "; + pstrcat(buf, buf_size, tstr); + v = type->ref->v & ~SYM_STRUCT; + if (v >= SYM_FIRST_ANOM) + pstrcat(buf, buf_size, ""); + else + pstrcat(buf, buf_size, get_tok_str(v, NULL)); + break; + case VT_FUNC: + s = type->ref; + type_to_str(buf, buf_size, &s->type, varstr); + pstrcat(buf, buf_size, "("); + sa = s->next; + while (sa != NULL) { + type_to_str(buf1, sizeof(buf1), &sa->type, NULL); + pstrcat(buf, buf_size, buf1); + sa = sa->next; + if (sa) + pstrcat(buf, buf_size, ", "); + } + pstrcat(buf, buf_size, ")"); + goto no_var; + case VT_PTR: + s = type->ref; + pstrcpy(buf1, sizeof(buf1), "*"); + if (varstr) + pstrcat(buf1, sizeof(buf1), varstr); + type_to_str(buf, buf_size, &s->type, buf1); + goto no_var; + } + if (varstr) { + pstrcat(buf, buf_size, " "); + pstrcat(buf, buf_size, varstr); + } + no_var: ; +} + +/* verify type compatibility to store vtop in 'dt' type, and generate + casts if needed. */ +static void gen_assign_cast(CType *dt) +{ + CType *st, *type1, *type2, tmp_type1, tmp_type2; + char buf1[256], buf2[256]; + int dbt, sbt; + + st = &vtop->type; /* source type */ + dbt = dt->t & VT_BTYPE; + sbt = st->t & VT_BTYPE; + if (dt->t & VT_CONSTANT) + warning("assignment of read-only location"); + switch(dbt) { + case VT_PTR: + /* special cases for pointers */ + /* '0' can also be a pointer */ + if (is_null_pointer(vtop)) + goto type_ok; + /* accept implicit pointer to integer cast with warning */ + if (is_integer_btype(sbt)) { + warning("assignment makes pointer from integer without a cast"); + goto type_ok; + } + type1 = pointed_type(dt); + /* a function is implicitely a function pointer */ + if (sbt == VT_FUNC) { + if ((type1->t & VT_BTYPE) != VT_VOID && + !is_compatible_types(pointed_type(dt), st)) + goto error; + else + goto type_ok; + } + if (sbt != VT_PTR) + goto error; + type2 = pointed_type(st); + if ((type1->t & VT_BTYPE) == VT_VOID || + (type2->t & VT_BTYPE) == VT_VOID) { + /* void * can match anything */ + } else { + /* exact type match, except for unsigned */ + tmp_type1 = *type1; + tmp_type2 = *type2; + tmp_type1.t &= ~(VT_UNSIGNED | VT_CONSTANT | VT_VOLATILE); + tmp_type2.t &= ~(VT_UNSIGNED | VT_CONSTANT | VT_VOLATILE); + if (!is_compatible_types(&tmp_type1, &tmp_type2)) + goto error; + } + /* check const and volatile */ + if ((!(type1->t & VT_CONSTANT) && (type2->t & VT_CONSTANT)) || + (!(type1->t & VT_VOLATILE) && (type2->t & VT_VOLATILE))) + warning("assignment discards qualifiers from pointer target type"); + break; + case VT_BYTE: + case VT_SHORT: + case VT_INT: + case VT_LLONG: + if (sbt == VT_PTR || sbt == VT_FUNC) { + warning("assignment makes integer from pointer without a cast"); + } + /* XXX: more tests */ + //fprintf(stderr,"### source type %d dest type %d\n", sbt, dbt); + break; + case VT_STRUCT: + tmp_type1 = *dt; + tmp_type2 = *st; + tmp_type1.t &= ~(VT_CONSTANT | VT_VOLATILE); + tmp_type2.t &= ~(VT_CONSTANT | VT_VOLATILE); + if (!is_compatible_types(&tmp_type1, &tmp_type2)) { + error: + type_to_str(buf1, sizeof(buf1), st, NULL); + type_to_str(buf2, sizeof(buf2), dt, NULL); + error("cannot cast '%s' to '%s'", buf1, buf2); + } + break; + } + type_ok: + gen_cast(dt); +} + +/* store vtop in lvalue pushed on stack */ +void vstore(void) +{ + int sbt, dbt, ft, r, t, size, align, bit_size, bit_pos, rc, delayed_cast; + static int nocast = 0; + + ft = vtop[-1].type.t; + sbt = vtop->type.t & VT_BTYPE; + dbt = ft & VT_BTYPE; + //fprintf(stderr,"vstore sbt 0x%x dbt 0x%x\n",sbt,dbt); + if (((sbt == VT_INT || sbt == VT_SHORT) && dbt == VT_BYTE) || + (sbt == VT_INT && dbt == VT_SHORT)) { + /* optimize char/short casts */ + delayed_cast = VT_MUSTCAST; + vtop->type.t = ft & VT_TYPE; + /* XXX: factorize */ + if (ft & VT_CONSTANT) + warning("assignment of read-only location"); + } else { + delayed_cast = 0; + if (!(ft & VT_BITFIELD) && !nocast) + gen_assign_cast(&vtop[-1].type); + } + + if (sbt == VT_STRUCT) { + /* if structure, only generate pointer */ + /* structure assignment : generate memcpy */ + /* XXX: optimize if small size */ + if (!nocode_wanted) { + size = type_size(&vtop->type, &align); + //if(size == 2) asm("int $3"); + //fprintf(stderr,"vtop type 0x%x size %d\n", vtop->type.t, size); + + vpush_global_sym(&func_old_type, TOK_memcpy); + + /* destination */ + vpushv(vtop - 2); + vtop->type.t = VT_PTR; + gaddrof(); + /* source */ + vpushv(vtop - 2); + vtop->type.t = VT_PTR; + gaddrof(); + /* type size */ + vpushi(size); + gfunc_call(3); + + vswap(); + vpop(); + } else { + vswap(); + vpop(); + } + /* leave source on stack */ + } else if (ft & VT_BITFIELD && !nocast) { + /* bitfield store handling */ + bit_pos = (ft >> VT_STRUCT_SHIFT) & 0x3f; + bit_size = (ft >> (VT_STRUCT_SHIFT + 6)) & 0x3f; + /* remove bit field info to avoid loops */ + vtop[-1].type.t = ft & ~(VT_BITFIELD | (-1 << VT_STRUCT_SHIFT)); + //fprintf(stderr,"vtop[-1].type.t 0x%x\n",vtop[-1].type.t); + + gen_assign_cast(&vtop[-1].type); + nocast = 1; // make sure our hard-earned bitfield value is not cast to bits again (e.g. to bool) + + /* duplicate destination */ + vdup(); + vtop[-1] = vtop[-2]; + + /* mask and shift source */ + vpushi((1 << bit_size) - 1); + gen_op('&'); + vpushi(bit_pos); + gen_op(TOK_SHL); + /* load destination, mask and or with source */ + vswap(); + vtop->r |= VT_LVAL; /* 20000113-1.c, bf-sign-1.c */ + vpushi(~(((1 << bit_size) - 1) << bit_pos)); + gen_op('&'); + gen_op('|'); + /* store result */ + vstore(); + /* This value may be used further down, so it has to be sign- or + zero-extended */ + if (ft & VT_UNSIGNED) { + vpushi(bit_pos); + gen_op(TOK_SHR); + vpushi((1 << bit_size) - 1); + gen_op('&'); + } + else { + vpushi(16-bit_size-bit_pos); + gen_op(TOK_SHL); + vpushi(16-bit_size); + gen_op(TOK_SAR); + } + + } else { +#ifdef CONFIG_TCC_BCHECK + /* bound check case */ + if (vtop[-1].r & VT_MUSTBOUND) { + vswap(); + gbound(); + vswap(); + } +#endif + if (!nocode_wanted) { + rc = RC_INT; + if (is_float(ft)) + rc = RC_FLOAT; + r = gv(rc); /* generate value */ + /* if lvalue was saved on stack, must read it */ + if ((vtop[-1].r & VT_VALMASK) == VT_LLOCAL) { + SValue sv; + t = get_reg(RC_INT); + sv.type.t = VT_PTR; /* 20030313-1.c */ + sv.r = VT_LOCAL | VT_LVAL; + sv.c.ul = vtop[-1].c.ul; + load(t, &sv); + vtop[-1].r = t | VT_LVAL; + } + store(r, vtop - 1); + /* two word case handling : store second register at word + 4 */ + if ((ft & VT_BTYPE) == VT_LLONG) { + vswap(); + /* convert to int to increment easily */ + vtop->type.t = VT_INT; + gaddrof(); +#ifdef TCC_TARGET_816 + vpushi(2); +#else + vpushi(4); +#endif + gen_op('+'); + vtop->r |= VT_LVAL; + vswap(); + /* XXX: it works because r2 is spilled last ! */ + store(vtop->r2, vtop - 1); + } + } + vswap(); + vtop--; /* NOT vpop() because on x86 it would flush the fp stack */ + vtop->r |= delayed_cast; + } + nocast = 0; + //fprintf(stderr,"end vstore\n"); +} + +/* post defines POST/PRE add. c is the token ++ or -- */ +void inc(int post, int c) +{ + test_lvalue(); + vdup(); /* save lvalue */ + if (post) { + gv_dup(); /* duplicate value */ + vrotb(3); + vrotb(3); + } + /* add constant */ + vpushi(c - TOK_MID); + gen_op('+'); + vstore(); /* store value */ + if (post) + vpop(); /* if post op, return saved value */ +} + +/* Parse GNUC __attribute__ extension. Currently, the following + extensions are recognized: + - aligned(n) : set data/function alignment. + - packed : force data alignment to 1 + - section(x) : generate data/code in this section. + - unused : currently ignored, but may be used someday. + - regparm(n) : pass function parameters in registers (i386 only) + */ +static void parse_attribute(AttributeDef *ad) +{ + int t, n; + + while (tok == TOK_ATTRIBUTE1 || tok == TOK_ATTRIBUTE2) { + next(); + skip('('); + skip('('); + while (tok != ')') { + if (tok < TOK_IDENT) + expect("attribute name"); + t = tok; + next(); + switch(t) { + case TOK_SECTION1: + case TOK_SECTION2: + skip('('); + if (tok != TOK_STR) + expect("section name"); + ad->section = find_section(tcc_state, (char *)tokc.cstr->data); + next(); + skip(')'); + break; + case TOK_ALIGNED1: + case TOK_ALIGNED2: + if (tok == '(') { + next(); + n = expr_const(); + if (n <= 0 || (n & (n - 1)) != 0) + error("alignment must be a positive power of two"); + skip(')'); + } else { + n = MAX_ALIGN; + } + ad->aligned = n; + break; + case TOK_PACKED1: + case TOK_PACKED2: + ad->packed = 1; + break; + case TOK_UNUSED1: + case TOK_UNUSED2: + /* currently, no need to handle it because tcc does not + track unused objects */ + break; + case TOK_NORETURN1: + case TOK_NORETURN2: + /* currently, no need to handle it because tcc does not + track unused objects */ + break; + case TOK_CDECL1: + case TOK_CDECL2: + case TOK_CDECL3: + ad->func_call = FUNC_CDECL; + break; + case TOK_STDCALL1: + case TOK_STDCALL2: + case TOK_STDCALL3: + ad->func_call = FUNC_STDCALL; + break; +#ifdef TCC_TARGET_I386 + case TOK_REGPARM1: + case TOK_REGPARM2: + skip('('); + n = expr_const(); + if (n > 3) + n = 3; + else if (n < 0) + n = 0; + if (n > 0) + ad->func_call = FUNC_FASTCALL1 + n - 1; + skip(')'); + break; +#endif + case TOK_DLLEXPORT: + ad->dllexport = 1; + break; + default: + if (tcc_state->warn_unsupported) + warning("'%s' attribute ignored", get_tok_str(t, NULL)); + /* skip parameters */ + /* XXX: skip parenthesis too */ + if (tok == '(') { + next(); + while (tok != ')' && tok != -1) + next(); + next(); + } + break; + } + if (tok != ',') + break; + next(); + } + skip(')'); + skip(')'); + } +} + +/* enum/struct/union declaration. u is either VT_ENUM or VT_STRUCT */ +static void struct_decl(CType *type, int u) +{ + int a, v, size = 0, align, maxalign, c, offset; + int bit_size, bit_pos, bsize, bt, lbit_pos; + Sym *s, *ss, **ps; + AttributeDef ad; + CType type1, btype; + + a = tok; /* save decl type */ + next(); + if (tok != '{') { + v = tok; + next(); + /* struct already defined ? return it */ + if (v < TOK_IDENT) + expect("struct/union/enum name"); + s = struct_find(v); + if (s) { + if (s->type.t != a) + error("invalid struct type"); + goto do_decl; + } + } else { + v = anon_sym++; + } + type1.t = a; + /* we put an undefined size for struct/union */ + s = sym_push(v | SYM_STRUCT, &type1, 0, -1); + s->r = 0; /* default alignment is zero as gcc */ + /* put struct/union/enum name in type */ + do_decl: + type->t = u; + type->ref = s; + + if (tok == '{') { + next(); + if (s->c != -1) + error("struct/union/enum already defined"); + /* cannot be empty */ + c = 0; + /* non empty enums are not allowed */ + if (a == TOK_ENUM) { + for(;;) { + v = tok; + if (v < TOK_UIDENT) + expect("identifier"); + next(); + if (tok == '=') { + next(); + c = expr_const(); + } + /* enum symbols have static storage */ + ss = sym_push(v, &int_type, VT_CONST, c); + ss->type.t |= VT_STATIC; + if (tok != ',') + break; + next(); + c++; + /* NOTE: we accept a trailing comma */ + if (tok == '}') + break; + } + skip('}'); + } else { + maxalign = 1; + ps = &s->next; + bit_pos = 0; + offset = 0; + while (tok != '}') { + parse_btype(&btype, &ad); + while (1) { + bit_size = -1; + v = 0; + type1 = btype; + if (tok != ':') { + type_decl(&type1, &ad, &v, TYPE_DIRECT); + if ((type1.t & VT_BTYPE) == VT_FUNC || + (type1.t & (VT_TYPEDEF | VT_STATIC | VT_EXTERN | VT_INLINE))) + error("invalid type for '%s'", + get_tok_str(v, NULL)); + } + if (tok == ':') { + next(); + bit_size = expr_const(); + /* XXX: handle v = 0 case for messages */ + if (bit_size < 0) + error("negative width in bit-field '%s'", + get_tok_str(v, NULL)); + if (v && bit_size == 0) + error("zero width for bit-field '%s'", + get_tok_str(v, NULL)); + } + size = type_size(&type1, &align); + if(size < 0) { + warning("unknown type size in struct %p",s); + //size = 1; + //asm("int $3"); + } + if (ad.aligned) { + if (align < ad.aligned) + align = ad.aligned; + } else if (ad.packed) { + align = 1; + } else if (*tcc_state->pack_stack_ptr) { + if (align > *tcc_state->pack_stack_ptr) + align = *tcc_state->pack_stack_ptr; + } + lbit_pos = 0; + if (bit_size >= 0) { + bt = type1.t & VT_BTYPE; + if (bt != VT_INT && + bt != VT_BYTE && + bt != VT_SHORT && + bt != VT_BOOL && + bt != VT_ENUM) + error("bitfields must have scalar type"); + bsize = size * 8; + if (bit_size > bsize) { + error("width of '%s' exceeds its type", + get_tok_str(v, NULL)); + } else if (bit_size == bsize) { + /* no need for bit fields */ + bit_pos = 0; + } else if (bit_size == 0) { + /* XXX: what to do if only padding in a + structure ? */ + /* zero size: means to pad */ + if (bit_pos > 0) + bit_pos = bsize; + } else { + /* we do not have enough room ? */ + if ((bit_pos + bit_size) > bsize) + bit_pos = 0; + lbit_pos = bit_pos; + /* XXX: handle LSB first */ + type1.t |= VT_BITFIELD | + (bit_pos << VT_STRUCT_SHIFT) | + (bit_size << (VT_STRUCT_SHIFT + 6)); + bit_pos += bit_size; + } + } else { + bit_pos = 0; + } + if (v) { + /* add new memory data only if starting + bit field */ + if (lbit_pos == 0) { + if (a == TOK_STRUCT) { + c = (c + align - 1) & -align; + offset = c; + c += size; + } else { + offset = 0; + if (size > c) + c = size; + } + if (align > maxalign) + maxalign = align; + } +#if 0 + printf("add field %s offset=%d", + get_tok_str(v, NULL), offset); + if (type1.t & VT_BITFIELD) { + printf(" pos=%d size=%d", + (type1.t >> VT_STRUCT_SHIFT) & 0x3f, + (type1.t >> (VT_STRUCT_SHIFT + 6)) & 0x3f); + } + printf("\n"); +#endif + ss = sym_push(v | SYM_FIELD, &type1, 0, offset); + *ps = ss; + ps = &ss->next; + } + if (tok == ';' || tok == TOK_EOF) + break; + skip(','); + } + skip(';'); + } + skip('}'); + /* store size and alignment */ + if(size < 0) s->c = size; else s->c = (c + maxalign - 1) & -maxalign; + s->r = maxalign; + } + } +} + +/* return 0 if no type declaration. otherwise, return the basic type + and skip it. + */ +static int parse_btype(CType *type, AttributeDef *ad) +{ + int t, u, type_found, typespec_found; + Sym *s; + CType type1; + + memset(ad, 0, sizeof(AttributeDef)); + type_found = 0; + typespec_found = 0; + t = 0; + while(1) { + switch(tok) { + case TOK_EXTENSION: + /* currently, we really ignore extension */ + next(); + continue; + + /* basic types */ + case TOK_CHAR: + u = VT_BYTE; + basic_type: + next(); + basic_type1: + if ((t & VT_BTYPE) != 0) + error("too many basic types"); + t |= u; + typespec_found = 1; + break; + case TOK_VOID: + u = VT_VOID; + goto basic_type; + case TOK_SHORT: +#ifdef TCC_TARGET_816 + u = VT_INT; +#else + u = VT_SHORT; +#endif + goto basic_type; + case TOK_INT: + next(); + typespec_found = 1; + break; + case TOK_LONG: + next(); +#ifdef TCC_TARGET_816 + if ((t & VT_BTYPE) == VT_FLOAT) { + // ignore + } else +#endif + if ((t & VT_BTYPE) == VT_DOUBLE) { + t = (t & ~VT_BTYPE) | VT_LDOUBLE; + } else if ((t & VT_BTYPE) == VT_LONG) { + t = (t & ~VT_BTYPE) | VT_LLONG; + } else { + u = VT_LONG; + goto basic_type1; + } + break; + case TOK_BOOL: + /* _Bool must be unsigned, or sign extension will get in our way when + using it in bitfields (20030714-1.c) */ + u = VT_BOOL | VT_UNSIGNED; + goto basic_type; + case TOK_FLOAT: + u = VT_FLOAT; + goto basic_type; + case TOK_DOUBLE: +#ifdef TCC_TARGET_816 + if((t & VT_BTYPE) == VT_LONG) { + t = (t & ~VT_BTYPE); + } + u = VT_FLOAT; + goto basic_type; +#else + next(); + if ((t & VT_BTYPE) == VT_LONG) { + t = (t & ~VT_BTYPE) | VT_LDOUBLE; + } else { + u = VT_DOUBLE; + goto basic_type1; + } +#endif + break; + case TOK_ENUM: + struct_decl(&type1, VT_ENUM); + type1.t |= VT_UNSIGNED; + basic_type2: + u = type1.t; + type->ref = type1.ref; + goto basic_type1; + case TOK_STRUCT: + case TOK_UNION: + struct_decl(&type1, VT_STRUCT); + goto basic_type2; + + /* type modifiers */ + case TOK_CONST1: + case TOK_CONST2: + case TOK_CONST3: + t |= VT_CONSTANT; + next(); + break; + case TOK_VOLATILE1: + case TOK_VOLATILE2: + case TOK_VOLATILE3: + t |= VT_VOLATILE; + next(); + break; + case TOK_SIGNED1: + case TOK_SIGNED2: + case TOK_SIGNED3: + typespec_found = 1; + t |= VT_SIGNED; + next(); + break; + case TOK_REGISTER: + case TOK_AUTO: + case TOK_RESTRICT1: + case TOK_RESTRICT2: + case TOK_RESTRICT3: + next(); + break; + case TOK_UNSIGNED: + t |= VT_UNSIGNED; + next(); + typespec_found = 1; + break; + + /* storage */ + case TOK_EXTERN: + t |= VT_EXTERN; + next(); + break; + case TOK_STATIC: + t |= VT_STATIC; + next(); + break; + case TOK_TYPEDEF: + t |= VT_TYPEDEF; + next(); + break; + case TOK_INLINE1: + case TOK_INLINE2: + case TOK_INLINE3: + t |= VT_INLINE; + next(); + break; + + /* GNUC attribute */ + case TOK_ATTRIBUTE1: + case TOK_ATTRIBUTE2: + parse_attribute(ad); + break; + /* GNUC typeof */ + case TOK_TYPEOF1: + case TOK_TYPEOF2: + case TOK_TYPEOF3: + next(); + parse_expr_type(&type1); + goto basic_type2; + default: + if (typespec_found) + goto the_end; + s = sym_find(tok); + if (!s || !(s->type.t & VT_TYPEDEF)) + goto the_end; + t |= (s->type.t & ~VT_TYPEDEF); + type->ref = s->type.ref; + next(); + break; + } + type_found = 1; + } +the_end: + if ((t & (VT_SIGNED|VT_UNSIGNED)) == (VT_SIGNED|VT_UNSIGNED)) + error("signed and unsigned modifier"); + if (tcc_state->char_is_unsigned) { + if ((t & (VT_SIGNED|VT_UNSIGNED|VT_BTYPE)) == VT_BYTE) + t |= VT_UNSIGNED; + } + t &= ~VT_SIGNED; + + /* long is never used as type */ + if ((t & VT_BTYPE) == VT_LONG) + t = (t & ~VT_BTYPE) | VT_INT; + + type->t = t; + return type_found; +} + +/* convert a function parameter type (array to pointer and function to + function pointer) */ +static inline void convert_parameter_type(CType *pt) +{ + /* remove const and volatile qualifiers (XXX: const could be used + to indicate a const function parameter */ + pt->t &= ~(VT_CONSTANT | VT_VOLATILE); + /* array must be transformed to pointer according to ANSI C */ + pt->t &= ~VT_ARRAY; + if ((pt->t & VT_BTYPE) == VT_FUNC) { + mk_pointer(pt); + } +} + +static void post_type(CType *type, AttributeDef *ad) +{ + int n, l, t1; + Sym **plast, *s, *first; + AttributeDef ad1; + CType pt; + + if (tok == '(') { + /* function declaration */ + next(); + l = 0; + first = NULL; + plast = &first; + while (tok != ')') { + /* read param name and compute offset */ + if (l != FUNC_OLD) { + if (!parse_btype(&pt, &ad1)) { + if (l) { + error("invalid type in function declaration"); + } else { + l = FUNC_OLD; + goto old_proto; + } + } + l = FUNC_NEW; + if ((pt.t & VT_BTYPE) == VT_VOID && tok == ')') + break; + type_decl(&pt, &ad1, &n, TYPE_DIRECT | TYPE_ABSTRACT); + if ((pt.t & VT_BTYPE) == VT_VOID) + error("parameter declared as void"); + } else { + old_proto: + n = tok; + pt.t = VT_INT; + next(); + if (!(tok == ',' || tok == ')')) + error("unknown type in function declaration"); + } + convert_parameter_type(&pt); + s = sym_push(n | SYM_FIELD, &pt, 0, 0); + *plast = s; + plast = &s->next; + if (tok == ',') { + next(); + if (l == FUNC_NEW && tok == TOK_DOTS) { + l = FUNC_ELLIPSIS; + next(); + break; + } + } + } + /* if no parameters, then old type prototype */ + if (l == 0) + l = FUNC_OLD; + skip(')'); + t1 = type->t & VT_STORAGE; + /* NOTE: const is ignored in returned type as it has a special + meaning in gcc / C++ */ + type->t &= ~(VT_STORAGE | VT_CONSTANT); + post_type(type, ad); + /* we push a anonymous symbol which will contain the function prototype */ + s = sym_push(SYM_FIELD, type, ad->func_call, l); + s->next = first; + type->t = t1 | VT_FUNC; + type->ref = s; + } else if (tok == '[') { + /* array definition */ + next(); + n = -1; + if (tok != ']') { + n = expr_const(); + if (n < 0) + error("invalid array size"); + } + + skip(']'); + /* parse next post type */ + t1 = type->t & VT_STORAGE; + type->t &= ~VT_STORAGE; + post_type(type, ad); + + /* we push a anonymous symbol which will contain the array + element type */ + s = sym_push(SYM_FIELD, type, 0, n); + //asm("int $3"); + type->t = t1 | VT_ARRAY | VT_PTR; + type->ref = s; + } +} + +/* Parse a type declaration (except basic type), and return the type + in 'type'. 'td' is a bitmask indicating which kind of type decl is + expected. 'type' should contain the basic type. 'ad' is the + attribute definition of the basic type. It can be modified by + type_decl(). + */ +static void type_decl(CType *type, AttributeDef *ad, int *v, int td) +{ + Sym *s; + CType type1, *type2; + int qualifiers; + + while (tok == '*') { + qualifiers = 0; + redo: + next(); + switch(tok) { + case TOK_CONST1: + case TOK_CONST2: + case TOK_CONST3: + qualifiers |= VT_CONSTANT; + goto redo; + case TOK_VOLATILE1: + case TOK_VOLATILE2: + case TOK_VOLATILE3: + qualifiers |= VT_VOLATILE; + goto redo; + case TOK_RESTRICT1: + case TOK_RESTRICT2: + case TOK_RESTRICT3: + goto redo; + } + mk_pointer(type); + type->t |= qualifiers; + } + + /* XXX: clarify attribute handling */ + if (tok == TOK_ATTRIBUTE1 || tok == TOK_ATTRIBUTE2) + parse_attribute(ad); + + /* recursive type */ + /* XXX: incorrect if abstract type for functions (e.g. 'int ()') */ + type1.t = 0; /* XXX: same as int */ + if (tok == '(') { + next(); + /* XXX: this is not correct to modify 'ad' at this point, but + the syntax is not clear */ + if (tok == TOK_ATTRIBUTE1 || tok == TOK_ATTRIBUTE2) + parse_attribute(ad); + type_decl(&type1, ad, v, td); + skip(')'); + } else { + /* type identifier */ + if (tok >= TOK_IDENT && (td & TYPE_DIRECT)) { + *v = tok; + next(); + } else { + if (!(td & TYPE_ABSTRACT)) + expect("identifier"); + *v = 0; + } + } + post_type(type, ad); + if (tok == TOK_ATTRIBUTE1 || tok == TOK_ATTRIBUTE2) + parse_attribute(ad); + if (!type1.t) + return; + /* append type at the end of type1 */ + type2 = &type1; + for(;;) { + s = type2->ref; + type2 = &s->type; + if (!type2->t) { + *type2 = *type; + break; + } + } + *type = type1; +} + +/* compute the lvalue VT_LVAL_xxx needed to match type t. */ +static int lvalue_type(int t) +{ + int bt, r; + r = VT_LVAL; + bt = t & VT_BTYPE; + if (bt == VT_BYTE || bt == VT_BOOL) + r |= VT_LVAL_BYTE; + else if (bt == VT_SHORT) + r |= VT_LVAL_SHORT; + else + return r; + if (t & VT_UNSIGNED) + r |= VT_LVAL_UNSIGNED; + return r; +} + +/* indirection with full error checking and bound check */ +static void indir(void) +{ + if ((vtop->type.t & VT_BTYPE) != VT_PTR) + expect("pointer"); + if ((vtop->r & VT_LVAL) && !nocode_wanted) + gv(RC_INT); + vtop->type = *pointed_type(&vtop->type); + /* an array is never an lvalue */ + if (!(vtop->type.t & VT_ARRAY)) { + vtop->r |= lvalue_type(vtop->type.t); + /* if bound checking, the referenced pointer must be checked */ + if (do_bounds_check) + vtop->r |= VT_MUSTBOUND; + } +} + +/* pass a parameter to a function and do type checking and casting */ +static void gfunc_param_typed(Sym *func, Sym *arg) +{ + int func_type; + CType type; + + func_type = func->c; + if (func_type == FUNC_OLD || + (func_type == FUNC_ELLIPSIS && arg == NULL)) { + /* default casting : only need to convert float to double */ +#ifndef TCC_TARGET_816 + if ((vtop->type.t & VT_BTYPE) == VT_FLOAT) { + type.t = VT_DOUBLE; + gen_cast(&type); + } +#endif + } else if (arg == NULL) { + error("too many arguments to function"); + } else { + type = arg->type; + type.t &= ~VT_CONSTANT; /* need to do that to avoid false warning */ + //fprintf(stderr,"### assign cast vtop->type.t 0x%x type 0x%x\n", vtop->type.t, type.t); + gen_assign_cast(&type); + } +} + +/* parse an expression of the form '(type)' or '(expr)' and return its + type */ +static void parse_expr_type(CType *type) +{ + int n; + AttributeDef ad; + + skip('('); + if (parse_btype(type, &ad)) { + type_decl(type, &ad, &n, TYPE_ABSTRACT); + } else { + expr_type(type); + } + skip(')'); +} + +static void parse_type(CType *type) +{ + AttributeDef ad; + int n; + + if (!parse_btype(type, &ad)) { + expect("type"); + } + type_decl(type, &ad, &n, TYPE_ABSTRACT); +} + +static void vpush_tokc(int t) +{ + CType type; + type.t = t; + vsetc(&type, VT_CONST, &tokc); +} + +static void unary(void) +{ + int n, t, align, size, r; + CType type; + Sym *s; + AttributeDef ad; + + /* XXX: GCC 2.95.3 does not generate a table although it should be + better here */ + tok_next: + switch(tok) { + case TOK_EXTENSION: + next(); + goto tok_next; + case TOK_CINT: + case TOK_CCHAR: + case TOK_LCHAR: + vpushi(tokc.i); + next(); + break; + case TOK_CUINT: + vpush_tokc(VT_INT | VT_UNSIGNED); + next(); + break; + case TOK_CLLONG: + vpush_tokc(VT_LLONG); + next(); + break; + case TOK_CULLONG: + vpush_tokc(VT_LLONG | VT_UNSIGNED); + next(); + break; + case TOK_CFLOAT: + vpush_tokc(VT_FLOAT); + next(); + break; + case TOK_CDOUBLE: +#ifdef TCC_TARGET_816 + vpush_tokc(VT_FLOAT); +#else + vpush_tokc(VT_DOUBLE); +#endif + next(); + break; + case TOK_CLDOUBLE: +#ifdef TCC_TARGET_816 + vpush_tokc(VT_FLOAT); +#else + vpush_tokc(VT_LDOUBLE); +#endif + next(); + break; + case TOK___FUNCTION__: + if (!gnu_ext) + goto tok_identifier; + /* fall thru */ + case TOK___FUNC__: + { + void *ptr; + int len; + /* special function name identifier */ + len = strlen(funcname) + 1; + /* generate char[len] type */ + type.t = VT_BYTE; + mk_pointer(&type); + type.t |= VT_ARRAY; + type.ref->c = len; + vpush_ref(&type, data_section, data_section->data_offset, len); + ptr = section_ptr_add(data_section, len); + memcpy(ptr, funcname, len); + next(); + } + break; + case TOK_LSTR: + t = VT_INT; + goto str_init; + case TOK_STR: + /* string parsing */ + t = VT_BYTE; + str_init: + if (tcc_state->warn_write_strings) + t |= VT_CONSTANT; + type.t = t; + mk_pointer(&type); + type.t |= VT_ARRAY; + memset(&ad, 0, sizeof(AttributeDef)); + decl_initializer_alloc(&type, &ad, VT_CONST, 2, 0, 0); + break; + case '(': + next(); + /* cast ? */ + if (parse_btype(&type, &ad)) { + type_decl(&type, &ad, &n, TYPE_ABSTRACT); + skip(')'); + /* check ISOC99 compound literal */ + if (tok == '{') { + /* data is allocated locally by default */ + if (global_expr) + r = VT_CONST; + else + r = VT_LOCAL; + /* all except arrays are lvalues */ + if (!(type.t & VT_ARRAY)) + r |= lvalue_type(type.t); + memset(&ad, 0, sizeof(AttributeDef)); + decl_initializer_alloc(&type, &ad, r, 1, 0, 0); + } else { + unary(); + gen_cast(&type); + } + } else if (tok == '{') { + /* save all registers */ + save_regs(0); + /* statement expression : we do not accept break/continue + inside as GCC does */ + block(NULL, NULL, NULL, NULL, 0, 1); + skip(')'); + } else { + gexpr(); + skip(')'); + } + break; + case '*': + next(); + unary(); + indir(); + break; + case '&': + next(); + unary(); + /* functions names must be treated as function pointers, + except for unary '&' and sizeof. Since we consider that + functions are not lvalues, we only have to handle it + there and in function calls. */ + /* arrays can also be used although they are not lvalues */ + if ((vtop->type.t & VT_BTYPE) != VT_FUNC && + !(vtop->type.t & VT_ARRAY)) + test_lvalue(); + mk_pointer(&vtop->type); + gaddrof(); + break; + case '!': + next(); + unary(); + if ((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST) + vtop->c.i = !vtop->c.i; + else if ((vtop->r & VT_VALMASK) == VT_CMP) + vtop->c.i = vtop->c.i ^ 1; + else + vseti(VT_JMP, gtst(1, 0)); + break; + case '~': + next(); + unary(); + vpushi(-1); + gen_op('^'); + break; + case '+': + next(); + /* in order to force cast, we add zero */ + unary(); + if ((vtop->type.t & VT_BTYPE) == VT_PTR) + error("pointer not accepted for unary plus"); + vpushi(0); + gen_op('+'); + break; + case TOK_SIZEOF: + case TOK_ALIGNOF1: + case TOK_ALIGNOF2: + t = tok; + next(); + if (tok == '(') { + parse_expr_type(&type); + } else { + unary_type(&type); + } + size = type_size(&type, &align); + if (t == TOK_SIZEOF) { + if (size < 0) + error("sizeof applied to an incomplete type"); + vpushi(size); + } else { + vpushi(align); + } + break; + + case TOK_builtin_types_compatible_p: + { + CType type1, type2; + next(); + skip('('); + parse_type(&type1); + skip(','); + parse_type(&type2); + skip(')'); + type1.t &= ~(VT_CONSTANT | VT_VOLATILE); + type2.t &= ~(VT_CONSTANT | VT_VOLATILE); + vpushi(is_compatible_types(&type1, &type2)); + } + break; + case TOK_builtin_constant_p: + { + int saved_nocode_wanted, res; + next(); + skip('('); + saved_nocode_wanted = nocode_wanted; + nocode_wanted = 1; + gexpr(); + res = (vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST; + vpop(); + nocode_wanted = saved_nocode_wanted; + skip(')'); + vpushi(res); + } + break; + case TOK_INC: + case TOK_DEC: + t = tok; + next(); + unary(); + inc(0, t); + break; + case '-': + next(); + vpushi(0); + unary(); + gen_op('-'); + break; + case TOK_LAND: + if (!gnu_ext) + goto tok_identifier; + next(); + /* allow to take the address of a label */ + if (tok < TOK_UIDENT) + expect("label identifier"); + s = label_find(tok); + if (!s) { + s = label_push(&global_label_stack, tok, LABEL_FORWARD); + } else { + if (s->r == LABEL_DECLARED) + s->r = LABEL_FORWARD; + } + if (!s->type.t) { + s->type.t = VT_VOID; + mk_pointer(&s->type); + s->type.t |= VT_STATIC; + } + vset(&s->type, VT_CONST | VT_SYM, 0); + vtop->sym = s; + next(); + break; + default: + tok_identifier: + t = tok; + next(); + if (t < TOK_UIDENT) + expect("identifier"); + s = sym_find(t); + if (!s) { + if (tok != '(') + error("'%s' undeclared", get_tok_str(t, NULL)); + /* for simple function calls, we tolerate undeclared + external reference to int() function */ + if (tcc_state->warn_implicit_function_declaration) + warning("implicit declaration of function '%s'", + get_tok_str(t, NULL)); + s = external_global_sym(t, &func_old_type, 0); + } + if ((s->type.t & (VT_STATIC | VT_INLINE | VT_BTYPE)) == + (VT_STATIC | VT_INLINE | VT_FUNC)) { + /* if referencing an inline function, then we generate a + symbol to it if not already done. It will have the + effect to generate code for it at the end of the + compilation unit. Inline function as always + generated in the text section. */ + if (!s->c) + put_extern_sym(s, text_section, 0, 0); + r = VT_SYM | VT_CONST; + } else { + r = s->r; + } + vset(&s->type, r, s->c); + /* if forward reference, we must point to s */ + if (vtop->r & VT_SYM) { + vtop->sym = s; + vtop->c.ul = 0; + } + break; + } + + /* post operations */ + while (1) { + if (tok == TOK_INC || tok == TOK_DEC) { + inc(1, tok); + next(); + } else if (tok == '.' || tok == TOK_ARROW) { + /* field */ + if (tok == TOK_ARROW) + indir(); + test_lvalue(); + gaddrof(); + next(); + /* expect pointer on structure */ + if ((vtop->type.t & VT_BTYPE) != VT_STRUCT) + expect("struct or union"); + s = vtop->type.ref; + /* find field */ + tok |= SYM_FIELD; + while ((s = s->next) != NULL) { + if (s->v == tok) + break; + } + if (!s) + error("field not found"); + /* add field offset to pointer */ + vtop->type = char_pointer_type; /* change type to 'char *' */ + vpushi(s->c); + gen_op('+'); + /* change type to field type, and set to lvalue */ + //fprintf(stderr,"ft 0x%x r 0x%x\n", vtop->type.t,vtop->r); + vtop->type = s->type; + //fprintf(stderr,"ft 0x%x r 0x%x\n", vtop->type.t,vtop->r); + /* an array is never an lvalue */ + if (!(vtop->type.t & VT_ARRAY)) { + vtop->r |= lvalue_type(vtop->type.t); + /* if bound checking, the referenced pointer must be checked */ + if (do_bounds_check) + vtop->r |= VT_MUSTBOUND; + } + //fprintf(stderr,"ft 0x%x r 0x%x\n", vtop->type.t,vtop->r); + next(); + } else if (tok == '[') { + next(); + gexpr(); + gen_op('+'); + indir(); + skip(']'); + } else if (tok == '(') { + SValue ret; + Sym *sa; + int nb_args; + + /* function call */ + if ((vtop->type.t & VT_BTYPE) != VT_FUNC) { + /* pointer test (no array accepted) */ + if ((vtop->type.t & (VT_BTYPE | VT_ARRAY)) == VT_PTR) { + vtop->type = *pointed_type(&vtop->type); + if ((vtop->type.t & VT_BTYPE) != VT_FUNC) + goto error_func; + } else { + error_func: + expect("function pointer"); + } + } else { + vtop->r &= ~VT_LVAL; /* no lvalue */ + } + /* get return type */ + s = vtop->type.ref; + next(); + sa = s->next; /* first parameter */ + nb_args = 0; + /* compute first implicit argument if a structure is returned */ + if ((s->type.t & VT_BTYPE) == VT_STRUCT) { + /* get some space for the returned structure */ + size = type_size(&s->type, &align); + loc = (loc - size) & -align; + ret.type = s->type; + ret.r = VT_LOCAL | VT_LVAL; + /* pass it as 'int' to avoid structure arg passing + problems */ + //vseti(VT_LOCAL, loc); // asdf + vset(&ptr_type, VT_LOCAL, loc); + ret.c = vtop->c; + nb_args++; + } else { + ret.type = s->type; + ret.r2 = VT_CONST; + /* return in register */ + if (is_float(ret.type.t)) { + ret.r = REG_FRET; + } else { + if ((ret.type.t & VT_BTYPE) == VT_LLONG) + ret.r2 = REG_LRET; + ret.r = REG_IRET; + } + ret.c.i = 0; + } + if (tok != ')') { + for(;;) { + expr_eq(); + gfunc_param_typed(s, sa); + nb_args++; + if (sa) + sa = sa->next; + if (tok == ')') + break; + skip(','); + } + } + if (sa) + error("too few arguments to function"); + skip(')'); + if (!nocode_wanted) { + gfunc_call(nb_args); + } else { + vtop -= (nb_args + 1); + } + /* return value */ + vsetc(&ret.type, ret.r, &ret.c); + vtop->r2 = ret.r2; + } else { + break; + } + } +} + +static void uneq(void) +{ + int t; + + unary(); + if (tok == '=' || + (tok >= TOK_A_MOD && tok <= TOK_A_DIV) || + tok == TOK_A_XOR || tok == TOK_A_OR || + tok == TOK_A_SHL || tok == TOK_A_SAR) { + test_lvalue(); + t = tok; + next(); + if (t == '=') { + expr_eq(); + } else { + vdup(); + expr_eq(); + gen_op(t & 0x7f); + } + vstore(); + } +} + +static void expr_prod(void) +{ + int t; + + uneq(); + while (tok == '*' || tok == '/' || tok == '%') { + t = tok; + next(); + uneq(); + gen_op(t); + } +} + +static void expr_sum(void) +{ + int t; + + expr_prod(); + while (tok == '+' || tok == '-') { + t = tok; + next(); + expr_prod(); + gen_op(t); + } +} + +static void expr_shift(void) +{ + int t; + + expr_sum(); + while (tok == TOK_SHL || tok == TOK_SAR) { + t = tok; + next(); + expr_sum(); + gen_op(t); + } +} + +static void expr_cmp(void) +{ + int t; + + expr_shift(); + while ((tok >= TOK_ULE && tok <= TOK_GT) || + tok == TOK_ULT || tok == TOK_UGE) { + t = tok; + next(); + expr_shift(); + gen_op(t); + } +} + +static void expr_cmpeq(void) +{ + int t; + + expr_cmp(); + while (tok == TOK_EQ || tok == TOK_NE) { + t = tok; + next(); + expr_cmp(); + gen_op(t); + } +} + +static void expr_and(void) +{ + expr_cmpeq(); + while (tok == '&') { + next(); + expr_cmpeq(); + gen_op('&'); + } +} + +static void expr_xor(void) +{ + expr_and(); + while (tok == '^') { + next(); + expr_and(); + gen_op('^'); + } +} + +static void expr_or(void) +{ + expr_xor(); + while (tok == '|') { + next(); + expr_xor(); + gen_op('|'); + } +} + +/* XXX: fix this mess */ +static void expr_land_const(void) +{ + expr_or(); + while (tok == TOK_LAND) { + next(); + expr_or(); + gen_op(TOK_LAND); + } +} + +/* XXX: fix this mess */ +static void expr_lor_const(void) +{ + expr_land_const(); + while (tok == TOK_LOR) { + next(); + expr_land_const(); + gen_op(TOK_LOR); + } +} + +/* only used if non constant */ +static void expr_land(void) +{ + int t; + + expr_or(); + if (tok == TOK_LAND) { + t = 0; + for(;;) { + t = gtst(1, t); + if (tok != TOK_LAND) { + vseti(VT_JMPI, t); + break; + } + next(); + expr_or(); + } + } +} + +static void expr_lor(void) +{ + int t; + + expr_land(); + if (tok == TOK_LOR) { + t = 0; + for(;;) { + t = gtst(0, t); + if (tok != TOK_LOR) { + vseti(VT_JMP, t); + break; + } + next(); + expr_land(); + } + } +} + +/* XXX: better constant handling */ +static void expr_eq(void) +{ + int tt, u, r1, r2, rc, t1, t2, bt1, bt2; + SValue sv; + CType type, type1, type2; + + if (const_wanted) { + int c1, c; + expr_lor_const(); + if (tok == '?') { + c = vtop->c.i; + vpop(); + next(); + if (tok == ':' && gnu_ext) { + c1 = c; + } else { + gexpr(); + c1 = vtop->c.i; + vpop(); + } + skip(':'); + expr_eq(); + if (c) + vtop->c.i = c1; + } + } else { + expr_lor(); + if (tok == '?') { + next(); + if (vtop != vstack) { + /* needed to avoid having different registers saved in + each branch */ + if (is_float(vtop->type.t)) + rc = RC_FLOAT; + else + rc = RC_INT; + gv(rc); + save_regs(1); + } + if (tok == ':' && gnu_ext) { + gv_dup(); + tt = gtst(1, 0); + } else { + tt = gtst(1, 0); + gexpr(); + } + type1 = vtop->type; + sv = *vtop; /* save value to handle it later */ + vtop--; /* no vpop so that FP stack is not flushed */ + skip(':'); + u = gjmp(0); + gsym(tt); + expr_eq(); + type2 = vtop->type; + + t1 = type1.t; + bt1 = t1 & VT_BTYPE; + t2 = type2.t; + bt2 = t2 & VT_BTYPE; + /* cast operands to correct type according to ISOC rules */ + if (is_float(bt1) || is_float(bt2)) { + if (bt1 == VT_LDOUBLE || bt2 == VT_LDOUBLE) { + type.t = VT_LDOUBLE; + } else if (bt1 == VT_DOUBLE || bt2 == VT_DOUBLE) { + type.t = VT_DOUBLE; + } else { + type.t = VT_FLOAT; + } + } else if (bt1 == VT_LLONG || bt2 == VT_LLONG) { + /* cast to biggest op */ + type.t = VT_LLONG; + /* convert to unsigned if it does not fit in a long long */ + if ((t1 & (VT_BTYPE | VT_UNSIGNED)) == (VT_LLONG | VT_UNSIGNED) || + (t2 & (VT_BTYPE | VT_UNSIGNED)) == (VT_LLONG | VT_UNSIGNED)) + type.t |= VT_UNSIGNED; + } else if (bt1 == VT_PTR || bt2 == VT_PTR) { + /* XXX: test pointer compatibility */ + type = type1; + } else if (bt1 == VT_STRUCT || bt2 == VT_STRUCT) { + /* XXX: test structure compatibility */ + type = type1; + } else if (bt1 == VT_VOID || bt2 == VT_VOID) { + /* NOTE: as an extension, we accept void on only one side */ + type.t = VT_VOID; + } else { + /* integer operations */ + type.t = VT_INT; + /* convert to unsigned if it does not fit in an integer */ + if ((t1 & (VT_BTYPE | VT_UNSIGNED)) == (VT_INT | VT_UNSIGNED) || + (t2 & (VT_BTYPE | VT_UNSIGNED)) == (VT_INT | VT_UNSIGNED)) + type.t |= VT_UNSIGNED; + } + + /* now we convert second operand */ + gen_cast(&type); + rc = RC_INT; + if (is_float(type.t)) { + rc = RC_FLOAT; + } else if ((type.t & VT_BTYPE) == VT_LLONG) { + /* for long longs, we use fixed registers to avoid having + to handle a complicated move */ + rc = RC_IRET; + } + + r2 = gv(rc); + /* this is horrible, but we must also convert first + operand */ + tt = gjmp(0); + gsym(u); + /* put again first value and cast it */ + *vtop = sv; + gen_cast(&type); + r1 = gv(rc); + move_reg(r2, r1); + vtop->r = r2; + gsym(tt); + } + } +} + +static void gexpr(void) +{ + while (1) { + expr_eq(); + if (tok != ',') + break; + vpop(); + next(); + } +} + +/* parse an expression and return its type without any side effect. */ +static void expr_type(CType *type) +{ + int saved_nocode_wanted; + + saved_nocode_wanted = nocode_wanted; + nocode_wanted = 1; + gexpr(); + *type = vtop->type; + vpop(); + nocode_wanted = saved_nocode_wanted; +} + +/* parse a unary expression and return its type without any side + effect. */ +static void unary_type(CType *type) +{ + int a; + + a = nocode_wanted; + nocode_wanted = 1; + unary(); + *type = vtop->type; + vpop(); + nocode_wanted = a; +} + +/* parse a constant expression and return value in vtop. */ +static void expr_const1(void) +{ + int a; + a = const_wanted; + const_wanted = 1; + expr_eq(); + const_wanted = a; +} + +/* parse an integer constant and return its value. */ +static int expr_const(void) +{ + int c; + expr_const1(); + if ((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) != VT_CONST) + expect("constant expression"); + c = vtop->c.i; + vpop(); + return c; +} + +/* return the label token if current token is a label, otherwise + return zero */ +static int is_label(void) +{ + int last_tok; + + /* fast test first */ + if (tok < TOK_UIDENT) + return 0; + /* no need to save tokc because tok is an identifier */ + last_tok = tok; + next(); + if (tok == ':') { + next(); + return last_tok; + } else { + unget_tok(last_tok); + return 0; + } +} + +static void block(int *bsym, int *csym, int *case_sym, int *def_sym, + int case_reg, int is_expr) +{ + int a, b, c, d; + Sym *s; + + /* generate line number info */ + if (do_debug && + (last_line_num != file->line_num || last_ind != ind)) { + put_stabn(N_SLINE, 0, file->line_num, ind - func_ind); + last_ind = ind; + last_line_num = file->line_num; + } + + if (is_expr) { + /* default return value is (void) */ + vpushi(0); + vtop->type.t = VT_VOID; + } + + if (tok == TOK_IF) { + /* if test */ + next(); + skip('('); + gexpr(); + skip(')'); + a = gtst(1, 0); + block(bsym, csym, case_sym, def_sym, case_reg, 0); + c = tok; + if (c == TOK_ELSE) { + next(); + d = gjmp(0); + gsym(a); + block(bsym, csym, case_sym, def_sym, case_reg, 0); + gsym(d); /* patch else jmp */ + } else + gsym(a); + } else if (tok == TOK_WHILE) { + next(); + d = ind; + skip('('); + gexpr(); + skip(')'); + a = gtst(1, 0); + b = 0; + block(&a, &b, case_sym, def_sym, case_reg, 0); + gjmp_addr(d); + gsym(a); + gsym_addr(b, d); + } else if (tok == '{') { + Sym *llabel; + + next(); + /* record local declaration stack position */ + s = local_stack; + llabel = local_label_stack; + /* handle local labels declarations */ + if (tok == TOK_LABEL) { + next(); + for(;;) { + if (tok < TOK_UIDENT) + expect("label identifier"); + label_push(&local_label_stack, tok, LABEL_DECLARED); + next(); + if (tok == ',') { + next(); + } else { + skip(';'); + break; + } + } + } + while (tok != '}') { + decl(VT_LOCAL); + if (tok != '}') { + if (is_expr) + vpop(); + block(bsym, csym, case_sym, def_sym, case_reg, is_expr); + } + } + /* pop locally defined labels */ + label_pop(&local_label_stack, llabel); + /* pop locally defined symbols */ + sym_pop(&local_stack, s); + next(); + } else if (tok == TOK_RETURN) { + next(); + if (tok != ';') { + gexpr(); + gen_assign_cast(&func_vt); + if ((func_vt.t & VT_BTYPE) == VT_STRUCT) { + CType type; + /* if returning structure, must copy it to implicit + first pointer arg location */ + type = func_vt; + mk_pointer(&type); + vset(&type, VT_LOCAL | VT_LVAL, func_vc); + indir(); + vswap(); + /* copy structure value to pointer */ + vstore(); + } else if (is_float(func_vt.t)) { + gv(RC_FRET); + } else { + gv(RC_IRET); + } + vtop--; /* NOT vpop() because on x86 it would flush the fp stack */ + } + skip(';'); + rsym = gjmp(rsym); /* jmp */ + } else if (tok == TOK_BREAK) { + /* compute jump */ + if (!bsym) + error("cannot break"); + *bsym = gjmp(*bsym); + next(); + skip(';'); + } else if (tok == TOK_CONTINUE) { + /* compute jump */ + if (!csym) + error("cannot continue"); + *csym = gjmp(*csym); + next(); + skip(';'); + } else if (tok == TOK_FOR) { + int e; + next(); + skip('('); + if (tok != ';') { + gexpr(); + vpop(); + } + skip(';'); + d = ind; + c = ind; + a = 0; + b = 0; + if (tok != ';') { + gexpr(); + a = gtst(1, 0); + } + skip(';'); + if (tok != ')') { + e = gjmp(0); + c = ind; + gexpr(); + vpop(); + gjmp_addr(d); + gsym(e); + } + skip(')'); + block(&a, &b, case_sym, def_sym, case_reg, 0); + gjmp_addr(c); + gsym(a); + gsym_addr(b, c); + } else + if (tok == TOK_DO) { + next(); + a = 0; + b = 0; + d = ind; + block(&a, &b, case_sym, def_sym, case_reg, 0); + skip(TOK_WHILE); + skip('('); + gsym(b); + gexpr(); + c = gtst(0, 0); + gsym_addr(c, d); + skip(')'); + gsym(a); + skip(';'); + } else + if (tok == TOK_SWITCH) { + next(); + skip('('); + gexpr(); + /* XXX: other types than integer */ + case_reg = gv(RC_INT); + vpop(); + skip(')'); + a = 0; + b = gjmp(0); /* jump to first case */ + c = 0; + block(&a, csym, &b, &c, case_reg, 0); + /* if no default, jmp after switch */ + if (c == 0) + c = ind; + /* default label */ + gsym_addr(b, c); + /* break label */ + gsym(a); + } else + if (tok == TOK_CASE) { + int v1, v2; + if (!case_sym) + expect("switch"); + next(); + v1 = expr_const(); + v2 = v1; + if (gnu_ext && tok == TOK_DOTS) { + next(); + v2 = expr_const(); + if (v2 < v1) + warning("empty case range"); + } + /* since a case is like a label, we must skip it with a jmp */ + b = gjmp(0); + gsym(*case_sym); + vseti(case_reg, 0); + vpushi(v1); + if (v1 == v2) { + gen_op(TOK_EQ); + *case_sym = gtst(1, 0); + } else { + gen_op(TOK_GE); + *case_sym = gtst(1, 0); + vseti(case_reg, 0); + vpushi(v2); + gen_op(TOK_LE); + *case_sym = gtst(1, *case_sym); + } + gsym(b); + skip(':'); + is_expr = 0; + goto block_after_label; + } else + if (tok == TOK_DEFAULT) { + next(); + skip(':'); + if (!def_sym) + expect("switch"); + if (*def_sym) + error("too many 'default'"); + *def_sym = ind; + is_expr = 0; + goto block_after_label; + } else + if (tok == TOK_GOTO) { + next(); + if (tok == '*' && gnu_ext) { + /* computed goto */ + next(); + gexpr(); + if ((vtop->type.t & VT_BTYPE) != VT_PTR) + expect("pointer"); + ggoto(); + } else if (tok >= TOK_UIDENT) { + s = label_find(tok); + /* put forward definition if needed */ + if (!s) { + s = label_push(&global_label_stack, tok, LABEL_FORWARD); + } else { + if (s->r == LABEL_DECLARED) + s->r = LABEL_FORWARD; + } + /* label already defined */ + if (s->r & LABEL_FORWARD) + s->next = (void *)(long)gjmp((long)s->next); + else + gjmp_addr((long)s->next); + next(); + } else { + expect("label identifier"); + } + skip(';'); + } else if (tok == TOK_ASM1 || tok == TOK_ASM2 || tok == TOK_ASM3) { + asm_instr(); + } else { + b = is_label(); + if (b) { + /* label case */ + s = label_find(b); + if (s) { + if (s->r == LABEL_DEFINED) + error("duplicate label '%s'", get_tok_str(s->v, NULL)); +#ifdef TCC_TARGET_816 + /* 816 code generator needs to know the names of labels, but only + gets addresses; using label_workaround to both indicate that + this is a label, and what its name is. gsym_addr() resets + label_workaround to NULL when done. */ + label_workaround = get_tok_str(s->v, NULL); + gsym((long)s->next); +#endif + s->r = LABEL_DEFINED; + } else { + s = label_push(&global_label_stack, b, LABEL_DEFINED); +#ifdef TCC_TARGET_816 + /* see above */ + label_workaround = get_tok_str(s->v, NULL); + gsym((long)s->next); /* without this, labels end up in the wrong place (too late) */ +#endif + } + s->next = (void *)(long)ind; + /* we accept this, but it is a mistake */ + block_after_label: + if (tok == '}') { + warning("deprecated use of label at end of compound statement"); + } else { + if (is_expr) + vpop(); + block(bsym, csym, case_sym, def_sym, case_reg, is_expr); + } + } else { + /* expression case */ + if (tok != ';') { + if (is_expr) { + vpop(); + gexpr(); + } else { + gexpr(); + vpop(); + } + } + skip(';'); + } + } +} + +/* t is the array or struct type. c is the array or struct + address. cur_index/cur_field is the pointer to the current + value. 'size_only' is true if only size info is needed (only used + in arrays) */ +static void decl_designator(CType *type, Section *sec, unsigned long c, + int *cur_index, Sym **cur_field, + int size_only) +{ + Sym *s, *f; + int notfirst, index, index_last, align, l, nb_elems, elem_size; + CType type1; + + notfirst = 0; + elem_size = 0; + nb_elems = 1; + if (gnu_ext && (l = is_label()) != 0) + goto struct_field; + while (tok == '[' || tok == '.') { + if (tok == '[') { + if (!(type->t & VT_ARRAY)) + expect("array type"); + s = type->ref; + next(); + index = expr_const(); + if (index < 0 || (s->c >= 0 && index >= s->c)) + expect("invalid index"); + if (tok == TOK_DOTS && gnu_ext) { + next(); + index_last = expr_const(); + if (index_last < 0 || + (s->c >= 0 && index_last >= s->c) || + index_last < index) + expect("invalid index"); + } else { + index_last = index; + } + skip(']'); + if (!notfirst) + *cur_index = index_last; + type = pointed_type(type); + elem_size = type_size(type, &align); + c += index * elem_size; + /* NOTE: we only support ranges for last designator */ + nb_elems = index_last - index + 1; + if (nb_elems != 1) { + notfirst = 1; + break; + } + } else { + next(); + l = tok; + next(); + struct_field: + if ((type->t & VT_BTYPE) != VT_STRUCT) + expect("struct/union type"); + s = type->ref; + l |= SYM_FIELD; + f = s->next; + while (f) { + if (f->v == l) + break; + f = f->next; + } + if (!f) + expect("field"); + if (!notfirst) + *cur_field = f; + /* XXX: fix this mess by using explicit storage field */ + type1 = f->type; + type1.t |= (type->t & ~VT_TYPE); + type = &type1; + c += f->c; + } + notfirst = 1; + } + if (notfirst) { + if (tok == '=') { + next(); + } else { + if (!gnu_ext) + expect("="); + } + } else { + if (type->t & VT_ARRAY) { + index = *cur_index; + type = pointed_type(type); + c += index * type_size(type, &align); + } else { + f = *cur_field; + if (!f) + error("too many field init"); + //fprintf(stderr,"design type before 0x%x ftype 0x%x\n", type->t,f->type.t); + /* XXX: fix this mess by using explicit storage field */ + type1 = f->type; + type1.t |= (type->t & ~VT_TYPE); + type = &type1; + //fprintf(stderr,"design type after 0x%x\n", type->t); + c += f->c; + } + } + decl_initializer(type, sec, c, 0, size_only); + + /* XXX: make it more general */ + if (!size_only && nb_elems > 1) { + unsigned long c_end; + uint8_t *src, *dst; + int i; + + if (!sec) + error("range init not supported yet for dynamic storage"); + c_end = c + nb_elems * elem_size; + if (c_end > sec->data_allocated) + section_realloc(sec, c_end); + src = sec->data + c; + dst = src; + for(i = 1; i < nb_elems; i++) { + dst += elem_size; + memcpy(dst, src, elem_size); + } + } +} + +#define EXPR_VAL 0 +#define EXPR_CONST 1 +#define EXPR_ANY 2 + +/* store a value or an expression directly in global data or in local array */ +static void init_putv(CType *type, Section *sec, unsigned long c, + int v, int expr_type) +{ + int saved_global_expr, bt, bit_pos, bit_size; + void *ptr; + unsigned long long bit_mask; + CType dtype; + + switch(expr_type) { + case EXPR_VAL: + vpushi(v); + break; + case EXPR_CONST: + /* compound literals must be allocated globally in this case */ + saved_global_expr = global_expr; + global_expr = 1; + expr_const1(); + global_expr = saved_global_expr; + /* NOTE: symbols are accepted */ + if ((vtop->r & (VT_VALMASK | VT_LVAL)) != VT_CONST) + error("initializer element is not constant"); + break; + case EXPR_ANY: + expr_eq(); + break; + } + + dtype = *type; + dtype.t &= ~VT_CONSTANT; /* need to do that to avoid false warning */ + + if (sec) { + /* XXX: not portable */ + /* XXX: generate error if incorrect relocation */ + gen_assign_cast(&dtype); + bt = type->t & VT_BTYPE; + ptr = sec->data + c; +#if 0 + if(!ptr) { + fprintf(stderr,"section allocd %d size %d\n", sec->data_allocated, sec->sh_size); + section_realloc(sec, c + PTR_SIZE); + sec->sh_size += c + PTR_SIZE; + ptr = sec->data + c; + } +#endif + /* XXX: make code faster ? */ + if (!(type->t & VT_BITFIELD)) { + bit_pos = 0; + bit_size = 32; + bit_mask = -1LL; + } else { + bit_pos = (vtop->type.t >> VT_STRUCT_SHIFT) & 0x3f; + bit_size = (vtop->type.t >> (VT_STRUCT_SHIFT + 6)) & 0x3f; + bit_mask = (1LL << bit_size) - 1; + } + //fprintf(stderr,"@@@ alrighty, we have bit_pos %d bit_size %d bit_mask %lld\n", bit_pos, bit_size, bit_mask); + if ((vtop->r & VT_SYM) && + (bt == VT_BYTE || + bt == VT_SHORT || + bt == VT_DOUBLE || + bt == VT_LDOUBLE || + bt == VT_LLONG || + (bt == VT_INT && bit_size != 32))) + error("initializer element is not computable at load time"); + switch(bt) { + case VT_BYTE: + *(char *)ptr |= (vtop->c.i & bit_mask) << bit_pos; + break; + case VT_SHORT: + *(short *)ptr |= (vtop->c.i & bit_mask) << bit_pos; + break; +#ifdef TCC_TARGET_816 + case VT_FLOAT: + float_to_woz(vtop->c.f, ptr); + break; +#endif + case VT_DOUBLE: + *(double *)ptr = vtop->c.d; + break; + case VT_LDOUBLE: + *(long double *)ptr = vtop->c.ld; + break; + case VT_LLONG: +#ifdef TCC_TARGET_816 + *(int *) +#else + *(long long *) +#endif + ptr |= (vtop->c.ll & bit_mask) << bit_pos; + break; + default: + if (vtop->r & VT_SYM) { + //fprintf(stderr,"@@@ alrighty, reloccing to section %s, c %ld\n", sec->name, c); + greloc(sec, vtop->sym, c, R_DATA_32); + } +#ifdef TCC_TARGET_816 + *(short *) +#else + *(int *) +#endif + ptr |= (vtop->c.i & bit_mask) << bit_pos; + break; + } + vtop--; + } else { + vset(&dtype, VT_LOCAL, c); + vswap(); + vstore(); + vpop(); + } +} + +/* put zeros for variable based init */ +static void init_putz(CType *t, Section *sec, unsigned long c, int size) +{ + if (sec) { + /* nothing to do because globals are already set to zero */ + } else { + vpush_global_sym(&func_old_type, TOK_memset); + //vseti(VT_LOCAL, c); + vset(&ptr_type, VT_LOCAL, c); + vpushi(0); + vpushi(size); + gfunc_call(3); + } +} + +/* 't' contains the type and storage info. 'c' is the offset of the + object in section 'sec'. If 'sec' is NULL, it means stack based + allocation. 'first' is true if array '{' must be read (multi + dimension implicit array init handling). 'size_only' is true if + size only evaluation is wanted (only for arrays). */ +static void decl_initializer(CType *type, Section *sec, unsigned long c, + int first, int size_only) +{ + int index, array_length, n, no_oblock, nb, parlevel, i; + int size1, align1, expr_type; + Sym *s, *f; + CType *t1; + + if (type->t & VT_ARRAY) { + s = type->ref; + n = s->c; + array_length = 0; + t1 = pointed_type(type); + size1 = type_size(t1, &align1); + + no_oblock = 1; + if ((first && tok != TOK_LSTR && tok != TOK_STR) || + tok == '{') { + skip('{'); + no_oblock = 0; + } + + /* only parse strings here if correct type (otherwise: handle + them as ((w)char *) expressions */ + if ((tok == TOK_LSTR && + (t1->t & VT_BTYPE) == VT_INT) || + (tok == TOK_STR && + (t1->t & VT_BTYPE) == VT_BYTE)) { + while (tok == TOK_STR || tok == TOK_LSTR) { + int cstr_len, ch; + CString *cstr; + + cstr = tokc.cstr; + /* compute maximum number of chars wanted */ + if (tok == TOK_STR) + cstr_len = cstr->size; + else + cstr_len = cstr->size / sizeof(int); + cstr_len--; + nb = cstr_len; + if (n >= 0 && nb > (n - array_length)) + nb = n - array_length; + if (!size_only) { + if (cstr_len > nb) + warning("initializer-string for array is too long"); + /* in order to go faster for common case (char + string in global variable, we handle it + specifically */ + if (sec && tok == TOK_STR && size1 == 1) { + //fprintf(stderr,"c %d array_length %d\n", c, array_length); + //section_realloc(sec, c + array_length + nb); + memcpy(sec->data + c + array_length, cstr->data, nb); + } else { + for(i=0;idata)[i]; + else + ch = ((int *)cstr->data)[i]; + init_putv(t1, sec, c + (array_length + i) * size1, + ch, EXPR_VAL); + } + } + } + array_length += nb; + next(); + } + /* only add trailing zero if enough storage (no + warning in this case since it is standard) */ + if (n < 0 || array_length < n) { + if (!size_only) { + init_putv(t1, sec, c + (array_length * size1), 0, EXPR_VAL); + } + array_length++; + } + } else { + index = 0; + while (tok != '}') { + decl_designator(type, sec, c, &index, NULL, size_only); + if (n >= 0 && index >= n) + error("index too large"); + /* must put zero in holes (note that doing it that way + ensures that it even works with designators) */ + if (!size_only && array_length < index) { + init_putz(t1, sec, c + array_length * size1, + (index - array_length) * size1); + } + index++; + if (index > array_length) + array_length = index; + /* special test for multi dimensional arrays (may not + be strictly correct if designators are used at the + same time) */ + if (index >= n && no_oblock) + break; + if (tok == '}') + break; + skip(','); + } + } + if (!no_oblock) + skip('}'); + /* put zeros at the end */ + if (!size_only && n >= 0 && array_length < n) { + init_putz(t1, sec, c + array_length * size1, + (n - array_length) * size1); + } + /* patch type size if needed */ + if (n < 0) { + //fprintf(stderr,"patching length from %d to %d in %p (prev %p)\n", s->c, array_length,s,s->prev); + //asm("int $3"); + s->c = array_length; + } + } else if ((type->t & VT_BTYPE) == VT_STRUCT && + (sec || !first || tok == '{')) { + int par_count; + + /* NOTE: the previous test is a specific case for automatic + struct/union init */ + /* XXX: union needs only one init */ + + /* XXX: this test is incorrect for local initializers + beginning with ( without {. It would be much more difficult + to do it correctly (ideally, the expression parser should + be used in all cases) */ + par_count = 0; + if (tok == '(') { + AttributeDef ad1; + CType type1; + next(); + while (tok == '(') { + par_count++; + next(); + } + if (!parse_btype(&type1, &ad1)) + expect("cast"); + type_decl(&type1, &ad1, &n, TYPE_ABSTRACT); +#if 0 + if (!is_assignable_types(type, &type1)) + error("invalid type for cast"); +#endif + skip(')'); + } + no_oblock = 1; + if (first || tok == '{') { + skip('{'); + no_oblock = 0; + } + s = type->ref; + f = s->next; + array_length = 0; + index = 0; + n = s->c; + if(!size_only && n != -1) { + /* zeroing the entire struct before filling in the values ensures + that decl_designator() won't forget filling in holes in structs inside + this one, and is probably more efficient anyway than filling each hole + with its own memset() call. */ + init_putz(type, sec, c, n); + } + while (tok != '}') { + //asm("int $3"); + decl_designator(type, sec, c, NULL, &f, size_only); + index = f->c; + //printf("n %d index %d array_length %d\n",n,index,array_length); + if (!size_only && array_length < index) { + //printf("; init_putz 1\n"); + //init_putz(type, sec, c + array_length, + // index - array_length); + } + index = index + type_size(&f->type, &align1); + if (index > array_length) + array_length = index; + f = f->next; + if (no_oblock && f == NULL) + break; + if (tok == '}') + break; + skip(','); + } + if(n == -1) n = s->c = array_length; /* size was unknown before, set it properly */ + +#if 0 + /* put zeros at the end */ + if (!size_only && array_length < n) { + printf("; init_putz 2\n"); + init_putz(type, sec, c + array_length, + n - array_length); + } +#endif + if (!no_oblock) + skip('}'); + while (par_count) { + skip(')'); + par_count--; + } + } else if (tok == '{') { + next(); + decl_initializer(type, sec, c, first, size_only); + skip('}'); + } else if (size_only) { + /* just skip expression */ + parlevel = 0; + while ((parlevel > 0 || (tok != '}' && tok != ',')) && + tok != -1) { + if (tok == '(') + parlevel++; + else if (tok == ')') + parlevel--; + next(); + } + } else { + /* currently, we always use constant expression for globals + (may change for scripting case) */ + expr_type = EXPR_CONST; + if (!sec) + expr_type = EXPR_ANY; + init_putv(type, sec, c, 0, expr_type); + } +} + +/* parse an initializer for type 't' if 'has_init' is non zero, and + allocate space in local or global data space ('r' is either + VT_LOCAL or VT_CONST). If 'v' is non zero, then an associated + variable 'v' of scope 'scope' is declared before initializers are + parsed. If 'v' is zero, then a reference to the new object is put + in the value stack. If 'has_init' is 2, a special parsing is done + to handle string constants. */ +static void decl_initializer_alloc(CType *type, AttributeDef *ad, int r, + int has_init, int v, int scope) +{ + int size, align, addr, data_offset; + int level; + ParseState saved_parse_state; + TokenString init_str; + Section *sec; + + size = type_size(type, &align); + /* If unknown size, we must evaluate it before + evaluating initializers because + initializers can generate global data too + (e.g. string pointers or ISOC99 compound + literals). It also simplifies local + initializers handling */ + tok_str_new(&init_str); + if (size < 0) { + if (!has_init) + error("unknown type size"); + /* get all init string */ + if (has_init == 2) { + /* only get strings */ + while (tok == TOK_STR || tok == TOK_LSTR) { + tok_str_add_tok(&init_str); + next(); + } + } else { + level = 0; + while (level > 0 || (tok != ',' && tok != ';')) { + if (tok < 0) + error("unexpected end of file in initializer"); + tok_str_add_tok(&init_str); + if (tok == '{') + level++; + else if (tok == '}') { + if (level == 0) + break; + level--; + } + next(); + } + } + tok_str_add(&init_str, -1); + tok_str_add(&init_str, 0); + + /* compute size */ + save_parse_state(&saved_parse_state); + + macro_ptr = init_str.str; + next(); + decl_initializer(type, NULL, 0, 1, 1); + /* prepare second initializer parsing */ + macro_ptr = init_str.str; + next(); + + /* if still unknown size, error */ + size = type_size(type, &align); + if (size < 0) + error("unknown type size"); + } + /* take into account specified alignment if bigger */ + if (ad->aligned) { + if (ad->aligned > align) + align = ad->aligned; + } else if (ad->packed) { + align = 1; + } + if ((r & VT_VALMASK) == VT_LOCAL) { + sec = NULL; + if (do_bounds_check && (type->t & VT_ARRAY)) + loc--; + loc = (loc - size) & -align; + addr = loc; + /* handles bounds */ + /* XXX: currently, since we do only one pass, we cannot track + '&' operators, so we add only arrays */ + if (do_bounds_check && (type->t & VT_ARRAY)) { + unsigned long *bounds_ptr; + /* add padding between regions */ + loc--; + /* then add local bound info */ + bounds_ptr = section_ptr_add(lbounds_section, 2 * sizeof(unsigned long)); + bounds_ptr[0] = addr; + bounds_ptr[1] = size; + } + if (v) { + /* local variable */ + sym_push(v, type, r, addr); + } else { + /* push local reference */ + vset(type, r, addr); + } + } else { + Sym *sym; + + sym = NULL; + if (v && scope == VT_CONST) { + /* see if the symbol was already defined */ + sym = sym_find(v); + if (sym) { + if (!is_compatible_types(&sym->type, type)) + error("incompatible types for redefinition of '%s'", + get_tok_str(v, NULL)); + if (sym->type.t & VT_EXTERN) { + /* if the variable is extern, it was not allocated */ + sym->type.t &= ~VT_EXTERN; + /* set array size if it was ommited in extern + declaration */ + if ((sym->type.t & VT_ARRAY) && + sym->type.ref->c < 0 && + type->ref->c >= 0) + sym->type.ref->c = type->ref->c; + } else { + /* we accept several definitions of the same + global variable. this is tricky, because we + must play with the SHN_COMMON type of the symbol */ + /* XXX: should check if the variable was already + initialized. It is incorrect to initialized it + twice */ + /* no init data, we won't add more to the symbol */ + if (!has_init) + goto no_alloc; + } + } + } + + /* allocate symbol in corresponding section */ + sec = ad->section; + if (!sec) { + if (has_init == 2) + sec = rodata_section; + else + if (has_init) + sec = data_section; + else if (tcc_state->nocommon) + sec = bss_section; + } + //fprintf(stderr,"SECS %s\n",sec==data_section?"data":sec==bss_section?"bss":sec==rodata_section?"rodata":"unknown"); + if (sec) { + data_offset = sec->data_offset; + data_offset = (data_offset + align - 1) & -align; + addr = data_offset; + /* very important to increment global pointer at this time + because initializers themselves can create new initializers */ + data_offset += size; + /* add padding if bound check */ + if (do_bounds_check) + data_offset++; + sec->data_offset = data_offset; + /* allocate section space to put the data */ + if (sec->sh_type != SHT_NOBITS && + data_offset > sec->data_allocated) + section_realloc(sec, data_offset); + /* align section if needed */ + if (align > sec->sh_addralign) + sec->sh_addralign = align; + } else { + addr = 0; /* avoid warning */ + } + + if (v) { + if (scope == VT_CONST) { + if (!sym) + goto do_def; + } else { + do_def: + sym = sym_push(v, type, r | VT_SYM, 0); + } + /* update symbol definition */ + if (sec) { + put_extern_sym(sym, sec, addr, size); + } else { + Elf32_Sym *esym; + /* put a common area */ + put_extern_sym(sym, NULL, align, size); + /* XXX: find a nicer way */ + esym = &((Elf32_Sym *)symtab_section->data)[sym->c]; + esym->st_shndx = SHN_COMMON; + } + } else { + CValue cval; + + /* push global reference */ + sym = get_sym_ref(type, sec, addr, size); + cval.ul = 0; + vsetc(type, VT_CONST | VT_SYM, &cval); + vtop->sym = sym; + } + + /* handles bounds now because the symbol must be defined + before for the relocation */ + if (do_bounds_check) { + unsigned long *bounds_ptr; + + greloc(bounds_section, sym, bounds_section->data_offset, R_DATA_32); + /* then add global bound info */ + bounds_ptr = section_ptr_add(bounds_section, 2 * sizeof(long)); + bounds_ptr[0] = 0; /* relocated */ + bounds_ptr[1] = size; + } + } + if (has_init) { + decl_initializer(type, sec, addr, 1, 0); + /* restore parse state if needed */ + if (init_str.str) { + tok_str_free(init_str.str); + restore_parse_state(&saved_parse_state); + } + } + no_alloc: ; +} + +void put_func_debug(Sym *sym) +{ + char buf[512]; + + /* stabs info */ + /* XXX: we put here a dummy type */ + snprintf(buf, sizeof(buf), "%s:%c1", + funcname, sym->type.t & VT_STATIC ? 'f' : 'F'); + put_stabs_r(buf, N_FUN, 0, file->line_num, 0, + cur_text_section, sym->c); + last_ind = 0; + last_line_num = 0; +} + +/* parse an old style function declaration list */ +/* XXX: check multiple parameter */ +static void func_decl_list(Sym *func_sym) +{ + AttributeDef ad; + int v; + Sym *s; + CType btype, type; + + /* parse each declaration */ + while (tok != '{' && tok != ';' && tok != ',' && tok != TOK_EOF) { + if (!parse_btype(&btype, &ad)) + expect("declaration list"); + if (((btype.t & VT_BTYPE) == VT_ENUM || + (btype.t & VT_BTYPE) == VT_STRUCT) && + tok == ';') { + /* we accept no variable after */ + } else { + for(;;) { + type = btype; + type_decl(&type, &ad, &v, TYPE_DIRECT); + /* find parameter in function parameter list */ + s = func_sym->next; + while (s != NULL) { + if ((s->v & ~SYM_FIELD) == v) + goto found; + s = s->next; + } + error("declaration for parameter '%s' but no such parameter", + get_tok_str(v, NULL)); + found: + /* check that no storage specifier except 'register' was given */ + if (type.t & VT_STORAGE) + error("storage class specified for '%s'", get_tok_str(v, NULL)); + convert_parameter_type(&type); + /* we can add the type (NOTE: it could be local to the function) */ + s->type = type; + /* accept other parameters */ + if (tok == ',') + next(); + else + break; + } + } + skip(';'); + } +} + +/* parse a function defined by symbol 'sym' and generate its code in + 'cur_text_section' */ +static void gen_function(Sym *sym) +{ + ind = cur_text_section->data_offset; + /* NOTE: we patch the symbol size later */ + put_extern_sym(sym, cur_text_section, ind, 0); + funcname = get_tok_str(sym->v, NULL); + func_ind = ind; + /* put debug symbol */ + if (do_debug) + put_func_debug(sym); + /* push a dummy symbol to enable local sym storage */ + sym_push2(&local_stack, SYM_FIELD, 0, 0); + gfunc_prolog(&sym->type); + rsym = 0; + block(NULL, NULL, NULL, NULL, 0, 0); + gsym(rsym); + gfunc_epilog(); + cur_text_section->data_offset = ind; +#if 0 + Sym* ls = global_label_stack; + fprintf(stderr,"dumping global_label_stack\n"); + for(;ls;ls=ls->next) fprintf(stderr,"--- glabel %s r 0x%x c 0x%x\n",get_tok_str(ls->v,NULL),ls->r,ls->c); +#endif + label_pop(&global_label_stack, NULL); + sym_pop(&local_stack, NULL); /* reset local stack */ + /* end of function */ + /* patch symbol size */ + ((Elf32_Sym *)symtab_section->data)[sym->c].st_size = + ind - func_ind; + if (do_debug) { + put_stabn(N_FUN, 0, 0, ind - func_ind); + } + funcname = ""; /* for safety */ + func_vt.t = VT_VOID; /* for safety */ + ind = 0; /* for safety */ +} + +static void gen_inline_functions(void) +{ + Sym *sym; + CType *type; + int *str, inline_generated; + + /* iterate while inline function are referenced */ + for(;;) { + inline_generated = 0; + for(sym = global_stack; sym != NULL; sym = sym->prev) { + type = &sym->type; + if (((type->t & VT_BTYPE) == VT_FUNC) && + (type->t & (VT_STATIC | VT_INLINE)) == + (VT_STATIC | VT_INLINE) && + sym->c != 0) { + /* the function was used: generate its code and + convert it to a normal function */ + str = (int *)sym->r; + sym->r = VT_SYM | VT_CONST; + type->t &= ~VT_INLINE; + + macro_ptr = str; + next(); + cur_text_section = text_section; + gen_function(sym); + macro_ptr = NULL; /* fail safe */ + + tok_str_free(str); + inline_generated = 1; + } + } + if (!inline_generated) + break; + } + + /* free all remaining inline function tokens */ + for(sym = global_stack; sym != NULL; sym = sym->prev) { + type = &sym->type; + if (((type->t & VT_BTYPE) == VT_FUNC) && + (type->t & (VT_STATIC | VT_INLINE)) == + (VT_STATIC | VT_INLINE)) { + str = (int *)sym->r; + tok_str_free(str); + sym->r = 0; /* fail safe */ + } + } +} + +/* 'l' is VT_LOCAL or VT_CONST to define default storage type */ +static void decl(int l) +{ + int v, has_init, r; + CType type, btype; + Sym *sym; + AttributeDef ad; + + while (1) { + if (!parse_btype(&btype, &ad)) { + /* skip redundant ';' */ + /* XXX: find more elegant solution */ + if (tok == ';') { + next(); + continue; + } + if (l == VT_CONST && + (tok == TOK_ASM1 || tok == TOK_ASM2 || tok == TOK_ASM3)) { + /* global asm block */ + asm_global_instr(); + continue; + } + /* special test for old K&R protos without explicit int + type. Only accepted when defining global data */ + if (l == VT_LOCAL || tok < TOK_DEFINE) + break; + btype.t = VT_INT; + } + if (((btype.t & VT_BTYPE) == VT_ENUM || + (btype.t & VT_BTYPE) == VT_STRUCT) && + tok == ';') { + /* we accept no variable after */ + next(); + continue; + } + while (1) { /* iterate thru each declaration */ + type = btype; + type_decl(&type, &ad, &v, TYPE_DIRECT); +#if 0 + { + char buf[500]; + type_to_str(buf, sizeof(buf), &type, get_tok_str(v, NULL)); + printf("type = '%s'\n", buf); + } +#endif + if ((type.t & VT_BTYPE) == VT_FUNC) { + /* if old style function prototype, we accept a + declaration list */ + sym = type.ref; + if (sym->c == FUNC_OLD) + func_decl_list(sym); + } + + if (tok == '{') { + if (l == VT_LOCAL) + error("cannot use local functions"); + if (!(type.t & VT_FUNC)) + expect("function definition"); + + /* reject abstract declarators in function definition */ + sym = type.ref; + while ((sym = sym->next) != NULL) + if (!(sym->v & ~SYM_FIELD)) + expect("identifier"); + + /* XXX: cannot do better now: convert extern line to static inline */ + if ((type.t & (VT_EXTERN | VT_INLINE)) == (VT_EXTERN | VT_INLINE)) + type.t = (type.t & ~VT_EXTERN) | VT_STATIC; + + sym = sym_find(v); + if (sym) { + if ((sym->type.t & VT_BTYPE) != VT_FUNC) + goto func_error1; + /* specific case: if not func_call defined, we put + the one of the prototype */ + /* XXX: should have default value */ + if (sym->type.ref->r != FUNC_CDECL && + type.ref->r == FUNC_CDECL) + type.ref->r = sym->type.ref->r; + if (!is_compatible_types(&sym->type, &type)) { + func_error1: + error("incompatible types for redefinition of '%s'", + get_tok_str(v, NULL)); + } + /* if symbol is already defined, then put complete type */ + sym->type = type; + } else { + /* put function symbol */ + sym = global_identifier_push(v, type.t, 0); + sym->type.ref = type.ref; + } + + /* static inline functions are just recorded as a kind + of macro. Their code will be emitted at the end of + the compilation unit only if they are used */ + if ((type.t & (VT_INLINE | VT_STATIC)) == + (VT_INLINE | VT_STATIC)) { + TokenString func_str; + int block_level; + + tok_str_new(&func_str); + + block_level = 0; + for(;;) { + int t; + if (tok == TOK_EOF) + error("unexpected end of file"); + tok_str_add_tok(&func_str); + t = tok; + next(); + if (t == '{') { + block_level++; + } else if (t == '}') { + block_level--; + if (block_level == 0) + break; + } + } + tok_str_add(&func_str, -1); + tok_str_add(&func_str, 0); + sym->r = (long)func_str.str; + } else { + /* compute text section */ + cur_text_section = ad.section; + if (!cur_text_section) + cur_text_section = text_section; + sym->r = VT_SYM | VT_CONST; + gen_function(sym); +#ifdef TCC_TARGET_PE + if (ad.dllexport) { + ((Elf32_Sym *)symtab_section->data)[sym->c].st_other |= 1; + } +#endif + } + break; + } else { + if (btype.t & VT_TYPEDEF) { + /* save typedefed type */ + /* XXX: test storage specifiers ? */ + sym = sym_push(v, &type, 0, 0); + sym->type.t |= VT_TYPEDEF; + } else if ((type.t & VT_BTYPE) == VT_FUNC) { + /* external function definition */ + /* specific case for func_call attribute */ + if (ad.func_call) + type.ref->r = ad.func_call; + external_sym(v, &type, 0); + } else { + /* not lvalue if array */ + r = 0; + if (!(type.t & VT_ARRAY)) + r |= lvalue_type(type.t); + has_init = (tok == '='); + if ((btype.t & VT_EXTERN) || + ((type.t & VT_ARRAY) && (type.t & VT_STATIC) && + !has_init && l == VT_CONST && type.ref->c < 0)) { + /* external variable */ + /* NOTE: as GCC, uninitialized global static + arrays of null size are considered as + extern */ + external_sym(v, &type, r); + } else { + if (type.t & VT_STATIC) { + r |= VT_CONST; + // handle with care: introducing a new flag seems to introduce subtle lossage + if(l == VT_LOCAL) + type.t |= VT_STATICLOCAL; + } + else + r |= l; + if (has_init) + next(); + decl_initializer_alloc(&type, &ad, r, + has_init, v, l); + } + } + if (tok != ',') { + skip(';'); + break; + } + next(); + } + } + } +} + +/* better than nothing, but needs extension to handle '-E' option + correctly too */ +static void preprocess_init(TCCState *s1) +{ + s1->include_stack_ptr = s1->include_stack; + /* XXX: move that before to avoid having to initialize + file->ifdef_stack_ptr ? */ + s1->ifdef_stack_ptr = s1->ifdef_stack; + file->ifdef_stack_ptr = s1->ifdef_stack_ptr; + + /* XXX: not ANSI compliant: bound checking says error */ + vtop = vstack - 1; + s1->pack_stack[0] = 0; + s1->pack_stack_ptr = s1->pack_stack; +} + +/* compile the C file opened in 'file'. Return non zero if errors. */ +static int tcc_compile(TCCState *s1) +{ + Sym *define_start; + char buf[512]; + volatile int section_sym; + +#ifdef INC_DEBUG + printf("%s: **** new file\n", file->filename); +#endif + preprocess_init(s1); + + funcname = ""; + anon_sym = SYM_FIRST_ANOM; + + /* file info: full path + filename */ + section_sym = 0; /* avoid warning */ + if (do_debug) { + section_sym = put_elf_sym(symtab_section, 0, 0, + ELF32_ST_INFO(STB_LOCAL, STT_SECTION), 0, + text_section->sh_num, NULL); + getcwd(buf, sizeof(buf)); + pstrcat(buf, sizeof(buf), "/"); + put_stabs_r(buf, N_SO, 0, 0, + text_section->data_offset, text_section, section_sym); + put_stabs_r(file->filename, N_SO, 0, 0, + text_section->data_offset, text_section, section_sym); + } + /* an elf symbol of type STT_FILE must be put so that STB_LOCAL + symbols can be safely used */ + put_elf_sym(symtab_section, 0, 0, + ELF32_ST_INFO(STB_LOCAL, STT_FILE), 0, + SHN_ABS, file->filename); + + /* define some often used types */ + int_type.t = VT_INT; + ptr_type.t = VT_PTR; + + char_pointer_type.t = VT_BYTE; + mk_pointer(&char_pointer_type); + + func_old_type.t = VT_FUNC; + func_old_type.ref = sym_push(SYM_FIELD, &int_type, FUNC_CDECL, FUNC_OLD); + +#if 0 + /* define 'void *alloca(unsigned int)' builtin function */ + { + Sym *s1; + + p = anon_sym++; + sym = sym_push(p, mk_pointer(VT_VOID), FUNC_CDECL, FUNC_NEW); + s1 = sym_push(SYM_FIELD, VT_UNSIGNED | VT_INT, 0, 0); + s1->next = NULL; + sym->next = s1; + sym_push(TOK_alloca, VT_FUNC | (p << VT_STRUCT_SHIFT), VT_CONST, 0); + } +#endif + + define_start = define_stack; + + if (setjmp(s1->error_jmp_buf) == 0) { + s1->nb_errors = 0; + s1->error_set_jmp_enabled = 1; + + ch = file->buf_ptr[0]; + tok_flags = TOK_FLAG_BOL | TOK_FLAG_BOF; + parse_flags = PARSE_FLAG_PREPROCESS | PARSE_FLAG_TOK_NUM; + next(); + decl(VT_CONST); + if (tok != TOK_EOF) + expect("declaration"); + + /* end of translation unit info */ + if (do_debug) { + put_stabs_r(NULL, N_SO, 0, 0, + text_section->data_offset, text_section, section_sym); + } + } + s1->error_set_jmp_enabled = 0; + + /* reset define stack, but leave -Dsymbols (may be incorrect if + they are undefined) */ + free_defines(define_start); + + gen_inline_functions(); + + //sym_pop(&global_stack, NULL); + + return s1->nb_errors != 0 ? -1 : 0; +} + +#ifdef LIBTCC +int tcc_compile_string(TCCState *s, const char *str) +{ + BufferedFile bf1, *bf = &bf1; + int ret, len; + char *buf; + + /* init file structure */ + bf->fd = -1; + /* XXX: avoid copying */ + len = strlen(str); + buf = tcc_malloc(len + 1); + if (!buf) + return -1; + memcpy(buf, str, len); + buf[len] = CH_EOB; + bf->buf_ptr = buf; + bf->buf_end = buf + len; + pstrcpy(bf->filename, sizeof(bf->filename), ""); + bf->line_num = 1; + file = bf; + + ret = tcc_compile(s); + + tcc_free(buf); + + /* currently, no need to close */ + return ret; +} +#endif + +/* define a preprocessor symbol. A value can also be provided with the '=' operator */ +void tcc_define_symbol(TCCState *s1, const char *sym, const char *value) +{ + BufferedFile bf1, *bf = &bf1; + + pstrcpy(bf->buffer, IO_BUF_SIZE, sym); + pstrcat(bf->buffer, IO_BUF_SIZE, " "); + /* default value */ + if (!value) + value = "1"; + pstrcat(bf->buffer, IO_BUF_SIZE, value); + + /* init file structure */ + bf->fd = -1; + bf->buf_ptr = bf->buffer; + bf->buf_end = bf->buffer + strlen(bf->buffer); + *bf->buf_end = CH_EOB; + bf->filename[0] = '\0'; + bf->line_num = 1; + file = bf; + + s1->include_stack_ptr = s1->include_stack; + + /* parse with define parser */ + ch = file->buf_ptr[0]; + next_nomacro(); + parse_define(); + file = NULL; +} + +/* undefine a preprocessor symbol */ +void tcc_undefine_symbol(TCCState *s1, const char *sym) +{ + TokenSym *ts; + Sym *s; + ts = tok_alloc(sym, strlen(sym)); + s = define_find(ts->tok); + /* undefine symbol by putting an invalid name */ + if (s) + define_undef(s); +} + +#ifdef CONFIG_TCC_ASM + +#ifdef TCC_TARGET_I386 +#include "i386-asm.c" +#endif +#include "tccasm.c" + +#else +static void asm_instr(void) +{ + error("inline asm() not supported"); +} +static void asm_global_instr(void) +{ + error("inline asm() not supported"); +} +#endif + +#include "tccelf.c" + +TCCState *tcc_new(void) +{ + const char *p, *r; + TCCState *s; + TokenSym *ts; + int i, c; + + s = tcc_mallocz(sizeof(TCCState)); + if (!s) + return NULL; + tcc_state = s; + s->output_type = TCC_OUTPUT_MEMORY; + + /* init isid table */ + for(i=0;i<256;i++) + isidnum_table[i] = isid(i) || isnum(i); + + /* add all tokens */ + table_ident = NULL; + memset(hash_ident, 0, TOK_HASH_SIZE * sizeof(TokenSym *)); + + tok_ident = TOK_IDENT; + p = tcc_keywords; + while (*p) { + r = p; + for(;;) { + c = *r++; + if (c == '\0') + break; + } + ts = tok_alloc(p, r - p - 1); + p = r; + } + + /* we add dummy defines for some special macros to speed up tests + and to have working defined() */ + define_push(TOK___LINE__, MACRO_OBJ, NULL, NULL); + define_push(TOK___FILE__, MACRO_OBJ, NULL, NULL); + define_push(TOK___DATE__, MACRO_OBJ, NULL, NULL); + define_push(TOK___TIME__, MACRO_OBJ, NULL, NULL); + + /* standard defines */ + tcc_define_symbol(s, "__STDC__", NULL); +#if defined(TCC_TARGET_I386) + tcc_define_symbol(s, "__i386__", NULL); +#endif +#if defined(TCC_TARGET_ARM) + tcc_define_symbol(s, "__ARM_ARCH_4__", NULL); + tcc_define_symbol(s, "__arm_elf__", NULL); + tcc_define_symbol(s, "__arm_elf", NULL); + tcc_define_symbol(s, "arm_elf", NULL); + tcc_define_symbol(s, "__arm__", NULL); + tcc_define_symbol(s, "__arm", NULL); + tcc_define_symbol(s, "arm", NULL); + tcc_define_symbol(s, "__APCS_32__", NULL); +#endif +#if defined(TCC_TARGET_816) + tcc_define_symbol(s, "__65816__", NULL); +#endif +#if defined(linux) + tcc_define_symbol(s, "__linux__", NULL); + tcc_define_symbol(s, "linux", NULL); +#endif + /* tiny C specific defines */ + tcc_define_symbol(s, "__TINYC__", NULL); + + /* tiny C & gcc defines */ + tcc_define_symbol(s, "__SIZE_TYPE__", "unsigned int"); + tcc_define_symbol(s, "__PTRDIFF_TYPE__", "int"); + tcc_define_symbol(s, "__WCHAR_TYPE__", "int"); + tcc_define_symbol(s, "__CHAR_BIT__", "8"); +#ifdef TCC_TARGET_816 + tcc_define_symbol(s, "__INT_MAX__", "32767"); + tcc_define_symbol(s, "__LONG_MAX__", "32767"); + tcc_define_symbol(s, "__LONG_LONG_MAX__", "2147483647LL"); + tcc_define_symbol(s, "__FLT_MIN__", "0x0.1p-127"); + tcc_define_symbol(s, "__FLT_MAX__", "0x1.fffffep127"); + tcc_define_symbol(s, "__DBL_MIN__", "0x0.1p-127"); + tcc_define_symbol(s, "__DBL_MAX__", "0x1.fffffep127"); + tcc_define_symbol(s, "__LDBL_MIN__", "0x0.1p-127"); + tcc_define_symbol(s, "__LDBL_MAX__", "0x1.fffffep127"); + tcc_define_symbol(s, "__WCHAR_MAX__", "65535"); +#endif + + /* default library paths */ +#ifdef TCC_TARGET_PE + { + char buf[1024]; + snprintf(buf, sizeof(buf), "%s/lib", tcc_lib_path); + tcc_add_library_path(s, buf); + } +#else + tcc_add_library_path(s, "/usr/local/lib"); + tcc_add_library_path(s, "/usr/lib"); + tcc_add_library_path(s, "/lib"); +#endif + + /* no section zero */ + dynarray_add((void ***)&s->sections, &s->nb_sections, NULL); + + /* create standard sections */ + text_section = new_section(s, ".text", SHT_PROGBITS, SHF_ALLOC | SHF_EXECINSTR); + data_section = new_section(s, ".data", SHT_PROGBITS, SHF_ALLOC | SHF_WRITE); + rodata_section = new_section(s, ".rodata", SHT_PROGBITS, SHF_ALLOC); + bss_section = new_section(s, ".bss", SHT_NOBITS, SHF_ALLOC | SHF_WRITE); + + /* symbols are always generated for linking stage */ + symtab_section = new_symtab(s, ".symtab", SHT_SYMTAB, 0, + ".strtab", + ".hashtab", SHF_PRIVATE); + strtab_section = symtab_section->link; + + /* private symbol table for dynamic symbols */ + s->dynsymtab_section = new_symtab(s, ".dynsymtab", SHT_SYMTAB, SHF_PRIVATE, + ".dynstrtab", + ".dynhashtab", SHF_PRIVATE); + s->alacarte_link = 1; + +#ifdef CHAR_IS_UNSIGNED + s->char_is_unsigned = 1; +#endif +#if defined(TCC_TARGET_PE) && 0 + /* XXX: currently the PE linker is not ready to support that */ + s->leading_underscore = 1; +#endif + return s; +} + +void tcc_delete(TCCState *s1) +{ + int i, n; + + /* free -D defines */ + free_defines(NULL); + + /* free tokens */ + n = tok_ident - TOK_IDENT; + for(i = 0; i < n; i++) + tcc_free(table_ident[i]); + tcc_free(table_ident); + + /* free all sections */ + + free_section(symtab_section->hash); + + free_section(s1->dynsymtab_section->hash); + free_section(s1->dynsymtab_section->link); + free_section(s1->dynsymtab_section); + + for(i = 1; i < s1->nb_sections; i++) + free_section(s1->sections[i]); + tcc_free(s1->sections); + + /* free loaded dlls array */ + for(i = 0; i < s1->nb_loaded_dlls; i++) + tcc_free(s1->loaded_dlls[i]); + tcc_free(s1->loaded_dlls); + + /* library paths */ + for(i = 0; i < s1->nb_library_paths; i++) + tcc_free(s1->library_paths[i]); + tcc_free(s1->library_paths); + + /* cached includes */ + for(i = 0; i < s1->nb_cached_includes; i++) + tcc_free(s1->cached_includes[i]); + tcc_free(s1->cached_includes); + + for(i = 0; i < s1->nb_include_paths; i++) + tcc_free(s1->include_paths[i]); + tcc_free(s1->include_paths); + + for(i = 0; i < s1->nb_sysinclude_paths; i++) + tcc_free(s1->sysinclude_paths[i]); + tcc_free(s1->sysinclude_paths); + + tcc_free(s1); +} + +int tcc_add_include_path(TCCState *s1, const char *pathname) +{ + char *pathname1; + + pathname1 = tcc_strdup(pathname); + dynarray_add((void ***)&s1->include_paths, &s1->nb_include_paths, pathname1); + return 0; +} + +int tcc_add_sysinclude_path(TCCState *s1, const char *pathname) +{ + char *pathname1; + + pathname1 = tcc_strdup(pathname); + dynarray_add((void ***)&s1->sysinclude_paths, &s1->nb_sysinclude_paths, pathname1); + return 0; +} + +static int tcc_add_file_internal(TCCState *s1, const char *filename, int flags) +{ + const char *ext, *filename1; + int ret; + BufferedFile *saved_file; + + /* find source file type with extension */ + filename1 = strrchr(filename, '/'); + if (filename1) + filename1++; + else + filename1 = filename; + ext = strrchr(filename1, '.'); + if (ext) + ext++; + + /* open the file */ + saved_file = file; + file = tcc_open(s1, filename); + if (!file) { + if (flags & AFF_PRINT_ERROR) { + error_noabort("file '%s' not found", filename); + } + ret = -1; + goto fail1; + } + + if (!ext || !strcmp(ext, "c")) { + /* C file assumed */ + ret = tcc_compile(s1); + } else { + error_noabort("unrecognized file type"); + goto fail; + } + the_end: + tcc_close(file); + fail1: + file = saved_file; + return ret; + fail: + ret = -1; + goto the_end; +} + +int tcc_add_file(TCCState *s, const char *filename) +{ + return tcc_add_file_internal(s, filename, AFF_PRINT_ERROR); +} + +int tcc_add_library_path(TCCState *s, const char *pathname) +{ + char *pathname1; + + pathname1 = tcc_strdup(pathname); + dynarray_add((void ***)&s->library_paths, &s->nb_library_paths, pathname1); + return 0; +} + +/* find and load a dll. Return non zero if not found */ +/* XXX: add '-rpath' option support ? */ +static int tcc_add_dll(TCCState *s, const char *filename, int flags) +{ + char buf[1024]; + int i; + + for(i = 0; i < s->nb_library_paths; i++) { + snprintf(buf, sizeof(buf), "%s/%s", + s->library_paths[i], filename); + if (tcc_add_file_internal(s, buf, flags) == 0) + return 0; + } + return -1; +} + +/* the library name is the same as the argument of the '-l' option */ +int tcc_add_library(TCCState *s, const char *libraryname) +{ + char buf[1024]; + int i; + + /* first we look for the dynamic library if not static linking */ + if (!s->static_link) { +#ifdef TCC_TARGET_PE + snprintf(buf, sizeof(buf), "%s.def", libraryname); +#else + snprintf(buf, sizeof(buf), "lib%s.so", libraryname); +#endif + if (tcc_add_dll(s, buf, 0) == 0) + return 0; + } + + /* then we look for the static library */ + for(i = 0; i < s->nb_library_paths; i++) { + snprintf(buf, sizeof(buf), "%s/lib%s.a", + s->library_paths[i], libraryname); + if (tcc_add_file_internal(s, buf, 0) == 0) + return 0; + } + return -1; +} + +int tcc_add_symbol(TCCState *s, const char *name, unsigned long val) +{ + add_elf_sym(symtab_section, val, 0, + ELF32_ST_INFO(STB_GLOBAL, STT_NOTYPE), 0, + SHN_ABS, name); + return 0; +} + +int tcc_set_output_type(TCCState *s, int output_type) +{ + s->output_type = output_type; + + if (!s->nostdinc) { + char buf[1024]; + + /* default include paths */ + /* XXX: reverse order needed if -isystem support */ +#if !defined(TCC_TARGET_PE) && !defined(TCC_TARGET_816) + tcc_add_sysinclude_path(s, "/usr/local/include"); + tcc_add_sysinclude_path(s, "/usr/include"); +#endif + snprintf(buf, sizeof(buf), "%s/include", tcc_lib_path); + tcc_add_sysinclude_path(s, buf); +#ifdef TCC_TARGET_PE + snprintf(buf, sizeof(buf), "%s/include/winapi", tcc_lib_path); + tcc_add_sysinclude_path(s, buf); +#endif + } + + /* if bound checking, then add corresponding sections */ +#ifdef CONFIG_TCC_BCHECK + if (do_bounds_check) { + /* define symbol */ + tcc_define_symbol(s, "__BOUNDS_CHECKING_ON", NULL); + /* create bounds sections */ + bounds_section = new_section(s, ".bounds", + SHT_PROGBITS, SHF_ALLOC); + lbounds_section = new_section(s, ".lbounds", + SHT_PROGBITS, SHF_ALLOC); + } +#endif + + if (s->char_is_unsigned) { + tcc_define_symbol(s, "__CHAR_UNSIGNED__", NULL); + } + + /* add debug sections */ + if (do_debug) { + /* stab symbols */ + stab_section = new_section(s, ".stab", SHT_PROGBITS, 0); + stab_section->sh_entsize = sizeof(Stab_Sym); + stabstr_section = new_section(s, ".stabstr", SHT_STRTAB, 0); + put_elf_str(stabstr_section, ""); + stab_section->link = stabstr_section; + /* put first entry */ + put_stabs("", 0, 0, 0, 0); + } + + /* add libc crt1/crti objects */ +#ifndef TCC_TARGET_PE + if ((output_type == TCC_OUTPUT_EXE || output_type == TCC_OUTPUT_DLL) && + !s->nostdlib) { + if (output_type != TCC_OUTPUT_DLL) + tcc_add_file(s, CONFIG_TCC_CRT_PREFIX "/crt1.o"); + tcc_add_file(s, CONFIG_TCC_CRT_PREFIX "/crti.o"); + } +#endif + return 0; +} + +#define WD_ALL 0x0001 /* warning is activated when using -Wall */ +#define FD_INVERT 0x0002 /* invert value before storing */ + +typedef struct FlagDef { + uint16_t offset; + uint16_t flags; + const char *name; +} FlagDef; + +static const FlagDef warning_defs[] = { + { offsetof(TCCState, warn_unsupported), 0, "unsupported" }, + { offsetof(TCCState, warn_write_strings), 0, "write-strings" }, + { offsetof(TCCState, warn_error), 0, "error" }, + { offsetof(TCCState, warn_implicit_function_declaration), WD_ALL, + "implicit-function-declaration" }, +}; + +static int set_flag(TCCState *s, const FlagDef *flags, int nb_flags, + const char *name, int value) +{ + int i; + const FlagDef *p; + const char *r; + + r = name; + if (r[0] == 'n' && r[1] == 'o' && r[2] == '-') { + r += 3; + value = !value; + } + for(i = 0, p = flags; i < nb_flags; i++, p++) { + if (!strcmp(r, p->name)) + goto found; + } + return -1; + found: + if (p->flags & FD_INVERT) + value = !value; + *(int *)((uint8_t *)s + p->offset) = value; + return 0; +} + + +/* set/reset a warning */ +int tcc_set_warning(TCCState *s, const char *warning_name, int value) +{ + int i; + const FlagDef *p; + + if (!strcmp(warning_name, "all")) { + for(i = 0, p = warning_defs; i < countof(warning_defs); i++, p++) { + if (p->flags & WD_ALL) + *(int *)((uint8_t *)s + p->offset) = 1; + } + return 0; + } else { + return set_flag(s, warning_defs, countof(warning_defs), + warning_name, value); + } +} + +static const FlagDef flag_defs[] = { + { offsetof(TCCState, char_is_unsigned), 0, "unsigned-char" }, + { offsetof(TCCState, char_is_unsigned), FD_INVERT, "signed-char" }, + { offsetof(TCCState, nocommon), FD_INVERT, "common" }, + { offsetof(TCCState, leading_underscore), 0, "leading-underscore" }, +}; + +/* set/reset a flag */ +int tcc_set_flag(TCCState *s, const char *flag_name, int value) +{ + return set_flag(s, flag_defs, countof(flag_defs), + flag_name, value); +} + +#if !defined(LIBTCC) + +/* extract the basename of a file */ +static const char *tcc_basename(const char *name) +{ + const char *p; + p = strrchr(name, '/'); +#ifdef WIN32 + if (!p) + p = strrchr(name, '\\'); +#endif + if (!p) + p = name; + else + p++; + return p; +} + +static int64_t getclock_us(void) +{ +#ifdef WIN32 + struct _timeb tb; + _ftime(&tb); + return (tb.time * 1000LL + tb.millitm) * 1000LL; +#else + struct timeval tv; + gettimeofday(&tv, NULL); + return tv.tv_sec * 1000000LL + tv.tv_usec; +#endif +} + +void help(void) +{ + printf("tcc version " TCC_VERSION " - Tiny C Compiler - Copyright (C) 2001-2005 Fabrice Bellard\n" + "usage: tcc [-v] [-c] [-o outfile] [-Bdir] [-bench] [-Idir] [-Dsym[=val]] [-Usym]\n" + " [-Wwarn] [-g] [-b] [-bt N] [-Ldir] [-llib] [-shared] [-static]\n" + " [infile1 infile2...] [-run infile args...]\n" + "\n" + "General options:\n" + " -v display current version\n" + " -c compile only - generate an object file\n" + " -o outfile set output filename\n" + " -Bdir set tcc internal library path\n" + " -bench output compilation statistics\n" + " -run run compiled source\n" + " -fflag set or reset (with 'no-' prefix) 'flag' (see man page)\n" + " -Wwarning set or reset (with 'no-' prefix) 'warning' (see man page)\n" + " -w disable all warnings\n" + "Preprocessor options:\n" + " -Idir add include path 'dir'\n" + " -Dsym[=val] define 'sym' with value 'val'\n" + " -Usym undefine 'sym'\n" + "Linker options:\n" + " -Ldir add library path 'dir'\n" + " -llib link with dynamic or static library 'lib'\n" + " -shared generate a shared library\n" + " -static static linking\n" + " -rdynamic export all global symbols to dynamic linker\n" + " -r relocatable output\n" + "Debugger options:\n" + " -g generate runtime debug info\n" +#ifdef CONFIG_TCC_BCHECK + " -b compile with built-in memory and bounds checker (implies -g)\n" +#endif + " -bt N show N callers in stack traces\n" + ); +} + +#define TCC_OPTION_HAS_ARG 0x0001 +#define TCC_OPTION_NOSEP 0x0002 /* cannot have space before option and arg */ + +typedef struct TCCOption { + const char *name; + uint16_t index; + uint16_t flags; +} TCCOption; + +enum { + TCC_OPTION_HELP, + TCC_OPTION_I, + TCC_OPTION_D, + TCC_OPTION_U, + TCC_OPTION_L, + TCC_OPTION_B, + TCC_OPTION_l, + TCC_OPTION_bench, + TCC_OPTION_bt, + TCC_OPTION_b, + TCC_OPTION_g, + TCC_OPTION_c, + TCC_OPTION_static, + TCC_OPTION_shared, + TCC_OPTION_o, + TCC_OPTION_r, + TCC_OPTION_Wl, + TCC_OPTION_W, + TCC_OPTION_O, + TCC_OPTION_m, + TCC_OPTION_f, + TCC_OPTION_nostdinc, + TCC_OPTION_nostdlib, + TCC_OPTION_print_search_dirs, + TCC_OPTION_rdynamic, + TCC_OPTION_run, + TCC_OPTION_v, + TCC_OPTION_w, + TCC_OPTION_pipe, +}; + +static const TCCOption tcc_options[] = { + { "h", TCC_OPTION_HELP, 0 }, + { "?", TCC_OPTION_HELP, 0 }, + { "I", TCC_OPTION_I, TCC_OPTION_HAS_ARG }, + { "D", TCC_OPTION_D, TCC_OPTION_HAS_ARG }, + { "U", TCC_OPTION_U, TCC_OPTION_HAS_ARG }, + { "L", TCC_OPTION_L, TCC_OPTION_HAS_ARG }, + { "B", TCC_OPTION_B, TCC_OPTION_HAS_ARG }, + { "l", TCC_OPTION_l, TCC_OPTION_HAS_ARG | TCC_OPTION_NOSEP }, + { "bench", TCC_OPTION_bench, 0 }, + { "bt", TCC_OPTION_bt, TCC_OPTION_HAS_ARG }, +#ifdef CONFIG_TCC_BCHECK + { "b", TCC_OPTION_b, 0 }, +#endif + { "g", TCC_OPTION_g, TCC_OPTION_HAS_ARG | TCC_OPTION_NOSEP }, + { "c", TCC_OPTION_c, 0 }, + { "static", TCC_OPTION_static, 0 }, + { "shared", TCC_OPTION_shared, 0 }, + { "o", TCC_OPTION_o, TCC_OPTION_HAS_ARG }, + { "run", TCC_OPTION_run, TCC_OPTION_HAS_ARG | TCC_OPTION_NOSEP }, + { "rdynamic", TCC_OPTION_rdynamic, 0 }, + { "r", TCC_OPTION_r, 0 }, + { "Wl,", TCC_OPTION_Wl, TCC_OPTION_HAS_ARG | TCC_OPTION_NOSEP }, + { "W", TCC_OPTION_W, TCC_OPTION_HAS_ARG | TCC_OPTION_NOSEP }, + { "O", TCC_OPTION_O, TCC_OPTION_HAS_ARG | TCC_OPTION_NOSEP }, + { "m", TCC_OPTION_m, TCC_OPTION_HAS_ARG }, + { "f", TCC_OPTION_f, TCC_OPTION_HAS_ARG | TCC_OPTION_NOSEP }, + { "nostdinc", TCC_OPTION_nostdinc, 0 }, + { "nostdlib", TCC_OPTION_nostdlib, 0 }, + { "print-search-dirs", TCC_OPTION_print_search_dirs, 0 }, + { "v", TCC_OPTION_v, 0 }, + { "w", TCC_OPTION_w, 0 }, + { "pipe", TCC_OPTION_pipe, 0}, + { NULL }, +}; + +/* convert 'str' into an array of space separated strings */ +static int expand_args(char ***pargv, const char *str) +{ + const char *s1; + char **argv, *arg; + int argc, len; + + argc = 0; + argv = NULL; + for(;;) { + while (is_space(*str)) + str++; + if (*str == '\0') + break; + s1 = str; + while (*str != '\0' && !is_space(*str)) + str++; + len = str - s1; + arg = tcc_malloc(len + 1); + memcpy(arg, s1, len); + arg[len] = '\0'; + dynarray_add((void ***)&argv, &argc, arg); + } + *pargv = argv; + return argc; +} + +static char **files; +static int nb_files, nb_libraries; +static int multiple_files; +static int print_search_dirs; +static int output_type; +static int reloc_output; +static const char *outfile; + +int parse_args(TCCState *s, int argc, char **argv) +{ + int optind; + const TCCOption *popt; + const char *optarg, *p1, *r1; + char *r; + + s->output_format = TCC_OUTPUT_FORMAT_BINARY; + + optind = 0; + while (1) { + if (optind >= argc) { + if (nb_files == 0 && !print_search_dirs) + goto show_help; + else + break; + } + r = argv[optind++]; + if (r[0] != '-') { + /* add a new file */ + dynarray_add((void ***)&files, &nb_files, r); + if (!multiple_files) { + optind--; + /* argv[0] will be this file */ + break; + } + } else { + /* find option in table (match only the first chars */ + popt = tcc_options; + for(;;) { + p1 = popt->name; + if (p1 == NULL) + error("invalid option -- '%s'", r); + r1 = r + 1; + for(;;) { + if (*p1 == '\0') + goto option_found; + if (*r1 != *p1) + break; + p1++; + r1++; + } + popt++; + } + option_found: + if (popt->flags & TCC_OPTION_HAS_ARG) { + if (*r1 != '\0' || (popt->flags & TCC_OPTION_NOSEP)) { + optarg = r1; + } else { + if (optind >= argc) + error("argument to '%s' is missing", r); + optarg = argv[optind++]; + } + } else { + if (*r1 != '\0') + goto show_help; + optarg = NULL; + } + + switch(popt->index) { + case TCC_OPTION_HELP: + show_help: + help(); + exit(1); + case TCC_OPTION_I: + if (tcc_add_include_path(s, optarg) < 0) + error("too many include paths"); + break; + case TCC_OPTION_D: + { + char *sym, *value; + sym = (char *)optarg; + value = strchr(sym, '='); + if (value) { + *value = '\0'; + value++; + } + tcc_define_symbol(s, sym, value); + } + break; + case TCC_OPTION_U: + tcc_undefine_symbol(s, optarg); + break; + case TCC_OPTION_L: + tcc_add_library_path(s, optarg); + break; + case TCC_OPTION_B: + /* set tcc utilities path (mainly for tcc development) */ + tcc_lib_path = optarg; + break; + case TCC_OPTION_l: + dynarray_add((void ***)&files, &nb_files, r); + nb_libraries++; + break; + case TCC_OPTION_bench: + do_bench = 1; + break; + case TCC_OPTION_bt: + num_callers = atoi(optarg); + break; +#ifdef CONFIG_TCC_BCHECK + case TCC_OPTION_b: + do_bounds_check = 1; + do_debug = 1; + break; +#endif + case TCC_OPTION_g: + do_debug = 1; + break; + case TCC_OPTION_c: + multiple_files = 1; + output_type = TCC_OUTPUT_OBJ; + break; + case TCC_OPTION_static: + s->static_link = 1; + break; + case TCC_OPTION_shared: + output_type = TCC_OUTPUT_DLL; + break; + case TCC_OPTION_o: + multiple_files = 1; + outfile = optarg; + break; + case TCC_OPTION_r: + /* generate a .o merging several output files */ + reloc_output = 1; + output_type = TCC_OUTPUT_OBJ; + break; + case TCC_OPTION_nostdinc: + s->nostdinc = 1; + break; + case TCC_OPTION_nostdlib: + s->nostdlib = 1; + break; + case TCC_OPTION_print_search_dirs: + print_search_dirs = 1; + break; + case TCC_OPTION_run: + { + int argc1; + char **argv1; + argc1 = expand_args(&argv1, optarg); + if (argc1 > 0) { + parse_args(s, argc1, argv1); + } + multiple_files = 0; + output_type = TCC_OUTPUT_MEMORY; + } + break; + case TCC_OPTION_v: + printf("tcc version %s\n", TCC_VERSION); + exit(0); + case TCC_OPTION_f: + if (tcc_set_flag(s, optarg, 1) < 0 && s->warn_unsupported) + goto unsupported_option; + break; + case TCC_OPTION_W: + if (tcc_set_warning(s, optarg, 1) < 0 && + s->warn_unsupported) + goto unsupported_option; + break; + case TCC_OPTION_w: + s->warn_none = 1; + break; + case TCC_OPTION_rdynamic: + s->rdynamic = 1; + break; + case TCC_OPTION_Wl: + { + const char *p; + if (strstart(optarg, "-Ttext,", &p)) { + s->text_addr = strtoul(p, NULL, 16); + s->has_text_addr = 1; + } else if (strstart(optarg, "--oformat,", &p)) { + if (strstart(p, "elf32-", NULL)) { + s->output_format = TCC_OUTPUT_FORMAT_ELF; + } else if (!strcmp(p, "binary")) { + s->output_format = TCC_OUTPUT_FORMAT_BINARY; + } else +#ifdef TCC_TARGET_COFF + if (!strcmp(p, "coff")) { + s->output_format = TCC_OUTPUT_FORMAT_COFF; + } else +#endif + { + error("target %s not found", p); + } + } else { + error("unsupported linker option '%s'", optarg); + } + } + break; + case TCC_OPTION_O: + s->optimize = 1; + break; + default: + if (s->warn_unsupported) { + unsupported_option: + warning("unsupported option '%s'", r); + } + break; + } + } + } + return optind; +} + +int main(int argc, char **argv) +{ + int i; + TCCState *s; + int nb_objfiles, ret, optind; + char objfilename[1024]; + int64_t start_time = 0; + +#ifdef WIN32 + /* on win32, we suppose the lib and includes are at the location + of 'tcc.exe' */ + { + static char path[1024]; + char *p, *d; + + GetModuleFileNameA(NULL, path, sizeof path); + p = d = strlwr(path); + while (*d) + { + if (*d == '\\') *d = '/', p = d; + ++d; + } + *p = '\0'; + tcc_lib_path = path; + } +#endif + + s = tcc_new(); + output_type = TCC_OUTPUT_EXE; + outfile = NULL; + multiple_files = 1; + files = NULL; + nb_files = 0; + nb_libraries = 0; + reloc_output = 0; + print_search_dirs = 0; + + optind = parse_args(s, argc - 1, argv + 1) + 1; + + if (print_search_dirs) { + /* enough for Linux kernel */ + printf("install: %s/\n", tcc_lib_path); + return 0; + } + + nb_objfiles = nb_files - nb_libraries; + + /* if outfile provided without other options, we output an + executable */ + if (outfile && output_type == TCC_OUTPUT_MEMORY) + output_type = TCC_OUTPUT_EXE; + + /* check -c consistency : only single file handled. XXX: checks file type */ + if (output_type == TCC_OUTPUT_OBJ && !reloc_output) { + /* accepts only a single input file */ + if (nb_objfiles != 1) + error("cannot specify multiple files with -c"); + if (nb_libraries != 0) + error("cannot specify libraries with -c"); + } + + if (output_type != TCC_OUTPUT_MEMORY) { + if (!outfile) { + /* compute default outfile name */ + pstrcpy(objfilename, sizeof(objfilename) - 1, + /* strip path */ + tcc_basename(files[0])); +#ifdef TCC_TARGET_PE + pe_guess_outfile(objfilename, output_type); +#else + if (output_type == TCC_OUTPUT_OBJ && !reloc_output) { + char *ext = strrchr(objfilename, '.'); + if (!ext) + goto default_outfile; + /* add .o extension */ + strcpy(ext + 1, "o"); + } else { + default_outfile: + pstrcpy(objfilename, sizeof(objfilename), "a.out"); + } +#endif + outfile = objfilename; + } + } + + if (do_bench) { + start_time = getclock_us(); + } + + tcc_set_output_type(s, output_type); + + /* compile or add each files or library */ + for(i = 0;i < nb_files; i++) { + const char *filename; + + filename = files[i]; + if (filename[0] == '-') { + if (tcc_add_library(s, filename + 2) < 0) + error("cannot find %s", filename); + } else { + if (tcc_add_file(s, filename) < 0) { + ret = 1; + goto the_end; + } + } + } + + /* free all files */ + tcc_free(files); + + if (do_bench) { + double total_time; + total_time = (double)(getclock_us() - start_time) / 1000000.0; + if (total_time < 0.001) + total_time = 0.001; + if (total_bytes < 1) + total_bytes = 1; + printf("%d idents, %d lines, %d bytes, %0.3f s, %d lines/s, %0.1f MB/s\n", + tok_ident - TOK_IDENT, total_lines, total_bytes, + total_time, (int)(total_lines / total_time), + total_bytes / total_time / 1000000.0); + } + + { + if (s->optimize) { + char *outfile_pre = tcc_malloc(strlen(outfile) + 4 + 1); + sprintf(outfile_pre, "%s.pre", outfile); + tcc_output_file(s, outfile_pre); + char *cmd = tcc_malloc(strlen(outfile_pre) + strlen(outfile) + 100); + sprintf(cmd, CONFIG_TCCDIR "/bin/816-opt %s >%s", outfile_pre, outfile); + if (system(cmd)) { + error("optimizer failed"); + } + unlink(outfile_pre); + tcc_free(outfile_pre); + tcc_free(cmd); + } + else { + tcc_output_file(s, outfile); + } + ret = 0; + } + the_end: + /* XXX: cannot do it with bound checking because of the malloc hooks */ + if (!do_bounds_check) + tcc_delete(s); + +#ifdef MEM_DEBUG + if (do_bench) { + printf("memory: %d bytes, max = %d bytes\n", mem_cur_size, mem_max_size); + } +#endif + return ret; +} + +#endif diff --git a/tccelf.c b/tccelf.c new file mode 100644 index 0000000..498691f --- /dev/null +++ b/tccelf.c @@ -0,0 +1,828 @@ +/* + * ELF file handling for TCC + * + * Copyright (c) 2001-2004 Fabrice Bellard + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +static int put_elf_str(Section *s, const char *sym) +{ + int offset, len; + char *ptr; + + //fprintf(stderr,"put_elf_str %s\n",sym); + len = strlen(sym) + 1; + offset = s->data_offset; + ptr = section_ptr_add(s, len); + memcpy(ptr, sym, len); + return offset; +} + +/* elf symbol hashing function */ +static unsigned long elf_hash(const unsigned char *name) +{ + unsigned long h = 0, g; + + while (*name) { + h = (h << 4) + *name++; + g = h & 0xf0000000; + if (g) + h ^= g >> 24; + h &= ~g; + } + return h; +} + +/* rebuild hash table of section s */ +/* NOTE: we do factorize the hash table code to go faster */ +static void rebuild_hash(Section *s, unsigned int nb_buckets) +{ + Elf32_Sym *sym; + int *ptr, *hash, nb_syms, sym_index, h; + char *strtab; + + strtab = s->link->data; + nb_syms = s->data_offset / sizeof(Elf32_Sym); + + s->hash->data_offset = 0; + ptr = section_ptr_add(s->hash, (2 + nb_buckets + nb_syms) * sizeof(int)); + ptr[0] = nb_buckets; + ptr[1] = nb_syms; + ptr += 2; + hash = ptr; + memset(hash, 0, (nb_buckets + 1) * sizeof(int)); + ptr += nb_buckets + 1; + + sym = (Elf32_Sym *)s->data + 1; + for(sym_index = 1; sym_index < nb_syms; sym_index++) { + if (ELF32_ST_BIND(sym->st_info) != STB_LOCAL) { + h = elf_hash(strtab + sym->st_name) % nb_buckets; + *ptr = hash[h]; + hash[h] = sym_index; + } else { + *ptr = 0; + } + ptr++; + sym++; + } +} + +/* return the symbol number */ +static int put_elf_sym(Section *s, + unsigned long value, unsigned long size, + int info, int other, int shndx, const char *name) +{ + int name_offset, sym_index; + int nbuckets, h; + Elf32_Sym *sym; + Section *hs; + //fprintf(stderr,"\\\\\\ putting elf symbol %s in section type %d, section %p, value %ld size %ld info %d other %d\n",name,s->sh_type,s,value,size,info,other); + // HACK + //info |= 0x10; + sym = section_ptr_add(s, sizeof(Elf32_Sym)); + if (name) + name_offset = put_elf_str(s->link, name); + else + name_offset = 0; + /* XXX: endianness */ + sym->st_name = name_offset; + sym->st_value = value; + sym->st_size = size; + sym->st_info = info; + sym->st_other = other; + sym->st_shndx = shndx; + sym_index = sym - (Elf32_Sym *)s->data; + hs = s->hash; + if (hs) { + int *ptr, *base; + ptr = section_ptr_add(hs, sizeof(int)); + base = (int *)hs->data; + /* only add global or weak symbols */ + if (ELF32_ST_BIND(info) != STB_LOCAL) { + /* add another hashing entry */ + nbuckets = base[0]; + h = elf_hash(name) % nbuckets; + *ptr = base[2 + h]; + base[2 + h] = sym_index; + base[1]++; + /* we resize the hash table */ + hs->nb_hashed_syms++; + if (hs->nb_hashed_syms > 2 * nbuckets) { + rebuild_hash(s, 2 * nbuckets); + } + } else { + *ptr = 0; + base[1]++; + } + } + return sym_index; +} + +/* find global ELF symbol 'name' and return its index. Return 0 if not + found. */ +static int find_elf_sym(Section *s, const char *name) +{ + Elf32_Sym *sym; + Section *hs; + int nbuckets, sym_index, h; + const char *name1; + + hs = s->hash; + if (!hs) + return 0; + nbuckets = ((int *)hs->data)[0]; + h = elf_hash(name) % nbuckets; + sym_index = ((int *)hs->data)[2 + h]; + while (sym_index != 0) { + sym = &((Elf32_Sym *)s->data)[sym_index]; + name1 = s->link->data + sym->st_name; + if (!strcmp(name, name1)) + return sym_index; + sym_index = ((int *)hs->data)[2 + nbuckets + sym_index]; + } + return 0; +} + +/* return elf symbol value or error */ +int tcc_get_symbol(TCCState *s, unsigned long *pval, const char *name) +{ + int sym_index; + Elf32_Sym *sym; + + sym_index = find_elf_sym(symtab_section, name); + if (!sym_index) + return -1; + sym = &((Elf32_Sym *)symtab_section->data)[sym_index]; + *pval = sym->st_value; + return 0; +} + +/* return elf symbol value or error */ +Elf32_Sym* tcc_really_get_symbol(TCCState *s, unsigned long *pval, const char *name) +{ + int sym_index; + Elf32_Sym *sym; + + sym_index = find_elf_sym(symtab_section, name); + if (!sym_index) + return NULL; + sym = &((Elf32_Sym *)symtab_section->data)[sym_index]; + *pval = sym->st_value; + return sym; +} + +void *tcc_get_symbol_err(TCCState *s, const char *name) +{ + unsigned long val; + if (tcc_get_symbol(s, &val, name) < 0) + error("%s not defined", name); + return (void *)val; +} + +/* add an elf symbol : check if it is already defined and patch + it. Return symbol index. NOTE that sh_num can be SHN_UNDEF. */ +static int add_elf_sym(Section *s, unsigned long value, unsigned long size, + int info, int other, int sh_num, const char *name) +{ + Elf32_Sym *esym; + int sym_bind, sym_index, sym_type, esym_bind; + + sym_bind = ELF32_ST_BIND(info); + sym_type = ELF32_ST_TYPE(info); + + if (sym_bind != STB_LOCAL) { + /* we search global or weak symbols */ + sym_index = find_elf_sym(s, name); + if (!sym_index) + goto do_def; + esym = &((Elf32_Sym *)s->data)[sym_index]; + if (esym->st_shndx != SHN_UNDEF) { + esym_bind = ELF32_ST_BIND(esym->st_info); + if (sh_num == SHN_UNDEF) { + /* ignore adding of undefined symbol if the + corresponding symbol is already defined */ + } else if (sym_bind == STB_GLOBAL && esym_bind == STB_WEAK) { + /* global overrides weak, so patch */ + goto do_patch; + } else if (sym_bind == STB_WEAK && esym_bind == STB_GLOBAL) { + /* weak is ignored if already global */ + } else { +#if 0 + printf("new_bind=%d new_shndx=%d last_bind=%d old_shndx=%d\n", + sym_bind, sh_num, esym_bind, esym->st_shndx); +#endif + /* NOTE: we accept that two DLL define the same symbol */ + if (s != tcc_state->dynsymtab_section) + error_noabort("'%s' defined twice", name); + } + } else { + do_patch: + esym->st_info = ELF32_ST_INFO(sym_bind, sym_type); + esym->st_shndx = sh_num; + esym->st_value = value; + esym->st_size = size; + esym->st_other = other; + } + } else { + do_def: + sym_index = put_elf_sym(s, value, size, + ELF32_ST_INFO(sym_bind, sym_type), other, + sh_num, name); + } + return sym_index; +} + +/* put relocation */ +static void put_elf_reloc(Section *symtab, Section *s, unsigned long offset, + int type, int symbol) +{ + char buf[256]; + Section *sr; + Elf32_Rel *rel; + + sr = s->reloc; + if (!sr) { + /* if no relocation section, create it */ + snprintf(buf, sizeof(buf), ".rel%s", s->name); + /* if the symtab is allocated, then we consider the relocation + are also */ + sr = new_section(tcc_state, buf, SHT_REL, symtab->sh_flags); + sr->sh_entsize = sizeof(Elf32_Rel); + sr->link = symtab; + sr->sh_info = s->sh_num; + s->reloc = sr; + } + rel = section_ptr_add(sr, sizeof(Elf32_Rel)); + rel->r_offset = offset; + rel->r_info = ELF32_R_INFO(symbol, type); +} + +/* put stab debug information */ + +typedef struct { + unsigned long n_strx; /* index into string table of name */ + unsigned char n_type; /* type of symbol */ + unsigned char n_other; /* misc info (usually empty) */ + unsigned short n_desc; /* description field */ + unsigned long n_value; /* value of symbol */ +} Stab_Sym; + +static void put_stabs(const char *str, int type, int other, int desc, + unsigned long value) +{ + Stab_Sym *sym; + + sym = section_ptr_add(stab_section, sizeof(Stab_Sym)); + if (str) { + sym->n_strx = put_elf_str(stabstr_section, str); + } else { + sym->n_strx = 0; + } + sym->n_type = type; + sym->n_other = other; + sym->n_desc = desc; + sym->n_value = value; +} + +static void put_stabs_r(const char *str, int type, int other, int desc, + unsigned long value, Section *sec, int sym_index) +{ + put_stabs(str, type, other, desc, value); + put_elf_reloc(symtab_section, stab_section, + stab_section->data_offset - sizeof(unsigned long), + R_DATA_32, sym_index); +} + +static void put_stabn(int type, int other, int desc, int value) +{ + put_stabs(NULL, type, other, desc, value); +} + +static void put_stabd(int type, int other, int desc) +{ + put_stabs(NULL, type, other, desc, 0); +} + +char** relocptrs = NULL; + +/* relocate a given section (CPU dependent) */ +static void relocate_section(TCCState *s1, Section *s) +{ + Section *sr; + Elf32_Rel *rel, *rel_end, *qrel; + Elf32_Sym *sym; + int type, sym_index; + unsigned char *ptr; + unsigned long val, addr; +#if defined(TCC_TARGET_I386) + int esym_index; +#endif + + if (!relocptrs) { + relocptrs = calloc(0x100000, sizeof(char *)); + } + + sr = s->reloc; + rel_end = (Elf32_Rel *)(sr->data + sr->data_offset); + qrel = (Elf32_Rel *)sr->data; + for(rel = qrel; + rel < rel_end; + rel++) { + ptr = s->data + rel->r_offset; + + sym_index = ELF32_R_SYM(rel->r_info); + sym = &((Elf32_Sym *)symtab_section->data)[sym_index]; + val = sym->st_value; + type = ELF32_R_TYPE(rel->r_info); + addr = s->sh_addr + rel->r_offset; + + /* CPU specific */ + switch(type) { +#if defined(TCC_TARGET_816) + case R_DATA_32: + //fprintf(stderr,"___ relocating at 0x%lx to 0x%lx, sr %p, s %p, shndx %d name %s info 0x%x other 0x%x relocindex 0x%x ptr 0x%x\n",addr,val,sr,s,sym->st_shndx,symtab_section->link->data + sym->st_name, sym->st_info, sym->st_other,relocindices[addr],*(unsigned int*)ptr); + if(relocptrs[((unsigned long)ptr)&0xfffff]) error("relocptrs collision"); + /* if(ELF32_ST_BIND(sym->st_info) == STB_LOCAL) { + relocptrs[((unsigned int)ptr)&0xfffff] = calloc(1,strlen(static_prefix) + strlen(symtab_section->link->data + sym->st_name) + 1); + sprintf(relocptrs[((unsigned int)ptr)&0xfffff], "%s%s", static_prefix, symtab_section->link->data + sym->st_name); + } + else */ relocptrs[((unsigned long)ptr)&0xfffff] = symtab_section->link->data + sym->st_name; + /* no need to change the value at ptr, we only need the offset, and that's already there */ + break; + default: + fprintf(stderr,"FIXME: handle reloc type 0x%x at 0x%lx [%.8lx] to 0x%lx\n", + type, addr, (unsigned long)ptr, val); + break; +#else +#error unsupported processor +#endif + } + } + /* if the relocation is allocated, we change its symbol table */ + if (sr->sh_flags & SHF_ALLOC) + sr->link = s1->dynsym; +} + +static Section *new_symtab(TCCState *s1, + const char *symtab_name, int sh_type, int sh_flags, + const char *strtab_name, + const char *hash_name, int hash_sh_flags) +{ + Section *symtab, *strtab, *hash; + int *ptr, nb_buckets; + + symtab = new_section(s1, symtab_name, sh_type, sh_flags); + symtab->sh_entsize = sizeof(Elf32_Sym); + strtab = new_section(s1, strtab_name, SHT_STRTAB, sh_flags); + put_elf_str(strtab, ""); + symtab->link = strtab; + put_elf_sym(symtab, 0, 0, 0, 0, 0, NULL); + + nb_buckets = 1; + + hash = new_section(s1, hash_name, SHT_HASH, hash_sh_flags); + hash->sh_entsize = sizeof(int); + symtab->hash = hash; + hash->link = symtab; + + ptr = section_ptr_add(hash, (2 + nb_buckets + 1) * sizeof(int)); + ptr[0] = nb_buckets; + ptr[1] = 1; + memset(ptr + 2, 0, (nb_buckets + 1) * sizeof(int)); + return symtab; +} + +static void tcc_output_binary(TCCState *s1, FILE *f, + const int *section_order) +{ + Section *s; + int i,j, k, size; + + //fprintf(stderr,"outputting binary, %d sections\n",s1->nb_sections); + +#if 0 + Elf32_Sym* esym; + for(j = 0, esym = (Elf32_Sym*) symtab_section->data; j < symtab_section->sh_size / 4; esym++, j++) { + fprintf(stderr,"symbol st_shndx %d\n", esym->st_shndx); + if(esym->st_shndx == 2) fprintf(stderr,"symbol %s value %d\n", symtab_section->link->data + esym->st_name,esym->st_value); + } +#endif + + /* include header */ + /* fprintf(f, ".incdir \"" CONFIG_TCCDIR "/include\"\n"); */ + fprintf(f, ".include \"hdr.asm\"\n"); + fprintf(f, ".accu 16\n.index 16\n"); + fprintf(f, ".16bit\n"); + + /* local variable size constants; used to be generated as part of the + function epilog, but WLA DX barfed once in a while about missing + symbols. putting them at the start of the file works around that. */ + for(i=0; inb_sections;i++) { + s = s1->sections[section_order[i]]; + //fprintf(stderr,"___ relocating section %p (%s) (reloc %p)\n",s,s->name,s->reloc); + if (s->reloc && s != s1->got) + relocate_section(s1, s); + } + + /* output sections */ + for(i=1;inb_sections;i++) { + s = s1->sections[section_order[i]]; + //fprintf(stderr,"section %p, sh_size %ld, sh_num %d\n",s,s->sh_size,s->sh_num); + + /* these sections are meaningless when writing plain-text assembler output */ + if(strcmp(".symtab", s->name) == 0 || + strcmp(".strtab", s->name) == 0 || + strcmp(".rel.data", s->name) == 0 || + strcmp(".shstrtab", s->name) == 0) continue; + + //fprintf(f,"\n;.section %p\n",s->reloc); + + size = s->sh_size; /* section size in bytes */ + //fprintf(stderr,"%d bytes: %s\n",size,s->name); + + if(s == text_section) { + /* functions each have their own section (otherwise WLA DX is + not able to allocate ROM space for them efficiently), so we + do not have to print a function header here */ + int next_jump_pos = 0; /* the next offset in the text section where we will look for a jump target */ + for(j = 0; j < size; j++) { + //Elf32_Sym* esym; + for(k = 0; k < labels; k++) { + //fprintf(stderr,"label %s at %d\n", label[k].name, label[k].pos); + if(label[k].pos == j) fprintf(f, "%s%s:\n", static_prefix /* "__local_" */, label[k].name); + } + /* insert jump labels */ + if(next_jump_pos == j) { + next_jump_pos = size; + for(k = 0; k < jumps; k++) { + /* while we're here, look for the next jump target after this one */ + if(jump[k][1] > j && jump[k][1] < next_jump_pos) next_jump_pos = jump[k][1]; + /* write the jump target label(s) for this position */ + //if(jump[k][1] == j) fprintf(f, LOCAL_LABEL ": ; at %d\n", k, j); + if(jump[k][1] == j) fprintf(f, LOCAL_LABEL ":\n", k); + } + } + fputc(s->data[j], f); + } + if(!section_closed) fprintf(f, ".ends\n"); + } + else if(s == bss_section) { + /* uninitialized data, we only need a .ramsection */ + Elf32_Sym* esym; + int empty = 1; + fprintf(f, ".ramsection \".bss\" bank $7e slot 2\n"); + //fprintf(f, "ramsection.bss dsb 0\n"); + for(j = 0, esym = (Elf32_Sym*) symtab_section->data; j < symtab_section->sh_size / sizeof(Elf32_Sym); esym++, j++) { + //fprintf(stderr,"%d/%d symbol %p st_shndx %d\n", j, symtab_section->sh_size / sizeof(Elf32_Sym*), esym, esym->st_shndx); + //fprintf(stderr,"esym %p\n", esym); + //if(esym->st_shndx < 3) fprintf(stderr,"symbol %s\n", symtab_section->link->data + esym->st_name); + if(esym->st_shndx == SHN_COMMON + && strlen(symtab_section->link->data + esym->st_name)) /* omit nameless symbols (fixes 20041218-1.c) */ + { + /* looks like these are the symbols that need to go here, + but that is merely an educated guess. works for me, though. */ + //fprintf(stderr,"COM symbol %s: value %d size %d\n",get_tok_str(ps->v, NULL),esym->st_value,esym->st_size); + fprintf(f, "%s%s dsb %d\n", /*ELF32_ST_BIND(esym->st_info) == STB_LOCAL ? static_prefix:*/"", symtab_section->link->data + esym->st_name, esym->st_size); + empty = 0; + } + } +#if 0 + for(;ps;ps=ps->prev) { + if((esym = tcc_really_get_symbol(s1, &pval, get_tok_str(ps->v, NULL)))) { + if(esym->st_shndx == SHN_COMMON) { + /* looks like these are the symbols that need to go here, + but that is merely an educated guess. works for me, though. */ + //fprintf(stderr,"COM symbol %s: value %d size %d\n",get_tok_str(ps->v, NULL),esym->st_value,esym->st_size); + fprintf(f, "%s dsb %d\n", get_tok_str(ps->v, NULL), esym->st_size); + empty = 0; + } + } + } +#endif + if(empty) fprintf(f, "__local_dummybss dsb 1\n"); + //fprintf(f, "endsection.bss dsb 0\n"); + fprintf(f, ".ends\n"); + } + else { /* .data, .rodata, user-defined sections */ + + int deebeed = 0; /* remembers whether we have printed ".db" + before; reset after a newline or a + different sized prefix, e.g. ".dw" */ + int startk = 0; /* 0 == .ramsection, 1 == .section */ + int endk = 2; /* do both by default */ + + if(s != data_section) startk = 1; /* only do .section (.rodata and user sections go to ROM) */ + + int bytecount = 0; /* how many bytes to reserve in .ramsection */ + + /* k == 0: output .ramsection; k == 1: output .section */ + for(k = startk; k < endk; k++) { + + if(k == 0) { /* .ramsection */ + fprintf(f, ".ramsection \"ram%s\" bank $7f slot 3\n",s->name); + //fprintf(f, "ramsection%s dsb 0\n", s->name); + } + else { /* (ROM) .section */ + fprintf(f, ".section \"%s\" superfree\n", s->name); + //fprintf(f, "startsection%s:", s->name); + } + + //int next_symbol_pos = 0; /* position inside the section at which to look for the next symbol */ + + for(j=0; jdata; ps < symtab_section->sh_size / sizeof(Elf32_Sym); esym++, ps++) { + //if(!find_elf_sym(symtab_section, get_tok_str(ps->v, NULL))) continue; + unsigned long pval; + char* symname = symtab_section->link->data + esym->st_name; + char* symprefix = ""; + + //fprintf(stderr,"gsym %p name %s type 0x%x num %d reg 0x%x\n",ps,get_tok_str(ps->v,NULL),ps->type.t,ps->c,ps->r); + + /* we do not have to care about external references (handled by the linker) or + functions (handled by the code generator */ + //if((ps->type.t & VT_EXTERN) || ((ps->type.t & VT_BTYPE) == VT_FUNC)) continue; + + /* look up this symbol */ + pval = esym->st_value; + + //fprintf(stderr,"/// pval %d, j %d esym->st_shndx %d s->sh_num %d\n",pval,j,esym->st_shndx,s->sh_num); + + /* look for the next symbol after this one */ + //if(pval > j && pval < next_symbol_pos) next_symbol_pos = pval; + + /* Is this symbol at this position and in this section? */ + if(pval != j || esym->st_shndx != s->sh_num) continue; + + /* skip empty symbols (bug?) */ + if(strlen(symname) == 0) continue; + /* some symbols appear more than once; avoid defining them more than once (bug?) */ + if(lastsym && !strcmp(lastsym, symname)) continue; + /* remember this symbol for the next iteration */ + lastsym = symname; + + /* if this is a local (static) symbol, prefix it so the assembler knows this + is file-local. */ + /* FIXME: breaks for local static variables (name collision) */ + //if(ELF32_ST_BIND(esym->st_info) == STB_LOCAL) { symprefix = static_prefix; } + + /* if this is a ramsection, we now know how large the _previous_ symbol was; print it. */ + /* if we already printed a symbol in this section, define this symbol as size 0 so it + gets the same address as the other ones at this position. */ + if(k==0 && (bytecount > 0 || symbol_printed)) { + fprintf(f, "dsb %d", bytecount); + bytecount = 0; + } + + /* if there are two sections, print label only in .ramsection */ + if(k == 0) fprintf(f, "\n%s%s ", symprefix, symname); + else if(startk == 1) fprintf(f,"\n%s%s: ", symprefix, symname); + else fprintf(f, "\n"); + symbol_printed = 1; + + } + + if(symbol_printed) { + /* pointers and arrays may have a symbolic name. find out if that's the case. + everything else is literal and handled later */ + //if((ps->type.t & (VT_PTR|VT_ARRAY)) /* == VT_PTR */) { + unsigned int ptr = *((unsigned int*)&s->data[j]); + unsigned char ptrc = *((unsigned char*)&s->data[j]); + //fprintf(stderr, "%%%%%%%%pointer type 0x%x v 0x%x r 0x%x c 0x%x, value 0x%x\n",ps->type.t,ps->v,ps->r,ps->c,ptr); + + if(k == 0) { /* .ramsection, just count bytes */ + bytecount ++; + } + else { /* (ROM) .section, need to output data */ + if(relocptrs && relocptrs[((unsigned long)&s->data[j])&0xfffff]) { + /* relocated -> print a symbolic pointer */ + //fprintf(f,".dw ramsection%s + $%x", s->name, ptr); + char* ptrname = relocptrs[((unsigned long)&s->data[j])&0xfffff]; + fprintf(f,".dw %s + %d, :%s", ptrname, ptr, ptrname); + j+=3; /* we have handled 3 more bytes than expected */ + deebeed = 0; + } + else { + /* any non-symbolic data; print one byte, then let the generic code take over */ + //fprintf(f,"; type 0x%x\n", ps->type.t); + //if(ps->type.t & VT_BYTE) exit(42); + fprintf(f,".db $%x", ptrc); + deebeed = 1; + } + } + continue; /* data has been printed, go ahead */ + } + + /* no symbol here, just print the data */ + if(k == 1 && relocptrs && relocptrs[((unsigned long)&s->data[j])&0xfffff]) { + /* unlabeled data may have been relocated, too */ + fprintf(f,"\n.dw %s + %d\n.dw :%s", relocptrs[((unsigned long)&s->data[j])&0xfffff], *(unsigned int*)(&s->data[j]), relocptrs[((unsigned long)&s->data[j])&0xfffff]); + j+=3; + deebeed = 0; + continue; + } + + if(!deebeed) { + if(k == 1) fprintf(f, "\n.db "); + deebeed = 1; + } + else if(k==1) fprintf(f,","); + if(k==1) fprintf(f, "$%x",s->data[j]); + bytecount++; + } + if(k==0) { if(!bytecount) { fprintf(f, "__local_dummy%s ", s->name); bytecount++; } fprintf(f, "dsb %d\n", bytecount); bytecount = 0; } + //if(k==1 && deebeed) fprintf(f,"\n"); + if(k==1) { + //fprintf(f,"\nendsection%s:", s->name); + if(!size) fprintf(f, "\n__local_dummy%s: .db 0", s->name); + } + fprintf(f,"\n.ends\n\n"); + } + } + +#if 0 + fprintf(stderr,"sh_type %d\n",s->sh_type); + fprintf(stderr,"index of L.0 %d\n",find_elf_sym(s, "L.0")); + + if(s->sh_type == SHT_REL) { + for(j = 0; j < s->sh_size; j++) { + fprintf(stderr,"%02x ", s->data[j]); + if(j%4 == 3) fprintf(stderr,"\n"); + } + fprintf(stderr,"\n"); + //fprintf(stderr,"symtab %s\n",s->data); + } +#endif + + } + //fprintf(stderr,"index of L.0 in symtab_section %d\n",find_elf_sym(symtab_section,"L.0")); +} + +/* output an ELF file */ +/* XXX: suppress unneeded sections */ +int tcc_output_file(TCCState *s1, const char *filename) +{ + Elf32_Ehdr ehdr; + FILE *f; + int fd, mode, ret; + int *section_order; + int shnum, i, phnum, file_offset, sh_order_index; + Section *strsec, *s; + Elf32_Phdr *phdr; + Section *interp, *dynamic, *dynstr; + unsigned long saved_dynamic_data_offset; + int file_type; + + file_type = s1->output_type; + s1->nb_errors = 0; + + if (file_type != TCC_OUTPUT_OBJ) { + abort(); + } + + phdr = NULL; + section_order = NULL; + interp = NULL; + dynamic = NULL; + dynstr = NULL; /* avoid warning */ + saved_dynamic_data_offset = 0; /* avoid warning */ + + if (file_type != TCC_OUTPUT_OBJ) { + abort(); + } + + memset(&ehdr, 0, sizeof(ehdr)); + + /* we add a section for symbols */ + strsec = new_section(s1, ".shstrtab", SHT_STRTAB, 0); + put_elf_str(strsec, ""); + + /* compute number of sections */ + shnum = s1->nb_sections; + + /* this array is used to reorder sections in the output file */ + section_order = tcc_malloc(sizeof(int) * shnum); + section_order[0] = 0; + sh_order_index = 1; + + /* compute number of program headers */ + switch(file_type) { + default: + case TCC_OUTPUT_OBJ: + phnum = 0; + break; + case TCC_OUTPUT_EXE: + if (!s1->static_link) + phnum = 4; + else + phnum = 2; + break; + case TCC_OUTPUT_DLL: + phnum = 3; + break; + } + + /* allocate strings for section names and decide if an unallocated + section should be output */ + /* NOTE: the strsec section comes last, so its size is also + correct ! */ + for(i = 1; i < s1->nb_sections; i++) { + s = s1->sections[i]; + s->sh_name = put_elf_str(strsec, s->name); + /* when generating a DLL, we include relocations but we may + patch them */ + if (file_type == TCC_OUTPUT_DLL && + s->sh_type == SHT_REL && + !(s->sh_flags & SHF_ALLOC)) { + abort(); + } else if (do_debug || + file_type == TCC_OUTPUT_OBJ || + (s->sh_flags & SHF_ALLOC) || + i == (s1->nb_sections - 1)) { + /* we output all sections if debug or object file */ + s->sh_size = s->data_offset; + } + } + + /* allocate program segment headers */ + phdr = tcc_mallocz(phnum * sizeof(Elf32_Phdr)); + + if (s1->output_format == TCC_OUTPUT_FORMAT_ELF) { + file_offset = sizeof(Elf32_Ehdr) + phnum * sizeof(Elf32_Phdr); + } else { + file_offset = 0; + } + if (phnum > 0) { + abort(); + } + + /* all other sections come after */ + for(i = 1; i < s1->nb_sections; i++) { + s = s1->sections[i]; + if (phnum > 0 && (s->sh_flags & SHF_ALLOC)) + continue; + section_order[sh_order_index++] = i; + + file_offset = (file_offset + s->sh_addralign - 1) & + ~(s->sh_addralign - 1); + s->sh_offset = file_offset; + if (s->sh_type != SHT_NOBITS) + file_offset += s->sh_size; + } + + /* write elf file */ + if (file_type == TCC_OUTPUT_OBJ) + mode = 0666; + else + mode = 0777; + fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, mode); + if (fd < 0) { + error_noabort("could not write '%s'", filename); + ret = -1; + goto the_end; + } + f = fdopen(fd, "wb"); + + if (s1->output_format == TCC_OUTPUT_FORMAT_ELF) { + abort(); + } else { + tcc_output_binary(s1, f, section_order); + } + fclose(f); + + ret = 0; + the_end: + tcc_free(s1->symtab_to_dynsym); + tcc_free(section_order); + tcc_free(phdr); + tcc_free(s1->got_offsets); + return ret; +} + diff --git a/tcclib.h b/tcclib.h new file mode 100644 index 0000000..a7cc8a3 --- /dev/null +++ b/tcclib.h @@ -0,0 +1,77 @@ +/* Simple libc header for TCC + * + * Add any function you want from the libc there. This file is here + * only for your convenience so that you do not need to put the whole + * glibc include files on your floppy disk + */ +#ifndef _TCCLIB_H +#define _TCCLIB_H + +#include +#include + +/* stdlib.h */ +void *calloc(size_t nmemb, size_t size); +void *malloc(size_t size); +void free(void *ptr); +void *realloc(void *ptr, size_t size); +int atoi(const char *nptr); +long int strtol(const char *nptr, char **endptr, int base); +unsigned long int strtoul(const char *nptr, char **endptr, int base); + +/* stdio.h */ +typedef struct __FILE FILE; +#define EOF (-1) +extern FILE *stdin; +extern FILE *stdout; +extern FILE *stderr; +FILE *fopen(const char *path, const char *mode); +FILE *fdopen(int fildes, const char *mode); +FILE *freopen(const char *path, const char *mode, FILE *stream); +int fclose(FILE *stream); +size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream); +size_t fwrite(void *ptr, size_t size, size_t nmemb, FILE *stream); +int fgetc(FILE *stream); +char *fgets(char *s, int size, FILE *stream); +int getc(FILE *stream); +int getchar(void); +char *gets(char *s); +int ungetc(int c, FILE *stream); +int fflush(FILE *stream); + +int printf(const char *format, ...); +int fprintf(FILE *stream, const char *format, ...); +int sprintf(char *str, const char *format, ...); +int snprintf(char *str, size_t size, const char *format, ...); +int asprintf(char **strp, const char *format, ...); +int dprintf(int fd, const char *format, ...); +int vprintf(const char *format, va_list ap); +int vfprintf(FILE *stream, const char *format, va_list ap); +int vsprintf(char *str, const char *format, va_list ap); +int vsnprintf(char *str, size_t size, const char *format, va_list ap); +int vasprintf(char **strp, const char *format, va_list ap); +int vdprintf(int fd, const char *format, va_list ap); + +void perror(const char *s); + +/* string.h */ +char *strcat(char *dest, const char *src); +char *strchr(const char *s, int c); +char *strrchr(const char *s, int c); +char *strcpy(char *dest, const char *src); +void *memcpy(void *dest, const void *src, size_t n); +void *memmove(void *dest, const void *src, size_t n); +void *memset(void *s, int c, size_t n); +char *strdup(const char *s); + +/* dlfcn.h */ +#define RTLD_LAZY 0x001 +#define RTLD_NOW 0x002 +#define RTLD_GLOBAL 0x100 + +void *dlopen(const char *filename, int flag); +const char *dlerror(void); +void *dlsym(void *handle, char *symbol); +int dlclose(void *handle); + +#endif /* _TCCLIB_H */ diff --git a/tcctest.c b/tcctest.c new file mode 100644 index 0000000..70f2d9b --- /dev/null +++ b/tcctest.c @@ -0,0 +1,1988 @@ +/* + * TCC auto test program + */ +#include "config.h" + +#if GCC_MAJOR >= 3 + +/* Unfortunately, gcc version < 3 does not handle that! */ +#define ALL_ISOC99 + +/* only gcc 3 handles _Bool correctly */ +#define BOOL_ISOC99 + +/* gcc 2.95.3 does not handle correctly CR in strings or after strays */ +#define CORRECT_CR_HANDLING + +#endif + +/* deprecated and no longer supported in gcc 3.3 */ +//#define ACCEPT_CR_IN_STRINGS + +/* __VA_ARGS__ and __func__ support */ +#define C99_MACROS + +/* test various include syntaxes */ + +#define TCCLIB_INC +#define TCCLIB_INC1 +#define TCCLIB_INC3 "tcclib" + +#include TCCLIB_INC + +#include TCCLIB_INC1.TCCLIB_INC2 + +#include TCCLIB_INC1.h> + +/* gcc 3.2 does not accept that (bug ?) */ +//#include TCCLIB_INC3 ".h" + +#include + +#include "tcclib.h" + +void string_test(); +void expr_test(); +void macro_test(); +void scope_test(); +void forward_test(); +void funcptr_test(); +void loop_test(); +void switch_test(); +void goto_test(); +void enum_test(); +void typedef_test(); +void struct_test(); +void array_test(); +void expr_ptr_test(); +void bool_test(); +void expr2_test(); +void constant_expr_test(); +void expr_cmp_test(); +void char_short_test(); +void init_test(void); +void compound_literal_test(void); +int kr_test(); +void struct_assign_test(void); +void cast_test(void); +void bitfield_test(void); +void c99_bool_test(void); +void float_test(void); +void longlong_test(void); +void stdarg_test(void); +void whitespace_test(void); +void relocation_test(void); +void old_style_function(void); +void sizeof_test(void); +void typeof_test(void); +void local_label_test(void); +void statement_expr_test(void); +void asm_test(void); +void builtin_test(void); + +int fib(int n); +void num(int n); +void forward_ref(void); +int isid(int c); + +#define A 2 +#define N 1234 + A +#define pf printf +#define M1(a, b) (a) + (b) + +#define str\ +(s) # s +#define glue(a, b) a ## b +#define xglue(a, b) glue(a, b) +#define HIGHLOW "hello" +#define LOW LOW ", world" + +#define min(a, b) ((a) < (b) ? (a) : (b)) + +#ifdef C99_MACROS +#define dprintf(level,...) printf(__VA_ARGS__) +#endif + +/* gcc vararg macros */ +#define dprintf1(level, fmt, args...) printf(fmt, ## args) + +#define MACRO_NOARGS() + +#define AAA 3 +#undef AAA +#define AAA 4 + +#if 1 +#define B3 1 +#elif 1 +#define B3 2 +#elif 0 +#define B3 3 +#else +#define B3 4 +#endif + +#define __INT64_C(c) c ## LL +#define INT64_MIN (-__INT64_C(9223372036854775807)-1) + +int qq(int x) +{ + return x + 40; +} +#define qq(x) x + +#define spin_lock(lock) do { } while (0) +#define wq_spin_lock spin_lock +#define TEST2() wq_spin_lock(a) + +void macro_test(void) +{ + printf("macro:\n"); + pf("N=%d\n", N); + printf("aaa=%d\n", AAA); + + printf("min=%d\n", min(1, min(2, -1))); + + printf("s1=%s\n", glue(HIGH, LOW)); + printf("s2=%s\n", xglue(HIGH, LOW)); + printf("s3=%s\n", str("c")); + printf("s4=%s\n", str(a1)); + printf("B3=%d\n", B3); + +#ifdef A + printf("A defined\n"); +#endif +#ifdef B + printf("B defined\n"); +#endif +#ifdef A + printf("A defined\n"); +#else + printf("A not defined\n"); +#endif +#ifdef B + printf("B defined\n"); +#else + printf("B not defined\n"); +#endif + +#ifdef A + printf("A defined\n"); +#ifdef B + printf("B1 defined\n"); +#else + printf("B1 not defined\n"); +#endif +#else + printf("A not defined\n"); +#ifdef B + printf("B2 defined\n"); +#else + printf("B2 not defined\n"); +#endif +#endif + +#if 1+1 + printf("test true1\n"); +#endif +#if 0 + printf("test true2\n"); +#endif +#if 1-1 + printf("test true3\n"); +#endif +#if defined(A) + printf("test trueA\n"); +#endif +#if defined(B) + printf("test trueB\n"); +#endif + +#if 0 + printf("test 0\n"); +#elif 0 + printf("test 1\n"); +#elif 2 + printf("test 2\n"); +#else + printf("test 3\n"); +#endif + + MACRO_NOARGS(); + +#ifdef __LINE__ + printf("__LINE__ defined\n"); +#endif + + printf("__LINE__=%d __FILE__=%s\n", + __LINE__, __FILE__); +#line 200 + printf("__LINE__=%d __FILE__=%s\n", + __LINE__, __FILE__); +#line 203 "test" + printf("__LINE__=%d __FILE__=%s\n", + __LINE__, __FILE__); +#line 220 "tcctest.c" + + /* not strictly preprocessor, but we test it there */ +#ifdef C99_MACROS + printf("__func__ = %s\n", __func__); + dprintf(1, "vaarg=%d\n", 1); +#endif + dprintf1(1, "vaarg1\n"); + dprintf1(1, "vaarg1=%d\n", 2); + dprintf1(1, "vaarg1=%d %d\n", 1, 2); + + /* gcc extension */ + printf("func='%s'\n", __FUNCTION__); + + /* complicated macros in glibc */ + printf("INT64_MIN=%Ld\n", INT64_MIN); + { + int a; + a = 1; + glue(a+, +); + printf("a=%d\n", a); + glue(a <, <= 2); + printf("a=%d\n", a); + } + + /* macro function with argument outside the macro string */ +#define MF_s MF_hello +#define MF_hello(msg) printf("%s\n",msg) + +#define MF_t printf("tralala\n"); MF_hello + + MF_s("hi"); + MF_t("hi"); + + /* test macro substituion inside args (should not eat stream) */ + printf("qq=%d\n", qq(qq)(2)); + + /* test zero argument case. NOTE: gcc 2.95.x does not accept a + null argument without a space. gcc 3.2 fixes that. */ + +#define qq1(x) 1 + printf("qq1=%d\n", qq1( )); + + /* comment with stray handling *\ +/ + /* this is a valid *\/ comment */ + /* this is a valid comment *\*/ + // this is a valid\ +comment + + /* test function macro substitution when the function name is + substituted */ + TEST2(); +} + +int op(a,b) +{ + return a / b; +} + +int ret(a) +{ + if (a == 2) + return 1; + if (a == 3) + return 2; + return 0; +} + +void ps(const char *s) +{ + int c; + while (1) { + c = *s; + if (c == 0) + break; + printf("%c", c); + s++; + } +} + +const char foo1_string[] = "\ +bar\n\ +test\14\ +1"; + +void string_test() +{ + int b; + printf("string:\n"); + printf("\141\1423\143\n");/* dezdez test */ + printf("\x41\x42\x43\x3a\n"); + printf("c=%c\n", 'r'); + printf("wc=%C 0x%lx %C\n", L'a', L'\x1234', L'c'); + printf("foo1_string='%s'\n", foo1_string); +#if 0 + printf("wstring=%S\n", L"abc"); + printf("wstring=%S\n", L"abc" L"def" "ghi"); + printf("'\\377'=%d '\\xff'=%d\n", '\377', '\xff'); + printf("L'\\377'=%d L'\\xff'=%d\n", L'\377', L'\xff'); +#endif + ps("test\n"); + b = 32; + while ((b = b + 1) < 96) { + printf("%c", b); + } + printf("\n"); + printf("fib=%d\n", fib(33)); + b = 262144; + while (b != 0x80000000) { + num(b); + b = b * 2; + } +} + +void loop_test() +{ + int i; + i = 0; + while (i < 10) + printf("%d", i++); + printf("\n"); + for(i = 0; i < 10;i++) + printf("%d", i); + printf("\n"); + i = 0; + do { + printf("%d", i++); + } while (i < 10); + printf("\n"); + + /* break/continue tests */ + i = 0; + while (1) { + if (i == 6) + break; + i++; + if (i == 3) + continue; + printf("%d", i); + } + printf("\n"); + + /* break/continue tests */ + i = 0; + do { + if (i == 6) + break; + i++; + if (i == 3) + continue; + printf("%d", i); + } while(1); + printf("\n"); + + for(i = 0;i < 10;i++) { + if (i == 3) + continue; + printf("%d", i); + } + printf("\n"); +} + + +void goto_test() +{ + int i; + static void *label_table[3] = { &&label1, &&label2, &&label3 }; + + printf("goto:\n"); + i = 0; + s_loop: + if (i >= 10) + goto s_end; + printf("%d", i); + i++; + goto s_loop; + s_end: + printf("\n"); + + /* we also test computed gotos (GCC extension) */ + for(i=0;i<3;i++) { + goto *label_table[i]; + label1: + printf("label1\n"); + goto next; + label2: + printf("label2\n"); + goto next; + label3: + printf("label3\n"); + next: ; + } +} + +enum { + E0, + E1 = 2, + E2 = 4, + E3, + E4, +}; + +enum test { + E5 = 1000, +}; + +void enum_test() +{ + enum test b1; + printf("enum:\n%d %d %d %d %d %d\n", + E0, E1, E2, E3, E4, E5); + b1 = 1; + printf("b1=%d\n", b1); +} + +typedef int *my_ptr; + +void typedef_test() +{ + my_ptr a; + int b; + a = &b; + *a = 1234; + printf("typedef:\n"); + printf("a=%d\n", *a); +} + +void forward_test() +{ + printf("forward:\n"); + forward_ref(); + forward_ref(); +} + + +void forward_ref(void) +{ + printf("forward ok\n"); +} + +typedef struct struct1 { + int f1; + int f2, f3; + union union1 { + int v1; + int v2; + } u; + char str[3]; +} struct1; + +struct struct2 { + int a; + char b; +}; + +union union2 { + int w1; + int w2; +}; + +struct struct1 st1, st2; + +int main(int argc, char **argv) +{ + string_test(); + expr_test(); + macro_test(); + scope_test(); + forward_test(); + funcptr_test(); + loop_test(); + switch_test(); + goto_test(); + enum_test(); + typedef_test(); + struct_test(); + array_test(); + expr_ptr_test(); + bool_test(); + expr2_test(); + constant_expr_test(); + expr_cmp_test(); + char_short_test(); + init_test(); + compound_literal_test(); + kr_test(); + struct_assign_test(); + cast_test(); + bitfield_test(); + c99_bool_test(); + float_test(); + longlong_test(); + stdarg_test(); + whitespace_test(); + relocation_test(); + old_style_function(); + sizeof_test(); + typeof_test(); + statement_expr_test(); + local_label_test(); + asm_test(); + builtin_test(); + return 0; +} + +int tab[3]; +int tab2[3][2]; + +int g; + +void f1(g) +{ + printf("g1=%d\n", g); +} + +void scope_test() +{ + printf("scope:\n"); + g = 2; + f1(1); + printf("g2=%d\n", g); + { + int g; + g = 3; + printf("g3=%d\n", g); + { + int g; + g = 4; + printf("g4=%d\n", g); + } + } + printf("g5=%d\n", g); +} + +void array_test(int a[4]) +{ + int i, j; + + printf("array:\n"); + printf("sizeof(a) = %d\n", sizeof(a)); + printf("sizeof(\"a\") = %d\n", sizeof("a")); +#ifdef C99_MACROS + printf("sizeof(__func__) = %d\n", sizeof(__func__)); +#endif + printf("sizeof tab %d\n", sizeof(tab)); + printf("sizeof tab2 %d\n", sizeof tab2); + tab[0] = 1; + tab[1] = 2; + tab[2] = 3; + printf("%d %d %d\n", tab[0], tab[1], tab[2]); + for(i=0;i<3;i++) + for(j=0;j<2;j++) + tab2[i][j] = 10 * i + j; + for(i=0;i<3*2;i++) { + printf(" %3d", ((int *)tab2)[i]); + } + printf("\n"); +} + +void expr_test() +{ + int a, b; + a = 0; + printf("%d\n", a += 1); + printf("%d\n", a -= 2); + printf("%d\n", a *= 31232132); + printf("%d\n", a /= 4); + printf("%d\n", a %= 20); + printf("%d\n", a &= 6); + printf("%d\n", a ^= 7); + printf("%d\n", a |= 8); + printf("%d\n", a >>= 3); + printf("%d\n", a <<= 4); + + a = 22321; + b = -22321; + printf("%d\n", a + 1); + printf("%d\n", a - 2); + printf("%d\n", a * 312); + printf("%d\n", a / 4); + printf("%d\n", b / 4); + printf("%d\n", (unsigned)b / 4); + printf("%d\n", a % 20); + printf("%d\n", b % 20); + printf("%d\n", (unsigned)b % 20); + printf("%d\n", a & 6); + printf("%d\n", a ^ 7); + printf("%d\n", a | 8); + printf("%d\n", a >> 3); + printf("%d\n", b >> 3); + printf("%d\n", (unsigned)b >> 3); + printf("%d\n", a << 4); + printf("%d\n", ~a); + printf("%d\n", -a); + printf("%d\n", +a); + + printf("%d\n", 12 + 1); + printf("%d\n", 12 - 2); + printf("%d\n", 12 * 312); + printf("%d\n", 12 / 4); + printf("%d\n", 12 % 20); + printf("%d\n", 12 & 6); + printf("%d\n", 12 ^ 7); + printf("%d\n", 12 | 8); + printf("%d\n", 12 >> 2); + printf("%d\n", 12 << 4); + printf("%d\n", ~12); + printf("%d\n", -12); + printf("%d\n", +12); + printf("%d %d %d %d\n", + isid('a'), + isid('g'), + isid('T'), + isid('(')); +} + +int isid(int c) +{ + return (c >= 'a' & c <= 'z') | (c >= 'A' & c <= 'Z') | c == '_'; +} + +/**********************/ + +int vstack[10], *vstack_ptr; + +void vpush(int vt, int vc) +{ + *vstack_ptr++ = vt; + *vstack_ptr++ = vc; +} + +void vpop(int *ft, int *fc) +{ + *fc = *--vstack_ptr; + *ft = *--vstack_ptr; +} + +void expr2_test() +{ + int a, b; + + printf("expr2:\n"); + vstack_ptr = vstack; + vpush(1432432, 2); + vstack_ptr[-2] &= ~0xffffff80; + vpop(&a, &b); + printf("res= %d %d\n", a, b); +} + +void constant_expr_test() +{ + int a; + printf("constant_expr:\n"); + a = 3; + printf("%d\n", a * 16); + printf("%d\n", a * 1); + printf("%d\n", a + 0); +} + +int tab4[10]; + +void expr_ptr_test() +{ + int *p, *q; + + printf("expr_ptr:\n"); + p = tab4; + q = tab4 + 10; + printf("diff=%d\n", q - p); + p++; + printf("inc=%d\n", p - tab4); + p--; + printf("dec=%d\n", p - tab4); + ++p; + printf("inc=%d\n", p - tab4); + --p; + printf("dec=%d\n", p - tab4); + printf("add=%d\n", p + 3 - tab4); + printf("add=%d\n", 3 + p - tab4); +} + +void expr_cmp_test() +{ + int a, b; + printf("constant_expr:\n"); + a = -1; + b = 1; + printf("%d\n", a == a); + printf("%d\n", a != a); + + printf("%d\n", a < b); + printf("%d\n", a <= b); + printf("%d\n", a <= a); + printf("%d\n", b >= a); + printf("%d\n", a >= a); + printf("%d\n", b > a); + + printf("%d\n", (unsigned)a < b); + printf("%d\n", (unsigned)a <= b); + printf("%d\n", (unsigned)a <= a); + printf("%d\n", (unsigned)b >= a); + printf("%d\n", (unsigned)a >= a); + printf("%d\n", (unsigned)b > a); +} + +struct empty { +}; + +struct aligntest1 { + char a[10]; +}; + +struct aligntest2 { + int a; + char b[10]; +}; + +struct aligntest3 { + double a, b; +}; + +struct aligntest4 { + double a[0]; +}; + +void struct_test() +{ + struct1 *s; + union union2 u; + + printf("struct:\n"); + printf("sizes: %d %d %d %d\n", + sizeof(struct struct1), + sizeof(struct struct2), + sizeof(union union1), + sizeof(union union2)); + st1.f1 = 1; + st1.f2 = 2; + st1.f3 = 3; + printf("st1: %d %d %d\n", + st1.f1, st1.f2, st1.f3); + st1.u.v1 = 1; + st1.u.v2 = 2; + printf("union1: %d\n", st1.u.v1); + u.w1 = 1; + u.w2 = 2; + printf("union2: %d\n", u.w1); + s = &st2; + s->f1 = 3; + s->f2 = 2; + s->f3 = 1; + printf("st2: %d %d %d\n", + s->f1, s->f2, s->f3); + printf("str_addr=%x\n", (int)st1.str - (int)&st1.f1); + + /* align / size tests */ + printf("aligntest1 sizeof=%d alignof=%d\n", + sizeof(struct aligntest1), __alignof__(struct aligntest1)); + printf("aligntest2 sizeof=%d alignof=%d\n", + sizeof(struct aligntest2), __alignof__(struct aligntest2)); + printf("aligntest3 sizeof=%d alignof=%d\n", + sizeof(struct aligntest3), __alignof__(struct aligntest3)); + printf("aligntest4 sizeof=%d alignof=%d\n", + sizeof(struct aligntest4), __alignof__(struct aligntest4)); + + /* empty structures (GCC extension) */ + printf("sizeof(struct empty) = %d\n", sizeof(struct empty)); + printf("alignof(struct empty) = %d\n", __alignof__(struct empty)); +} + +/* XXX: depend on endianness */ +void char_short_test() +{ + int var1, var2; + + printf("char_short:\n"); + + var1 = 0x01020304; + var2 = 0xfffefdfc; + printf("s8=%d %d\n", + *(char *)&var1, *(char *)&var2); + printf("u8=%d %d\n", + *(unsigned char *)&var1, *(unsigned char *)&var2); + printf("s16=%d %d\n", + *(short *)&var1, *(short *)&var2); + printf("u16=%d %d\n", + *(unsigned short *)&var1, *(unsigned short *)&var2); + printf("s32=%d %d\n", + *(int *)&var1, *(int *)&var2); + printf("u32=%d %d\n", + *(unsigned int *)&var1, *(unsigned int *)&var2); + *(char *)&var1 = 0x08; + printf("var1=%x\n", var1); + *(short *)&var1 = 0x0809; + printf("var1=%x\n", var1); + *(int *)&var1 = 0x08090a0b; + printf("var1=%x\n", var1); +} + +/******************/ + +typedef struct Sym { + int v; + int t; + int c; + struct Sym *next; + struct Sym *prev; +} Sym; + +#define ISLOWER(c) ('a' <= (c) && (c) <= 'z') +#define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c)) + +static int toupper1(int a) +{ + return TOUPPER(a); +} + +void bool_test() +{ + int *s, a, b, t, f, i; + + a = 0; + s = (void*)0; + printf("!s=%d\n", !s); + + if (!s || !s[0]) + a = 1; + printf("a=%d\n", a); + + printf("a=%d %d %d\n", 0 || 0, 0 || 1, 1 || 1); + printf("a=%d %d %d\n", 0 && 0, 0 && 1, 1 && 1); + printf("a=%d %d\n", 1 ? 1 : 0, 0 ? 1 : 0); +#if 1 && 1 + printf("a1\n"); +#endif +#if 1 || 0 + printf("a2\n"); +#endif +#if 1 ? 0 : 1 + printf("a3\n"); +#endif +#if 0 ? 0 : 1 + printf("a4\n"); +#endif + + a = 4; + printf("b=%d\n", a + (0 ? 1 : a / 2)); + + /* test register spilling */ + a = 10; + b = 10; + a = (a + b) * ((a < b) ? + ((b - a) * (a - b)): a + b); + printf("a=%d\n", a); + + /* test complex || or && expressions */ + t = 1; + f = 0; + a = 32; + printf("exp=%d\n", f == (32 <= a && a <= 3)); + printf("r=%d\n", (t || f) + (t && f)); + + /* test ? : cast */ + { + int aspect_on; + int aspect_native = 65536; + double bfu_aspect = 1.0; + int aspect; + for(aspect_on = 0; aspect_on < 2; aspect_on++) { + aspect=aspect_on?(aspect_native*bfu_aspect+0.5):65535UL; + printf("aspect=%d\n", aspect); + } + } + + /* test ? : GCC extension */ + { + static int v1 = 34 ? : -1; /* constant case */ + static int v2 = 0 ? : -1; /* constant case */ + int a = 30; + + printf("%d %d\n", v1, v2); + printf("%d %d\n", a - 30 ? : a * 2, a + 1 ? : a * 2); + } + + /* again complex expression */ + for(i=0;i<256;i++) { + if (toupper1 (i) != TOUPPER (i)) + printf("error %d\n", i); + } +} + +/* GCC accepts that */ +static int tab_reinit[]; +static int tab_reinit[10]; + +//int cinit1; /* a global variable can be defined several times without error ! */ +int cinit1; +int cinit1; +int cinit1 = 0; +int *cinit2 = (int []){3, 2, 1}; + +void compound_literal_test(void) +{ + int *p, i; + char *q, *q3; + + printf("compound_test:\n"); + + p = (int []){1, 2, 3}; + for(i=0;i<3;i++) + printf(" %d", p[i]); + printf("\n"); + + for(i=0;i<3;i++) + printf("%d", cinit2[i]); + printf("\n"); + + q = "tralala1"; + printf("q1=%s\n", q); + + q = (char *){ "tralala2" }; + printf("q2=%s\n", q); + + q3 = (char *){ q }; + printf("q3=%s\n", q3); + + q = (char []){ "tralala3" }; + printf("q4=%s\n", q); + +#ifdef ALL_ISOC99 + p = (int []){1, 2, cinit1 + 3}; + for(i=0;i<3;i++) + printf(" %d", p[i]); + printf("\n"); + + for(i=0;i<3;i++) { + p = (int []){1, 2, 4 + i}; + printf("%d %d %d\n", + p[0], + p[1], + p[2]); + } +#endif +} + +/* K & R protos */ + +kr_func1(a, b) +{ + return a + b; +} + +int kr_func2(a, b) +{ + return a + b; +} + +kr_test() +{ + printf("kr_test:\n"); + printf("func1=%d\n", kr_func1(3, 4)); + printf("func2=%d\n", kr_func2(3, 4)); + return 0; +} + +void num(int n) +{ + char *tab, *p; + tab = (char*)malloc(20); + p = tab; + while (1) { + *p = 48 + (n % 10); + p++; + n = n / 10; + if (n == 0) + break; + } + while (p != tab) { + p--; + printf("%c", *p); + } + printf("\n"); +} + +/* structure assignment tests */ +struct structa1 { + int f1; + char f2; +}; + +struct structa1 ssta1; + +void struct_assign_test1(struct structa1 s1, int t) +{ + printf("%d %d %d\n", s1.f1, s1.f2, t); +} + +struct structa1 struct_assign_test2(struct structa1 s1, int t) +{ + s1.f1 += t; + s1.f2 -= t; + return s1; +} + +void struct_assign_test(void) +{ + struct structa1 lsta1, lsta2; + +#if 0 + printf("struct_assign_test:\n"); + + lsta1.f1 = 1; + lsta1.f2 = 2; + printf("%d %d\n", lsta1.f1, lsta1.f2); + lsta2 = lsta1; + printf("%d %d\n", lsta2.f1, lsta2.f2); +#else + lsta2.f1 = 1; + lsta2.f2 = 2; +#endif + struct_assign_test1(lsta2, 3); + + printf("before call: %d %d\n", lsta2.f1, lsta2.f2); + lsta2 = struct_assign_test2(lsta2, 4); + printf("after call: %d %d\n", lsta2.f1, lsta2.f2); +} + +/* casts to short/char */ + +void cast1(char a, short b, unsigned char c, unsigned short d) +{ + printf("%d %d %d %d\n", a, b, c, d); +} + +char bcast; +short scast; + +void cast_test() +{ + int a; + char c; + char tab[10]; + + printf("cast_test:\n"); + a = 0xfffff; + cast1(a, a, a, a); + a = 0xffffe; + printf("%d %d %d %d\n", + (char)(a + 1), + (short)(a + 1), + (unsigned char)(a + 1), + (unsigned short)(a + 1)); + printf("%d %d %d %d\n", + (char)0xfffff, + (short)0xfffff, + (unsigned char)0xfffff, + (unsigned short)0xfffff); + + a = (bcast = 128) + 1; + printf("%d\n", a); + a = (scast = 65536) + 1; + printf("%d\n", a); + + printf("sizeof(c) = %d, sizeof((int)c) = %d\n", sizeof(c), sizeof((int)c)); + + /* test implicit int casting for array accesses */ + c = 0; + tab[1] = 2; + tab[c] = 1; + printf("%d %d\n", tab[0], tab[1]); + + /* test implicit casting on some operators */ + printf("sizeof(+(char)'a') = %d\n", sizeof(+(char)'a')); + printf("sizeof(-(char)'a') = %d\n", sizeof(-(char)'a')); + printf("sizeof(~(char)'a') = %d\n", sizeof(-(char)'a')); +} + +/* initializers tests */ +struct structinit1 { + int f1; + char f2; + short f3; + int farray[3]; +}; + +int sinit1 = 2; +int sinit2 = { 3 }; +int sinit3[3] = { 1, 2, {{3}}, }; +int sinit4[3][2] = { {1, 2}, {3, 4}, {5, 6} }; +int sinit5[3][2] = { 1, 2, 3, 4, 5, 6 }; +int sinit6[] = { 1, 2, 3 }; +int sinit7[] = { [2] = 3, [0] = 1, 2 }; +char sinit8[] = "hello" "trala"; + +struct structinit1 sinit9 = { 1, 2, 3 }; +struct structinit1 sinit10 = { .f2 = 2, 3, .f1 = 1 }; +struct structinit1 sinit11 = { .f2 = 2, 3, .f1 = 1, +#ifdef ALL_ISOC99 + .farray[0] = 10, + .farray[1] = 11, + .farray[2] = 12, +#endif +}; + +char *sinit12 = "hello world"; +char *sinit13[] = { + "test1", + "test2", + "test3", +}; +char sinit14[10] = { "abc" }; +int sinit15[3] = { sizeof(sinit15), 1, 2 }; + +struct { int a[3], b; } sinit16[] = { { 1 }, 2 }; + +struct bar { + char *s; + int len; +} sinit17[] = { + "a1", 4, + "a2", 1 +}; + +int sinit18[10] = { + [2 ... 5] = 20, + 2, + [8] = 10, +}; + +void init_test(void) +{ + int linit1 = 2; + int linit2 = { 3 }; + int linit4[3][2] = { {1, 2}, {3, 4}, {5, 6} }; + int linit6[] = { 1, 2, 3 }; + int i, j; + char linit8[] = "hello" "trala"; + int linit12[10] = { 1, 2 }; + int linit13[10] = { 1, 2, [7] = 3, [3] = 4, }; + char linit14[10] = "abc"; + int linit15[10] = { linit1, linit1 + 1, [6] = linit1 + 2, }; + struct linit16 { int a1, a2, a3, a4; } linit16 = { 1, .a3 = 2 }; + int linit17 = sizeof(linit17); + + printf("init_test:\n"); + + printf("sinit1=%d\n", sinit1); + printf("sinit2=%d\n", sinit2); + printf("sinit3=%d %d %d %d\n", + sizeof(sinit3), + sinit3[0], + sinit3[1], + sinit3[2] + ); + printf("sinit6=%d\n", sizeof(sinit6)); + printf("sinit7=%d %d %d %d\n", + sizeof(sinit7), + sinit7[0], + sinit7[1], + sinit7[2] + ); + printf("sinit8=%s\n", sinit8); + printf("sinit9=%d %d %d\n", + sinit9.f1, + sinit9.f2, + sinit9.f3 + ); + printf("sinit10=%d %d %d\n", + sinit10.f1, + sinit10.f2, + sinit10.f3 + ); + printf("sinit11=%d %d %d %d %d %d\n", + sinit11.f1, + sinit11.f2, + sinit11.f3, + sinit11.farray[0], + sinit11.farray[1], + sinit11.farray[2] + ); + + for(i=0;i<3;i++) + for(j=0;j<2;j++) + printf("[%d][%d] = %d %d %d\n", + i, j, sinit4[i][j], sinit5[i][j], linit4[i][j]); + printf("linit1=%d\n", linit1); + printf("linit2=%d\n", linit2); + printf("linit6=%d\n", sizeof(linit6)); + printf("linit8=%d %s\n", sizeof(linit8), linit8); + + printf("sinit12=%s\n", sinit12); + printf("sinit13=%d %s %s %s\n", + sizeof(sinit13), + sinit13[0], + sinit13[1], + sinit13[2]); + printf("sinit14=%s\n", sinit14); + + for(i=0;i<10;i++) printf(" %d", linit12[i]); + printf("\n"); + for(i=0;i<10;i++) printf(" %d", linit13[i]); + printf("\n"); + for(i=0;i<10;i++) printf(" %d", linit14[i]); + printf("\n"); + for(i=0;i<10;i++) printf(" %d", linit15[i]); + printf("\n"); + printf("%d %d %d %d\n", + linit16.a1, + linit16.a2, + linit16.a3, + linit16.a4); + /* test that initialisation is done after variable declare */ + printf("linit17=%d\n", linit17); + printf("sinit15=%d\n", sinit15[0]); + printf("sinit16=%d %d\n", sinit16[0].a[0], sinit16[1].a[0]); + printf("sinit17=%s %d %s %d\n", + sinit17[0].s, sinit17[0].len, + sinit17[1].s, sinit17[1].len); + for(i=0;i<10;i++) + printf("%x ", sinit18[i]); + printf("\n"); +} + + +void switch_test() +{ + int i; + + for(i=0;i<15;i++) { + switch(i) { + case 0: + case 1: + printf("a"); + break; + default: + printf("%d", i); + break; + case 8 ... 12: + printf("c"); + break; + case 3: + printf("b"); + break; + } + } + printf("\n"); +} + +/* ISOC99 _Bool type */ +void c99_bool_test(void) +{ +#ifdef BOOL_ISOC99 + int a; + _Bool b; + + printf("bool_test:\n"); + printf("sizeof(_Bool) = %d\n", sizeof(_Bool)); + a = 3; + printf("cast: %d %d %d\n", (_Bool)10, (_Bool)0, (_Bool)a); + b = 3; + printf("b = %d\n", b); + b++; + printf("b = %d\n", b); +#endif +} + +void bitfield_test(void) +{ + int a; + struct sbf1 { + int f1 : 3; + int : 2; + int f2 : 1; + int : 0; + int f3 : 5; + int f4 : 7; + unsigned int f5 : 7; + } st1; + printf("bitfield_test:"); + printf("sizeof(st1) = %d\n", sizeof(st1)); + + st1.f1 = 3; + st1.f2 = 1; + st1.f3 = 15; + a = 120; + st1.f4 = a; + st1.f5 = a; + st1.f5++; + printf("%d %d %d %d %d\n", + st1.f1, st1.f2, st1.f3, st1.f4, st1.f5); + + st1.f1 = 7; + if (st1.f1 == -1) + printf("st1.f1 == -1\n"); + else + printf("st1.f1 != -1\n"); + if (st1.f2 == -1) + printf("st1.f2 == -1\n"); + else + printf("st1.f2 != -1\n"); +} + +#define FTEST(prefix, type, fmt)\ +void prefix ## cmp(type a, type b)\ +{\ + printf("%d %d %d %d %d %d\n",\ + a == b,\ + a != b,\ + a < b,\ + a > b,\ + a >= b,\ + a <= b);\ + printf(fmt " " fmt " " fmt " " fmt " " fmt " " fmt " " fmt "\n",\ + a,\ + b,\ + a + b,\ + a - b,\ + a * b,\ + a / b,\ + -a);\ + printf(fmt "\n", ++a);\ + printf(fmt "\n", a++);\ + printf(fmt "\n", a);\ +}\ +void prefix ## fcast(type a)\ +{\ + float fa;\ + double da;\ + long double la;\ + int ia;\ + unsigned int ua;\ + type b;\ + fa = a;\ + da = a;\ + la = a;\ + printf("ftof: %f %f %Lf\n", fa, da, la);\ + ia = (int)a;\ + ua = (unsigned int)a;\ + printf("ftoi: %d %u\n", ia, ua);\ + ia = -1234;\ + ua = 0x81234500;\ + b = ia;\ + printf("itof: " fmt "\n", b);\ + b = ua;\ + printf("utof: " fmt "\n", b);\ +}\ +\ +void prefix ## test(void)\ +{\ + printf("testing '%s'\n", #type);\ + prefix ## cmp(1, 2.5);\ + prefix ## cmp(2, 1.5);\ + prefix ## cmp(1, 1);\ + prefix ## fcast(234.6);\ + prefix ## fcast(-2334.6);\ +} + +FTEST(f, float, "%f") +FTEST(d, double, "%f") +FTEST(ld, long double, "%Lf") + +double ftab1[3] = { 1.2, 3.4, -5.6 }; + + +void float_test(void) +{ + float fa, fb; + double da, db; + int a; + unsigned int b; + + printf("float_test:\n"); + printf("sizeof(float) = %d\n", sizeof(float)); + printf("sizeof(double) = %d\n", sizeof(double)); + printf("sizeof(long double) = %d\n", sizeof(long double)); + ftest(); + dtest(); + ldtest(); + printf("%f %f %f\n", ftab1[0], ftab1[1], ftab1[2]); + printf("%f %f %f\n", 2.12, .5, 2.3e10); + // printf("%f %f %f\n", 0x1234p12, 0x1e23.23p10, 0x12dp-10); + da = 123; + printf("da=%f\n", da); + fa = 123; + printf("fa=%f\n", fa); + a = 4000000000; + da = a; + printf("da = %f\n", da); + b = 4000000000; + db = b; + printf("db = %f\n", db); +} + +int fib(int n) +{ + if (n <= 2) + return 1; + else + return fib(n-1) + fib(n-2); +} + +void funcptr_test() +{ + void (*func)(int); + int a; + struct { + int dummy; + void (*func)(int); + } st1; + + printf("funcptr:\n"); + func = # + (*func)(12345); + func = num; + a = 1; + a = 1; + func(12345); + /* more complicated pointer computation */ + st1.func = num; + st1.func(12346); + printf("sizeof1 = %d\n", sizeof(funcptr_test)); + printf("sizeof2 = %d\n", sizeof funcptr_test); + printf("sizeof3 = %d\n", sizeof(&funcptr_test)); + printf("sizeof4 = %d\n", sizeof &funcptr_test); +} + +void lloptest(long long a, long long b) +{ + unsigned long long ua, ub; + + ua = a; + ub = b; + /* arith */ + printf("arith: %Ld %Ld %Ld\n", + a + b, + a - b, + a * b); + + if (b != 0) { + printf("arith1: %Ld %Ld\n", + a / b, + a % b); + } + + /* binary */ + printf("bin: %Ld %Ld %Ld\n", + a & b, + a | b, + a ^ b); + + /* tests */ + printf("test: %d %d %d %d %d %d\n", + a == b, + a != b, + a < b, + a > b, + a >= b, + a <= b); + + printf("utest: %d %d %d %d %d %d\n", + ua == ub, + ua != ub, + ua < ub, + ua > ub, + ua >= ub, + ua <= ub); + + /* arith2 */ + a++; + b++; + printf("arith2: %Ld %Ld\n", a, b); + printf("arith2: %Ld %Ld\n", a++, b++); + printf("arith2: %Ld %Ld\n", --a, --b); + printf("arith2: %Ld %Ld\n", a, b); +} + +void llshift(long long a, int b) +{ + printf("shift: %Ld %Ld %Ld\n", + (unsigned long long)a >> b, + a >> b, + a << b); + printf("shiftc: %Ld %Ld %Ld\n", + (unsigned long long)a >> 3, + a >> 3, + a << 3); + printf("shiftc: %Ld %Ld %Ld\n", + (unsigned long long)a >> 35, + a >> 35, + a << 35); +} + +void llfloat(void) +{ + float fa; + double da; + long double lda; + long long la, lb, lc; + unsigned long long ula, ulb, ulc; + la = 0x12345678; + ula = 0x72345678; + la = (la << 20) | 0x12345; + ula = ula << 33; + printf("la=%Ld ula=%Lu\n", la, ula); + + fa = la; + da = la; + lda = la; + printf("lltof: %f %f %Lf\n", fa, da, lda); + + la = fa; + lb = da; + lc = lda; + printf("ftoll: %Ld %Ld %Ld\n", la, lb, lc); + + fa = ula; + da = ula; + lda = ula; + printf("ulltof: %f %f %Lf\n", fa, da, lda); + + ula = fa; + ulb = da; + ulc = lda; + printf("ftoull: %Lu %Lu %Lu\n", ula, ulb, ulc); +} + +long long llfunc1(int a) +{ + return a * 2; +} + +struct S { + int id; + char item; +}; + +long long int value(struct S *v) +{ + return ((long long int)v->item); +} + +void longlong_test(void) +{ + long long a, b, c; + int ia; + unsigned int ua; + printf("longlong_test:\n"); + printf("sizeof(long long) = %d\n", sizeof(long long)); + ia = -1; + ua = -2; + a = ia; + b = ua; + printf("%Ld %Ld\n", a, b); + printf("%Ld %Ld %Ld %Lx\n", + (long long)1, + (long long)-2, + 1LL, + 0x1234567812345679); + a = llfunc1(-3); + printf("%Ld\n", a); + + lloptest(1000, 23); + lloptest(0xff, 0x1234); + b = 0x72345678 << 10; + lloptest(-3, b); + llshift(0x123, 5); + llshift(-23, 5); + b = 0x72345678LL << 10; + llshift(b, 47); + + llfloat(); +#if 1 + b = 0x12345678; + a = -1; + c = a + b; + printf("%Lx\n", c); +#endif + + /* long long reg spill test */ + { + struct S a; + + a.item = 3; + printf("%lld\n", value(&a)); + } + lloptest(0x80000000, 0); + + /* another long long spill test */ + { + long long *p, v; + v = 1; + p = &v; + p[0]++; + printf("%lld\n", *p); + } +} + +void vprintf1(const char *fmt, ...) +{ + va_list ap; + const char *p; + int c, i; + double d; + long long ll; + + va_start(ap, fmt); + + p = fmt; + for(;;) { + c = *p; + if (c == '\0') + break; + p++; + if (c == '%') { + c = *p; + switch(c) { + case '\0': + goto the_end; + case 'd': + i = va_arg(ap, int); + printf("%d", i); + break; + case 'f': + d = va_arg(ap, double); + printf("%f", d); + break; + case 'l': + ll = va_arg(ap, long long); + printf("%Ld", ll); + break; + } + p++; + } else { + putchar(c); + } + } + the_end: + va_end(ap); +} + + +void stdarg_test(void) +{ + vprintf1("%d %d %d\n", 1, 2, 3); + vprintf1("%f %d %f\n", 1.0, 2, 3.0); + vprintf1("%l %l %d %f\n", 1234567891234LL, 987654321986LL, 3, 1234.0); +} + +void whitespace_test(void) +{ + char *str; + + #if 1 + pri\ +ntf("whitspace:\n"); +#endif + pf("N=%d\n", 2); + +#ifdef CORRECT_CR_HANDLING + pri\ +ntf("aaa=%d\n", 3); +#endif + + pri\ +\ +ntf("min=%d\n", 4); + +#ifdef ACCEPT_CR_IN_STRINGS + printf("len1=%d\n", strlen(" +")); +#ifdef CORRECT_CR_HANDLING + str = " +"; + printf("len1=%d str[0]=%d\n", strlen(str), str[0]); +#endif + printf("len1=%d\n", strlen(" a +")); +#endif /* ACCEPT_CR_IN_STRINGS */ +} + +int reltab[3] = { 1, 2, 3 }; + +int *rel1 = &reltab[1]; +int *rel2 = &reltab[2]; + +void relocation_test(void) +{ + printf("*rel1=%d\n", *rel1); + printf("*rel2=%d\n", *rel2); +} + +void old_style_f(a,b,c) + int a, b; + double c; +{ + printf("a=%d b=%d b=%f\n", a, b, c); +} + +void decl_func1(int cmpfn()) +{ + printf("cmpfn=%lx\n", (long)cmpfn); +} + +void decl_func2(cmpfn) +int cmpfn(); +{ + printf("cmpfn=%lx\n", (long)cmpfn); +} + +void old_style_function(void) +{ + old_style_f((void *)1, 2, 3.0); + decl_func1(NULL); + decl_func2(NULL); +} + +void sizeof_test(void) +{ + int a; + int **ptr; + + printf("sizeof(int) = %d\n", sizeof(int)); + printf("sizeof(unsigned int) = %d\n", sizeof(unsigned int)); + printf("sizeof(short) = %d\n", sizeof(short)); + printf("sizeof(unsigned short) = %d\n", sizeof(unsigned short)); + printf("sizeof(char) = %d\n", sizeof(char)); + printf("sizeof(unsigned char) = %d\n", sizeof(unsigned char)); + printf("sizeof(func) = %d\n", sizeof sizeof_test()); + a = 1; + printf("sizeof(a++) = %d\n", sizeof a++); + printf("a=%d\n", a); + ptr = NULL; + printf("sizeof(**ptr) = %d\n", sizeof (**ptr)); + + /* some alignof tests */ + printf("__alignof__(int) = %d\n", __alignof__(int)); + printf("__alignof__(unsigned int) = %d\n", __alignof__(unsigned int)); + printf("__alignof__(short) = %d\n", __alignof__(short)); + printf("__alignof__(unsigned short) = %d\n", __alignof__(unsigned short)); + printf("__alignof__(char) = %d\n", __alignof__(char)); + printf("__alignof__(unsigned char) = %d\n", __alignof__(unsigned char)); + printf("__alignof__(func) = %d\n", __alignof__ sizeof_test()); +} + +void typeof_test(void) +{ + double a; + typeof(a) b; + typeof(float) c; + + a = 1.5; + b = 2.5; + c = 3.5; + printf("a=%f b=%f c=%f\n", a, b, c); +} + +void statement_expr_test(void) +{ + int a, i; + + a = 0; + for(i=0;i<10;i++) { + a += 1 + + ( { int b, j; + b = 0; + for(j=0;j<5;j++) + b += j; b; + } ); + } + printf("a=%d\n", a); + +} + +void local_label_test(void) +{ + int a; + goto l1; + l2: + a = 1 + ({ + __label__ l1, l2, l3; + goto l4; + l5: + printf("aa1\n"); + goto l1; + l2: + printf("aa3\n"); + goto l3; + l1: + printf("aa2\n"); + goto l2; + l3:; + 1; + }); + printf("a=%d\n", a); + return; + l1: + printf("bb1\n"); + goto l2; + l4: + printf("bb2\n"); + goto l5; +} + +/* inline assembler test */ +#ifdef __i386__ + +/* from linux kernel */ +static char * strncat1(char * dest,const char * src,size_t count) +{ +int d0, d1, d2, d3; +__asm__ __volatile__( + "repne\n\t" + "scasb\n\t" + "decl %1\n\t" + "movl %8,%3\n" + "1:\tdecl %3\n\t" + "js 2f\n\t" + "lodsb\n\t" + "stosb\n\t" + "testb %%al,%%al\n\t" + "jne 1b\n" + "2:\txorl %2,%2\n\t" + "stosb" + : "=&S" (d0), "=&D" (d1), "=&a" (d2), "=&c" (d3) + : "0" (src),"1" (dest),"2" (0),"3" (0xffffffff), "g" (count) + : "memory"); +return dest; +} + +static inline void * memcpy1(void * to, const void * from, size_t n) +{ +int d0, d1, d2; +__asm__ __volatile__( + "rep ; movsl\n\t" + "testb $2,%b4\n\t" + "je 1f\n\t" + "movsw\n" + "1:\ttestb $1,%b4\n\t" + "je 2f\n\t" + "movsb\n" + "2:" + : "=&c" (d0), "=&D" (d1), "=&S" (d2) + :"0" (n/4), "q" (n),"1" ((long) to),"2" ((long) from) + : "memory"); +return (to); +} + +static __inline__ void sigaddset1(unsigned int *set, int _sig) +{ + __asm__("btsl %1,%0" : "=m"(*set) : "Ir"(_sig - 1) : "cc"); +} + +static __inline__ void sigdelset1(unsigned int *set, int _sig) +{ + asm("btrl %1,%0" : "=m"(*set) : "Ir"(_sig - 1) : "cc"); +} + +static __inline__ __const__ unsigned int swab32(unsigned int x) +{ + __asm__("xchgb %b0,%h0\n\t" /* swap lower bytes */ + "rorl $16,%0\n\t" /* swap words */ + "xchgb %b0,%h0" /* swap higher bytes */ + :"=q" (x) + : "0" (x)); + return x; +} + +static __inline__ unsigned long long mul64(unsigned int a, unsigned int b) +{ + unsigned long long res; + __asm__("mull %2" : "=A" (res) : "a" (a), "r" (b)); + return res; +} + +static __inline__ unsigned long long inc64(unsigned long long a) +{ + unsigned long long res; + __asm__("addl $1, %%eax ; adcl $0, %%edx" : "=A" (res) : "A" (a)); + return res; +} + +unsigned int set; + +void asm_test(void) +{ + char buf[128]; + unsigned int val; + + printf("inline asm:\n"); + /* test the no operand case */ + asm volatile ("xorl %eax, %eax"); + + memcpy1(buf, "hello", 6); + strncat1(buf, " worldXXXXX", 3); + printf("%s\n", buf); + + /* 'A' constraint test */ + printf("mul64=0x%Lx\n", mul64(0x12345678, 0xabcd1234)); + printf("inc64=0x%Lx\n", inc64(0x12345678ffffffff)); + + set = 0xff; + sigdelset1(&set, 2); + sigaddset1(&set, 16); + /* NOTE: we test here if C labels are correctly restored after the + asm statement */ + goto label1; + label2: + __asm__("btsl %1,%0" : "=m"(set) : "Ir"(20) : "cc"); + printf("set=0x%x\n", set); + val = 0x01020304; + printf("swab32(0x%08x) = 0x%0x\n", val, swab32(val)); + return; + label1: + goto label2; +} + +#else + +void asm_test(void) +{ +} + +#endif + +#define COMPAT_TYPE(type1, type2) \ +{\ + printf("__builtin_types_compatible_p(%s, %s) = %d\n", #type1, #type2, \ + __builtin_types_compatible_p (type1, type2));\ +} + +int constant_p_var; + +void builtin_test(void) +{ +#if GCC_MAJOR >= 3 + COMPAT_TYPE(int, int); + COMPAT_TYPE(int, unsigned int); + COMPAT_TYPE(int, char); + COMPAT_TYPE(int, const int); + COMPAT_TYPE(int, volatile int); + COMPAT_TYPE(int *, int *); + COMPAT_TYPE(int *, void *); + COMPAT_TYPE(int *, const int *); + COMPAT_TYPE(char *, unsigned char *); +/* space is needed because tcc preprocessor introduces a space between each token */ + COMPAT_TYPE(char * *, void *); +#endif + printf("res = %d\n", __builtin_constant_p(1)); + printf("res = %d\n", __builtin_constant_p(1 + 2)); + printf("res = %d\n", __builtin_constant_p(&constant_p_var)); + printf("res = %d\n", __builtin_constant_p(constant_p_var)); +} + + +void const_func(const int a) +{ +} + +void const_warn_test(void) +{ + const_func(1); +} diff --git a/tcctok.h b/tcctok.h new file mode 100644 index 0000000..63eea31 --- /dev/null +++ b/tcctok.h @@ -0,0 +1,445 @@ +/* keywords */ + DEF(TOK_INT, "int") + DEF(TOK_VOID, "void") + DEF(TOK_CHAR, "char") + DEF(TOK_IF, "if") + DEF(TOK_ELSE, "else") + DEF(TOK_WHILE, "while") + DEF(TOK_BREAK, "break") + DEF(TOK_RETURN, "return") + DEF(TOK_FOR, "for") + DEF(TOK_EXTERN, "extern") + DEF(TOK_STATIC, "static") + DEF(TOK_UNSIGNED, "unsigned") + DEF(TOK_GOTO, "goto") + DEF(TOK_DO, "do") + DEF(TOK_CONTINUE, "continue") + DEF(TOK_SWITCH, "switch") + DEF(TOK_CASE, "case") + + DEF(TOK_CONST1, "const") + DEF(TOK_CONST2, "__const") /* gcc keyword */ + DEF(TOK_CONST3, "__const__") /* gcc keyword */ + DEF(TOK_VOLATILE1, "volatile") + DEF(TOK_VOLATILE2, "__volatile") /* gcc keyword */ + DEF(TOK_VOLATILE3, "__volatile__") /* gcc keyword */ + DEF(TOK_LONG, "long") + DEF(TOK_REGISTER, "register") + DEF(TOK_SIGNED1, "signed") + DEF(TOK_SIGNED2, "__signed") /* gcc keyword */ + DEF(TOK_SIGNED3, "__signed__") /* gcc keyword */ + DEF(TOK_AUTO, "auto") + DEF(TOK_INLINE1, "inline") + DEF(TOK_INLINE2, "__inline") /* gcc keyword */ + DEF(TOK_INLINE3, "__inline__") /* gcc keyword */ + DEF(TOK_RESTRICT1, "restrict") + DEF(TOK_RESTRICT2, "__restrict") + DEF(TOK_RESTRICT3, "__restrict__") + DEF(TOK_EXTENSION, "__extension__") /* gcc keyword */ + + DEF(TOK_FLOAT, "float") + DEF(TOK_DOUBLE, "double") + DEF(TOK_BOOL, "_Bool") + DEF(TOK_SHORT, "short") + DEF(TOK_STRUCT, "struct") + DEF(TOK_UNION, "union") + DEF(TOK_TYPEDEF, "typedef") + DEF(TOK_DEFAULT, "default") + DEF(TOK_ENUM, "enum") + DEF(TOK_SIZEOF, "sizeof") + DEF(TOK_ATTRIBUTE1, "__attribute") + DEF(TOK_ATTRIBUTE2, "__attribute__") + DEF(TOK_ALIGNOF1, "__alignof") + DEF(TOK_ALIGNOF2, "__alignof__") + DEF(TOK_TYPEOF1, "typeof") + DEF(TOK_TYPEOF2, "__typeof") + DEF(TOK_TYPEOF3, "__typeof__") + DEF(TOK_LABEL, "__label__") + DEF(TOK_ASM1, "asm") + DEF(TOK_ASM2, "__asm") + DEF(TOK_ASM3, "__asm__") + +/*********************************************************************/ +/* the following are not keywords. They are included to ease parsing */ +/* preprocessor only */ + DEF(TOK_DEFINE, "define") + DEF(TOK_INCLUDE, "include") + DEF(TOK_INCLUDE_NEXT, "include_next") + DEF(TOK_IFDEF, "ifdef") + DEF(TOK_IFNDEF, "ifndef") + DEF(TOK_ELIF, "elif") + DEF(TOK_ENDIF, "endif") + DEF(TOK_DEFINED, "defined") + DEF(TOK_UNDEF, "undef") + DEF(TOK_ERROR, "error") + DEF(TOK_WARNING, "warning") + DEF(TOK_LINE, "line") + DEF(TOK_PRAGMA, "pragma") + DEF(TOK___LINE__, "__LINE__") + DEF(TOK___FILE__, "__FILE__") + DEF(TOK___DATE__, "__DATE__") + DEF(TOK___TIME__, "__TIME__") + DEF(TOK___FUNCTION__, "__FUNCTION__") + DEF(TOK___VA_ARGS__, "__VA_ARGS__") + +/* special identifiers */ + DEF(TOK___FUNC__, "__func__") + +/* attribute identifiers */ +/* XXX: handle all tokens generically since speed is not critical */ + DEF(TOK_SECTION1, "section") + DEF(TOK_SECTION2, "__section__") + DEF(TOK_ALIGNED1, "aligned") + DEF(TOK_ALIGNED2, "__aligned__") + DEF(TOK_PACKED1, "packed") + DEF(TOK_PACKED2, "__packed__") + DEF(TOK_UNUSED1, "unused") + DEF(TOK_UNUSED2, "__unused__") + DEF(TOK_CDECL1, "cdecl") + DEF(TOK_CDECL2, "__cdecl") + DEF(TOK_CDECL3, "__cdecl__") + DEF(TOK_STDCALL1, "stdcall") + DEF(TOK_STDCALL2, "__stdcall") + DEF(TOK_STDCALL3, "__stdcall__") + DEF(TOK_DLLEXPORT, "dllexport") + DEF(TOK_NORETURN1, "noreturn") + DEF(TOK_NORETURN2, "__noreturn__") + DEF(TOK_builtin_types_compatible_p, "__builtin_types_compatible_p") + DEF(TOK_builtin_constant_p, "__builtin_constant_p") + DEF(TOK_REGPARM1, "regparm") + DEF(TOK_REGPARM2, "__regparm__") + +/* pragma */ + DEF(TOK_pack, "pack") +#if !defined(TCC_TARGET_I386) + /* already defined for assembler */ + DEF(TOK_ASM_push, "push") + DEF(TOK_ASM_pop, "pop") +#endif + +/* builtin functions or variables */ + DEF(TOK_memcpy, "memcpy") + DEF(TOK_memset, "memset") + DEF(TOK_alloca, "alloca") +#if defined(TCC_TARGET_816) + DEF(TOK___divdi3, "tcc__divdi3") + DEF(TOK___moddi3, "tcc__moddi3") + DEF(TOK___udivdi3, "tcc__udivdi3") + DEF(TOK___umoddi3, "tcc__umoddi3") +#else + DEF(TOK___divdi3, "__divdi3") + DEF(TOK___moddi3, "__moddi3") + DEF(TOK___udivdi3, "__udivdi3") + DEF(TOK___umoddi3, "__umoddi3") +#endif +#if defined(TCC_TARGET_ARM) + DEF(TOK___divsi3, "__divsi3") + DEF(TOK___modsi3, "__modsi3") + DEF(TOK___udivsi3, "__udivsi3") + DEF(TOK___umodsi3, "__umodsi3") + DEF(TOK___sardi3, "__ashrdi3") + DEF(TOK___shrdi3, "__lshrdi3") + DEF(TOK___shldi3, "__ashldi3") + DEF(TOK___slltold, "__slltold") + DEF(TOK___fixunssfsi, "__fixunssfsi") + DEF(TOK___fixunsdfsi, "__fixunsdfsi") + DEF(TOK___fixunsxfsi, "__fixunsxfsi") + DEF(TOK___fixsfdi, "__fixsfdi") + DEF(TOK___fixdfdi, "__fixdfdi") + DEF(TOK___fixxfdi, "__fixxfdi") +#elif defined(TCC_TARGET_C67) + DEF(TOK__divi, "_divi") + DEF(TOK__divu, "_divu") + DEF(TOK__divf, "_divf") + DEF(TOK__divd, "_divd") + DEF(TOK__remi, "_remi") + DEF(TOK__remu, "_remu") + DEF(TOK___sardi3, "__sardi3") + DEF(TOK___shrdi3, "__shrdi3") + DEF(TOK___shldi3, "__shldi3") +#elif defined(TCC_TARGET_816) + DEF(TOK___sardi3, "tcc__sardi3") + DEF(TOK___shrdi3, "tcc__shrdi3") + DEF(TOK___shldi3, "tcc__shldi3") +#else + /* XXX: same names on i386 ? */ + DEF(TOK___sardi3, "__sardi3") + DEF(TOK___shrdi3, "__shrdi3") + DEF(TOK___shldi3, "__shldi3") +#endif + DEF(TOK___tcc_int_fpu_control, "__tcc_int_fpu_control") + DEF(TOK___tcc_fpu_control, "__tcc_fpu_control") +#ifdef TCC_TARGET_816 + DEF(TOK___ulltof, "tcc__ulltof") + DEF(TOK___ulltod, "tcc__ulltod") + DEF(TOK___ulltold, "tcc__ulltold") + DEF(TOK___fixunssfdi, "tcc__fixunssfdi") + DEF(TOK___fixunsdfdi, "tcc__fixunsdfdi") + DEF(TOK___fixunsxfdi, "tcc__fixunsxfdi") +#else + DEF(TOK___ulltof, "__ulltof") + DEF(TOK___ulltod, "__ulltod") + DEF(TOK___ulltold, "__ulltold") + DEF(TOK___fixunssfdi, "__fixunssfdi") + DEF(TOK___fixunsdfdi, "__fixunsdfdi") + DEF(TOK___fixunsxfdi, "__fixunsxfdi") +#endif + DEF(TOK___chkstk, "__chkstk") + +/* bound checking symbols */ +#ifdef CONFIG_TCC_BCHECK + DEF(TOK___bound_ptr_add, "__bound_ptr_add") + DEF(TOK___bound_ptr_indir1, "__bound_ptr_indir1") + DEF(TOK___bound_ptr_indir2, "__bound_ptr_indir2") + DEF(TOK___bound_ptr_indir4, "__bound_ptr_indir4") + DEF(TOK___bound_ptr_indir8, "__bound_ptr_indir8") + DEF(TOK___bound_ptr_indir12, "__bound_ptr_indir12") + DEF(TOK___bound_ptr_indir16, "__bound_ptr_indir16") + DEF(TOK___bound_local_new, "__bound_local_new") + DEF(TOK___bound_local_delete, "__bound_local_delete") + DEF(TOK_malloc, "malloc") + DEF(TOK_free, "free") + DEF(TOK_realloc, "realloc") + DEF(TOK_memalign, "memalign") + DEF(TOK_calloc, "calloc") + DEF(TOK_memmove, "memmove") + DEF(TOK_strlen, "strlen") + DEF(TOK_strcpy, "strcpy") +#endif + +/* Tiny Assembler */ + + DEF_ASM(byte) + DEF_ASM(align) + DEF_ASM(skip) + DEF_ASM(space) + DEF_ASM(string) + DEF_ASM(asciz) + DEF_ASM(ascii) + DEF_ASM(globl) + DEF_ASM(global) + DEF_ASM(text) + DEF_ASM(data) + DEF_ASM(bss) + DEF_ASM(previous) + DEF_ASM(fill) + DEF_ASM(org) + DEF_ASM(quad) + +#ifdef TCC_TARGET_I386 + +/* WARNING: relative order of tokens is important. */ + DEF_ASM(al) + DEF_ASM(cl) + DEF_ASM(dl) + DEF_ASM(bl) + DEF_ASM(ah) + DEF_ASM(ch) + DEF_ASM(dh) + DEF_ASM(bh) + DEF_ASM(ax) + DEF_ASM(cx) + DEF_ASM(dx) + DEF_ASM(bx) + DEF_ASM(sp) + DEF_ASM(bp) + DEF_ASM(si) + DEF_ASM(di) + DEF_ASM(eax) + DEF_ASM(ecx) + DEF_ASM(edx) + DEF_ASM(ebx) + DEF_ASM(esp) + DEF_ASM(ebp) + DEF_ASM(esi) + DEF_ASM(edi) + DEF_ASM(mm0) + DEF_ASM(mm1) + DEF_ASM(mm2) + DEF_ASM(mm3) + DEF_ASM(mm4) + DEF_ASM(mm5) + DEF_ASM(mm6) + DEF_ASM(mm7) + DEF_ASM(xmm0) + DEF_ASM(xmm1) + DEF_ASM(xmm2) + DEF_ASM(xmm3) + DEF_ASM(xmm4) + DEF_ASM(xmm5) + DEF_ASM(xmm6) + DEF_ASM(xmm7) + DEF_ASM(cr0) + DEF_ASM(cr1) + DEF_ASM(cr2) + DEF_ASM(cr3) + DEF_ASM(cr4) + DEF_ASM(cr5) + DEF_ASM(cr6) + DEF_ASM(cr7) + DEF_ASM(tr0) + DEF_ASM(tr1) + DEF_ASM(tr2) + DEF_ASM(tr3) + DEF_ASM(tr4) + DEF_ASM(tr5) + DEF_ASM(tr6) + DEF_ASM(tr7) + DEF_ASM(db0) + DEF_ASM(db1) + DEF_ASM(db2) + DEF_ASM(db3) + DEF_ASM(db4) + DEF_ASM(db5) + DEF_ASM(db6) + DEF_ASM(db7) + DEF_ASM(dr0) + DEF_ASM(dr1) + DEF_ASM(dr2) + DEF_ASM(dr3) + DEF_ASM(dr4) + DEF_ASM(dr5) + DEF_ASM(dr6) + DEF_ASM(dr7) + DEF_ASM(es) + DEF_ASM(cs) + DEF_ASM(ss) + DEF_ASM(ds) + DEF_ASM(fs) + DEF_ASM(gs) + DEF_ASM(st) + + DEF_BWL(mov) + + /* generic two operands */ + DEF_BWL(add) + DEF_BWL(or) + DEF_BWL(adc) + DEF_BWL(sbb) + DEF_BWL(and) + DEF_BWL(sub) + DEF_BWL(xor) + DEF_BWL(cmp) + + /* unary ops */ + DEF_BWL(inc) + DEF_BWL(dec) + DEF_BWL(not) + DEF_BWL(neg) + DEF_BWL(mul) + DEF_BWL(imul) + DEF_BWL(div) + DEF_BWL(idiv) + + DEF_BWL(xchg) + DEF_BWL(test) + + /* shifts */ + DEF_BWL(rol) + DEF_BWL(ror) + DEF_BWL(rcl) + DEF_BWL(rcr) + DEF_BWL(shl) + DEF_BWL(shr) + DEF_BWL(sar) + + DEF_ASM(shldw) + DEF_ASM(shldl) + DEF_ASM(shld) + DEF_ASM(shrdw) + DEF_ASM(shrdl) + DEF_ASM(shrd) + + DEF_ASM(pushw) + DEF_ASM(pushl) + DEF_ASM(push) + DEF_ASM(popw) + DEF_ASM(popl) + DEF_ASM(pop) + DEF_BWL(in) + DEF_BWL(out) + + DEF_WL(movzb) + + DEF_ASM(movzwl) + DEF_ASM(movsbw) + DEF_ASM(movsbl) + DEF_ASM(movswl) + + DEF_WL(lea) + + DEF_ASM(les) + DEF_ASM(lds) + DEF_ASM(lss) + DEF_ASM(lfs) + DEF_ASM(lgs) + + DEF_ASM(call) + DEF_ASM(jmp) + DEF_ASM(lcall) + DEF_ASM(ljmp) + + DEF_ASMTEST(j) + + DEF_ASMTEST(set) + DEF_ASMTEST(cmov) + + DEF_WL(bsf) + DEF_WL(bsr) + DEF_WL(bt) + DEF_WL(bts) + DEF_WL(btr) + DEF_WL(btc) + + DEF_WL(lsl) + + /* generic FP ops */ + DEF_FP(add) + DEF_FP(mul) + + DEF_ASM(fcom) + DEF_ASM(fcom_1) /* non existant op, just to have a regular table */ + DEF_FP1(com) + + DEF_FP(comp) + DEF_FP(sub) + DEF_FP(subr) + DEF_FP(div) + DEF_FP(divr) + + DEF_BWL(xadd) + DEF_BWL(cmpxchg) + + /* string ops */ + DEF_BWL(cmps) + DEF_BWL(scmp) + DEF_BWL(ins) + DEF_BWL(outs) + DEF_BWL(lods) + DEF_BWL(slod) + DEF_BWL(movs) + DEF_BWL(smov) + DEF_BWL(scas) + DEF_BWL(ssca) + DEF_BWL(stos) + DEF_BWL(ssto) + + /* generic asm ops */ + +#define ALT(x) +#define DEF_ASM_OP0(name, opcode) DEF_ASM(name) +#define DEF_ASM_OP0L(name, opcode, group, instr_type) +#define DEF_ASM_OP1(name, opcode, group, instr_type, op0) +#define DEF_ASM_OP2(name, opcode, group, instr_type, op0, op1) +#define DEF_ASM_OP3(name, opcode, group, instr_type, op0, op1, op2) +#include "i386-asm.h" + +#define ALT(x) +#define DEF_ASM_OP0(name, opcode) +#define DEF_ASM_OP0L(name, opcode, group, instr_type) DEF_ASM(name) +#define DEF_ASM_OP1(name, opcode, group, instr_type, op0) DEF_ASM(name) +#define DEF_ASM_OP2(name, opcode, group, instr_type, op0, op1) DEF_ASM(name) +#define DEF_ASM_OP3(name, opcode, group, instr_type, op0, op1, op2) DEF_ASM(name) +#include "i386-asm.h" + +#endif diff --git a/test/broken/20020920-1.c b/test/broken/20020920-1.c new file mode 100644 index 0000000..9a15c66 --- /dev/null +++ b/test/broken/20020920-1.c @@ -0,0 +1,39 @@ +// serious problem: a.b is not initialized properly; TCC +// does a.b.x, then stops. does not look like it's easy to fix + +extern void abort (void); +extern void exit (int); + +struct B +{ + int x; + int y; +}; + +struct A +{ + int z; + struct B b; +}; + +struct A +f () +{ + struct B b = { 0, 1 }; + struct A a = { 2, b }; + return a; +} + +int +main (void) +{ + struct A a = f (); +#if 0 + if (a.z != 2 || a.b.x != 0 || a.b.y != 1) + abort (); +#endif + //if (a.z != 2) exit(1); + //if(a.b.x != 0) exit(2); + if(a.b.y != 1) exit(3); + exit (0); +} diff --git a/test/broken/largestack/20010129-1.c b/test/broken/largestack/20010129-1.c new file mode 100644 index 0000000..40d74cc --- /dev/null +++ b/test/broken/largestack/20010129-1.c @@ -0,0 +1,72 @@ +// breaks because of the fat local array in foo + +#ifdef __65816__ +#else +#define long short +#define int short +#endif + +long baz1 (void *a) +{ + static long l; + return l++; +} + +int baz2 (const char *a) +{ + return 0; +} + +int baz3 (int i) +{ + if (!i) + abort (); + return 1; +} + +void **bar; + +int foo (void *a, long b, int c) +{ + int d = 0, e, f = 0, i; + char g[256]; + void **h; + + g[0] = '\n'; + g[1] = 0; + + while (baz1 (a) < b) { + if (g[0] != ' ' && g[0] != '\t') { + f = 1; + e = 0; + if (!d && baz2 (g) == 0) { + if ((c & 0x10) == 0) + continue; + e = d = 1; + } + if (!((c & 0x10) && (c & 0x4000) && e) && (c & 2)) + continue; + if ((c & 0x2000) && baz2 (g) == 0) + continue; + if ((c & 0x1408) && baz2 (g) == 0) + continue; + if ((c & 0x200) && baz2 (g) == 0) + continue; + if (c & 0x80) { + for (h = bar, i = 0; h; h = (void **)*h, i++) + if (baz3 (i)) + break; + } + f = 0; + } + } + return 0; +} + +int main () +{ + void *n = 0; + bar = &n; + foo (&n, 1, 0xc811); + exit (0); +} diff --git a/test/broken/largestack/20040219-1.c b/test/broken/largestack/20040219-1.c new file mode 100644 index 0000000..1a277d6 --- /dev/null +++ b/test/broken/largestack/20040219-1.c @@ -0,0 +1,74 @@ +/* Testing save/restore of floating point caller-save registers, on ia64 + this resulted in bad code. Not all targets will use caller-save regs. */ + +/* { dg-do run } */ +/* { dg-options "-O2" } */ +/* { dg-options "-O2 -minline-float-divide-max-throughput" { target ia64-*-* } } */ + +/* Testing save/restore of floating point caller-save registers on ia64. */ + +extern void abort (void); + +double foo(double a, double b, double c) +{ + return (a+b+c); +} + +main () +{ + double f1, f2, f3, f4, f5, f6, f7, f8, f9,f10; + double f11,f12,f13,f14,f15,f16,f17,f18,f19,f20; + double f21,f22,f23,f24,f25,f26,f27,f28,f29,f30; + double x; + int i,j,k; + + f1 = 0.1; f2 = 0.2; f3 = 0.3; f4 = 0.4; f5 = 0.5; + f6 = 0.6; f7 = 0.7; f8 = 0.8; f9 = 0.9; f10 = 1.0; + f11 = 1.1; f12 = 1.2; f13 = 1.3; f14 = 1.4; f15 = 1.5; + f16 = 1.6; f17 = 1.7; f18 = 1.8; f19 = 1.9; f20 = 2.0; + f21 = 2.1; f22 = 2.2; f23 = 2.3; f24 = 2.4; f25 = 2.5; + f26 = 2.6; f27 = 2.7; f28 = 2.8; f29 = 2.9; f30 = 3.0; + + i = (int) foo(1.0,1.0,1.0); + while (i > 0) { + f1 = f2 / f3 * f30; + f2 = f3 / f4 * f30; + f3 = f4 / f5 * f30; + f4 = f5 / f6 * f30; + f5 = f6 / f7 * f30; + f6 = f7 / f8 * f30; + f7 = f8 / f9 * f30; + f8 = f9 / f10 * f30; + f9 = f10 / f11 * f30; + f10 = f11 / f12 * f30; + f11 = f12 / f13 * f30; + f12 = f13 / f14 * f25; + f13 = f14 / f15 * f30; + f14 = f15 / f16 * f30; + f15 = f16 / f17 * f30; + f16 = f17 / f18 * f30; + f17 = f18 / f19 * f30; + f18 = f19 / f20 * f30; + f19 = f20 / f21 * f30; + f20 = f21 / f22 * f20; + f21 = f22 / f23 * f30; + f22 = f23 / f24 * f30; + f23 = f24 / f25 * f30; + f24 = f25 / f26 * f30; + f25 = f26 / f27 * f30; + f26 = f27 / f28 * f30; + f27 = f28 / f29 * f30; + f28 = f29 / f30 * f30; + f29 = f30 / f1 * f30; + f30 = f1 / f2 * f30; + x = foo(f1,f2,f3); + i = i - 1; + } + x = (f1+f2+f3+f4+f5+f6+f7+f8+f9+f10) * + (f11+f12+f13+f14+f15+f16+f17+f18+f19+f20) * + (f21+f22+f23+f24+f25+f26+f27+f28+f29+f30); + + /* Exact value is not needed, on IA64 it is massively off. */ + if (x < 19503.0 || x > 19504.0) abort(); + return 0; +} diff --git a/test/broken/largestack/930406-1.c b/test/broken/largestack/930406-1.c new file mode 100644 index 0000000..8362678 --- /dev/null +++ b/test/broken/largestack/930406-1.c @@ -0,0 +1,25 @@ +// big local array breaks stack access + +f() +{ + int x = 1; +#if defined(STACK_SIZE) + char big[STACK_SIZE/2]; +#else + char big[0x1000]; +#endif + + ({ + __label__ mylabel; + mylabel: + x++; + if (x != 3) + goto mylabel; + }); + exit(0); +} + +main() +{ + f(); +} diff --git a/test/compile/tcc-fn-unktype.c b/test/compile/tcc-fn-unktype.c new file mode 100644 index 0000000..626be1d --- /dev/null +++ b/test/compile/tcc-fn-unktype.c @@ -0,0 +1,6 @@ +/* using unknown pointer type as the first argument in function implementations caused segfault + because it was mistaken for a K&R-style function declaration */ +int main(unknown *x, void *x) +{ + return 0; +} diff --git a/test/dg/20000108-1.c b/test/dg/20000108-1.c new file mode 100644 index 0000000..9bab52a --- /dev/null +++ b/test/dg/20000108-1.c @@ -0,0 +1,20 @@ +/* Copyright (C) 2000 Free Software Foundation. + + by Alexandre Oliva */ + +/* { dg-do run } */ +/* { dg-options "-O3" } */ + +extern void abort (void); + +void foo () {} /* unused, but essential to trigger the bug */ + +int main () { + int i; + /* use asms to prevent optimizations */ + i = -1; //*/ asm ("" : "=r" (i) : "0" (-1)); + i = 1; //*/ asm ("" : "=r" (i) : "0" (i ? 1 : 2)); + if (i != 1) + abort(); + return 0; +} diff --git a/test/dg/20000623-1.c b/test/dg/20000623-1.c new file mode 100644 index 0000000..bbc8c10 --- /dev/null +++ b/test/dg/20000623-1.c @@ -0,0 +1,20 @@ +/* { dg-do run } */ +/* { dg-options "-O3 -fno-strict-aliasing" } */ + +extern void exit (int); +extern void abort (void); + +struct foos { int l; }; +int foo; +static struct foos *getfoo(void); +int main (void) +{ + struct foos *f = getfoo(); + f->l = 1; + foo = 2; + if (f->l == 1) + abort(); + exit(0); +} +static struct foos *getfoo(void) +{ return (struct foos *)&foo; } diff --git a/test/dg/20000906-1.c b/test/dg/20000906-1.c new file mode 100644 index 0000000..bd723b4 --- /dev/null +++ b/test/dg/20000906-1.c @@ -0,0 +1,78 @@ +/* { dg-do run } */ + +/* Testcase distilled from glibc's nss_parse_service_list in nss/nsswitch.c + It can't be distilled further. Fails with `-O2' for i[3456]86. */ + +/* this simulates a bounded-pointer type. */ +struct ucharp { unsigned char *v, *l, *h; }; + +/* this simulates bounded-pointer check prior to pointer dereference. */ +#define AREF(var, idx) ((((((((var).v+(idx)) < (var).l) \ + || (((var).v+(idx)+1) > (var).h))) \ + && (__builtin_abort (), 0)), \ + (var).v)[(idx)]) + +struct list +{ + struct list *next; +}; + +struct list * +alloc_list (void) +{ + static struct list l; + return &l; +} + +int one = 1; + +void +foo (struct ucharp cp, struct ucharp lp, struct list **nextp) +{ + while (1) + { + struct list *list; + while (AREF (lp, 0) && AREF (cp, AREF (lp, 0))) + ++lp.v; + list = alloc_list (); + while (AREF (cp, AREF (lp, 0))) + ++lp.v; + if (AREF (lp, 0) == one) + do + ++lp.v; + while (AREF (lp, 0) && AREF (cp, AREF (lp, 0))); + /* The above AREF (cp, ...) fails because the pseudo created to + hold cp.v holds garbage, having never been set. + The easiest way to see the problem is to compile wiht `-O2 -da' + then look at *.09.loop. Search for something like this: + + Hoisted regno 183 r/o from (mem/s:SI (reg:SI 16 argp) 10) + Replaced reg 91, deleting init_insn (213). + + Now, look for the use of reg 91, which has no set. */ + + *nextp = list; + nextp = &list->next; + if (!*lp.v) + break; + } +} + +extern void exit (int); + +int +main (void) +{ + static unsigned char cp0[] = "\0\0\0\0"; + struct ucharp cp = { cp0, cp0, cp0 + sizeof (cp0) }; + + static unsigned char lp0[] = "\1\1\0\0"; + struct ucharp lp = { lp0, lp0, lp0 + sizeof (lp0) }; + + struct list list; + struct list *nextp = &list; + + foo (cp, lp, &nextp); + + exit (0); +} diff --git a/test/dg/20001012-1.c b/test/dg/20001012-1.c new file mode 100644 index 0000000..4babc67 --- /dev/null +++ b/test/dg/20001012-1.c @@ -0,0 +1,18 @@ +/* { dg-do run { target fpic } } */ +/* { dg-options "-O2 -fpic" } */ + +extern void abort (void); +extern void exit (int); + +double +foo (void) +{ + return (__extension__ ((union { unsigned long long __l __attribute__((__mode__(__SI__))); float __d; }) { __l: 0x4080UL }).__d); +} + +main () +{ + if (foo() != 1.0) + abort (); + exit (0); +} diff --git a/test/dg/20001023-1.c b/test/dg/20001023-1.c new file mode 100644 index 0000000..10cb272 --- /dev/null +++ b/test/dg/20001023-1.c @@ -0,0 +1,62 @@ +/* { dg-do run } */ +/* { dg-options "-O2 -fomit-frame-pointer" } */ + +extern void abort (void); +extern void exit (int); + +unsigned char a[256], b[256], c[256], d[256]; + +void foo(unsigned char *x, int y, unsigned char *z) +{ +} + +void bar(int x, ...) +{ +} + +void baz(int y) +{ + if (y != 0x10) + abort(); +} + +void test(int x, unsigned char *y) +{ + unsigned char g,h,j, k[5],l[5], m[30]; + int i; + + bar(x, y[0], y[1], y[2], y[3], y[4], y[5], y[6], y[7], y[8], y[9]); + for (i = 5; --i >= 0; ) + k[i] = y[5 + i] ^ a[i] ^ c[i]; + + foo(&m[29], sizeof m, k); + g = d[x] ^ c[x]; + bar(x, d[x], x, c[x]); + baz(g); + for (i = 5, h = 0; --i >= 0; h = y[i]) + { + j = m[25 + i] ^ y[i]; + j = b[j] ^ g; + k[i] = c[j] ^ h; + } + for (i = 5, h = 0; --i >= 0; h = k[i]) + { + j = m[20 + i] ^ k[i]; + j = b[j] ^ g; + l[i] = c[j] ^ h; + } + for (i = 5, h = 0; --i >= 0; h = l[i]) { + j = m[15 + i] ^ l[i]; + j = b[j] ^ g; + j = c[j] ^ h; + k[i] = a[j] ^ c[j]; + } +} + +int main() +{ + c[4] = 0xdc; + d[4] = 0xcc; + test(4, a); + exit(0); +} diff --git a/test/dg/20001108-1.c b/test/dg/20001108-1.c new file mode 100644 index 0000000..682257f --- /dev/null +++ b/test/dg/20001108-1.c @@ -0,0 +1,33 @@ +/* { dg-do run } */ +/* { dg-options "-O2 -fomit-frame-pointer" } */ + +extern void abort (void); +extern void exit (int); + +void die (long) __attribute__ ((noreturn)); + +void die (long e) +{ + abort (); + for (;;); +} + +long foo (double i) +{ + if (i != 2.0) + abort (); + return 26; +} + +long bar (long i, double x) +{ + if (x < 0) die (1); + return foo (x); +} + +main() +{ + if (bar (0, 2.0) != 26) + abort (); + exit (0); +} diff --git a/test/dg/20001117-1.c b/test/dg/20001117-1.c new file mode 100644 index 0000000..baf0691 --- /dev/null +++ b/test/dg/20001117-1.c @@ -0,0 +1,28 @@ +/* { dg-do run } */ +/* { dg-options "-O2 -finstrument-functions" } */ + +extern void abort (void); +extern void exit (int); + +double +foo (double a, double b) +{ + double c; + if (0.0 < a) + c = a; + else if (b > 0.0) + c = 0.0; + else + return 0; + return 2.0 * (b - c); +} + +int main () +{ + if (foo (1.0, 4.0) != 6.0) + abort (); + exit (0); +} + +void __attribute__((no_instrument_function)) __cyg_profile_func_enter(void *this_fn, void *call_site) { } +void __attribute__((no_instrument_function)) __cyg_profile_func_exit(void *this_fn, void *call_site) { } diff --git a/test/dg/20010822-1.c b/test/dg/20010822-1.c new file mode 100644 index 0000000..b1c1cd4 --- /dev/null +++ b/test/dg/20010822-1.c @@ -0,0 +1,44 @@ +/* { dg-do run } */ +/* { dg-options "-Os" } */ + +extern void abort (void); + +void foo (unsigned long x) +{ +} + +typedef struct a { + volatile unsigned int a1, a2, a3, a4, a5; +} *A; +typedef struct { + volatile unsigned int b1, b2, b3, b4, b5; +} *B; +struct C { + void *c1, *c2; + A c3; + unsigned char c4; +}; + +void +bar (struct C *c, unsigned int *d) +{ + *d = *d | 1; + ((c->c4 >= 2) + ? (*(volatile unsigned int *) ((void *)(&((A)c->c3)->a5)) = *d) + : (*(volatile unsigned int *) ((void *)(&((B)c->c3)->b5)) = *d)); + + foo (50); +} + +int main (void) +{ + struct a a; + struct C c; + unsigned int d = 8; + c.c3 = &a; + c.c4 = 0; + bar (&c, &d); + if (a.a5 != 9) + abort (); + return 0; +} diff --git a/test/dg/20010912-1.c b/test/dg/20010912-1.c new file mode 100644 index 0000000..f41f698 --- /dev/null +++ b/test/dg/20010912-1.c @@ -0,0 +1,49 @@ +/* { dg-do run { target fpic } } */ +/* { dg-options "-O2 -fpic" } */ +/* { dg-bogus "\[Uu\]nresolved symbol .(_GLOBAL_OFFSET_TABLE_|\[_.A-Za-z\]\[_.0-9A-Za-z\]*@(PLT|GOT|GOTOFF))" "PIC unsupported" { xfail *-*-netware* } 0 } */ + +extern void abort (void); +extern void exit (int); + +int bar (int x, char **y) +{ + if (x != 56) + abort (); + if (**y != 'a') + abort (); + *y = "def"; + return 1; +} + +int baz (int x, char **y) +{ + if (x != 56) + abort (); + if (**y != 'a') + abort (); + return 26; +} + +int foo (int x, char *y) +{ + int a; + char *b = y; + a = bar (x, &y); + if (a) + { + y = b; + a = baz (x, &y); + } + if (a) + return a; + + baz (x, &y); + return 0; +} + +int main () +{ + if (foo (56, "abc") != 26) + abort (); + exit (0); +} diff --git a/test/dg/20011008-2.c b/test/dg/20011008-2.c new file mode 100644 index 0000000..cf9a161 --- /dev/null +++ b/test/dg/20011008-2.c @@ -0,0 +1,23 @@ +/* { dg-do run } */ +/* { dg-options "-O0" } */ + +extern void abort (void); +extern void exit (int); + +struct { union {int x; int y;} z; int q; } b; +union { struct {int x;} z; int q; } e; + +main() +{ + b.z.y = 10; + b.z.x = 15; + if (b.z.y != 15) + abort(); + + e.z.x = 10; + e.q = 15; + if (e.z.x != 15) + abort(); + + exit(0); +} diff --git a/test/dg/20020206-1.c b/test/dg/20020206-1.c new file mode 100644 index 0000000..837718b --- /dev/null +++ b/test/dg/20020206-1.c @@ -0,0 +1,45 @@ +/* This code is from the beginning of combine_reloads in reload.c in + GCC 3.1-20020117, with simplifications. It compiled incorrectly + for -O2 -fprefetch-loop-arrays for ix86 targets. */ + +/* { dg-do run } */ +/* { dg-options "-O2 -fprefetch-loop-arrays -w" } */ +/* { dg-options "-O2 -fprefetch-loop-arrays -mtune=pentium3 -w" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */ + + +struct reload +{ + int first_member; + int out; + int final_member; +}; + +int n_reloads; +struct reload rld[10]; + +static int +combine_reloads () +{ + int i; + int output_reload = -1; + int secondary_out = -1; + + for (i = 0; i < n_reloads; i++) + if (rld[i].out != 0) + { + if (output_reload >= 0) + return output_reload; + output_reload = i; + } + return output_reload; +} + +int +main () +{ + n_reloads = 4; + rld[2].out = 2; + if (combine_reloads () != 2) + abort (); + exit (0); +} diff --git a/test/dg/20020210-1.c b/test/dg/20020210-1.c new file mode 100644 index 0000000..369963b --- /dev/null +++ b/test/dg/20020210-1.c @@ -0,0 +1,28 @@ +/* This used to fail on H8/300 due to incorrect specification of pushi1. */ + +/* { dg-do run } */ +/* { dg-options "-O2" } */ +/* { dg-options "-O2 -fomit-frame-pointer" { target h8300-*-* } } */ + +extern void abort (void); +extern void exit (int); + +void +bar (int a, int b, int c, int d, int e) +{ + if (d != 1) + abort (); +} + +void +foo (int a, int b, int c, int d, int e) +{ + bar (a, b, c, d, e); +} + +int +main () +{ + foo (0, 0, 0, 1, 2); + exit (0); +} diff --git a/test/dg/20020219-1.c b/test/dg/20020219-1.c new file mode 100644 index 0000000..3664949 --- /dev/null +++ b/test/dg/20020219-1.c @@ -0,0 +1,47 @@ +/* PR c/4389 + This testcase failed because host_integerp (x, 0) was returning + 1 even for constants bigger than 2^31. It fails under under hppa + hpux without -mdisable-indexing because the pointer x - 1 is used + as the base address of an indexed load. Because the struct A is not + actually allocated, x - 1 lies in the text segment and this causes + the wrong space register to be selected for the load. It fails on + IA64 hpux in ILP32 mode because extending x - 1 before adding the + array offset gives a different answer then adding first and then + extending. The underlying problem is the same as with hppa, x - 1 is + not a legal data address. */ +/* { dg-do run } */ +/* { dg-options "-O2" } */ +/* { dg-options "-O2 -mdisable-indexing" { target hppa*-*-hpux* } } */ +/* { dg-skip-if "" { "ia64-*-hpux*" } "*" "-mlp64" } */ + +/* Disable the test entirely for 16-bit targets. */ +#if __INT_MAX__ > 32767 + +extern void abort (void); +extern void exit (int); +struct A { + int a[10000][10000]; +}; +int b[2] = { 213151, 0 }; + +void foo (struct A *x, int y) +{ + if (x->a[9999][9999] != x->a[y][y]) + abort (); + if (x->a[9999][9999] != 213151) + abort (); +} + +int main (void) +{ + struct A *x; + asm ("" : "=r" (x) : "0" (&b[1])); + foo (x - 1, 9999); + exit (0); +} + +#else + +int main () { return 0; } + +#endif /* __INT_MAX__ */ diff --git a/test/dg/20020310-1.c b/test/dg/20020310-1.c new file mode 100644 index 0000000..bdd2967 --- /dev/null +++ b/test/dg/20020310-1.c @@ -0,0 +1,54 @@ +/* PR optimization/5844 + This testcase was miscompiled because of an rtx sharing bug. */ +/* { dg-do run } */ +/* { dg-options "-O2" } */ +/* { dg-options "-O2 -mtune=i586" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */ + +struct A +{ + struct A *a; + int b; +}; + +struct B +{ + struct A *c; + unsigned int d; +}; + +struct A p = { &p, -1 }; +struct B q = { &p, 0 }; + +extern void abort (void); +extern void exit (int); + +struct B * +foo (void) +{ + return &q; +} + +void +bar (void) +{ + struct B *e = foo (); + struct A *f = e->c; + int g = f->b; + + if (++g == 0) + { + e->d++; + e->c = f->a; + } + + f->b = g; +} + +int +main () +{ + bar (); + if (p.b != 0 || q.d != 1 || q.c != &p) + abort (); + exit (0); +} diff --git a/test/dg/20020426-2.c b/test/dg/20020426-2.c new file mode 100644 index 0000000..5ddb348 --- /dev/null +++ b/test/dg/20020426-2.c @@ -0,0 +1,177 @@ +/* PR optimization/6475 + Distilled from zlib sources. */ +/* { dg-do run } */ +/* { dg-options "-O2" } */ +/* { dg-options "-O2 -frename-registers -fomit-frame-pointer -fPIC -mtune=i686" { target { { i?86-*-* x86_64-*-* } && { ilp32 && fpic } } } } */ +/* { dg-bogus "\[Uu\]nresolved symbol .(_GLOBAL_OFFSET_TABLE_|\[_.A-Za-z\]\[_.0-9A-Za-z\]*@(PLT|GOT|GOTOFF))" "PIC unsupported" { xfail *-*-netware* } 0 } */ + +extern void exit (int); + +typedef struct +{ + union + { + struct + { + unsigned char a3; + unsigned char a4; + } a2; + unsigned int a5; + } a0; + unsigned int a1; +} A; + +static int +foo (unsigned int *b, unsigned int n, unsigned int s, const unsigned int *d, + const unsigned int *e, A **t, unsigned int *m, A *hp, unsigned int *hn, + unsigned int *v) +{ + unsigned int a, c[15 + 1], f; + int g, h; + unsigned int i, j, k; + int l; + unsigned int ee; + unsigned int *p; + A *q, r, *u[15]; + int w; + unsigned int x[15 + 1], *xx; + int y; + unsigned int z; + p = c; + *p++ = 0; *p++ = 0; *p++ = 0; *p++ = 0; + *p++ = 0; *p++ = 0; *p++ = 0; *p++ = 0; + *p++ = 0; *p++ = 0; *p++ = 0; *p++ = 0; + *p++ = 0; *p++ = 0; *p++ = 0; *p++ = 0; + p = b; + i = n; + do + c[*p++]++; + while (--i); + if (c[0] == n) + { + *t = (A *) 0; + *m = 0; + return 0; + } + l = *m; + for (j = 1; j <= 15; j++) + if (c[j]) + break; + k = j; + if ((unsigned int) l < j) + l = j; + for (i = 15; i; i--) + if (c[i]) + break; + g = i; + if ((unsigned int) l > i) + l = i; + *m = l; + for (y = 1 << j; j < i; j++, y <<= 1) + if ((y -= c[j]) < 0) + return -3; + if ((y -= c[i]) < 0) + return -3; + c[i] += y; + x[1] = j = 0; + p = c + 1; + xx = x + 2; + while (--i) + *xx++ = (j += *p++); + p = b; + i = 0; + do + if ((j = *p++) != 0) + v[x[j]++] = i; + while (++i < n); + n = x[g]; + x[0] = i = 0; + p = v; + h = -1; + w = -l; + u[0] = (A *) 0; + q = (A *) 0; + z = 0; + for (; k <= g; k++) + { + a = c[k]; + while (a--) + { + while (k > w + l) + { + h++; + w += l; + z = g - w; + z = z > (unsigned int) l ? l : z; + if ((f = 1 << (j = k - w)) > a + 1) + { + f -= a + 1; + xx = c + k; + if (j < z) + while (++j < z) + { + if ((f <<= 1) <= *++xx) + break; + f -= *xx; + } + } + z = 1 << j; + if (*hn + z > 1440) + return -3; + u[h] = q = hp + *hn; + *hn += z; + if (h) + { + x[h] = i; + r.a0.a2.a4 = (unsigned char) l; + r.a0.a2.a3 = (unsigned char) j; + j = i >> (w - l); + r.a1 = (unsigned int) (q - u[h - 1] - j); + u[h - 1][j] = r; + } + else + *t = q; + } + r.a0.a2.a4 = (unsigned char) (k - w); + if (p >= v + n) + r.a0.a2.a3 = 128 + 64; + else if (*p < s) + { + r.a0.a2.a3 = (unsigned char) (*p < 256 ? 0 : 32 + 64); + r.a1 = *p++; + } + else + { + r.a0.a2.a3 = (unsigned char) (e[*p - s] + 16 + 64); + r.a1 = d[*p++ - s]; + } + f = 1 << (k - w); + for (j = i >> w; j < z; j += f) + q[j] = r; + for (j = 1 << (k - 1); i & j; j >>= 1) + i ^= j; + i ^= j; + ee = (1 << w) - 1; + while ((i & ee) != x[h]) + { + h--; + w -= l; + ee = (1 << w) - 1; + } + } + } + return y != 0 && g != 1 ? (-5) : 0; +} + +unsigned int a[19] = { 3, 4, 0, 2, 2, [17] = 3, 3 }; +unsigned int d[19]; +A h[1440]; + +int +main (void) +{ + unsigned int b = 0, c = 0; + A *e = 0; + foo (a, 19, 19, 0, 0, &e, &b, h, &c, d); + exit (0); +} diff --git a/test/dg/20020517-1.c b/test/dg/20020517-1.c new file mode 100644 index 0000000..032ccd2 --- /dev/null +++ b/test/dg/20020517-1.c @@ -0,0 +1,28 @@ +/* This testcase caused ICE in do_SUBST on IA-32, because 0xf6 constant + was not sign-extended for QImode. */ +/* { dg-do run } */ +/* { dg-options "-O2" } */ +/* { dg-options "-O2 -mtune=i686" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */ + +#include + +void abort (void); +void exit (int); + +void foo (void) +{ + int i; + char *p; + + p = (char *) &i; + *p = -10; + if (* (unsigned char *) p != 0x100 - 10) + abort (); +} + +int main (void) +{ + if (UCHAR_MAX == 255) + foo (); + exit (0); +} diff --git a/test/dg/20020525-1.c b/test/dg/20020525-1.c new file mode 100644 index 0000000..7db44f0 --- /dev/null +++ b/test/dg/20020525-1.c @@ -0,0 +1,24 @@ +/* PR optimization/6703 + Origin: Glen Nakamura */ +/* { dg-do run } */ +/* { dg-options "-O2" } */ + +extern void abort (void); +extern void exit (int); + +void foo (int *x, int y) +{ + __builtin_memset (x, 0, y); +} + +int main () +{ + int x[2] = { -1, -1 }; + + if (x[1] != -1) + abort (); + foo (x, sizeof (int) + 1); + if (x[1] == -1) + abort (); + exit (0); +} diff --git a/test/dg/20020607-1.c b/test/dg/20020607-1.c new file mode 100644 index 0000000..afad78d --- /dev/null +++ b/test/dg/20020607-1.c @@ -0,0 +1,40 @@ +/* PR middle-end/6950 + gcc 3.0.4 mistakenly set lhs.low to 0 at the beginning of the num_eq + expansion; it should use a temporary. +/* { dg-do run } */ + +typedef struct cpp_num cpp_num; +struct cpp_num +{ + long high; + long low; + char overflow; +}; + +#define num_eq(num1, num2) (num1.low == num2.low && num1.high == num2.high) + +static cpp_num +num_equality_op (lhs, rhs) + cpp_num lhs, rhs; +{ + lhs.low = num_eq (lhs, rhs); + lhs.high = 0; + lhs.overflow = 0; + return lhs; +} + +int main() +{ + cpp_num a = { 1, 2 }; + cpp_num b = { 3, 4 }; + + cpp_num result = num_equality_op (a, b); + if (result.low) + return 1; + + result = num_equality_op (a, a); + if (!result.low) + return 2; + + return 0; +} diff --git a/test/dg/20020607-2.c b/test/dg/20020607-2.c new file mode 100644 index 0000000..239aa9b --- /dev/null +++ b/test/dg/20020607-2.c @@ -0,0 +1,74 @@ +/* Copyright (C) 2002 Free Software Foundation. + + Test for correctness of floating point comparisons. + + Written by Roger Sayle, 3rd June 2002. */ + +/* { dg-do run } */ +/* { dg-options "-O2 -ffast-math" } */ + +extern void abort (void); + +int test1 (double x, int ok) +{ + if ((x - 1.0) > 0.0) + { + if (!ok) abort (); + } + else + if (ok) abort (); +} + +int test1f (float x, int ok) +{ + if ((x - 1.0f) > 0.0f) + { + if (!ok) abort (); + } + else + if (ok) abort (); +} + +int test2 (double x, int ok) +{ + if ((x + 1.0) < 0.0) + { + if (!ok) abort (); + } + else + if (ok) abort (); +} + +int test2f (float x, int ok) +{ + if ((x + 1.0f) < 0.0f) + { + if (!ok) abort (); + } + else + if (ok) abort (); +} + + +int +main () +{ + test1 (-2.0, 0); + test1 ( 0.0, 0); + test1 ( 2.0, 1); + + test1f (-2.0f, 0); + test1f ( 0.0f, 0); + test1f ( 2.0f, 1); + + test2 (-2.0, 1); + test2 ( 0.0, 0); + test2 ( 2.0, 0); + + test2f (-2.0f, 1); + test2f ( 0.0f, 0); + test2f ( 2.0f, 0); + + return 0; +} + diff --git a/test/dg/20021014-1.c b/test/dg/20021014-1.c new file mode 100644 index 0000000..c0ba296 --- /dev/null +++ b/test/dg/20021014-1.c @@ -0,0 +1,27 @@ +/* { dg-do run } */ +/* { dg-require-profiling "-p" } */ +/* { dg-options "-O2 -p" } */ +/* { dg-options "-O2 -p -static" { target hppa*-*-hpux* } } */ +/* { dg-error "profiler" "No profiler support" { target xstormy16-*-* } 0 } */ +/* { dg-error "" "consider using `-pg' instead of `-p' with gprof(1)" { target *-*-freebsd* } 0 } */ + +extern void abort (void); +extern void exit (int); + + int bar (int x) + { + return x + 3; + } +int foo (void) +{ + return bar (1) + bar (2); +} + +int main (void) +{ + if (foo () != 9) + abort (); + exit (0); +} + +/* { dg-final { cleanup-profile-file } } */ diff --git a/test/dg/20021018-1.c b/test/dg/20021018-1.c new file mode 100644 index 0000000..f1d296d --- /dev/null +++ b/test/dg/20021018-1.c @@ -0,0 +1,30 @@ +/* { dg-do run { target fpic } } */ +/* { dg-options "-O2 -fpic" } */ +/* { dg-bogus "\[Uu\]nresolved symbol .(_GLOBAL_OFFSET_TABLE_|\[_.A-Za-z\]\[_.0-9A-Za-z\]*@(PLT|GOT|GOTOFF))" "PIC unsupported" { xfail *-*-netware* } 0 } */ + +extern void abort (void); +extern void exit (int); + +#if __INT_MAX__ >= 2147483647L +static const long foo [10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + +long __attribute__((noinline)) +bar (int x) +{ + return foo [x - 0x6ffffffa]; +} + +int +main (void) +{ + if (bar (0x6ffffffc) != 2) + abort (); + exit (0); +} +#else +int +main (void) +{ + exit (0); +} +#endif diff --git a/test/dg/20030225-1.c b/test/dg/20030225-1.c new file mode 100644 index 0000000..7f32fdc --- /dev/null +++ b/test/dg/20030225-1.c @@ -0,0 +1,102 @@ +/* PR target/9732 + This testcase segfaulted on PPC because PIC_OFFSET_TABLE_REGNUM was no + fixed register. + Distilled from the xvid sources by Guillaume Morin + and Benjamin Herrenschmidt . */ +/* { dg-do run { target fpic } } */ +/* { dg-options "-O2 -fPIC" } */ +/* { dg-bogus "\[Uu\]nresolved symbol .(_GLOBAL_OFFSET_TABLE_|\[_.A-Za-z\]\[_.0-9A-Za-z\]*@(PLT|GOT|GOTOFF))" "PIC unsupported" { xfail *-*-netware* } 0 } */ + +extern void exit (int); + +#define W1 2841 /* 2048*sqrt(2)*cos(1*pi/16) */ +#define W2 2676 /* 2048*sqrt(2)*cos(2*pi/16) */ +#define W3 2408 /* 2048*sqrt(2)*cos(3*pi/16) */ +#define W5 1609 /* 2048*sqrt(2)*cos(5*pi/16) */ +#define W6 1108 /* 2048*sqrt(2)*cos(6*pi/16) */ +#define W7 565 /* 2048*sqrt(2)*cos(7*pi/16) */ + + +/* private data */ +static short iclip[1024]; /* clipping table */ +static short *iclp; + +void +idct_int32(short *const block) +{ + static short *blk; + static long i; + static long X0, X1, X2, X3, X4, X5, X6, X7, X8; + + for (i = 0; i < 8; i++) /* idct columns */ + { + blk = block + i; + /* shortcut */ + if (! ((X1 = (blk[8 * 4] << 8)) | (X2 = blk[8 * 6]) + | (X3 = blk[8 * 2]) | (X4 = blk[8 * 1]) | (X5 = blk[8 * 7]) + | (X6 = blk[8 * 5]) | (X7 = blk[8 * 3]))) + { + blk[8 * 0] = blk[8 * 1] = blk[8 * 2] = + blk[8 * 3] = blk[8 * 4] = + blk[8 * 5] = blk[8 * 6] = blk[8 * 7] = + iclp[(blk[8 * 0] + 32) >> 6]; + continue; + } + X0 = (blk[8 * 0] << 8) + 8192; + + /* first stage */ + X8 = W7 * (X4 + X5) + 4; + X4 = (X8 + (W1 - W7) * X4) >> 3; + X5 = (X8 - (W1 + W7) * X5) >> 3; + X8 = W3 * (X6 + X7) + 4; + X6 = (X8 - (W3 - W5) * X6) >> 3; + X7 = (X8 - (W3 + W5) * X7) >> 3; + + /* second stage */ + X8 = X0 + X1; + X0 -= X1; + X1 = W6 * (X3 + X2) + 4; + X2 = (X1 - (W2 + W6) * X2) >> 3; + X3 = (X1 + (W2 - W6) * X3) >> 3; + X1 = X4 + X6; + X4 -= X6; + X6 = X5 + X7; + X5 -= X7; + + /* third stage */ + X7 = X8 + X3; + X8 -= X3; + X3 = X0 + X2; + X0 -= X2; + X2 = (181 * (X4 + X5) + 128) >> 8; + X4 = (181 * (X4 - X5) + 128) >> 8; + + /* fourth stage */ + blk[8 * 0] = iclp[(X7 + X1) >> 14]; + blk[8 * 1] = iclp[(X3 + X2) >> 14]; + blk[8 * 2] = iclp[(X0 + X4) >> 14]; + blk[8 * 3] = iclp[(X8 + X6) >> 14]; + blk[8 * 4] = iclp[(X8 - X6) >> 14]; + blk[8 * 5] = iclp[(X0 - X4) >> 14]; + blk[8 * 6] = iclp[(X3 - X2) >> 14]; + blk[8 * 7] = iclp[(X7 - X1) >> 14]; + } +} /* end function idct_int32(block) */ + + +int main(void) { + int i; + unsigned short tab[64]; + + for (i = 0 ; i < 64 ; ++i) + { + tab[i] = (1+(int) (65535)*8000/(2147483647+1.0)); + } + + iclp = iclip + 512; + for (i = -512; i < 512; i++) + iclp[i] = (i < -256) ? -256 : ((i > 255) ? 255 : i); + + idct_int32((short *) tab); + exit (0); +} diff --git a/test/dg/20030323-1.c b/test/dg/20030323-1.c new file mode 100644 index 0000000..8a563ec --- /dev/null +++ b/test/dg/20030323-1.c @@ -0,0 +1,24 @@ +/* { dg-do run } */ + +/* PR c/8224 */ +/* Contributed by Mikulas Patocka */ + +extern void abort (void); + +unsigned f (int x) +{ + return (unsigned) (x / 2) / 2; +} + +unsigned f1 (int x) +{ + unsigned xx = x / 2; + return xx / 2; +} + +int main () +{ + if (f1 (-5) != f (-5)) + abort (); + return 0; +} diff --git a/test/dg/20030324-1.c b/test/dg/20030324-1.c new file mode 100644 index 0000000..67db669 --- /dev/null +++ b/test/dg/20030324-1.c @@ -0,0 +1,39 @@ +/* { dg-do run } */ +/* { dg-options "-O -fstrict-aliasing -fgcse" } */ + +/* PR optimization/10087 */ +/* Contributed by Peter van Hoof */ + +extern void abort(void); + +void b(int*,int*); + +typedef struct { + double T1; + char c; +} S; + +int main(void) +{ + int i,j; + double s; + + S x1[2][2]; + S *x[2] = { x1[0], x1[1] }; + S **E = x; + + for( i=0; i < 2; i++ ) + for( j=0; j < 2; j++ ) + E[j][i].T1 = 1; + + for( i=0; i < 2; i++ ) + for( j=0; j < 2; j++ ) + s = E[j][i].T1; + + b(&j,&i); + if (s != 1) + abort (); + return 0; +} + +void b(int *i, int *j) {} diff --git a/test/dg/20030414-2.c b/test/dg/20030414-2.c new file mode 100644 index 0000000..e571823 --- /dev/null +++ b/test/dg/20030414-2.c @@ -0,0 +1,39 @@ +/* Copyright (C) 2003 Free Software Foundation. + + Check that constant folding (c1 - x) op c2 into x swap(op) c1-c2 + doesn't break anything. + + Written by Roger Sayle, 27th March 2003. */ + +/* { dg-do run } */ +/* { dg-options "-O2 -ffast-math" } */ + +extern void abort (void); +extern float fabs(float); + +int foo(double x) +{ + return (10.0 - x) > 3.0; +} + +int bar (double x) +{ + return (10.0 - x) == 5.0; +} + +int main() +{ + if (foo (8.0)) + abort (); + + if (! foo (6.0)) + abort (); + + if (bar (1.0)) + exit (1); + + if (! bar (5.0)) + exit (2); + return 0; +} + diff --git a/test/dg/20030612-1.c b/test/dg/20030612-1.c new file mode 100644 index 0000000..f087512 --- /dev/null +++ b/test/dg/20030612-1.c @@ -0,0 +1,24 @@ +/* { dg-do run } */ +/* { dg-options "-O2" } */ + +extern void abort (void); + +int A, B; + +void foo() +{ + long x = 3; + (void)({ + A = B + x + ((1) - 1); + return; /* { dg-warning "statement-expressions should end with a non-void expression" "" { xfail *-*-* } } */ + }); +} + +main() +{ + B = 5; + foo(); + if (A != 8) + abort (); + return 0; +} diff --git a/test/dg/20030805-1.c b/test/dg/20030805-1.c new file mode 100644 index 0000000..6297c5d --- /dev/null +++ b/test/dg/20030805-1.c @@ -0,0 +1,23 @@ +/* Test that gcc understands that the call to g might clobber i. */ + +/* { dg-do run } */ +/* { dg-options "-O2" } */ + +__inline int f () +{ + static int i; + int i2 = i; + i = i2 + 1; + return i; +} + +int g () { return f (); } + +int main () +{ + if (f() != 1 + || g() != 2 + || f() != 3) + return 1; + return 0; +} diff --git a/test/dg/20030826-1.c b/test/dg/20030826-1.c new file mode 100644 index 0000000..b344ad2 --- /dev/null +++ b/test/dg/20030826-1.c @@ -0,0 +1,33 @@ +/* Copyright (C) 2003 Free Software Foundation. + + Check that constant folding of mathematical expressions doesn't + break anything. + + Written by Roger Sayle, 24th August 2003. */ + +/* { dg-do run } */ +/* { dg-options "-O2 -ffast-math" } */ + +void abort(void); + +double foo(double x) +{ + return 12.0/(x*3.0); +} + +double bar(double x) +{ + return (3.0/x)*4.0; +} + +int main() +{ + if (foo(2.0) != 2.0) + abort (); + + if (bar(2.0) != 6.0) + abort (); + + return 0; +} + diff --git a/test/dg/20031202-1.c b/test/dg/20031202-1.c new file mode 100644 index 0000000..2671947 --- /dev/null +++ b/test/dg/20031202-1.c @@ -0,0 +1,44 @@ +/* { dg-do run } */ +/* { dg-options "-O2" } */ +/* { dg-options "-O2 -mtune=i686" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */ + +extern void abort (void); +extern void exit (int); + +struct A { char p[6]; } __attribute__((packed)); +struct B { + struct A a; + void * const b; + struct A const * const c; + struct A const *d; +}; + +char v; + +int __attribute__((noinline)) +foo (struct B *b) +{ + int i; + for (i = 0; i < 6; ++i) + if (b->a.p[i]) + abort (); + if (b->b != &v || b->c || b->d) + abort (); + return 12; +} + +int __attribute__((noinline)) +bar (void *x) +{ + //__asm __volatile ("" : "=r" (x) : "0" (x)); + struct B y = { .b = x, .c = (void *) 0 }; + return foo (&y) + 1; +} + +int +main (void) +{ + if (bar (&v) != 13) + abort (); + exit (0); +} diff --git a/test/dg/20031216-1.c b/test/dg/20031216-1.c new file mode 100644 index 0000000..7c706d8 --- /dev/null +++ b/test/dg/20031216-1.c @@ -0,0 +1,39 @@ +/* This used to abort due to a loop bug on s390*. */ + +/* { dg-do run } */ +/* { dg-options "-O2" } */ +/* { dg-options "-O2 -fPIC" { target s390*-*-* } } */ + +extern void abort (void); + +int count = 0; +char *str; + +void test (int flag) +{ + char *p; + + for (;;) + { + if (count > 5) + return; + + p = "test"; + + if (flag) + count++; + + str = p; + } +} + +int main (void) +{ + test (1); + + if (str[0] != 't') + abort (); + + return 0; +} + diff --git a/test/dg/20040305-2.c b/test/dg/20040305-2.c new file mode 100644 index 0000000..ffaf353 --- /dev/null +++ b/test/dg/20040305-2.c @@ -0,0 +1,49 @@ +/* PR target/14262 */ +/* { dg-do run } */ + +extern void abort (void); + +typedef char ACS; +typedef char LSM; +typedef char PANEL; +typedef char DRIVE; +typedef struct { + ACS acs; + LSM lsm; +} LSMID; +typedef struct { + LSMID lsm_id; + PANEL panel; +} PANELID; +typedef struct { + PANELID panel_id; + DRIVE drive; +} DRIVEID; + +void sub (DRIVEID driveid) +{ + if (driveid.drive != 1) + abort (); + if (driveid.panel_id.panel != 2) + abort (); + if (driveid.panel_id.lsm_id.lsm != 3) + abort (); + if (driveid.panel_id.lsm_id.acs != 4) + abort (); +} + +int main(void) +{ + DRIVEID driveid; + + driveid.drive = 1; + driveid.panel_id.panel = 2; + driveid.panel_id.lsm_id.lsm = 3; + driveid.panel_id.lsm_id.acs = 4; + + sub(driveid); + + return 0; +} + + diff --git a/test/dg/20040309-1.c b/test/dg/20040309-1.c new file mode 100644 index 0000000..7361507 --- /dev/null +++ b/test/dg/20040309-1.c @@ -0,0 +1,17 @@ +/* Test integer mod on ia64. There was a bug in the inline integer + division code. */ + +/* { dg-do run } */ +/* { dg-options "-minline-int-divide-max-throughput" { target ia64-*-* } } */ + +extern void abort (void); + +volatile int i = 10; +volatile int j = 10; + +int main() +{ + int k = i % j; + if (k != 0) abort(); + return 0; +} diff --git a/test/dg/20040331-1.c b/test/dg/20040331-1.c new file mode 100644 index 0000000..4cef3d3 --- /dev/null +++ b/test/dg/20040331-1.c @@ -0,0 +1,14 @@ +/* { dg-do run } */ +/* { dg-options "-O2 -fwrapv" } */ + +extern void abort (void); +extern void exit (int); + +int +main (void) +{ + struct { int count: 2; } s = { -2 }; + while (s.count-- != -2) + abort (); + exit (0); +} diff --git a/test/dg/20041219-1.c b/test/dg/20041219-1.c new file mode 100644 index 0000000..faa1047 --- /dev/null +++ b/test/dg/20041219-1.c @@ -0,0 +1,47 @@ +/* PR18191 Struct member is not getting default-initialized. + Origin: Grigory Zagorodnev */ + +/* { dg-do run } */ + +//extern int printf (__const char *__restrict __format, ...); + +typedef struct S { + const char* s; + int i; +} S; + +void +foo (void) +{ + S dummy[2]; + unsigned i; + + /* Put some garbage on the stack. */ + for (i = 0; i < sizeof(dummy); i++) + ((char *)&dummy)[i] = -1; +} + +int +bar (void) +{ + /* Allocate object on the stack. */ + S obj[2] = { {"m0"}, {"m1"} }; + + /* Assume fields those not explicitly initialized + are default initialized to 0 [8.5.1/7 and 8.5/5]. */ + if (obj[0].i == 0) + return 0; + else + { + /* printf("Failed: obj[0].i == '%d', expecting '0'\n", obj[0].i); */ + return 1; + } +} + +int +main (void) +{ + foo(); + return bar(); +} + diff --git a/test/dg/20050603-2.c b/test/dg/20050603-2.c new file mode 100644 index 0000000..363e3cd --- /dev/null +++ b/test/dg/20050603-2.c @@ -0,0 +1,21 @@ +/* { dg-do run } */ +/* { dg-options "-O2" } */ +#include +struct s { + unsigned short f: 16; + unsigned short y: 8; + unsigned short g: 2; + unsigned int x; +}; + +void set (struct s*, int) __attribute__((noinline)); +void set (struct s* p, int flags) { + p->g = flags << 1; +} +main() { + struct s foo = {0 , 0, 3, 0}; + set (&foo, -1); + if (foo.g != 2) + abort(); + return 0; +} diff --git a/test/dg/20050922-1.c b/test/dg/20050922-1.c new file mode 100644 index 0000000..365b639 --- /dev/null +++ b/test/dg/20050922-1.c @@ -0,0 +1,48 @@ +/* This revealed a bug when rotates are expanded into + two shifts. */ + +/* { dg-do run } */ +/* { dg-options "-O1 -std=c99" } */ + +#include + +#if __INT_MAX__ == 2147483647 +typedef unsigned int uint32_t; +#elif __LONG_MAX__ == 2147483647 +typedef unsigned long uint32_t; +#else +//#error unable to find 32-bit integer type +typedef unsigned long long uint32_t; +#endif + +uint32_t +f (uint32_t *S, int j) +{ + uint32_t A, B, k, L[2] = {1234, 5678}; + int i, m; + + A = B = 0; + for (i = 0; i < j; i++) + { + k = (S[i] + A + B) & 0xffffffffL; + A = S[i] = + ((k << (3 & 0x1f)) | ((k & 0xffffffff) >> (32 - (3 & 0x1f)))); + + m = (int) (A + B); + k = (L[i] + A + B) & 0xffffffffL; + B = L[i] = + ((k << (m & 0x1f)) | ((k & 0xffffffff) >> (32 - (m & 0x1f)))); + } + return L[0] + L[1]; +} + +int +main () +{ + uint32_t S[2] = {0xffff, 0xffffff}; + + if (f (S,2)!= 1392607300) + abort(); + + return 0; +} diff --git a/test/dg/20050922-2.c b/test/dg/20050922-2.c new file mode 100644 index 0000000..39073f1 --- /dev/null +++ b/test/dg/20050922-2.c @@ -0,0 +1,34 @@ +/* 20050922-1.c does not trigger the expand_shift rotate bug on sh4-elf, but + this does. */ + +/* { dg-do run } */ +/* { dg-options "-O1 -std=c99" } */ + +#include + +#if __INT_MAX__ == 2147483647 +typedef unsigned int uint32_t; +#elif __LONG_MAX__ == 2147483647 +typedef unsigned long uint32_t; +#else +//#error unable to find 32-bit integer type +typedef unsigned long long uint32_t; +#endif + +#define rotl(x,n) (((x) << ((int)(n))) | ((x) >> (32 - (int)(n)))) + +uint32_t +f (uint32_t a, uint32_t b) +{ + + b = rotl (a, b & 31); + return b; +} + +int +main () +{ + if (f(2,31) != 1) + abort (); + exit (0); +} diff --git a/test/dg/20060425-1.c b/test/dg/20060425-1.c new file mode 100644 index 0000000..7d899b2 --- /dev/null +++ b/test/dg/20060425-1.c @@ -0,0 +1,38 @@ +/* { dg-do run } */ +/* { dg-options "-O1" } */ + +/* This failed because if conversion didn't handle insv patterns properly. */ + +void abort (void); + +union y +{ + int a; + unsigned short b; +}; + +void __attribute__ ((noinline)) +bar (unsigned short u, union y v) +{ + if (u != 1) + abort (); +} + +void __attribute__ ((noinline)) +foo (int check) +{ + union y x; + + if (check != 0) + x.b = 1; + else + x.b = 2; + bar (x.b, x); +} + +int +main () +{ + foo (1); + return 0; +} diff --git a/test/dg/20070507-1.c b/test/dg/20070507-1.c new file mode 100644 index 0000000..2884d1a --- /dev/null +++ b/test/dg/20070507-1.c @@ -0,0 +1,103 @@ +/* This failed on s390x due to bug in loop.c. + loop.c failed to remove a REG_EQUAL note when + hoisting an insn from a loop body. */ + +/* { dg-options "-O3 -fPIC" } */ +/* { dg-do run { target fpic } } */ + +typedef __SIZE_TYPE__ size_t; +int memcmp(const void *s1, const void *s2, size_t n); + +typedef struct +{ + char name[30]; + int a; +} LOCAL; + +int global = 0; +int sy = 1; +int subroutine_offset; + +LOCAL local = { "local", 0 }; +LOCAL keywords = { "keywords", 1 }; +int local_table = 0; +int keywords_table = 0; + +void __attribute__((noinline)) bar (char *p_buffer) +{ + p_buffer[255] = 1; +} + +int __attribute__((noinline)) foo (char *p_str1) +{ + global = 1; + return 1; +} + +int __attribute__((noinline)) loop_next (int *p_table, char *p_table_head) +{ + static loop_next = 0; + + if (loop_next == 1) + return 1; + + loop_next = 1; + return 0; +} + +int +main () +{ + char buffer[256]; + int ende = 0; + int index; + int local_base = 2; + + keywords.a = 1; + for (sy = 0;; sy++) + { + for (index = 1;;) + { + bar (buffer); + if (buffer[sy] != 0) + { + ende = 1; + break; + }; + if (foo (buffer)) + { + keywords.a += index - 1; + break; + } + index++; + } + if (ende) + break; + } + + subroutine_offset = 0; + + for (;;) + { + if (loop_next (&keywords_table, (char*)&keywords)) + break; + + if ((!memcmp (keywords.name, "+++", 3))) + local_base = 100; + else + local_base = 0; + + if ((!memcmp (keywords.name, "+++", 3))) + subroutine_offset += local_table; + + for (;;) + { + if (loop_next (&local_table, (char*)&local)) + break;; + if ((local.a == 0)) + continue;; + foo (local.name); + } + } + return 0; +} diff --git a/test/dg/20070725-1.c b/test/dg/20070725-1.c new file mode 100644 index 0000000..07b609c --- /dev/null +++ b/test/dg/20070725-1.c @@ -0,0 +1,64 @@ +/* This used to fail due to a ifcombine problem wrecking 64bit + checks. Fixed with rev. 126876. */ +/* { dg-do run } */ +/* { dg-options "-O1" } */ + +struct tree_base +{ + unsigned code:16; + + unsigned side_effects_flag:1; + unsigned constant_flag:1; + unsigned addressable_flag:1; + unsigned volatile_flag:1; + unsigned readonly_flag:1; + unsigned unsigned_flag:1; + unsigned asm_written_flag:1; + unsigned nowarning_flag:1; + + unsigned used_flag:1; + unsigned nothrow_flag:1; + unsigned static_flag:1; + unsigned public_flag:1; + unsigned private_flag:1; + unsigned protected_flag:1; + unsigned deprecated_flag:1; + unsigned invariant_flag:1; + + unsigned lang_flag_0:1; + unsigned lang_flag_1:1; + unsigned lang_flag_2:1; + unsigned lang_flag_3:1; + unsigned lang_flag_4:1; + unsigned lang_flag_5:1; + unsigned lang_flag_6:1; + unsigned visited:1; + + unsigned spare1:16; + unsigned spare2:8; + unsigned long a; +}; + +int +foo (struct tree_base *rhs) +{ + if (({const struct tree_base* __t = (rhs); __t;})->readonly_flag + && (rhs)->static_flag) + return 1; + + return 0; +} + +extern void abort (void); + +int +main () +{ + struct tree_base t; + + t.readonly_flag = t.static_flag = 0; + if (foo (&t)) + abort (); + + return 0; +} diff --git a/test/dg/980523-1.c b/test/dg/980523-1.c new file mode 100644 index 0000000..970b57c --- /dev/null +++ b/test/dg/980523-1.c @@ -0,0 +1,53 @@ +/* { dg-do run { target fpic } } */ +/* { dg-options "-O2 -fpic" } */ + +extern void exit (int); + +void foo1(int a, char *b, int c) +{ + c =a+c+234; +} + +int foo2(int d) +{ + return d*d; +} + +int bar1, bar2, bar3; +char * bar4; + +int main(void) { + int h; + bar1 = foo2(1); + bar2 = foo2(1); + + h = foo2(1); + foo1(1, "a", foo2(1)); + foo1(bar1, "a", foo2(1)); + foo2(1); + + h = foo2(1); + bar3 = 1; + bar4 = "a"; + foo1(1, "n", foo2(1)); + foo1(1, "o", foo2(1)); + foo1(1, "p", foo2(1)); + foo1(bar1, "a", foo2(1)); + + bar3 = h; + bar4 = "b"; foo1(bar1, "b", foo2(1)); + foo1(1, "q", foo2(1)); + bar4 = "c"; foo1(1, "c", foo2(1)); + bar4 = "d"; foo1(1, "d", foo2(1)); + bar4 = "e"; foo1(1, "e", foo2(1)); + bar4 = "f"; foo1(1, "f", foo2(1)); + bar4 = "g"; foo1(1, "g", foo2(1)); + bar4 = "h"; foo1(1, "h", foo2(1)); + bar4 = "i"; foo1(1, "i", foo2(1)); + bar4 = "j"; foo1(1, "j", foo2(1)); + bar4 = "k"; foo1(1, "k", foo2(1)); + bar4 = "l"; foo1(1, "l", foo2(1)); + bar4 = "m"; + foo1(bar2, "m", foo2(1)); + exit(0); +} diff --git a/test/dg/Wdeclaration-after-statement-1.c b/test/dg/Wdeclaration-after-statement-1.c new file mode 100644 index 0000000..64a173a --- /dev/null +++ b/test/dg/Wdeclaration-after-statement-1.c @@ -0,0 +1,26 @@ +/* Test for -Wdeclaration-after-statement emitting warnings when no + standard-specifying option is given. See also c9?-mixdecl-*. */ +/* Origin: Joseph Myers */ +/* { dg-do run } */ +/* { dg-options "-Wdeclaration-after-statement" } */ + +extern void abort (void); +extern void exit (int); + +int +main (void) +{ + int i = 0; + if (i != 0) + abort (); + i++; + if (i != 1) + abort (); + int j = i; /* { dg-warning "" "declaration after statement" } */ + if (j != 1) + abort (); + struct foo { int i0; } k = { 4 }; /* { dg-warning "" "declaration after statement" } */ + if (k.i0 != 4) + abort (); + exit (0); +} diff --git a/test/dg/Wdeclaration-after-statement-2.c b/test/dg/Wdeclaration-after-statement-2.c new file mode 100644 index 0000000..ac89bbc --- /dev/null +++ b/test/dg/Wdeclaration-after-statement-2.c @@ -0,0 +1,26 @@ +/* Test for C99 mixed declarations and code giving warnings, not error with + -Wdeclaration-after-statement. See also c9?-mixdecl-*. */ +/* Origin: Joseph Myers */ +/* { dg-do run } */ +/* { dg-options "-std=c99 -pedantic-errors -Wdeclaration-after-statement" } */ + +extern void abort (void); +extern void exit (int); + +int +main (void) +{ + int i = 0; + if (i != 0) + abort (); + i++; + if (i != 1) + abort (); + int j = i; /* { dg-warning "" "declaration-after-statement" } */ + if (j != 1) + abort (); + struct foo { int i0; } k = { 4 }; /* { dg-warning "" "declaration-after-statement" } */ + if (k.i0 != 4) + abort (); + exit (0); +} diff --git a/test/dg/align-1.c b/test/dg/align-1.c new file mode 100644 index 0000000..187eb52 --- /dev/null +++ b/test/dg/align-1.c @@ -0,0 +1,28 @@ +/* PR java/10145 + Test that requesting an alignment of 1 does not increase the alignment + of a long long field. + + { dg-do run } + { dg-options "" } +*/ + +extern void abort (void); + +struct A +{ + char c; + long long i; +}; + +struct B +{ + char c; + long long i __attribute ((__aligned__ (1))); +}; + +int main () +{ + if (sizeof (struct A) != sizeof (struct B)) + abort (); + return 0; +} diff --git a/test/dg/array-init-2.c b/test/dg/array-init-2.c new file mode 100644 index 0000000..9c42581 --- /dev/null +++ b/test/dg/array-init-2.c @@ -0,0 +1,51 @@ +/* Test array initializion by store_by_pieces. */ +/* { dg-do run } */ +/* { dg-options "-O2" } */ + +struct A { char c[10]; }; +extern void abort (void); + +void +__attribute__((noinline)) +check (struct A * a, int b) +{ + const char *p; + switch (b) + { + case 0: + p = "abcdefghi"; + break; + case 1: + p = "j\0\0\0\0\0\0\0\0"; + break; + case 2: + p = "kl\0\0\0\0\0\0\0"; + break; + case 3: + p = "mnop\0\0\0\0\0"; + break; + case 4: + p = "qrstuvwx\0"; + break; + default: + abort (); + } + if (__builtin_memcmp (a->c, p, 10) != 0) + abort (); +} + +int +main (void) +{ + struct A a = { "abcdefghi" }; + check (&a, 0); + struct A b = { "j" }; + check (&b, 1); + struct A c = { "kl" }; + check (&c, 2); + struct A d = { "mnop" }; + check (&d, 3); + struct A e = { "qrstuvwx" }; + check (&e, 4); + return 0; +} diff --git a/test/dg/bitfld-3.c b/test/dg/bitfld-3.c new file mode 100644 index 0000000..7e9343f --- /dev/null +++ b/test/dg/bitfld-3.c @@ -0,0 +1,67 @@ +/* Test for bitfield alignment in structs and unions. */ +/* { dg-do run { target pcc_bitfield_type_matters } } */ +/* { dg-options "-O2" } */ + +extern void abort (void); +extern void exit (int); + +typedef long la __attribute__((aligned (8))); + +struct A +{ + char a; + union UA + { + char x; + la y : 6; + } b; + char c; +} a; + +struct B +{ + char a; + union UB + { + char x; + long y : 6 /* __attribute__((aligned (8))) */; + } b; + char c; +} b; + +struct C +{ + char a; + struct UC + { + la y : 6; + } b; + char c; +} c; + +struct D +{ + char a; + struct UD + { + long y : 6 /* __attribute__((aligned (8))) */; + } b; + char c; +} d; + +int main (void) +{ + if (sizeof (a) != sizeof (b)) + abort (); + if (sizeof (a) != sizeof (c)) + abort (); + if (sizeof (a) != sizeof (d)) + abort (); + if ((&a.c - &a.a) != (&b.c - &b.a)) + abort (); + if ((&a.c - &a.a) != (&c.c - &c.a)) + abort (); + if ((&a.c - &a.a) != (&d.c - &d.a)) + abort (); + exit (0); +} diff --git a/test/dg/bitfld-4.c b/test/dg/bitfld-4.c new file mode 100644 index 0000000..074b936 --- /dev/null +++ b/test/dg/bitfld-4.c @@ -0,0 +1,42 @@ +/* { dg-do run { target { pcc_bitfield_type_matters || default_packed } } } */ +/* { dg-options "" } */ + +/* Check bitfields and non-bitfields are aligned & sized similarly. + + Copyright (C) 2002 Free Software Foundation Inc + Contributed by Nathan Sidwell +*/ + +#include +//#include + +static int fail; + +#define CHECK1(N, T) do { \ + typedef struct Field_##N { char c; T f; } Field_##N; \ + typedef struct BitField_##N { char c; T f : sizeof (T) * CHAR_BIT; } BitField_##N; \ + if (sizeof (Field_##N) != sizeof (BitField_##N)) { \ + fail = 1; /* printf ("sizeof %s failed\n", #T); */ \ + } \ + if (__alignof__ (Field_##N) != __alignof__ (BitField_##N)) { \ + fail = 1; /* printf ("__alignof__ %s failed\n", #T); */ \ + } \ +} while (0) + +#define CHECK(N, T) do { \ + CHECK1(N, T); \ + CHECK1 (s##N, signed T); \ + CHECK1 (u##N, unsigned T); \ +} while (0) + +int main () +{ + + CHECK (c, char); + CHECK (s, short); + CHECK (i, int); + CHECK (l, long); + //CHECK (ll, long long); + + return fail; +} diff --git a/test/dg/builtins-24.c b/test/dg/builtins-24.c new file mode 100644 index 0000000..0f29006 --- /dev/null +++ b/test/dg/builtins-24.c @@ -0,0 +1,36 @@ +/* Copyright (C) 2003 Free Software Foundation. + + Check that the RTL expansion of floating point exponentiation by + a constant integer doesn't break anything and produces the expected + results. + + Written by Roger Sayle, 20th June 2003. */ + +/* { dg-do run } */ +/* { dg-options "-O2 -ffast-math" } */ + +extern float pow(float,float); +extern void abort(void); +extern float fabs(float); + +float foo (float x) +{ + return pow (x, 6); +} + +float bar (float x) +{ + return pow (x, -4); +} + +int main() +{ + if (fabs(foo(2.0) - 64.0) > .0002) /* no, it doesn't get more exact than that... */ + abort (); + + if (bar (2.0) != 0.0625) + abort (); + + return 0; +} + diff --git a/test/dg/c99-bool-1.c b/test/dg/c99-bool-1.c new file mode 100644 index 0000000..efe83cd --- /dev/null +++ b/test/dg/c99-bool-1.c @@ -0,0 +1,248 @@ +/* Test for _Bool and in C99. */ +/* Origin: Joseph Myers */ +/* { dg-do run } */ +/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */ + +/* _Bool must be a builtin type. */ + +_Bool foo; + +#include + +/* Three macros must be integer constant expressions suitable for use + in #if. +*/ + +#if !defined(true) || (true != 1) +#error "bad stdbool true" /* { dg-bogus "#error" "bad stdbool.h" } */ +#endif + +#if !defined(false) || (false != 0) +#error "bad stdbool false" /* { dg-bogus "#error" "bad stdbool.h" } */ +#endif + +#if !defined(__bool_true_false_are_defined) || (__bool_true_false_are_defined != 1) +#error "bad stdbool __bool_true_false_are_defined" /* { dg-bogus "#error" "bad stdbool.h" } */ +#endif + +int a = true; +int b = false; +int c = __bool_true_false_are_defined; + +struct foo +{ + _Bool a : 1; +} sf; + +#define str(x) xstr(x) +#define xstr(x) #x + + +extern void abort (void); +extern void exit (int); +extern int strcmp (const char *, const char *); + +int +main (void) +{ + /* The macro `bool' must expand to _Bool. */ + const char *t = str (bool); + _Bool u, v; + if (strcmp (t, "_Bool")) + abort (); + if (a != 1 || b != 0 || c != 1) + abort (); + /* Casts to _Bool have a specified behavior. */ + if ((int)(_Bool)2 != 1) + exit ((int)(_Bool)2); + if ((int)(_Bool)0.2 != 1) + abort (); + /* Pointers may be assigned to _Bool. */ + if ((u = t) != 1) + exit (u); + /* _Bool may be used to subscript arrays. */ + u = 0; + if (t[u] != '_') + abort (); + if (u[t] != '_') + abort (); + u = 1; + if (t[u] != 'B') + abort (); + if (u[t] != 'B') + abort (); + /* Test increment and decrement operators. */ + u = 0; + if (u++ != 0) + abort (); + if (u != 1) + abort (); + if (u++ != 1) + abort (); + if (u != 1) + abort (); + u = 0; + if (++u != 1) + abort (); + if (u != 1) + abort (); + if (++u != 1) + abort (); + if (u != 1) + abort (); + u = 0; + if (u-- != 0) + abort (); + if (u != 1) + abort (); + if (u-- != 1) + abort (); + if (u != 0) + abort (); + u = 0; + if (--u != 1) + abort (); + if (u != 1) + abort (); + if (--u != 0) + abort (); + if (u != 0) + abort (); + /* Test unary + - ~ !. */ + u = 0; + if (+u != 0) + abort (); + if (-u != 0) + abort (); + u = 1; + if (+u != 1) + abort (); + if (-u != -1) + abort (); + u = 2; + if (+u != 1) + abort (); + if (-u != -1) + abort (); + u = 0; + if (~u != ~(int)0) + abort (); + u = 1; + if (~u != ~(int)1) + abort (); + u = 0; + if (!u != 1) + abort (); + u = 1; + if (!u != 0) + abort (); + /* Test arithmetic * / % + - (which all apply promotions). */ + u = 0; + if (u + 2 != 2) + abort (); + u = 1; + if (u * 4 != 4) + abort (); + if (u % 3 != 1) + abort (); + if (u / 1 != 1) + abort (); + if (4 / u != 4) + abort (); + if (u - 7 != -6) + abort (); + /* Test bitwise shift << >>. */ + u = 1; + if (u << 1 != 2) + abort (); + if (u >> 1 != 0) + abort (); + /* Test relational and equality operators < > <= >= == !=. */ + u = 0; + v = 0; + if (u < v || u > v || !(u <= v) || !(u >= v) || !(u == v) || u != v) + abort (); + u = 0; + v = 1; + if (!(u < v) || u > v || !(u <= v) || u >= v || u == v || !(u != v)) + abort (); + /* Test bitwise operators & ^ |. */ + u = 1; + if ((u | 2) != 3) + abort (); + if ((u ^ 3) != 2) + abort (); + if ((u & 1) != 1) + abort (); + if ((u & 0) != 0) + abort (); + /* Test logical && ||. */ + u = 0; + v = 1; + if (!(u || v)) + abort (); + if (!(v || u)) + abort (); + if (u && v) + abort (); + if (v && u) + abort (); + u = 1; + v = 1; + if (!(u && v)) + abort (); + /* Test conditional ? :. */ + u = 0; + if ((u ? 4 : 7) != 7) + abort (); + u = 1; + v = 0; + if ((1 ? u : v) != 1) + abort (); + if ((1 ? 4 : u) != 4) + abort (); + /* Test assignment operators = *= /= %= += -= <<= >>= &= ^= |=. */ + if ((u = 2) != 1) + abort (); + if (u != 1) + abort (); + if ((u *= -1) != 1) + abort (); + if (u != 1) + abort (); + if ((u /= 2) != 0) + abort (); + if ((u += 3) != 1) + abort (); + if ((u -= 1) != 0) + abort (); + u = 1; + if ((u <<= 4) != 1) + abort (); + if ((u >>= 1) != 0) + abort (); + u = 1; + if ((u &= 0) != 0) + abort (); + if ((u |= 2) != 1) + abort (); + if ((u ^= 3) != 1) + abort (); + /* Test comma expressions. */ + u = 1; + if ((4, u) != 1) + abort (); + /* Test bitfields. */ + { + int i; + for (i = 0; i < sizeof (struct foo); i++) + *((unsigned char *)&sf + i) = (unsigned char) -1; + sf.a = 1; + if (sf.a != 1) + abort (); + sf.a = 0; + if (sf.a != 0) + abort (); + } + exit (0); +} diff --git a/test/dg/c99-bool-3.c b/test/dg/c99-bool-3.c new file mode 100644 index 0000000..63bf768 --- /dev/null +++ b/test/dg/c99-bool-3.c @@ -0,0 +1,33 @@ +/* Test for _Bool bit-fields. They have the semantics of _Bool, at + least for now (DR#335 Spring 2007 discussion). */ +/* Origin: Joseph Myers */ +/* { dg-do run } */ +/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */ +struct foo +{ + _Bool a : 1; +} sf; + +extern void abort (void); +extern void exit (int); + +int +main (void) +{ + int i; + for (i = 0; i < sizeof (struct foo); i++) + *((unsigned char *)&sf + i) = (unsigned char) -1; + sf.a = 2; + if (sf.a != 1) + abort (); + sf.a = 0; + if (sf.a != 0) + abort (); + sf.a = (_Bool)0.2; + if (sf.a != 1) + abort (); + sf.a = (_Bool)&sf; + if (sf.a != 1) + abort (); + exit (0); +} diff --git a/test/dg/c99-func-1.c b/test/dg/c99-func-1.c new file mode 100644 index 0000000..43fb032 --- /dev/null +++ b/test/dg/c99-func-1.c @@ -0,0 +1,17 @@ +/* Test for C99 __func__. */ +/* Origin: Joseph Myers */ +/* { dg-do run } */ +/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */ + +extern void abort (void); +extern int strcmp (const char *, const char *); +extern void exit (int); + +int +main (void) +{ + if (strcmp (__func__, "main") || sizeof (__func__) != 5) + abort (); + else + exit (0); +} diff --git a/test/dg/c99-func-3.c b/test/dg/c99-func-3.c new file mode 100644 index 0000000..f8a06a0 --- /dev/null +++ b/test/dg/c99-func-3.c @@ -0,0 +1,16 @@ +/* Test for C99 __func__: not merging with string literals. */ +/* Origin: Joseph Myers */ +/* { dg-do run } */ +/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */ + +extern void abort (void); +extern void exit (int); + +int +main (void) +{ + if ("main" == __func__) + abort (); + else + exit (0); +} diff --git a/test/dg/c99-hexfloat-2.c b/test/dg/c99-hexfloat-2.c new file mode 100644 index 0000000..3ca15c3 --- /dev/null +++ b/test/dg/c99-hexfloat-2.c @@ -0,0 +1,24 @@ +/* Test for hex floating point constants: in C99 only. Preprocessor test. */ +/* Origin: Joseph Myers */ +/* { dg-do run } */ +/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */ + +#define f ( +#define l ) +#define str(x) #x +#define xstr(x) str(x) + +/* C90: "0x1p+( 0x1p+)"; C99: "0x1p+f 0x1p+l" */ +const char *s = xstr(0x1p+f 0x1p+l); + +extern void abort (void); +extern int strcmp (const char *, const char *); + +int +main (void) +{ + if (strcmp (s, "0x1p+f 0x1p+l")) + abort (); + else + return 0; /* Correct C99 behavior. */ +} diff --git a/test/dg/c99-main-1.c b/test/dg/c99-main-1.c new file mode 100644 index 0000000..fdef9fd --- /dev/null +++ b/test/dg/c99-main-1.c @@ -0,0 +1,9 @@ +/* Test for implicit return 0 from main in C99. */ +/* Origin: Joseph Myers */ +/* { dg-do run } */ +/* { dg-options "-std=iso9899:1999 -pedantic-errors -Wreturn-type -O -fhosted" } */ + +int +main (void) +{ +} /* { dg-bogus "control reaches end" "missing implicit return" } */ diff --git a/test/dg/c99-mixdecl-1.c b/test/dg/c99-mixdecl-1.c new file mode 100644 index 0000000..cfedad4 --- /dev/null +++ b/test/dg/c99-mixdecl-1.c @@ -0,0 +1,25 @@ +/* Test for C99 mixed declarations and code. */ +/* Origin: Joseph Myers */ +/* { dg-do run } */ +/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */ + +extern void abort (void); +extern void exit (int); + +int +main (void) +{ + int i = 0; + if (i != 0) + abort (); + i++; + if (i != 1) + abort (); + int j = i; + if (j != 1) + abort (); + struct foo { int i0; } k = { 4 }; + if (k.i0 != 4) + abort (); + exit (0); +} diff --git a/test/dg/char-compare.c b/test/dg/char-compare.c new file mode 100644 index 0000000..f8b2fb9 --- /dev/null +++ b/test/dg/char-compare.c @@ -0,0 +1,23 @@ +/* PR rtl-optimization/23241 */ +/* Origin: Josh Conner */ + +/* { dg-do run } */ +/* { dg-options "-O2" } */ + +extern void abort(void); + +struct fbs { + unsigned char uc; +} fbs1 = {255}; + +void fn(struct fbs *fbs_ptr) +{ + if ((fbs_ptr->uc != 255) && (fbs_ptr->uc != 0)) + abort(); +} + +int main(void) +{ + fn(&fbs1); + return 0; +} diff --git a/test/dg/conv-3.c b/test/dg/conv-3.c new file mode 100644 index 0000000..3b4f430 --- /dev/null +++ b/test/dg/conv-3.c @@ -0,0 +1,18 @@ +/* PR middle-end/19100 */ +/* { dg-do run } */ +/* { dg-options "-O2" } */ + +void abort (void); + +int test (int v) +{ + return ((signed char) (v ? 0x100 : 0)) ? 17 : 18; +} + +int main() +{ + if (test (2) != 18) + abort (); + return 0; +} + diff --git a/test/dg/div-compare-1.c b/test/dg/div-compare-1.c new file mode 100644 index 0000000..ec1ca65 --- /dev/null +++ b/test/dg/div-compare-1.c @@ -0,0 +1,21 @@ +/* { dg-do run } */ +/* { dg-options "-std=c99" } */ + +extern void abort(void); + +typedef unsigned long long uint64; + +int very_large_value (uint64 t) +{ + return (t / 10000ULL) > 300000ULL; +} + +int main(void) +{ + uint64 t = 0xC0000000ULL; + + if (!very_large_value (t)) + abort (); + + return 0; +} diff --git a/test/dg/doloop-2.c b/test/dg/doloop-2.c new file mode 100644 index 0000000..115ec74 --- /dev/null +++ b/test/dg/doloop-2.c @@ -0,0 +1,19 @@ +/* { dg-do run } */ +/* { dg-options "-O2" } */ +extern void abort (void); +unsigned global_iters; + +void bi_reverse(int len) +{ + do { + global_iters++; + } while (--len > 0); +} + +int main() +{ + bi_reverse(5); + if (global_iters != 5) + abort (); + return 0; +} diff --git a/test/dg/duff-1.c b/test/dg/duff-1.c new file mode 100644 index 0000000..b718f6c --- /dev/null +++ b/test/dg/duff-1.c @@ -0,0 +1,50 @@ +/* Duff's device is legal C; test to make sure the compiler + doesn't complain about it. + + Jason Thorpe + Derived from PR 3846. */ + +/* { dg-do run } */ +/* { dg-options "-O2" } */ + +extern void abort (void); +extern void exit (int); + +typedef __SIZE_TYPE__ size_t; +extern int memcmp (const void *, const void *, size_t); + +void +duffcpy (char *dst, const char *src, unsigned long size) +{ + switch (size & 3) + { + for (;;) + { + *dst++ = *src++; + case 3: + *dst++ = *src++; + case 2: + *dst++ = *src++; + case 1: + *dst++ = *src++; + case 0: + if (size <= 3) + break; + size -= 4; + } + } +} + +const char testpat[] = "The quick brown fox jumped over the lazy dog."; + +int +main() +{ + char buf[64]; + + duffcpy (buf, testpat, sizeof (testpat)); + if (memcmp (buf, testpat, sizeof (testpat)) != 0) + abort (); + + exit (0); +} diff --git a/test/dg/duff-2.c b/test/dg/duff-2.c new file mode 100644 index 0000000..6fefd09 --- /dev/null +++ b/test/dg/duff-2.c @@ -0,0 +1,60 @@ +/* Duff's device is legal C; test to make sure the compiler + doesn't complain about it. + + Jason Thorpe + Derived from the BSD Telnet Kerberos 4 checksum routine. + See also PR 5230. */ + +/* { dg-do run } */ +/* { dg-options "-O2" } */ + +extern void abort (void); +extern void exit (int); + +#if __INT_MAX__ >= 2147483647 +/* At least 32-bit integers. */ +typedef int type32; +#else +typedef long long type32; +#endif + +type32 +cksum (const unsigned char *src, unsigned long size) +{ + type32 ck = 0; + + switch (size & 3) + { + while (size > 0) + { + case 0: + ck ^= (type32)*src++ << 24; + --size; + case 3: + ck ^= (type32)*src++ << 16; + --size; + case 2: + ck ^= (type32)*src++ << 8; + --size; + case 1: + ck ^= (type32)*src++; + --size; + } + } + + return ck; +} + +const char testpat[] = "The quick brown fox jumped over the lazy dog."; + +int +main() +{ + type32 ck; + + ck = cksum ((const unsigned char *) testpat, sizeof (testpat)); + if (ck != 925902908) + abort (); + + exit (0); +} diff --git a/test/dg/duff-3.c b/test/dg/duff-3.c new file mode 100644 index 0000000..23cddef --- /dev/null +++ b/test/dg/duff-3.c @@ -0,0 +1,47 @@ +/* Duff's device is legal C; test to make sure the compiler + doesn't complain about it. + + Jason Thorpe + Derived from Tom Duff's original usenet message about the device. */ + +/* { dg-do run } */ +/* { dg-options "-O2" } */ + +extern void abort (void); +extern void exit (int); + +typedef __SIZE_TYPE__ size_t; +extern int memcmp (const void *, const void *, size_t); + +void +duffcpy (char *dst, const char *src, unsigned long size) +{ + unsigned long n = (size + 7) / 8; + + switch (size % 8) + { + case 0: do { *dst++ = *src++; + case 7: *dst++ = *src++; + case 6: *dst++ = *src++; + case 5: *dst++ = *src++; + case 4: *dst++ = *src++; + case 3: *dst++ = *src++; + case 2: *dst++ = *src++; + case 1: *dst++ = *src++; + } while (--n > 0); + } +} + +const char testpat[] = "The quick brown fox jumped over the lazy dog."; + +int +main() +{ + char buf[64]; + + duffcpy (buf, testpat, sizeof (testpat)); + if (memcmp (buf, testpat, sizeof (testpat)) != 0) + abort (); + + exit (0); +} diff --git a/test/dg/duff-4.c b/test/dg/duff-4.c new file mode 100644 index 0000000..9f3b754 --- /dev/null +++ b/test/dg/duff-4.c @@ -0,0 +1,60 @@ +/* Duff's device is legal C; test to make sure the compiler + doesn't complain about it. + + Roger Sayle + Derived from duff-2.c. */ + +/* { dg-do run } */ +/* { dg-options "-O2" } */ + +extern void abort (void); +extern void exit (int); + +#if __INT_MAX__ >= 2147483647 +/* At least 32-bit integers. */ +typedef int type32; +#else +typedef long long type32; +#endif + +type32 +cksum (const unsigned char *src, unsigned long size) +{ + type32 ck = 0; + + switch (size & 3) + { + do + { + case 0: + ck ^= (type32)*src++ << 24; + --size; + case 3: + ck ^= (type32)*src++ << 16; + --size; + case 2: + ck ^= (type32)*src++ << 8; + --size; + case 1: + ck ^= (type32)*src++; + --size; + } + while (size > 0); + } + + return ck; +} + +const char testpat[] = "The quick brown fox jumped over the lazy dog."; + +int +main() +{ + type32 ck; + + ck = cksum ((const unsigned char *) testpat, sizeof (testpat)); + if (ck != 925902908) + abort (); + + exit (0); +} diff --git a/test/dg/empty1.c b/test/dg/empty1.c new file mode 100644 index 0000000..89b2de1 --- /dev/null +++ b/test/dg/empty1.c @@ -0,0 +1,11 @@ +/* { dg-do run } */ +/* { dg-options "" } */ + +struct S { int : 0; }; +union U { int : 0; }; + +int main () { + if (__alignof__ (struct S) != __alignof__ (union U)) + return 1; + return 0; +} diff --git a/test/dg/fastmath-1.c b/test/dg/fastmath-1.c new file mode 100644 index 0000000..4efe430 --- /dev/null +++ b/test/dg/fastmath-1.c @@ -0,0 +1,26 @@ +/* { dg-do run } */ +/* { dg-options "-O2 -ffast-math" } */ + +extern void abort (void); + +int foo ( float* dists, int k) +{ +if ( ( dists [ 0 ] > 0 ) == ( dists [ 1 ] > 0 ) ) + return k; +return 0; +} +main() { + float dists[16] = { 0., 1., 1., 0., 0., -1., -1., 0., + 1., 1., 1., -1., -1., 1., -1., -1. }; + if ( foo(&dists[0], 1) + + foo(&dists[2], 2) + + foo(&dists[4], 4) + + foo(&dists[6], 8) + + foo(&dists[8], 16) + + foo(&dists[10], 32) + + foo(&dists[12], 64) + + foo(&dists[14], 128) + != 156) + abort(); + return 0; +} diff --git a/test/dg/fixuns-trunc-1.c b/test/dg/fixuns-trunc-1.c new file mode 100644 index 0000000..0d09429 --- /dev/null +++ b/test/dg/fixuns-trunc-1.c @@ -0,0 +1,31 @@ +/* { dg-do run } */ +/* { dg-options "-std=c99" } */ + +unsigned long foo(double d) +{ + return (unsigned long) d; +} + +extern void abort(void); + +int main(void) +{ + double d; + unsigned long l; + +#ifdef __LP64__ + d = 9223372036854775808.7; + l = 1LL << 63; + + if (foo(d) != l) + abort(); +#endif + + d = 122485.2; + l = 122485; + + if (foo(d) != l) + abort(); + + return 0; +} diff --git a/test/dg/fnegate-1.c b/test/dg/fnegate-1.c new file mode 100644 index 0000000..ad0f4e0 --- /dev/null +++ b/test/dg/fnegate-1.c @@ -0,0 +1,113 @@ +/* Copyright (C) 2002 Free Software Foundation. + + Test floating point negation produces the expected results. + + Written by Roger Sayle, 21st May 2002. */ + +/* { dg-do run } */ +/* { dg-options "-O2 -ffast-math" } */ + +extern void abort (); + + +double +dneg (double x) +{ + return -x; +} + +double +dmult (double x) +{ + return -1.0 * x; +} + +double +ddiv (double x) +{ + return x / -1.0; +} + + +float +fneg (float x) +{ + return -x; +} + +float +fmult (float x) +{ + return -1.0f * x; +} + +float +fdiv (float x) +{ + return x / -1.0f; +} + + +void +ftest(float src, float dst) +{ + if (fneg (src) != dst) + abort (); + + if (src != fneg (dst)) + abort (); + + if (fmult (src) != dst) + abort (); + + if (src != fmult (dst)) + abort (); + + if (fdiv (src) != dst) + abort (); + + if (src != fdiv(dst)) + abort (); +} + +void +dtest(double src, double dst) +{ + if (dneg (src) != dst) + abort (); + + if (src != dneg (dst)) + abort (); + + if (dmult (src) != dst) + abort (); + + if (src != dmult (dst)) + abort (); + + if (ddiv (src) != dst) + abort (); + + if (src != ddiv(dst)) + abort (); +} + + +int +main () +{ + ftest (1.0f, -1.0f); + ftest (2.0f, -2.0f); + ftest (-3.0f, 3.0f); + ftest (0.0f, -0.0f); + ftest (-0.0f, 0.0f); + + dtest (1.0, -1.0); + dtest (2.0, -2.0); + dtest (-3.0, 3.0); + dtest (0.0, -0.0); + dtest (-0.0, 0.0); + + return 0; +} + diff --git a/test/dg/fold-abs-2.c b/test/dg/fold-abs-2.c new file mode 100644 index 0000000..6291d7e --- /dev/null +++ b/test/dg/fold-abs-2.c @@ -0,0 +1,17 @@ +/* { dg-do run } */ +/* { dg-options "-O1 -fwrapv" } */ +#include +void exit (int); +void abort (); +#define ABS(x) (x > 0 ? x : -x) +int f (int a) { + if (ABS(a) >= 0) return 1; + else return 0; +} + +int main (int argc, char *argv[]) { + if (f(INT_MIN)) + abort (); + else + exit (0); +} diff --git a/test/dg/fshort-wchar.c b/test/dg/fshort-wchar.c new file mode 100644 index 0000000..9f49463 --- /dev/null +++ b/test/dg/fshort-wchar.c @@ -0,0 +1,20 @@ +/* Copyright (C) 2002 Free Software Foundation, Inc. */ + +/* { dg-do run } */ +/* { dg-options "-fshort-wchar" } */ + +/* Source: Neil Booth, 10 Dec 2002. + + Test that __WCHAR_MAX__ is correct with -fshort-wchar. */ + +extern void abort (void); + +int main () +{ + __WCHAR_TYPE__ w = ~(__WCHAR_TYPE__) 0; + + if (w != __WCHAR_MAX__) + abort (); + + return 0; +} diff --git a/test/dg/ftrapv-1.c b/test/dg/ftrapv-1.c new file mode 100644 index 0000000..44eb176 --- /dev/null +++ b/test/dg/ftrapv-1.c @@ -0,0 +1,25 @@ +/* Copyright (C) 2004 Free Software Foundation. + + PR other/15526 + Verify correct overflow checking with -ftrapv. + + Written by Falk Hueffner, 20th May 2004. */ + +/* { dg-do run } */ +/* { dg-options "-ftrapv" } */ + +__attribute__((noinline)) int +mulv(int a, int b) +{ + return a * b; +} + +int +main() +{ + mulv( 0, 0); + mulv( 0, -1); + mulv(-1, 0); + mulv(-1, -1); + return 0; +} diff --git a/test/dg/ftrapv-2.c b/test/dg/ftrapv-2.c new file mode 100644 index 0000000..d79b86d --- /dev/null +++ b/test/dg/ftrapv-2.c @@ -0,0 +1,108 @@ +/* Copyright (C) 2004 Free Software Foundation. + + PR other/18665 + Verify that -ftrapv doesn't produce bogus results + on 64-bit platforms. + + Written by Eric Botcazou */ + +/* { dg-do run } */ +/* { dg-options "-ftrapv" } */ + +extern void abort(void); +extern long labs(long); + +int __attribute__((noinline)) +iabsv(int a) +{ + return abs(a); +} + +int __attribute__((noinline)) +iaddv(int a, int b) +{ + return a + b; +} + +int __attribute__((noinline)) +isubv(int a, int b) +{ + return a - b; +} + +int __attribute__((noinline)) +imulv(int a, int b) +{ + return a * b; +} + +int __attribute__((noinline)) +inegv(int a) +{ + return -a; +} + +long __attribute__((noinline)) +labsv(long a) +{ + return labs(a); +} + +long __attribute__((noinline)) +laddv(long a, long b) +{ + return a + b; +} + +long __attribute__((noinline)) +lsubv(long a, long b) +{ + return a - b; +} + +long __attribute__((noinline)) +lmulv(long a, long b) +{ + return a * b; +} + +long __attribute__((noinline)) +lnegv(long a) +{ + return -a; +} + +int main(void) +{ + if (iabsv (-1) != 1) + abort (); + + if (iaddv (2,-3) != -1) + abort (); + + if (isubv (2,3) != -1) + abort (); + + if (imulv (-2,3) != -6) + abort (); + + if (inegv (-1) != 1) + abort (); + + if (labsv (-1L) != 1L) + abort (); + + if (laddv (2L,-3L) != -1L) + abort (); + + if (lsubv (2L,3L) != -1L) + abort (); + + if (lmulv (-2L,3L) != -6L) + abort (); + + if (lnegv (-1L) != 1L) + abort (); + + return 0; +} diff --git a/test/dg/fwrapv-1.c b/test/dg/fwrapv-1.c new file mode 100644 index 0000000..f7ddda4 --- /dev/null +++ b/test/dg/fwrapv-1.c @@ -0,0 +1,28 @@ +/* Copyright (C) 2003 Free Software Foundation. + + Test that the -fwrapv command line option is accepted and disables + "unsafe" optimizations that rely on undefined arithmetic overflow. + + Written by Roger Sayle, 24th March 2003. */ + +/* { dg-do run } */ +/* { dg-options "-O2 -fwrapv" } */ + +#include + +extern void abort (); + +int test(int x) +{ + return (2*x)/2; +} + +main() +{ + int x = INT_MAX; + + if (test(x) == x) + abort (); + return 0; +} + diff --git a/test/dg/ifcvt-fabs-1.c b/test/dg/ifcvt-fabs-1.c new file mode 100644 index 0000000..bdf6b39 --- /dev/null +++ b/test/dg/ifcvt-fabs-1.c @@ -0,0 +1,21 @@ +/* { dg-do run } */ +/* { dg-options "-O" } */ +/* { dg-options "-O -march=i686" { target { { i686-*-* x86_64-*-* } && ilp32 } } } */ + +extern void abort(void); + +float foo(float f) +{ + if (f < 0.0f) + f = -f; + + return f; +} + +int main(void) +{ + if (foo (-1.0f) != 1.0f) + abort (); + + return 0; +} diff --git a/test/dg/ifelse-2.c b/test/dg/ifelse-2.c new file mode 100644 index 0000000..0210fcf --- /dev/null +++ b/test/dg/ifelse-2.c @@ -0,0 +1,34 @@ +/* +{ dg-do run } +{ dg-options "-O2" } +*/ + +extern void abort (void); + +enum Status +{ + P_ON_LOWER = -4, + P_ON_UPPER = -2, + P_FREE = -1 +}; + +void +foo (enum Status *stat, double newUpper, double lower, double max) +{ + if (newUpper >= max) + *stat = P_FREE; + else if (newUpper == lower) + *stat = P_ON_LOWER; +} + +int +main () +{ + enum Status stat = P_ON_UPPER; + + foo (&stat, 5.0, -10.0, 10.0); + + if (stat != P_ON_UPPER) + abort (); + return 0; +} diff --git a/test/dg/long-long-cst1.c b/test/dg/long-long-cst1.c new file mode 100644 index 0000000..7c60648 --- /dev/null +++ b/test/dg/long-long-cst1.c @@ -0,0 +1,18 @@ +/* PR middle-end/27724 */ +/* { dg-do run } */ +/* { dg-options "" } */ + +extern void abort(); + +struct st{ + int _mark; +}; +unsigned long long t = ((int)(__SIZE_TYPE__)&(((struct st*)16)->_mark) - 32); + +int main() +{ + if (t != (unsigned long long)(int)-16) + abort (); + return 0; +} + diff --git a/test/dg/loop-2.c b/test/dg/loop-2.c new file mode 100644 index 0000000..fa96f89 --- /dev/null +++ b/test/dg/loop-2.c @@ -0,0 +1,23 @@ +/* PR optimization/10171 */ +/* Bug: unroll_loop misoptimized the function so that we got + 0 iterations of the loop rather than the correct 1. */ +/* { dg-do run } */ + +extern void abort (void); +extern void exit (int); + +__inline__ int tag() { return 0; } + +void f (); + +int main() { + int i; + for (i = 0; i < (tag() ? 2 : 1); i++) + f(); + abort (); +} + +void f () +{ + exit (0); +} diff --git a/test/dg/loop-4.c b/test/dg/loop-4.c new file mode 100644 index 0000000..c83fd1c --- /dev/null +++ b/test/dg/loop-4.c @@ -0,0 +1,25 @@ +/* PR optimization/11841 */ +/* Originator: Andrey Panov */ +/* Reduced testcase by Volker Reichelt */ + +/* Verify that the (old) loop unroller doesn't wrongly mark a pseudo + referenced in a note as local. */ + +/* { dg-do run } */ +/* { dg-options "-O2 -funroll-loops" } */ + +int *a; + +int main() +{ + double d[6]; + int i, j; + + for (i=0; i<4; ++i) + for (j=0; j<3; ++j) + d[i+j] = 0; + + a = &i; + + return 0; +} diff --git a/test/dg/loop-6.c b/test/dg/loop-6.c new file mode 100644 index 0000000..653854e --- /dev/null +++ b/test/dg/loop-6.c @@ -0,0 +1,25 @@ +/* PR optimization/18577 */ +/* Origin: Falk Hueffner */ + +/* { dg-do run } */ +/* { dg-options "-O2 -funroll-all-loops" } */ + +static float tfcos12[3]; +__attribute__((noinline)) double f(double x) { return x; } +int g; + +int main(void) +{ + int i, j; + for (i = 0; i < 1; i++) + tfcos12[i] = 0.5; + + for (i = 0; i < 1; i++) + { + tfcos12[i] = 0.5 * f(i); + for (j = 0; j < 12; j++) + g++; + } + + return 0; +} diff --git a/test/dg/minmax-1.c b/test/dg/minmax-1.c new file mode 100644 index 0000000..e279c0e --- /dev/null +++ b/test/dg/minmax-1.c @@ -0,0 +1,83 @@ +/* { dg-do run } */ +/* { dg-options "-fdump-tree-original" } */ + +/* Check that MIN-MAX and MAX-MIN combinations are folded. */ + +extern void abort (void); + +#define MIN(a,b) ((a) < (b) ? (a) : (b)) +#define MAX(a,b) ((a) > (b) ? (a) : (b)) + +int f1(int a, int b) +{ + return MIN (MAX (a, b), b); /* == b */ +} + +int f2(int a, int b) +{ + return MAX (MIN (a, b), b); /* == b */ +} + +int f3(int a, int b) +{ + return MIN (MAX (b, a), b); /* == b */ +} + +int f4(int a, int b) +{ + return MAX (MIN (b, a), b); /* == b */ +} + + +int g1(int a, int b) +{ + return MIN (a, MAX (a, b)); /* == a */ +} + +int g2(int a, int b) +{ + return MAX (a, MIN (a, b)); /* == a */ +} + +int g3(int a, int b) +{ + return MIN (a, MAX (b, a)); /* == a */ +} + +int g4(int a, int b) +{ + return MAX (a, MIN (b, a)); /* == a */ +} + +int main(void) +{ + if (f1 (1, 2) != 2) + abort (); + + if (f2 (1, 2) != 2) + abort (); + + if (f3 (1, 2) != 2) + abort (); + + if (f4 (1, 2) != 2) + abort (); + + if (g1 (1, 2) != 1) + abort (); + + if (g2 (1, 2) != 1) + abort (); + + if (g3 (1, 2) != 1) + abort (); + + if (g4 (1, 2) != 1) + abort (); + + return 0; +} + +/* { dg-final { scan-tree-dump-times "MIN_EXPR" 0 "original"} } */ +/* { dg-final { scan-tree-dump-times "MAX_EXPR" 0 "original"} } */ +/* { dg-final { cleanup-tree-dump "original" } } */ diff --git a/test/dg/multiword-1.c b/test/dg/multiword-1.c new file mode 100644 index 0000000..21d05b4 --- /dev/null +++ b/test/dg/multiword-1.c @@ -0,0 +1,68 @@ +/* { dg-do run } */ +/* { dg-options "-O3" } */ +/* { dg-require-effective-target ilp32 } */ + +typedef unsigned int u32; +typedef unsigned long long u64; + +u64 __attribute__((noinline)) +foo (u32 high, u32 low) +{ + return ((u64)high << 16) | low; +} + +u32 __attribute__((noinline)) +right (u64 t) +{ + return (u32)(t >> 16); +} + +u64 __attribute__((noinline)) +left (u32 t) +{ + return (u64)t << 16; +} + +u32 __attribute__((noinline)) +right2 (u64 t) +{ + return (u32)(t >> 24); +} + +u64 __attribute__((noinline)) +left2 (u32 t) +{ + return (u64)t << 8; +} + +u64 __attribute__((noinline)) +zeroextend (u32 t) +{ + return (u64)t; +} + +extern void abort (); + +int +main () +{ + if (foo (13000, 12000) != 851980000ULL) + abort (); + + if (right (851980000ULL) != 13000) + abort (); + + if (left (13000) != 851968000ULL) + abort (); + + if (right2 (851968000ULL) != 50) + abort (); + + if (left2 (13000) != 3328000ULL) + abort (); + + if (zeroextend (13000) != 13000ULL) + abort (); + + return 0; +} diff --git a/test/dg/nest.c b/test/dg/nest.c new file mode 100644 index 0000000..9064e4e --- /dev/null +++ b/test/dg/nest.c @@ -0,0 +1,28 @@ +/* PR 5967, PR 7114 */ +/* { dg-do run } */ +/* { dg-require-profiling "-pg" } */ +/* { dg-options "-O2 -pg" } */ +/* { dg-options "-O2 -pg -static" { target hppa*-*-hpux* } } */ +/* { dg-error "profiler" "No profiler support" { target xstormy16-*-* } 0 } */ + +extern void abort (void); + + long bar (long z) { return z * 2; } +long foo (long x) +{ + long i, sum = 0; + + for (i = 0; i < x; i++) + sum += bar (i); + + return sum; +} + +int main (void) +{ + if (foo(10) != 90) + abort (); + return 0; +} + +/* { dg-final { cleanup-profile-file } } */ diff --git a/test/dg/nested-calls-1.c b/test/dg/nested-calls-1.c new file mode 100644 index 0000000..89fdc88 --- /dev/null +++ b/test/dg/nested-calls-1.c @@ -0,0 +1,42 @@ +/* PR middle-end/24003 */ +/* Contributed by Eric Botcazou */ + +/* { dg-do run } */ +/* { dg-options "-std=c99 -O -fno-inline" } */ +/* { dg-options "-std=c99 -O -fno-inline -mtune=i686" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */ + +#include + +typedef unsigned long uns32_t; +typedef unsigned long long uns64_t; + +extern void abort(void); + +uns32_t lo (uns64_t p) +{ + return (uns32_t)p; +} + +uns64_t concat (uns32_t p1, uns32_t p2) +{ +#if LLONG_MAX > 2147483647L + return ((uns64_t)p1 << 32) | p2; +#else + return 0; +#endif +} + +uns64_t lshift32 (uns64_t p1, uns32_t p2) +{ + return concat (lo (p1), p2); +} + +int main(void) +{ +#if LLONG_MAX > 2147483647L + if (lshift32 (0xFFFFFFFF12345678ULL, 0x90ABCDEFUL) != 0x1234567890ABCDEFULL) + abort (); +#endif + + return 0; +} diff --git a/test/dg/nrv1.c b/test/dg/nrv1.c new file mode 100644 index 0000000..ca70092 --- /dev/null +++ b/test/dg/nrv1.c @@ -0,0 +1,28 @@ +/* Test that the NRV optimization doesn't cause a1 to change too soon. This + is equivalent to c++/19317. */ +/* { dg-do run } */ + +void abort (void); + +struct A +{ + int i[100]; +}; + +struct A a1; + +struct A f () +{ + struct A a2; + a2.i[0] = 42; + /* a1.i[0] should still be 0 until we return. */ + if (a1.i[0] != 0) + abort (); + return a2; +} + +int main() +{ + a1 = f(); + return 0; +} diff --git a/test/dg/pack-test-4.c b/test/dg/pack-test-4.c new file mode 100644 index 0000000..1ad8ee4 --- /dev/null +++ b/test/dg/pack-test-4.c @@ -0,0 +1,36 @@ +/* PR c/11885 + Bug: flag4 was allocated into the same byte as the other flags. + { dg-options "" } + { dg-do run } */ + +extern void abort (void); + +typedef unsigned char uint8_t; + +typedef struct { + uint8_t flag1:2; + uint8_t flag2:1; + uint8_t flag3:1; + + uint8_t flag4; + +} __attribute__ ((packed)) MyType; + +int main (void) +{ + MyType a; + MyType *b = &a; + + b->flag1 = 0; + b->flag2 = 0; + b->flag3 = 0; + + b->flag4 = 0; + + b->flag4++; + + if (b->flag1 != 0) + abort (); + + return 0; +} diff --git a/test/dg/postincr-1.c b/test/dg/postincr-1.c new file mode 100644 index 0000000..752cda4 --- /dev/null +++ b/test/dg/postincr-1.c @@ -0,0 +1,21 @@ +/* Simple test for proper postincrement semantics. */ +/* { dg-do run } */ + +extern void abort (void); + +int i; +int c; +int *f () +{ + ++c; + return &i; +} + +int main () +{ + int r; + r = (*f())++; + if (!(r == 0 && i == 1 && c == 1)) + abort (); + return 0; +} diff --git a/test/dg/pr10392-1.c b/test/dg/pr10392-1.c new file mode 100644 index 0000000..8d599b8 --- /dev/null +++ b/test/dg/pr10392-1.c @@ -0,0 +1,63 @@ +/* PR optimization/10392 + * Reporter: marcus@mc.pp.se + * Summary: [3.3/3.4 regression] [SH] optimizer generates faulty array indexing + * Description: + * The address calculation of an index operation on an array on the stack + * can _under some conditions_ get messed up completely + * + * Testcase tweaked by dank@kegel.com + * Problem only happens with -O2 -m4, so it should only happen on sh4, + * but what the heck, let's test other architectures, too. + * Not marked as xfail since it's a regression. +*/ +/* { dg-do run } */ +/* { dg-options "-O2" } */ +/* { dg-options "-O2 -m4" { target sh4-*-* } } */ +extern void abort (void); +const char *dont_optimize_function_away; + +const char *use(const char *str) +{ + dont_optimize_function_away = str; + if (str[0] != 'v') + abort(); + if (str[1] < '1' || str[1] > '6') + abort(); + if (str[2]) + abort(); + return str[2] ? "notused" : "v6"; +} + +const char *func(char *a, char *b) +{ + char buf[128]; + unsigned char i; + const char *result; + + char *item[] = { + "v1", + "v2", + }; + + buf[0] = 'v'; + buf[1] = '3'; + buf[2] = 0; + + for (i = 0; i < 2; i++) { + /* bug is: following line passes wild pointer to use() on sh4 -O2 */ + result = use(item[i]); + + use(buf); + use(a); + use(b); + result = use(result); + } + return result; +} + +int main() +{ + func("v4", "v5"); + return 0; +} + diff --git a/test/dg/pr11864-1.c b/test/dg/pr11864-1.c new file mode 100644 index 0000000..b8d7134 --- /dev/null +++ b/test/dg/pr11864-1.c @@ -0,0 +1,42 @@ +/* PR optimization/11864 + * Reporter: Kazumoto Kojima + * Summary: [3.3/3.4 regression] miscompiles zero extension and test + * Description: + * gcc-3.3/3.4 -O2 for sh target may miscompile the combination of zero extension + * and test if it's zero. + * + * Testcase tweaked by dank@kegel.com. Not marked as xfail because it's a regression. + */ +/* { dg-do run } */ +/* { dg-options "-O2" } */ + +extern void abort(void); + +int val = 0xff00; + +int f(void) +{ + return val; +} + +unsigned char a[1]; + +void foo(void) +{ + a[0] = f() & 255; + + if (!a[0]) + a[0] = f() & 255; + + if (!a[0]) + a[0] = 1 + (f() & 127); +} + +int main(int argc, char **argv) +{ + foo(); + if (!a[0]) + abort(); + + return 0; +} diff --git a/test/dg/pr17112-1.c b/test/dg/pr17112-1.c new file mode 100644 index 0000000..38da074 --- /dev/null +++ b/test/dg/pr17112-1.c @@ -0,0 +1,33 @@ +/* PR middle-end/17112 */ +/* { dg-do run } */ +/* { dg-require-effective-target int32plus } */ +/* { dg-options "-O2" } */ + +extern void abort(void); + +typedef struct { + int int24:12 /* __attribute__((packed))*/; /* { dg-warning "attribute ignored" "" { target { default_packed && { ! pcc_bitfield_type_matters } } } } */ +} myint24; + +myint24 x[3] = { + 0x123, + 0x789, + 0xdef +}; + +myint24 y[3]; // starts out as zeros + +void foo() +{ + y[1] = x[1]; +} + +int main() +{ + foo(); + + if (y[0].int24 != 0 || y[2].int24 != 0) + abort(); + return 0; +} + diff --git a/test/dg/pr17581-1.c b/test/dg/pr17581-1.c new file mode 100644 index 0000000..b63517c --- /dev/null +++ b/test/dg/pr17581-1.c @@ -0,0 +1,30 @@ +/* PR rtl-optimization/17581 */ +/* { dg-do run } */ +/* { dg-options "-O2" } */ + +void abort (void); + +int foo(int x) +{ + unsigned long long tmp = 0; + + switch(x) { + case 21: + tmp |= 1; + tmp |= 2; + tmp |= 8; + break; + default: + break; + } + + return (int)tmp; +} + +int main() +{ + if (foo(21) != 11) + abort (); + return 0; +} + diff --git a/test/dg/pr18241-1.c b/test/dg/pr18241-1.c new file mode 100644 index 0000000..d6bdbcc --- /dev/null +++ b/test/dg/pr18241-1.c @@ -0,0 +1,107 @@ +/* { dg-do run } */ +/* { dg-options "-std=gnu99 -Wall -Wextra -O1" } */ + +extern void *memset (void*, int, __SIZE_TYPE__); +extern void abort (void); + +struct radix_tree_root { + unsigned int height; + struct radix_tree_node *rnode; +}; + +struct radix_tree_node { + unsigned int count; + void *slots[64]; + unsigned long tags[2][2]; +}; + +struct radix_tree_path { + struct radix_tree_node *node, **slot; + int offset; +}; + +static unsigned long height_to_maxindex[7] = +{0, 63, 4095, 262143, 16777215, 1073741823, 4294967295}; + +static inline void tag_clear(struct radix_tree_node *node, int tag, int offset) +{ + int nr; + volatile unsigned long *addr; + int mask; + + nr = offset; + addr = &node->tags[tag][0]; + + addr += nr >> 5; + mask = 1 << (nr & 0x1f); + *addr &= ~mask; +} + +void *radix_tree_tag_clear(struct radix_tree_root *root, unsigned long index, int tag) +{ + struct radix_tree_path path[7], *pathp = path; + unsigned int height, shift; + void *ret = 0; + + height = root->height; + if (index > height_to_maxindex[height]) + goto out; + + shift = (height - 1) * 6; + pathp->node = 0; + pathp->slot = &root->rnode; + + while (height > 0) { + int offset; + + if (*pathp->slot == 0) + goto out; + + offset = (index >> shift) & (64-1); + pathp[1].offset = offset; + pathp[1].node = *pathp[0].slot; + pathp[1].slot = (struct radix_tree_node **) + (pathp[1].node->slots + offset); + pathp++; + shift -= 6; + height--; + } + + ret = *pathp[0].slot; + if (ret == 0) + goto out; + + do { + int idx; + + tag_clear(pathp[0].node, tag, pathp[0].offset); + for (idx = 0; idx < 2; idx++) { + if (pathp[0].node->tags[tag][idx]) + goto out; + } + pathp--; + } while (pathp[0].node); +out: + return ret; +} + +int main () +{ + struct radix_tree_root r; + struct radix_tree_node node; + void *p = (void *) 0xdeadbeef; + + r.height = 1; + r.rnode = &node; + + memset (&node, 0, sizeof (node)); + + node.count = 1; + node.slots [13] = p; + + radix_tree_tag_clear (&r, 13, 1); + + if (r.rnode->slots[13] != p) + abort (); + return 0; +} diff --git a/test/dg/pr18241-2.c b/test/dg/pr18241-2.c new file mode 100644 index 0000000..a3ff1de --- /dev/null +++ b/test/dg/pr18241-2.c @@ -0,0 +1,65 @@ +/* { dg-do run } */ +/* { dg-options "-std=gnu99 -Wall -Wextra -O1" } */ + +extern void *memset (void*, int, __SIZE_TYPE__); +extern void abort (void); + +struct radix_tree_root { + unsigned int height; + struct radix_tree_node *rnode; +}; + +struct radix_tree_node { + unsigned int count; + void *slots[64]; + unsigned long tags[2]; +}; + +struct radix_tree_path { + struct radix_tree_node *node, **slot; + int offset; +}; + +void radix_tree_tag_clear(struct radix_tree_root *root, unsigned long index) +{ + struct radix_tree_path path[7], *pathp = path; + unsigned int height, shift; + volatile unsigned long *addr; + + height = root->height; + + shift = (height - 1) * 6; + path[0].slot = &root->rnode; + + while (height > 0) { + int offset; + + offset = (index >> shift) & (64-1); + pathp[1].offset = offset; + pathp[1].node = *pathp[0].slot; + pathp[1].slot = (struct radix_tree_node **) + (pathp[1].node->slots + offset); + pathp++; + shift -= 6; + height--; + } + + addr = &(pathp->node->tags[0]) + 1; + *addr = 574; +} + +struct radix_tree_root r; +struct radix_tree_node node; + +int main () +{ + r.height = 1; + r.rnode = &node; + + memset (&node, 0, sizeof (node)); + + node.count = 1; + + radix_tree_tag_clear (&r, 13); + return 0; +} diff --git a/test/dg/pr18241-3.c b/test/dg/pr18241-3.c new file mode 100644 index 0000000..869b1e9 --- /dev/null +++ b/test/dg/pr18241-3.c @@ -0,0 +1,31 @@ +/* { dg-do run } */ +/* { dg-options "-O1" } */ + +void abort (void); + +void radix_tree_tag_clear (int *node) +{ + int *path[2], **pathp = path, height; + volatile int *addr; + + height = 1; + pathp[0] = node; + + while (height > 0) { + pathp[1] = pathp[0]; + pathp++; + height--; + } + + addr = pathp[0]; + *addr = 1; +} + +int main () +{ + int n; + radix_tree_tag_clear (&n); + if (n != 1) + abort (); + return 0; +} diff --git a/test/dg/pr18241-4.c b/test/dg/pr18241-4.c new file mode 100644 index 0000000..ad61937 --- /dev/null +++ b/test/dg/pr18241-4.c @@ -0,0 +1,22 @@ +/* { dg-do run } */ +/* { dg-options "-O1" } */ + +void abort (void); + +int f(int i1243) +{ + int i[2], *i1 = i; + i[0] = 1; + volatile int *i2 = i1; + i2[1] = 1; + i1243 = 0; + return i2[1]+i2[0]; +} + + +int main(void) +{ + if( f(100) != 2) + abort (); + return 0; +} diff --git a/test/dg/pr18241-5.c b/test/dg/pr18241-5.c new file mode 100644 index 0000000..0ddb55f --- /dev/null +++ b/test/dg/pr18241-5.c @@ -0,0 +1,14 @@ +/* { dg-do run } */ +/* { dg-options "-O1" } */ + +void abort (void); + +int main () +{ + int a; + volatile int *b = &a; + a = 1; + if (*b != 1) + abort (); + return 0; +} diff --git a/test/dg/pr18921-1.c b/test/dg/pr18921-1.c new file mode 100644 index 0000000..b8c91aa --- /dev/null +++ b/test/dg/pr18921-1.c @@ -0,0 +1,20 @@ +/* PR middle-end/18921 */ +/* { dg-do run } */ +/* { dg-options "-O2" } */ + +extern void abort (void); + +int foo (int k) +{ + unsigned char j = 0; + (k ? 0 : j++) == -1; + return j; +} + +int main () +{ + if (!foo (0)) + abort (); + return 0; +} + diff --git a/test/dg/pr19633-1.c b/test/dg/pr19633-1.c new file mode 100644 index 0000000..a0152f6 --- /dev/null +++ b/test/dg/pr19633-1.c @@ -0,0 +1,72 @@ +/* { dg-do run } */ + +/* The max-aliased-vops setting is a temporary workaround to avoid the + random failures as described in PR 30194. This test case does not + need alias sets bigger than 13 elements. */ +/* { dg-options "-O2 --param max-aliased-vops=15" } */ + +extern void abort (void); + +struct S +{ + int w, x, y, z; +}; + +struct T +{ + int r; + struct S s; +}; + +struct S bar (struct S x, struct S *y) +{ + y->w = 4; + return *y; +} + +void +foo (int a, struct T b) +{ + struct S x; + struct S *c = &x; + if (a) + c = &b.s; + b.s.w = 3; + /* This call should be marked as clobbering 'x' and 'b'. */ + *c = bar (*c, c); + if (b.s.w == 3) + abort (); +} + +float Y; + +struct S bar1 (struct S x, struct S y) +{ + Y = 4; + return x; +} + +void +foo1 (int a, struct T b) +{ + struct S x; + struct S *c = &x; + float z, *k = &z; + if (a) + c = &b.s; + b.s.w = 3; + /* This call should NOT be marked as clobbering 'x' and 'b'. */ + x = bar1 (*c, *c); +#if 0 + if (b.s.w != 3) + link_error (); +#endif +} + +int main () +{ + struct T b; + foo (3, b); + foo1 (3, b); + return 0; +} diff --git a/test/dg/pr20100.c b/test/dg/pr20100.c new file mode 100644 index 0000000..988fbda --- /dev/null +++ b/test/dg/pr20100.c @@ -0,0 +1,32 @@ +/* { dg-do run } */ +/* { dg-options "-O2" } */ + +int func_pure (void) __attribute__ ((pure)); +void func_other (int); +int global_int; +void abort (); +void func_other(int a) +{ + if (a != global_int) + abort (); + global_int++; +} + +int func_pure(void) +{ + return global_int; +} + +int +func_loop (int arg) +{ + // global_int ++; + while (arg--) + func_other (func_pure ()); +} + +int main(void) +{ + func_loop(10); + return 0; +} diff --git a/test/dg/pr20115.c b/test/dg/pr20115.c new file mode 100644 index 0000000..cea4b48 --- /dev/null +++ b/test/dg/pr20115.c @@ -0,0 +1,28 @@ +/* { dg-do run } */ +/* { dg-options "-O2" } */ + +int func_pure (void); +void func_other (int); +int global_int; +int func_pure (void) { return global_int; } +void func_other (int a) +{ + global_int = a + 1; +} +int f(void) +{ + int a; + a = func_pure(); + func_other (a); + a = func_pure (); // We were removing this function call + return a; +} +void abort (void); + +int main(void) +{ + global_int = 10; + if (f() != 11) + abort (); + return 0; +} diff --git a/test/dg/pr20126.c b/test/dg/pr20126.c new file mode 100644 index 0000000..257832a --- /dev/null +++ b/test/dg/pr20126.c @@ -0,0 +1,50 @@ +/* dg-do run */ +/* dg-options "-O2" */ + +/* PR target/20126 was not really target-specific, but rather a loop's + failure to take into account the possibility that a DEST_ADDR giv + replacement might fail, such as when you attempt to replace a REG + with a PLUS in one of the register_operands of cmpstrqi_rex_1. */ + +extern void abort (void); + +typedef struct { int a; char b[3]; } S; +S c = { 2, "aa" }, d = { 2, "aa" }; + +void * +bar (const void *x, int y, int z) +{ + return (void *) 0; +} + +int +foo (S *x, S *y) +{ + const char *e, *f, *g; + int h; + + h = y->a; + f = y->b; + e = x->b; + + if (h == 1) + return bar (e, *f, x->a) != 0; + + g = e + x->a - h; + while (e <= g) + { + const char *t = e + 1; + if (__builtin_memcmp (e, f, h) == 0) + return 1; + e = t; + } + return 0; +} + +int +main (void) +{ + if (foo (&c, &d) != 1) + abort (); + return 0; +} diff --git a/test/dg/pr23518.c b/test/dg/pr23518.c new file mode 100644 index 0000000..3c6bd27 --- /dev/null +++ b/test/dg/pr23518.c @@ -0,0 +1,21 @@ +/* PR tree-optimization/23518. + make_range used to transform a + 1 < 0 into a < -1 even when a is + signed and -fwrapv is given. Make sure that no longer happens. */ + +/* { dg-do run } */ +/* { dg-options "-O2 -fwrapv" } */ + +#include + +extern void abort (void); +extern void exit (int); + +int +main (void) +{ + int a = INT_MAX; + if ((a < 0) || (a + 1 < 0)) + exit (0); + + abort (); +} diff --git a/test/dg/pr23818.c b/test/dg/pr23818.c new file mode 100644 index 0000000..be0bb9a --- /dev/null +++ b/test/dg/pr23818.c @@ -0,0 +1,33 @@ +/* PR tree-optimization/23818 */ +/* { dg-do run } */ +/* { dg-options "-O2 -fno-tree-dominator-opts" } */ + +#include + +extern void abort (void); + +void +foo (int p[100], int k, ...) +{ + int j, *q; + va_list ap; + + va_start (ap, k); + q = va_arg (ap, int *); + for (j = 0; j < 100; j++) + q[j] = p[j] + 10; + va_end(ap); +} + +int +main (void) +{ + int buf[100], buf2[100], i; + for (i = 0; i < 100; i++) + buf[i] = i + 1; + foo (buf, 0, buf2); + for (i = 0; i < 100; i++) + if (buf2[i] != buf[i] + 10) + abort (); + return 0; +} diff --git a/test/dg/pr26719.c b/test/dg/pr26719.c new file mode 100644 index 0000000..3c87df1 --- /dev/null +++ b/test/dg/pr26719.c @@ -0,0 +1,21 @@ +/* { dg-do compile } */ +/* { dg-do run } */ +/* { dg-options "-O2" } */ + +void abort (void); + +int table[32][256]; + +int main(void) +{ + int i, j; + + for (i = 0; i < 32; i++) + for (j = 0; j < 256; j++) + table[i][j] = ((signed char)j) * i; + + if (table[9][132] != -1116) + abort (); + + return 0; +} diff --git a/test/dg/pr26729-1.c b/test/dg/pr26729-1.c new file mode 100644 index 0000000..2f55ef7 --- /dev/null +++ b/test/dg/pr26729-1.c @@ -0,0 +1,16 @@ +/* { dg-do run } */ +/* { dg-options "-O2" } */ + +void abort(void); + +__attribute__((noinline)) +int f (unsigned short word) { + return (word & 0x1) && (((unsigned short) (word & 0x8000)) == 0x8000); +} + +int main(void) { + if (!f(0x8001)) + abort(); + return 0; +} + diff --git a/test/dg/pr27003.c b/test/dg/pr27003.c new file mode 100644 index 0000000..5e416f4 --- /dev/null +++ b/test/dg/pr27003.c @@ -0,0 +1,31 @@ +/* { dg-do compile } */ +/* { dg-do run } */ +/* { dg-options "-Os" } */ + +unsigned int +foo (unsigned int x) +{ + unsigned int r = x; + while (--x) + r *= x; + return r; +} + +unsigned long long +bar (unsigned long long x) +{ + unsigned long long r = x; + while (--x) + r *= x; + return r; +} + +extern void abort (void); + +int +main (void) +{ + if (foo (5) != 120 || bar (5) != 120) + abort (); + return 0; +} diff --git a/test/dg/pr27363.c b/test/dg/pr27363.c new file mode 100644 index 0000000..40a3c6b --- /dev/null +++ b/test/dg/pr27363.c @@ -0,0 +1,39 @@ +/* PR27363. CSE was breaking on the arm store multiple insn used for + structure copies. */ +/* { dg-do run } */ +/* { dg-options "-Os" } */ +extern void abort (void); + +struct snd_mask { + unsigned int bits[6]; +}; + +static int __attribute__((noinline)) +snd_mask_refine(struct snd_mask *mask) +{ + struct snd_mask old; + + old = *mask; + if (mask->bits[0]==0 && mask->bits[1]==0) + return 1; + + return old.bits[0] != mask->bits[0]; +} + +int main(int argc, char *argv[]) +{ + struct snd_mask mask; + + + mask.bits[0] = 23; + mask.bits[1] = 42; + mask.bits[2] = 0; + mask.bits[3] = 0; + mask.bits[4] = 0; + mask.bits[5] = 0; + + + if (snd_mask_refine(&mask)) + abort(); + return 0; +} diff --git a/test/dg/pr27671-2.c b/test/dg/pr27671-2.c new file mode 100644 index 0000000..7882042 --- /dev/null +++ b/test/dg/pr27671-2.c @@ -0,0 +1,24 @@ +/* PR rtl-optimization/27671. + The combiner used to simplify "a ^ b == a" to "a" via + simplify_relational_operation_1 in simplify-rtx.c. */ +/* { dg-do run } */ +/* { dg-options "-O1" } */ +/* { dg-options "-O1 -march=pentium4" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */ + +extern void abort (void) __attribute__ ((noreturn)); +extern void exit (int) __attribute__ ((noreturn)); + +static void __attribute__ ((noinline)) +bar (int k) +{ + int n = k % 2; + if (n == 0) + abort (); +} + +int +main (void) +{ + bar (1); + exit (0); +} diff --git a/test/dg/pr27758.c b/test/dg/pr27758.c new file mode 100644 index 0000000..d385fc5 --- /dev/null +++ b/test/dg/pr27758.c @@ -0,0 +1,24 @@ +/* PR target/27758 */ +/* { dg-do run { target fpic } } */ +/* { dg-options "-O0 -fpic" } */ + +typedef int (*fn) (void); + +static inline int +foo (void) +{ + return 1; +} + +fn +test (void) +{ + return foo; +} + +int +main (void) +{ + fn f = test (); + return f () != 1; +} diff --git a/test/dg/pr27959-2.c b/test/dg/pr27959-2.c new file mode 100644 index 0000000..c70dade --- /dev/null +++ b/test/dg/pr27959-2.c @@ -0,0 +1,94 @@ +/* PR middle-end/27959 */ +/* { dg-do run { target { stdint_types } } } */ +/* { dg-options "-O2" } */ +/* { dg-options "-O2 -mtune=z990" { target s390*-*-* } } */ + +#include +extern void abort (void); + +struct B +{ + unsigned int b1, b2, b3; + char b4; +}; + +struct C +{ + char c1; +}; + +struct D +{ + char *d1; + struct C **d2; + unsigned int d3; +}; + +void +__attribute__((noinline)) +foo (void *x, struct B *y, unsigned int *z) +{ + if (x) + abort (); + if (y->b1 != 7 || y->b2 != 5 || y->b3 != 3 || y->b4) + abort (); + if (*z != 2) + abort (); +} + +int +__attribute__((noinline)) +baz (unsigned int *x, unsigned int y) +{ + //asm volatile ("" : : "r" (&x), "r" (&y) : "memory"); + return *x + y; +} + +inline int bar (unsigned int *x, unsigned int y) +{ + if (y < *x) + return 0; + return baz (x, y); +} + +unsigned int * +__attribute__((noinline)) +test (struct D *x, unsigned int *y) +{ + struct B b; + uint32_t c; + + bar (y, x->d3); + if ((*(x->d2))->c1) + c = ((uint32_t) x->d1[0] + + ((uint32_t) x->d1[1] << 8) + + ((uint32_t) x->d1[2] << 16) + + ((uint32_t) x->d1[3] << 24)); + else + { + int32_t d; + ((char *) &d)[0] = x->d1[0]; + ((char *) &d)[1] = x->d1[1]; + ((char *) &d)[2] = x->d1[2]; + ((char *) &d)[3] = x->d1[3]; + c = d; + } + b.b4 = 0; + b.b1 = c / 10000L % 10000; + b.b2 = c / 100 % 100; + b.b3 = c % 100; + foo (0, &b, y); + return y; +} + +int +main (void) +{ + uint32_t x = 900070503; + unsigned int y = 2; + struct C c = { 0 }, *cptr = &c; + struct D d = { (char *) &x, &cptr, 0 }; + if (test (&d, &y) != &y) + abort (); + return 0; +} diff --git a/test/dg/pr27959.c b/test/dg/pr27959.c new file mode 100644 index 0000000..9680438 --- /dev/null +++ b/test/dg/pr27959.c @@ -0,0 +1,93 @@ +/* PR middle-end/27959 */ +/* { dg-do run { target { int32plus } } } */ +/* { dg-options "-O2" } */ +/* { dg-options "-O2 -mtune=z990" { target s390*-*-* } } */ + +extern void abort (void); + +struct B +{ + unsigned long long b1, b2, b3; + char b4; +}; + +struct C +{ + char c1; +}; + +struct D +{ + char *d1; + struct C **d2; + unsigned long long d3; +}; + +void +__attribute__((noinline)) +foo (void *x, struct B *y, unsigned long long *z) +{ + if (x) + abort (); + if (y->b1 != 7 || y->b2 != 5 || y->b3 != 3 || y->b4) + abort (); + if (*z != 2) + abort (); +} + +long long +__attribute__((noinline)) +baz (unsigned long long *x, unsigned long long y) +{ + //asm volatile ("" : : "r" (&x), "r" (&y) : "memory"); + return *x + y; +} + +inline long long bar (unsigned long long *x, unsigned long long y) +{ + if (y < *x) + return 0; + return baz (x, y); +} + +unsigned long long * +__attribute__((noinline)) +test (struct D *x, unsigned long long *y) +{ + struct B b; + unsigned long long c; + + bar (y, x->d3); + if ((*(x->d2))->c1) + c = ((unsigned char) x->d1[0] + + ((unsigned char) x->d1[1] << 8) + + ((unsigned char) x->d1[2] << 16) + + ((short) x->d1[3] << 24)); + else + { + long long d; + ((char *) &d)[0] = x->d1[0]; + ((char *) &d)[1] = x->d1[1]; + ((char *) &d)[2] = x->d1[2]; + ((char *) &d)[3] = x->d1[3]; + c = d; + } + b.b4 = 0; + b.b1 = c / 10000L % 10000; + b.b2 = c / 100 % 100; + b.b3 = c % 100; + foo (0, &b, y); + return y; +} + +int +main (void) +{ + unsigned long long x = 900070503; + unsigned long long y = 2; + struct C c = { 0 }, *cptr = &c; + struct D d = { (char *) &x, &cptr, 0 }; + if (test (&d, &y) != &y) + abort (); + return 0; +} diff --git a/test/dg/pr28726.c b/test/dg/pr28726.c new file mode 100644 index 0000000..11232ac --- /dev/null +++ b/test/dg/pr28726.c @@ -0,0 +1,29 @@ +/* PR rtl-optimization/28726 */ +/* Origin: Sigurd Schneider */ + +/* { dg-do run } */ +/* { dg-options "-O2 -fsched2-use-superblocks" } */ + +extern void abort (void); + +static double my_loop(void) __attribute__((noinline)); + +static double my_loop(void) +{ + double retval = 0.0; + const unsigned char *start = "\005\b\000"; + const unsigned char *const end = start + 2; + + while (start < end) + retval += *start++; + + return retval; +} + +int main(void) +{ + if (my_loop() != 13.0) + abort (); + + return 0; +} diff --git a/test/dg/pr29581-1.c b/test/dg/pr29581-1.c new file mode 100644 index 0000000..e540073 --- /dev/null +++ b/test/dg/pr29581-1.c @@ -0,0 +1,44 @@ +/* PR tree-optimization/29581 */ +/* Origin: gcc.dg/vect/vect-85.c */ +/* { dg-do run } */ +/* { dg-options "-O2 -ftree-loop-linear" } */ + +extern void abort (void); + +#define N 16 + +int main1 (int *a) +{ + int i, j, k; + int b[N]; + + for (i = 0; i < N; i++) + { + for (j = 0; j < N; j++) + { + k = i + N; + a[j] = k; + } + b[i] = k; + } + + + for (j = 0; j < N; j++) + if (a[j] != i + N - 1) + abort(); + + for (j = 0; j < N; j++) + if (b[j] != j + N) + abort(); + + return 0; +} + +int main (void) +{ + int a[N] __attribute__ ((__aligned__(16))); + + main1 (a); + + return 0; +} diff --git a/test/dg/pr29581-2.c b/test/dg/pr29581-2.c new file mode 100644 index 0000000..c99d78c --- /dev/null +++ b/test/dg/pr29581-2.c @@ -0,0 +1,46 @@ +/* PR tree-optimization/29581 */ +/* Origin: gcc.dg/vect/vect-86.c */ +/* { dg-do run } */ +/* { dg-options "-O2 -ftree-loop-linear" } */ + +extern void abort (void); + +#define N 16 + +int main1 (int n) +{ + int i, j, k; + int a[N], b[N]; + + for (i = 0; i < n; i++) + { + for (j = 0; j < n; j++) + { + k = i + n; + a[j] = k; + } + b[i] = k; + } + + + for (j = 0; j < n; j++) + if (a[j] != i + n - 1) + abort(); + + for (i = 0; i < n; i++) + if (b[i] != i + n) + abort(); + + return 0; +} + +int main (void) +{ + main1 (N); + main1 (0); + main1 (1); + main1 (2); + main1 (N-1); + + return 0; +} diff --git a/test/dg/pr29581-3.c b/test/dg/pr29581-3.c new file mode 100644 index 0000000..c9d72ce --- /dev/null +++ b/test/dg/pr29581-3.c @@ -0,0 +1,48 @@ +/* PR tree-optimization/29581 */ +/* Origin: gcc.dg/vect/vect-87.c */ +/* { dg-do run } */ +/* { dg-options "-O2 -ftree-loop-linear" } */ + +extern void abort (void); + +#define N 16 + +int main1 (int n, int *a) +{ + int i, j, k; + int b[N]; + + for (i = 0; i < n; i++) + { + for (j = 0; j < n; j++) + { + k = i + n; + a[j] = k; + } + b[i] = k; + } + + + for (j = 0; j < n; j++) + if (a[j] != i + n - 1) + abort(); + + for (j = 0; j < n; j++) + if (b[j] != j + n) + abort(); + + return 0; +} + +int main (void) +{ + int a[N] __attribute__ ((__aligned__(16))); + + main1 (N, a); + main1 (0, a); + main1 (1, a); + main1 (2, a); + main1 (N-1, a); + + return 0; +} diff --git a/test/dg/pr29581-4.c b/test/dg/pr29581-4.c new file mode 100644 index 0000000..c2d894c --- /dev/null +++ b/test/dg/pr29581-4.c @@ -0,0 +1,48 @@ +/* PR tree-optimization/29581 */ +/* Origin: gcc.dg/vect/vect-88.c */ +/* { dg-do run } */ +/* { dg-options "-O2 -ftree-loop-linear" } */ + +extern void abort (void); + +#define N 16 + +int main1 (int n, int *a) +{ + int i, j, k; + int b[N]; + + for (i = 0; i < n; i++) + { + for (j = 0; j < n; j++) + { + k = i + n; + a[j] = k; + } + b[i] = k; + } + + + for (j = 0; j < n; j++) + if (a[j] != i + n - 1) + abort(); + + for (j = 0; j < n; j++) + if (b[j] != j + n) + abort(); + + return 0; +} + +int main (void) +{ + int a[N+1] __attribute__ ((__aligned__(16))); + + main1 (N, a+1); + main1 (0, a+1); + main1 (1, a+1); + main1 (2, a+1); + main1 (N-1, a+1); + + return 0; +} diff --git a/test/dg/pr29683.c b/test/dg/pr29683.c new file mode 100644 index 0000000..4bed679 --- /dev/null +++ b/test/dg/pr29683.c @@ -0,0 +1,43 @@ +/* { dg-do run } */ +/* { dg-options "-Os -fno-inline-functions" } */ + +void abort (void); + +typedef struct { + int x[7]; +} agg7; + +typedef struct { + int mbr1; + int mbr2; +} agg2; + +int expected = 31415; +agg7 filler; + +int GetConst (agg7 filler, agg2 split) +{ + return expected; +} + +void VerifyValues (agg7 filler, int last_reg, int first_stack, int second_stack) +{ + if (first_stack != 123 || second_stack != expected) + abort (); +} + +void RunTest (agg2 a) +{ + int result; + + result = GetConst (filler, a); + VerifyValues (filler, 0, a.mbr1, result); +} + +int main(void) +{ + agg2 result = {123, 456}; + RunTest (result); + return 0; +} + diff --git a/test/dg/pr30286.c b/test/dg/pr30286.c new file mode 100644 index 0000000..9ec49b4 --- /dev/null +++ b/test/dg/pr30286.c @@ -0,0 +1,37 @@ +/* PR middle-end/30286 */ +/* { dg-do run } */ +/* { dg-options "-O2 -ftrapv" } */ + +extern void abort (void); +struct S { struct S *s; }; +struct T { struct S *t[25]; }; + +void +__attribute__((noinline)) +foo (int i, struct T *x, struct S *y) +{ + int j; + for (j = 14; j > i; j--) + x->t[j] = y->s; +} + +int +main (void) +{ + struct S s; + struct T t; + int i; + + s.s = &s; + __builtin_memset (&t, 0, sizeof (t)); + foo (6, &t, &s); + for (i = 0; i < 25; i++) + if (t.t[i] != ((i > 6 && i <= 14) ? &s : (struct S *) 0)) + abort (); + __builtin_memset (&t, 0, sizeof (t)); + foo (-1, &t, &s); + for (i = 0; i < 25; i++) + if (t.t[i] != ((i >= 0 && i <= 14) ? &s : (struct S *) 0)) + abort (); + return 0; +} diff --git a/test/dg/pr32450.c b/test/dg/pr32450.c new file mode 100644 index 0000000..9606e30 --- /dev/null +++ b/test/dg/pr32450.c @@ -0,0 +1,36 @@ +/* Contributed by Joost VandeVondele */ + +/* { dg-do run } */ +/* { dg-require-profiling "-pg" } */ +/* { dg-options "-O2 -pg" } */ +/* { dg-options "-O2 -pg -mtune=core2" { target { i?86-*-* x86_64-*-* } } } */ +/* { dg-options "-O2 -pg -static" { target hppa*-*-hpux* } } */ + +extern void abort (void); + +int stack_pointer; + +void +__attribute__((noinline)) +mystop () +{ + abort (); +} + +void +__attribute__((noinline)) +add () +{ + if (stack_pointer + 1 > 10) + mystop (); + + stack_pointer = stack_pointer + 1; +} + +int main () +{ + add (); + return stack_pointer - 1; +} + +/* { dg-final { cleanup-profile-file } } */ diff --git a/test/dg/pr32912-1.c b/test/dg/pr32912-1.c new file mode 100644 index 0000000..1ceb77a --- /dev/null +++ b/test/dg/pr32912-1.c @@ -0,0 +1,45 @@ +/* PR middle-end/32912 */ +/* { dg-do run } */ +/* { dg-options "-O2 -w" } */ +/* { dg-options "-O2 -w -fno-common" { target hppa*-*-hpux* } } */ + +extern void abort (void); + +typedef int __m128i __attribute__ ((__vector_size__ (16))); + +__m128i a, b, c, d, e, f; + +void +foo (__m128i x) +{ + a = x ^ ~x; + b = ~x ^ x; + c = x | ~x; + d = ~x | x; + e = x & ~x; + f = ~x & x; +} + +int +main (void) +{ + union { __m128i v; int i[sizeof (__m128i) / sizeof (int)]; } u; + int i; + + for (i = 0; i < sizeof (u.i) / sizeof (u.i[0]); i++) + u.i[i] = i * 49 - 36; + foo (u.v); +#define check(x, val) \ + u.v = (x); \ + for (i = 0; i < sizeof (u.i) / sizeof (u.i[0]); i++) \ + if (u.i[i] != (val)) \ + abort () + + check (a, ~0); + check (b, ~0); + check (c, ~0); + check (d, ~0); + check (e, 0); + check (f, 0); + return 0; +} diff --git a/test/dg/pr33017.c b/test/dg/pr33017.c new file mode 100644 index 0000000..851fe71 --- /dev/null +++ b/test/dg/pr33017.c @@ -0,0 +1,30 @@ +/* PR tree-optimization/33017 */ +/* { dg-do run } */ +/* { dg-options "-O2 -ftree-vectorize" } */ + +extern __SIZE_TYPE__ strlen (const char *); +extern void abort (void); + +char * +__attribute__((noinline)) +foo (const char *string) +{ + int len; + static char var[0x104]; + int off; + len = strlen (string); + for (off = 0; off < 64; off++) + var[len + off + 2] = 0x57; + return var; +} + +int +main (void) +{ + char *p = foo ("abcd"); + int i; + for (i = 0; i < 0x104; i++) + if (p[i] != ((i >= 6 && i < 70) ? 0x57 : 0)) + abort (); + return 0; +} diff --git a/test/dg/pr33676.c b/test/dg/pr33676.c new file mode 100644 index 0000000..af65478 --- /dev/null +++ b/test/dg/pr33676.c @@ -0,0 +1,51 @@ +/* { dg-do run } */ +/* { dg-options "-O0 -mtune=i386 -fomit-frame-pointer" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */ + +__attribute__((noreturn,noinline)) void abrt (const char *fi, const char *fu) +{ + __builtin_abort (); +} + +__attribute__((noinline)) int f (int k) +{ + return k; +} + +__attribute__((noinline)) int g (int t, int k) +{ + int b; + + switch (t) + { + case 0: + abrt (__FILE__, __FUNCTION__); + + case 1: + b = f (k); + break; + + case 2: + b = f (k); + break; + + case 3: + b = f (k); + break; + + case 4: + b = f (k); + break; + + default: + abrt (__FILE__, __FUNCTION__); + } + + return b; +} + +int main (void) +{ + if (g (3, 1337) != 1337) + abrt (__FILE__, __FUNCTION__); + return 0; +} diff --git a/test/dg/pr9814-1.c b/test/dg/pr9814-1.c new file mode 100644 index 0000000..51b79f7 --- /dev/null +++ b/test/dg/pr9814-1.c @@ -0,0 +1,107 @@ +/* PR tree-optimization/9814 */ +/* { dg-do run } */ +/* { dg-options "-O2" } */ + +extern void abort(void); + +int test1(int x) +{ + if (x & 2) + x |= 2; + return x; +} + +int test2(int x) +{ + if (!(x & 2)) + x |= 2; + return x; +} + +int test3(int x) +{ + if (x & 2) + x ^= 2; + return x; +} + +int test4(int x) +{ + if (!(x & 2)) + x ^= 2; + return x; +} + +int test5(int x) +{ + if (x & 2) + x &= ~2; + return x; +} + +int test6(int x) +{ + if (!(x & 2)) + x &= ~2; + return x; +} + +int main() +{ + if (test1(0) != 0) + abort(); + if (test1(2) != 2) + abort(); + if (test1(5) != 5) + abort(); + if (test1(7) != 7) + abort(); + + if (test2(0) != 2) + abort(); + if (test2(2) != 2) + abort(); + if (test2(5) != 7) + abort(); + if (test2(7) != 7) + abort(); + + if (test3(0) != 0) + abort(); + if (test3(2) != 0) + abort(); + if (test3(5) != 5) + abort(); + if (test3(7) != 5) + abort(); + + if (test4(0) != 2) + abort(); + if (test4(2) != 2) + abort(); + if (test4(5) != 7) + abort(); + if (test4(7) != 7) + abort(); + + if (test5(0) != 0) + abort(); + if (test5(2) != 0) + abort(); + if (test5(5) != 5) + abort(); + if (test5(7) != 5) + abort(); + + if (test6(0) != 0) + abort(); + if (test6(2) != 2) + abort(); + if (test6(5) != 5) + abort(); + if (test6(7) != 7) + abort(); + + return 0; +} + diff --git a/test/dg/pragma-align.c b/test/dg/pragma-align.c new file mode 100644 index 0000000..b00ed75 --- /dev/null +++ b/test/dg/pragma-align.c @@ -0,0 +1,47 @@ +/* Prove that HANDLE_SYSTEMV_PRAGMA alignment handling works somewhat. */ + +/* { dg-do run { target i?86-*-linux* x86_64-*-linux* i?86-*-*bsd* i?86-*-sco3.2v5* *-*-solaris2.* } } */ + +extern void abort (void); + +struct { + char one; + long two; +} defaultalign; + +#if defined(__LP64__) +#pragma pack(8) +#else +#pragma pack(4) +#endif +struct { + char one; + long two; +} sixteen; + +#pragma pack(1) +struct { + char one; + long two; +} two; + +#pragma pack(2) +struct { + char one; + long two; +} three; + +#pragma pack() +struct { + char one; + long two; +} resetalign; + +main() +{ + if(sizeof(sixteen) < sizeof(defaultalign)) abort(); + if(sizeof(two) >= sizeof(defaultalign)) abort(); + if(sizeof(three) <= sizeof(two)) abort(); + if(sizeof(resetalign) != sizeof(defaultalign)) abort(); + return 0; +} diff --git a/test/dg/pragma-pack-2.c b/test/dg/pragma-pack-2.c new file mode 100644 index 0000000..f44f8db --- /dev/null +++ b/test/dg/pragma-pack-2.c @@ -0,0 +1,48 @@ +/* On Solaris, #pragma pack should accept macro expansion. */ + +/* { dg-do run { target *-*-solaris2.* } } */ + +extern void abort (void); + +struct { + char one; + long two; +} defaultalign; + +#define ALIGNHIGH 16 + +#pragma pack(ALIGNHIGH) +struct { + char one; + long two; +} sixteen; + +#define ALIGN1(X) 1 +#pragma pack(ALIGN1(4)) +struct { + char one; + long two; +} two; + +#define ALIGN2(X) X +#pragma pack(ALIGN2(2)) +struct { + char one; + long two; +} three; + +#define EMPTY +#pragma pack(EMPTY) +struct { + char one; + long two; +} resetalign; + +main() +{ + if(sizeof(sixteen) < sizeof(defaultalign)) abort(); + if(sizeof(two) >= sizeof(defaultalign)) abort(); + if(sizeof(three) <= sizeof(two)) abort(); + if(sizeof(resetalign) != sizeof(defaultalign)) abort(); + return 0; +} diff --git a/test/dg/pragma-pack-3.c b/test/dg/pragma-pack-3.c new file mode 100644 index 0000000..e276bd0 --- /dev/null +++ b/test/dg/pragma-pack-3.c @@ -0,0 +1,27 @@ +/* PR c++/25294 */ +/* { dg-options "-std=gnu99" } */ +/* { dg-do run } */ + +extern void abort (void); + +struct S +{ + char a[3]; +#pragma pack(1) /* A block comment + that ends on the next line. */ + struct T + { + char b; + int c; + } d; +#pragma pack /*/ */ () // C++ comment + int e; +} s; + +int +main () +{ + if (sizeof (int) == 4 && sizeof (s) != 12) + abort (); + return 0; +} diff --git a/test/dg/range-test-1.c b/test/dg/range-test-1.c new file mode 100644 index 0000000..ed74945 --- /dev/null +++ b/test/dg/range-test-1.c @@ -0,0 +1,168 @@ +/* Test fold-const.c (fold_range_test) optimizations. */ +/* { dg-do run } */ +/* { dg-options "-O2" } */ + +#include +//#include +#include + +#if (INT_MAX == 2147483647) && (INT_MIN == -2147483648) \ + && (SCHAR_MIN == -128) && (SCHAR_MAX == 127) \ + && (UCHAR_MIN == 0) && (UCHAR_MAX == 255) + +#ifndef T + +enum integers +{ + int_smallest = INT_MIN, + int_2ndsmallest = INT_MIN + 1, + int_3rdsmallest = INT_MIN + 2, + int_minus2 = -2, + int_minus1 = -1, + int_zero = 0, + int_one = 1, + int_two = 2, + int_3rdlargest = INT_MAX - 2, + int_2ndlargest = INT_MAX - 1, + int_largest = INT_MAX +}; + +int var; +void +check (void) +{ + ++var; +} + +#define T(IDX, TYPE, TEST, YESARR, NOARR) \ +void __attribute__((noinline)) \ +test##IDX (TYPE x) \ +{ \ + if (TEST) \ + check (); \ +} +#include "range-test-1.c" +#undef T + +int +main (void) +{ + int i, fails = 0; + +#define C , +#define T(IDX, TYPE, TEST, YESARR, NOARR) \ + { \ + static TYPE yesarr##IDX [] = YESARR; \ + static TYPE noarr##IDX [] = NOARR; \ + for (i = 0; i < (int) (sizeof (yesarr##IDX) / sizeof (TYPE)); ++i) \ + { \ + var = 0; \ + test##IDX (yesarr##IDX [i]); \ + if (var != 1) \ + printf ("test" #IDX " failed for yesarr [%u]\n", i), ++fails; \ + } \ + var = 0; \ + for (i = 0; i < (int) (sizeof (noarr##IDX) / sizeof (TYPE)); ++i) \ + { \ + test##IDX (noarr##IDX [i]); \ + if (var != 0) \ + printf ("test" #IDX " failed for noarr [%u]\n", i), ++fails; \ + } \ + } +#include "range-test-1.c" +#undef T + + if (fails) + abort (); + + exit (0); +} + +#else + +/* Use `C' instead of `,' below to separate array entries. */ + +/* These ought to be all optimized into single comparison. */ +T(1, unsigned int, x == 0 || x == 1, + { 0 C 1 }, { -1U C 2 C 12 C 35 C 0x7fffffff C 0x80000000 }) +T(2, unsigned int, x == 0 || x == -1U || x == -2U, + { 0 C -1U C -2U }, { -3U C -6U C 1 C 2 C 12 C 35 C 0x7fffffff C 0x80000000 }) +T(3, unsigned int, x == 0 || x == 1 || x == 2, + { 0 C 1 C 2 }, { -3U C -6U C -1U C -2U C 12 C 35 C 0x7fffffff C 0x80000000 }) +T(4, unsigned int, x == 3 || x == 4 || x == 5 || x == 6, + { 3 C 4 C 5 C 6 }, { -3U C 0 C 1 C 2 C 7 C 8 C 12 C 0x7fffffff C 0x80000000 }) +T(5, unsigned int, x == -3U || x == -4U || x == -5U || x == -6U, + { -3U C -4U C -5U C -6U }, { -7U C -8U C -2U C -1U C 1 C 2 C 0x7fffffff C 0x80000000 }) +T(6, unsigned int, x == -3U || x == -4U || x == -5U, + { -3U C -4U C -5U }, { -6U C -7U C -8U C -2U C -1U C 1 C 2 C 0x7fffffff C 0x80000000 }) +T(7, char *, x == (char *) -3UL || x == (char *) -4UL || x == (char *) -5UL, + { (char *) -3UL C (char *) -4UL C (char *) -5UL }, + { (char *) -6UL C (char *) -20UL C (char *) -2UL C (char *) -1UL C (char *) 0 + C (char *) 1UL C (char *) 35UL C (char *) 0x7fffffffUL C (char *) 0x80000000UL }) +T(8, unsigned long, x == -2UL || x == -1UL || x == 0, + { 0 C -1UL C -2UL }, { -3UL C -6UL C 1 C 2 C 12 C 35 C 0x7fffffff C 0x80000000 }) +T(9, unsigned long, x >= -4UL || x <= 8, + { -4UL C -3UL C -2UL C -1UL C 0 C 1 C 2 C 3 C 4 C 5 C 6 C 7 C 8 }, + { -7UL C -5UL C 9 C 10 C 61 C 127 C 0x7fffffff C 0x80000000 }) +T(10, signed char, x == 0 || x == -1 || x == -2 || x == -3, + { 0 C -1 C -2 C -3 }, { -4 C -5 C 1 C 2 C 3 C 35 C -24 }) +T(11, int, x == 0 || x == 1, + { 0 C 1 }, { -1 C 2 C 12 C 35 C INT_MAX C INT_MIN }) +T(12, int, x == 0 || x == -1 || x == -2, + { 0 C -1 C -2 }, { -3 C -6 C 1 C 2 C 12 C 35 C INT_MAX C INT_MIN }) +T(13, int, x == 0 || x == 1 || x == 2, + { 0 C 1 C 2 }, { -3 C -6 C -1 C -2 C 12 C 35 C INT_MAX C INT_MIN }) +T(14, int, x == 3 || x == 4 || x == 5 || x == 6, + { 3 C 4 C 5 C 6 }, { -3 C 0 C 1 C 2 C 7 C 8 C 12 C INT_MAX C INT_MIN }) +T(15, int, x == -3 || x == -4 || x == -5 || x == -6, + { -3 C -4 C -5 C -6 }, { -7 C -8 C -2 C -1 C 1 C 2 C INT_MAX C INT_MIN }) +T(16, int, x == -3 || x == -4 || x == -5, + { -3 C -4 C -5 }, { -6 C -7 C -8 C -2 C -1 C 1 C 2 C INT_MAX C INT_MIN }) +T(17, unsigned int, (x >= -8U && x <= -3U) || x == -2U || x == -1U || x == 0 || x == 1 || x == 2, + { -8U C -7U C -6U C -5U C -4U C -3U C -2U C -1U C 0 C 1 C 2 }, + { -9U C -10U C 3 C 4 C 12 C -54U C INT_MAX C INT_MIN }) +T(18, int, (x >= -8 && x <= -3) || x == -2 || x == -1 || x == 0 || x == 1 || x == 2, + { -8 C -7 C -6 C -5 C -4 C -3 C -2 C -1 C 0 C 1 C 2 }, + { -9 C -10 C 3 C 4 C 12 C -54 C INT_MAX C INT_MIN }) +T(19, unsigned long, (x >= 0 && x <= 16) || (x >= 18 && x <= -1UL), + { -3UL C -6UL C -1UL C 0 C 1 C 2 C 12 C 15 C 16 C 18 C 19 C 35 C 0x7fffffff + C 0x80000000 }, { 17 }) +T(20, char *, x == (char *) -1UL || x == 0, + { (char *) -1UL C 0 }, { (char *) -6UL C (char *) -20UL C (char *) -2UL + C (char *) 1UL C (char *) 35UL C (char *) 0x7fffffffUL C (char *) 0x80000000UL }) +T(21, enum integers, x == int_zero || x == int_one, + { int_zero C int_one }, { int_minus1 C int_two C 12 C 35 C int_largest C int_smallest }) +T(22, int, x == INT_MIN || x == INT_MAX, + { INT_MIN C INT_MAX }, + { -1 C 0 C 1 C INT_MAX - 1 C INT_MAX - 2 C INT_MIN + 1 C INT_MIN + 2 }) +T(23, int, x == INT_MIN + 1 || x == INT_MIN + 2 || x == INT_MIN || x == INT_MAX, + { INT_MIN + 1 C INT_MIN + 2 C INT_MIN C INT_MAX }, + { -1 C 0 C 1 C INT_MAX - 1 C INT_MAX - 2 C INT_MIN + 3 C INT_MIN + 4 }) +T(24, signed char, x == SCHAR_MIN || x == SCHAR_MAX, + { SCHAR_MIN C SCHAR_MAX }, + { -1 C 0 C 1 C SCHAR_MAX - 1 C SCHAR_MAX - 2 C SCHAR_MIN + 1 C SCHAR_MIN + 2 }) +T(25, enum integers, x == int_smallest || x == int_largest, + { int_smallest C int_largest }, { int_minus1 C int_zero C int_one + C int_2ndsmallest C int_2ndlargest C int_3rdsmallest C int_3rdlargest }) + +/* This should be optimized into unconditional jump. */ +T(o1, unsigned long, (x >= 0 && x <= 16) || (x >= 17 && x <= -1UL), + { -3UL C -6UL C -1UL C 0 C 1 C 2 C 12 C 15 C 16 C 17 C 18 C 19 C 35 C 0x7fffffff + C 0x80000000 }, { }) +T(o2, unsigned long, (x >= 0 && x <= -3UL) || (x == -2UL || x == -1UL), + { -3UL C -6UL C -1UL C 0 C 1 C 2 C 12 C 15 C 16 C 17 C 18 C 19 C 35 C 0x7fffffff + C 0x80000000 }, { }) + +/* This should be eventually optimized into a single comparison. */ +T(td1, unsigned char, x == 0 || x == 4 || x == 1 || x == 5 || x == 2 || x == 6 || x == 3, + { 0 C 1 C 2 C 3 C 4 C 5 C 6 }, { 7 C 8 C 127 C 128 C 254 C 255 }) + +#endif + +#else +int +main (void) +{ + return 0; +} +#endif diff --git a/test/dg/setjmp-3.c b/test/dg/setjmp-3.c new file mode 100644 index 0000000..306861d --- /dev/null +++ b/test/dg/setjmp-3.c @@ -0,0 +1,38 @@ +/* { dg-do run } */ +/* { dg-options "-O" } */ + +#include + +extern void abort (void); + +jmp_buf buf; + +void raise0(void) +{ + __builtin_longjmp (buf, 1); +} + +int execute(int cmd) +{ + int last = 0; + + if (__builtin_setjmp (buf) == 0) + while (1) + { + last = 1; + raise0 (); + } + + if (last == 0) + return 0; + else + return cmd; +} + +int main(void) +{ + if (execute (1) == 0) + abort (); + + return 0; +} diff --git a/test/dg/setjmp-4.c b/test/dg/setjmp-4.c new file mode 100644 index 0000000..53bf0e8 --- /dev/null +++ b/test/dg/setjmp-4.c @@ -0,0 +1,40 @@ +/* { dg-do run } */ +/* { dg-options "-O" } */ + +#include + +extern void abort (void); + +jmp_buf buf; + +void raise0(void) +{ + __builtin_longjmp (buf, 1); +} + +int execute(int cmd) +{ + int last = 0; + + __builtin_setjmp (buf); + + if (last == 0) + while (1) + { + last = 1; + raise0 (); + } + + if (last == 0) + return 0; + else + return cmd; +} + +int main(void) +{ + if (execute (1) == 0) + abort (); + + return 0; +} diff --git a/test/dg/short-compare-1.c b/test/dg/short-compare-1.c new file mode 100644 index 0000000..4c47052 --- /dev/null +++ b/test/dg/short-compare-1.c @@ -0,0 +1,20 @@ +/* PR rtl-optimization/19296 */ +/* Origin: Falk Hueffner */ + +/* { dg-do run } */ +/* { dg-options "-O" } */ +/* { dg-options "-O -mtune=i686" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */ + +extern void abort(void); + +void f(unsigned short ad) +{ + if (ad >= 0x4000 && ad < 0xc000) + abort(); +} + +int main(void) +{ + f(0xff00); + return 0; +} diff --git a/test/dg/short-compare-2.c b/test/dg/short-compare-2.c new file mode 100644 index 0000000..0026a88 --- /dev/null +++ b/test/dg/short-compare-2.c @@ -0,0 +1,21 @@ +/* PR rtl-optimization/19296 */ +/* Origin: Falk Hueffner */ +/* Testcase by Andrew Pinski */ + +/* { dg-do run } */ +/* { dg-options "-O" } */ +/* { dg-options "-O -mtune=i686" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */ + +extern void abort(); + +void f(unsigned short ad) +{ + if ((short) (ad - 0x4000) >= 0) + abort(); +} + +int main(void) +{ + f(0xc000); + return 0; +} diff --git a/test/dg/sibcall-7.c b/test/dg/sibcall-7.c new file mode 100644 index 0000000..6d59ca3 --- /dev/null +++ b/test/dg/sibcall-7.c @@ -0,0 +1,46 @@ +/* Simple check that tail recursive call optimization is also + controlled by -foptimize-sibling-calls. + + Copyright (C) 2006 Free Software Foundation Inc. + Original test by Hans-Peter Nilsson */ + +/* On IA64 the call frame is allocated on the register stack, not the + normal stack. */ + +/* { dg-do run { target { ! "ia64-*-*" } } } */ +/* { dg-options "-O2 -fno-optimize-sibling-calls" } */ + + +extern void abort (void); + +extern void recurser_void (int); +extern void track (int); + +int main (void) +{ + recurser_void (0); + return 0; +} + +void recurser_void (int n) +{ + if (n == 0 || n == 7) + track (n); + + if (n == 10) + return; + + recurser_void (n + 1); +} + +void *trackpoint; + +void track (int n) +{ + char stackpos[1]; + + if (n == 0) + trackpoint = stackpos; + else if (n != 7 || trackpoint == stackpos) + abort (); +} diff --git a/test/dg/sibcall-8.c b/test/dg/sibcall-8.c new file mode 100644 index 0000000..767040f --- /dev/null +++ b/test/dg/sibcall-8.c @@ -0,0 +1,30 @@ +/* { dg-do run } */ +/* { dg-options "-O2 -foptimize-sibling-calls" } */ + +typedef struct { + int data[4]; +} arr16_t; + +int result = 0; + +void func2(int i, int j, arr16_t arr) +{ + result = (arr.data[0] != 1 + || arr.data[1] != 2 + || arr.data[2] != 3 + || arr.data[3] != 4); +} + +void func1(int i, int j, int k, arr16_t a) +{ + func2(i, j, a); +} + +int main(int argc, const char *argv[]) +{ + arr16_t arr = {{1, 2, 3, 4}}; + + func1(0, 0, 0, arr); + return result; +} + diff --git a/test/dg/single-precision-constant.c b/test/dg/single-precision-constant.c new file mode 100644 index 0000000..d37a538 --- /dev/null +++ b/test/dg/single-precision-constant.c @@ -0,0 +1,26 @@ +/* Test that double precision constants are correctly handled + when code is compiled with -fsingle-precision-constant */ +/* Origin: Carlos O'Donell */ + +/* { dg-do run } */ +/* { dg-options "-fsingle-precision-constant" } */ +/* { dg-add-options c99_runtime } */ + +#include +#include + +//#include "builtins-config.h" + +int main (void) +{ + int result = 0; + double local_DBL_MAX = DBL_MAX; + double local_DBL_MIN = DBL_MIN; +#ifdef HAVE_C99_RUNTIME + if (isinf (local_DBL_MAX)) + result |= 1; +#endif + if (local_DBL_MIN <= 0.0) + result |= 1; + return result; +} diff --git a/test/dg/smod-1.c b/test/dg/smod-1.c new file mode 100644 index 0000000..8ff60de --- /dev/null +++ b/test/dg/smod-1.c @@ -0,0 +1,25 @@ +/* PR middle-end/18045 */ +/* Contributed by Eric Botcazou */ + +/* { dg-do run } */ +/* { dg-options "-std=c99" } */ +/* { dg-options "-std=c99 -mtune=i486" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */ + +#include + +extern void abort(void); + +long long smod16(long long x) +{ + return x % 16; +} + +int main(void) +{ +#if LLONG_MAX > 2147483647L + if (smod16 (0xFFFFFFFF) != 0xF) + abort (); +#endif + + return 0; +} diff --git a/test/dg/sms-1.c b/test/dg/sms-1.c new file mode 100644 index 0000000..d915ef5 --- /dev/null +++ b/test/dg/sms-1.c @@ -0,0 +1,38 @@ +/* The same test as loop-3c.c. It failed on ia64 + due to not handling of subreg in the lhs that is fixed. */ +/* { dg-do run } */ +/* { dg-options "-O2 -fmodulo-sched -fmodulo-sched-allow-regmoves -w" } */ + + +#include + +void * a[255]; + +f (m) +{ + int i; + int sh = 0x100; + i = m; + do + { + a[sh >>= 1] = ((unsigned)i << 3) + (char*)a; + i += 4; + } + while (i < INT_MAX/2 + 1 + 4 * 4); +} + +main () +{ + a[0x10] = 0; + a[0x08] = 0; + f (INT_MAX/2 + INT_MAX/4 + 2); + if (a[0x10] || a[0x08]) + abort (); + a[0x10] = 0; + a[0x08] = 0; + f (INT_MAX/2 + 1); + if (! a[0x10] || a[0x08]) + abort (); + exit (0); +} + diff --git a/test/dg/sms-antideps.c b/test/dg/sms-antideps.c new file mode 100644 index 0000000..85976d6 --- /dev/null +++ b/test/dg/sms-antideps.c @@ -0,0 +1,38 @@ +/* This test is a reduced test case for a bug that caused + bootstrapping with -fmodulo-sched. Related to a broken anti-dep + that was not fixed by reg-moves. */ + + /* { dg-do run } */ + /* { dg-options "-O2 -fmodulo-sched -fmodulo-sched-allow-regmoves" } */ + +#include + +unsigned long long +foo (long long ixi, unsigned ctr) +{ + unsigned long long irslt = 1; + long long ix = ixi; + + for (; ctr; ctr--) + { + irslt *= ix; + ix *= ix; + } + + if (irslt != 14348907) + abort (); + return irslt; +} + + +int +main () +{ + unsigned long long res; + + res = foo (3, 4); + return 0; +} + + + diff --git a/test/dg/struct-by-value-1.c b/test/dg/struct-by-value-1.c new file mode 100644 index 0000000..addf253 --- /dev/null +++ b/test/dg/struct-by-value-1.c @@ -0,0 +1,83 @@ +/* Test structure passing by value. */ +/* { dg-do run } */ +/* { dg-options "-O2" } */ + +#define T(N) \ +struct S##N { unsigned char i[N]; }; \ +struct S##N g1s##N, g2s##N, g3s##N; \ + \ +void \ +init##N (struct S##N *p, int i) \ +{ \ + int j; \ + for (j = 0; j < N; j++) \ + p->i[j] = i + j; \ +} \ + \ +void \ +check##N (struct S##N *p, int i) \ +{ \ + int j; \ + for (j = 0; j < N; j++) \ + if (p->i[j] != i + j) abort (); \ +} \ + \ +void \ +test##N (struct S##N s1, struct S##N s2, \ + struct S##N s3) \ +{ \ + check##N (&s1, 64); \ + check##N (&s2, 128); \ + check##N (&s3, 192); \ +} \ + \ +void \ +test2_##N (struct S##N s1, struct S##N s2) \ +{ \ + test##N (s1, g2s##N, s2); \ +} \ + \ +void \ +testit##N (void) \ +{ \ + init##N (&g1s##N, 64); \ + check##N (&g1s##N, 64); \ + init##N (&g2s##N, 128); \ + check##N (&g2s##N, 128); \ + init##N (&g3s##N, 192); \ + check##N (&g3s##N, 192); \ + test##N (g1s##N, g2s##N, g3s##N); \ + test2_##N (g1s##N, g3s##N); \ +} + +extern void abort (void); +extern void exit (int); + +T(0) T(1) T(2) T(3) T(4) T(5) T(6) T(7) +T(8) T(9) T(10) T(11) T(12) T(13) T(14) T(15) +T(16) T(17) T(18) T(19) T(20) T(21) T(22) T(23) +T(24) T(25) T(26) T(27) T(28) T(29) T(30) T(31) +T(32) T(33) T(34) T(35) T(36) T(37) T(38) T(39) +T(40) T(41) T(42) T(43) T(44) T(45) T(46) T(47) +T(48) T(49) T(50) T(51) T(52) T(53) T(54) T(55) +T(56) T(57) T(58) T(59) T(60) T(61) T(62) T(63) + +#undef T + +int +main () +{ +#define T(N) testit##N (); + +T(0) T(1) T(2) T(3) T(4) T(5) T(6) T(7) +T(8) T(9) T(10) T(11) T(12) T(13) T(14) T(15) +T(16) T(17) T(18) T(19) T(20) T(21) T(22) T(23) +T(24) T(25) T(26) T(27) T(28) T(29) T(30) T(31) +T(32) T(33) T(34) T(35) T(36) T(37) T(38) T(39) +T(40) T(41) T(42) T(43) T(44) T(45) T(46) T(47) +T(48) T(49) T(50) T(51) T(52) T(53) T(54) T(55) +T(56) T(57) T(58) T(59) T(60) T(61) T(62) T(63) + +#undef T + exit (0); +} diff --git a/test/dg/struct-ret-1.c b/test/dg/struct-ret-1.c new file mode 100644 index 0000000..23c9e98 --- /dev/null +++ b/test/dg/struct-ret-1.c @@ -0,0 +1,47 @@ +/* { dg-do run { target hppa*-*-* } } */ +/* { dg-options { -O2 } { target hppa*-*-* } } */ +extern void abort (void); +extern void exit (int); +typedef struct { + int x; + int y; +} point_t; + +int main(int argc, char *argv[]); +int printPoints(point_t a, point_t b); +point_t toPoint(int x1, int y1); + +int +main(int argc, char *argv[]) +{ + + if (printPoints(toPoint(0, 0), toPoint(1000, 1000)) != 1) + abort(); + else + exit(0); + + return 0; +} + +int +printPoints(point_t a, point_t b) +{ + if (a.x != 0 + || a.y != 0 + || b.x != 1000 + || b.y != 1000) + return 0; + else + return 1; +} + +point_t +toPoint(int x1, int y1) +{ + point_t p; + + p.x = x1; + p.y = y1; + + return p; +} diff --git a/test/dg/switch-warn-1.c b/test/dg/switch-warn-1.c new file mode 100644 index 0000000..04ca4e3 --- /dev/null +++ b/test/dg/switch-warn-1.c @@ -0,0 +1,47 @@ +/* { dg-do run } */ +/* { dg-options "-O0" } */ + +extern void abort (void); +extern void exit (int); + +/* Check that out-of-bounds case warnings work in the case that the + testing expression is promoted. */ +int +foo1 (unsigned char i) +{ + switch (i) + { + case -1: /* { dg-warning "case label value is less than minimum value for type" } */ + return 1; + case 256: /* { dg-warning "case label value exceeds maximum value for type" } */ + return 2; + default: + return 3; + } +} + +/* Like above, but for case ranges that need to be satured. */ +int +foo2 (unsigned char i) +{ + switch (i) + { + case -1 ... 1: /* { dg-warning "lower value in case label range less than minimum value for type" } */ + return 1; + case 254 ... 256: /* { dg-warning "upper value in case label range exceeds maximum value for type" } */ + return 2; + default: + return 3; + } +} + +int +main (void) +{ + if (foo1 (10) != 3) + abort (); + if (foo2 (10) != 3) + abort (); + exit (0); +} + diff --git a/test/dg/switch-warn-2.c b/test/dg/switch-warn-2.c new file mode 100644 index 0000000..7778b66 --- /dev/null +++ b/test/dg/switch-warn-2.c @@ -0,0 +1,26 @@ +/* This should not warn about the case label being out of range. */ +/* { dg-do run } */ +/* { dg-options "-O0" } */ + +extern void abort (void); +extern void exit (int); + +int +foo (unsigned int i) +{ + switch (i) + { + case 123456123456ULL: /* { dg-warning "large integer implicitly truncated to unsigned type" } */ + return 0; + default: + return 3; + } +} + +int +main (void) +{ + if (foo (10) != 3) + abort (); + exit (0); +} diff --git a/test/dg/titype-1.c b/test/dg/titype-1.c new file mode 100644 index 0000000..1d0c570 --- /dev/null +++ b/test/dg/titype-1.c @@ -0,0 +1,34 @@ +/* { dg-do run } */ + +/* Not all platforms support TImode integers. */ +#if defined(__LP64__) && !defined(__hppa__) +typedef int TItype __attribute__ ((mode (TI))); +#else +typedef long TItype; +#endif + +#include + +extern void abort(void); + + +void foo(int i, ...) +{ + TItype q; + va_list va; + + va_start(va, i); + q = va_arg(va, TItype); + va_end(va); + + if (q != 5) + abort(); +} + +int main(void) +{ + TItype q = 5; + + foo(1, q); + return 0; +} diff --git a/test/dg/unaligned-1.c b/test/dg/unaligned-1.c new file mode 100644 index 0000000..5df1b37 --- /dev/null +++ b/test/dg/unaligned-1.c @@ -0,0 +1,49 @@ +/* PR middle-end/7847 */ +/* Originator: */ +/* { dg-do run } */ + +/* This used to fail on SPARC at runtime because of + an unaligned memory access. */ + +typedef char int8_t; +typedef short int16_t; +typedef int int32_t; +typedef unsigned char uint8_t; +typedef unsigned short uint16_t; +typedef unsigned int uint32_t; + +typedef struct { + uint32_t address; + uint16_t size; +} __attribute__ ((packed)) sml_agl_data_t; + +typedef struct { + sml_agl_data_t data[9]; +} __attribute__ ((packed)) sml_agli_t; + +typedef struct { + sml_agli_t sml_agli; +} __attribute__ ((packed)) dsi_t; + +typedef struct { + int a; + dsi_t dsi_pack; +} dvd_priv_t; + +int dvd_read_sector(dvd_priv_t *d, unsigned char* data) +{ + int i, skip=0; + + for (i=0; i < 9; i++) + if ((skip=d->dsi_pack.sml_agli.data[i].address) != 0) + break; + + return skip; +} + +int main(void) +{ + static dvd_priv_t dvd_priv; + dvd_read_sector(&dvd_priv, 0); + return 0; +} diff --git a/test/dg/union-2.c b/test/dg/union-2.c new file mode 100644 index 0000000..edc8a7a --- /dev/null +++ b/test/dg/union-2.c @@ -0,0 +1,28 @@ +/* This used to segfault on SPARC 64-bit at runtime because + the stack pointer was clobbered by the function call. */ + +/* { dg-do run } */ + +#include + +union U +{ + long l1[2]; +}; + +union U u; + +void foo (int z, ...) +{ + int i; + va_list ap; + va_start(ap,z); + i = va_arg(ap, int); + va_end(ap); +} + +int main(void) +{ + foo (1, 1, 1, 1, 1, u); + return 0; +} diff --git a/test/dg/unroll-1.c b/test/dg/unroll-1.c new file mode 100644 index 0000000..5ff07e2 --- /dev/null +++ b/test/dg/unroll-1.c @@ -0,0 +1,27 @@ +/* PR optimization/8599 */ +/* { dg-do run } */ +/* { dg-options "-O2 -funroll-loops" } */ +/* { dg-options "-mtune=k6 -O2 -funroll-loops" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */ + + +extern void abort (void); + +int array[6] = { 1,2,3,4,5,6 }; + +void foo() +{ + int i; + + for (i = 0; i < 5; i++) + array[i] = 0; +} + +int main() +{ + foo(); + if (array[0] || array [1] || array[2] || array[3] || array[4]) + abort (); + if (array[5] != 6) + abort (); + return 0; +} diff --git a/test/dg/unsigned-long-compare.c b/test/dg/unsigned-long-compare.c new file mode 100644 index 0000000..74e7638 --- /dev/null +++ b/test/dg/unsigned-long-compare.c @@ -0,0 +1,24 @@ +/* Copyright (C) 2006 Free Software Foundation, Inc. */ +/* Contributed by Carlos O'Donell on 2006-01-30 */ + +/* Test a division corner case where the expression simplifies + to a comparison, and the optab expansion is wrong. The optab + expansion emits a function whose return is unbiased and needs + adjustment. */ +/* Origin: Carlos O'Donell */ +/* { dg-do run } */ +/* { dg-options "" } */ +#include + +#define BIG_CONSTANT 0xFFFFFFFF80000000ULL + +int main (void) +{ + unsigned long long OneULL = 1ULL; + unsigned long long result; + + result = OneULL / BIG_CONSTANT; + if (result) + abort (); + exit (0); +} diff --git a/test/dg/var-expand2.c b/test/dg/var-expand2.c new file mode 100644 index 0000000..499de55 --- /dev/null +++ b/test/dg/var-expand2.c @@ -0,0 +1,29 @@ +/* { dg-do run } */ +/* { dg-options "-O2 -funroll-loops -ffast-math -fvariable-expansion-in-unroller" } */ + +extern void abort (void); + +float array[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; + +int +foo (int n) +{ + unsigned i; + float accum = 0; + + for (i = 0; i < n; i++) + accum += array[i]; + + if (accum != 55) + abort (); + + return 0; +} + +int +main (void) +{ + return foo (10); +} + + diff --git a/test/gunk/x.asm b/test/gunk/x.asm new file mode 100644 index 0000000..83f58eb --- /dev/null +++ b/test/gunk/x.asm @@ -0,0 +1,306 @@ +;==LoRom== ; We'll get to HiRom some other time. + +.MEMORYMAP ; Begin describing the system architecture. + SLOTSIZE $8000 ; The slot is $8000 bytes in size. More details on slots later. + DEFAULTSLOT 0 ; There's only 1 slot in SNES, there are more in other consoles. + SLOT 0 $8000 ; Defines Slot 0's starting address. + SLOT 1 $0 +.ENDME ; End MemoryMap definition + +.ROMBANKSIZE $8000 ; Every ROM bank is 32 KBytes in size +.ROMBANKS 8 ; 2 Mbits - Tell WLA we want to use 8 ROM Banks + +.SNESHEADER + ID "SNES" ; 1-4 letter string, just leave it as "SNES" + + NAME "SNES Tile Demo " ; Program Title - can't be over 21 bytes, + ; "123456789012345678901" ; use spaces for unused bytes of the name. + + SLOWROM + LOROM + + CARTRIDGETYPE $00 ; $00 = ROM only, see WLA documentation for others + ROMSIZE $08 ; $08 = 2 Mbits, see WLA doc for more.. + SRAMSIZE $00 ; No SRAM see WLA doc for more.. + COUNTRY $01 ; $01 = U.S. $00 = Japan, that's all I know + LICENSEECODE $00 ; Just use $00 + VERSION $00 ; $00 = 1.00, $01 = 1.01, etc. +.ENDSNES + +.SNESNATIVEVECTOR ; Define Native Mode interrupt vector table + COP EmptyHandler + BRK EmptyHandler + ABORT EmptyHandler + NMI VBlank + IRQ EmptyHandler +.ENDNATIVEVECTOR + +.SNESEMUVECTOR ; Define Emulation Mode interrupt vector table + COP EmptyHandler + ABORT EmptyHandler + NMI EmptyHandler + RESET Start ; where execution starts + IRQBRK EmptyHandler +.ENDEMUVECTOR + +.ramsection "registers" bank 0 slot 1 +r0l dw +r0h dw +r1l dw +r1h dw +.ends + +.BANK 0 SLOT 0 ; Defines the ROM bank and the slot it is inserted in memory. +.ORG 0 ; .ORG 0 is really $8000, because the slot starts at $8000 +.SECTION "EmptyVectors" SEMIFREE + +EmptyHandler: + rti + +.ENDS + +.EMPTYFILL $00 ; fill unused areas with $00, opcode for BRK. + ; BRK will crash the snes if executed. +.MACRO Snes_Init + sei ; Disabled interrupts + clc ; clear carry to switch to native mode + xce ; Xchange carry & emulation bit. native mode + rep #$18 ; Binary mode (decimal mode off), X/Y 16 bit + ldx #$1FFF ; set stack to $1FFF + txs + + jsr Init +.ENDM + +.bank 0 +.section "Snes_Init" SEMIFREE +Init: + sep #$30 ; X,Y,A are 8 bit numbers + lda #$8F ; screen off, full brightness + sta $2100 ; brightness + screen enable register + stz $2101 ; Sprite register (size + address in VRAM) + stz $2102 ; Sprite registers (address of sprite memory [OAM]) + stz $2103 ; "" "" + stz $2105 ; Mode 0, = Graphic mode register + stz $2106 ; noplanes, no mosaic, = Mosaic register + stz $2107 ; Plane 0 map VRAM location + stz $2108 ; Plane 1 map VRAM location + stz $2109 ; Plane 2 map VRAM location + stz $210A ; Plane 3 map VRAM location + stz $210B ; Plane 0+1 Tile data location + stz $210C ; Plane 2+3 Tile data location + stz $210D ; Plane 0 scroll x (first 8 bits) + stz $210D ; Plane 0 scroll x (last 3 bits) #$0 - #$07ff + stz $210E ; Plane 0 scroll y (first 8 bits) + stz $210E ; Plane 0 scroll y (last 3 bits) #$0 - #$07ff + stz $210F ; Plane 1 scroll x (first 8 bits) + stz $210F ; Plane 1 scroll x (last 3 bits) #$0 - #$07ff + stz $2110 ; Plane 1 scroll y (first 8 bits) + stz $2110 ; Plane 1 scroll y (last 3 bits) #$0 - #$07ff + stz $2111 ; Plane 2 scroll x (first 8 bits) + stz $2111 ; Plane 2 scroll x (last 3 bits) #$0 - #$07ff + stz $2112 ; Plane 2 scroll y (first 8 bits) + stz $2112 ; Plane 2 scroll y (last 3 bits) #$0 - #$07ff + stz $2113 ; Plane 3 scroll x (first 8 bits) + stz $2113 ; Plane 3 scroll x (last 3 bits) #$0 - #$07ff + stz $2114 ; Plane 3 scroll y (first 8 bits) + stz $2114 ; Plane 3 scroll y (last 3 bits) #$0 - #$07ff + lda #$80 ; increase VRAM address after writing to $2119 + sta $2115 ; VRAM address increment register + stz $2116 ; VRAM address low + stz $2117 ; VRAM address high + stz $211A ; Initial Mode 7 setting register + stz $211B ; Mode 7 matrix parameter A register (low) + lda #$01 + sta $211B ; Mode 7 matrix parameter A register (high) + stz $211C ; Mode 7 matrix parameter B register (low) + stz $211C ; Mode 7 matrix parameter B register (high) + stz $211D ; Mode 7 matrix parameter C register (low) + stz $211D ; Mode 7 matrix parameter C register (high) + stz $211E ; Mode 7 matrix parameter D register (low) + sta $211E ; Mode 7 matrix parameter D register (high) + stz $211F ; Mode 7 center position X register (low) + stz $211F ; Mode 7 center position X register (high) + stz $2120 ; Mode 7 center position Y register (low) + stz $2120 ; Mode 7 center position Y register (high) + stz $2121 ; Color number register ($0-ff) + stz $2123 ; BG1 & BG2 Window mask setting register + stz $2124 ; BG3 & BG4 Window mask setting register + stz $2125 ; OBJ & Color Window mask setting register + stz $2126 ; Window 1 left position register + stz $2127 ; Window 2 left position register + stz $2128 ; Window 3 left position register + stz $2129 ; Window 4 left position register + stz $212A ; BG1, BG2, BG3, BG4 Window Logic register + stz $212B ; OBJ, Color Window Logic Register (or,and,xor,xnor) + sta $212C ; Main Screen designation (planes, sprites enable) + stz $212D ; Sub Screen designation + stz $212E ; Window mask for Main Screen + stz $212F ; Window mask for Sub Screen + lda #$30 + sta $2130 ; Color addition & screen addition init setting + stz $2131 ; Add/Sub sub designation for screen, sprite, color + lda #$E0 + sta $2132 ; color data for addition/subtraction + stz $2133 ; Screen setting (interlace x,y/enable SFX data) + stz $4200 ; Enable V-blank, interrupt, Joypad register + lda #$FF + sta $4201 ; Programmable I/O port + stz $4202 ; Multiplicand A + stz $4203 ; Multiplier B + stz $4204 ; Multiplier C + stz $4205 ; Multiplicand C + stz $4206 ; Divisor B + stz $4207 ; Horizontal Count Timer + stz $4208 ; Horizontal Count Timer MSB (most significant bit) + stz $4209 ; Vertical Count Timer + stz $420A ; Vertical Count Timer MSB + stz $420B ; General DMA enable (bits 0-7) + stz $420C ; Horizontal DMA (HDMA) enable (bits 0-7) + stz $420D ; Access cycle designation (slow/fast rom) + cli ; Enable interrupts + rts +.ends + +; Needed to satisfy interrupt definition in "Header.inc". +VBlank: + RTI + +.bank 0 +.section "MainCode" + +Start: + ; Initialize the SNES. + Snes_Init + rep #$30 + ; jsr main +forever: + jmp forever +.ends + +; .include "hw2.asm" +;.include "hw3.asm" + + +main2: rts ; remove +; sub sp,#_main2_params +tsa +sec +sbc #_main2_params +tas + +; ld #8448,r0 +lda #8448 +sta r0l +lda #0 +sta r0h + +;st r0, [sp,0] +lda r0l +sta 0,s +lda r0h +sta 2,s + +;ld #8482,r0 +lda #8482 +sta r0l +lda #0 +sta r0h + +;st r0, [sp,4] +lda r0l +sta 4,s +lda r0h +sta 6,s + +;ld32 [sp,0],r0 +lda 0,s +sta r0l +lda 2,s +sta r0h + +;ld #128,r1 +lda #128 +sta r1l +lda #0 +sta r1h + +;st r1, [r0,0] +ldx r0l +lda r1l +sta 0,x +lda r1h +sta 2,x + +;ld32 [sp,4],r0 +lda 4,s +sta r0l +lda 6,s +sta r0h + +;ld #224,r1 +lda #224 +sta r1l +lda #0 +sta r1h + +;st r1, [r0,0] +ldx r0l +lda r1l +sta 0,x +lda r1h +sta 2,x + +;ld32 [sp,4],r0 +lda 4,s +sta r0l +lda 6,s +sta r0h + +;ld #0,r1 +lda #0 +sta r0l +sta r0h + +;st r1, [r0,0] +ldx r0l +lda r1l +sta 0,x +lda r1h +sta 2,x + +;ld32 [sp,0],r0 +lda 0,s +sta r0l +lda 2,s +sta r0h + +;ld #15,r1 +lda #15 +sta r1l +lda #0 +sta r1h + +;st r1, [r0,0] +ldx r0l +lda r1l +sta 0,x +lda r1h +sta 2,x + +;add sp, #_main_params +tsa +clc +adc #_main2_params +tas + +rts +.define _main2_params 8 + +;.ends + +.ramsection ".data" bank 0 slot 1 +hans: db +wurscht: db +.ends + diff --git a/test/gunk/x.lnk b/test/gunk/x.lnk new file mode 100644 index 0000000..1fcf825 --- /dev/null +++ b/test/gunk/x.lnk @@ -0,0 +1,3 @@ +[objects] +x.obj +y.obj diff --git a/test/gunk/x.sym b/test/gunk/x.sym new file mode 100644 index 0000000..ac25f7e --- /dev/null +++ b/test/gunk/x.sym @@ -0,0 +1,18 @@ +; this file was created with wlalink by ville helin . +; wla symbolic information for "x.smc". + +[labels] +0000:0000 r0l +0000:0002 r0h +0000:0004 r1l +0000:0006 r1h +0000:8000 EmptyHandler +0000:8001 Init +0000:80f5 VBlank +0000:80f6 Start +0000:8104 forever +0000:8011 main2 +0000:000c hans +0000:000d wurscht +0000:0008 fritz +0000:000a salami diff --git a/test/gunk/xy.c b/test/gunk/xy.c new file mode 100644 index 0000000..404f833 --- /dev/null +++ b/test/gunk/xy.c @@ -0,0 +1,12 @@ +int main() +{ + short x = -32768; + float a = x; + printf("0x%x\n", *((int*)&a)); + printf("%lf\n", a); + short y = 32767; + float b = y; + printf("%lf\n", b/a); + short z = b/a; + printf("%d\n", z); +} \ No newline at end of file diff --git a/test/gunk/y.asm b/test/gunk/y.asm new file mode 100644 index 0000000..cfb26cf --- /dev/null +++ b/test/gunk/y.asm @@ -0,0 +1,49 @@ +;==LoRom== ; We'll get to HiRom some other time. + +.MEMORYMAP ; Begin describing the system architecture. + SLOTSIZE $8000 ; The slot is $8000 bytes in size. More details on slots later. + DEFAULTSLOT 0 ; There's only 1 slot in SNES, there are more in other consoles. + SLOT 0 $8000 ; Defines Slot 0's starting address. + SLOT 1 $0 +.ENDME ; End MemoryMap definition + +.ROMBANKSIZE $8000 ; Every ROM bank is 32 KBytes in size +.ROMBANKS 8 ; 2 Mbits - Tell WLA we want to use 8 ROM Banks + +.SNESHEADER + ID "SNES" ; 1-4 letter string, just leave it as "SNES" + + NAME "SNES Tile Demo " ; Program Title - can't be over 21 bytes, + ; "123456789012345678901" ; use spaces for unused bytes of the name. + + SLOWROM + LOROM + + CARTRIDGETYPE $00 ; $00 = ROM only, see WLA documentation for others + ROMSIZE $08 ; $08 = 2 Mbits, see WLA doc for more.. + SRAMSIZE $00 ; No SRAM see WLA doc for more.. + COUNTRY $01 ; $01 = U.S. $00 = Japan, that's all I know + LICENSEECODE $00 ; Just use $00 + VERSION $00 ; $00 = 1.00, $01 = 1.01, etc. +.ENDSNES + +.SNESNATIVEVECTOR ; Define Native Mode interrupt vector table + COP EmptyHandler + BRK EmptyHandler + ABORT EmptyHandler + NMI VBlank + IRQ EmptyHandler +.ENDNATIVEVECTOR + +.SNESEMUVECTOR ; Define Emulation Mode interrupt vector table + COP EmptyHandler + ABORT EmptyHandler + NMI EmptyHandler + RESET Start ; where execution starts + IRQBRK EmptyHandler +.ENDEMUVECTOR + +.ramsection ".data" bank 0 slot 1 +fritz: dw +salami: dw +.ends diff --git a/test/hdr.asm b/test/hdr.asm new file mode 120000 index 0000000..ea41042 --- /dev/null +++ b/test/hdr.asm @@ -0,0 +1 @@ +../../libs/hdr.asm \ No newline at end of file diff --git a/test/hw/asmfptest.asm b/test/hw/asmfptest.asm new file mode 100644 index 0000000..aed8d8d --- /dev/null +++ b/test/hw/asmfptest.asm @@ -0,0 +1,73 @@ +.include "hdr.asm" + +.section ".libm" superfree +.accu 16 +.index 16 +.16bit +asmfptest: + sep #$20 + stz.b tcc__M1 + 2 + lda.b #0 + sta.b tcc__M1 + lda.b #42 + sta.b tcc__M1 + 1 + rep #$20 + sep #$30 + jsr float + rep #$30 + lda.b tcc__X1 + sta.b tcc__X2 + lda.b tcc__X1 + 2 + sta.b tcc__X2 + 2 + sep #$20 + stz.b tcc__M1 + 2 + stz.b tcc__M1 + lda.b #23 + sta.b tcc__M1 + 1 + rep #$20 + sep #$30 + jsr float + rep #$30 + sep #$30 + jsr FDIV ; FP2 / FP1 => FP1 + rep #$30 + lda.b tcc__X1 + sta.b tcc__X2 + lda.b tcc__X1 + 2 + sta.b tcc__X2 + 2 + sep #$20 + stz.b tcc__M1 + 2 + stz.b tcc__M1 + lda.b #100 + sta.b tcc__M1 + 1 + rep #$20 + sep #$30 + jsr float + rep #$30 + sep #$30 + jsr fmul + rep #$30 +.endasm + sep #$20 + lda.b #$88 + sta.b tcc__X1 + lda.b #$44 + sta.b tcc__M1 + lda.b #$80 + sta.b tcc__M1 + 1 + stz.b tcc__M1 + 2 + rep #$20 +.asm + sep #$30 + jsr fix + rep #$30 + + sep #$20 + lda.b tcc__M1 + xba + lda.b tcc__M1 + 1 + rep #$20 + sta.b tcc__r0 + rtl + +.ends diff --git a/test/hw/hdr.asm b/test/hw/hdr.asm new file mode 120000 index 0000000..57e474e --- /dev/null +++ b/test/hw/hdr.asm @@ -0,0 +1 @@ +../../../libs/hdr.asm \ No newline at end of file diff --git a/test/hw/hw.c b/test/hw/hw.c new file mode 100644 index 0000000..067b82b --- /dev/null +++ b/test/hw/hw.c @@ -0,0 +1,24 @@ +extern void some_func(char* str, int x); +extern int x; + +int b = 0xbb; +int c = 0xcc; +int d = 0xdd; + +char* bums = "bums"; +char* fallera = "fallera"; +char* chachacha = "chachacha"; + +void other_func(int y) +{ +} + +int main(int argc, char** argv) +{ + int a; + a = 0; + a *= 5; + a *= x; + some_func("hello_world", a); + other_func(a); +} diff --git a/test/hw/hw2.asm b/test/hw/hw2.asm new file mode 100644 index 0000000..dd82885 --- /dev/null +++ b/test/hw/hw2.asm @@ -0,0 +1,99 @@ +;.section (nil) +main: +; sub sp,#_main_params +tsa +sec +sbc #_main_params +tas +; ld #8448,r0 +lda #$2100 +sta r0l +lda #$0 +sta r0h +; st r0, [sp,0] +lda r0l +sta 0,s +lda r0h +sta 2,s +; ld #8482,r0 +lda #$2122 +sta r0l +lda #$0 +sta r0h +; st r0, [sp,4] +lda r0l +sta 4,s +lda r0h +sta 6,s +; ld32 [sp,0],r0 +lda 0,s +sta r0l +lda 2,s +sta r0h +; ld #128,r1 +lda #$80 +sta r1l +lda #$0 +sta r1h +; st r1, [r0,0] +ldx r0l +lda r1l +sta 0,x +lda r1h +sta 2,x +; ld32 [sp,4],r0 +lda 4,s +sta r0l +lda 6,s +sta r0h +; ld #224,r1 +lda #$e0 +sta r1l +lda #$0 +sta r1h +; st r1, [r0,0] +ldx r0l +lda r1l +sta 0,x +lda r1h +sta 2,x +; ld32 [sp,4],r0 +lda 4,s +sta r0l +lda 6,s +sta r0h +; ld #0,r1 +lda #$0 +sta r1l +lda #$0 +sta r1h +; st r1, [r0,0] +ldx r0l +lda r1l +sta 0,x +lda r1h +sta 2,x +; ld32 [sp,0],r0 +lda 0,s +sta r0l +lda 2,s +sta r0h +; ld #15,r1 +lda #$f +sta r1l +lda #$0 +sta r1h +; st r1, [r0,0] +ldx r0l +lda r1l +sta 0,x +lda r1h +sta 2,x +; add sp, #_main_params +tsa +clc +adc #_main_params +tas +rts +.define _main_params 8 +;.section (nil) diff --git a/test/hw/hw2.c b/test/hw/hw2.c new file mode 100644 index 0000000..263c333 --- /dev/null +++ b/test/hw/hw2.c @@ -0,0 +1,9 @@ +void main(void) +{ + volatile unsigned char* vb = (unsigned char*)0x2100; + volatile unsigned char* col = (unsigned char*)0x2122; + *vb = 0x80; + *col = 0xe0; + *col = 0; + *vb = 0xf; +} \ No newline at end of file diff --git a/test/hw/hw3.c b/test/hw/hw3.c new file mode 100644 index 0000000..609adb5 --- /dev/null +++ b/test/hw/hw3.c @@ -0,0 +1,1036 @@ +#include "hw3.h" + +#if 1 +static void gibdir(void); +void testfields(void); +void testlonglong(void); +int testfloat(void); +void testcasts(void); +void testptrconv(void); +void testcontrol(int num); +void testellipsis(void); + +char* string = "hello, world!\n"; // pointer goes to RAM, string constant to ROM +char* string2 = "good-bye\n"; // dto. +char string3[5] = "1234"; // RAM + +const int a[50] = {1,2,3,4,5}; // RAM +int b[50] = {6,7,8,9,10}; // RAM + +#ifndef __APPLE__ +const int __attribute__((section(".rotzdata"))) c[50] = {65,66,67,14,15}; // ROM (extra section) +const int __attribute__((section(".rodata"))) e[10] = {99,98,97,96}; // ROM (together with string constants) +#endif + + +int d[50]; // BSS +int* f = d; +int g = 3; + +#ifndef __APPLE__ +const char __attribute__((section(".rotzdata"))) x[] = "fritze"; // ROM (extra section) +#endif +const char const* leer1 = ""; // pointer in RAM points to empty string in ROM +const char const leer2[] = ""; // empty string in RAM + +#ifndef __65816__ +#define OUTC(x) (putchar(x)) +#define OUTLIT(x) (putchar(x)) +#else +volatile char* out = (char*)0xfffe; +#define OUTC(x) (*out = (x)) +#define OUTLIT(x) (*((char*)0xfffe) = (x)) +#endif + +int zahl(void) { + return a[2]; +} + +unsigned short testus(unsigned short n) +{ + return n & 0xf000; +} + +short tests(short n) +{ + return n & 0xf000; +} + +int test(int n) +{ + return n & 0xf000; +} + +void write(char* s) { +// while(*s) OUTC(*s++); + while(*s) OUTLIT(*s++); +} + +void hexu(unsigned int n) { + unsigned int nn; + unsigned int lead = 0; + unsigned int count = 4; + write("0x"); + while(count--) { + nn = (n & 0xf000) >> 12; + if(nn + lead) { + if(nn >= 10) OUTC(nn - 10 + 'a'); + else OUTC(nn + '0'); + lead = 1; + } + n <<= 4; + } + if(!lead) OUTC('0'); +} + +void hexun(unsigned int n) +{ + hexu(n); OUTC('\n'); +} + +void simplehex(int n) { + unsigned int nn; + nn = n; + if(nn >= 10) write("ok\n"); + else write("nok\n"); +} + +void hex(int n) { + unsigned int nn; + unsigned int lead = 0; + unsigned int un; + int count = 4; + if(n < 0) { + //write("n is smaller than zero\n"); + OUTC('-'); + n = -n; + } + write("0x"); + un = n; + //write("un "); hexu(un); + while(count--) { + nn = (un & 0xf000) >> 12; + //write("digit "); hexu(nn); + if(nn + lead) { + if(nn >= 10) OUTC(nn - 10 + 'a'); + else OUTC(nn + '0'); + lead = 1; + } + un <<= 4; + } + if(!lead) OUTC('0'); +} + +#define hexint hex +#define hex__uint hexu +#define hexchar hex +#define hex__uchar hexu +#define hex__longlong hexl +#define hex__ulonglong hexlu + +void hexlu(unsigned long long n) { + unsigned int nn; + unsigned int lead = 0; + unsigned long long un; + int count = 8; + + write("0x"); + //write("un "); hexu(un); + while(count--) { + nn = (n & 0xf0000000ULL) >> 28; + //write("digit "); hexu(nn); + if(nn + lead) { + if(nn >= 10) OUTC(nn - 10 + 'a'); + else OUTC(nn + '0'); + lead = 1; + } + n <<= 4; + } + if(!lead) OUTC('0'); +} + +void hexl(long long n) { + unsigned int nn; + unsigned int lead = 0; + unsigned long long un = n; + int count = 8; + + write("0x"); + //write("un "); hexu(un); + while(count--) { + nn = (un & 0xf0000000ULL) >> 28; + //write("digit "); hexu(nn); + if(nn + lead) { + if(nn >= 10) OUTC(nn - 10 + 'a'); + else OUTC(nn + '0'); + lead = 1; + } + un <<= 4; + } + if(!lead) OUTC('0'); +} + +void hexus(int n) +{ + hex(n); write(" ("); hexu(n); OUTC(')'); +} + +void hexn(int n) +{ + hex(n); OUTC('\n'); +} + +void writeequation(int num, char* op, int num2) +{ + hexu(num); OUTC(' '); write(op); OUTC(' '); hexu(num2); write(" == "); +} + +void testasr(int num, int shift) +{ + writeequation(num, ">>", shift); + //hexu(num); write(" >> "); hexu(shift); write(" == "); + num >>= shift; + hexu(num); OUTC('\n'); +} + +void testlsr(unsigned int num, int shift) +{ + writeequation(num, "u>>", shift); + //hexu(num); write(" >> "); hexu(shift); write(" == "); + num >>= shift; + hexu(num); OUTC('\n'); +} + +void testsub(int num, int sub) +{ + writeequation(num, "-", sub); + //hex(num); write(" - "); hex(sub); write(" == "); + num -= sub; + hex(num); OUTC('\n'); +} + +void testadd(int num, int add) +{ + writeequation(num, "+", add); + num += add; + hex(num); OUTC('\n'); +} + +static void testmul(int a, int b) +{ + writeequation(a, "*", b); + a *= b; + hex(a); OUTC('\n'); +} + +void testdiv(int a, int b) +{ + writeequation(a, "/", b); + a /= b; + hex(a); OUTC('\n'); +} + +void testdivu(unsigned int a, unsigned int b) +{ + writeequation(a, "u/", b); + a /= b; + hexu(a); OUTC('\n'); +} + +void testmod(int a, int b) +{ + writeequation(a, "%", b); + a %= b; + hex(a); OUTC('\n'); +} + +#define gen_testop(type) void testop_##type(type a, char* op, type b, type c) \ +{ \ + write(#type " "); writeequation(a, op, b); \ + hexus(c); OUTC('\n'); \ +} + +gen_testop(int) +gen_testop(__uint) +gen_testop(char) +gen_testop(__uchar) +gen_testop(__longlong) +gen_testop(__ulonglong) +gen_testop(float) + +#define gen_testunaryop(type) void testunaryop_##type(type a, char* op, type b) \ +{ \ + write(#type " "); write(op); hex(a); OUTC(' '); write(op); OUTC(' '); hex(b); OUTC('\n'); \ +} + +gen_testunaryop(int) +gen_testunaryop(__uint) +gen_testunaryop(char) +gen_testunaryop(__uchar) +gen_testunaryop(__longlong) +gen_testunaryop(__ulonglong) +gen_testunaryop(float) + +#define gen_test(op, sop, type) void test##op##type(type a, type b) \ +{ \ + testop_##type(a, #sop, b, a sop b); \ +} + +#define gen_testnotzero(op, sop, type) void test##op##type(type a, type b) \ +{ \ + if(b) testop_##type(a, #sop, b, a sop b); \ +} + +#define gen_testunary(op, sop, type) void test##op##type(type a) \ +{ \ + testunaryop_##type(a, #sop, sop a); \ +} + +#define gen_testconst(op, sop, cst, type) void testconst##op##type(type a) \ +{ \ + testunaryop_##type(a, #op #cst, a sop cst); \ +} + +#if 1 +#define gen_testall(op, sop) \ + gen_test(op, sop, int) \ + gen_test(op, sop, __uint) \ + gen_test(op, sop, char) \ + gen_test(op, sop, __uchar) \ + gen_test(op, sop, __longlong) \ + gen_test(op, sop, __ulonglong) + +#define gen_testallnotzero(op, sop) \ + gen_testnotzero(op, sop, int) \ + gen_testnotzero(op, sop, __uint) \ + gen_testnotzero(op, sop, char) \ + gen_testnotzero(op, sop, __uchar) \ + gen_testnotzero(op, sop, __longlong) \ + gen_testnotzero(op, sop, __ulonglong) + +#else +#define gen_testall(op, sop) +#endif + +#define gen_testreallyall(op, sop) \ + gen_testall(op, sop) \ + gen_test(op, sop, float) + +#define gen_testreallyallnotzero(op, sop) \ + gen_testallnotzero(op, sop) \ + gen_testnotzero(op, sop, float) + +#define gen_testallunary(op, sop) \ + gen_testunary(op, sop, int) \ + gen_testunary(op, sop, __uint) \ + gen_testunary(op, sop, char) \ + gen_testunary(op, sop, __uchar) \ + gen_testunary(op, sop, __longlong) \ + gen_testunary(op, sop, __ulonglong) + +#define gen_testallconst(op, sop, cst) \ + gen_testconst(op, sop, cst, int) \ + gen_testconst(op, sop, cst, __uint) \ + gen_testconst(op, sop, cst, char) \ + gen_testconst(op, sop, cst, __uchar) \ + gen_testconst(op, sop, cst, __longlong) \ + gen_testconst(op, sop, cst, __ulonglong) + +#define gen_testreallyallconst(op, sop, cst) \ + gen_testallconst(op, sop, cst) \ + gen_testconst(op, sop, cst, float) + +#if 1 +#define run_test(op, a, b) \ + test##op ##int(a, b); \ + test##op ##__uint(a, b); \ + test##op ##char(a, b); \ + test##op ##__uchar(a, b); \ + test##op ##__longlong(a, b); \ + test##op ##__ulonglong(a, b); +#else +#define run_test(op, a, b) +#endif + +#define run_testreallyall(op, a, b) \ + run_test(op, a, b) \ + test##op ##float(a, b); + +#define run_testunary(op, a) \ + test##op ##int(a); \ + test##op ##__uint(a); \ + test##op ##char(a); \ + test##op ##__uchar(a); \ + test##op ##__longlong(a); \ + test##op ##__ulonglong(a); + +#define run_testconst(op, a) \ + testconst##op ##int(a); \ + testconst##op ##__uint(a); \ + testconst##op ##char(a); \ + testconst##op ##__uchar(a); \ + testconst##op ##__longlong(a); \ + testconst##op ##__ulonglong(a); + +#define run_testreallyallconst(op, a) \ + run_testconst(op, a) \ + testconst##op ##float(a); + +gen_testreallyall(add, +) +gen_testreallyall(sub, -) +gen_testreallyall(mul, *) +gen_testreallyallnotzero(div, /) +gen_testreallyall(lt, <) +gen_testreallyall(gt, >) +gen_testreallyall(le, <=) +gen_testreallyall(eq, ==) +gen_testreallyall(ne, !=) +gen_testreallyall(ge, >=) + +gen_testall(land, &&) +gen_testall(lor, ||) +gen_testall(xor, ^) +gen_testall(and, &) +gen_testall(or, |) +gen_testall(shl, <<) +gen_testall(shr, >>) +gen_testallnotzero(mod, %) + +gen_testreallyallconst(add, +, 42) +gen_testreallyallconst(sub, -, 42) +gen_testreallyallconst(mul, *, 42) +gen_testreallyallconst(div, /, 42) +gen_testreallyallconst(lt, <, 42) +gen_testreallyallconst(gt, >, 42) +gen_testreallyallconst(le, <=, 42) +gen_testreallyallconst(eq, ==, 42) +gen_testreallyallconst(ne, !=, 42) +gen_testreallyallconst(ge, >=, 42) + +gen_testallconst(land, &&, 1) +gen_testallconst(lor, ||, 1) +gen_testallconst(xor, ^, 42) +gen_testallconst(and, &, 42) +gen_testallconst(or, |, 42) +gen_testallconst(shl, <<, 5) +gen_testallconst(shr, >>, 5) +gen_testallconst(mod, %, 23) + +gen_testallunary(minus, -) +gen_testallunary(not, ~) +gen_testallunary(lnot, !) + +#define gen_testcast(from, to, outfn) to testcast##from##to(from v) \ +{ \ + write("cast from " #from " "); outfn(v); write(" to " #to " "); \ + outfn((to)v); OUTC('\n'); \ +} + +void dumplong(__longlong); + +#define gen_testallcasts(from) \ + gen_testcast(from, char, hex) \ + gen_testcast(from, __uchar, hexu) \ + gen_testcast(from, __int, hex) \ + gen_testcast(from, __uint, hexu) \ + gen_testcast(from, float, hex) \ + gen_testcast(from, __longlong, dumplong) \ + gen_testcast(from, __ulonglong, dumplong) + +gen_testallcasts(char) +gen_testallcasts(__uchar) +gen_testallcasts(__int) +gen_testallcasts(__uint) +gen_testallcasts(__longlong) +gen_testallcasts(__ulonglong) +gen_testallcasts(float) + +#define run_cast(from, v) \ + testcast##from ##char(v); \ + testcast##from ##__uchar(v); \ + testcast##from ##__int(v); \ + testcast##from ##__uint(v); \ + testcast##from ##float(v); \ + testcast##from ##__longlong(v); \ + testcast##from ##__ulonglong(v); + +typedef void (*testfuncptr)(int, int); +typedef void (*testufuncptr)(int); + +const testfuncptr tf[] = {testmul, testdiv, testmod}; //, testxorint}; +const testufuncptr tfu[] = {testnotint, testlnotint, testminusint}; + +#ifdef __65816__ +int asmfptest(void); +#endif + +int nums1[] = {0, -1, 1, 2, -2, 4, -4, 10, -10, 5, 7, 42, 23, 32767, -32768, -1000, -10000}; +// nums2 is local to main() + +float float1[] = { 1.0, -1.0, 0.0, 2.5, 1000000.0f }; +float float2[] = { 1.0, -1.0, 2.5, 23.0f, -42.0f }; + +__longlong ll1[] = { -1, 0, 1, 10, 100, 1000000 }; +__longlong ll2[] = { -1, 1, 23, 42, 99, -1000000}; +__ulonglong* ull1 = ll1; + +char char1[] = {-1, 0, 1, 10, 23, 42, 127}; +char char2[] = {-1, 1, -10, -23, -42, -128}; +__uchar* uchar1 = char1; + +extern void printsizes(void); + +int main(void) +{ + int i,j,k; + d[5] = -10; +#ifdef __65816__ + // turn the SNES bg green + volatile unsigned char* vb = (unsigned char*)0x2100; + volatile unsigned char* col = (unsigned char*)0x2122; + *vb = 0x80; + *col = 0xe0; + *col = 0; + *vb = 0xf; + hexun(asmfptest()); +#endif + hexn(testfloat()); + gibdir(); + +#if 0 + __longlong blubb = 5; + __longlong bla = 3; + hexn(blubb * bla); + exit(0); +#endif + +#if 1 + simplehex(5); + simplehex(15); + write(string); + string += zahl(); + write(string); + string += -3; + string -= -1; + write(string); + write("signed numbers\n"); + hex(-10); + hexn(-10); + hexn(0x5); + hexn(10); + write("unsigned numbers\n"); + hexun(-10); + hexun(5); + hexun(10); + write("arith shift right\n"); + testasr(-1, 2); + testasr(0xff00, 4); + testasr(0xf0, 2); + testasr(0x8000, 1); + testasr(0x8001, 1); + testasr(0x7fff, 1); + testlsr(-1, 2); + testlsr(0xff00, 4); + testlsr(0xf0, 2); + testlsr(0x8000, 1); + testlsr(0x8001, 1); + testlsr(0x7fff, 1); + testsub(10, 5); + testsub(10,10); + testsub(5, 10); + testsub(0, 10); + testsub(-10, 0); + testsub(10,0); + testsub(-10,-5); + testsub(-10,5); + testsub(10,-10); + testadd(5,10); + testadd(-5,10); + testadd(0,5); + testadd(0,-5); + testadd(-5,0); + testadd(5,0); + testadd(5,-10); + testmul(2,4); + testmul(-2,4); + testmul(0,2); + testmul(0,-2); + testmul(2,-4); + testmul(2,0); + testmul(-2,0); + testmul(256,256); + testdivu(42,5); + testdivu(5,42); + testdivu(-42,5); + testdivu(42,-5); + testdivu(-5,42); + testdivu(40,8); + testdivu(0,8); + testdiv(42,5); + testdiv(5,42); + testdiv(-42,5); + testdiv(42,-5); + testdiv(-5,42); + testdiv(40,8); + testdiv(0,8); + testdiv(-42,-5); + printsizes(); + write("finished\n"); + write(leer1); + write(leer2); + write("leer finished\n"); +#endif + + int nums2[] = {-1, 1, 2, -2, 4, -4, 10, -10, 5, 7, 42, 23, 32767, -32768, 1000, 10000}; + // shifts are undefined for negative values and values > type size, so we use separate test values + int shifts2[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 14, 16, 18, 20, 22}; +#if 1 + for(j = 0; j < (sizeof(nums1)/sizeof(int)) ; j++) { + for(k = 0; k < (sizeof(nums2)/sizeof(int)) ; k++) { + for(i = 0; i < (sizeof(tf)/sizeof(testfuncptr)); i++) + tf[i](nums1[j],nums2[k]); + run_test(xor, nums1[j], nums2[k]) + run_test(land, nums1[j], nums2[k]) + run_test(lor, nums1[j], nums2[k]) + run_test(and, nums1[j], nums2[k]) + run_test(or, nums1[j], nums2[k]) + run_test(shl, nums1[j], shifts2[k]) + run_test(shr, nums1[j], shifts2[k]) + run_testreallyall(add, nums1[j], nums2[k]) + run_testreallyall(sub, nums1[j], nums2[k]) + run_testreallyall(mul, nums1[j], nums2[k]) + run_testreallyall(lt, nums1[j], nums2[k]) + run_testreallyall(gt, nums1[j], nums2[k]) + run_testreallyall(le, nums1[j], nums2[k]) + run_testreallyall(eq, nums1[j], nums2[k]) + run_testreallyall(ne, nums1[j], nums2[k]) + run_testreallyall(ge, nums1[j], nums2[k]) + run_testreallyall(div, nums1[j], nums2[k]) /* has one problem when float dividing 32767/-32768 + resulting in -1 instead of zero */ + run_test(mod, nums1[j], nums2[k]) + //testltfloat(nums1[j], nums2[k]); + } + run_testconst(xor, nums1[j]) + run_testconst(land, nums1[j]) + run_testconst(lor, nums1[j]) + run_testconst(and, nums1[j]) + run_testconst(or, nums1[j]) + run_testconst(shl, nums1[j]) + run_testconst(shr, nums1[j]) + run_testreallyallconst(add, nums1[j]) + run_testreallyallconst(sub, nums1[j]) + run_testreallyallconst(mul, nums1[j]) + run_testreallyallconst(lt, nums1[j]) + run_testreallyallconst(gt, nums1[j]) + run_testreallyallconst(le, nums1[j]) + run_testreallyallconst(eq, nums1[j]) + run_testreallyallconst(ne, nums1[j]) + run_testreallyallconst(ge, nums1[j]) + run_testreallyallconst(div, nums1[j]) + run_testconst(mod, nums1[j]) + + } +#endif + + testcasts(); + +#if 1 + for(i = 0; i < (sizeof(tfu)/sizeof(testufuncptr)); i++) + { + for(j = 0; j < (sizeof(nums1)/sizeof(int)) ; j++) { + tfu[i](nums1[j]); + write("xchar "); tfu[i]((char)nums1[j]); + run_testunary(not, nums1[j]) + run_testunary(lnot, nums1[j]) + run_testunary(minus, nums1[j]) + } + } + + for(i = 0; i < 5; i++) { + hex(a[5-i]); OUTC(','); + } + OUTC('\n'); + + + int logic1[] = {0, 1, -1, 42, 23, 32767, -32768}; + for(i = 0; i < (sizeof(logic1)/sizeof(int)); i++) { + for(j = 0; j < (sizeof(logic1)/sizeof(int)); j++) { + run_test(lor, logic1[i], logic1[j]); + run_test(land, logic1[i], logic1[j]) + } + } +#endif + + gibdir(); + testfields(); + testlonglong(); + testptrconv(); + testellipsis(); + + for(i = 0; i < 25; i++) testcontrol(i); + + + // conversion of certain boundary values + float a = 0xffffU; + hexn(a); /* this one results in various values, e.g. 0x7fff, -0x8000, -0x1, depending on + GCC options (-m32/64, -msse..., -ffast-math) */ + hexun(a); + + return d[5] + 10; +} + +#if 1 +struct bla { + int a; + int b; + int c; + int d; +}; + +struct bla sx64; + +// get struct by value argument +int nimmmich(struct bla x, int off) +{ + return x.c + off; +} + +// return struct by value +struct bla holmich(void) +{ + sx64.c = 0xbabe; + return sx64; +} + +// get struct by value, modify and pass it as argument +static void gibdir(void) +{ + struct bla xy = holmich(); + struct bla yz = holmich(); + // overwrite c to check that we actually pass a copy + xy.c = 0xbeef; + // write to members before and after to catch wrong offsets + yz.b = 1; + yz.d = 2; + hexun(nimmmich(xy,1)); + hexun(nimmmich(yz,2)); +} + +#endif + +// test bitfields +struct fields { + int a :1; + int b :1; + int c :2; + int d :4; + int e :3; + int f :1; + int g :12; + int x; +}; + +struct fields fd; + +// get/modify struct by reference +void modifyfields(struct fields* f, int x) +{ + f->x = 42; + f->a = 1; + f->b = 0; + f->c = 2; + f->d = x; // cast to bitfield + f->e = 0; + f->f = 1; + f->g = 23; +} + +// return bitfield struct +struct fields getfield(void) +{ + modifyfields(&fd, 2); + return fd; +} + +void testfields(void) +{ + struct fields f = getfield(); // get + hexn(f.x); + hexn(f.d); + hexn(f.g); + modifyfields(&f, 3); + hexn(f.x); + hexn(f.d); + hexn(f.g); + hexn(fd.d); +} + +__longlong longschlong(void) +{ + __longlong a = 5; + if(a == 42) return 23; /* triggers VT_JMPI problems */ + a += 3; //zahl(); + return a; +} + +void dumplong(__longlong x) +{ + //hexu(x >> 16); hexun(x); + hexlu(x); write(" ("); hexl(x); write(")\n"); +} + +void testlonglong(void) +{ + volatile __longlong x; + x = longschlong(); + hexn(x); + x += 32767; + dumplong(x); + x -= 5; + dumplong(x); + x >>= 3; + dumplong(x); + x <<= 3; + dumplong(x); + x <<= 3; + + // see if LLONG parameters get passed correctly + hexu(x >> 16); hexun(x); + dumplong(x); + + x = -x; + dumplong(x); +} + +float getfloat(void) +{ + return 5; +} + +#if 1 +int takefloat(float x) +{ + return (int)x; +} +#endif + +void testextreme(float x) +{ + write("extreme "); hexun(x); +} + +int ex1 = -1; +int ex2 = -32768; +int nex = 42; + +int testfloat(void) +{ + float a; + a = (float)0x112; //5; + a += getfloat(); + a += g; + + hexun(nex); testextreme(nex); + hexun(ex1); testextreme(ex1); + hexun(ex2); testextreme(ex2); + return takefloat(a); +} +#endif + +void xy(int bla) +{ +} + +void yz(char x) +{ + xy(x); +} + +void zz(int y) +{ + yz(y); +} + +void testcasts(void) +{ + int i; +#if 1 + for(i = 0; i < (sizeof(nums1)/sizeof(int)); i++) { + run_cast(char, nums1[i]); + run_cast(__uchar, nums1[i]); + run_cast(__int, nums1[i]); + run_cast(__uint, nums1[i]); + run_cast(float, nums1[i]); + run_cast(__longlong, nums1[i]); + run_cast(__ulonglong, nums1[i]); + } +#endif + + for(i = 0; i < (sizeof(float1)/sizeof(float)); i++) { + write("(int)float1["); hex(i); write("] == "); hexn(float1[i]); + } +#if 1 + for(i = 0; i < (sizeof(float1)/sizeof(float)); i++) { + run_cast(char, float1[i]); + run_cast(__uchar, float1[i]); + run_cast(__int, float1[i]); + run_cast(__uint, float1[i]); + run_cast(float, float1[i]); + run_cast(__longlong, float1[i]); + run_cast(__ulonglong, float1[i]); + } +#endif + +#if 1 + for(i = 0; i < (sizeof(ll1)/sizeof(__longlong)); i++) { + write("casting ll1["); hex(i); write("]\n"); +#if 1 + run_cast(char, ll1[i]); + run_cast(__uchar, ll1[i]); + run_cast(__int, ll1[i]); + run_cast(__uint, ll1[i]); + run_cast(float, ll1[i]); + run_cast(__longlong, ll1[i]); + run_cast(__ulonglong, ll1[i]); +#endif + run_cast(char, ull1[i]); + run_cast(__uchar, ull1[i]); + run_cast(__int, ull1[i]); + run_cast(__uint, ull1[i]); + run_cast(float, ull1[i]); + run_cast(__longlong, ull1[i]); + run_cast(__ulonglong, ull1[i]); + } +#endif + +#if 1 + for(i = 0; i < (sizeof(char1)/sizeof(char)); i++) { + run_cast(char, char1[i]); + run_cast(__uchar, char1[i]); + run_cast(__int, char1[i]); + run_cast(__uint, char1[i]); + run_cast(float, char1[i]); + run_cast(__longlong, char1[i]); + run_cast(__ulonglong, char1[i]); + run_cast(char, uchar1[i]); + run_cast(__uchar, uchar1[i]); + run_cast(__int, uchar1[i]); + run_cast(__uint, uchar1[i]); + run_cast(float, uchar1[i]); + run_cast(__longlong, uchar1[i]); + run_cast(__ulonglong, uchar1[i]); + } +#endif +} + +int* hans = b; +int* bx = (int*)5; + +void testptrconv(void) +{ + int* fritz; + int hannes; + + fritz = hans; + write("fritzhans "); hexn(*fritz); + +#if 0 // TCC does not allow conversion between pointers and long longs + __longlong herbert; + __ulonglong markus; + herbert = (__longlong)fritz; + write("herberthans "); hexn(*((int*)herbert)); + + markus = (__ulonglong)fritz; + write("markushans "); hexn(*((int*)markus)); +#endif + + hannes = (int)fritz; + +#if 0 // arithmetics are 16-bit only, so this is true on 65816 + if((int*)hannes == hans) write("int saves\n"); + else write("int does not save\n"); +#endif + + if(hannes == (int)hans) write("hans2int OK\n"); + else write("hans2int funky\n"); + + int ax = 3; + bx += 1; + if((int)ax == (int)bx) write("huhu\n"); + else write("bubu\n"); +} + +void testcontrol(int num) +{ +#if 1 + switch(num) { + case 0: write("null"); break; + case 1: write("eins"); break; + case 2: write("zwei"); break; + case 3: write("drei, nicht "); // falltrhu + case 4: write("vier"); break; + default: write("wos moanst?"); break; + } + OUTC('\n'); +#endif + +#if 1 + if(num <= 10) write("<= 10\n"); + else if(num > 11) write("> 11\n"); + else write("== 11\n"); + + int i; + for(i = num; i; --i) hex(i); + OUTC('\n'); +#endif + + i = num; + do { + hex(i); + } while(i--); + OUTC('\n'); + + i = num; +label: + hex(i); + if(!i--) { + OUTC('\n'); + return; + } + goto label; +} + +#include + +// certain wasteful compilers promote any type to int or double +#ifdef __65816__ +#define vachar char +#define vaint int +#define vafloat float +#else +#define vachar int32_t +#define vaint int32_t +#define vafloat double +#endif + +void ellprint(char* format, ...) +{ + va_list vl; + va_start(vl, format); + while(*format) { + switch(*format) { + case 'c': hex(va_arg(vl, vachar)); break; + case 'i': hex(va_arg(vl, vaint)); break; + case 'l': hexl(va_arg(vl, __longlong)); break; + case 'f': write("float "); hex(va_arg(vl, vafloat)); break; + default: break; + } + format++; + } + va_end(vl); +} + +void testellipsis(void) +{ + ellprint("cilf", char1[3], nums1[3], ll1[3], float1[3]); +} diff --git a/test/hw/hw3.h b/test/hw/hw3.h new file mode 100644 index 0000000..c33acf2 --- /dev/null +++ b/test/hw/hw3.h @@ -0,0 +1,15 @@ +#ifndef __65816__ +#include +#include +typedef int32_t __longlong; +typedef uint32_t __ulonglong; +#define int short +typedef int16_t __int; +#else +typedef long long __longlong; +typedef unsigned long long __ulonglong; +typedef int __int; +#endif + +typedef unsigned char __uchar; +typedef unsigned int __uint; diff --git a/test/hw/hw3_8regs.asm b/test/hw/hw3_8regs.asm new file mode 100644 index 0000000..00c5ccc --- /dev/null +++ b/test/hw/hw3_8regs.asm @@ -0,0 +1,191 @@ +.include "hdr.asm" +.accu 16 +.index 16 +.16bit +.section ".text" +main: +; sub sp,#__main_locals +tsa +sec +sbc #__main_locals +tas +; ld #8448,r0 +lda #$2100 +sta r0 +; store r 0 fr 0xf2 fc 0x2 +; st16 r0, [sp,2] +lda r0 +sta 2 + 1, s +; ld #8482,r0 +lda #$2122 +sta r0 +; store r 0 fr 0xf2 fc 0x0 +; st16 r0, [sp,0] +lda r0 +sta 0 + 1, s +; ld16 [sp,2],r0 +lda 2 + 1, s +sta r0 +; ld #128,r1 +lda #$80 +sta r1 +; store r 1 fr 0x5100 fc 0x2 +; st8 r1, [r0,0] +sep #$20 +ldx r0 +lda r1 +sta 0, x +rep #$20 +; ld16 [sp,0],r0 +lda 0 + 1, s +sta r0 +; ld #224,r1 +lda #$e0 +sta r1 +; store r 1 fr 0x5100 fc 0x0 +; st8 r1, [r0,0] +sep #$20 +ldx r0 +lda r1 +sta 0, x +rep #$20 +; ld16 [sp,0],r0 +lda 0 + 1, s +sta r0 +; ld #0,r1 +lda #$0 +sta r1 +; store r 1 fr 0x5100 fc 0x0 +; st8 r1, [r0,0] +sep #$20 +ldx r0 +lda r1 +sta 0, x +rep #$20 +; ld16 [sp,2],r0 +lda 2 + 1, s +sta r0 +; ld #15,r1 +lda #$f +sta r1 +; store r 1 fr 0x5100 fc 0x2 +; st8 r1, [r0,0] +sep #$20 +ldx r0 +lda r1 +sta 0, x +rep #$20 +__local_1: ; at 862 +; ld [string + 0], r0 +lda string +sta r0 +; gtst inv 1 t 0 v 0 r 902 +; ld8 [r0,0],r1 +stz r1 +sep #$20 +ldx r0 +lda 0, x +sta r1 +rep #$20 +; reg 1 to compare reg +lda r1 +sta r10 +; gtst inv 1 t 0 v 243 r 1031 +; cmp op 0x95 inv 1 +; compare +lda r10 +cmp #0 +beq __local_0 +; ld [out + 0], r0 +lda out +sta r0 +; ld [string + 0], r1 +lda string +sta r1 +; mov r1, r2 +lda r1 +sta r2 +; ld #1,r3 +lda #$1 +sta r3 +; add r3, r1 +clc +lda r1 +adc r3 +sta r1 +; store r 1 fr 0x3f0 fc 0x0 +; ld #string, r9 +lda #string +sta r9 +; st16 r1, [r9,0] +ldx r9 +lda r1 +sta 0, x +; ld8 [r2,0],r1 +stz r1 +sep #$20 +ldx r2 +lda 0, x +sta r1 +rep #$20 +; store r 1 fr 0x1100 fc 0x0 +; st8 r1, [r0,0] +sep #$20 +ldx r0 +lda r1 +sta 0, x +rep #$20 +; gjmp_addr 862 at 1541 +jmp __local_1 +; gsym_addr t 1541 a 862 +__local_0: ; at 1604 +; gsym_addr t 1031 a 1604 +; gsym_addr t 0 a 862 +; ld [d + 10], r0 +ldx d +lda 10, x +sta r0 +; gjmp_addr 0 at 1693 +jmp __local_2 +; gsym_addr t 1693 a 0 +__local_2: ; at 1752 +; gsym_addr t 1693 a 1752 +; add sp, #__main_locals +tsa +clc +adc #__main_locals +tas +rts +.define __main_locals 4 +.ends + +.ramsection "ram.data" bank 0 slot 1 +ramsection.data dsb 0 +string dsb 18 +out dsb 2 +a dsb 100 +b dsb 100 +.ends + +.section ".data" +startsection.data: +.dw ramsection.data + $2 +.db $68,$65,$6c,$6c,$6f,$2c,$20,$77,$6f,$72,$6c,$64,$21,$a,$0,$0 +.dw $fffe +.dw $1 +.db $2,$0,$3,$0,$4,$0,$5,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0 +.dw $6 +.db $7,$0,$8,$0,$9,$0,$a,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0 +endsection.data: +.ends + +.ramsection ".bss" bank 0 slot 1 +d dsb 100 +.ends +.section ".rotzdata" +startsection.rotzdata: +c: .dw $41 +.db $42,$0,$43,$0,$e,$0,$f,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0 +endsection.rotzdata: +.ends + diff --git a/test/hw/hw3_ptr16.asm b/test/hw/hw3_ptr16.asm new file mode 100644 index 0000000..7de7952 --- /dev/null +++ b/test/hw/hw3_ptr16.asm @@ -0,0 +1,2428 @@ +.include "hdr.asm" +.accu 16 +.index 16 +.16bit +.define __zahl_locals 0 +.define __write_locals 2 +.define __hexu_locals 6 +.define __hexun_locals 0 +.define __hex_locals 8 +.define __hexn_locals 0 +.define __writeequation_locals 0 +.define __testasr_locals 0 +.define __testlsr_locals 0 +.define __testsub_locals 0 +.define __testadd_locals 0 +.define __testmul_locals 0 +.define __testdiv_locals 0 +.define __testdivu_locals 0 +.define __main_locals 8 +.section ".text" + +zahl: +; sub sp,#__zahl_locals +.ifgr __zahl_locals 0 +tsa +sec +sbc #__zahl_locals +tas +.endif +; ld [a + 4], r0 +lda.l a + 4 +tax +; gjmp_addr 0 at 124 +jmp __local_0 +; gsym_addr t 124 a 0 +__local_0: ; at 181 +; gsym_addr t 124 a 181 +; add sp, #__zahl_locals +.ifgr __zahl_locals 0 +tsa +clc +adc #__zahl_locals +tas +.endif +rts + +write: +; sub sp,#__write_locals +.ifgr __write_locals 0 +tsa +sec +sbc #__write_locals +tas +.endif +__local_2: ; at 389 +; ld16 [sp,2],r0 (loc 0) +lda 2 + __write_locals + 1, s +tax +; gtst inv 1 t 0 v 0 r 448 +; ld8 [r0,0],r1 +; long problem: pointer in register +lda #0 +sep #$20 +lda 0,x +tay +rep #$20 +; y to accu +tya +; gtst inv 1 t 0 v 243 r 580 +; cmp op 0x95 inv 1 +; compare +cmp #0 +bne + +jmp __local_1 ++ +; ld [out + 0], r0 +lda.l out +tax +; ld16 [sp,2],r1 (loc 0) +lda 2 + __write_locals + 1, s +tay +; store r 0 fr 0x1f2 fc 0xfffffffe +; st16 r0, [sp,-2] +txa +sta -2 + __write_locals + 1, s +; mov r1, r0 +tyx +; adc r240 (0xf0), r1 (0x1) (fr type 0x0 c 1) +iny +; store r 1 fr 0x1f2 fc 0x2 +; st16 r1, [sp,2] +tya +sta 2 + __write_locals + 1, s +; ld8 [r0,0],r1 +; long problem: pointer in register +lda #0 +sep #$20 +lda 0,x +tay +rep #$20 +; ld16 [sp,-2],r0 (loc -2) +lda -2 + __write_locals + 1, s +tax +; store r 1 fr 0x100 fc 0xfffffffe +; st8 r1, [r0,0] +; long problem: pointer in register +sep #$20 +tya +sta 0,x +rep #$20 +; gjmp_addr 389 at 1265 +jmp __local_2 +; gsym_addr t 1265 a 389 +__local_1: ; at 1328 +; gsym_addr t 580 a 1328 +; gsym_addr t 0 a 389 +; gsym_addr t 0 a 1375 +; add sp, #__write_locals +.ifgr __write_locals 0 +tsa +clc +adc #__write_locals +tas +.endif +rts + +hexu: +; sub sp,#__hexu_locals +.ifgr __hexu_locals 0 +tsa +sec +sbc #__hexu_locals +tas +.endif +; ld #0,r0 +; potential long problem: constant to register +ldx #$0 +; store r 0 fr 0xf2 fc 0xfffffffc +; st16 r0, [sp,-4] +txa +sta -4 + __hexu_locals + 1, s +; ld #4,r0 +; potential long problem: constant to register +ldx #$4 +; store r 0 fr 0xf2 fc 0xfffffffa +; st16 r0, [sp,-6] +txa +sta -6 + __hexu_locals + 1, s +; push imm r 0x2f0 +pea L.3 +; call r 0x2f0 +jsr write +; add sp, #2 +pla +__local_7: ; at 1956 +; ld16 [sp,-6],r0 (loc -6) +lda -6 + __hexu_locals + 1, s +tax +; mov r0, r1 +txy +; adc r240 (0xf0), r0 (0x0) (fr type 0x10 c -1) +clc +txa +adc #-1 +tax +; store r 0 fr 0x1f2 fc 0xfffffffa +; st16 r0, [sp,-6] +txa +sta -6 + __hexu_locals + 1, s +; gtst inv 1 t 0 v 1 r 2190 +; y to accu +tya +; gtst inv 1 t 0 v 243 r 2234 +; cmp op 0x95 inv 1 +; compare +cmp #0 +bne + +jmp __local_3 ++ +; and r240 (0xf0), r498 (0x1f2) (fr type 0x10 c 61440) +; ld16 [sp,2],r0 (loc -6) +lda 2 + __hexu_locals + 1, s +tax +; nop +txa +and #61440 +tax +; ld #12,r1 +; potential long problem: constant to register +ldy #$c +; shr r1, r0 +txa +- cpy #0 +beq + +lsr a +dey +bra - ++ tax +; store r 0 fr 0x1f2 fc 0xfffffffe +; st16 r0, [sp,-2] +txa +sta -2 + __hexu_locals + 1, s +; adc r498 (0x1f2), r498 (0x1f2) (fr type 0x10 c -4) +; ld16 [sp,-2],r0 (loc -6) +lda -2 + __hexu_locals + 1, s +tax +; ld16 [sp,-4],r1 (loc -6) +lda -4 + __hexu_locals + 1, s +tay +clc +txa +phy +adc 1,s +tax +pla +; gtst inv 1 t 0 v 0 r 2874 +; x to accu +txa +; gtst inv 1 t 0 v 243 r 2918 +; cmp op 0x95 inv 1 +; compare +cmp #0 +bne + +jmp __local_4 ++ +; ld16 [sp,-2],r0 (loc -6) +lda -2 + __hexu_locals + 1, s +tax +; ld #10,r1 +; potential long problem: constant to register +ldy #$a +; cmpge r0, r1 +phy +txa +ldx #1 +cmp 1,s +bcs + +dex ++ ply +; gtst inv 1 t 0 v 0 r 3189 +; x to accu +txa +; gtst inv 1 t 0 v 243 r 3233 +; cmp op 0x95 inv 1 +; compare +cmp #0 +bne + +jmp __local_5 ++ +; ld [out + 0], r0 +lda.l out +tax +; sbc r240 (0xf0), r498 (0x1f2) (fr type 0x10 c 10) +; ld16 [sp,-2],r1 (loc -6) +lda -2 + __hexu_locals + 1, s +tay +sec +tya +sbc #10 +tay +; adc r240 (0xf0), r1 (0x1) (fr type 0x10 c 97) +clc +tya +adc #97 +tay +; store r 1 fr 0x1100 fc 0x0 +; st8 r1, [r0,0] +; long problem: pointer in register +sep #$20 +tya +sta 0,x +rep #$20 +; gjmp_addr 0 at 3668 +jmp __local_6 +; gsym_addr t 3668 a 0 +__local_5: ; at 3727 +; gsym_addr t 3233 a 3727 +; ld [out + 0], r0 +lda.l out +tax +; adc r240 (0xf0), r498 (0x1f2) (fr type 0x10 c 48) +; ld16 [sp,-2],r1 (loc -6) +lda -2 + __hexu_locals + 1, s +tay +clc +tya +adc #48 +tay +; store r 1 fr 0x1100 fc 0x0 +; st8 r1, [r0,0] +; long problem: pointer in register +sep #$20 +tya +sta 0,x +rep #$20 +__local_6: ; at 4031 +; gsym_addr t 3668 a 4031 +; ld #1,r0 +; potential long problem: constant to register +ldx #$1 +; store r 0 fr 0x1f2 fc 0xfffffffc +; st16 r0, [sp,-4] +txa +sta -4 + __hexu_locals + 1, s +__local_4: ; at 4211 +; gsym_addr t 2918 a 4211 +; ld16 [sp,2],r0 (loc -6) +lda 2 + __hexu_locals + 1, s +tax +; ld #4,r1 +; potential long problem: constant to register +ldy #$4 +; shl r1, r0 +txa +- cpy #0 +beq + +asl a +dey +bra - ++ tax +; store r 0 fr 0x1f2 fc 0x2 +; st16 r0, [sp,2] +txa +sta 2 + __hexu_locals + 1, s +; gjmp_addr 1956 at 4495 +jmp __local_7 +; gsym_addr t 4495 a 1956 +__local_3: ; at 4560 +; gsym_addr t 2234 a 4560 +; gsym_addr t 0 a 1956 +; gtst inv 1 t 0 v 242 r 4609 +; ld16 [sp,-4],r0 (loc -6) +lda -4 + __hexu_locals + 1, s +tax +; x to accu +txa +; gtst inv 1 t 0 v 243 r 4716 +; cmp op 0x95 inv 1 +; compare +cmp #0 +bne + +jmp __local_8 ++ +; gtst inv 1 t 0 v 244 r 4805 +; VT_jmp r 4805 t 0 +; gjmp_addr 0 at 4855 +jmp __local_9 +; gsym_addr t 4855 a 0 +__local_8: ; at 4914 +; gsym_addr t 4716 a 4914 +; ld [out + 0], r0 +lda.l out +tax +; ld #48,r1 +; potential long problem: constant to register +ldy #$30 +; store r 1 fr 0x1100 fc 0x0 +; st8 r1, [r0,0] +; long problem: pointer in register +sep #$20 +tya +sta 0,x +rep #$20 +__local_9: ; at 5153 +; gsym_addr t 4855 a 5153 +; gsym_addr t 0 a 5179 +; add sp, #__hexu_locals +.ifgr __hexu_locals 0 +tsa +clc +adc #__hexu_locals +tas +.endif +rts + +hexun: +; sub sp,#__hexun_locals +.ifgr __hexun_locals 0 +tsa +sec +sbc #__hexun_locals +tas +.endif +; ld16 [sp,2],r0 (loc 0) +lda 2 + __hexun_locals + 1, s +tax +phx +; call r 0x2f0 +jsr hexu +; add sp, #2 +pla +; ld [out + 0], r0 +lda.l out +tax +; ld #10,r1 +; potential long problem: constant to register +ldy #$a +; store r 1 fr 0x1100 fc 0x0 +; st8 r1, [r0,0] +; long problem: pointer in register +sep #$20 +tya +sta 0,x +rep #$20 +; gsym_addr t 0 a 5702 +; add sp, #__hexun_locals +.ifgr __hexun_locals 0 +tsa +clc +adc #__hexun_locals +tas +.endif +rts + +hex: +; sub sp,#__hex_locals +.ifgr __hex_locals 0 +tsa +sec +sbc #__hex_locals +tas +.endif +; ld #0,r0 +; potential long problem: constant to register +ldx #$0 +; store r 0 fr 0xf2 fc 0xfffffffc +; st16 r0, [sp,-4] +txa +sta -4 + __hex_locals + 1, s +; ld #4,r0 +; potential long problem: constant to register +ldx #$4 +; store r 0 fr 0xf2 fc 0xfffffff8 +; st16 r0, [sp,-8] +txa +sta -8 + __hex_locals + 1, s +; ld16 [sp,2],r0 (loc -8) +lda 2 + __hex_locals + 1, s +tax +; ld #0,r1 +; potential long problem: constant to register +ldy #$0 +; cmpge r0, r1 +phy +txa +ldx #1 +sec +sbc 1,s +bvc + +eor #$8000 ++ bmi +++ +++ dex ++++ ply +; gtst inv 1 t 0 v 0 r 6416 +; x to accu +txa +; gtst inv 1 t 0 v 243 r 6460 +; cmp op 0x95 inv 1 +; compare +cmp #0 +bne + +jmp __local_10 ++ +; ld [out + 0], r0 +lda.l out +tax +; ld #45,r1 +; potential long problem: constant to register +ldy #$2d +; store r 1 fr 0x1100 fc 0x0 +; st8 r1, [r0,0] +; long problem: pointer in register +sep #$20 +tya +sta 0,x +rep #$20 +; sbc r498 (0x1f2), r240 (0xf0) (fr type 0x0 c 2) +; ld #0,r0 +; potential long problem: constant to register +ldx #$0 +; ld16 [sp,2],r1 (loc -8) +lda 2 + __hex_locals + 1, s +tay +sec +txa +phy +sbc 1,s +tax +pla +; store r 0 fr 0x1f2 fc 0x2 +; st16 r0, [sp,2] +txa +sta 2 + __hex_locals + 1, s +__local_10: ; at 7043 +; gsym_addr t 6460 a 7043 +; push imm r 0x2f0 +pea L.4 +; call r 0x2f0 +jsr write +; add sp, #2 +pla +; ld16 [sp,2],r0 (loc -8) +lda 2 + __hex_locals + 1, s +tax +; store r 0 fr 0x1f2 fc 0xfffffffa +; st16 r0, [sp,-6] +txa +sta -6 + __hex_locals + 1, s +__local_15: ; at 7283 +; ld16 [sp,-8],r0 (loc -8) +lda -8 + __hex_locals + 1, s +tax +; mov r0, r1 +txy +; adc r240 (0xf0), r0 (0x0) (fr type 0x0 c -1) +clc +txa +adc #-1 +tax +; store r 0 fr 0x1f2 fc 0xfffffff8 +; st16 r0, [sp,-8] +txa +sta -8 + __hex_locals + 1, s +; gtst inv 1 t 0 v 1 r 7514 +; y to accu +tya +; gtst inv 1 t 0 v 243 r 7558 +; cmp op 0x95 inv 1 +; compare +cmp #0 +bne + +jmp __local_11 ++ +; and r240 (0xf0), r498 (0x1f2) (fr type 0x10 c 61440) +; ld16 [sp,-6],r0 (loc -8) +lda -6 + __hex_locals + 1, s +tax +; nop +txa +and #61440 +tax +; ld #12,r1 +; potential long problem: constant to register +ldy #$c +; shr r1, r0 +txa +- cpy #0 +beq + +lsr a +dey +bra - ++ tax +; store r 0 fr 0x1f2 fc 0xfffffffe +; st16 r0, [sp,-2] +txa +sta -2 + __hex_locals + 1, s +; adc r498 (0x1f2), r498 (0x1f2) (fr type 0x10 c -4) +; ld16 [sp,-2],r0 (loc -8) +lda -2 + __hex_locals + 1, s +tax +; ld16 [sp,-4],r1 (loc -8) +lda -4 + __hex_locals + 1, s +tay +clc +txa +phy +adc 1,s +tax +pla +; gtst inv 1 t 0 v 0 r 8197 +; x to accu +txa +; gtst inv 1 t 0 v 243 r 8241 +; cmp op 0x95 inv 1 +; compare +cmp #0 +bne + +jmp __local_12 ++ +; ld16 [sp,-2],r0 (loc -8) +lda -2 + __hex_locals + 1, s +tax +; ld #10,r1 +; potential long problem: constant to register +ldy #$a +; cmpge r0, r1 +phy +txa +ldx #1 +cmp 1,s +bcs + +dex ++ ply +; gtst inv 1 t 0 v 0 r 8512 +; x to accu +txa +; gtst inv 1 t 0 v 243 r 8556 +; cmp op 0x95 inv 1 +; compare +cmp #0 +bne + +jmp __local_13 ++ +; ld [out + 0], r0 +lda.l out +tax +; sbc r240 (0xf0), r498 (0x1f2) (fr type 0x10 c 10) +; ld16 [sp,-2],r1 (loc -8) +lda -2 + __hex_locals + 1, s +tay +sec +tya +sbc #10 +tay +; adc r240 (0xf0), r1 (0x1) (fr type 0x10 c 97) +clc +tya +adc #97 +tay +; store r 1 fr 0x1100 fc 0x0 +; st8 r1, [r0,0] +; long problem: pointer in register +sep #$20 +tya +sta 0,x +rep #$20 +; gjmp_addr 0 at 8991 +jmp __local_14 +; gsym_addr t 8991 a 0 +__local_13: ; at 9051 +; gsym_addr t 8556 a 9051 +; ld [out + 0], r0 +lda.l out +tax +; adc r240 (0xf0), r498 (0x1f2) (fr type 0x10 c 48) +; ld16 [sp,-2],r1 (loc -8) +lda -2 + __hex_locals + 1, s +tay +clc +tya +adc #48 +tay +; store r 1 fr 0x1100 fc 0x0 +; st8 r1, [r0,0] +; long problem: pointer in register +sep #$20 +tya +sta 0,x +rep #$20 +__local_14: ; at 9354 +; gsym_addr t 8991 a 9354 +; ld #1,r0 +; potential long problem: constant to register +ldx #$1 +; store r 0 fr 0x1f2 fc 0xfffffffc +; st16 r0, [sp,-4] +txa +sta -4 + __hex_locals + 1, s +__local_12: ; at 9533 +; gsym_addr t 8241 a 9533 +; ld16 [sp,-6],r0 (loc -8) +lda -6 + __hex_locals + 1, s +tax +; ld #4,r1 +; potential long problem: constant to register +ldy #$4 +; shl r1, r0 +txa +- cpy #0 +beq + +asl a +dey +bra - ++ tax +; store r 0 fr 0x1f2 fc 0xfffffffa +; st16 r0, [sp,-6] +txa +sta -6 + __hex_locals + 1, s +; gjmp_addr 7283 at 9826 +jmp __local_15 +; gsym_addr t 9826 a 7283 +__local_11: ; at 9892 +; gsym_addr t 7558 a 9892 +; gsym_addr t 0 a 7283 +; gtst inv 1 t 0 v 242 r 9941 +; ld16 [sp,-4],r0 (loc -8) +lda -4 + __hex_locals + 1, s +tax +; x to accu +txa +; gtst inv 1 t 0 v 243 r 10047 +; cmp op 0x95 inv 1 +; compare +cmp #0 +bne + +jmp __local_16 ++ +; gtst inv 1 t 0 v 244 r 10138 +; VT_jmp r 10138 t 0 +; gjmp_addr 0 at 10190 +jmp __local_17 +; gsym_addr t 10190 a 0 +__local_16: ; at 10252 +; gsym_addr t 10047 a 10252 +; ld [out + 0], r0 +lda.l out +tax +; ld #48,r1 +; potential long problem: constant to register +ldy #$30 +; store r 1 fr 0x1100 fc 0x0 +; st8 r1, [r0,0] +; long problem: pointer in register +sep #$20 +tya +sta 0,x +rep #$20 +__local_17: ; at 10493 +; gsym_addr t 10190 a 10493 +; gsym_addr t 0 a 10521 +; add sp, #__hex_locals +.ifgr __hex_locals 0 +tsa +clc +adc #__hex_locals +tas +.endif +rts + +hexn: +; sub sp,#__hexn_locals +.ifgr __hexn_locals 0 +tsa +sec +sbc #__hexn_locals +tas +.endif +; ld16 [sp,2],r0 (loc 0) +lda 2 + __hexn_locals + 1, s +tax +phx +; call r 0x2f0 +jsr hex +; add sp, #2 +pla +; ld [out + 0], r0 +lda.l out +tax +; ld #10,r1 +; potential long problem: constant to register +ldy #$a +; store r 1 fr 0x1100 fc 0x0 +; st8 r1, [r0,0] +; long problem: pointer in register +sep #$20 +tya +sta 0,x +rep #$20 +; gsym_addr t 0 a 11036 +; add sp, #__hexn_locals +.ifgr __hexn_locals 0 +tsa +clc +adc #__hexn_locals +tas +.endif +rts + +writeequation: +; sub sp,#__writeequation_locals +.ifgr __writeequation_locals 0 +tsa +sec +sbc #__writeequation_locals +tas +.endif +; ld16 [sp,2],r0 (loc 0) +lda 2 + __writeequation_locals + 1, s +tax +phx +; call r 0x2f0 +jsr hexu +; add sp, #2 +pla +; ld [out + 0], r0 +lda.l out +tax +; ld #32,r1 +; potential long problem: constant to register +ldy #$20 +; store r 1 fr 0x1100 fc 0x0 +; st8 r1, [r0,0] +; long problem: pointer in register +sep #$20 +tya +sta 0,x +rep #$20 +; ld16 [sp,4],r0 (loc 0) +lda 4 + __writeequation_locals + 1, s +tax +phx +; call r 0x2f0 +jsr write +; add sp, #2 +pla +; ld [out + 0], r0 +lda.l out +tax +; ld #32,r1 +; potential long problem: constant to register +ldy #$20 +; store r 1 fr 0x1100 fc 0x0 +; st8 r1, [r0,0] +; long problem: pointer in register +sep #$20 +tya +sta 0,x +rep #$20 +; ld16 [sp,6],r0 (loc 0) +lda 6 + __writeequation_locals + 1, s +tax +phx +; call r 0x2f0 +jsr hexu +; add sp, #2 +pla +; push imm r 0x2f0 +pea L.5 +; call r 0x2f0 +jsr write +; add sp, #2 +pla +; gsym_addr t 0 a 12108 +; add sp, #__writeequation_locals +.ifgr __writeequation_locals 0 +tsa +clc +adc #__writeequation_locals +tas +.endif +rts + +testasr: +; sub sp,#__testasr_locals +.ifgr __testasr_locals 0 +tsa +sec +sbc #__testasr_locals +tas +.endif +; ld16 [sp,4],r0 (loc 0) +lda 4 + __testasr_locals + 1, s +tax +phx +; push imm r 0x2f0 +pea L.6 +; ld16 [sp,2],r0 (loc 0) +lda 6 + __testasr_locals + 1, s +tax +phx +; call r 0x2f0 +jsr writeequation +; add sp, #6 +tsa +clc +adc #6 +tas +; ld16 [sp,2],r0 (loc 0) +lda 2 + __testasr_locals + 1, s +tax +; ld16 [sp,4],r1 (loc 0) +lda 4 + __testasr_locals + 1, s +tay +; sar r1, r0 +txa +- cpy #0 +beq + +cmp #$8000 +ror a +dey +bra - ++ tax +; store r 0 fr 0x1f2 fc 0x2 +; st16 r0, [sp,2] +txa +sta 2 + __testasr_locals + 1, s +; ld16 [sp,2],r0 (loc 0) +lda 2 + __testasr_locals + 1, s +tax +phx +; call r 0x2f0 +jsr hexu +; add sp, #2 +pla +; ld [out + 0], r0 +lda.l out +tax +; ld #10,r1 +; potential long problem: constant to register +ldy #$a +; store r 1 fr 0x1100 fc 0x0 +; st8 r1, [r0,0] +; long problem: pointer in register +sep #$20 +tya +sta 0,x +rep #$20 +; gsym_addr t 0 a 13160 +; add sp, #__testasr_locals +.ifgr __testasr_locals 0 +tsa +clc +adc #__testasr_locals +tas +.endif +rts + +testlsr: +; sub sp,#__testlsr_locals +.ifgr __testlsr_locals 0 +tsa +sec +sbc #__testlsr_locals +tas +.endif +; ld16 [sp,4],r0 (loc 0) +lda 4 + __testlsr_locals + 1, s +tax +phx +; push imm r 0x2f0 +pea L.7 +; ld16 [sp,2],r0 (loc 0) +lda 6 + __testlsr_locals + 1, s +tax +phx +; call r 0x2f0 +jsr writeequation +; add sp, #6 +tsa +clc +adc #6 +tas +; ld16 [sp,2],r0 (loc 0) +lda 2 + __testlsr_locals + 1, s +tax +; ld16 [sp,4],r1 (loc 0) +lda 4 + __testlsr_locals + 1, s +tay +; shr r1, r0 +txa +- cpy #0 +beq + +lsr a +dey +bra - ++ tax +; store r 0 fr 0x1f2 fc 0x2 +; st16 r0, [sp,2] +txa +sta 2 + __testlsr_locals + 1, s +; ld16 [sp,2],r0 (loc 0) +lda 2 + __testlsr_locals + 1, s +tax +phx +; call r 0x2f0 +jsr hexu +; add sp, #2 +pla +; ld [out + 0], r0 +lda.l out +tax +; ld #10,r1 +; potential long problem: constant to register +ldy #$a +; store r 1 fr 0x1100 fc 0x0 +; st8 r1, [r0,0] +; long problem: pointer in register +sep #$20 +tya +sta 0,x +rep #$20 +; gsym_addr t 0 a 14183 +; add sp, #__testlsr_locals +.ifgr __testlsr_locals 0 +tsa +clc +adc #__testlsr_locals +tas +.endif +rts + +testsub: +; sub sp,#__testsub_locals +.ifgr __testsub_locals 0 +tsa +sec +sbc #__testsub_locals +tas +.endif +; ld16 [sp,4],r0 (loc 0) +lda 4 + __testsub_locals + 1, s +tax +phx +; push imm r 0x2f0 +pea L.8 +; ld16 [sp,2],r0 (loc 0) +lda 6 + __testsub_locals + 1, s +tax +phx +; call r 0x2f0 +jsr writeequation +; add sp, #6 +tsa +clc +adc #6 +tas +; sbc r498 (0x1f2), r498 (0x1f2) (fr type 0x0 c 4) +; ld16 [sp,2],r0 (loc 0) +lda 2 + __testsub_locals + 1, s +tax +; ld16 [sp,4],r1 (loc 0) +lda 4 + __testsub_locals + 1, s +tay +sec +txa +phy +sbc 1,s +tax +pla +; store r 0 fr 0x1f2 fc 0x2 +; st16 r0, [sp,2] +txa +sta 2 + __testsub_locals + 1, s +; ld16 [sp,2],r0 (loc 0) +lda 2 + __testsub_locals + 1, s +tax +phx +; call r 0x2f0 +jsr hex +; add sp, #2 +pla +; ld [out + 0], r0 +lda.l out +tax +; ld #10,r1 +; potential long problem: constant to register +ldy #$a +; store r 1 fr 0x1100 fc 0x0 +; st8 r1, [r0,0] +; long problem: pointer in register +sep #$20 +tya +sta 0,x +rep #$20 +; gsym_addr t 0 a 15230 +; add sp, #__testsub_locals +.ifgr __testsub_locals 0 +tsa +clc +adc #__testsub_locals +tas +.endif +rts + +testadd: +; sub sp,#__testadd_locals +.ifgr __testadd_locals 0 +tsa +sec +sbc #__testadd_locals +tas +.endif +; ld16 [sp,4],r0 (loc 0) +lda 4 + __testadd_locals + 1, s +tax +phx +; push imm r 0x2f0 +pea L.9 +; ld16 [sp,2],r0 (loc 0) +lda 6 + __testadd_locals + 1, s +tax +phx +; call r 0x2f0 +jsr writeequation +; add sp, #6 +tsa +clc +adc #6 +tas +; adc r498 (0x1f2), r498 (0x1f2) (fr type 0x0 c 4) +; ld16 [sp,2],r0 (loc 0) +lda 2 + __testadd_locals + 1, s +tax +; ld16 [sp,4],r1 (loc 0) +lda 4 + __testadd_locals + 1, s +tay +clc +txa +phy +adc 1,s +tax +pla +; store r 0 fr 0x1f2 fc 0x2 +; st16 r0, [sp,2] +txa +sta 2 + __testadd_locals + 1, s +; ld16 [sp,2],r0 (loc 0) +lda 2 + __testadd_locals + 1, s +tax +phx +; call r 0x2f0 +jsr hex +; add sp, #2 +pla +; ld [out + 0], r0 +lda.l out +tax +; ld #10,r1 +; potential long problem: constant to register +ldy #$a +; store r 1 fr 0x1100 fc 0x0 +; st8 r1, [r0,0] +; long problem: pointer in register +sep #$20 +tya +sta 0,x +rep #$20 +; gsym_addr t 0 a 16277 +; add sp, #__testadd_locals +.ifgr __testadd_locals 0 +tsa +clc +adc #__testadd_locals +tas +.endif +rts + +testmul: +; sub sp,#__testmul_locals +.ifgr __testmul_locals 0 +tsa +sec +sbc #__testmul_locals +tas +.endif +; ld16 [sp,4],r0 (loc 0) +lda 4 + __testmul_locals + 1, s +tax +phx +; push imm r 0x2f0 +pea L.10 +; ld16 [sp,2],r0 (loc 0) +lda 6 + __testmul_locals + 1, s +tax +phx +; call r 0x2f0 +jsr writeequation +; add sp, #6 +tsa +clc +adc #6 +tas +; ld16 [sp,2],r0 (loc 0) +lda 2 + __testmul_locals + 1, s +tax +; ld16 [sp,4],r1 (loc 0) +lda 4 + __testmul_locals + 1, s +tay +; mul r1,r0 +tya +sta.l r9 +txa +sta.l r10 +jsr tcc__mul +tax +lda.l r9 +tay +; store r 0 fr 0x1f2 fc 0x2 +; st16 r0, [sp,2] +txa +sta 2 + __testmul_locals + 1, s +; ld16 [sp,2],r0 (loc 0) +lda 2 + __testmul_locals + 1, s +tax +phx +; call r 0x2f0 +jsr hex +; add sp, #2 +pla +; ld [out + 0], r0 +lda.l out +tax +; ld #10,r1 +; potential long problem: constant to register +ldy #$a +; store r 1 fr 0x1100 fc 0x0 +; st8 r1, [r0,0] +; long problem: pointer in register +sep #$20 +tya +sta 0,x +rep #$20 +; gsym_addr t 0 a 17315 +; add sp, #__testmul_locals +.ifgr __testmul_locals 0 +tsa +clc +adc #__testmul_locals +tas +.endif +rts + +testdiv: +; sub sp,#__testdiv_locals +.ifgr __testdiv_locals 0 +tsa +sec +sbc #__testdiv_locals +tas +.endif +; ld16 [sp,4],r0 (loc 0) +lda 4 + __testdiv_locals + 1, s +tax +phx +; push imm r 0x2f0 +pea L.11 +; ld16 [sp,2],r0 (loc 0) +lda 6 + __testdiv_locals + 1, s +tax +phx +; call r 0x2f0 +jsr writeequation +; add sp, #6 +tsa +clc +adc #6 +tas +; ld16 [sp,2],r0 (loc 0) +lda 2 + __testdiv_locals + 1, s +tax +; ld16 [sp,4],r1 (loc 0) +lda 4 + __testdiv_locals + 1, s +tay +; div r1,r0 +phy +tya +jsr tcc__div +lda.l r9 +tax +ply +; store r 0 fr 0x1f2 fc 0x2 +; st16 r0, [sp,2] +txa +sta 2 + __testdiv_locals + 1, s +; ld16 [sp,2],r0 (loc 0) +lda 2 + __testdiv_locals + 1, s +tax +phx +; call r 0x2f0 +jsr hex +; add sp, #2 +pla +; ld [out + 0], r0 +lda.l out +tax +; ld #10,r1 +; potential long problem: constant to register +ldy #$a +; store r 1 fr 0x1100 fc 0x0 +; st8 r1, [r0,0] +; long problem: pointer in register +sep #$20 +tya +sta 0,x +rep #$20 +; gsym_addr t 0 a 18334 +; add sp, #__testdiv_locals +.ifgr __testdiv_locals 0 +tsa +clc +adc #__testdiv_locals +tas +.endif +rts + +testdivu: +; sub sp,#__testdivu_locals +.ifgr __testdivu_locals 0 +tsa +sec +sbc #__testdivu_locals +tas +.endif +; ld16 [sp,4],r0 (loc 0) +lda 4 + __testdivu_locals + 1, s +tax +phx +; push imm r 0x2f0 +pea L.12 +; ld16 [sp,2],r0 (loc 0) +lda 6 + __testdivu_locals + 1, s +tax +phx +; call r 0x2f0 +jsr writeequation +; add sp, #6 +tsa +clc +adc #6 +tas +; ld16 [sp,2],r0 (loc 0) +lda 2 + __testdivu_locals + 1, s +tax +; ld16 [sp,4],r1 (loc 0) +lda 4 + __testdivu_locals + 1, s +tay +; div r1,r0 +phy +tya +jsr tcc__udiv +lda.l r9 +tax +ply +; store r 0 fr 0x1f2 fc 0x2 +; st16 r0, [sp,2] +txa +sta 2 + __testdivu_locals + 1, s +; ld16 [sp,2],r0 (loc 0) +lda 2 + __testdivu_locals + 1, s +tax +phx +; call r 0x2f0 +jsr hexu +; add sp, #2 +pla +; ld [out + 0], r0 +lda.l out +tax +; ld #10,r1 +; potential long problem: constant to register +ldy #$a +; store r 1 fr 0x1100 fc 0x0 +; st8 r1, [r0,0] +; long problem: pointer in register +sep #$20 +tya +sta 0,x +rep #$20 +; gsym_addr t 0 a 19365 +; add sp, #__testdivu_locals +.ifgr __testdivu_locals 0 +tsa +clc +adc #__testdivu_locals +tas +.endif +rts + +main: +; sub sp,#__main_locals +.ifgr __main_locals 0 +tsa +sec +sbc #__main_locals +tas +.endif +; ld #8448,r0 +; potential long problem: constant to register +ldx #$2100 +; store r 0 fr 0xf2 fc 0xfffffffc +; st16 r0, [sp,-4] +txa +sta -4 + __main_locals + 1, s +; ld #8482,r0 +; potential long problem: constant to register +ldx #$2122 +; store r 0 fr 0xf2 fc 0xfffffffa +; st16 r0, [sp,-6] +txa +sta -6 + __main_locals + 1, s +; ld16 [sp,-4],r0 (loc -6) +lda -4 + __main_locals + 1, s +tax +; ld #128,r1 +; potential long problem: constant to register +ldy #$80 +; store r 1 fr 0x5100 fc 0xfffffffc +; st8 r1, [r0,0] +; long problem: pointer in register +sep #$20 +tya +sta 0,x +rep #$20 +; ld16 [sp,-6],r0 (loc -6) +lda -6 + __main_locals + 1, s +tax +; ld #224,r1 +; potential long problem: constant to register +ldy #$e0 +; store r 1 fr 0x5100 fc 0xfffffffa +; st8 r1, [r0,0] +; long problem: pointer in register +sep #$20 +tya +sta 0,x +rep #$20 +; ld16 [sp,-6],r0 (loc -6) +lda -6 + __main_locals + 1, s +tax +; ld #0,r1 +; potential long problem: constant to register +ldy #$0 +; store r 1 fr 0x5100 fc 0xfffffffa +; st8 r1, [r0,0] +; long problem: pointer in register +sep #$20 +tya +sta 0,x +rep #$20 +; ld16 [sp,-4],r0 (loc -6) +lda -4 + __main_locals + 1, s +tax +; ld #15,r1 +; potential long problem: constant to register +ldy #$f +; store r 1 fr 0x5100 fc 0xfffffffc +; st8 r1, [r0,0] +; long problem: pointer in register +sep #$20 +tya +sta 0,x +rep #$20 +; ld [string + 0], r0 +lda.l string +tax +phx +; call r 0x2f0 +jsr write +; add sp, #2 +pla +; call r 0x2f0 +jsr zahl +; adc r0 (0x0), r1008 (0x3f0) (fr type 0x0 c 0) +; ld [string + 0], r1 +lda.l string +tay +clc +tya +phx +adc 1,s +tay +pla +; store r 1 fr 0x3f0 fc 0x0 +; ld #string, r9 +; long problem: symbol to register +lda #string +sta.l r9 +; st16 r1, [r9,0] +; long problem: pointer in register +phx +lda.l r9 +tax +tya +sta 0, x +plx +; ld [string + 0], r0 +lda.l string +tax +phx +; call r 0x2f0 +jsr write +; add sp, #2 +pla +; adc r240 (0xf0), r1008 (0x3f0) (fr type 0x0 c -2) +; ld [string + 0], r0 +lda.l string +tax +clc +txa +adc #-2 +tax +; store r 0 fr 0x3f0 fc 0x0 +; ld #string, r9 +; long problem: symbol to register +lda #string +sta.l r9 +; st16 r0, [r9,0] +; long problem: pointer in register +phx +lda.l r9 +tax +lda 1,s +sta 0, x +plx +; ld [string + 0], r0 +lda.l string +tax +phx +; call r 0x2f0 +jsr write +; add sp, #2 +pla +; push imm r 0x2f0 +pea L.13 +; call r 0x2f0 +jsr write +; add sp, #2 +pla +; push imm r 0xf0 +pea $fff6 +; call r 0x2f0 +jsr hexn +; add sp, #2 +pla +; push imm r 0xf0 +pea $5 +; call r 0x2f0 +jsr hexn +; add sp, #2 +pla +; push imm r 0xf0 +pea $a +; call r 0x2f0 +jsr hexn +; add sp, #2 +pla +; push imm r 0x2f0 +pea L.14 +; call r 0x2f0 +jsr write +; add sp, #2 +pla +; push imm r 0xf0 +pea $fff6 +; call r 0x2f0 +jsr hexun +; add sp, #2 +pla +; push imm r 0xf0 +pea $5 +; call r 0x2f0 +jsr hexun +; add sp, #2 +pla +; push imm r 0xf0 +pea $a +; call r 0x2f0 +jsr hexun +; add sp, #2 +pla +; push imm r 0x2f0 +pea L.15 +; call r 0x2f0 +jsr write +; add sp, #2 +pla +; push imm r 0xf0 +pea $2 +; push imm r 0xf0 +pea $ffff +; call r 0x2f0 +jsr testasr +; add sp, #4 +tsa +clc +adc #4 +tas +; push imm r 0xf0 +pea $4 +; push imm r 0xf0 +pea $ff00 +; call r 0x2f0 +jsr testasr +; add sp, #4 +tsa +clc +adc #4 +tas +; push imm r 0xf0 +pea $2 +; push imm r 0xf0 +pea $f0 +; call r 0x2f0 +jsr testasr +; add sp, #4 +tsa +clc +adc #4 +tas +; push imm r 0xf0 +pea $1 +; push imm r 0xf0 +pea $8000 +; call r 0x2f0 +jsr testasr +; add sp, #4 +tsa +clc +adc #4 +tas +; push imm r 0xf0 +pea $1 +; push imm r 0xf0 +pea $8001 +; call r 0x2f0 +jsr testasr +; add sp, #4 +tsa +clc +adc #4 +tas +; push imm r 0xf0 +pea $1 +; push imm r 0xf0 +pea $7fff +; call r 0x2f0 +jsr testasr +; add sp, #4 +tsa +clc +adc #4 +tas +; push imm r 0xf0 +pea $2 +; push imm r 0xf0 +pea $ffff +; call r 0x2f0 +jsr testlsr +; add sp, #4 +tsa +clc +adc #4 +tas +; push imm r 0xf0 +pea $4 +; push imm r 0xf0 +pea $ff00 +; call r 0x2f0 +jsr testlsr +; add sp, #4 +tsa +clc +adc #4 +tas +; push imm r 0xf0 +pea $2 +; push imm r 0xf0 +pea $f0 +; call r 0x2f0 +jsr testlsr +; add sp, #4 +tsa +clc +adc #4 +tas +; push imm r 0xf0 +pea $1 +; push imm r 0xf0 +pea $8000 +; call r 0x2f0 +jsr testlsr +; add sp, #4 +tsa +clc +adc #4 +tas +; push imm r 0xf0 +pea $1 +; push imm r 0xf0 +pea $8001 +; call r 0x2f0 +jsr testlsr +; add sp, #4 +tsa +clc +adc #4 +tas +; push imm r 0xf0 +pea $1 +; push imm r 0xf0 +pea $7fff +; call r 0x2f0 +jsr testlsr +; add sp, #4 +tsa +clc +adc #4 +tas +; push imm r 0xf0 +pea $5 +; push imm r 0xf0 +pea $a +; call r 0x2f0 +jsr testsub +; add sp, #4 +tsa +clc +adc #4 +tas +; push imm r 0xf0 +pea $a +; push imm r 0xf0 +pea $a +; call r 0x2f0 +jsr testsub +; add sp, #4 +tsa +clc +adc #4 +tas +; push imm r 0xf0 +pea $a +; push imm r 0xf0 +pea $5 +; call r 0x2f0 +jsr testsub +; add sp, #4 +tsa +clc +adc #4 +tas +; push imm r 0xf0 +pea $a +; push imm r 0xf0 +pea $0 +; call r 0x2f0 +jsr testsub +; add sp, #4 +tsa +clc +adc #4 +tas +; push imm r 0xf0 +pea $0 +; push imm r 0xf0 +pea $fff6 +; call r 0x2f0 +jsr testsub +; add sp, #4 +tsa +clc +adc #4 +tas +; push imm r 0xf0 +pea $0 +; push imm r 0xf0 +pea $a +; call r 0x2f0 +jsr testsub +; add sp, #4 +tsa +clc +adc #4 +tas +; push imm r 0xf0 +pea $fffb +; push imm r 0xf0 +pea $fff6 +; call r 0x2f0 +jsr testsub +; add sp, #4 +tsa +clc +adc #4 +tas +; push imm r 0xf0 +pea $5 +; push imm r 0xf0 +pea $fff6 +; call r 0x2f0 +jsr testsub +; add sp, #4 +tsa +clc +adc #4 +tas +; push imm r 0xf0 +pea $fff6 +; push imm r 0xf0 +pea $a +; call r 0x2f0 +jsr testsub +; add sp, #4 +tsa +clc +adc #4 +tas +; push imm r 0xf0 +pea $a +; push imm r 0xf0 +pea $5 +; call r 0x2f0 +jsr testadd +; add sp, #4 +tsa +clc +adc #4 +tas +; push imm r 0xf0 +pea $a +; push imm r 0xf0 +pea $fffb +; call r 0x2f0 +jsr testadd +; add sp, #4 +tsa +clc +adc #4 +tas +; push imm r 0xf0 +pea $5 +; push imm r 0xf0 +pea $0 +; call r 0x2f0 +jsr testadd +; add sp, #4 +tsa +clc +adc #4 +tas +; push imm r 0xf0 +pea $fffb +; push imm r 0xf0 +pea $0 +; call r 0x2f0 +jsr testadd +; add sp, #4 +tsa +clc +adc #4 +tas +; push imm r 0xf0 +pea $0 +; push imm r 0xf0 +pea $fffb +; call r 0x2f0 +jsr testadd +; add sp, #4 +tsa +clc +adc #4 +tas +; push imm r 0xf0 +pea $0 +; push imm r 0xf0 +pea $5 +; call r 0x2f0 +jsr testadd +; add sp, #4 +tsa +clc +adc #4 +tas +; push imm r 0xf0 +pea $fff6 +; push imm r 0xf0 +pea $5 +; call r 0x2f0 +jsr testadd +; add sp, #4 +tsa +clc +adc #4 +tas +; push imm r 0xf0 +pea $4 +; push imm r 0xf0 +pea $2 +; call r 0x2f0 +jsr testmul +; add sp, #4 +tsa +clc +adc #4 +tas +; push imm r 0xf0 +pea $4 +; push imm r 0xf0 +pea $fffe +; call r 0x2f0 +jsr testmul +; add sp, #4 +tsa +clc +adc #4 +tas +; push imm r 0xf0 +pea $2 +; push imm r 0xf0 +pea $0 +; call r 0x2f0 +jsr testmul +; add sp, #4 +tsa +clc +adc #4 +tas +; push imm r 0xf0 +pea $fffe +; push imm r 0xf0 +pea $0 +; call r 0x2f0 +jsr testmul +; add sp, #4 +tsa +clc +adc #4 +tas +; push imm r 0xf0 +pea $fffc +; push imm r 0xf0 +pea $2 +; call r 0x2f0 +jsr testmul +; add sp, #4 +tsa +clc +adc #4 +tas +; push imm r 0xf0 +pea $0 +; push imm r 0xf0 +pea $2 +; call r 0x2f0 +jsr testmul +; add sp, #4 +tsa +clc +adc #4 +tas +; push imm r 0xf0 +pea $0 +; push imm r 0xf0 +pea $fffe +; call r 0x2f0 +jsr testmul +; add sp, #4 +tsa +clc +adc #4 +tas +; push imm r 0xf0 +pea $100 +; push imm r 0xf0 +pea $100 +; call r 0x2f0 +jsr testmul +; add sp, #4 +tsa +clc +adc #4 +tas +; push imm r 0xf0 +pea $5 +; push imm r 0xf0 +pea $2a +; call r 0x2f0 +jsr testdiv +; add sp, #4 +tsa +clc +adc #4 +tas +; push imm r 0xf0 +pea $2a +; push imm r 0xf0 +pea $5 +; call r 0x2f0 +jsr testdiv +; add sp, #4 +tsa +clc +adc #4 +tas +; push imm r 0xf0 +pea $5 +; push imm r 0xf0 +pea $ffd6 +; call r 0x2f0 +jsr testdiv +; add sp, #4 +tsa +clc +adc #4 +tas +; push imm r 0xf0 +pea $fffb +; push imm r 0xf0 +pea $2a +; call r 0x2f0 +jsr testdiv +; add sp, #4 +tsa +clc +adc #4 +tas +; push imm r 0xf0 +pea $2a +; push imm r 0xf0 +pea $fffb +; call r 0x2f0 +jsr testdiv +; add sp, #4 +tsa +clc +adc #4 +tas +; push imm r 0xf0 +pea $8 +; push imm r 0xf0 +pea $28 +; call r 0x2f0 +jsr testdiv +; add sp, #4 +tsa +clc +adc #4 +tas +; push imm r 0xf0 +pea $8 +; push imm r 0xf0 +pea $0 +; call r 0x2f0 +jsr testdiv +; add sp, #4 +tsa +clc +adc #4 +tas +; push imm r 0xf0 +pea $fffb +; push imm r 0xf0 +pea $ffd6 +; call r 0x2f0 +jsr testdiv +; add sp, #4 +tsa +clc +adc #4 +tas +; push imm r 0xf0 +pea $5 +; push imm r 0xf0 +pea $2a +; call r 0x2f0 +jsr testdivu +; add sp, #4 +tsa +clc +adc #4 +tas +; push imm r 0xf0 +pea $2a +; push imm r 0xf0 +pea $5 +; call r 0x2f0 +jsr testdivu +; add sp, #4 +tsa +clc +adc #4 +tas +; push imm r 0xf0 +pea $5 +; push imm r 0xf0 +pea $ffd6 +; call r 0x2f0 +jsr testdivu +; add sp, #4 +tsa +clc +adc #4 +tas +; push imm r 0xf0 +pea $fffb +; push imm r 0xf0 +pea $2a +; call r 0x2f0 +jsr testdivu +; add sp, #4 +tsa +clc +adc #4 +tas +; push imm r 0xf0 +pea $2a +; push imm r 0xf0 +pea $fffb +; call r 0x2f0 +jsr testdivu +; add sp, #4 +tsa +clc +adc #4 +tas +; push imm r 0xf0 +pea $8 +; push imm r 0xf0 +pea $28 +; call r 0x2f0 +jsr testdivu +; add sp, #4 +tsa +clc +adc #4 +tas +; push imm r 0xf0 +pea $8 +; push imm r 0xf0 +pea $0 +; call r 0x2f0 +jsr testdivu +; add sp, #4 +tsa +clc +adc #4 +tas +; push imm r 0x2f0 +pea L.16 +; call r 0x2f0 +jsr write +; add sp, #2 +pla +; push imm r 0xf0 +pea $1 +; call r 0x2f0 +jsr hexun +; add sp, #2 +pla +; push imm r 0x2f0 +pea L.17 +; call r 0x2f0 +jsr write +; add sp, #2 +pla +; push imm r 0xf0 +pea $2 +; call r 0x2f0 +jsr hexun +; add sp, #2 +pla +; push imm r 0x2f0 +pea L.18 +; call r 0x2f0 +jsr write +; add sp, #2 +pla +; push imm r 0xf0 +pea $2 +; call r 0x2f0 +jsr hexun +; add sp, #2 +pla +; push imm r 0x2f0 +pea L.19 +; call r 0x2f0 +jsr write +; add sp, #2 +pla +; push imm r 0xf0 +pea $2 +; call r 0x2f0 +jsr hexun +; add sp, #2 +pla +; push imm r 0x2f0 +pea L.20 +; call r 0x2f0 +jsr write +; add sp, #2 +pla +; push imm r 0xf0 +pea $4 +; call r 0x2f0 +jsr hexun +; add sp, #2 +pla +; push imm r 0x2f0 +pea L.21 +; call r 0x2f0 +jsr write +; add sp, #2 +pla +; ld [leer1 + 0], r0 +lda.l leer1 +tax +phx +; call r 0x2f0 +jsr write +; add sp, #2 +pla +; push imm r 0x2f0 +pea leer2 +; call r 0x2f0 +jsr write +; add sp, #2 +pla +; push imm r 0x2f0 +pea L.22 +; call r 0x2f0 +jsr write +; add sp, #2 +pla +; ld #0,r0 +; potential long problem: constant to register +ldx #$0 +; store r 0 fr 0x1f2 fc 0xfffffffe +; st16 r0, [sp,-2] +txa +sta -2 + __main_locals + 1, s +__local_20: ; at 29200 +; ld16 [sp,-2],r0 (loc -6) +lda -2 + __main_locals + 1, s +tax +; ld #2,r1 +; potential long problem: constant to register +ldy #$2 +; cmpge r0, r1 +phy +txa +ldx #1 +sec +sbc 1,s +bvc + +eor #$8000 ++ bmi +++ +++ dex ++++ ply +; gtst inv 1 t 0 v 0 r 29411 +; x to accu +txa +; gtst inv 1 t 0 v 243 r 29456 +; cmp op 0x95 inv 1 +; compare +cmp #0 +bne + +jmp __local_18 ++ +; gjmp_addr 0 at 29547 +jmp __local_19 +; gsym_addr t 29547 a 0 +__local_21: ; at 29609 +; ld16 [sp,-2],r0 (loc -6) +lda -2 + __main_locals + 1, s +tax +; mov r0, r1 +txy +; adc r240 (0xf0), r0 (0x0) (fr type 0x0 c 1) +inx +; store r 0 fr 0x1f2 fc 0xfffffffe +; st16 r0, [sp,-2] +txa +sta -2 + __main_locals + 1, s +; gjmp_addr 29200 at 29825 +jmp __local_20 +; gsym_addr t 29825 a 29200 +__local_19: ; at 29895 +; gsym_addr t 29547 a 29895 +; ld16 [sp,-2],r0 (loc -6) +lda -2 + __main_locals + 1, s +tax +; ld #1,r1 +; potential long problem: constant to register +ldy #$1 +; shl r1, r0 +txa +- cpy #0 +beq + +asl a +dey +bra - ++ tax +; adc r0 (0x0), r752 (0x2f0) (fr type 0x0 c -2) +; ld #tf, r1 +; long problem: symbol to register +ldy #tf +clc +tya +phx +adc 1,s +tay +pla +; push imm r 0xf0 +pea $4 +; push imm r 0xf0 +pea $2 +; store r 1 fr 0x1f2 fc 0xfffffff8 +; st16 r1, [sp,-8] +tya +sta -4 + __main_locals + 1, s +; call r 0x1f1 +; ld16 [sp,-8],r10 (loc -8) +lda -4 + __main_locals + 1, s +sta.l r10 +lda.l r10 +tax +jsr (0,x) +; add sp, #4 +tsa +clc +adc #4 +tas +; gjmp_addr 29609 at 30513 +jmp __local_21 +; gsym_addr t 30513 a 29609 +__local_18: ; at 30583 +; gsym_addr t 29456 a 30583 +; gsym_addr t 0 a 29609 +; adc r240 (0xf0), r1008 (0x3f0) (fr type 0x0 c 10) +; ld [d + 10], r0 +lda.l d + 10 +tax +clc +txa +adc #10 +tax +; gjmp_addr 0 at 30742 +jmp __local_22 +; gsym_addr t 30742 a 0 +__local_22: ; at 30804 +; gsym_addr t 30742 a 30804 +; add sp, #__main_locals +.ifgr __main_locals 0 +tsa +clc +adc #__main_locals +tas +.endif +rts +.ends + +.ramsection "ram.data" bank 0 slot 1 +ramsection.data dsb 0 +string dsb 2 +string2 dsb 2 +string3 dsb 6 +a dsb 100 +b dsb 100 +leer1 dsb 2 +leer2 dsb 2 +out dsb 2 +tf dsb 4 +.ends + +.section ".data" +startsection.data: +.dw L.0 +.dw L.1 +.db $31 +.db $32,$33,$34,$0,$0 +.db $1 +.db $0,$2,$0,$3,$0,$4,$0,$5,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0 +.db $6 +.db $0,$7,$0,$8,$0,$9,$0,$a,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0 +.dw L.2 +.db $0 +.db $0 +.db $fe +.db $ff +.dw testmul +.dw testdiv +endsection.data: +.ends + +.section ".rodata" +startsection.rodata: +L.0: .db $68 +.db $65,$6c,$6c,$6f,$2c,$20,$77,$6f,$72,$6c,$64,$21,$a,$0 +L.1: .db $67 +.db $6f,$6f,$64,$2d,$62,$79,$65,$a,$0,$0 +e: .db $63 +.db $0,$62,$0,$61,$0,$60,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0 +L.2: .db $0 +L.3: .db $30 +.db $78,$0 +L.4: .db $30 +.db $78,$0 +L.5: .db $20 +.db $3d,$3d,$20,$0 +L.6: .db $3e +.db $3e,$0 +L.7: .db $75 +.db $3e,$3e,$0 +L.8: .db $2d +.db $0 +L.9: .db $2b +.db $0 +L.10: .db $2a +.db $0 +L.11: .db $2f +.db $0 +L.12: .db $75 +.db $2f,$0 +L.13: .db $73 +.db $69,$67,$6e,$65,$64,$20,$6e,$75,$6d,$62,$65,$72,$73,$a,$0 +L.14: .db $75 +.db $6e,$73,$69,$67,$6e,$65,$64,$20,$6e,$75,$6d,$62,$65,$72,$73,$a,$0 +L.15: .db $61 +.db $72,$69,$74,$68,$20,$73,$68,$69,$66,$74,$20,$72,$69,$67,$68,$74,$a,$0 +L.16: .db $73 +.db $69,$7a,$65,$6f,$66,$28,$63,$68,$61,$72,$29,$20,$3d,$3d,$20,$0 +L.17: .db $73 +.db $69,$7a,$65,$6f,$66,$28,$73,$68,$6f,$72,$74,$29,$20,$3d,$3d,$20,$0 +L.18: .db $73 +.db $69,$7a,$65,$6f,$66,$28,$69,$6e,$74,$29,$20,$3d,$3d,$20,$0 +L.19: .db $73 +.db $69,$7a,$65,$6f,$66,$28,$6c,$6f,$6e,$67,$29,$20,$3d,$3d,$20,$0 +L.20: .db $73 +.db $69,$7a,$65,$6f,$66,$28,$6c,$6f,$6e,$67,$20,$6c,$6f,$6e,$67,$29,$20,$3d,$3d,$20,$0 +L.21: .db $66 +.db $69,$6e,$69,$73,$68,$65,$64,$a,$0 +L.22: .db $72 +.db $65,$61,$6c,$6c,$79,$20,$66,$69,$6e,$69,$73,$68,$65,$64,$a,$0 +endsection.rodata: +.ends + +.ramsection ".bss" bank 0 slot 1 +d dsb 100 +.ends +.section ".rotzdata" +startsection.rotzdata: +c: .db $41 +.db $0,$42,$0,$43,$0,$e,$0,$f,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0 +x: .db $66 +.db $72,$69,$74,$7a,$65,$0 +endsection.rotzdata: +.ends + diff --git a/test/hw/hw3_r9.asm b/test/hw/hw3_r9.asm new file mode 100644 index 0000000..17a6ed5 --- /dev/null +++ b/test/hw/hw3_r9.asm @@ -0,0 +1,163 @@ +.include "hdr.asm" +.accu 16 +.index 16 +.16bit +.section ".text" +main: +; sub sp,#__main_locals +tsa +sec +sbc #__main_locals +tas +; ld #8448,r0 +ldx #$2100 +; store r 0 fr 0xf2 fc 0x2 +; st16 r0, [sp,2] +stx 2 + 1, s +; ld #8482,r0 +ldx #$2122 +; store r 0 fr 0xf2 fc 0x0 +; st16 r0, [sp,0] +stx 0 + 1, s +; ld16 [sp,2],r0 +ldx 2 + 1, s +; ld #128,r1 +ldy #$80 +; store r 1 fr 0x5100 fc 0x2 +; st8 r1, [r0,0] +sep #$20 +sty 0,x +rep #$20 +; ld16 [sp,0],r0 +ldx 0 + 1, s +; ld #224,r1 +ldy #$e0 +; store r 1 fr 0x5100 fc 0x0 +; st8 r1, [r0,0] +sep #$20 +sty 0,x +rep #$20 +; ld16 [sp,0],r0 +ldx 0 + 1, s +; ld #0,r1 +ldy #$0 +; store r 1 fr 0x5100 fc 0x0 +; st8 r1, [r0,0] +sep #$20 +sty 0,x +rep #$20 +; ld16 [sp,2],r0 +ldx 2 + 1, s +; ld #15,r1 +ldy #$f +; store r 1 fr 0x5100 fc 0x2 +; st8 r1, [r0,0] +sep #$20 +sty 0,x +rep #$20 +__local_1: ; at 718 +; ld [string + 0], r0 +ldx string +; gtst inv 1 t 0 v 0 r 751 +; ld8 [r0,0],r1 +sep #$30 +ldy 0,x +rep #$30 +; y to accu +tya +; gtst inv 1 t 0 v 243 r 836 +; cmp op 0x95 inv 1 +; compare +cmp #0 +beq __local_0 +; ld [out + 0], r0 +ldx out +; ld [string + 0], r1 +ldy string +; store r 0 fr 0x1f2 fc 0xfffffffe +; st16 r0, [sp,2] +stx 2 + 1, s +; mov r1, r0 +tyx +; store r 0 fr 0x1f2 fc 0xfffffffc +; st16 r0, [sp,4] +stx 4 + 1, s +; ld #1,r0 +ldx #$1 +; add r0, r1 +clc +tya +phx +adc 1,s +tay +pla +; store r 1 fr 0x3f0 fc 0x0 +; ld #string, r2 +ldS #string +; st16 r1, [r2,0] +sty 0,S +; ld16 [sp,4],r0 +ldx 4 + 1, s +; ld8 [r0,0],r1 +sep #$30 +ldy 0,x +rep #$30 +; ld16 [sp,2],r0 +ldx 2 + 1, s +; store r 1 fr 0x100 fc 0xfffffffe +; st8 r1, [r0,0] +sep #$20 +sty 0,x +rep #$20 +; gjmp_addr 718 at 1448 +jmp __local_1 +; gsym_addr t 1448 a 718 +__local_0: ; at 1511 +; gsym_addr t 836 a 1511 +; gsym_addr t 0 a 718 +; ld [d + 10], r0 +ldx d + 10 +; gjmp_addr 0 at 1587 +jmp __local_2 +; gsym_addr t 1587 a 0 +__local_2: ; at 1646 +; gsym_addr t 1587 a 1646 +; add sp, #__main_locals +tsa +clc +adc #__main_locals +tas +rts +.define __main_locals 8 +.ends + +.ramsection "ram.data" bank 0 slot 1 +ramsection.data dsb 0 +string dsb 18 +out dsb 2 +a dsb 100 +b dsb 100 +.ends + +.section ".data" +startsection.data: +.dw ramsection.data + $2 +.db $68,$65,$6c,$6c,$6f,$2c,$20,$77,$6f,$72,$6c,$64,$21,$a,$0,$0 +.dw $fffe +.dw $1 +.db $2,$0,$3,$0,$4,$0,$5,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0 +.dw $6 +.db $7,$0,$8,$0,$9,$0,$a,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0 +endsection.data: +.ends + +.ramsection ".bss" bank 0 slot 1 +d dsb 100 +.ends +.section ".rotzdata" +startsection.rotzdata: +c: .dw $41 +.db $42,$0,$43,$0,$e,$0,$f,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0 +endsection.rotzdata: +.ends + diff --git a/test/hw/hw3a.c b/test/hw/hw3a.c new file mode 100644 index 0000000..e7bffb0 --- /dev/null +++ b/test/hw/hw3a.c @@ -0,0 +1,13 @@ +#include "hw3.h" + +extern void write(char* s); +extern void hexun(int); + +void printsizes(void) +{ + write("sizeof(char) == "); hexun(sizeof(char)); + write("sizeof(short) == "); hexun(sizeof(short)); + write("sizeof(int) == "); hexun(sizeof(int)); + write("sizeof(long) == "); hexun(sizeof(long)); + write("sizeof(long long) == "); hexun(sizeof(__longlong)); +} diff --git a/test/hw/hw3ref.asm b/test/hw/hw3ref.asm new file mode 100644 index 0000000..1db9dd2 --- /dev/null +++ b/test/hw/hw3ref.asm @@ -0,0 +1,164 @@ +.section ".text" +;.section (nil) +main: +; sub sp,#__main_locals +tsa +sec +sbc #__main_locals +tas +; ld #8448,r0 +lda #$2100 +sta r0 +; store r 0 fr 0xf2 fc 0x2 +; st r0, [sp,2] +lda r0 +sta 2 + 1, s +; ld #8482,r0 +lda #$2122 +sta r0 +; store r 0 fr 0xf2 fc 0x0 +; st r0, [sp,0] +lda r0 +sta 0 + 1, s +; ld32 [sp,2],r0 +lda 2 + 1, s +sta r0 +; ld #128,r1 +lda #$80 +sta r1 +; store r 1 fr 0x5100 fc 0x2 +; st r1, [r0,0] +ldx r0 +lda r1 +sta 0, x +; ld32 [sp,0],r0 +lda 0 + 1, s +sta r0 +; ld #224,r1 +lda #$e0 +sta r1 +; store r 1 fr 0x5100 fc 0x0 +; st r1, [r0,0] +ldx r0 +lda r1 +sta 0, x +; ld32 [sp,0],r0 +lda 0 + 1, s +sta r0 +; ld #0,r1 +lda #$0 +sta r1 +; store r 1 fr 0x5100 fc 0x0 +; st r1, [r0,0] +ldx r0 +lda r1 +sta 0, x +; ld32 [sp,2],r0 +lda 2 + 1, s +sta r0 +; ld #15,r1 +lda #$f +sta r1 +; store r 1 fr 0x5100 fc 0x2 +; st r1, [r0,0] +ldx r0 +lda r1 +sta 0, x +__local_1: ; at 782 +; ld [string + 0], r0 +lda (string) +sta r0 +; gtst inv 1 t 0 v 0 r 824 +; ld32 [r0,0],r1 +ldx r0 +lda 0, x +sta r1 +; reg 1 to compare reg +lda r1 +sta r10 +; gtst inv 1 t 0 v 243 r 929 +; cmp op 0x95 inv 1 +; compare +lda r10 +cmp #0 +beq __local_0 +; ld [string + 0], r0 +lda (string) +sta r0 +; mov r0, r1 +lda r0 +sta r1 +; ld #1,r2 +lda #$1 +sta r2 +; add r2, r0 +clc +lda r0 +adc r2 +sta r0 +; store r 0 fr 0x3f0 fc 0x0 +; ld #string, r9 +lda #string +sta r9 +; st r0, [r9,0] +ldx r9 +lda r0 +sta 0, x +; gjmp_addr 782 at 1253 +jmp __local_1 +; gsym_addr t 1253 a 782 +__local_0: ; at 1316 +; gsym_addr t 929 a 1316 +; gsym_addr t 0 a 782 +; ld [a + 10], r0 +ldx #a +lda 10, x +sta r0 +; gjmp_addr 0 at 1405 +jmp __local_2 +; gsym_addr t 1405 a 0 +__local_2: ; at 1464 +; gsym_addr t 1405 a 1464 +; add sp, #__main_locals +tsa +clc +adc #__main_locals +tas +rts +.define __main_locals 4 +.ends + +;.section 0x808aa68 +.ramsection "ram.data" bank 0 slot 1 +string dw +__1: dsb 16 +out dw +a dw +__2: dsb 98 +b dw +__3: dsb 98 +.ends + +.section ".data" +__data_start: +.dw __data_start + $2 +.db $68,$65,$6c,$6c,$6f,$2c,$20,$77,$6f,$72,$6c,$64,$21,$a,$0,$0 +.dw $ffff +.dw $1 +.db $2,$0,$3,$0,$4,$0,$5,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0 +.dw $6 +.db $7,$0,$8,$0,$9,$0,$a,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0 +.ends + + +;.section (nil) +.ramsection "ram.bss" bank 0 slot 1 +.ends + + +;.section (nil) +.section ".rotzdata" +c: .dw $41 +.db $42,$0,$43,$0,$e,$0,$f,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0 +.ends + diff --git a/test/hw/mk b/test/hw/mk new file mode 100755 index 0000000..7390759 --- /dev/null +++ b/test/hw/mk @@ -0,0 +1,13 @@ +#!/bin/bash -x +set -e +for i in hw3 hw3a ; do ../../816-tcc -I. -o $i.asm -c $i.c ; done +for i in hw3 hw3a ; do python ../../816-opt.py $i.asm >$i.opt.asm ; done +#for i in hw3 hw3a ; do cp $i.asm $i.opt.asm ; done +for i in hw3 hw3a ; do ../../../wla_dx/wla-65816 -io $i.opt.asm $i.obj ; done +../../../wla_dx/wla-65816 -io asmfptest.asm asmfptest.obj +../../../wla_dx/wlalink/wlalink -dvSn test.lnk test.smc +gcc -m32 hw3.c hw3a.c +./a.out >output.gcc || true +../../../bsnes/bsnes test.smc >output.snes || exit 1 +diff -u output.gcc output.snes +rm -f hw3.asm hw3a.asm test.sym test.smc hw3.obj hw3a.obj output.gcc a.out output.snes diff --git a/test/hw/output.gcc.linux32 b/test/hw/output.gcc.linux32 new file mode 100644 index 0000000..d143741 --- /dev/null +++ b/test/hw/output.gcc.linux32 @@ -0,0 +1,40394 @@ +0x2a +extreme 0x2a +0xffff +extreme 0xffff +0x8000 +extreme 0x8000 +0x11a +0xbef0 +0xbac0 +nok +ok +hello, world! +lo, world! +ello, world! +signed numbers +-0xa-0xa +0x5 +0xa +unsigned numbers +0xfff6 +0x5 +0xa +arith shift right +0xffff >> 0x2 == 0xffff +0xff00 >> 0x4 == 0xfff0 +0xf0 >> 0x2 == 0x3c +0x8000 >> 0x1 == 0xc000 +0x8001 >> 0x1 == 0xc000 +0x7fff >> 0x1 == 0x3fff +0xffff u>> 0x2 == 0x3fff +0xff00 u>> 0x4 == 0xff0 +0xf0 u>> 0x2 == 0x3c +0x8000 u>> 0x1 == 0x4000 +0x8001 u>> 0x1 == 0x4000 +0x7fff u>> 0x1 == 0x3fff +0xa - 0x5 == 0x5 +0xa - 0xa == 0x0 +0x5 - 0xa == -0x5 +0x0 - 0xa == -0xa +0xfff6 - 0x0 == -0xa +0xa - 0x0 == 0xa +0xfff6 - 0xfffb == -0x5 +0xfff6 - 0x5 == -0xf +0xa - 0xfff6 == 0x14 +0x5 + 0xa == 0xf +0xfffb + 0xa == 0x5 +0x0 + 0x5 == 0x5 +0x0 + 0xfffb == -0x5 +0xfffb + 0x0 == -0x5 +0x5 + 0x0 == 0x5 +0x5 + 0xfff6 == -0x5 +0x2 * 0x4 == 0x8 +0xfffe * 0x4 == -0x8 +0x0 * 0x2 == 0x0 +0x0 * 0xfffe == 0x0 +0x2 * 0xfffc == -0x8 +0x2 * 0x0 == 0x0 +0xfffe * 0x0 == 0x0 +0x100 * 0x100 == 0x0 +0x2a u/ 0x5 == 0x8 +0x5 u/ 0x2a == 0x0 +0xffd6 u/ 0x5 == 0x332a +0x2a u/ 0xfffb == 0x0 +0xfffb u/ 0x2a == 0x618 +0x28 u/ 0x8 == 0x5 +0x0 u/ 0x8 == 0x0 +0x2a / 0x5 == 0x8 +0x5 / 0x2a == 0x0 +0xffd6 / 0x5 == -0x8 +0x2a / 0xfffb == -0x8 +0xfffb / 0x2a == 0x0 +0x28 / 0x8 == 0x5 +0x0 / 0x8 == 0x0 +0xffd6 / 0xfffb == 0x8 +sizeof(char) == 0x1 +sizeof(short) == 0x2 +sizeof(int) == 0x2 +sizeof(long) == 0x4 +sizeof(long long) == 0x4 +finished +leer finished +0x0 * 0xffff == 0x0 +0x0 / 0xffff == 0x0 +0x0 % 0xffff == 0x0 +int 0x0 ^ 0xffff == -0x1 (0xffff) +__uint 0x0 ^ 0xffff == -0x1 (0xffff) +char 0x0 ^ 0xffff == -0x1 (0xffff) +__uchar 0x0 ^ 0xff == 0xff (0xff) +__longlong 0x0 ^ 0xffff == -0x1 (0xffff) +__ulonglong 0x0 ^ 0xffff == -0x1 (0xffff) +int 0x0 && 0xffff == 0x0 (0x0) +__uint 0x0 && 0xffff == 0x0 (0x0) +char 0x0 && 0xffff == 0x0 (0x0) +__uchar 0x0 && 0xff == 0x0 (0x0) +__longlong 0x0 && 0xffff == 0x0 (0x0) +__ulonglong 0x0 && 0xffff == 0x0 (0x0) +int 0x0 || 0xffff == 0x1 (0x1) +__uint 0x0 || 0xffff == 0x1 (0x1) +char 0x0 || 0xffff == 0x1 (0x1) +__uchar 0x0 || 0xff == 0x1 (0x1) +__longlong 0x0 || 0xffff == 0x1 (0x1) +__ulonglong 0x0 || 0xffff == 0x1 (0x1) +int 0x0 & 0xffff == 0x0 (0x0) +__uint 0x0 & 0xffff == 0x0 (0x0) +char 0x0 & 0xffff == 0x0 (0x0) +__uchar 0x0 & 0xff == 0x0 (0x0) +__longlong 0x0 & 0xffff == 0x0 (0x0) +__ulonglong 0x0 & 0xffff == 0x0 (0x0) +int 0x0 | 0xffff == -0x1 (0xffff) +__uint 0x0 | 0xffff == -0x1 (0xffff) +char 0x0 | 0xffff == -0x1 (0xffff) +__uchar 0x0 | 0xff == 0xff (0xff) +__longlong 0x0 | 0xffff == -0x1 (0xffff) +__ulonglong 0x0 | 0xffff == -0x1 (0xffff) +int 0x0 << 0x1 == 0x0 (0x0) +__uint 0x0 << 0x1 == 0x0 (0x0) +char 0x0 << 0x1 == 0x0 (0x0) +__uchar 0x0 << 0x1 == 0x0 (0x0) +__longlong 0x0 << 0x1 == 0x0 (0x0) +__ulonglong 0x0 << 0x1 == 0x0 (0x0) +int 0x0 >> 0x1 == 0x0 (0x0) +__uint 0x0 >> 0x1 == 0x0 (0x0) +char 0x0 >> 0x1 == 0x0 (0x0) +__uchar 0x0 >> 0x1 == 0x0 (0x0) +__longlong 0x0 >> 0x1 == 0x0 (0x0) +__ulonglong 0x0 >> 0x1 == 0x0 (0x0) +int 0x0 + 0xffff == -0x1 (0xffff) +__uint 0x0 + 0xffff == -0x1 (0xffff) +char 0x0 + 0xffff == -0x1 (0xffff) +__uchar 0x0 + 0xff == 0xff (0xff) +__longlong 0x0 + 0xffff == -0x1 (0xffff) +__ulonglong 0x0 + 0xffff == -0x1 (0xffff) +float 0x0 + 0xffff == -0x1 (0xffff) +int 0x0 - 0xffff == 0x1 (0x1) +__uint 0x0 - 0xffff == 0x1 (0x1) +char 0x0 - 0xffff == 0x1 (0x1) +__uchar 0x0 - 0xff == 0x1 (0x1) +__longlong 0x0 - 0xffff == 0x1 (0x1) +__ulonglong 0x0 - 0xffff == 0x1 (0x1) +float 0x0 - 0xffff == 0x1 (0x1) +int 0x0 * 0xffff == 0x0 (0x0) +__uint 0x0 * 0xffff == 0x0 (0x0) +char 0x0 * 0xffff == 0x0 (0x0) +__uchar 0x0 * 0xff == 0x0 (0x0) +__longlong 0x0 * 0xffff == 0x0 (0x0) +__ulonglong 0x0 * 0xffff == 0x0 (0x0) +float 0x0 * 0xffff == 0x0 (0x0) +int 0x0 < 0xffff == 0x0 (0x0) +__uint 0x0 < 0xffff == 0x1 (0x1) +char 0x0 < 0xffff == 0x0 (0x0) +__uchar 0x0 < 0xff == 0x1 (0x1) +__longlong 0x0 < 0xffff == 0x0 (0x0) +__ulonglong 0x0 < 0xffff == 0x1 (0x1) +float 0x0 < 0xffff == 0x0 (0x0) +int 0x0 > 0xffff == 0x1 (0x1) +__uint 0x0 > 0xffff == 0x0 (0x0) +char 0x0 > 0xffff == 0x1 (0x1) +__uchar 0x0 > 0xff == 0x0 (0x0) +__longlong 0x0 > 0xffff == 0x1 (0x1) +__ulonglong 0x0 > 0xffff == 0x0 (0x0) +float 0x0 > 0xffff == 0x1 (0x1) +int 0x0 <= 0xffff == 0x0 (0x0) +__uint 0x0 <= 0xffff == 0x1 (0x1) +char 0x0 <= 0xffff == 0x0 (0x0) +__uchar 0x0 <= 0xff == 0x1 (0x1) +__longlong 0x0 <= 0xffff == 0x0 (0x0) +__ulonglong 0x0 <= 0xffff == 0x1 (0x1) +float 0x0 <= 0xffff == 0x0 (0x0) +int 0x0 == 0xffff == 0x0 (0x0) +__uint 0x0 == 0xffff == 0x0 (0x0) +char 0x0 == 0xffff == 0x0 (0x0) +__uchar 0x0 == 0xff == 0x0 (0x0) +__longlong 0x0 == 0xffff == 0x0 (0x0) +__ulonglong 0x0 == 0xffff == 0x0 (0x0) +float 0x0 == 0xffff == 0x0 (0x0) +int 0x0 != 0xffff == 0x1 (0x1) +__uint 0x0 != 0xffff == 0x1 (0x1) +char 0x0 != 0xffff == 0x1 (0x1) +__uchar 0x0 != 0xff == 0x1 (0x1) +__longlong 0x0 != 0xffff == 0x1 (0x1) +__ulonglong 0x0 != 0xffff == 0x1 (0x1) +float 0x0 != 0xffff == 0x1 (0x1) +int 0x0 >= 0xffff == 0x1 (0x1) +__uint 0x0 >= 0xffff == 0x0 (0x0) +char 0x0 >= 0xffff == 0x1 (0x1) +__uchar 0x0 >= 0xff == 0x0 (0x0) +__longlong 0x0 >= 0xffff == 0x1 (0x1) +__ulonglong 0x0 >= 0xffff == 0x0 (0x0) +float 0x0 >= 0xffff == 0x1 (0x1) +int 0x0 / 0xffff == 0x0 (0x0) +__uint 0x0 / 0xffff == 0x0 (0x0) +char 0x0 / 0xffff == 0x0 (0x0) +__uchar 0x0 / 0xff == 0x0 (0x0) +__longlong 0x0 / 0xffff == 0x0 (0x0) +__ulonglong 0x0 / 0xffff == 0x0 (0x0) +float 0x0 / 0xffff == 0x0 (0x0) +int 0x0 % 0xffff == 0x0 (0x0) +__uint 0x0 % 0xffff == 0x0 (0x0) +char 0x0 % 0xffff == 0x0 (0x0) +__uchar 0x0 % 0xff == 0x0 (0x0) +__longlong 0x0 % 0xffff == 0x0 (0x0) +__ulonglong 0x0 % 0xffff == 0x0 (0x0) +0x0 * 0x1 == 0x0 +0x0 / 0x1 == 0x0 +0x0 % 0x1 == 0x0 +int 0x0 ^ 0x1 == 0x1 (0x1) +__uint 0x0 ^ 0x1 == 0x1 (0x1) +char 0x0 ^ 0x1 == 0x1 (0x1) +__uchar 0x0 ^ 0x1 == 0x1 (0x1) +__longlong 0x0 ^ 0x1 == 0x1 (0x1) +__ulonglong 0x0 ^ 0x1 == 0x1 (0x1) +int 0x0 && 0x1 == 0x0 (0x0) +__uint 0x0 && 0x1 == 0x0 (0x0) +char 0x0 && 0x1 == 0x0 (0x0) +__uchar 0x0 && 0x1 == 0x0 (0x0) +__longlong 0x0 && 0x1 == 0x0 (0x0) +__ulonglong 0x0 && 0x1 == 0x0 (0x0) +int 0x0 || 0x1 == 0x1 (0x1) +__uint 0x0 || 0x1 == 0x1 (0x1) +char 0x0 || 0x1 == 0x1 (0x1) +__uchar 0x0 || 0x1 == 0x1 (0x1) +__longlong 0x0 || 0x1 == 0x1 (0x1) +__ulonglong 0x0 || 0x1 == 0x1 (0x1) +int 0x0 & 0x1 == 0x0 (0x0) +__uint 0x0 & 0x1 == 0x0 (0x0) +char 0x0 & 0x1 == 0x0 (0x0) +__uchar 0x0 & 0x1 == 0x0 (0x0) +__longlong 0x0 & 0x1 == 0x0 (0x0) +__ulonglong 0x0 & 0x1 == 0x0 (0x0) +int 0x0 | 0x1 == 0x1 (0x1) +__uint 0x0 | 0x1 == 0x1 (0x1) +char 0x0 | 0x1 == 0x1 (0x1) +__uchar 0x0 | 0x1 == 0x1 (0x1) +__longlong 0x0 | 0x1 == 0x1 (0x1) +__ulonglong 0x0 | 0x1 == 0x1 (0x1) +int 0x0 << 0x2 == 0x0 (0x0) +__uint 0x0 << 0x2 == 0x0 (0x0) +char 0x0 << 0x2 == 0x0 (0x0) +__uchar 0x0 << 0x2 == 0x0 (0x0) +__longlong 0x0 << 0x2 == 0x0 (0x0) +__ulonglong 0x0 << 0x2 == 0x0 (0x0) +int 0x0 >> 0x2 == 0x0 (0x0) +__uint 0x0 >> 0x2 == 0x0 (0x0) +char 0x0 >> 0x2 == 0x0 (0x0) +__uchar 0x0 >> 0x2 == 0x0 (0x0) +__longlong 0x0 >> 0x2 == 0x0 (0x0) +__ulonglong 0x0 >> 0x2 == 0x0 (0x0) +int 0x0 + 0x1 == 0x1 (0x1) +__uint 0x0 + 0x1 == 0x1 (0x1) +char 0x0 + 0x1 == 0x1 (0x1) +__uchar 0x0 + 0x1 == 0x1 (0x1) +__longlong 0x0 + 0x1 == 0x1 (0x1) +__ulonglong 0x0 + 0x1 == 0x1 (0x1) +float 0x0 + 0x1 == 0x1 (0x1) +int 0x0 - 0x1 == -0x1 (0xffff) +__uint 0x0 - 0x1 == -0x1 (0xffff) +char 0x0 - 0x1 == -0x1 (0xffff) +__uchar 0x0 - 0x1 == 0xff (0xff) +__longlong 0x0 - 0x1 == -0x1 (0xffff) +__ulonglong 0x0 - 0x1 == -0x1 (0xffff) +float 0x0 - 0x1 == -0x1 (0xffff) +int 0x0 * 0x1 == 0x0 (0x0) +__uint 0x0 * 0x1 == 0x0 (0x0) +char 0x0 * 0x1 == 0x0 (0x0) +__uchar 0x0 * 0x1 == 0x0 (0x0) +__longlong 0x0 * 0x1 == 0x0 (0x0) +__ulonglong 0x0 * 0x1 == 0x0 (0x0) +float 0x0 * 0x1 == 0x0 (0x0) +int 0x0 < 0x1 == 0x1 (0x1) +__uint 0x0 < 0x1 == 0x1 (0x1) +char 0x0 < 0x1 == 0x1 (0x1) +__uchar 0x0 < 0x1 == 0x1 (0x1) +__longlong 0x0 < 0x1 == 0x1 (0x1) +__ulonglong 0x0 < 0x1 == 0x1 (0x1) +float 0x0 < 0x1 == 0x1 (0x1) +int 0x0 > 0x1 == 0x0 (0x0) +__uint 0x0 > 0x1 == 0x0 (0x0) +char 0x0 > 0x1 == 0x0 (0x0) +__uchar 0x0 > 0x1 == 0x0 (0x0) +__longlong 0x0 > 0x1 == 0x0 (0x0) +__ulonglong 0x0 > 0x1 == 0x0 (0x0) +float 0x0 > 0x1 == 0x0 (0x0) +int 0x0 <= 0x1 == 0x1 (0x1) +__uint 0x0 <= 0x1 == 0x1 (0x1) +char 0x0 <= 0x1 == 0x1 (0x1) +__uchar 0x0 <= 0x1 == 0x1 (0x1) +__longlong 0x0 <= 0x1 == 0x1 (0x1) +__ulonglong 0x0 <= 0x1 == 0x1 (0x1) +float 0x0 <= 0x1 == 0x1 (0x1) +int 0x0 == 0x1 == 0x0 (0x0) +__uint 0x0 == 0x1 == 0x0 (0x0) +char 0x0 == 0x1 == 0x0 (0x0) +__uchar 0x0 == 0x1 == 0x0 (0x0) +__longlong 0x0 == 0x1 == 0x0 (0x0) +__ulonglong 0x0 == 0x1 == 0x0 (0x0) +float 0x0 == 0x1 == 0x0 (0x0) +int 0x0 != 0x1 == 0x1 (0x1) +__uint 0x0 != 0x1 == 0x1 (0x1) +char 0x0 != 0x1 == 0x1 (0x1) +__uchar 0x0 != 0x1 == 0x1 (0x1) +__longlong 0x0 != 0x1 == 0x1 (0x1) +__ulonglong 0x0 != 0x1 == 0x1 (0x1) +float 0x0 != 0x1 == 0x1 (0x1) +int 0x0 >= 0x1 == 0x0 (0x0) +__uint 0x0 >= 0x1 == 0x0 (0x0) +char 0x0 >= 0x1 == 0x0 (0x0) +__uchar 0x0 >= 0x1 == 0x0 (0x0) +__longlong 0x0 >= 0x1 == 0x0 (0x0) +__ulonglong 0x0 >= 0x1 == 0x0 (0x0) +float 0x0 >= 0x1 == 0x0 (0x0) +int 0x0 / 0x1 == 0x0 (0x0) +__uint 0x0 / 0x1 == 0x0 (0x0) +char 0x0 / 0x1 == 0x0 (0x0) +__uchar 0x0 / 0x1 == 0x0 (0x0) +__longlong 0x0 / 0x1 == 0x0 (0x0) +__ulonglong 0x0 / 0x1 == 0x0 (0x0) +float 0x0 / 0x1 == 0x0 (0x0) +int 0x0 % 0x1 == 0x0 (0x0) +__uint 0x0 % 0x1 == 0x0 (0x0) +char 0x0 % 0x1 == 0x0 (0x0) +__uchar 0x0 % 0x1 == 0x0 (0x0) +__longlong 0x0 % 0x1 == 0x0 (0x0) +__ulonglong 0x0 % 0x1 == 0x0 (0x0) +0x0 * 0x2 == 0x0 +0x0 / 0x2 == 0x0 +0x0 % 0x2 == 0x0 +int 0x0 ^ 0x2 == 0x2 (0x2) +__uint 0x0 ^ 0x2 == 0x2 (0x2) +char 0x0 ^ 0x2 == 0x2 (0x2) +__uchar 0x0 ^ 0x2 == 0x2 (0x2) +__longlong 0x0 ^ 0x2 == 0x2 (0x2) +__ulonglong 0x0 ^ 0x2 == 0x2 (0x2) +int 0x0 && 0x2 == 0x0 (0x0) +__uint 0x0 && 0x2 == 0x0 (0x0) +char 0x0 && 0x2 == 0x0 (0x0) +__uchar 0x0 && 0x2 == 0x0 (0x0) +__longlong 0x0 && 0x2 == 0x0 (0x0) +__ulonglong 0x0 && 0x2 == 0x0 (0x0) +int 0x0 || 0x2 == 0x1 (0x1) +__uint 0x0 || 0x2 == 0x1 (0x1) +char 0x0 || 0x2 == 0x1 (0x1) +__uchar 0x0 || 0x2 == 0x1 (0x1) +__longlong 0x0 || 0x2 == 0x1 (0x1) +__ulonglong 0x0 || 0x2 == 0x1 (0x1) +int 0x0 & 0x2 == 0x0 (0x0) +__uint 0x0 & 0x2 == 0x0 (0x0) +char 0x0 & 0x2 == 0x0 (0x0) +__uchar 0x0 & 0x2 == 0x0 (0x0) +__longlong 0x0 & 0x2 == 0x0 (0x0) +__ulonglong 0x0 & 0x2 == 0x0 (0x0) +int 0x0 | 0x2 == 0x2 (0x2) +__uint 0x0 | 0x2 == 0x2 (0x2) +char 0x0 | 0x2 == 0x2 (0x2) +__uchar 0x0 | 0x2 == 0x2 (0x2) +__longlong 0x0 | 0x2 == 0x2 (0x2) +__ulonglong 0x0 | 0x2 == 0x2 (0x2) +int 0x0 << 0x3 == 0x0 (0x0) +__uint 0x0 << 0x3 == 0x0 (0x0) +char 0x0 << 0x3 == 0x0 (0x0) +__uchar 0x0 << 0x3 == 0x0 (0x0) +__longlong 0x0 << 0x3 == 0x0 (0x0) +__ulonglong 0x0 << 0x3 == 0x0 (0x0) +int 0x0 >> 0x3 == 0x0 (0x0) +__uint 0x0 >> 0x3 == 0x0 (0x0) +char 0x0 >> 0x3 == 0x0 (0x0) +__uchar 0x0 >> 0x3 == 0x0 (0x0) +__longlong 0x0 >> 0x3 == 0x0 (0x0) +__ulonglong 0x0 >> 0x3 == 0x0 (0x0) +int 0x0 + 0x2 == 0x2 (0x2) +__uint 0x0 + 0x2 == 0x2 (0x2) +char 0x0 + 0x2 == 0x2 (0x2) +__uchar 0x0 + 0x2 == 0x2 (0x2) +__longlong 0x0 + 0x2 == 0x2 (0x2) +__ulonglong 0x0 + 0x2 == 0x2 (0x2) +float 0x0 + 0x2 == 0x2 (0x2) +int 0x0 - 0x2 == -0x2 (0xfffe) +__uint 0x0 - 0x2 == -0x2 (0xfffe) +char 0x0 - 0x2 == -0x2 (0xfffe) +__uchar 0x0 - 0x2 == 0xfe (0xfe) +__longlong 0x0 - 0x2 == -0x2 (0xfffe) +__ulonglong 0x0 - 0x2 == -0x2 (0xfffe) +float 0x0 - 0x2 == -0x2 (0xfffe) +int 0x0 * 0x2 == 0x0 (0x0) +__uint 0x0 * 0x2 == 0x0 (0x0) +char 0x0 * 0x2 == 0x0 (0x0) +__uchar 0x0 * 0x2 == 0x0 (0x0) +__longlong 0x0 * 0x2 == 0x0 (0x0) +__ulonglong 0x0 * 0x2 == 0x0 (0x0) +float 0x0 * 0x2 == 0x0 (0x0) +int 0x0 < 0x2 == 0x1 (0x1) +__uint 0x0 < 0x2 == 0x1 (0x1) +char 0x0 < 0x2 == 0x1 (0x1) +__uchar 0x0 < 0x2 == 0x1 (0x1) +__longlong 0x0 < 0x2 == 0x1 (0x1) +__ulonglong 0x0 < 0x2 == 0x1 (0x1) +float 0x0 < 0x2 == 0x1 (0x1) +int 0x0 > 0x2 == 0x0 (0x0) +__uint 0x0 > 0x2 == 0x0 (0x0) +char 0x0 > 0x2 == 0x0 (0x0) +__uchar 0x0 > 0x2 == 0x0 (0x0) +__longlong 0x0 > 0x2 == 0x0 (0x0) +__ulonglong 0x0 > 0x2 == 0x0 (0x0) +float 0x0 > 0x2 == 0x0 (0x0) +int 0x0 <= 0x2 == 0x1 (0x1) +__uint 0x0 <= 0x2 == 0x1 (0x1) +char 0x0 <= 0x2 == 0x1 (0x1) +__uchar 0x0 <= 0x2 == 0x1 (0x1) +__longlong 0x0 <= 0x2 == 0x1 (0x1) +__ulonglong 0x0 <= 0x2 == 0x1 (0x1) +float 0x0 <= 0x2 == 0x1 (0x1) +int 0x0 == 0x2 == 0x0 (0x0) +__uint 0x0 == 0x2 == 0x0 (0x0) +char 0x0 == 0x2 == 0x0 (0x0) +__uchar 0x0 == 0x2 == 0x0 (0x0) +__longlong 0x0 == 0x2 == 0x0 (0x0) +__ulonglong 0x0 == 0x2 == 0x0 (0x0) +float 0x0 == 0x2 == 0x0 (0x0) +int 0x0 != 0x2 == 0x1 (0x1) +__uint 0x0 != 0x2 == 0x1 (0x1) +char 0x0 != 0x2 == 0x1 (0x1) +__uchar 0x0 != 0x2 == 0x1 (0x1) +__longlong 0x0 != 0x2 == 0x1 (0x1) +__ulonglong 0x0 != 0x2 == 0x1 (0x1) +float 0x0 != 0x2 == 0x1 (0x1) +int 0x0 >= 0x2 == 0x0 (0x0) +__uint 0x0 >= 0x2 == 0x0 (0x0) +char 0x0 >= 0x2 == 0x0 (0x0) +__uchar 0x0 >= 0x2 == 0x0 (0x0) +__longlong 0x0 >= 0x2 == 0x0 (0x0) +__ulonglong 0x0 >= 0x2 == 0x0 (0x0) +float 0x0 >= 0x2 == 0x0 (0x0) +int 0x0 / 0x2 == 0x0 (0x0) +__uint 0x0 / 0x2 == 0x0 (0x0) +char 0x0 / 0x2 == 0x0 (0x0) +__uchar 0x0 / 0x2 == 0x0 (0x0) +__longlong 0x0 / 0x2 == 0x0 (0x0) +__ulonglong 0x0 / 0x2 == 0x0 (0x0) +float 0x0 / 0x2 == 0x0 (0x0) +int 0x0 % 0x2 == 0x0 (0x0) +__uint 0x0 % 0x2 == 0x0 (0x0) +char 0x0 % 0x2 == 0x0 (0x0) +__uchar 0x0 % 0x2 == 0x0 (0x0) +__longlong 0x0 % 0x2 == 0x0 (0x0) +__ulonglong 0x0 % 0x2 == 0x0 (0x0) +0x0 * 0xfffe == 0x0 +0x0 / 0xfffe == 0x0 +0x0 % 0xfffe == 0x0 +int 0x0 ^ 0xfffe == -0x2 (0xfffe) +__uint 0x0 ^ 0xfffe == -0x2 (0xfffe) +char 0x0 ^ 0xfffe == -0x2 (0xfffe) +__uchar 0x0 ^ 0xfe == 0xfe (0xfe) +__longlong 0x0 ^ 0xfffe == -0x2 (0xfffe) +__ulonglong 0x0 ^ 0xfffe == -0x2 (0xfffe) +int 0x0 && 0xfffe == 0x0 (0x0) +__uint 0x0 && 0xfffe == 0x0 (0x0) +char 0x0 && 0xfffe == 0x0 (0x0) +__uchar 0x0 && 0xfe == 0x0 (0x0) +__longlong 0x0 && 0xfffe == 0x0 (0x0) +__ulonglong 0x0 && 0xfffe == 0x0 (0x0) +int 0x0 || 0xfffe == 0x1 (0x1) +__uint 0x0 || 0xfffe == 0x1 (0x1) +char 0x0 || 0xfffe == 0x1 (0x1) +__uchar 0x0 || 0xfe == 0x1 (0x1) +__longlong 0x0 || 0xfffe == 0x1 (0x1) +__ulonglong 0x0 || 0xfffe == 0x1 (0x1) +int 0x0 & 0xfffe == 0x0 (0x0) +__uint 0x0 & 0xfffe == 0x0 (0x0) +char 0x0 & 0xfffe == 0x0 (0x0) +__uchar 0x0 & 0xfe == 0x0 (0x0) +__longlong 0x0 & 0xfffe == 0x0 (0x0) +__ulonglong 0x0 & 0xfffe == 0x0 (0x0) +int 0x0 | 0xfffe == -0x2 (0xfffe) +__uint 0x0 | 0xfffe == -0x2 (0xfffe) +char 0x0 | 0xfffe == -0x2 (0xfffe) +__uchar 0x0 | 0xfe == 0xfe (0xfe) +__longlong 0x0 | 0xfffe == -0x2 (0xfffe) +__ulonglong 0x0 | 0xfffe == -0x2 (0xfffe) +int 0x0 << 0x4 == 0x0 (0x0) +__uint 0x0 << 0x4 == 0x0 (0x0) +char 0x0 << 0x4 == 0x0 (0x0) +__uchar 0x0 << 0x4 == 0x0 (0x0) +__longlong 0x0 << 0x4 == 0x0 (0x0) +__ulonglong 0x0 << 0x4 == 0x0 (0x0) +int 0x0 >> 0x4 == 0x0 (0x0) +__uint 0x0 >> 0x4 == 0x0 (0x0) +char 0x0 >> 0x4 == 0x0 (0x0) +__uchar 0x0 >> 0x4 == 0x0 (0x0) +__longlong 0x0 >> 0x4 == 0x0 (0x0) +__ulonglong 0x0 >> 0x4 == 0x0 (0x0) +int 0x0 + 0xfffe == -0x2 (0xfffe) +__uint 0x0 + 0xfffe == -0x2 (0xfffe) +char 0x0 + 0xfffe == -0x2 (0xfffe) +__uchar 0x0 + 0xfe == 0xfe (0xfe) +__longlong 0x0 + 0xfffe == -0x2 (0xfffe) +__ulonglong 0x0 + 0xfffe == -0x2 (0xfffe) +float 0x0 + 0xfffe == -0x2 (0xfffe) +int 0x0 - 0xfffe == 0x2 (0x2) +__uint 0x0 - 0xfffe == 0x2 (0x2) +char 0x0 - 0xfffe == 0x2 (0x2) +__uchar 0x0 - 0xfe == 0x2 (0x2) +__longlong 0x0 - 0xfffe == 0x2 (0x2) +__ulonglong 0x0 - 0xfffe == 0x2 (0x2) +float 0x0 - 0xfffe == 0x2 (0x2) +int 0x0 * 0xfffe == 0x0 (0x0) +__uint 0x0 * 0xfffe == 0x0 (0x0) +char 0x0 * 0xfffe == 0x0 (0x0) +__uchar 0x0 * 0xfe == 0x0 (0x0) +__longlong 0x0 * 0xfffe == 0x0 (0x0) +__ulonglong 0x0 * 0xfffe == 0x0 (0x0) +float 0x0 * 0xfffe == 0x0 (0x0) +int 0x0 < 0xfffe == 0x0 (0x0) +__uint 0x0 < 0xfffe == 0x1 (0x1) +char 0x0 < 0xfffe == 0x0 (0x0) +__uchar 0x0 < 0xfe == 0x1 (0x1) +__longlong 0x0 < 0xfffe == 0x0 (0x0) +__ulonglong 0x0 < 0xfffe == 0x1 (0x1) +float 0x0 < 0xfffe == 0x0 (0x0) +int 0x0 > 0xfffe == 0x1 (0x1) +__uint 0x0 > 0xfffe == 0x0 (0x0) +char 0x0 > 0xfffe == 0x1 (0x1) +__uchar 0x0 > 0xfe == 0x0 (0x0) +__longlong 0x0 > 0xfffe == 0x1 (0x1) +__ulonglong 0x0 > 0xfffe == 0x0 (0x0) +float 0x0 > 0xfffe == 0x1 (0x1) +int 0x0 <= 0xfffe == 0x0 (0x0) +__uint 0x0 <= 0xfffe == 0x1 (0x1) +char 0x0 <= 0xfffe == 0x0 (0x0) +__uchar 0x0 <= 0xfe == 0x1 (0x1) +__longlong 0x0 <= 0xfffe == 0x0 (0x0) +__ulonglong 0x0 <= 0xfffe == 0x1 (0x1) +float 0x0 <= 0xfffe == 0x0 (0x0) +int 0x0 == 0xfffe == 0x0 (0x0) +__uint 0x0 == 0xfffe == 0x0 (0x0) +char 0x0 == 0xfffe == 0x0 (0x0) +__uchar 0x0 == 0xfe == 0x0 (0x0) +__longlong 0x0 == 0xfffe == 0x0 (0x0) +__ulonglong 0x0 == 0xfffe == 0x0 (0x0) +float 0x0 == 0xfffe == 0x0 (0x0) +int 0x0 != 0xfffe == 0x1 (0x1) +__uint 0x0 != 0xfffe == 0x1 (0x1) +char 0x0 != 0xfffe == 0x1 (0x1) +__uchar 0x0 != 0xfe == 0x1 (0x1) +__longlong 0x0 != 0xfffe == 0x1 (0x1) +__ulonglong 0x0 != 0xfffe == 0x1 (0x1) +float 0x0 != 0xfffe == 0x1 (0x1) +int 0x0 >= 0xfffe == 0x1 (0x1) +__uint 0x0 >= 0xfffe == 0x0 (0x0) +char 0x0 >= 0xfffe == 0x1 (0x1) +__uchar 0x0 >= 0xfe == 0x0 (0x0) +__longlong 0x0 >= 0xfffe == 0x1 (0x1) +__ulonglong 0x0 >= 0xfffe == 0x0 (0x0) +float 0x0 >= 0xfffe == 0x1 (0x1) +int 0x0 / 0xfffe == 0x0 (0x0) +__uint 0x0 / 0xfffe == 0x0 (0x0) +char 0x0 / 0xfffe == 0x0 (0x0) +__uchar 0x0 / 0xfe == 0x0 (0x0) +__longlong 0x0 / 0xfffe == 0x0 (0x0) +__ulonglong 0x0 / 0xfffe == 0x0 (0x0) +float 0x0 / 0xfffe == 0x0 (0x0) +int 0x0 % 0xfffe == 0x0 (0x0) +__uint 0x0 % 0xfffe == 0x0 (0x0) +char 0x0 % 0xfffe == 0x0 (0x0) +__uchar 0x0 % 0xfe == 0x0 (0x0) +__longlong 0x0 % 0xfffe == 0x0 (0x0) +__ulonglong 0x0 % 0xfffe == 0x0 (0x0) +0x0 * 0x4 == 0x0 +0x0 / 0x4 == 0x0 +0x0 % 0x4 == 0x0 +int 0x0 ^ 0x4 == 0x4 (0x4) +__uint 0x0 ^ 0x4 == 0x4 (0x4) +char 0x0 ^ 0x4 == 0x4 (0x4) +__uchar 0x0 ^ 0x4 == 0x4 (0x4) +__longlong 0x0 ^ 0x4 == 0x4 (0x4) +__ulonglong 0x0 ^ 0x4 == 0x4 (0x4) +int 0x0 && 0x4 == 0x0 (0x0) +__uint 0x0 && 0x4 == 0x0 (0x0) +char 0x0 && 0x4 == 0x0 (0x0) +__uchar 0x0 && 0x4 == 0x0 (0x0) +__longlong 0x0 && 0x4 == 0x0 (0x0) +__ulonglong 0x0 && 0x4 == 0x0 (0x0) +int 0x0 || 0x4 == 0x1 (0x1) +__uint 0x0 || 0x4 == 0x1 (0x1) +char 0x0 || 0x4 == 0x1 (0x1) +__uchar 0x0 || 0x4 == 0x1 (0x1) +__longlong 0x0 || 0x4 == 0x1 (0x1) +__ulonglong 0x0 || 0x4 == 0x1 (0x1) +int 0x0 & 0x4 == 0x0 (0x0) +__uint 0x0 & 0x4 == 0x0 (0x0) +char 0x0 & 0x4 == 0x0 (0x0) +__uchar 0x0 & 0x4 == 0x0 (0x0) +__longlong 0x0 & 0x4 == 0x0 (0x0) +__ulonglong 0x0 & 0x4 == 0x0 (0x0) +int 0x0 | 0x4 == 0x4 (0x4) +__uint 0x0 | 0x4 == 0x4 (0x4) +char 0x0 | 0x4 == 0x4 (0x4) +__uchar 0x0 | 0x4 == 0x4 (0x4) +__longlong 0x0 | 0x4 == 0x4 (0x4) +__ulonglong 0x0 | 0x4 == 0x4 (0x4) +int 0x0 << 0x5 == 0x0 (0x0) +__uint 0x0 << 0x5 == 0x0 (0x0) +char 0x0 << 0x5 == 0x0 (0x0) +__uchar 0x0 << 0x5 == 0x0 (0x0) +__longlong 0x0 << 0x5 == 0x0 (0x0) +__ulonglong 0x0 << 0x5 == 0x0 (0x0) +int 0x0 >> 0x5 == 0x0 (0x0) +__uint 0x0 >> 0x5 == 0x0 (0x0) +char 0x0 >> 0x5 == 0x0 (0x0) +__uchar 0x0 >> 0x5 == 0x0 (0x0) +__longlong 0x0 >> 0x5 == 0x0 (0x0) +__ulonglong 0x0 >> 0x5 == 0x0 (0x0) +int 0x0 + 0x4 == 0x4 (0x4) +__uint 0x0 + 0x4 == 0x4 (0x4) +char 0x0 + 0x4 == 0x4 (0x4) +__uchar 0x0 + 0x4 == 0x4 (0x4) +__longlong 0x0 + 0x4 == 0x4 (0x4) +__ulonglong 0x0 + 0x4 == 0x4 (0x4) +float 0x0 + 0x4 == 0x4 (0x4) +int 0x0 - 0x4 == -0x4 (0xfffc) +__uint 0x0 - 0x4 == -0x4 (0xfffc) +char 0x0 - 0x4 == -0x4 (0xfffc) +__uchar 0x0 - 0x4 == 0xfc (0xfc) +__longlong 0x0 - 0x4 == -0x4 (0xfffc) +__ulonglong 0x0 - 0x4 == -0x4 (0xfffc) +float 0x0 - 0x4 == -0x4 (0xfffc) +int 0x0 * 0x4 == 0x0 (0x0) +__uint 0x0 * 0x4 == 0x0 (0x0) +char 0x0 * 0x4 == 0x0 (0x0) +__uchar 0x0 * 0x4 == 0x0 (0x0) +__longlong 0x0 * 0x4 == 0x0 (0x0) +__ulonglong 0x0 * 0x4 == 0x0 (0x0) +float 0x0 * 0x4 == 0x0 (0x0) +int 0x0 < 0x4 == 0x1 (0x1) +__uint 0x0 < 0x4 == 0x1 (0x1) +char 0x0 < 0x4 == 0x1 (0x1) +__uchar 0x0 < 0x4 == 0x1 (0x1) +__longlong 0x0 < 0x4 == 0x1 (0x1) +__ulonglong 0x0 < 0x4 == 0x1 (0x1) +float 0x0 < 0x4 == 0x1 (0x1) +int 0x0 > 0x4 == 0x0 (0x0) +__uint 0x0 > 0x4 == 0x0 (0x0) +char 0x0 > 0x4 == 0x0 (0x0) +__uchar 0x0 > 0x4 == 0x0 (0x0) +__longlong 0x0 > 0x4 == 0x0 (0x0) +__ulonglong 0x0 > 0x4 == 0x0 (0x0) +float 0x0 > 0x4 == 0x0 (0x0) +int 0x0 <= 0x4 == 0x1 (0x1) +__uint 0x0 <= 0x4 == 0x1 (0x1) +char 0x0 <= 0x4 == 0x1 (0x1) +__uchar 0x0 <= 0x4 == 0x1 (0x1) +__longlong 0x0 <= 0x4 == 0x1 (0x1) +__ulonglong 0x0 <= 0x4 == 0x1 (0x1) +float 0x0 <= 0x4 == 0x1 (0x1) +int 0x0 == 0x4 == 0x0 (0x0) +__uint 0x0 == 0x4 == 0x0 (0x0) +char 0x0 == 0x4 == 0x0 (0x0) +__uchar 0x0 == 0x4 == 0x0 (0x0) +__longlong 0x0 == 0x4 == 0x0 (0x0) +__ulonglong 0x0 == 0x4 == 0x0 (0x0) +float 0x0 == 0x4 == 0x0 (0x0) +int 0x0 != 0x4 == 0x1 (0x1) +__uint 0x0 != 0x4 == 0x1 (0x1) +char 0x0 != 0x4 == 0x1 (0x1) +__uchar 0x0 != 0x4 == 0x1 (0x1) +__longlong 0x0 != 0x4 == 0x1 (0x1) +__ulonglong 0x0 != 0x4 == 0x1 (0x1) +float 0x0 != 0x4 == 0x1 (0x1) +int 0x0 >= 0x4 == 0x0 (0x0) +__uint 0x0 >= 0x4 == 0x0 (0x0) +char 0x0 >= 0x4 == 0x0 (0x0) +__uchar 0x0 >= 0x4 == 0x0 (0x0) +__longlong 0x0 >= 0x4 == 0x0 (0x0) +__ulonglong 0x0 >= 0x4 == 0x0 (0x0) +float 0x0 >= 0x4 == 0x0 (0x0) +int 0x0 / 0x4 == 0x0 (0x0) +__uint 0x0 / 0x4 == 0x0 (0x0) +char 0x0 / 0x4 == 0x0 (0x0) +__uchar 0x0 / 0x4 == 0x0 (0x0) +__longlong 0x0 / 0x4 == 0x0 (0x0) +__ulonglong 0x0 / 0x4 == 0x0 (0x0) +float 0x0 / 0x4 == 0x0 (0x0) +int 0x0 % 0x4 == 0x0 (0x0) +__uint 0x0 % 0x4 == 0x0 (0x0) +char 0x0 % 0x4 == 0x0 (0x0) +__uchar 0x0 % 0x4 == 0x0 (0x0) +__longlong 0x0 % 0x4 == 0x0 (0x0) +__ulonglong 0x0 % 0x4 == 0x0 (0x0) +0x0 * 0xfffc == 0x0 +0x0 / 0xfffc == 0x0 +0x0 % 0xfffc == 0x0 +int 0x0 ^ 0xfffc == -0x4 (0xfffc) +__uint 0x0 ^ 0xfffc == -0x4 (0xfffc) +char 0x0 ^ 0xfffc == -0x4 (0xfffc) +__uchar 0x0 ^ 0xfc == 0xfc (0xfc) +__longlong 0x0 ^ 0xfffc == -0x4 (0xfffc) +__ulonglong 0x0 ^ 0xfffc == -0x4 (0xfffc) +int 0x0 && 0xfffc == 0x0 (0x0) +__uint 0x0 && 0xfffc == 0x0 (0x0) +char 0x0 && 0xfffc == 0x0 (0x0) +__uchar 0x0 && 0xfc == 0x0 (0x0) +__longlong 0x0 && 0xfffc == 0x0 (0x0) +__ulonglong 0x0 && 0xfffc == 0x0 (0x0) +int 0x0 || 0xfffc == 0x1 (0x1) +__uint 0x0 || 0xfffc == 0x1 (0x1) +char 0x0 || 0xfffc == 0x1 (0x1) +__uchar 0x0 || 0xfc == 0x1 (0x1) +__longlong 0x0 || 0xfffc == 0x1 (0x1) +__ulonglong 0x0 || 0xfffc == 0x1 (0x1) +int 0x0 & 0xfffc == 0x0 (0x0) +__uint 0x0 & 0xfffc == 0x0 (0x0) +char 0x0 & 0xfffc == 0x0 (0x0) +__uchar 0x0 & 0xfc == 0x0 (0x0) +__longlong 0x0 & 0xfffc == 0x0 (0x0) +__ulonglong 0x0 & 0xfffc == 0x0 (0x0) +int 0x0 | 0xfffc == -0x4 (0xfffc) +__uint 0x0 | 0xfffc == -0x4 (0xfffc) +char 0x0 | 0xfffc == -0x4 (0xfffc) +__uchar 0x0 | 0xfc == 0xfc (0xfc) +__longlong 0x0 | 0xfffc == -0x4 (0xfffc) +__ulonglong 0x0 | 0xfffc == -0x4 (0xfffc) +int 0x0 << 0x6 == 0x0 (0x0) +__uint 0x0 << 0x6 == 0x0 (0x0) +char 0x0 << 0x6 == 0x0 (0x0) +__uchar 0x0 << 0x6 == 0x0 (0x0) +__longlong 0x0 << 0x6 == 0x0 (0x0) +__ulonglong 0x0 << 0x6 == 0x0 (0x0) +int 0x0 >> 0x6 == 0x0 (0x0) +__uint 0x0 >> 0x6 == 0x0 (0x0) +char 0x0 >> 0x6 == 0x0 (0x0) +__uchar 0x0 >> 0x6 == 0x0 (0x0) +__longlong 0x0 >> 0x6 == 0x0 (0x0) +__ulonglong 0x0 >> 0x6 == 0x0 (0x0) +int 0x0 + 0xfffc == -0x4 (0xfffc) +__uint 0x0 + 0xfffc == -0x4 (0xfffc) +char 0x0 + 0xfffc == -0x4 (0xfffc) +__uchar 0x0 + 0xfc == 0xfc (0xfc) +__longlong 0x0 + 0xfffc == -0x4 (0xfffc) +__ulonglong 0x0 + 0xfffc == -0x4 (0xfffc) +float 0x0 + 0xfffc == -0x4 (0xfffc) +int 0x0 - 0xfffc == 0x4 (0x4) +__uint 0x0 - 0xfffc == 0x4 (0x4) +char 0x0 - 0xfffc == 0x4 (0x4) +__uchar 0x0 - 0xfc == 0x4 (0x4) +__longlong 0x0 - 0xfffc == 0x4 (0x4) +__ulonglong 0x0 - 0xfffc == 0x4 (0x4) +float 0x0 - 0xfffc == 0x4 (0x4) +int 0x0 * 0xfffc == 0x0 (0x0) +__uint 0x0 * 0xfffc == 0x0 (0x0) +char 0x0 * 0xfffc == 0x0 (0x0) +__uchar 0x0 * 0xfc == 0x0 (0x0) +__longlong 0x0 * 0xfffc == 0x0 (0x0) +__ulonglong 0x0 * 0xfffc == 0x0 (0x0) +float 0x0 * 0xfffc == 0x0 (0x0) +int 0x0 < 0xfffc == 0x0 (0x0) +__uint 0x0 < 0xfffc == 0x1 (0x1) +char 0x0 < 0xfffc == 0x0 (0x0) +__uchar 0x0 < 0xfc == 0x1 (0x1) +__longlong 0x0 < 0xfffc == 0x0 (0x0) +__ulonglong 0x0 < 0xfffc == 0x1 (0x1) +float 0x0 < 0xfffc == 0x0 (0x0) +int 0x0 > 0xfffc == 0x1 (0x1) +__uint 0x0 > 0xfffc == 0x0 (0x0) +char 0x0 > 0xfffc == 0x1 (0x1) +__uchar 0x0 > 0xfc == 0x0 (0x0) +__longlong 0x0 > 0xfffc == 0x1 (0x1) +__ulonglong 0x0 > 0xfffc == 0x0 (0x0) +float 0x0 > 0xfffc == 0x1 (0x1) +int 0x0 <= 0xfffc == 0x0 (0x0) +__uint 0x0 <= 0xfffc == 0x1 (0x1) +char 0x0 <= 0xfffc == 0x0 (0x0) +__uchar 0x0 <= 0xfc == 0x1 (0x1) +__longlong 0x0 <= 0xfffc == 0x0 (0x0) +__ulonglong 0x0 <= 0xfffc == 0x1 (0x1) +float 0x0 <= 0xfffc == 0x0 (0x0) +int 0x0 == 0xfffc == 0x0 (0x0) +__uint 0x0 == 0xfffc == 0x0 (0x0) +char 0x0 == 0xfffc == 0x0 (0x0) +__uchar 0x0 == 0xfc == 0x0 (0x0) +__longlong 0x0 == 0xfffc == 0x0 (0x0) +__ulonglong 0x0 == 0xfffc == 0x0 (0x0) +float 0x0 == 0xfffc == 0x0 (0x0) +int 0x0 != 0xfffc == 0x1 (0x1) +__uint 0x0 != 0xfffc == 0x1 (0x1) +char 0x0 != 0xfffc == 0x1 (0x1) +__uchar 0x0 != 0xfc == 0x1 (0x1) +__longlong 0x0 != 0xfffc == 0x1 (0x1) +__ulonglong 0x0 != 0xfffc == 0x1 (0x1) +float 0x0 != 0xfffc == 0x1 (0x1) +int 0x0 >= 0xfffc == 0x1 (0x1) +__uint 0x0 >= 0xfffc == 0x0 (0x0) +char 0x0 >= 0xfffc == 0x1 (0x1) +__uchar 0x0 >= 0xfc == 0x0 (0x0) +__longlong 0x0 >= 0xfffc == 0x1 (0x1) +__ulonglong 0x0 >= 0xfffc == 0x0 (0x0) +float 0x0 >= 0xfffc == 0x1 (0x1) +int 0x0 / 0xfffc == 0x0 (0x0) +__uint 0x0 / 0xfffc == 0x0 (0x0) +char 0x0 / 0xfffc == 0x0 (0x0) +__uchar 0x0 / 0xfc == 0x0 (0x0) +__longlong 0x0 / 0xfffc == 0x0 (0x0) +__ulonglong 0x0 / 0xfffc == 0x0 (0x0) +float 0x0 / 0xfffc == 0x0 (0x0) +int 0x0 % 0xfffc == 0x0 (0x0) +__uint 0x0 % 0xfffc == 0x0 (0x0) +char 0x0 % 0xfffc == 0x0 (0x0) +__uchar 0x0 % 0xfc == 0x0 (0x0) +__longlong 0x0 % 0xfffc == 0x0 (0x0) +__ulonglong 0x0 % 0xfffc == 0x0 (0x0) +0x0 * 0xa == 0x0 +0x0 / 0xa == 0x0 +0x0 % 0xa == 0x0 +int 0x0 ^ 0xa == 0xa (0xa) +__uint 0x0 ^ 0xa == 0xa (0xa) +char 0x0 ^ 0xa == 0xa (0xa) +__uchar 0x0 ^ 0xa == 0xa (0xa) +__longlong 0x0 ^ 0xa == 0xa (0xa) +__ulonglong 0x0 ^ 0xa == 0xa (0xa) +int 0x0 && 0xa == 0x0 (0x0) +__uint 0x0 && 0xa == 0x0 (0x0) +char 0x0 && 0xa == 0x0 (0x0) +__uchar 0x0 && 0xa == 0x0 (0x0) +__longlong 0x0 && 0xa == 0x0 (0x0) +__ulonglong 0x0 && 0xa == 0x0 (0x0) +int 0x0 || 0xa == 0x1 (0x1) +__uint 0x0 || 0xa == 0x1 (0x1) +char 0x0 || 0xa == 0x1 (0x1) +__uchar 0x0 || 0xa == 0x1 (0x1) +__longlong 0x0 || 0xa == 0x1 (0x1) +__ulonglong 0x0 || 0xa == 0x1 (0x1) +int 0x0 & 0xa == 0x0 (0x0) +__uint 0x0 & 0xa == 0x0 (0x0) +char 0x0 & 0xa == 0x0 (0x0) +__uchar 0x0 & 0xa == 0x0 (0x0) +__longlong 0x0 & 0xa == 0x0 (0x0) +__ulonglong 0x0 & 0xa == 0x0 (0x0) +int 0x0 | 0xa == 0xa (0xa) +__uint 0x0 | 0xa == 0xa (0xa) +char 0x0 | 0xa == 0xa (0xa) +__uchar 0x0 | 0xa == 0xa (0xa) +__longlong 0x0 | 0xa == 0xa (0xa) +__ulonglong 0x0 | 0xa == 0xa (0xa) +int 0x0 << 0x7 == 0x0 (0x0) +__uint 0x0 << 0x7 == 0x0 (0x0) +char 0x0 << 0x7 == 0x0 (0x0) +__uchar 0x0 << 0x7 == 0x0 (0x0) +__longlong 0x0 << 0x7 == 0x0 (0x0) +__ulonglong 0x0 << 0x7 == 0x0 (0x0) +int 0x0 >> 0x7 == 0x0 (0x0) +__uint 0x0 >> 0x7 == 0x0 (0x0) +char 0x0 >> 0x7 == 0x0 (0x0) +__uchar 0x0 >> 0x7 == 0x0 (0x0) +__longlong 0x0 >> 0x7 == 0x0 (0x0) +__ulonglong 0x0 >> 0x7 == 0x0 (0x0) +int 0x0 + 0xa == 0xa (0xa) +__uint 0x0 + 0xa == 0xa (0xa) +char 0x0 + 0xa == 0xa (0xa) +__uchar 0x0 + 0xa == 0xa (0xa) +__longlong 0x0 + 0xa == 0xa (0xa) +__ulonglong 0x0 + 0xa == 0xa (0xa) +float 0x0 + 0xa == 0xa (0xa) +int 0x0 - 0xa == -0xa (0xfff6) +__uint 0x0 - 0xa == -0xa (0xfff6) +char 0x0 - 0xa == -0xa (0xfff6) +__uchar 0x0 - 0xa == 0xf6 (0xf6) +__longlong 0x0 - 0xa == -0xa (0xfff6) +__ulonglong 0x0 - 0xa == -0xa (0xfff6) +float 0x0 - 0xa == -0xa (0xfff6) +int 0x0 * 0xa == 0x0 (0x0) +__uint 0x0 * 0xa == 0x0 (0x0) +char 0x0 * 0xa == 0x0 (0x0) +__uchar 0x0 * 0xa == 0x0 (0x0) +__longlong 0x0 * 0xa == 0x0 (0x0) +__ulonglong 0x0 * 0xa == 0x0 (0x0) +float 0x0 * 0xa == 0x0 (0x0) +int 0x0 < 0xa == 0x1 (0x1) +__uint 0x0 < 0xa == 0x1 (0x1) +char 0x0 < 0xa == 0x1 (0x1) +__uchar 0x0 < 0xa == 0x1 (0x1) +__longlong 0x0 < 0xa == 0x1 (0x1) +__ulonglong 0x0 < 0xa == 0x1 (0x1) +float 0x0 < 0xa == 0x1 (0x1) +int 0x0 > 0xa == 0x0 (0x0) +__uint 0x0 > 0xa == 0x0 (0x0) +char 0x0 > 0xa == 0x0 (0x0) +__uchar 0x0 > 0xa == 0x0 (0x0) +__longlong 0x0 > 0xa == 0x0 (0x0) +__ulonglong 0x0 > 0xa == 0x0 (0x0) +float 0x0 > 0xa == 0x0 (0x0) +int 0x0 <= 0xa == 0x1 (0x1) +__uint 0x0 <= 0xa == 0x1 (0x1) +char 0x0 <= 0xa == 0x1 (0x1) +__uchar 0x0 <= 0xa == 0x1 (0x1) +__longlong 0x0 <= 0xa == 0x1 (0x1) +__ulonglong 0x0 <= 0xa == 0x1 (0x1) +float 0x0 <= 0xa == 0x1 (0x1) +int 0x0 == 0xa == 0x0 (0x0) +__uint 0x0 == 0xa == 0x0 (0x0) +char 0x0 == 0xa == 0x0 (0x0) +__uchar 0x0 == 0xa == 0x0 (0x0) +__longlong 0x0 == 0xa == 0x0 (0x0) +__ulonglong 0x0 == 0xa == 0x0 (0x0) +float 0x0 == 0xa == 0x0 (0x0) +int 0x0 != 0xa == 0x1 (0x1) +__uint 0x0 != 0xa == 0x1 (0x1) +char 0x0 != 0xa == 0x1 (0x1) +__uchar 0x0 != 0xa == 0x1 (0x1) +__longlong 0x0 != 0xa == 0x1 (0x1) +__ulonglong 0x0 != 0xa == 0x1 (0x1) +float 0x0 != 0xa == 0x1 (0x1) +int 0x0 >= 0xa == 0x0 (0x0) +__uint 0x0 >= 0xa == 0x0 (0x0) +char 0x0 >= 0xa == 0x0 (0x0) +__uchar 0x0 >= 0xa == 0x0 (0x0) +__longlong 0x0 >= 0xa == 0x0 (0x0) +__ulonglong 0x0 >= 0xa == 0x0 (0x0) +float 0x0 >= 0xa == 0x0 (0x0) +int 0x0 / 0xa == 0x0 (0x0) +__uint 0x0 / 0xa == 0x0 (0x0) +char 0x0 / 0xa == 0x0 (0x0) +__uchar 0x0 / 0xa == 0x0 (0x0) +__longlong 0x0 / 0xa == 0x0 (0x0) +__ulonglong 0x0 / 0xa == 0x0 (0x0) +float 0x0 / 0xa == 0x0 (0x0) +int 0x0 % 0xa == 0x0 (0x0) +__uint 0x0 % 0xa == 0x0 (0x0) +char 0x0 % 0xa == 0x0 (0x0) +__uchar 0x0 % 0xa == 0x0 (0x0) +__longlong 0x0 % 0xa == 0x0 (0x0) +__ulonglong 0x0 % 0xa == 0x0 (0x0) +0x0 * 0xfff6 == 0x0 +0x0 / 0xfff6 == 0x0 +0x0 % 0xfff6 == 0x0 +int 0x0 ^ 0xfff6 == -0xa (0xfff6) +__uint 0x0 ^ 0xfff6 == -0xa (0xfff6) +char 0x0 ^ 0xfff6 == -0xa (0xfff6) +__uchar 0x0 ^ 0xf6 == 0xf6 (0xf6) +__longlong 0x0 ^ 0xfff6 == -0xa (0xfff6) +__ulonglong 0x0 ^ 0xfff6 == -0xa (0xfff6) +int 0x0 && 0xfff6 == 0x0 (0x0) +__uint 0x0 && 0xfff6 == 0x0 (0x0) +char 0x0 && 0xfff6 == 0x0 (0x0) +__uchar 0x0 && 0xf6 == 0x0 (0x0) +__longlong 0x0 && 0xfff6 == 0x0 (0x0) +__ulonglong 0x0 && 0xfff6 == 0x0 (0x0) +int 0x0 || 0xfff6 == 0x1 (0x1) +__uint 0x0 || 0xfff6 == 0x1 (0x1) +char 0x0 || 0xfff6 == 0x1 (0x1) +__uchar 0x0 || 0xf6 == 0x1 (0x1) +__longlong 0x0 || 0xfff6 == 0x1 (0x1) +__ulonglong 0x0 || 0xfff6 == 0x1 (0x1) +int 0x0 & 0xfff6 == 0x0 (0x0) +__uint 0x0 & 0xfff6 == 0x0 (0x0) +char 0x0 & 0xfff6 == 0x0 (0x0) +__uchar 0x0 & 0xf6 == 0x0 (0x0) +__longlong 0x0 & 0xfff6 == 0x0 (0x0) +__ulonglong 0x0 & 0xfff6 == 0x0 (0x0) +int 0x0 | 0xfff6 == -0xa (0xfff6) +__uint 0x0 | 0xfff6 == -0xa (0xfff6) +char 0x0 | 0xfff6 == -0xa (0xfff6) +__uchar 0x0 | 0xf6 == 0xf6 (0xf6) +__longlong 0x0 | 0xfff6 == -0xa (0xfff6) +__ulonglong 0x0 | 0xfff6 == -0xa (0xfff6) +int 0x0 << 0x8 == 0x0 (0x0) +__uint 0x0 << 0x8 == 0x0 (0x0) +char 0x0 << 0x8 == 0x0 (0x0) +__uchar 0x0 << 0x8 == 0x0 (0x0) +__longlong 0x0 << 0x8 == 0x0 (0x0) +__ulonglong 0x0 << 0x8 == 0x0 (0x0) +int 0x0 >> 0x8 == 0x0 (0x0) +__uint 0x0 >> 0x8 == 0x0 (0x0) +char 0x0 >> 0x8 == 0x0 (0x0) +__uchar 0x0 >> 0x8 == 0x0 (0x0) +__longlong 0x0 >> 0x8 == 0x0 (0x0) +__ulonglong 0x0 >> 0x8 == 0x0 (0x0) +int 0x0 + 0xfff6 == -0xa (0xfff6) +__uint 0x0 + 0xfff6 == -0xa (0xfff6) +char 0x0 + 0xfff6 == -0xa (0xfff6) +__uchar 0x0 + 0xf6 == 0xf6 (0xf6) +__longlong 0x0 + 0xfff6 == -0xa (0xfff6) +__ulonglong 0x0 + 0xfff6 == -0xa (0xfff6) +float 0x0 + 0xfff6 == -0xa (0xfff6) +int 0x0 - 0xfff6 == 0xa (0xa) +__uint 0x0 - 0xfff6 == 0xa (0xa) +char 0x0 - 0xfff6 == 0xa (0xa) +__uchar 0x0 - 0xf6 == 0xa (0xa) +__longlong 0x0 - 0xfff6 == 0xa (0xa) +__ulonglong 0x0 - 0xfff6 == 0xa (0xa) +float 0x0 - 0xfff6 == 0xa (0xa) +int 0x0 * 0xfff6 == 0x0 (0x0) +__uint 0x0 * 0xfff6 == 0x0 (0x0) +char 0x0 * 0xfff6 == 0x0 (0x0) +__uchar 0x0 * 0xf6 == 0x0 (0x0) +__longlong 0x0 * 0xfff6 == 0x0 (0x0) +__ulonglong 0x0 * 0xfff6 == 0x0 (0x0) +float 0x0 * 0xfff6 == 0x0 (0x0) +int 0x0 < 0xfff6 == 0x0 (0x0) +__uint 0x0 < 0xfff6 == 0x1 (0x1) +char 0x0 < 0xfff6 == 0x0 (0x0) +__uchar 0x0 < 0xf6 == 0x1 (0x1) +__longlong 0x0 < 0xfff6 == 0x0 (0x0) +__ulonglong 0x0 < 0xfff6 == 0x1 (0x1) +float 0x0 < 0xfff6 == 0x0 (0x0) +int 0x0 > 0xfff6 == 0x1 (0x1) +__uint 0x0 > 0xfff6 == 0x0 (0x0) +char 0x0 > 0xfff6 == 0x1 (0x1) +__uchar 0x0 > 0xf6 == 0x0 (0x0) +__longlong 0x0 > 0xfff6 == 0x1 (0x1) +__ulonglong 0x0 > 0xfff6 == 0x0 (0x0) +float 0x0 > 0xfff6 == 0x1 (0x1) +int 0x0 <= 0xfff6 == 0x0 (0x0) +__uint 0x0 <= 0xfff6 == 0x1 (0x1) +char 0x0 <= 0xfff6 == 0x0 (0x0) +__uchar 0x0 <= 0xf6 == 0x1 (0x1) +__longlong 0x0 <= 0xfff6 == 0x0 (0x0) +__ulonglong 0x0 <= 0xfff6 == 0x1 (0x1) +float 0x0 <= 0xfff6 == 0x0 (0x0) +int 0x0 == 0xfff6 == 0x0 (0x0) +__uint 0x0 == 0xfff6 == 0x0 (0x0) +char 0x0 == 0xfff6 == 0x0 (0x0) +__uchar 0x0 == 0xf6 == 0x0 (0x0) +__longlong 0x0 == 0xfff6 == 0x0 (0x0) +__ulonglong 0x0 == 0xfff6 == 0x0 (0x0) +float 0x0 == 0xfff6 == 0x0 (0x0) +int 0x0 != 0xfff6 == 0x1 (0x1) +__uint 0x0 != 0xfff6 == 0x1 (0x1) +char 0x0 != 0xfff6 == 0x1 (0x1) +__uchar 0x0 != 0xf6 == 0x1 (0x1) +__longlong 0x0 != 0xfff6 == 0x1 (0x1) +__ulonglong 0x0 != 0xfff6 == 0x1 (0x1) +float 0x0 != 0xfff6 == 0x1 (0x1) +int 0x0 >= 0xfff6 == 0x1 (0x1) +__uint 0x0 >= 0xfff6 == 0x0 (0x0) +char 0x0 >= 0xfff6 == 0x1 (0x1) +__uchar 0x0 >= 0xf6 == 0x0 (0x0) +__longlong 0x0 >= 0xfff6 == 0x1 (0x1) +__ulonglong 0x0 >= 0xfff6 == 0x0 (0x0) +float 0x0 >= 0xfff6 == 0x1 (0x1) +int 0x0 / 0xfff6 == 0x0 (0x0) +__uint 0x0 / 0xfff6 == 0x0 (0x0) +char 0x0 / 0xfff6 == 0x0 (0x0) +__uchar 0x0 / 0xf6 == 0x0 (0x0) +__longlong 0x0 / 0xfff6 == 0x0 (0x0) +__ulonglong 0x0 / 0xfff6 == 0x0 (0x0) +float 0x0 / 0xfff6 == 0x0 (0x0) +int 0x0 % 0xfff6 == 0x0 (0x0) +__uint 0x0 % 0xfff6 == 0x0 (0x0) +char 0x0 % 0xfff6 == 0x0 (0x0) +__uchar 0x0 % 0xf6 == 0x0 (0x0) +__longlong 0x0 % 0xfff6 == 0x0 (0x0) +__ulonglong 0x0 % 0xfff6 == 0x0 (0x0) +0x0 * 0x5 == 0x0 +0x0 / 0x5 == 0x0 +0x0 % 0x5 == 0x0 +int 0x0 ^ 0x5 == 0x5 (0x5) +__uint 0x0 ^ 0x5 == 0x5 (0x5) +char 0x0 ^ 0x5 == 0x5 (0x5) +__uchar 0x0 ^ 0x5 == 0x5 (0x5) +__longlong 0x0 ^ 0x5 == 0x5 (0x5) +__ulonglong 0x0 ^ 0x5 == 0x5 (0x5) +int 0x0 && 0x5 == 0x0 (0x0) +__uint 0x0 && 0x5 == 0x0 (0x0) +char 0x0 && 0x5 == 0x0 (0x0) +__uchar 0x0 && 0x5 == 0x0 (0x0) +__longlong 0x0 && 0x5 == 0x0 (0x0) +__ulonglong 0x0 && 0x5 == 0x0 (0x0) +int 0x0 || 0x5 == 0x1 (0x1) +__uint 0x0 || 0x5 == 0x1 (0x1) +char 0x0 || 0x5 == 0x1 (0x1) +__uchar 0x0 || 0x5 == 0x1 (0x1) +__longlong 0x0 || 0x5 == 0x1 (0x1) +__ulonglong 0x0 || 0x5 == 0x1 (0x1) +int 0x0 & 0x5 == 0x0 (0x0) +__uint 0x0 & 0x5 == 0x0 (0x0) +char 0x0 & 0x5 == 0x0 (0x0) +__uchar 0x0 & 0x5 == 0x0 (0x0) +__longlong 0x0 & 0x5 == 0x0 (0x0) +__ulonglong 0x0 & 0x5 == 0x0 (0x0) +int 0x0 | 0x5 == 0x5 (0x5) +__uint 0x0 | 0x5 == 0x5 (0x5) +char 0x0 | 0x5 == 0x5 (0x5) +__uchar 0x0 | 0x5 == 0x5 (0x5) +__longlong 0x0 | 0x5 == 0x5 (0x5) +__ulonglong 0x0 | 0x5 == 0x5 (0x5) +int 0x0 << 0x9 == 0x0 (0x0) +__uint 0x0 << 0x9 == 0x0 (0x0) +char 0x0 << 0x9 == 0x0 (0x0) +__uchar 0x0 << 0x9 == 0x0 (0x0) +__longlong 0x0 << 0x9 == 0x0 (0x0) +__ulonglong 0x0 << 0x9 == 0x0 (0x0) +int 0x0 >> 0x9 == 0x0 (0x0) +__uint 0x0 >> 0x9 == 0x0 (0x0) +char 0x0 >> 0x9 == 0x0 (0x0) +__uchar 0x0 >> 0x9 == 0x0 (0x0) +__longlong 0x0 >> 0x9 == 0x0 (0x0) +__ulonglong 0x0 >> 0x9 == 0x0 (0x0) +int 0x0 + 0x5 == 0x5 (0x5) +__uint 0x0 + 0x5 == 0x5 (0x5) +char 0x0 + 0x5 == 0x5 (0x5) +__uchar 0x0 + 0x5 == 0x5 (0x5) +__longlong 0x0 + 0x5 == 0x5 (0x5) +__ulonglong 0x0 + 0x5 == 0x5 (0x5) +float 0x0 + 0x5 == 0x5 (0x5) +int 0x0 - 0x5 == -0x5 (0xfffb) +__uint 0x0 - 0x5 == -0x5 (0xfffb) +char 0x0 - 0x5 == -0x5 (0xfffb) +__uchar 0x0 - 0x5 == 0xfb (0xfb) +__longlong 0x0 - 0x5 == -0x5 (0xfffb) +__ulonglong 0x0 - 0x5 == -0x5 (0xfffb) +float 0x0 - 0x5 == -0x5 (0xfffb) +int 0x0 * 0x5 == 0x0 (0x0) +__uint 0x0 * 0x5 == 0x0 (0x0) +char 0x0 * 0x5 == 0x0 (0x0) +__uchar 0x0 * 0x5 == 0x0 (0x0) +__longlong 0x0 * 0x5 == 0x0 (0x0) +__ulonglong 0x0 * 0x5 == 0x0 (0x0) +float 0x0 * 0x5 == 0x0 (0x0) +int 0x0 < 0x5 == 0x1 (0x1) +__uint 0x0 < 0x5 == 0x1 (0x1) +char 0x0 < 0x5 == 0x1 (0x1) +__uchar 0x0 < 0x5 == 0x1 (0x1) +__longlong 0x0 < 0x5 == 0x1 (0x1) +__ulonglong 0x0 < 0x5 == 0x1 (0x1) +float 0x0 < 0x5 == 0x1 (0x1) +int 0x0 > 0x5 == 0x0 (0x0) +__uint 0x0 > 0x5 == 0x0 (0x0) +char 0x0 > 0x5 == 0x0 (0x0) +__uchar 0x0 > 0x5 == 0x0 (0x0) +__longlong 0x0 > 0x5 == 0x0 (0x0) +__ulonglong 0x0 > 0x5 == 0x0 (0x0) +float 0x0 > 0x5 == 0x0 (0x0) +int 0x0 <= 0x5 == 0x1 (0x1) +__uint 0x0 <= 0x5 == 0x1 (0x1) +char 0x0 <= 0x5 == 0x1 (0x1) +__uchar 0x0 <= 0x5 == 0x1 (0x1) +__longlong 0x0 <= 0x5 == 0x1 (0x1) +__ulonglong 0x0 <= 0x5 == 0x1 (0x1) +float 0x0 <= 0x5 == 0x1 (0x1) +int 0x0 == 0x5 == 0x0 (0x0) +__uint 0x0 == 0x5 == 0x0 (0x0) +char 0x0 == 0x5 == 0x0 (0x0) +__uchar 0x0 == 0x5 == 0x0 (0x0) +__longlong 0x0 == 0x5 == 0x0 (0x0) +__ulonglong 0x0 == 0x5 == 0x0 (0x0) +float 0x0 == 0x5 == 0x0 (0x0) +int 0x0 != 0x5 == 0x1 (0x1) +__uint 0x0 != 0x5 == 0x1 (0x1) +char 0x0 != 0x5 == 0x1 (0x1) +__uchar 0x0 != 0x5 == 0x1 (0x1) +__longlong 0x0 != 0x5 == 0x1 (0x1) +__ulonglong 0x0 != 0x5 == 0x1 (0x1) +float 0x0 != 0x5 == 0x1 (0x1) +int 0x0 >= 0x5 == 0x0 (0x0) +__uint 0x0 >= 0x5 == 0x0 (0x0) +char 0x0 >= 0x5 == 0x0 (0x0) +__uchar 0x0 >= 0x5 == 0x0 (0x0) +__longlong 0x0 >= 0x5 == 0x0 (0x0) +__ulonglong 0x0 >= 0x5 == 0x0 (0x0) +float 0x0 >= 0x5 == 0x0 (0x0) +int 0x0 / 0x5 == 0x0 (0x0) +__uint 0x0 / 0x5 == 0x0 (0x0) +char 0x0 / 0x5 == 0x0 (0x0) +__uchar 0x0 / 0x5 == 0x0 (0x0) +__longlong 0x0 / 0x5 == 0x0 (0x0) +__ulonglong 0x0 / 0x5 == 0x0 (0x0) +float 0x0 / 0x5 == 0x0 (0x0) +int 0x0 % 0x5 == 0x0 (0x0) +__uint 0x0 % 0x5 == 0x0 (0x0) +char 0x0 % 0x5 == 0x0 (0x0) +__uchar 0x0 % 0x5 == 0x0 (0x0) +__longlong 0x0 % 0x5 == 0x0 (0x0) +__ulonglong 0x0 % 0x5 == 0x0 (0x0) +0x0 * 0x7 == 0x0 +0x0 / 0x7 == 0x0 +0x0 % 0x7 == 0x0 +int 0x0 ^ 0x7 == 0x7 (0x7) +__uint 0x0 ^ 0x7 == 0x7 (0x7) +char 0x0 ^ 0x7 == 0x7 (0x7) +__uchar 0x0 ^ 0x7 == 0x7 (0x7) +__longlong 0x0 ^ 0x7 == 0x7 (0x7) +__ulonglong 0x0 ^ 0x7 == 0x7 (0x7) +int 0x0 && 0x7 == 0x0 (0x0) +__uint 0x0 && 0x7 == 0x0 (0x0) +char 0x0 && 0x7 == 0x0 (0x0) +__uchar 0x0 && 0x7 == 0x0 (0x0) +__longlong 0x0 && 0x7 == 0x0 (0x0) +__ulonglong 0x0 && 0x7 == 0x0 (0x0) +int 0x0 || 0x7 == 0x1 (0x1) +__uint 0x0 || 0x7 == 0x1 (0x1) +char 0x0 || 0x7 == 0x1 (0x1) +__uchar 0x0 || 0x7 == 0x1 (0x1) +__longlong 0x0 || 0x7 == 0x1 (0x1) +__ulonglong 0x0 || 0x7 == 0x1 (0x1) +int 0x0 & 0x7 == 0x0 (0x0) +__uint 0x0 & 0x7 == 0x0 (0x0) +char 0x0 & 0x7 == 0x0 (0x0) +__uchar 0x0 & 0x7 == 0x0 (0x0) +__longlong 0x0 & 0x7 == 0x0 (0x0) +__ulonglong 0x0 & 0x7 == 0x0 (0x0) +int 0x0 | 0x7 == 0x7 (0x7) +__uint 0x0 | 0x7 == 0x7 (0x7) +char 0x0 | 0x7 == 0x7 (0x7) +__uchar 0x0 | 0x7 == 0x7 (0x7) +__longlong 0x0 | 0x7 == 0x7 (0x7) +__ulonglong 0x0 | 0x7 == 0x7 (0x7) +int 0x0 << 0xa == 0x0 (0x0) +__uint 0x0 << 0xa == 0x0 (0x0) +char 0x0 << 0xa == 0x0 (0x0) +__uchar 0x0 << 0xa == 0x0 (0x0) +__longlong 0x0 << 0xa == 0x0 (0x0) +__ulonglong 0x0 << 0xa == 0x0 (0x0) +int 0x0 >> 0xa == 0x0 (0x0) +__uint 0x0 >> 0xa == 0x0 (0x0) +char 0x0 >> 0xa == 0x0 (0x0) +__uchar 0x0 >> 0xa == 0x0 (0x0) +__longlong 0x0 >> 0xa == 0x0 (0x0) +__ulonglong 0x0 >> 0xa == 0x0 (0x0) +int 0x0 + 0x7 == 0x7 (0x7) +__uint 0x0 + 0x7 == 0x7 (0x7) +char 0x0 + 0x7 == 0x7 (0x7) +__uchar 0x0 + 0x7 == 0x7 (0x7) +__longlong 0x0 + 0x7 == 0x7 (0x7) +__ulonglong 0x0 + 0x7 == 0x7 (0x7) +float 0x0 + 0x7 == 0x7 (0x7) +int 0x0 - 0x7 == -0x7 (0xfff9) +__uint 0x0 - 0x7 == -0x7 (0xfff9) +char 0x0 - 0x7 == -0x7 (0xfff9) +__uchar 0x0 - 0x7 == 0xf9 (0xf9) +__longlong 0x0 - 0x7 == -0x7 (0xfff9) +__ulonglong 0x0 - 0x7 == -0x7 (0xfff9) +float 0x0 - 0x7 == -0x7 (0xfff9) +int 0x0 * 0x7 == 0x0 (0x0) +__uint 0x0 * 0x7 == 0x0 (0x0) +char 0x0 * 0x7 == 0x0 (0x0) +__uchar 0x0 * 0x7 == 0x0 (0x0) +__longlong 0x0 * 0x7 == 0x0 (0x0) +__ulonglong 0x0 * 0x7 == 0x0 (0x0) +float 0x0 * 0x7 == 0x0 (0x0) +int 0x0 < 0x7 == 0x1 (0x1) +__uint 0x0 < 0x7 == 0x1 (0x1) +char 0x0 < 0x7 == 0x1 (0x1) +__uchar 0x0 < 0x7 == 0x1 (0x1) +__longlong 0x0 < 0x7 == 0x1 (0x1) +__ulonglong 0x0 < 0x7 == 0x1 (0x1) +float 0x0 < 0x7 == 0x1 (0x1) +int 0x0 > 0x7 == 0x0 (0x0) +__uint 0x0 > 0x7 == 0x0 (0x0) +char 0x0 > 0x7 == 0x0 (0x0) +__uchar 0x0 > 0x7 == 0x0 (0x0) +__longlong 0x0 > 0x7 == 0x0 (0x0) +__ulonglong 0x0 > 0x7 == 0x0 (0x0) +float 0x0 > 0x7 == 0x0 (0x0) +int 0x0 <= 0x7 == 0x1 (0x1) +__uint 0x0 <= 0x7 == 0x1 (0x1) +char 0x0 <= 0x7 == 0x1 (0x1) +__uchar 0x0 <= 0x7 == 0x1 (0x1) +__longlong 0x0 <= 0x7 == 0x1 (0x1) +__ulonglong 0x0 <= 0x7 == 0x1 (0x1) +float 0x0 <= 0x7 == 0x1 (0x1) +int 0x0 == 0x7 == 0x0 (0x0) +__uint 0x0 == 0x7 == 0x0 (0x0) +char 0x0 == 0x7 == 0x0 (0x0) +__uchar 0x0 == 0x7 == 0x0 (0x0) +__longlong 0x0 == 0x7 == 0x0 (0x0) +__ulonglong 0x0 == 0x7 == 0x0 (0x0) +float 0x0 == 0x7 == 0x0 (0x0) +int 0x0 != 0x7 == 0x1 (0x1) +__uint 0x0 != 0x7 == 0x1 (0x1) +char 0x0 != 0x7 == 0x1 (0x1) +__uchar 0x0 != 0x7 == 0x1 (0x1) +__longlong 0x0 != 0x7 == 0x1 (0x1) +__ulonglong 0x0 != 0x7 == 0x1 (0x1) +float 0x0 != 0x7 == 0x1 (0x1) +int 0x0 >= 0x7 == 0x0 (0x0) +__uint 0x0 >= 0x7 == 0x0 (0x0) +char 0x0 >= 0x7 == 0x0 (0x0) +__uchar 0x0 >= 0x7 == 0x0 (0x0) +__longlong 0x0 >= 0x7 == 0x0 (0x0) +__ulonglong 0x0 >= 0x7 == 0x0 (0x0) +float 0x0 >= 0x7 == 0x0 (0x0) +int 0x0 / 0x7 == 0x0 (0x0) +__uint 0x0 / 0x7 == 0x0 (0x0) +char 0x0 / 0x7 == 0x0 (0x0) +__uchar 0x0 / 0x7 == 0x0 (0x0) +__longlong 0x0 / 0x7 == 0x0 (0x0) +__ulonglong 0x0 / 0x7 == 0x0 (0x0) +float 0x0 / 0x7 == 0x0 (0x0) +int 0x0 % 0x7 == 0x0 (0x0) +__uint 0x0 % 0x7 == 0x0 (0x0) +char 0x0 % 0x7 == 0x0 (0x0) +__uchar 0x0 % 0x7 == 0x0 (0x0) +__longlong 0x0 % 0x7 == 0x0 (0x0) +__ulonglong 0x0 % 0x7 == 0x0 (0x0) +0x0 * 0x2a == 0x0 +0x0 / 0x2a == 0x0 +0x0 % 0x2a == 0x0 +int 0x0 ^ 0x2a == 0x2a (0x2a) +__uint 0x0 ^ 0x2a == 0x2a (0x2a) +char 0x0 ^ 0x2a == 0x2a (0x2a) +__uchar 0x0 ^ 0x2a == 0x2a (0x2a) +__longlong 0x0 ^ 0x2a == 0x2a (0x2a) +__ulonglong 0x0 ^ 0x2a == 0x2a (0x2a) +int 0x0 && 0x2a == 0x0 (0x0) +__uint 0x0 && 0x2a == 0x0 (0x0) +char 0x0 && 0x2a == 0x0 (0x0) +__uchar 0x0 && 0x2a == 0x0 (0x0) +__longlong 0x0 && 0x2a == 0x0 (0x0) +__ulonglong 0x0 && 0x2a == 0x0 (0x0) +int 0x0 || 0x2a == 0x1 (0x1) +__uint 0x0 || 0x2a == 0x1 (0x1) +char 0x0 || 0x2a == 0x1 (0x1) +__uchar 0x0 || 0x2a == 0x1 (0x1) +__longlong 0x0 || 0x2a == 0x1 (0x1) +__ulonglong 0x0 || 0x2a == 0x1 (0x1) +int 0x0 & 0x2a == 0x0 (0x0) +__uint 0x0 & 0x2a == 0x0 (0x0) +char 0x0 & 0x2a == 0x0 (0x0) +__uchar 0x0 & 0x2a == 0x0 (0x0) +__longlong 0x0 & 0x2a == 0x0 (0x0) +__ulonglong 0x0 & 0x2a == 0x0 (0x0) +int 0x0 | 0x2a == 0x2a (0x2a) +__uint 0x0 | 0x2a == 0x2a (0x2a) +char 0x0 | 0x2a == 0x2a (0x2a) +__uchar 0x0 | 0x2a == 0x2a (0x2a) +__longlong 0x0 | 0x2a == 0x2a (0x2a) +__ulonglong 0x0 | 0x2a == 0x2a (0x2a) +int 0x0 << 0xc == 0x0 (0x0) +__uint 0x0 << 0xc == 0x0 (0x0) +char 0x0 << 0xc == 0x0 (0x0) +__uchar 0x0 << 0xc == 0x0 (0x0) +__longlong 0x0 << 0xc == 0x0 (0x0) +__ulonglong 0x0 << 0xc == 0x0 (0x0) +int 0x0 >> 0xc == 0x0 (0x0) +__uint 0x0 >> 0xc == 0x0 (0x0) +char 0x0 >> 0xc == 0x0 (0x0) +__uchar 0x0 >> 0xc == 0x0 (0x0) +__longlong 0x0 >> 0xc == 0x0 (0x0) +__ulonglong 0x0 >> 0xc == 0x0 (0x0) +int 0x0 + 0x2a == 0x2a (0x2a) +__uint 0x0 + 0x2a == 0x2a (0x2a) +char 0x0 + 0x2a == 0x2a (0x2a) +__uchar 0x0 + 0x2a == 0x2a (0x2a) +__longlong 0x0 + 0x2a == 0x2a (0x2a) +__ulonglong 0x0 + 0x2a == 0x2a (0x2a) +float 0x0 + 0x2a == 0x2a (0x2a) +int 0x0 - 0x2a == -0x2a (0xffd6) +__uint 0x0 - 0x2a == -0x2a (0xffd6) +char 0x0 - 0x2a == -0x2a (0xffd6) +__uchar 0x0 - 0x2a == 0xd6 (0xd6) +__longlong 0x0 - 0x2a == -0x2a (0xffd6) +__ulonglong 0x0 - 0x2a == -0x2a (0xffd6) +float 0x0 - 0x2a == -0x2a (0xffd6) +int 0x0 * 0x2a == 0x0 (0x0) +__uint 0x0 * 0x2a == 0x0 (0x0) +char 0x0 * 0x2a == 0x0 (0x0) +__uchar 0x0 * 0x2a == 0x0 (0x0) +__longlong 0x0 * 0x2a == 0x0 (0x0) +__ulonglong 0x0 * 0x2a == 0x0 (0x0) +float 0x0 * 0x2a == 0x0 (0x0) +int 0x0 < 0x2a == 0x1 (0x1) +__uint 0x0 < 0x2a == 0x1 (0x1) +char 0x0 < 0x2a == 0x1 (0x1) +__uchar 0x0 < 0x2a == 0x1 (0x1) +__longlong 0x0 < 0x2a == 0x1 (0x1) +__ulonglong 0x0 < 0x2a == 0x1 (0x1) +float 0x0 < 0x2a == 0x1 (0x1) +int 0x0 > 0x2a == 0x0 (0x0) +__uint 0x0 > 0x2a == 0x0 (0x0) +char 0x0 > 0x2a == 0x0 (0x0) +__uchar 0x0 > 0x2a == 0x0 (0x0) +__longlong 0x0 > 0x2a == 0x0 (0x0) +__ulonglong 0x0 > 0x2a == 0x0 (0x0) +float 0x0 > 0x2a == 0x0 (0x0) +int 0x0 <= 0x2a == 0x1 (0x1) +__uint 0x0 <= 0x2a == 0x1 (0x1) +char 0x0 <= 0x2a == 0x1 (0x1) +__uchar 0x0 <= 0x2a == 0x1 (0x1) +__longlong 0x0 <= 0x2a == 0x1 (0x1) +__ulonglong 0x0 <= 0x2a == 0x1 (0x1) +float 0x0 <= 0x2a == 0x1 (0x1) +int 0x0 == 0x2a == 0x0 (0x0) +__uint 0x0 == 0x2a == 0x0 (0x0) +char 0x0 == 0x2a == 0x0 (0x0) +__uchar 0x0 == 0x2a == 0x0 (0x0) +__longlong 0x0 == 0x2a == 0x0 (0x0) +__ulonglong 0x0 == 0x2a == 0x0 (0x0) +float 0x0 == 0x2a == 0x0 (0x0) +int 0x0 != 0x2a == 0x1 (0x1) +__uint 0x0 != 0x2a == 0x1 (0x1) +char 0x0 != 0x2a == 0x1 (0x1) +__uchar 0x0 != 0x2a == 0x1 (0x1) +__longlong 0x0 != 0x2a == 0x1 (0x1) +__ulonglong 0x0 != 0x2a == 0x1 (0x1) +float 0x0 != 0x2a == 0x1 (0x1) +int 0x0 >= 0x2a == 0x0 (0x0) +__uint 0x0 >= 0x2a == 0x0 (0x0) +char 0x0 >= 0x2a == 0x0 (0x0) +__uchar 0x0 >= 0x2a == 0x0 (0x0) +__longlong 0x0 >= 0x2a == 0x0 (0x0) +__ulonglong 0x0 >= 0x2a == 0x0 (0x0) +float 0x0 >= 0x2a == 0x0 (0x0) +int 0x0 / 0x2a == 0x0 (0x0) +__uint 0x0 / 0x2a == 0x0 (0x0) +char 0x0 / 0x2a == 0x0 (0x0) +__uchar 0x0 / 0x2a == 0x0 (0x0) +__longlong 0x0 / 0x2a == 0x0 (0x0) +__ulonglong 0x0 / 0x2a == 0x0 (0x0) +float 0x0 / 0x2a == 0x0 (0x0) +int 0x0 % 0x2a == 0x0 (0x0) +__uint 0x0 % 0x2a == 0x0 (0x0) +char 0x0 % 0x2a == 0x0 (0x0) +__uchar 0x0 % 0x2a == 0x0 (0x0) +__longlong 0x0 % 0x2a == 0x0 (0x0) +__ulonglong 0x0 % 0x2a == 0x0 (0x0) +0x0 * 0x17 == 0x0 +0x0 / 0x17 == 0x0 +0x0 % 0x17 == 0x0 +int 0x0 ^ 0x17 == 0x17 (0x17) +__uint 0x0 ^ 0x17 == 0x17 (0x17) +char 0x0 ^ 0x17 == 0x17 (0x17) +__uchar 0x0 ^ 0x17 == 0x17 (0x17) +__longlong 0x0 ^ 0x17 == 0x17 (0x17) +__ulonglong 0x0 ^ 0x17 == 0x17 (0x17) +int 0x0 && 0x17 == 0x0 (0x0) +__uint 0x0 && 0x17 == 0x0 (0x0) +char 0x0 && 0x17 == 0x0 (0x0) +__uchar 0x0 && 0x17 == 0x0 (0x0) +__longlong 0x0 && 0x17 == 0x0 (0x0) +__ulonglong 0x0 && 0x17 == 0x0 (0x0) +int 0x0 || 0x17 == 0x1 (0x1) +__uint 0x0 || 0x17 == 0x1 (0x1) +char 0x0 || 0x17 == 0x1 (0x1) +__uchar 0x0 || 0x17 == 0x1 (0x1) +__longlong 0x0 || 0x17 == 0x1 (0x1) +__ulonglong 0x0 || 0x17 == 0x1 (0x1) +int 0x0 & 0x17 == 0x0 (0x0) +__uint 0x0 & 0x17 == 0x0 (0x0) +char 0x0 & 0x17 == 0x0 (0x0) +__uchar 0x0 & 0x17 == 0x0 (0x0) +__longlong 0x0 & 0x17 == 0x0 (0x0) +__ulonglong 0x0 & 0x17 == 0x0 (0x0) +int 0x0 | 0x17 == 0x17 (0x17) +__uint 0x0 | 0x17 == 0x17 (0x17) +char 0x0 | 0x17 == 0x17 (0x17) +__uchar 0x0 | 0x17 == 0x17 (0x17) +__longlong 0x0 | 0x17 == 0x17 (0x17) +__ulonglong 0x0 | 0x17 == 0x17 (0x17) +int 0x0 << 0xe == 0x0 (0x0) +__uint 0x0 << 0xe == 0x0 (0x0) +char 0x0 << 0xe == 0x0 (0x0) +__uchar 0x0 << 0xe == 0x0 (0x0) +__longlong 0x0 << 0xe == 0x0 (0x0) +__ulonglong 0x0 << 0xe == 0x0 (0x0) +int 0x0 >> 0xe == 0x0 (0x0) +__uint 0x0 >> 0xe == 0x0 (0x0) +char 0x0 >> 0xe == 0x0 (0x0) +__uchar 0x0 >> 0xe == 0x0 (0x0) +__longlong 0x0 >> 0xe == 0x0 (0x0) +__ulonglong 0x0 >> 0xe == 0x0 (0x0) +int 0x0 + 0x17 == 0x17 (0x17) +__uint 0x0 + 0x17 == 0x17 (0x17) +char 0x0 + 0x17 == 0x17 (0x17) +__uchar 0x0 + 0x17 == 0x17 (0x17) +__longlong 0x0 + 0x17 == 0x17 (0x17) +__ulonglong 0x0 + 0x17 == 0x17 (0x17) +float 0x0 + 0x17 == 0x17 (0x17) +int 0x0 - 0x17 == -0x17 (0xffe9) +__uint 0x0 - 0x17 == -0x17 (0xffe9) +char 0x0 - 0x17 == -0x17 (0xffe9) +__uchar 0x0 - 0x17 == 0xe9 (0xe9) +__longlong 0x0 - 0x17 == -0x17 (0xffe9) +__ulonglong 0x0 - 0x17 == -0x17 (0xffe9) +float 0x0 - 0x17 == -0x17 (0xffe9) +int 0x0 * 0x17 == 0x0 (0x0) +__uint 0x0 * 0x17 == 0x0 (0x0) +char 0x0 * 0x17 == 0x0 (0x0) +__uchar 0x0 * 0x17 == 0x0 (0x0) +__longlong 0x0 * 0x17 == 0x0 (0x0) +__ulonglong 0x0 * 0x17 == 0x0 (0x0) +float 0x0 * 0x17 == 0x0 (0x0) +int 0x0 < 0x17 == 0x1 (0x1) +__uint 0x0 < 0x17 == 0x1 (0x1) +char 0x0 < 0x17 == 0x1 (0x1) +__uchar 0x0 < 0x17 == 0x1 (0x1) +__longlong 0x0 < 0x17 == 0x1 (0x1) +__ulonglong 0x0 < 0x17 == 0x1 (0x1) +float 0x0 < 0x17 == 0x1 (0x1) +int 0x0 > 0x17 == 0x0 (0x0) +__uint 0x0 > 0x17 == 0x0 (0x0) +char 0x0 > 0x17 == 0x0 (0x0) +__uchar 0x0 > 0x17 == 0x0 (0x0) +__longlong 0x0 > 0x17 == 0x0 (0x0) +__ulonglong 0x0 > 0x17 == 0x0 (0x0) +float 0x0 > 0x17 == 0x0 (0x0) +int 0x0 <= 0x17 == 0x1 (0x1) +__uint 0x0 <= 0x17 == 0x1 (0x1) +char 0x0 <= 0x17 == 0x1 (0x1) +__uchar 0x0 <= 0x17 == 0x1 (0x1) +__longlong 0x0 <= 0x17 == 0x1 (0x1) +__ulonglong 0x0 <= 0x17 == 0x1 (0x1) +float 0x0 <= 0x17 == 0x1 (0x1) +int 0x0 == 0x17 == 0x0 (0x0) +__uint 0x0 == 0x17 == 0x0 (0x0) +char 0x0 == 0x17 == 0x0 (0x0) +__uchar 0x0 == 0x17 == 0x0 (0x0) +__longlong 0x0 == 0x17 == 0x0 (0x0) +__ulonglong 0x0 == 0x17 == 0x0 (0x0) +float 0x0 == 0x17 == 0x0 (0x0) +int 0x0 != 0x17 == 0x1 (0x1) +__uint 0x0 != 0x17 == 0x1 (0x1) +char 0x0 != 0x17 == 0x1 (0x1) +__uchar 0x0 != 0x17 == 0x1 (0x1) +__longlong 0x0 != 0x17 == 0x1 (0x1) +__ulonglong 0x0 != 0x17 == 0x1 (0x1) +float 0x0 != 0x17 == 0x1 (0x1) +int 0x0 >= 0x17 == 0x0 (0x0) +__uint 0x0 >= 0x17 == 0x0 (0x0) +char 0x0 >= 0x17 == 0x0 (0x0) +__uchar 0x0 >= 0x17 == 0x0 (0x0) +__longlong 0x0 >= 0x17 == 0x0 (0x0) +__ulonglong 0x0 >= 0x17 == 0x0 (0x0) +float 0x0 >= 0x17 == 0x0 (0x0) +int 0x0 / 0x17 == 0x0 (0x0) +__uint 0x0 / 0x17 == 0x0 (0x0) +char 0x0 / 0x17 == 0x0 (0x0) +__uchar 0x0 / 0x17 == 0x0 (0x0) +__longlong 0x0 / 0x17 == 0x0 (0x0) +__ulonglong 0x0 / 0x17 == 0x0 (0x0) +float 0x0 / 0x17 == 0x0 (0x0) +int 0x0 % 0x17 == 0x0 (0x0) +__uint 0x0 % 0x17 == 0x0 (0x0) +char 0x0 % 0x17 == 0x0 (0x0) +__uchar 0x0 % 0x17 == 0x0 (0x0) +__longlong 0x0 % 0x17 == 0x0 (0x0) +__ulonglong 0x0 % 0x17 == 0x0 (0x0) +0x0 * 0x7fff == 0x0 +0x0 / 0x7fff == 0x0 +0x0 % 0x7fff == 0x0 +int 0x0 ^ 0x7fff == 0x7fff (0x7fff) +__uint 0x0 ^ 0x7fff == 0x7fff (0x7fff) +char 0x0 ^ 0xffff == -0x1 (0xffff) +__uchar 0x0 ^ 0xff == 0xff (0xff) +__longlong 0x0 ^ 0x7fff == 0x7fff (0x7fff) +__ulonglong 0x0 ^ 0x7fff == 0x7fff (0x7fff) +int 0x0 && 0x7fff == 0x0 (0x0) +__uint 0x0 && 0x7fff == 0x0 (0x0) +char 0x0 && 0xffff == 0x0 (0x0) +__uchar 0x0 && 0xff == 0x0 (0x0) +__longlong 0x0 && 0x7fff == 0x0 (0x0) +__ulonglong 0x0 && 0x7fff == 0x0 (0x0) +int 0x0 || 0x7fff == 0x1 (0x1) +__uint 0x0 || 0x7fff == 0x1 (0x1) +char 0x0 || 0xffff == 0x1 (0x1) +__uchar 0x0 || 0xff == 0x1 (0x1) +__longlong 0x0 || 0x7fff == 0x1 (0x1) +__ulonglong 0x0 || 0x7fff == 0x1 (0x1) +int 0x0 & 0x7fff == 0x0 (0x0) +__uint 0x0 & 0x7fff == 0x0 (0x0) +char 0x0 & 0xffff == 0x0 (0x0) +__uchar 0x0 & 0xff == 0x0 (0x0) +__longlong 0x0 & 0x7fff == 0x0 (0x0) +__ulonglong 0x0 & 0x7fff == 0x0 (0x0) +int 0x0 | 0x7fff == 0x7fff (0x7fff) +__uint 0x0 | 0x7fff == 0x7fff (0x7fff) +char 0x0 | 0xffff == -0x1 (0xffff) +__uchar 0x0 | 0xff == 0xff (0xff) +__longlong 0x0 | 0x7fff == 0x7fff (0x7fff) +__ulonglong 0x0 | 0x7fff == 0x7fff (0x7fff) +int 0x0 << 0x10 == 0x0 (0x0) +__uint 0x0 << 0x10 == 0x0 (0x0) +char 0x0 << 0x10 == 0x0 (0x0) +__uchar 0x0 << 0x10 == 0x0 (0x0) +__longlong 0x0 << 0x10 == 0x0 (0x0) +__ulonglong 0x0 << 0x10 == 0x0 (0x0) +int 0x0 >> 0x10 == 0x0 (0x0) +__uint 0x0 >> 0x10 == 0x0 (0x0) +char 0x0 >> 0x10 == 0x0 (0x0) +__uchar 0x0 >> 0x10 == 0x0 (0x0) +__longlong 0x0 >> 0x10 == 0x0 (0x0) +__ulonglong 0x0 >> 0x10 == 0x0 (0x0) +int 0x0 + 0x7fff == 0x7fff (0x7fff) +__uint 0x0 + 0x7fff == 0x7fff (0x7fff) +char 0x0 + 0xffff == -0x1 (0xffff) +__uchar 0x0 + 0xff == 0xff (0xff) +__longlong 0x0 + 0x7fff == 0x7fff (0x7fff) +__ulonglong 0x0 + 0x7fff == 0x7fff (0x7fff) +float 0x0 + 0x7fff == 0x7fff (0x7fff) +int 0x0 - 0x7fff == -0x7fff (0x8001) +__uint 0x0 - 0x7fff == -0x7fff (0x8001) +char 0x0 - 0xffff == 0x1 (0x1) +__uchar 0x0 - 0xff == 0x1 (0x1) +__longlong 0x0 - 0x7fff == -0x7fff (0x8001) +__ulonglong 0x0 - 0x7fff == -0x7fff (0x8001) +float 0x0 - 0x7fff == -0x7fff (0x8001) +int 0x0 * 0x7fff == 0x0 (0x0) +__uint 0x0 * 0x7fff == 0x0 (0x0) +char 0x0 * 0xffff == 0x0 (0x0) +__uchar 0x0 * 0xff == 0x0 (0x0) +__longlong 0x0 * 0x7fff == 0x0 (0x0) +__ulonglong 0x0 * 0x7fff == 0x0 (0x0) +float 0x0 * 0x7fff == 0x0 (0x0) +int 0x0 < 0x7fff == 0x1 (0x1) +__uint 0x0 < 0x7fff == 0x1 (0x1) +char 0x0 < 0xffff == 0x0 (0x0) +__uchar 0x0 < 0xff == 0x1 (0x1) +__longlong 0x0 < 0x7fff == 0x1 (0x1) +__ulonglong 0x0 < 0x7fff == 0x1 (0x1) +float 0x0 < 0x7fff == 0x1 (0x1) +int 0x0 > 0x7fff == 0x0 (0x0) +__uint 0x0 > 0x7fff == 0x0 (0x0) +char 0x0 > 0xffff == 0x1 (0x1) +__uchar 0x0 > 0xff == 0x0 (0x0) +__longlong 0x0 > 0x7fff == 0x0 (0x0) +__ulonglong 0x0 > 0x7fff == 0x0 (0x0) +float 0x0 > 0x7fff == 0x0 (0x0) +int 0x0 <= 0x7fff == 0x1 (0x1) +__uint 0x0 <= 0x7fff == 0x1 (0x1) +char 0x0 <= 0xffff == 0x0 (0x0) +__uchar 0x0 <= 0xff == 0x1 (0x1) +__longlong 0x0 <= 0x7fff == 0x1 (0x1) +__ulonglong 0x0 <= 0x7fff == 0x1 (0x1) +float 0x0 <= 0x7fff == 0x1 (0x1) +int 0x0 == 0x7fff == 0x0 (0x0) +__uint 0x0 == 0x7fff == 0x0 (0x0) +char 0x0 == 0xffff == 0x0 (0x0) +__uchar 0x0 == 0xff == 0x0 (0x0) +__longlong 0x0 == 0x7fff == 0x0 (0x0) +__ulonglong 0x0 == 0x7fff == 0x0 (0x0) +float 0x0 == 0x7fff == 0x0 (0x0) +int 0x0 != 0x7fff == 0x1 (0x1) +__uint 0x0 != 0x7fff == 0x1 (0x1) +char 0x0 != 0xffff == 0x1 (0x1) +__uchar 0x0 != 0xff == 0x1 (0x1) +__longlong 0x0 != 0x7fff == 0x1 (0x1) +__ulonglong 0x0 != 0x7fff == 0x1 (0x1) +float 0x0 != 0x7fff == 0x1 (0x1) +int 0x0 >= 0x7fff == 0x0 (0x0) +__uint 0x0 >= 0x7fff == 0x0 (0x0) +char 0x0 >= 0xffff == 0x1 (0x1) +__uchar 0x0 >= 0xff == 0x0 (0x0) +__longlong 0x0 >= 0x7fff == 0x0 (0x0) +__ulonglong 0x0 >= 0x7fff == 0x0 (0x0) +float 0x0 >= 0x7fff == 0x0 (0x0) +int 0x0 / 0x7fff == 0x0 (0x0) +__uint 0x0 / 0x7fff == 0x0 (0x0) +char 0x0 / 0xffff == 0x0 (0x0) +__uchar 0x0 / 0xff == 0x0 (0x0) +__longlong 0x0 / 0x7fff == 0x0 (0x0) +__ulonglong 0x0 / 0x7fff == 0x0 (0x0) +float 0x0 / 0x7fff == 0x0 (0x0) +int 0x0 % 0x7fff == 0x0 (0x0) +__uint 0x0 % 0x7fff == 0x0 (0x0) +char 0x0 % 0xffff == 0x0 (0x0) +__uchar 0x0 % 0xff == 0x0 (0x0) +__longlong 0x0 % 0x7fff == 0x0 (0x0) +__ulonglong 0x0 % 0x7fff == 0x0 (0x0) +0x0 * 0x8000 == 0x0 +0x0 / 0x8000 == 0x0 +0x0 % 0x8000 == 0x0 +int 0x0 ^ 0x8000 == -0x8000 (0x8000) +__uint 0x0 ^ 0x8000 == -0x8000 (0x8000) +char 0x0 ^ 0x0 == 0x0 (0x0) +__uchar 0x0 ^ 0x0 == 0x0 (0x0) +__longlong 0x0 ^ 0x8000 == -0x8000 (0x8000) +__ulonglong 0x0 ^ 0x8000 == -0x8000 (0x8000) +int 0x0 && 0x8000 == 0x0 (0x0) +__uint 0x0 && 0x8000 == 0x0 (0x0) +char 0x0 && 0x0 == 0x0 (0x0) +__uchar 0x0 && 0x0 == 0x0 (0x0) +__longlong 0x0 && 0x8000 == 0x0 (0x0) +__ulonglong 0x0 && 0x8000 == 0x0 (0x0) +int 0x0 || 0x8000 == 0x1 (0x1) +__uint 0x0 || 0x8000 == 0x1 (0x1) +char 0x0 || 0x0 == 0x0 (0x0) +__uchar 0x0 || 0x0 == 0x0 (0x0) +__longlong 0x0 || 0x8000 == 0x1 (0x1) +__ulonglong 0x0 || 0x8000 == 0x1 (0x1) +int 0x0 & 0x8000 == 0x0 (0x0) +__uint 0x0 & 0x8000 == 0x0 (0x0) +char 0x0 & 0x0 == 0x0 (0x0) +__uchar 0x0 & 0x0 == 0x0 (0x0) +__longlong 0x0 & 0x8000 == 0x0 (0x0) +__ulonglong 0x0 & 0x8000 == 0x0 (0x0) +int 0x0 | 0x8000 == -0x8000 (0x8000) +__uint 0x0 | 0x8000 == -0x8000 (0x8000) +char 0x0 | 0x0 == 0x0 (0x0) +__uchar 0x0 | 0x0 == 0x0 (0x0) +__longlong 0x0 | 0x8000 == -0x8000 (0x8000) +__ulonglong 0x0 | 0x8000 == -0x8000 (0x8000) +int 0x0 << 0x12 == 0x0 (0x0) +__uint 0x0 << 0x12 == 0x0 (0x0) +char 0x0 << 0x12 == 0x0 (0x0) +__uchar 0x0 << 0x12 == 0x0 (0x0) +__longlong 0x0 << 0x12 == 0x0 (0x0) +__ulonglong 0x0 << 0x12 == 0x0 (0x0) +int 0x0 >> 0x12 == 0x0 (0x0) +__uint 0x0 >> 0x12 == 0x0 (0x0) +char 0x0 >> 0x12 == 0x0 (0x0) +__uchar 0x0 >> 0x12 == 0x0 (0x0) +__longlong 0x0 >> 0x12 == 0x0 (0x0) +__ulonglong 0x0 >> 0x12 == 0x0 (0x0) +int 0x0 + 0x8000 == -0x8000 (0x8000) +__uint 0x0 + 0x8000 == -0x8000 (0x8000) +char 0x0 + 0x0 == 0x0 (0x0) +__uchar 0x0 + 0x0 == 0x0 (0x0) +__longlong 0x0 + 0x8000 == -0x8000 (0x8000) +__ulonglong 0x0 + 0x8000 == -0x8000 (0x8000) +float 0x0 + 0x8000 == -0x8000 (0x8000) +int 0x0 - 0x8000 == -0x8000 (0x8000) +__uint 0x0 - 0x8000 == -0x8000 (0x8000) +char 0x0 - 0x0 == 0x0 (0x0) +__uchar 0x0 - 0x0 == 0x0 (0x0) +__longlong 0x0 - 0x8000 == -0x8000 (0x8000) +__ulonglong 0x0 - 0x8000 == -0x8000 (0x8000) +float 0x0 - 0x8000 == -0x8000 (0x8000) +int 0x0 * 0x8000 == 0x0 (0x0) +__uint 0x0 * 0x8000 == 0x0 (0x0) +char 0x0 * 0x0 == 0x0 (0x0) +__uchar 0x0 * 0x0 == 0x0 (0x0) +__longlong 0x0 * 0x8000 == 0x0 (0x0) +__ulonglong 0x0 * 0x8000 == 0x0 (0x0) +float 0x0 * 0x8000 == 0x0 (0x0) +int 0x0 < 0x8000 == 0x0 (0x0) +__uint 0x0 < 0x8000 == 0x1 (0x1) +char 0x0 < 0x0 == 0x0 (0x0) +__uchar 0x0 < 0x0 == 0x0 (0x0) +__longlong 0x0 < 0x8000 == 0x0 (0x0) +__ulonglong 0x0 < 0x8000 == 0x1 (0x1) +float 0x0 < 0x8000 == 0x0 (0x0) +int 0x0 > 0x8000 == 0x1 (0x1) +__uint 0x0 > 0x8000 == 0x0 (0x0) +char 0x0 > 0x0 == 0x0 (0x0) +__uchar 0x0 > 0x0 == 0x0 (0x0) +__longlong 0x0 > 0x8000 == 0x1 (0x1) +__ulonglong 0x0 > 0x8000 == 0x0 (0x0) +float 0x0 > 0x8000 == 0x1 (0x1) +int 0x0 <= 0x8000 == 0x0 (0x0) +__uint 0x0 <= 0x8000 == 0x1 (0x1) +char 0x0 <= 0x0 == 0x1 (0x1) +__uchar 0x0 <= 0x0 == 0x1 (0x1) +__longlong 0x0 <= 0x8000 == 0x0 (0x0) +__ulonglong 0x0 <= 0x8000 == 0x1 (0x1) +float 0x0 <= 0x8000 == 0x0 (0x0) +int 0x0 == 0x8000 == 0x0 (0x0) +__uint 0x0 == 0x8000 == 0x0 (0x0) +char 0x0 == 0x0 == 0x1 (0x1) +__uchar 0x0 == 0x0 == 0x1 (0x1) +__longlong 0x0 == 0x8000 == 0x0 (0x0) +__ulonglong 0x0 == 0x8000 == 0x0 (0x0) +float 0x0 == 0x8000 == 0x0 (0x0) +int 0x0 != 0x8000 == 0x1 (0x1) +__uint 0x0 != 0x8000 == 0x1 (0x1) +char 0x0 != 0x0 == 0x0 (0x0) +__uchar 0x0 != 0x0 == 0x0 (0x0) +__longlong 0x0 != 0x8000 == 0x1 (0x1) +__ulonglong 0x0 != 0x8000 == 0x1 (0x1) +float 0x0 != 0x8000 == 0x1 (0x1) +int 0x0 >= 0x8000 == 0x1 (0x1) +__uint 0x0 >= 0x8000 == 0x0 (0x0) +char 0x0 >= 0x0 == 0x1 (0x1) +__uchar 0x0 >= 0x0 == 0x1 (0x1) +__longlong 0x0 >= 0x8000 == 0x1 (0x1) +__ulonglong 0x0 >= 0x8000 == 0x0 (0x0) +float 0x0 >= 0x8000 == 0x1 (0x1) +int 0x0 / 0x8000 == 0x0 (0x0) +__uint 0x0 / 0x8000 == 0x0 (0x0) +__longlong 0x0 / 0x8000 == 0x0 (0x0) +__ulonglong 0x0 / 0x8000 == 0x0 (0x0) +float 0x0 / 0x8000 == 0x0 (0x0) +int 0x0 % 0x8000 == 0x0 (0x0) +__uint 0x0 % 0x8000 == 0x0 (0x0) +__longlong 0x0 % 0x8000 == 0x0 (0x0) +__ulonglong 0x0 % 0x8000 == 0x0 (0x0) +0x0 * 0x3e8 == 0x0 +0x0 / 0x3e8 == 0x0 +0x0 % 0x3e8 == 0x0 +int 0x0 ^ 0x3e8 == 0x3e8 (0x3e8) +__uint 0x0 ^ 0x3e8 == 0x3e8 (0x3e8) +char 0x0 ^ 0xffe8 == -0x18 (0xffe8) +__uchar 0x0 ^ 0xe8 == 0xe8 (0xe8) +__longlong 0x0 ^ 0x3e8 == 0x3e8 (0x3e8) +__ulonglong 0x0 ^ 0x3e8 == 0x3e8 (0x3e8) +int 0x0 && 0x3e8 == 0x0 (0x0) +__uint 0x0 && 0x3e8 == 0x0 (0x0) +char 0x0 && 0xffe8 == 0x0 (0x0) +__uchar 0x0 && 0xe8 == 0x0 (0x0) +__longlong 0x0 && 0x3e8 == 0x0 (0x0) +__ulonglong 0x0 && 0x3e8 == 0x0 (0x0) +int 0x0 || 0x3e8 == 0x1 (0x1) +__uint 0x0 || 0x3e8 == 0x1 (0x1) +char 0x0 || 0xffe8 == 0x1 (0x1) +__uchar 0x0 || 0xe8 == 0x1 (0x1) +__longlong 0x0 || 0x3e8 == 0x1 (0x1) +__ulonglong 0x0 || 0x3e8 == 0x1 (0x1) +int 0x0 & 0x3e8 == 0x0 (0x0) +__uint 0x0 & 0x3e8 == 0x0 (0x0) +char 0x0 & 0xffe8 == 0x0 (0x0) +__uchar 0x0 & 0xe8 == 0x0 (0x0) +__longlong 0x0 & 0x3e8 == 0x0 (0x0) +__ulonglong 0x0 & 0x3e8 == 0x0 (0x0) +int 0x0 | 0x3e8 == 0x3e8 (0x3e8) +__uint 0x0 | 0x3e8 == 0x3e8 (0x3e8) +char 0x0 | 0xffe8 == -0x18 (0xffe8) +__uchar 0x0 | 0xe8 == 0xe8 (0xe8) +__longlong 0x0 | 0x3e8 == 0x3e8 (0x3e8) +__ulonglong 0x0 | 0x3e8 == 0x3e8 (0x3e8) +int 0x0 << 0x14 == 0x0 (0x0) +__uint 0x0 << 0x14 == 0x0 (0x0) +char 0x0 << 0x14 == 0x0 (0x0) +__uchar 0x0 << 0x14 == 0x0 (0x0) +__longlong 0x0 << 0x14 == 0x0 (0x0) +__ulonglong 0x0 << 0x14 == 0x0 (0x0) +int 0x0 >> 0x14 == 0x0 (0x0) +__uint 0x0 >> 0x14 == 0x0 (0x0) +char 0x0 >> 0x14 == 0x0 (0x0) +__uchar 0x0 >> 0x14 == 0x0 (0x0) +__longlong 0x0 >> 0x14 == 0x0 (0x0) +__ulonglong 0x0 >> 0x14 == 0x0 (0x0) +int 0x0 + 0x3e8 == 0x3e8 (0x3e8) +__uint 0x0 + 0x3e8 == 0x3e8 (0x3e8) +char 0x0 + 0xffe8 == -0x18 (0xffe8) +__uchar 0x0 + 0xe8 == 0xe8 (0xe8) +__longlong 0x0 + 0x3e8 == 0x3e8 (0x3e8) +__ulonglong 0x0 + 0x3e8 == 0x3e8 (0x3e8) +float 0x0 + 0x3e8 == 0x3e8 (0x3e8) +int 0x0 - 0x3e8 == -0x3e8 (0xfc18) +__uint 0x0 - 0x3e8 == -0x3e8 (0xfc18) +char 0x0 - 0xffe8 == 0x18 (0x18) +__uchar 0x0 - 0xe8 == 0x18 (0x18) +__longlong 0x0 - 0x3e8 == -0x3e8 (0xfc18) +__ulonglong 0x0 - 0x3e8 == -0x3e8 (0xfc18) +float 0x0 - 0x3e8 == -0x3e8 (0xfc18) +int 0x0 * 0x3e8 == 0x0 (0x0) +__uint 0x0 * 0x3e8 == 0x0 (0x0) +char 0x0 * 0xffe8 == 0x0 (0x0) +__uchar 0x0 * 0xe8 == 0x0 (0x0) +__longlong 0x0 * 0x3e8 == 0x0 (0x0) +__ulonglong 0x0 * 0x3e8 == 0x0 (0x0) +float 0x0 * 0x3e8 == 0x0 (0x0) +int 0x0 < 0x3e8 == 0x1 (0x1) +__uint 0x0 < 0x3e8 == 0x1 (0x1) +char 0x0 < 0xffe8 == 0x0 (0x0) +__uchar 0x0 < 0xe8 == 0x1 (0x1) +__longlong 0x0 < 0x3e8 == 0x1 (0x1) +__ulonglong 0x0 < 0x3e8 == 0x1 (0x1) +float 0x0 < 0x3e8 == 0x1 (0x1) +int 0x0 > 0x3e8 == 0x0 (0x0) +__uint 0x0 > 0x3e8 == 0x0 (0x0) +char 0x0 > 0xffe8 == 0x1 (0x1) +__uchar 0x0 > 0xe8 == 0x0 (0x0) +__longlong 0x0 > 0x3e8 == 0x0 (0x0) +__ulonglong 0x0 > 0x3e8 == 0x0 (0x0) +float 0x0 > 0x3e8 == 0x0 (0x0) +int 0x0 <= 0x3e8 == 0x1 (0x1) +__uint 0x0 <= 0x3e8 == 0x1 (0x1) +char 0x0 <= 0xffe8 == 0x0 (0x0) +__uchar 0x0 <= 0xe8 == 0x1 (0x1) +__longlong 0x0 <= 0x3e8 == 0x1 (0x1) +__ulonglong 0x0 <= 0x3e8 == 0x1 (0x1) +float 0x0 <= 0x3e8 == 0x1 (0x1) +int 0x0 == 0x3e8 == 0x0 (0x0) +__uint 0x0 == 0x3e8 == 0x0 (0x0) +char 0x0 == 0xffe8 == 0x0 (0x0) +__uchar 0x0 == 0xe8 == 0x0 (0x0) +__longlong 0x0 == 0x3e8 == 0x0 (0x0) +__ulonglong 0x0 == 0x3e8 == 0x0 (0x0) +float 0x0 == 0x3e8 == 0x0 (0x0) +int 0x0 != 0x3e8 == 0x1 (0x1) +__uint 0x0 != 0x3e8 == 0x1 (0x1) +char 0x0 != 0xffe8 == 0x1 (0x1) +__uchar 0x0 != 0xe8 == 0x1 (0x1) +__longlong 0x0 != 0x3e8 == 0x1 (0x1) +__ulonglong 0x0 != 0x3e8 == 0x1 (0x1) +float 0x0 != 0x3e8 == 0x1 (0x1) +int 0x0 >= 0x3e8 == 0x0 (0x0) +__uint 0x0 >= 0x3e8 == 0x0 (0x0) +char 0x0 >= 0xffe8 == 0x1 (0x1) +__uchar 0x0 >= 0xe8 == 0x0 (0x0) +__longlong 0x0 >= 0x3e8 == 0x0 (0x0) +__ulonglong 0x0 >= 0x3e8 == 0x0 (0x0) +float 0x0 >= 0x3e8 == 0x0 (0x0) +int 0x0 / 0x3e8 == 0x0 (0x0) +__uint 0x0 / 0x3e8 == 0x0 (0x0) +char 0x0 / 0xffe8 == 0x0 (0x0) +__uchar 0x0 / 0xe8 == 0x0 (0x0) +__longlong 0x0 / 0x3e8 == 0x0 (0x0) +__ulonglong 0x0 / 0x3e8 == 0x0 (0x0) +float 0x0 / 0x3e8 == 0x0 (0x0) +int 0x0 % 0x3e8 == 0x0 (0x0) +__uint 0x0 % 0x3e8 == 0x0 (0x0) +char 0x0 % 0xffe8 == 0x0 (0x0) +__uchar 0x0 % 0xe8 == 0x0 (0x0) +__longlong 0x0 % 0x3e8 == 0x0 (0x0) +__ulonglong 0x0 % 0x3e8 == 0x0 (0x0) +0x0 * 0x2710 == 0x0 +0x0 / 0x2710 == 0x0 +0x0 % 0x2710 == 0x0 +int 0x0 ^ 0x2710 == 0x2710 (0x2710) +__uint 0x0 ^ 0x2710 == 0x2710 (0x2710) +char 0x0 ^ 0x10 == 0x10 (0x10) +__uchar 0x0 ^ 0x10 == 0x10 (0x10) +__longlong 0x0 ^ 0x2710 == 0x2710 (0x2710) +__ulonglong 0x0 ^ 0x2710 == 0x2710 (0x2710) +int 0x0 && 0x2710 == 0x0 (0x0) +__uint 0x0 && 0x2710 == 0x0 (0x0) +char 0x0 && 0x10 == 0x0 (0x0) +__uchar 0x0 && 0x10 == 0x0 (0x0) +__longlong 0x0 && 0x2710 == 0x0 (0x0) +__ulonglong 0x0 && 0x2710 == 0x0 (0x0) +int 0x0 || 0x2710 == 0x1 (0x1) +__uint 0x0 || 0x2710 == 0x1 (0x1) +char 0x0 || 0x10 == 0x1 (0x1) +__uchar 0x0 || 0x10 == 0x1 (0x1) +__longlong 0x0 || 0x2710 == 0x1 (0x1) +__ulonglong 0x0 || 0x2710 == 0x1 (0x1) +int 0x0 & 0x2710 == 0x0 (0x0) +__uint 0x0 & 0x2710 == 0x0 (0x0) +char 0x0 & 0x10 == 0x0 (0x0) +__uchar 0x0 & 0x10 == 0x0 (0x0) +__longlong 0x0 & 0x2710 == 0x0 (0x0) +__ulonglong 0x0 & 0x2710 == 0x0 (0x0) +int 0x0 | 0x2710 == 0x2710 (0x2710) +__uint 0x0 | 0x2710 == 0x2710 (0x2710) +char 0x0 | 0x10 == 0x10 (0x10) +__uchar 0x0 | 0x10 == 0x10 (0x10) +__longlong 0x0 | 0x2710 == 0x2710 (0x2710) +__ulonglong 0x0 | 0x2710 == 0x2710 (0x2710) +int 0x0 << 0x16 == 0x0 (0x0) +__uint 0x0 << 0x16 == 0x0 (0x0) +char 0x0 << 0x16 == 0x0 (0x0) +__uchar 0x0 << 0x16 == 0x0 (0x0) +__longlong 0x0 << 0x16 == 0x0 (0x0) +__ulonglong 0x0 << 0x16 == 0x0 (0x0) +int 0x0 >> 0x16 == 0x0 (0x0) +__uint 0x0 >> 0x16 == 0x0 (0x0) +char 0x0 >> 0x16 == 0x0 (0x0) +__uchar 0x0 >> 0x16 == 0x0 (0x0) +__longlong 0x0 >> 0x16 == 0x0 (0x0) +__ulonglong 0x0 >> 0x16 == 0x0 (0x0) +int 0x0 + 0x2710 == 0x2710 (0x2710) +__uint 0x0 + 0x2710 == 0x2710 (0x2710) +char 0x0 + 0x10 == 0x10 (0x10) +__uchar 0x0 + 0x10 == 0x10 (0x10) +__longlong 0x0 + 0x2710 == 0x2710 (0x2710) +__ulonglong 0x0 + 0x2710 == 0x2710 (0x2710) +float 0x0 + 0x2710 == 0x2710 (0x2710) +int 0x0 - 0x2710 == -0x2710 (0xd8f0) +__uint 0x0 - 0x2710 == -0x2710 (0xd8f0) +char 0x0 - 0x10 == -0x10 (0xfff0) +__uchar 0x0 - 0x10 == 0xf0 (0xf0) +__longlong 0x0 - 0x2710 == -0x2710 (0xd8f0) +__ulonglong 0x0 - 0x2710 == -0x2710 (0xd8f0) +float 0x0 - 0x2710 == -0x2710 (0xd8f0) +int 0x0 * 0x2710 == 0x0 (0x0) +__uint 0x0 * 0x2710 == 0x0 (0x0) +char 0x0 * 0x10 == 0x0 (0x0) +__uchar 0x0 * 0x10 == 0x0 (0x0) +__longlong 0x0 * 0x2710 == 0x0 (0x0) +__ulonglong 0x0 * 0x2710 == 0x0 (0x0) +float 0x0 * 0x2710 == 0x0 (0x0) +int 0x0 < 0x2710 == 0x1 (0x1) +__uint 0x0 < 0x2710 == 0x1 (0x1) +char 0x0 < 0x10 == 0x1 (0x1) +__uchar 0x0 < 0x10 == 0x1 (0x1) +__longlong 0x0 < 0x2710 == 0x1 (0x1) +__ulonglong 0x0 < 0x2710 == 0x1 (0x1) +float 0x0 < 0x2710 == 0x1 (0x1) +int 0x0 > 0x2710 == 0x0 (0x0) +__uint 0x0 > 0x2710 == 0x0 (0x0) +char 0x0 > 0x10 == 0x0 (0x0) +__uchar 0x0 > 0x10 == 0x0 (0x0) +__longlong 0x0 > 0x2710 == 0x0 (0x0) +__ulonglong 0x0 > 0x2710 == 0x0 (0x0) +float 0x0 > 0x2710 == 0x0 (0x0) +int 0x0 <= 0x2710 == 0x1 (0x1) +__uint 0x0 <= 0x2710 == 0x1 (0x1) +char 0x0 <= 0x10 == 0x1 (0x1) +__uchar 0x0 <= 0x10 == 0x1 (0x1) +__longlong 0x0 <= 0x2710 == 0x1 (0x1) +__ulonglong 0x0 <= 0x2710 == 0x1 (0x1) +float 0x0 <= 0x2710 == 0x1 (0x1) +int 0x0 == 0x2710 == 0x0 (0x0) +__uint 0x0 == 0x2710 == 0x0 (0x0) +char 0x0 == 0x10 == 0x0 (0x0) +__uchar 0x0 == 0x10 == 0x0 (0x0) +__longlong 0x0 == 0x2710 == 0x0 (0x0) +__ulonglong 0x0 == 0x2710 == 0x0 (0x0) +float 0x0 == 0x2710 == 0x0 (0x0) +int 0x0 != 0x2710 == 0x1 (0x1) +__uint 0x0 != 0x2710 == 0x1 (0x1) +char 0x0 != 0x10 == 0x1 (0x1) +__uchar 0x0 != 0x10 == 0x1 (0x1) +__longlong 0x0 != 0x2710 == 0x1 (0x1) +__ulonglong 0x0 != 0x2710 == 0x1 (0x1) +float 0x0 != 0x2710 == 0x1 (0x1) +int 0x0 >= 0x2710 == 0x0 (0x0) +__uint 0x0 >= 0x2710 == 0x0 (0x0) +char 0x0 >= 0x10 == 0x0 (0x0) +__uchar 0x0 >= 0x10 == 0x0 (0x0) +__longlong 0x0 >= 0x2710 == 0x0 (0x0) +__ulonglong 0x0 >= 0x2710 == 0x0 (0x0) +float 0x0 >= 0x2710 == 0x0 (0x0) +int 0x0 / 0x2710 == 0x0 (0x0) +__uint 0x0 / 0x2710 == 0x0 (0x0) +char 0x0 / 0x10 == 0x0 (0x0) +__uchar 0x0 / 0x10 == 0x0 (0x0) +__longlong 0x0 / 0x2710 == 0x0 (0x0) +__ulonglong 0x0 / 0x2710 == 0x0 (0x0) +float 0x0 / 0x2710 == 0x0 (0x0) +int 0x0 % 0x2710 == 0x0 (0x0) +__uint 0x0 % 0x2710 == 0x0 (0x0) +char 0x0 % 0x10 == 0x0 (0x0) +__uchar 0x0 % 0x10 == 0x0 (0x0) +__longlong 0x0 % 0x2710 == 0x0 (0x0) +__ulonglong 0x0 % 0x2710 == 0x0 (0x0) +int xor420x0 xor42 0x2a +__uint xor420x0 xor42 0x2a +char xor420x0 xor42 0x2a +__uchar xor420x0 xor42 0x2a +__longlong xor420x0 xor42 0x2a +__ulonglong xor420x0 xor42 0x2a +int land10x0 land1 0x0 +__uint land10x0 land1 0x0 +char land10x0 land1 0x0 +__uchar land10x0 land1 0x0 +__longlong land10x0 land1 0x0 +__ulonglong land10x0 land1 0x0 +int lor10x0 lor1 0x1 +__uint lor10x0 lor1 0x1 +char lor10x0 lor1 0x1 +__uchar lor10x0 lor1 0x1 +__longlong lor10x0 lor1 0x1 +__ulonglong lor10x0 lor1 0x1 +int and420x0 and42 0x0 +__uint and420x0 and42 0x0 +char and420x0 and42 0x0 +__uchar and420x0 and42 0x0 +__longlong and420x0 and42 0x0 +__ulonglong and420x0 and42 0x0 +int or420x0 or42 0x2a +__uint or420x0 or42 0x2a +char or420x0 or42 0x2a +__uchar or420x0 or42 0x2a +__longlong or420x0 or42 0x2a +__ulonglong or420x0 or42 0x2a +int shl50x0 shl5 0x0 +__uint shl50x0 shl5 0x0 +char shl50x0 shl5 0x0 +__uchar shl50x0 shl5 0x0 +__longlong shl50x0 shl5 0x0 +__ulonglong shl50x0 shl5 0x0 +int shr50x0 shr5 0x0 +__uint shr50x0 shr5 0x0 +char shr50x0 shr5 0x0 +__uchar shr50x0 shr5 0x0 +__longlong shr50x0 shr5 0x0 +__ulonglong shr50x0 shr5 0x0 +int add420x0 add42 0x2a +__uint add420x0 add42 0x2a +char add420x0 add42 0x2a +__uchar add420x0 add42 0x2a +__longlong add420x0 add42 0x2a +__ulonglong add420x0 add42 0x2a +float add420x0 add42 0x2a +int sub420x0 sub42 -0x2a +__uint sub420x0 sub42 -0x2a +char sub420x0 sub42 -0x2a +__uchar sub420x0 sub42 0xd6 +__longlong sub420x0 sub42 -0x2a +__ulonglong sub420x0 sub42 -0x2a +float sub420x0 sub42 -0x2a +int mul420x0 mul42 0x0 +__uint mul420x0 mul42 0x0 +char mul420x0 mul42 0x0 +__uchar mul420x0 mul42 0x0 +__longlong mul420x0 mul42 0x0 +__ulonglong mul420x0 mul42 0x0 +float mul420x0 mul42 0x0 +int lt420x0 lt42 0x1 +__uint lt420x0 lt42 0x1 +char lt420x0 lt42 0x1 +__uchar lt420x0 lt42 0x1 +__longlong lt420x0 lt42 0x1 +__ulonglong lt420x0 lt42 0x1 +float lt420x0 lt42 0x1 +int gt420x0 gt42 0x0 +__uint gt420x0 gt42 0x0 +char gt420x0 gt42 0x0 +__uchar gt420x0 gt42 0x0 +__longlong gt420x0 gt42 0x0 +__ulonglong gt420x0 gt42 0x0 +float gt420x0 gt42 0x0 +int le420x0 le42 0x1 +__uint le420x0 le42 0x1 +char le420x0 le42 0x1 +__uchar le420x0 le42 0x1 +__longlong le420x0 le42 0x1 +__ulonglong le420x0 le42 0x1 +float le420x0 le42 0x1 +int eq420x0 eq42 0x0 +__uint eq420x0 eq42 0x0 +char eq420x0 eq42 0x0 +__uchar eq420x0 eq42 0x0 +__longlong eq420x0 eq42 0x0 +__ulonglong eq420x0 eq42 0x0 +float eq420x0 eq42 0x0 +int ne420x0 ne42 0x1 +__uint ne420x0 ne42 0x1 +char ne420x0 ne42 0x1 +__uchar ne420x0 ne42 0x1 +__longlong ne420x0 ne42 0x1 +__ulonglong ne420x0 ne42 0x1 +float ne420x0 ne42 0x1 +int ge420x0 ge42 0x0 +__uint ge420x0 ge42 0x0 +char ge420x0 ge42 0x0 +__uchar ge420x0 ge42 0x0 +__longlong ge420x0 ge42 0x0 +__ulonglong ge420x0 ge42 0x0 +float ge420x0 ge42 0x0 +int div420x0 div42 0x0 +__uint div420x0 div42 0x0 +char div420x0 div42 0x0 +__uchar div420x0 div42 0x0 +__longlong div420x0 div42 0x0 +__ulonglong div420x0 div42 0x0 +float div420x0 div42 0x0 +int mod230x0 mod23 0x0 +__uint mod230x0 mod23 0x0 +char mod230x0 mod23 0x0 +__uchar mod230x0 mod23 0x0 +__longlong mod230x0 mod23 0x0 +__ulonglong mod230x0 mod23 0x0 +0xffff * 0xffff == 0x1 +0xffff / 0xffff == 0x1 +0xffff % 0xffff == 0x0 +int 0xffff ^ 0xffff == 0x0 (0x0) +__uint 0xffff ^ 0xffff == 0x0 (0x0) +char 0xffff ^ 0xffff == 0x0 (0x0) +__uchar 0xff ^ 0xff == 0x0 (0x0) +__longlong 0xffff ^ 0xffff == 0x0 (0x0) +__ulonglong 0xffff ^ 0xffff == 0x0 (0x0) +int 0xffff && 0xffff == 0x1 (0x1) +__uint 0xffff && 0xffff == 0x1 (0x1) +char 0xffff && 0xffff == 0x1 (0x1) +__uchar 0xff && 0xff == 0x1 (0x1) +__longlong 0xffff && 0xffff == 0x1 (0x1) +__ulonglong 0xffff && 0xffff == 0x1 (0x1) +int 0xffff || 0xffff == 0x1 (0x1) +__uint 0xffff || 0xffff == 0x1 (0x1) +char 0xffff || 0xffff == 0x1 (0x1) +__uchar 0xff || 0xff == 0x1 (0x1) +__longlong 0xffff || 0xffff == 0x1 (0x1) +__ulonglong 0xffff || 0xffff == 0x1 (0x1) +int 0xffff & 0xffff == -0x1 (0xffff) +__uint 0xffff & 0xffff == -0x1 (0xffff) +char 0xffff & 0xffff == -0x1 (0xffff) +__uchar 0xff & 0xff == 0xff (0xff) +__longlong 0xffff & 0xffff == -0x1 (0xffff) +__ulonglong 0xffff & 0xffff == -0x1 (0xffff) +int 0xffff | 0xffff == -0x1 (0xffff) +__uint 0xffff | 0xffff == -0x1 (0xffff) +char 0xffff | 0xffff == -0x1 (0xffff) +__uchar 0xff | 0xff == 0xff (0xff) +__longlong 0xffff | 0xffff == -0x1 (0xffff) +__ulonglong 0xffff | 0xffff == -0x1 (0xffff) +int 0xffff << 0x1 == -0x2 (0xfffe) +__uint 0xffff << 0x1 == -0x2 (0xfffe) +char 0xffff << 0x1 == -0x2 (0xfffe) +__uchar 0xff << 0x1 == 0xfe (0xfe) +__longlong 0xffff << 0x1 == -0x2 (0xfffe) +__ulonglong 0xffff << 0x1 == -0x2 (0xfffe) +int 0xffff >> 0x1 == -0x1 (0xffff) +__uint 0xffff >> 0x1 == 0x7fff (0x7fff) +char 0xffff >> 0x1 == -0x1 (0xffff) +__uchar 0xff >> 0x1 == 0x7f (0x7f) +__longlong 0xffff >> 0x1 == -0x1 (0xffff) +__ulonglong 0xffff >> 0x1 == -0x1 (0xffff) +int 0xffff + 0xffff == -0x2 (0xfffe) +__uint 0xffff + 0xffff == -0x2 (0xfffe) +char 0xffff + 0xffff == -0x2 (0xfffe) +__uchar 0xff + 0xff == 0xfe (0xfe) +__longlong 0xffff + 0xffff == -0x2 (0xfffe) +__ulonglong 0xffff + 0xffff == -0x2 (0xfffe) +float 0xffff + 0xffff == -0x2 (0xfffe) +int 0xffff - 0xffff == 0x0 (0x0) +__uint 0xffff - 0xffff == 0x0 (0x0) +char 0xffff - 0xffff == 0x0 (0x0) +__uchar 0xff - 0xff == 0x0 (0x0) +__longlong 0xffff - 0xffff == 0x0 (0x0) +__ulonglong 0xffff - 0xffff == 0x0 (0x0) +float 0xffff - 0xffff == 0x0 (0x0) +int 0xffff * 0xffff == 0x1 (0x1) +__uint 0xffff * 0xffff == 0x1 (0x1) +char 0xffff * 0xffff == 0x1 (0x1) +__uchar 0xff * 0xff == 0x1 (0x1) +__longlong 0xffff * 0xffff == 0x1 (0x1) +__ulonglong 0xffff * 0xffff == 0x1 (0x1) +float 0xffff * 0xffff == 0x1 (0x1) +int 0xffff < 0xffff == 0x0 (0x0) +__uint 0xffff < 0xffff == 0x0 (0x0) +char 0xffff < 0xffff == 0x0 (0x0) +__uchar 0xff < 0xff == 0x0 (0x0) +__longlong 0xffff < 0xffff == 0x0 (0x0) +__ulonglong 0xffff < 0xffff == 0x0 (0x0) +float 0xffff < 0xffff == 0x0 (0x0) +int 0xffff > 0xffff == 0x0 (0x0) +__uint 0xffff > 0xffff == 0x0 (0x0) +char 0xffff > 0xffff == 0x0 (0x0) +__uchar 0xff > 0xff == 0x0 (0x0) +__longlong 0xffff > 0xffff == 0x0 (0x0) +__ulonglong 0xffff > 0xffff == 0x0 (0x0) +float 0xffff > 0xffff == 0x0 (0x0) +int 0xffff <= 0xffff == 0x1 (0x1) +__uint 0xffff <= 0xffff == 0x1 (0x1) +char 0xffff <= 0xffff == 0x1 (0x1) +__uchar 0xff <= 0xff == 0x1 (0x1) +__longlong 0xffff <= 0xffff == 0x1 (0x1) +__ulonglong 0xffff <= 0xffff == 0x1 (0x1) +float 0xffff <= 0xffff == 0x1 (0x1) +int 0xffff == 0xffff == 0x1 (0x1) +__uint 0xffff == 0xffff == 0x1 (0x1) +char 0xffff == 0xffff == 0x1 (0x1) +__uchar 0xff == 0xff == 0x1 (0x1) +__longlong 0xffff == 0xffff == 0x1 (0x1) +__ulonglong 0xffff == 0xffff == 0x1 (0x1) +float 0xffff == 0xffff == 0x1 (0x1) +int 0xffff != 0xffff == 0x0 (0x0) +__uint 0xffff != 0xffff == 0x0 (0x0) +char 0xffff != 0xffff == 0x0 (0x0) +__uchar 0xff != 0xff == 0x0 (0x0) +__longlong 0xffff != 0xffff == 0x0 (0x0) +__ulonglong 0xffff != 0xffff == 0x0 (0x0) +float 0xffff != 0xffff == 0x0 (0x0) +int 0xffff >= 0xffff == 0x1 (0x1) +__uint 0xffff >= 0xffff == 0x1 (0x1) +char 0xffff >= 0xffff == 0x1 (0x1) +__uchar 0xff >= 0xff == 0x1 (0x1) +__longlong 0xffff >= 0xffff == 0x1 (0x1) +__ulonglong 0xffff >= 0xffff == 0x1 (0x1) +float 0xffff >= 0xffff == 0x1 (0x1) +int 0xffff / 0xffff == 0x1 (0x1) +__uint 0xffff / 0xffff == 0x1 (0x1) +char 0xffff / 0xffff == 0x1 (0x1) +__uchar 0xff / 0xff == 0x1 (0x1) +__longlong 0xffff / 0xffff == 0x1 (0x1) +__ulonglong 0xffff / 0xffff == 0x1 (0x1) +float 0xffff / 0xffff == 0x1 (0x1) +int 0xffff % 0xffff == 0x0 (0x0) +__uint 0xffff % 0xffff == 0x0 (0x0) +char 0xffff % 0xffff == 0x0 (0x0) +__uchar 0xff % 0xff == 0x0 (0x0) +__longlong 0xffff % 0xffff == 0x0 (0x0) +__ulonglong 0xffff % 0xffff == 0x0 (0x0) +0xffff * 0x1 == -0x1 +0xffff / 0x1 == -0x1 +0xffff % 0x1 == 0x0 +int 0xffff ^ 0x1 == -0x2 (0xfffe) +__uint 0xffff ^ 0x1 == -0x2 (0xfffe) +char 0xffff ^ 0x1 == -0x2 (0xfffe) +__uchar 0xff ^ 0x1 == 0xfe (0xfe) +__longlong 0xffff ^ 0x1 == -0x2 (0xfffe) +__ulonglong 0xffff ^ 0x1 == -0x2 (0xfffe) +int 0xffff && 0x1 == 0x1 (0x1) +__uint 0xffff && 0x1 == 0x1 (0x1) +char 0xffff && 0x1 == 0x1 (0x1) +__uchar 0xff && 0x1 == 0x1 (0x1) +__longlong 0xffff && 0x1 == 0x1 (0x1) +__ulonglong 0xffff && 0x1 == 0x1 (0x1) +int 0xffff || 0x1 == 0x1 (0x1) +__uint 0xffff || 0x1 == 0x1 (0x1) +char 0xffff || 0x1 == 0x1 (0x1) +__uchar 0xff || 0x1 == 0x1 (0x1) +__longlong 0xffff || 0x1 == 0x1 (0x1) +__ulonglong 0xffff || 0x1 == 0x1 (0x1) +int 0xffff & 0x1 == 0x1 (0x1) +__uint 0xffff & 0x1 == 0x1 (0x1) +char 0xffff & 0x1 == 0x1 (0x1) +__uchar 0xff & 0x1 == 0x1 (0x1) +__longlong 0xffff & 0x1 == 0x1 (0x1) +__ulonglong 0xffff & 0x1 == 0x1 (0x1) +int 0xffff | 0x1 == -0x1 (0xffff) +__uint 0xffff | 0x1 == -0x1 (0xffff) +char 0xffff | 0x1 == -0x1 (0xffff) +__uchar 0xff | 0x1 == 0xff (0xff) +__longlong 0xffff | 0x1 == -0x1 (0xffff) +__ulonglong 0xffff | 0x1 == -0x1 (0xffff) +int 0xffff << 0x2 == -0x4 (0xfffc) +__uint 0xffff << 0x2 == -0x4 (0xfffc) +char 0xffff << 0x2 == -0x4 (0xfffc) +__uchar 0xff << 0x2 == 0xfc (0xfc) +__longlong 0xffff << 0x2 == -0x4 (0xfffc) +__ulonglong 0xffff << 0x2 == -0x4 (0xfffc) +int 0xffff >> 0x2 == -0x1 (0xffff) +__uint 0xffff >> 0x2 == 0x3fff (0x3fff) +char 0xffff >> 0x2 == -0x1 (0xffff) +__uchar 0xff >> 0x2 == 0x3f (0x3f) +__longlong 0xffff >> 0x2 == -0x1 (0xffff) +__ulonglong 0xffff >> 0x2 == -0x1 (0xffff) +int 0xffff + 0x1 == 0x0 (0x0) +__uint 0xffff + 0x1 == 0x0 (0x0) +char 0xffff + 0x1 == 0x0 (0x0) +__uchar 0xff + 0x1 == 0x0 (0x0) +__longlong 0xffff + 0x1 == 0x0 (0x0) +__ulonglong 0xffff + 0x1 == 0x0 (0x0) +float 0xffff + 0x1 == 0x0 (0x0) +int 0xffff - 0x1 == -0x2 (0xfffe) +__uint 0xffff - 0x1 == -0x2 (0xfffe) +char 0xffff - 0x1 == -0x2 (0xfffe) +__uchar 0xff - 0x1 == 0xfe (0xfe) +__longlong 0xffff - 0x1 == -0x2 (0xfffe) +__ulonglong 0xffff - 0x1 == -0x2 (0xfffe) +float 0xffff - 0x1 == -0x2 (0xfffe) +int 0xffff * 0x1 == -0x1 (0xffff) +__uint 0xffff * 0x1 == -0x1 (0xffff) +char 0xffff * 0x1 == -0x1 (0xffff) +__uchar 0xff * 0x1 == 0xff (0xff) +__longlong 0xffff * 0x1 == -0x1 (0xffff) +__ulonglong 0xffff * 0x1 == -0x1 (0xffff) +float 0xffff * 0x1 == -0x1 (0xffff) +int 0xffff < 0x1 == 0x1 (0x1) +__uint 0xffff < 0x1 == 0x0 (0x0) +char 0xffff < 0x1 == 0x1 (0x1) +__uchar 0xff < 0x1 == 0x0 (0x0) +__longlong 0xffff < 0x1 == 0x1 (0x1) +__ulonglong 0xffff < 0x1 == 0x0 (0x0) +float 0xffff < 0x1 == 0x1 (0x1) +int 0xffff > 0x1 == 0x0 (0x0) +__uint 0xffff > 0x1 == 0x1 (0x1) +char 0xffff > 0x1 == 0x0 (0x0) +__uchar 0xff > 0x1 == 0x1 (0x1) +__longlong 0xffff > 0x1 == 0x0 (0x0) +__ulonglong 0xffff > 0x1 == 0x1 (0x1) +float 0xffff > 0x1 == 0x0 (0x0) +int 0xffff <= 0x1 == 0x1 (0x1) +__uint 0xffff <= 0x1 == 0x0 (0x0) +char 0xffff <= 0x1 == 0x1 (0x1) +__uchar 0xff <= 0x1 == 0x0 (0x0) +__longlong 0xffff <= 0x1 == 0x1 (0x1) +__ulonglong 0xffff <= 0x1 == 0x0 (0x0) +float 0xffff <= 0x1 == 0x1 (0x1) +int 0xffff == 0x1 == 0x0 (0x0) +__uint 0xffff == 0x1 == 0x0 (0x0) +char 0xffff == 0x1 == 0x0 (0x0) +__uchar 0xff == 0x1 == 0x0 (0x0) +__longlong 0xffff == 0x1 == 0x0 (0x0) +__ulonglong 0xffff == 0x1 == 0x0 (0x0) +float 0xffff == 0x1 == 0x0 (0x0) +int 0xffff != 0x1 == 0x1 (0x1) +__uint 0xffff != 0x1 == 0x1 (0x1) +char 0xffff != 0x1 == 0x1 (0x1) +__uchar 0xff != 0x1 == 0x1 (0x1) +__longlong 0xffff != 0x1 == 0x1 (0x1) +__ulonglong 0xffff != 0x1 == 0x1 (0x1) +float 0xffff != 0x1 == 0x1 (0x1) +int 0xffff >= 0x1 == 0x0 (0x0) +__uint 0xffff >= 0x1 == 0x1 (0x1) +char 0xffff >= 0x1 == 0x0 (0x0) +__uchar 0xff >= 0x1 == 0x1 (0x1) +__longlong 0xffff >= 0x1 == 0x0 (0x0) +__ulonglong 0xffff >= 0x1 == 0x1 (0x1) +float 0xffff >= 0x1 == 0x0 (0x0) +int 0xffff / 0x1 == -0x1 (0xffff) +__uint 0xffff / 0x1 == -0x1 (0xffff) +char 0xffff / 0x1 == -0x1 (0xffff) +__uchar 0xff / 0x1 == 0xff (0xff) +__longlong 0xffff / 0x1 == -0x1 (0xffff) +__ulonglong 0xffff / 0x1 == -0x1 (0xffff) +float 0xffff / 0x1 == -0x1 (0xffff) +int 0xffff % 0x1 == 0x0 (0x0) +__uint 0xffff % 0x1 == 0x0 (0x0) +char 0xffff % 0x1 == 0x0 (0x0) +__uchar 0xff % 0x1 == 0x0 (0x0) +__longlong 0xffff % 0x1 == 0x0 (0x0) +__ulonglong 0xffff % 0x1 == 0x0 (0x0) +0xffff * 0x2 == -0x2 +0xffff / 0x2 == 0x0 +0xffff % 0x2 == -0x1 +int 0xffff ^ 0x2 == -0x3 (0xfffd) +__uint 0xffff ^ 0x2 == -0x3 (0xfffd) +char 0xffff ^ 0x2 == -0x3 (0xfffd) +__uchar 0xff ^ 0x2 == 0xfd (0xfd) +__longlong 0xffff ^ 0x2 == -0x3 (0xfffd) +__ulonglong 0xffff ^ 0x2 == -0x3 (0xfffd) +int 0xffff && 0x2 == 0x1 (0x1) +__uint 0xffff && 0x2 == 0x1 (0x1) +char 0xffff && 0x2 == 0x1 (0x1) +__uchar 0xff && 0x2 == 0x1 (0x1) +__longlong 0xffff && 0x2 == 0x1 (0x1) +__ulonglong 0xffff && 0x2 == 0x1 (0x1) +int 0xffff || 0x2 == 0x1 (0x1) +__uint 0xffff || 0x2 == 0x1 (0x1) +char 0xffff || 0x2 == 0x1 (0x1) +__uchar 0xff || 0x2 == 0x1 (0x1) +__longlong 0xffff || 0x2 == 0x1 (0x1) +__ulonglong 0xffff || 0x2 == 0x1 (0x1) +int 0xffff & 0x2 == 0x2 (0x2) +__uint 0xffff & 0x2 == 0x2 (0x2) +char 0xffff & 0x2 == 0x2 (0x2) +__uchar 0xff & 0x2 == 0x2 (0x2) +__longlong 0xffff & 0x2 == 0x2 (0x2) +__ulonglong 0xffff & 0x2 == 0x2 (0x2) +int 0xffff | 0x2 == -0x1 (0xffff) +__uint 0xffff | 0x2 == -0x1 (0xffff) +char 0xffff | 0x2 == -0x1 (0xffff) +__uchar 0xff | 0x2 == 0xff (0xff) +__longlong 0xffff | 0x2 == -0x1 (0xffff) +__ulonglong 0xffff | 0x2 == -0x1 (0xffff) +int 0xffff << 0x3 == -0x8 (0xfff8) +__uint 0xffff << 0x3 == -0x8 (0xfff8) +char 0xffff << 0x3 == -0x8 (0xfff8) +__uchar 0xff << 0x3 == 0xf8 (0xf8) +__longlong 0xffff << 0x3 == -0x8 (0xfff8) +__ulonglong 0xffff << 0x3 == -0x8 (0xfff8) +int 0xffff >> 0x3 == -0x1 (0xffff) +__uint 0xffff >> 0x3 == 0x1fff (0x1fff) +char 0xffff >> 0x3 == -0x1 (0xffff) +__uchar 0xff >> 0x3 == 0x1f (0x1f) +__longlong 0xffff >> 0x3 == -0x1 (0xffff) +__ulonglong 0xffff >> 0x3 == -0x1 (0xffff) +int 0xffff + 0x2 == 0x1 (0x1) +__uint 0xffff + 0x2 == 0x1 (0x1) +char 0xffff + 0x2 == 0x1 (0x1) +__uchar 0xff + 0x2 == 0x1 (0x1) +__longlong 0xffff + 0x2 == 0x1 (0x1) +__ulonglong 0xffff + 0x2 == 0x1 (0x1) +float 0xffff + 0x2 == 0x1 (0x1) +int 0xffff - 0x2 == -0x3 (0xfffd) +__uint 0xffff - 0x2 == -0x3 (0xfffd) +char 0xffff - 0x2 == -0x3 (0xfffd) +__uchar 0xff - 0x2 == 0xfd (0xfd) +__longlong 0xffff - 0x2 == -0x3 (0xfffd) +__ulonglong 0xffff - 0x2 == -0x3 (0xfffd) +float 0xffff - 0x2 == -0x3 (0xfffd) +int 0xffff * 0x2 == -0x2 (0xfffe) +__uint 0xffff * 0x2 == -0x2 (0xfffe) +char 0xffff * 0x2 == -0x2 (0xfffe) +__uchar 0xff * 0x2 == 0xfe (0xfe) +__longlong 0xffff * 0x2 == -0x2 (0xfffe) +__ulonglong 0xffff * 0x2 == -0x2 (0xfffe) +float 0xffff * 0x2 == -0x2 (0xfffe) +int 0xffff < 0x2 == 0x1 (0x1) +__uint 0xffff < 0x2 == 0x0 (0x0) +char 0xffff < 0x2 == 0x1 (0x1) +__uchar 0xff < 0x2 == 0x0 (0x0) +__longlong 0xffff < 0x2 == 0x1 (0x1) +__ulonglong 0xffff < 0x2 == 0x0 (0x0) +float 0xffff < 0x2 == 0x1 (0x1) +int 0xffff > 0x2 == 0x0 (0x0) +__uint 0xffff > 0x2 == 0x1 (0x1) +char 0xffff > 0x2 == 0x0 (0x0) +__uchar 0xff > 0x2 == 0x1 (0x1) +__longlong 0xffff > 0x2 == 0x0 (0x0) +__ulonglong 0xffff > 0x2 == 0x1 (0x1) +float 0xffff > 0x2 == 0x0 (0x0) +int 0xffff <= 0x2 == 0x1 (0x1) +__uint 0xffff <= 0x2 == 0x0 (0x0) +char 0xffff <= 0x2 == 0x1 (0x1) +__uchar 0xff <= 0x2 == 0x0 (0x0) +__longlong 0xffff <= 0x2 == 0x1 (0x1) +__ulonglong 0xffff <= 0x2 == 0x0 (0x0) +float 0xffff <= 0x2 == 0x1 (0x1) +int 0xffff == 0x2 == 0x0 (0x0) +__uint 0xffff == 0x2 == 0x0 (0x0) +char 0xffff == 0x2 == 0x0 (0x0) +__uchar 0xff == 0x2 == 0x0 (0x0) +__longlong 0xffff == 0x2 == 0x0 (0x0) +__ulonglong 0xffff == 0x2 == 0x0 (0x0) +float 0xffff == 0x2 == 0x0 (0x0) +int 0xffff != 0x2 == 0x1 (0x1) +__uint 0xffff != 0x2 == 0x1 (0x1) +char 0xffff != 0x2 == 0x1 (0x1) +__uchar 0xff != 0x2 == 0x1 (0x1) +__longlong 0xffff != 0x2 == 0x1 (0x1) +__ulonglong 0xffff != 0x2 == 0x1 (0x1) +float 0xffff != 0x2 == 0x1 (0x1) +int 0xffff >= 0x2 == 0x0 (0x0) +__uint 0xffff >= 0x2 == 0x1 (0x1) +char 0xffff >= 0x2 == 0x0 (0x0) +__uchar 0xff >= 0x2 == 0x1 (0x1) +__longlong 0xffff >= 0x2 == 0x0 (0x0) +__ulonglong 0xffff >= 0x2 == 0x1 (0x1) +float 0xffff >= 0x2 == 0x0 (0x0) +int 0xffff / 0x2 == 0x0 (0x0) +__uint 0xffff / 0x2 == 0x7fff (0x7fff) +char 0xffff / 0x2 == 0x0 (0x0) +__uchar 0xff / 0x2 == 0x7f (0x7f) +__longlong 0xffff / 0x2 == 0x0 (0x0) +__ulonglong 0xffff / 0x2 == -0x1 (0xffff) +float 0xffff / 0x2 == 0x0 (0x0) +int 0xffff % 0x2 == -0x1 (0xffff) +__uint 0xffff % 0x2 == 0x1 (0x1) +char 0xffff % 0x2 == -0x1 (0xffff) +__uchar 0xff % 0x2 == 0x1 (0x1) +__longlong 0xffff % 0x2 == -0x1 (0xffff) +__ulonglong 0xffff % 0x2 == 0x1 (0x1) +0xffff * 0xfffe == 0x2 +0xffff / 0xfffe == 0x0 +0xffff % 0xfffe == -0x1 +int 0xffff ^ 0xfffe == 0x1 (0x1) +__uint 0xffff ^ 0xfffe == 0x1 (0x1) +char 0xffff ^ 0xfffe == 0x1 (0x1) +__uchar 0xff ^ 0xfe == 0x1 (0x1) +__longlong 0xffff ^ 0xfffe == 0x1 (0x1) +__ulonglong 0xffff ^ 0xfffe == 0x1 (0x1) +int 0xffff && 0xfffe == 0x1 (0x1) +__uint 0xffff && 0xfffe == 0x1 (0x1) +char 0xffff && 0xfffe == 0x1 (0x1) +__uchar 0xff && 0xfe == 0x1 (0x1) +__longlong 0xffff && 0xfffe == 0x1 (0x1) +__ulonglong 0xffff && 0xfffe == 0x1 (0x1) +int 0xffff || 0xfffe == 0x1 (0x1) +__uint 0xffff || 0xfffe == 0x1 (0x1) +char 0xffff || 0xfffe == 0x1 (0x1) +__uchar 0xff || 0xfe == 0x1 (0x1) +__longlong 0xffff || 0xfffe == 0x1 (0x1) +__ulonglong 0xffff || 0xfffe == 0x1 (0x1) +int 0xffff & 0xfffe == -0x2 (0xfffe) +__uint 0xffff & 0xfffe == -0x2 (0xfffe) +char 0xffff & 0xfffe == -0x2 (0xfffe) +__uchar 0xff & 0xfe == 0xfe (0xfe) +__longlong 0xffff & 0xfffe == -0x2 (0xfffe) +__ulonglong 0xffff & 0xfffe == -0x2 (0xfffe) +int 0xffff | 0xfffe == -0x1 (0xffff) +__uint 0xffff | 0xfffe == -0x1 (0xffff) +char 0xffff | 0xfffe == -0x1 (0xffff) +__uchar 0xff | 0xfe == 0xff (0xff) +__longlong 0xffff | 0xfffe == -0x1 (0xffff) +__ulonglong 0xffff | 0xfffe == -0x1 (0xffff) +int 0xffff << 0x4 == -0x10 (0xfff0) +__uint 0xffff << 0x4 == -0x10 (0xfff0) +char 0xffff << 0x4 == -0x10 (0xfff0) +__uchar 0xff << 0x4 == 0xf0 (0xf0) +__longlong 0xffff << 0x4 == -0x10 (0xfff0) +__ulonglong 0xffff << 0x4 == -0x10 (0xfff0) +int 0xffff >> 0x4 == -0x1 (0xffff) +__uint 0xffff >> 0x4 == 0xfff (0xfff) +char 0xffff >> 0x4 == -0x1 (0xffff) +__uchar 0xff >> 0x4 == 0xf (0xf) +__longlong 0xffff >> 0x4 == -0x1 (0xffff) +__ulonglong 0xffff >> 0x4 == -0x1 (0xffff) +int 0xffff + 0xfffe == -0x3 (0xfffd) +__uint 0xffff + 0xfffe == -0x3 (0xfffd) +char 0xffff + 0xfffe == -0x3 (0xfffd) +__uchar 0xff + 0xfe == 0xfd (0xfd) +__longlong 0xffff + 0xfffe == -0x3 (0xfffd) +__ulonglong 0xffff + 0xfffe == -0x3 (0xfffd) +float 0xffff + 0xfffe == -0x3 (0xfffd) +int 0xffff - 0xfffe == 0x1 (0x1) +__uint 0xffff - 0xfffe == 0x1 (0x1) +char 0xffff - 0xfffe == 0x1 (0x1) +__uchar 0xff - 0xfe == 0x1 (0x1) +__longlong 0xffff - 0xfffe == 0x1 (0x1) +__ulonglong 0xffff - 0xfffe == 0x1 (0x1) +float 0xffff - 0xfffe == 0x1 (0x1) +int 0xffff * 0xfffe == 0x2 (0x2) +__uint 0xffff * 0xfffe == 0x2 (0x2) +char 0xffff * 0xfffe == 0x2 (0x2) +__uchar 0xff * 0xfe == 0x2 (0x2) +__longlong 0xffff * 0xfffe == 0x2 (0x2) +__ulonglong 0xffff * 0xfffe == 0x2 (0x2) +float 0xffff * 0xfffe == 0x2 (0x2) +int 0xffff < 0xfffe == 0x0 (0x0) +__uint 0xffff < 0xfffe == 0x0 (0x0) +char 0xffff < 0xfffe == 0x0 (0x0) +__uchar 0xff < 0xfe == 0x0 (0x0) +__longlong 0xffff < 0xfffe == 0x0 (0x0) +__ulonglong 0xffff < 0xfffe == 0x0 (0x0) +float 0xffff < 0xfffe == 0x0 (0x0) +int 0xffff > 0xfffe == 0x1 (0x1) +__uint 0xffff > 0xfffe == 0x1 (0x1) +char 0xffff > 0xfffe == 0x1 (0x1) +__uchar 0xff > 0xfe == 0x1 (0x1) +__longlong 0xffff > 0xfffe == 0x1 (0x1) +__ulonglong 0xffff > 0xfffe == 0x1 (0x1) +float 0xffff > 0xfffe == 0x1 (0x1) +int 0xffff <= 0xfffe == 0x0 (0x0) +__uint 0xffff <= 0xfffe == 0x0 (0x0) +char 0xffff <= 0xfffe == 0x0 (0x0) +__uchar 0xff <= 0xfe == 0x0 (0x0) +__longlong 0xffff <= 0xfffe == 0x0 (0x0) +__ulonglong 0xffff <= 0xfffe == 0x0 (0x0) +float 0xffff <= 0xfffe == 0x0 (0x0) +int 0xffff == 0xfffe == 0x0 (0x0) +__uint 0xffff == 0xfffe == 0x0 (0x0) +char 0xffff == 0xfffe == 0x0 (0x0) +__uchar 0xff == 0xfe == 0x0 (0x0) +__longlong 0xffff == 0xfffe == 0x0 (0x0) +__ulonglong 0xffff == 0xfffe == 0x0 (0x0) +float 0xffff == 0xfffe == 0x0 (0x0) +int 0xffff != 0xfffe == 0x1 (0x1) +__uint 0xffff != 0xfffe == 0x1 (0x1) +char 0xffff != 0xfffe == 0x1 (0x1) +__uchar 0xff != 0xfe == 0x1 (0x1) +__longlong 0xffff != 0xfffe == 0x1 (0x1) +__ulonglong 0xffff != 0xfffe == 0x1 (0x1) +float 0xffff != 0xfffe == 0x1 (0x1) +int 0xffff >= 0xfffe == 0x1 (0x1) +__uint 0xffff >= 0xfffe == 0x1 (0x1) +char 0xffff >= 0xfffe == 0x1 (0x1) +__uchar 0xff >= 0xfe == 0x1 (0x1) +__longlong 0xffff >= 0xfffe == 0x1 (0x1) +__ulonglong 0xffff >= 0xfffe == 0x1 (0x1) +float 0xffff >= 0xfffe == 0x1 (0x1) +int 0xffff / 0xfffe == 0x0 (0x0) +__uint 0xffff / 0xfffe == 0x1 (0x1) +char 0xffff / 0xfffe == 0x0 (0x0) +__uchar 0xff / 0xfe == 0x1 (0x1) +__longlong 0xffff / 0xfffe == 0x0 (0x0) +__ulonglong 0xffff / 0xfffe == 0x1 (0x1) +float 0xffff / 0xfffe == 0x0 (0x0) +int 0xffff % 0xfffe == -0x1 (0xffff) +__uint 0xffff % 0xfffe == 0x1 (0x1) +char 0xffff % 0xfffe == -0x1 (0xffff) +__uchar 0xff % 0xfe == 0x1 (0x1) +__longlong 0xffff % 0xfffe == -0x1 (0xffff) +__ulonglong 0xffff % 0xfffe == 0x1 (0x1) +0xffff * 0x4 == -0x4 +0xffff / 0x4 == 0x0 +0xffff % 0x4 == -0x1 +int 0xffff ^ 0x4 == -0x5 (0xfffb) +__uint 0xffff ^ 0x4 == -0x5 (0xfffb) +char 0xffff ^ 0x4 == -0x5 (0xfffb) +__uchar 0xff ^ 0x4 == 0xfb (0xfb) +__longlong 0xffff ^ 0x4 == -0x5 (0xfffb) +__ulonglong 0xffff ^ 0x4 == -0x5 (0xfffb) +int 0xffff && 0x4 == 0x1 (0x1) +__uint 0xffff && 0x4 == 0x1 (0x1) +char 0xffff && 0x4 == 0x1 (0x1) +__uchar 0xff && 0x4 == 0x1 (0x1) +__longlong 0xffff && 0x4 == 0x1 (0x1) +__ulonglong 0xffff && 0x4 == 0x1 (0x1) +int 0xffff || 0x4 == 0x1 (0x1) +__uint 0xffff || 0x4 == 0x1 (0x1) +char 0xffff || 0x4 == 0x1 (0x1) +__uchar 0xff || 0x4 == 0x1 (0x1) +__longlong 0xffff || 0x4 == 0x1 (0x1) +__ulonglong 0xffff || 0x4 == 0x1 (0x1) +int 0xffff & 0x4 == 0x4 (0x4) +__uint 0xffff & 0x4 == 0x4 (0x4) +char 0xffff & 0x4 == 0x4 (0x4) +__uchar 0xff & 0x4 == 0x4 (0x4) +__longlong 0xffff & 0x4 == 0x4 (0x4) +__ulonglong 0xffff & 0x4 == 0x4 (0x4) +int 0xffff | 0x4 == -0x1 (0xffff) +__uint 0xffff | 0x4 == -0x1 (0xffff) +char 0xffff | 0x4 == -0x1 (0xffff) +__uchar 0xff | 0x4 == 0xff (0xff) +__longlong 0xffff | 0x4 == -0x1 (0xffff) +__ulonglong 0xffff | 0x4 == -0x1 (0xffff) +int 0xffff << 0x5 == -0x20 (0xffe0) +__uint 0xffff << 0x5 == -0x20 (0xffe0) +char 0xffff << 0x5 == -0x20 (0xffe0) +__uchar 0xff << 0x5 == 0xe0 (0xe0) +__longlong 0xffff << 0x5 == -0x20 (0xffe0) +__ulonglong 0xffff << 0x5 == -0x20 (0xffe0) +int 0xffff >> 0x5 == -0x1 (0xffff) +__uint 0xffff >> 0x5 == 0x7ff (0x7ff) +char 0xffff >> 0x5 == -0x1 (0xffff) +__uchar 0xff >> 0x5 == 0x7 (0x7) +__longlong 0xffff >> 0x5 == -0x1 (0xffff) +__ulonglong 0xffff >> 0x5 == -0x1 (0xffff) +int 0xffff + 0x4 == 0x3 (0x3) +__uint 0xffff + 0x4 == 0x3 (0x3) +char 0xffff + 0x4 == 0x3 (0x3) +__uchar 0xff + 0x4 == 0x3 (0x3) +__longlong 0xffff + 0x4 == 0x3 (0x3) +__ulonglong 0xffff + 0x4 == 0x3 (0x3) +float 0xffff + 0x4 == 0x3 (0x3) +int 0xffff - 0x4 == -0x5 (0xfffb) +__uint 0xffff - 0x4 == -0x5 (0xfffb) +char 0xffff - 0x4 == -0x5 (0xfffb) +__uchar 0xff - 0x4 == 0xfb (0xfb) +__longlong 0xffff - 0x4 == -0x5 (0xfffb) +__ulonglong 0xffff - 0x4 == -0x5 (0xfffb) +float 0xffff - 0x4 == -0x5 (0xfffb) +int 0xffff * 0x4 == -0x4 (0xfffc) +__uint 0xffff * 0x4 == -0x4 (0xfffc) +char 0xffff * 0x4 == -0x4 (0xfffc) +__uchar 0xff * 0x4 == 0xfc (0xfc) +__longlong 0xffff * 0x4 == -0x4 (0xfffc) +__ulonglong 0xffff * 0x4 == -0x4 (0xfffc) +float 0xffff * 0x4 == -0x4 (0xfffc) +int 0xffff < 0x4 == 0x1 (0x1) +__uint 0xffff < 0x4 == 0x0 (0x0) +char 0xffff < 0x4 == 0x1 (0x1) +__uchar 0xff < 0x4 == 0x0 (0x0) +__longlong 0xffff < 0x4 == 0x1 (0x1) +__ulonglong 0xffff < 0x4 == 0x0 (0x0) +float 0xffff < 0x4 == 0x1 (0x1) +int 0xffff > 0x4 == 0x0 (0x0) +__uint 0xffff > 0x4 == 0x1 (0x1) +char 0xffff > 0x4 == 0x0 (0x0) +__uchar 0xff > 0x4 == 0x1 (0x1) +__longlong 0xffff > 0x4 == 0x0 (0x0) +__ulonglong 0xffff > 0x4 == 0x1 (0x1) +float 0xffff > 0x4 == 0x0 (0x0) +int 0xffff <= 0x4 == 0x1 (0x1) +__uint 0xffff <= 0x4 == 0x0 (0x0) +char 0xffff <= 0x4 == 0x1 (0x1) +__uchar 0xff <= 0x4 == 0x0 (0x0) +__longlong 0xffff <= 0x4 == 0x1 (0x1) +__ulonglong 0xffff <= 0x4 == 0x0 (0x0) +float 0xffff <= 0x4 == 0x1 (0x1) +int 0xffff == 0x4 == 0x0 (0x0) +__uint 0xffff == 0x4 == 0x0 (0x0) +char 0xffff == 0x4 == 0x0 (0x0) +__uchar 0xff == 0x4 == 0x0 (0x0) +__longlong 0xffff == 0x4 == 0x0 (0x0) +__ulonglong 0xffff == 0x4 == 0x0 (0x0) +float 0xffff == 0x4 == 0x0 (0x0) +int 0xffff != 0x4 == 0x1 (0x1) +__uint 0xffff != 0x4 == 0x1 (0x1) +char 0xffff != 0x4 == 0x1 (0x1) +__uchar 0xff != 0x4 == 0x1 (0x1) +__longlong 0xffff != 0x4 == 0x1 (0x1) +__ulonglong 0xffff != 0x4 == 0x1 (0x1) +float 0xffff != 0x4 == 0x1 (0x1) +int 0xffff >= 0x4 == 0x0 (0x0) +__uint 0xffff >= 0x4 == 0x1 (0x1) +char 0xffff >= 0x4 == 0x0 (0x0) +__uchar 0xff >= 0x4 == 0x1 (0x1) +__longlong 0xffff >= 0x4 == 0x0 (0x0) +__ulonglong 0xffff >= 0x4 == 0x1 (0x1) +float 0xffff >= 0x4 == 0x0 (0x0) +int 0xffff / 0x4 == 0x0 (0x0) +__uint 0xffff / 0x4 == 0x3fff (0x3fff) +char 0xffff / 0x4 == 0x0 (0x0) +__uchar 0xff / 0x4 == 0x3f (0x3f) +__longlong 0xffff / 0x4 == 0x0 (0x0) +__ulonglong 0xffff / 0x4 == -0x1 (0xffff) +float 0xffff / 0x4 == 0x0 (0x0) +int 0xffff % 0x4 == -0x1 (0xffff) +__uint 0xffff % 0x4 == 0x3 (0x3) +char 0xffff % 0x4 == -0x1 (0xffff) +__uchar 0xff % 0x4 == 0x3 (0x3) +__longlong 0xffff % 0x4 == -0x1 (0xffff) +__ulonglong 0xffff % 0x4 == 0x3 (0x3) +0xffff * 0xfffc == 0x4 +0xffff / 0xfffc == 0x0 +0xffff % 0xfffc == -0x1 +int 0xffff ^ 0xfffc == 0x3 (0x3) +__uint 0xffff ^ 0xfffc == 0x3 (0x3) +char 0xffff ^ 0xfffc == 0x3 (0x3) +__uchar 0xff ^ 0xfc == 0x3 (0x3) +__longlong 0xffff ^ 0xfffc == 0x3 (0x3) +__ulonglong 0xffff ^ 0xfffc == 0x3 (0x3) +int 0xffff && 0xfffc == 0x1 (0x1) +__uint 0xffff && 0xfffc == 0x1 (0x1) +char 0xffff && 0xfffc == 0x1 (0x1) +__uchar 0xff && 0xfc == 0x1 (0x1) +__longlong 0xffff && 0xfffc == 0x1 (0x1) +__ulonglong 0xffff && 0xfffc == 0x1 (0x1) +int 0xffff || 0xfffc == 0x1 (0x1) +__uint 0xffff || 0xfffc == 0x1 (0x1) +char 0xffff || 0xfffc == 0x1 (0x1) +__uchar 0xff || 0xfc == 0x1 (0x1) +__longlong 0xffff || 0xfffc == 0x1 (0x1) +__ulonglong 0xffff || 0xfffc == 0x1 (0x1) +int 0xffff & 0xfffc == -0x4 (0xfffc) +__uint 0xffff & 0xfffc == -0x4 (0xfffc) +char 0xffff & 0xfffc == -0x4 (0xfffc) +__uchar 0xff & 0xfc == 0xfc (0xfc) +__longlong 0xffff & 0xfffc == -0x4 (0xfffc) +__ulonglong 0xffff & 0xfffc == -0x4 (0xfffc) +int 0xffff | 0xfffc == -0x1 (0xffff) +__uint 0xffff | 0xfffc == -0x1 (0xffff) +char 0xffff | 0xfffc == -0x1 (0xffff) +__uchar 0xff | 0xfc == 0xff (0xff) +__longlong 0xffff | 0xfffc == -0x1 (0xffff) +__ulonglong 0xffff | 0xfffc == -0x1 (0xffff) +int 0xffff << 0x6 == -0x40 (0xffc0) +__uint 0xffff << 0x6 == -0x40 (0xffc0) +char 0xffff << 0x6 == -0x40 (0xffc0) +__uchar 0xff << 0x6 == 0xc0 (0xc0) +__longlong 0xffff << 0x6 == -0x40 (0xffc0) +__ulonglong 0xffff << 0x6 == -0x40 (0xffc0) +int 0xffff >> 0x6 == -0x1 (0xffff) +__uint 0xffff >> 0x6 == 0x3ff (0x3ff) +char 0xffff >> 0x6 == -0x1 (0xffff) +__uchar 0xff >> 0x6 == 0x3 (0x3) +__longlong 0xffff >> 0x6 == -0x1 (0xffff) +__ulonglong 0xffff >> 0x6 == -0x1 (0xffff) +int 0xffff + 0xfffc == -0x5 (0xfffb) +__uint 0xffff + 0xfffc == -0x5 (0xfffb) +char 0xffff + 0xfffc == -0x5 (0xfffb) +__uchar 0xff + 0xfc == 0xfb (0xfb) +__longlong 0xffff + 0xfffc == -0x5 (0xfffb) +__ulonglong 0xffff + 0xfffc == -0x5 (0xfffb) +float 0xffff + 0xfffc == -0x5 (0xfffb) +int 0xffff - 0xfffc == 0x3 (0x3) +__uint 0xffff - 0xfffc == 0x3 (0x3) +char 0xffff - 0xfffc == 0x3 (0x3) +__uchar 0xff - 0xfc == 0x3 (0x3) +__longlong 0xffff - 0xfffc == 0x3 (0x3) +__ulonglong 0xffff - 0xfffc == 0x3 (0x3) +float 0xffff - 0xfffc == 0x3 (0x3) +int 0xffff * 0xfffc == 0x4 (0x4) +__uint 0xffff * 0xfffc == 0x4 (0x4) +char 0xffff * 0xfffc == 0x4 (0x4) +__uchar 0xff * 0xfc == 0x4 (0x4) +__longlong 0xffff * 0xfffc == 0x4 (0x4) +__ulonglong 0xffff * 0xfffc == 0x4 (0x4) +float 0xffff * 0xfffc == 0x4 (0x4) +int 0xffff < 0xfffc == 0x0 (0x0) +__uint 0xffff < 0xfffc == 0x0 (0x0) +char 0xffff < 0xfffc == 0x0 (0x0) +__uchar 0xff < 0xfc == 0x0 (0x0) +__longlong 0xffff < 0xfffc == 0x0 (0x0) +__ulonglong 0xffff < 0xfffc == 0x0 (0x0) +float 0xffff < 0xfffc == 0x0 (0x0) +int 0xffff > 0xfffc == 0x1 (0x1) +__uint 0xffff > 0xfffc == 0x1 (0x1) +char 0xffff > 0xfffc == 0x1 (0x1) +__uchar 0xff > 0xfc == 0x1 (0x1) +__longlong 0xffff > 0xfffc == 0x1 (0x1) +__ulonglong 0xffff > 0xfffc == 0x1 (0x1) +float 0xffff > 0xfffc == 0x1 (0x1) +int 0xffff <= 0xfffc == 0x0 (0x0) +__uint 0xffff <= 0xfffc == 0x0 (0x0) +char 0xffff <= 0xfffc == 0x0 (0x0) +__uchar 0xff <= 0xfc == 0x0 (0x0) +__longlong 0xffff <= 0xfffc == 0x0 (0x0) +__ulonglong 0xffff <= 0xfffc == 0x0 (0x0) +float 0xffff <= 0xfffc == 0x0 (0x0) +int 0xffff == 0xfffc == 0x0 (0x0) +__uint 0xffff == 0xfffc == 0x0 (0x0) +char 0xffff == 0xfffc == 0x0 (0x0) +__uchar 0xff == 0xfc == 0x0 (0x0) +__longlong 0xffff == 0xfffc == 0x0 (0x0) +__ulonglong 0xffff == 0xfffc == 0x0 (0x0) +float 0xffff == 0xfffc == 0x0 (0x0) +int 0xffff != 0xfffc == 0x1 (0x1) +__uint 0xffff != 0xfffc == 0x1 (0x1) +char 0xffff != 0xfffc == 0x1 (0x1) +__uchar 0xff != 0xfc == 0x1 (0x1) +__longlong 0xffff != 0xfffc == 0x1 (0x1) +__ulonglong 0xffff != 0xfffc == 0x1 (0x1) +float 0xffff != 0xfffc == 0x1 (0x1) +int 0xffff >= 0xfffc == 0x1 (0x1) +__uint 0xffff >= 0xfffc == 0x1 (0x1) +char 0xffff >= 0xfffc == 0x1 (0x1) +__uchar 0xff >= 0xfc == 0x1 (0x1) +__longlong 0xffff >= 0xfffc == 0x1 (0x1) +__ulonglong 0xffff >= 0xfffc == 0x1 (0x1) +float 0xffff >= 0xfffc == 0x1 (0x1) +int 0xffff / 0xfffc == 0x0 (0x0) +__uint 0xffff / 0xfffc == 0x1 (0x1) +char 0xffff / 0xfffc == 0x0 (0x0) +__uchar 0xff / 0xfc == 0x1 (0x1) +__longlong 0xffff / 0xfffc == 0x0 (0x0) +__ulonglong 0xffff / 0xfffc == 0x1 (0x1) +float 0xffff / 0xfffc == 0x0 (0x0) +int 0xffff % 0xfffc == -0x1 (0xffff) +__uint 0xffff % 0xfffc == 0x3 (0x3) +char 0xffff % 0xfffc == -0x1 (0xffff) +__uchar 0xff % 0xfc == 0x3 (0x3) +__longlong 0xffff % 0xfffc == -0x1 (0xffff) +__ulonglong 0xffff % 0xfffc == 0x3 (0x3) +0xffff * 0xa == -0xa +0xffff / 0xa == 0x0 +0xffff % 0xa == -0x1 +int 0xffff ^ 0xa == -0xb (0xfff5) +__uint 0xffff ^ 0xa == -0xb (0xfff5) +char 0xffff ^ 0xa == -0xb (0xfff5) +__uchar 0xff ^ 0xa == 0xf5 (0xf5) +__longlong 0xffff ^ 0xa == -0xb (0xfff5) +__ulonglong 0xffff ^ 0xa == -0xb (0xfff5) +int 0xffff && 0xa == 0x1 (0x1) +__uint 0xffff && 0xa == 0x1 (0x1) +char 0xffff && 0xa == 0x1 (0x1) +__uchar 0xff && 0xa == 0x1 (0x1) +__longlong 0xffff && 0xa == 0x1 (0x1) +__ulonglong 0xffff && 0xa == 0x1 (0x1) +int 0xffff || 0xa == 0x1 (0x1) +__uint 0xffff || 0xa == 0x1 (0x1) +char 0xffff || 0xa == 0x1 (0x1) +__uchar 0xff || 0xa == 0x1 (0x1) +__longlong 0xffff || 0xa == 0x1 (0x1) +__ulonglong 0xffff || 0xa == 0x1 (0x1) +int 0xffff & 0xa == 0xa (0xa) +__uint 0xffff & 0xa == 0xa (0xa) +char 0xffff & 0xa == 0xa (0xa) +__uchar 0xff & 0xa == 0xa (0xa) +__longlong 0xffff & 0xa == 0xa (0xa) +__ulonglong 0xffff & 0xa == 0xa (0xa) +int 0xffff | 0xa == -0x1 (0xffff) +__uint 0xffff | 0xa == -0x1 (0xffff) +char 0xffff | 0xa == -0x1 (0xffff) +__uchar 0xff | 0xa == 0xff (0xff) +__longlong 0xffff | 0xa == -0x1 (0xffff) +__ulonglong 0xffff | 0xa == -0x1 (0xffff) +int 0xffff << 0x7 == -0x80 (0xff80) +__uint 0xffff << 0x7 == -0x80 (0xff80) +char 0xffff << 0x7 == -0x80 (0xff80) +__uchar 0xff << 0x7 == 0x80 (0x80) +__longlong 0xffff << 0x7 == -0x80 (0xff80) +__ulonglong 0xffff << 0x7 == -0x80 (0xff80) +int 0xffff >> 0x7 == -0x1 (0xffff) +__uint 0xffff >> 0x7 == 0x1ff (0x1ff) +char 0xffff >> 0x7 == -0x1 (0xffff) +__uchar 0xff >> 0x7 == 0x1 (0x1) +__longlong 0xffff >> 0x7 == -0x1 (0xffff) +__ulonglong 0xffff >> 0x7 == -0x1 (0xffff) +int 0xffff + 0xa == 0x9 (0x9) +__uint 0xffff + 0xa == 0x9 (0x9) +char 0xffff + 0xa == 0x9 (0x9) +__uchar 0xff + 0xa == 0x9 (0x9) +__longlong 0xffff + 0xa == 0x9 (0x9) +__ulonglong 0xffff + 0xa == 0x9 (0x9) +float 0xffff + 0xa == 0x9 (0x9) +int 0xffff - 0xa == -0xb (0xfff5) +__uint 0xffff - 0xa == -0xb (0xfff5) +char 0xffff - 0xa == -0xb (0xfff5) +__uchar 0xff - 0xa == 0xf5 (0xf5) +__longlong 0xffff - 0xa == -0xb (0xfff5) +__ulonglong 0xffff - 0xa == -0xb (0xfff5) +float 0xffff - 0xa == -0xb (0xfff5) +int 0xffff * 0xa == -0xa (0xfff6) +__uint 0xffff * 0xa == -0xa (0xfff6) +char 0xffff * 0xa == -0xa (0xfff6) +__uchar 0xff * 0xa == 0xf6 (0xf6) +__longlong 0xffff * 0xa == -0xa (0xfff6) +__ulonglong 0xffff * 0xa == -0xa (0xfff6) +float 0xffff * 0xa == -0xa (0xfff6) +int 0xffff < 0xa == 0x1 (0x1) +__uint 0xffff < 0xa == 0x0 (0x0) +char 0xffff < 0xa == 0x1 (0x1) +__uchar 0xff < 0xa == 0x0 (0x0) +__longlong 0xffff < 0xa == 0x1 (0x1) +__ulonglong 0xffff < 0xa == 0x0 (0x0) +float 0xffff < 0xa == 0x1 (0x1) +int 0xffff > 0xa == 0x0 (0x0) +__uint 0xffff > 0xa == 0x1 (0x1) +char 0xffff > 0xa == 0x0 (0x0) +__uchar 0xff > 0xa == 0x1 (0x1) +__longlong 0xffff > 0xa == 0x0 (0x0) +__ulonglong 0xffff > 0xa == 0x1 (0x1) +float 0xffff > 0xa == 0x0 (0x0) +int 0xffff <= 0xa == 0x1 (0x1) +__uint 0xffff <= 0xa == 0x0 (0x0) +char 0xffff <= 0xa == 0x1 (0x1) +__uchar 0xff <= 0xa == 0x0 (0x0) +__longlong 0xffff <= 0xa == 0x1 (0x1) +__ulonglong 0xffff <= 0xa == 0x0 (0x0) +float 0xffff <= 0xa == 0x1 (0x1) +int 0xffff == 0xa == 0x0 (0x0) +__uint 0xffff == 0xa == 0x0 (0x0) +char 0xffff == 0xa == 0x0 (0x0) +__uchar 0xff == 0xa == 0x0 (0x0) +__longlong 0xffff == 0xa == 0x0 (0x0) +__ulonglong 0xffff == 0xa == 0x0 (0x0) +float 0xffff == 0xa == 0x0 (0x0) +int 0xffff != 0xa == 0x1 (0x1) +__uint 0xffff != 0xa == 0x1 (0x1) +char 0xffff != 0xa == 0x1 (0x1) +__uchar 0xff != 0xa == 0x1 (0x1) +__longlong 0xffff != 0xa == 0x1 (0x1) +__ulonglong 0xffff != 0xa == 0x1 (0x1) +float 0xffff != 0xa == 0x1 (0x1) +int 0xffff >= 0xa == 0x0 (0x0) +__uint 0xffff >= 0xa == 0x1 (0x1) +char 0xffff >= 0xa == 0x0 (0x0) +__uchar 0xff >= 0xa == 0x1 (0x1) +__longlong 0xffff >= 0xa == 0x0 (0x0) +__ulonglong 0xffff >= 0xa == 0x1 (0x1) +float 0xffff >= 0xa == 0x0 (0x0) +int 0xffff / 0xa == 0x0 (0x0) +__uint 0xffff / 0xa == 0x1999 (0x1999) +char 0xffff / 0xa == 0x0 (0x0) +__uchar 0xff / 0xa == 0x19 (0x19) +__longlong 0xffff / 0xa == 0x0 (0x0) +__ulonglong 0xffff / 0xa == -0x6667 (0x9999) +float 0xffff / 0xa == 0x0 (0x0) +int 0xffff % 0xa == -0x1 (0xffff) +__uint 0xffff % 0xa == 0x5 (0x5) +char 0xffff % 0xa == -0x1 (0xffff) +__uchar 0xff % 0xa == 0x5 (0x5) +__longlong 0xffff % 0xa == -0x1 (0xffff) +__ulonglong 0xffff % 0xa == 0x5 (0x5) +0xffff * 0xfff6 == 0xa +0xffff / 0xfff6 == 0x0 +0xffff % 0xfff6 == -0x1 +int 0xffff ^ 0xfff6 == 0x9 (0x9) +__uint 0xffff ^ 0xfff6 == 0x9 (0x9) +char 0xffff ^ 0xfff6 == 0x9 (0x9) +__uchar 0xff ^ 0xf6 == 0x9 (0x9) +__longlong 0xffff ^ 0xfff6 == 0x9 (0x9) +__ulonglong 0xffff ^ 0xfff6 == 0x9 (0x9) +int 0xffff && 0xfff6 == 0x1 (0x1) +__uint 0xffff && 0xfff6 == 0x1 (0x1) +char 0xffff && 0xfff6 == 0x1 (0x1) +__uchar 0xff && 0xf6 == 0x1 (0x1) +__longlong 0xffff && 0xfff6 == 0x1 (0x1) +__ulonglong 0xffff && 0xfff6 == 0x1 (0x1) +int 0xffff || 0xfff6 == 0x1 (0x1) +__uint 0xffff || 0xfff6 == 0x1 (0x1) +char 0xffff || 0xfff6 == 0x1 (0x1) +__uchar 0xff || 0xf6 == 0x1 (0x1) +__longlong 0xffff || 0xfff6 == 0x1 (0x1) +__ulonglong 0xffff || 0xfff6 == 0x1 (0x1) +int 0xffff & 0xfff6 == -0xa (0xfff6) +__uint 0xffff & 0xfff6 == -0xa (0xfff6) +char 0xffff & 0xfff6 == -0xa (0xfff6) +__uchar 0xff & 0xf6 == 0xf6 (0xf6) +__longlong 0xffff & 0xfff6 == -0xa (0xfff6) +__ulonglong 0xffff & 0xfff6 == -0xa (0xfff6) +int 0xffff | 0xfff6 == -0x1 (0xffff) +__uint 0xffff | 0xfff6 == -0x1 (0xffff) +char 0xffff | 0xfff6 == -0x1 (0xffff) +__uchar 0xff | 0xf6 == 0xff (0xff) +__longlong 0xffff | 0xfff6 == -0x1 (0xffff) +__ulonglong 0xffff | 0xfff6 == -0x1 (0xffff) +int 0xffff << 0x8 == -0x100 (0xff00) +__uint 0xffff << 0x8 == -0x100 (0xff00) +char 0xffff << 0x8 == 0x0 (0x0) +__uchar 0xff << 0x8 == 0x0 (0x0) +__longlong 0xffff << 0x8 == -0x100 (0xff00) +__ulonglong 0xffff << 0x8 == -0x100 (0xff00) +int 0xffff >> 0x8 == -0x1 (0xffff) +__uint 0xffff >> 0x8 == 0xff (0xff) +char 0xffff >> 0x8 == -0x1 (0xffff) +__uchar 0xff >> 0x8 == 0x0 (0x0) +__longlong 0xffff >> 0x8 == -0x1 (0xffff) +__ulonglong 0xffff >> 0x8 == -0x1 (0xffff) +int 0xffff + 0xfff6 == -0xb (0xfff5) +__uint 0xffff + 0xfff6 == -0xb (0xfff5) +char 0xffff + 0xfff6 == -0xb (0xfff5) +__uchar 0xff + 0xf6 == 0xf5 (0xf5) +__longlong 0xffff + 0xfff6 == -0xb (0xfff5) +__ulonglong 0xffff + 0xfff6 == -0xb (0xfff5) +float 0xffff + 0xfff6 == -0xb (0xfff5) +int 0xffff - 0xfff6 == 0x9 (0x9) +__uint 0xffff - 0xfff6 == 0x9 (0x9) +char 0xffff - 0xfff6 == 0x9 (0x9) +__uchar 0xff - 0xf6 == 0x9 (0x9) +__longlong 0xffff - 0xfff6 == 0x9 (0x9) +__ulonglong 0xffff - 0xfff6 == 0x9 (0x9) +float 0xffff - 0xfff6 == 0x9 (0x9) +int 0xffff * 0xfff6 == 0xa (0xa) +__uint 0xffff * 0xfff6 == 0xa (0xa) +char 0xffff * 0xfff6 == 0xa (0xa) +__uchar 0xff * 0xf6 == 0xa (0xa) +__longlong 0xffff * 0xfff6 == 0xa (0xa) +__ulonglong 0xffff * 0xfff6 == 0xa (0xa) +float 0xffff * 0xfff6 == 0xa (0xa) +int 0xffff < 0xfff6 == 0x0 (0x0) +__uint 0xffff < 0xfff6 == 0x0 (0x0) +char 0xffff < 0xfff6 == 0x0 (0x0) +__uchar 0xff < 0xf6 == 0x0 (0x0) +__longlong 0xffff < 0xfff6 == 0x0 (0x0) +__ulonglong 0xffff < 0xfff6 == 0x0 (0x0) +float 0xffff < 0xfff6 == 0x0 (0x0) +int 0xffff > 0xfff6 == 0x1 (0x1) +__uint 0xffff > 0xfff6 == 0x1 (0x1) +char 0xffff > 0xfff6 == 0x1 (0x1) +__uchar 0xff > 0xf6 == 0x1 (0x1) +__longlong 0xffff > 0xfff6 == 0x1 (0x1) +__ulonglong 0xffff > 0xfff6 == 0x1 (0x1) +float 0xffff > 0xfff6 == 0x1 (0x1) +int 0xffff <= 0xfff6 == 0x0 (0x0) +__uint 0xffff <= 0xfff6 == 0x0 (0x0) +char 0xffff <= 0xfff6 == 0x0 (0x0) +__uchar 0xff <= 0xf6 == 0x0 (0x0) +__longlong 0xffff <= 0xfff6 == 0x0 (0x0) +__ulonglong 0xffff <= 0xfff6 == 0x0 (0x0) +float 0xffff <= 0xfff6 == 0x0 (0x0) +int 0xffff == 0xfff6 == 0x0 (0x0) +__uint 0xffff == 0xfff6 == 0x0 (0x0) +char 0xffff == 0xfff6 == 0x0 (0x0) +__uchar 0xff == 0xf6 == 0x0 (0x0) +__longlong 0xffff == 0xfff6 == 0x0 (0x0) +__ulonglong 0xffff == 0xfff6 == 0x0 (0x0) +float 0xffff == 0xfff6 == 0x0 (0x0) +int 0xffff != 0xfff6 == 0x1 (0x1) +__uint 0xffff != 0xfff6 == 0x1 (0x1) +char 0xffff != 0xfff6 == 0x1 (0x1) +__uchar 0xff != 0xf6 == 0x1 (0x1) +__longlong 0xffff != 0xfff6 == 0x1 (0x1) +__ulonglong 0xffff != 0xfff6 == 0x1 (0x1) +float 0xffff != 0xfff6 == 0x1 (0x1) +int 0xffff >= 0xfff6 == 0x1 (0x1) +__uint 0xffff >= 0xfff6 == 0x1 (0x1) +char 0xffff >= 0xfff6 == 0x1 (0x1) +__uchar 0xff >= 0xf6 == 0x1 (0x1) +__longlong 0xffff >= 0xfff6 == 0x1 (0x1) +__ulonglong 0xffff >= 0xfff6 == 0x1 (0x1) +float 0xffff >= 0xfff6 == 0x1 (0x1) +int 0xffff / 0xfff6 == 0x0 (0x0) +__uint 0xffff / 0xfff6 == 0x1 (0x1) +char 0xffff / 0xfff6 == 0x0 (0x0) +__uchar 0xff / 0xf6 == 0x1 (0x1) +__longlong 0xffff / 0xfff6 == 0x0 (0x0) +__ulonglong 0xffff / 0xfff6 == 0x1 (0x1) +float 0xffff / 0xfff6 == 0x0 (0x0) +int 0xffff % 0xfff6 == -0x1 (0xffff) +__uint 0xffff % 0xfff6 == 0x9 (0x9) +char 0xffff % 0xfff6 == -0x1 (0xffff) +__uchar 0xff % 0xf6 == 0x9 (0x9) +__longlong 0xffff % 0xfff6 == -0x1 (0xffff) +__ulonglong 0xffff % 0xfff6 == 0x9 (0x9) +0xffff * 0x5 == -0x5 +0xffff / 0x5 == 0x0 +0xffff % 0x5 == -0x1 +int 0xffff ^ 0x5 == -0x6 (0xfffa) +__uint 0xffff ^ 0x5 == -0x6 (0xfffa) +char 0xffff ^ 0x5 == -0x6 (0xfffa) +__uchar 0xff ^ 0x5 == 0xfa (0xfa) +__longlong 0xffff ^ 0x5 == -0x6 (0xfffa) +__ulonglong 0xffff ^ 0x5 == -0x6 (0xfffa) +int 0xffff && 0x5 == 0x1 (0x1) +__uint 0xffff && 0x5 == 0x1 (0x1) +char 0xffff && 0x5 == 0x1 (0x1) +__uchar 0xff && 0x5 == 0x1 (0x1) +__longlong 0xffff && 0x5 == 0x1 (0x1) +__ulonglong 0xffff && 0x5 == 0x1 (0x1) +int 0xffff || 0x5 == 0x1 (0x1) +__uint 0xffff || 0x5 == 0x1 (0x1) +char 0xffff || 0x5 == 0x1 (0x1) +__uchar 0xff || 0x5 == 0x1 (0x1) +__longlong 0xffff || 0x5 == 0x1 (0x1) +__ulonglong 0xffff || 0x5 == 0x1 (0x1) +int 0xffff & 0x5 == 0x5 (0x5) +__uint 0xffff & 0x5 == 0x5 (0x5) +char 0xffff & 0x5 == 0x5 (0x5) +__uchar 0xff & 0x5 == 0x5 (0x5) +__longlong 0xffff & 0x5 == 0x5 (0x5) +__ulonglong 0xffff & 0x5 == 0x5 (0x5) +int 0xffff | 0x5 == -0x1 (0xffff) +__uint 0xffff | 0x5 == -0x1 (0xffff) +char 0xffff | 0x5 == -0x1 (0xffff) +__uchar 0xff | 0x5 == 0xff (0xff) +__longlong 0xffff | 0x5 == -0x1 (0xffff) +__ulonglong 0xffff | 0x5 == -0x1 (0xffff) +int 0xffff << 0x9 == -0x200 (0xfe00) +__uint 0xffff << 0x9 == -0x200 (0xfe00) +char 0xffff << 0x9 == 0x0 (0x0) +__uchar 0xff << 0x9 == 0x0 (0x0) +__longlong 0xffff << 0x9 == -0x200 (0xfe00) +__ulonglong 0xffff << 0x9 == -0x200 (0xfe00) +int 0xffff >> 0x9 == -0x1 (0xffff) +__uint 0xffff >> 0x9 == 0x7f (0x7f) +char 0xffff >> 0x9 == -0x1 (0xffff) +__uchar 0xff >> 0x9 == 0x0 (0x0) +__longlong 0xffff >> 0x9 == -0x1 (0xffff) +__ulonglong 0xffff >> 0x9 == -0x1 (0xffff) +int 0xffff + 0x5 == 0x4 (0x4) +__uint 0xffff + 0x5 == 0x4 (0x4) +char 0xffff + 0x5 == 0x4 (0x4) +__uchar 0xff + 0x5 == 0x4 (0x4) +__longlong 0xffff + 0x5 == 0x4 (0x4) +__ulonglong 0xffff + 0x5 == 0x4 (0x4) +float 0xffff + 0x5 == 0x4 (0x4) +int 0xffff - 0x5 == -0x6 (0xfffa) +__uint 0xffff - 0x5 == -0x6 (0xfffa) +char 0xffff - 0x5 == -0x6 (0xfffa) +__uchar 0xff - 0x5 == 0xfa (0xfa) +__longlong 0xffff - 0x5 == -0x6 (0xfffa) +__ulonglong 0xffff - 0x5 == -0x6 (0xfffa) +float 0xffff - 0x5 == -0x6 (0xfffa) +int 0xffff * 0x5 == -0x5 (0xfffb) +__uint 0xffff * 0x5 == -0x5 (0xfffb) +char 0xffff * 0x5 == -0x5 (0xfffb) +__uchar 0xff * 0x5 == 0xfb (0xfb) +__longlong 0xffff * 0x5 == -0x5 (0xfffb) +__ulonglong 0xffff * 0x5 == -0x5 (0xfffb) +float 0xffff * 0x5 == -0x5 (0xfffb) +int 0xffff < 0x5 == 0x1 (0x1) +__uint 0xffff < 0x5 == 0x0 (0x0) +char 0xffff < 0x5 == 0x1 (0x1) +__uchar 0xff < 0x5 == 0x0 (0x0) +__longlong 0xffff < 0x5 == 0x1 (0x1) +__ulonglong 0xffff < 0x5 == 0x0 (0x0) +float 0xffff < 0x5 == 0x1 (0x1) +int 0xffff > 0x5 == 0x0 (0x0) +__uint 0xffff > 0x5 == 0x1 (0x1) +char 0xffff > 0x5 == 0x0 (0x0) +__uchar 0xff > 0x5 == 0x1 (0x1) +__longlong 0xffff > 0x5 == 0x0 (0x0) +__ulonglong 0xffff > 0x5 == 0x1 (0x1) +float 0xffff > 0x5 == 0x0 (0x0) +int 0xffff <= 0x5 == 0x1 (0x1) +__uint 0xffff <= 0x5 == 0x0 (0x0) +char 0xffff <= 0x5 == 0x1 (0x1) +__uchar 0xff <= 0x5 == 0x0 (0x0) +__longlong 0xffff <= 0x5 == 0x1 (0x1) +__ulonglong 0xffff <= 0x5 == 0x0 (0x0) +float 0xffff <= 0x5 == 0x1 (0x1) +int 0xffff == 0x5 == 0x0 (0x0) +__uint 0xffff == 0x5 == 0x0 (0x0) +char 0xffff == 0x5 == 0x0 (0x0) +__uchar 0xff == 0x5 == 0x0 (0x0) +__longlong 0xffff == 0x5 == 0x0 (0x0) +__ulonglong 0xffff == 0x5 == 0x0 (0x0) +float 0xffff == 0x5 == 0x0 (0x0) +int 0xffff != 0x5 == 0x1 (0x1) +__uint 0xffff != 0x5 == 0x1 (0x1) +char 0xffff != 0x5 == 0x1 (0x1) +__uchar 0xff != 0x5 == 0x1 (0x1) +__longlong 0xffff != 0x5 == 0x1 (0x1) +__ulonglong 0xffff != 0x5 == 0x1 (0x1) +float 0xffff != 0x5 == 0x1 (0x1) +int 0xffff >= 0x5 == 0x0 (0x0) +__uint 0xffff >= 0x5 == 0x1 (0x1) +char 0xffff >= 0x5 == 0x0 (0x0) +__uchar 0xff >= 0x5 == 0x1 (0x1) +__longlong 0xffff >= 0x5 == 0x0 (0x0) +__ulonglong 0xffff >= 0x5 == 0x1 (0x1) +float 0xffff >= 0x5 == 0x0 (0x0) +int 0xffff / 0x5 == 0x0 (0x0) +__uint 0xffff / 0x5 == 0x3333 (0x3333) +char 0xffff / 0x5 == 0x0 (0x0) +__uchar 0xff / 0x5 == 0x33 (0x33) +__longlong 0xffff / 0x5 == 0x0 (0x0) +__ulonglong 0xffff / 0x5 == 0x3333 (0x3333) +float 0xffff / 0x5 == 0x0 (0x0) +int 0xffff % 0x5 == -0x1 (0xffff) +__uint 0xffff % 0x5 == 0x0 (0x0) +char 0xffff % 0x5 == -0x1 (0xffff) +__uchar 0xff % 0x5 == 0x0 (0x0) +__longlong 0xffff % 0x5 == -0x1 (0xffff) +__ulonglong 0xffff % 0x5 == 0x0 (0x0) +0xffff * 0x7 == -0x7 +0xffff / 0x7 == 0x0 +0xffff % 0x7 == -0x1 +int 0xffff ^ 0x7 == -0x8 (0xfff8) +__uint 0xffff ^ 0x7 == -0x8 (0xfff8) +char 0xffff ^ 0x7 == -0x8 (0xfff8) +__uchar 0xff ^ 0x7 == 0xf8 (0xf8) +__longlong 0xffff ^ 0x7 == -0x8 (0xfff8) +__ulonglong 0xffff ^ 0x7 == -0x8 (0xfff8) +int 0xffff && 0x7 == 0x1 (0x1) +__uint 0xffff && 0x7 == 0x1 (0x1) +char 0xffff && 0x7 == 0x1 (0x1) +__uchar 0xff && 0x7 == 0x1 (0x1) +__longlong 0xffff && 0x7 == 0x1 (0x1) +__ulonglong 0xffff && 0x7 == 0x1 (0x1) +int 0xffff || 0x7 == 0x1 (0x1) +__uint 0xffff || 0x7 == 0x1 (0x1) +char 0xffff || 0x7 == 0x1 (0x1) +__uchar 0xff || 0x7 == 0x1 (0x1) +__longlong 0xffff || 0x7 == 0x1 (0x1) +__ulonglong 0xffff || 0x7 == 0x1 (0x1) +int 0xffff & 0x7 == 0x7 (0x7) +__uint 0xffff & 0x7 == 0x7 (0x7) +char 0xffff & 0x7 == 0x7 (0x7) +__uchar 0xff & 0x7 == 0x7 (0x7) +__longlong 0xffff & 0x7 == 0x7 (0x7) +__ulonglong 0xffff & 0x7 == 0x7 (0x7) +int 0xffff | 0x7 == -0x1 (0xffff) +__uint 0xffff | 0x7 == -0x1 (0xffff) +char 0xffff | 0x7 == -0x1 (0xffff) +__uchar 0xff | 0x7 == 0xff (0xff) +__longlong 0xffff | 0x7 == -0x1 (0xffff) +__ulonglong 0xffff | 0x7 == -0x1 (0xffff) +int 0xffff << 0xa == -0x400 (0xfc00) +__uint 0xffff << 0xa == -0x400 (0xfc00) +char 0xffff << 0xa == 0x0 (0x0) +__uchar 0xff << 0xa == 0x0 (0x0) +__longlong 0xffff << 0xa == -0x400 (0xfc00) +__ulonglong 0xffff << 0xa == -0x400 (0xfc00) +int 0xffff >> 0xa == -0x1 (0xffff) +__uint 0xffff >> 0xa == 0x3f (0x3f) +char 0xffff >> 0xa == -0x1 (0xffff) +__uchar 0xff >> 0xa == 0x0 (0x0) +__longlong 0xffff >> 0xa == -0x1 (0xffff) +__ulonglong 0xffff >> 0xa == -0x1 (0xffff) +int 0xffff + 0x7 == 0x6 (0x6) +__uint 0xffff + 0x7 == 0x6 (0x6) +char 0xffff + 0x7 == 0x6 (0x6) +__uchar 0xff + 0x7 == 0x6 (0x6) +__longlong 0xffff + 0x7 == 0x6 (0x6) +__ulonglong 0xffff + 0x7 == 0x6 (0x6) +float 0xffff + 0x7 == 0x6 (0x6) +int 0xffff - 0x7 == -0x8 (0xfff8) +__uint 0xffff - 0x7 == -0x8 (0xfff8) +char 0xffff - 0x7 == -0x8 (0xfff8) +__uchar 0xff - 0x7 == 0xf8 (0xf8) +__longlong 0xffff - 0x7 == -0x8 (0xfff8) +__ulonglong 0xffff - 0x7 == -0x8 (0xfff8) +float 0xffff - 0x7 == -0x8 (0xfff8) +int 0xffff * 0x7 == -0x7 (0xfff9) +__uint 0xffff * 0x7 == -0x7 (0xfff9) +char 0xffff * 0x7 == -0x7 (0xfff9) +__uchar 0xff * 0x7 == 0xf9 (0xf9) +__longlong 0xffff * 0x7 == -0x7 (0xfff9) +__ulonglong 0xffff * 0x7 == -0x7 (0xfff9) +float 0xffff * 0x7 == -0x7 (0xfff9) +int 0xffff < 0x7 == 0x1 (0x1) +__uint 0xffff < 0x7 == 0x0 (0x0) +char 0xffff < 0x7 == 0x1 (0x1) +__uchar 0xff < 0x7 == 0x0 (0x0) +__longlong 0xffff < 0x7 == 0x1 (0x1) +__ulonglong 0xffff < 0x7 == 0x0 (0x0) +float 0xffff < 0x7 == 0x1 (0x1) +int 0xffff > 0x7 == 0x0 (0x0) +__uint 0xffff > 0x7 == 0x1 (0x1) +char 0xffff > 0x7 == 0x0 (0x0) +__uchar 0xff > 0x7 == 0x1 (0x1) +__longlong 0xffff > 0x7 == 0x0 (0x0) +__ulonglong 0xffff > 0x7 == 0x1 (0x1) +float 0xffff > 0x7 == 0x0 (0x0) +int 0xffff <= 0x7 == 0x1 (0x1) +__uint 0xffff <= 0x7 == 0x0 (0x0) +char 0xffff <= 0x7 == 0x1 (0x1) +__uchar 0xff <= 0x7 == 0x0 (0x0) +__longlong 0xffff <= 0x7 == 0x1 (0x1) +__ulonglong 0xffff <= 0x7 == 0x0 (0x0) +float 0xffff <= 0x7 == 0x1 (0x1) +int 0xffff == 0x7 == 0x0 (0x0) +__uint 0xffff == 0x7 == 0x0 (0x0) +char 0xffff == 0x7 == 0x0 (0x0) +__uchar 0xff == 0x7 == 0x0 (0x0) +__longlong 0xffff == 0x7 == 0x0 (0x0) +__ulonglong 0xffff == 0x7 == 0x0 (0x0) +float 0xffff == 0x7 == 0x0 (0x0) +int 0xffff != 0x7 == 0x1 (0x1) +__uint 0xffff != 0x7 == 0x1 (0x1) +char 0xffff != 0x7 == 0x1 (0x1) +__uchar 0xff != 0x7 == 0x1 (0x1) +__longlong 0xffff != 0x7 == 0x1 (0x1) +__ulonglong 0xffff != 0x7 == 0x1 (0x1) +float 0xffff != 0x7 == 0x1 (0x1) +int 0xffff >= 0x7 == 0x0 (0x0) +__uint 0xffff >= 0x7 == 0x1 (0x1) +char 0xffff >= 0x7 == 0x0 (0x0) +__uchar 0xff >= 0x7 == 0x1 (0x1) +__longlong 0xffff >= 0x7 == 0x0 (0x0) +__ulonglong 0xffff >= 0x7 == 0x1 (0x1) +float 0xffff >= 0x7 == 0x0 (0x0) +int 0xffff / 0x7 == 0x0 (0x0) +__uint 0xffff / 0x7 == 0x2492 (0x2492) +char 0xffff / 0x7 == 0x0 (0x0) +__uchar 0xff / 0x7 == 0x24 (0x24) +__longlong 0xffff / 0x7 == 0x0 (0x0) +__ulonglong 0xffff / 0x7 == 0x4924 (0x4924) +float 0xffff / 0x7 == 0x0 (0x0) +int 0xffff % 0x7 == -0x1 (0xffff) +__uint 0xffff % 0x7 == 0x1 (0x1) +char 0xffff % 0x7 == -0x1 (0xffff) +__uchar 0xff % 0x7 == 0x3 (0x3) +__longlong 0xffff % 0x7 == -0x1 (0xffff) +__ulonglong 0xffff % 0x7 == 0x3 (0x3) +0xffff * 0x2a == -0x2a +0xffff / 0x2a == 0x0 +0xffff % 0x2a == -0x1 +int 0xffff ^ 0x2a == -0x2b (0xffd5) +__uint 0xffff ^ 0x2a == -0x2b (0xffd5) +char 0xffff ^ 0x2a == -0x2b (0xffd5) +__uchar 0xff ^ 0x2a == 0xd5 (0xd5) +__longlong 0xffff ^ 0x2a == -0x2b (0xffd5) +__ulonglong 0xffff ^ 0x2a == -0x2b (0xffd5) +int 0xffff && 0x2a == 0x1 (0x1) +__uint 0xffff && 0x2a == 0x1 (0x1) +char 0xffff && 0x2a == 0x1 (0x1) +__uchar 0xff && 0x2a == 0x1 (0x1) +__longlong 0xffff && 0x2a == 0x1 (0x1) +__ulonglong 0xffff && 0x2a == 0x1 (0x1) +int 0xffff || 0x2a == 0x1 (0x1) +__uint 0xffff || 0x2a == 0x1 (0x1) +char 0xffff || 0x2a == 0x1 (0x1) +__uchar 0xff || 0x2a == 0x1 (0x1) +__longlong 0xffff || 0x2a == 0x1 (0x1) +__ulonglong 0xffff || 0x2a == 0x1 (0x1) +int 0xffff & 0x2a == 0x2a (0x2a) +__uint 0xffff & 0x2a == 0x2a (0x2a) +char 0xffff & 0x2a == 0x2a (0x2a) +__uchar 0xff & 0x2a == 0x2a (0x2a) +__longlong 0xffff & 0x2a == 0x2a (0x2a) +__ulonglong 0xffff & 0x2a == 0x2a (0x2a) +int 0xffff | 0x2a == -0x1 (0xffff) +__uint 0xffff | 0x2a == -0x1 (0xffff) +char 0xffff | 0x2a == -0x1 (0xffff) +__uchar 0xff | 0x2a == 0xff (0xff) +__longlong 0xffff | 0x2a == -0x1 (0xffff) +__ulonglong 0xffff | 0x2a == -0x1 (0xffff) +int 0xffff << 0xc == -0x1000 (0xf000) +__uint 0xffff << 0xc == -0x1000 (0xf000) +char 0xffff << 0xc == 0x0 (0x0) +__uchar 0xff << 0xc == 0x0 (0x0) +__longlong 0xffff << 0xc == -0x1000 (0xf000) +__ulonglong 0xffff << 0xc == -0x1000 (0xf000) +int 0xffff >> 0xc == -0x1 (0xffff) +__uint 0xffff >> 0xc == 0xf (0xf) +char 0xffff >> 0xc == -0x1 (0xffff) +__uchar 0xff >> 0xc == 0x0 (0x0) +__longlong 0xffff >> 0xc == -0x1 (0xffff) +__ulonglong 0xffff >> 0xc == -0x1 (0xffff) +int 0xffff + 0x2a == 0x29 (0x29) +__uint 0xffff + 0x2a == 0x29 (0x29) +char 0xffff + 0x2a == 0x29 (0x29) +__uchar 0xff + 0x2a == 0x29 (0x29) +__longlong 0xffff + 0x2a == 0x29 (0x29) +__ulonglong 0xffff + 0x2a == 0x29 (0x29) +float 0xffff + 0x2a == 0x29 (0x29) +int 0xffff - 0x2a == -0x2b (0xffd5) +__uint 0xffff - 0x2a == -0x2b (0xffd5) +char 0xffff - 0x2a == -0x2b (0xffd5) +__uchar 0xff - 0x2a == 0xd5 (0xd5) +__longlong 0xffff - 0x2a == -0x2b (0xffd5) +__ulonglong 0xffff - 0x2a == -0x2b (0xffd5) +float 0xffff - 0x2a == -0x2b (0xffd5) +int 0xffff * 0x2a == -0x2a (0xffd6) +__uint 0xffff * 0x2a == -0x2a (0xffd6) +char 0xffff * 0x2a == -0x2a (0xffd6) +__uchar 0xff * 0x2a == 0xd6 (0xd6) +__longlong 0xffff * 0x2a == -0x2a (0xffd6) +__ulonglong 0xffff * 0x2a == -0x2a (0xffd6) +float 0xffff * 0x2a == -0x2a (0xffd6) +int 0xffff < 0x2a == 0x1 (0x1) +__uint 0xffff < 0x2a == 0x0 (0x0) +char 0xffff < 0x2a == 0x1 (0x1) +__uchar 0xff < 0x2a == 0x0 (0x0) +__longlong 0xffff < 0x2a == 0x1 (0x1) +__ulonglong 0xffff < 0x2a == 0x0 (0x0) +float 0xffff < 0x2a == 0x1 (0x1) +int 0xffff > 0x2a == 0x0 (0x0) +__uint 0xffff > 0x2a == 0x1 (0x1) +char 0xffff > 0x2a == 0x0 (0x0) +__uchar 0xff > 0x2a == 0x1 (0x1) +__longlong 0xffff > 0x2a == 0x0 (0x0) +__ulonglong 0xffff > 0x2a == 0x1 (0x1) +float 0xffff > 0x2a == 0x0 (0x0) +int 0xffff <= 0x2a == 0x1 (0x1) +__uint 0xffff <= 0x2a == 0x0 (0x0) +char 0xffff <= 0x2a == 0x1 (0x1) +__uchar 0xff <= 0x2a == 0x0 (0x0) +__longlong 0xffff <= 0x2a == 0x1 (0x1) +__ulonglong 0xffff <= 0x2a == 0x0 (0x0) +float 0xffff <= 0x2a == 0x1 (0x1) +int 0xffff == 0x2a == 0x0 (0x0) +__uint 0xffff == 0x2a == 0x0 (0x0) +char 0xffff == 0x2a == 0x0 (0x0) +__uchar 0xff == 0x2a == 0x0 (0x0) +__longlong 0xffff == 0x2a == 0x0 (0x0) +__ulonglong 0xffff == 0x2a == 0x0 (0x0) +float 0xffff == 0x2a == 0x0 (0x0) +int 0xffff != 0x2a == 0x1 (0x1) +__uint 0xffff != 0x2a == 0x1 (0x1) +char 0xffff != 0x2a == 0x1 (0x1) +__uchar 0xff != 0x2a == 0x1 (0x1) +__longlong 0xffff != 0x2a == 0x1 (0x1) +__ulonglong 0xffff != 0x2a == 0x1 (0x1) +float 0xffff != 0x2a == 0x1 (0x1) +int 0xffff >= 0x2a == 0x0 (0x0) +__uint 0xffff >= 0x2a == 0x1 (0x1) +char 0xffff >= 0x2a == 0x0 (0x0) +__uchar 0xff >= 0x2a == 0x1 (0x1) +__longlong 0xffff >= 0x2a == 0x0 (0x0) +__ulonglong 0xffff >= 0x2a == 0x1 (0x1) +float 0xffff >= 0x2a == 0x0 (0x0) +int 0xffff / 0x2a == 0x0 (0x0) +__uint 0xffff / 0x2a == 0x618 (0x618) +char 0xffff / 0x2a == 0x0 (0x0) +__uchar 0xff / 0x2a == 0x6 (0x6) +__longlong 0xffff / 0x2a == 0x0 (0x0) +__ulonglong 0xffff / 0x2a == 0x6186 (0x6186) +float 0xffff / 0x2a == 0x0 (0x0) +int 0xffff % 0x2a == -0x1 (0xffff) +__uint 0xffff % 0x2a == 0xf (0xf) +char 0xffff % 0x2a == -0x1 (0xffff) +__uchar 0xff % 0x2a == 0x3 (0x3) +__longlong 0xffff % 0x2a == -0x1 (0xffff) +__ulonglong 0xffff % 0x2a == 0x3 (0x3) +0xffff * 0x17 == -0x17 +0xffff / 0x17 == 0x0 +0xffff % 0x17 == -0x1 +int 0xffff ^ 0x17 == -0x18 (0xffe8) +__uint 0xffff ^ 0x17 == -0x18 (0xffe8) +char 0xffff ^ 0x17 == -0x18 (0xffe8) +__uchar 0xff ^ 0x17 == 0xe8 (0xe8) +__longlong 0xffff ^ 0x17 == -0x18 (0xffe8) +__ulonglong 0xffff ^ 0x17 == -0x18 (0xffe8) +int 0xffff && 0x17 == 0x1 (0x1) +__uint 0xffff && 0x17 == 0x1 (0x1) +char 0xffff && 0x17 == 0x1 (0x1) +__uchar 0xff && 0x17 == 0x1 (0x1) +__longlong 0xffff && 0x17 == 0x1 (0x1) +__ulonglong 0xffff && 0x17 == 0x1 (0x1) +int 0xffff || 0x17 == 0x1 (0x1) +__uint 0xffff || 0x17 == 0x1 (0x1) +char 0xffff || 0x17 == 0x1 (0x1) +__uchar 0xff || 0x17 == 0x1 (0x1) +__longlong 0xffff || 0x17 == 0x1 (0x1) +__ulonglong 0xffff || 0x17 == 0x1 (0x1) +int 0xffff & 0x17 == 0x17 (0x17) +__uint 0xffff & 0x17 == 0x17 (0x17) +char 0xffff & 0x17 == 0x17 (0x17) +__uchar 0xff & 0x17 == 0x17 (0x17) +__longlong 0xffff & 0x17 == 0x17 (0x17) +__ulonglong 0xffff & 0x17 == 0x17 (0x17) +int 0xffff | 0x17 == -0x1 (0xffff) +__uint 0xffff | 0x17 == -0x1 (0xffff) +char 0xffff | 0x17 == -0x1 (0xffff) +__uchar 0xff | 0x17 == 0xff (0xff) +__longlong 0xffff | 0x17 == -0x1 (0xffff) +__ulonglong 0xffff | 0x17 == -0x1 (0xffff) +int 0xffff << 0xe == -0x4000 (0xc000) +__uint 0xffff << 0xe == -0x4000 (0xc000) +char 0xffff << 0xe == 0x0 (0x0) +__uchar 0xff << 0xe == 0x0 (0x0) +__longlong 0xffff << 0xe == -0x4000 (0xc000) +__ulonglong 0xffff << 0xe == -0x4000 (0xc000) +int 0xffff >> 0xe == -0x1 (0xffff) +__uint 0xffff >> 0xe == 0x3 (0x3) +char 0xffff >> 0xe == -0x1 (0xffff) +__uchar 0xff >> 0xe == 0x0 (0x0) +__longlong 0xffff >> 0xe == -0x1 (0xffff) +__ulonglong 0xffff >> 0xe == -0x1 (0xffff) +int 0xffff + 0x17 == 0x16 (0x16) +__uint 0xffff + 0x17 == 0x16 (0x16) +char 0xffff + 0x17 == 0x16 (0x16) +__uchar 0xff + 0x17 == 0x16 (0x16) +__longlong 0xffff + 0x17 == 0x16 (0x16) +__ulonglong 0xffff + 0x17 == 0x16 (0x16) +float 0xffff + 0x17 == 0x16 (0x16) +int 0xffff - 0x17 == -0x18 (0xffe8) +__uint 0xffff - 0x17 == -0x18 (0xffe8) +char 0xffff - 0x17 == -0x18 (0xffe8) +__uchar 0xff - 0x17 == 0xe8 (0xe8) +__longlong 0xffff - 0x17 == -0x18 (0xffe8) +__ulonglong 0xffff - 0x17 == -0x18 (0xffe8) +float 0xffff - 0x17 == -0x18 (0xffe8) +int 0xffff * 0x17 == -0x17 (0xffe9) +__uint 0xffff * 0x17 == -0x17 (0xffe9) +char 0xffff * 0x17 == -0x17 (0xffe9) +__uchar 0xff * 0x17 == 0xe9 (0xe9) +__longlong 0xffff * 0x17 == -0x17 (0xffe9) +__ulonglong 0xffff * 0x17 == -0x17 (0xffe9) +float 0xffff * 0x17 == -0x17 (0xffe9) +int 0xffff < 0x17 == 0x1 (0x1) +__uint 0xffff < 0x17 == 0x0 (0x0) +char 0xffff < 0x17 == 0x1 (0x1) +__uchar 0xff < 0x17 == 0x0 (0x0) +__longlong 0xffff < 0x17 == 0x1 (0x1) +__ulonglong 0xffff < 0x17 == 0x0 (0x0) +float 0xffff < 0x17 == 0x1 (0x1) +int 0xffff > 0x17 == 0x0 (0x0) +__uint 0xffff > 0x17 == 0x1 (0x1) +char 0xffff > 0x17 == 0x0 (0x0) +__uchar 0xff > 0x17 == 0x1 (0x1) +__longlong 0xffff > 0x17 == 0x0 (0x0) +__ulonglong 0xffff > 0x17 == 0x1 (0x1) +float 0xffff > 0x17 == 0x0 (0x0) +int 0xffff <= 0x17 == 0x1 (0x1) +__uint 0xffff <= 0x17 == 0x0 (0x0) +char 0xffff <= 0x17 == 0x1 (0x1) +__uchar 0xff <= 0x17 == 0x0 (0x0) +__longlong 0xffff <= 0x17 == 0x1 (0x1) +__ulonglong 0xffff <= 0x17 == 0x0 (0x0) +float 0xffff <= 0x17 == 0x1 (0x1) +int 0xffff == 0x17 == 0x0 (0x0) +__uint 0xffff == 0x17 == 0x0 (0x0) +char 0xffff == 0x17 == 0x0 (0x0) +__uchar 0xff == 0x17 == 0x0 (0x0) +__longlong 0xffff == 0x17 == 0x0 (0x0) +__ulonglong 0xffff == 0x17 == 0x0 (0x0) +float 0xffff == 0x17 == 0x0 (0x0) +int 0xffff != 0x17 == 0x1 (0x1) +__uint 0xffff != 0x17 == 0x1 (0x1) +char 0xffff != 0x17 == 0x1 (0x1) +__uchar 0xff != 0x17 == 0x1 (0x1) +__longlong 0xffff != 0x17 == 0x1 (0x1) +__ulonglong 0xffff != 0x17 == 0x1 (0x1) +float 0xffff != 0x17 == 0x1 (0x1) +int 0xffff >= 0x17 == 0x0 (0x0) +__uint 0xffff >= 0x17 == 0x1 (0x1) +char 0xffff >= 0x17 == 0x0 (0x0) +__uchar 0xff >= 0x17 == 0x1 (0x1) +__longlong 0xffff >= 0x17 == 0x0 (0x0) +__ulonglong 0xffff >= 0x17 == 0x1 (0x1) +float 0xffff >= 0x17 == 0x0 (0x0) +int 0xffff / 0x17 == 0x0 (0x0) +__uint 0xffff / 0x17 == 0xb21 (0xb21) +char 0xffff / 0x17 == 0x0 (0x0) +__uchar 0xff / 0x17 == 0xb (0xb) +__longlong 0xffff / 0x17 == 0x0 (0x0) +__ulonglong 0xffff / 0x17 == 0x642c (0x642c) +float 0xffff / 0x17 == 0x0 (0x0) +int 0xffff % 0x17 == -0x1 (0xffff) +__uint 0xffff % 0x17 == 0x8 (0x8) +char 0xffff % 0x17 == -0x1 (0xffff) +__uchar 0xff % 0x17 == 0x2 (0x2) +__longlong 0xffff % 0x17 == -0x1 (0xffff) +__ulonglong 0xffff % 0x17 == 0xb (0xb) +0xffff * 0x7fff == -0x7fff +0xffff / 0x7fff == 0x0 +0xffff % 0x7fff == -0x1 +int 0xffff ^ 0x7fff == -0x8000 (0x8000) +__uint 0xffff ^ 0x7fff == -0x8000 (0x8000) +char 0xffff ^ 0xffff == 0x0 (0x0) +__uchar 0xff ^ 0xff == 0x0 (0x0) +__longlong 0xffff ^ 0x7fff == -0x8000 (0x8000) +__ulonglong 0xffff ^ 0x7fff == -0x8000 (0x8000) +int 0xffff && 0x7fff == 0x1 (0x1) +__uint 0xffff && 0x7fff == 0x1 (0x1) +char 0xffff && 0xffff == 0x1 (0x1) +__uchar 0xff && 0xff == 0x1 (0x1) +__longlong 0xffff && 0x7fff == 0x1 (0x1) +__ulonglong 0xffff && 0x7fff == 0x1 (0x1) +int 0xffff || 0x7fff == 0x1 (0x1) +__uint 0xffff || 0x7fff == 0x1 (0x1) +char 0xffff || 0xffff == 0x1 (0x1) +__uchar 0xff || 0xff == 0x1 (0x1) +__longlong 0xffff || 0x7fff == 0x1 (0x1) +__ulonglong 0xffff || 0x7fff == 0x1 (0x1) +int 0xffff & 0x7fff == 0x7fff (0x7fff) +__uint 0xffff & 0x7fff == 0x7fff (0x7fff) +char 0xffff & 0xffff == -0x1 (0xffff) +__uchar 0xff & 0xff == 0xff (0xff) +__longlong 0xffff & 0x7fff == 0x7fff (0x7fff) +__ulonglong 0xffff & 0x7fff == 0x7fff (0x7fff) +int 0xffff | 0x7fff == -0x1 (0xffff) +__uint 0xffff | 0x7fff == -0x1 (0xffff) +char 0xffff | 0xffff == -0x1 (0xffff) +__uchar 0xff | 0xff == 0xff (0xff) +__longlong 0xffff | 0x7fff == -0x1 (0xffff) +__ulonglong 0xffff | 0x7fff == -0x1 (0xffff) +int 0xffff << 0x10 == 0x0 (0x0) +__uint 0xffff << 0x10 == 0x0 (0x0) +char 0xffff << 0x10 == 0x0 (0x0) +__uchar 0xff << 0x10 == 0x0 (0x0) +__longlong 0xffff << 0x10 == 0x0 (0x0) +__ulonglong 0xffff << 0x10 == 0x0 (0x0) +int 0xffff >> 0x10 == -0x1 (0xffff) +__uint 0xffff >> 0x10 == 0x0 (0x0) +char 0xffff >> 0x10 == -0x1 (0xffff) +__uchar 0xff >> 0x10 == 0x0 (0x0) +__longlong 0xffff >> 0x10 == -0x1 (0xffff) +__ulonglong 0xffff >> 0x10 == -0x1 (0xffff) +int 0xffff + 0x7fff == 0x7ffe (0x7ffe) +__uint 0xffff + 0x7fff == 0x7ffe (0x7ffe) +char 0xffff + 0xffff == -0x2 (0xfffe) +__uchar 0xff + 0xff == 0xfe (0xfe) +__longlong 0xffff + 0x7fff == 0x7ffe (0x7ffe) +__ulonglong 0xffff + 0x7fff == 0x7ffe (0x7ffe) +float 0xffff + 0x7fff == 0x7ffe (0x7ffe) +int 0xffff - 0x7fff == -0x8000 (0x8000) +__uint 0xffff - 0x7fff == -0x8000 (0x8000) +char 0xffff - 0xffff == 0x0 (0x0) +__uchar 0xff - 0xff == 0x0 (0x0) +__longlong 0xffff - 0x7fff == -0x8000 (0x8000) +__ulonglong 0xffff - 0x7fff == -0x8000 (0x8000) +float 0xffff - 0x7fff == -0x8000 (0x8000) +int 0xffff * 0x7fff == -0x7fff (0x8001) +__uint 0xffff * 0x7fff == -0x7fff (0x8001) +char 0xffff * 0xffff == 0x1 (0x1) +__uchar 0xff * 0xff == 0x1 (0x1) +__longlong 0xffff * 0x7fff == -0x7fff (0x8001) +__ulonglong 0xffff * 0x7fff == -0x7fff (0x8001) +float 0xffff * 0x7fff == -0x7fff (0x8001) +int 0xffff < 0x7fff == 0x1 (0x1) +__uint 0xffff < 0x7fff == 0x0 (0x0) +char 0xffff < 0xffff == 0x0 (0x0) +__uchar 0xff < 0xff == 0x0 (0x0) +__longlong 0xffff < 0x7fff == 0x1 (0x1) +__ulonglong 0xffff < 0x7fff == 0x0 (0x0) +float 0xffff < 0x7fff == 0x1 (0x1) +int 0xffff > 0x7fff == 0x0 (0x0) +__uint 0xffff > 0x7fff == 0x1 (0x1) +char 0xffff > 0xffff == 0x0 (0x0) +__uchar 0xff > 0xff == 0x0 (0x0) +__longlong 0xffff > 0x7fff == 0x0 (0x0) +__ulonglong 0xffff > 0x7fff == 0x1 (0x1) +float 0xffff > 0x7fff == 0x0 (0x0) +int 0xffff <= 0x7fff == 0x1 (0x1) +__uint 0xffff <= 0x7fff == 0x0 (0x0) +char 0xffff <= 0xffff == 0x1 (0x1) +__uchar 0xff <= 0xff == 0x1 (0x1) +__longlong 0xffff <= 0x7fff == 0x1 (0x1) +__ulonglong 0xffff <= 0x7fff == 0x0 (0x0) +float 0xffff <= 0x7fff == 0x1 (0x1) +int 0xffff == 0x7fff == 0x0 (0x0) +__uint 0xffff == 0x7fff == 0x0 (0x0) +char 0xffff == 0xffff == 0x1 (0x1) +__uchar 0xff == 0xff == 0x1 (0x1) +__longlong 0xffff == 0x7fff == 0x0 (0x0) +__ulonglong 0xffff == 0x7fff == 0x0 (0x0) +float 0xffff == 0x7fff == 0x0 (0x0) +int 0xffff != 0x7fff == 0x1 (0x1) +__uint 0xffff != 0x7fff == 0x1 (0x1) +char 0xffff != 0xffff == 0x0 (0x0) +__uchar 0xff != 0xff == 0x0 (0x0) +__longlong 0xffff != 0x7fff == 0x1 (0x1) +__ulonglong 0xffff != 0x7fff == 0x1 (0x1) +float 0xffff != 0x7fff == 0x1 (0x1) +int 0xffff >= 0x7fff == 0x0 (0x0) +__uint 0xffff >= 0x7fff == 0x1 (0x1) +char 0xffff >= 0xffff == 0x1 (0x1) +__uchar 0xff >= 0xff == 0x1 (0x1) +__longlong 0xffff >= 0x7fff == 0x0 (0x0) +__ulonglong 0xffff >= 0x7fff == 0x1 (0x1) +float 0xffff >= 0x7fff == 0x0 (0x0) +int 0xffff / 0x7fff == 0x0 (0x0) +__uint 0xffff / 0x7fff == 0x2 (0x2) +char 0xffff / 0xffff == 0x1 (0x1) +__uchar 0xff / 0xff == 0x1 (0x1) +__longlong 0xffff / 0x7fff == 0x0 (0x0) +__ulonglong 0xffff / 0x7fff == 0x4 (0x4) +float 0xffff / 0x7fff == 0x0 (0x0) +int 0xffff % 0x7fff == -0x1 (0xffff) +__uint 0xffff % 0x7fff == 0x1 (0x1) +char 0xffff % 0xffff == 0x0 (0x0) +__uchar 0xff % 0xff == 0x0 (0x0) +__longlong 0xffff % 0x7fff == -0x1 (0xffff) +__ulonglong 0xffff % 0x7fff == 0x3 (0x3) +0xffff * 0x8000 == -0x8000 +0xffff / 0x8000 == 0x0 +0xffff % 0x8000 == -0x1 +int 0xffff ^ 0x8000 == 0x7fff (0x7fff) +__uint 0xffff ^ 0x8000 == 0x7fff (0x7fff) +char 0xffff ^ 0x0 == -0x1 (0xffff) +__uchar 0xff ^ 0x0 == 0xff (0xff) +__longlong 0xffff ^ 0x8000 == 0x7fff (0x7fff) +__ulonglong 0xffff ^ 0x8000 == 0x7fff (0x7fff) +int 0xffff && 0x8000 == 0x1 (0x1) +__uint 0xffff && 0x8000 == 0x1 (0x1) +char 0xffff && 0x0 == 0x0 (0x0) +__uchar 0xff && 0x0 == 0x0 (0x0) +__longlong 0xffff && 0x8000 == 0x1 (0x1) +__ulonglong 0xffff && 0x8000 == 0x1 (0x1) +int 0xffff || 0x8000 == 0x1 (0x1) +__uint 0xffff || 0x8000 == 0x1 (0x1) +char 0xffff || 0x0 == 0x1 (0x1) +__uchar 0xff || 0x0 == 0x1 (0x1) +__longlong 0xffff || 0x8000 == 0x1 (0x1) +__ulonglong 0xffff || 0x8000 == 0x1 (0x1) +int 0xffff & 0x8000 == -0x8000 (0x8000) +__uint 0xffff & 0x8000 == -0x8000 (0x8000) +char 0xffff & 0x0 == 0x0 (0x0) +__uchar 0xff & 0x0 == 0x0 (0x0) +__longlong 0xffff & 0x8000 == -0x8000 (0x8000) +__ulonglong 0xffff & 0x8000 == -0x8000 (0x8000) +int 0xffff | 0x8000 == -0x1 (0xffff) +__uint 0xffff | 0x8000 == -0x1 (0xffff) +char 0xffff | 0x0 == -0x1 (0xffff) +__uchar 0xff | 0x0 == 0xff (0xff) +__longlong 0xffff | 0x8000 == -0x1 (0xffff) +__ulonglong 0xffff | 0x8000 == -0x1 (0xffff) +int 0xffff << 0x12 == 0x0 (0x0) +__uint 0xffff << 0x12 == 0x0 (0x0) +char 0xffff << 0x12 == 0x0 (0x0) +__uchar 0xff << 0x12 == 0x0 (0x0) +__longlong 0xffff << 0x12 == 0x0 (0x0) +__ulonglong 0xffff << 0x12 == 0x0 (0x0) +int 0xffff >> 0x12 == -0x1 (0xffff) +__uint 0xffff >> 0x12 == 0x0 (0x0) +char 0xffff >> 0x12 == -0x1 (0xffff) +__uchar 0xff >> 0x12 == 0x0 (0x0) +__longlong 0xffff >> 0x12 == -0x1 (0xffff) +__ulonglong 0xffff >> 0x12 == 0x3fff (0x3fff) +int 0xffff + 0x8000 == 0x7fff (0x7fff) +__uint 0xffff + 0x8000 == 0x7fff (0x7fff) +char 0xffff + 0x0 == -0x1 (0xffff) +__uchar 0xff + 0x0 == 0xff (0xff) +__longlong 0xffff + 0x8000 == 0x7fff (0x7fff) +__ulonglong 0xffff + 0x8000 == 0x7fff (0x7fff) +float 0xffff + 0x8000 == -0x8000 (0x8000) +int 0xffff - 0x8000 == 0x7fff (0x7fff) +__uint 0xffff - 0x8000 == 0x7fff (0x7fff) +char 0xffff - 0x0 == -0x1 (0xffff) +__uchar 0xff - 0x0 == 0xff (0xff) +__longlong 0xffff - 0x8000 == 0x7fff (0x7fff) +__ulonglong 0xffff - 0x8000 == 0x7fff (0x7fff) +float 0xffff - 0x8000 == 0x7fff (0x7fff) +int 0xffff * 0x8000 == -0x8000 (0x8000) +__uint 0xffff * 0x8000 == -0x8000 (0x8000) +char 0xffff * 0x0 == 0x0 (0x0) +__uchar 0xff * 0x0 == 0x0 (0x0) +__longlong 0xffff * 0x8000 == -0x8000 (0x8000) +__ulonglong 0xffff * 0x8000 == -0x8000 (0x8000) +float 0xffff * 0x8000 == -0x8000 (0x8000) +int 0xffff < 0x8000 == 0x0 (0x0) +__uint 0xffff < 0x8000 == 0x0 (0x0) +char 0xffff < 0x0 == 0x1 (0x1) +__uchar 0xff < 0x0 == 0x0 (0x0) +__longlong 0xffff < 0x8000 == 0x0 (0x0) +__ulonglong 0xffff < 0x8000 == 0x0 (0x0) +float 0xffff < 0x8000 == 0x0 (0x0) +int 0xffff > 0x8000 == 0x1 (0x1) +__uint 0xffff > 0x8000 == 0x1 (0x1) +char 0xffff > 0x0 == 0x0 (0x0) +__uchar 0xff > 0x0 == 0x1 (0x1) +__longlong 0xffff > 0x8000 == 0x1 (0x1) +__ulonglong 0xffff > 0x8000 == 0x1 (0x1) +float 0xffff > 0x8000 == 0x1 (0x1) +int 0xffff <= 0x8000 == 0x0 (0x0) +__uint 0xffff <= 0x8000 == 0x0 (0x0) +char 0xffff <= 0x0 == 0x1 (0x1) +__uchar 0xff <= 0x0 == 0x0 (0x0) +__longlong 0xffff <= 0x8000 == 0x0 (0x0) +__ulonglong 0xffff <= 0x8000 == 0x0 (0x0) +float 0xffff <= 0x8000 == 0x0 (0x0) +int 0xffff == 0x8000 == 0x0 (0x0) +__uint 0xffff == 0x8000 == 0x0 (0x0) +char 0xffff == 0x0 == 0x0 (0x0) +__uchar 0xff == 0x0 == 0x0 (0x0) +__longlong 0xffff == 0x8000 == 0x0 (0x0) +__ulonglong 0xffff == 0x8000 == 0x0 (0x0) +float 0xffff == 0x8000 == 0x0 (0x0) +int 0xffff != 0x8000 == 0x1 (0x1) +__uint 0xffff != 0x8000 == 0x1 (0x1) +char 0xffff != 0x0 == 0x1 (0x1) +__uchar 0xff != 0x0 == 0x1 (0x1) +__longlong 0xffff != 0x8000 == 0x1 (0x1) +__ulonglong 0xffff != 0x8000 == 0x1 (0x1) +float 0xffff != 0x8000 == 0x1 (0x1) +int 0xffff >= 0x8000 == 0x1 (0x1) +__uint 0xffff >= 0x8000 == 0x1 (0x1) +char 0xffff >= 0x0 == 0x0 (0x0) +__uchar 0xff >= 0x0 == 0x1 (0x1) +__longlong 0xffff >= 0x8000 == 0x1 (0x1) +__ulonglong 0xffff >= 0x8000 == 0x1 (0x1) +float 0xffff >= 0x8000 == 0x1 (0x1) +int 0xffff / 0x8000 == 0x0 (0x0) +__uint 0xffff / 0x8000 == 0x1 (0x1) +__longlong 0xffff / 0x8000 == 0x0 (0x0) +__ulonglong 0xffff / 0x8000 == 0x1 (0x1) +float 0xffff / 0x8000 == 0x0 (0x0) +int 0xffff % 0x8000 == -0x1 (0xffff) +__uint 0xffff % 0x8000 == 0x7fff (0x7fff) +__longlong 0xffff % 0x8000 == -0x1 (0xffff) +__ulonglong 0xffff % 0x8000 == 0x7fff (0x7fff) +0xffff * 0x3e8 == -0x3e8 +0xffff / 0x3e8 == 0x0 +0xffff % 0x3e8 == -0x1 +int 0xffff ^ 0x3e8 == -0x3e9 (0xfc17) +__uint 0xffff ^ 0x3e8 == -0x3e9 (0xfc17) +char 0xffff ^ 0xffe8 == 0x17 (0x17) +__uchar 0xff ^ 0xe8 == 0x17 (0x17) +__longlong 0xffff ^ 0x3e8 == -0x3e9 (0xfc17) +__ulonglong 0xffff ^ 0x3e8 == -0x3e9 (0xfc17) +int 0xffff && 0x3e8 == 0x1 (0x1) +__uint 0xffff && 0x3e8 == 0x1 (0x1) +char 0xffff && 0xffe8 == 0x1 (0x1) +__uchar 0xff && 0xe8 == 0x1 (0x1) +__longlong 0xffff && 0x3e8 == 0x1 (0x1) +__ulonglong 0xffff && 0x3e8 == 0x1 (0x1) +int 0xffff || 0x3e8 == 0x1 (0x1) +__uint 0xffff || 0x3e8 == 0x1 (0x1) +char 0xffff || 0xffe8 == 0x1 (0x1) +__uchar 0xff || 0xe8 == 0x1 (0x1) +__longlong 0xffff || 0x3e8 == 0x1 (0x1) +__ulonglong 0xffff || 0x3e8 == 0x1 (0x1) +int 0xffff & 0x3e8 == 0x3e8 (0x3e8) +__uint 0xffff & 0x3e8 == 0x3e8 (0x3e8) +char 0xffff & 0xffe8 == -0x18 (0xffe8) +__uchar 0xff & 0xe8 == 0xe8 (0xe8) +__longlong 0xffff & 0x3e8 == 0x3e8 (0x3e8) +__ulonglong 0xffff & 0x3e8 == 0x3e8 (0x3e8) +int 0xffff | 0x3e8 == -0x1 (0xffff) +__uint 0xffff | 0x3e8 == -0x1 (0xffff) +char 0xffff | 0xffe8 == -0x1 (0xffff) +__uchar 0xff | 0xe8 == 0xff (0xff) +__longlong 0xffff | 0x3e8 == -0x1 (0xffff) +__ulonglong 0xffff | 0x3e8 == -0x1 (0xffff) +int 0xffff << 0x14 == 0x0 (0x0) +__uint 0xffff << 0x14 == 0x0 (0x0) +char 0xffff << 0x14 == 0x0 (0x0) +__uchar 0xff << 0x14 == 0x0 (0x0) +__longlong 0xffff << 0x14 == 0x0 (0x0) +__ulonglong 0xffff << 0x14 == 0x0 (0x0) +int 0xffff >> 0x14 == -0x1 (0xffff) +__uint 0xffff >> 0x14 == 0x0 (0x0) +char 0xffff >> 0x14 == -0x1 (0xffff) +__uchar 0xff >> 0x14 == 0x0 (0x0) +__longlong 0xffff >> 0x14 == -0x1 (0xffff) +__ulonglong 0xffff >> 0x14 == 0xfff (0xfff) +int 0xffff + 0x3e8 == 0x3e7 (0x3e7) +__uint 0xffff + 0x3e8 == 0x3e7 (0x3e7) +char 0xffff + 0xffe8 == -0x19 (0xffe7) +__uchar 0xff + 0xe8 == 0xe7 (0xe7) +__longlong 0xffff + 0x3e8 == 0x3e7 (0x3e7) +__ulonglong 0xffff + 0x3e8 == 0x3e7 (0x3e7) +float 0xffff + 0x3e8 == 0x3e7 (0x3e7) +int 0xffff - 0x3e8 == -0x3e9 (0xfc17) +__uint 0xffff - 0x3e8 == -0x3e9 (0xfc17) +char 0xffff - 0xffe8 == 0x17 (0x17) +__uchar 0xff - 0xe8 == 0x17 (0x17) +__longlong 0xffff - 0x3e8 == -0x3e9 (0xfc17) +__ulonglong 0xffff - 0x3e8 == -0x3e9 (0xfc17) +float 0xffff - 0x3e8 == -0x3e9 (0xfc17) +int 0xffff * 0x3e8 == -0x3e8 (0xfc18) +__uint 0xffff * 0x3e8 == -0x3e8 (0xfc18) +char 0xffff * 0xffe8 == 0x18 (0x18) +__uchar 0xff * 0xe8 == 0x18 (0x18) +__longlong 0xffff * 0x3e8 == -0x3e8 (0xfc18) +__ulonglong 0xffff * 0x3e8 == -0x3e8 (0xfc18) +float 0xffff * 0x3e8 == -0x3e8 (0xfc18) +int 0xffff < 0x3e8 == 0x1 (0x1) +__uint 0xffff < 0x3e8 == 0x0 (0x0) +char 0xffff < 0xffe8 == 0x0 (0x0) +__uchar 0xff < 0xe8 == 0x0 (0x0) +__longlong 0xffff < 0x3e8 == 0x1 (0x1) +__ulonglong 0xffff < 0x3e8 == 0x0 (0x0) +float 0xffff < 0x3e8 == 0x1 (0x1) +int 0xffff > 0x3e8 == 0x0 (0x0) +__uint 0xffff > 0x3e8 == 0x1 (0x1) +char 0xffff > 0xffe8 == 0x1 (0x1) +__uchar 0xff > 0xe8 == 0x1 (0x1) +__longlong 0xffff > 0x3e8 == 0x0 (0x0) +__ulonglong 0xffff > 0x3e8 == 0x1 (0x1) +float 0xffff > 0x3e8 == 0x0 (0x0) +int 0xffff <= 0x3e8 == 0x1 (0x1) +__uint 0xffff <= 0x3e8 == 0x0 (0x0) +char 0xffff <= 0xffe8 == 0x0 (0x0) +__uchar 0xff <= 0xe8 == 0x0 (0x0) +__longlong 0xffff <= 0x3e8 == 0x1 (0x1) +__ulonglong 0xffff <= 0x3e8 == 0x0 (0x0) +float 0xffff <= 0x3e8 == 0x1 (0x1) +int 0xffff == 0x3e8 == 0x0 (0x0) +__uint 0xffff == 0x3e8 == 0x0 (0x0) +char 0xffff == 0xffe8 == 0x0 (0x0) +__uchar 0xff == 0xe8 == 0x0 (0x0) +__longlong 0xffff == 0x3e8 == 0x0 (0x0) +__ulonglong 0xffff == 0x3e8 == 0x0 (0x0) +float 0xffff == 0x3e8 == 0x0 (0x0) +int 0xffff != 0x3e8 == 0x1 (0x1) +__uint 0xffff != 0x3e8 == 0x1 (0x1) +char 0xffff != 0xffe8 == 0x1 (0x1) +__uchar 0xff != 0xe8 == 0x1 (0x1) +__longlong 0xffff != 0x3e8 == 0x1 (0x1) +__ulonglong 0xffff != 0x3e8 == 0x1 (0x1) +float 0xffff != 0x3e8 == 0x1 (0x1) +int 0xffff >= 0x3e8 == 0x0 (0x0) +__uint 0xffff >= 0x3e8 == 0x1 (0x1) +char 0xffff >= 0xffe8 == 0x1 (0x1) +__uchar 0xff >= 0xe8 == 0x1 (0x1) +__longlong 0xffff >= 0x3e8 == 0x0 (0x0) +__ulonglong 0xffff >= 0x3e8 == 0x1 (0x1) +float 0xffff >= 0x3e8 == 0x0 (0x0) +int 0xffff / 0x3e8 == 0x0 (0x0) +__uint 0xffff / 0x3e8 == 0x41 (0x41) +char 0xffff / 0xffe8 == 0x0 (0x0) +__uchar 0xff / 0xe8 == 0x1 (0x1) +__longlong 0xffff / 0x3e8 == 0x0 (0x0) +__ulonglong 0xffff / 0x3e8 == -0x76c9 (0x8937) +float 0xffff / 0x3e8 == 0x0 (0x0) +int 0xffff % 0x3e8 == -0x1 (0xffff) +__uint 0xffff % 0x3e8 == 0x217 (0x217) +char 0xffff % 0xffe8 == -0x1 (0xffff) +__uchar 0xff % 0xe8 == 0x17 (0x17) +__longlong 0xffff % 0x3e8 == -0x1 (0xffff) +__ulonglong 0xffff % 0x3e8 == 0x127 (0x127) +0xffff * 0x2710 == -0x2710 +0xffff / 0x2710 == 0x0 +0xffff % 0x2710 == -0x1 +int 0xffff ^ 0x2710 == -0x2711 (0xd8ef) +__uint 0xffff ^ 0x2710 == -0x2711 (0xd8ef) +char 0xffff ^ 0x10 == -0x11 (0xffef) +__uchar 0xff ^ 0x10 == 0xef (0xef) +__longlong 0xffff ^ 0x2710 == -0x2711 (0xd8ef) +__ulonglong 0xffff ^ 0x2710 == -0x2711 (0xd8ef) +int 0xffff && 0x2710 == 0x1 (0x1) +__uint 0xffff && 0x2710 == 0x1 (0x1) +char 0xffff && 0x10 == 0x1 (0x1) +__uchar 0xff && 0x10 == 0x1 (0x1) +__longlong 0xffff && 0x2710 == 0x1 (0x1) +__ulonglong 0xffff && 0x2710 == 0x1 (0x1) +int 0xffff || 0x2710 == 0x1 (0x1) +__uint 0xffff || 0x2710 == 0x1 (0x1) +char 0xffff || 0x10 == 0x1 (0x1) +__uchar 0xff || 0x10 == 0x1 (0x1) +__longlong 0xffff || 0x2710 == 0x1 (0x1) +__ulonglong 0xffff || 0x2710 == 0x1 (0x1) +int 0xffff & 0x2710 == 0x2710 (0x2710) +__uint 0xffff & 0x2710 == 0x2710 (0x2710) +char 0xffff & 0x10 == 0x10 (0x10) +__uchar 0xff & 0x10 == 0x10 (0x10) +__longlong 0xffff & 0x2710 == 0x2710 (0x2710) +__ulonglong 0xffff & 0x2710 == 0x2710 (0x2710) +int 0xffff | 0x2710 == -0x1 (0xffff) +__uint 0xffff | 0x2710 == -0x1 (0xffff) +char 0xffff | 0x10 == -0x1 (0xffff) +__uchar 0xff | 0x10 == 0xff (0xff) +__longlong 0xffff | 0x2710 == -0x1 (0xffff) +__ulonglong 0xffff | 0x2710 == -0x1 (0xffff) +int 0xffff << 0x16 == 0x0 (0x0) +__uint 0xffff << 0x16 == 0x0 (0x0) +char 0xffff << 0x16 == 0x0 (0x0) +__uchar 0xff << 0x16 == 0x0 (0x0) +__longlong 0xffff << 0x16 == 0x0 (0x0) +__ulonglong 0xffff << 0x16 == 0x0 (0x0) +int 0xffff >> 0x16 == -0x1 (0xffff) +__uint 0xffff >> 0x16 == 0x0 (0x0) +char 0xffff >> 0x16 == -0x1 (0xffff) +__uchar 0xff >> 0x16 == 0x0 (0x0) +__longlong 0xffff >> 0x16 == -0x1 (0xffff) +__ulonglong 0xffff >> 0x16 == 0x3ff (0x3ff) +int 0xffff + 0x2710 == 0x270f (0x270f) +__uint 0xffff + 0x2710 == 0x270f (0x270f) +char 0xffff + 0x10 == 0xf (0xf) +__uchar 0xff + 0x10 == 0xf (0xf) +__longlong 0xffff + 0x2710 == 0x270f (0x270f) +__ulonglong 0xffff + 0x2710 == 0x270f (0x270f) +float 0xffff + 0x2710 == 0x270f (0x270f) +int 0xffff - 0x2710 == -0x2711 (0xd8ef) +__uint 0xffff - 0x2710 == -0x2711 (0xd8ef) +char 0xffff - 0x10 == -0x11 (0xffef) +__uchar 0xff - 0x10 == 0xef (0xef) +__longlong 0xffff - 0x2710 == -0x2711 (0xd8ef) +__ulonglong 0xffff - 0x2710 == -0x2711 (0xd8ef) +float 0xffff - 0x2710 == -0x2711 (0xd8ef) +int 0xffff * 0x2710 == -0x2710 (0xd8f0) +__uint 0xffff * 0x2710 == -0x2710 (0xd8f0) +char 0xffff * 0x10 == -0x10 (0xfff0) +__uchar 0xff * 0x10 == 0xf0 (0xf0) +__longlong 0xffff * 0x2710 == -0x2710 (0xd8f0) +__ulonglong 0xffff * 0x2710 == -0x2710 (0xd8f0) +float 0xffff * 0x2710 == -0x2710 (0xd8f0) +int 0xffff < 0x2710 == 0x1 (0x1) +__uint 0xffff < 0x2710 == 0x0 (0x0) +char 0xffff < 0x10 == 0x1 (0x1) +__uchar 0xff < 0x10 == 0x0 (0x0) +__longlong 0xffff < 0x2710 == 0x1 (0x1) +__ulonglong 0xffff < 0x2710 == 0x0 (0x0) +float 0xffff < 0x2710 == 0x1 (0x1) +int 0xffff > 0x2710 == 0x0 (0x0) +__uint 0xffff > 0x2710 == 0x1 (0x1) +char 0xffff > 0x10 == 0x0 (0x0) +__uchar 0xff > 0x10 == 0x1 (0x1) +__longlong 0xffff > 0x2710 == 0x0 (0x0) +__ulonglong 0xffff > 0x2710 == 0x1 (0x1) +float 0xffff > 0x2710 == 0x0 (0x0) +int 0xffff <= 0x2710 == 0x1 (0x1) +__uint 0xffff <= 0x2710 == 0x0 (0x0) +char 0xffff <= 0x10 == 0x1 (0x1) +__uchar 0xff <= 0x10 == 0x0 (0x0) +__longlong 0xffff <= 0x2710 == 0x1 (0x1) +__ulonglong 0xffff <= 0x2710 == 0x0 (0x0) +float 0xffff <= 0x2710 == 0x1 (0x1) +int 0xffff == 0x2710 == 0x0 (0x0) +__uint 0xffff == 0x2710 == 0x0 (0x0) +char 0xffff == 0x10 == 0x0 (0x0) +__uchar 0xff == 0x10 == 0x0 (0x0) +__longlong 0xffff == 0x2710 == 0x0 (0x0) +__ulonglong 0xffff == 0x2710 == 0x0 (0x0) +float 0xffff == 0x2710 == 0x0 (0x0) +int 0xffff != 0x2710 == 0x1 (0x1) +__uint 0xffff != 0x2710 == 0x1 (0x1) +char 0xffff != 0x10 == 0x1 (0x1) +__uchar 0xff != 0x10 == 0x1 (0x1) +__longlong 0xffff != 0x2710 == 0x1 (0x1) +__ulonglong 0xffff != 0x2710 == 0x1 (0x1) +float 0xffff != 0x2710 == 0x1 (0x1) +int 0xffff >= 0x2710 == 0x0 (0x0) +__uint 0xffff >= 0x2710 == 0x1 (0x1) +char 0xffff >= 0x10 == 0x0 (0x0) +__uchar 0xff >= 0x10 == 0x1 (0x1) +__longlong 0xffff >= 0x2710 == 0x0 (0x0) +__ulonglong 0xffff >= 0x2710 == 0x1 (0x1) +float 0xffff >= 0x2710 == 0x0 (0x0) +int 0xffff / 0x2710 == 0x0 (0x0) +__uint 0xffff / 0x2710 == 0x6 (0x6) +char 0xffff / 0x10 == 0x0 (0x0) +__uchar 0xff / 0x10 == 0xf (0xf) +__longlong 0xffff / 0x2710 == 0x0 (0x0) +__ulonglong 0xffff / 0x2710 == -0x7248 (0x8db8) +float 0xffff / 0x2710 == 0x0 (0x0) +int 0xffff % 0x2710 == -0x1 (0xffff) +__uint 0xffff % 0x2710 == 0x159f (0x159f) +char 0xffff % 0x10 == -0x1 (0xffff) +__uchar 0xff % 0x10 == 0xf (0xf) +__longlong 0xffff % 0x2710 == -0x1 (0xffff) +__ulonglong 0xffff % 0x2710 == 0x1c7f (0x1c7f) +int xor42-0x1 xor42 -0x2b +__uint xor42-0x1 xor42 -0x2b +char xor42-0x1 xor42 -0x2b +__uchar xor420xff xor42 0xd5 +__longlong xor42-0x1 xor42 -0x2b +__ulonglong xor42-0x1 xor42 -0x2b +int land1-0x1 land1 0x1 +__uint land1-0x1 land1 0x1 +char land1-0x1 land1 0x1 +__uchar land10xff land1 0x1 +__longlong land1-0x1 land1 0x1 +__ulonglong land1-0x1 land1 0x1 +int lor1-0x1 lor1 0x1 +__uint lor1-0x1 lor1 0x1 +char lor1-0x1 lor1 0x1 +__uchar lor10xff lor1 0x1 +__longlong lor1-0x1 lor1 0x1 +__ulonglong lor1-0x1 lor1 0x1 +int and42-0x1 and42 0x2a +__uint and42-0x1 and42 0x2a +char and42-0x1 and42 0x2a +__uchar and420xff and42 0x2a +__longlong and42-0x1 and42 0x2a +__ulonglong and42-0x1 and42 0x2a +int or42-0x1 or42 -0x1 +__uint or42-0x1 or42 -0x1 +char or42-0x1 or42 -0x1 +__uchar or420xff or42 0xff +__longlong or42-0x1 or42 -0x1 +__ulonglong or42-0x1 or42 -0x1 +int shl5-0x1 shl5 -0x20 +__uint shl5-0x1 shl5 -0x20 +char shl5-0x1 shl5 -0x20 +__uchar shl50xff shl5 0xe0 +__longlong shl5-0x1 shl5 -0x20 +__ulonglong shl5-0x1 shl5 -0x20 +int shr5-0x1 shr5 -0x1 +__uint shr5-0x1 shr5 0x7ff +char shr5-0x1 shr5 -0x1 +__uchar shr50xff shr5 0x7 +__longlong shr5-0x1 shr5 -0x1 +__ulonglong shr5-0x1 shr5 -0x1 +int add42-0x1 add42 0x29 +__uint add42-0x1 add42 0x29 +char add42-0x1 add42 0x29 +__uchar add420xff add42 0x29 +__longlong add42-0x1 add42 0x29 +__ulonglong add42-0x1 add42 0x29 +float add42-0x1 add42 0x29 +int sub42-0x1 sub42 -0x2b +__uint sub42-0x1 sub42 -0x2b +char sub42-0x1 sub42 -0x2b +__uchar sub420xff sub42 0xd5 +__longlong sub42-0x1 sub42 -0x2b +__ulonglong sub42-0x1 sub42 -0x2b +float sub42-0x1 sub42 -0x2b +int mul42-0x1 mul42 -0x2a +__uint mul42-0x1 mul42 -0x2a +char mul42-0x1 mul42 -0x2a +__uchar mul420xff mul42 0xd6 +__longlong mul42-0x1 mul42 -0x2a +__ulonglong mul42-0x1 mul42 -0x2a +float mul42-0x1 mul42 -0x2a +int lt42-0x1 lt42 0x1 +__uint lt42-0x1 lt42 0x0 +char lt42-0x1 lt42 0x1 +__uchar lt420xff lt42 0x0 +__longlong lt42-0x1 lt42 0x1 +__ulonglong lt42-0x1 lt42 0x0 +float lt42-0x1 lt42 0x1 +int gt42-0x1 gt42 0x0 +__uint gt42-0x1 gt42 0x1 +char gt42-0x1 gt42 0x0 +__uchar gt420xff gt42 0x1 +__longlong gt42-0x1 gt42 0x0 +__ulonglong gt42-0x1 gt42 0x1 +float gt42-0x1 gt42 0x0 +int le42-0x1 le42 0x1 +__uint le42-0x1 le42 0x0 +char le42-0x1 le42 0x1 +__uchar le420xff le42 0x0 +__longlong le42-0x1 le42 0x1 +__ulonglong le42-0x1 le42 0x0 +float le42-0x1 le42 0x1 +int eq42-0x1 eq42 0x0 +__uint eq42-0x1 eq42 0x0 +char eq42-0x1 eq42 0x0 +__uchar eq420xff eq42 0x0 +__longlong eq42-0x1 eq42 0x0 +__ulonglong eq42-0x1 eq42 0x0 +float eq42-0x1 eq42 0x0 +int ne42-0x1 ne42 0x1 +__uint ne42-0x1 ne42 0x1 +char ne42-0x1 ne42 0x1 +__uchar ne420xff ne42 0x1 +__longlong ne42-0x1 ne42 0x1 +__ulonglong ne42-0x1 ne42 0x1 +float ne42-0x1 ne42 0x1 +int ge42-0x1 ge42 0x0 +__uint ge42-0x1 ge42 0x1 +char ge42-0x1 ge42 0x0 +__uchar ge420xff ge42 0x1 +__longlong ge42-0x1 ge42 0x0 +__ulonglong ge42-0x1 ge42 0x1 +float ge42-0x1 ge42 0x0 +int div42-0x1 div42 0x0 +__uint div42-0x1 div42 0x618 +char div42-0x1 div42 0x0 +__uchar div420xff div42 0x6 +__longlong div42-0x1 div42 0x0 +__ulonglong div42-0x1 div42 0x6186 +float div42-0x1 div42 0x0 +int mod23-0x1 mod23 -0x1 +__uint mod23-0x1 mod23 0x8 +char mod23-0x1 mod23 -0x1 +__uchar mod230xff mod23 0x2 +__longlong mod23-0x1 mod23 -0x1 +__ulonglong mod23-0x1 mod23 0xb +0x1 * 0xffff == -0x1 +0x1 / 0xffff == -0x1 +0x1 % 0xffff == 0x0 +int 0x1 ^ 0xffff == -0x2 (0xfffe) +__uint 0x1 ^ 0xffff == -0x2 (0xfffe) +char 0x1 ^ 0xffff == -0x2 (0xfffe) +__uchar 0x1 ^ 0xff == 0xfe (0xfe) +__longlong 0x1 ^ 0xffff == -0x2 (0xfffe) +__ulonglong 0x1 ^ 0xffff == -0x2 (0xfffe) +int 0x1 && 0xffff == 0x1 (0x1) +__uint 0x1 && 0xffff == 0x1 (0x1) +char 0x1 && 0xffff == 0x1 (0x1) +__uchar 0x1 && 0xff == 0x1 (0x1) +__longlong 0x1 && 0xffff == 0x1 (0x1) +__ulonglong 0x1 && 0xffff == 0x1 (0x1) +int 0x1 || 0xffff == 0x1 (0x1) +__uint 0x1 || 0xffff == 0x1 (0x1) +char 0x1 || 0xffff == 0x1 (0x1) +__uchar 0x1 || 0xff == 0x1 (0x1) +__longlong 0x1 || 0xffff == 0x1 (0x1) +__ulonglong 0x1 || 0xffff == 0x1 (0x1) +int 0x1 & 0xffff == 0x1 (0x1) +__uint 0x1 & 0xffff == 0x1 (0x1) +char 0x1 & 0xffff == 0x1 (0x1) +__uchar 0x1 & 0xff == 0x1 (0x1) +__longlong 0x1 & 0xffff == 0x1 (0x1) +__ulonglong 0x1 & 0xffff == 0x1 (0x1) +int 0x1 | 0xffff == -0x1 (0xffff) +__uint 0x1 | 0xffff == -0x1 (0xffff) +char 0x1 | 0xffff == -0x1 (0xffff) +__uchar 0x1 | 0xff == 0xff (0xff) +__longlong 0x1 | 0xffff == -0x1 (0xffff) +__ulonglong 0x1 | 0xffff == -0x1 (0xffff) +int 0x1 << 0x1 == 0x2 (0x2) +__uint 0x1 << 0x1 == 0x2 (0x2) +char 0x1 << 0x1 == 0x2 (0x2) +__uchar 0x1 << 0x1 == 0x2 (0x2) +__longlong 0x1 << 0x1 == 0x2 (0x2) +__ulonglong 0x1 << 0x1 == 0x2 (0x2) +int 0x1 >> 0x1 == 0x0 (0x0) +__uint 0x1 >> 0x1 == 0x0 (0x0) +char 0x1 >> 0x1 == 0x0 (0x0) +__uchar 0x1 >> 0x1 == 0x0 (0x0) +__longlong 0x1 >> 0x1 == 0x0 (0x0) +__ulonglong 0x1 >> 0x1 == 0x0 (0x0) +int 0x1 + 0xffff == 0x0 (0x0) +__uint 0x1 + 0xffff == 0x0 (0x0) +char 0x1 + 0xffff == 0x0 (0x0) +__uchar 0x1 + 0xff == 0x0 (0x0) +__longlong 0x1 + 0xffff == 0x0 (0x0) +__ulonglong 0x1 + 0xffff == 0x0 (0x0) +float 0x1 + 0xffff == 0x0 (0x0) +int 0x1 - 0xffff == 0x2 (0x2) +__uint 0x1 - 0xffff == 0x2 (0x2) +char 0x1 - 0xffff == 0x2 (0x2) +__uchar 0x1 - 0xff == 0x2 (0x2) +__longlong 0x1 - 0xffff == 0x2 (0x2) +__ulonglong 0x1 - 0xffff == 0x2 (0x2) +float 0x1 - 0xffff == 0x2 (0x2) +int 0x1 * 0xffff == -0x1 (0xffff) +__uint 0x1 * 0xffff == -0x1 (0xffff) +char 0x1 * 0xffff == -0x1 (0xffff) +__uchar 0x1 * 0xff == 0xff (0xff) +__longlong 0x1 * 0xffff == -0x1 (0xffff) +__ulonglong 0x1 * 0xffff == -0x1 (0xffff) +float 0x1 * 0xffff == -0x1 (0xffff) +int 0x1 < 0xffff == 0x0 (0x0) +__uint 0x1 < 0xffff == 0x1 (0x1) +char 0x1 < 0xffff == 0x0 (0x0) +__uchar 0x1 < 0xff == 0x1 (0x1) +__longlong 0x1 < 0xffff == 0x0 (0x0) +__ulonglong 0x1 < 0xffff == 0x1 (0x1) +float 0x1 < 0xffff == 0x0 (0x0) +int 0x1 > 0xffff == 0x1 (0x1) +__uint 0x1 > 0xffff == 0x0 (0x0) +char 0x1 > 0xffff == 0x1 (0x1) +__uchar 0x1 > 0xff == 0x0 (0x0) +__longlong 0x1 > 0xffff == 0x1 (0x1) +__ulonglong 0x1 > 0xffff == 0x0 (0x0) +float 0x1 > 0xffff == 0x1 (0x1) +int 0x1 <= 0xffff == 0x0 (0x0) +__uint 0x1 <= 0xffff == 0x1 (0x1) +char 0x1 <= 0xffff == 0x0 (0x0) +__uchar 0x1 <= 0xff == 0x1 (0x1) +__longlong 0x1 <= 0xffff == 0x0 (0x0) +__ulonglong 0x1 <= 0xffff == 0x1 (0x1) +float 0x1 <= 0xffff == 0x0 (0x0) +int 0x1 == 0xffff == 0x0 (0x0) +__uint 0x1 == 0xffff == 0x0 (0x0) +char 0x1 == 0xffff == 0x0 (0x0) +__uchar 0x1 == 0xff == 0x0 (0x0) +__longlong 0x1 == 0xffff == 0x0 (0x0) +__ulonglong 0x1 == 0xffff == 0x0 (0x0) +float 0x1 == 0xffff == 0x0 (0x0) +int 0x1 != 0xffff == 0x1 (0x1) +__uint 0x1 != 0xffff == 0x1 (0x1) +char 0x1 != 0xffff == 0x1 (0x1) +__uchar 0x1 != 0xff == 0x1 (0x1) +__longlong 0x1 != 0xffff == 0x1 (0x1) +__ulonglong 0x1 != 0xffff == 0x1 (0x1) +float 0x1 != 0xffff == 0x1 (0x1) +int 0x1 >= 0xffff == 0x1 (0x1) +__uint 0x1 >= 0xffff == 0x0 (0x0) +char 0x1 >= 0xffff == 0x1 (0x1) +__uchar 0x1 >= 0xff == 0x0 (0x0) +__longlong 0x1 >= 0xffff == 0x1 (0x1) +__ulonglong 0x1 >= 0xffff == 0x0 (0x0) +float 0x1 >= 0xffff == 0x1 (0x1) +int 0x1 / 0xffff == -0x1 (0xffff) +__uint 0x1 / 0xffff == 0x0 (0x0) +char 0x1 / 0xffff == -0x1 (0xffff) +__uchar 0x1 / 0xff == 0x0 (0x0) +__longlong 0x1 / 0xffff == -0x1 (0xffff) +__ulonglong 0x1 / 0xffff == 0x0 (0x0) +float 0x1 / 0xffff == -0x1 (0xffff) +int 0x1 % 0xffff == 0x0 (0x0) +__uint 0x1 % 0xffff == 0x1 (0x1) +char 0x1 % 0xffff == 0x0 (0x0) +__uchar 0x1 % 0xff == 0x1 (0x1) +__longlong 0x1 % 0xffff == 0x0 (0x0) +__ulonglong 0x1 % 0xffff == 0x1 (0x1) +0x1 * 0x1 == 0x1 +0x1 / 0x1 == 0x1 +0x1 % 0x1 == 0x0 +int 0x1 ^ 0x1 == 0x0 (0x0) +__uint 0x1 ^ 0x1 == 0x0 (0x0) +char 0x1 ^ 0x1 == 0x0 (0x0) +__uchar 0x1 ^ 0x1 == 0x0 (0x0) +__longlong 0x1 ^ 0x1 == 0x0 (0x0) +__ulonglong 0x1 ^ 0x1 == 0x0 (0x0) +int 0x1 && 0x1 == 0x1 (0x1) +__uint 0x1 && 0x1 == 0x1 (0x1) +char 0x1 && 0x1 == 0x1 (0x1) +__uchar 0x1 && 0x1 == 0x1 (0x1) +__longlong 0x1 && 0x1 == 0x1 (0x1) +__ulonglong 0x1 && 0x1 == 0x1 (0x1) +int 0x1 || 0x1 == 0x1 (0x1) +__uint 0x1 || 0x1 == 0x1 (0x1) +char 0x1 || 0x1 == 0x1 (0x1) +__uchar 0x1 || 0x1 == 0x1 (0x1) +__longlong 0x1 || 0x1 == 0x1 (0x1) +__ulonglong 0x1 || 0x1 == 0x1 (0x1) +int 0x1 & 0x1 == 0x1 (0x1) +__uint 0x1 & 0x1 == 0x1 (0x1) +char 0x1 & 0x1 == 0x1 (0x1) +__uchar 0x1 & 0x1 == 0x1 (0x1) +__longlong 0x1 & 0x1 == 0x1 (0x1) +__ulonglong 0x1 & 0x1 == 0x1 (0x1) +int 0x1 | 0x1 == 0x1 (0x1) +__uint 0x1 | 0x1 == 0x1 (0x1) +char 0x1 | 0x1 == 0x1 (0x1) +__uchar 0x1 | 0x1 == 0x1 (0x1) +__longlong 0x1 | 0x1 == 0x1 (0x1) +__ulonglong 0x1 | 0x1 == 0x1 (0x1) +int 0x1 << 0x2 == 0x4 (0x4) +__uint 0x1 << 0x2 == 0x4 (0x4) +char 0x1 << 0x2 == 0x4 (0x4) +__uchar 0x1 << 0x2 == 0x4 (0x4) +__longlong 0x1 << 0x2 == 0x4 (0x4) +__ulonglong 0x1 << 0x2 == 0x4 (0x4) +int 0x1 >> 0x2 == 0x0 (0x0) +__uint 0x1 >> 0x2 == 0x0 (0x0) +char 0x1 >> 0x2 == 0x0 (0x0) +__uchar 0x1 >> 0x2 == 0x0 (0x0) +__longlong 0x1 >> 0x2 == 0x0 (0x0) +__ulonglong 0x1 >> 0x2 == 0x0 (0x0) +int 0x1 + 0x1 == 0x2 (0x2) +__uint 0x1 + 0x1 == 0x2 (0x2) +char 0x1 + 0x1 == 0x2 (0x2) +__uchar 0x1 + 0x1 == 0x2 (0x2) +__longlong 0x1 + 0x1 == 0x2 (0x2) +__ulonglong 0x1 + 0x1 == 0x2 (0x2) +float 0x1 + 0x1 == 0x2 (0x2) +int 0x1 - 0x1 == 0x0 (0x0) +__uint 0x1 - 0x1 == 0x0 (0x0) +char 0x1 - 0x1 == 0x0 (0x0) +__uchar 0x1 - 0x1 == 0x0 (0x0) +__longlong 0x1 - 0x1 == 0x0 (0x0) +__ulonglong 0x1 - 0x1 == 0x0 (0x0) +float 0x1 - 0x1 == 0x0 (0x0) +int 0x1 * 0x1 == 0x1 (0x1) +__uint 0x1 * 0x1 == 0x1 (0x1) +char 0x1 * 0x1 == 0x1 (0x1) +__uchar 0x1 * 0x1 == 0x1 (0x1) +__longlong 0x1 * 0x1 == 0x1 (0x1) +__ulonglong 0x1 * 0x1 == 0x1 (0x1) +float 0x1 * 0x1 == 0x1 (0x1) +int 0x1 < 0x1 == 0x0 (0x0) +__uint 0x1 < 0x1 == 0x0 (0x0) +char 0x1 < 0x1 == 0x0 (0x0) +__uchar 0x1 < 0x1 == 0x0 (0x0) +__longlong 0x1 < 0x1 == 0x0 (0x0) +__ulonglong 0x1 < 0x1 == 0x0 (0x0) +float 0x1 < 0x1 == 0x0 (0x0) +int 0x1 > 0x1 == 0x0 (0x0) +__uint 0x1 > 0x1 == 0x0 (0x0) +char 0x1 > 0x1 == 0x0 (0x0) +__uchar 0x1 > 0x1 == 0x0 (0x0) +__longlong 0x1 > 0x1 == 0x0 (0x0) +__ulonglong 0x1 > 0x1 == 0x0 (0x0) +float 0x1 > 0x1 == 0x0 (0x0) +int 0x1 <= 0x1 == 0x1 (0x1) +__uint 0x1 <= 0x1 == 0x1 (0x1) +char 0x1 <= 0x1 == 0x1 (0x1) +__uchar 0x1 <= 0x1 == 0x1 (0x1) +__longlong 0x1 <= 0x1 == 0x1 (0x1) +__ulonglong 0x1 <= 0x1 == 0x1 (0x1) +float 0x1 <= 0x1 == 0x1 (0x1) +int 0x1 == 0x1 == 0x1 (0x1) +__uint 0x1 == 0x1 == 0x1 (0x1) +char 0x1 == 0x1 == 0x1 (0x1) +__uchar 0x1 == 0x1 == 0x1 (0x1) +__longlong 0x1 == 0x1 == 0x1 (0x1) +__ulonglong 0x1 == 0x1 == 0x1 (0x1) +float 0x1 == 0x1 == 0x1 (0x1) +int 0x1 != 0x1 == 0x0 (0x0) +__uint 0x1 != 0x1 == 0x0 (0x0) +char 0x1 != 0x1 == 0x0 (0x0) +__uchar 0x1 != 0x1 == 0x0 (0x0) +__longlong 0x1 != 0x1 == 0x0 (0x0) +__ulonglong 0x1 != 0x1 == 0x0 (0x0) +float 0x1 != 0x1 == 0x0 (0x0) +int 0x1 >= 0x1 == 0x1 (0x1) +__uint 0x1 >= 0x1 == 0x1 (0x1) +char 0x1 >= 0x1 == 0x1 (0x1) +__uchar 0x1 >= 0x1 == 0x1 (0x1) +__longlong 0x1 >= 0x1 == 0x1 (0x1) +__ulonglong 0x1 >= 0x1 == 0x1 (0x1) +float 0x1 >= 0x1 == 0x1 (0x1) +int 0x1 / 0x1 == 0x1 (0x1) +__uint 0x1 / 0x1 == 0x1 (0x1) +char 0x1 / 0x1 == 0x1 (0x1) +__uchar 0x1 / 0x1 == 0x1 (0x1) +__longlong 0x1 / 0x1 == 0x1 (0x1) +__ulonglong 0x1 / 0x1 == 0x1 (0x1) +float 0x1 / 0x1 == 0x1 (0x1) +int 0x1 % 0x1 == 0x0 (0x0) +__uint 0x1 % 0x1 == 0x0 (0x0) +char 0x1 % 0x1 == 0x0 (0x0) +__uchar 0x1 % 0x1 == 0x0 (0x0) +__longlong 0x1 % 0x1 == 0x0 (0x0) +__ulonglong 0x1 % 0x1 == 0x0 (0x0) +0x1 * 0x2 == 0x2 +0x1 / 0x2 == 0x0 +0x1 % 0x2 == 0x1 +int 0x1 ^ 0x2 == 0x3 (0x3) +__uint 0x1 ^ 0x2 == 0x3 (0x3) +char 0x1 ^ 0x2 == 0x3 (0x3) +__uchar 0x1 ^ 0x2 == 0x3 (0x3) +__longlong 0x1 ^ 0x2 == 0x3 (0x3) +__ulonglong 0x1 ^ 0x2 == 0x3 (0x3) +int 0x1 && 0x2 == 0x1 (0x1) +__uint 0x1 && 0x2 == 0x1 (0x1) +char 0x1 && 0x2 == 0x1 (0x1) +__uchar 0x1 && 0x2 == 0x1 (0x1) +__longlong 0x1 && 0x2 == 0x1 (0x1) +__ulonglong 0x1 && 0x2 == 0x1 (0x1) +int 0x1 || 0x2 == 0x1 (0x1) +__uint 0x1 || 0x2 == 0x1 (0x1) +char 0x1 || 0x2 == 0x1 (0x1) +__uchar 0x1 || 0x2 == 0x1 (0x1) +__longlong 0x1 || 0x2 == 0x1 (0x1) +__ulonglong 0x1 || 0x2 == 0x1 (0x1) +int 0x1 & 0x2 == 0x0 (0x0) +__uint 0x1 & 0x2 == 0x0 (0x0) +char 0x1 & 0x2 == 0x0 (0x0) +__uchar 0x1 & 0x2 == 0x0 (0x0) +__longlong 0x1 & 0x2 == 0x0 (0x0) +__ulonglong 0x1 & 0x2 == 0x0 (0x0) +int 0x1 | 0x2 == 0x3 (0x3) +__uint 0x1 | 0x2 == 0x3 (0x3) +char 0x1 | 0x2 == 0x3 (0x3) +__uchar 0x1 | 0x2 == 0x3 (0x3) +__longlong 0x1 | 0x2 == 0x3 (0x3) +__ulonglong 0x1 | 0x2 == 0x3 (0x3) +int 0x1 << 0x3 == 0x8 (0x8) +__uint 0x1 << 0x3 == 0x8 (0x8) +char 0x1 << 0x3 == 0x8 (0x8) +__uchar 0x1 << 0x3 == 0x8 (0x8) +__longlong 0x1 << 0x3 == 0x8 (0x8) +__ulonglong 0x1 << 0x3 == 0x8 (0x8) +int 0x1 >> 0x3 == 0x0 (0x0) +__uint 0x1 >> 0x3 == 0x0 (0x0) +char 0x1 >> 0x3 == 0x0 (0x0) +__uchar 0x1 >> 0x3 == 0x0 (0x0) +__longlong 0x1 >> 0x3 == 0x0 (0x0) +__ulonglong 0x1 >> 0x3 == 0x0 (0x0) +int 0x1 + 0x2 == 0x3 (0x3) +__uint 0x1 + 0x2 == 0x3 (0x3) +char 0x1 + 0x2 == 0x3 (0x3) +__uchar 0x1 + 0x2 == 0x3 (0x3) +__longlong 0x1 + 0x2 == 0x3 (0x3) +__ulonglong 0x1 + 0x2 == 0x3 (0x3) +float 0x1 + 0x2 == 0x3 (0x3) +int 0x1 - 0x2 == -0x1 (0xffff) +__uint 0x1 - 0x2 == -0x1 (0xffff) +char 0x1 - 0x2 == -0x1 (0xffff) +__uchar 0x1 - 0x2 == 0xff (0xff) +__longlong 0x1 - 0x2 == -0x1 (0xffff) +__ulonglong 0x1 - 0x2 == -0x1 (0xffff) +float 0x1 - 0x2 == -0x1 (0xffff) +int 0x1 * 0x2 == 0x2 (0x2) +__uint 0x1 * 0x2 == 0x2 (0x2) +char 0x1 * 0x2 == 0x2 (0x2) +__uchar 0x1 * 0x2 == 0x2 (0x2) +__longlong 0x1 * 0x2 == 0x2 (0x2) +__ulonglong 0x1 * 0x2 == 0x2 (0x2) +float 0x1 * 0x2 == 0x2 (0x2) +int 0x1 < 0x2 == 0x1 (0x1) +__uint 0x1 < 0x2 == 0x1 (0x1) +char 0x1 < 0x2 == 0x1 (0x1) +__uchar 0x1 < 0x2 == 0x1 (0x1) +__longlong 0x1 < 0x2 == 0x1 (0x1) +__ulonglong 0x1 < 0x2 == 0x1 (0x1) +float 0x1 < 0x2 == 0x1 (0x1) +int 0x1 > 0x2 == 0x0 (0x0) +__uint 0x1 > 0x2 == 0x0 (0x0) +char 0x1 > 0x2 == 0x0 (0x0) +__uchar 0x1 > 0x2 == 0x0 (0x0) +__longlong 0x1 > 0x2 == 0x0 (0x0) +__ulonglong 0x1 > 0x2 == 0x0 (0x0) +float 0x1 > 0x2 == 0x0 (0x0) +int 0x1 <= 0x2 == 0x1 (0x1) +__uint 0x1 <= 0x2 == 0x1 (0x1) +char 0x1 <= 0x2 == 0x1 (0x1) +__uchar 0x1 <= 0x2 == 0x1 (0x1) +__longlong 0x1 <= 0x2 == 0x1 (0x1) +__ulonglong 0x1 <= 0x2 == 0x1 (0x1) +float 0x1 <= 0x2 == 0x1 (0x1) +int 0x1 == 0x2 == 0x0 (0x0) +__uint 0x1 == 0x2 == 0x0 (0x0) +char 0x1 == 0x2 == 0x0 (0x0) +__uchar 0x1 == 0x2 == 0x0 (0x0) +__longlong 0x1 == 0x2 == 0x0 (0x0) +__ulonglong 0x1 == 0x2 == 0x0 (0x0) +float 0x1 == 0x2 == 0x0 (0x0) +int 0x1 != 0x2 == 0x1 (0x1) +__uint 0x1 != 0x2 == 0x1 (0x1) +char 0x1 != 0x2 == 0x1 (0x1) +__uchar 0x1 != 0x2 == 0x1 (0x1) +__longlong 0x1 != 0x2 == 0x1 (0x1) +__ulonglong 0x1 != 0x2 == 0x1 (0x1) +float 0x1 != 0x2 == 0x1 (0x1) +int 0x1 >= 0x2 == 0x0 (0x0) +__uint 0x1 >= 0x2 == 0x0 (0x0) +char 0x1 >= 0x2 == 0x0 (0x0) +__uchar 0x1 >= 0x2 == 0x0 (0x0) +__longlong 0x1 >= 0x2 == 0x0 (0x0) +__ulonglong 0x1 >= 0x2 == 0x0 (0x0) +float 0x1 >= 0x2 == 0x0 (0x0) +int 0x1 / 0x2 == 0x0 (0x0) +__uint 0x1 / 0x2 == 0x0 (0x0) +char 0x1 / 0x2 == 0x0 (0x0) +__uchar 0x1 / 0x2 == 0x0 (0x0) +__longlong 0x1 / 0x2 == 0x0 (0x0) +__ulonglong 0x1 / 0x2 == 0x0 (0x0) +float 0x1 / 0x2 == 0x0 (0x0) +int 0x1 % 0x2 == 0x1 (0x1) +__uint 0x1 % 0x2 == 0x1 (0x1) +char 0x1 % 0x2 == 0x1 (0x1) +__uchar 0x1 % 0x2 == 0x1 (0x1) +__longlong 0x1 % 0x2 == 0x1 (0x1) +__ulonglong 0x1 % 0x2 == 0x1 (0x1) +0x1 * 0xfffe == -0x2 +0x1 / 0xfffe == 0x0 +0x1 % 0xfffe == 0x1 +int 0x1 ^ 0xfffe == -0x1 (0xffff) +__uint 0x1 ^ 0xfffe == -0x1 (0xffff) +char 0x1 ^ 0xfffe == -0x1 (0xffff) +__uchar 0x1 ^ 0xfe == 0xff (0xff) +__longlong 0x1 ^ 0xfffe == -0x1 (0xffff) +__ulonglong 0x1 ^ 0xfffe == -0x1 (0xffff) +int 0x1 && 0xfffe == 0x1 (0x1) +__uint 0x1 && 0xfffe == 0x1 (0x1) +char 0x1 && 0xfffe == 0x1 (0x1) +__uchar 0x1 && 0xfe == 0x1 (0x1) +__longlong 0x1 && 0xfffe == 0x1 (0x1) +__ulonglong 0x1 && 0xfffe == 0x1 (0x1) +int 0x1 || 0xfffe == 0x1 (0x1) +__uint 0x1 || 0xfffe == 0x1 (0x1) +char 0x1 || 0xfffe == 0x1 (0x1) +__uchar 0x1 || 0xfe == 0x1 (0x1) +__longlong 0x1 || 0xfffe == 0x1 (0x1) +__ulonglong 0x1 || 0xfffe == 0x1 (0x1) +int 0x1 & 0xfffe == 0x0 (0x0) +__uint 0x1 & 0xfffe == 0x0 (0x0) +char 0x1 & 0xfffe == 0x0 (0x0) +__uchar 0x1 & 0xfe == 0x0 (0x0) +__longlong 0x1 & 0xfffe == 0x0 (0x0) +__ulonglong 0x1 & 0xfffe == 0x0 (0x0) +int 0x1 | 0xfffe == -0x1 (0xffff) +__uint 0x1 | 0xfffe == -0x1 (0xffff) +char 0x1 | 0xfffe == -0x1 (0xffff) +__uchar 0x1 | 0xfe == 0xff (0xff) +__longlong 0x1 | 0xfffe == -0x1 (0xffff) +__ulonglong 0x1 | 0xfffe == -0x1 (0xffff) +int 0x1 << 0x4 == 0x10 (0x10) +__uint 0x1 << 0x4 == 0x10 (0x10) +char 0x1 << 0x4 == 0x10 (0x10) +__uchar 0x1 << 0x4 == 0x10 (0x10) +__longlong 0x1 << 0x4 == 0x10 (0x10) +__ulonglong 0x1 << 0x4 == 0x10 (0x10) +int 0x1 >> 0x4 == 0x0 (0x0) +__uint 0x1 >> 0x4 == 0x0 (0x0) +char 0x1 >> 0x4 == 0x0 (0x0) +__uchar 0x1 >> 0x4 == 0x0 (0x0) +__longlong 0x1 >> 0x4 == 0x0 (0x0) +__ulonglong 0x1 >> 0x4 == 0x0 (0x0) +int 0x1 + 0xfffe == -0x1 (0xffff) +__uint 0x1 + 0xfffe == -0x1 (0xffff) +char 0x1 + 0xfffe == -0x1 (0xffff) +__uchar 0x1 + 0xfe == 0xff (0xff) +__longlong 0x1 + 0xfffe == -0x1 (0xffff) +__ulonglong 0x1 + 0xfffe == -0x1 (0xffff) +float 0x1 + 0xfffe == -0x1 (0xffff) +int 0x1 - 0xfffe == 0x3 (0x3) +__uint 0x1 - 0xfffe == 0x3 (0x3) +char 0x1 - 0xfffe == 0x3 (0x3) +__uchar 0x1 - 0xfe == 0x3 (0x3) +__longlong 0x1 - 0xfffe == 0x3 (0x3) +__ulonglong 0x1 - 0xfffe == 0x3 (0x3) +float 0x1 - 0xfffe == 0x3 (0x3) +int 0x1 * 0xfffe == -0x2 (0xfffe) +__uint 0x1 * 0xfffe == -0x2 (0xfffe) +char 0x1 * 0xfffe == -0x2 (0xfffe) +__uchar 0x1 * 0xfe == 0xfe (0xfe) +__longlong 0x1 * 0xfffe == -0x2 (0xfffe) +__ulonglong 0x1 * 0xfffe == -0x2 (0xfffe) +float 0x1 * 0xfffe == -0x2 (0xfffe) +int 0x1 < 0xfffe == 0x0 (0x0) +__uint 0x1 < 0xfffe == 0x1 (0x1) +char 0x1 < 0xfffe == 0x0 (0x0) +__uchar 0x1 < 0xfe == 0x1 (0x1) +__longlong 0x1 < 0xfffe == 0x0 (0x0) +__ulonglong 0x1 < 0xfffe == 0x1 (0x1) +float 0x1 < 0xfffe == 0x0 (0x0) +int 0x1 > 0xfffe == 0x1 (0x1) +__uint 0x1 > 0xfffe == 0x0 (0x0) +char 0x1 > 0xfffe == 0x1 (0x1) +__uchar 0x1 > 0xfe == 0x0 (0x0) +__longlong 0x1 > 0xfffe == 0x1 (0x1) +__ulonglong 0x1 > 0xfffe == 0x0 (0x0) +float 0x1 > 0xfffe == 0x1 (0x1) +int 0x1 <= 0xfffe == 0x0 (0x0) +__uint 0x1 <= 0xfffe == 0x1 (0x1) +char 0x1 <= 0xfffe == 0x0 (0x0) +__uchar 0x1 <= 0xfe == 0x1 (0x1) +__longlong 0x1 <= 0xfffe == 0x0 (0x0) +__ulonglong 0x1 <= 0xfffe == 0x1 (0x1) +float 0x1 <= 0xfffe == 0x0 (0x0) +int 0x1 == 0xfffe == 0x0 (0x0) +__uint 0x1 == 0xfffe == 0x0 (0x0) +char 0x1 == 0xfffe == 0x0 (0x0) +__uchar 0x1 == 0xfe == 0x0 (0x0) +__longlong 0x1 == 0xfffe == 0x0 (0x0) +__ulonglong 0x1 == 0xfffe == 0x0 (0x0) +float 0x1 == 0xfffe == 0x0 (0x0) +int 0x1 != 0xfffe == 0x1 (0x1) +__uint 0x1 != 0xfffe == 0x1 (0x1) +char 0x1 != 0xfffe == 0x1 (0x1) +__uchar 0x1 != 0xfe == 0x1 (0x1) +__longlong 0x1 != 0xfffe == 0x1 (0x1) +__ulonglong 0x1 != 0xfffe == 0x1 (0x1) +float 0x1 != 0xfffe == 0x1 (0x1) +int 0x1 >= 0xfffe == 0x1 (0x1) +__uint 0x1 >= 0xfffe == 0x0 (0x0) +char 0x1 >= 0xfffe == 0x1 (0x1) +__uchar 0x1 >= 0xfe == 0x0 (0x0) +__longlong 0x1 >= 0xfffe == 0x1 (0x1) +__ulonglong 0x1 >= 0xfffe == 0x0 (0x0) +float 0x1 >= 0xfffe == 0x1 (0x1) +int 0x1 / 0xfffe == 0x0 (0x0) +__uint 0x1 / 0xfffe == 0x0 (0x0) +char 0x1 / 0xfffe == 0x0 (0x0) +__uchar 0x1 / 0xfe == 0x0 (0x0) +__longlong 0x1 / 0xfffe == 0x0 (0x0) +__ulonglong 0x1 / 0xfffe == 0x0 (0x0) +float 0x1 / 0xfffe == 0x0 (0x0) +int 0x1 % 0xfffe == 0x1 (0x1) +__uint 0x1 % 0xfffe == 0x1 (0x1) +char 0x1 % 0xfffe == 0x1 (0x1) +__uchar 0x1 % 0xfe == 0x1 (0x1) +__longlong 0x1 % 0xfffe == 0x1 (0x1) +__ulonglong 0x1 % 0xfffe == 0x1 (0x1) +0x1 * 0x4 == 0x4 +0x1 / 0x4 == 0x0 +0x1 % 0x4 == 0x1 +int 0x1 ^ 0x4 == 0x5 (0x5) +__uint 0x1 ^ 0x4 == 0x5 (0x5) +char 0x1 ^ 0x4 == 0x5 (0x5) +__uchar 0x1 ^ 0x4 == 0x5 (0x5) +__longlong 0x1 ^ 0x4 == 0x5 (0x5) +__ulonglong 0x1 ^ 0x4 == 0x5 (0x5) +int 0x1 && 0x4 == 0x1 (0x1) +__uint 0x1 && 0x4 == 0x1 (0x1) +char 0x1 && 0x4 == 0x1 (0x1) +__uchar 0x1 && 0x4 == 0x1 (0x1) +__longlong 0x1 && 0x4 == 0x1 (0x1) +__ulonglong 0x1 && 0x4 == 0x1 (0x1) +int 0x1 || 0x4 == 0x1 (0x1) +__uint 0x1 || 0x4 == 0x1 (0x1) +char 0x1 || 0x4 == 0x1 (0x1) +__uchar 0x1 || 0x4 == 0x1 (0x1) +__longlong 0x1 || 0x4 == 0x1 (0x1) +__ulonglong 0x1 || 0x4 == 0x1 (0x1) +int 0x1 & 0x4 == 0x0 (0x0) +__uint 0x1 & 0x4 == 0x0 (0x0) +char 0x1 & 0x4 == 0x0 (0x0) +__uchar 0x1 & 0x4 == 0x0 (0x0) +__longlong 0x1 & 0x4 == 0x0 (0x0) +__ulonglong 0x1 & 0x4 == 0x0 (0x0) +int 0x1 | 0x4 == 0x5 (0x5) +__uint 0x1 | 0x4 == 0x5 (0x5) +char 0x1 | 0x4 == 0x5 (0x5) +__uchar 0x1 | 0x4 == 0x5 (0x5) +__longlong 0x1 | 0x4 == 0x5 (0x5) +__ulonglong 0x1 | 0x4 == 0x5 (0x5) +int 0x1 << 0x5 == 0x20 (0x20) +__uint 0x1 << 0x5 == 0x20 (0x20) +char 0x1 << 0x5 == 0x20 (0x20) +__uchar 0x1 << 0x5 == 0x20 (0x20) +__longlong 0x1 << 0x5 == 0x20 (0x20) +__ulonglong 0x1 << 0x5 == 0x20 (0x20) +int 0x1 >> 0x5 == 0x0 (0x0) +__uint 0x1 >> 0x5 == 0x0 (0x0) +char 0x1 >> 0x5 == 0x0 (0x0) +__uchar 0x1 >> 0x5 == 0x0 (0x0) +__longlong 0x1 >> 0x5 == 0x0 (0x0) +__ulonglong 0x1 >> 0x5 == 0x0 (0x0) +int 0x1 + 0x4 == 0x5 (0x5) +__uint 0x1 + 0x4 == 0x5 (0x5) +char 0x1 + 0x4 == 0x5 (0x5) +__uchar 0x1 + 0x4 == 0x5 (0x5) +__longlong 0x1 + 0x4 == 0x5 (0x5) +__ulonglong 0x1 + 0x4 == 0x5 (0x5) +float 0x1 + 0x4 == 0x5 (0x5) +int 0x1 - 0x4 == -0x3 (0xfffd) +__uint 0x1 - 0x4 == -0x3 (0xfffd) +char 0x1 - 0x4 == -0x3 (0xfffd) +__uchar 0x1 - 0x4 == 0xfd (0xfd) +__longlong 0x1 - 0x4 == -0x3 (0xfffd) +__ulonglong 0x1 - 0x4 == -0x3 (0xfffd) +float 0x1 - 0x4 == -0x3 (0xfffd) +int 0x1 * 0x4 == 0x4 (0x4) +__uint 0x1 * 0x4 == 0x4 (0x4) +char 0x1 * 0x4 == 0x4 (0x4) +__uchar 0x1 * 0x4 == 0x4 (0x4) +__longlong 0x1 * 0x4 == 0x4 (0x4) +__ulonglong 0x1 * 0x4 == 0x4 (0x4) +float 0x1 * 0x4 == 0x4 (0x4) +int 0x1 < 0x4 == 0x1 (0x1) +__uint 0x1 < 0x4 == 0x1 (0x1) +char 0x1 < 0x4 == 0x1 (0x1) +__uchar 0x1 < 0x4 == 0x1 (0x1) +__longlong 0x1 < 0x4 == 0x1 (0x1) +__ulonglong 0x1 < 0x4 == 0x1 (0x1) +float 0x1 < 0x4 == 0x1 (0x1) +int 0x1 > 0x4 == 0x0 (0x0) +__uint 0x1 > 0x4 == 0x0 (0x0) +char 0x1 > 0x4 == 0x0 (0x0) +__uchar 0x1 > 0x4 == 0x0 (0x0) +__longlong 0x1 > 0x4 == 0x0 (0x0) +__ulonglong 0x1 > 0x4 == 0x0 (0x0) +float 0x1 > 0x4 == 0x0 (0x0) +int 0x1 <= 0x4 == 0x1 (0x1) +__uint 0x1 <= 0x4 == 0x1 (0x1) +char 0x1 <= 0x4 == 0x1 (0x1) +__uchar 0x1 <= 0x4 == 0x1 (0x1) +__longlong 0x1 <= 0x4 == 0x1 (0x1) +__ulonglong 0x1 <= 0x4 == 0x1 (0x1) +float 0x1 <= 0x4 == 0x1 (0x1) +int 0x1 == 0x4 == 0x0 (0x0) +__uint 0x1 == 0x4 == 0x0 (0x0) +char 0x1 == 0x4 == 0x0 (0x0) +__uchar 0x1 == 0x4 == 0x0 (0x0) +__longlong 0x1 == 0x4 == 0x0 (0x0) +__ulonglong 0x1 == 0x4 == 0x0 (0x0) +float 0x1 == 0x4 == 0x0 (0x0) +int 0x1 != 0x4 == 0x1 (0x1) +__uint 0x1 != 0x4 == 0x1 (0x1) +char 0x1 != 0x4 == 0x1 (0x1) +__uchar 0x1 != 0x4 == 0x1 (0x1) +__longlong 0x1 != 0x4 == 0x1 (0x1) +__ulonglong 0x1 != 0x4 == 0x1 (0x1) +float 0x1 != 0x4 == 0x1 (0x1) +int 0x1 >= 0x4 == 0x0 (0x0) +__uint 0x1 >= 0x4 == 0x0 (0x0) +char 0x1 >= 0x4 == 0x0 (0x0) +__uchar 0x1 >= 0x4 == 0x0 (0x0) +__longlong 0x1 >= 0x4 == 0x0 (0x0) +__ulonglong 0x1 >= 0x4 == 0x0 (0x0) +float 0x1 >= 0x4 == 0x0 (0x0) +int 0x1 / 0x4 == 0x0 (0x0) +__uint 0x1 / 0x4 == 0x0 (0x0) +char 0x1 / 0x4 == 0x0 (0x0) +__uchar 0x1 / 0x4 == 0x0 (0x0) +__longlong 0x1 / 0x4 == 0x0 (0x0) +__ulonglong 0x1 / 0x4 == 0x0 (0x0) +float 0x1 / 0x4 == 0x0 (0x0) +int 0x1 % 0x4 == 0x1 (0x1) +__uint 0x1 % 0x4 == 0x1 (0x1) +char 0x1 % 0x4 == 0x1 (0x1) +__uchar 0x1 % 0x4 == 0x1 (0x1) +__longlong 0x1 % 0x4 == 0x1 (0x1) +__ulonglong 0x1 % 0x4 == 0x1 (0x1) +0x1 * 0xfffc == -0x4 +0x1 / 0xfffc == 0x0 +0x1 % 0xfffc == 0x1 +int 0x1 ^ 0xfffc == -0x3 (0xfffd) +__uint 0x1 ^ 0xfffc == -0x3 (0xfffd) +char 0x1 ^ 0xfffc == -0x3 (0xfffd) +__uchar 0x1 ^ 0xfc == 0xfd (0xfd) +__longlong 0x1 ^ 0xfffc == -0x3 (0xfffd) +__ulonglong 0x1 ^ 0xfffc == -0x3 (0xfffd) +int 0x1 && 0xfffc == 0x1 (0x1) +__uint 0x1 && 0xfffc == 0x1 (0x1) +char 0x1 && 0xfffc == 0x1 (0x1) +__uchar 0x1 && 0xfc == 0x1 (0x1) +__longlong 0x1 && 0xfffc == 0x1 (0x1) +__ulonglong 0x1 && 0xfffc == 0x1 (0x1) +int 0x1 || 0xfffc == 0x1 (0x1) +__uint 0x1 || 0xfffc == 0x1 (0x1) +char 0x1 || 0xfffc == 0x1 (0x1) +__uchar 0x1 || 0xfc == 0x1 (0x1) +__longlong 0x1 || 0xfffc == 0x1 (0x1) +__ulonglong 0x1 || 0xfffc == 0x1 (0x1) +int 0x1 & 0xfffc == 0x0 (0x0) +__uint 0x1 & 0xfffc == 0x0 (0x0) +char 0x1 & 0xfffc == 0x0 (0x0) +__uchar 0x1 & 0xfc == 0x0 (0x0) +__longlong 0x1 & 0xfffc == 0x0 (0x0) +__ulonglong 0x1 & 0xfffc == 0x0 (0x0) +int 0x1 | 0xfffc == -0x3 (0xfffd) +__uint 0x1 | 0xfffc == -0x3 (0xfffd) +char 0x1 | 0xfffc == -0x3 (0xfffd) +__uchar 0x1 | 0xfc == 0xfd (0xfd) +__longlong 0x1 | 0xfffc == -0x3 (0xfffd) +__ulonglong 0x1 | 0xfffc == -0x3 (0xfffd) +int 0x1 << 0x6 == 0x40 (0x40) +__uint 0x1 << 0x6 == 0x40 (0x40) +char 0x1 << 0x6 == 0x40 (0x40) +__uchar 0x1 << 0x6 == 0x40 (0x40) +__longlong 0x1 << 0x6 == 0x40 (0x40) +__ulonglong 0x1 << 0x6 == 0x40 (0x40) +int 0x1 >> 0x6 == 0x0 (0x0) +__uint 0x1 >> 0x6 == 0x0 (0x0) +char 0x1 >> 0x6 == 0x0 (0x0) +__uchar 0x1 >> 0x6 == 0x0 (0x0) +__longlong 0x1 >> 0x6 == 0x0 (0x0) +__ulonglong 0x1 >> 0x6 == 0x0 (0x0) +int 0x1 + 0xfffc == -0x3 (0xfffd) +__uint 0x1 + 0xfffc == -0x3 (0xfffd) +char 0x1 + 0xfffc == -0x3 (0xfffd) +__uchar 0x1 + 0xfc == 0xfd (0xfd) +__longlong 0x1 + 0xfffc == -0x3 (0xfffd) +__ulonglong 0x1 + 0xfffc == -0x3 (0xfffd) +float 0x1 + 0xfffc == -0x3 (0xfffd) +int 0x1 - 0xfffc == 0x5 (0x5) +__uint 0x1 - 0xfffc == 0x5 (0x5) +char 0x1 - 0xfffc == 0x5 (0x5) +__uchar 0x1 - 0xfc == 0x5 (0x5) +__longlong 0x1 - 0xfffc == 0x5 (0x5) +__ulonglong 0x1 - 0xfffc == 0x5 (0x5) +float 0x1 - 0xfffc == 0x5 (0x5) +int 0x1 * 0xfffc == -0x4 (0xfffc) +__uint 0x1 * 0xfffc == -0x4 (0xfffc) +char 0x1 * 0xfffc == -0x4 (0xfffc) +__uchar 0x1 * 0xfc == 0xfc (0xfc) +__longlong 0x1 * 0xfffc == -0x4 (0xfffc) +__ulonglong 0x1 * 0xfffc == -0x4 (0xfffc) +float 0x1 * 0xfffc == -0x4 (0xfffc) +int 0x1 < 0xfffc == 0x0 (0x0) +__uint 0x1 < 0xfffc == 0x1 (0x1) +char 0x1 < 0xfffc == 0x0 (0x0) +__uchar 0x1 < 0xfc == 0x1 (0x1) +__longlong 0x1 < 0xfffc == 0x0 (0x0) +__ulonglong 0x1 < 0xfffc == 0x1 (0x1) +float 0x1 < 0xfffc == 0x0 (0x0) +int 0x1 > 0xfffc == 0x1 (0x1) +__uint 0x1 > 0xfffc == 0x0 (0x0) +char 0x1 > 0xfffc == 0x1 (0x1) +__uchar 0x1 > 0xfc == 0x0 (0x0) +__longlong 0x1 > 0xfffc == 0x1 (0x1) +__ulonglong 0x1 > 0xfffc == 0x0 (0x0) +float 0x1 > 0xfffc == 0x1 (0x1) +int 0x1 <= 0xfffc == 0x0 (0x0) +__uint 0x1 <= 0xfffc == 0x1 (0x1) +char 0x1 <= 0xfffc == 0x0 (0x0) +__uchar 0x1 <= 0xfc == 0x1 (0x1) +__longlong 0x1 <= 0xfffc == 0x0 (0x0) +__ulonglong 0x1 <= 0xfffc == 0x1 (0x1) +float 0x1 <= 0xfffc == 0x0 (0x0) +int 0x1 == 0xfffc == 0x0 (0x0) +__uint 0x1 == 0xfffc == 0x0 (0x0) +char 0x1 == 0xfffc == 0x0 (0x0) +__uchar 0x1 == 0xfc == 0x0 (0x0) +__longlong 0x1 == 0xfffc == 0x0 (0x0) +__ulonglong 0x1 == 0xfffc == 0x0 (0x0) +float 0x1 == 0xfffc == 0x0 (0x0) +int 0x1 != 0xfffc == 0x1 (0x1) +__uint 0x1 != 0xfffc == 0x1 (0x1) +char 0x1 != 0xfffc == 0x1 (0x1) +__uchar 0x1 != 0xfc == 0x1 (0x1) +__longlong 0x1 != 0xfffc == 0x1 (0x1) +__ulonglong 0x1 != 0xfffc == 0x1 (0x1) +float 0x1 != 0xfffc == 0x1 (0x1) +int 0x1 >= 0xfffc == 0x1 (0x1) +__uint 0x1 >= 0xfffc == 0x0 (0x0) +char 0x1 >= 0xfffc == 0x1 (0x1) +__uchar 0x1 >= 0xfc == 0x0 (0x0) +__longlong 0x1 >= 0xfffc == 0x1 (0x1) +__ulonglong 0x1 >= 0xfffc == 0x0 (0x0) +float 0x1 >= 0xfffc == 0x1 (0x1) +int 0x1 / 0xfffc == 0x0 (0x0) +__uint 0x1 / 0xfffc == 0x0 (0x0) +char 0x1 / 0xfffc == 0x0 (0x0) +__uchar 0x1 / 0xfc == 0x0 (0x0) +__longlong 0x1 / 0xfffc == 0x0 (0x0) +__ulonglong 0x1 / 0xfffc == 0x0 (0x0) +float 0x1 / 0xfffc == 0x0 (0x0) +int 0x1 % 0xfffc == 0x1 (0x1) +__uint 0x1 % 0xfffc == 0x1 (0x1) +char 0x1 % 0xfffc == 0x1 (0x1) +__uchar 0x1 % 0xfc == 0x1 (0x1) +__longlong 0x1 % 0xfffc == 0x1 (0x1) +__ulonglong 0x1 % 0xfffc == 0x1 (0x1) +0x1 * 0xa == 0xa +0x1 / 0xa == 0x0 +0x1 % 0xa == 0x1 +int 0x1 ^ 0xa == 0xb (0xb) +__uint 0x1 ^ 0xa == 0xb (0xb) +char 0x1 ^ 0xa == 0xb (0xb) +__uchar 0x1 ^ 0xa == 0xb (0xb) +__longlong 0x1 ^ 0xa == 0xb (0xb) +__ulonglong 0x1 ^ 0xa == 0xb (0xb) +int 0x1 && 0xa == 0x1 (0x1) +__uint 0x1 && 0xa == 0x1 (0x1) +char 0x1 && 0xa == 0x1 (0x1) +__uchar 0x1 && 0xa == 0x1 (0x1) +__longlong 0x1 && 0xa == 0x1 (0x1) +__ulonglong 0x1 && 0xa == 0x1 (0x1) +int 0x1 || 0xa == 0x1 (0x1) +__uint 0x1 || 0xa == 0x1 (0x1) +char 0x1 || 0xa == 0x1 (0x1) +__uchar 0x1 || 0xa == 0x1 (0x1) +__longlong 0x1 || 0xa == 0x1 (0x1) +__ulonglong 0x1 || 0xa == 0x1 (0x1) +int 0x1 & 0xa == 0x0 (0x0) +__uint 0x1 & 0xa == 0x0 (0x0) +char 0x1 & 0xa == 0x0 (0x0) +__uchar 0x1 & 0xa == 0x0 (0x0) +__longlong 0x1 & 0xa == 0x0 (0x0) +__ulonglong 0x1 & 0xa == 0x0 (0x0) +int 0x1 | 0xa == 0xb (0xb) +__uint 0x1 | 0xa == 0xb (0xb) +char 0x1 | 0xa == 0xb (0xb) +__uchar 0x1 | 0xa == 0xb (0xb) +__longlong 0x1 | 0xa == 0xb (0xb) +__ulonglong 0x1 | 0xa == 0xb (0xb) +int 0x1 << 0x7 == 0x80 (0x80) +__uint 0x1 << 0x7 == 0x80 (0x80) +char 0x1 << 0x7 == -0x80 (0xff80) +__uchar 0x1 << 0x7 == 0x80 (0x80) +__longlong 0x1 << 0x7 == 0x80 (0x80) +__ulonglong 0x1 << 0x7 == 0x80 (0x80) +int 0x1 >> 0x7 == 0x0 (0x0) +__uint 0x1 >> 0x7 == 0x0 (0x0) +char 0x1 >> 0x7 == 0x0 (0x0) +__uchar 0x1 >> 0x7 == 0x0 (0x0) +__longlong 0x1 >> 0x7 == 0x0 (0x0) +__ulonglong 0x1 >> 0x7 == 0x0 (0x0) +int 0x1 + 0xa == 0xb (0xb) +__uint 0x1 + 0xa == 0xb (0xb) +char 0x1 + 0xa == 0xb (0xb) +__uchar 0x1 + 0xa == 0xb (0xb) +__longlong 0x1 + 0xa == 0xb (0xb) +__ulonglong 0x1 + 0xa == 0xb (0xb) +float 0x1 + 0xa == 0xb (0xb) +int 0x1 - 0xa == -0x9 (0xfff7) +__uint 0x1 - 0xa == -0x9 (0xfff7) +char 0x1 - 0xa == -0x9 (0xfff7) +__uchar 0x1 - 0xa == 0xf7 (0xf7) +__longlong 0x1 - 0xa == -0x9 (0xfff7) +__ulonglong 0x1 - 0xa == -0x9 (0xfff7) +float 0x1 - 0xa == -0x9 (0xfff7) +int 0x1 * 0xa == 0xa (0xa) +__uint 0x1 * 0xa == 0xa (0xa) +char 0x1 * 0xa == 0xa (0xa) +__uchar 0x1 * 0xa == 0xa (0xa) +__longlong 0x1 * 0xa == 0xa (0xa) +__ulonglong 0x1 * 0xa == 0xa (0xa) +float 0x1 * 0xa == 0xa (0xa) +int 0x1 < 0xa == 0x1 (0x1) +__uint 0x1 < 0xa == 0x1 (0x1) +char 0x1 < 0xa == 0x1 (0x1) +__uchar 0x1 < 0xa == 0x1 (0x1) +__longlong 0x1 < 0xa == 0x1 (0x1) +__ulonglong 0x1 < 0xa == 0x1 (0x1) +float 0x1 < 0xa == 0x1 (0x1) +int 0x1 > 0xa == 0x0 (0x0) +__uint 0x1 > 0xa == 0x0 (0x0) +char 0x1 > 0xa == 0x0 (0x0) +__uchar 0x1 > 0xa == 0x0 (0x0) +__longlong 0x1 > 0xa == 0x0 (0x0) +__ulonglong 0x1 > 0xa == 0x0 (0x0) +float 0x1 > 0xa == 0x0 (0x0) +int 0x1 <= 0xa == 0x1 (0x1) +__uint 0x1 <= 0xa == 0x1 (0x1) +char 0x1 <= 0xa == 0x1 (0x1) +__uchar 0x1 <= 0xa == 0x1 (0x1) +__longlong 0x1 <= 0xa == 0x1 (0x1) +__ulonglong 0x1 <= 0xa == 0x1 (0x1) +float 0x1 <= 0xa == 0x1 (0x1) +int 0x1 == 0xa == 0x0 (0x0) +__uint 0x1 == 0xa == 0x0 (0x0) +char 0x1 == 0xa == 0x0 (0x0) +__uchar 0x1 == 0xa == 0x0 (0x0) +__longlong 0x1 == 0xa == 0x0 (0x0) +__ulonglong 0x1 == 0xa == 0x0 (0x0) +float 0x1 == 0xa == 0x0 (0x0) +int 0x1 != 0xa == 0x1 (0x1) +__uint 0x1 != 0xa == 0x1 (0x1) +char 0x1 != 0xa == 0x1 (0x1) +__uchar 0x1 != 0xa == 0x1 (0x1) +__longlong 0x1 != 0xa == 0x1 (0x1) +__ulonglong 0x1 != 0xa == 0x1 (0x1) +float 0x1 != 0xa == 0x1 (0x1) +int 0x1 >= 0xa == 0x0 (0x0) +__uint 0x1 >= 0xa == 0x0 (0x0) +char 0x1 >= 0xa == 0x0 (0x0) +__uchar 0x1 >= 0xa == 0x0 (0x0) +__longlong 0x1 >= 0xa == 0x0 (0x0) +__ulonglong 0x1 >= 0xa == 0x0 (0x0) +float 0x1 >= 0xa == 0x0 (0x0) +int 0x1 / 0xa == 0x0 (0x0) +__uint 0x1 / 0xa == 0x0 (0x0) +char 0x1 / 0xa == 0x0 (0x0) +__uchar 0x1 / 0xa == 0x0 (0x0) +__longlong 0x1 / 0xa == 0x0 (0x0) +__ulonglong 0x1 / 0xa == 0x0 (0x0) +float 0x1 / 0xa == 0x0 (0x0) +int 0x1 % 0xa == 0x1 (0x1) +__uint 0x1 % 0xa == 0x1 (0x1) +char 0x1 % 0xa == 0x1 (0x1) +__uchar 0x1 % 0xa == 0x1 (0x1) +__longlong 0x1 % 0xa == 0x1 (0x1) +__ulonglong 0x1 % 0xa == 0x1 (0x1) +0x1 * 0xfff6 == -0xa +0x1 / 0xfff6 == 0x0 +0x1 % 0xfff6 == 0x1 +int 0x1 ^ 0xfff6 == -0x9 (0xfff7) +__uint 0x1 ^ 0xfff6 == -0x9 (0xfff7) +char 0x1 ^ 0xfff6 == -0x9 (0xfff7) +__uchar 0x1 ^ 0xf6 == 0xf7 (0xf7) +__longlong 0x1 ^ 0xfff6 == -0x9 (0xfff7) +__ulonglong 0x1 ^ 0xfff6 == -0x9 (0xfff7) +int 0x1 && 0xfff6 == 0x1 (0x1) +__uint 0x1 && 0xfff6 == 0x1 (0x1) +char 0x1 && 0xfff6 == 0x1 (0x1) +__uchar 0x1 && 0xf6 == 0x1 (0x1) +__longlong 0x1 && 0xfff6 == 0x1 (0x1) +__ulonglong 0x1 && 0xfff6 == 0x1 (0x1) +int 0x1 || 0xfff6 == 0x1 (0x1) +__uint 0x1 || 0xfff6 == 0x1 (0x1) +char 0x1 || 0xfff6 == 0x1 (0x1) +__uchar 0x1 || 0xf6 == 0x1 (0x1) +__longlong 0x1 || 0xfff6 == 0x1 (0x1) +__ulonglong 0x1 || 0xfff6 == 0x1 (0x1) +int 0x1 & 0xfff6 == 0x0 (0x0) +__uint 0x1 & 0xfff6 == 0x0 (0x0) +char 0x1 & 0xfff6 == 0x0 (0x0) +__uchar 0x1 & 0xf6 == 0x0 (0x0) +__longlong 0x1 & 0xfff6 == 0x0 (0x0) +__ulonglong 0x1 & 0xfff6 == 0x0 (0x0) +int 0x1 | 0xfff6 == -0x9 (0xfff7) +__uint 0x1 | 0xfff6 == -0x9 (0xfff7) +char 0x1 | 0xfff6 == -0x9 (0xfff7) +__uchar 0x1 | 0xf6 == 0xf7 (0xf7) +__longlong 0x1 | 0xfff6 == -0x9 (0xfff7) +__ulonglong 0x1 | 0xfff6 == -0x9 (0xfff7) +int 0x1 << 0x8 == 0x100 (0x100) +__uint 0x1 << 0x8 == 0x100 (0x100) +char 0x1 << 0x8 == 0x0 (0x0) +__uchar 0x1 << 0x8 == 0x0 (0x0) +__longlong 0x1 << 0x8 == 0x100 (0x100) +__ulonglong 0x1 << 0x8 == 0x100 (0x100) +int 0x1 >> 0x8 == 0x0 (0x0) +__uint 0x1 >> 0x8 == 0x0 (0x0) +char 0x1 >> 0x8 == 0x0 (0x0) +__uchar 0x1 >> 0x8 == 0x0 (0x0) +__longlong 0x1 >> 0x8 == 0x0 (0x0) +__ulonglong 0x1 >> 0x8 == 0x0 (0x0) +int 0x1 + 0xfff6 == -0x9 (0xfff7) +__uint 0x1 + 0xfff6 == -0x9 (0xfff7) +char 0x1 + 0xfff6 == -0x9 (0xfff7) +__uchar 0x1 + 0xf6 == 0xf7 (0xf7) +__longlong 0x1 + 0xfff6 == -0x9 (0xfff7) +__ulonglong 0x1 + 0xfff6 == -0x9 (0xfff7) +float 0x1 + 0xfff6 == -0x9 (0xfff7) +int 0x1 - 0xfff6 == 0xb (0xb) +__uint 0x1 - 0xfff6 == 0xb (0xb) +char 0x1 - 0xfff6 == 0xb (0xb) +__uchar 0x1 - 0xf6 == 0xb (0xb) +__longlong 0x1 - 0xfff6 == 0xb (0xb) +__ulonglong 0x1 - 0xfff6 == 0xb (0xb) +float 0x1 - 0xfff6 == 0xb (0xb) +int 0x1 * 0xfff6 == -0xa (0xfff6) +__uint 0x1 * 0xfff6 == -0xa (0xfff6) +char 0x1 * 0xfff6 == -0xa (0xfff6) +__uchar 0x1 * 0xf6 == 0xf6 (0xf6) +__longlong 0x1 * 0xfff6 == -0xa (0xfff6) +__ulonglong 0x1 * 0xfff6 == -0xa (0xfff6) +float 0x1 * 0xfff6 == -0xa (0xfff6) +int 0x1 < 0xfff6 == 0x0 (0x0) +__uint 0x1 < 0xfff6 == 0x1 (0x1) +char 0x1 < 0xfff6 == 0x0 (0x0) +__uchar 0x1 < 0xf6 == 0x1 (0x1) +__longlong 0x1 < 0xfff6 == 0x0 (0x0) +__ulonglong 0x1 < 0xfff6 == 0x1 (0x1) +float 0x1 < 0xfff6 == 0x0 (0x0) +int 0x1 > 0xfff6 == 0x1 (0x1) +__uint 0x1 > 0xfff6 == 0x0 (0x0) +char 0x1 > 0xfff6 == 0x1 (0x1) +__uchar 0x1 > 0xf6 == 0x0 (0x0) +__longlong 0x1 > 0xfff6 == 0x1 (0x1) +__ulonglong 0x1 > 0xfff6 == 0x0 (0x0) +float 0x1 > 0xfff6 == 0x1 (0x1) +int 0x1 <= 0xfff6 == 0x0 (0x0) +__uint 0x1 <= 0xfff6 == 0x1 (0x1) +char 0x1 <= 0xfff6 == 0x0 (0x0) +__uchar 0x1 <= 0xf6 == 0x1 (0x1) +__longlong 0x1 <= 0xfff6 == 0x0 (0x0) +__ulonglong 0x1 <= 0xfff6 == 0x1 (0x1) +float 0x1 <= 0xfff6 == 0x0 (0x0) +int 0x1 == 0xfff6 == 0x0 (0x0) +__uint 0x1 == 0xfff6 == 0x0 (0x0) +char 0x1 == 0xfff6 == 0x0 (0x0) +__uchar 0x1 == 0xf6 == 0x0 (0x0) +__longlong 0x1 == 0xfff6 == 0x0 (0x0) +__ulonglong 0x1 == 0xfff6 == 0x0 (0x0) +float 0x1 == 0xfff6 == 0x0 (0x0) +int 0x1 != 0xfff6 == 0x1 (0x1) +__uint 0x1 != 0xfff6 == 0x1 (0x1) +char 0x1 != 0xfff6 == 0x1 (0x1) +__uchar 0x1 != 0xf6 == 0x1 (0x1) +__longlong 0x1 != 0xfff6 == 0x1 (0x1) +__ulonglong 0x1 != 0xfff6 == 0x1 (0x1) +float 0x1 != 0xfff6 == 0x1 (0x1) +int 0x1 >= 0xfff6 == 0x1 (0x1) +__uint 0x1 >= 0xfff6 == 0x0 (0x0) +char 0x1 >= 0xfff6 == 0x1 (0x1) +__uchar 0x1 >= 0xf6 == 0x0 (0x0) +__longlong 0x1 >= 0xfff6 == 0x1 (0x1) +__ulonglong 0x1 >= 0xfff6 == 0x0 (0x0) +float 0x1 >= 0xfff6 == 0x1 (0x1) +int 0x1 / 0xfff6 == 0x0 (0x0) +__uint 0x1 / 0xfff6 == 0x0 (0x0) +char 0x1 / 0xfff6 == 0x0 (0x0) +__uchar 0x1 / 0xf6 == 0x0 (0x0) +__longlong 0x1 / 0xfff6 == 0x0 (0x0) +__ulonglong 0x1 / 0xfff6 == 0x0 (0x0) +float 0x1 / 0xfff6 == 0x0 (0x0) +int 0x1 % 0xfff6 == 0x1 (0x1) +__uint 0x1 % 0xfff6 == 0x1 (0x1) +char 0x1 % 0xfff6 == 0x1 (0x1) +__uchar 0x1 % 0xf6 == 0x1 (0x1) +__longlong 0x1 % 0xfff6 == 0x1 (0x1) +__ulonglong 0x1 % 0xfff6 == 0x1 (0x1) +0x1 * 0x5 == 0x5 +0x1 / 0x5 == 0x0 +0x1 % 0x5 == 0x1 +int 0x1 ^ 0x5 == 0x4 (0x4) +__uint 0x1 ^ 0x5 == 0x4 (0x4) +char 0x1 ^ 0x5 == 0x4 (0x4) +__uchar 0x1 ^ 0x5 == 0x4 (0x4) +__longlong 0x1 ^ 0x5 == 0x4 (0x4) +__ulonglong 0x1 ^ 0x5 == 0x4 (0x4) +int 0x1 && 0x5 == 0x1 (0x1) +__uint 0x1 && 0x5 == 0x1 (0x1) +char 0x1 && 0x5 == 0x1 (0x1) +__uchar 0x1 && 0x5 == 0x1 (0x1) +__longlong 0x1 && 0x5 == 0x1 (0x1) +__ulonglong 0x1 && 0x5 == 0x1 (0x1) +int 0x1 || 0x5 == 0x1 (0x1) +__uint 0x1 || 0x5 == 0x1 (0x1) +char 0x1 || 0x5 == 0x1 (0x1) +__uchar 0x1 || 0x5 == 0x1 (0x1) +__longlong 0x1 || 0x5 == 0x1 (0x1) +__ulonglong 0x1 || 0x5 == 0x1 (0x1) +int 0x1 & 0x5 == 0x1 (0x1) +__uint 0x1 & 0x5 == 0x1 (0x1) +char 0x1 & 0x5 == 0x1 (0x1) +__uchar 0x1 & 0x5 == 0x1 (0x1) +__longlong 0x1 & 0x5 == 0x1 (0x1) +__ulonglong 0x1 & 0x5 == 0x1 (0x1) +int 0x1 | 0x5 == 0x5 (0x5) +__uint 0x1 | 0x5 == 0x5 (0x5) +char 0x1 | 0x5 == 0x5 (0x5) +__uchar 0x1 | 0x5 == 0x5 (0x5) +__longlong 0x1 | 0x5 == 0x5 (0x5) +__ulonglong 0x1 | 0x5 == 0x5 (0x5) +int 0x1 << 0x9 == 0x200 (0x200) +__uint 0x1 << 0x9 == 0x200 (0x200) +char 0x1 << 0x9 == 0x0 (0x0) +__uchar 0x1 << 0x9 == 0x0 (0x0) +__longlong 0x1 << 0x9 == 0x200 (0x200) +__ulonglong 0x1 << 0x9 == 0x200 (0x200) +int 0x1 >> 0x9 == 0x0 (0x0) +__uint 0x1 >> 0x9 == 0x0 (0x0) +char 0x1 >> 0x9 == 0x0 (0x0) +__uchar 0x1 >> 0x9 == 0x0 (0x0) +__longlong 0x1 >> 0x9 == 0x0 (0x0) +__ulonglong 0x1 >> 0x9 == 0x0 (0x0) +int 0x1 + 0x5 == 0x6 (0x6) +__uint 0x1 + 0x5 == 0x6 (0x6) +char 0x1 + 0x5 == 0x6 (0x6) +__uchar 0x1 + 0x5 == 0x6 (0x6) +__longlong 0x1 + 0x5 == 0x6 (0x6) +__ulonglong 0x1 + 0x5 == 0x6 (0x6) +float 0x1 + 0x5 == 0x6 (0x6) +int 0x1 - 0x5 == -0x4 (0xfffc) +__uint 0x1 - 0x5 == -0x4 (0xfffc) +char 0x1 - 0x5 == -0x4 (0xfffc) +__uchar 0x1 - 0x5 == 0xfc (0xfc) +__longlong 0x1 - 0x5 == -0x4 (0xfffc) +__ulonglong 0x1 - 0x5 == -0x4 (0xfffc) +float 0x1 - 0x5 == -0x4 (0xfffc) +int 0x1 * 0x5 == 0x5 (0x5) +__uint 0x1 * 0x5 == 0x5 (0x5) +char 0x1 * 0x5 == 0x5 (0x5) +__uchar 0x1 * 0x5 == 0x5 (0x5) +__longlong 0x1 * 0x5 == 0x5 (0x5) +__ulonglong 0x1 * 0x5 == 0x5 (0x5) +float 0x1 * 0x5 == 0x5 (0x5) +int 0x1 < 0x5 == 0x1 (0x1) +__uint 0x1 < 0x5 == 0x1 (0x1) +char 0x1 < 0x5 == 0x1 (0x1) +__uchar 0x1 < 0x5 == 0x1 (0x1) +__longlong 0x1 < 0x5 == 0x1 (0x1) +__ulonglong 0x1 < 0x5 == 0x1 (0x1) +float 0x1 < 0x5 == 0x1 (0x1) +int 0x1 > 0x5 == 0x0 (0x0) +__uint 0x1 > 0x5 == 0x0 (0x0) +char 0x1 > 0x5 == 0x0 (0x0) +__uchar 0x1 > 0x5 == 0x0 (0x0) +__longlong 0x1 > 0x5 == 0x0 (0x0) +__ulonglong 0x1 > 0x5 == 0x0 (0x0) +float 0x1 > 0x5 == 0x0 (0x0) +int 0x1 <= 0x5 == 0x1 (0x1) +__uint 0x1 <= 0x5 == 0x1 (0x1) +char 0x1 <= 0x5 == 0x1 (0x1) +__uchar 0x1 <= 0x5 == 0x1 (0x1) +__longlong 0x1 <= 0x5 == 0x1 (0x1) +__ulonglong 0x1 <= 0x5 == 0x1 (0x1) +float 0x1 <= 0x5 == 0x1 (0x1) +int 0x1 == 0x5 == 0x0 (0x0) +__uint 0x1 == 0x5 == 0x0 (0x0) +char 0x1 == 0x5 == 0x0 (0x0) +__uchar 0x1 == 0x5 == 0x0 (0x0) +__longlong 0x1 == 0x5 == 0x0 (0x0) +__ulonglong 0x1 == 0x5 == 0x0 (0x0) +float 0x1 == 0x5 == 0x0 (0x0) +int 0x1 != 0x5 == 0x1 (0x1) +__uint 0x1 != 0x5 == 0x1 (0x1) +char 0x1 != 0x5 == 0x1 (0x1) +__uchar 0x1 != 0x5 == 0x1 (0x1) +__longlong 0x1 != 0x5 == 0x1 (0x1) +__ulonglong 0x1 != 0x5 == 0x1 (0x1) +float 0x1 != 0x5 == 0x1 (0x1) +int 0x1 >= 0x5 == 0x0 (0x0) +__uint 0x1 >= 0x5 == 0x0 (0x0) +char 0x1 >= 0x5 == 0x0 (0x0) +__uchar 0x1 >= 0x5 == 0x0 (0x0) +__longlong 0x1 >= 0x5 == 0x0 (0x0) +__ulonglong 0x1 >= 0x5 == 0x0 (0x0) +float 0x1 >= 0x5 == 0x0 (0x0) +int 0x1 / 0x5 == 0x0 (0x0) +__uint 0x1 / 0x5 == 0x0 (0x0) +char 0x1 / 0x5 == 0x0 (0x0) +__uchar 0x1 / 0x5 == 0x0 (0x0) +__longlong 0x1 / 0x5 == 0x0 (0x0) +__ulonglong 0x1 / 0x5 == 0x0 (0x0) +float 0x1 / 0x5 == 0x0 (0x0) +int 0x1 % 0x5 == 0x1 (0x1) +__uint 0x1 % 0x5 == 0x1 (0x1) +char 0x1 % 0x5 == 0x1 (0x1) +__uchar 0x1 % 0x5 == 0x1 (0x1) +__longlong 0x1 % 0x5 == 0x1 (0x1) +__ulonglong 0x1 % 0x5 == 0x1 (0x1) +0x1 * 0x7 == 0x7 +0x1 / 0x7 == 0x0 +0x1 % 0x7 == 0x1 +int 0x1 ^ 0x7 == 0x6 (0x6) +__uint 0x1 ^ 0x7 == 0x6 (0x6) +char 0x1 ^ 0x7 == 0x6 (0x6) +__uchar 0x1 ^ 0x7 == 0x6 (0x6) +__longlong 0x1 ^ 0x7 == 0x6 (0x6) +__ulonglong 0x1 ^ 0x7 == 0x6 (0x6) +int 0x1 && 0x7 == 0x1 (0x1) +__uint 0x1 && 0x7 == 0x1 (0x1) +char 0x1 && 0x7 == 0x1 (0x1) +__uchar 0x1 && 0x7 == 0x1 (0x1) +__longlong 0x1 && 0x7 == 0x1 (0x1) +__ulonglong 0x1 && 0x7 == 0x1 (0x1) +int 0x1 || 0x7 == 0x1 (0x1) +__uint 0x1 || 0x7 == 0x1 (0x1) +char 0x1 || 0x7 == 0x1 (0x1) +__uchar 0x1 || 0x7 == 0x1 (0x1) +__longlong 0x1 || 0x7 == 0x1 (0x1) +__ulonglong 0x1 || 0x7 == 0x1 (0x1) +int 0x1 & 0x7 == 0x1 (0x1) +__uint 0x1 & 0x7 == 0x1 (0x1) +char 0x1 & 0x7 == 0x1 (0x1) +__uchar 0x1 & 0x7 == 0x1 (0x1) +__longlong 0x1 & 0x7 == 0x1 (0x1) +__ulonglong 0x1 & 0x7 == 0x1 (0x1) +int 0x1 | 0x7 == 0x7 (0x7) +__uint 0x1 | 0x7 == 0x7 (0x7) +char 0x1 | 0x7 == 0x7 (0x7) +__uchar 0x1 | 0x7 == 0x7 (0x7) +__longlong 0x1 | 0x7 == 0x7 (0x7) +__ulonglong 0x1 | 0x7 == 0x7 (0x7) +int 0x1 << 0xa == 0x400 (0x400) +__uint 0x1 << 0xa == 0x400 (0x400) +char 0x1 << 0xa == 0x0 (0x0) +__uchar 0x1 << 0xa == 0x0 (0x0) +__longlong 0x1 << 0xa == 0x400 (0x400) +__ulonglong 0x1 << 0xa == 0x400 (0x400) +int 0x1 >> 0xa == 0x0 (0x0) +__uint 0x1 >> 0xa == 0x0 (0x0) +char 0x1 >> 0xa == 0x0 (0x0) +__uchar 0x1 >> 0xa == 0x0 (0x0) +__longlong 0x1 >> 0xa == 0x0 (0x0) +__ulonglong 0x1 >> 0xa == 0x0 (0x0) +int 0x1 + 0x7 == 0x8 (0x8) +__uint 0x1 + 0x7 == 0x8 (0x8) +char 0x1 + 0x7 == 0x8 (0x8) +__uchar 0x1 + 0x7 == 0x8 (0x8) +__longlong 0x1 + 0x7 == 0x8 (0x8) +__ulonglong 0x1 + 0x7 == 0x8 (0x8) +float 0x1 + 0x7 == 0x8 (0x8) +int 0x1 - 0x7 == -0x6 (0xfffa) +__uint 0x1 - 0x7 == -0x6 (0xfffa) +char 0x1 - 0x7 == -0x6 (0xfffa) +__uchar 0x1 - 0x7 == 0xfa (0xfa) +__longlong 0x1 - 0x7 == -0x6 (0xfffa) +__ulonglong 0x1 - 0x7 == -0x6 (0xfffa) +float 0x1 - 0x7 == -0x6 (0xfffa) +int 0x1 * 0x7 == 0x7 (0x7) +__uint 0x1 * 0x7 == 0x7 (0x7) +char 0x1 * 0x7 == 0x7 (0x7) +__uchar 0x1 * 0x7 == 0x7 (0x7) +__longlong 0x1 * 0x7 == 0x7 (0x7) +__ulonglong 0x1 * 0x7 == 0x7 (0x7) +float 0x1 * 0x7 == 0x7 (0x7) +int 0x1 < 0x7 == 0x1 (0x1) +__uint 0x1 < 0x7 == 0x1 (0x1) +char 0x1 < 0x7 == 0x1 (0x1) +__uchar 0x1 < 0x7 == 0x1 (0x1) +__longlong 0x1 < 0x7 == 0x1 (0x1) +__ulonglong 0x1 < 0x7 == 0x1 (0x1) +float 0x1 < 0x7 == 0x1 (0x1) +int 0x1 > 0x7 == 0x0 (0x0) +__uint 0x1 > 0x7 == 0x0 (0x0) +char 0x1 > 0x7 == 0x0 (0x0) +__uchar 0x1 > 0x7 == 0x0 (0x0) +__longlong 0x1 > 0x7 == 0x0 (0x0) +__ulonglong 0x1 > 0x7 == 0x0 (0x0) +float 0x1 > 0x7 == 0x0 (0x0) +int 0x1 <= 0x7 == 0x1 (0x1) +__uint 0x1 <= 0x7 == 0x1 (0x1) +char 0x1 <= 0x7 == 0x1 (0x1) +__uchar 0x1 <= 0x7 == 0x1 (0x1) +__longlong 0x1 <= 0x7 == 0x1 (0x1) +__ulonglong 0x1 <= 0x7 == 0x1 (0x1) +float 0x1 <= 0x7 == 0x1 (0x1) +int 0x1 == 0x7 == 0x0 (0x0) +__uint 0x1 == 0x7 == 0x0 (0x0) +char 0x1 == 0x7 == 0x0 (0x0) +__uchar 0x1 == 0x7 == 0x0 (0x0) +__longlong 0x1 == 0x7 == 0x0 (0x0) +__ulonglong 0x1 == 0x7 == 0x0 (0x0) +float 0x1 == 0x7 == 0x0 (0x0) +int 0x1 != 0x7 == 0x1 (0x1) +__uint 0x1 != 0x7 == 0x1 (0x1) +char 0x1 != 0x7 == 0x1 (0x1) +__uchar 0x1 != 0x7 == 0x1 (0x1) +__longlong 0x1 != 0x7 == 0x1 (0x1) +__ulonglong 0x1 != 0x7 == 0x1 (0x1) +float 0x1 != 0x7 == 0x1 (0x1) +int 0x1 >= 0x7 == 0x0 (0x0) +__uint 0x1 >= 0x7 == 0x0 (0x0) +char 0x1 >= 0x7 == 0x0 (0x0) +__uchar 0x1 >= 0x7 == 0x0 (0x0) +__longlong 0x1 >= 0x7 == 0x0 (0x0) +__ulonglong 0x1 >= 0x7 == 0x0 (0x0) +float 0x1 >= 0x7 == 0x0 (0x0) +int 0x1 / 0x7 == 0x0 (0x0) +__uint 0x1 / 0x7 == 0x0 (0x0) +char 0x1 / 0x7 == 0x0 (0x0) +__uchar 0x1 / 0x7 == 0x0 (0x0) +__longlong 0x1 / 0x7 == 0x0 (0x0) +__ulonglong 0x1 / 0x7 == 0x0 (0x0) +float 0x1 / 0x7 == 0x0 (0x0) +int 0x1 % 0x7 == 0x1 (0x1) +__uint 0x1 % 0x7 == 0x1 (0x1) +char 0x1 % 0x7 == 0x1 (0x1) +__uchar 0x1 % 0x7 == 0x1 (0x1) +__longlong 0x1 % 0x7 == 0x1 (0x1) +__ulonglong 0x1 % 0x7 == 0x1 (0x1) +0x1 * 0x2a == 0x2a +0x1 / 0x2a == 0x0 +0x1 % 0x2a == 0x1 +int 0x1 ^ 0x2a == 0x2b (0x2b) +__uint 0x1 ^ 0x2a == 0x2b (0x2b) +char 0x1 ^ 0x2a == 0x2b (0x2b) +__uchar 0x1 ^ 0x2a == 0x2b (0x2b) +__longlong 0x1 ^ 0x2a == 0x2b (0x2b) +__ulonglong 0x1 ^ 0x2a == 0x2b (0x2b) +int 0x1 && 0x2a == 0x1 (0x1) +__uint 0x1 && 0x2a == 0x1 (0x1) +char 0x1 && 0x2a == 0x1 (0x1) +__uchar 0x1 && 0x2a == 0x1 (0x1) +__longlong 0x1 && 0x2a == 0x1 (0x1) +__ulonglong 0x1 && 0x2a == 0x1 (0x1) +int 0x1 || 0x2a == 0x1 (0x1) +__uint 0x1 || 0x2a == 0x1 (0x1) +char 0x1 || 0x2a == 0x1 (0x1) +__uchar 0x1 || 0x2a == 0x1 (0x1) +__longlong 0x1 || 0x2a == 0x1 (0x1) +__ulonglong 0x1 || 0x2a == 0x1 (0x1) +int 0x1 & 0x2a == 0x0 (0x0) +__uint 0x1 & 0x2a == 0x0 (0x0) +char 0x1 & 0x2a == 0x0 (0x0) +__uchar 0x1 & 0x2a == 0x0 (0x0) +__longlong 0x1 & 0x2a == 0x0 (0x0) +__ulonglong 0x1 & 0x2a == 0x0 (0x0) +int 0x1 | 0x2a == 0x2b (0x2b) +__uint 0x1 | 0x2a == 0x2b (0x2b) +char 0x1 | 0x2a == 0x2b (0x2b) +__uchar 0x1 | 0x2a == 0x2b (0x2b) +__longlong 0x1 | 0x2a == 0x2b (0x2b) +__ulonglong 0x1 | 0x2a == 0x2b (0x2b) +int 0x1 << 0xc == 0x1000 (0x1000) +__uint 0x1 << 0xc == 0x1000 (0x1000) +char 0x1 << 0xc == 0x0 (0x0) +__uchar 0x1 << 0xc == 0x0 (0x0) +__longlong 0x1 << 0xc == 0x1000 (0x1000) +__ulonglong 0x1 << 0xc == 0x1000 (0x1000) +int 0x1 >> 0xc == 0x0 (0x0) +__uint 0x1 >> 0xc == 0x0 (0x0) +char 0x1 >> 0xc == 0x0 (0x0) +__uchar 0x1 >> 0xc == 0x0 (0x0) +__longlong 0x1 >> 0xc == 0x0 (0x0) +__ulonglong 0x1 >> 0xc == 0x0 (0x0) +int 0x1 + 0x2a == 0x2b (0x2b) +__uint 0x1 + 0x2a == 0x2b (0x2b) +char 0x1 + 0x2a == 0x2b (0x2b) +__uchar 0x1 + 0x2a == 0x2b (0x2b) +__longlong 0x1 + 0x2a == 0x2b (0x2b) +__ulonglong 0x1 + 0x2a == 0x2b (0x2b) +float 0x1 + 0x2a == 0x2b (0x2b) +int 0x1 - 0x2a == -0x29 (0xffd7) +__uint 0x1 - 0x2a == -0x29 (0xffd7) +char 0x1 - 0x2a == -0x29 (0xffd7) +__uchar 0x1 - 0x2a == 0xd7 (0xd7) +__longlong 0x1 - 0x2a == -0x29 (0xffd7) +__ulonglong 0x1 - 0x2a == -0x29 (0xffd7) +float 0x1 - 0x2a == -0x29 (0xffd7) +int 0x1 * 0x2a == 0x2a (0x2a) +__uint 0x1 * 0x2a == 0x2a (0x2a) +char 0x1 * 0x2a == 0x2a (0x2a) +__uchar 0x1 * 0x2a == 0x2a (0x2a) +__longlong 0x1 * 0x2a == 0x2a (0x2a) +__ulonglong 0x1 * 0x2a == 0x2a (0x2a) +float 0x1 * 0x2a == 0x2a (0x2a) +int 0x1 < 0x2a == 0x1 (0x1) +__uint 0x1 < 0x2a == 0x1 (0x1) +char 0x1 < 0x2a == 0x1 (0x1) +__uchar 0x1 < 0x2a == 0x1 (0x1) +__longlong 0x1 < 0x2a == 0x1 (0x1) +__ulonglong 0x1 < 0x2a == 0x1 (0x1) +float 0x1 < 0x2a == 0x1 (0x1) +int 0x1 > 0x2a == 0x0 (0x0) +__uint 0x1 > 0x2a == 0x0 (0x0) +char 0x1 > 0x2a == 0x0 (0x0) +__uchar 0x1 > 0x2a == 0x0 (0x0) +__longlong 0x1 > 0x2a == 0x0 (0x0) +__ulonglong 0x1 > 0x2a == 0x0 (0x0) +float 0x1 > 0x2a == 0x0 (0x0) +int 0x1 <= 0x2a == 0x1 (0x1) +__uint 0x1 <= 0x2a == 0x1 (0x1) +char 0x1 <= 0x2a == 0x1 (0x1) +__uchar 0x1 <= 0x2a == 0x1 (0x1) +__longlong 0x1 <= 0x2a == 0x1 (0x1) +__ulonglong 0x1 <= 0x2a == 0x1 (0x1) +float 0x1 <= 0x2a == 0x1 (0x1) +int 0x1 == 0x2a == 0x0 (0x0) +__uint 0x1 == 0x2a == 0x0 (0x0) +char 0x1 == 0x2a == 0x0 (0x0) +__uchar 0x1 == 0x2a == 0x0 (0x0) +__longlong 0x1 == 0x2a == 0x0 (0x0) +__ulonglong 0x1 == 0x2a == 0x0 (0x0) +float 0x1 == 0x2a == 0x0 (0x0) +int 0x1 != 0x2a == 0x1 (0x1) +__uint 0x1 != 0x2a == 0x1 (0x1) +char 0x1 != 0x2a == 0x1 (0x1) +__uchar 0x1 != 0x2a == 0x1 (0x1) +__longlong 0x1 != 0x2a == 0x1 (0x1) +__ulonglong 0x1 != 0x2a == 0x1 (0x1) +float 0x1 != 0x2a == 0x1 (0x1) +int 0x1 >= 0x2a == 0x0 (0x0) +__uint 0x1 >= 0x2a == 0x0 (0x0) +char 0x1 >= 0x2a == 0x0 (0x0) +__uchar 0x1 >= 0x2a == 0x0 (0x0) +__longlong 0x1 >= 0x2a == 0x0 (0x0) +__ulonglong 0x1 >= 0x2a == 0x0 (0x0) +float 0x1 >= 0x2a == 0x0 (0x0) +int 0x1 / 0x2a == 0x0 (0x0) +__uint 0x1 / 0x2a == 0x0 (0x0) +char 0x1 / 0x2a == 0x0 (0x0) +__uchar 0x1 / 0x2a == 0x0 (0x0) +__longlong 0x1 / 0x2a == 0x0 (0x0) +__ulonglong 0x1 / 0x2a == 0x0 (0x0) +float 0x1 / 0x2a == 0x0 (0x0) +int 0x1 % 0x2a == 0x1 (0x1) +__uint 0x1 % 0x2a == 0x1 (0x1) +char 0x1 % 0x2a == 0x1 (0x1) +__uchar 0x1 % 0x2a == 0x1 (0x1) +__longlong 0x1 % 0x2a == 0x1 (0x1) +__ulonglong 0x1 % 0x2a == 0x1 (0x1) +0x1 * 0x17 == 0x17 +0x1 / 0x17 == 0x0 +0x1 % 0x17 == 0x1 +int 0x1 ^ 0x17 == 0x16 (0x16) +__uint 0x1 ^ 0x17 == 0x16 (0x16) +char 0x1 ^ 0x17 == 0x16 (0x16) +__uchar 0x1 ^ 0x17 == 0x16 (0x16) +__longlong 0x1 ^ 0x17 == 0x16 (0x16) +__ulonglong 0x1 ^ 0x17 == 0x16 (0x16) +int 0x1 && 0x17 == 0x1 (0x1) +__uint 0x1 && 0x17 == 0x1 (0x1) +char 0x1 && 0x17 == 0x1 (0x1) +__uchar 0x1 && 0x17 == 0x1 (0x1) +__longlong 0x1 && 0x17 == 0x1 (0x1) +__ulonglong 0x1 && 0x17 == 0x1 (0x1) +int 0x1 || 0x17 == 0x1 (0x1) +__uint 0x1 || 0x17 == 0x1 (0x1) +char 0x1 || 0x17 == 0x1 (0x1) +__uchar 0x1 || 0x17 == 0x1 (0x1) +__longlong 0x1 || 0x17 == 0x1 (0x1) +__ulonglong 0x1 || 0x17 == 0x1 (0x1) +int 0x1 & 0x17 == 0x1 (0x1) +__uint 0x1 & 0x17 == 0x1 (0x1) +char 0x1 & 0x17 == 0x1 (0x1) +__uchar 0x1 & 0x17 == 0x1 (0x1) +__longlong 0x1 & 0x17 == 0x1 (0x1) +__ulonglong 0x1 & 0x17 == 0x1 (0x1) +int 0x1 | 0x17 == 0x17 (0x17) +__uint 0x1 | 0x17 == 0x17 (0x17) +char 0x1 | 0x17 == 0x17 (0x17) +__uchar 0x1 | 0x17 == 0x17 (0x17) +__longlong 0x1 | 0x17 == 0x17 (0x17) +__ulonglong 0x1 | 0x17 == 0x17 (0x17) +int 0x1 << 0xe == 0x4000 (0x4000) +__uint 0x1 << 0xe == 0x4000 (0x4000) +char 0x1 << 0xe == 0x0 (0x0) +__uchar 0x1 << 0xe == 0x0 (0x0) +__longlong 0x1 << 0xe == 0x4000 (0x4000) +__ulonglong 0x1 << 0xe == 0x4000 (0x4000) +int 0x1 >> 0xe == 0x0 (0x0) +__uint 0x1 >> 0xe == 0x0 (0x0) +char 0x1 >> 0xe == 0x0 (0x0) +__uchar 0x1 >> 0xe == 0x0 (0x0) +__longlong 0x1 >> 0xe == 0x0 (0x0) +__ulonglong 0x1 >> 0xe == 0x0 (0x0) +int 0x1 + 0x17 == 0x18 (0x18) +__uint 0x1 + 0x17 == 0x18 (0x18) +char 0x1 + 0x17 == 0x18 (0x18) +__uchar 0x1 + 0x17 == 0x18 (0x18) +__longlong 0x1 + 0x17 == 0x18 (0x18) +__ulonglong 0x1 + 0x17 == 0x18 (0x18) +float 0x1 + 0x17 == 0x18 (0x18) +int 0x1 - 0x17 == -0x16 (0xffea) +__uint 0x1 - 0x17 == -0x16 (0xffea) +char 0x1 - 0x17 == -0x16 (0xffea) +__uchar 0x1 - 0x17 == 0xea (0xea) +__longlong 0x1 - 0x17 == -0x16 (0xffea) +__ulonglong 0x1 - 0x17 == -0x16 (0xffea) +float 0x1 - 0x17 == -0x16 (0xffea) +int 0x1 * 0x17 == 0x17 (0x17) +__uint 0x1 * 0x17 == 0x17 (0x17) +char 0x1 * 0x17 == 0x17 (0x17) +__uchar 0x1 * 0x17 == 0x17 (0x17) +__longlong 0x1 * 0x17 == 0x17 (0x17) +__ulonglong 0x1 * 0x17 == 0x17 (0x17) +float 0x1 * 0x17 == 0x17 (0x17) +int 0x1 < 0x17 == 0x1 (0x1) +__uint 0x1 < 0x17 == 0x1 (0x1) +char 0x1 < 0x17 == 0x1 (0x1) +__uchar 0x1 < 0x17 == 0x1 (0x1) +__longlong 0x1 < 0x17 == 0x1 (0x1) +__ulonglong 0x1 < 0x17 == 0x1 (0x1) +float 0x1 < 0x17 == 0x1 (0x1) +int 0x1 > 0x17 == 0x0 (0x0) +__uint 0x1 > 0x17 == 0x0 (0x0) +char 0x1 > 0x17 == 0x0 (0x0) +__uchar 0x1 > 0x17 == 0x0 (0x0) +__longlong 0x1 > 0x17 == 0x0 (0x0) +__ulonglong 0x1 > 0x17 == 0x0 (0x0) +float 0x1 > 0x17 == 0x0 (0x0) +int 0x1 <= 0x17 == 0x1 (0x1) +__uint 0x1 <= 0x17 == 0x1 (0x1) +char 0x1 <= 0x17 == 0x1 (0x1) +__uchar 0x1 <= 0x17 == 0x1 (0x1) +__longlong 0x1 <= 0x17 == 0x1 (0x1) +__ulonglong 0x1 <= 0x17 == 0x1 (0x1) +float 0x1 <= 0x17 == 0x1 (0x1) +int 0x1 == 0x17 == 0x0 (0x0) +__uint 0x1 == 0x17 == 0x0 (0x0) +char 0x1 == 0x17 == 0x0 (0x0) +__uchar 0x1 == 0x17 == 0x0 (0x0) +__longlong 0x1 == 0x17 == 0x0 (0x0) +__ulonglong 0x1 == 0x17 == 0x0 (0x0) +float 0x1 == 0x17 == 0x0 (0x0) +int 0x1 != 0x17 == 0x1 (0x1) +__uint 0x1 != 0x17 == 0x1 (0x1) +char 0x1 != 0x17 == 0x1 (0x1) +__uchar 0x1 != 0x17 == 0x1 (0x1) +__longlong 0x1 != 0x17 == 0x1 (0x1) +__ulonglong 0x1 != 0x17 == 0x1 (0x1) +float 0x1 != 0x17 == 0x1 (0x1) +int 0x1 >= 0x17 == 0x0 (0x0) +__uint 0x1 >= 0x17 == 0x0 (0x0) +char 0x1 >= 0x17 == 0x0 (0x0) +__uchar 0x1 >= 0x17 == 0x0 (0x0) +__longlong 0x1 >= 0x17 == 0x0 (0x0) +__ulonglong 0x1 >= 0x17 == 0x0 (0x0) +float 0x1 >= 0x17 == 0x0 (0x0) +int 0x1 / 0x17 == 0x0 (0x0) +__uint 0x1 / 0x17 == 0x0 (0x0) +char 0x1 / 0x17 == 0x0 (0x0) +__uchar 0x1 / 0x17 == 0x0 (0x0) +__longlong 0x1 / 0x17 == 0x0 (0x0) +__ulonglong 0x1 / 0x17 == 0x0 (0x0) +float 0x1 / 0x17 == 0x0 (0x0) +int 0x1 % 0x17 == 0x1 (0x1) +__uint 0x1 % 0x17 == 0x1 (0x1) +char 0x1 % 0x17 == 0x1 (0x1) +__uchar 0x1 % 0x17 == 0x1 (0x1) +__longlong 0x1 % 0x17 == 0x1 (0x1) +__ulonglong 0x1 % 0x17 == 0x1 (0x1) +0x1 * 0x7fff == 0x7fff +0x1 / 0x7fff == 0x0 +0x1 % 0x7fff == 0x1 +int 0x1 ^ 0x7fff == 0x7ffe (0x7ffe) +__uint 0x1 ^ 0x7fff == 0x7ffe (0x7ffe) +char 0x1 ^ 0xffff == -0x2 (0xfffe) +__uchar 0x1 ^ 0xff == 0xfe (0xfe) +__longlong 0x1 ^ 0x7fff == 0x7ffe (0x7ffe) +__ulonglong 0x1 ^ 0x7fff == 0x7ffe (0x7ffe) +int 0x1 && 0x7fff == 0x1 (0x1) +__uint 0x1 && 0x7fff == 0x1 (0x1) +char 0x1 && 0xffff == 0x1 (0x1) +__uchar 0x1 && 0xff == 0x1 (0x1) +__longlong 0x1 && 0x7fff == 0x1 (0x1) +__ulonglong 0x1 && 0x7fff == 0x1 (0x1) +int 0x1 || 0x7fff == 0x1 (0x1) +__uint 0x1 || 0x7fff == 0x1 (0x1) +char 0x1 || 0xffff == 0x1 (0x1) +__uchar 0x1 || 0xff == 0x1 (0x1) +__longlong 0x1 || 0x7fff == 0x1 (0x1) +__ulonglong 0x1 || 0x7fff == 0x1 (0x1) +int 0x1 & 0x7fff == 0x1 (0x1) +__uint 0x1 & 0x7fff == 0x1 (0x1) +char 0x1 & 0xffff == 0x1 (0x1) +__uchar 0x1 & 0xff == 0x1 (0x1) +__longlong 0x1 & 0x7fff == 0x1 (0x1) +__ulonglong 0x1 & 0x7fff == 0x1 (0x1) +int 0x1 | 0x7fff == 0x7fff (0x7fff) +__uint 0x1 | 0x7fff == 0x7fff (0x7fff) +char 0x1 | 0xffff == -0x1 (0xffff) +__uchar 0x1 | 0xff == 0xff (0xff) +__longlong 0x1 | 0x7fff == 0x7fff (0x7fff) +__ulonglong 0x1 | 0x7fff == 0x7fff (0x7fff) +int 0x1 << 0x10 == 0x0 (0x0) +__uint 0x1 << 0x10 == 0x0 (0x0) +char 0x1 << 0x10 == 0x0 (0x0) +__uchar 0x1 << 0x10 == 0x0 (0x0) +__longlong 0x1 << 0x10 == 0x0 (0x0) +__ulonglong 0x1 << 0x10 == 0x0 (0x0) +int 0x1 >> 0x10 == 0x0 (0x0) +__uint 0x1 >> 0x10 == 0x0 (0x0) +char 0x1 >> 0x10 == 0x0 (0x0) +__uchar 0x1 >> 0x10 == 0x0 (0x0) +__longlong 0x1 >> 0x10 == 0x0 (0x0) +__ulonglong 0x1 >> 0x10 == 0x0 (0x0) +int 0x1 + 0x7fff == -0x8000 (0x8000) +__uint 0x1 + 0x7fff == -0x8000 (0x8000) +char 0x1 + 0xffff == 0x0 (0x0) +__uchar 0x1 + 0xff == 0x0 (0x0) +__longlong 0x1 + 0x7fff == -0x8000 (0x8000) +__ulonglong 0x1 + 0x7fff == -0x8000 (0x8000) +float 0x1 + 0x7fff == -0x8000 (0x8000) +int 0x1 - 0x7fff == -0x7ffe (0x8002) +__uint 0x1 - 0x7fff == -0x7ffe (0x8002) +char 0x1 - 0xffff == 0x2 (0x2) +__uchar 0x1 - 0xff == 0x2 (0x2) +__longlong 0x1 - 0x7fff == -0x7ffe (0x8002) +__ulonglong 0x1 - 0x7fff == -0x7ffe (0x8002) +float 0x1 - 0x7fff == -0x7ffe (0x8002) +int 0x1 * 0x7fff == 0x7fff (0x7fff) +__uint 0x1 * 0x7fff == 0x7fff (0x7fff) +char 0x1 * 0xffff == -0x1 (0xffff) +__uchar 0x1 * 0xff == 0xff (0xff) +__longlong 0x1 * 0x7fff == 0x7fff (0x7fff) +__ulonglong 0x1 * 0x7fff == 0x7fff (0x7fff) +float 0x1 * 0x7fff == 0x7fff (0x7fff) +int 0x1 < 0x7fff == 0x1 (0x1) +__uint 0x1 < 0x7fff == 0x1 (0x1) +char 0x1 < 0xffff == 0x0 (0x0) +__uchar 0x1 < 0xff == 0x1 (0x1) +__longlong 0x1 < 0x7fff == 0x1 (0x1) +__ulonglong 0x1 < 0x7fff == 0x1 (0x1) +float 0x1 < 0x7fff == 0x1 (0x1) +int 0x1 > 0x7fff == 0x0 (0x0) +__uint 0x1 > 0x7fff == 0x0 (0x0) +char 0x1 > 0xffff == 0x1 (0x1) +__uchar 0x1 > 0xff == 0x0 (0x0) +__longlong 0x1 > 0x7fff == 0x0 (0x0) +__ulonglong 0x1 > 0x7fff == 0x0 (0x0) +float 0x1 > 0x7fff == 0x0 (0x0) +int 0x1 <= 0x7fff == 0x1 (0x1) +__uint 0x1 <= 0x7fff == 0x1 (0x1) +char 0x1 <= 0xffff == 0x0 (0x0) +__uchar 0x1 <= 0xff == 0x1 (0x1) +__longlong 0x1 <= 0x7fff == 0x1 (0x1) +__ulonglong 0x1 <= 0x7fff == 0x1 (0x1) +float 0x1 <= 0x7fff == 0x1 (0x1) +int 0x1 == 0x7fff == 0x0 (0x0) +__uint 0x1 == 0x7fff == 0x0 (0x0) +char 0x1 == 0xffff == 0x0 (0x0) +__uchar 0x1 == 0xff == 0x0 (0x0) +__longlong 0x1 == 0x7fff == 0x0 (0x0) +__ulonglong 0x1 == 0x7fff == 0x0 (0x0) +float 0x1 == 0x7fff == 0x0 (0x0) +int 0x1 != 0x7fff == 0x1 (0x1) +__uint 0x1 != 0x7fff == 0x1 (0x1) +char 0x1 != 0xffff == 0x1 (0x1) +__uchar 0x1 != 0xff == 0x1 (0x1) +__longlong 0x1 != 0x7fff == 0x1 (0x1) +__ulonglong 0x1 != 0x7fff == 0x1 (0x1) +float 0x1 != 0x7fff == 0x1 (0x1) +int 0x1 >= 0x7fff == 0x0 (0x0) +__uint 0x1 >= 0x7fff == 0x0 (0x0) +char 0x1 >= 0xffff == 0x1 (0x1) +__uchar 0x1 >= 0xff == 0x0 (0x0) +__longlong 0x1 >= 0x7fff == 0x0 (0x0) +__ulonglong 0x1 >= 0x7fff == 0x0 (0x0) +float 0x1 >= 0x7fff == 0x0 (0x0) +int 0x1 / 0x7fff == 0x0 (0x0) +__uint 0x1 / 0x7fff == 0x0 (0x0) +char 0x1 / 0xffff == -0x1 (0xffff) +__uchar 0x1 / 0xff == 0x0 (0x0) +__longlong 0x1 / 0x7fff == 0x0 (0x0) +__ulonglong 0x1 / 0x7fff == 0x0 (0x0) +float 0x1 / 0x7fff == 0x0 (0x0) +int 0x1 % 0x7fff == 0x1 (0x1) +__uint 0x1 % 0x7fff == 0x1 (0x1) +char 0x1 % 0xffff == 0x0 (0x0) +__uchar 0x1 % 0xff == 0x1 (0x1) +__longlong 0x1 % 0x7fff == 0x1 (0x1) +__ulonglong 0x1 % 0x7fff == 0x1 (0x1) +0x1 * 0x8000 == -0x8000 +0x1 / 0x8000 == 0x0 +0x1 % 0x8000 == 0x1 +int 0x1 ^ 0x8000 == -0x7fff (0x8001) +__uint 0x1 ^ 0x8000 == -0x7fff (0x8001) +char 0x1 ^ 0x0 == 0x1 (0x1) +__uchar 0x1 ^ 0x0 == 0x1 (0x1) +__longlong 0x1 ^ 0x8000 == -0x7fff (0x8001) +__ulonglong 0x1 ^ 0x8000 == -0x7fff (0x8001) +int 0x1 && 0x8000 == 0x1 (0x1) +__uint 0x1 && 0x8000 == 0x1 (0x1) +char 0x1 && 0x0 == 0x0 (0x0) +__uchar 0x1 && 0x0 == 0x0 (0x0) +__longlong 0x1 && 0x8000 == 0x1 (0x1) +__ulonglong 0x1 && 0x8000 == 0x1 (0x1) +int 0x1 || 0x8000 == 0x1 (0x1) +__uint 0x1 || 0x8000 == 0x1 (0x1) +char 0x1 || 0x0 == 0x1 (0x1) +__uchar 0x1 || 0x0 == 0x1 (0x1) +__longlong 0x1 || 0x8000 == 0x1 (0x1) +__ulonglong 0x1 || 0x8000 == 0x1 (0x1) +int 0x1 & 0x8000 == 0x0 (0x0) +__uint 0x1 & 0x8000 == 0x0 (0x0) +char 0x1 & 0x0 == 0x0 (0x0) +__uchar 0x1 & 0x0 == 0x0 (0x0) +__longlong 0x1 & 0x8000 == 0x0 (0x0) +__ulonglong 0x1 & 0x8000 == 0x0 (0x0) +int 0x1 | 0x8000 == -0x7fff (0x8001) +__uint 0x1 | 0x8000 == -0x7fff (0x8001) +char 0x1 | 0x0 == 0x1 (0x1) +__uchar 0x1 | 0x0 == 0x1 (0x1) +__longlong 0x1 | 0x8000 == -0x7fff (0x8001) +__ulonglong 0x1 | 0x8000 == -0x7fff (0x8001) +int 0x1 << 0x12 == 0x0 (0x0) +__uint 0x1 << 0x12 == 0x0 (0x0) +char 0x1 << 0x12 == 0x0 (0x0) +__uchar 0x1 << 0x12 == 0x0 (0x0) +__longlong 0x1 << 0x12 == 0x0 (0x0) +__ulonglong 0x1 << 0x12 == 0x0 (0x0) +int 0x1 >> 0x12 == 0x0 (0x0) +__uint 0x1 >> 0x12 == 0x0 (0x0) +char 0x1 >> 0x12 == 0x0 (0x0) +__uchar 0x1 >> 0x12 == 0x0 (0x0) +__longlong 0x1 >> 0x12 == 0x0 (0x0) +__ulonglong 0x1 >> 0x12 == 0x0 (0x0) +int 0x1 + 0x8000 == -0x7fff (0x8001) +__uint 0x1 + 0x8000 == -0x7fff (0x8001) +char 0x1 + 0x0 == 0x1 (0x1) +__uchar 0x1 + 0x0 == 0x1 (0x1) +__longlong 0x1 + 0x8000 == -0x7fff (0x8001) +__ulonglong 0x1 + 0x8000 == -0x7fff (0x8001) +float 0x1 + 0x8000 == -0x7fff (0x8001) +int 0x1 - 0x8000 == -0x7fff (0x8001) +__uint 0x1 - 0x8000 == -0x7fff (0x8001) +char 0x1 - 0x0 == 0x1 (0x1) +__uchar 0x1 - 0x0 == 0x1 (0x1) +__longlong 0x1 - 0x8000 == -0x7fff (0x8001) +__ulonglong 0x1 - 0x8000 == -0x7fff (0x8001) +float 0x1 - 0x8000 == -0x8000 (0x8000) +int 0x1 * 0x8000 == -0x8000 (0x8000) +__uint 0x1 * 0x8000 == -0x8000 (0x8000) +char 0x1 * 0x0 == 0x0 (0x0) +__uchar 0x1 * 0x0 == 0x0 (0x0) +__longlong 0x1 * 0x8000 == -0x8000 (0x8000) +__ulonglong 0x1 * 0x8000 == -0x8000 (0x8000) +float 0x1 * 0x8000 == -0x8000 (0x8000) +int 0x1 < 0x8000 == 0x0 (0x0) +__uint 0x1 < 0x8000 == 0x1 (0x1) +char 0x1 < 0x0 == 0x0 (0x0) +__uchar 0x1 < 0x0 == 0x0 (0x0) +__longlong 0x1 < 0x8000 == 0x0 (0x0) +__ulonglong 0x1 < 0x8000 == 0x1 (0x1) +float 0x1 < 0x8000 == 0x0 (0x0) +int 0x1 > 0x8000 == 0x1 (0x1) +__uint 0x1 > 0x8000 == 0x0 (0x0) +char 0x1 > 0x0 == 0x1 (0x1) +__uchar 0x1 > 0x0 == 0x1 (0x1) +__longlong 0x1 > 0x8000 == 0x1 (0x1) +__ulonglong 0x1 > 0x8000 == 0x0 (0x0) +float 0x1 > 0x8000 == 0x1 (0x1) +int 0x1 <= 0x8000 == 0x0 (0x0) +__uint 0x1 <= 0x8000 == 0x1 (0x1) +char 0x1 <= 0x0 == 0x0 (0x0) +__uchar 0x1 <= 0x0 == 0x0 (0x0) +__longlong 0x1 <= 0x8000 == 0x0 (0x0) +__ulonglong 0x1 <= 0x8000 == 0x1 (0x1) +float 0x1 <= 0x8000 == 0x0 (0x0) +int 0x1 == 0x8000 == 0x0 (0x0) +__uint 0x1 == 0x8000 == 0x0 (0x0) +char 0x1 == 0x0 == 0x0 (0x0) +__uchar 0x1 == 0x0 == 0x0 (0x0) +__longlong 0x1 == 0x8000 == 0x0 (0x0) +__ulonglong 0x1 == 0x8000 == 0x0 (0x0) +float 0x1 == 0x8000 == 0x0 (0x0) +int 0x1 != 0x8000 == 0x1 (0x1) +__uint 0x1 != 0x8000 == 0x1 (0x1) +char 0x1 != 0x0 == 0x1 (0x1) +__uchar 0x1 != 0x0 == 0x1 (0x1) +__longlong 0x1 != 0x8000 == 0x1 (0x1) +__ulonglong 0x1 != 0x8000 == 0x1 (0x1) +float 0x1 != 0x8000 == 0x1 (0x1) +int 0x1 >= 0x8000 == 0x1 (0x1) +__uint 0x1 >= 0x8000 == 0x0 (0x0) +char 0x1 >= 0x0 == 0x1 (0x1) +__uchar 0x1 >= 0x0 == 0x1 (0x1) +__longlong 0x1 >= 0x8000 == 0x1 (0x1) +__ulonglong 0x1 >= 0x8000 == 0x0 (0x0) +float 0x1 >= 0x8000 == 0x1 (0x1) +int 0x1 / 0x8000 == 0x0 (0x0) +__uint 0x1 / 0x8000 == 0x0 (0x0) +__longlong 0x1 / 0x8000 == 0x0 (0x0) +__ulonglong 0x1 / 0x8000 == 0x0 (0x0) +float 0x1 / 0x8000 == 0x0 (0x0) +int 0x1 % 0x8000 == 0x1 (0x1) +__uint 0x1 % 0x8000 == 0x1 (0x1) +__longlong 0x1 % 0x8000 == 0x1 (0x1) +__ulonglong 0x1 % 0x8000 == 0x1 (0x1) +0x1 * 0x3e8 == 0x3e8 +0x1 / 0x3e8 == 0x0 +0x1 % 0x3e8 == 0x1 +int 0x1 ^ 0x3e8 == 0x3e9 (0x3e9) +__uint 0x1 ^ 0x3e8 == 0x3e9 (0x3e9) +char 0x1 ^ 0xffe8 == -0x17 (0xffe9) +__uchar 0x1 ^ 0xe8 == 0xe9 (0xe9) +__longlong 0x1 ^ 0x3e8 == 0x3e9 (0x3e9) +__ulonglong 0x1 ^ 0x3e8 == 0x3e9 (0x3e9) +int 0x1 && 0x3e8 == 0x1 (0x1) +__uint 0x1 && 0x3e8 == 0x1 (0x1) +char 0x1 && 0xffe8 == 0x1 (0x1) +__uchar 0x1 && 0xe8 == 0x1 (0x1) +__longlong 0x1 && 0x3e8 == 0x1 (0x1) +__ulonglong 0x1 && 0x3e8 == 0x1 (0x1) +int 0x1 || 0x3e8 == 0x1 (0x1) +__uint 0x1 || 0x3e8 == 0x1 (0x1) +char 0x1 || 0xffe8 == 0x1 (0x1) +__uchar 0x1 || 0xe8 == 0x1 (0x1) +__longlong 0x1 || 0x3e8 == 0x1 (0x1) +__ulonglong 0x1 || 0x3e8 == 0x1 (0x1) +int 0x1 & 0x3e8 == 0x0 (0x0) +__uint 0x1 & 0x3e8 == 0x0 (0x0) +char 0x1 & 0xffe8 == 0x0 (0x0) +__uchar 0x1 & 0xe8 == 0x0 (0x0) +__longlong 0x1 & 0x3e8 == 0x0 (0x0) +__ulonglong 0x1 & 0x3e8 == 0x0 (0x0) +int 0x1 | 0x3e8 == 0x3e9 (0x3e9) +__uint 0x1 | 0x3e8 == 0x3e9 (0x3e9) +char 0x1 | 0xffe8 == -0x17 (0xffe9) +__uchar 0x1 | 0xe8 == 0xe9 (0xe9) +__longlong 0x1 | 0x3e8 == 0x3e9 (0x3e9) +__ulonglong 0x1 | 0x3e8 == 0x3e9 (0x3e9) +int 0x1 << 0x14 == 0x0 (0x0) +__uint 0x1 << 0x14 == 0x0 (0x0) +char 0x1 << 0x14 == 0x0 (0x0) +__uchar 0x1 << 0x14 == 0x0 (0x0) +__longlong 0x1 << 0x14 == 0x0 (0x0) +__ulonglong 0x1 << 0x14 == 0x0 (0x0) +int 0x1 >> 0x14 == 0x0 (0x0) +__uint 0x1 >> 0x14 == 0x0 (0x0) +char 0x1 >> 0x14 == 0x0 (0x0) +__uchar 0x1 >> 0x14 == 0x0 (0x0) +__longlong 0x1 >> 0x14 == 0x0 (0x0) +__ulonglong 0x1 >> 0x14 == 0x0 (0x0) +int 0x1 + 0x3e8 == 0x3e9 (0x3e9) +__uint 0x1 + 0x3e8 == 0x3e9 (0x3e9) +char 0x1 + 0xffe8 == -0x17 (0xffe9) +__uchar 0x1 + 0xe8 == 0xe9 (0xe9) +__longlong 0x1 + 0x3e8 == 0x3e9 (0x3e9) +__ulonglong 0x1 + 0x3e8 == 0x3e9 (0x3e9) +float 0x1 + 0x3e8 == 0x3e9 (0x3e9) +int 0x1 - 0x3e8 == -0x3e7 (0xfc19) +__uint 0x1 - 0x3e8 == -0x3e7 (0xfc19) +char 0x1 - 0xffe8 == 0x19 (0x19) +__uchar 0x1 - 0xe8 == 0x19 (0x19) +__longlong 0x1 - 0x3e8 == -0x3e7 (0xfc19) +__ulonglong 0x1 - 0x3e8 == -0x3e7 (0xfc19) +float 0x1 - 0x3e8 == -0x3e7 (0xfc19) +int 0x1 * 0x3e8 == 0x3e8 (0x3e8) +__uint 0x1 * 0x3e8 == 0x3e8 (0x3e8) +char 0x1 * 0xffe8 == -0x18 (0xffe8) +__uchar 0x1 * 0xe8 == 0xe8 (0xe8) +__longlong 0x1 * 0x3e8 == 0x3e8 (0x3e8) +__ulonglong 0x1 * 0x3e8 == 0x3e8 (0x3e8) +float 0x1 * 0x3e8 == 0x3e8 (0x3e8) +int 0x1 < 0x3e8 == 0x1 (0x1) +__uint 0x1 < 0x3e8 == 0x1 (0x1) +char 0x1 < 0xffe8 == 0x0 (0x0) +__uchar 0x1 < 0xe8 == 0x1 (0x1) +__longlong 0x1 < 0x3e8 == 0x1 (0x1) +__ulonglong 0x1 < 0x3e8 == 0x1 (0x1) +float 0x1 < 0x3e8 == 0x1 (0x1) +int 0x1 > 0x3e8 == 0x0 (0x0) +__uint 0x1 > 0x3e8 == 0x0 (0x0) +char 0x1 > 0xffe8 == 0x1 (0x1) +__uchar 0x1 > 0xe8 == 0x0 (0x0) +__longlong 0x1 > 0x3e8 == 0x0 (0x0) +__ulonglong 0x1 > 0x3e8 == 0x0 (0x0) +float 0x1 > 0x3e8 == 0x0 (0x0) +int 0x1 <= 0x3e8 == 0x1 (0x1) +__uint 0x1 <= 0x3e8 == 0x1 (0x1) +char 0x1 <= 0xffe8 == 0x0 (0x0) +__uchar 0x1 <= 0xe8 == 0x1 (0x1) +__longlong 0x1 <= 0x3e8 == 0x1 (0x1) +__ulonglong 0x1 <= 0x3e8 == 0x1 (0x1) +float 0x1 <= 0x3e8 == 0x1 (0x1) +int 0x1 == 0x3e8 == 0x0 (0x0) +__uint 0x1 == 0x3e8 == 0x0 (0x0) +char 0x1 == 0xffe8 == 0x0 (0x0) +__uchar 0x1 == 0xe8 == 0x0 (0x0) +__longlong 0x1 == 0x3e8 == 0x0 (0x0) +__ulonglong 0x1 == 0x3e8 == 0x0 (0x0) +float 0x1 == 0x3e8 == 0x0 (0x0) +int 0x1 != 0x3e8 == 0x1 (0x1) +__uint 0x1 != 0x3e8 == 0x1 (0x1) +char 0x1 != 0xffe8 == 0x1 (0x1) +__uchar 0x1 != 0xe8 == 0x1 (0x1) +__longlong 0x1 != 0x3e8 == 0x1 (0x1) +__ulonglong 0x1 != 0x3e8 == 0x1 (0x1) +float 0x1 != 0x3e8 == 0x1 (0x1) +int 0x1 >= 0x3e8 == 0x0 (0x0) +__uint 0x1 >= 0x3e8 == 0x0 (0x0) +char 0x1 >= 0xffe8 == 0x1 (0x1) +__uchar 0x1 >= 0xe8 == 0x0 (0x0) +__longlong 0x1 >= 0x3e8 == 0x0 (0x0) +__ulonglong 0x1 >= 0x3e8 == 0x0 (0x0) +float 0x1 >= 0x3e8 == 0x0 (0x0) +int 0x1 / 0x3e8 == 0x0 (0x0) +__uint 0x1 / 0x3e8 == 0x0 (0x0) +char 0x1 / 0xffe8 == 0x0 (0x0) +__uchar 0x1 / 0xe8 == 0x0 (0x0) +__longlong 0x1 / 0x3e8 == 0x0 (0x0) +__ulonglong 0x1 / 0x3e8 == 0x0 (0x0) +float 0x1 / 0x3e8 == 0x0 (0x0) +int 0x1 % 0x3e8 == 0x1 (0x1) +__uint 0x1 % 0x3e8 == 0x1 (0x1) +char 0x1 % 0xffe8 == 0x1 (0x1) +__uchar 0x1 % 0xe8 == 0x1 (0x1) +__longlong 0x1 % 0x3e8 == 0x1 (0x1) +__ulonglong 0x1 % 0x3e8 == 0x1 (0x1) +0x1 * 0x2710 == 0x2710 +0x1 / 0x2710 == 0x0 +0x1 % 0x2710 == 0x1 +int 0x1 ^ 0x2710 == 0x2711 (0x2711) +__uint 0x1 ^ 0x2710 == 0x2711 (0x2711) +char 0x1 ^ 0x10 == 0x11 (0x11) +__uchar 0x1 ^ 0x10 == 0x11 (0x11) +__longlong 0x1 ^ 0x2710 == 0x2711 (0x2711) +__ulonglong 0x1 ^ 0x2710 == 0x2711 (0x2711) +int 0x1 && 0x2710 == 0x1 (0x1) +__uint 0x1 && 0x2710 == 0x1 (0x1) +char 0x1 && 0x10 == 0x1 (0x1) +__uchar 0x1 && 0x10 == 0x1 (0x1) +__longlong 0x1 && 0x2710 == 0x1 (0x1) +__ulonglong 0x1 && 0x2710 == 0x1 (0x1) +int 0x1 || 0x2710 == 0x1 (0x1) +__uint 0x1 || 0x2710 == 0x1 (0x1) +char 0x1 || 0x10 == 0x1 (0x1) +__uchar 0x1 || 0x10 == 0x1 (0x1) +__longlong 0x1 || 0x2710 == 0x1 (0x1) +__ulonglong 0x1 || 0x2710 == 0x1 (0x1) +int 0x1 & 0x2710 == 0x0 (0x0) +__uint 0x1 & 0x2710 == 0x0 (0x0) +char 0x1 & 0x10 == 0x0 (0x0) +__uchar 0x1 & 0x10 == 0x0 (0x0) +__longlong 0x1 & 0x2710 == 0x0 (0x0) +__ulonglong 0x1 & 0x2710 == 0x0 (0x0) +int 0x1 | 0x2710 == 0x2711 (0x2711) +__uint 0x1 | 0x2710 == 0x2711 (0x2711) +char 0x1 | 0x10 == 0x11 (0x11) +__uchar 0x1 | 0x10 == 0x11 (0x11) +__longlong 0x1 | 0x2710 == 0x2711 (0x2711) +__ulonglong 0x1 | 0x2710 == 0x2711 (0x2711) +int 0x1 << 0x16 == 0x0 (0x0) +__uint 0x1 << 0x16 == 0x0 (0x0) +char 0x1 << 0x16 == 0x0 (0x0) +__uchar 0x1 << 0x16 == 0x0 (0x0) +__longlong 0x1 << 0x16 == 0x0 (0x0) +__ulonglong 0x1 << 0x16 == 0x0 (0x0) +int 0x1 >> 0x16 == 0x0 (0x0) +__uint 0x1 >> 0x16 == 0x0 (0x0) +char 0x1 >> 0x16 == 0x0 (0x0) +__uchar 0x1 >> 0x16 == 0x0 (0x0) +__longlong 0x1 >> 0x16 == 0x0 (0x0) +__ulonglong 0x1 >> 0x16 == 0x0 (0x0) +int 0x1 + 0x2710 == 0x2711 (0x2711) +__uint 0x1 + 0x2710 == 0x2711 (0x2711) +char 0x1 + 0x10 == 0x11 (0x11) +__uchar 0x1 + 0x10 == 0x11 (0x11) +__longlong 0x1 + 0x2710 == 0x2711 (0x2711) +__ulonglong 0x1 + 0x2710 == 0x2711 (0x2711) +float 0x1 + 0x2710 == 0x2711 (0x2711) +int 0x1 - 0x2710 == -0x270f (0xd8f1) +__uint 0x1 - 0x2710 == -0x270f (0xd8f1) +char 0x1 - 0x10 == -0xf (0xfff1) +__uchar 0x1 - 0x10 == 0xf1 (0xf1) +__longlong 0x1 - 0x2710 == -0x270f (0xd8f1) +__ulonglong 0x1 - 0x2710 == -0x270f (0xd8f1) +float 0x1 - 0x2710 == -0x270f (0xd8f1) +int 0x1 * 0x2710 == 0x2710 (0x2710) +__uint 0x1 * 0x2710 == 0x2710 (0x2710) +char 0x1 * 0x10 == 0x10 (0x10) +__uchar 0x1 * 0x10 == 0x10 (0x10) +__longlong 0x1 * 0x2710 == 0x2710 (0x2710) +__ulonglong 0x1 * 0x2710 == 0x2710 (0x2710) +float 0x1 * 0x2710 == 0x2710 (0x2710) +int 0x1 < 0x2710 == 0x1 (0x1) +__uint 0x1 < 0x2710 == 0x1 (0x1) +char 0x1 < 0x10 == 0x1 (0x1) +__uchar 0x1 < 0x10 == 0x1 (0x1) +__longlong 0x1 < 0x2710 == 0x1 (0x1) +__ulonglong 0x1 < 0x2710 == 0x1 (0x1) +float 0x1 < 0x2710 == 0x1 (0x1) +int 0x1 > 0x2710 == 0x0 (0x0) +__uint 0x1 > 0x2710 == 0x0 (0x0) +char 0x1 > 0x10 == 0x0 (0x0) +__uchar 0x1 > 0x10 == 0x0 (0x0) +__longlong 0x1 > 0x2710 == 0x0 (0x0) +__ulonglong 0x1 > 0x2710 == 0x0 (0x0) +float 0x1 > 0x2710 == 0x0 (0x0) +int 0x1 <= 0x2710 == 0x1 (0x1) +__uint 0x1 <= 0x2710 == 0x1 (0x1) +char 0x1 <= 0x10 == 0x1 (0x1) +__uchar 0x1 <= 0x10 == 0x1 (0x1) +__longlong 0x1 <= 0x2710 == 0x1 (0x1) +__ulonglong 0x1 <= 0x2710 == 0x1 (0x1) +float 0x1 <= 0x2710 == 0x1 (0x1) +int 0x1 == 0x2710 == 0x0 (0x0) +__uint 0x1 == 0x2710 == 0x0 (0x0) +char 0x1 == 0x10 == 0x0 (0x0) +__uchar 0x1 == 0x10 == 0x0 (0x0) +__longlong 0x1 == 0x2710 == 0x0 (0x0) +__ulonglong 0x1 == 0x2710 == 0x0 (0x0) +float 0x1 == 0x2710 == 0x0 (0x0) +int 0x1 != 0x2710 == 0x1 (0x1) +__uint 0x1 != 0x2710 == 0x1 (0x1) +char 0x1 != 0x10 == 0x1 (0x1) +__uchar 0x1 != 0x10 == 0x1 (0x1) +__longlong 0x1 != 0x2710 == 0x1 (0x1) +__ulonglong 0x1 != 0x2710 == 0x1 (0x1) +float 0x1 != 0x2710 == 0x1 (0x1) +int 0x1 >= 0x2710 == 0x0 (0x0) +__uint 0x1 >= 0x2710 == 0x0 (0x0) +char 0x1 >= 0x10 == 0x0 (0x0) +__uchar 0x1 >= 0x10 == 0x0 (0x0) +__longlong 0x1 >= 0x2710 == 0x0 (0x0) +__ulonglong 0x1 >= 0x2710 == 0x0 (0x0) +float 0x1 >= 0x2710 == 0x0 (0x0) +int 0x1 / 0x2710 == 0x0 (0x0) +__uint 0x1 / 0x2710 == 0x0 (0x0) +char 0x1 / 0x10 == 0x0 (0x0) +__uchar 0x1 / 0x10 == 0x0 (0x0) +__longlong 0x1 / 0x2710 == 0x0 (0x0) +__ulonglong 0x1 / 0x2710 == 0x0 (0x0) +float 0x1 / 0x2710 == 0x0 (0x0) +int 0x1 % 0x2710 == 0x1 (0x1) +__uint 0x1 % 0x2710 == 0x1 (0x1) +char 0x1 % 0x10 == 0x1 (0x1) +__uchar 0x1 % 0x10 == 0x1 (0x1) +__longlong 0x1 % 0x2710 == 0x1 (0x1) +__ulonglong 0x1 % 0x2710 == 0x1 (0x1) +int xor420x1 xor42 0x2b +__uint xor420x1 xor42 0x2b +char xor420x1 xor42 0x2b +__uchar xor420x1 xor42 0x2b +__longlong xor420x1 xor42 0x2b +__ulonglong xor420x1 xor42 0x2b +int land10x1 land1 0x1 +__uint land10x1 land1 0x1 +char land10x1 land1 0x1 +__uchar land10x1 land1 0x1 +__longlong land10x1 land1 0x1 +__ulonglong land10x1 land1 0x1 +int lor10x1 lor1 0x1 +__uint lor10x1 lor1 0x1 +char lor10x1 lor1 0x1 +__uchar lor10x1 lor1 0x1 +__longlong lor10x1 lor1 0x1 +__ulonglong lor10x1 lor1 0x1 +int and420x1 and42 0x0 +__uint and420x1 and42 0x0 +char and420x1 and42 0x0 +__uchar and420x1 and42 0x0 +__longlong and420x1 and42 0x0 +__ulonglong and420x1 and42 0x0 +int or420x1 or42 0x2b +__uint or420x1 or42 0x2b +char or420x1 or42 0x2b +__uchar or420x1 or42 0x2b +__longlong or420x1 or42 0x2b +__ulonglong or420x1 or42 0x2b +int shl50x1 shl5 0x20 +__uint shl50x1 shl5 0x20 +char shl50x1 shl5 0x20 +__uchar shl50x1 shl5 0x20 +__longlong shl50x1 shl5 0x20 +__ulonglong shl50x1 shl5 0x20 +int shr50x1 shr5 0x0 +__uint shr50x1 shr5 0x0 +char shr50x1 shr5 0x0 +__uchar shr50x1 shr5 0x0 +__longlong shr50x1 shr5 0x0 +__ulonglong shr50x1 shr5 0x0 +int add420x1 add42 0x2b +__uint add420x1 add42 0x2b +char add420x1 add42 0x2b +__uchar add420x1 add42 0x2b +__longlong add420x1 add42 0x2b +__ulonglong add420x1 add42 0x2b +float add420x1 add42 0x2b +int sub420x1 sub42 -0x29 +__uint sub420x1 sub42 -0x29 +char sub420x1 sub42 -0x29 +__uchar sub420x1 sub42 0xd7 +__longlong sub420x1 sub42 -0x29 +__ulonglong sub420x1 sub42 -0x29 +float sub420x1 sub42 -0x29 +int mul420x1 mul42 0x2a +__uint mul420x1 mul42 0x2a +char mul420x1 mul42 0x2a +__uchar mul420x1 mul42 0x2a +__longlong mul420x1 mul42 0x2a +__ulonglong mul420x1 mul42 0x2a +float mul420x1 mul42 0x2a +int lt420x1 lt42 0x1 +__uint lt420x1 lt42 0x1 +char lt420x1 lt42 0x1 +__uchar lt420x1 lt42 0x1 +__longlong lt420x1 lt42 0x1 +__ulonglong lt420x1 lt42 0x1 +float lt420x1 lt42 0x1 +int gt420x1 gt42 0x0 +__uint gt420x1 gt42 0x0 +char gt420x1 gt42 0x0 +__uchar gt420x1 gt42 0x0 +__longlong gt420x1 gt42 0x0 +__ulonglong gt420x1 gt42 0x0 +float gt420x1 gt42 0x0 +int le420x1 le42 0x1 +__uint le420x1 le42 0x1 +char le420x1 le42 0x1 +__uchar le420x1 le42 0x1 +__longlong le420x1 le42 0x1 +__ulonglong le420x1 le42 0x1 +float le420x1 le42 0x1 +int eq420x1 eq42 0x0 +__uint eq420x1 eq42 0x0 +char eq420x1 eq42 0x0 +__uchar eq420x1 eq42 0x0 +__longlong eq420x1 eq42 0x0 +__ulonglong eq420x1 eq42 0x0 +float eq420x1 eq42 0x0 +int ne420x1 ne42 0x1 +__uint ne420x1 ne42 0x1 +char ne420x1 ne42 0x1 +__uchar ne420x1 ne42 0x1 +__longlong ne420x1 ne42 0x1 +__ulonglong ne420x1 ne42 0x1 +float ne420x1 ne42 0x1 +int ge420x1 ge42 0x0 +__uint ge420x1 ge42 0x0 +char ge420x1 ge42 0x0 +__uchar ge420x1 ge42 0x0 +__longlong ge420x1 ge42 0x0 +__ulonglong ge420x1 ge42 0x0 +float ge420x1 ge42 0x0 +int div420x1 div42 0x0 +__uint div420x1 div42 0x0 +char div420x1 div42 0x0 +__uchar div420x1 div42 0x0 +__longlong div420x1 div42 0x0 +__ulonglong div420x1 div42 0x0 +float div420x1 div42 0x0 +int mod230x1 mod23 0x1 +__uint mod230x1 mod23 0x1 +char mod230x1 mod23 0x1 +__uchar mod230x1 mod23 0x1 +__longlong mod230x1 mod23 0x1 +__ulonglong mod230x1 mod23 0x1 +0x2 * 0xffff == -0x2 +0x2 / 0xffff == -0x2 +0x2 % 0xffff == 0x0 +int 0x2 ^ 0xffff == -0x3 (0xfffd) +__uint 0x2 ^ 0xffff == -0x3 (0xfffd) +char 0x2 ^ 0xffff == -0x3 (0xfffd) +__uchar 0x2 ^ 0xff == 0xfd (0xfd) +__longlong 0x2 ^ 0xffff == -0x3 (0xfffd) +__ulonglong 0x2 ^ 0xffff == -0x3 (0xfffd) +int 0x2 && 0xffff == 0x1 (0x1) +__uint 0x2 && 0xffff == 0x1 (0x1) +char 0x2 && 0xffff == 0x1 (0x1) +__uchar 0x2 && 0xff == 0x1 (0x1) +__longlong 0x2 && 0xffff == 0x1 (0x1) +__ulonglong 0x2 && 0xffff == 0x1 (0x1) +int 0x2 || 0xffff == 0x1 (0x1) +__uint 0x2 || 0xffff == 0x1 (0x1) +char 0x2 || 0xffff == 0x1 (0x1) +__uchar 0x2 || 0xff == 0x1 (0x1) +__longlong 0x2 || 0xffff == 0x1 (0x1) +__ulonglong 0x2 || 0xffff == 0x1 (0x1) +int 0x2 & 0xffff == 0x2 (0x2) +__uint 0x2 & 0xffff == 0x2 (0x2) +char 0x2 & 0xffff == 0x2 (0x2) +__uchar 0x2 & 0xff == 0x2 (0x2) +__longlong 0x2 & 0xffff == 0x2 (0x2) +__ulonglong 0x2 & 0xffff == 0x2 (0x2) +int 0x2 | 0xffff == -0x1 (0xffff) +__uint 0x2 | 0xffff == -0x1 (0xffff) +char 0x2 | 0xffff == -0x1 (0xffff) +__uchar 0x2 | 0xff == 0xff (0xff) +__longlong 0x2 | 0xffff == -0x1 (0xffff) +__ulonglong 0x2 | 0xffff == -0x1 (0xffff) +int 0x2 << 0x1 == 0x4 (0x4) +__uint 0x2 << 0x1 == 0x4 (0x4) +char 0x2 << 0x1 == 0x4 (0x4) +__uchar 0x2 << 0x1 == 0x4 (0x4) +__longlong 0x2 << 0x1 == 0x4 (0x4) +__ulonglong 0x2 << 0x1 == 0x4 (0x4) +int 0x2 >> 0x1 == 0x1 (0x1) +__uint 0x2 >> 0x1 == 0x1 (0x1) +char 0x2 >> 0x1 == 0x1 (0x1) +__uchar 0x2 >> 0x1 == 0x1 (0x1) +__longlong 0x2 >> 0x1 == 0x1 (0x1) +__ulonglong 0x2 >> 0x1 == 0x1 (0x1) +int 0x2 + 0xffff == 0x1 (0x1) +__uint 0x2 + 0xffff == 0x1 (0x1) +char 0x2 + 0xffff == 0x1 (0x1) +__uchar 0x2 + 0xff == 0x1 (0x1) +__longlong 0x2 + 0xffff == 0x1 (0x1) +__ulonglong 0x2 + 0xffff == 0x1 (0x1) +float 0x2 + 0xffff == 0x1 (0x1) +int 0x2 - 0xffff == 0x3 (0x3) +__uint 0x2 - 0xffff == 0x3 (0x3) +char 0x2 - 0xffff == 0x3 (0x3) +__uchar 0x2 - 0xff == 0x3 (0x3) +__longlong 0x2 - 0xffff == 0x3 (0x3) +__ulonglong 0x2 - 0xffff == 0x3 (0x3) +float 0x2 - 0xffff == 0x3 (0x3) +int 0x2 * 0xffff == -0x2 (0xfffe) +__uint 0x2 * 0xffff == -0x2 (0xfffe) +char 0x2 * 0xffff == -0x2 (0xfffe) +__uchar 0x2 * 0xff == 0xfe (0xfe) +__longlong 0x2 * 0xffff == -0x2 (0xfffe) +__ulonglong 0x2 * 0xffff == -0x2 (0xfffe) +float 0x2 * 0xffff == -0x2 (0xfffe) +int 0x2 < 0xffff == 0x0 (0x0) +__uint 0x2 < 0xffff == 0x1 (0x1) +char 0x2 < 0xffff == 0x0 (0x0) +__uchar 0x2 < 0xff == 0x1 (0x1) +__longlong 0x2 < 0xffff == 0x0 (0x0) +__ulonglong 0x2 < 0xffff == 0x1 (0x1) +float 0x2 < 0xffff == 0x0 (0x0) +int 0x2 > 0xffff == 0x1 (0x1) +__uint 0x2 > 0xffff == 0x0 (0x0) +char 0x2 > 0xffff == 0x1 (0x1) +__uchar 0x2 > 0xff == 0x0 (0x0) +__longlong 0x2 > 0xffff == 0x1 (0x1) +__ulonglong 0x2 > 0xffff == 0x0 (0x0) +float 0x2 > 0xffff == 0x1 (0x1) +int 0x2 <= 0xffff == 0x0 (0x0) +__uint 0x2 <= 0xffff == 0x1 (0x1) +char 0x2 <= 0xffff == 0x0 (0x0) +__uchar 0x2 <= 0xff == 0x1 (0x1) +__longlong 0x2 <= 0xffff == 0x0 (0x0) +__ulonglong 0x2 <= 0xffff == 0x1 (0x1) +float 0x2 <= 0xffff == 0x0 (0x0) +int 0x2 == 0xffff == 0x0 (0x0) +__uint 0x2 == 0xffff == 0x0 (0x0) +char 0x2 == 0xffff == 0x0 (0x0) +__uchar 0x2 == 0xff == 0x0 (0x0) +__longlong 0x2 == 0xffff == 0x0 (0x0) +__ulonglong 0x2 == 0xffff == 0x0 (0x0) +float 0x2 == 0xffff == 0x0 (0x0) +int 0x2 != 0xffff == 0x1 (0x1) +__uint 0x2 != 0xffff == 0x1 (0x1) +char 0x2 != 0xffff == 0x1 (0x1) +__uchar 0x2 != 0xff == 0x1 (0x1) +__longlong 0x2 != 0xffff == 0x1 (0x1) +__ulonglong 0x2 != 0xffff == 0x1 (0x1) +float 0x2 != 0xffff == 0x1 (0x1) +int 0x2 >= 0xffff == 0x1 (0x1) +__uint 0x2 >= 0xffff == 0x0 (0x0) +char 0x2 >= 0xffff == 0x1 (0x1) +__uchar 0x2 >= 0xff == 0x0 (0x0) +__longlong 0x2 >= 0xffff == 0x1 (0x1) +__ulonglong 0x2 >= 0xffff == 0x0 (0x0) +float 0x2 >= 0xffff == 0x1 (0x1) +int 0x2 / 0xffff == -0x2 (0xfffe) +__uint 0x2 / 0xffff == 0x0 (0x0) +char 0x2 / 0xffff == -0x2 (0xfffe) +__uchar 0x2 / 0xff == 0x0 (0x0) +__longlong 0x2 / 0xffff == -0x2 (0xfffe) +__ulonglong 0x2 / 0xffff == 0x0 (0x0) +float 0x2 / 0xffff == -0x2 (0xfffe) +int 0x2 % 0xffff == 0x0 (0x0) +__uint 0x2 % 0xffff == 0x2 (0x2) +char 0x2 % 0xffff == 0x0 (0x0) +__uchar 0x2 % 0xff == 0x2 (0x2) +__longlong 0x2 % 0xffff == 0x0 (0x0) +__ulonglong 0x2 % 0xffff == 0x2 (0x2) +0x2 * 0x1 == 0x2 +0x2 / 0x1 == 0x2 +0x2 % 0x1 == 0x0 +int 0x2 ^ 0x1 == 0x3 (0x3) +__uint 0x2 ^ 0x1 == 0x3 (0x3) +char 0x2 ^ 0x1 == 0x3 (0x3) +__uchar 0x2 ^ 0x1 == 0x3 (0x3) +__longlong 0x2 ^ 0x1 == 0x3 (0x3) +__ulonglong 0x2 ^ 0x1 == 0x3 (0x3) +int 0x2 && 0x1 == 0x1 (0x1) +__uint 0x2 && 0x1 == 0x1 (0x1) +char 0x2 && 0x1 == 0x1 (0x1) +__uchar 0x2 && 0x1 == 0x1 (0x1) +__longlong 0x2 && 0x1 == 0x1 (0x1) +__ulonglong 0x2 && 0x1 == 0x1 (0x1) +int 0x2 || 0x1 == 0x1 (0x1) +__uint 0x2 || 0x1 == 0x1 (0x1) +char 0x2 || 0x1 == 0x1 (0x1) +__uchar 0x2 || 0x1 == 0x1 (0x1) +__longlong 0x2 || 0x1 == 0x1 (0x1) +__ulonglong 0x2 || 0x1 == 0x1 (0x1) +int 0x2 & 0x1 == 0x0 (0x0) +__uint 0x2 & 0x1 == 0x0 (0x0) +char 0x2 & 0x1 == 0x0 (0x0) +__uchar 0x2 & 0x1 == 0x0 (0x0) +__longlong 0x2 & 0x1 == 0x0 (0x0) +__ulonglong 0x2 & 0x1 == 0x0 (0x0) +int 0x2 | 0x1 == 0x3 (0x3) +__uint 0x2 | 0x1 == 0x3 (0x3) +char 0x2 | 0x1 == 0x3 (0x3) +__uchar 0x2 | 0x1 == 0x3 (0x3) +__longlong 0x2 | 0x1 == 0x3 (0x3) +__ulonglong 0x2 | 0x1 == 0x3 (0x3) +int 0x2 << 0x2 == 0x8 (0x8) +__uint 0x2 << 0x2 == 0x8 (0x8) +char 0x2 << 0x2 == 0x8 (0x8) +__uchar 0x2 << 0x2 == 0x8 (0x8) +__longlong 0x2 << 0x2 == 0x8 (0x8) +__ulonglong 0x2 << 0x2 == 0x8 (0x8) +int 0x2 >> 0x2 == 0x0 (0x0) +__uint 0x2 >> 0x2 == 0x0 (0x0) +char 0x2 >> 0x2 == 0x0 (0x0) +__uchar 0x2 >> 0x2 == 0x0 (0x0) +__longlong 0x2 >> 0x2 == 0x0 (0x0) +__ulonglong 0x2 >> 0x2 == 0x0 (0x0) +int 0x2 + 0x1 == 0x3 (0x3) +__uint 0x2 + 0x1 == 0x3 (0x3) +char 0x2 + 0x1 == 0x3 (0x3) +__uchar 0x2 + 0x1 == 0x3 (0x3) +__longlong 0x2 + 0x1 == 0x3 (0x3) +__ulonglong 0x2 + 0x1 == 0x3 (0x3) +float 0x2 + 0x1 == 0x3 (0x3) +int 0x2 - 0x1 == 0x1 (0x1) +__uint 0x2 - 0x1 == 0x1 (0x1) +char 0x2 - 0x1 == 0x1 (0x1) +__uchar 0x2 - 0x1 == 0x1 (0x1) +__longlong 0x2 - 0x1 == 0x1 (0x1) +__ulonglong 0x2 - 0x1 == 0x1 (0x1) +float 0x2 - 0x1 == 0x1 (0x1) +int 0x2 * 0x1 == 0x2 (0x2) +__uint 0x2 * 0x1 == 0x2 (0x2) +char 0x2 * 0x1 == 0x2 (0x2) +__uchar 0x2 * 0x1 == 0x2 (0x2) +__longlong 0x2 * 0x1 == 0x2 (0x2) +__ulonglong 0x2 * 0x1 == 0x2 (0x2) +float 0x2 * 0x1 == 0x2 (0x2) +int 0x2 < 0x1 == 0x0 (0x0) +__uint 0x2 < 0x1 == 0x0 (0x0) +char 0x2 < 0x1 == 0x0 (0x0) +__uchar 0x2 < 0x1 == 0x0 (0x0) +__longlong 0x2 < 0x1 == 0x0 (0x0) +__ulonglong 0x2 < 0x1 == 0x0 (0x0) +float 0x2 < 0x1 == 0x0 (0x0) +int 0x2 > 0x1 == 0x1 (0x1) +__uint 0x2 > 0x1 == 0x1 (0x1) +char 0x2 > 0x1 == 0x1 (0x1) +__uchar 0x2 > 0x1 == 0x1 (0x1) +__longlong 0x2 > 0x1 == 0x1 (0x1) +__ulonglong 0x2 > 0x1 == 0x1 (0x1) +float 0x2 > 0x1 == 0x1 (0x1) +int 0x2 <= 0x1 == 0x0 (0x0) +__uint 0x2 <= 0x1 == 0x0 (0x0) +char 0x2 <= 0x1 == 0x0 (0x0) +__uchar 0x2 <= 0x1 == 0x0 (0x0) +__longlong 0x2 <= 0x1 == 0x0 (0x0) +__ulonglong 0x2 <= 0x1 == 0x0 (0x0) +float 0x2 <= 0x1 == 0x0 (0x0) +int 0x2 == 0x1 == 0x0 (0x0) +__uint 0x2 == 0x1 == 0x0 (0x0) +char 0x2 == 0x1 == 0x0 (0x0) +__uchar 0x2 == 0x1 == 0x0 (0x0) +__longlong 0x2 == 0x1 == 0x0 (0x0) +__ulonglong 0x2 == 0x1 == 0x0 (0x0) +float 0x2 == 0x1 == 0x0 (0x0) +int 0x2 != 0x1 == 0x1 (0x1) +__uint 0x2 != 0x1 == 0x1 (0x1) +char 0x2 != 0x1 == 0x1 (0x1) +__uchar 0x2 != 0x1 == 0x1 (0x1) +__longlong 0x2 != 0x1 == 0x1 (0x1) +__ulonglong 0x2 != 0x1 == 0x1 (0x1) +float 0x2 != 0x1 == 0x1 (0x1) +int 0x2 >= 0x1 == 0x1 (0x1) +__uint 0x2 >= 0x1 == 0x1 (0x1) +char 0x2 >= 0x1 == 0x1 (0x1) +__uchar 0x2 >= 0x1 == 0x1 (0x1) +__longlong 0x2 >= 0x1 == 0x1 (0x1) +__ulonglong 0x2 >= 0x1 == 0x1 (0x1) +float 0x2 >= 0x1 == 0x1 (0x1) +int 0x2 / 0x1 == 0x2 (0x2) +__uint 0x2 / 0x1 == 0x2 (0x2) +char 0x2 / 0x1 == 0x2 (0x2) +__uchar 0x2 / 0x1 == 0x2 (0x2) +__longlong 0x2 / 0x1 == 0x2 (0x2) +__ulonglong 0x2 / 0x1 == 0x2 (0x2) +float 0x2 / 0x1 == 0x2 (0x2) +int 0x2 % 0x1 == 0x0 (0x0) +__uint 0x2 % 0x1 == 0x0 (0x0) +char 0x2 % 0x1 == 0x0 (0x0) +__uchar 0x2 % 0x1 == 0x0 (0x0) +__longlong 0x2 % 0x1 == 0x0 (0x0) +__ulonglong 0x2 % 0x1 == 0x0 (0x0) +0x2 * 0x2 == 0x4 +0x2 / 0x2 == 0x1 +0x2 % 0x2 == 0x0 +int 0x2 ^ 0x2 == 0x0 (0x0) +__uint 0x2 ^ 0x2 == 0x0 (0x0) +char 0x2 ^ 0x2 == 0x0 (0x0) +__uchar 0x2 ^ 0x2 == 0x0 (0x0) +__longlong 0x2 ^ 0x2 == 0x0 (0x0) +__ulonglong 0x2 ^ 0x2 == 0x0 (0x0) +int 0x2 && 0x2 == 0x1 (0x1) +__uint 0x2 && 0x2 == 0x1 (0x1) +char 0x2 && 0x2 == 0x1 (0x1) +__uchar 0x2 && 0x2 == 0x1 (0x1) +__longlong 0x2 && 0x2 == 0x1 (0x1) +__ulonglong 0x2 && 0x2 == 0x1 (0x1) +int 0x2 || 0x2 == 0x1 (0x1) +__uint 0x2 || 0x2 == 0x1 (0x1) +char 0x2 || 0x2 == 0x1 (0x1) +__uchar 0x2 || 0x2 == 0x1 (0x1) +__longlong 0x2 || 0x2 == 0x1 (0x1) +__ulonglong 0x2 || 0x2 == 0x1 (0x1) +int 0x2 & 0x2 == 0x2 (0x2) +__uint 0x2 & 0x2 == 0x2 (0x2) +char 0x2 & 0x2 == 0x2 (0x2) +__uchar 0x2 & 0x2 == 0x2 (0x2) +__longlong 0x2 & 0x2 == 0x2 (0x2) +__ulonglong 0x2 & 0x2 == 0x2 (0x2) +int 0x2 | 0x2 == 0x2 (0x2) +__uint 0x2 | 0x2 == 0x2 (0x2) +char 0x2 | 0x2 == 0x2 (0x2) +__uchar 0x2 | 0x2 == 0x2 (0x2) +__longlong 0x2 | 0x2 == 0x2 (0x2) +__ulonglong 0x2 | 0x2 == 0x2 (0x2) +int 0x2 << 0x3 == 0x10 (0x10) +__uint 0x2 << 0x3 == 0x10 (0x10) +char 0x2 << 0x3 == 0x10 (0x10) +__uchar 0x2 << 0x3 == 0x10 (0x10) +__longlong 0x2 << 0x3 == 0x10 (0x10) +__ulonglong 0x2 << 0x3 == 0x10 (0x10) +int 0x2 >> 0x3 == 0x0 (0x0) +__uint 0x2 >> 0x3 == 0x0 (0x0) +char 0x2 >> 0x3 == 0x0 (0x0) +__uchar 0x2 >> 0x3 == 0x0 (0x0) +__longlong 0x2 >> 0x3 == 0x0 (0x0) +__ulonglong 0x2 >> 0x3 == 0x0 (0x0) +int 0x2 + 0x2 == 0x4 (0x4) +__uint 0x2 + 0x2 == 0x4 (0x4) +char 0x2 + 0x2 == 0x4 (0x4) +__uchar 0x2 + 0x2 == 0x4 (0x4) +__longlong 0x2 + 0x2 == 0x4 (0x4) +__ulonglong 0x2 + 0x2 == 0x4 (0x4) +float 0x2 + 0x2 == 0x4 (0x4) +int 0x2 - 0x2 == 0x0 (0x0) +__uint 0x2 - 0x2 == 0x0 (0x0) +char 0x2 - 0x2 == 0x0 (0x0) +__uchar 0x2 - 0x2 == 0x0 (0x0) +__longlong 0x2 - 0x2 == 0x0 (0x0) +__ulonglong 0x2 - 0x2 == 0x0 (0x0) +float 0x2 - 0x2 == 0x0 (0x0) +int 0x2 * 0x2 == 0x4 (0x4) +__uint 0x2 * 0x2 == 0x4 (0x4) +char 0x2 * 0x2 == 0x4 (0x4) +__uchar 0x2 * 0x2 == 0x4 (0x4) +__longlong 0x2 * 0x2 == 0x4 (0x4) +__ulonglong 0x2 * 0x2 == 0x4 (0x4) +float 0x2 * 0x2 == 0x4 (0x4) +int 0x2 < 0x2 == 0x0 (0x0) +__uint 0x2 < 0x2 == 0x0 (0x0) +char 0x2 < 0x2 == 0x0 (0x0) +__uchar 0x2 < 0x2 == 0x0 (0x0) +__longlong 0x2 < 0x2 == 0x0 (0x0) +__ulonglong 0x2 < 0x2 == 0x0 (0x0) +float 0x2 < 0x2 == 0x0 (0x0) +int 0x2 > 0x2 == 0x0 (0x0) +__uint 0x2 > 0x2 == 0x0 (0x0) +char 0x2 > 0x2 == 0x0 (0x0) +__uchar 0x2 > 0x2 == 0x0 (0x0) +__longlong 0x2 > 0x2 == 0x0 (0x0) +__ulonglong 0x2 > 0x2 == 0x0 (0x0) +float 0x2 > 0x2 == 0x0 (0x0) +int 0x2 <= 0x2 == 0x1 (0x1) +__uint 0x2 <= 0x2 == 0x1 (0x1) +char 0x2 <= 0x2 == 0x1 (0x1) +__uchar 0x2 <= 0x2 == 0x1 (0x1) +__longlong 0x2 <= 0x2 == 0x1 (0x1) +__ulonglong 0x2 <= 0x2 == 0x1 (0x1) +float 0x2 <= 0x2 == 0x1 (0x1) +int 0x2 == 0x2 == 0x1 (0x1) +__uint 0x2 == 0x2 == 0x1 (0x1) +char 0x2 == 0x2 == 0x1 (0x1) +__uchar 0x2 == 0x2 == 0x1 (0x1) +__longlong 0x2 == 0x2 == 0x1 (0x1) +__ulonglong 0x2 == 0x2 == 0x1 (0x1) +float 0x2 == 0x2 == 0x1 (0x1) +int 0x2 != 0x2 == 0x0 (0x0) +__uint 0x2 != 0x2 == 0x0 (0x0) +char 0x2 != 0x2 == 0x0 (0x0) +__uchar 0x2 != 0x2 == 0x0 (0x0) +__longlong 0x2 != 0x2 == 0x0 (0x0) +__ulonglong 0x2 != 0x2 == 0x0 (0x0) +float 0x2 != 0x2 == 0x0 (0x0) +int 0x2 >= 0x2 == 0x1 (0x1) +__uint 0x2 >= 0x2 == 0x1 (0x1) +char 0x2 >= 0x2 == 0x1 (0x1) +__uchar 0x2 >= 0x2 == 0x1 (0x1) +__longlong 0x2 >= 0x2 == 0x1 (0x1) +__ulonglong 0x2 >= 0x2 == 0x1 (0x1) +float 0x2 >= 0x2 == 0x1 (0x1) +int 0x2 / 0x2 == 0x1 (0x1) +__uint 0x2 / 0x2 == 0x1 (0x1) +char 0x2 / 0x2 == 0x1 (0x1) +__uchar 0x2 / 0x2 == 0x1 (0x1) +__longlong 0x2 / 0x2 == 0x1 (0x1) +__ulonglong 0x2 / 0x2 == 0x1 (0x1) +float 0x2 / 0x2 == 0x1 (0x1) +int 0x2 % 0x2 == 0x0 (0x0) +__uint 0x2 % 0x2 == 0x0 (0x0) +char 0x2 % 0x2 == 0x0 (0x0) +__uchar 0x2 % 0x2 == 0x0 (0x0) +__longlong 0x2 % 0x2 == 0x0 (0x0) +__ulonglong 0x2 % 0x2 == 0x0 (0x0) +0x2 * 0xfffe == -0x4 +0x2 / 0xfffe == -0x1 +0x2 % 0xfffe == 0x0 +int 0x2 ^ 0xfffe == -0x4 (0xfffc) +__uint 0x2 ^ 0xfffe == -0x4 (0xfffc) +char 0x2 ^ 0xfffe == -0x4 (0xfffc) +__uchar 0x2 ^ 0xfe == 0xfc (0xfc) +__longlong 0x2 ^ 0xfffe == -0x4 (0xfffc) +__ulonglong 0x2 ^ 0xfffe == -0x4 (0xfffc) +int 0x2 && 0xfffe == 0x1 (0x1) +__uint 0x2 && 0xfffe == 0x1 (0x1) +char 0x2 && 0xfffe == 0x1 (0x1) +__uchar 0x2 && 0xfe == 0x1 (0x1) +__longlong 0x2 && 0xfffe == 0x1 (0x1) +__ulonglong 0x2 && 0xfffe == 0x1 (0x1) +int 0x2 || 0xfffe == 0x1 (0x1) +__uint 0x2 || 0xfffe == 0x1 (0x1) +char 0x2 || 0xfffe == 0x1 (0x1) +__uchar 0x2 || 0xfe == 0x1 (0x1) +__longlong 0x2 || 0xfffe == 0x1 (0x1) +__ulonglong 0x2 || 0xfffe == 0x1 (0x1) +int 0x2 & 0xfffe == 0x2 (0x2) +__uint 0x2 & 0xfffe == 0x2 (0x2) +char 0x2 & 0xfffe == 0x2 (0x2) +__uchar 0x2 & 0xfe == 0x2 (0x2) +__longlong 0x2 & 0xfffe == 0x2 (0x2) +__ulonglong 0x2 & 0xfffe == 0x2 (0x2) +int 0x2 | 0xfffe == -0x2 (0xfffe) +__uint 0x2 | 0xfffe == -0x2 (0xfffe) +char 0x2 | 0xfffe == -0x2 (0xfffe) +__uchar 0x2 | 0xfe == 0xfe (0xfe) +__longlong 0x2 | 0xfffe == -0x2 (0xfffe) +__ulonglong 0x2 | 0xfffe == -0x2 (0xfffe) +int 0x2 << 0x4 == 0x20 (0x20) +__uint 0x2 << 0x4 == 0x20 (0x20) +char 0x2 << 0x4 == 0x20 (0x20) +__uchar 0x2 << 0x4 == 0x20 (0x20) +__longlong 0x2 << 0x4 == 0x20 (0x20) +__ulonglong 0x2 << 0x4 == 0x20 (0x20) +int 0x2 >> 0x4 == 0x0 (0x0) +__uint 0x2 >> 0x4 == 0x0 (0x0) +char 0x2 >> 0x4 == 0x0 (0x0) +__uchar 0x2 >> 0x4 == 0x0 (0x0) +__longlong 0x2 >> 0x4 == 0x0 (0x0) +__ulonglong 0x2 >> 0x4 == 0x0 (0x0) +int 0x2 + 0xfffe == 0x0 (0x0) +__uint 0x2 + 0xfffe == 0x0 (0x0) +char 0x2 + 0xfffe == 0x0 (0x0) +__uchar 0x2 + 0xfe == 0x0 (0x0) +__longlong 0x2 + 0xfffe == 0x0 (0x0) +__ulonglong 0x2 + 0xfffe == 0x0 (0x0) +float 0x2 + 0xfffe == 0x0 (0x0) +int 0x2 - 0xfffe == 0x4 (0x4) +__uint 0x2 - 0xfffe == 0x4 (0x4) +char 0x2 - 0xfffe == 0x4 (0x4) +__uchar 0x2 - 0xfe == 0x4 (0x4) +__longlong 0x2 - 0xfffe == 0x4 (0x4) +__ulonglong 0x2 - 0xfffe == 0x4 (0x4) +float 0x2 - 0xfffe == 0x4 (0x4) +int 0x2 * 0xfffe == -0x4 (0xfffc) +__uint 0x2 * 0xfffe == -0x4 (0xfffc) +char 0x2 * 0xfffe == -0x4 (0xfffc) +__uchar 0x2 * 0xfe == 0xfc (0xfc) +__longlong 0x2 * 0xfffe == -0x4 (0xfffc) +__ulonglong 0x2 * 0xfffe == -0x4 (0xfffc) +float 0x2 * 0xfffe == -0x4 (0xfffc) +int 0x2 < 0xfffe == 0x0 (0x0) +__uint 0x2 < 0xfffe == 0x1 (0x1) +char 0x2 < 0xfffe == 0x0 (0x0) +__uchar 0x2 < 0xfe == 0x1 (0x1) +__longlong 0x2 < 0xfffe == 0x0 (0x0) +__ulonglong 0x2 < 0xfffe == 0x1 (0x1) +float 0x2 < 0xfffe == 0x0 (0x0) +int 0x2 > 0xfffe == 0x1 (0x1) +__uint 0x2 > 0xfffe == 0x0 (0x0) +char 0x2 > 0xfffe == 0x1 (0x1) +__uchar 0x2 > 0xfe == 0x0 (0x0) +__longlong 0x2 > 0xfffe == 0x1 (0x1) +__ulonglong 0x2 > 0xfffe == 0x0 (0x0) +float 0x2 > 0xfffe == 0x1 (0x1) +int 0x2 <= 0xfffe == 0x0 (0x0) +__uint 0x2 <= 0xfffe == 0x1 (0x1) +char 0x2 <= 0xfffe == 0x0 (0x0) +__uchar 0x2 <= 0xfe == 0x1 (0x1) +__longlong 0x2 <= 0xfffe == 0x0 (0x0) +__ulonglong 0x2 <= 0xfffe == 0x1 (0x1) +float 0x2 <= 0xfffe == 0x0 (0x0) +int 0x2 == 0xfffe == 0x0 (0x0) +__uint 0x2 == 0xfffe == 0x0 (0x0) +char 0x2 == 0xfffe == 0x0 (0x0) +__uchar 0x2 == 0xfe == 0x0 (0x0) +__longlong 0x2 == 0xfffe == 0x0 (0x0) +__ulonglong 0x2 == 0xfffe == 0x0 (0x0) +float 0x2 == 0xfffe == 0x0 (0x0) +int 0x2 != 0xfffe == 0x1 (0x1) +__uint 0x2 != 0xfffe == 0x1 (0x1) +char 0x2 != 0xfffe == 0x1 (0x1) +__uchar 0x2 != 0xfe == 0x1 (0x1) +__longlong 0x2 != 0xfffe == 0x1 (0x1) +__ulonglong 0x2 != 0xfffe == 0x1 (0x1) +float 0x2 != 0xfffe == 0x1 (0x1) +int 0x2 >= 0xfffe == 0x1 (0x1) +__uint 0x2 >= 0xfffe == 0x0 (0x0) +char 0x2 >= 0xfffe == 0x1 (0x1) +__uchar 0x2 >= 0xfe == 0x0 (0x0) +__longlong 0x2 >= 0xfffe == 0x1 (0x1) +__ulonglong 0x2 >= 0xfffe == 0x0 (0x0) +float 0x2 >= 0xfffe == 0x1 (0x1) +int 0x2 / 0xfffe == -0x1 (0xffff) +__uint 0x2 / 0xfffe == 0x0 (0x0) +char 0x2 / 0xfffe == -0x1 (0xffff) +__uchar 0x2 / 0xfe == 0x0 (0x0) +__longlong 0x2 / 0xfffe == -0x1 (0xffff) +__ulonglong 0x2 / 0xfffe == 0x0 (0x0) +float 0x2 / 0xfffe == -0x1 (0xffff) +int 0x2 % 0xfffe == 0x0 (0x0) +__uint 0x2 % 0xfffe == 0x2 (0x2) +char 0x2 % 0xfffe == 0x0 (0x0) +__uchar 0x2 % 0xfe == 0x2 (0x2) +__longlong 0x2 % 0xfffe == 0x0 (0x0) +__ulonglong 0x2 % 0xfffe == 0x2 (0x2) +0x2 * 0x4 == 0x8 +0x2 / 0x4 == 0x0 +0x2 % 0x4 == 0x2 +int 0x2 ^ 0x4 == 0x6 (0x6) +__uint 0x2 ^ 0x4 == 0x6 (0x6) +char 0x2 ^ 0x4 == 0x6 (0x6) +__uchar 0x2 ^ 0x4 == 0x6 (0x6) +__longlong 0x2 ^ 0x4 == 0x6 (0x6) +__ulonglong 0x2 ^ 0x4 == 0x6 (0x6) +int 0x2 && 0x4 == 0x1 (0x1) +__uint 0x2 && 0x4 == 0x1 (0x1) +char 0x2 && 0x4 == 0x1 (0x1) +__uchar 0x2 && 0x4 == 0x1 (0x1) +__longlong 0x2 && 0x4 == 0x1 (0x1) +__ulonglong 0x2 && 0x4 == 0x1 (0x1) +int 0x2 || 0x4 == 0x1 (0x1) +__uint 0x2 || 0x4 == 0x1 (0x1) +char 0x2 || 0x4 == 0x1 (0x1) +__uchar 0x2 || 0x4 == 0x1 (0x1) +__longlong 0x2 || 0x4 == 0x1 (0x1) +__ulonglong 0x2 || 0x4 == 0x1 (0x1) +int 0x2 & 0x4 == 0x0 (0x0) +__uint 0x2 & 0x4 == 0x0 (0x0) +char 0x2 & 0x4 == 0x0 (0x0) +__uchar 0x2 & 0x4 == 0x0 (0x0) +__longlong 0x2 & 0x4 == 0x0 (0x0) +__ulonglong 0x2 & 0x4 == 0x0 (0x0) +int 0x2 | 0x4 == 0x6 (0x6) +__uint 0x2 | 0x4 == 0x6 (0x6) +char 0x2 | 0x4 == 0x6 (0x6) +__uchar 0x2 | 0x4 == 0x6 (0x6) +__longlong 0x2 | 0x4 == 0x6 (0x6) +__ulonglong 0x2 | 0x4 == 0x6 (0x6) +int 0x2 << 0x5 == 0x40 (0x40) +__uint 0x2 << 0x5 == 0x40 (0x40) +char 0x2 << 0x5 == 0x40 (0x40) +__uchar 0x2 << 0x5 == 0x40 (0x40) +__longlong 0x2 << 0x5 == 0x40 (0x40) +__ulonglong 0x2 << 0x5 == 0x40 (0x40) +int 0x2 >> 0x5 == 0x0 (0x0) +__uint 0x2 >> 0x5 == 0x0 (0x0) +char 0x2 >> 0x5 == 0x0 (0x0) +__uchar 0x2 >> 0x5 == 0x0 (0x0) +__longlong 0x2 >> 0x5 == 0x0 (0x0) +__ulonglong 0x2 >> 0x5 == 0x0 (0x0) +int 0x2 + 0x4 == 0x6 (0x6) +__uint 0x2 + 0x4 == 0x6 (0x6) +char 0x2 + 0x4 == 0x6 (0x6) +__uchar 0x2 + 0x4 == 0x6 (0x6) +__longlong 0x2 + 0x4 == 0x6 (0x6) +__ulonglong 0x2 + 0x4 == 0x6 (0x6) +float 0x2 + 0x4 == 0x6 (0x6) +int 0x2 - 0x4 == -0x2 (0xfffe) +__uint 0x2 - 0x4 == -0x2 (0xfffe) +char 0x2 - 0x4 == -0x2 (0xfffe) +__uchar 0x2 - 0x4 == 0xfe (0xfe) +__longlong 0x2 - 0x4 == -0x2 (0xfffe) +__ulonglong 0x2 - 0x4 == -0x2 (0xfffe) +float 0x2 - 0x4 == -0x2 (0xfffe) +int 0x2 * 0x4 == 0x8 (0x8) +__uint 0x2 * 0x4 == 0x8 (0x8) +char 0x2 * 0x4 == 0x8 (0x8) +__uchar 0x2 * 0x4 == 0x8 (0x8) +__longlong 0x2 * 0x4 == 0x8 (0x8) +__ulonglong 0x2 * 0x4 == 0x8 (0x8) +float 0x2 * 0x4 == 0x8 (0x8) +int 0x2 < 0x4 == 0x1 (0x1) +__uint 0x2 < 0x4 == 0x1 (0x1) +char 0x2 < 0x4 == 0x1 (0x1) +__uchar 0x2 < 0x4 == 0x1 (0x1) +__longlong 0x2 < 0x4 == 0x1 (0x1) +__ulonglong 0x2 < 0x4 == 0x1 (0x1) +float 0x2 < 0x4 == 0x1 (0x1) +int 0x2 > 0x4 == 0x0 (0x0) +__uint 0x2 > 0x4 == 0x0 (0x0) +char 0x2 > 0x4 == 0x0 (0x0) +__uchar 0x2 > 0x4 == 0x0 (0x0) +__longlong 0x2 > 0x4 == 0x0 (0x0) +__ulonglong 0x2 > 0x4 == 0x0 (0x0) +float 0x2 > 0x4 == 0x0 (0x0) +int 0x2 <= 0x4 == 0x1 (0x1) +__uint 0x2 <= 0x4 == 0x1 (0x1) +char 0x2 <= 0x4 == 0x1 (0x1) +__uchar 0x2 <= 0x4 == 0x1 (0x1) +__longlong 0x2 <= 0x4 == 0x1 (0x1) +__ulonglong 0x2 <= 0x4 == 0x1 (0x1) +float 0x2 <= 0x4 == 0x1 (0x1) +int 0x2 == 0x4 == 0x0 (0x0) +__uint 0x2 == 0x4 == 0x0 (0x0) +char 0x2 == 0x4 == 0x0 (0x0) +__uchar 0x2 == 0x4 == 0x0 (0x0) +__longlong 0x2 == 0x4 == 0x0 (0x0) +__ulonglong 0x2 == 0x4 == 0x0 (0x0) +float 0x2 == 0x4 == 0x0 (0x0) +int 0x2 != 0x4 == 0x1 (0x1) +__uint 0x2 != 0x4 == 0x1 (0x1) +char 0x2 != 0x4 == 0x1 (0x1) +__uchar 0x2 != 0x4 == 0x1 (0x1) +__longlong 0x2 != 0x4 == 0x1 (0x1) +__ulonglong 0x2 != 0x4 == 0x1 (0x1) +float 0x2 != 0x4 == 0x1 (0x1) +int 0x2 >= 0x4 == 0x0 (0x0) +__uint 0x2 >= 0x4 == 0x0 (0x0) +char 0x2 >= 0x4 == 0x0 (0x0) +__uchar 0x2 >= 0x4 == 0x0 (0x0) +__longlong 0x2 >= 0x4 == 0x0 (0x0) +__ulonglong 0x2 >= 0x4 == 0x0 (0x0) +float 0x2 >= 0x4 == 0x0 (0x0) +int 0x2 / 0x4 == 0x0 (0x0) +__uint 0x2 / 0x4 == 0x0 (0x0) +char 0x2 / 0x4 == 0x0 (0x0) +__uchar 0x2 / 0x4 == 0x0 (0x0) +__longlong 0x2 / 0x4 == 0x0 (0x0) +__ulonglong 0x2 / 0x4 == 0x0 (0x0) +float 0x2 / 0x4 == 0x0 (0x0) +int 0x2 % 0x4 == 0x2 (0x2) +__uint 0x2 % 0x4 == 0x2 (0x2) +char 0x2 % 0x4 == 0x2 (0x2) +__uchar 0x2 % 0x4 == 0x2 (0x2) +__longlong 0x2 % 0x4 == 0x2 (0x2) +__ulonglong 0x2 % 0x4 == 0x2 (0x2) +0x2 * 0xfffc == -0x8 +0x2 / 0xfffc == 0x0 +0x2 % 0xfffc == 0x2 +int 0x2 ^ 0xfffc == -0x2 (0xfffe) +__uint 0x2 ^ 0xfffc == -0x2 (0xfffe) +char 0x2 ^ 0xfffc == -0x2 (0xfffe) +__uchar 0x2 ^ 0xfc == 0xfe (0xfe) +__longlong 0x2 ^ 0xfffc == -0x2 (0xfffe) +__ulonglong 0x2 ^ 0xfffc == -0x2 (0xfffe) +int 0x2 && 0xfffc == 0x1 (0x1) +__uint 0x2 && 0xfffc == 0x1 (0x1) +char 0x2 && 0xfffc == 0x1 (0x1) +__uchar 0x2 && 0xfc == 0x1 (0x1) +__longlong 0x2 && 0xfffc == 0x1 (0x1) +__ulonglong 0x2 && 0xfffc == 0x1 (0x1) +int 0x2 || 0xfffc == 0x1 (0x1) +__uint 0x2 || 0xfffc == 0x1 (0x1) +char 0x2 || 0xfffc == 0x1 (0x1) +__uchar 0x2 || 0xfc == 0x1 (0x1) +__longlong 0x2 || 0xfffc == 0x1 (0x1) +__ulonglong 0x2 || 0xfffc == 0x1 (0x1) +int 0x2 & 0xfffc == 0x0 (0x0) +__uint 0x2 & 0xfffc == 0x0 (0x0) +char 0x2 & 0xfffc == 0x0 (0x0) +__uchar 0x2 & 0xfc == 0x0 (0x0) +__longlong 0x2 & 0xfffc == 0x0 (0x0) +__ulonglong 0x2 & 0xfffc == 0x0 (0x0) +int 0x2 | 0xfffc == -0x2 (0xfffe) +__uint 0x2 | 0xfffc == -0x2 (0xfffe) +char 0x2 | 0xfffc == -0x2 (0xfffe) +__uchar 0x2 | 0xfc == 0xfe (0xfe) +__longlong 0x2 | 0xfffc == -0x2 (0xfffe) +__ulonglong 0x2 | 0xfffc == -0x2 (0xfffe) +int 0x2 << 0x6 == 0x80 (0x80) +__uint 0x2 << 0x6 == 0x80 (0x80) +char 0x2 << 0x6 == -0x80 (0xff80) +__uchar 0x2 << 0x6 == 0x80 (0x80) +__longlong 0x2 << 0x6 == 0x80 (0x80) +__ulonglong 0x2 << 0x6 == 0x80 (0x80) +int 0x2 >> 0x6 == 0x0 (0x0) +__uint 0x2 >> 0x6 == 0x0 (0x0) +char 0x2 >> 0x6 == 0x0 (0x0) +__uchar 0x2 >> 0x6 == 0x0 (0x0) +__longlong 0x2 >> 0x6 == 0x0 (0x0) +__ulonglong 0x2 >> 0x6 == 0x0 (0x0) +int 0x2 + 0xfffc == -0x2 (0xfffe) +__uint 0x2 + 0xfffc == -0x2 (0xfffe) +char 0x2 + 0xfffc == -0x2 (0xfffe) +__uchar 0x2 + 0xfc == 0xfe (0xfe) +__longlong 0x2 + 0xfffc == -0x2 (0xfffe) +__ulonglong 0x2 + 0xfffc == -0x2 (0xfffe) +float 0x2 + 0xfffc == -0x2 (0xfffe) +int 0x2 - 0xfffc == 0x6 (0x6) +__uint 0x2 - 0xfffc == 0x6 (0x6) +char 0x2 - 0xfffc == 0x6 (0x6) +__uchar 0x2 - 0xfc == 0x6 (0x6) +__longlong 0x2 - 0xfffc == 0x6 (0x6) +__ulonglong 0x2 - 0xfffc == 0x6 (0x6) +float 0x2 - 0xfffc == 0x6 (0x6) +int 0x2 * 0xfffc == -0x8 (0xfff8) +__uint 0x2 * 0xfffc == -0x8 (0xfff8) +char 0x2 * 0xfffc == -0x8 (0xfff8) +__uchar 0x2 * 0xfc == 0xf8 (0xf8) +__longlong 0x2 * 0xfffc == -0x8 (0xfff8) +__ulonglong 0x2 * 0xfffc == -0x8 (0xfff8) +float 0x2 * 0xfffc == -0x8 (0xfff8) +int 0x2 < 0xfffc == 0x0 (0x0) +__uint 0x2 < 0xfffc == 0x1 (0x1) +char 0x2 < 0xfffc == 0x0 (0x0) +__uchar 0x2 < 0xfc == 0x1 (0x1) +__longlong 0x2 < 0xfffc == 0x0 (0x0) +__ulonglong 0x2 < 0xfffc == 0x1 (0x1) +float 0x2 < 0xfffc == 0x0 (0x0) +int 0x2 > 0xfffc == 0x1 (0x1) +__uint 0x2 > 0xfffc == 0x0 (0x0) +char 0x2 > 0xfffc == 0x1 (0x1) +__uchar 0x2 > 0xfc == 0x0 (0x0) +__longlong 0x2 > 0xfffc == 0x1 (0x1) +__ulonglong 0x2 > 0xfffc == 0x0 (0x0) +float 0x2 > 0xfffc == 0x1 (0x1) +int 0x2 <= 0xfffc == 0x0 (0x0) +__uint 0x2 <= 0xfffc == 0x1 (0x1) +char 0x2 <= 0xfffc == 0x0 (0x0) +__uchar 0x2 <= 0xfc == 0x1 (0x1) +__longlong 0x2 <= 0xfffc == 0x0 (0x0) +__ulonglong 0x2 <= 0xfffc == 0x1 (0x1) +float 0x2 <= 0xfffc == 0x0 (0x0) +int 0x2 == 0xfffc == 0x0 (0x0) +__uint 0x2 == 0xfffc == 0x0 (0x0) +char 0x2 == 0xfffc == 0x0 (0x0) +__uchar 0x2 == 0xfc == 0x0 (0x0) +__longlong 0x2 == 0xfffc == 0x0 (0x0) +__ulonglong 0x2 == 0xfffc == 0x0 (0x0) +float 0x2 == 0xfffc == 0x0 (0x0) +int 0x2 != 0xfffc == 0x1 (0x1) +__uint 0x2 != 0xfffc == 0x1 (0x1) +char 0x2 != 0xfffc == 0x1 (0x1) +__uchar 0x2 != 0xfc == 0x1 (0x1) +__longlong 0x2 != 0xfffc == 0x1 (0x1) +__ulonglong 0x2 != 0xfffc == 0x1 (0x1) +float 0x2 != 0xfffc == 0x1 (0x1) +int 0x2 >= 0xfffc == 0x1 (0x1) +__uint 0x2 >= 0xfffc == 0x0 (0x0) +char 0x2 >= 0xfffc == 0x1 (0x1) +__uchar 0x2 >= 0xfc == 0x0 (0x0) +__longlong 0x2 >= 0xfffc == 0x1 (0x1) +__ulonglong 0x2 >= 0xfffc == 0x0 (0x0) +float 0x2 >= 0xfffc == 0x1 (0x1) +int 0x2 / 0xfffc == 0x0 (0x0) +__uint 0x2 / 0xfffc == 0x0 (0x0) +char 0x2 / 0xfffc == 0x0 (0x0) +__uchar 0x2 / 0xfc == 0x0 (0x0) +__longlong 0x2 / 0xfffc == 0x0 (0x0) +__ulonglong 0x2 / 0xfffc == 0x0 (0x0) +float 0x2 / 0xfffc == 0x0 (0x0) +int 0x2 % 0xfffc == 0x2 (0x2) +__uint 0x2 % 0xfffc == 0x2 (0x2) +char 0x2 % 0xfffc == 0x2 (0x2) +__uchar 0x2 % 0xfc == 0x2 (0x2) +__longlong 0x2 % 0xfffc == 0x2 (0x2) +__ulonglong 0x2 % 0xfffc == 0x2 (0x2) +0x2 * 0xa == 0x14 +0x2 / 0xa == 0x0 +0x2 % 0xa == 0x2 +int 0x2 ^ 0xa == 0x8 (0x8) +__uint 0x2 ^ 0xa == 0x8 (0x8) +char 0x2 ^ 0xa == 0x8 (0x8) +__uchar 0x2 ^ 0xa == 0x8 (0x8) +__longlong 0x2 ^ 0xa == 0x8 (0x8) +__ulonglong 0x2 ^ 0xa == 0x8 (0x8) +int 0x2 && 0xa == 0x1 (0x1) +__uint 0x2 && 0xa == 0x1 (0x1) +char 0x2 && 0xa == 0x1 (0x1) +__uchar 0x2 && 0xa == 0x1 (0x1) +__longlong 0x2 && 0xa == 0x1 (0x1) +__ulonglong 0x2 && 0xa == 0x1 (0x1) +int 0x2 || 0xa == 0x1 (0x1) +__uint 0x2 || 0xa == 0x1 (0x1) +char 0x2 || 0xa == 0x1 (0x1) +__uchar 0x2 || 0xa == 0x1 (0x1) +__longlong 0x2 || 0xa == 0x1 (0x1) +__ulonglong 0x2 || 0xa == 0x1 (0x1) +int 0x2 & 0xa == 0x2 (0x2) +__uint 0x2 & 0xa == 0x2 (0x2) +char 0x2 & 0xa == 0x2 (0x2) +__uchar 0x2 & 0xa == 0x2 (0x2) +__longlong 0x2 & 0xa == 0x2 (0x2) +__ulonglong 0x2 & 0xa == 0x2 (0x2) +int 0x2 | 0xa == 0xa (0xa) +__uint 0x2 | 0xa == 0xa (0xa) +char 0x2 | 0xa == 0xa (0xa) +__uchar 0x2 | 0xa == 0xa (0xa) +__longlong 0x2 | 0xa == 0xa (0xa) +__ulonglong 0x2 | 0xa == 0xa (0xa) +int 0x2 << 0x7 == 0x100 (0x100) +__uint 0x2 << 0x7 == 0x100 (0x100) +char 0x2 << 0x7 == 0x0 (0x0) +__uchar 0x2 << 0x7 == 0x0 (0x0) +__longlong 0x2 << 0x7 == 0x100 (0x100) +__ulonglong 0x2 << 0x7 == 0x100 (0x100) +int 0x2 >> 0x7 == 0x0 (0x0) +__uint 0x2 >> 0x7 == 0x0 (0x0) +char 0x2 >> 0x7 == 0x0 (0x0) +__uchar 0x2 >> 0x7 == 0x0 (0x0) +__longlong 0x2 >> 0x7 == 0x0 (0x0) +__ulonglong 0x2 >> 0x7 == 0x0 (0x0) +int 0x2 + 0xa == 0xc (0xc) +__uint 0x2 + 0xa == 0xc (0xc) +char 0x2 + 0xa == 0xc (0xc) +__uchar 0x2 + 0xa == 0xc (0xc) +__longlong 0x2 + 0xa == 0xc (0xc) +__ulonglong 0x2 + 0xa == 0xc (0xc) +float 0x2 + 0xa == 0xc (0xc) +int 0x2 - 0xa == -0x8 (0xfff8) +__uint 0x2 - 0xa == -0x8 (0xfff8) +char 0x2 - 0xa == -0x8 (0xfff8) +__uchar 0x2 - 0xa == 0xf8 (0xf8) +__longlong 0x2 - 0xa == -0x8 (0xfff8) +__ulonglong 0x2 - 0xa == -0x8 (0xfff8) +float 0x2 - 0xa == -0x8 (0xfff8) +int 0x2 * 0xa == 0x14 (0x14) +__uint 0x2 * 0xa == 0x14 (0x14) +char 0x2 * 0xa == 0x14 (0x14) +__uchar 0x2 * 0xa == 0x14 (0x14) +__longlong 0x2 * 0xa == 0x14 (0x14) +__ulonglong 0x2 * 0xa == 0x14 (0x14) +float 0x2 * 0xa == 0x14 (0x14) +int 0x2 < 0xa == 0x1 (0x1) +__uint 0x2 < 0xa == 0x1 (0x1) +char 0x2 < 0xa == 0x1 (0x1) +__uchar 0x2 < 0xa == 0x1 (0x1) +__longlong 0x2 < 0xa == 0x1 (0x1) +__ulonglong 0x2 < 0xa == 0x1 (0x1) +float 0x2 < 0xa == 0x1 (0x1) +int 0x2 > 0xa == 0x0 (0x0) +__uint 0x2 > 0xa == 0x0 (0x0) +char 0x2 > 0xa == 0x0 (0x0) +__uchar 0x2 > 0xa == 0x0 (0x0) +__longlong 0x2 > 0xa == 0x0 (0x0) +__ulonglong 0x2 > 0xa == 0x0 (0x0) +float 0x2 > 0xa == 0x0 (0x0) +int 0x2 <= 0xa == 0x1 (0x1) +__uint 0x2 <= 0xa == 0x1 (0x1) +char 0x2 <= 0xa == 0x1 (0x1) +__uchar 0x2 <= 0xa == 0x1 (0x1) +__longlong 0x2 <= 0xa == 0x1 (0x1) +__ulonglong 0x2 <= 0xa == 0x1 (0x1) +float 0x2 <= 0xa == 0x1 (0x1) +int 0x2 == 0xa == 0x0 (0x0) +__uint 0x2 == 0xa == 0x0 (0x0) +char 0x2 == 0xa == 0x0 (0x0) +__uchar 0x2 == 0xa == 0x0 (0x0) +__longlong 0x2 == 0xa == 0x0 (0x0) +__ulonglong 0x2 == 0xa == 0x0 (0x0) +float 0x2 == 0xa == 0x0 (0x0) +int 0x2 != 0xa == 0x1 (0x1) +__uint 0x2 != 0xa == 0x1 (0x1) +char 0x2 != 0xa == 0x1 (0x1) +__uchar 0x2 != 0xa == 0x1 (0x1) +__longlong 0x2 != 0xa == 0x1 (0x1) +__ulonglong 0x2 != 0xa == 0x1 (0x1) +float 0x2 != 0xa == 0x1 (0x1) +int 0x2 >= 0xa == 0x0 (0x0) +__uint 0x2 >= 0xa == 0x0 (0x0) +char 0x2 >= 0xa == 0x0 (0x0) +__uchar 0x2 >= 0xa == 0x0 (0x0) +__longlong 0x2 >= 0xa == 0x0 (0x0) +__ulonglong 0x2 >= 0xa == 0x0 (0x0) +float 0x2 >= 0xa == 0x0 (0x0) +int 0x2 / 0xa == 0x0 (0x0) +__uint 0x2 / 0xa == 0x0 (0x0) +char 0x2 / 0xa == 0x0 (0x0) +__uchar 0x2 / 0xa == 0x0 (0x0) +__longlong 0x2 / 0xa == 0x0 (0x0) +__ulonglong 0x2 / 0xa == 0x0 (0x0) +float 0x2 / 0xa == 0x0 (0x0) +int 0x2 % 0xa == 0x2 (0x2) +__uint 0x2 % 0xa == 0x2 (0x2) +char 0x2 % 0xa == 0x2 (0x2) +__uchar 0x2 % 0xa == 0x2 (0x2) +__longlong 0x2 % 0xa == 0x2 (0x2) +__ulonglong 0x2 % 0xa == 0x2 (0x2) +0x2 * 0xfff6 == -0x14 +0x2 / 0xfff6 == 0x0 +0x2 % 0xfff6 == 0x2 +int 0x2 ^ 0xfff6 == -0xc (0xfff4) +__uint 0x2 ^ 0xfff6 == -0xc (0xfff4) +char 0x2 ^ 0xfff6 == -0xc (0xfff4) +__uchar 0x2 ^ 0xf6 == 0xf4 (0xf4) +__longlong 0x2 ^ 0xfff6 == -0xc (0xfff4) +__ulonglong 0x2 ^ 0xfff6 == -0xc (0xfff4) +int 0x2 && 0xfff6 == 0x1 (0x1) +__uint 0x2 && 0xfff6 == 0x1 (0x1) +char 0x2 && 0xfff6 == 0x1 (0x1) +__uchar 0x2 && 0xf6 == 0x1 (0x1) +__longlong 0x2 && 0xfff6 == 0x1 (0x1) +__ulonglong 0x2 && 0xfff6 == 0x1 (0x1) +int 0x2 || 0xfff6 == 0x1 (0x1) +__uint 0x2 || 0xfff6 == 0x1 (0x1) +char 0x2 || 0xfff6 == 0x1 (0x1) +__uchar 0x2 || 0xf6 == 0x1 (0x1) +__longlong 0x2 || 0xfff6 == 0x1 (0x1) +__ulonglong 0x2 || 0xfff6 == 0x1 (0x1) +int 0x2 & 0xfff6 == 0x2 (0x2) +__uint 0x2 & 0xfff6 == 0x2 (0x2) +char 0x2 & 0xfff6 == 0x2 (0x2) +__uchar 0x2 & 0xf6 == 0x2 (0x2) +__longlong 0x2 & 0xfff6 == 0x2 (0x2) +__ulonglong 0x2 & 0xfff6 == 0x2 (0x2) +int 0x2 | 0xfff6 == -0xa (0xfff6) +__uint 0x2 | 0xfff6 == -0xa (0xfff6) +char 0x2 | 0xfff6 == -0xa (0xfff6) +__uchar 0x2 | 0xf6 == 0xf6 (0xf6) +__longlong 0x2 | 0xfff6 == -0xa (0xfff6) +__ulonglong 0x2 | 0xfff6 == -0xa (0xfff6) +int 0x2 << 0x8 == 0x200 (0x200) +__uint 0x2 << 0x8 == 0x200 (0x200) +char 0x2 << 0x8 == 0x0 (0x0) +__uchar 0x2 << 0x8 == 0x0 (0x0) +__longlong 0x2 << 0x8 == 0x200 (0x200) +__ulonglong 0x2 << 0x8 == 0x200 (0x200) +int 0x2 >> 0x8 == 0x0 (0x0) +__uint 0x2 >> 0x8 == 0x0 (0x0) +char 0x2 >> 0x8 == 0x0 (0x0) +__uchar 0x2 >> 0x8 == 0x0 (0x0) +__longlong 0x2 >> 0x8 == 0x0 (0x0) +__ulonglong 0x2 >> 0x8 == 0x0 (0x0) +int 0x2 + 0xfff6 == -0x8 (0xfff8) +__uint 0x2 + 0xfff6 == -0x8 (0xfff8) +char 0x2 + 0xfff6 == -0x8 (0xfff8) +__uchar 0x2 + 0xf6 == 0xf8 (0xf8) +__longlong 0x2 + 0xfff6 == -0x8 (0xfff8) +__ulonglong 0x2 + 0xfff6 == -0x8 (0xfff8) +float 0x2 + 0xfff6 == -0x8 (0xfff8) +int 0x2 - 0xfff6 == 0xc (0xc) +__uint 0x2 - 0xfff6 == 0xc (0xc) +char 0x2 - 0xfff6 == 0xc (0xc) +__uchar 0x2 - 0xf6 == 0xc (0xc) +__longlong 0x2 - 0xfff6 == 0xc (0xc) +__ulonglong 0x2 - 0xfff6 == 0xc (0xc) +float 0x2 - 0xfff6 == 0xc (0xc) +int 0x2 * 0xfff6 == -0x14 (0xffec) +__uint 0x2 * 0xfff6 == -0x14 (0xffec) +char 0x2 * 0xfff6 == -0x14 (0xffec) +__uchar 0x2 * 0xf6 == 0xec (0xec) +__longlong 0x2 * 0xfff6 == -0x14 (0xffec) +__ulonglong 0x2 * 0xfff6 == -0x14 (0xffec) +float 0x2 * 0xfff6 == -0x14 (0xffec) +int 0x2 < 0xfff6 == 0x0 (0x0) +__uint 0x2 < 0xfff6 == 0x1 (0x1) +char 0x2 < 0xfff6 == 0x0 (0x0) +__uchar 0x2 < 0xf6 == 0x1 (0x1) +__longlong 0x2 < 0xfff6 == 0x0 (0x0) +__ulonglong 0x2 < 0xfff6 == 0x1 (0x1) +float 0x2 < 0xfff6 == 0x0 (0x0) +int 0x2 > 0xfff6 == 0x1 (0x1) +__uint 0x2 > 0xfff6 == 0x0 (0x0) +char 0x2 > 0xfff6 == 0x1 (0x1) +__uchar 0x2 > 0xf6 == 0x0 (0x0) +__longlong 0x2 > 0xfff6 == 0x1 (0x1) +__ulonglong 0x2 > 0xfff6 == 0x0 (0x0) +float 0x2 > 0xfff6 == 0x1 (0x1) +int 0x2 <= 0xfff6 == 0x0 (0x0) +__uint 0x2 <= 0xfff6 == 0x1 (0x1) +char 0x2 <= 0xfff6 == 0x0 (0x0) +__uchar 0x2 <= 0xf6 == 0x1 (0x1) +__longlong 0x2 <= 0xfff6 == 0x0 (0x0) +__ulonglong 0x2 <= 0xfff6 == 0x1 (0x1) +float 0x2 <= 0xfff6 == 0x0 (0x0) +int 0x2 == 0xfff6 == 0x0 (0x0) +__uint 0x2 == 0xfff6 == 0x0 (0x0) +char 0x2 == 0xfff6 == 0x0 (0x0) +__uchar 0x2 == 0xf6 == 0x0 (0x0) +__longlong 0x2 == 0xfff6 == 0x0 (0x0) +__ulonglong 0x2 == 0xfff6 == 0x0 (0x0) +float 0x2 == 0xfff6 == 0x0 (0x0) +int 0x2 != 0xfff6 == 0x1 (0x1) +__uint 0x2 != 0xfff6 == 0x1 (0x1) +char 0x2 != 0xfff6 == 0x1 (0x1) +__uchar 0x2 != 0xf6 == 0x1 (0x1) +__longlong 0x2 != 0xfff6 == 0x1 (0x1) +__ulonglong 0x2 != 0xfff6 == 0x1 (0x1) +float 0x2 != 0xfff6 == 0x1 (0x1) +int 0x2 >= 0xfff6 == 0x1 (0x1) +__uint 0x2 >= 0xfff6 == 0x0 (0x0) +char 0x2 >= 0xfff6 == 0x1 (0x1) +__uchar 0x2 >= 0xf6 == 0x0 (0x0) +__longlong 0x2 >= 0xfff6 == 0x1 (0x1) +__ulonglong 0x2 >= 0xfff6 == 0x0 (0x0) +float 0x2 >= 0xfff6 == 0x1 (0x1) +int 0x2 / 0xfff6 == 0x0 (0x0) +__uint 0x2 / 0xfff6 == 0x0 (0x0) +char 0x2 / 0xfff6 == 0x0 (0x0) +__uchar 0x2 / 0xf6 == 0x0 (0x0) +__longlong 0x2 / 0xfff6 == 0x0 (0x0) +__ulonglong 0x2 / 0xfff6 == 0x0 (0x0) +float 0x2 / 0xfff6 == 0x0 (0x0) +int 0x2 % 0xfff6 == 0x2 (0x2) +__uint 0x2 % 0xfff6 == 0x2 (0x2) +char 0x2 % 0xfff6 == 0x2 (0x2) +__uchar 0x2 % 0xf6 == 0x2 (0x2) +__longlong 0x2 % 0xfff6 == 0x2 (0x2) +__ulonglong 0x2 % 0xfff6 == 0x2 (0x2) +0x2 * 0x5 == 0xa +0x2 / 0x5 == 0x0 +0x2 % 0x5 == 0x2 +int 0x2 ^ 0x5 == 0x7 (0x7) +__uint 0x2 ^ 0x5 == 0x7 (0x7) +char 0x2 ^ 0x5 == 0x7 (0x7) +__uchar 0x2 ^ 0x5 == 0x7 (0x7) +__longlong 0x2 ^ 0x5 == 0x7 (0x7) +__ulonglong 0x2 ^ 0x5 == 0x7 (0x7) +int 0x2 && 0x5 == 0x1 (0x1) +__uint 0x2 && 0x5 == 0x1 (0x1) +char 0x2 && 0x5 == 0x1 (0x1) +__uchar 0x2 && 0x5 == 0x1 (0x1) +__longlong 0x2 && 0x5 == 0x1 (0x1) +__ulonglong 0x2 && 0x5 == 0x1 (0x1) +int 0x2 || 0x5 == 0x1 (0x1) +__uint 0x2 || 0x5 == 0x1 (0x1) +char 0x2 || 0x5 == 0x1 (0x1) +__uchar 0x2 || 0x5 == 0x1 (0x1) +__longlong 0x2 || 0x5 == 0x1 (0x1) +__ulonglong 0x2 || 0x5 == 0x1 (0x1) +int 0x2 & 0x5 == 0x0 (0x0) +__uint 0x2 & 0x5 == 0x0 (0x0) +char 0x2 & 0x5 == 0x0 (0x0) +__uchar 0x2 & 0x5 == 0x0 (0x0) +__longlong 0x2 & 0x5 == 0x0 (0x0) +__ulonglong 0x2 & 0x5 == 0x0 (0x0) +int 0x2 | 0x5 == 0x7 (0x7) +__uint 0x2 | 0x5 == 0x7 (0x7) +char 0x2 | 0x5 == 0x7 (0x7) +__uchar 0x2 | 0x5 == 0x7 (0x7) +__longlong 0x2 | 0x5 == 0x7 (0x7) +__ulonglong 0x2 | 0x5 == 0x7 (0x7) +int 0x2 << 0x9 == 0x400 (0x400) +__uint 0x2 << 0x9 == 0x400 (0x400) +char 0x2 << 0x9 == 0x0 (0x0) +__uchar 0x2 << 0x9 == 0x0 (0x0) +__longlong 0x2 << 0x9 == 0x400 (0x400) +__ulonglong 0x2 << 0x9 == 0x400 (0x400) +int 0x2 >> 0x9 == 0x0 (0x0) +__uint 0x2 >> 0x9 == 0x0 (0x0) +char 0x2 >> 0x9 == 0x0 (0x0) +__uchar 0x2 >> 0x9 == 0x0 (0x0) +__longlong 0x2 >> 0x9 == 0x0 (0x0) +__ulonglong 0x2 >> 0x9 == 0x0 (0x0) +int 0x2 + 0x5 == 0x7 (0x7) +__uint 0x2 + 0x5 == 0x7 (0x7) +char 0x2 + 0x5 == 0x7 (0x7) +__uchar 0x2 + 0x5 == 0x7 (0x7) +__longlong 0x2 + 0x5 == 0x7 (0x7) +__ulonglong 0x2 + 0x5 == 0x7 (0x7) +float 0x2 + 0x5 == 0x7 (0x7) +int 0x2 - 0x5 == -0x3 (0xfffd) +__uint 0x2 - 0x5 == -0x3 (0xfffd) +char 0x2 - 0x5 == -0x3 (0xfffd) +__uchar 0x2 - 0x5 == 0xfd (0xfd) +__longlong 0x2 - 0x5 == -0x3 (0xfffd) +__ulonglong 0x2 - 0x5 == -0x3 (0xfffd) +float 0x2 - 0x5 == -0x3 (0xfffd) +int 0x2 * 0x5 == 0xa (0xa) +__uint 0x2 * 0x5 == 0xa (0xa) +char 0x2 * 0x5 == 0xa (0xa) +__uchar 0x2 * 0x5 == 0xa (0xa) +__longlong 0x2 * 0x5 == 0xa (0xa) +__ulonglong 0x2 * 0x5 == 0xa (0xa) +float 0x2 * 0x5 == 0xa (0xa) +int 0x2 < 0x5 == 0x1 (0x1) +__uint 0x2 < 0x5 == 0x1 (0x1) +char 0x2 < 0x5 == 0x1 (0x1) +__uchar 0x2 < 0x5 == 0x1 (0x1) +__longlong 0x2 < 0x5 == 0x1 (0x1) +__ulonglong 0x2 < 0x5 == 0x1 (0x1) +float 0x2 < 0x5 == 0x1 (0x1) +int 0x2 > 0x5 == 0x0 (0x0) +__uint 0x2 > 0x5 == 0x0 (0x0) +char 0x2 > 0x5 == 0x0 (0x0) +__uchar 0x2 > 0x5 == 0x0 (0x0) +__longlong 0x2 > 0x5 == 0x0 (0x0) +__ulonglong 0x2 > 0x5 == 0x0 (0x0) +float 0x2 > 0x5 == 0x0 (0x0) +int 0x2 <= 0x5 == 0x1 (0x1) +__uint 0x2 <= 0x5 == 0x1 (0x1) +char 0x2 <= 0x5 == 0x1 (0x1) +__uchar 0x2 <= 0x5 == 0x1 (0x1) +__longlong 0x2 <= 0x5 == 0x1 (0x1) +__ulonglong 0x2 <= 0x5 == 0x1 (0x1) +float 0x2 <= 0x5 == 0x1 (0x1) +int 0x2 == 0x5 == 0x0 (0x0) +__uint 0x2 == 0x5 == 0x0 (0x0) +char 0x2 == 0x5 == 0x0 (0x0) +__uchar 0x2 == 0x5 == 0x0 (0x0) +__longlong 0x2 == 0x5 == 0x0 (0x0) +__ulonglong 0x2 == 0x5 == 0x0 (0x0) +float 0x2 == 0x5 == 0x0 (0x0) +int 0x2 != 0x5 == 0x1 (0x1) +__uint 0x2 != 0x5 == 0x1 (0x1) +char 0x2 != 0x5 == 0x1 (0x1) +__uchar 0x2 != 0x5 == 0x1 (0x1) +__longlong 0x2 != 0x5 == 0x1 (0x1) +__ulonglong 0x2 != 0x5 == 0x1 (0x1) +float 0x2 != 0x5 == 0x1 (0x1) +int 0x2 >= 0x5 == 0x0 (0x0) +__uint 0x2 >= 0x5 == 0x0 (0x0) +char 0x2 >= 0x5 == 0x0 (0x0) +__uchar 0x2 >= 0x5 == 0x0 (0x0) +__longlong 0x2 >= 0x5 == 0x0 (0x0) +__ulonglong 0x2 >= 0x5 == 0x0 (0x0) +float 0x2 >= 0x5 == 0x0 (0x0) +int 0x2 / 0x5 == 0x0 (0x0) +__uint 0x2 / 0x5 == 0x0 (0x0) +char 0x2 / 0x5 == 0x0 (0x0) +__uchar 0x2 / 0x5 == 0x0 (0x0) +__longlong 0x2 / 0x5 == 0x0 (0x0) +__ulonglong 0x2 / 0x5 == 0x0 (0x0) +float 0x2 / 0x5 == 0x0 (0x0) +int 0x2 % 0x5 == 0x2 (0x2) +__uint 0x2 % 0x5 == 0x2 (0x2) +char 0x2 % 0x5 == 0x2 (0x2) +__uchar 0x2 % 0x5 == 0x2 (0x2) +__longlong 0x2 % 0x5 == 0x2 (0x2) +__ulonglong 0x2 % 0x5 == 0x2 (0x2) +0x2 * 0x7 == 0xe +0x2 / 0x7 == 0x0 +0x2 % 0x7 == 0x2 +int 0x2 ^ 0x7 == 0x5 (0x5) +__uint 0x2 ^ 0x7 == 0x5 (0x5) +char 0x2 ^ 0x7 == 0x5 (0x5) +__uchar 0x2 ^ 0x7 == 0x5 (0x5) +__longlong 0x2 ^ 0x7 == 0x5 (0x5) +__ulonglong 0x2 ^ 0x7 == 0x5 (0x5) +int 0x2 && 0x7 == 0x1 (0x1) +__uint 0x2 && 0x7 == 0x1 (0x1) +char 0x2 && 0x7 == 0x1 (0x1) +__uchar 0x2 && 0x7 == 0x1 (0x1) +__longlong 0x2 && 0x7 == 0x1 (0x1) +__ulonglong 0x2 && 0x7 == 0x1 (0x1) +int 0x2 || 0x7 == 0x1 (0x1) +__uint 0x2 || 0x7 == 0x1 (0x1) +char 0x2 || 0x7 == 0x1 (0x1) +__uchar 0x2 || 0x7 == 0x1 (0x1) +__longlong 0x2 || 0x7 == 0x1 (0x1) +__ulonglong 0x2 || 0x7 == 0x1 (0x1) +int 0x2 & 0x7 == 0x2 (0x2) +__uint 0x2 & 0x7 == 0x2 (0x2) +char 0x2 & 0x7 == 0x2 (0x2) +__uchar 0x2 & 0x7 == 0x2 (0x2) +__longlong 0x2 & 0x7 == 0x2 (0x2) +__ulonglong 0x2 & 0x7 == 0x2 (0x2) +int 0x2 | 0x7 == 0x7 (0x7) +__uint 0x2 | 0x7 == 0x7 (0x7) +char 0x2 | 0x7 == 0x7 (0x7) +__uchar 0x2 | 0x7 == 0x7 (0x7) +__longlong 0x2 | 0x7 == 0x7 (0x7) +__ulonglong 0x2 | 0x7 == 0x7 (0x7) +int 0x2 << 0xa == 0x800 (0x800) +__uint 0x2 << 0xa == 0x800 (0x800) +char 0x2 << 0xa == 0x0 (0x0) +__uchar 0x2 << 0xa == 0x0 (0x0) +__longlong 0x2 << 0xa == 0x800 (0x800) +__ulonglong 0x2 << 0xa == 0x800 (0x800) +int 0x2 >> 0xa == 0x0 (0x0) +__uint 0x2 >> 0xa == 0x0 (0x0) +char 0x2 >> 0xa == 0x0 (0x0) +__uchar 0x2 >> 0xa == 0x0 (0x0) +__longlong 0x2 >> 0xa == 0x0 (0x0) +__ulonglong 0x2 >> 0xa == 0x0 (0x0) +int 0x2 + 0x7 == 0x9 (0x9) +__uint 0x2 + 0x7 == 0x9 (0x9) +char 0x2 + 0x7 == 0x9 (0x9) +__uchar 0x2 + 0x7 == 0x9 (0x9) +__longlong 0x2 + 0x7 == 0x9 (0x9) +__ulonglong 0x2 + 0x7 == 0x9 (0x9) +float 0x2 + 0x7 == 0x9 (0x9) +int 0x2 - 0x7 == -0x5 (0xfffb) +__uint 0x2 - 0x7 == -0x5 (0xfffb) +char 0x2 - 0x7 == -0x5 (0xfffb) +__uchar 0x2 - 0x7 == 0xfb (0xfb) +__longlong 0x2 - 0x7 == -0x5 (0xfffb) +__ulonglong 0x2 - 0x7 == -0x5 (0xfffb) +float 0x2 - 0x7 == -0x5 (0xfffb) +int 0x2 * 0x7 == 0xe (0xe) +__uint 0x2 * 0x7 == 0xe (0xe) +char 0x2 * 0x7 == 0xe (0xe) +__uchar 0x2 * 0x7 == 0xe (0xe) +__longlong 0x2 * 0x7 == 0xe (0xe) +__ulonglong 0x2 * 0x7 == 0xe (0xe) +float 0x2 * 0x7 == 0xe (0xe) +int 0x2 < 0x7 == 0x1 (0x1) +__uint 0x2 < 0x7 == 0x1 (0x1) +char 0x2 < 0x7 == 0x1 (0x1) +__uchar 0x2 < 0x7 == 0x1 (0x1) +__longlong 0x2 < 0x7 == 0x1 (0x1) +__ulonglong 0x2 < 0x7 == 0x1 (0x1) +float 0x2 < 0x7 == 0x1 (0x1) +int 0x2 > 0x7 == 0x0 (0x0) +__uint 0x2 > 0x7 == 0x0 (0x0) +char 0x2 > 0x7 == 0x0 (0x0) +__uchar 0x2 > 0x7 == 0x0 (0x0) +__longlong 0x2 > 0x7 == 0x0 (0x0) +__ulonglong 0x2 > 0x7 == 0x0 (0x0) +float 0x2 > 0x7 == 0x0 (0x0) +int 0x2 <= 0x7 == 0x1 (0x1) +__uint 0x2 <= 0x7 == 0x1 (0x1) +char 0x2 <= 0x7 == 0x1 (0x1) +__uchar 0x2 <= 0x7 == 0x1 (0x1) +__longlong 0x2 <= 0x7 == 0x1 (0x1) +__ulonglong 0x2 <= 0x7 == 0x1 (0x1) +float 0x2 <= 0x7 == 0x1 (0x1) +int 0x2 == 0x7 == 0x0 (0x0) +__uint 0x2 == 0x7 == 0x0 (0x0) +char 0x2 == 0x7 == 0x0 (0x0) +__uchar 0x2 == 0x7 == 0x0 (0x0) +__longlong 0x2 == 0x7 == 0x0 (0x0) +__ulonglong 0x2 == 0x7 == 0x0 (0x0) +float 0x2 == 0x7 == 0x0 (0x0) +int 0x2 != 0x7 == 0x1 (0x1) +__uint 0x2 != 0x7 == 0x1 (0x1) +char 0x2 != 0x7 == 0x1 (0x1) +__uchar 0x2 != 0x7 == 0x1 (0x1) +__longlong 0x2 != 0x7 == 0x1 (0x1) +__ulonglong 0x2 != 0x7 == 0x1 (0x1) +float 0x2 != 0x7 == 0x1 (0x1) +int 0x2 >= 0x7 == 0x0 (0x0) +__uint 0x2 >= 0x7 == 0x0 (0x0) +char 0x2 >= 0x7 == 0x0 (0x0) +__uchar 0x2 >= 0x7 == 0x0 (0x0) +__longlong 0x2 >= 0x7 == 0x0 (0x0) +__ulonglong 0x2 >= 0x7 == 0x0 (0x0) +float 0x2 >= 0x7 == 0x0 (0x0) +int 0x2 / 0x7 == 0x0 (0x0) +__uint 0x2 / 0x7 == 0x0 (0x0) +char 0x2 / 0x7 == 0x0 (0x0) +__uchar 0x2 / 0x7 == 0x0 (0x0) +__longlong 0x2 / 0x7 == 0x0 (0x0) +__ulonglong 0x2 / 0x7 == 0x0 (0x0) +float 0x2 / 0x7 == 0x0 (0x0) +int 0x2 % 0x7 == 0x2 (0x2) +__uint 0x2 % 0x7 == 0x2 (0x2) +char 0x2 % 0x7 == 0x2 (0x2) +__uchar 0x2 % 0x7 == 0x2 (0x2) +__longlong 0x2 % 0x7 == 0x2 (0x2) +__ulonglong 0x2 % 0x7 == 0x2 (0x2) +0x2 * 0x2a == 0x54 +0x2 / 0x2a == 0x0 +0x2 % 0x2a == 0x2 +int 0x2 ^ 0x2a == 0x28 (0x28) +__uint 0x2 ^ 0x2a == 0x28 (0x28) +char 0x2 ^ 0x2a == 0x28 (0x28) +__uchar 0x2 ^ 0x2a == 0x28 (0x28) +__longlong 0x2 ^ 0x2a == 0x28 (0x28) +__ulonglong 0x2 ^ 0x2a == 0x28 (0x28) +int 0x2 && 0x2a == 0x1 (0x1) +__uint 0x2 && 0x2a == 0x1 (0x1) +char 0x2 && 0x2a == 0x1 (0x1) +__uchar 0x2 && 0x2a == 0x1 (0x1) +__longlong 0x2 && 0x2a == 0x1 (0x1) +__ulonglong 0x2 && 0x2a == 0x1 (0x1) +int 0x2 || 0x2a == 0x1 (0x1) +__uint 0x2 || 0x2a == 0x1 (0x1) +char 0x2 || 0x2a == 0x1 (0x1) +__uchar 0x2 || 0x2a == 0x1 (0x1) +__longlong 0x2 || 0x2a == 0x1 (0x1) +__ulonglong 0x2 || 0x2a == 0x1 (0x1) +int 0x2 & 0x2a == 0x2 (0x2) +__uint 0x2 & 0x2a == 0x2 (0x2) +char 0x2 & 0x2a == 0x2 (0x2) +__uchar 0x2 & 0x2a == 0x2 (0x2) +__longlong 0x2 & 0x2a == 0x2 (0x2) +__ulonglong 0x2 & 0x2a == 0x2 (0x2) +int 0x2 | 0x2a == 0x2a (0x2a) +__uint 0x2 | 0x2a == 0x2a (0x2a) +char 0x2 | 0x2a == 0x2a (0x2a) +__uchar 0x2 | 0x2a == 0x2a (0x2a) +__longlong 0x2 | 0x2a == 0x2a (0x2a) +__ulonglong 0x2 | 0x2a == 0x2a (0x2a) +int 0x2 << 0xc == 0x2000 (0x2000) +__uint 0x2 << 0xc == 0x2000 (0x2000) +char 0x2 << 0xc == 0x0 (0x0) +__uchar 0x2 << 0xc == 0x0 (0x0) +__longlong 0x2 << 0xc == 0x2000 (0x2000) +__ulonglong 0x2 << 0xc == 0x2000 (0x2000) +int 0x2 >> 0xc == 0x0 (0x0) +__uint 0x2 >> 0xc == 0x0 (0x0) +char 0x2 >> 0xc == 0x0 (0x0) +__uchar 0x2 >> 0xc == 0x0 (0x0) +__longlong 0x2 >> 0xc == 0x0 (0x0) +__ulonglong 0x2 >> 0xc == 0x0 (0x0) +int 0x2 + 0x2a == 0x2c (0x2c) +__uint 0x2 + 0x2a == 0x2c (0x2c) +char 0x2 + 0x2a == 0x2c (0x2c) +__uchar 0x2 + 0x2a == 0x2c (0x2c) +__longlong 0x2 + 0x2a == 0x2c (0x2c) +__ulonglong 0x2 + 0x2a == 0x2c (0x2c) +float 0x2 + 0x2a == 0x2c (0x2c) +int 0x2 - 0x2a == -0x28 (0xffd8) +__uint 0x2 - 0x2a == -0x28 (0xffd8) +char 0x2 - 0x2a == -0x28 (0xffd8) +__uchar 0x2 - 0x2a == 0xd8 (0xd8) +__longlong 0x2 - 0x2a == -0x28 (0xffd8) +__ulonglong 0x2 - 0x2a == -0x28 (0xffd8) +float 0x2 - 0x2a == -0x28 (0xffd8) +int 0x2 * 0x2a == 0x54 (0x54) +__uint 0x2 * 0x2a == 0x54 (0x54) +char 0x2 * 0x2a == 0x54 (0x54) +__uchar 0x2 * 0x2a == 0x54 (0x54) +__longlong 0x2 * 0x2a == 0x54 (0x54) +__ulonglong 0x2 * 0x2a == 0x54 (0x54) +float 0x2 * 0x2a == 0x54 (0x54) +int 0x2 < 0x2a == 0x1 (0x1) +__uint 0x2 < 0x2a == 0x1 (0x1) +char 0x2 < 0x2a == 0x1 (0x1) +__uchar 0x2 < 0x2a == 0x1 (0x1) +__longlong 0x2 < 0x2a == 0x1 (0x1) +__ulonglong 0x2 < 0x2a == 0x1 (0x1) +float 0x2 < 0x2a == 0x1 (0x1) +int 0x2 > 0x2a == 0x0 (0x0) +__uint 0x2 > 0x2a == 0x0 (0x0) +char 0x2 > 0x2a == 0x0 (0x0) +__uchar 0x2 > 0x2a == 0x0 (0x0) +__longlong 0x2 > 0x2a == 0x0 (0x0) +__ulonglong 0x2 > 0x2a == 0x0 (0x0) +float 0x2 > 0x2a == 0x0 (0x0) +int 0x2 <= 0x2a == 0x1 (0x1) +__uint 0x2 <= 0x2a == 0x1 (0x1) +char 0x2 <= 0x2a == 0x1 (0x1) +__uchar 0x2 <= 0x2a == 0x1 (0x1) +__longlong 0x2 <= 0x2a == 0x1 (0x1) +__ulonglong 0x2 <= 0x2a == 0x1 (0x1) +float 0x2 <= 0x2a == 0x1 (0x1) +int 0x2 == 0x2a == 0x0 (0x0) +__uint 0x2 == 0x2a == 0x0 (0x0) +char 0x2 == 0x2a == 0x0 (0x0) +__uchar 0x2 == 0x2a == 0x0 (0x0) +__longlong 0x2 == 0x2a == 0x0 (0x0) +__ulonglong 0x2 == 0x2a == 0x0 (0x0) +float 0x2 == 0x2a == 0x0 (0x0) +int 0x2 != 0x2a == 0x1 (0x1) +__uint 0x2 != 0x2a == 0x1 (0x1) +char 0x2 != 0x2a == 0x1 (0x1) +__uchar 0x2 != 0x2a == 0x1 (0x1) +__longlong 0x2 != 0x2a == 0x1 (0x1) +__ulonglong 0x2 != 0x2a == 0x1 (0x1) +float 0x2 != 0x2a == 0x1 (0x1) +int 0x2 >= 0x2a == 0x0 (0x0) +__uint 0x2 >= 0x2a == 0x0 (0x0) +char 0x2 >= 0x2a == 0x0 (0x0) +__uchar 0x2 >= 0x2a == 0x0 (0x0) +__longlong 0x2 >= 0x2a == 0x0 (0x0) +__ulonglong 0x2 >= 0x2a == 0x0 (0x0) +float 0x2 >= 0x2a == 0x0 (0x0) +int 0x2 / 0x2a == 0x0 (0x0) +__uint 0x2 / 0x2a == 0x0 (0x0) +char 0x2 / 0x2a == 0x0 (0x0) +__uchar 0x2 / 0x2a == 0x0 (0x0) +__longlong 0x2 / 0x2a == 0x0 (0x0) +__ulonglong 0x2 / 0x2a == 0x0 (0x0) +float 0x2 / 0x2a == 0x0 (0x0) +int 0x2 % 0x2a == 0x2 (0x2) +__uint 0x2 % 0x2a == 0x2 (0x2) +char 0x2 % 0x2a == 0x2 (0x2) +__uchar 0x2 % 0x2a == 0x2 (0x2) +__longlong 0x2 % 0x2a == 0x2 (0x2) +__ulonglong 0x2 % 0x2a == 0x2 (0x2) +0x2 * 0x17 == 0x2e +0x2 / 0x17 == 0x0 +0x2 % 0x17 == 0x2 +int 0x2 ^ 0x17 == 0x15 (0x15) +__uint 0x2 ^ 0x17 == 0x15 (0x15) +char 0x2 ^ 0x17 == 0x15 (0x15) +__uchar 0x2 ^ 0x17 == 0x15 (0x15) +__longlong 0x2 ^ 0x17 == 0x15 (0x15) +__ulonglong 0x2 ^ 0x17 == 0x15 (0x15) +int 0x2 && 0x17 == 0x1 (0x1) +__uint 0x2 && 0x17 == 0x1 (0x1) +char 0x2 && 0x17 == 0x1 (0x1) +__uchar 0x2 && 0x17 == 0x1 (0x1) +__longlong 0x2 && 0x17 == 0x1 (0x1) +__ulonglong 0x2 && 0x17 == 0x1 (0x1) +int 0x2 || 0x17 == 0x1 (0x1) +__uint 0x2 || 0x17 == 0x1 (0x1) +char 0x2 || 0x17 == 0x1 (0x1) +__uchar 0x2 || 0x17 == 0x1 (0x1) +__longlong 0x2 || 0x17 == 0x1 (0x1) +__ulonglong 0x2 || 0x17 == 0x1 (0x1) +int 0x2 & 0x17 == 0x2 (0x2) +__uint 0x2 & 0x17 == 0x2 (0x2) +char 0x2 & 0x17 == 0x2 (0x2) +__uchar 0x2 & 0x17 == 0x2 (0x2) +__longlong 0x2 & 0x17 == 0x2 (0x2) +__ulonglong 0x2 & 0x17 == 0x2 (0x2) +int 0x2 | 0x17 == 0x17 (0x17) +__uint 0x2 | 0x17 == 0x17 (0x17) +char 0x2 | 0x17 == 0x17 (0x17) +__uchar 0x2 | 0x17 == 0x17 (0x17) +__longlong 0x2 | 0x17 == 0x17 (0x17) +__ulonglong 0x2 | 0x17 == 0x17 (0x17) +int 0x2 << 0xe == -0x8000 (0x8000) +__uint 0x2 << 0xe == -0x8000 (0x8000) +char 0x2 << 0xe == 0x0 (0x0) +__uchar 0x2 << 0xe == 0x0 (0x0) +__longlong 0x2 << 0xe == -0x8000 (0x8000) +__ulonglong 0x2 << 0xe == -0x8000 (0x8000) +int 0x2 >> 0xe == 0x0 (0x0) +__uint 0x2 >> 0xe == 0x0 (0x0) +char 0x2 >> 0xe == 0x0 (0x0) +__uchar 0x2 >> 0xe == 0x0 (0x0) +__longlong 0x2 >> 0xe == 0x0 (0x0) +__ulonglong 0x2 >> 0xe == 0x0 (0x0) +int 0x2 + 0x17 == 0x19 (0x19) +__uint 0x2 + 0x17 == 0x19 (0x19) +char 0x2 + 0x17 == 0x19 (0x19) +__uchar 0x2 + 0x17 == 0x19 (0x19) +__longlong 0x2 + 0x17 == 0x19 (0x19) +__ulonglong 0x2 + 0x17 == 0x19 (0x19) +float 0x2 + 0x17 == 0x19 (0x19) +int 0x2 - 0x17 == -0x15 (0xffeb) +__uint 0x2 - 0x17 == -0x15 (0xffeb) +char 0x2 - 0x17 == -0x15 (0xffeb) +__uchar 0x2 - 0x17 == 0xeb (0xeb) +__longlong 0x2 - 0x17 == -0x15 (0xffeb) +__ulonglong 0x2 - 0x17 == -0x15 (0xffeb) +float 0x2 - 0x17 == -0x15 (0xffeb) +int 0x2 * 0x17 == 0x2e (0x2e) +__uint 0x2 * 0x17 == 0x2e (0x2e) +char 0x2 * 0x17 == 0x2e (0x2e) +__uchar 0x2 * 0x17 == 0x2e (0x2e) +__longlong 0x2 * 0x17 == 0x2e (0x2e) +__ulonglong 0x2 * 0x17 == 0x2e (0x2e) +float 0x2 * 0x17 == 0x2e (0x2e) +int 0x2 < 0x17 == 0x1 (0x1) +__uint 0x2 < 0x17 == 0x1 (0x1) +char 0x2 < 0x17 == 0x1 (0x1) +__uchar 0x2 < 0x17 == 0x1 (0x1) +__longlong 0x2 < 0x17 == 0x1 (0x1) +__ulonglong 0x2 < 0x17 == 0x1 (0x1) +float 0x2 < 0x17 == 0x1 (0x1) +int 0x2 > 0x17 == 0x0 (0x0) +__uint 0x2 > 0x17 == 0x0 (0x0) +char 0x2 > 0x17 == 0x0 (0x0) +__uchar 0x2 > 0x17 == 0x0 (0x0) +__longlong 0x2 > 0x17 == 0x0 (0x0) +__ulonglong 0x2 > 0x17 == 0x0 (0x0) +float 0x2 > 0x17 == 0x0 (0x0) +int 0x2 <= 0x17 == 0x1 (0x1) +__uint 0x2 <= 0x17 == 0x1 (0x1) +char 0x2 <= 0x17 == 0x1 (0x1) +__uchar 0x2 <= 0x17 == 0x1 (0x1) +__longlong 0x2 <= 0x17 == 0x1 (0x1) +__ulonglong 0x2 <= 0x17 == 0x1 (0x1) +float 0x2 <= 0x17 == 0x1 (0x1) +int 0x2 == 0x17 == 0x0 (0x0) +__uint 0x2 == 0x17 == 0x0 (0x0) +char 0x2 == 0x17 == 0x0 (0x0) +__uchar 0x2 == 0x17 == 0x0 (0x0) +__longlong 0x2 == 0x17 == 0x0 (0x0) +__ulonglong 0x2 == 0x17 == 0x0 (0x0) +float 0x2 == 0x17 == 0x0 (0x0) +int 0x2 != 0x17 == 0x1 (0x1) +__uint 0x2 != 0x17 == 0x1 (0x1) +char 0x2 != 0x17 == 0x1 (0x1) +__uchar 0x2 != 0x17 == 0x1 (0x1) +__longlong 0x2 != 0x17 == 0x1 (0x1) +__ulonglong 0x2 != 0x17 == 0x1 (0x1) +float 0x2 != 0x17 == 0x1 (0x1) +int 0x2 >= 0x17 == 0x0 (0x0) +__uint 0x2 >= 0x17 == 0x0 (0x0) +char 0x2 >= 0x17 == 0x0 (0x0) +__uchar 0x2 >= 0x17 == 0x0 (0x0) +__longlong 0x2 >= 0x17 == 0x0 (0x0) +__ulonglong 0x2 >= 0x17 == 0x0 (0x0) +float 0x2 >= 0x17 == 0x0 (0x0) +int 0x2 / 0x17 == 0x0 (0x0) +__uint 0x2 / 0x17 == 0x0 (0x0) +char 0x2 / 0x17 == 0x0 (0x0) +__uchar 0x2 / 0x17 == 0x0 (0x0) +__longlong 0x2 / 0x17 == 0x0 (0x0) +__ulonglong 0x2 / 0x17 == 0x0 (0x0) +float 0x2 / 0x17 == 0x0 (0x0) +int 0x2 % 0x17 == 0x2 (0x2) +__uint 0x2 % 0x17 == 0x2 (0x2) +char 0x2 % 0x17 == 0x2 (0x2) +__uchar 0x2 % 0x17 == 0x2 (0x2) +__longlong 0x2 % 0x17 == 0x2 (0x2) +__ulonglong 0x2 % 0x17 == 0x2 (0x2) +0x2 * 0x7fff == -0x2 +0x2 / 0x7fff == 0x0 +0x2 % 0x7fff == 0x2 +int 0x2 ^ 0x7fff == 0x7ffd (0x7ffd) +__uint 0x2 ^ 0x7fff == 0x7ffd (0x7ffd) +char 0x2 ^ 0xffff == -0x3 (0xfffd) +__uchar 0x2 ^ 0xff == 0xfd (0xfd) +__longlong 0x2 ^ 0x7fff == 0x7ffd (0x7ffd) +__ulonglong 0x2 ^ 0x7fff == 0x7ffd (0x7ffd) +int 0x2 && 0x7fff == 0x1 (0x1) +__uint 0x2 && 0x7fff == 0x1 (0x1) +char 0x2 && 0xffff == 0x1 (0x1) +__uchar 0x2 && 0xff == 0x1 (0x1) +__longlong 0x2 && 0x7fff == 0x1 (0x1) +__ulonglong 0x2 && 0x7fff == 0x1 (0x1) +int 0x2 || 0x7fff == 0x1 (0x1) +__uint 0x2 || 0x7fff == 0x1 (0x1) +char 0x2 || 0xffff == 0x1 (0x1) +__uchar 0x2 || 0xff == 0x1 (0x1) +__longlong 0x2 || 0x7fff == 0x1 (0x1) +__ulonglong 0x2 || 0x7fff == 0x1 (0x1) +int 0x2 & 0x7fff == 0x2 (0x2) +__uint 0x2 & 0x7fff == 0x2 (0x2) +char 0x2 & 0xffff == 0x2 (0x2) +__uchar 0x2 & 0xff == 0x2 (0x2) +__longlong 0x2 & 0x7fff == 0x2 (0x2) +__ulonglong 0x2 & 0x7fff == 0x2 (0x2) +int 0x2 | 0x7fff == 0x7fff (0x7fff) +__uint 0x2 | 0x7fff == 0x7fff (0x7fff) +char 0x2 | 0xffff == -0x1 (0xffff) +__uchar 0x2 | 0xff == 0xff (0xff) +__longlong 0x2 | 0x7fff == 0x7fff (0x7fff) +__ulonglong 0x2 | 0x7fff == 0x7fff (0x7fff) +int 0x2 << 0x10 == 0x0 (0x0) +__uint 0x2 << 0x10 == 0x0 (0x0) +char 0x2 << 0x10 == 0x0 (0x0) +__uchar 0x2 << 0x10 == 0x0 (0x0) +__longlong 0x2 << 0x10 == 0x0 (0x0) +__ulonglong 0x2 << 0x10 == 0x0 (0x0) +int 0x2 >> 0x10 == 0x0 (0x0) +__uint 0x2 >> 0x10 == 0x0 (0x0) +char 0x2 >> 0x10 == 0x0 (0x0) +__uchar 0x2 >> 0x10 == 0x0 (0x0) +__longlong 0x2 >> 0x10 == 0x0 (0x0) +__ulonglong 0x2 >> 0x10 == 0x0 (0x0) +int 0x2 + 0x7fff == -0x7fff (0x8001) +__uint 0x2 + 0x7fff == -0x7fff (0x8001) +char 0x2 + 0xffff == 0x1 (0x1) +__uchar 0x2 + 0xff == 0x1 (0x1) +__longlong 0x2 + 0x7fff == -0x7fff (0x8001) +__ulonglong 0x2 + 0x7fff == -0x7fff (0x8001) +float 0x2 + 0x7fff == -0x8000 (0x8000) +int 0x2 - 0x7fff == -0x7ffd (0x8003) +__uint 0x2 - 0x7fff == -0x7ffd (0x8003) +char 0x2 - 0xffff == 0x3 (0x3) +__uchar 0x2 - 0xff == 0x3 (0x3) +__longlong 0x2 - 0x7fff == -0x7ffd (0x8003) +__ulonglong 0x2 - 0x7fff == -0x7ffd (0x8003) +float 0x2 - 0x7fff == -0x7ffd (0x8003) +int 0x2 * 0x7fff == -0x2 (0xfffe) +__uint 0x2 * 0x7fff == -0x2 (0xfffe) +char 0x2 * 0xffff == -0x2 (0xfffe) +__uchar 0x2 * 0xff == 0xfe (0xfe) +__longlong 0x2 * 0x7fff == -0x2 (0xfffe) +__ulonglong 0x2 * 0x7fff == -0x2 (0xfffe) +float 0x2 * 0x7fff == -0x8000 (0x8000) +int 0x2 < 0x7fff == 0x1 (0x1) +__uint 0x2 < 0x7fff == 0x1 (0x1) +char 0x2 < 0xffff == 0x0 (0x0) +__uchar 0x2 < 0xff == 0x1 (0x1) +__longlong 0x2 < 0x7fff == 0x1 (0x1) +__ulonglong 0x2 < 0x7fff == 0x1 (0x1) +float 0x2 < 0x7fff == 0x1 (0x1) +int 0x2 > 0x7fff == 0x0 (0x0) +__uint 0x2 > 0x7fff == 0x0 (0x0) +char 0x2 > 0xffff == 0x1 (0x1) +__uchar 0x2 > 0xff == 0x0 (0x0) +__longlong 0x2 > 0x7fff == 0x0 (0x0) +__ulonglong 0x2 > 0x7fff == 0x0 (0x0) +float 0x2 > 0x7fff == 0x0 (0x0) +int 0x2 <= 0x7fff == 0x1 (0x1) +__uint 0x2 <= 0x7fff == 0x1 (0x1) +char 0x2 <= 0xffff == 0x0 (0x0) +__uchar 0x2 <= 0xff == 0x1 (0x1) +__longlong 0x2 <= 0x7fff == 0x1 (0x1) +__ulonglong 0x2 <= 0x7fff == 0x1 (0x1) +float 0x2 <= 0x7fff == 0x1 (0x1) +int 0x2 == 0x7fff == 0x0 (0x0) +__uint 0x2 == 0x7fff == 0x0 (0x0) +char 0x2 == 0xffff == 0x0 (0x0) +__uchar 0x2 == 0xff == 0x0 (0x0) +__longlong 0x2 == 0x7fff == 0x0 (0x0) +__ulonglong 0x2 == 0x7fff == 0x0 (0x0) +float 0x2 == 0x7fff == 0x0 (0x0) +int 0x2 != 0x7fff == 0x1 (0x1) +__uint 0x2 != 0x7fff == 0x1 (0x1) +char 0x2 != 0xffff == 0x1 (0x1) +__uchar 0x2 != 0xff == 0x1 (0x1) +__longlong 0x2 != 0x7fff == 0x1 (0x1) +__ulonglong 0x2 != 0x7fff == 0x1 (0x1) +float 0x2 != 0x7fff == 0x1 (0x1) +int 0x2 >= 0x7fff == 0x0 (0x0) +__uint 0x2 >= 0x7fff == 0x0 (0x0) +char 0x2 >= 0xffff == 0x1 (0x1) +__uchar 0x2 >= 0xff == 0x0 (0x0) +__longlong 0x2 >= 0x7fff == 0x0 (0x0) +__ulonglong 0x2 >= 0x7fff == 0x0 (0x0) +float 0x2 >= 0x7fff == 0x0 (0x0) +int 0x2 / 0x7fff == 0x0 (0x0) +__uint 0x2 / 0x7fff == 0x0 (0x0) +char 0x2 / 0xffff == -0x2 (0xfffe) +__uchar 0x2 / 0xff == 0x0 (0x0) +__longlong 0x2 / 0x7fff == 0x0 (0x0) +__ulonglong 0x2 / 0x7fff == 0x0 (0x0) +float 0x2 / 0x7fff == 0x0 (0x0) +int 0x2 % 0x7fff == 0x2 (0x2) +__uint 0x2 % 0x7fff == 0x2 (0x2) +char 0x2 % 0xffff == 0x0 (0x0) +__uchar 0x2 % 0xff == 0x2 (0x2) +__longlong 0x2 % 0x7fff == 0x2 (0x2) +__ulonglong 0x2 % 0x7fff == 0x2 (0x2) +0x2 * 0x8000 == 0x0 +0x2 / 0x8000 == 0x0 +0x2 % 0x8000 == 0x2 +int 0x2 ^ 0x8000 == -0x7ffe (0x8002) +__uint 0x2 ^ 0x8000 == -0x7ffe (0x8002) +char 0x2 ^ 0x0 == 0x2 (0x2) +__uchar 0x2 ^ 0x0 == 0x2 (0x2) +__longlong 0x2 ^ 0x8000 == -0x7ffe (0x8002) +__ulonglong 0x2 ^ 0x8000 == -0x7ffe (0x8002) +int 0x2 && 0x8000 == 0x1 (0x1) +__uint 0x2 && 0x8000 == 0x1 (0x1) +char 0x2 && 0x0 == 0x0 (0x0) +__uchar 0x2 && 0x0 == 0x0 (0x0) +__longlong 0x2 && 0x8000 == 0x1 (0x1) +__ulonglong 0x2 && 0x8000 == 0x1 (0x1) +int 0x2 || 0x8000 == 0x1 (0x1) +__uint 0x2 || 0x8000 == 0x1 (0x1) +char 0x2 || 0x0 == 0x1 (0x1) +__uchar 0x2 || 0x0 == 0x1 (0x1) +__longlong 0x2 || 0x8000 == 0x1 (0x1) +__ulonglong 0x2 || 0x8000 == 0x1 (0x1) +int 0x2 & 0x8000 == 0x0 (0x0) +__uint 0x2 & 0x8000 == 0x0 (0x0) +char 0x2 & 0x0 == 0x0 (0x0) +__uchar 0x2 & 0x0 == 0x0 (0x0) +__longlong 0x2 & 0x8000 == 0x0 (0x0) +__ulonglong 0x2 & 0x8000 == 0x0 (0x0) +int 0x2 | 0x8000 == -0x7ffe (0x8002) +__uint 0x2 | 0x8000 == -0x7ffe (0x8002) +char 0x2 | 0x0 == 0x2 (0x2) +__uchar 0x2 | 0x0 == 0x2 (0x2) +__longlong 0x2 | 0x8000 == -0x7ffe (0x8002) +__ulonglong 0x2 | 0x8000 == -0x7ffe (0x8002) +int 0x2 << 0x12 == 0x0 (0x0) +__uint 0x2 << 0x12 == 0x0 (0x0) +char 0x2 << 0x12 == 0x0 (0x0) +__uchar 0x2 << 0x12 == 0x0 (0x0) +__longlong 0x2 << 0x12 == 0x0 (0x0) +__ulonglong 0x2 << 0x12 == 0x0 (0x0) +int 0x2 >> 0x12 == 0x0 (0x0) +__uint 0x2 >> 0x12 == 0x0 (0x0) +char 0x2 >> 0x12 == 0x0 (0x0) +__uchar 0x2 >> 0x12 == 0x0 (0x0) +__longlong 0x2 >> 0x12 == 0x0 (0x0) +__ulonglong 0x2 >> 0x12 == 0x0 (0x0) +int 0x2 + 0x8000 == -0x7ffe (0x8002) +__uint 0x2 + 0x8000 == -0x7ffe (0x8002) +char 0x2 + 0x0 == 0x2 (0x2) +__uchar 0x2 + 0x0 == 0x2 (0x2) +__longlong 0x2 + 0x8000 == -0x7ffe (0x8002) +__ulonglong 0x2 + 0x8000 == -0x7ffe (0x8002) +float 0x2 + 0x8000 == -0x7ffe (0x8002) +int 0x2 - 0x8000 == -0x7ffe (0x8002) +__uint 0x2 - 0x8000 == -0x7ffe (0x8002) +char 0x2 - 0x0 == 0x2 (0x2) +__uchar 0x2 - 0x0 == 0x2 (0x2) +__longlong 0x2 - 0x8000 == -0x7ffe (0x8002) +__ulonglong 0x2 - 0x8000 == -0x7ffe (0x8002) +float 0x2 - 0x8000 == -0x8000 (0x8000) +int 0x2 * 0x8000 == 0x0 (0x0) +__uint 0x2 * 0x8000 == 0x0 (0x0) +char 0x2 * 0x0 == 0x0 (0x0) +__uchar 0x2 * 0x0 == 0x0 (0x0) +__longlong 0x2 * 0x8000 == 0x0 (0x0) +__ulonglong 0x2 * 0x8000 == 0x0 (0x0) +float 0x2 * 0x8000 == -0x8000 (0x8000) +int 0x2 < 0x8000 == 0x0 (0x0) +__uint 0x2 < 0x8000 == 0x1 (0x1) +char 0x2 < 0x0 == 0x0 (0x0) +__uchar 0x2 < 0x0 == 0x0 (0x0) +__longlong 0x2 < 0x8000 == 0x0 (0x0) +__ulonglong 0x2 < 0x8000 == 0x1 (0x1) +float 0x2 < 0x8000 == 0x0 (0x0) +int 0x2 > 0x8000 == 0x1 (0x1) +__uint 0x2 > 0x8000 == 0x0 (0x0) +char 0x2 > 0x0 == 0x1 (0x1) +__uchar 0x2 > 0x0 == 0x1 (0x1) +__longlong 0x2 > 0x8000 == 0x1 (0x1) +__ulonglong 0x2 > 0x8000 == 0x0 (0x0) +float 0x2 > 0x8000 == 0x1 (0x1) +int 0x2 <= 0x8000 == 0x0 (0x0) +__uint 0x2 <= 0x8000 == 0x1 (0x1) +char 0x2 <= 0x0 == 0x0 (0x0) +__uchar 0x2 <= 0x0 == 0x0 (0x0) +__longlong 0x2 <= 0x8000 == 0x0 (0x0) +__ulonglong 0x2 <= 0x8000 == 0x1 (0x1) +float 0x2 <= 0x8000 == 0x0 (0x0) +int 0x2 == 0x8000 == 0x0 (0x0) +__uint 0x2 == 0x8000 == 0x0 (0x0) +char 0x2 == 0x0 == 0x0 (0x0) +__uchar 0x2 == 0x0 == 0x0 (0x0) +__longlong 0x2 == 0x8000 == 0x0 (0x0) +__ulonglong 0x2 == 0x8000 == 0x0 (0x0) +float 0x2 == 0x8000 == 0x0 (0x0) +int 0x2 != 0x8000 == 0x1 (0x1) +__uint 0x2 != 0x8000 == 0x1 (0x1) +char 0x2 != 0x0 == 0x1 (0x1) +__uchar 0x2 != 0x0 == 0x1 (0x1) +__longlong 0x2 != 0x8000 == 0x1 (0x1) +__ulonglong 0x2 != 0x8000 == 0x1 (0x1) +float 0x2 != 0x8000 == 0x1 (0x1) +int 0x2 >= 0x8000 == 0x1 (0x1) +__uint 0x2 >= 0x8000 == 0x0 (0x0) +char 0x2 >= 0x0 == 0x1 (0x1) +__uchar 0x2 >= 0x0 == 0x1 (0x1) +__longlong 0x2 >= 0x8000 == 0x1 (0x1) +__ulonglong 0x2 >= 0x8000 == 0x0 (0x0) +float 0x2 >= 0x8000 == 0x1 (0x1) +int 0x2 / 0x8000 == 0x0 (0x0) +__uint 0x2 / 0x8000 == 0x0 (0x0) +__longlong 0x2 / 0x8000 == 0x0 (0x0) +__ulonglong 0x2 / 0x8000 == 0x0 (0x0) +float 0x2 / 0x8000 == 0x0 (0x0) +int 0x2 % 0x8000 == 0x2 (0x2) +__uint 0x2 % 0x8000 == 0x2 (0x2) +__longlong 0x2 % 0x8000 == 0x2 (0x2) +__ulonglong 0x2 % 0x8000 == 0x2 (0x2) +0x2 * 0x3e8 == 0x7d0 +0x2 / 0x3e8 == 0x0 +0x2 % 0x3e8 == 0x2 +int 0x2 ^ 0x3e8 == 0x3ea (0x3ea) +__uint 0x2 ^ 0x3e8 == 0x3ea (0x3ea) +char 0x2 ^ 0xffe8 == -0x16 (0xffea) +__uchar 0x2 ^ 0xe8 == 0xea (0xea) +__longlong 0x2 ^ 0x3e8 == 0x3ea (0x3ea) +__ulonglong 0x2 ^ 0x3e8 == 0x3ea (0x3ea) +int 0x2 && 0x3e8 == 0x1 (0x1) +__uint 0x2 && 0x3e8 == 0x1 (0x1) +char 0x2 && 0xffe8 == 0x1 (0x1) +__uchar 0x2 && 0xe8 == 0x1 (0x1) +__longlong 0x2 && 0x3e8 == 0x1 (0x1) +__ulonglong 0x2 && 0x3e8 == 0x1 (0x1) +int 0x2 || 0x3e8 == 0x1 (0x1) +__uint 0x2 || 0x3e8 == 0x1 (0x1) +char 0x2 || 0xffe8 == 0x1 (0x1) +__uchar 0x2 || 0xe8 == 0x1 (0x1) +__longlong 0x2 || 0x3e8 == 0x1 (0x1) +__ulonglong 0x2 || 0x3e8 == 0x1 (0x1) +int 0x2 & 0x3e8 == 0x0 (0x0) +__uint 0x2 & 0x3e8 == 0x0 (0x0) +char 0x2 & 0xffe8 == 0x0 (0x0) +__uchar 0x2 & 0xe8 == 0x0 (0x0) +__longlong 0x2 & 0x3e8 == 0x0 (0x0) +__ulonglong 0x2 & 0x3e8 == 0x0 (0x0) +int 0x2 | 0x3e8 == 0x3ea (0x3ea) +__uint 0x2 | 0x3e8 == 0x3ea (0x3ea) +char 0x2 | 0xffe8 == -0x16 (0xffea) +__uchar 0x2 | 0xe8 == 0xea (0xea) +__longlong 0x2 | 0x3e8 == 0x3ea (0x3ea) +__ulonglong 0x2 | 0x3e8 == 0x3ea (0x3ea) +int 0x2 << 0x14 == 0x0 (0x0) +__uint 0x2 << 0x14 == 0x0 (0x0) +char 0x2 << 0x14 == 0x0 (0x0) +__uchar 0x2 << 0x14 == 0x0 (0x0) +__longlong 0x2 << 0x14 == 0x0 (0x0) +__ulonglong 0x2 << 0x14 == 0x0 (0x0) +int 0x2 >> 0x14 == 0x0 (0x0) +__uint 0x2 >> 0x14 == 0x0 (0x0) +char 0x2 >> 0x14 == 0x0 (0x0) +__uchar 0x2 >> 0x14 == 0x0 (0x0) +__longlong 0x2 >> 0x14 == 0x0 (0x0) +__ulonglong 0x2 >> 0x14 == 0x0 (0x0) +int 0x2 + 0x3e8 == 0x3ea (0x3ea) +__uint 0x2 + 0x3e8 == 0x3ea (0x3ea) +char 0x2 + 0xffe8 == -0x16 (0xffea) +__uchar 0x2 + 0xe8 == 0xea (0xea) +__longlong 0x2 + 0x3e8 == 0x3ea (0x3ea) +__ulonglong 0x2 + 0x3e8 == 0x3ea (0x3ea) +float 0x2 + 0x3e8 == 0x3ea (0x3ea) +int 0x2 - 0x3e8 == -0x3e6 (0xfc1a) +__uint 0x2 - 0x3e8 == -0x3e6 (0xfc1a) +char 0x2 - 0xffe8 == 0x1a (0x1a) +__uchar 0x2 - 0xe8 == 0x1a (0x1a) +__longlong 0x2 - 0x3e8 == -0x3e6 (0xfc1a) +__ulonglong 0x2 - 0x3e8 == -0x3e6 (0xfc1a) +float 0x2 - 0x3e8 == -0x3e6 (0xfc1a) +int 0x2 * 0x3e8 == 0x7d0 (0x7d0) +__uint 0x2 * 0x3e8 == 0x7d0 (0x7d0) +char 0x2 * 0xffe8 == -0x30 (0xffd0) +__uchar 0x2 * 0xe8 == 0xd0 (0xd0) +__longlong 0x2 * 0x3e8 == 0x7d0 (0x7d0) +__ulonglong 0x2 * 0x3e8 == 0x7d0 (0x7d0) +float 0x2 * 0x3e8 == 0x7d0 (0x7d0) +int 0x2 < 0x3e8 == 0x1 (0x1) +__uint 0x2 < 0x3e8 == 0x1 (0x1) +char 0x2 < 0xffe8 == 0x0 (0x0) +__uchar 0x2 < 0xe8 == 0x1 (0x1) +__longlong 0x2 < 0x3e8 == 0x1 (0x1) +__ulonglong 0x2 < 0x3e8 == 0x1 (0x1) +float 0x2 < 0x3e8 == 0x1 (0x1) +int 0x2 > 0x3e8 == 0x0 (0x0) +__uint 0x2 > 0x3e8 == 0x0 (0x0) +char 0x2 > 0xffe8 == 0x1 (0x1) +__uchar 0x2 > 0xe8 == 0x0 (0x0) +__longlong 0x2 > 0x3e8 == 0x0 (0x0) +__ulonglong 0x2 > 0x3e8 == 0x0 (0x0) +float 0x2 > 0x3e8 == 0x0 (0x0) +int 0x2 <= 0x3e8 == 0x1 (0x1) +__uint 0x2 <= 0x3e8 == 0x1 (0x1) +char 0x2 <= 0xffe8 == 0x0 (0x0) +__uchar 0x2 <= 0xe8 == 0x1 (0x1) +__longlong 0x2 <= 0x3e8 == 0x1 (0x1) +__ulonglong 0x2 <= 0x3e8 == 0x1 (0x1) +float 0x2 <= 0x3e8 == 0x1 (0x1) +int 0x2 == 0x3e8 == 0x0 (0x0) +__uint 0x2 == 0x3e8 == 0x0 (0x0) +char 0x2 == 0xffe8 == 0x0 (0x0) +__uchar 0x2 == 0xe8 == 0x0 (0x0) +__longlong 0x2 == 0x3e8 == 0x0 (0x0) +__ulonglong 0x2 == 0x3e8 == 0x0 (0x0) +float 0x2 == 0x3e8 == 0x0 (0x0) +int 0x2 != 0x3e8 == 0x1 (0x1) +__uint 0x2 != 0x3e8 == 0x1 (0x1) +char 0x2 != 0xffe8 == 0x1 (0x1) +__uchar 0x2 != 0xe8 == 0x1 (0x1) +__longlong 0x2 != 0x3e8 == 0x1 (0x1) +__ulonglong 0x2 != 0x3e8 == 0x1 (0x1) +float 0x2 != 0x3e8 == 0x1 (0x1) +int 0x2 >= 0x3e8 == 0x0 (0x0) +__uint 0x2 >= 0x3e8 == 0x0 (0x0) +char 0x2 >= 0xffe8 == 0x1 (0x1) +__uchar 0x2 >= 0xe8 == 0x0 (0x0) +__longlong 0x2 >= 0x3e8 == 0x0 (0x0) +__ulonglong 0x2 >= 0x3e8 == 0x0 (0x0) +float 0x2 >= 0x3e8 == 0x0 (0x0) +int 0x2 / 0x3e8 == 0x0 (0x0) +__uint 0x2 / 0x3e8 == 0x0 (0x0) +char 0x2 / 0xffe8 == 0x0 (0x0) +__uchar 0x2 / 0xe8 == 0x0 (0x0) +__longlong 0x2 / 0x3e8 == 0x0 (0x0) +__ulonglong 0x2 / 0x3e8 == 0x0 (0x0) +float 0x2 / 0x3e8 == 0x0 (0x0) +int 0x2 % 0x3e8 == 0x2 (0x2) +__uint 0x2 % 0x3e8 == 0x2 (0x2) +char 0x2 % 0xffe8 == 0x2 (0x2) +__uchar 0x2 % 0xe8 == 0x2 (0x2) +__longlong 0x2 % 0x3e8 == 0x2 (0x2) +__ulonglong 0x2 % 0x3e8 == 0x2 (0x2) +0x2 * 0x2710 == 0x4e20 +0x2 / 0x2710 == 0x0 +0x2 % 0x2710 == 0x2 +int 0x2 ^ 0x2710 == 0x2712 (0x2712) +__uint 0x2 ^ 0x2710 == 0x2712 (0x2712) +char 0x2 ^ 0x10 == 0x12 (0x12) +__uchar 0x2 ^ 0x10 == 0x12 (0x12) +__longlong 0x2 ^ 0x2710 == 0x2712 (0x2712) +__ulonglong 0x2 ^ 0x2710 == 0x2712 (0x2712) +int 0x2 && 0x2710 == 0x1 (0x1) +__uint 0x2 && 0x2710 == 0x1 (0x1) +char 0x2 && 0x10 == 0x1 (0x1) +__uchar 0x2 && 0x10 == 0x1 (0x1) +__longlong 0x2 && 0x2710 == 0x1 (0x1) +__ulonglong 0x2 && 0x2710 == 0x1 (0x1) +int 0x2 || 0x2710 == 0x1 (0x1) +__uint 0x2 || 0x2710 == 0x1 (0x1) +char 0x2 || 0x10 == 0x1 (0x1) +__uchar 0x2 || 0x10 == 0x1 (0x1) +__longlong 0x2 || 0x2710 == 0x1 (0x1) +__ulonglong 0x2 || 0x2710 == 0x1 (0x1) +int 0x2 & 0x2710 == 0x0 (0x0) +__uint 0x2 & 0x2710 == 0x0 (0x0) +char 0x2 & 0x10 == 0x0 (0x0) +__uchar 0x2 & 0x10 == 0x0 (0x0) +__longlong 0x2 & 0x2710 == 0x0 (0x0) +__ulonglong 0x2 & 0x2710 == 0x0 (0x0) +int 0x2 | 0x2710 == 0x2712 (0x2712) +__uint 0x2 | 0x2710 == 0x2712 (0x2712) +char 0x2 | 0x10 == 0x12 (0x12) +__uchar 0x2 | 0x10 == 0x12 (0x12) +__longlong 0x2 | 0x2710 == 0x2712 (0x2712) +__ulonglong 0x2 | 0x2710 == 0x2712 (0x2712) +int 0x2 << 0x16 == 0x0 (0x0) +__uint 0x2 << 0x16 == 0x0 (0x0) +char 0x2 << 0x16 == 0x0 (0x0) +__uchar 0x2 << 0x16 == 0x0 (0x0) +__longlong 0x2 << 0x16 == 0x0 (0x0) +__ulonglong 0x2 << 0x16 == 0x0 (0x0) +int 0x2 >> 0x16 == 0x0 (0x0) +__uint 0x2 >> 0x16 == 0x0 (0x0) +char 0x2 >> 0x16 == 0x0 (0x0) +__uchar 0x2 >> 0x16 == 0x0 (0x0) +__longlong 0x2 >> 0x16 == 0x0 (0x0) +__ulonglong 0x2 >> 0x16 == 0x0 (0x0) +int 0x2 + 0x2710 == 0x2712 (0x2712) +__uint 0x2 + 0x2710 == 0x2712 (0x2712) +char 0x2 + 0x10 == 0x12 (0x12) +__uchar 0x2 + 0x10 == 0x12 (0x12) +__longlong 0x2 + 0x2710 == 0x2712 (0x2712) +__ulonglong 0x2 + 0x2710 == 0x2712 (0x2712) +float 0x2 + 0x2710 == 0x2712 (0x2712) +int 0x2 - 0x2710 == -0x270e (0xd8f2) +__uint 0x2 - 0x2710 == -0x270e (0xd8f2) +char 0x2 - 0x10 == -0xe (0xfff2) +__uchar 0x2 - 0x10 == 0xf2 (0xf2) +__longlong 0x2 - 0x2710 == -0x270e (0xd8f2) +__ulonglong 0x2 - 0x2710 == -0x270e (0xd8f2) +float 0x2 - 0x2710 == -0x270e (0xd8f2) +int 0x2 * 0x2710 == 0x4e20 (0x4e20) +__uint 0x2 * 0x2710 == 0x4e20 (0x4e20) +char 0x2 * 0x10 == 0x20 (0x20) +__uchar 0x2 * 0x10 == 0x20 (0x20) +__longlong 0x2 * 0x2710 == 0x4e20 (0x4e20) +__ulonglong 0x2 * 0x2710 == 0x4e20 (0x4e20) +float 0x2 * 0x2710 == 0x4e20 (0x4e20) +int 0x2 < 0x2710 == 0x1 (0x1) +__uint 0x2 < 0x2710 == 0x1 (0x1) +char 0x2 < 0x10 == 0x1 (0x1) +__uchar 0x2 < 0x10 == 0x1 (0x1) +__longlong 0x2 < 0x2710 == 0x1 (0x1) +__ulonglong 0x2 < 0x2710 == 0x1 (0x1) +float 0x2 < 0x2710 == 0x1 (0x1) +int 0x2 > 0x2710 == 0x0 (0x0) +__uint 0x2 > 0x2710 == 0x0 (0x0) +char 0x2 > 0x10 == 0x0 (0x0) +__uchar 0x2 > 0x10 == 0x0 (0x0) +__longlong 0x2 > 0x2710 == 0x0 (0x0) +__ulonglong 0x2 > 0x2710 == 0x0 (0x0) +float 0x2 > 0x2710 == 0x0 (0x0) +int 0x2 <= 0x2710 == 0x1 (0x1) +__uint 0x2 <= 0x2710 == 0x1 (0x1) +char 0x2 <= 0x10 == 0x1 (0x1) +__uchar 0x2 <= 0x10 == 0x1 (0x1) +__longlong 0x2 <= 0x2710 == 0x1 (0x1) +__ulonglong 0x2 <= 0x2710 == 0x1 (0x1) +float 0x2 <= 0x2710 == 0x1 (0x1) +int 0x2 == 0x2710 == 0x0 (0x0) +__uint 0x2 == 0x2710 == 0x0 (0x0) +char 0x2 == 0x10 == 0x0 (0x0) +__uchar 0x2 == 0x10 == 0x0 (0x0) +__longlong 0x2 == 0x2710 == 0x0 (0x0) +__ulonglong 0x2 == 0x2710 == 0x0 (0x0) +float 0x2 == 0x2710 == 0x0 (0x0) +int 0x2 != 0x2710 == 0x1 (0x1) +__uint 0x2 != 0x2710 == 0x1 (0x1) +char 0x2 != 0x10 == 0x1 (0x1) +__uchar 0x2 != 0x10 == 0x1 (0x1) +__longlong 0x2 != 0x2710 == 0x1 (0x1) +__ulonglong 0x2 != 0x2710 == 0x1 (0x1) +float 0x2 != 0x2710 == 0x1 (0x1) +int 0x2 >= 0x2710 == 0x0 (0x0) +__uint 0x2 >= 0x2710 == 0x0 (0x0) +char 0x2 >= 0x10 == 0x0 (0x0) +__uchar 0x2 >= 0x10 == 0x0 (0x0) +__longlong 0x2 >= 0x2710 == 0x0 (0x0) +__ulonglong 0x2 >= 0x2710 == 0x0 (0x0) +float 0x2 >= 0x2710 == 0x0 (0x0) +int 0x2 / 0x2710 == 0x0 (0x0) +__uint 0x2 / 0x2710 == 0x0 (0x0) +char 0x2 / 0x10 == 0x0 (0x0) +__uchar 0x2 / 0x10 == 0x0 (0x0) +__longlong 0x2 / 0x2710 == 0x0 (0x0) +__ulonglong 0x2 / 0x2710 == 0x0 (0x0) +float 0x2 / 0x2710 == 0x0 (0x0) +int 0x2 % 0x2710 == 0x2 (0x2) +__uint 0x2 % 0x2710 == 0x2 (0x2) +char 0x2 % 0x10 == 0x2 (0x2) +__uchar 0x2 % 0x10 == 0x2 (0x2) +__longlong 0x2 % 0x2710 == 0x2 (0x2) +__ulonglong 0x2 % 0x2710 == 0x2 (0x2) +int xor420x2 xor42 0x28 +__uint xor420x2 xor42 0x28 +char xor420x2 xor42 0x28 +__uchar xor420x2 xor42 0x28 +__longlong xor420x2 xor42 0x28 +__ulonglong xor420x2 xor42 0x28 +int land10x2 land1 0x1 +__uint land10x2 land1 0x1 +char land10x2 land1 0x1 +__uchar land10x2 land1 0x1 +__longlong land10x2 land1 0x1 +__ulonglong land10x2 land1 0x1 +int lor10x2 lor1 0x1 +__uint lor10x2 lor1 0x1 +char lor10x2 lor1 0x1 +__uchar lor10x2 lor1 0x1 +__longlong lor10x2 lor1 0x1 +__ulonglong lor10x2 lor1 0x1 +int and420x2 and42 0x2 +__uint and420x2 and42 0x2 +char and420x2 and42 0x2 +__uchar and420x2 and42 0x2 +__longlong and420x2 and42 0x2 +__ulonglong and420x2 and42 0x2 +int or420x2 or42 0x2a +__uint or420x2 or42 0x2a +char or420x2 or42 0x2a +__uchar or420x2 or42 0x2a +__longlong or420x2 or42 0x2a +__ulonglong or420x2 or42 0x2a +int shl50x2 shl5 0x40 +__uint shl50x2 shl5 0x40 +char shl50x2 shl5 0x40 +__uchar shl50x2 shl5 0x40 +__longlong shl50x2 shl5 0x40 +__ulonglong shl50x2 shl5 0x40 +int shr50x2 shr5 0x0 +__uint shr50x2 shr5 0x0 +char shr50x2 shr5 0x0 +__uchar shr50x2 shr5 0x0 +__longlong shr50x2 shr5 0x0 +__ulonglong shr50x2 shr5 0x0 +int add420x2 add42 0x2c +__uint add420x2 add42 0x2c +char add420x2 add42 0x2c +__uchar add420x2 add42 0x2c +__longlong add420x2 add42 0x2c +__ulonglong add420x2 add42 0x2c +float add420x2 add42 0x2c +int sub420x2 sub42 -0x28 +__uint sub420x2 sub42 -0x28 +char sub420x2 sub42 -0x28 +__uchar sub420x2 sub42 0xd8 +__longlong sub420x2 sub42 -0x28 +__ulonglong sub420x2 sub42 -0x28 +float sub420x2 sub42 -0x28 +int mul420x2 mul42 0x54 +__uint mul420x2 mul42 0x54 +char mul420x2 mul42 0x54 +__uchar mul420x2 mul42 0x54 +__longlong mul420x2 mul42 0x54 +__ulonglong mul420x2 mul42 0x54 +float mul420x2 mul42 0x54 +int lt420x2 lt42 0x1 +__uint lt420x2 lt42 0x1 +char lt420x2 lt42 0x1 +__uchar lt420x2 lt42 0x1 +__longlong lt420x2 lt42 0x1 +__ulonglong lt420x2 lt42 0x1 +float lt420x2 lt42 0x1 +int gt420x2 gt42 0x0 +__uint gt420x2 gt42 0x0 +char gt420x2 gt42 0x0 +__uchar gt420x2 gt42 0x0 +__longlong gt420x2 gt42 0x0 +__ulonglong gt420x2 gt42 0x0 +float gt420x2 gt42 0x0 +int le420x2 le42 0x1 +__uint le420x2 le42 0x1 +char le420x2 le42 0x1 +__uchar le420x2 le42 0x1 +__longlong le420x2 le42 0x1 +__ulonglong le420x2 le42 0x1 +float le420x2 le42 0x1 +int eq420x2 eq42 0x0 +__uint eq420x2 eq42 0x0 +char eq420x2 eq42 0x0 +__uchar eq420x2 eq42 0x0 +__longlong eq420x2 eq42 0x0 +__ulonglong eq420x2 eq42 0x0 +float eq420x2 eq42 0x0 +int ne420x2 ne42 0x1 +__uint ne420x2 ne42 0x1 +char ne420x2 ne42 0x1 +__uchar ne420x2 ne42 0x1 +__longlong ne420x2 ne42 0x1 +__ulonglong ne420x2 ne42 0x1 +float ne420x2 ne42 0x1 +int ge420x2 ge42 0x0 +__uint ge420x2 ge42 0x0 +char ge420x2 ge42 0x0 +__uchar ge420x2 ge42 0x0 +__longlong ge420x2 ge42 0x0 +__ulonglong ge420x2 ge42 0x0 +float ge420x2 ge42 0x0 +int div420x2 div42 0x0 +__uint div420x2 div42 0x0 +char div420x2 div42 0x0 +__uchar div420x2 div42 0x0 +__longlong div420x2 div42 0x0 +__ulonglong div420x2 div42 0x0 +float div420x2 div42 0x0 +int mod230x2 mod23 0x2 +__uint mod230x2 mod23 0x2 +char mod230x2 mod23 0x2 +__uchar mod230x2 mod23 0x2 +__longlong mod230x2 mod23 0x2 +__ulonglong mod230x2 mod23 0x2 +0xfffe * 0xffff == 0x2 +0xfffe / 0xffff == 0x2 +0xfffe % 0xffff == 0x0 +int 0xfffe ^ 0xffff == 0x1 (0x1) +__uint 0xfffe ^ 0xffff == 0x1 (0x1) +char 0xfffe ^ 0xffff == 0x1 (0x1) +__uchar 0xfe ^ 0xff == 0x1 (0x1) +__longlong 0xfffe ^ 0xffff == 0x1 (0x1) +__ulonglong 0xfffe ^ 0xffff == 0x1 (0x1) +int 0xfffe && 0xffff == 0x1 (0x1) +__uint 0xfffe && 0xffff == 0x1 (0x1) +char 0xfffe && 0xffff == 0x1 (0x1) +__uchar 0xfe && 0xff == 0x1 (0x1) +__longlong 0xfffe && 0xffff == 0x1 (0x1) +__ulonglong 0xfffe && 0xffff == 0x1 (0x1) +int 0xfffe || 0xffff == 0x1 (0x1) +__uint 0xfffe || 0xffff == 0x1 (0x1) +char 0xfffe || 0xffff == 0x1 (0x1) +__uchar 0xfe || 0xff == 0x1 (0x1) +__longlong 0xfffe || 0xffff == 0x1 (0x1) +__ulonglong 0xfffe || 0xffff == 0x1 (0x1) +int 0xfffe & 0xffff == -0x2 (0xfffe) +__uint 0xfffe & 0xffff == -0x2 (0xfffe) +char 0xfffe & 0xffff == -0x2 (0xfffe) +__uchar 0xfe & 0xff == 0xfe (0xfe) +__longlong 0xfffe & 0xffff == -0x2 (0xfffe) +__ulonglong 0xfffe & 0xffff == -0x2 (0xfffe) +int 0xfffe | 0xffff == -0x1 (0xffff) +__uint 0xfffe | 0xffff == -0x1 (0xffff) +char 0xfffe | 0xffff == -0x1 (0xffff) +__uchar 0xfe | 0xff == 0xff (0xff) +__longlong 0xfffe | 0xffff == -0x1 (0xffff) +__ulonglong 0xfffe | 0xffff == -0x1 (0xffff) +int 0xfffe << 0x1 == -0x4 (0xfffc) +__uint 0xfffe << 0x1 == -0x4 (0xfffc) +char 0xfffe << 0x1 == -0x4 (0xfffc) +__uchar 0xfe << 0x1 == 0xfc (0xfc) +__longlong 0xfffe << 0x1 == -0x4 (0xfffc) +__ulonglong 0xfffe << 0x1 == -0x4 (0xfffc) +int 0xfffe >> 0x1 == -0x1 (0xffff) +__uint 0xfffe >> 0x1 == 0x7fff (0x7fff) +char 0xfffe >> 0x1 == -0x1 (0xffff) +__uchar 0xfe >> 0x1 == 0x7f (0x7f) +__longlong 0xfffe >> 0x1 == -0x1 (0xffff) +__ulonglong 0xfffe >> 0x1 == -0x1 (0xffff) +int 0xfffe + 0xffff == -0x3 (0xfffd) +__uint 0xfffe + 0xffff == -0x3 (0xfffd) +char 0xfffe + 0xffff == -0x3 (0xfffd) +__uchar 0xfe + 0xff == 0xfd (0xfd) +__longlong 0xfffe + 0xffff == -0x3 (0xfffd) +__ulonglong 0xfffe + 0xffff == -0x3 (0xfffd) +float 0xfffe + 0xffff == -0x3 (0xfffd) +int 0xfffe - 0xffff == -0x1 (0xffff) +__uint 0xfffe - 0xffff == -0x1 (0xffff) +char 0xfffe - 0xffff == -0x1 (0xffff) +__uchar 0xfe - 0xff == 0xff (0xff) +__longlong 0xfffe - 0xffff == -0x1 (0xffff) +__ulonglong 0xfffe - 0xffff == -0x1 (0xffff) +float 0xfffe - 0xffff == -0x1 (0xffff) +int 0xfffe * 0xffff == 0x2 (0x2) +__uint 0xfffe * 0xffff == 0x2 (0x2) +char 0xfffe * 0xffff == 0x2 (0x2) +__uchar 0xfe * 0xff == 0x2 (0x2) +__longlong 0xfffe * 0xffff == 0x2 (0x2) +__ulonglong 0xfffe * 0xffff == 0x2 (0x2) +float 0xfffe * 0xffff == 0x2 (0x2) +int 0xfffe < 0xffff == 0x1 (0x1) +__uint 0xfffe < 0xffff == 0x1 (0x1) +char 0xfffe < 0xffff == 0x1 (0x1) +__uchar 0xfe < 0xff == 0x1 (0x1) +__longlong 0xfffe < 0xffff == 0x1 (0x1) +__ulonglong 0xfffe < 0xffff == 0x1 (0x1) +float 0xfffe < 0xffff == 0x1 (0x1) +int 0xfffe > 0xffff == 0x0 (0x0) +__uint 0xfffe > 0xffff == 0x0 (0x0) +char 0xfffe > 0xffff == 0x0 (0x0) +__uchar 0xfe > 0xff == 0x0 (0x0) +__longlong 0xfffe > 0xffff == 0x0 (0x0) +__ulonglong 0xfffe > 0xffff == 0x0 (0x0) +float 0xfffe > 0xffff == 0x0 (0x0) +int 0xfffe <= 0xffff == 0x1 (0x1) +__uint 0xfffe <= 0xffff == 0x1 (0x1) +char 0xfffe <= 0xffff == 0x1 (0x1) +__uchar 0xfe <= 0xff == 0x1 (0x1) +__longlong 0xfffe <= 0xffff == 0x1 (0x1) +__ulonglong 0xfffe <= 0xffff == 0x1 (0x1) +float 0xfffe <= 0xffff == 0x1 (0x1) +int 0xfffe == 0xffff == 0x0 (0x0) +__uint 0xfffe == 0xffff == 0x0 (0x0) +char 0xfffe == 0xffff == 0x0 (0x0) +__uchar 0xfe == 0xff == 0x0 (0x0) +__longlong 0xfffe == 0xffff == 0x0 (0x0) +__ulonglong 0xfffe == 0xffff == 0x0 (0x0) +float 0xfffe == 0xffff == 0x0 (0x0) +int 0xfffe != 0xffff == 0x1 (0x1) +__uint 0xfffe != 0xffff == 0x1 (0x1) +char 0xfffe != 0xffff == 0x1 (0x1) +__uchar 0xfe != 0xff == 0x1 (0x1) +__longlong 0xfffe != 0xffff == 0x1 (0x1) +__ulonglong 0xfffe != 0xffff == 0x1 (0x1) +float 0xfffe != 0xffff == 0x1 (0x1) +int 0xfffe >= 0xffff == 0x0 (0x0) +__uint 0xfffe >= 0xffff == 0x0 (0x0) +char 0xfffe >= 0xffff == 0x0 (0x0) +__uchar 0xfe >= 0xff == 0x0 (0x0) +__longlong 0xfffe >= 0xffff == 0x0 (0x0) +__ulonglong 0xfffe >= 0xffff == 0x0 (0x0) +float 0xfffe >= 0xffff == 0x0 (0x0) +int 0xfffe / 0xffff == 0x2 (0x2) +__uint 0xfffe / 0xffff == 0x0 (0x0) +char 0xfffe / 0xffff == 0x2 (0x2) +__uchar 0xfe / 0xff == 0x0 (0x0) +__longlong 0xfffe / 0xffff == 0x2 (0x2) +__ulonglong 0xfffe / 0xffff == 0x0 (0x0) +float 0xfffe / 0xffff == 0x2 (0x2) +int 0xfffe % 0xffff == 0x0 (0x0) +__uint 0xfffe % 0xffff == -0x2 (0xfffe) +char 0xfffe % 0xffff == 0x0 (0x0) +__uchar 0xfe % 0xff == 0xfe (0xfe) +__longlong 0xfffe % 0xffff == 0x0 (0x0) +__ulonglong 0xfffe % 0xffff == -0x2 (0xfffe) +0xfffe * 0x1 == -0x2 +0xfffe / 0x1 == -0x2 +0xfffe % 0x1 == 0x0 +int 0xfffe ^ 0x1 == -0x1 (0xffff) +__uint 0xfffe ^ 0x1 == -0x1 (0xffff) +char 0xfffe ^ 0x1 == -0x1 (0xffff) +__uchar 0xfe ^ 0x1 == 0xff (0xff) +__longlong 0xfffe ^ 0x1 == -0x1 (0xffff) +__ulonglong 0xfffe ^ 0x1 == -0x1 (0xffff) +int 0xfffe && 0x1 == 0x1 (0x1) +__uint 0xfffe && 0x1 == 0x1 (0x1) +char 0xfffe && 0x1 == 0x1 (0x1) +__uchar 0xfe && 0x1 == 0x1 (0x1) +__longlong 0xfffe && 0x1 == 0x1 (0x1) +__ulonglong 0xfffe && 0x1 == 0x1 (0x1) +int 0xfffe || 0x1 == 0x1 (0x1) +__uint 0xfffe || 0x1 == 0x1 (0x1) +char 0xfffe || 0x1 == 0x1 (0x1) +__uchar 0xfe || 0x1 == 0x1 (0x1) +__longlong 0xfffe || 0x1 == 0x1 (0x1) +__ulonglong 0xfffe || 0x1 == 0x1 (0x1) +int 0xfffe & 0x1 == 0x0 (0x0) +__uint 0xfffe & 0x1 == 0x0 (0x0) +char 0xfffe & 0x1 == 0x0 (0x0) +__uchar 0xfe & 0x1 == 0x0 (0x0) +__longlong 0xfffe & 0x1 == 0x0 (0x0) +__ulonglong 0xfffe & 0x1 == 0x0 (0x0) +int 0xfffe | 0x1 == -0x1 (0xffff) +__uint 0xfffe | 0x1 == -0x1 (0xffff) +char 0xfffe | 0x1 == -0x1 (0xffff) +__uchar 0xfe | 0x1 == 0xff (0xff) +__longlong 0xfffe | 0x1 == -0x1 (0xffff) +__ulonglong 0xfffe | 0x1 == -0x1 (0xffff) +int 0xfffe << 0x2 == -0x8 (0xfff8) +__uint 0xfffe << 0x2 == -0x8 (0xfff8) +char 0xfffe << 0x2 == -0x8 (0xfff8) +__uchar 0xfe << 0x2 == 0xf8 (0xf8) +__longlong 0xfffe << 0x2 == -0x8 (0xfff8) +__ulonglong 0xfffe << 0x2 == -0x8 (0xfff8) +int 0xfffe >> 0x2 == -0x1 (0xffff) +__uint 0xfffe >> 0x2 == 0x3fff (0x3fff) +char 0xfffe >> 0x2 == -0x1 (0xffff) +__uchar 0xfe >> 0x2 == 0x3f (0x3f) +__longlong 0xfffe >> 0x2 == -0x1 (0xffff) +__ulonglong 0xfffe >> 0x2 == -0x1 (0xffff) +int 0xfffe + 0x1 == -0x1 (0xffff) +__uint 0xfffe + 0x1 == -0x1 (0xffff) +char 0xfffe + 0x1 == -0x1 (0xffff) +__uchar 0xfe + 0x1 == 0xff (0xff) +__longlong 0xfffe + 0x1 == -0x1 (0xffff) +__ulonglong 0xfffe + 0x1 == -0x1 (0xffff) +float 0xfffe + 0x1 == -0x1 (0xffff) +int 0xfffe - 0x1 == -0x3 (0xfffd) +__uint 0xfffe - 0x1 == -0x3 (0xfffd) +char 0xfffe - 0x1 == -0x3 (0xfffd) +__uchar 0xfe - 0x1 == 0xfd (0xfd) +__longlong 0xfffe - 0x1 == -0x3 (0xfffd) +__ulonglong 0xfffe - 0x1 == -0x3 (0xfffd) +float 0xfffe - 0x1 == -0x3 (0xfffd) +int 0xfffe * 0x1 == -0x2 (0xfffe) +__uint 0xfffe * 0x1 == -0x2 (0xfffe) +char 0xfffe * 0x1 == -0x2 (0xfffe) +__uchar 0xfe * 0x1 == 0xfe (0xfe) +__longlong 0xfffe * 0x1 == -0x2 (0xfffe) +__ulonglong 0xfffe * 0x1 == -0x2 (0xfffe) +float 0xfffe * 0x1 == -0x2 (0xfffe) +int 0xfffe < 0x1 == 0x1 (0x1) +__uint 0xfffe < 0x1 == 0x0 (0x0) +char 0xfffe < 0x1 == 0x1 (0x1) +__uchar 0xfe < 0x1 == 0x0 (0x0) +__longlong 0xfffe < 0x1 == 0x1 (0x1) +__ulonglong 0xfffe < 0x1 == 0x0 (0x0) +float 0xfffe < 0x1 == 0x1 (0x1) +int 0xfffe > 0x1 == 0x0 (0x0) +__uint 0xfffe > 0x1 == 0x1 (0x1) +char 0xfffe > 0x1 == 0x0 (0x0) +__uchar 0xfe > 0x1 == 0x1 (0x1) +__longlong 0xfffe > 0x1 == 0x0 (0x0) +__ulonglong 0xfffe > 0x1 == 0x1 (0x1) +float 0xfffe > 0x1 == 0x0 (0x0) +int 0xfffe <= 0x1 == 0x1 (0x1) +__uint 0xfffe <= 0x1 == 0x0 (0x0) +char 0xfffe <= 0x1 == 0x1 (0x1) +__uchar 0xfe <= 0x1 == 0x0 (0x0) +__longlong 0xfffe <= 0x1 == 0x1 (0x1) +__ulonglong 0xfffe <= 0x1 == 0x0 (0x0) +float 0xfffe <= 0x1 == 0x1 (0x1) +int 0xfffe == 0x1 == 0x0 (0x0) +__uint 0xfffe == 0x1 == 0x0 (0x0) +char 0xfffe == 0x1 == 0x0 (0x0) +__uchar 0xfe == 0x1 == 0x0 (0x0) +__longlong 0xfffe == 0x1 == 0x0 (0x0) +__ulonglong 0xfffe == 0x1 == 0x0 (0x0) +float 0xfffe == 0x1 == 0x0 (0x0) +int 0xfffe != 0x1 == 0x1 (0x1) +__uint 0xfffe != 0x1 == 0x1 (0x1) +char 0xfffe != 0x1 == 0x1 (0x1) +__uchar 0xfe != 0x1 == 0x1 (0x1) +__longlong 0xfffe != 0x1 == 0x1 (0x1) +__ulonglong 0xfffe != 0x1 == 0x1 (0x1) +float 0xfffe != 0x1 == 0x1 (0x1) +int 0xfffe >= 0x1 == 0x0 (0x0) +__uint 0xfffe >= 0x1 == 0x1 (0x1) +char 0xfffe >= 0x1 == 0x0 (0x0) +__uchar 0xfe >= 0x1 == 0x1 (0x1) +__longlong 0xfffe >= 0x1 == 0x0 (0x0) +__ulonglong 0xfffe >= 0x1 == 0x1 (0x1) +float 0xfffe >= 0x1 == 0x0 (0x0) +int 0xfffe / 0x1 == -0x2 (0xfffe) +__uint 0xfffe / 0x1 == -0x2 (0xfffe) +char 0xfffe / 0x1 == -0x2 (0xfffe) +__uchar 0xfe / 0x1 == 0xfe (0xfe) +__longlong 0xfffe / 0x1 == -0x2 (0xfffe) +__ulonglong 0xfffe / 0x1 == -0x2 (0xfffe) +float 0xfffe / 0x1 == -0x2 (0xfffe) +int 0xfffe % 0x1 == 0x0 (0x0) +__uint 0xfffe % 0x1 == 0x0 (0x0) +char 0xfffe % 0x1 == 0x0 (0x0) +__uchar 0xfe % 0x1 == 0x0 (0x0) +__longlong 0xfffe % 0x1 == 0x0 (0x0) +__ulonglong 0xfffe % 0x1 == 0x0 (0x0) +0xfffe * 0x2 == -0x4 +0xfffe / 0x2 == -0x1 +0xfffe % 0x2 == 0x0 +int 0xfffe ^ 0x2 == -0x4 (0xfffc) +__uint 0xfffe ^ 0x2 == -0x4 (0xfffc) +char 0xfffe ^ 0x2 == -0x4 (0xfffc) +__uchar 0xfe ^ 0x2 == 0xfc (0xfc) +__longlong 0xfffe ^ 0x2 == -0x4 (0xfffc) +__ulonglong 0xfffe ^ 0x2 == -0x4 (0xfffc) +int 0xfffe && 0x2 == 0x1 (0x1) +__uint 0xfffe && 0x2 == 0x1 (0x1) +char 0xfffe && 0x2 == 0x1 (0x1) +__uchar 0xfe && 0x2 == 0x1 (0x1) +__longlong 0xfffe && 0x2 == 0x1 (0x1) +__ulonglong 0xfffe && 0x2 == 0x1 (0x1) +int 0xfffe || 0x2 == 0x1 (0x1) +__uint 0xfffe || 0x2 == 0x1 (0x1) +char 0xfffe || 0x2 == 0x1 (0x1) +__uchar 0xfe || 0x2 == 0x1 (0x1) +__longlong 0xfffe || 0x2 == 0x1 (0x1) +__ulonglong 0xfffe || 0x2 == 0x1 (0x1) +int 0xfffe & 0x2 == 0x2 (0x2) +__uint 0xfffe & 0x2 == 0x2 (0x2) +char 0xfffe & 0x2 == 0x2 (0x2) +__uchar 0xfe & 0x2 == 0x2 (0x2) +__longlong 0xfffe & 0x2 == 0x2 (0x2) +__ulonglong 0xfffe & 0x2 == 0x2 (0x2) +int 0xfffe | 0x2 == -0x2 (0xfffe) +__uint 0xfffe | 0x2 == -0x2 (0xfffe) +char 0xfffe | 0x2 == -0x2 (0xfffe) +__uchar 0xfe | 0x2 == 0xfe (0xfe) +__longlong 0xfffe | 0x2 == -0x2 (0xfffe) +__ulonglong 0xfffe | 0x2 == -0x2 (0xfffe) +int 0xfffe << 0x3 == -0x10 (0xfff0) +__uint 0xfffe << 0x3 == -0x10 (0xfff0) +char 0xfffe << 0x3 == -0x10 (0xfff0) +__uchar 0xfe << 0x3 == 0xf0 (0xf0) +__longlong 0xfffe << 0x3 == -0x10 (0xfff0) +__ulonglong 0xfffe << 0x3 == -0x10 (0xfff0) +int 0xfffe >> 0x3 == -0x1 (0xffff) +__uint 0xfffe >> 0x3 == 0x1fff (0x1fff) +char 0xfffe >> 0x3 == -0x1 (0xffff) +__uchar 0xfe >> 0x3 == 0x1f (0x1f) +__longlong 0xfffe >> 0x3 == -0x1 (0xffff) +__ulonglong 0xfffe >> 0x3 == -0x1 (0xffff) +int 0xfffe + 0x2 == 0x0 (0x0) +__uint 0xfffe + 0x2 == 0x0 (0x0) +char 0xfffe + 0x2 == 0x0 (0x0) +__uchar 0xfe + 0x2 == 0x0 (0x0) +__longlong 0xfffe + 0x2 == 0x0 (0x0) +__ulonglong 0xfffe + 0x2 == 0x0 (0x0) +float 0xfffe + 0x2 == 0x0 (0x0) +int 0xfffe - 0x2 == -0x4 (0xfffc) +__uint 0xfffe - 0x2 == -0x4 (0xfffc) +char 0xfffe - 0x2 == -0x4 (0xfffc) +__uchar 0xfe - 0x2 == 0xfc (0xfc) +__longlong 0xfffe - 0x2 == -0x4 (0xfffc) +__ulonglong 0xfffe - 0x2 == -0x4 (0xfffc) +float 0xfffe - 0x2 == -0x4 (0xfffc) +int 0xfffe * 0x2 == -0x4 (0xfffc) +__uint 0xfffe * 0x2 == -0x4 (0xfffc) +char 0xfffe * 0x2 == -0x4 (0xfffc) +__uchar 0xfe * 0x2 == 0xfc (0xfc) +__longlong 0xfffe * 0x2 == -0x4 (0xfffc) +__ulonglong 0xfffe * 0x2 == -0x4 (0xfffc) +float 0xfffe * 0x2 == -0x4 (0xfffc) +int 0xfffe < 0x2 == 0x1 (0x1) +__uint 0xfffe < 0x2 == 0x0 (0x0) +char 0xfffe < 0x2 == 0x1 (0x1) +__uchar 0xfe < 0x2 == 0x0 (0x0) +__longlong 0xfffe < 0x2 == 0x1 (0x1) +__ulonglong 0xfffe < 0x2 == 0x0 (0x0) +float 0xfffe < 0x2 == 0x1 (0x1) +int 0xfffe > 0x2 == 0x0 (0x0) +__uint 0xfffe > 0x2 == 0x1 (0x1) +char 0xfffe > 0x2 == 0x0 (0x0) +__uchar 0xfe > 0x2 == 0x1 (0x1) +__longlong 0xfffe > 0x2 == 0x0 (0x0) +__ulonglong 0xfffe > 0x2 == 0x1 (0x1) +float 0xfffe > 0x2 == 0x0 (0x0) +int 0xfffe <= 0x2 == 0x1 (0x1) +__uint 0xfffe <= 0x2 == 0x0 (0x0) +char 0xfffe <= 0x2 == 0x1 (0x1) +__uchar 0xfe <= 0x2 == 0x0 (0x0) +__longlong 0xfffe <= 0x2 == 0x1 (0x1) +__ulonglong 0xfffe <= 0x2 == 0x0 (0x0) +float 0xfffe <= 0x2 == 0x1 (0x1) +int 0xfffe == 0x2 == 0x0 (0x0) +__uint 0xfffe == 0x2 == 0x0 (0x0) +char 0xfffe == 0x2 == 0x0 (0x0) +__uchar 0xfe == 0x2 == 0x0 (0x0) +__longlong 0xfffe == 0x2 == 0x0 (0x0) +__ulonglong 0xfffe == 0x2 == 0x0 (0x0) +float 0xfffe == 0x2 == 0x0 (0x0) +int 0xfffe != 0x2 == 0x1 (0x1) +__uint 0xfffe != 0x2 == 0x1 (0x1) +char 0xfffe != 0x2 == 0x1 (0x1) +__uchar 0xfe != 0x2 == 0x1 (0x1) +__longlong 0xfffe != 0x2 == 0x1 (0x1) +__ulonglong 0xfffe != 0x2 == 0x1 (0x1) +float 0xfffe != 0x2 == 0x1 (0x1) +int 0xfffe >= 0x2 == 0x0 (0x0) +__uint 0xfffe >= 0x2 == 0x1 (0x1) +char 0xfffe >= 0x2 == 0x0 (0x0) +__uchar 0xfe >= 0x2 == 0x1 (0x1) +__longlong 0xfffe >= 0x2 == 0x0 (0x0) +__ulonglong 0xfffe >= 0x2 == 0x1 (0x1) +float 0xfffe >= 0x2 == 0x0 (0x0) +int 0xfffe / 0x2 == -0x1 (0xffff) +__uint 0xfffe / 0x2 == 0x7fff (0x7fff) +char 0xfffe / 0x2 == -0x1 (0xffff) +__uchar 0xfe / 0x2 == 0x7f (0x7f) +__longlong 0xfffe / 0x2 == -0x1 (0xffff) +__ulonglong 0xfffe / 0x2 == -0x1 (0xffff) +float 0xfffe / 0x2 == -0x1 (0xffff) +int 0xfffe % 0x2 == 0x0 (0x0) +__uint 0xfffe % 0x2 == 0x0 (0x0) +char 0xfffe % 0x2 == 0x0 (0x0) +__uchar 0xfe % 0x2 == 0x0 (0x0) +__longlong 0xfffe % 0x2 == 0x0 (0x0) +__ulonglong 0xfffe % 0x2 == 0x0 (0x0) +0xfffe * 0xfffe == 0x4 +0xfffe / 0xfffe == 0x1 +0xfffe % 0xfffe == 0x0 +int 0xfffe ^ 0xfffe == 0x0 (0x0) +__uint 0xfffe ^ 0xfffe == 0x0 (0x0) +char 0xfffe ^ 0xfffe == 0x0 (0x0) +__uchar 0xfe ^ 0xfe == 0x0 (0x0) +__longlong 0xfffe ^ 0xfffe == 0x0 (0x0) +__ulonglong 0xfffe ^ 0xfffe == 0x0 (0x0) +int 0xfffe && 0xfffe == 0x1 (0x1) +__uint 0xfffe && 0xfffe == 0x1 (0x1) +char 0xfffe && 0xfffe == 0x1 (0x1) +__uchar 0xfe && 0xfe == 0x1 (0x1) +__longlong 0xfffe && 0xfffe == 0x1 (0x1) +__ulonglong 0xfffe && 0xfffe == 0x1 (0x1) +int 0xfffe || 0xfffe == 0x1 (0x1) +__uint 0xfffe || 0xfffe == 0x1 (0x1) +char 0xfffe || 0xfffe == 0x1 (0x1) +__uchar 0xfe || 0xfe == 0x1 (0x1) +__longlong 0xfffe || 0xfffe == 0x1 (0x1) +__ulonglong 0xfffe || 0xfffe == 0x1 (0x1) +int 0xfffe & 0xfffe == -0x2 (0xfffe) +__uint 0xfffe & 0xfffe == -0x2 (0xfffe) +char 0xfffe & 0xfffe == -0x2 (0xfffe) +__uchar 0xfe & 0xfe == 0xfe (0xfe) +__longlong 0xfffe & 0xfffe == -0x2 (0xfffe) +__ulonglong 0xfffe & 0xfffe == -0x2 (0xfffe) +int 0xfffe | 0xfffe == -0x2 (0xfffe) +__uint 0xfffe | 0xfffe == -0x2 (0xfffe) +char 0xfffe | 0xfffe == -0x2 (0xfffe) +__uchar 0xfe | 0xfe == 0xfe (0xfe) +__longlong 0xfffe | 0xfffe == -0x2 (0xfffe) +__ulonglong 0xfffe | 0xfffe == -0x2 (0xfffe) +int 0xfffe << 0x4 == -0x20 (0xffe0) +__uint 0xfffe << 0x4 == -0x20 (0xffe0) +char 0xfffe << 0x4 == -0x20 (0xffe0) +__uchar 0xfe << 0x4 == 0xe0 (0xe0) +__longlong 0xfffe << 0x4 == -0x20 (0xffe0) +__ulonglong 0xfffe << 0x4 == -0x20 (0xffe0) +int 0xfffe >> 0x4 == -0x1 (0xffff) +__uint 0xfffe >> 0x4 == 0xfff (0xfff) +char 0xfffe >> 0x4 == -0x1 (0xffff) +__uchar 0xfe >> 0x4 == 0xf (0xf) +__longlong 0xfffe >> 0x4 == -0x1 (0xffff) +__ulonglong 0xfffe >> 0x4 == -0x1 (0xffff) +int 0xfffe + 0xfffe == -0x4 (0xfffc) +__uint 0xfffe + 0xfffe == -0x4 (0xfffc) +char 0xfffe + 0xfffe == -0x4 (0xfffc) +__uchar 0xfe + 0xfe == 0xfc (0xfc) +__longlong 0xfffe + 0xfffe == -0x4 (0xfffc) +__ulonglong 0xfffe + 0xfffe == -0x4 (0xfffc) +float 0xfffe + 0xfffe == -0x4 (0xfffc) +int 0xfffe - 0xfffe == 0x0 (0x0) +__uint 0xfffe - 0xfffe == 0x0 (0x0) +char 0xfffe - 0xfffe == 0x0 (0x0) +__uchar 0xfe - 0xfe == 0x0 (0x0) +__longlong 0xfffe - 0xfffe == 0x0 (0x0) +__ulonglong 0xfffe - 0xfffe == 0x0 (0x0) +float 0xfffe - 0xfffe == 0x0 (0x0) +int 0xfffe * 0xfffe == 0x4 (0x4) +__uint 0xfffe * 0xfffe == 0x4 (0x4) +char 0xfffe * 0xfffe == 0x4 (0x4) +__uchar 0xfe * 0xfe == 0x4 (0x4) +__longlong 0xfffe * 0xfffe == 0x4 (0x4) +__ulonglong 0xfffe * 0xfffe == 0x4 (0x4) +float 0xfffe * 0xfffe == 0x4 (0x4) +int 0xfffe < 0xfffe == 0x0 (0x0) +__uint 0xfffe < 0xfffe == 0x0 (0x0) +char 0xfffe < 0xfffe == 0x0 (0x0) +__uchar 0xfe < 0xfe == 0x0 (0x0) +__longlong 0xfffe < 0xfffe == 0x0 (0x0) +__ulonglong 0xfffe < 0xfffe == 0x0 (0x0) +float 0xfffe < 0xfffe == 0x0 (0x0) +int 0xfffe > 0xfffe == 0x0 (0x0) +__uint 0xfffe > 0xfffe == 0x0 (0x0) +char 0xfffe > 0xfffe == 0x0 (0x0) +__uchar 0xfe > 0xfe == 0x0 (0x0) +__longlong 0xfffe > 0xfffe == 0x0 (0x0) +__ulonglong 0xfffe > 0xfffe == 0x0 (0x0) +float 0xfffe > 0xfffe == 0x0 (0x0) +int 0xfffe <= 0xfffe == 0x1 (0x1) +__uint 0xfffe <= 0xfffe == 0x1 (0x1) +char 0xfffe <= 0xfffe == 0x1 (0x1) +__uchar 0xfe <= 0xfe == 0x1 (0x1) +__longlong 0xfffe <= 0xfffe == 0x1 (0x1) +__ulonglong 0xfffe <= 0xfffe == 0x1 (0x1) +float 0xfffe <= 0xfffe == 0x1 (0x1) +int 0xfffe == 0xfffe == 0x1 (0x1) +__uint 0xfffe == 0xfffe == 0x1 (0x1) +char 0xfffe == 0xfffe == 0x1 (0x1) +__uchar 0xfe == 0xfe == 0x1 (0x1) +__longlong 0xfffe == 0xfffe == 0x1 (0x1) +__ulonglong 0xfffe == 0xfffe == 0x1 (0x1) +float 0xfffe == 0xfffe == 0x1 (0x1) +int 0xfffe != 0xfffe == 0x0 (0x0) +__uint 0xfffe != 0xfffe == 0x0 (0x0) +char 0xfffe != 0xfffe == 0x0 (0x0) +__uchar 0xfe != 0xfe == 0x0 (0x0) +__longlong 0xfffe != 0xfffe == 0x0 (0x0) +__ulonglong 0xfffe != 0xfffe == 0x0 (0x0) +float 0xfffe != 0xfffe == 0x0 (0x0) +int 0xfffe >= 0xfffe == 0x1 (0x1) +__uint 0xfffe >= 0xfffe == 0x1 (0x1) +char 0xfffe >= 0xfffe == 0x1 (0x1) +__uchar 0xfe >= 0xfe == 0x1 (0x1) +__longlong 0xfffe >= 0xfffe == 0x1 (0x1) +__ulonglong 0xfffe >= 0xfffe == 0x1 (0x1) +float 0xfffe >= 0xfffe == 0x1 (0x1) +int 0xfffe / 0xfffe == 0x1 (0x1) +__uint 0xfffe / 0xfffe == 0x1 (0x1) +char 0xfffe / 0xfffe == 0x1 (0x1) +__uchar 0xfe / 0xfe == 0x1 (0x1) +__longlong 0xfffe / 0xfffe == 0x1 (0x1) +__ulonglong 0xfffe / 0xfffe == 0x1 (0x1) +float 0xfffe / 0xfffe == 0x1 (0x1) +int 0xfffe % 0xfffe == 0x0 (0x0) +__uint 0xfffe % 0xfffe == 0x0 (0x0) +char 0xfffe % 0xfffe == 0x0 (0x0) +__uchar 0xfe % 0xfe == 0x0 (0x0) +__longlong 0xfffe % 0xfffe == 0x0 (0x0) +__ulonglong 0xfffe % 0xfffe == 0x0 (0x0) +0xfffe * 0x4 == -0x8 +0xfffe / 0x4 == 0x0 +0xfffe % 0x4 == -0x2 +int 0xfffe ^ 0x4 == -0x6 (0xfffa) +__uint 0xfffe ^ 0x4 == -0x6 (0xfffa) +char 0xfffe ^ 0x4 == -0x6 (0xfffa) +__uchar 0xfe ^ 0x4 == 0xfa (0xfa) +__longlong 0xfffe ^ 0x4 == -0x6 (0xfffa) +__ulonglong 0xfffe ^ 0x4 == -0x6 (0xfffa) +int 0xfffe && 0x4 == 0x1 (0x1) +__uint 0xfffe && 0x4 == 0x1 (0x1) +char 0xfffe && 0x4 == 0x1 (0x1) +__uchar 0xfe && 0x4 == 0x1 (0x1) +__longlong 0xfffe && 0x4 == 0x1 (0x1) +__ulonglong 0xfffe && 0x4 == 0x1 (0x1) +int 0xfffe || 0x4 == 0x1 (0x1) +__uint 0xfffe || 0x4 == 0x1 (0x1) +char 0xfffe || 0x4 == 0x1 (0x1) +__uchar 0xfe || 0x4 == 0x1 (0x1) +__longlong 0xfffe || 0x4 == 0x1 (0x1) +__ulonglong 0xfffe || 0x4 == 0x1 (0x1) +int 0xfffe & 0x4 == 0x4 (0x4) +__uint 0xfffe & 0x4 == 0x4 (0x4) +char 0xfffe & 0x4 == 0x4 (0x4) +__uchar 0xfe & 0x4 == 0x4 (0x4) +__longlong 0xfffe & 0x4 == 0x4 (0x4) +__ulonglong 0xfffe & 0x4 == 0x4 (0x4) +int 0xfffe | 0x4 == -0x2 (0xfffe) +__uint 0xfffe | 0x4 == -0x2 (0xfffe) +char 0xfffe | 0x4 == -0x2 (0xfffe) +__uchar 0xfe | 0x4 == 0xfe (0xfe) +__longlong 0xfffe | 0x4 == -0x2 (0xfffe) +__ulonglong 0xfffe | 0x4 == -0x2 (0xfffe) +int 0xfffe << 0x5 == -0x40 (0xffc0) +__uint 0xfffe << 0x5 == -0x40 (0xffc0) +char 0xfffe << 0x5 == -0x40 (0xffc0) +__uchar 0xfe << 0x5 == 0xc0 (0xc0) +__longlong 0xfffe << 0x5 == -0x40 (0xffc0) +__ulonglong 0xfffe << 0x5 == -0x40 (0xffc0) +int 0xfffe >> 0x5 == -0x1 (0xffff) +__uint 0xfffe >> 0x5 == 0x7ff (0x7ff) +char 0xfffe >> 0x5 == -0x1 (0xffff) +__uchar 0xfe >> 0x5 == 0x7 (0x7) +__longlong 0xfffe >> 0x5 == -0x1 (0xffff) +__ulonglong 0xfffe >> 0x5 == -0x1 (0xffff) +int 0xfffe + 0x4 == 0x2 (0x2) +__uint 0xfffe + 0x4 == 0x2 (0x2) +char 0xfffe + 0x4 == 0x2 (0x2) +__uchar 0xfe + 0x4 == 0x2 (0x2) +__longlong 0xfffe + 0x4 == 0x2 (0x2) +__ulonglong 0xfffe + 0x4 == 0x2 (0x2) +float 0xfffe + 0x4 == 0x2 (0x2) +int 0xfffe - 0x4 == -0x6 (0xfffa) +__uint 0xfffe - 0x4 == -0x6 (0xfffa) +char 0xfffe - 0x4 == -0x6 (0xfffa) +__uchar 0xfe - 0x4 == 0xfa (0xfa) +__longlong 0xfffe - 0x4 == -0x6 (0xfffa) +__ulonglong 0xfffe - 0x4 == -0x6 (0xfffa) +float 0xfffe - 0x4 == -0x6 (0xfffa) +int 0xfffe * 0x4 == -0x8 (0xfff8) +__uint 0xfffe * 0x4 == -0x8 (0xfff8) +char 0xfffe * 0x4 == -0x8 (0xfff8) +__uchar 0xfe * 0x4 == 0xf8 (0xf8) +__longlong 0xfffe * 0x4 == -0x8 (0xfff8) +__ulonglong 0xfffe * 0x4 == -0x8 (0xfff8) +float 0xfffe * 0x4 == -0x8 (0xfff8) +int 0xfffe < 0x4 == 0x1 (0x1) +__uint 0xfffe < 0x4 == 0x0 (0x0) +char 0xfffe < 0x4 == 0x1 (0x1) +__uchar 0xfe < 0x4 == 0x0 (0x0) +__longlong 0xfffe < 0x4 == 0x1 (0x1) +__ulonglong 0xfffe < 0x4 == 0x0 (0x0) +float 0xfffe < 0x4 == 0x1 (0x1) +int 0xfffe > 0x4 == 0x0 (0x0) +__uint 0xfffe > 0x4 == 0x1 (0x1) +char 0xfffe > 0x4 == 0x0 (0x0) +__uchar 0xfe > 0x4 == 0x1 (0x1) +__longlong 0xfffe > 0x4 == 0x0 (0x0) +__ulonglong 0xfffe > 0x4 == 0x1 (0x1) +float 0xfffe > 0x4 == 0x0 (0x0) +int 0xfffe <= 0x4 == 0x1 (0x1) +__uint 0xfffe <= 0x4 == 0x0 (0x0) +char 0xfffe <= 0x4 == 0x1 (0x1) +__uchar 0xfe <= 0x4 == 0x0 (0x0) +__longlong 0xfffe <= 0x4 == 0x1 (0x1) +__ulonglong 0xfffe <= 0x4 == 0x0 (0x0) +float 0xfffe <= 0x4 == 0x1 (0x1) +int 0xfffe == 0x4 == 0x0 (0x0) +__uint 0xfffe == 0x4 == 0x0 (0x0) +char 0xfffe == 0x4 == 0x0 (0x0) +__uchar 0xfe == 0x4 == 0x0 (0x0) +__longlong 0xfffe == 0x4 == 0x0 (0x0) +__ulonglong 0xfffe == 0x4 == 0x0 (0x0) +float 0xfffe == 0x4 == 0x0 (0x0) +int 0xfffe != 0x4 == 0x1 (0x1) +__uint 0xfffe != 0x4 == 0x1 (0x1) +char 0xfffe != 0x4 == 0x1 (0x1) +__uchar 0xfe != 0x4 == 0x1 (0x1) +__longlong 0xfffe != 0x4 == 0x1 (0x1) +__ulonglong 0xfffe != 0x4 == 0x1 (0x1) +float 0xfffe != 0x4 == 0x1 (0x1) +int 0xfffe >= 0x4 == 0x0 (0x0) +__uint 0xfffe >= 0x4 == 0x1 (0x1) +char 0xfffe >= 0x4 == 0x0 (0x0) +__uchar 0xfe >= 0x4 == 0x1 (0x1) +__longlong 0xfffe >= 0x4 == 0x0 (0x0) +__ulonglong 0xfffe >= 0x4 == 0x1 (0x1) +float 0xfffe >= 0x4 == 0x0 (0x0) +int 0xfffe / 0x4 == 0x0 (0x0) +__uint 0xfffe / 0x4 == 0x3fff (0x3fff) +char 0xfffe / 0x4 == 0x0 (0x0) +__uchar 0xfe / 0x4 == 0x3f (0x3f) +__longlong 0xfffe / 0x4 == 0x0 (0x0) +__ulonglong 0xfffe / 0x4 == -0x1 (0xffff) +float 0xfffe / 0x4 == 0x0 (0x0) +int 0xfffe % 0x4 == -0x2 (0xfffe) +__uint 0xfffe % 0x4 == 0x2 (0x2) +char 0xfffe % 0x4 == -0x2 (0xfffe) +__uchar 0xfe % 0x4 == 0x2 (0x2) +__longlong 0xfffe % 0x4 == -0x2 (0xfffe) +__ulonglong 0xfffe % 0x4 == 0x2 (0x2) +0xfffe * 0xfffc == 0x8 +0xfffe / 0xfffc == 0x0 +0xfffe % 0xfffc == -0x2 +int 0xfffe ^ 0xfffc == 0x2 (0x2) +__uint 0xfffe ^ 0xfffc == 0x2 (0x2) +char 0xfffe ^ 0xfffc == 0x2 (0x2) +__uchar 0xfe ^ 0xfc == 0x2 (0x2) +__longlong 0xfffe ^ 0xfffc == 0x2 (0x2) +__ulonglong 0xfffe ^ 0xfffc == 0x2 (0x2) +int 0xfffe && 0xfffc == 0x1 (0x1) +__uint 0xfffe && 0xfffc == 0x1 (0x1) +char 0xfffe && 0xfffc == 0x1 (0x1) +__uchar 0xfe && 0xfc == 0x1 (0x1) +__longlong 0xfffe && 0xfffc == 0x1 (0x1) +__ulonglong 0xfffe && 0xfffc == 0x1 (0x1) +int 0xfffe || 0xfffc == 0x1 (0x1) +__uint 0xfffe || 0xfffc == 0x1 (0x1) +char 0xfffe || 0xfffc == 0x1 (0x1) +__uchar 0xfe || 0xfc == 0x1 (0x1) +__longlong 0xfffe || 0xfffc == 0x1 (0x1) +__ulonglong 0xfffe || 0xfffc == 0x1 (0x1) +int 0xfffe & 0xfffc == -0x4 (0xfffc) +__uint 0xfffe & 0xfffc == -0x4 (0xfffc) +char 0xfffe & 0xfffc == -0x4 (0xfffc) +__uchar 0xfe & 0xfc == 0xfc (0xfc) +__longlong 0xfffe & 0xfffc == -0x4 (0xfffc) +__ulonglong 0xfffe & 0xfffc == -0x4 (0xfffc) +int 0xfffe | 0xfffc == -0x2 (0xfffe) +__uint 0xfffe | 0xfffc == -0x2 (0xfffe) +char 0xfffe | 0xfffc == -0x2 (0xfffe) +__uchar 0xfe | 0xfc == 0xfe (0xfe) +__longlong 0xfffe | 0xfffc == -0x2 (0xfffe) +__ulonglong 0xfffe | 0xfffc == -0x2 (0xfffe) +int 0xfffe << 0x6 == -0x80 (0xff80) +__uint 0xfffe << 0x6 == -0x80 (0xff80) +char 0xfffe << 0x6 == -0x80 (0xff80) +__uchar 0xfe << 0x6 == 0x80 (0x80) +__longlong 0xfffe << 0x6 == -0x80 (0xff80) +__ulonglong 0xfffe << 0x6 == -0x80 (0xff80) +int 0xfffe >> 0x6 == -0x1 (0xffff) +__uint 0xfffe >> 0x6 == 0x3ff (0x3ff) +char 0xfffe >> 0x6 == -0x1 (0xffff) +__uchar 0xfe >> 0x6 == 0x3 (0x3) +__longlong 0xfffe >> 0x6 == -0x1 (0xffff) +__ulonglong 0xfffe >> 0x6 == -0x1 (0xffff) +int 0xfffe + 0xfffc == -0x6 (0xfffa) +__uint 0xfffe + 0xfffc == -0x6 (0xfffa) +char 0xfffe + 0xfffc == -0x6 (0xfffa) +__uchar 0xfe + 0xfc == 0xfa (0xfa) +__longlong 0xfffe + 0xfffc == -0x6 (0xfffa) +__ulonglong 0xfffe + 0xfffc == -0x6 (0xfffa) +float 0xfffe + 0xfffc == -0x6 (0xfffa) +int 0xfffe - 0xfffc == 0x2 (0x2) +__uint 0xfffe - 0xfffc == 0x2 (0x2) +char 0xfffe - 0xfffc == 0x2 (0x2) +__uchar 0xfe - 0xfc == 0x2 (0x2) +__longlong 0xfffe - 0xfffc == 0x2 (0x2) +__ulonglong 0xfffe - 0xfffc == 0x2 (0x2) +float 0xfffe - 0xfffc == 0x2 (0x2) +int 0xfffe * 0xfffc == 0x8 (0x8) +__uint 0xfffe * 0xfffc == 0x8 (0x8) +char 0xfffe * 0xfffc == 0x8 (0x8) +__uchar 0xfe * 0xfc == 0x8 (0x8) +__longlong 0xfffe * 0xfffc == 0x8 (0x8) +__ulonglong 0xfffe * 0xfffc == 0x8 (0x8) +float 0xfffe * 0xfffc == 0x8 (0x8) +int 0xfffe < 0xfffc == 0x0 (0x0) +__uint 0xfffe < 0xfffc == 0x0 (0x0) +char 0xfffe < 0xfffc == 0x0 (0x0) +__uchar 0xfe < 0xfc == 0x0 (0x0) +__longlong 0xfffe < 0xfffc == 0x0 (0x0) +__ulonglong 0xfffe < 0xfffc == 0x0 (0x0) +float 0xfffe < 0xfffc == 0x0 (0x0) +int 0xfffe > 0xfffc == 0x1 (0x1) +__uint 0xfffe > 0xfffc == 0x1 (0x1) +char 0xfffe > 0xfffc == 0x1 (0x1) +__uchar 0xfe > 0xfc == 0x1 (0x1) +__longlong 0xfffe > 0xfffc == 0x1 (0x1) +__ulonglong 0xfffe > 0xfffc == 0x1 (0x1) +float 0xfffe > 0xfffc == 0x1 (0x1) +int 0xfffe <= 0xfffc == 0x0 (0x0) +__uint 0xfffe <= 0xfffc == 0x0 (0x0) +char 0xfffe <= 0xfffc == 0x0 (0x0) +__uchar 0xfe <= 0xfc == 0x0 (0x0) +__longlong 0xfffe <= 0xfffc == 0x0 (0x0) +__ulonglong 0xfffe <= 0xfffc == 0x0 (0x0) +float 0xfffe <= 0xfffc == 0x0 (0x0) +int 0xfffe == 0xfffc == 0x0 (0x0) +__uint 0xfffe == 0xfffc == 0x0 (0x0) +char 0xfffe == 0xfffc == 0x0 (0x0) +__uchar 0xfe == 0xfc == 0x0 (0x0) +__longlong 0xfffe == 0xfffc == 0x0 (0x0) +__ulonglong 0xfffe == 0xfffc == 0x0 (0x0) +float 0xfffe == 0xfffc == 0x0 (0x0) +int 0xfffe != 0xfffc == 0x1 (0x1) +__uint 0xfffe != 0xfffc == 0x1 (0x1) +char 0xfffe != 0xfffc == 0x1 (0x1) +__uchar 0xfe != 0xfc == 0x1 (0x1) +__longlong 0xfffe != 0xfffc == 0x1 (0x1) +__ulonglong 0xfffe != 0xfffc == 0x1 (0x1) +float 0xfffe != 0xfffc == 0x1 (0x1) +int 0xfffe >= 0xfffc == 0x1 (0x1) +__uint 0xfffe >= 0xfffc == 0x1 (0x1) +char 0xfffe >= 0xfffc == 0x1 (0x1) +__uchar 0xfe >= 0xfc == 0x1 (0x1) +__longlong 0xfffe >= 0xfffc == 0x1 (0x1) +__ulonglong 0xfffe >= 0xfffc == 0x1 (0x1) +float 0xfffe >= 0xfffc == 0x1 (0x1) +int 0xfffe / 0xfffc == 0x0 (0x0) +__uint 0xfffe / 0xfffc == 0x1 (0x1) +char 0xfffe / 0xfffc == 0x0 (0x0) +__uchar 0xfe / 0xfc == 0x1 (0x1) +__longlong 0xfffe / 0xfffc == 0x0 (0x0) +__ulonglong 0xfffe / 0xfffc == 0x1 (0x1) +float 0xfffe / 0xfffc == 0x0 (0x0) +int 0xfffe % 0xfffc == -0x2 (0xfffe) +__uint 0xfffe % 0xfffc == 0x2 (0x2) +char 0xfffe % 0xfffc == -0x2 (0xfffe) +__uchar 0xfe % 0xfc == 0x2 (0x2) +__longlong 0xfffe % 0xfffc == -0x2 (0xfffe) +__ulonglong 0xfffe % 0xfffc == 0x2 (0x2) +0xfffe * 0xa == -0x14 +0xfffe / 0xa == 0x0 +0xfffe % 0xa == -0x2 +int 0xfffe ^ 0xa == -0xc (0xfff4) +__uint 0xfffe ^ 0xa == -0xc (0xfff4) +char 0xfffe ^ 0xa == -0xc (0xfff4) +__uchar 0xfe ^ 0xa == 0xf4 (0xf4) +__longlong 0xfffe ^ 0xa == -0xc (0xfff4) +__ulonglong 0xfffe ^ 0xa == -0xc (0xfff4) +int 0xfffe && 0xa == 0x1 (0x1) +__uint 0xfffe && 0xa == 0x1 (0x1) +char 0xfffe && 0xa == 0x1 (0x1) +__uchar 0xfe && 0xa == 0x1 (0x1) +__longlong 0xfffe && 0xa == 0x1 (0x1) +__ulonglong 0xfffe && 0xa == 0x1 (0x1) +int 0xfffe || 0xa == 0x1 (0x1) +__uint 0xfffe || 0xa == 0x1 (0x1) +char 0xfffe || 0xa == 0x1 (0x1) +__uchar 0xfe || 0xa == 0x1 (0x1) +__longlong 0xfffe || 0xa == 0x1 (0x1) +__ulonglong 0xfffe || 0xa == 0x1 (0x1) +int 0xfffe & 0xa == 0xa (0xa) +__uint 0xfffe & 0xa == 0xa (0xa) +char 0xfffe & 0xa == 0xa (0xa) +__uchar 0xfe & 0xa == 0xa (0xa) +__longlong 0xfffe & 0xa == 0xa (0xa) +__ulonglong 0xfffe & 0xa == 0xa (0xa) +int 0xfffe | 0xa == -0x2 (0xfffe) +__uint 0xfffe | 0xa == -0x2 (0xfffe) +char 0xfffe | 0xa == -0x2 (0xfffe) +__uchar 0xfe | 0xa == 0xfe (0xfe) +__longlong 0xfffe | 0xa == -0x2 (0xfffe) +__ulonglong 0xfffe | 0xa == -0x2 (0xfffe) +int 0xfffe << 0x7 == -0x100 (0xff00) +__uint 0xfffe << 0x7 == -0x100 (0xff00) +char 0xfffe << 0x7 == 0x0 (0x0) +__uchar 0xfe << 0x7 == 0x0 (0x0) +__longlong 0xfffe << 0x7 == -0x100 (0xff00) +__ulonglong 0xfffe << 0x7 == -0x100 (0xff00) +int 0xfffe >> 0x7 == -0x1 (0xffff) +__uint 0xfffe >> 0x7 == 0x1ff (0x1ff) +char 0xfffe >> 0x7 == -0x1 (0xffff) +__uchar 0xfe >> 0x7 == 0x1 (0x1) +__longlong 0xfffe >> 0x7 == -0x1 (0xffff) +__ulonglong 0xfffe >> 0x7 == -0x1 (0xffff) +int 0xfffe + 0xa == 0x8 (0x8) +__uint 0xfffe + 0xa == 0x8 (0x8) +char 0xfffe + 0xa == 0x8 (0x8) +__uchar 0xfe + 0xa == 0x8 (0x8) +__longlong 0xfffe + 0xa == 0x8 (0x8) +__ulonglong 0xfffe + 0xa == 0x8 (0x8) +float 0xfffe + 0xa == 0x8 (0x8) +int 0xfffe - 0xa == -0xc (0xfff4) +__uint 0xfffe - 0xa == -0xc (0xfff4) +char 0xfffe - 0xa == -0xc (0xfff4) +__uchar 0xfe - 0xa == 0xf4 (0xf4) +__longlong 0xfffe - 0xa == -0xc (0xfff4) +__ulonglong 0xfffe - 0xa == -0xc (0xfff4) +float 0xfffe - 0xa == -0xc (0xfff4) +int 0xfffe * 0xa == -0x14 (0xffec) +__uint 0xfffe * 0xa == -0x14 (0xffec) +char 0xfffe * 0xa == -0x14 (0xffec) +__uchar 0xfe * 0xa == 0xec (0xec) +__longlong 0xfffe * 0xa == -0x14 (0xffec) +__ulonglong 0xfffe * 0xa == -0x14 (0xffec) +float 0xfffe * 0xa == -0x14 (0xffec) +int 0xfffe < 0xa == 0x1 (0x1) +__uint 0xfffe < 0xa == 0x0 (0x0) +char 0xfffe < 0xa == 0x1 (0x1) +__uchar 0xfe < 0xa == 0x0 (0x0) +__longlong 0xfffe < 0xa == 0x1 (0x1) +__ulonglong 0xfffe < 0xa == 0x0 (0x0) +float 0xfffe < 0xa == 0x1 (0x1) +int 0xfffe > 0xa == 0x0 (0x0) +__uint 0xfffe > 0xa == 0x1 (0x1) +char 0xfffe > 0xa == 0x0 (0x0) +__uchar 0xfe > 0xa == 0x1 (0x1) +__longlong 0xfffe > 0xa == 0x0 (0x0) +__ulonglong 0xfffe > 0xa == 0x1 (0x1) +float 0xfffe > 0xa == 0x0 (0x0) +int 0xfffe <= 0xa == 0x1 (0x1) +__uint 0xfffe <= 0xa == 0x0 (0x0) +char 0xfffe <= 0xa == 0x1 (0x1) +__uchar 0xfe <= 0xa == 0x0 (0x0) +__longlong 0xfffe <= 0xa == 0x1 (0x1) +__ulonglong 0xfffe <= 0xa == 0x0 (0x0) +float 0xfffe <= 0xa == 0x1 (0x1) +int 0xfffe == 0xa == 0x0 (0x0) +__uint 0xfffe == 0xa == 0x0 (0x0) +char 0xfffe == 0xa == 0x0 (0x0) +__uchar 0xfe == 0xa == 0x0 (0x0) +__longlong 0xfffe == 0xa == 0x0 (0x0) +__ulonglong 0xfffe == 0xa == 0x0 (0x0) +float 0xfffe == 0xa == 0x0 (0x0) +int 0xfffe != 0xa == 0x1 (0x1) +__uint 0xfffe != 0xa == 0x1 (0x1) +char 0xfffe != 0xa == 0x1 (0x1) +__uchar 0xfe != 0xa == 0x1 (0x1) +__longlong 0xfffe != 0xa == 0x1 (0x1) +__ulonglong 0xfffe != 0xa == 0x1 (0x1) +float 0xfffe != 0xa == 0x1 (0x1) +int 0xfffe >= 0xa == 0x0 (0x0) +__uint 0xfffe >= 0xa == 0x1 (0x1) +char 0xfffe >= 0xa == 0x0 (0x0) +__uchar 0xfe >= 0xa == 0x1 (0x1) +__longlong 0xfffe >= 0xa == 0x0 (0x0) +__ulonglong 0xfffe >= 0xa == 0x1 (0x1) +float 0xfffe >= 0xa == 0x0 (0x0) +int 0xfffe / 0xa == 0x0 (0x0) +__uint 0xfffe / 0xa == 0x1999 (0x1999) +char 0xfffe / 0xa == 0x0 (0x0) +__uchar 0xfe / 0xa == 0x19 (0x19) +__longlong 0xfffe / 0xa == 0x0 (0x0) +__ulonglong 0xfffe / 0xa == -0x6667 (0x9999) +float 0xfffe / 0xa == 0x0 (0x0) +int 0xfffe % 0xa == -0x2 (0xfffe) +__uint 0xfffe % 0xa == 0x4 (0x4) +char 0xfffe % 0xa == -0x2 (0xfffe) +__uchar 0xfe % 0xa == 0x4 (0x4) +__longlong 0xfffe % 0xa == -0x2 (0xfffe) +__ulonglong 0xfffe % 0xa == 0x4 (0x4) +0xfffe * 0xfff6 == 0x14 +0xfffe / 0xfff6 == 0x0 +0xfffe % 0xfff6 == -0x2 +int 0xfffe ^ 0xfff6 == 0x8 (0x8) +__uint 0xfffe ^ 0xfff6 == 0x8 (0x8) +char 0xfffe ^ 0xfff6 == 0x8 (0x8) +__uchar 0xfe ^ 0xf6 == 0x8 (0x8) +__longlong 0xfffe ^ 0xfff6 == 0x8 (0x8) +__ulonglong 0xfffe ^ 0xfff6 == 0x8 (0x8) +int 0xfffe && 0xfff6 == 0x1 (0x1) +__uint 0xfffe && 0xfff6 == 0x1 (0x1) +char 0xfffe && 0xfff6 == 0x1 (0x1) +__uchar 0xfe && 0xf6 == 0x1 (0x1) +__longlong 0xfffe && 0xfff6 == 0x1 (0x1) +__ulonglong 0xfffe && 0xfff6 == 0x1 (0x1) +int 0xfffe || 0xfff6 == 0x1 (0x1) +__uint 0xfffe || 0xfff6 == 0x1 (0x1) +char 0xfffe || 0xfff6 == 0x1 (0x1) +__uchar 0xfe || 0xf6 == 0x1 (0x1) +__longlong 0xfffe || 0xfff6 == 0x1 (0x1) +__ulonglong 0xfffe || 0xfff6 == 0x1 (0x1) +int 0xfffe & 0xfff6 == -0xa (0xfff6) +__uint 0xfffe & 0xfff6 == -0xa (0xfff6) +char 0xfffe & 0xfff6 == -0xa (0xfff6) +__uchar 0xfe & 0xf6 == 0xf6 (0xf6) +__longlong 0xfffe & 0xfff6 == -0xa (0xfff6) +__ulonglong 0xfffe & 0xfff6 == -0xa (0xfff6) +int 0xfffe | 0xfff6 == -0x2 (0xfffe) +__uint 0xfffe | 0xfff6 == -0x2 (0xfffe) +char 0xfffe | 0xfff6 == -0x2 (0xfffe) +__uchar 0xfe | 0xf6 == 0xfe (0xfe) +__longlong 0xfffe | 0xfff6 == -0x2 (0xfffe) +__ulonglong 0xfffe | 0xfff6 == -0x2 (0xfffe) +int 0xfffe << 0x8 == -0x200 (0xfe00) +__uint 0xfffe << 0x8 == -0x200 (0xfe00) +char 0xfffe << 0x8 == 0x0 (0x0) +__uchar 0xfe << 0x8 == 0x0 (0x0) +__longlong 0xfffe << 0x8 == -0x200 (0xfe00) +__ulonglong 0xfffe << 0x8 == -0x200 (0xfe00) +int 0xfffe >> 0x8 == -0x1 (0xffff) +__uint 0xfffe >> 0x8 == 0xff (0xff) +char 0xfffe >> 0x8 == -0x1 (0xffff) +__uchar 0xfe >> 0x8 == 0x0 (0x0) +__longlong 0xfffe >> 0x8 == -0x1 (0xffff) +__ulonglong 0xfffe >> 0x8 == -0x1 (0xffff) +int 0xfffe + 0xfff6 == -0xc (0xfff4) +__uint 0xfffe + 0xfff6 == -0xc (0xfff4) +char 0xfffe + 0xfff6 == -0xc (0xfff4) +__uchar 0xfe + 0xf6 == 0xf4 (0xf4) +__longlong 0xfffe + 0xfff6 == -0xc (0xfff4) +__ulonglong 0xfffe + 0xfff6 == -0xc (0xfff4) +float 0xfffe + 0xfff6 == -0xc (0xfff4) +int 0xfffe - 0xfff6 == 0x8 (0x8) +__uint 0xfffe - 0xfff6 == 0x8 (0x8) +char 0xfffe - 0xfff6 == 0x8 (0x8) +__uchar 0xfe - 0xf6 == 0x8 (0x8) +__longlong 0xfffe - 0xfff6 == 0x8 (0x8) +__ulonglong 0xfffe - 0xfff6 == 0x8 (0x8) +float 0xfffe - 0xfff6 == 0x8 (0x8) +int 0xfffe * 0xfff6 == 0x14 (0x14) +__uint 0xfffe * 0xfff6 == 0x14 (0x14) +char 0xfffe * 0xfff6 == 0x14 (0x14) +__uchar 0xfe * 0xf6 == 0x14 (0x14) +__longlong 0xfffe * 0xfff6 == 0x14 (0x14) +__ulonglong 0xfffe * 0xfff6 == 0x14 (0x14) +float 0xfffe * 0xfff6 == 0x14 (0x14) +int 0xfffe < 0xfff6 == 0x0 (0x0) +__uint 0xfffe < 0xfff6 == 0x0 (0x0) +char 0xfffe < 0xfff6 == 0x0 (0x0) +__uchar 0xfe < 0xf6 == 0x0 (0x0) +__longlong 0xfffe < 0xfff6 == 0x0 (0x0) +__ulonglong 0xfffe < 0xfff6 == 0x0 (0x0) +float 0xfffe < 0xfff6 == 0x0 (0x0) +int 0xfffe > 0xfff6 == 0x1 (0x1) +__uint 0xfffe > 0xfff6 == 0x1 (0x1) +char 0xfffe > 0xfff6 == 0x1 (0x1) +__uchar 0xfe > 0xf6 == 0x1 (0x1) +__longlong 0xfffe > 0xfff6 == 0x1 (0x1) +__ulonglong 0xfffe > 0xfff6 == 0x1 (0x1) +float 0xfffe > 0xfff6 == 0x1 (0x1) +int 0xfffe <= 0xfff6 == 0x0 (0x0) +__uint 0xfffe <= 0xfff6 == 0x0 (0x0) +char 0xfffe <= 0xfff6 == 0x0 (0x0) +__uchar 0xfe <= 0xf6 == 0x0 (0x0) +__longlong 0xfffe <= 0xfff6 == 0x0 (0x0) +__ulonglong 0xfffe <= 0xfff6 == 0x0 (0x0) +float 0xfffe <= 0xfff6 == 0x0 (0x0) +int 0xfffe == 0xfff6 == 0x0 (0x0) +__uint 0xfffe == 0xfff6 == 0x0 (0x0) +char 0xfffe == 0xfff6 == 0x0 (0x0) +__uchar 0xfe == 0xf6 == 0x0 (0x0) +__longlong 0xfffe == 0xfff6 == 0x0 (0x0) +__ulonglong 0xfffe == 0xfff6 == 0x0 (0x0) +float 0xfffe == 0xfff6 == 0x0 (0x0) +int 0xfffe != 0xfff6 == 0x1 (0x1) +__uint 0xfffe != 0xfff6 == 0x1 (0x1) +char 0xfffe != 0xfff6 == 0x1 (0x1) +__uchar 0xfe != 0xf6 == 0x1 (0x1) +__longlong 0xfffe != 0xfff6 == 0x1 (0x1) +__ulonglong 0xfffe != 0xfff6 == 0x1 (0x1) +float 0xfffe != 0xfff6 == 0x1 (0x1) +int 0xfffe >= 0xfff6 == 0x1 (0x1) +__uint 0xfffe >= 0xfff6 == 0x1 (0x1) +char 0xfffe >= 0xfff6 == 0x1 (0x1) +__uchar 0xfe >= 0xf6 == 0x1 (0x1) +__longlong 0xfffe >= 0xfff6 == 0x1 (0x1) +__ulonglong 0xfffe >= 0xfff6 == 0x1 (0x1) +float 0xfffe >= 0xfff6 == 0x1 (0x1) +int 0xfffe / 0xfff6 == 0x0 (0x0) +__uint 0xfffe / 0xfff6 == 0x1 (0x1) +char 0xfffe / 0xfff6 == 0x0 (0x0) +__uchar 0xfe / 0xf6 == 0x1 (0x1) +__longlong 0xfffe / 0xfff6 == 0x0 (0x0) +__ulonglong 0xfffe / 0xfff6 == 0x1 (0x1) +float 0xfffe / 0xfff6 == 0x0 (0x0) +int 0xfffe % 0xfff6 == -0x2 (0xfffe) +__uint 0xfffe % 0xfff6 == 0x8 (0x8) +char 0xfffe % 0xfff6 == -0x2 (0xfffe) +__uchar 0xfe % 0xf6 == 0x8 (0x8) +__longlong 0xfffe % 0xfff6 == -0x2 (0xfffe) +__ulonglong 0xfffe % 0xfff6 == 0x8 (0x8) +0xfffe * 0x5 == -0xa +0xfffe / 0x5 == 0x0 +0xfffe % 0x5 == -0x2 +int 0xfffe ^ 0x5 == -0x5 (0xfffb) +__uint 0xfffe ^ 0x5 == -0x5 (0xfffb) +char 0xfffe ^ 0x5 == -0x5 (0xfffb) +__uchar 0xfe ^ 0x5 == 0xfb (0xfb) +__longlong 0xfffe ^ 0x5 == -0x5 (0xfffb) +__ulonglong 0xfffe ^ 0x5 == -0x5 (0xfffb) +int 0xfffe && 0x5 == 0x1 (0x1) +__uint 0xfffe && 0x5 == 0x1 (0x1) +char 0xfffe && 0x5 == 0x1 (0x1) +__uchar 0xfe && 0x5 == 0x1 (0x1) +__longlong 0xfffe && 0x5 == 0x1 (0x1) +__ulonglong 0xfffe && 0x5 == 0x1 (0x1) +int 0xfffe || 0x5 == 0x1 (0x1) +__uint 0xfffe || 0x5 == 0x1 (0x1) +char 0xfffe || 0x5 == 0x1 (0x1) +__uchar 0xfe || 0x5 == 0x1 (0x1) +__longlong 0xfffe || 0x5 == 0x1 (0x1) +__ulonglong 0xfffe || 0x5 == 0x1 (0x1) +int 0xfffe & 0x5 == 0x4 (0x4) +__uint 0xfffe & 0x5 == 0x4 (0x4) +char 0xfffe & 0x5 == 0x4 (0x4) +__uchar 0xfe & 0x5 == 0x4 (0x4) +__longlong 0xfffe & 0x5 == 0x4 (0x4) +__ulonglong 0xfffe & 0x5 == 0x4 (0x4) +int 0xfffe | 0x5 == -0x1 (0xffff) +__uint 0xfffe | 0x5 == -0x1 (0xffff) +char 0xfffe | 0x5 == -0x1 (0xffff) +__uchar 0xfe | 0x5 == 0xff (0xff) +__longlong 0xfffe | 0x5 == -0x1 (0xffff) +__ulonglong 0xfffe | 0x5 == -0x1 (0xffff) +int 0xfffe << 0x9 == -0x400 (0xfc00) +__uint 0xfffe << 0x9 == -0x400 (0xfc00) +char 0xfffe << 0x9 == 0x0 (0x0) +__uchar 0xfe << 0x9 == 0x0 (0x0) +__longlong 0xfffe << 0x9 == -0x400 (0xfc00) +__ulonglong 0xfffe << 0x9 == -0x400 (0xfc00) +int 0xfffe >> 0x9 == -0x1 (0xffff) +__uint 0xfffe >> 0x9 == 0x7f (0x7f) +char 0xfffe >> 0x9 == -0x1 (0xffff) +__uchar 0xfe >> 0x9 == 0x0 (0x0) +__longlong 0xfffe >> 0x9 == -0x1 (0xffff) +__ulonglong 0xfffe >> 0x9 == -0x1 (0xffff) +int 0xfffe + 0x5 == 0x3 (0x3) +__uint 0xfffe + 0x5 == 0x3 (0x3) +char 0xfffe + 0x5 == 0x3 (0x3) +__uchar 0xfe + 0x5 == 0x3 (0x3) +__longlong 0xfffe + 0x5 == 0x3 (0x3) +__ulonglong 0xfffe + 0x5 == 0x3 (0x3) +float 0xfffe + 0x5 == 0x3 (0x3) +int 0xfffe - 0x5 == -0x7 (0xfff9) +__uint 0xfffe - 0x5 == -0x7 (0xfff9) +char 0xfffe - 0x5 == -0x7 (0xfff9) +__uchar 0xfe - 0x5 == 0xf9 (0xf9) +__longlong 0xfffe - 0x5 == -0x7 (0xfff9) +__ulonglong 0xfffe - 0x5 == -0x7 (0xfff9) +float 0xfffe - 0x5 == -0x7 (0xfff9) +int 0xfffe * 0x5 == -0xa (0xfff6) +__uint 0xfffe * 0x5 == -0xa (0xfff6) +char 0xfffe * 0x5 == -0xa (0xfff6) +__uchar 0xfe * 0x5 == 0xf6 (0xf6) +__longlong 0xfffe * 0x5 == -0xa (0xfff6) +__ulonglong 0xfffe * 0x5 == -0xa (0xfff6) +float 0xfffe * 0x5 == -0xa (0xfff6) +int 0xfffe < 0x5 == 0x1 (0x1) +__uint 0xfffe < 0x5 == 0x0 (0x0) +char 0xfffe < 0x5 == 0x1 (0x1) +__uchar 0xfe < 0x5 == 0x0 (0x0) +__longlong 0xfffe < 0x5 == 0x1 (0x1) +__ulonglong 0xfffe < 0x5 == 0x0 (0x0) +float 0xfffe < 0x5 == 0x1 (0x1) +int 0xfffe > 0x5 == 0x0 (0x0) +__uint 0xfffe > 0x5 == 0x1 (0x1) +char 0xfffe > 0x5 == 0x0 (0x0) +__uchar 0xfe > 0x5 == 0x1 (0x1) +__longlong 0xfffe > 0x5 == 0x0 (0x0) +__ulonglong 0xfffe > 0x5 == 0x1 (0x1) +float 0xfffe > 0x5 == 0x0 (0x0) +int 0xfffe <= 0x5 == 0x1 (0x1) +__uint 0xfffe <= 0x5 == 0x0 (0x0) +char 0xfffe <= 0x5 == 0x1 (0x1) +__uchar 0xfe <= 0x5 == 0x0 (0x0) +__longlong 0xfffe <= 0x5 == 0x1 (0x1) +__ulonglong 0xfffe <= 0x5 == 0x0 (0x0) +float 0xfffe <= 0x5 == 0x1 (0x1) +int 0xfffe == 0x5 == 0x0 (0x0) +__uint 0xfffe == 0x5 == 0x0 (0x0) +char 0xfffe == 0x5 == 0x0 (0x0) +__uchar 0xfe == 0x5 == 0x0 (0x0) +__longlong 0xfffe == 0x5 == 0x0 (0x0) +__ulonglong 0xfffe == 0x5 == 0x0 (0x0) +float 0xfffe == 0x5 == 0x0 (0x0) +int 0xfffe != 0x5 == 0x1 (0x1) +__uint 0xfffe != 0x5 == 0x1 (0x1) +char 0xfffe != 0x5 == 0x1 (0x1) +__uchar 0xfe != 0x5 == 0x1 (0x1) +__longlong 0xfffe != 0x5 == 0x1 (0x1) +__ulonglong 0xfffe != 0x5 == 0x1 (0x1) +float 0xfffe != 0x5 == 0x1 (0x1) +int 0xfffe >= 0x5 == 0x0 (0x0) +__uint 0xfffe >= 0x5 == 0x1 (0x1) +char 0xfffe >= 0x5 == 0x0 (0x0) +__uchar 0xfe >= 0x5 == 0x1 (0x1) +__longlong 0xfffe >= 0x5 == 0x0 (0x0) +__ulonglong 0xfffe >= 0x5 == 0x1 (0x1) +float 0xfffe >= 0x5 == 0x0 (0x0) +int 0xfffe / 0x5 == 0x0 (0x0) +__uint 0xfffe / 0x5 == 0x3332 (0x3332) +char 0xfffe / 0x5 == 0x0 (0x0) +__uchar 0xfe / 0x5 == 0x32 (0x32) +__longlong 0xfffe / 0x5 == 0x0 (0x0) +__ulonglong 0xfffe / 0x5 == 0x3332 (0x3332) +float 0xfffe / 0x5 == 0x0 (0x0) +int 0xfffe % 0x5 == -0x2 (0xfffe) +__uint 0xfffe % 0x5 == 0x4 (0x4) +char 0xfffe % 0x5 == -0x2 (0xfffe) +__uchar 0xfe % 0x5 == 0x4 (0x4) +__longlong 0xfffe % 0x5 == -0x2 (0xfffe) +__ulonglong 0xfffe % 0x5 == 0x4 (0x4) +0xfffe * 0x7 == -0xe +0xfffe / 0x7 == 0x0 +0xfffe % 0x7 == -0x2 +int 0xfffe ^ 0x7 == -0x7 (0xfff9) +__uint 0xfffe ^ 0x7 == -0x7 (0xfff9) +char 0xfffe ^ 0x7 == -0x7 (0xfff9) +__uchar 0xfe ^ 0x7 == 0xf9 (0xf9) +__longlong 0xfffe ^ 0x7 == -0x7 (0xfff9) +__ulonglong 0xfffe ^ 0x7 == -0x7 (0xfff9) +int 0xfffe && 0x7 == 0x1 (0x1) +__uint 0xfffe && 0x7 == 0x1 (0x1) +char 0xfffe && 0x7 == 0x1 (0x1) +__uchar 0xfe && 0x7 == 0x1 (0x1) +__longlong 0xfffe && 0x7 == 0x1 (0x1) +__ulonglong 0xfffe && 0x7 == 0x1 (0x1) +int 0xfffe || 0x7 == 0x1 (0x1) +__uint 0xfffe || 0x7 == 0x1 (0x1) +char 0xfffe || 0x7 == 0x1 (0x1) +__uchar 0xfe || 0x7 == 0x1 (0x1) +__longlong 0xfffe || 0x7 == 0x1 (0x1) +__ulonglong 0xfffe || 0x7 == 0x1 (0x1) +int 0xfffe & 0x7 == 0x6 (0x6) +__uint 0xfffe & 0x7 == 0x6 (0x6) +char 0xfffe & 0x7 == 0x6 (0x6) +__uchar 0xfe & 0x7 == 0x6 (0x6) +__longlong 0xfffe & 0x7 == 0x6 (0x6) +__ulonglong 0xfffe & 0x7 == 0x6 (0x6) +int 0xfffe | 0x7 == -0x1 (0xffff) +__uint 0xfffe | 0x7 == -0x1 (0xffff) +char 0xfffe | 0x7 == -0x1 (0xffff) +__uchar 0xfe | 0x7 == 0xff (0xff) +__longlong 0xfffe | 0x7 == -0x1 (0xffff) +__ulonglong 0xfffe | 0x7 == -0x1 (0xffff) +int 0xfffe << 0xa == -0x800 (0xf800) +__uint 0xfffe << 0xa == -0x800 (0xf800) +char 0xfffe << 0xa == 0x0 (0x0) +__uchar 0xfe << 0xa == 0x0 (0x0) +__longlong 0xfffe << 0xa == -0x800 (0xf800) +__ulonglong 0xfffe << 0xa == -0x800 (0xf800) +int 0xfffe >> 0xa == -0x1 (0xffff) +__uint 0xfffe >> 0xa == 0x3f (0x3f) +char 0xfffe >> 0xa == -0x1 (0xffff) +__uchar 0xfe >> 0xa == 0x0 (0x0) +__longlong 0xfffe >> 0xa == -0x1 (0xffff) +__ulonglong 0xfffe >> 0xa == -0x1 (0xffff) +int 0xfffe + 0x7 == 0x5 (0x5) +__uint 0xfffe + 0x7 == 0x5 (0x5) +char 0xfffe + 0x7 == 0x5 (0x5) +__uchar 0xfe + 0x7 == 0x5 (0x5) +__longlong 0xfffe + 0x7 == 0x5 (0x5) +__ulonglong 0xfffe + 0x7 == 0x5 (0x5) +float 0xfffe + 0x7 == 0x5 (0x5) +int 0xfffe - 0x7 == -0x9 (0xfff7) +__uint 0xfffe - 0x7 == -0x9 (0xfff7) +char 0xfffe - 0x7 == -0x9 (0xfff7) +__uchar 0xfe - 0x7 == 0xf7 (0xf7) +__longlong 0xfffe - 0x7 == -0x9 (0xfff7) +__ulonglong 0xfffe - 0x7 == -0x9 (0xfff7) +float 0xfffe - 0x7 == -0x9 (0xfff7) +int 0xfffe * 0x7 == -0xe (0xfff2) +__uint 0xfffe * 0x7 == -0xe (0xfff2) +char 0xfffe * 0x7 == -0xe (0xfff2) +__uchar 0xfe * 0x7 == 0xf2 (0xf2) +__longlong 0xfffe * 0x7 == -0xe (0xfff2) +__ulonglong 0xfffe * 0x7 == -0xe (0xfff2) +float 0xfffe * 0x7 == -0xe (0xfff2) +int 0xfffe < 0x7 == 0x1 (0x1) +__uint 0xfffe < 0x7 == 0x0 (0x0) +char 0xfffe < 0x7 == 0x1 (0x1) +__uchar 0xfe < 0x7 == 0x0 (0x0) +__longlong 0xfffe < 0x7 == 0x1 (0x1) +__ulonglong 0xfffe < 0x7 == 0x0 (0x0) +float 0xfffe < 0x7 == 0x1 (0x1) +int 0xfffe > 0x7 == 0x0 (0x0) +__uint 0xfffe > 0x7 == 0x1 (0x1) +char 0xfffe > 0x7 == 0x0 (0x0) +__uchar 0xfe > 0x7 == 0x1 (0x1) +__longlong 0xfffe > 0x7 == 0x0 (0x0) +__ulonglong 0xfffe > 0x7 == 0x1 (0x1) +float 0xfffe > 0x7 == 0x0 (0x0) +int 0xfffe <= 0x7 == 0x1 (0x1) +__uint 0xfffe <= 0x7 == 0x0 (0x0) +char 0xfffe <= 0x7 == 0x1 (0x1) +__uchar 0xfe <= 0x7 == 0x0 (0x0) +__longlong 0xfffe <= 0x7 == 0x1 (0x1) +__ulonglong 0xfffe <= 0x7 == 0x0 (0x0) +float 0xfffe <= 0x7 == 0x1 (0x1) +int 0xfffe == 0x7 == 0x0 (0x0) +__uint 0xfffe == 0x7 == 0x0 (0x0) +char 0xfffe == 0x7 == 0x0 (0x0) +__uchar 0xfe == 0x7 == 0x0 (0x0) +__longlong 0xfffe == 0x7 == 0x0 (0x0) +__ulonglong 0xfffe == 0x7 == 0x0 (0x0) +float 0xfffe == 0x7 == 0x0 (0x0) +int 0xfffe != 0x7 == 0x1 (0x1) +__uint 0xfffe != 0x7 == 0x1 (0x1) +char 0xfffe != 0x7 == 0x1 (0x1) +__uchar 0xfe != 0x7 == 0x1 (0x1) +__longlong 0xfffe != 0x7 == 0x1 (0x1) +__ulonglong 0xfffe != 0x7 == 0x1 (0x1) +float 0xfffe != 0x7 == 0x1 (0x1) +int 0xfffe >= 0x7 == 0x0 (0x0) +__uint 0xfffe >= 0x7 == 0x1 (0x1) +char 0xfffe >= 0x7 == 0x0 (0x0) +__uchar 0xfe >= 0x7 == 0x1 (0x1) +__longlong 0xfffe >= 0x7 == 0x0 (0x0) +__ulonglong 0xfffe >= 0x7 == 0x1 (0x1) +float 0xfffe >= 0x7 == 0x0 (0x0) +int 0xfffe / 0x7 == 0x0 (0x0) +__uint 0xfffe / 0x7 == 0x2492 (0x2492) +char 0xfffe / 0x7 == 0x0 (0x0) +__uchar 0xfe / 0x7 == 0x24 (0x24) +__longlong 0xfffe / 0x7 == 0x0 (0x0) +__ulonglong 0xfffe / 0x7 == 0x4924 (0x4924) +float 0xfffe / 0x7 == 0x0 (0x0) +int 0xfffe % 0x7 == -0x2 (0xfffe) +__uint 0xfffe % 0x7 == 0x0 (0x0) +char 0xfffe % 0x7 == -0x2 (0xfffe) +__uchar 0xfe % 0x7 == 0x2 (0x2) +__longlong 0xfffe % 0x7 == -0x2 (0xfffe) +__ulonglong 0xfffe % 0x7 == 0x2 (0x2) +0xfffe * 0x2a == -0x54 +0xfffe / 0x2a == 0x0 +0xfffe % 0x2a == -0x2 +int 0xfffe ^ 0x2a == -0x2c (0xffd4) +__uint 0xfffe ^ 0x2a == -0x2c (0xffd4) +char 0xfffe ^ 0x2a == -0x2c (0xffd4) +__uchar 0xfe ^ 0x2a == 0xd4 (0xd4) +__longlong 0xfffe ^ 0x2a == -0x2c (0xffd4) +__ulonglong 0xfffe ^ 0x2a == -0x2c (0xffd4) +int 0xfffe && 0x2a == 0x1 (0x1) +__uint 0xfffe && 0x2a == 0x1 (0x1) +char 0xfffe && 0x2a == 0x1 (0x1) +__uchar 0xfe && 0x2a == 0x1 (0x1) +__longlong 0xfffe && 0x2a == 0x1 (0x1) +__ulonglong 0xfffe && 0x2a == 0x1 (0x1) +int 0xfffe || 0x2a == 0x1 (0x1) +__uint 0xfffe || 0x2a == 0x1 (0x1) +char 0xfffe || 0x2a == 0x1 (0x1) +__uchar 0xfe || 0x2a == 0x1 (0x1) +__longlong 0xfffe || 0x2a == 0x1 (0x1) +__ulonglong 0xfffe || 0x2a == 0x1 (0x1) +int 0xfffe & 0x2a == 0x2a (0x2a) +__uint 0xfffe & 0x2a == 0x2a (0x2a) +char 0xfffe & 0x2a == 0x2a (0x2a) +__uchar 0xfe & 0x2a == 0x2a (0x2a) +__longlong 0xfffe & 0x2a == 0x2a (0x2a) +__ulonglong 0xfffe & 0x2a == 0x2a (0x2a) +int 0xfffe | 0x2a == -0x2 (0xfffe) +__uint 0xfffe | 0x2a == -0x2 (0xfffe) +char 0xfffe | 0x2a == -0x2 (0xfffe) +__uchar 0xfe | 0x2a == 0xfe (0xfe) +__longlong 0xfffe | 0x2a == -0x2 (0xfffe) +__ulonglong 0xfffe | 0x2a == -0x2 (0xfffe) +int 0xfffe << 0xc == -0x2000 (0xe000) +__uint 0xfffe << 0xc == -0x2000 (0xe000) +char 0xfffe << 0xc == 0x0 (0x0) +__uchar 0xfe << 0xc == 0x0 (0x0) +__longlong 0xfffe << 0xc == -0x2000 (0xe000) +__ulonglong 0xfffe << 0xc == -0x2000 (0xe000) +int 0xfffe >> 0xc == -0x1 (0xffff) +__uint 0xfffe >> 0xc == 0xf (0xf) +char 0xfffe >> 0xc == -0x1 (0xffff) +__uchar 0xfe >> 0xc == 0x0 (0x0) +__longlong 0xfffe >> 0xc == -0x1 (0xffff) +__ulonglong 0xfffe >> 0xc == -0x1 (0xffff) +int 0xfffe + 0x2a == 0x28 (0x28) +__uint 0xfffe + 0x2a == 0x28 (0x28) +char 0xfffe + 0x2a == 0x28 (0x28) +__uchar 0xfe + 0x2a == 0x28 (0x28) +__longlong 0xfffe + 0x2a == 0x28 (0x28) +__ulonglong 0xfffe + 0x2a == 0x28 (0x28) +float 0xfffe + 0x2a == 0x28 (0x28) +int 0xfffe - 0x2a == -0x2c (0xffd4) +__uint 0xfffe - 0x2a == -0x2c (0xffd4) +char 0xfffe - 0x2a == -0x2c (0xffd4) +__uchar 0xfe - 0x2a == 0xd4 (0xd4) +__longlong 0xfffe - 0x2a == -0x2c (0xffd4) +__ulonglong 0xfffe - 0x2a == -0x2c (0xffd4) +float 0xfffe - 0x2a == -0x2c (0xffd4) +int 0xfffe * 0x2a == -0x54 (0xffac) +__uint 0xfffe * 0x2a == -0x54 (0xffac) +char 0xfffe * 0x2a == -0x54 (0xffac) +__uchar 0xfe * 0x2a == 0xac (0xac) +__longlong 0xfffe * 0x2a == -0x54 (0xffac) +__ulonglong 0xfffe * 0x2a == -0x54 (0xffac) +float 0xfffe * 0x2a == -0x54 (0xffac) +int 0xfffe < 0x2a == 0x1 (0x1) +__uint 0xfffe < 0x2a == 0x0 (0x0) +char 0xfffe < 0x2a == 0x1 (0x1) +__uchar 0xfe < 0x2a == 0x0 (0x0) +__longlong 0xfffe < 0x2a == 0x1 (0x1) +__ulonglong 0xfffe < 0x2a == 0x0 (0x0) +float 0xfffe < 0x2a == 0x1 (0x1) +int 0xfffe > 0x2a == 0x0 (0x0) +__uint 0xfffe > 0x2a == 0x1 (0x1) +char 0xfffe > 0x2a == 0x0 (0x0) +__uchar 0xfe > 0x2a == 0x1 (0x1) +__longlong 0xfffe > 0x2a == 0x0 (0x0) +__ulonglong 0xfffe > 0x2a == 0x1 (0x1) +float 0xfffe > 0x2a == 0x0 (0x0) +int 0xfffe <= 0x2a == 0x1 (0x1) +__uint 0xfffe <= 0x2a == 0x0 (0x0) +char 0xfffe <= 0x2a == 0x1 (0x1) +__uchar 0xfe <= 0x2a == 0x0 (0x0) +__longlong 0xfffe <= 0x2a == 0x1 (0x1) +__ulonglong 0xfffe <= 0x2a == 0x0 (0x0) +float 0xfffe <= 0x2a == 0x1 (0x1) +int 0xfffe == 0x2a == 0x0 (0x0) +__uint 0xfffe == 0x2a == 0x0 (0x0) +char 0xfffe == 0x2a == 0x0 (0x0) +__uchar 0xfe == 0x2a == 0x0 (0x0) +__longlong 0xfffe == 0x2a == 0x0 (0x0) +__ulonglong 0xfffe == 0x2a == 0x0 (0x0) +float 0xfffe == 0x2a == 0x0 (0x0) +int 0xfffe != 0x2a == 0x1 (0x1) +__uint 0xfffe != 0x2a == 0x1 (0x1) +char 0xfffe != 0x2a == 0x1 (0x1) +__uchar 0xfe != 0x2a == 0x1 (0x1) +__longlong 0xfffe != 0x2a == 0x1 (0x1) +__ulonglong 0xfffe != 0x2a == 0x1 (0x1) +float 0xfffe != 0x2a == 0x1 (0x1) +int 0xfffe >= 0x2a == 0x0 (0x0) +__uint 0xfffe >= 0x2a == 0x1 (0x1) +char 0xfffe >= 0x2a == 0x0 (0x0) +__uchar 0xfe >= 0x2a == 0x1 (0x1) +__longlong 0xfffe >= 0x2a == 0x0 (0x0) +__ulonglong 0xfffe >= 0x2a == 0x1 (0x1) +float 0xfffe >= 0x2a == 0x0 (0x0) +int 0xfffe / 0x2a == 0x0 (0x0) +__uint 0xfffe / 0x2a == 0x618 (0x618) +char 0xfffe / 0x2a == 0x0 (0x0) +__uchar 0xfe / 0x2a == 0x6 (0x6) +__longlong 0xfffe / 0x2a == 0x0 (0x0) +__ulonglong 0xfffe / 0x2a == 0x6186 (0x6186) +float 0xfffe / 0x2a == 0x0 (0x0) +int 0xfffe % 0x2a == -0x2 (0xfffe) +__uint 0xfffe % 0x2a == 0xe (0xe) +char 0xfffe % 0x2a == -0x2 (0xfffe) +__uchar 0xfe % 0x2a == 0x2 (0x2) +__longlong 0xfffe % 0x2a == -0x2 (0xfffe) +__ulonglong 0xfffe % 0x2a == 0x2 (0x2) +0xfffe * 0x17 == -0x2e +0xfffe / 0x17 == 0x0 +0xfffe % 0x17 == -0x2 +int 0xfffe ^ 0x17 == -0x17 (0xffe9) +__uint 0xfffe ^ 0x17 == -0x17 (0xffe9) +char 0xfffe ^ 0x17 == -0x17 (0xffe9) +__uchar 0xfe ^ 0x17 == 0xe9 (0xe9) +__longlong 0xfffe ^ 0x17 == -0x17 (0xffe9) +__ulonglong 0xfffe ^ 0x17 == -0x17 (0xffe9) +int 0xfffe && 0x17 == 0x1 (0x1) +__uint 0xfffe && 0x17 == 0x1 (0x1) +char 0xfffe && 0x17 == 0x1 (0x1) +__uchar 0xfe && 0x17 == 0x1 (0x1) +__longlong 0xfffe && 0x17 == 0x1 (0x1) +__ulonglong 0xfffe && 0x17 == 0x1 (0x1) +int 0xfffe || 0x17 == 0x1 (0x1) +__uint 0xfffe || 0x17 == 0x1 (0x1) +char 0xfffe || 0x17 == 0x1 (0x1) +__uchar 0xfe || 0x17 == 0x1 (0x1) +__longlong 0xfffe || 0x17 == 0x1 (0x1) +__ulonglong 0xfffe || 0x17 == 0x1 (0x1) +int 0xfffe & 0x17 == 0x16 (0x16) +__uint 0xfffe & 0x17 == 0x16 (0x16) +char 0xfffe & 0x17 == 0x16 (0x16) +__uchar 0xfe & 0x17 == 0x16 (0x16) +__longlong 0xfffe & 0x17 == 0x16 (0x16) +__ulonglong 0xfffe & 0x17 == 0x16 (0x16) +int 0xfffe | 0x17 == -0x1 (0xffff) +__uint 0xfffe | 0x17 == -0x1 (0xffff) +char 0xfffe | 0x17 == -0x1 (0xffff) +__uchar 0xfe | 0x17 == 0xff (0xff) +__longlong 0xfffe | 0x17 == -0x1 (0xffff) +__ulonglong 0xfffe | 0x17 == -0x1 (0xffff) +int 0xfffe << 0xe == -0x8000 (0x8000) +__uint 0xfffe << 0xe == -0x8000 (0x8000) +char 0xfffe << 0xe == 0x0 (0x0) +__uchar 0xfe << 0xe == 0x0 (0x0) +__longlong 0xfffe << 0xe == -0x8000 (0x8000) +__ulonglong 0xfffe << 0xe == -0x8000 (0x8000) +int 0xfffe >> 0xe == -0x1 (0xffff) +__uint 0xfffe >> 0xe == 0x3 (0x3) +char 0xfffe >> 0xe == -0x1 (0xffff) +__uchar 0xfe >> 0xe == 0x0 (0x0) +__longlong 0xfffe >> 0xe == -0x1 (0xffff) +__ulonglong 0xfffe >> 0xe == -0x1 (0xffff) +int 0xfffe + 0x17 == 0x15 (0x15) +__uint 0xfffe + 0x17 == 0x15 (0x15) +char 0xfffe + 0x17 == 0x15 (0x15) +__uchar 0xfe + 0x17 == 0x15 (0x15) +__longlong 0xfffe + 0x17 == 0x15 (0x15) +__ulonglong 0xfffe + 0x17 == 0x15 (0x15) +float 0xfffe + 0x17 == 0x15 (0x15) +int 0xfffe - 0x17 == -0x19 (0xffe7) +__uint 0xfffe - 0x17 == -0x19 (0xffe7) +char 0xfffe - 0x17 == -0x19 (0xffe7) +__uchar 0xfe - 0x17 == 0xe7 (0xe7) +__longlong 0xfffe - 0x17 == -0x19 (0xffe7) +__ulonglong 0xfffe - 0x17 == -0x19 (0xffe7) +float 0xfffe - 0x17 == -0x19 (0xffe7) +int 0xfffe * 0x17 == -0x2e (0xffd2) +__uint 0xfffe * 0x17 == -0x2e (0xffd2) +char 0xfffe * 0x17 == -0x2e (0xffd2) +__uchar 0xfe * 0x17 == 0xd2 (0xd2) +__longlong 0xfffe * 0x17 == -0x2e (0xffd2) +__ulonglong 0xfffe * 0x17 == -0x2e (0xffd2) +float 0xfffe * 0x17 == -0x2e (0xffd2) +int 0xfffe < 0x17 == 0x1 (0x1) +__uint 0xfffe < 0x17 == 0x0 (0x0) +char 0xfffe < 0x17 == 0x1 (0x1) +__uchar 0xfe < 0x17 == 0x0 (0x0) +__longlong 0xfffe < 0x17 == 0x1 (0x1) +__ulonglong 0xfffe < 0x17 == 0x0 (0x0) +float 0xfffe < 0x17 == 0x1 (0x1) +int 0xfffe > 0x17 == 0x0 (0x0) +__uint 0xfffe > 0x17 == 0x1 (0x1) +char 0xfffe > 0x17 == 0x0 (0x0) +__uchar 0xfe > 0x17 == 0x1 (0x1) +__longlong 0xfffe > 0x17 == 0x0 (0x0) +__ulonglong 0xfffe > 0x17 == 0x1 (0x1) +float 0xfffe > 0x17 == 0x0 (0x0) +int 0xfffe <= 0x17 == 0x1 (0x1) +__uint 0xfffe <= 0x17 == 0x0 (0x0) +char 0xfffe <= 0x17 == 0x1 (0x1) +__uchar 0xfe <= 0x17 == 0x0 (0x0) +__longlong 0xfffe <= 0x17 == 0x1 (0x1) +__ulonglong 0xfffe <= 0x17 == 0x0 (0x0) +float 0xfffe <= 0x17 == 0x1 (0x1) +int 0xfffe == 0x17 == 0x0 (0x0) +__uint 0xfffe == 0x17 == 0x0 (0x0) +char 0xfffe == 0x17 == 0x0 (0x0) +__uchar 0xfe == 0x17 == 0x0 (0x0) +__longlong 0xfffe == 0x17 == 0x0 (0x0) +__ulonglong 0xfffe == 0x17 == 0x0 (0x0) +float 0xfffe == 0x17 == 0x0 (0x0) +int 0xfffe != 0x17 == 0x1 (0x1) +__uint 0xfffe != 0x17 == 0x1 (0x1) +char 0xfffe != 0x17 == 0x1 (0x1) +__uchar 0xfe != 0x17 == 0x1 (0x1) +__longlong 0xfffe != 0x17 == 0x1 (0x1) +__ulonglong 0xfffe != 0x17 == 0x1 (0x1) +float 0xfffe != 0x17 == 0x1 (0x1) +int 0xfffe >= 0x17 == 0x0 (0x0) +__uint 0xfffe >= 0x17 == 0x1 (0x1) +char 0xfffe >= 0x17 == 0x0 (0x0) +__uchar 0xfe >= 0x17 == 0x1 (0x1) +__longlong 0xfffe >= 0x17 == 0x0 (0x0) +__ulonglong 0xfffe >= 0x17 == 0x1 (0x1) +float 0xfffe >= 0x17 == 0x0 (0x0) +int 0xfffe / 0x17 == 0x0 (0x0) +__uint 0xfffe / 0x17 == 0xb21 (0xb21) +char 0xfffe / 0x17 == 0x0 (0x0) +__uchar 0xfe / 0x17 == 0xb (0xb) +__longlong 0xfffe / 0x17 == 0x0 (0x0) +__ulonglong 0xfffe / 0x17 == 0x642c (0x642c) +float 0xfffe / 0x17 == 0x0 (0x0) +int 0xfffe % 0x17 == -0x2 (0xfffe) +__uint 0xfffe % 0x17 == 0x7 (0x7) +char 0xfffe % 0x17 == -0x2 (0xfffe) +__uchar 0xfe % 0x17 == 0x1 (0x1) +__longlong 0xfffe % 0x17 == -0x2 (0xfffe) +__ulonglong 0xfffe % 0x17 == 0xa (0xa) +0xfffe * 0x7fff == 0x2 +0xfffe / 0x7fff == 0x0 +0xfffe % 0x7fff == -0x2 +int 0xfffe ^ 0x7fff == -0x7fff (0x8001) +__uint 0xfffe ^ 0x7fff == -0x7fff (0x8001) +char 0xfffe ^ 0xffff == 0x1 (0x1) +__uchar 0xfe ^ 0xff == 0x1 (0x1) +__longlong 0xfffe ^ 0x7fff == -0x7fff (0x8001) +__ulonglong 0xfffe ^ 0x7fff == -0x7fff (0x8001) +int 0xfffe && 0x7fff == 0x1 (0x1) +__uint 0xfffe && 0x7fff == 0x1 (0x1) +char 0xfffe && 0xffff == 0x1 (0x1) +__uchar 0xfe && 0xff == 0x1 (0x1) +__longlong 0xfffe && 0x7fff == 0x1 (0x1) +__ulonglong 0xfffe && 0x7fff == 0x1 (0x1) +int 0xfffe || 0x7fff == 0x1 (0x1) +__uint 0xfffe || 0x7fff == 0x1 (0x1) +char 0xfffe || 0xffff == 0x1 (0x1) +__uchar 0xfe || 0xff == 0x1 (0x1) +__longlong 0xfffe || 0x7fff == 0x1 (0x1) +__ulonglong 0xfffe || 0x7fff == 0x1 (0x1) +int 0xfffe & 0x7fff == 0x7ffe (0x7ffe) +__uint 0xfffe & 0x7fff == 0x7ffe (0x7ffe) +char 0xfffe & 0xffff == -0x2 (0xfffe) +__uchar 0xfe & 0xff == 0xfe (0xfe) +__longlong 0xfffe & 0x7fff == 0x7ffe (0x7ffe) +__ulonglong 0xfffe & 0x7fff == 0x7ffe (0x7ffe) +int 0xfffe | 0x7fff == -0x1 (0xffff) +__uint 0xfffe | 0x7fff == -0x1 (0xffff) +char 0xfffe | 0xffff == -0x1 (0xffff) +__uchar 0xfe | 0xff == 0xff (0xff) +__longlong 0xfffe | 0x7fff == -0x1 (0xffff) +__ulonglong 0xfffe | 0x7fff == -0x1 (0xffff) +int 0xfffe << 0x10 == 0x0 (0x0) +__uint 0xfffe << 0x10 == 0x0 (0x0) +char 0xfffe << 0x10 == 0x0 (0x0) +__uchar 0xfe << 0x10 == 0x0 (0x0) +__longlong 0xfffe << 0x10 == 0x0 (0x0) +__ulonglong 0xfffe << 0x10 == 0x0 (0x0) +int 0xfffe >> 0x10 == -0x1 (0xffff) +__uint 0xfffe >> 0x10 == 0x0 (0x0) +char 0xfffe >> 0x10 == -0x1 (0xffff) +__uchar 0xfe >> 0x10 == 0x0 (0x0) +__longlong 0xfffe >> 0x10 == -0x1 (0xffff) +__ulonglong 0xfffe >> 0x10 == -0x1 (0xffff) +int 0xfffe + 0x7fff == 0x7ffd (0x7ffd) +__uint 0xfffe + 0x7fff == 0x7ffd (0x7ffd) +char 0xfffe + 0xffff == -0x3 (0xfffd) +__uchar 0xfe + 0xff == 0xfd (0xfd) +__longlong 0xfffe + 0x7fff == 0x7ffd (0x7ffd) +__ulonglong 0xfffe + 0x7fff == 0x7ffd (0x7ffd) +float 0xfffe + 0x7fff == 0x7ffd (0x7ffd) +int 0xfffe - 0x7fff == 0x7fff (0x7fff) +__uint 0xfffe - 0x7fff == 0x7fff (0x7fff) +char 0xfffe - 0xffff == -0x1 (0xffff) +__uchar 0xfe - 0xff == 0xff (0xff) +__longlong 0xfffe - 0x7fff == 0x7fff (0x7fff) +__ulonglong 0xfffe - 0x7fff == 0x7fff (0x7fff) +float 0xfffe - 0x7fff == -0x8000 (0x8000) +int 0xfffe * 0x7fff == 0x2 (0x2) +__uint 0xfffe * 0x7fff == 0x2 (0x2) +char 0xfffe * 0xffff == 0x2 (0x2) +__uchar 0xfe * 0xff == 0x2 (0x2) +__longlong 0xfffe * 0x7fff == 0x2 (0x2) +__ulonglong 0xfffe * 0x7fff == 0x2 (0x2) +float 0xfffe * 0x7fff == -0x8000 (0x8000) +int 0xfffe < 0x7fff == 0x1 (0x1) +__uint 0xfffe < 0x7fff == 0x0 (0x0) +char 0xfffe < 0xffff == 0x1 (0x1) +__uchar 0xfe < 0xff == 0x1 (0x1) +__longlong 0xfffe < 0x7fff == 0x1 (0x1) +__ulonglong 0xfffe < 0x7fff == 0x0 (0x0) +float 0xfffe < 0x7fff == 0x1 (0x1) +int 0xfffe > 0x7fff == 0x0 (0x0) +__uint 0xfffe > 0x7fff == 0x1 (0x1) +char 0xfffe > 0xffff == 0x0 (0x0) +__uchar 0xfe > 0xff == 0x0 (0x0) +__longlong 0xfffe > 0x7fff == 0x0 (0x0) +__ulonglong 0xfffe > 0x7fff == 0x1 (0x1) +float 0xfffe > 0x7fff == 0x0 (0x0) +int 0xfffe <= 0x7fff == 0x1 (0x1) +__uint 0xfffe <= 0x7fff == 0x0 (0x0) +char 0xfffe <= 0xffff == 0x1 (0x1) +__uchar 0xfe <= 0xff == 0x1 (0x1) +__longlong 0xfffe <= 0x7fff == 0x1 (0x1) +__ulonglong 0xfffe <= 0x7fff == 0x0 (0x0) +float 0xfffe <= 0x7fff == 0x1 (0x1) +int 0xfffe == 0x7fff == 0x0 (0x0) +__uint 0xfffe == 0x7fff == 0x0 (0x0) +char 0xfffe == 0xffff == 0x0 (0x0) +__uchar 0xfe == 0xff == 0x0 (0x0) +__longlong 0xfffe == 0x7fff == 0x0 (0x0) +__ulonglong 0xfffe == 0x7fff == 0x0 (0x0) +float 0xfffe == 0x7fff == 0x0 (0x0) +int 0xfffe != 0x7fff == 0x1 (0x1) +__uint 0xfffe != 0x7fff == 0x1 (0x1) +char 0xfffe != 0xffff == 0x1 (0x1) +__uchar 0xfe != 0xff == 0x1 (0x1) +__longlong 0xfffe != 0x7fff == 0x1 (0x1) +__ulonglong 0xfffe != 0x7fff == 0x1 (0x1) +float 0xfffe != 0x7fff == 0x1 (0x1) +int 0xfffe >= 0x7fff == 0x0 (0x0) +__uint 0xfffe >= 0x7fff == 0x1 (0x1) +char 0xfffe >= 0xffff == 0x0 (0x0) +__uchar 0xfe >= 0xff == 0x0 (0x0) +__longlong 0xfffe >= 0x7fff == 0x0 (0x0) +__ulonglong 0xfffe >= 0x7fff == 0x1 (0x1) +float 0xfffe >= 0x7fff == 0x0 (0x0) +int 0xfffe / 0x7fff == 0x0 (0x0) +__uint 0xfffe / 0x7fff == 0x2 (0x2) +char 0xfffe / 0xffff == 0x2 (0x2) +__uchar 0xfe / 0xff == 0x0 (0x0) +__longlong 0xfffe / 0x7fff == 0x0 (0x0) +__ulonglong 0xfffe / 0x7fff == 0x4 (0x4) +float 0xfffe / 0x7fff == 0x0 (0x0) +int 0xfffe % 0x7fff == -0x2 (0xfffe) +__uint 0xfffe % 0x7fff == 0x0 (0x0) +char 0xfffe % 0xffff == 0x0 (0x0) +__uchar 0xfe % 0xff == 0xfe (0xfe) +__longlong 0xfffe % 0x7fff == -0x2 (0xfffe) +__ulonglong 0xfffe % 0x7fff == 0x2 (0x2) +0xfffe * 0x8000 == 0x0 +0xfffe / 0x8000 == 0x0 +0xfffe % 0x8000 == -0x2 +int 0xfffe ^ 0x8000 == 0x7ffe (0x7ffe) +__uint 0xfffe ^ 0x8000 == 0x7ffe (0x7ffe) +char 0xfffe ^ 0x0 == -0x2 (0xfffe) +__uchar 0xfe ^ 0x0 == 0xfe (0xfe) +__longlong 0xfffe ^ 0x8000 == 0x7ffe (0x7ffe) +__ulonglong 0xfffe ^ 0x8000 == 0x7ffe (0x7ffe) +int 0xfffe && 0x8000 == 0x1 (0x1) +__uint 0xfffe && 0x8000 == 0x1 (0x1) +char 0xfffe && 0x0 == 0x0 (0x0) +__uchar 0xfe && 0x0 == 0x0 (0x0) +__longlong 0xfffe && 0x8000 == 0x1 (0x1) +__ulonglong 0xfffe && 0x8000 == 0x1 (0x1) +int 0xfffe || 0x8000 == 0x1 (0x1) +__uint 0xfffe || 0x8000 == 0x1 (0x1) +char 0xfffe || 0x0 == 0x1 (0x1) +__uchar 0xfe || 0x0 == 0x1 (0x1) +__longlong 0xfffe || 0x8000 == 0x1 (0x1) +__ulonglong 0xfffe || 0x8000 == 0x1 (0x1) +int 0xfffe & 0x8000 == -0x8000 (0x8000) +__uint 0xfffe & 0x8000 == -0x8000 (0x8000) +char 0xfffe & 0x0 == 0x0 (0x0) +__uchar 0xfe & 0x0 == 0x0 (0x0) +__longlong 0xfffe & 0x8000 == -0x8000 (0x8000) +__ulonglong 0xfffe & 0x8000 == -0x8000 (0x8000) +int 0xfffe | 0x8000 == -0x2 (0xfffe) +__uint 0xfffe | 0x8000 == -0x2 (0xfffe) +char 0xfffe | 0x0 == -0x2 (0xfffe) +__uchar 0xfe | 0x0 == 0xfe (0xfe) +__longlong 0xfffe | 0x8000 == -0x2 (0xfffe) +__ulonglong 0xfffe | 0x8000 == -0x2 (0xfffe) +int 0xfffe << 0x12 == 0x0 (0x0) +__uint 0xfffe << 0x12 == 0x0 (0x0) +char 0xfffe << 0x12 == 0x0 (0x0) +__uchar 0xfe << 0x12 == 0x0 (0x0) +__longlong 0xfffe << 0x12 == 0x0 (0x0) +__ulonglong 0xfffe << 0x12 == 0x0 (0x0) +int 0xfffe >> 0x12 == -0x1 (0xffff) +__uint 0xfffe >> 0x12 == 0x0 (0x0) +char 0xfffe >> 0x12 == -0x1 (0xffff) +__uchar 0xfe >> 0x12 == 0x0 (0x0) +__longlong 0xfffe >> 0x12 == -0x1 (0xffff) +__ulonglong 0xfffe >> 0x12 == 0x3fff (0x3fff) +int 0xfffe + 0x8000 == 0x7ffe (0x7ffe) +__uint 0xfffe + 0x8000 == 0x7ffe (0x7ffe) +char 0xfffe + 0x0 == -0x2 (0xfffe) +__uchar 0xfe + 0x0 == 0xfe (0xfe) +__longlong 0xfffe + 0x8000 == 0x7ffe (0x7ffe) +__ulonglong 0xfffe + 0x8000 == 0x7ffe (0x7ffe) +float 0xfffe + 0x8000 == -0x8000 (0x8000) +int 0xfffe - 0x8000 == 0x7ffe (0x7ffe) +__uint 0xfffe - 0x8000 == 0x7ffe (0x7ffe) +char 0xfffe - 0x0 == -0x2 (0xfffe) +__uchar 0xfe - 0x0 == 0xfe (0xfe) +__longlong 0xfffe - 0x8000 == 0x7ffe (0x7ffe) +__ulonglong 0xfffe - 0x8000 == 0x7ffe (0x7ffe) +float 0xfffe - 0x8000 == 0x7ffe (0x7ffe) +int 0xfffe * 0x8000 == 0x0 (0x0) +__uint 0xfffe * 0x8000 == 0x0 (0x0) +char 0xfffe * 0x0 == 0x0 (0x0) +__uchar 0xfe * 0x0 == 0x0 (0x0) +__longlong 0xfffe * 0x8000 == 0x0 (0x0) +__ulonglong 0xfffe * 0x8000 == 0x0 (0x0) +float 0xfffe * 0x8000 == -0x8000 (0x8000) +int 0xfffe < 0x8000 == 0x0 (0x0) +__uint 0xfffe < 0x8000 == 0x0 (0x0) +char 0xfffe < 0x0 == 0x1 (0x1) +__uchar 0xfe < 0x0 == 0x0 (0x0) +__longlong 0xfffe < 0x8000 == 0x0 (0x0) +__ulonglong 0xfffe < 0x8000 == 0x0 (0x0) +float 0xfffe < 0x8000 == 0x0 (0x0) +int 0xfffe > 0x8000 == 0x1 (0x1) +__uint 0xfffe > 0x8000 == 0x1 (0x1) +char 0xfffe > 0x0 == 0x0 (0x0) +__uchar 0xfe > 0x0 == 0x1 (0x1) +__longlong 0xfffe > 0x8000 == 0x1 (0x1) +__ulonglong 0xfffe > 0x8000 == 0x1 (0x1) +float 0xfffe > 0x8000 == 0x1 (0x1) +int 0xfffe <= 0x8000 == 0x0 (0x0) +__uint 0xfffe <= 0x8000 == 0x0 (0x0) +char 0xfffe <= 0x0 == 0x1 (0x1) +__uchar 0xfe <= 0x0 == 0x0 (0x0) +__longlong 0xfffe <= 0x8000 == 0x0 (0x0) +__ulonglong 0xfffe <= 0x8000 == 0x0 (0x0) +float 0xfffe <= 0x8000 == 0x0 (0x0) +int 0xfffe == 0x8000 == 0x0 (0x0) +__uint 0xfffe == 0x8000 == 0x0 (0x0) +char 0xfffe == 0x0 == 0x0 (0x0) +__uchar 0xfe == 0x0 == 0x0 (0x0) +__longlong 0xfffe == 0x8000 == 0x0 (0x0) +__ulonglong 0xfffe == 0x8000 == 0x0 (0x0) +float 0xfffe == 0x8000 == 0x0 (0x0) +int 0xfffe != 0x8000 == 0x1 (0x1) +__uint 0xfffe != 0x8000 == 0x1 (0x1) +char 0xfffe != 0x0 == 0x1 (0x1) +__uchar 0xfe != 0x0 == 0x1 (0x1) +__longlong 0xfffe != 0x8000 == 0x1 (0x1) +__ulonglong 0xfffe != 0x8000 == 0x1 (0x1) +float 0xfffe != 0x8000 == 0x1 (0x1) +int 0xfffe >= 0x8000 == 0x1 (0x1) +__uint 0xfffe >= 0x8000 == 0x1 (0x1) +char 0xfffe >= 0x0 == 0x0 (0x0) +__uchar 0xfe >= 0x0 == 0x1 (0x1) +__longlong 0xfffe >= 0x8000 == 0x1 (0x1) +__ulonglong 0xfffe >= 0x8000 == 0x1 (0x1) +float 0xfffe >= 0x8000 == 0x1 (0x1) +int 0xfffe / 0x8000 == 0x0 (0x0) +__uint 0xfffe / 0x8000 == 0x1 (0x1) +__longlong 0xfffe / 0x8000 == 0x0 (0x0) +__ulonglong 0xfffe / 0x8000 == 0x1 (0x1) +float 0xfffe / 0x8000 == 0x0 (0x0) +int 0xfffe % 0x8000 == -0x2 (0xfffe) +__uint 0xfffe % 0x8000 == 0x7ffe (0x7ffe) +__longlong 0xfffe % 0x8000 == -0x2 (0xfffe) +__ulonglong 0xfffe % 0x8000 == 0x7ffe (0x7ffe) +0xfffe * 0x3e8 == -0x7d0 +0xfffe / 0x3e8 == 0x0 +0xfffe % 0x3e8 == -0x2 +int 0xfffe ^ 0x3e8 == -0x3ea (0xfc16) +__uint 0xfffe ^ 0x3e8 == -0x3ea (0xfc16) +char 0xfffe ^ 0xffe8 == 0x16 (0x16) +__uchar 0xfe ^ 0xe8 == 0x16 (0x16) +__longlong 0xfffe ^ 0x3e8 == -0x3ea (0xfc16) +__ulonglong 0xfffe ^ 0x3e8 == -0x3ea (0xfc16) +int 0xfffe && 0x3e8 == 0x1 (0x1) +__uint 0xfffe && 0x3e8 == 0x1 (0x1) +char 0xfffe && 0xffe8 == 0x1 (0x1) +__uchar 0xfe && 0xe8 == 0x1 (0x1) +__longlong 0xfffe && 0x3e8 == 0x1 (0x1) +__ulonglong 0xfffe && 0x3e8 == 0x1 (0x1) +int 0xfffe || 0x3e8 == 0x1 (0x1) +__uint 0xfffe || 0x3e8 == 0x1 (0x1) +char 0xfffe || 0xffe8 == 0x1 (0x1) +__uchar 0xfe || 0xe8 == 0x1 (0x1) +__longlong 0xfffe || 0x3e8 == 0x1 (0x1) +__ulonglong 0xfffe || 0x3e8 == 0x1 (0x1) +int 0xfffe & 0x3e8 == 0x3e8 (0x3e8) +__uint 0xfffe & 0x3e8 == 0x3e8 (0x3e8) +char 0xfffe & 0xffe8 == -0x18 (0xffe8) +__uchar 0xfe & 0xe8 == 0xe8 (0xe8) +__longlong 0xfffe & 0x3e8 == 0x3e8 (0x3e8) +__ulonglong 0xfffe & 0x3e8 == 0x3e8 (0x3e8) +int 0xfffe | 0x3e8 == -0x2 (0xfffe) +__uint 0xfffe | 0x3e8 == -0x2 (0xfffe) +char 0xfffe | 0xffe8 == -0x2 (0xfffe) +__uchar 0xfe | 0xe8 == 0xfe (0xfe) +__longlong 0xfffe | 0x3e8 == -0x2 (0xfffe) +__ulonglong 0xfffe | 0x3e8 == -0x2 (0xfffe) +int 0xfffe << 0x14 == 0x0 (0x0) +__uint 0xfffe << 0x14 == 0x0 (0x0) +char 0xfffe << 0x14 == 0x0 (0x0) +__uchar 0xfe << 0x14 == 0x0 (0x0) +__longlong 0xfffe << 0x14 == 0x0 (0x0) +__ulonglong 0xfffe << 0x14 == 0x0 (0x0) +int 0xfffe >> 0x14 == -0x1 (0xffff) +__uint 0xfffe >> 0x14 == 0x0 (0x0) +char 0xfffe >> 0x14 == -0x1 (0xffff) +__uchar 0xfe >> 0x14 == 0x0 (0x0) +__longlong 0xfffe >> 0x14 == -0x1 (0xffff) +__ulonglong 0xfffe >> 0x14 == 0xfff (0xfff) +int 0xfffe + 0x3e8 == 0x3e6 (0x3e6) +__uint 0xfffe + 0x3e8 == 0x3e6 (0x3e6) +char 0xfffe + 0xffe8 == -0x1a (0xffe6) +__uchar 0xfe + 0xe8 == 0xe6 (0xe6) +__longlong 0xfffe + 0x3e8 == 0x3e6 (0x3e6) +__ulonglong 0xfffe + 0x3e8 == 0x3e6 (0x3e6) +float 0xfffe + 0x3e8 == 0x3e6 (0x3e6) +int 0xfffe - 0x3e8 == -0x3ea (0xfc16) +__uint 0xfffe - 0x3e8 == -0x3ea (0xfc16) +char 0xfffe - 0xffe8 == 0x16 (0x16) +__uchar 0xfe - 0xe8 == 0x16 (0x16) +__longlong 0xfffe - 0x3e8 == -0x3ea (0xfc16) +__ulonglong 0xfffe - 0x3e8 == -0x3ea (0xfc16) +float 0xfffe - 0x3e8 == -0x3ea (0xfc16) +int 0xfffe * 0x3e8 == -0x7d0 (0xf830) +__uint 0xfffe * 0x3e8 == -0x7d0 (0xf830) +char 0xfffe * 0xffe8 == 0x30 (0x30) +__uchar 0xfe * 0xe8 == 0x30 (0x30) +__longlong 0xfffe * 0x3e8 == -0x7d0 (0xf830) +__ulonglong 0xfffe * 0x3e8 == -0x7d0 (0xf830) +float 0xfffe * 0x3e8 == -0x7d0 (0xf830) +int 0xfffe < 0x3e8 == 0x1 (0x1) +__uint 0xfffe < 0x3e8 == 0x0 (0x0) +char 0xfffe < 0xffe8 == 0x0 (0x0) +__uchar 0xfe < 0xe8 == 0x0 (0x0) +__longlong 0xfffe < 0x3e8 == 0x1 (0x1) +__ulonglong 0xfffe < 0x3e8 == 0x0 (0x0) +float 0xfffe < 0x3e8 == 0x1 (0x1) +int 0xfffe > 0x3e8 == 0x0 (0x0) +__uint 0xfffe > 0x3e8 == 0x1 (0x1) +char 0xfffe > 0xffe8 == 0x1 (0x1) +__uchar 0xfe > 0xe8 == 0x1 (0x1) +__longlong 0xfffe > 0x3e8 == 0x0 (0x0) +__ulonglong 0xfffe > 0x3e8 == 0x1 (0x1) +float 0xfffe > 0x3e8 == 0x0 (0x0) +int 0xfffe <= 0x3e8 == 0x1 (0x1) +__uint 0xfffe <= 0x3e8 == 0x0 (0x0) +char 0xfffe <= 0xffe8 == 0x0 (0x0) +__uchar 0xfe <= 0xe8 == 0x0 (0x0) +__longlong 0xfffe <= 0x3e8 == 0x1 (0x1) +__ulonglong 0xfffe <= 0x3e8 == 0x0 (0x0) +float 0xfffe <= 0x3e8 == 0x1 (0x1) +int 0xfffe == 0x3e8 == 0x0 (0x0) +__uint 0xfffe == 0x3e8 == 0x0 (0x0) +char 0xfffe == 0xffe8 == 0x0 (0x0) +__uchar 0xfe == 0xe8 == 0x0 (0x0) +__longlong 0xfffe == 0x3e8 == 0x0 (0x0) +__ulonglong 0xfffe == 0x3e8 == 0x0 (0x0) +float 0xfffe == 0x3e8 == 0x0 (0x0) +int 0xfffe != 0x3e8 == 0x1 (0x1) +__uint 0xfffe != 0x3e8 == 0x1 (0x1) +char 0xfffe != 0xffe8 == 0x1 (0x1) +__uchar 0xfe != 0xe8 == 0x1 (0x1) +__longlong 0xfffe != 0x3e8 == 0x1 (0x1) +__ulonglong 0xfffe != 0x3e8 == 0x1 (0x1) +float 0xfffe != 0x3e8 == 0x1 (0x1) +int 0xfffe >= 0x3e8 == 0x0 (0x0) +__uint 0xfffe >= 0x3e8 == 0x1 (0x1) +char 0xfffe >= 0xffe8 == 0x1 (0x1) +__uchar 0xfe >= 0xe8 == 0x1 (0x1) +__longlong 0xfffe >= 0x3e8 == 0x0 (0x0) +__ulonglong 0xfffe >= 0x3e8 == 0x1 (0x1) +float 0xfffe >= 0x3e8 == 0x0 (0x0) +int 0xfffe / 0x3e8 == 0x0 (0x0) +__uint 0xfffe / 0x3e8 == 0x41 (0x41) +char 0xfffe / 0xffe8 == 0x0 (0x0) +__uchar 0xfe / 0xe8 == 0x1 (0x1) +__longlong 0xfffe / 0x3e8 == 0x0 (0x0) +__ulonglong 0xfffe / 0x3e8 == -0x76c9 (0x8937) +float 0xfffe / 0x3e8 == 0x0 (0x0) +int 0xfffe % 0x3e8 == -0x2 (0xfffe) +__uint 0xfffe % 0x3e8 == 0x216 (0x216) +char 0xfffe % 0xffe8 == -0x2 (0xfffe) +__uchar 0xfe % 0xe8 == 0x16 (0x16) +__longlong 0xfffe % 0x3e8 == -0x2 (0xfffe) +__ulonglong 0xfffe % 0x3e8 == 0x126 (0x126) +0xfffe * 0x2710 == -0x4e20 +0xfffe / 0x2710 == 0x0 +0xfffe % 0x2710 == -0x2 +int 0xfffe ^ 0x2710 == -0x2712 (0xd8ee) +__uint 0xfffe ^ 0x2710 == -0x2712 (0xd8ee) +char 0xfffe ^ 0x10 == -0x12 (0xffee) +__uchar 0xfe ^ 0x10 == 0xee (0xee) +__longlong 0xfffe ^ 0x2710 == -0x2712 (0xd8ee) +__ulonglong 0xfffe ^ 0x2710 == -0x2712 (0xd8ee) +int 0xfffe && 0x2710 == 0x1 (0x1) +__uint 0xfffe && 0x2710 == 0x1 (0x1) +char 0xfffe && 0x10 == 0x1 (0x1) +__uchar 0xfe && 0x10 == 0x1 (0x1) +__longlong 0xfffe && 0x2710 == 0x1 (0x1) +__ulonglong 0xfffe && 0x2710 == 0x1 (0x1) +int 0xfffe || 0x2710 == 0x1 (0x1) +__uint 0xfffe || 0x2710 == 0x1 (0x1) +char 0xfffe || 0x10 == 0x1 (0x1) +__uchar 0xfe || 0x10 == 0x1 (0x1) +__longlong 0xfffe || 0x2710 == 0x1 (0x1) +__ulonglong 0xfffe || 0x2710 == 0x1 (0x1) +int 0xfffe & 0x2710 == 0x2710 (0x2710) +__uint 0xfffe & 0x2710 == 0x2710 (0x2710) +char 0xfffe & 0x10 == 0x10 (0x10) +__uchar 0xfe & 0x10 == 0x10 (0x10) +__longlong 0xfffe & 0x2710 == 0x2710 (0x2710) +__ulonglong 0xfffe & 0x2710 == 0x2710 (0x2710) +int 0xfffe | 0x2710 == -0x2 (0xfffe) +__uint 0xfffe | 0x2710 == -0x2 (0xfffe) +char 0xfffe | 0x10 == -0x2 (0xfffe) +__uchar 0xfe | 0x10 == 0xfe (0xfe) +__longlong 0xfffe | 0x2710 == -0x2 (0xfffe) +__ulonglong 0xfffe | 0x2710 == -0x2 (0xfffe) +int 0xfffe << 0x16 == 0x0 (0x0) +__uint 0xfffe << 0x16 == 0x0 (0x0) +char 0xfffe << 0x16 == 0x0 (0x0) +__uchar 0xfe << 0x16 == 0x0 (0x0) +__longlong 0xfffe << 0x16 == 0x0 (0x0) +__ulonglong 0xfffe << 0x16 == 0x0 (0x0) +int 0xfffe >> 0x16 == -0x1 (0xffff) +__uint 0xfffe >> 0x16 == 0x0 (0x0) +char 0xfffe >> 0x16 == -0x1 (0xffff) +__uchar 0xfe >> 0x16 == 0x0 (0x0) +__longlong 0xfffe >> 0x16 == -0x1 (0xffff) +__ulonglong 0xfffe >> 0x16 == 0x3ff (0x3ff) +int 0xfffe + 0x2710 == 0x270e (0x270e) +__uint 0xfffe + 0x2710 == 0x270e (0x270e) +char 0xfffe + 0x10 == 0xe (0xe) +__uchar 0xfe + 0x10 == 0xe (0xe) +__longlong 0xfffe + 0x2710 == 0x270e (0x270e) +__ulonglong 0xfffe + 0x2710 == 0x270e (0x270e) +float 0xfffe + 0x2710 == 0x270e (0x270e) +int 0xfffe - 0x2710 == -0x2712 (0xd8ee) +__uint 0xfffe - 0x2710 == -0x2712 (0xd8ee) +char 0xfffe - 0x10 == -0x12 (0xffee) +__uchar 0xfe - 0x10 == 0xee (0xee) +__longlong 0xfffe - 0x2710 == -0x2712 (0xd8ee) +__ulonglong 0xfffe - 0x2710 == -0x2712 (0xd8ee) +float 0xfffe - 0x2710 == -0x2712 (0xd8ee) +int 0xfffe * 0x2710 == -0x4e20 (0xb1e0) +__uint 0xfffe * 0x2710 == -0x4e20 (0xb1e0) +char 0xfffe * 0x10 == -0x20 (0xffe0) +__uchar 0xfe * 0x10 == 0xe0 (0xe0) +__longlong 0xfffe * 0x2710 == -0x4e20 (0xb1e0) +__ulonglong 0xfffe * 0x2710 == -0x4e20 (0xb1e0) +float 0xfffe * 0x2710 == -0x4e20 (0xb1e0) +int 0xfffe < 0x2710 == 0x1 (0x1) +__uint 0xfffe < 0x2710 == 0x0 (0x0) +char 0xfffe < 0x10 == 0x1 (0x1) +__uchar 0xfe < 0x10 == 0x0 (0x0) +__longlong 0xfffe < 0x2710 == 0x1 (0x1) +__ulonglong 0xfffe < 0x2710 == 0x0 (0x0) +float 0xfffe < 0x2710 == 0x1 (0x1) +int 0xfffe > 0x2710 == 0x0 (0x0) +__uint 0xfffe > 0x2710 == 0x1 (0x1) +char 0xfffe > 0x10 == 0x0 (0x0) +__uchar 0xfe > 0x10 == 0x1 (0x1) +__longlong 0xfffe > 0x2710 == 0x0 (0x0) +__ulonglong 0xfffe > 0x2710 == 0x1 (0x1) +float 0xfffe > 0x2710 == 0x0 (0x0) +int 0xfffe <= 0x2710 == 0x1 (0x1) +__uint 0xfffe <= 0x2710 == 0x0 (0x0) +char 0xfffe <= 0x10 == 0x1 (0x1) +__uchar 0xfe <= 0x10 == 0x0 (0x0) +__longlong 0xfffe <= 0x2710 == 0x1 (0x1) +__ulonglong 0xfffe <= 0x2710 == 0x0 (0x0) +float 0xfffe <= 0x2710 == 0x1 (0x1) +int 0xfffe == 0x2710 == 0x0 (0x0) +__uint 0xfffe == 0x2710 == 0x0 (0x0) +char 0xfffe == 0x10 == 0x0 (0x0) +__uchar 0xfe == 0x10 == 0x0 (0x0) +__longlong 0xfffe == 0x2710 == 0x0 (0x0) +__ulonglong 0xfffe == 0x2710 == 0x0 (0x0) +float 0xfffe == 0x2710 == 0x0 (0x0) +int 0xfffe != 0x2710 == 0x1 (0x1) +__uint 0xfffe != 0x2710 == 0x1 (0x1) +char 0xfffe != 0x10 == 0x1 (0x1) +__uchar 0xfe != 0x10 == 0x1 (0x1) +__longlong 0xfffe != 0x2710 == 0x1 (0x1) +__ulonglong 0xfffe != 0x2710 == 0x1 (0x1) +float 0xfffe != 0x2710 == 0x1 (0x1) +int 0xfffe >= 0x2710 == 0x0 (0x0) +__uint 0xfffe >= 0x2710 == 0x1 (0x1) +char 0xfffe >= 0x10 == 0x0 (0x0) +__uchar 0xfe >= 0x10 == 0x1 (0x1) +__longlong 0xfffe >= 0x2710 == 0x0 (0x0) +__ulonglong 0xfffe >= 0x2710 == 0x1 (0x1) +float 0xfffe >= 0x2710 == 0x0 (0x0) +int 0xfffe / 0x2710 == 0x0 (0x0) +__uint 0xfffe / 0x2710 == 0x6 (0x6) +char 0xfffe / 0x10 == 0x0 (0x0) +__uchar 0xfe / 0x10 == 0xf (0xf) +__longlong 0xfffe / 0x2710 == 0x0 (0x0) +__ulonglong 0xfffe / 0x2710 == -0x7248 (0x8db8) +float 0xfffe / 0x2710 == 0x0 (0x0) +int 0xfffe % 0x2710 == -0x2 (0xfffe) +__uint 0xfffe % 0x2710 == 0x159e (0x159e) +char 0xfffe % 0x10 == -0x2 (0xfffe) +__uchar 0xfe % 0x10 == 0xe (0xe) +__longlong 0xfffe % 0x2710 == -0x2 (0xfffe) +__ulonglong 0xfffe % 0x2710 == 0x1c7e (0x1c7e) +int xor42-0x2 xor42 -0x2c +__uint xor42-0x2 xor42 -0x2c +char xor42-0x2 xor42 -0x2c +__uchar xor420xfe xor42 0xd4 +__longlong xor42-0x2 xor42 -0x2c +__ulonglong xor42-0x2 xor42 -0x2c +int land1-0x2 land1 0x1 +__uint land1-0x2 land1 0x1 +char land1-0x2 land1 0x1 +__uchar land10xfe land1 0x1 +__longlong land1-0x2 land1 0x1 +__ulonglong land1-0x2 land1 0x1 +int lor1-0x2 lor1 0x1 +__uint lor1-0x2 lor1 0x1 +char lor1-0x2 lor1 0x1 +__uchar lor10xfe lor1 0x1 +__longlong lor1-0x2 lor1 0x1 +__ulonglong lor1-0x2 lor1 0x1 +int and42-0x2 and42 0x2a +__uint and42-0x2 and42 0x2a +char and42-0x2 and42 0x2a +__uchar and420xfe and42 0x2a +__longlong and42-0x2 and42 0x2a +__ulonglong and42-0x2 and42 0x2a +int or42-0x2 or42 -0x2 +__uint or42-0x2 or42 -0x2 +char or42-0x2 or42 -0x2 +__uchar or420xfe or42 0xfe +__longlong or42-0x2 or42 -0x2 +__ulonglong or42-0x2 or42 -0x2 +int shl5-0x2 shl5 -0x40 +__uint shl5-0x2 shl5 -0x40 +char shl5-0x2 shl5 -0x40 +__uchar shl50xfe shl5 0xc0 +__longlong shl5-0x2 shl5 -0x40 +__ulonglong shl5-0x2 shl5 -0x40 +int shr5-0x2 shr5 -0x1 +__uint shr5-0x2 shr5 0x7ff +char shr5-0x2 shr5 -0x1 +__uchar shr50xfe shr5 0x7 +__longlong shr5-0x2 shr5 -0x1 +__ulonglong shr5-0x2 shr5 -0x1 +int add42-0x2 add42 0x28 +__uint add42-0x2 add42 0x28 +char add42-0x2 add42 0x28 +__uchar add420xfe add42 0x28 +__longlong add42-0x2 add42 0x28 +__ulonglong add42-0x2 add42 0x28 +float add42-0x2 add42 0x28 +int sub42-0x2 sub42 -0x2c +__uint sub42-0x2 sub42 -0x2c +char sub42-0x2 sub42 -0x2c +__uchar sub420xfe sub42 0xd4 +__longlong sub42-0x2 sub42 -0x2c +__ulonglong sub42-0x2 sub42 -0x2c +float sub42-0x2 sub42 -0x2c +int mul42-0x2 mul42 -0x54 +__uint mul42-0x2 mul42 -0x54 +char mul42-0x2 mul42 -0x54 +__uchar mul420xfe mul42 0xac +__longlong mul42-0x2 mul42 -0x54 +__ulonglong mul42-0x2 mul42 -0x54 +float mul42-0x2 mul42 -0x54 +int lt42-0x2 lt42 0x1 +__uint lt42-0x2 lt42 0x0 +char lt42-0x2 lt42 0x1 +__uchar lt420xfe lt42 0x0 +__longlong lt42-0x2 lt42 0x1 +__ulonglong lt42-0x2 lt42 0x0 +float lt42-0x2 lt42 0x1 +int gt42-0x2 gt42 0x0 +__uint gt42-0x2 gt42 0x1 +char gt42-0x2 gt42 0x0 +__uchar gt420xfe gt42 0x1 +__longlong gt42-0x2 gt42 0x0 +__ulonglong gt42-0x2 gt42 0x1 +float gt42-0x2 gt42 0x0 +int le42-0x2 le42 0x1 +__uint le42-0x2 le42 0x0 +char le42-0x2 le42 0x1 +__uchar le420xfe le42 0x0 +__longlong le42-0x2 le42 0x1 +__ulonglong le42-0x2 le42 0x0 +float le42-0x2 le42 0x1 +int eq42-0x2 eq42 0x0 +__uint eq42-0x2 eq42 0x0 +char eq42-0x2 eq42 0x0 +__uchar eq420xfe eq42 0x0 +__longlong eq42-0x2 eq42 0x0 +__ulonglong eq42-0x2 eq42 0x0 +float eq42-0x2 eq42 0x0 +int ne42-0x2 ne42 0x1 +__uint ne42-0x2 ne42 0x1 +char ne42-0x2 ne42 0x1 +__uchar ne420xfe ne42 0x1 +__longlong ne42-0x2 ne42 0x1 +__ulonglong ne42-0x2 ne42 0x1 +float ne42-0x2 ne42 0x1 +int ge42-0x2 ge42 0x0 +__uint ge42-0x2 ge42 0x1 +char ge42-0x2 ge42 0x0 +__uchar ge420xfe ge42 0x1 +__longlong ge42-0x2 ge42 0x0 +__ulonglong ge42-0x2 ge42 0x1 +float ge42-0x2 ge42 0x0 +int div42-0x2 div42 0x0 +__uint div42-0x2 div42 0x618 +char div42-0x2 div42 0x0 +__uchar div420xfe div42 0x6 +__longlong div42-0x2 div42 0x0 +__ulonglong div42-0x2 div42 0x6186 +float div42-0x2 div42 0x0 +int mod23-0x2 mod23 -0x2 +__uint mod23-0x2 mod23 0x7 +char mod23-0x2 mod23 -0x2 +__uchar mod230xfe mod23 0x1 +__longlong mod23-0x2 mod23 -0x2 +__ulonglong mod23-0x2 mod23 0xa +0x4 * 0xffff == -0x4 +0x4 / 0xffff == -0x4 +0x4 % 0xffff == 0x0 +int 0x4 ^ 0xffff == -0x5 (0xfffb) +__uint 0x4 ^ 0xffff == -0x5 (0xfffb) +char 0x4 ^ 0xffff == -0x5 (0xfffb) +__uchar 0x4 ^ 0xff == 0xfb (0xfb) +__longlong 0x4 ^ 0xffff == -0x5 (0xfffb) +__ulonglong 0x4 ^ 0xffff == -0x5 (0xfffb) +int 0x4 && 0xffff == 0x1 (0x1) +__uint 0x4 && 0xffff == 0x1 (0x1) +char 0x4 && 0xffff == 0x1 (0x1) +__uchar 0x4 && 0xff == 0x1 (0x1) +__longlong 0x4 && 0xffff == 0x1 (0x1) +__ulonglong 0x4 && 0xffff == 0x1 (0x1) +int 0x4 || 0xffff == 0x1 (0x1) +__uint 0x4 || 0xffff == 0x1 (0x1) +char 0x4 || 0xffff == 0x1 (0x1) +__uchar 0x4 || 0xff == 0x1 (0x1) +__longlong 0x4 || 0xffff == 0x1 (0x1) +__ulonglong 0x4 || 0xffff == 0x1 (0x1) +int 0x4 & 0xffff == 0x4 (0x4) +__uint 0x4 & 0xffff == 0x4 (0x4) +char 0x4 & 0xffff == 0x4 (0x4) +__uchar 0x4 & 0xff == 0x4 (0x4) +__longlong 0x4 & 0xffff == 0x4 (0x4) +__ulonglong 0x4 & 0xffff == 0x4 (0x4) +int 0x4 | 0xffff == -0x1 (0xffff) +__uint 0x4 | 0xffff == -0x1 (0xffff) +char 0x4 | 0xffff == -0x1 (0xffff) +__uchar 0x4 | 0xff == 0xff (0xff) +__longlong 0x4 | 0xffff == -0x1 (0xffff) +__ulonglong 0x4 | 0xffff == -0x1 (0xffff) +int 0x4 << 0x1 == 0x8 (0x8) +__uint 0x4 << 0x1 == 0x8 (0x8) +char 0x4 << 0x1 == 0x8 (0x8) +__uchar 0x4 << 0x1 == 0x8 (0x8) +__longlong 0x4 << 0x1 == 0x8 (0x8) +__ulonglong 0x4 << 0x1 == 0x8 (0x8) +int 0x4 >> 0x1 == 0x2 (0x2) +__uint 0x4 >> 0x1 == 0x2 (0x2) +char 0x4 >> 0x1 == 0x2 (0x2) +__uchar 0x4 >> 0x1 == 0x2 (0x2) +__longlong 0x4 >> 0x1 == 0x2 (0x2) +__ulonglong 0x4 >> 0x1 == 0x2 (0x2) +int 0x4 + 0xffff == 0x3 (0x3) +__uint 0x4 + 0xffff == 0x3 (0x3) +char 0x4 + 0xffff == 0x3 (0x3) +__uchar 0x4 + 0xff == 0x3 (0x3) +__longlong 0x4 + 0xffff == 0x3 (0x3) +__ulonglong 0x4 + 0xffff == 0x3 (0x3) +float 0x4 + 0xffff == 0x3 (0x3) +int 0x4 - 0xffff == 0x5 (0x5) +__uint 0x4 - 0xffff == 0x5 (0x5) +char 0x4 - 0xffff == 0x5 (0x5) +__uchar 0x4 - 0xff == 0x5 (0x5) +__longlong 0x4 - 0xffff == 0x5 (0x5) +__ulonglong 0x4 - 0xffff == 0x5 (0x5) +float 0x4 - 0xffff == 0x5 (0x5) +int 0x4 * 0xffff == -0x4 (0xfffc) +__uint 0x4 * 0xffff == -0x4 (0xfffc) +char 0x4 * 0xffff == -0x4 (0xfffc) +__uchar 0x4 * 0xff == 0xfc (0xfc) +__longlong 0x4 * 0xffff == -0x4 (0xfffc) +__ulonglong 0x4 * 0xffff == -0x4 (0xfffc) +float 0x4 * 0xffff == -0x4 (0xfffc) +int 0x4 < 0xffff == 0x0 (0x0) +__uint 0x4 < 0xffff == 0x1 (0x1) +char 0x4 < 0xffff == 0x0 (0x0) +__uchar 0x4 < 0xff == 0x1 (0x1) +__longlong 0x4 < 0xffff == 0x0 (0x0) +__ulonglong 0x4 < 0xffff == 0x1 (0x1) +float 0x4 < 0xffff == 0x0 (0x0) +int 0x4 > 0xffff == 0x1 (0x1) +__uint 0x4 > 0xffff == 0x0 (0x0) +char 0x4 > 0xffff == 0x1 (0x1) +__uchar 0x4 > 0xff == 0x0 (0x0) +__longlong 0x4 > 0xffff == 0x1 (0x1) +__ulonglong 0x4 > 0xffff == 0x0 (0x0) +float 0x4 > 0xffff == 0x1 (0x1) +int 0x4 <= 0xffff == 0x0 (0x0) +__uint 0x4 <= 0xffff == 0x1 (0x1) +char 0x4 <= 0xffff == 0x0 (0x0) +__uchar 0x4 <= 0xff == 0x1 (0x1) +__longlong 0x4 <= 0xffff == 0x0 (0x0) +__ulonglong 0x4 <= 0xffff == 0x1 (0x1) +float 0x4 <= 0xffff == 0x0 (0x0) +int 0x4 == 0xffff == 0x0 (0x0) +__uint 0x4 == 0xffff == 0x0 (0x0) +char 0x4 == 0xffff == 0x0 (0x0) +__uchar 0x4 == 0xff == 0x0 (0x0) +__longlong 0x4 == 0xffff == 0x0 (0x0) +__ulonglong 0x4 == 0xffff == 0x0 (0x0) +float 0x4 == 0xffff == 0x0 (0x0) +int 0x4 != 0xffff == 0x1 (0x1) +__uint 0x4 != 0xffff == 0x1 (0x1) +char 0x4 != 0xffff == 0x1 (0x1) +__uchar 0x4 != 0xff == 0x1 (0x1) +__longlong 0x4 != 0xffff == 0x1 (0x1) +__ulonglong 0x4 != 0xffff == 0x1 (0x1) +float 0x4 != 0xffff == 0x1 (0x1) +int 0x4 >= 0xffff == 0x1 (0x1) +__uint 0x4 >= 0xffff == 0x0 (0x0) +char 0x4 >= 0xffff == 0x1 (0x1) +__uchar 0x4 >= 0xff == 0x0 (0x0) +__longlong 0x4 >= 0xffff == 0x1 (0x1) +__ulonglong 0x4 >= 0xffff == 0x0 (0x0) +float 0x4 >= 0xffff == 0x1 (0x1) +int 0x4 / 0xffff == -0x4 (0xfffc) +__uint 0x4 / 0xffff == 0x0 (0x0) +char 0x4 / 0xffff == -0x4 (0xfffc) +__uchar 0x4 / 0xff == 0x0 (0x0) +__longlong 0x4 / 0xffff == -0x4 (0xfffc) +__ulonglong 0x4 / 0xffff == 0x0 (0x0) +float 0x4 / 0xffff == -0x4 (0xfffc) +int 0x4 % 0xffff == 0x0 (0x0) +__uint 0x4 % 0xffff == 0x4 (0x4) +char 0x4 % 0xffff == 0x0 (0x0) +__uchar 0x4 % 0xff == 0x4 (0x4) +__longlong 0x4 % 0xffff == 0x0 (0x0) +__ulonglong 0x4 % 0xffff == 0x4 (0x4) +0x4 * 0x1 == 0x4 +0x4 / 0x1 == 0x4 +0x4 % 0x1 == 0x0 +int 0x4 ^ 0x1 == 0x5 (0x5) +__uint 0x4 ^ 0x1 == 0x5 (0x5) +char 0x4 ^ 0x1 == 0x5 (0x5) +__uchar 0x4 ^ 0x1 == 0x5 (0x5) +__longlong 0x4 ^ 0x1 == 0x5 (0x5) +__ulonglong 0x4 ^ 0x1 == 0x5 (0x5) +int 0x4 && 0x1 == 0x1 (0x1) +__uint 0x4 && 0x1 == 0x1 (0x1) +char 0x4 && 0x1 == 0x1 (0x1) +__uchar 0x4 && 0x1 == 0x1 (0x1) +__longlong 0x4 && 0x1 == 0x1 (0x1) +__ulonglong 0x4 && 0x1 == 0x1 (0x1) +int 0x4 || 0x1 == 0x1 (0x1) +__uint 0x4 || 0x1 == 0x1 (0x1) +char 0x4 || 0x1 == 0x1 (0x1) +__uchar 0x4 || 0x1 == 0x1 (0x1) +__longlong 0x4 || 0x1 == 0x1 (0x1) +__ulonglong 0x4 || 0x1 == 0x1 (0x1) +int 0x4 & 0x1 == 0x0 (0x0) +__uint 0x4 & 0x1 == 0x0 (0x0) +char 0x4 & 0x1 == 0x0 (0x0) +__uchar 0x4 & 0x1 == 0x0 (0x0) +__longlong 0x4 & 0x1 == 0x0 (0x0) +__ulonglong 0x4 & 0x1 == 0x0 (0x0) +int 0x4 | 0x1 == 0x5 (0x5) +__uint 0x4 | 0x1 == 0x5 (0x5) +char 0x4 | 0x1 == 0x5 (0x5) +__uchar 0x4 | 0x1 == 0x5 (0x5) +__longlong 0x4 | 0x1 == 0x5 (0x5) +__ulonglong 0x4 | 0x1 == 0x5 (0x5) +int 0x4 << 0x2 == 0x10 (0x10) +__uint 0x4 << 0x2 == 0x10 (0x10) +char 0x4 << 0x2 == 0x10 (0x10) +__uchar 0x4 << 0x2 == 0x10 (0x10) +__longlong 0x4 << 0x2 == 0x10 (0x10) +__ulonglong 0x4 << 0x2 == 0x10 (0x10) +int 0x4 >> 0x2 == 0x1 (0x1) +__uint 0x4 >> 0x2 == 0x1 (0x1) +char 0x4 >> 0x2 == 0x1 (0x1) +__uchar 0x4 >> 0x2 == 0x1 (0x1) +__longlong 0x4 >> 0x2 == 0x1 (0x1) +__ulonglong 0x4 >> 0x2 == 0x1 (0x1) +int 0x4 + 0x1 == 0x5 (0x5) +__uint 0x4 + 0x1 == 0x5 (0x5) +char 0x4 + 0x1 == 0x5 (0x5) +__uchar 0x4 + 0x1 == 0x5 (0x5) +__longlong 0x4 + 0x1 == 0x5 (0x5) +__ulonglong 0x4 + 0x1 == 0x5 (0x5) +float 0x4 + 0x1 == 0x5 (0x5) +int 0x4 - 0x1 == 0x3 (0x3) +__uint 0x4 - 0x1 == 0x3 (0x3) +char 0x4 - 0x1 == 0x3 (0x3) +__uchar 0x4 - 0x1 == 0x3 (0x3) +__longlong 0x4 - 0x1 == 0x3 (0x3) +__ulonglong 0x4 - 0x1 == 0x3 (0x3) +float 0x4 - 0x1 == 0x3 (0x3) +int 0x4 * 0x1 == 0x4 (0x4) +__uint 0x4 * 0x1 == 0x4 (0x4) +char 0x4 * 0x1 == 0x4 (0x4) +__uchar 0x4 * 0x1 == 0x4 (0x4) +__longlong 0x4 * 0x1 == 0x4 (0x4) +__ulonglong 0x4 * 0x1 == 0x4 (0x4) +float 0x4 * 0x1 == 0x4 (0x4) +int 0x4 < 0x1 == 0x0 (0x0) +__uint 0x4 < 0x1 == 0x0 (0x0) +char 0x4 < 0x1 == 0x0 (0x0) +__uchar 0x4 < 0x1 == 0x0 (0x0) +__longlong 0x4 < 0x1 == 0x0 (0x0) +__ulonglong 0x4 < 0x1 == 0x0 (0x0) +float 0x4 < 0x1 == 0x0 (0x0) +int 0x4 > 0x1 == 0x1 (0x1) +__uint 0x4 > 0x1 == 0x1 (0x1) +char 0x4 > 0x1 == 0x1 (0x1) +__uchar 0x4 > 0x1 == 0x1 (0x1) +__longlong 0x4 > 0x1 == 0x1 (0x1) +__ulonglong 0x4 > 0x1 == 0x1 (0x1) +float 0x4 > 0x1 == 0x1 (0x1) +int 0x4 <= 0x1 == 0x0 (0x0) +__uint 0x4 <= 0x1 == 0x0 (0x0) +char 0x4 <= 0x1 == 0x0 (0x0) +__uchar 0x4 <= 0x1 == 0x0 (0x0) +__longlong 0x4 <= 0x1 == 0x0 (0x0) +__ulonglong 0x4 <= 0x1 == 0x0 (0x0) +float 0x4 <= 0x1 == 0x0 (0x0) +int 0x4 == 0x1 == 0x0 (0x0) +__uint 0x4 == 0x1 == 0x0 (0x0) +char 0x4 == 0x1 == 0x0 (0x0) +__uchar 0x4 == 0x1 == 0x0 (0x0) +__longlong 0x4 == 0x1 == 0x0 (0x0) +__ulonglong 0x4 == 0x1 == 0x0 (0x0) +float 0x4 == 0x1 == 0x0 (0x0) +int 0x4 != 0x1 == 0x1 (0x1) +__uint 0x4 != 0x1 == 0x1 (0x1) +char 0x4 != 0x1 == 0x1 (0x1) +__uchar 0x4 != 0x1 == 0x1 (0x1) +__longlong 0x4 != 0x1 == 0x1 (0x1) +__ulonglong 0x4 != 0x1 == 0x1 (0x1) +float 0x4 != 0x1 == 0x1 (0x1) +int 0x4 >= 0x1 == 0x1 (0x1) +__uint 0x4 >= 0x1 == 0x1 (0x1) +char 0x4 >= 0x1 == 0x1 (0x1) +__uchar 0x4 >= 0x1 == 0x1 (0x1) +__longlong 0x4 >= 0x1 == 0x1 (0x1) +__ulonglong 0x4 >= 0x1 == 0x1 (0x1) +float 0x4 >= 0x1 == 0x1 (0x1) +int 0x4 / 0x1 == 0x4 (0x4) +__uint 0x4 / 0x1 == 0x4 (0x4) +char 0x4 / 0x1 == 0x4 (0x4) +__uchar 0x4 / 0x1 == 0x4 (0x4) +__longlong 0x4 / 0x1 == 0x4 (0x4) +__ulonglong 0x4 / 0x1 == 0x4 (0x4) +float 0x4 / 0x1 == 0x4 (0x4) +int 0x4 % 0x1 == 0x0 (0x0) +__uint 0x4 % 0x1 == 0x0 (0x0) +char 0x4 % 0x1 == 0x0 (0x0) +__uchar 0x4 % 0x1 == 0x0 (0x0) +__longlong 0x4 % 0x1 == 0x0 (0x0) +__ulonglong 0x4 % 0x1 == 0x0 (0x0) +0x4 * 0x2 == 0x8 +0x4 / 0x2 == 0x2 +0x4 % 0x2 == 0x0 +int 0x4 ^ 0x2 == 0x6 (0x6) +__uint 0x4 ^ 0x2 == 0x6 (0x6) +char 0x4 ^ 0x2 == 0x6 (0x6) +__uchar 0x4 ^ 0x2 == 0x6 (0x6) +__longlong 0x4 ^ 0x2 == 0x6 (0x6) +__ulonglong 0x4 ^ 0x2 == 0x6 (0x6) +int 0x4 && 0x2 == 0x1 (0x1) +__uint 0x4 && 0x2 == 0x1 (0x1) +char 0x4 && 0x2 == 0x1 (0x1) +__uchar 0x4 && 0x2 == 0x1 (0x1) +__longlong 0x4 && 0x2 == 0x1 (0x1) +__ulonglong 0x4 && 0x2 == 0x1 (0x1) +int 0x4 || 0x2 == 0x1 (0x1) +__uint 0x4 || 0x2 == 0x1 (0x1) +char 0x4 || 0x2 == 0x1 (0x1) +__uchar 0x4 || 0x2 == 0x1 (0x1) +__longlong 0x4 || 0x2 == 0x1 (0x1) +__ulonglong 0x4 || 0x2 == 0x1 (0x1) +int 0x4 & 0x2 == 0x0 (0x0) +__uint 0x4 & 0x2 == 0x0 (0x0) +char 0x4 & 0x2 == 0x0 (0x0) +__uchar 0x4 & 0x2 == 0x0 (0x0) +__longlong 0x4 & 0x2 == 0x0 (0x0) +__ulonglong 0x4 & 0x2 == 0x0 (0x0) +int 0x4 | 0x2 == 0x6 (0x6) +__uint 0x4 | 0x2 == 0x6 (0x6) +char 0x4 | 0x2 == 0x6 (0x6) +__uchar 0x4 | 0x2 == 0x6 (0x6) +__longlong 0x4 | 0x2 == 0x6 (0x6) +__ulonglong 0x4 | 0x2 == 0x6 (0x6) +int 0x4 << 0x3 == 0x20 (0x20) +__uint 0x4 << 0x3 == 0x20 (0x20) +char 0x4 << 0x3 == 0x20 (0x20) +__uchar 0x4 << 0x3 == 0x20 (0x20) +__longlong 0x4 << 0x3 == 0x20 (0x20) +__ulonglong 0x4 << 0x3 == 0x20 (0x20) +int 0x4 >> 0x3 == 0x0 (0x0) +__uint 0x4 >> 0x3 == 0x0 (0x0) +char 0x4 >> 0x3 == 0x0 (0x0) +__uchar 0x4 >> 0x3 == 0x0 (0x0) +__longlong 0x4 >> 0x3 == 0x0 (0x0) +__ulonglong 0x4 >> 0x3 == 0x0 (0x0) +int 0x4 + 0x2 == 0x6 (0x6) +__uint 0x4 + 0x2 == 0x6 (0x6) +char 0x4 + 0x2 == 0x6 (0x6) +__uchar 0x4 + 0x2 == 0x6 (0x6) +__longlong 0x4 + 0x2 == 0x6 (0x6) +__ulonglong 0x4 + 0x2 == 0x6 (0x6) +float 0x4 + 0x2 == 0x6 (0x6) +int 0x4 - 0x2 == 0x2 (0x2) +__uint 0x4 - 0x2 == 0x2 (0x2) +char 0x4 - 0x2 == 0x2 (0x2) +__uchar 0x4 - 0x2 == 0x2 (0x2) +__longlong 0x4 - 0x2 == 0x2 (0x2) +__ulonglong 0x4 - 0x2 == 0x2 (0x2) +float 0x4 - 0x2 == 0x2 (0x2) +int 0x4 * 0x2 == 0x8 (0x8) +__uint 0x4 * 0x2 == 0x8 (0x8) +char 0x4 * 0x2 == 0x8 (0x8) +__uchar 0x4 * 0x2 == 0x8 (0x8) +__longlong 0x4 * 0x2 == 0x8 (0x8) +__ulonglong 0x4 * 0x2 == 0x8 (0x8) +float 0x4 * 0x2 == 0x8 (0x8) +int 0x4 < 0x2 == 0x0 (0x0) +__uint 0x4 < 0x2 == 0x0 (0x0) +char 0x4 < 0x2 == 0x0 (0x0) +__uchar 0x4 < 0x2 == 0x0 (0x0) +__longlong 0x4 < 0x2 == 0x0 (0x0) +__ulonglong 0x4 < 0x2 == 0x0 (0x0) +float 0x4 < 0x2 == 0x0 (0x0) +int 0x4 > 0x2 == 0x1 (0x1) +__uint 0x4 > 0x2 == 0x1 (0x1) +char 0x4 > 0x2 == 0x1 (0x1) +__uchar 0x4 > 0x2 == 0x1 (0x1) +__longlong 0x4 > 0x2 == 0x1 (0x1) +__ulonglong 0x4 > 0x2 == 0x1 (0x1) +float 0x4 > 0x2 == 0x1 (0x1) +int 0x4 <= 0x2 == 0x0 (0x0) +__uint 0x4 <= 0x2 == 0x0 (0x0) +char 0x4 <= 0x2 == 0x0 (0x0) +__uchar 0x4 <= 0x2 == 0x0 (0x0) +__longlong 0x4 <= 0x2 == 0x0 (0x0) +__ulonglong 0x4 <= 0x2 == 0x0 (0x0) +float 0x4 <= 0x2 == 0x0 (0x0) +int 0x4 == 0x2 == 0x0 (0x0) +__uint 0x4 == 0x2 == 0x0 (0x0) +char 0x4 == 0x2 == 0x0 (0x0) +__uchar 0x4 == 0x2 == 0x0 (0x0) +__longlong 0x4 == 0x2 == 0x0 (0x0) +__ulonglong 0x4 == 0x2 == 0x0 (0x0) +float 0x4 == 0x2 == 0x0 (0x0) +int 0x4 != 0x2 == 0x1 (0x1) +__uint 0x4 != 0x2 == 0x1 (0x1) +char 0x4 != 0x2 == 0x1 (0x1) +__uchar 0x4 != 0x2 == 0x1 (0x1) +__longlong 0x4 != 0x2 == 0x1 (0x1) +__ulonglong 0x4 != 0x2 == 0x1 (0x1) +float 0x4 != 0x2 == 0x1 (0x1) +int 0x4 >= 0x2 == 0x1 (0x1) +__uint 0x4 >= 0x2 == 0x1 (0x1) +char 0x4 >= 0x2 == 0x1 (0x1) +__uchar 0x4 >= 0x2 == 0x1 (0x1) +__longlong 0x4 >= 0x2 == 0x1 (0x1) +__ulonglong 0x4 >= 0x2 == 0x1 (0x1) +float 0x4 >= 0x2 == 0x1 (0x1) +int 0x4 / 0x2 == 0x2 (0x2) +__uint 0x4 / 0x2 == 0x2 (0x2) +char 0x4 / 0x2 == 0x2 (0x2) +__uchar 0x4 / 0x2 == 0x2 (0x2) +__longlong 0x4 / 0x2 == 0x2 (0x2) +__ulonglong 0x4 / 0x2 == 0x2 (0x2) +float 0x4 / 0x2 == 0x2 (0x2) +int 0x4 % 0x2 == 0x0 (0x0) +__uint 0x4 % 0x2 == 0x0 (0x0) +char 0x4 % 0x2 == 0x0 (0x0) +__uchar 0x4 % 0x2 == 0x0 (0x0) +__longlong 0x4 % 0x2 == 0x0 (0x0) +__ulonglong 0x4 % 0x2 == 0x0 (0x0) +0x4 * 0xfffe == -0x8 +0x4 / 0xfffe == -0x2 +0x4 % 0xfffe == 0x0 +int 0x4 ^ 0xfffe == -0x6 (0xfffa) +__uint 0x4 ^ 0xfffe == -0x6 (0xfffa) +char 0x4 ^ 0xfffe == -0x6 (0xfffa) +__uchar 0x4 ^ 0xfe == 0xfa (0xfa) +__longlong 0x4 ^ 0xfffe == -0x6 (0xfffa) +__ulonglong 0x4 ^ 0xfffe == -0x6 (0xfffa) +int 0x4 && 0xfffe == 0x1 (0x1) +__uint 0x4 && 0xfffe == 0x1 (0x1) +char 0x4 && 0xfffe == 0x1 (0x1) +__uchar 0x4 && 0xfe == 0x1 (0x1) +__longlong 0x4 && 0xfffe == 0x1 (0x1) +__ulonglong 0x4 && 0xfffe == 0x1 (0x1) +int 0x4 || 0xfffe == 0x1 (0x1) +__uint 0x4 || 0xfffe == 0x1 (0x1) +char 0x4 || 0xfffe == 0x1 (0x1) +__uchar 0x4 || 0xfe == 0x1 (0x1) +__longlong 0x4 || 0xfffe == 0x1 (0x1) +__ulonglong 0x4 || 0xfffe == 0x1 (0x1) +int 0x4 & 0xfffe == 0x4 (0x4) +__uint 0x4 & 0xfffe == 0x4 (0x4) +char 0x4 & 0xfffe == 0x4 (0x4) +__uchar 0x4 & 0xfe == 0x4 (0x4) +__longlong 0x4 & 0xfffe == 0x4 (0x4) +__ulonglong 0x4 & 0xfffe == 0x4 (0x4) +int 0x4 | 0xfffe == -0x2 (0xfffe) +__uint 0x4 | 0xfffe == -0x2 (0xfffe) +char 0x4 | 0xfffe == -0x2 (0xfffe) +__uchar 0x4 | 0xfe == 0xfe (0xfe) +__longlong 0x4 | 0xfffe == -0x2 (0xfffe) +__ulonglong 0x4 | 0xfffe == -0x2 (0xfffe) +int 0x4 << 0x4 == 0x40 (0x40) +__uint 0x4 << 0x4 == 0x40 (0x40) +char 0x4 << 0x4 == 0x40 (0x40) +__uchar 0x4 << 0x4 == 0x40 (0x40) +__longlong 0x4 << 0x4 == 0x40 (0x40) +__ulonglong 0x4 << 0x4 == 0x40 (0x40) +int 0x4 >> 0x4 == 0x0 (0x0) +__uint 0x4 >> 0x4 == 0x0 (0x0) +char 0x4 >> 0x4 == 0x0 (0x0) +__uchar 0x4 >> 0x4 == 0x0 (0x0) +__longlong 0x4 >> 0x4 == 0x0 (0x0) +__ulonglong 0x4 >> 0x4 == 0x0 (0x0) +int 0x4 + 0xfffe == 0x2 (0x2) +__uint 0x4 + 0xfffe == 0x2 (0x2) +char 0x4 + 0xfffe == 0x2 (0x2) +__uchar 0x4 + 0xfe == 0x2 (0x2) +__longlong 0x4 + 0xfffe == 0x2 (0x2) +__ulonglong 0x4 + 0xfffe == 0x2 (0x2) +float 0x4 + 0xfffe == 0x2 (0x2) +int 0x4 - 0xfffe == 0x6 (0x6) +__uint 0x4 - 0xfffe == 0x6 (0x6) +char 0x4 - 0xfffe == 0x6 (0x6) +__uchar 0x4 - 0xfe == 0x6 (0x6) +__longlong 0x4 - 0xfffe == 0x6 (0x6) +__ulonglong 0x4 - 0xfffe == 0x6 (0x6) +float 0x4 - 0xfffe == 0x6 (0x6) +int 0x4 * 0xfffe == -0x8 (0xfff8) +__uint 0x4 * 0xfffe == -0x8 (0xfff8) +char 0x4 * 0xfffe == -0x8 (0xfff8) +__uchar 0x4 * 0xfe == 0xf8 (0xf8) +__longlong 0x4 * 0xfffe == -0x8 (0xfff8) +__ulonglong 0x4 * 0xfffe == -0x8 (0xfff8) +float 0x4 * 0xfffe == -0x8 (0xfff8) +int 0x4 < 0xfffe == 0x0 (0x0) +__uint 0x4 < 0xfffe == 0x1 (0x1) +char 0x4 < 0xfffe == 0x0 (0x0) +__uchar 0x4 < 0xfe == 0x1 (0x1) +__longlong 0x4 < 0xfffe == 0x0 (0x0) +__ulonglong 0x4 < 0xfffe == 0x1 (0x1) +float 0x4 < 0xfffe == 0x0 (0x0) +int 0x4 > 0xfffe == 0x1 (0x1) +__uint 0x4 > 0xfffe == 0x0 (0x0) +char 0x4 > 0xfffe == 0x1 (0x1) +__uchar 0x4 > 0xfe == 0x0 (0x0) +__longlong 0x4 > 0xfffe == 0x1 (0x1) +__ulonglong 0x4 > 0xfffe == 0x0 (0x0) +float 0x4 > 0xfffe == 0x1 (0x1) +int 0x4 <= 0xfffe == 0x0 (0x0) +__uint 0x4 <= 0xfffe == 0x1 (0x1) +char 0x4 <= 0xfffe == 0x0 (0x0) +__uchar 0x4 <= 0xfe == 0x1 (0x1) +__longlong 0x4 <= 0xfffe == 0x0 (0x0) +__ulonglong 0x4 <= 0xfffe == 0x1 (0x1) +float 0x4 <= 0xfffe == 0x0 (0x0) +int 0x4 == 0xfffe == 0x0 (0x0) +__uint 0x4 == 0xfffe == 0x0 (0x0) +char 0x4 == 0xfffe == 0x0 (0x0) +__uchar 0x4 == 0xfe == 0x0 (0x0) +__longlong 0x4 == 0xfffe == 0x0 (0x0) +__ulonglong 0x4 == 0xfffe == 0x0 (0x0) +float 0x4 == 0xfffe == 0x0 (0x0) +int 0x4 != 0xfffe == 0x1 (0x1) +__uint 0x4 != 0xfffe == 0x1 (0x1) +char 0x4 != 0xfffe == 0x1 (0x1) +__uchar 0x4 != 0xfe == 0x1 (0x1) +__longlong 0x4 != 0xfffe == 0x1 (0x1) +__ulonglong 0x4 != 0xfffe == 0x1 (0x1) +float 0x4 != 0xfffe == 0x1 (0x1) +int 0x4 >= 0xfffe == 0x1 (0x1) +__uint 0x4 >= 0xfffe == 0x0 (0x0) +char 0x4 >= 0xfffe == 0x1 (0x1) +__uchar 0x4 >= 0xfe == 0x0 (0x0) +__longlong 0x4 >= 0xfffe == 0x1 (0x1) +__ulonglong 0x4 >= 0xfffe == 0x0 (0x0) +float 0x4 >= 0xfffe == 0x1 (0x1) +int 0x4 / 0xfffe == -0x2 (0xfffe) +__uint 0x4 / 0xfffe == 0x0 (0x0) +char 0x4 / 0xfffe == -0x2 (0xfffe) +__uchar 0x4 / 0xfe == 0x0 (0x0) +__longlong 0x4 / 0xfffe == -0x2 (0xfffe) +__ulonglong 0x4 / 0xfffe == 0x0 (0x0) +float 0x4 / 0xfffe == -0x2 (0xfffe) +int 0x4 % 0xfffe == 0x0 (0x0) +__uint 0x4 % 0xfffe == 0x4 (0x4) +char 0x4 % 0xfffe == 0x0 (0x0) +__uchar 0x4 % 0xfe == 0x4 (0x4) +__longlong 0x4 % 0xfffe == 0x0 (0x0) +__ulonglong 0x4 % 0xfffe == 0x4 (0x4) +0x4 * 0x4 == 0x10 +0x4 / 0x4 == 0x1 +0x4 % 0x4 == 0x0 +int 0x4 ^ 0x4 == 0x0 (0x0) +__uint 0x4 ^ 0x4 == 0x0 (0x0) +char 0x4 ^ 0x4 == 0x0 (0x0) +__uchar 0x4 ^ 0x4 == 0x0 (0x0) +__longlong 0x4 ^ 0x4 == 0x0 (0x0) +__ulonglong 0x4 ^ 0x4 == 0x0 (0x0) +int 0x4 && 0x4 == 0x1 (0x1) +__uint 0x4 && 0x4 == 0x1 (0x1) +char 0x4 && 0x4 == 0x1 (0x1) +__uchar 0x4 && 0x4 == 0x1 (0x1) +__longlong 0x4 && 0x4 == 0x1 (0x1) +__ulonglong 0x4 && 0x4 == 0x1 (0x1) +int 0x4 || 0x4 == 0x1 (0x1) +__uint 0x4 || 0x4 == 0x1 (0x1) +char 0x4 || 0x4 == 0x1 (0x1) +__uchar 0x4 || 0x4 == 0x1 (0x1) +__longlong 0x4 || 0x4 == 0x1 (0x1) +__ulonglong 0x4 || 0x4 == 0x1 (0x1) +int 0x4 & 0x4 == 0x4 (0x4) +__uint 0x4 & 0x4 == 0x4 (0x4) +char 0x4 & 0x4 == 0x4 (0x4) +__uchar 0x4 & 0x4 == 0x4 (0x4) +__longlong 0x4 & 0x4 == 0x4 (0x4) +__ulonglong 0x4 & 0x4 == 0x4 (0x4) +int 0x4 | 0x4 == 0x4 (0x4) +__uint 0x4 | 0x4 == 0x4 (0x4) +char 0x4 | 0x4 == 0x4 (0x4) +__uchar 0x4 | 0x4 == 0x4 (0x4) +__longlong 0x4 | 0x4 == 0x4 (0x4) +__ulonglong 0x4 | 0x4 == 0x4 (0x4) +int 0x4 << 0x5 == 0x80 (0x80) +__uint 0x4 << 0x5 == 0x80 (0x80) +char 0x4 << 0x5 == -0x80 (0xff80) +__uchar 0x4 << 0x5 == 0x80 (0x80) +__longlong 0x4 << 0x5 == 0x80 (0x80) +__ulonglong 0x4 << 0x5 == 0x80 (0x80) +int 0x4 >> 0x5 == 0x0 (0x0) +__uint 0x4 >> 0x5 == 0x0 (0x0) +char 0x4 >> 0x5 == 0x0 (0x0) +__uchar 0x4 >> 0x5 == 0x0 (0x0) +__longlong 0x4 >> 0x5 == 0x0 (0x0) +__ulonglong 0x4 >> 0x5 == 0x0 (0x0) +int 0x4 + 0x4 == 0x8 (0x8) +__uint 0x4 + 0x4 == 0x8 (0x8) +char 0x4 + 0x4 == 0x8 (0x8) +__uchar 0x4 + 0x4 == 0x8 (0x8) +__longlong 0x4 + 0x4 == 0x8 (0x8) +__ulonglong 0x4 + 0x4 == 0x8 (0x8) +float 0x4 + 0x4 == 0x8 (0x8) +int 0x4 - 0x4 == 0x0 (0x0) +__uint 0x4 - 0x4 == 0x0 (0x0) +char 0x4 - 0x4 == 0x0 (0x0) +__uchar 0x4 - 0x4 == 0x0 (0x0) +__longlong 0x4 - 0x4 == 0x0 (0x0) +__ulonglong 0x4 - 0x4 == 0x0 (0x0) +float 0x4 - 0x4 == 0x0 (0x0) +int 0x4 * 0x4 == 0x10 (0x10) +__uint 0x4 * 0x4 == 0x10 (0x10) +char 0x4 * 0x4 == 0x10 (0x10) +__uchar 0x4 * 0x4 == 0x10 (0x10) +__longlong 0x4 * 0x4 == 0x10 (0x10) +__ulonglong 0x4 * 0x4 == 0x10 (0x10) +float 0x4 * 0x4 == 0x10 (0x10) +int 0x4 < 0x4 == 0x0 (0x0) +__uint 0x4 < 0x4 == 0x0 (0x0) +char 0x4 < 0x4 == 0x0 (0x0) +__uchar 0x4 < 0x4 == 0x0 (0x0) +__longlong 0x4 < 0x4 == 0x0 (0x0) +__ulonglong 0x4 < 0x4 == 0x0 (0x0) +float 0x4 < 0x4 == 0x0 (0x0) +int 0x4 > 0x4 == 0x0 (0x0) +__uint 0x4 > 0x4 == 0x0 (0x0) +char 0x4 > 0x4 == 0x0 (0x0) +__uchar 0x4 > 0x4 == 0x0 (0x0) +__longlong 0x4 > 0x4 == 0x0 (0x0) +__ulonglong 0x4 > 0x4 == 0x0 (0x0) +float 0x4 > 0x4 == 0x0 (0x0) +int 0x4 <= 0x4 == 0x1 (0x1) +__uint 0x4 <= 0x4 == 0x1 (0x1) +char 0x4 <= 0x4 == 0x1 (0x1) +__uchar 0x4 <= 0x4 == 0x1 (0x1) +__longlong 0x4 <= 0x4 == 0x1 (0x1) +__ulonglong 0x4 <= 0x4 == 0x1 (0x1) +float 0x4 <= 0x4 == 0x1 (0x1) +int 0x4 == 0x4 == 0x1 (0x1) +__uint 0x4 == 0x4 == 0x1 (0x1) +char 0x4 == 0x4 == 0x1 (0x1) +__uchar 0x4 == 0x4 == 0x1 (0x1) +__longlong 0x4 == 0x4 == 0x1 (0x1) +__ulonglong 0x4 == 0x4 == 0x1 (0x1) +float 0x4 == 0x4 == 0x1 (0x1) +int 0x4 != 0x4 == 0x0 (0x0) +__uint 0x4 != 0x4 == 0x0 (0x0) +char 0x4 != 0x4 == 0x0 (0x0) +__uchar 0x4 != 0x4 == 0x0 (0x0) +__longlong 0x4 != 0x4 == 0x0 (0x0) +__ulonglong 0x4 != 0x4 == 0x0 (0x0) +float 0x4 != 0x4 == 0x0 (0x0) +int 0x4 >= 0x4 == 0x1 (0x1) +__uint 0x4 >= 0x4 == 0x1 (0x1) +char 0x4 >= 0x4 == 0x1 (0x1) +__uchar 0x4 >= 0x4 == 0x1 (0x1) +__longlong 0x4 >= 0x4 == 0x1 (0x1) +__ulonglong 0x4 >= 0x4 == 0x1 (0x1) +float 0x4 >= 0x4 == 0x1 (0x1) +int 0x4 / 0x4 == 0x1 (0x1) +__uint 0x4 / 0x4 == 0x1 (0x1) +char 0x4 / 0x4 == 0x1 (0x1) +__uchar 0x4 / 0x4 == 0x1 (0x1) +__longlong 0x4 / 0x4 == 0x1 (0x1) +__ulonglong 0x4 / 0x4 == 0x1 (0x1) +float 0x4 / 0x4 == 0x1 (0x1) +int 0x4 % 0x4 == 0x0 (0x0) +__uint 0x4 % 0x4 == 0x0 (0x0) +char 0x4 % 0x4 == 0x0 (0x0) +__uchar 0x4 % 0x4 == 0x0 (0x0) +__longlong 0x4 % 0x4 == 0x0 (0x0) +__ulonglong 0x4 % 0x4 == 0x0 (0x0) +0x4 * 0xfffc == -0x10 +0x4 / 0xfffc == -0x1 +0x4 % 0xfffc == 0x0 +int 0x4 ^ 0xfffc == -0x8 (0xfff8) +__uint 0x4 ^ 0xfffc == -0x8 (0xfff8) +char 0x4 ^ 0xfffc == -0x8 (0xfff8) +__uchar 0x4 ^ 0xfc == 0xf8 (0xf8) +__longlong 0x4 ^ 0xfffc == -0x8 (0xfff8) +__ulonglong 0x4 ^ 0xfffc == -0x8 (0xfff8) +int 0x4 && 0xfffc == 0x1 (0x1) +__uint 0x4 && 0xfffc == 0x1 (0x1) +char 0x4 && 0xfffc == 0x1 (0x1) +__uchar 0x4 && 0xfc == 0x1 (0x1) +__longlong 0x4 && 0xfffc == 0x1 (0x1) +__ulonglong 0x4 && 0xfffc == 0x1 (0x1) +int 0x4 || 0xfffc == 0x1 (0x1) +__uint 0x4 || 0xfffc == 0x1 (0x1) +char 0x4 || 0xfffc == 0x1 (0x1) +__uchar 0x4 || 0xfc == 0x1 (0x1) +__longlong 0x4 || 0xfffc == 0x1 (0x1) +__ulonglong 0x4 || 0xfffc == 0x1 (0x1) +int 0x4 & 0xfffc == 0x4 (0x4) +__uint 0x4 & 0xfffc == 0x4 (0x4) +char 0x4 & 0xfffc == 0x4 (0x4) +__uchar 0x4 & 0xfc == 0x4 (0x4) +__longlong 0x4 & 0xfffc == 0x4 (0x4) +__ulonglong 0x4 & 0xfffc == 0x4 (0x4) +int 0x4 | 0xfffc == -0x4 (0xfffc) +__uint 0x4 | 0xfffc == -0x4 (0xfffc) +char 0x4 | 0xfffc == -0x4 (0xfffc) +__uchar 0x4 | 0xfc == 0xfc (0xfc) +__longlong 0x4 | 0xfffc == -0x4 (0xfffc) +__ulonglong 0x4 | 0xfffc == -0x4 (0xfffc) +int 0x4 << 0x6 == 0x100 (0x100) +__uint 0x4 << 0x6 == 0x100 (0x100) +char 0x4 << 0x6 == 0x0 (0x0) +__uchar 0x4 << 0x6 == 0x0 (0x0) +__longlong 0x4 << 0x6 == 0x100 (0x100) +__ulonglong 0x4 << 0x6 == 0x100 (0x100) +int 0x4 >> 0x6 == 0x0 (0x0) +__uint 0x4 >> 0x6 == 0x0 (0x0) +char 0x4 >> 0x6 == 0x0 (0x0) +__uchar 0x4 >> 0x6 == 0x0 (0x0) +__longlong 0x4 >> 0x6 == 0x0 (0x0) +__ulonglong 0x4 >> 0x6 == 0x0 (0x0) +int 0x4 + 0xfffc == 0x0 (0x0) +__uint 0x4 + 0xfffc == 0x0 (0x0) +char 0x4 + 0xfffc == 0x0 (0x0) +__uchar 0x4 + 0xfc == 0x0 (0x0) +__longlong 0x4 + 0xfffc == 0x0 (0x0) +__ulonglong 0x4 + 0xfffc == 0x0 (0x0) +float 0x4 + 0xfffc == 0x0 (0x0) +int 0x4 - 0xfffc == 0x8 (0x8) +__uint 0x4 - 0xfffc == 0x8 (0x8) +char 0x4 - 0xfffc == 0x8 (0x8) +__uchar 0x4 - 0xfc == 0x8 (0x8) +__longlong 0x4 - 0xfffc == 0x8 (0x8) +__ulonglong 0x4 - 0xfffc == 0x8 (0x8) +float 0x4 - 0xfffc == 0x8 (0x8) +int 0x4 * 0xfffc == -0x10 (0xfff0) +__uint 0x4 * 0xfffc == -0x10 (0xfff0) +char 0x4 * 0xfffc == -0x10 (0xfff0) +__uchar 0x4 * 0xfc == 0xf0 (0xf0) +__longlong 0x4 * 0xfffc == -0x10 (0xfff0) +__ulonglong 0x4 * 0xfffc == -0x10 (0xfff0) +float 0x4 * 0xfffc == -0x10 (0xfff0) +int 0x4 < 0xfffc == 0x0 (0x0) +__uint 0x4 < 0xfffc == 0x1 (0x1) +char 0x4 < 0xfffc == 0x0 (0x0) +__uchar 0x4 < 0xfc == 0x1 (0x1) +__longlong 0x4 < 0xfffc == 0x0 (0x0) +__ulonglong 0x4 < 0xfffc == 0x1 (0x1) +float 0x4 < 0xfffc == 0x0 (0x0) +int 0x4 > 0xfffc == 0x1 (0x1) +__uint 0x4 > 0xfffc == 0x0 (0x0) +char 0x4 > 0xfffc == 0x1 (0x1) +__uchar 0x4 > 0xfc == 0x0 (0x0) +__longlong 0x4 > 0xfffc == 0x1 (0x1) +__ulonglong 0x4 > 0xfffc == 0x0 (0x0) +float 0x4 > 0xfffc == 0x1 (0x1) +int 0x4 <= 0xfffc == 0x0 (0x0) +__uint 0x4 <= 0xfffc == 0x1 (0x1) +char 0x4 <= 0xfffc == 0x0 (0x0) +__uchar 0x4 <= 0xfc == 0x1 (0x1) +__longlong 0x4 <= 0xfffc == 0x0 (0x0) +__ulonglong 0x4 <= 0xfffc == 0x1 (0x1) +float 0x4 <= 0xfffc == 0x0 (0x0) +int 0x4 == 0xfffc == 0x0 (0x0) +__uint 0x4 == 0xfffc == 0x0 (0x0) +char 0x4 == 0xfffc == 0x0 (0x0) +__uchar 0x4 == 0xfc == 0x0 (0x0) +__longlong 0x4 == 0xfffc == 0x0 (0x0) +__ulonglong 0x4 == 0xfffc == 0x0 (0x0) +float 0x4 == 0xfffc == 0x0 (0x0) +int 0x4 != 0xfffc == 0x1 (0x1) +__uint 0x4 != 0xfffc == 0x1 (0x1) +char 0x4 != 0xfffc == 0x1 (0x1) +__uchar 0x4 != 0xfc == 0x1 (0x1) +__longlong 0x4 != 0xfffc == 0x1 (0x1) +__ulonglong 0x4 != 0xfffc == 0x1 (0x1) +float 0x4 != 0xfffc == 0x1 (0x1) +int 0x4 >= 0xfffc == 0x1 (0x1) +__uint 0x4 >= 0xfffc == 0x0 (0x0) +char 0x4 >= 0xfffc == 0x1 (0x1) +__uchar 0x4 >= 0xfc == 0x0 (0x0) +__longlong 0x4 >= 0xfffc == 0x1 (0x1) +__ulonglong 0x4 >= 0xfffc == 0x0 (0x0) +float 0x4 >= 0xfffc == 0x1 (0x1) +int 0x4 / 0xfffc == -0x1 (0xffff) +__uint 0x4 / 0xfffc == 0x0 (0x0) +char 0x4 / 0xfffc == -0x1 (0xffff) +__uchar 0x4 / 0xfc == 0x0 (0x0) +__longlong 0x4 / 0xfffc == -0x1 (0xffff) +__ulonglong 0x4 / 0xfffc == 0x0 (0x0) +float 0x4 / 0xfffc == -0x1 (0xffff) +int 0x4 % 0xfffc == 0x0 (0x0) +__uint 0x4 % 0xfffc == 0x4 (0x4) +char 0x4 % 0xfffc == 0x0 (0x0) +__uchar 0x4 % 0xfc == 0x4 (0x4) +__longlong 0x4 % 0xfffc == 0x0 (0x0) +__ulonglong 0x4 % 0xfffc == 0x4 (0x4) +0x4 * 0xa == 0x28 +0x4 / 0xa == 0x0 +0x4 % 0xa == 0x4 +int 0x4 ^ 0xa == 0xe (0xe) +__uint 0x4 ^ 0xa == 0xe (0xe) +char 0x4 ^ 0xa == 0xe (0xe) +__uchar 0x4 ^ 0xa == 0xe (0xe) +__longlong 0x4 ^ 0xa == 0xe (0xe) +__ulonglong 0x4 ^ 0xa == 0xe (0xe) +int 0x4 && 0xa == 0x1 (0x1) +__uint 0x4 && 0xa == 0x1 (0x1) +char 0x4 && 0xa == 0x1 (0x1) +__uchar 0x4 && 0xa == 0x1 (0x1) +__longlong 0x4 && 0xa == 0x1 (0x1) +__ulonglong 0x4 && 0xa == 0x1 (0x1) +int 0x4 || 0xa == 0x1 (0x1) +__uint 0x4 || 0xa == 0x1 (0x1) +char 0x4 || 0xa == 0x1 (0x1) +__uchar 0x4 || 0xa == 0x1 (0x1) +__longlong 0x4 || 0xa == 0x1 (0x1) +__ulonglong 0x4 || 0xa == 0x1 (0x1) +int 0x4 & 0xa == 0x0 (0x0) +__uint 0x4 & 0xa == 0x0 (0x0) +char 0x4 & 0xa == 0x0 (0x0) +__uchar 0x4 & 0xa == 0x0 (0x0) +__longlong 0x4 & 0xa == 0x0 (0x0) +__ulonglong 0x4 & 0xa == 0x0 (0x0) +int 0x4 | 0xa == 0xe (0xe) +__uint 0x4 | 0xa == 0xe (0xe) +char 0x4 | 0xa == 0xe (0xe) +__uchar 0x4 | 0xa == 0xe (0xe) +__longlong 0x4 | 0xa == 0xe (0xe) +__ulonglong 0x4 | 0xa == 0xe (0xe) +int 0x4 << 0x7 == 0x200 (0x200) +__uint 0x4 << 0x7 == 0x200 (0x200) +char 0x4 << 0x7 == 0x0 (0x0) +__uchar 0x4 << 0x7 == 0x0 (0x0) +__longlong 0x4 << 0x7 == 0x200 (0x200) +__ulonglong 0x4 << 0x7 == 0x200 (0x200) +int 0x4 >> 0x7 == 0x0 (0x0) +__uint 0x4 >> 0x7 == 0x0 (0x0) +char 0x4 >> 0x7 == 0x0 (0x0) +__uchar 0x4 >> 0x7 == 0x0 (0x0) +__longlong 0x4 >> 0x7 == 0x0 (0x0) +__ulonglong 0x4 >> 0x7 == 0x0 (0x0) +int 0x4 + 0xa == 0xe (0xe) +__uint 0x4 + 0xa == 0xe (0xe) +char 0x4 + 0xa == 0xe (0xe) +__uchar 0x4 + 0xa == 0xe (0xe) +__longlong 0x4 + 0xa == 0xe (0xe) +__ulonglong 0x4 + 0xa == 0xe (0xe) +float 0x4 + 0xa == 0xe (0xe) +int 0x4 - 0xa == -0x6 (0xfffa) +__uint 0x4 - 0xa == -0x6 (0xfffa) +char 0x4 - 0xa == -0x6 (0xfffa) +__uchar 0x4 - 0xa == 0xfa (0xfa) +__longlong 0x4 - 0xa == -0x6 (0xfffa) +__ulonglong 0x4 - 0xa == -0x6 (0xfffa) +float 0x4 - 0xa == -0x6 (0xfffa) +int 0x4 * 0xa == 0x28 (0x28) +__uint 0x4 * 0xa == 0x28 (0x28) +char 0x4 * 0xa == 0x28 (0x28) +__uchar 0x4 * 0xa == 0x28 (0x28) +__longlong 0x4 * 0xa == 0x28 (0x28) +__ulonglong 0x4 * 0xa == 0x28 (0x28) +float 0x4 * 0xa == 0x28 (0x28) +int 0x4 < 0xa == 0x1 (0x1) +__uint 0x4 < 0xa == 0x1 (0x1) +char 0x4 < 0xa == 0x1 (0x1) +__uchar 0x4 < 0xa == 0x1 (0x1) +__longlong 0x4 < 0xa == 0x1 (0x1) +__ulonglong 0x4 < 0xa == 0x1 (0x1) +float 0x4 < 0xa == 0x1 (0x1) +int 0x4 > 0xa == 0x0 (0x0) +__uint 0x4 > 0xa == 0x0 (0x0) +char 0x4 > 0xa == 0x0 (0x0) +__uchar 0x4 > 0xa == 0x0 (0x0) +__longlong 0x4 > 0xa == 0x0 (0x0) +__ulonglong 0x4 > 0xa == 0x0 (0x0) +float 0x4 > 0xa == 0x0 (0x0) +int 0x4 <= 0xa == 0x1 (0x1) +__uint 0x4 <= 0xa == 0x1 (0x1) +char 0x4 <= 0xa == 0x1 (0x1) +__uchar 0x4 <= 0xa == 0x1 (0x1) +__longlong 0x4 <= 0xa == 0x1 (0x1) +__ulonglong 0x4 <= 0xa == 0x1 (0x1) +float 0x4 <= 0xa == 0x1 (0x1) +int 0x4 == 0xa == 0x0 (0x0) +__uint 0x4 == 0xa == 0x0 (0x0) +char 0x4 == 0xa == 0x0 (0x0) +__uchar 0x4 == 0xa == 0x0 (0x0) +__longlong 0x4 == 0xa == 0x0 (0x0) +__ulonglong 0x4 == 0xa == 0x0 (0x0) +float 0x4 == 0xa == 0x0 (0x0) +int 0x4 != 0xa == 0x1 (0x1) +__uint 0x4 != 0xa == 0x1 (0x1) +char 0x4 != 0xa == 0x1 (0x1) +__uchar 0x4 != 0xa == 0x1 (0x1) +__longlong 0x4 != 0xa == 0x1 (0x1) +__ulonglong 0x4 != 0xa == 0x1 (0x1) +float 0x4 != 0xa == 0x1 (0x1) +int 0x4 >= 0xa == 0x0 (0x0) +__uint 0x4 >= 0xa == 0x0 (0x0) +char 0x4 >= 0xa == 0x0 (0x0) +__uchar 0x4 >= 0xa == 0x0 (0x0) +__longlong 0x4 >= 0xa == 0x0 (0x0) +__ulonglong 0x4 >= 0xa == 0x0 (0x0) +float 0x4 >= 0xa == 0x0 (0x0) +int 0x4 / 0xa == 0x0 (0x0) +__uint 0x4 / 0xa == 0x0 (0x0) +char 0x4 / 0xa == 0x0 (0x0) +__uchar 0x4 / 0xa == 0x0 (0x0) +__longlong 0x4 / 0xa == 0x0 (0x0) +__ulonglong 0x4 / 0xa == 0x0 (0x0) +float 0x4 / 0xa == 0x0 (0x0) +int 0x4 % 0xa == 0x4 (0x4) +__uint 0x4 % 0xa == 0x4 (0x4) +char 0x4 % 0xa == 0x4 (0x4) +__uchar 0x4 % 0xa == 0x4 (0x4) +__longlong 0x4 % 0xa == 0x4 (0x4) +__ulonglong 0x4 % 0xa == 0x4 (0x4) +0x4 * 0xfff6 == -0x28 +0x4 / 0xfff6 == 0x0 +0x4 % 0xfff6 == 0x4 +int 0x4 ^ 0xfff6 == -0xe (0xfff2) +__uint 0x4 ^ 0xfff6 == -0xe (0xfff2) +char 0x4 ^ 0xfff6 == -0xe (0xfff2) +__uchar 0x4 ^ 0xf6 == 0xf2 (0xf2) +__longlong 0x4 ^ 0xfff6 == -0xe (0xfff2) +__ulonglong 0x4 ^ 0xfff6 == -0xe (0xfff2) +int 0x4 && 0xfff6 == 0x1 (0x1) +__uint 0x4 && 0xfff6 == 0x1 (0x1) +char 0x4 && 0xfff6 == 0x1 (0x1) +__uchar 0x4 && 0xf6 == 0x1 (0x1) +__longlong 0x4 && 0xfff6 == 0x1 (0x1) +__ulonglong 0x4 && 0xfff6 == 0x1 (0x1) +int 0x4 || 0xfff6 == 0x1 (0x1) +__uint 0x4 || 0xfff6 == 0x1 (0x1) +char 0x4 || 0xfff6 == 0x1 (0x1) +__uchar 0x4 || 0xf6 == 0x1 (0x1) +__longlong 0x4 || 0xfff6 == 0x1 (0x1) +__ulonglong 0x4 || 0xfff6 == 0x1 (0x1) +int 0x4 & 0xfff6 == 0x4 (0x4) +__uint 0x4 & 0xfff6 == 0x4 (0x4) +char 0x4 & 0xfff6 == 0x4 (0x4) +__uchar 0x4 & 0xf6 == 0x4 (0x4) +__longlong 0x4 & 0xfff6 == 0x4 (0x4) +__ulonglong 0x4 & 0xfff6 == 0x4 (0x4) +int 0x4 | 0xfff6 == -0xa (0xfff6) +__uint 0x4 | 0xfff6 == -0xa (0xfff6) +char 0x4 | 0xfff6 == -0xa (0xfff6) +__uchar 0x4 | 0xf6 == 0xf6 (0xf6) +__longlong 0x4 | 0xfff6 == -0xa (0xfff6) +__ulonglong 0x4 | 0xfff6 == -0xa (0xfff6) +int 0x4 << 0x8 == 0x400 (0x400) +__uint 0x4 << 0x8 == 0x400 (0x400) +char 0x4 << 0x8 == 0x0 (0x0) +__uchar 0x4 << 0x8 == 0x0 (0x0) +__longlong 0x4 << 0x8 == 0x400 (0x400) +__ulonglong 0x4 << 0x8 == 0x400 (0x400) +int 0x4 >> 0x8 == 0x0 (0x0) +__uint 0x4 >> 0x8 == 0x0 (0x0) +char 0x4 >> 0x8 == 0x0 (0x0) +__uchar 0x4 >> 0x8 == 0x0 (0x0) +__longlong 0x4 >> 0x8 == 0x0 (0x0) +__ulonglong 0x4 >> 0x8 == 0x0 (0x0) +int 0x4 + 0xfff6 == -0x6 (0xfffa) +__uint 0x4 + 0xfff6 == -0x6 (0xfffa) +char 0x4 + 0xfff6 == -0x6 (0xfffa) +__uchar 0x4 + 0xf6 == 0xfa (0xfa) +__longlong 0x4 + 0xfff6 == -0x6 (0xfffa) +__ulonglong 0x4 + 0xfff6 == -0x6 (0xfffa) +float 0x4 + 0xfff6 == -0x6 (0xfffa) +int 0x4 - 0xfff6 == 0xe (0xe) +__uint 0x4 - 0xfff6 == 0xe (0xe) +char 0x4 - 0xfff6 == 0xe (0xe) +__uchar 0x4 - 0xf6 == 0xe (0xe) +__longlong 0x4 - 0xfff6 == 0xe (0xe) +__ulonglong 0x4 - 0xfff6 == 0xe (0xe) +float 0x4 - 0xfff6 == 0xe (0xe) +int 0x4 * 0xfff6 == -0x28 (0xffd8) +__uint 0x4 * 0xfff6 == -0x28 (0xffd8) +char 0x4 * 0xfff6 == -0x28 (0xffd8) +__uchar 0x4 * 0xf6 == 0xd8 (0xd8) +__longlong 0x4 * 0xfff6 == -0x28 (0xffd8) +__ulonglong 0x4 * 0xfff6 == -0x28 (0xffd8) +float 0x4 * 0xfff6 == -0x28 (0xffd8) +int 0x4 < 0xfff6 == 0x0 (0x0) +__uint 0x4 < 0xfff6 == 0x1 (0x1) +char 0x4 < 0xfff6 == 0x0 (0x0) +__uchar 0x4 < 0xf6 == 0x1 (0x1) +__longlong 0x4 < 0xfff6 == 0x0 (0x0) +__ulonglong 0x4 < 0xfff6 == 0x1 (0x1) +float 0x4 < 0xfff6 == 0x0 (0x0) +int 0x4 > 0xfff6 == 0x1 (0x1) +__uint 0x4 > 0xfff6 == 0x0 (0x0) +char 0x4 > 0xfff6 == 0x1 (0x1) +__uchar 0x4 > 0xf6 == 0x0 (0x0) +__longlong 0x4 > 0xfff6 == 0x1 (0x1) +__ulonglong 0x4 > 0xfff6 == 0x0 (0x0) +float 0x4 > 0xfff6 == 0x1 (0x1) +int 0x4 <= 0xfff6 == 0x0 (0x0) +__uint 0x4 <= 0xfff6 == 0x1 (0x1) +char 0x4 <= 0xfff6 == 0x0 (0x0) +__uchar 0x4 <= 0xf6 == 0x1 (0x1) +__longlong 0x4 <= 0xfff6 == 0x0 (0x0) +__ulonglong 0x4 <= 0xfff6 == 0x1 (0x1) +float 0x4 <= 0xfff6 == 0x0 (0x0) +int 0x4 == 0xfff6 == 0x0 (0x0) +__uint 0x4 == 0xfff6 == 0x0 (0x0) +char 0x4 == 0xfff6 == 0x0 (0x0) +__uchar 0x4 == 0xf6 == 0x0 (0x0) +__longlong 0x4 == 0xfff6 == 0x0 (0x0) +__ulonglong 0x4 == 0xfff6 == 0x0 (0x0) +float 0x4 == 0xfff6 == 0x0 (0x0) +int 0x4 != 0xfff6 == 0x1 (0x1) +__uint 0x4 != 0xfff6 == 0x1 (0x1) +char 0x4 != 0xfff6 == 0x1 (0x1) +__uchar 0x4 != 0xf6 == 0x1 (0x1) +__longlong 0x4 != 0xfff6 == 0x1 (0x1) +__ulonglong 0x4 != 0xfff6 == 0x1 (0x1) +float 0x4 != 0xfff6 == 0x1 (0x1) +int 0x4 >= 0xfff6 == 0x1 (0x1) +__uint 0x4 >= 0xfff6 == 0x0 (0x0) +char 0x4 >= 0xfff6 == 0x1 (0x1) +__uchar 0x4 >= 0xf6 == 0x0 (0x0) +__longlong 0x4 >= 0xfff6 == 0x1 (0x1) +__ulonglong 0x4 >= 0xfff6 == 0x0 (0x0) +float 0x4 >= 0xfff6 == 0x1 (0x1) +int 0x4 / 0xfff6 == 0x0 (0x0) +__uint 0x4 / 0xfff6 == 0x0 (0x0) +char 0x4 / 0xfff6 == 0x0 (0x0) +__uchar 0x4 / 0xf6 == 0x0 (0x0) +__longlong 0x4 / 0xfff6 == 0x0 (0x0) +__ulonglong 0x4 / 0xfff6 == 0x0 (0x0) +float 0x4 / 0xfff6 == 0x0 (0x0) +int 0x4 % 0xfff6 == 0x4 (0x4) +__uint 0x4 % 0xfff6 == 0x4 (0x4) +char 0x4 % 0xfff6 == 0x4 (0x4) +__uchar 0x4 % 0xf6 == 0x4 (0x4) +__longlong 0x4 % 0xfff6 == 0x4 (0x4) +__ulonglong 0x4 % 0xfff6 == 0x4 (0x4) +0x4 * 0x5 == 0x14 +0x4 / 0x5 == 0x0 +0x4 % 0x5 == 0x4 +int 0x4 ^ 0x5 == 0x1 (0x1) +__uint 0x4 ^ 0x5 == 0x1 (0x1) +char 0x4 ^ 0x5 == 0x1 (0x1) +__uchar 0x4 ^ 0x5 == 0x1 (0x1) +__longlong 0x4 ^ 0x5 == 0x1 (0x1) +__ulonglong 0x4 ^ 0x5 == 0x1 (0x1) +int 0x4 && 0x5 == 0x1 (0x1) +__uint 0x4 && 0x5 == 0x1 (0x1) +char 0x4 && 0x5 == 0x1 (0x1) +__uchar 0x4 && 0x5 == 0x1 (0x1) +__longlong 0x4 && 0x5 == 0x1 (0x1) +__ulonglong 0x4 && 0x5 == 0x1 (0x1) +int 0x4 || 0x5 == 0x1 (0x1) +__uint 0x4 || 0x5 == 0x1 (0x1) +char 0x4 || 0x5 == 0x1 (0x1) +__uchar 0x4 || 0x5 == 0x1 (0x1) +__longlong 0x4 || 0x5 == 0x1 (0x1) +__ulonglong 0x4 || 0x5 == 0x1 (0x1) +int 0x4 & 0x5 == 0x4 (0x4) +__uint 0x4 & 0x5 == 0x4 (0x4) +char 0x4 & 0x5 == 0x4 (0x4) +__uchar 0x4 & 0x5 == 0x4 (0x4) +__longlong 0x4 & 0x5 == 0x4 (0x4) +__ulonglong 0x4 & 0x5 == 0x4 (0x4) +int 0x4 | 0x5 == 0x5 (0x5) +__uint 0x4 | 0x5 == 0x5 (0x5) +char 0x4 | 0x5 == 0x5 (0x5) +__uchar 0x4 | 0x5 == 0x5 (0x5) +__longlong 0x4 | 0x5 == 0x5 (0x5) +__ulonglong 0x4 | 0x5 == 0x5 (0x5) +int 0x4 << 0x9 == 0x800 (0x800) +__uint 0x4 << 0x9 == 0x800 (0x800) +char 0x4 << 0x9 == 0x0 (0x0) +__uchar 0x4 << 0x9 == 0x0 (0x0) +__longlong 0x4 << 0x9 == 0x800 (0x800) +__ulonglong 0x4 << 0x9 == 0x800 (0x800) +int 0x4 >> 0x9 == 0x0 (0x0) +__uint 0x4 >> 0x9 == 0x0 (0x0) +char 0x4 >> 0x9 == 0x0 (0x0) +__uchar 0x4 >> 0x9 == 0x0 (0x0) +__longlong 0x4 >> 0x9 == 0x0 (0x0) +__ulonglong 0x4 >> 0x9 == 0x0 (0x0) +int 0x4 + 0x5 == 0x9 (0x9) +__uint 0x4 + 0x5 == 0x9 (0x9) +char 0x4 + 0x5 == 0x9 (0x9) +__uchar 0x4 + 0x5 == 0x9 (0x9) +__longlong 0x4 + 0x5 == 0x9 (0x9) +__ulonglong 0x4 + 0x5 == 0x9 (0x9) +float 0x4 + 0x5 == 0x9 (0x9) +int 0x4 - 0x5 == -0x1 (0xffff) +__uint 0x4 - 0x5 == -0x1 (0xffff) +char 0x4 - 0x5 == -0x1 (0xffff) +__uchar 0x4 - 0x5 == 0xff (0xff) +__longlong 0x4 - 0x5 == -0x1 (0xffff) +__ulonglong 0x4 - 0x5 == -0x1 (0xffff) +float 0x4 - 0x5 == -0x1 (0xffff) +int 0x4 * 0x5 == 0x14 (0x14) +__uint 0x4 * 0x5 == 0x14 (0x14) +char 0x4 * 0x5 == 0x14 (0x14) +__uchar 0x4 * 0x5 == 0x14 (0x14) +__longlong 0x4 * 0x5 == 0x14 (0x14) +__ulonglong 0x4 * 0x5 == 0x14 (0x14) +float 0x4 * 0x5 == 0x14 (0x14) +int 0x4 < 0x5 == 0x1 (0x1) +__uint 0x4 < 0x5 == 0x1 (0x1) +char 0x4 < 0x5 == 0x1 (0x1) +__uchar 0x4 < 0x5 == 0x1 (0x1) +__longlong 0x4 < 0x5 == 0x1 (0x1) +__ulonglong 0x4 < 0x5 == 0x1 (0x1) +float 0x4 < 0x5 == 0x1 (0x1) +int 0x4 > 0x5 == 0x0 (0x0) +__uint 0x4 > 0x5 == 0x0 (0x0) +char 0x4 > 0x5 == 0x0 (0x0) +__uchar 0x4 > 0x5 == 0x0 (0x0) +__longlong 0x4 > 0x5 == 0x0 (0x0) +__ulonglong 0x4 > 0x5 == 0x0 (0x0) +float 0x4 > 0x5 == 0x0 (0x0) +int 0x4 <= 0x5 == 0x1 (0x1) +__uint 0x4 <= 0x5 == 0x1 (0x1) +char 0x4 <= 0x5 == 0x1 (0x1) +__uchar 0x4 <= 0x5 == 0x1 (0x1) +__longlong 0x4 <= 0x5 == 0x1 (0x1) +__ulonglong 0x4 <= 0x5 == 0x1 (0x1) +float 0x4 <= 0x5 == 0x1 (0x1) +int 0x4 == 0x5 == 0x0 (0x0) +__uint 0x4 == 0x5 == 0x0 (0x0) +char 0x4 == 0x5 == 0x0 (0x0) +__uchar 0x4 == 0x5 == 0x0 (0x0) +__longlong 0x4 == 0x5 == 0x0 (0x0) +__ulonglong 0x4 == 0x5 == 0x0 (0x0) +float 0x4 == 0x5 == 0x0 (0x0) +int 0x4 != 0x5 == 0x1 (0x1) +__uint 0x4 != 0x5 == 0x1 (0x1) +char 0x4 != 0x5 == 0x1 (0x1) +__uchar 0x4 != 0x5 == 0x1 (0x1) +__longlong 0x4 != 0x5 == 0x1 (0x1) +__ulonglong 0x4 != 0x5 == 0x1 (0x1) +float 0x4 != 0x5 == 0x1 (0x1) +int 0x4 >= 0x5 == 0x0 (0x0) +__uint 0x4 >= 0x5 == 0x0 (0x0) +char 0x4 >= 0x5 == 0x0 (0x0) +__uchar 0x4 >= 0x5 == 0x0 (0x0) +__longlong 0x4 >= 0x5 == 0x0 (0x0) +__ulonglong 0x4 >= 0x5 == 0x0 (0x0) +float 0x4 >= 0x5 == 0x0 (0x0) +int 0x4 / 0x5 == 0x0 (0x0) +__uint 0x4 / 0x5 == 0x0 (0x0) +char 0x4 / 0x5 == 0x0 (0x0) +__uchar 0x4 / 0x5 == 0x0 (0x0) +__longlong 0x4 / 0x5 == 0x0 (0x0) +__ulonglong 0x4 / 0x5 == 0x0 (0x0) +float 0x4 / 0x5 == 0x0 (0x0) +int 0x4 % 0x5 == 0x4 (0x4) +__uint 0x4 % 0x5 == 0x4 (0x4) +char 0x4 % 0x5 == 0x4 (0x4) +__uchar 0x4 % 0x5 == 0x4 (0x4) +__longlong 0x4 % 0x5 == 0x4 (0x4) +__ulonglong 0x4 % 0x5 == 0x4 (0x4) +0x4 * 0x7 == 0x1c +0x4 / 0x7 == 0x0 +0x4 % 0x7 == 0x4 +int 0x4 ^ 0x7 == 0x3 (0x3) +__uint 0x4 ^ 0x7 == 0x3 (0x3) +char 0x4 ^ 0x7 == 0x3 (0x3) +__uchar 0x4 ^ 0x7 == 0x3 (0x3) +__longlong 0x4 ^ 0x7 == 0x3 (0x3) +__ulonglong 0x4 ^ 0x7 == 0x3 (0x3) +int 0x4 && 0x7 == 0x1 (0x1) +__uint 0x4 && 0x7 == 0x1 (0x1) +char 0x4 && 0x7 == 0x1 (0x1) +__uchar 0x4 && 0x7 == 0x1 (0x1) +__longlong 0x4 && 0x7 == 0x1 (0x1) +__ulonglong 0x4 && 0x7 == 0x1 (0x1) +int 0x4 || 0x7 == 0x1 (0x1) +__uint 0x4 || 0x7 == 0x1 (0x1) +char 0x4 || 0x7 == 0x1 (0x1) +__uchar 0x4 || 0x7 == 0x1 (0x1) +__longlong 0x4 || 0x7 == 0x1 (0x1) +__ulonglong 0x4 || 0x7 == 0x1 (0x1) +int 0x4 & 0x7 == 0x4 (0x4) +__uint 0x4 & 0x7 == 0x4 (0x4) +char 0x4 & 0x7 == 0x4 (0x4) +__uchar 0x4 & 0x7 == 0x4 (0x4) +__longlong 0x4 & 0x7 == 0x4 (0x4) +__ulonglong 0x4 & 0x7 == 0x4 (0x4) +int 0x4 | 0x7 == 0x7 (0x7) +__uint 0x4 | 0x7 == 0x7 (0x7) +char 0x4 | 0x7 == 0x7 (0x7) +__uchar 0x4 | 0x7 == 0x7 (0x7) +__longlong 0x4 | 0x7 == 0x7 (0x7) +__ulonglong 0x4 | 0x7 == 0x7 (0x7) +int 0x4 << 0xa == 0x1000 (0x1000) +__uint 0x4 << 0xa == 0x1000 (0x1000) +char 0x4 << 0xa == 0x0 (0x0) +__uchar 0x4 << 0xa == 0x0 (0x0) +__longlong 0x4 << 0xa == 0x1000 (0x1000) +__ulonglong 0x4 << 0xa == 0x1000 (0x1000) +int 0x4 >> 0xa == 0x0 (0x0) +__uint 0x4 >> 0xa == 0x0 (0x0) +char 0x4 >> 0xa == 0x0 (0x0) +__uchar 0x4 >> 0xa == 0x0 (0x0) +__longlong 0x4 >> 0xa == 0x0 (0x0) +__ulonglong 0x4 >> 0xa == 0x0 (0x0) +int 0x4 + 0x7 == 0xb (0xb) +__uint 0x4 + 0x7 == 0xb (0xb) +char 0x4 + 0x7 == 0xb (0xb) +__uchar 0x4 + 0x7 == 0xb (0xb) +__longlong 0x4 + 0x7 == 0xb (0xb) +__ulonglong 0x4 + 0x7 == 0xb (0xb) +float 0x4 + 0x7 == 0xb (0xb) +int 0x4 - 0x7 == -0x3 (0xfffd) +__uint 0x4 - 0x7 == -0x3 (0xfffd) +char 0x4 - 0x7 == -0x3 (0xfffd) +__uchar 0x4 - 0x7 == 0xfd (0xfd) +__longlong 0x4 - 0x7 == -0x3 (0xfffd) +__ulonglong 0x4 - 0x7 == -0x3 (0xfffd) +float 0x4 - 0x7 == -0x3 (0xfffd) +int 0x4 * 0x7 == 0x1c (0x1c) +__uint 0x4 * 0x7 == 0x1c (0x1c) +char 0x4 * 0x7 == 0x1c (0x1c) +__uchar 0x4 * 0x7 == 0x1c (0x1c) +__longlong 0x4 * 0x7 == 0x1c (0x1c) +__ulonglong 0x4 * 0x7 == 0x1c (0x1c) +float 0x4 * 0x7 == 0x1c (0x1c) +int 0x4 < 0x7 == 0x1 (0x1) +__uint 0x4 < 0x7 == 0x1 (0x1) +char 0x4 < 0x7 == 0x1 (0x1) +__uchar 0x4 < 0x7 == 0x1 (0x1) +__longlong 0x4 < 0x7 == 0x1 (0x1) +__ulonglong 0x4 < 0x7 == 0x1 (0x1) +float 0x4 < 0x7 == 0x1 (0x1) +int 0x4 > 0x7 == 0x0 (0x0) +__uint 0x4 > 0x7 == 0x0 (0x0) +char 0x4 > 0x7 == 0x0 (0x0) +__uchar 0x4 > 0x7 == 0x0 (0x0) +__longlong 0x4 > 0x7 == 0x0 (0x0) +__ulonglong 0x4 > 0x7 == 0x0 (0x0) +float 0x4 > 0x7 == 0x0 (0x0) +int 0x4 <= 0x7 == 0x1 (0x1) +__uint 0x4 <= 0x7 == 0x1 (0x1) +char 0x4 <= 0x7 == 0x1 (0x1) +__uchar 0x4 <= 0x7 == 0x1 (0x1) +__longlong 0x4 <= 0x7 == 0x1 (0x1) +__ulonglong 0x4 <= 0x7 == 0x1 (0x1) +float 0x4 <= 0x7 == 0x1 (0x1) +int 0x4 == 0x7 == 0x0 (0x0) +__uint 0x4 == 0x7 == 0x0 (0x0) +char 0x4 == 0x7 == 0x0 (0x0) +__uchar 0x4 == 0x7 == 0x0 (0x0) +__longlong 0x4 == 0x7 == 0x0 (0x0) +__ulonglong 0x4 == 0x7 == 0x0 (0x0) +float 0x4 == 0x7 == 0x0 (0x0) +int 0x4 != 0x7 == 0x1 (0x1) +__uint 0x4 != 0x7 == 0x1 (0x1) +char 0x4 != 0x7 == 0x1 (0x1) +__uchar 0x4 != 0x7 == 0x1 (0x1) +__longlong 0x4 != 0x7 == 0x1 (0x1) +__ulonglong 0x4 != 0x7 == 0x1 (0x1) +float 0x4 != 0x7 == 0x1 (0x1) +int 0x4 >= 0x7 == 0x0 (0x0) +__uint 0x4 >= 0x7 == 0x0 (0x0) +char 0x4 >= 0x7 == 0x0 (0x0) +__uchar 0x4 >= 0x7 == 0x0 (0x0) +__longlong 0x4 >= 0x7 == 0x0 (0x0) +__ulonglong 0x4 >= 0x7 == 0x0 (0x0) +float 0x4 >= 0x7 == 0x0 (0x0) +int 0x4 / 0x7 == 0x0 (0x0) +__uint 0x4 / 0x7 == 0x0 (0x0) +char 0x4 / 0x7 == 0x0 (0x0) +__uchar 0x4 / 0x7 == 0x0 (0x0) +__longlong 0x4 / 0x7 == 0x0 (0x0) +__ulonglong 0x4 / 0x7 == 0x0 (0x0) +float 0x4 / 0x7 == 0x0 (0x0) +int 0x4 % 0x7 == 0x4 (0x4) +__uint 0x4 % 0x7 == 0x4 (0x4) +char 0x4 % 0x7 == 0x4 (0x4) +__uchar 0x4 % 0x7 == 0x4 (0x4) +__longlong 0x4 % 0x7 == 0x4 (0x4) +__ulonglong 0x4 % 0x7 == 0x4 (0x4) +0x4 * 0x2a == 0xa8 +0x4 / 0x2a == 0x0 +0x4 % 0x2a == 0x4 +int 0x4 ^ 0x2a == 0x2e (0x2e) +__uint 0x4 ^ 0x2a == 0x2e (0x2e) +char 0x4 ^ 0x2a == 0x2e (0x2e) +__uchar 0x4 ^ 0x2a == 0x2e (0x2e) +__longlong 0x4 ^ 0x2a == 0x2e (0x2e) +__ulonglong 0x4 ^ 0x2a == 0x2e (0x2e) +int 0x4 && 0x2a == 0x1 (0x1) +__uint 0x4 && 0x2a == 0x1 (0x1) +char 0x4 && 0x2a == 0x1 (0x1) +__uchar 0x4 && 0x2a == 0x1 (0x1) +__longlong 0x4 && 0x2a == 0x1 (0x1) +__ulonglong 0x4 && 0x2a == 0x1 (0x1) +int 0x4 || 0x2a == 0x1 (0x1) +__uint 0x4 || 0x2a == 0x1 (0x1) +char 0x4 || 0x2a == 0x1 (0x1) +__uchar 0x4 || 0x2a == 0x1 (0x1) +__longlong 0x4 || 0x2a == 0x1 (0x1) +__ulonglong 0x4 || 0x2a == 0x1 (0x1) +int 0x4 & 0x2a == 0x0 (0x0) +__uint 0x4 & 0x2a == 0x0 (0x0) +char 0x4 & 0x2a == 0x0 (0x0) +__uchar 0x4 & 0x2a == 0x0 (0x0) +__longlong 0x4 & 0x2a == 0x0 (0x0) +__ulonglong 0x4 & 0x2a == 0x0 (0x0) +int 0x4 | 0x2a == 0x2e (0x2e) +__uint 0x4 | 0x2a == 0x2e (0x2e) +char 0x4 | 0x2a == 0x2e (0x2e) +__uchar 0x4 | 0x2a == 0x2e (0x2e) +__longlong 0x4 | 0x2a == 0x2e (0x2e) +__ulonglong 0x4 | 0x2a == 0x2e (0x2e) +int 0x4 << 0xc == 0x4000 (0x4000) +__uint 0x4 << 0xc == 0x4000 (0x4000) +char 0x4 << 0xc == 0x0 (0x0) +__uchar 0x4 << 0xc == 0x0 (0x0) +__longlong 0x4 << 0xc == 0x4000 (0x4000) +__ulonglong 0x4 << 0xc == 0x4000 (0x4000) +int 0x4 >> 0xc == 0x0 (0x0) +__uint 0x4 >> 0xc == 0x0 (0x0) +char 0x4 >> 0xc == 0x0 (0x0) +__uchar 0x4 >> 0xc == 0x0 (0x0) +__longlong 0x4 >> 0xc == 0x0 (0x0) +__ulonglong 0x4 >> 0xc == 0x0 (0x0) +int 0x4 + 0x2a == 0x2e (0x2e) +__uint 0x4 + 0x2a == 0x2e (0x2e) +char 0x4 + 0x2a == 0x2e (0x2e) +__uchar 0x4 + 0x2a == 0x2e (0x2e) +__longlong 0x4 + 0x2a == 0x2e (0x2e) +__ulonglong 0x4 + 0x2a == 0x2e (0x2e) +float 0x4 + 0x2a == 0x2e (0x2e) +int 0x4 - 0x2a == -0x26 (0xffda) +__uint 0x4 - 0x2a == -0x26 (0xffda) +char 0x4 - 0x2a == -0x26 (0xffda) +__uchar 0x4 - 0x2a == 0xda (0xda) +__longlong 0x4 - 0x2a == -0x26 (0xffda) +__ulonglong 0x4 - 0x2a == -0x26 (0xffda) +float 0x4 - 0x2a == -0x26 (0xffda) +int 0x4 * 0x2a == 0xa8 (0xa8) +__uint 0x4 * 0x2a == 0xa8 (0xa8) +char 0x4 * 0x2a == -0x58 (0xffa8) +__uchar 0x4 * 0x2a == 0xa8 (0xa8) +__longlong 0x4 * 0x2a == 0xa8 (0xa8) +__ulonglong 0x4 * 0x2a == 0xa8 (0xa8) +float 0x4 * 0x2a == 0xa8 (0xa8) +int 0x4 < 0x2a == 0x1 (0x1) +__uint 0x4 < 0x2a == 0x1 (0x1) +char 0x4 < 0x2a == 0x1 (0x1) +__uchar 0x4 < 0x2a == 0x1 (0x1) +__longlong 0x4 < 0x2a == 0x1 (0x1) +__ulonglong 0x4 < 0x2a == 0x1 (0x1) +float 0x4 < 0x2a == 0x1 (0x1) +int 0x4 > 0x2a == 0x0 (0x0) +__uint 0x4 > 0x2a == 0x0 (0x0) +char 0x4 > 0x2a == 0x0 (0x0) +__uchar 0x4 > 0x2a == 0x0 (0x0) +__longlong 0x4 > 0x2a == 0x0 (0x0) +__ulonglong 0x4 > 0x2a == 0x0 (0x0) +float 0x4 > 0x2a == 0x0 (0x0) +int 0x4 <= 0x2a == 0x1 (0x1) +__uint 0x4 <= 0x2a == 0x1 (0x1) +char 0x4 <= 0x2a == 0x1 (0x1) +__uchar 0x4 <= 0x2a == 0x1 (0x1) +__longlong 0x4 <= 0x2a == 0x1 (0x1) +__ulonglong 0x4 <= 0x2a == 0x1 (0x1) +float 0x4 <= 0x2a == 0x1 (0x1) +int 0x4 == 0x2a == 0x0 (0x0) +__uint 0x4 == 0x2a == 0x0 (0x0) +char 0x4 == 0x2a == 0x0 (0x0) +__uchar 0x4 == 0x2a == 0x0 (0x0) +__longlong 0x4 == 0x2a == 0x0 (0x0) +__ulonglong 0x4 == 0x2a == 0x0 (0x0) +float 0x4 == 0x2a == 0x0 (0x0) +int 0x4 != 0x2a == 0x1 (0x1) +__uint 0x4 != 0x2a == 0x1 (0x1) +char 0x4 != 0x2a == 0x1 (0x1) +__uchar 0x4 != 0x2a == 0x1 (0x1) +__longlong 0x4 != 0x2a == 0x1 (0x1) +__ulonglong 0x4 != 0x2a == 0x1 (0x1) +float 0x4 != 0x2a == 0x1 (0x1) +int 0x4 >= 0x2a == 0x0 (0x0) +__uint 0x4 >= 0x2a == 0x0 (0x0) +char 0x4 >= 0x2a == 0x0 (0x0) +__uchar 0x4 >= 0x2a == 0x0 (0x0) +__longlong 0x4 >= 0x2a == 0x0 (0x0) +__ulonglong 0x4 >= 0x2a == 0x0 (0x0) +float 0x4 >= 0x2a == 0x0 (0x0) +int 0x4 / 0x2a == 0x0 (0x0) +__uint 0x4 / 0x2a == 0x0 (0x0) +char 0x4 / 0x2a == 0x0 (0x0) +__uchar 0x4 / 0x2a == 0x0 (0x0) +__longlong 0x4 / 0x2a == 0x0 (0x0) +__ulonglong 0x4 / 0x2a == 0x0 (0x0) +float 0x4 / 0x2a == 0x0 (0x0) +int 0x4 % 0x2a == 0x4 (0x4) +__uint 0x4 % 0x2a == 0x4 (0x4) +char 0x4 % 0x2a == 0x4 (0x4) +__uchar 0x4 % 0x2a == 0x4 (0x4) +__longlong 0x4 % 0x2a == 0x4 (0x4) +__ulonglong 0x4 % 0x2a == 0x4 (0x4) +0x4 * 0x17 == 0x5c +0x4 / 0x17 == 0x0 +0x4 % 0x17 == 0x4 +int 0x4 ^ 0x17 == 0x13 (0x13) +__uint 0x4 ^ 0x17 == 0x13 (0x13) +char 0x4 ^ 0x17 == 0x13 (0x13) +__uchar 0x4 ^ 0x17 == 0x13 (0x13) +__longlong 0x4 ^ 0x17 == 0x13 (0x13) +__ulonglong 0x4 ^ 0x17 == 0x13 (0x13) +int 0x4 && 0x17 == 0x1 (0x1) +__uint 0x4 && 0x17 == 0x1 (0x1) +char 0x4 && 0x17 == 0x1 (0x1) +__uchar 0x4 && 0x17 == 0x1 (0x1) +__longlong 0x4 && 0x17 == 0x1 (0x1) +__ulonglong 0x4 && 0x17 == 0x1 (0x1) +int 0x4 || 0x17 == 0x1 (0x1) +__uint 0x4 || 0x17 == 0x1 (0x1) +char 0x4 || 0x17 == 0x1 (0x1) +__uchar 0x4 || 0x17 == 0x1 (0x1) +__longlong 0x4 || 0x17 == 0x1 (0x1) +__ulonglong 0x4 || 0x17 == 0x1 (0x1) +int 0x4 & 0x17 == 0x4 (0x4) +__uint 0x4 & 0x17 == 0x4 (0x4) +char 0x4 & 0x17 == 0x4 (0x4) +__uchar 0x4 & 0x17 == 0x4 (0x4) +__longlong 0x4 & 0x17 == 0x4 (0x4) +__ulonglong 0x4 & 0x17 == 0x4 (0x4) +int 0x4 | 0x17 == 0x17 (0x17) +__uint 0x4 | 0x17 == 0x17 (0x17) +char 0x4 | 0x17 == 0x17 (0x17) +__uchar 0x4 | 0x17 == 0x17 (0x17) +__longlong 0x4 | 0x17 == 0x17 (0x17) +__ulonglong 0x4 | 0x17 == 0x17 (0x17) +int 0x4 << 0xe == 0x0 (0x0) +__uint 0x4 << 0xe == 0x0 (0x0) +char 0x4 << 0xe == 0x0 (0x0) +__uchar 0x4 << 0xe == 0x0 (0x0) +__longlong 0x4 << 0xe == 0x0 (0x0) +__ulonglong 0x4 << 0xe == 0x0 (0x0) +int 0x4 >> 0xe == 0x0 (0x0) +__uint 0x4 >> 0xe == 0x0 (0x0) +char 0x4 >> 0xe == 0x0 (0x0) +__uchar 0x4 >> 0xe == 0x0 (0x0) +__longlong 0x4 >> 0xe == 0x0 (0x0) +__ulonglong 0x4 >> 0xe == 0x0 (0x0) +int 0x4 + 0x17 == 0x1b (0x1b) +__uint 0x4 + 0x17 == 0x1b (0x1b) +char 0x4 + 0x17 == 0x1b (0x1b) +__uchar 0x4 + 0x17 == 0x1b (0x1b) +__longlong 0x4 + 0x17 == 0x1b (0x1b) +__ulonglong 0x4 + 0x17 == 0x1b (0x1b) +float 0x4 + 0x17 == 0x1b (0x1b) +int 0x4 - 0x17 == -0x13 (0xffed) +__uint 0x4 - 0x17 == -0x13 (0xffed) +char 0x4 - 0x17 == -0x13 (0xffed) +__uchar 0x4 - 0x17 == 0xed (0xed) +__longlong 0x4 - 0x17 == -0x13 (0xffed) +__ulonglong 0x4 - 0x17 == -0x13 (0xffed) +float 0x4 - 0x17 == -0x13 (0xffed) +int 0x4 * 0x17 == 0x5c (0x5c) +__uint 0x4 * 0x17 == 0x5c (0x5c) +char 0x4 * 0x17 == 0x5c (0x5c) +__uchar 0x4 * 0x17 == 0x5c (0x5c) +__longlong 0x4 * 0x17 == 0x5c (0x5c) +__ulonglong 0x4 * 0x17 == 0x5c (0x5c) +float 0x4 * 0x17 == 0x5c (0x5c) +int 0x4 < 0x17 == 0x1 (0x1) +__uint 0x4 < 0x17 == 0x1 (0x1) +char 0x4 < 0x17 == 0x1 (0x1) +__uchar 0x4 < 0x17 == 0x1 (0x1) +__longlong 0x4 < 0x17 == 0x1 (0x1) +__ulonglong 0x4 < 0x17 == 0x1 (0x1) +float 0x4 < 0x17 == 0x1 (0x1) +int 0x4 > 0x17 == 0x0 (0x0) +__uint 0x4 > 0x17 == 0x0 (0x0) +char 0x4 > 0x17 == 0x0 (0x0) +__uchar 0x4 > 0x17 == 0x0 (0x0) +__longlong 0x4 > 0x17 == 0x0 (0x0) +__ulonglong 0x4 > 0x17 == 0x0 (0x0) +float 0x4 > 0x17 == 0x0 (0x0) +int 0x4 <= 0x17 == 0x1 (0x1) +__uint 0x4 <= 0x17 == 0x1 (0x1) +char 0x4 <= 0x17 == 0x1 (0x1) +__uchar 0x4 <= 0x17 == 0x1 (0x1) +__longlong 0x4 <= 0x17 == 0x1 (0x1) +__ulonglong 0x4 <= 0x17 == 0x1 (0x1) +float 0x4 <= 0x17 == 0x1 (0x1) +int 0x4 == 0x17 == 0x0 (0x0) +__uint 0x4 == 0x17 == 0x0 (0x0) +char 0x4 == 0x17 == 0x0 (0x0) +__uchar 0x4 == 0x17 == 0x0 (0x0) +__longlong 0x4 == 0x17 == 0x0 (0x0) +__ulonglong 0x4 == 0x17 == 0x0 (0x0) +float 0x4 == 0x17 == 0x0 (0x0) +int 0x4 != 0x17 == 0x1 (0x1) +__uint 0x4 != 0x17 == 0x1 (0x1) +char 0x4 != 0x17 == 0x1 (0x1) +__uchar 0x4 != 0x17 == 0x1 (0x1) +__longlong 0x4 != 0x17 == 0x1 (0x1) +__ulonglong 0x4 != 0x17 == 0x1 (0x1) +float 0x4 != 0x17 == 0x1 (0x1) +int 0x4 >= 0x17 == 0x0 (0x0) +__uint 0x4 >= 0x17 == 0x0 (0x0) +char 0x4 >= 0x17 == 0x0 (0x0) +__uchar 0x4 >= 0x17 == 0x0 (0x0) +__longlong 0x4 >= 0x17 == 0x0 (0x0) +__ulonglong 0x4 >= 0x17 == 0x0 (0x0) +float 0x4 >= 0x17 == 0x0 (0x0) +int 0x4 / 0x17 == 0x0 (0x0) +__uint 0x4 / 0x17 == 0x0 (0x0) +char 0x4 / 0x17 == 0x0 (0x0) +__uchar 0x4 / 0x17 == 0x0 (0x0) +__longlong 0x4 / 0x17 == 0x0 (0x0) +__ulonglong 0x4 / 0x17 == 0x0 (0x0) +float 0x4 / 0x17 == 0x0 (0x0) +int 0x4 % 0x17 == 0x4 (0x4) +__uint 0x4 % 0x17 == 0x4 (0x4) +char 0x4 % 0x17 == 0x4 (0x4) +__uchar 0x4 % 0x17 == 0x4 (0x4) +__longlong 0x4 % 0x17 == 0x4 (0x4) +__ulonglong 0x4 % 0x17 == 0x4 (0x4) +0x4 * 0x7fff == -0x4 +0x4 / 0x7fff == 0x0 +0x4 % 0x7fff == 0x4 +int 0x4 ^ 0x7fff == 0x7ffb (0x7ffb) +__uint 0x4 ^ 0x7fff == 0x7ffb (0x7ffb) +char 0x4 ^ 0xffff == -0x5 (0xfffb) +__uchar 0x4 ^ 0xff == 0xfb (0xfb) +__longlong 0x4 ^ 0x7fff == 0x7ffb (0x7ffb) +__ulonglong 0x4 ^ 0x7fff == 0x7ffb (0x7ffb) +int 0x4 && 0x7fff == 0x1 (0x1) +__uint 0x4 && 0x7fff == 0x1 (0x1) +char 0x4 && 0xffff == 0x1 (0x1) +__uchar 0x4 && 0xff == 0x1 (0x1) +__longlong 0x4 && 0x7fff == 0x1 (0x1) +__ulonglong 0x4 && 0x7fff == 0x1 (0x1) +int 0x4 || 0x7fff == 0x1 (0x1) +__uint 0x4 || 0x7fff == 0x1 (0x1) +char 0x4 || 0xffff == 0x1 (0x1) +__uchar 0x4 || 0xff == 0x1 (0x1) +__longlong 0x4 || 0x7fff == 0x1 (0x1) +__ulonglong 0x4 || 0x7fff == 0x1 (0x1) +int 0x4 & 0x7fff == 0x4 (0x4) +__uint 0x4 & 0x7fff == 0x4 (0x4) +char 0x4 & 0xffff == 0x4 (0x4) +__uchar 0x4 & 0xff == 0x4 (0x4) +__longlong 0x4 & 0x7fff == 0x4 (0x4) +__ulonglong 0x4 & 0x7fff == 0x4 (0x4) +int 0x4 | 0x7fff == 0x7fff (0x7fff) +__uint 0x4 | 0x7fff == 0x7fff (0x7fff) +char 0x4 | 0xffff == -0x1 (0xffff) +__uchar 0x4 | 0xff == 0xff (0xff) +__longlong 0x4 | 0x7fff == 0x7fff (0x7fff) +__ulonglong 0x4 | 0x7fff == 0x7fff (0x7fff) +int 0x4 << 0x10 == 0x0 (0x0) +__uint 0x4 << 0x10 == 0x0 (0x0) +char 0x4 << 0x10 == 0x0 (0x0) +__uchar 0x4 << 0x10 == 0x0 (0x0) +__longlong 0x4 << 0x10 == 0x0 (0x0) +__ulonglong 0x4 << 0x10 == 0x0 (0x0) +int 0x4 >> 0x10 == 0x0 (0x0) +__uint 0x4 >> 0x10 == 0x0 (0x0) +char 0x4 >> 0x10 == 0x0 (0x0) +__uchar 0x4 >> 0x10 == 0x0 (0x0) +__longlong 0x4 >> 0x10 == 0x0 (0x0) +__ulonglong 0x4 >> 0x10 == 0x0 (0x0) +int 0x4 + 0x7fff == -0x7ffd (0x8003) +__uint 0x4 + 0x7fff == -0x7ffd (0x8003) +char 0x4 + 0xffff == 0x3 (0x3) +__uchar 0x4 + 0xff == 0x3 (0x3) +__longlong 0x4 + 0x7fff == -0x7ffd (0x8003) +__ulonglong 0x4 + 0x7fff == -0x7ffd (0x8003) +float 0x4 + 0x7fff == -0x8000 (0x8000) +int 0x4 - 0x7fff == -0x7ffb (0x8005) +__uint 0x4 - 0x7fff == -0x7ffb (0x8005) +char 0x4 - 0xffff == 0x5 (0x5) +__uchar 0x4 - 0xff == 0x5 (0x5) +__longlong 0x4 - 0x7fff == -0x7ffb (0x8005) +__ulonglong 0x4 - 0x7fff == -0x7ffb (0x8005) +float 0x4 - 0x7fff == -0x7ffb (0x8005) +int 0x4 * 0x7fff == -0x4 (0xfffc) +__uint 0x4 * 0x7fff == -0x4 (0xfffc) +char 0x4 * 0xffff == -0x4 (0xfffc) +__uchar 0x4 * 0xff == 0xfc (0xfc) +__longlong 0x4 * 0x7fff == -0x4 (0xfffc) +__ulonglong 0x4 * 0x7fff == -0x4 (0xfffc) +float 0x4 * 0x7fff == -0x8000 (0x8000) +int 0x4 < 0x7fff == 0x1 (0x1) +__uint 0x4 < 0x7fff == 0x1 (0x1) +char 0x4 < 0xffff == 0x0 (0x0) +__uchar 0x4 < 0xff == 0x1 (0x1) +__longlong 0x4 < 0x7fff == 0x1 (0x1) +__ulonglong 0x4 < 0x7fff == 0x1 (0x1) +float 0x4 < 0x7fff == 0x1 (0x1) +int 0x4 > 0x7fff == 0x0 (0x0) +__uint 0x4 > 0x7fff == 0x0 (0x0) +char 0x4 > 0xffff == 0x1 (0x1) +__uchar 0x4 > 0xff == 0x0 (0x0) +__longlong 0x4 > 0x7fff == 0x0 (0x0) +__ulonglong 0x4 > 0x7fff == 0x0 (0x0) +float 0x4 > 0x7fff == 0x0 (0x0) +int 0x4 <= 0x7fff == 0x1 (0x1) +__uint 0x4 <= 0x7fff == 0x1 (0x1) +char 0x4 <= 0xffff == 0x0 (0x0) +__uchar 0x4 <= 0xff == 0x1 (0x1) +__longlong 0x4 <= 0x7fff == 0x1 (0x1) +__ulonglong 0x4 <= 0x7fff == 0x1 (0x1) +float 0x4 <= 0x7fff == 0x1 (0x1) +int 0x4 == 0x7fff == 0x0 (0x0) +__uint 0x4 == 0x7fff == 0x0 (0x0) +char 0x4 == 0xffff == 0x0 (0x0) +__uchar 0x4 == 0xff == 0x0 (0x0) +__longlong 0x4 == 0x7fff == 0x0 (0x0) +__ulonglong 0x4 == 0x7fff == 0x0 (0x0) +float 0x4 == 0x7fff == 0x0 (0x0) +int 0x4 != 0x7fff == 0x1 (0x1) +__uint 0x4 != 0x7fff == 0x1 (0x1) +char 0x4 != 0xffff == 0x1 (0x1) +__uchar 0x4 != 0xff == 0x1 (0x1) +__longlong 0x4 != 0x7fff == 0x1 (0x1) +__ulonglong 0x4 != 0x7fff == 0x1 (0x1) +float 0x4 != 0x7fff == 0x1 (0x1) +int 0x4 >= 0x7fff == 0x0 (0x0) +__uint 0x4 >= 0x7fff == 0x0 (0x0) +char 0x4 >= 0xffff == 0x1 (0x1) +__uchar 0x4 >= 0xff == 0x0 (0x0) +__longlong 0x4 >= 0x7fff == 0x0 (0x0) +__ulonglong 0x4 >= 0x7fff == 0x0 (0x0) +float 0x4 >= 0x7fff == 0x0 (0x0) +int 0x4 / 0x7fff == 0x0 (0x0) +__uint 0x4 / 0x7fff == 0x0 (0x0) +char 0x4 / 0xffff == -0x4 (0xfffc) +__uchar 0x4 / 0xff == 0x0 (0x0) +__longlong 0x4 / 0x7fff == 0x0 (0x0) +__ulonglong 0x4 / 0x7fff == 0x0 (0x0) +float 0x4 / 0x7fff == 0x0 (0x0) +int 0x4 % 0x7fff == 0x4 (0x4) +__uint 0x4 % 0x7fff == 0x4 (0x4) +char 0x4 % 0xffff == 0x0 (0x0) +__uchar 0x4 % 0xff == 0x4 (0x4) +__longlong 0x4 % 0x7fff == 0x4 (0x4) +__ulonglong 0x4 % 0x7fff == 0x4 (0x4) +0x4 * 0x8000 == 0x0 +0x4 / 0x8000 == 0x0 +0x4 % 0x8000 == 0x4 +int 0x4 ^ 0x8000 == -0x7ffc (0x8004) +__uint 0x4 ^ 0x8000 == -0x7ffc (0x8004) +char 0x4 ^ 0x0 == 0x4 (0x4) +__uchar 0x4 ^ 0x0 == 0x4 (0x4) +__longlong 0x4 ^ 0x8000 == -0x7ffc (0x8004) +__ulonglong 0x4 ^ 0x8000 == -0x7ffc (0x8004) +int 0x4 && 0x8000 == 0x1 (0x1) +__uint 0x4 && 0x8000 == 0x1 (0x1) +char 0x4 && 0x0 == 0x0 (0x0) +__uchar 0x4 && 0x0 == 0x0 (0x0) +__longlong 0x4 && 0x8000 == 0x1 (0x1) +__ulonglong 0x4 && 0x8000 == 0x1 (0x1) +int 0x4 || 0x8000 == 0x1 (0x1) +__uint 0x4 || 0x8000 == 0x1 (0x1) +char 0x4 || 0x0 == 0x1 (0x1) +__uchar 0x4 || 0x0 == 0x1 (0x1) +__longlong 0x4 || 0x8000 == 0x1 (0x1) +__ulonglong 0x4 || 0x8000 == 0x1 (0x1) +int 0x4 & 0x8000 == 0x0 (0x0) +__uint 0x4 & 0x8000 == 0x0 (0x0) +char 0x4 & 0x0 == 0x0 (0x0) +__uchar 0x4 & 0x0 == 0x0 (0x0) +__longlong 0x4 & 0x8000 == 0x0 (0x0) +__ulonglong 0x4 & 0x8000 == 0x0 (0x0) +int 0x4 | 0x8000 == -0x7ffc (0x8004) +__uint 0x4 | 0x8000 == -0x7ffc (0x8004) +char 0x4 | 0x0 == 0x4 (0x4) +__uchar 0x4 | 0x0 == 0x4 (0x4) +__longlong 0x4 | 0x8000 == -0x7ffc (0x8004) +__ulonglong 0x4 | 0x8000 == -0x7ffc (0x8004) +int 0x4 << 0x12 == 0x0 (0x0) +__uint 0x4 << 0x12 == 0x0 (0x0) +char 0x4 << 0x12 == 0x0 (0x0) +__uchar 0x4 << 0x12 == 0x0 (0x0) +__longlong 0x4 << 0x12 == 0x0 (0x0) +__ulonglong 0x4 << 0x12 == 0x0 (0x0) +int 0x4 >> 0x12 == 0x0 (0x0) +__uint 0x4 >> 0x12 == 0x0 (0x0) +char 0x4 >> 0x12 == 0x0 (0x0) +__uchar 0x4 >> 0x12 == 0x0 (0x0) +__longlong 0x4 >> 0x12 == 0x0 (0x0) +__ulonglong 0x4 >> 0x12 == 0x0 (0x0) +int 0x4 + 0x8000 == -0x7ffc (0x8004) +__uint 0x4 + 0x8000 == -0x7ffc (0x8004) +char 0x4 + 0x0 == 0x4 (0x4) +__uchar 0x4 + 0x0 == 0x4 (0x4) +__longlong 0x4 + 0x8000 == -0x7ffc (0x8004) +__ulonglong 0x4 + 0x8000 == -0x7ffc (0x8004) +float 0x4 + 0x8000 == -0x7ffc (0x8004) +int 0x4 - 0x8000 == -0x7ffc (0x8004) +__uint 0x4 - 0x8000 == -0x7ffc (0x8004) +char 0x4 - 0x0 == 0x4 (0x4) +__uchar 0x4 - 0x0 == 0x4 (0x4) +__longlong 0x4 - 0x8000 == -0x7ffc (0x8004) +__ulonglong 0x4 - 0x8000 == -0x7ffc (0x8004) +float 0x4 - 0x8000 == -0x8000 (0x8000) +int 0x4 * 0x8000 == 0x0 (0x0) +__uint 0x4 * 0x8000 == 0x0 (0x0) +char 0x4 * 0x0 == 0x0 (0x0) +__uchar 0x4 * 0x0 == 0x0 (0x0) +__longlong 0x4 * 0x8000 == 0x0 (0x0) +__ulonglong 0x4 * 0x8000 == 0x0 (0x0) +float 0x4 * 0x8000 == -0x8000 (0x8000) +int 0x4 < 0x8000 == 0x0 (0x0) +__uint 0x4 < 0x8000 == 0x1 (0x1) +char 0x4 < 0x0 == 0x0 (0x0) +__uchar 0x4 < 0x0 == 0x0 (0x0) +__longlong 0x4 < 0x8000 == 0x0 (0x0) +__ulonglong 0x4 < 0x8000 == 0x1 (0x1) +float 0x4 < 0x8000 == 0x0 (0x0) +int 0x4 > 0x8000 == 0x1 (0x1) +__uint 0x4 > 0x8000 == 0x0 (0x0) +char 0x4 > 0x0 == 0x1 (0x1) +__uchar 0x4 > 0x0 == 0x1 (0x1) +__longlong 0x4 > 0x8000 == 0x1 (0x1) +__ulonglong 0x4 > 0x8000 == 0x0 (0x0) +float 0x4 > 0x8000 == 0x1 (0x1) +int 0x4 <= 0x8000 == 0x0 (0x0) +__uint 0x4 <= 0x8000 == 0x1 (0x1) +char 0x4 <= 0x0 == 0x0 (0x0) +__uchar 0x4 <= 0x0 == 0x0 (0x0) +__longlong 0x4 <= 0x8000 == 0x0 (0x0) +__ulonglong 0x4 <= 0x8000 == 0x1 (0x1) +float 0x4 <= 0x8000 == 0x0 (0x0) +int 0x4 == 0x8000 == 0x0 (0x0) +__uint 0x4 == 0x8000 == 0x0 (0x0) +char 0x4 == 0x0 == 0x0 (0x0) +__uchar 0x4 == 0x0 == 0x0 (0x0) +__longlong 0x4 == 0x8000 == 0x0 (0x0) +__ulonglong 0x4 == 0x8000 == 0x0 (0x0) +float 0x4 == 0x8000 == 0x0 (0x0) +int 0x4 != 0x8000 == 0x1 (0x1) +__uint 0x4 != 0x8000 == 0x1 (0x1) +char 0x4 != 0x0 == 0x1 (0x1) +__uchar 0x4 != 0x0 == 0x1 (0x1) +__longlong 0x4 != 0x8000 == 0x1 (0x1) +__ulonglong 0x4 != 0x8000 == 0x1 (0x1) +float 0x4 != 0x8000 == 0x1 (0x1) +int 0x4 >= 0x8000 == 0x1 (0x1) +__uint 0x4 >= 0x8000 == 0x0 (0x0) +char 0x4 >= 0x0 == 0x1 (0x1) +__uchar 0x4 >= 0x0 == 0x1 (0x1) +__longlong 0x4 >= 0x8000 == 0x1 (0x1) +__ulonglong 0x4 >= 0x8000 == 0x0 (0x0) +float 0x4 >= 0x8000 == 0x1 (0x1) +int 0x4 / 0x8000 == 0x0 (0x0) +__uint 0x4 / 0x8000 == 0x0 (0x0) +__longlong 0x4 / 0x8000 == 0x0 (0x0) +__ulonglong 0x4 / 0x8000 == 0x0 (0x0) +float 0x4 / 0x8000 == 0x0 (0x0) +int 0x4 % 0x8000 == 0x4 (0x4) +__uint 0x4 % 0x8000 == 0x4 (0x4) +__longlong 0x4 % 0x8000 == 0x4 (0x4) +__ulonglong 0x4 % 0x8000 == 0x4 (0x4) +0x4 * 0x3e8 == 0xfa0 +0x4 / 0x3e8 == 0x0 +0x4 % 0x3e8 == 0x4 +int 0x4 ^ 0x3e8 == 0x3ec (0x3ec) +__uint 0x4 ^ 0x3e8 == 0x3ec (0x3ec) +char 0x4 ^ 0xffe8 == -0x14 (0xffec) +__uchar 0x4 ^ 0xe8 == 0xec (0xec) +__longlong 0x4 ^ 0x3e8 == 0x3ec (0x3ec) +__ulonglong 0x4 ^ 0x3e8 == 0x3ec (0x3ec) +int 0x4 && 0x3e8 == 0x1 (0x1) +__uint 0x4 && 0x3e8 == 0x1 (0x1) +char 0x4 && 0xffe8 == 0x1 (0x1) +__uchar 0x4 && 0xe8 == 0x1 (0x1) +__longlong 0x4 && 0x3e8 == 0x1 (0x1) +__ulonglong 0x4 && 0x3e8 == 0x1 (0x1) +int 0x4 || 0x3e8 == 0x1 (0x1) +__uint 0x4 || 0x3e8 == 0x1 (0x1) +char 0x4 || 0xffe8 == 0x1 (0x1) +__uchar 0x4 || 0xe8 == 0x1 (0x1) +__longlong 0x4 || 0x3e8 == 0x1 (0x1) +__ulonglong 0x4 || 0x3e8 == 0x1 (0x1) +int 0x4 & 0x3e8 == 0x0 (0x0) +__uint 0x4 & 0x3e8 == 0x0 (0x0) +char 0x4 & 0xffe8 == 0x0 (0x0) +__uchar 0x4 & 0xe8 == 0x0 (0x0) +__longlong 0x4 & 0x3e8 == 0x0 (0x0) +__ulonglong 0x4 & 0x3e8 == 0x0 (0x0) +int 0x4 | 0x3e8 == 0x3ec (0x3ec) +__uint 0x4 | 0x3e8 == 0x3ec (0x3ec) +char 0x4 | 0xffe8 == -0x14 (0xffec) +__uchar 0x4 | 0xe8 == 0xec (0xec) +__longlong 0x4 | 0x3e8 == 0x3ec (0x3ec) +__ulonglong 0x4 | 0x3e8 == 0x3ec (0x3ec) +int 0x4 << 0x14 == 0x0 (0x0) +__uint 0x4 << 0x14 == 0x0 (0x0) +char 0x4 << 0x14 == 0x0 (0x0) +__uchar 0x4 << 0x14 == 0x0 (0x0) +__longlong 0x4 << 0x14 == 0x0 (0x0) +__ulonglong 0x4 << 0x14 == 0x0 (0x0) +int 0x4 >> 0x14 == 0x0 (0x0) +__uint 0x4 >> 0x14 == 0x0 (0x0) +char 0x4 >> 0x14 == 0x0 (0x0) +__uchar 0x4 >> 0x14 == 0x0 (0x0) +__longlong 0x4 >> 0x14 == 0x0 (0x0) +__ulonglong 0x4 >> 0x14 == 0x0 (0x0) +int 0x4 + 0x3e8 == 0x3ec (0x3ec) +__uint 0x4 + 0x3e8 == 0x3ec (0x3ec) +char 0x4 + 0xffe8 == -0x14 (0xffec) +__uchar 0x4 + 0xe8 == 0xec (0xec) +__longlong 0x4 + 0x3e8 == 0x3ec (0x3ec) +__ulonglong 0x4 + 0x3e8 == 0x3ec (0x3ec) +float 0x4 + 0x3e8 == 0x3ec (0x3ec) +int 0x4 - 0x3e8 == -0x3e4 (0xfc1c) +__uint 0x4 - 0x3e8 == -0x3e4 (0xfc1c) +char 0x4 - 0xffe8 == 0x1c (0x1c) +__uchar 0x4 - 0xe8 == 0x1c (0x1c) +__longlong 0x4 - 0x3e8 == -0x3e4 (0xfc1c) +__ulonglong 0x4 - 0x3e8 == -0x3e4 (0xfc1c) +float 0x4 - 0x3e8 == -0x3e4 (0xfc1c) +int 0x4 * 0x3e8 == 0xfa0 (0xfa0) +__uint 0x4 * 0x3e8 == 0xfa0 (0xfa0) +char 0x4 * 0xffe8 == -0x60 (0xffa0) +__uchar 0x4 * 0xe8 == 0xa0 (0xa0) +__longlong 0x4 * 0x3e8 == 0xfa0 (0xfa0) +__ulonglong 0x4 * 0x3e8 == 0xfa0 (0xfa0) +float 0x4 * 0x3e8 == 0xfa0 (0xfa0) +int 0x4 < 0x3e8 == 0x1 (0x1) +__uint 0x4 < 0x3e8 == 0x1 (0x1) +char 0x4 < 0xffe8 == 0x0 (0x0) +__uchar 0x4 < 0xe8 == 0x1 (0x1) +__longlong 0x4 < 0x3e8 == 0x1 (0x1) +__ulonglong 0x4 < 0x3e8 == 0x1 (0x1) +float 0x4 < 0x3e8 == 0x1 (0x1) +int 0x4 > 0x3e8 == 0x0 (0x0) +__uint 0x4 > 0x3e8 == 0x0 (0x0) +char 0x4 > 0xffe8 == 0x1 (0x1) +__uchar 0x4 > 0xe8 == 0x0 (0x0) +__longlong 0x4 > 0x3e8 == 0x0 (0x0) +__ulonglong 0x4 > 0x3e8 == 0x0 (0x0) +float 0x4 > 0x3e8 == 0x0 (0x0) +int 0x4 <= 0x3e8 == 0x1 (0x1) +__uint 0x4 <= 0x3e8 == 0x1 (0x1) +char 0x4 <= 0xffe8 == 0x0 (0x0) +__uchar 0x4 <= 0xe8 == 0x1 (0x1) +__longlong 0x4 <= 0x3e8 == 0x1 (0x1) +__ulonglong 0x4 <= 0x3e8 == 0x1 (0x1) +float 0x4 <= 0x3e8 == 0x1 (0x1) +int 0x4 == 0x3e8 == 0x0 (0x0) +__uint 0x4 == 0x3e8 == 0x0 (0x0) +char 0x4 == 0xffe8 == 0x0 (0x0) +__uchar 0x4 == 0xe8 == 0x0 (0x0) +__longlong 0x4 == 0x3e8 == 0x0 (0x0) +__ulonglong 0x4 == 0x3e8 == 0x0 (0x0) +float 0x4 == 0x3e8 == 0x0 (0x0) +int 0x4 != 0x3e8 == 0x1 (0x1) +__uint 0x4 != 0x3e8 == 0x1 (0x1) +char 0x4 != 0xffe8 == 0x1 (0x1) +__uchar 0x4 != 0xe8 == 0x1 (0x1) +__longlong 0x4 != 0x3e8 == 0x1 (0x1) +__ulonglong 0x4 != 0x3e8 == 0x1 (0x1) +float 0x4 != 0x3e8 == 0x1 (0x1) +int 0x4 >= 0x3e8 == 0x0 (0x0) +__uint 0x4 >= 0x3e8 == 0x0 (0x0) +char 0x4 >= 0xffe8 == 0x1 (0x1) +__uchar 0x4 >= 0xe8 == 0x0 (0x0) +__longlong 0x4 >= 0x3e8 == 0x0 (0x0) +__ulonglong 0x4 >= 0x3e8 == 0x0 (0x0) +float 0x4 >= 0x3e8 == 0x0 (0x0) +int 0x4 / 0x3e8 == 0x0 (0x0) +__uint 0x4 / 0x3e8 == 0x0 (0x0) +char 0x4 / 0xffe8 == 0x0 (0x0) +__uchar 0x4 / 0xe8 == 0x0 (0x0) +__longlong 0x4 / 0x3e8 == 0x0 (0x0) +__ulonglong 0x4 / 0x3e8 == 0x0 (0x0) +float 0x4 / 0x3e8 == 0x0 (0x0) +int 0x4 % 0x3e8 == 0x4 (0x4) +__uint 0x4 % 0x3e8 == 0x4 (0x4) +char 0x4 % 0xffe8 == 0x4 (0x4) +__uchar 0x4 % 0xe8 == 0x4 (0x4) +__longlong 0x4 % 0x3e8 == 0x4 (0x4) +__ulonglong 0x4 % 0x3e8 == 0x4 (0x4) +0x4 * 0x2710 == -0x63c0 +0x4 / 0x2710 == 0x0 +0x4 % 0x2710 == 0x4 +int 0x4 ^ 0x2710 == 0x2714 (0x2714) +__uint 0x4 ^ 0x2710 == 0x2714 (0x2714) +char 0x4 ^ 0x10 == 0x14 (0x14) +__uchar 0x4 ^ 0x10 == 0x14 (0x14) +__longlong 0x4 ^ 0x2710 == 0x2714 (0x2714) +__ulonglong 0x4 ^ 0x2710 == 0x2714 (0x2714) +int 0x4 && 0x2710 == 0x1 (0x1) +__uint 0x4 && 0x2710 == 0x1 (0x1) +char 0x4 && 0x10 == 0x1 (0x1) +__uchar 0x4 && 0x10 == 0x1 (0x1) +__longlong 0x4 && 0x2710 == 0x1 (0x1) +__ulonglong 0x4 && 0x2710 == 0x1 (0x1) +int 0x4 || 0x2710 == 0x1 (0x1) +__uint 0x4 || 0x2710 == 0x1 (0x1) +char 0x4 || 0x10 == 0x1 (0x1) +__uchar 0x4 || 0x10 == 0x1 (0x1) +__longlong 0x4 || 0x2710 == 0x1 (0x1) +__ulonglong 0x4 || 0x2710 == 0x1 (0x1) +int 0x4 & 0x2710 == 0x0 (0x0) +__uint 0x4 & 0x2710 == 0x0 (0x0) +char 0x4 & 0x10 == 0x0 (0x0) +__uchar 0x4 & 0x10 == 0x0 (0x0) +__longlong 0x4 & 0x2710 == 0x0 (0x0) +__ulonglong 0x4 & 0x2710 == 0x0 (0x0) +int 0x4 | 0x2710 == 0x2714 (0x2714) +__uint 0x4 | 0x2710 == 0x2714 (0x2714) +char 0x4 | 0x10 == 0x14 (0x14) +__uchar 0x4 | 0x10 == 0x14 (0x14) +__longlong 0x4 | 0x2710 == 0x2714 (0x2714) +__ulonglong 0x4 | 0x2710 == 0x2714 (0x2714) +int 0x4 << 0x16 == 0x0 (0x0) +__uint 0x4 << 0x16 == 0x0 (0x0) +char 0x4 << 0x16 == 0x0 (0x0) +__uchar 0x4 << 0x16 == 0x0 (0x0) +__longlong 0x4 << 0x16 == 0x0 (0x0) +__ulonglong 0x4 << 0x16 == 0x0 (0x0) +int 0x4 >> 0x16 == 0x0 (0x0) +__uint 0x4 >> 0x16 == 0x0 (0x0) +char 0x4 >> 0x16 == 0x0 (0x0) +__uchar 0x4 >> 0x16 == 0x0 (0x0) +__longlong 0x4 >> 0x16 == 0x0 (0x0) +__ulonglong 0x4 >> 0x16 == 0x0 (0x0) +int 0x4 + 0x2710 == 0x2714 (0x2714) +__uint 0x4 + 0x2710 == 0x2714 (0x2714) +char 0x4 + 0x10 == 0x14 (0x14) +__uchar 0x4 + 0x10 == 0x14 (0x14) +__longlong 0x4 + 0x2710 == 0x2714 (0x2714) +__ulonglong 0x4 + 0x2710 == 0x2714 (0x2714) +float 0x4 + 0x2710 == 0x2714 (0x2714) +int 0x4 - 0x2710 == -0x270c (0xd8f4) +__uint 0x4 - 0x2710 == -0x270c (0xd8f4) +char 0x4 - 0x10 == -0xc (0xfff4) +__uchar 0x4 - 0x10 == 0xf4 (0xf4) +__longlong 0x4 - 0x2710 == -0x270c (0xd8f4) +__ulonglong 0x4 - 0x2710 == -0x270c (0xd8f4) +float 0x4 - 0x2710 == -0x270c (0xd8f4) +int 0x4 * 0x2710 == -0x63c0 (0x9c40) +__uint 0x4 * 0x2710 == -0x63c0 (0x9c40) +char 0x4 * 0x10 == 0x40 (0x40) +__uchar 0x4 * 0x10 == 0x40 (0x40) +__longlong 0x4 * 0x2710 == -0x63c0 (0x9c40) +__ulonglong 0x4 * 0x2710 == -0x63c0 (0x9c40) +float 0x4 * 0x2710 == -0x8000 (0x8000) +int 0x4 < 0x2710 == 0x1 (0x1) +__uint 0x4 < 0x2710 == 0x1 (0x1) +char 0x4 < 0x10 == 0x1 (0x1) +__uchar 0x4 < 0x10 == 0x1 (0x1) +__longlong 0x4 < 0x2710 == 0x1 (0x1) +__ulonglong 0x4 < 0x2710 == 0x1 (0x1) +float 0x4 < 0x2710 == 0x1 (0x1) +int 0x4 > 0x2710 == 0x0 (0x0) +__uint 0x4 > 0x2710 == 0x0 (0x0) +char 0x4 > 0x10 == 0x0 (0x0) +__uchar 0x4 > 0x10 == 0x0 (0x0) +__longlong 0x4 > 0x2710 == 0x0 (0x0) +__ulonglong 0x4 > 0x2710 == 0x0 (0x0) +float 0x4 > 0x2710 == 0x0 (0x0) +int 0x4 <= 0x2710 == 0x1 (0x1) +__uint 0x4 <= 0x2710 == 0x1 (0x1) +char 0x4 <= 0x10 == 0x1 (0x1) +__uchar 0x4 <= 0x10 == 0x1 (0x1) +__longlong 0x4 <= 0x2710 == 0x1 (0x1) +__ulonglong 0x4 <= 0x2710 == 0x1 (0x1) +float 0x4 <= 0x2710 == 0x1 (0x1) +int 0x4 == 0x2710 == 0x0 (0x0) +__uint 0x4 == 0x2710 == 0x0 (0x0) +char 0x4 == 0x10 == 0x0 (0x0) +__uchar 0x4 == 0x10 == 0x0 (0x0) +__longlong 0x4 == 0x2710 == 0x0 (0x0) +__ulonglong 0x4 == 0x2710 == 0x0 (0x0) +float 0x4 == 0x2710 == 0x0 (0x0) +int 0x4 != 0x2710 == 0x1 (0x1) +__uint 0x4 != 0x2710 == 0x1 (0x1) +char 0x4 != 0x10 == 0x1 (0x1) +__uchar 0x4 != 0x10 == 0x1 (0x1) +__longlong 0x4 != 0x2710 == 0x1 (0x1) +__ulonglong 0x4 != 0x2710 == 0x1 (0x1) +float 0x4 != 0x2710 == 0x1 (0x1) +int 0x4 >= 0x2710 == 0x0 (0x0) +__uint 0x4 >= 0x2710 == 0x0 (0x0) +char 0x4 >= 0x10 == 0x0 (0x0) +__uchar 0x4 >= 0x10 == 0x0 (0x0) +__longlong 0x4 >= 0x2710 == 0x0 (0x0) +__ulonglong 0x4 >= 0x2710 == 0x0 (0x0) +float 0x4 >= 0x2710 == 0x0 (0x0) +int 0x4 / 0x2710 == 0x0 (0x0) +__uint 0x4 / 0x2710 == 0x0 (0x0) +char 0x4 / 0x10 == 0x0 (0x0) +__uchar 0x4 / 0x10 == 0x0 (0x0) +__longlong 0x4 / 0x2710 == 0x0 (0x0) +__ulonglong 0x4 / 0x2710 == 0x0 (0x0) +float 0x4 / 0x2710 == 0x0 (0x0) +int 0x4 % 0x2710 == 0x4 (0x4) +__uint 0x4 % 0x2710 == 0x4 (0x4) +char 0x4 % 0x10 == 0x4 (0x4) +__uchar 0x4 % 0x10 == 0x4 (0x4) +__longlong 0x4 % 0x2710 == 0x4 (0x4) +__ulonglong 0x4 % 0x2710 == 0x4 (0x4) +int xor420x4 xor42 0x2e +__uint xor420x4 xor42 0x2e +char xor420x4 xor42 0x2e +__uchar xor420x4 xor42 0x2e +__longlong xor420x4 xor42 0x2e +__ulonglong xor420x4 xor42 0x2e +int land10x4 land1 0x1 +__uint land10x4 land1 0x1 +char land10x4 land1 0x1 +__uchar land10x4 land1 0x1 +__longlong land10x4 land1 0x1 +__ulonglong land10x4 land1 0x1 +int lor10x4 lor1 0x1 +__uint lor10x4 lor1 0x1 +char lor10x4 lor1 0x1 +__uchar lor10x4 lor1 0x1 +__longlong lor10x4 lor1 0x1 +__ulonglong lor10x4 lor1 0x1 +int and420x4 and42 0x0 +__uint and420x4 and42 0x0 +char and420x4 and42 0x0 +__uchar and420x4 and42 0x0 +__longlong and420x4 and42 0x0 +__ulonglong and420x4 and42 0x0 +int or420x4 or42 0x2e +__uint or420x4 or42 0x2e +char or420x4 or42 0x2e +__uchar or420x4 or42 0x2e +__longlong or420x4 or42 0x2e +__ulonglong or420x4 or42 0x2e +int shl50x4 shl5 0x80 +__uint shl50x4 shl5 0x80 +char shl50x4 shl5 -0x80 +__uchar shl50x4 shl5 0x80 +__longlong shl50x4 shl5 0x80 +__ulonglong shl50x4 shl5 0x80 +int shr50x4 shr5 0x0 +__uint shr50x4 shr5 0x0 +char shr50x4 shr5 0x0 +__uchar shr50x4 shr5 0x0 +__longlong shr50x4 shr5 0x0 +__ulonglong shr50x4 shr5 0x0 +int add420x4 add42 0x2e +__uint add420x4 add42 0x2e +char add420x4 add42 0x2e +__uchar add420x4 add42 0x2e +__longlong add420x4 add42 0x2e +__ulonglong add420x4 add42 0x2e +float add420x4 add42 0x2e +int sub420x4 sub42 -0x26 +__uint sub420x4 sub42 -0x26 +char sub420x4 sub42 -0x26 +__uchar sub420x4 sub42 0xda +__longlong sub420x4 sub42 -0x26 +__ulonglong sub420x4 sub42 -0x26 +float sub420x4 sub42 -0x26 +int mul420x4 mul42 0xa8 +__uint mul420x4 mul42 0xa8 +char mul420x4 mul42 -0x58 +__uchar mul420x4 mul42 0xa8 +__longlong mul420x4 mul42 0xa8 +__ulonglong mul420x4 mul42 0xa8 +float mul420x4 mul42 0xa8 +int lt420x4 lt42 0x1 +__uint lt420x4 lt42 0x1 +char lt420x4 lt42 0x1 +__uchar lt420x4 lt42 0x1 +__longlong lt420x4 lt42 0x1 +__ulonglong lt420x4 lt42 0x1 +float lt420x4 lt42 0x1 +int gt420x4 gt42 0x0 +__uint gt420x4 gt42 0x0 +char gt420x4 gt42 0x0 +__uchar gt420x4 gt42 0x0 +__longlong gt420x4 gt42 0x0 +__ulonglong gt420x4 gt42 0x0 +float gt420x4 gt42 0x0 +int le420x4 le42 0x1 +__uint le420x4 le42 0x1 +char le420x4 le42 0x1 +__uchar le420x4 le42 0x1 +__longlong le420x4 le42 0x1 +__ulonglong le420x4 le42 0x1 +float le420x4 le42 0x1 +int eq420x4 eq42 0x0 +__uint eq420x4 eq42 0x0 +char eq420x4 eq42 0x0 +__uchar eq420x4 eq42 0x0 +__longlong eq420x4 eq42 0x0 +__ulonglong eq420x4 eq42 0x0 +float eq420x4 eq42 0x0 +int ne420x4 ne42 0x1 +__uint ne420x4 ne42 0x1 +char ne420x4 ne42 0x1 +__uchar ne420x4 ne42 0x1 +__longlong ne420x4 ne42 0x1 +__ulonglong ne420x4 ne42 0x1 +float ne420x4 ne42 0x1 +int ge420x4 ge42 0x0 +__uint ge420x4 ge42 0x0 +char ge420x4 ge42 0x0 +__uchar ge420x4 ge42 0x0 +__longlong ge420x4 ge42 0x0 +__ulonglong ge420x4 ge42 0x0 +float ge420x4 ge42 0x0 +int div420x4 div42 0x0 +__uint div420x4 div42 0x0 +char div420x4 div42 0x0 +__uchar div420x4 div42 0x0 +__longlong div420x4 div42 0x0 +__ulonglong div420x4 div42 0x0 +float div420x4 div42 0x0 +int mod230x4 mod23 0x4 +__uint mod230x4 mod23 0x4 +char mod230x4 mod23 0x4 +__uchar mod230x4 mod23 0x4 +__longlong mod230x4 mod23 0x4 +__ulonglong mod230x4 mod23 0x4 +0xfffc * 0xffff == 0x4 +0xfffc / 0xffff == 0x4 +0xfffc % 0xffff == 0x0 +int 0xfffc ^ 0xffff == 0x3 (0x3) +__uint 0xfffc ^ 0xffff == 0x3 (0x3) +char 0xfffc ^ 0xffff == 0x3 (0x3) +__uchar 0xfc ^ 0xff == 0x3 (0x3) +__longlong 0xfffc ^ 0xffff == 0x3 (0x3) +__ulonglong 0xfffc ^ 0xffff == 0x3 (0x3) +int 0xfffc && 0xffff == 0x1 (0x1) +__uint 0xfffc && 0xffff == 0x1 (0x1) +char 0xfffc && 0xffff == 0x1 (0x1) +__uchar 0xfc && 0xff == 0x1 (0x1) +__longlong 0xfffc && 0xffff == 0x1 (0x1) +__ulonglong 0xfffc && 0xffff == 0x1 (0x1) +int 0xfffc || 0xffff == 0x1 (0x1) +__uint 0xfffc || 0xffff == 0x1 (0x1) +char 0xfffc || 0xffff == 0x1 (0x1) +__uchar 0xfc || 0xff == 0x1 (0x1) +__longlong 0xfffc || 0xffff == 0x1 (0x1) +__ulonglong 0xfffc || 0xffff == 0x1 (0x1) +int 0xfffc & 0xffff == -0x4 (0xfffc) +__uint 0xfffc & 0xffff == -0x4 (0xfffc) +char 0xfffc & 0xffff == -0x4 (0xfffc) +__uchar 0xfc & 0xff == 0xfc (0xfc) +__longlong 0xfffc & 0xffff == -0x4 (0xfffc) +__ulonglong 0xfffc & 0xffff == -0x4 (0xfffc) +int 0xfffc | 0xffff == -0x1 (0xffff) +__uint 0xfffc | 0xffff == -0x1 (0xffff) +char 0xfffc | 0xffff == -0x1 (0xffff) +__uchar 0xfc | 0xff == 0xff (0xff) +__longlong 0xfffc | 0xffff == -0x1 (0xffff) +__ulonglong 0xfffc | 0xffff == -0x1 (0xffff) +int 0xfffc << 0x1 == -0x8 (0xfff8) +__uint 0xfffc << 0x1 == -0x8 (0xfff8) +char 0xfffc << 0x1 == -0x8 (0xfff8) +__uchar 0xfc << 0x1 == 0xf8 (0xf8) +__longlong 0xfffc << 0x1 == -0x8 (0xfff8) +__ulonglong 0xfffc << 0x1 == -0x8 (0xfff8) +int 0xfffc >> 0x1 == -0x2 (0xfffe) +__uint 0xfffc >> 0x1 == 0x7ffe (0x7ffe) +char 0xfffc >> 0x1 == -0x2 (0xfffe) +__uchar 0xfc >> 0x1 == 0x7e (0x7e) +__longlong 0xfffc >> 0x1 == -0x2 (0xfffe) +__ulonglong 0xfffc >> 0x1 == -0x2 (0xfffe) +int 0xfffc + 0xffff == -0x5 (0xfffb) +__uint 0xfffc + 0xffff == -0x5 (0xfffb) +char 0xfffc + 0xffff == -0x5 (0xfffb) +__uchar 0xfc + 0xff == 0xfb (0xfb) +__longlong 0xfffc + 0xffff == -0x5 (0xfffb) +__ulonglong 0xfffc + 0xffff == -0x5 (0xfffb) +float 0xfffc + 0xffff == -0x5 (0xfffb) +int 0xfffc - 0xffff == -0x3 (0xfffd) +__uint 0xfffc - 0xffff == -0x3 (0xfffd) +char 0xfffc - 0xffff == -0x3 (0xfffd) +__uchar 0xfc - 0xff == 0xfd (0xfd) +__longlong 0xfffc - 0xffff == -0x3 (0xfffd) +__ulonglong 0xfffc - 0xffff == -0x3 (0xfffd) +float 0xfffc - 0xffff == -0x3 (0xfffd) +int 0xfffc * 0xffff == 0x4 (0x4) +__uint 0xfffc * 0xffff == 0x4 (0x4) +char 0xfffc * 0xffff == 0x4 (0x4) +__uchar 0xfc * 0xff == 0x4 (0x4) +__longlong 0xfffc * 0xffff == 0x4 (0x4) +__ulonglong 0xfffc * 0xffff == 0x4 (0x4) +float 0xfffc * 0xffff == 0x4 (0x4) +int 0xfffc < 0xffff == 0x1 (0x1) +__uint 0xfffc < 0xffff == 0x1 (0x1) +char 0xfffc < 0xffff == 0x1 (0x1) +__uchar 0xfc < 0xff == 0x1 (0x1) +__longlong 0xfffc < 0xffff == 0x1 (0x1) +__ulonglong 0xfffc < 0xffff == 0x1 (0x1) +float 0xfffc < 0xffff == 0x1 (0x1) +int 0xfffc > 0xffff == 0x0 (0x0) +__uint 0xfffc > 0xffff == 0x0 (0x0) +char 0xfffc > 0xffff == 0x0 (0x0) +__uchar 0xfc > 0xff == 0x0 (0x0) +__longlong 0xfffc > 0xffff == 0x0 (0x0) +__ulonglong 0xfffc > 0xffff == 0x0 (0x0) +float 0xfffc > 0xffff == 0x0 (0x0) +int 0xfffc <= 0xffff == 0x1 (0x1) +__uint 0xfffc <= 0xffff == 0x1 (0x1) +char 0xfffc <= 0xffff == 0x1 (0x1) +__uchar 0xfc <= 0xff == 0x1 (0x1) +__longlong 0xfffc <= 0xffff == 0x1 (0x1) +__ulonglong 0xfffc <= 0xffff == 0x1 (0x1) +float 0xfffc <= 0xffff == 0x1 (0x1) +int 0xfffc == 0xffff == 0x0 (0x0) +__uint 0xfffc == 0xffff == 0x0 (0x0) +char 0xfffc == 0xffff == 0x0 (0x0) +__uchar 0xfc == 0xff == 0x0 (0x0) +__longlong 0xfffc == 0xffff == 0x0 (0x0) +__ulonglong 0xfffc == 0xffff == 0x0 (0x0) +float 0xfffc == 0xffff == 0x0 (0x0) +int 0xfffc != 0xffff == 0x1 (0x1) +__uint 0xfffc != 0xffff == 0x1 (0x1) +char 0xfffc != 0xffff == 0x1 (0x1) +__uchar 0xfc != 0xff == 0x1 (0x1) +__longlong 0xfffc != 0xffff == 0x1 (0x1) +__ulonglong 0xfffc != 0xffff == 0x1 (0x1) +float 0xfffc != 0xffff == 0x1 (0x1) +int 0xfffc >= 0xffff == 0x0 (0x0) +__uint 0xfffc >= 0xffff == 0x0 (0x0) +char 0xfffc >= 0xffff == 0x0 (0x0) +__uchar 0xfc >= 0xff == 0x0 (0x0) +__longlong 0xfffc >= 0xffff == 0x0 (0x0) +__ulonglong 0xfffc >= 0xffff == 0x0 (0x0) +float 0xfffc >= 0xffff == 0x0 (0x0) +int 0xfffc / 0xffff == 0x4 (0x4) +__uint 0xfffc / 0xffff == 0x0 (0x0) +char 0xfffc / 0xffff == 0x4 (0x4) +__uchar 0xfc / 0xff == 0x0 (0x0) +__longlong 0xfffc / 0xffff == 0x4 (0x4) +__ulonglong 0xfffc / 0xffff == 0x0 (0x0) +float 0xfffc / 0xffff == 0x4 (0x4) +int 0xfffc % 0xffff == 0x0 (0x0) +__uint 0xfffc % 0xffff == -0x4 (0xfffc) +char 0xfffc % 0xffff == 0x0 (0x0) +__uchar 0xfc % 0xff == 0xfc (0xfc) +__longlong 0xfffc % 0xffff == 0x0 (0x0) +__ulonglong 0xfffc % 0xffff == -0x4 (0xfffc) +0xfffc * 0x1 == -0x4 +0xfffc / 0x1 == -0x4 +0xfffc % 0x1 == 0x0 +int 0xfffc ^ 0x1 == -0x3 (0xfffd) +__uint 0xfffc ^ 0x1 == -0x3 (0xfffd) +char 0xfffc ^ 0x1 == -0x3 (0xfffd) +__uchar 0xfc ^ 0x1 == 0xfd (0xfd) +__longlong 0xfffc ^ 0x1 == -0x3 (0xfffd) +__ulonglong 0xfffc ^ 0x1 == -0x3 (0xfffd) +int 0xfffc && 0x1 == 0x1 (0x1) +__uint 0xfffc && 0x1 == 0x1 (0x1) +char 0xfffc && 0x1 == 0x1 (0x1) +__uchar 0xfc && 0x1 == 0x1 (0x1) +__longlong 0xfffc && 0x1 == 0x1 (0x1) +__ulonglong 0xfffc && 0x1 == 0x1 (0x1) +int 0xfffc || 0x1 == 0x1 (0x1) +__uint 0xfffc || 0x1 == 0x1 (0x1) +char 0xfffc || 0x1 == 0x1 (0x1) +__uchar 0xfc || 0x1 == 0x1 (0x1) +__longlong 0xfffc || 0x1 == 0x1 (0x1) +__ulonglong 0xfffc || 0x1 == 0x1 (0x1) +int 0xfffc & 0x1 == 0x0 (0x0) +__uint 0xfffc & 0x1 == 0x0 (0x0) +char 0xfffc & 0x1 == 0x0 (0x0) +__uchar 0xfc & 0x1 == 0x0 (0x0) +__longlong 0xfffc & 0x1 == 0x0 (0x0) +__ulonglong 0xfffc & 0x1 == 0x0 (0x0) +int 0xfffc | 0x1 == -0x3 (0xfffd) +__uint 0xfffc | 0x1 == -0x3 (0xfffd) +char 0xfffc | 0x1 == -0x3 (0xfffd) +__uchar 0xfc | 0x1 == 0xfd (0xfd) +__longlong 0xfffc | 0x1 == -0x3 (0xfffd) +__ulonglong 0xfffc | 0x1 == -0x3 (0xfffd) +int 0xfffc << 0x2 == -0x10 (0xfff0) +__uint 0xfffc << 0x2 == -0x10 (0xfff0) +char 0xfffc << 0x2 == -0x10 (0xfff0) +__uchar 0xfc << 0x2 == 0xf0 (0xf0) +__longlong 0xfffc << 0x2 == -0x10 (0xfff0) +__ulonglong 0xfffc << 0x2 == -0x10 (0xfff0) +int 0xfffc >> 0x2 == -0x1 (0xffff) +__uint 0xfffc >> 0x2 == 0x3fff (0x3fff) +char 0xfffc >> 0x2 == -0x1 (0xffff) +__uchar 0xfc >> 0x2 == 0x3f (0x3f) +__longlong 0xfffc >> 0x2 == -0x1 (0xffff) +__ulonglong 0xfffc >> 0x2 == -0x1 (0xffff) +int 0xfffc + 0x1 == -0x3 (0xfffd) +__uint 0xfffc + 0x1 == -0x3 (0xfffd) +char 0xfffc + 0x1 == -0x3 (0xfffd) +__uchar 0xfc + 0x1 == 0xfd (0xfd) +__longlong 0xfffc + 0x1 == -0x3 (0xfffd) +__ulonglong 0xfffc + 0x1 == -0x3 (0xfffd) +float 0xfffc + 0x1 == -0x3 (0xfffd) +int 0xfffc - 0x1 == -0x5 (0xfffb) +__uint 0xfffc - 0x1 == -0x5 (0xfffb) +char 0xfffc - 0x1 == -0x5 (0xfffb) +__uchar 0xfc - 0x1 == 0xfb (0xfb) +__longlong 0xfffc - 0x1 == -0x5 (0xfffb) +__ulonglong 0xfffc - 0x1 == -0x5 (0xfffb) +float 0xfffc - 0x1 == -0x5 (0xfffb) +int 0xfffc * 0x1 == -0x4 (0xfffc) +__uint 0xfffc * 0x1 == -0x4 (0xfffc) +char 0xfffc * 0x1 == -0x4 (0xfffc) +__uchar 0xfc * 0x1 == 0xfc (0xfc) +__longlong 0xfffc * 0x1 == -0x4 (0xfffc) +__ulonglong 0xfffc * 0x1 == -0x4 (0xfffc) +float 0xfffc * 0x1 == -0x4 (0xfffc) +int 0xfffc < 0x1 == 0x1 (0x1) +__uint 0xfffc < 0x1 == 0x0 (0x0) +char 0xfffc < 0x1 == 0x1 (0x1) +__uchar 0xfc < 0x1 == 0x0 (0x0) +__longlong 0xfffc < 0x1 == 0x1 (0x1) +__ulonglong 0xfffc < 0x1 == 0x0 (0x0) +float 0xfffc < 0x1 == 0x1 (0x1) +int 0xfffc > 0x1 == 0x0 (0x0) +__uint 0xfffc > 0x1 == 0x1 (0x1) +char 0xfffc > 0x1 == 0x0 (0x0) +__uchar 0xfc > 0x1 == 0x1 (0x1) +__longlong 0xfffc > 0x1 == 0x0 (0x0) +__ulonglong 0xfffc > 0x1 == 0x1 (0x1) +float 0xfffc > 0x1 == 0x0 (0x0) +int 0xfffc <= 0x1 == 0x1 (0x1) +__uint 0xfffc <= 0x1 == 0x0 (0x0) +char 0xfffc <= 0x1 == 0x1 (0x1) +__uchar 0xfc <= 0x1 == 0x0 (0x0) +__longlong 0xfffc <= 0x1 == 0x1 (0x1) +__ulonglong 0xfffc <= 0x1 == 0x0 (0x0) +float 0xfffc <= 0x1 == 0x1 (0x1) +int 0xfffc == 0x1 == 0x0 (0x0) +__uint 0xfffc == 0x1 == 0x0 (0x0) +char 0xfffc == 0x1 == 0x0 (0x0) +__uchar 0xfc == 0x1 == 0x0 (0x0) +__longlong 0xfffc == 0x1 == 0x0 (0x0) +__ulonglong 0xfffc == 0x1 == 0x0 (0x0) +float 0xfffc == 0x1 == 0x0 (0x0) +int 0xfffc != 0x1 == 0x1 (0x1) +__uint 0xfffc != 0x1 == 0x1 (0x1) +char 0xfffc != 0x1 == 0x1 (0x1) +__uchar 0xfc != 0x1 == 0x1 (0x1) +__longlong 0xfffc != 0x1 == 0x1 (0x1) +__ulonglong 0xfffc != 0x1 == 0x1 (0x1) +float 0xfffc != 0x1 == 0x1 (0x1) +int 0xfffc >= 0x1 == 0x0 (0x0) +__uint 0xfffc >= 0x1 == 0x1 (0x1) +char 0xfffc >= 0x1 == 0x0 (0x0) +__uchar 0xfc >= 0x1 == 0x1 (0x1) +__longlong 0xfffc >= 0x1 == 0x0 (0x0) +__ulonglong 0xfffc >= 0x1 == 0x1 (0x1) +float 0xfffc >= 0x1 == 0x0 (0x0) +int 0xfffc / 0x1 == -0x4 (0xfffc) +__uint 0xfffc / 0x1 == -0x4 (0xfffc) +char 0xfffc / 0x1 == -0x4 (0xfffc) +__uchar 0xfc / 0x1 == 0xfc (0xfc) +__longlong 0xfffc / 0x1 == -0x4 (0xfffc) +__ulonglong 0xfffc / 0x1 == -0x4 (0xfffc) +float 0xfffc / 0x1 == -0x4 (0xfffc) +int 0xfffc % 0x1 == 0x0 (0x0) +__uint 0xfffc % 0x1 == 0x0 (0x0) +char 0xfffc % 0x1 == 0x0 (0x0) +__uchar 0xfc % 0x1 == 0x0 (0x0) +__longlong 0xfffc % 0x1 == 0x0 (0x0) +__ulonglong 0xfffc % 0x1 == 0x0 (0x0) +0xfffc * 0x2 == -0x8 +0xfffc / 0x2 == -0x2 +0xfffc % 0x2 == 0x0 +int 0xfffc ^ 0x2 == -0x2 (0xfffe) +__uint 0xfffc ^ 0x2 == -0x2 (0xfffe) +char 0xfffc ^ 0x2 == -0x2 (0xfffe) +__uchar 0xfc ^ 0x2 == 0xfe (0xfe) +__longlong 0xfffc ^ 0x2 == -0x2 (0xfffe) +__ulonglong 0xfffc ^ 0x2 == -0x2 (0xfffe) +int 0xfffc && 0x2 == 0x1 (0x1) +__uint 0xfffc && 0x2 == 0x1 (0x1) +char 0xfffc && 0x2 == 0x1 (0x1) +__uchar 0xfc && 0x2 == 0x1 (0x1) +__longlong 0xfffc && 0x2 == 0x1 (0x1) +__ulonglong 0xfffc && 0x2 == 0x1 (0x1) +int 0xfffc || 0x2 == 0x1 (0x1) +__uint 0xfffc || 0x2 == 0x1 (0x1) +char 0xfffc || 0x2 == 0x1 (0x1) +__uchar 0xfc || 0x2 == 0x1 (0x1) +__longlong 0xfffc || 0x2 == 0x1 (0x1) +__ulonglong 0xfffc || 0x2 == 0x1 (0x1) +int 0xfffc & 0x2 == 0x0 (0x0) +__uint 0xfffc & 0x2 == 0x0 (0x0) +char 0xfffc & 0x2 == 0x0 (0x0) +__uchar 0xfc & 0x2 == 0x0 (0x0) +__longlong 0xfffc & 0x2 == 0x0 (0x0) +__ulonglong 0xfffc & 0x2 == 0x0 (0x0) +int 0xfffc | 0x2 == -0x2 (0xfffe) +__uint 0xfffc | 0x2 == -0x2 (0xfffe) +char 0xfffc | 0x2 == -0x2 (0xfffe) +__uchar 0xfc | 0x2 == 0xfe (0xfe) +__longlong 0xfffc | 0x2 == -0x2 (0xfffe) +__ulonglong 0xfffc | 0x2 == -0x2 (0xfffe) +int 0xfffc << 0x3 == -0x20 (0xffe0) +__uint 0xfffc << 0x3 == -0x20 (0xffe0) +char 0xfffc << 0x3 == -0x20 (0xffe0) +__uchar 0xfc << 0x3 == 0xe0 (0xe0) +__longlong 0xfffc << 0x3 == -0x20 (0xffe0) +__ulonglong 0xfffc << 0x3 == -0x20 (0xffe0) +int 0xfffc >> 0x3 == -0x1 (0xffff) +__uint 0xfffc >> 0x3 == 0x1fff (0x1fff) +char 0xfffc >> 0x3 == -0x1 (0xffff) +__uchar 0xfc >> 0x3 == 0x1f (0x1f) +__longlong 0xfffc >> 0x3 == -0x1 (0xffff) +__ulonglong 0xfffc >> 0x3 == -0x1 (0xffff) +int 0xfffc + 0x2 == -0x2 (0xfffe) +__uint 0xfffc + 0x2 == -0x2 (0xfffe) +char 0xfffc + 0x2 == -0x2 (0xfffe) +__uchar 0xfc + 0x2 == 0xfe (0xfe) +__longlong 0xfffc + 0x2 == -0x2 (0xfffe) +__ulonglong 0xfffc + 0x2 == -0x2 (0xfffe) +float 0xfffc + 0x2 == -0x2 (0xfffe) +int 0xfffc - 0x2 == -0x6 (0xfffa) +__uint 0xfffc - 0x2 == -0x6 (0xfffa) +char 0xfffc - 0x2 == -0x6 (0xfffa) +__uchar 0xfc - 0x2 == 0xfa (0xfa) +__longlong 0xfffc - 0x2 == -0x6 (0xfffa) +__ulonglong 0xfffc - 0x2 == -0x6 (0xfffa) +float 0xfffc - 0x2 == -0x6 (0xfffa) +int 0xfffc * 0x2 == -0x8 (0xfff8) +__uint 0xfffc * 0x2 == -0x8 (0xfff8) +char 0xfffc * 0x2 == -0x8 (0xfff8) +__uchar 0xfc * 0x2 == 0xf8 (0xf8) +__longlong 0xfffc * 0x2 == -0x8 (0xfff8) +__ulonglong 0xfffc * 0x2 == -0x8 (0xfff8) +float 0xfffc * 0x2 == -0x8 (0xfff8) +int 0xfffc < 0x2 == 0x1 (0x1) +__uint 0xfffc < 0x2 == 0x0 (0x0) +char 0xfffc < 0x2 == 0x1 (0x1) +__uchar 0xfc < 0x2 == 0x0 (0x0) +__longlong 0xfffc < 0x2 == 0x1 (0x1) +__ulonglong 0xfffc < 0x2 == 0x0 (0x0) +float 0xfffc < 0x2 == 0x1 (0x1) +int 0xfffc > 0x2 == 0x0 (0x0) +__uint 0xfffc > 0x2 == 0x1 (0x1) +char 0xfffc > 0x2 == 0x0 (0x0) +__uchar 0xfc > 0x2 == 0x1 (0x1) +__longlong 0xfffc > 0x2 == 0x0 (0x0) +__ulonglong 0xfffc > 0x2 == 0x1 (0x1) +float 0xfffc > 0x2 == 0x0 (0x0) +int 0xfffc <= 0x2 == 0x1 (0x1) +__uint 0xfffc <= 0x2 == 0x0 (0x0) +char 0xfffc <= 0x2 == 0x1 (0x1) +__uchar 0xfc <= 0x2 == 0x0 (0x0) +__longlong 0xfffc <= 0x2 == 0x1 (0x1) +__ulonglong 0xfffc <= 0x2 == 0x0 (0x0) +float 0xfffc <= 0x2 == 0x1 (0x1) +int 0xfffc == 0x2 == 0x0 (0x0) +__uint 0xfffc == 0x2 == 0x0 (0x0) +char 0xfffc == 0x2 == 0x0 (0x0) +__uchar 0xfc == 0x2 == 0x0 (0x0) +__longlong 0xfffc == 0x2 == 0x0 (0x0) +__ulonglong 0xfffc == 0x2 == 0x0 (0x0) +float 0xfffc == 0x2 == 0x0 (0x0) +int 0xfffc != 0x2 == 0x1 (0x1) +__uint 0xfffc != 0x2 == 0x1 (0x1) +char 0xfffc != 0x2 == 0x1 (0x1) +__uchar 0xfc != 0x2 == 0x1 (0x1) +__longlong 0xfffc != 0x2 == 0x1 (0x1) +__ulonglong 0xfffc != 0x2 == 0x1 (0x1) +float 0xfffc != 0x2 == 0x1 (0x1) +int 0xfffc >= 0x2 == 0x0 (0x0) +__uint 0xfffc >= 0x2 == 0x1 (0x1) +char 0xfffc >= 0x2 == 0x0 (0x0) +__uchar 0xfc >= 0x2 == 0x1 (0x1) +__longlong 0xfffc >= 0x2 == 0x0 (0x0) +__ulonglong 0xfffc >= 0x2 == 0x1 (0x1) +float 0xfffc >= 0x2 == 0x0 (0x0) +int 0xfffc / 0x2 == -0x2 (0xfffe) +__uint 0xfffc / 0x2 == 0x7ffe (0x7ffe) +char 0xfffc / 0x2 == -0x2 (0xfffe) +__uchar 0xfc / 0x2 == 0x7e (0x7e) +__longlong 0xfffc / 0x2 == -0x2 (0xfffe) +__ulonglong 0xfffc / 0x2 == -0x2 (0xfffe) +float 0xfffc / 0x2 == -0x2 (0xfffe) +int 0xfffc % 0x2 == 0x0 (0x0) +__uint 0xfffc % 0x2 == 0x0 (0x0) +char 0xfffc % 0x2 == 0x0 (0x0) +__uchar 0xfc % 0x2 == 0x0 (0x0) +__longlong 0xfffc % 0x2 == 0x0 (0x0) +__ulonglong 0xfffc % 0x2 == 0x0 (0x0) +0xfffc * 0xfffe == 0x8 +0xfffc / 0xfffe == 0x2 +0xfffc % 0xfffe == 0x0 +int 0xfffc ^ 0xfffe == 0x2 (0x2) +__uint 0xfffc ^ 0xfffe == 0x2 (0x2) +char 0xfffc ^ 0xfffe == 0x2 (0x2) +__uchar 0xfc ^ 0xfe == 0x2 (0x2) +__longlong 0xfffc ^ 0xfffe == 0x2 (0x2) +__ulonglong 0xfffc ^ 0xfffe == 0x2 (0x2) +int 0xfffc && 0xfffe == 0x1 (0x1) +__uint 0xfffc && 0xfffe == 0x1 (0x1) +char 0xfffc && 0xfffe == 0x1 (0x1) +__uchar 0xfc && 0xfe == 0x1 (0x1) +__longlong 0xfffc && 0xfffe == 0x1 (0x1) +__ulonglong 0xfffc && 0xfffe == 0x1 (0x1) +int 0xfffc || 0xfffe == 0x1 (0x1) +__uint 0xfffc || 0xfffe == 0x1 (0x1) +char 0xfffc || 0xfffe == 0x1 (0x1) +__uchar 0xfc || 0xfe == 0x1 (0x1) +__longlong 0xfffc || 0xfffe == 0x1 (0x1) +__ulonglong 0xfffc || 0xfffe == 0x1 (0x1) +int 0xfffc & 0xfffe == -0x4 (0xfffc) +__uint 0xfffc & 0xfffe == -0x4 (0xfffc) +char 0xfffc & 0xfffe == -0x4 (0xfffc) +__uchar 0xfc & 0xfe == 0xfc (0xfc) +__longlong 0xfffc & 0xfffe == -0x4 (0xfffc) +__ulonglong 0xfffc & 0xfffe == -0x4 (0xfffc) +int 0xfffc | 0xfffe == -0x2 (0xfffe) +__uint 0xfffc | 0xfffe == -0x2 (0xfffe) +char 0xfffc | 0xfffe == -0x2 (0xfffe) +__uchar 0xfc | 0xfe == 0xfe (0xfe) +__longlong 0xfffc | 0xfffe == -0x2 (0xfffe) +__ulonglong 0xfffc | 0xfffe == -0x2 (0xfffe) +int 0xfffc << 0x4 == -0x40 (0xffc0) +__uint 0xfffc << 0x4 == -0x40 (0xffc0) +char 0xfffc << 0x4 == -0x40 (0xffc0) +__uchar 0xfc << 0x4 == 0xc0 (0xc0) +__longlong 0xfffc << 0x4 == -0x40 (0xffc0) +__ulonglong 0xfffc << 0x4 == -0x40 (0xffc0) +int 0xfffc >> 0x4 == -0x1 (0xffff) +__uint 0xfffc >> 0x4 == 0xfff (0xfff) +char 0xfffc >> 0x4 == -0x1 (0xffff) +__uchar 0xfc >> 0x4 == 0xf (0xf) +__longlong 0xfffc >> 0x4 == -0x1 (0xffff) +__ulonglong 0xfffc >> 0x4 == -0x1 (0xffff) +int 0xfffc + 0xfffe == -0x6 (0xfffa) +__uint 0xfffc + 0xfffe == -0x6 (0xfffa) +char 0xfffc + 0xfffe == -0x6 (0xfffa) +__uchar 0xfc + 0xfe == 0xfa (0xfa) +__longlong 0xfffc + 0xfffe == -0x6 (0xfffa) +__ulonglong 0xfffc + 0xfffe == -0x6 (0xfffa) +float 0xfffc + 0xfffe == -0x6 (0xfffa) +int 0xfffc - 0xfffe == -0x2 (0xfffe) +__uint 0xfffc - 0xfffe == -0x2 (0xfffe) +char 0xfffc - 0xfffe == -0x2 (0xfffe) +__uchar 0xfc - 0xfe == 0xfe (0xfe) +__longlong 0xfffc - 0xfffe == -0x2 (0xfffe) +__ulonglong 0xfffc - 0xfffe == -0x2 (0xfffe) +float 0xfffc - 0xfffe == -0x2 (0xfffe) +int 0xfffc * 0xfffe == 0x8 (0x8) +__uint 0xfffc * 0xfffe == 0x8 (0x8) +char 0xfffc * 0xfffe == 0x8 (0x8) +__uchar 0xfc * 0xfe == 0x8 (0x8) +__longlong 0xfffc * 0xfffe == 0x8 (0x8) +__ulonglong 0xfffc * 0xfffe == 0x8 (0x8) +float 0xfffc * 0xfffe == 0x8 (0x8) +int 0xfffc < 0xfffe == 0x1 (0x1) +__uint 0xfffc < 0xfffe == 0x1 (0x1) +char 0xfffc < 0xfffe == 0x1 (0x1) +__uchar 0xfc < 0xfe == 0x1 (0x1) +__longlong 0xfffc < 0xfffe == 0x1 (0x1) +__ulonglong 0xfffc < 0xfffe == 0x1 (0x1) +float 0xfffc < 0xfffe == 0x1 (0x1) +int 0xfffc > 0xfffe == 0x0 (0x0) +__uint 0xfffc > 0xfffe == 0x0 (0x0) +char 0xfffc > 0xfffe == 0x0 (0x0) +__uchar 0xfc > 0xfe == 0x0 (0x0) +__longlong 0xfffc > 0xfffe == 0x0 (0x0) +__ulonglong 0xfffc > 0xfffe == 0x0 (0x0) +float 0xfffc > 0xfffe == 0x0 (0x0) +int 0xfffc <= 0xfffe == 0x1 (0x1) +__uint 0xfffc <= 0xfffe == 0x1 (0x1) +char 0xfffc <= 0xfffe == 0x1 (0x1) +__uchar 0xfc <= 0xfe == 0x1 (0x1) +__longlong 0xfffc <= 0xfffe == 0x1 (0x1) +__ulonglong 0xfffc <= 0xfffe == 0x1 (0x1) +float 0xfffc <= 0xfffe == 0x1 (0x1) +int 0xfffc == 0xfffe == 0x0 (0x0) +__uint 0xfffc == 0xfffe == 0x0 (0x0) +char 0xfffc == 0xfffe == 0x0 (0x0) +__uchar 0xfc == 0xfe == 0x0 (0x0) +__longlong 0xfffc == 0xfffe == 0x0 (0x0) +__ulonglong 0xfffc == 0xfffe == 0x0 (0x0) +float 0xfffc == 0xfffe == 0x0 (0x0) +int 0xfffc != 0xfffe == 0x1 (0x1) +__uint 0xfffc != 0xfffe == 0x1 (0x1) +char 0xfffc != 0xfffe == 0x1 (0x1) +__uchar 0xfc != 0xfe == 0x1 (0x1) +__longlong 0xfffc != 0xfffe == 0x1 (0x1) +__ulonglong 0xfffc != 0xfffe == 0x1 (0x1) +float 0xfffc != 0xfffe == 0x1 (0x1) +int 0xfffc >= 0xfffe == 0x0 (0x0) +__uint 0xfffc >= 0xfffe == 0x0 (0x0) +char 0xfffc >= 0xfffe == 0x0 (0x0) +__uchar 0xfc >= 0xfe == 0x0 (0x0) +__longlong 0xfffc >= 0xfffe == 0x0 (0x0) +__ulonglong 0xfffc >= 0xfffe == 0x0 (0x0) +float 0xfffc >= 0xfffe == 0x0 (0x0) +int 0xfffc / 0xfffe == 0x2 (0x2) +__uint 0xfffc / 0xfffe == 0x0 (0x0) +char 0xfffc / 0xfffe == 0x2 (0x2) +__uchar 0xfc / 0xfe == 0x0 (0x0) +__longlong 0xfffc / 0xfffe == 0x2 (0x2) +__ulonglong 0xfffc / 0xfffe == 0x0 (0x0) +float 0xfffc / 0xfffe == 0x2 (0x2) +int 0xfffc % 0xfffe == 0x0 (0x0) +__uint 0xfffc % 0xfffe == -0x4 (0xfffc) +char 0xfffc % 0xfffe == 0x0 (0x0) +__uchar 0xfc % 0xfe == 0xfc (0xfc) +__longlong 0xfffc % 0xfffe == 0x0 (0x0) +__ulonglong 0xfffc % 0xfffe == -0x4 (0xfffc) +0xfffc * 0x4 == -0x10 +0xfffc / 0x4 == -0x1 +0xfffc % 0x4 == 0x0 +int 0xfffc ^ 0x4 == -0x8 (0xfff8) +__uint 0xfffc ^ 0x4 == -0x8 (0xfff8) +char 0xfffc ^ 0x4 == -0x8 (0xfff8) +__uchar 0xfc ^ 0x4 == 0xf8 (0xf8) +__longlong 0xfffc ^ 0x4 == -0x8 (0xfff8) +__ulonglong 0xfffc ^ 0x4 == -0x8 (0xfff8) +int 0xfffc && 0x4 == 0x1 (0x1) +__uint 0xfffc && 0x4 == 0x1 (0x1) +char 0xfffc && 0x4 == 0x1 (0x1) +__uchar 0xfc && 0x4 == 0x1 (0x1) +__longlong 0xfffc && 0x4 == 0x1 (0x1) +__ulonglong 0xfffc && 0x4 == 0x1 (0x1) +int 0xfffc || 0x4 == 0x1 (0x1) +__uint 0xfffc || 0x4 == 0x1 (0x1) +char 0xfffc || 0x4 == 0x1 (0x1) +__uchar 0xfc || 0x4 == 0x1 (0x1) +__longlong 0xfffc || 0x4 == 0x1 (0x1) +__ulonglong 0xfffc || 0x4 == 0x1 (0x1) +int 0xfffc & 0x4 == 0x4 (0x4) +__uint 0xfffc & 0x4 == 0x4 (0x4) +char 0xfffc & 0x4 == 0x4 (0x4) +__uchar 0xfc & 0x4 == 0x4 (0x4) +__longlong 0xfffc & 0x4 == 0x4 (0x4) +__ulonglong 0xfffc & 0x4 == 0x4 (0x4) +int 0xfffc | 0x4 == -0x4 (0xfffc) +__uint 0xfffc | 0x4 == -0x4 (0xfffc) +char 0xfffc | 0x4 == -0x4 (0xfffc) +__uchar 0xfc | 0x4 == 0xfc (0xfc) +__longlong 0xfffc | 0x4 == -0x4 (0xfffc) +__ulonglong 0xfffc | 0x4 == -0x4 (0xfffc) +int 0xfffc << 0x5 == -0x80 (0xff80) +__uint 0xfffc << 0x5 == -0x80 (0xff80) +char 0xfffc << 0x5 == -0x80 (0xff80) +__uchar 0xfc << 0x5 == 0x80 (0x80) +__longlong 0xfffc << 0x5 == -0x80 (0xff80) +__ulonglong 0xfffc << 0x5 == -0x80 (0xff80) +int 0xfffc >> 0x5 == -0x1 (0xffff) +__uint 0xfffc >> 0x5 == 0x7ff (0x7ff) +char 0xfffc >> 0x5 == -0x1 (0xffff) +__uchar 0xfc >> 0x5 == 0x7 (0x7) +__longlong 0xfffc >> 0x5 == -0x1 (0xffff) +__ulonglong 0xfffc >> 0x5 == -0x1 (0xffff) +int 0xfffc + 0x4 == 0x0 (0x0) +__uint 0xfffc + 0x4 == 0x0 (0x0) +char 0xfffc + 0x4 == 0x0 (0x0) +__uchar 0xfc + 0x4 == 0x0 (0x0) +__longlong 0xfffc + 0x4 == 0x0 (0x0) +__ulonglong 0xfffc + 0x4 == 0x0 (0x0) +float 0xfffc + 0x4 == 0x0 (0x0) +int 0xfffc - 0x4 == -0x8 (0xfff8) +__uint 0xfffc - 0x4 == -0x8 (0xfff8) +char 0xfffc - 0x4 == -0x8 (0xfff8) +__uchar 0xfc - 0x4 == 0xf8 (0xf8) +__longlong 0xfffc - 0x4 == -0x8 (0xfff8) +__ulonglong 0xfffc - 0x4 == -0x8 (0xfff8) +float 0xfffc - 0x4 == -0x8 (0xfff8) +int 0xfffc * 0x4 == -0x10 (0xfff0) +__uint 0xfffc * 0x4 == -0x10 (0xfff0) +char 0xfffc * 0x4 == -0x10 (0xfff0) +__uchar 0xfc * 0x4 == 0xf0 (0xf0) +__longlong 0xfffc * 0x4 == -0x10 (0xfff0) +__ulonglong 0xfffc * 0x4 == -0x10 (0xfff0) +float 0xfffc * 0x4 == -0x10 (0xfff0) +int 0xfffc < 0x4 == 0x1 (0x1) +__uint 0xfffc < 0x4 == 0x0 (0x0) +char 0xfffc < 0x4 == 0x1 (0x1) +__uchar 0xfc < 0x4 == 0x0 (0x0) +__longlong 0xfffc < 0x4 == 0x1 (0x1) +__ulonglong 0xfffc < 0x4 == 0x0 (0x0) +float 0xfffc < 0x4 == 0x1 (0x1) +int 0xfffc > 0x4 == 0x0 (0x0) +__uint 0xfffc > 0x4 == 0x1 (0x1) +char 0xfffc > 0x4 == 0x0 (0x0) +__uchar 0xfc > 0x4 == 0x1 (0x1) +__longlong 0xfffc > 0x4 == 0x0 (0x0) +__ulonglong 0xfffc > 0x4 == 0x1 (0x1) +float 0xfffc > 0x4 == 0x0 (0x0) +int 0xfffc <= 0x4 == 0x1 (0x1) +__uint 0xfffc <= 0x4 == 0x0 (0x0) +char 0xfffc <= 0x4 == 0x1 (0x1) +__uchar 0xfc <= 0x4 == 0x0 (0x0) +__longlong 0xfffc <= 0x4 == 0x1 (0x1) +__ulonglong 0xfffc <= 0x4 == 0x0 (0x0) +float 0xfffc <= 0x4 == 0x1 (0x1) +int 0xfffc == 0x4 == 0x0 (0x0) +__uint 0xfffc == 0x4 == 0x0 (0x0) +char 0xfffc == 0x4 == 0x0 (0x0) +__uchar 0xfc == 0x4 == 0x0 (0x0) +__longlong 0xfffc == 0x4 == 0x0 (0x0) +__ulonglong 0xfffc == 0x4 == 0x0 (0x0) +float 0xfffc == 0x4 == 0x0 (0x0) +int 0xfffc != 0x4 == 0x1 (0x1) +__uint 0xfffc != 0x4 == 0x1 (0x1) +char 0xfffc != 0x4 == 0x1 (0x1) +__uchar 0xfc != 0x4 == 0x1 (0x1) +__longlong 0xfffc != 0x4 == 0x1 (0x1) +__ulonglong 0xfffc != 0x4 == 0x1 (0x1) +float 0xfffc != 0x4 == 0x1 (0x1) +int 0xfffc >= 0x4 == 0x0 (0x0) +__uint 0xfffc >= 0x4 == 0x1 (0x1) +char 0xfffc >= 0x4 == 0x0 (0x0) +__uchar 0xfc >= 0x4 == 0x1 (0x1) +__longlong 0xfffc >= 0x4 == 0x0 (0x0) +__ulonglong 0xfffc >= 0x4 == 0x1 (0x1) +float 0xfffc >= 0x4 == 0x0 (0x0) +int 0xfffc / 0x4 == -0x1 (0xffff) +__uint 0xfffc / 0x4 == 0x3fff (0x3fff) +char 0xfffc / 0x4 == -0x1 (0xffff) +__uchar 0xfc / 0x4 == 0x3f (0x3f) +__longlong 0xfffc / 0x4 == -0x1 (0xffff) +__ulonglong 0xfffc / 0x4 == -0x1 (0xffff) +float 0xfffc / 0x4 == -0x1 (0xffff) +int 0xfffc % 0x4 == 0x0 (0x0) +__uint 0xfffc % 0x4 == 0x0 (0x0) +char 0xfffc % 0x4 == 0x0 (0x0) +__uchar 0xfc % 0x4 == 0x0 (0x0) +__longlong 0xfffc % 0x4 == 0x0 (0x0) +__ulonglong 0xfffc % 0x4 == 0x0 (0x0) +0xfffc * 0xfffc == 0x10 +0xfffc / 0xfffc == 0x1 +0xfffc % 0xfffc == 0x0 +int 0xfffc ^ 0xfffc == 0x0 (0x0) +__uint 0xfffc ^ 0xfffc == 0x0 (0x0) +char 0xfffc ^ 0xfffc == 0x0 (0x0) +__uchar 0xfc ^ 0xfc == 0x0 (0x0) +__longlong 0xfffc ^ 0xfffc == 0x0 (0x0) +__ulonglong 0xfffc ^ 0xfffc == 0x0 (0x0) +int 0xfffc && 0xfffc == 0x1 (0x1) +__uint 0xfffc && 0xfffc == 0x1 (0x1) +char 0xfffc && 0xfffc == 0x1 (0x1) +__uchar 0xfc && 0xfc == 0x1 (0x1) +__longlong 0xfffc && 0xfffc == 0x1 (0x1) +__ulonglong 0xfffc && 0xfffc == 0x1 (0x1) +int 0xfffc || 0xfffc == 0x1 (0x1) +__uint 0xfffc || 0xfffc == 0x1 (0x1) +char 0xfffc || 0xfffc == 0x1 (0x1) +__uchar 0xfc || 0xfc == 0x1 (0x1) +__longlong 0xfffc || 0xfffc == 0x1 (0x1) +__ulonglong 0xfffc || 0xfffc == 0x1 (0x1) +int 0xfffc & 0xfffc == -0x4 (0xfffc) +__uint 0xfffc & 0xfffc == -0x4 (0xfffc) +char 0xfffc & 0xfffc == -0x4 (0xfffc) +__uchar 0xfc & 0xfc == 0xfc (0xfc) +__longlong 0xfffc & 0xfffc == -0x4 (0xfffc) +__ulonglong 0xfffc & 0xfffc == -0x4 (0xfffc) +int 0xfffc | 0xfffc == -0x4 (0xfffc) +__uint 0xfffc | 0xfffc == -0x4 (0xfffc) +char 0xfffc | 0xfffc == -0x4 (0xfffc) +__uchar 0xfc | 0xfc == 0xfc (0xfc) +__longlong 0xfffc | 0xfffc == -0x4 (0xfffc) +__ulonglong 0xfffc | 0xfffc == -0x4 (0xfffc) +int 0xfffc << 0x6 == -0x100 (0xff00) +__uint 0xfffc << 0x6 == -0x100 (0xff00) +char 0xfffc << 0x6 == 0x0 (0x0) +__uchar 0xfc << 0x6 == 0x0 (0x0) +__longlong 0xfffc << 0x6 == -0x100 (0xff00) +__ulonglong 0xfffc << 0x6 == -0x100 (0xff00) +int 0xfffc >> 0x6 == -0x1 (0xffff) +__uint 0xfffc >> 0x6 == 0x3ff (0x3ff) +char 0xfffc >> 0x6 == -0x1 (0xffff) +__uchar 0xfc >> 0x6 == 0x3 (0x3) +__longlong 0xfffc >> 0x6 == -0x1 (0xffff) +__ulonglong 0xfffc >> 0x6 == -0x1 (0xffff) +int 0xfffc + 0xfffc == -0x8 (0xfff8) +__uint 0xfffc + 0xfffc == -0x8 (0xfff8) +char 0xfffc + 0xfffc == -0x8 (0xfff8) +__uchar 0xfc + 0xfc == 0xf8 (0xf8) +__longlong 0xfffc + 0xfffc == -0x8 (0xfff8) +__ulonglong 0xfffc + 0xfffc == -0x8 (0xfff8) +float 0xfffc + 0xfffc == -0x8 (0xfff8) +int 0xfffc - 0xfffc == 0x0 (0x0) +__uint 0xfffc - 0xfffc == 0x0 (0x0) +char 0xfffc - 0xfffc == 0x0 (0x0) +__uchar 0xfc - 0xfc == 0x0 (0x0) +__longlong 0xfffc - 0xfffc == 0x0 (0x0) +__ulonglong 0xfffc - 0xfffc == 0x0 (0x0) +float 0xfffc - 0xfffc == 0x0 (0x0) +int 0xfffc * 0xfffc == 0x10 (0x10) +__uint 0xfffc * 0xfffc == 0x10 (0x10) +char 0xfffc * 0xfffc == 0x10 (0x10) +__uchar 0xfc * 0xfc == 0x10 (0x10) +__longlong 0xfffc * 0xfffc == 0x10 (0x10) +__ulonglong 0xfffc * 0xfffc == 0x10 (0x10) +float 0xfffc * 0xfffc == 0x10 (0x10) +int 0xfffc < 0xfffc == 0x0 (0x0) +__uint 0xfffc < 0xfffc == 0x0 (0x0) +char 0xfffc < 0xfffc == 0x0 (0x0) +__uchar 0xfc < 0xfc == 0x0 (0x0) +__longlong 0xfffc < 0xfffc == 0x0 (0x0) +__ulonglong 0xfffc < 0xfffc == 0x0 (0x0) +float 0xfffc < 0xfffc == 0x0 (0x0) +int 0xfffc > 0xfffc == 0x0 (0x0) +__uint 0xfffc > 0xfffc == 0x0 (0x0) +char 0xfffc > 0xfffc == 0x0 (0x0) +__uchar 0xfc > 0xfc == 0x0 (0x0) +__longlong 0xfffc > 0xfffc == 0x0 (0x0) +__ulonglong 0xfffc > 0xfffc == 0x0 (0x0) +float 0xfffc > 0xfffc == 0x0 (0x0) +int 0xfffc <= 0xfffc == 0x1 (0x1) +__uint 0xfffc <= 0xfffc == 0x1 (0x1) +char 0xfffc <= 0xfffc == 0x1 (0x1) +__uchar 0xfc <= 0xfc == 0x1 (0x1) +__longlong 0xfffc <= 0xfffc == 0x1 (0x1) +__ulonglong 0xfffc <= 0xfffc == 0x1 (0x1) +float 0xfffc <= 0xfffc == 0x1 (0x1) +int 0xfffc == 0xfffc == 0x1 (0x1) +__uint 0xfffc == 0xfffc == 0x1 (0x1) +char 0xfffc == 0xfffc == 0x1 (0x1) +__uchar 0xfc == 0xfc == 0x1 (0x1) +__longlong 0xfffc == 0xfffc == 0x1 (0x1) +__ulonglong 0xfffc == 0xfffc == 0x1 (0x1) +float 0xfffc == 0xfffc == 0x1 (0x1) +int 0xfffc != 0xfffc == 0x0 (0x0) +__uint 0xfffc != 0xfffc == 0x0 (0x0) +char 0xfffc != 0xfffc == 0x0 (0x0) +__uchar 0xfc != 0xfc == 0x0 (0x0) +__longlong 0xfffc != 0xfffc == 0x0 (0x0) +__ulonglong 0xfffc != 0xfffc == 0x0 (0x0) +float 0xfffc != 0xfffc == 0x0 (0x0) +int 0xfffc >= 0xfffc == 0x1 (0x1) +__uint 0xfffc >= 0xfffc == 0x1 (0x1) +char 0xfffc >= 0xfffc == 0x1 (0x1) +__uchar 0xfc >= 0xfc == 0x1 (0x1) +__longlong 0xfffc >= 0xfffc == 0x1 (0x1) +__ulonglong 0xfffc >= 0xfffc == 0x1 (0x1) +float 0xfffc >= 0xfffc == 0x1 (0x1) +int 0xfffc / 0xfffc == 0x1 (0x1) +__uint 0xfffc / 0xfffc == 0x1 (0x1) +char 0xfffc / 0xfffc == 0x1 (0x1) +__uchar 0xfc / 0xfc == 0x1 (0x1) +__longlong 0xfffc / 0xfffc == 0x1 (0x1) +__ulonglong 0xfffc / 0xfffc == 0x1 (0x1) +float 0xfffc / 0xfffc == 0x1 (0x1) +int 0xfffc % 0xfffc == 0x0 (0x0) +__uint 0xfffc % 0xfffc == 0x0 (0x0) +char 0xfffc % 0xfffc == 0x0 (0x0) +__uchar 0xfc % 0xfc == 0x0 (0x0) +__longlong 0xfffc % 0xfffc == 0x0 (0x0) +__ulonglong 0xfffc % 0xfffc == 0x0 (0x0) +0xfffc * 0xa == -0x28 +0xfffc / 0xa == 0x0 +0xfffc % 0xa == -0x4 +int 0xfffc ^ 0xa == -0xa (0xfff6) +__uint 0xfffc ^ 0xa == -0xa (0xfff6) +char 0xfffc ^ 0xa == -0xa (0xfff6) +__uchar 0xfc ^ 0xa == 0xf6 (0xf6) +__longlong 0xfffc ^ 0xa == -0xa (0xfff6) +__ulonglong 0xfffc ^ 0xa == -0xa (0xfff6) +int 0xfffc && 0xa == 0x1 (0x1) +__uint 0xfffc && 0xa == 0x1 (0x1) +char 0xfffc && 0xa == 0x1 (0x1) +__uchar 0xfc && 0xa == 0x1 (0x1) +__longlong 0xfffc && 0xa == 0x1 (0x1) +__ulonglong 0xfffc && 0xa == 0x1 (0x1) +int 0xfffc || 0xa == 0x1 (0x1) +__uint 0xfffc || 0xa == 0x1 (0x1) +char 0xfffc || 0xa == 0x1 (0x1) +__uchar 0xfc || 0xa == 0x1 (0x1) +__longlong 0xfffc || 0xa == 0x1 (0x1) +__ulonglong 0xfffc || 0xa == 0x1 (0x1) +int 0xfffc & 0xa == 0x8 (0x8) +__uint 0xfffc & 0xa == 0x8 (0x8) +char 0xfffc & 0xa == 0x8 (0x8) +__uchar 0xfc & 0xa == 0x8 (0x8) +__longlong 0xfffc & 0xa == 0x8 (0x8) +__ulonglong 0xfffc & 0xa == 0x8 (0x8) +int 0xfffc | 0xa == -0x2 (0xfffe) +__uint 0xfffc | 0xa == -0x2 (0xfffe) +char 0xfffc | 0xa == -0x2 (0xfffe) +__uchar 0xfc | 0xa == 0xfe (0xfe) +__longlong 0xfffc | 0xa == -0x2 (0xfffe) +__ulonglong 0xfffc | 0xa == -0x2 (0xfffe) +int 0xfffc << 0x7 == -0x200 (0xfe00) +__uint 0xfffc << 0x7 == -0x200 (0xfe00) +char 0xfffc << 0x7 == 0x0 (0x0) +__uchar 0xfc << 0x7 == 0x0 (0x0) +__longlong 0xfffc << 0x7 == -0x200 (0xfe00) +__ulonglong 0xfffc << 0x7 == -0x200 (0xfe00) +int 0xfffc >> 0x7 == -0x1 (0xffff) +__uint 0xfffc >> 0x7 == 0x1ff (0x1ff) +char 0xfffc >> 0x7 == -0x1 (0xffff) +__uchar 0xfc >> 0x7 == 0x1 (0x1) +__longlong 0xfffc >> 0x7 == -0x1 (0xffff) +__ulonglong 0xfffc >> 0x7 == -0x1 (0xffff) +int 0xfffc + 0xa == 0x6 (0x6) +__uint 0xfffc + 0xa == 0x6 (0x6) +char 0xfffc + 0xa == 0x6 (0x6) +__uchar 0xfc + 0xa == 0x6 (0x6) +__longlong 0xfffc + 0xa == 0x6 (0x6) +__ulonglong 0xfffc + 0xa == 0x6 (0x6) +float 0xfffc + 0xa == 0x6 (0x6) +int 0xfffc - 0xa == -0xe (0xfff2) +__uint 0xfffc - 0xa == -0xe (0xfff2) +char 0xfffc - 0xa == -0xe (0xfff2) +__uchar 0xfc - 0xa == 0xf2 (0xf2) +__longlong 0xfffc - 0xa == -0xe (0xfff2) +__ulonglong 0xfffc - 0xa == -0xe (0xfff2) +float 0xfffc - 0xa == -0xe (0xfff2) +int 0xfffc * 0xa == -0x28 (0xffd8) +__uint 0xfffc * 0xa == -0x28 (0xffd8) +char 0xfffc * 0xa == -0x28 (0xffd8) +__uchar 0xfc * 0xa == 0xd8 (0xd8) +__longlong 0xfffc * 0xa == -0x28 (0xffd8) +__ulonglong 0xfffc * 0xa == -0x28 (0xffd8) +float 0xfffc * 0xa == -0x28 (0xffd8) +int 0xfffc < 0xa == 0x1 (0x1) +__uint 0xfffc < 0xa == 0x0 (0x0) +char 0xfffc < 0xa == 0x1 (0x1) +__uchar 0xfc < 0xa == 0x0 (0x0) +__longlong 0xfffc < 0xa == 0x1 (0x1) +__ulonglong 0xfffc < 0xa == 0x0 (0x0) +float 0xfffc < 0xa == 0x1 (0x1) +int 0xfffc > 0xa == 0x0 (0x0) +__uint 0xfffc > 0xa == 0x1 (0x1) +char 0xfffc > 0xa == 0x0 (0x0) +__uchar 0xfc > 0xa == 0x1 (0x1) +__longlong 0xfffc > 0xa == 0x0 (0x0) +__ulonglong 0xfffc > 0xa == 0x1 (0x1) +float 0xfffc > 0xa == 0x0 (0x0) +int 0xfffc <= 0xa == 0x1 (0x1) +__uint 0xfffc <= 0xa == 0x0 (0x0) +char 0xfffc <= 0xa == 0x1 (0x1) +__uchar 0xfc <= 0xa == 0x0 (0x0) +__longlong 0xfffc <= 0xa == 0x1 (0x1) +__ulonglong 0xfffc <= 0xa == 0x0 (0x0) +float 0xfffc <= 0xa == 0x1 (0x1) +int 0xfffc == 0xa == 0x0 (0x0) +__uint 0xfffc == 0xa == 0x0 (0x0) +char 0xfffc == 0xa == 0x0 (0x0) +__uchar 0xfc == 0xa == 0x0 (0x0) +__longlong 0xfffc == 0xa == 0x0 (0x0) +__ulonglong 0xfffc == 0xa == 0x0 (0x0) +float 0xfffc == 0xa == 0x0 (0x0) +int 0xfffc != 0xa == 0x1 (0x1) +__uint 0xfffc != 0xa == 0x1 (0x1) +char 0xfffc != 0xa == 0x1 (0x1) +__uchar 0xfc != 0xa == 0x1 (0x1) +__longlong 0xfffc != 0xa == 0x1 (0x1) +__ulonglong 0xfffc != 0xa == 0x1 (0x1) +float 0xfffc != 0xa == 0x1 (0x1) +int 0xfffc >= 0xa == 0x0 (0x0) +__uint 0xfffc >= 0xa == 0x1 (0x1) +char 0xfffc >= 0xa == 0x0 (0x0) +__uchar 0xfc >= 0xa == 0x1 (0x1) +__longlong 0xfffc >= 0xa == 0x0 (0x0) +__ulonglong 0xfffc >= 0xa == 0x1 (0x1) +float 0xfffc >= 0xa == 0x0 (0x0) +int 0xfffc / 0xa == 0x0 (0x0) +__uint 0xfffc / 0xa == 0x1999 (0x1999) +char 0xfffc / 0xa == 0x0 (0x0) +__uchar 0xfc / 0xa == 0x19 (0x19) +__longlong 0xfffc / 0xa == 0x0 (0x0) +__ulonglong 0xfffc / 0xa == -0x6667 (0x9999) +float 0xfffc / 0xa == 0x0 (0x0) +int 0xfffc % 0xa == -0x4 (0xfffc) +__uint 0xfffc % 0xa == 0x2 (0x2) +char 0xfffc % 0xa == -0x4 (0xfffc) +__uchar 0xfc % 0xa == 0x2 (0x2) +__longlong 0xfffc % 0xa == -0x4 (0xfffc) +__ulonglong 0xfffc % 0xa == 0x2 (0x2) +0xfffc * 0xfff6 == 0x28 +0xfffc / 0xfff6 == 0x0 +0xfffc % 0xfff6 == -0x4 +int 0xfffc ^ 0xfff6 == 0xa (0xa) +__uint 0xfffc ^ 0xfff6 == 0xa (0xa) +char 0xfffc ^ 0xfff6 == 0xa (0xa) +__uchar 0xfc ^ 0xf6 == 0xa (0xa) +__longlong 0xfffc ^ 0xfff6 == 0xa (0xa) +__ulonglong 0xfffc ^ 0xfff6 == 0xa (0xa) +int 0xfffc && 0xfff6 == 0x1 (0x1) +__uint 0xfffc && 0xfff6 == 0x1 (0x1) +char 0xfffc && 0xfff6 == 0x1 (0x1) +__uchar 0xfc && 0xf6 == 0x1 (0x1) +__longlong 0xfffc && 0xfff6 == 0x1 (0x1) +__ulonglong 0xfffc && 0xfff6 == 0x1 (0x1) +int 0xfffc || 0xfff6 == 0x1 (0x1) +__uint 0xfffc || 0xfff6 == 0x1 (0x1) +char 0xfffc || 0xfff6 == 0x1 (0x1) +__uchar 0xfc || 0xf6 == 0x1 (0x1) +__longlong 0xfffc || 0xfff6 == 0x1 (0x1) +__ulonglong 0xfffc || 0xfff6 == 0x1 (0x1) +int 0xfffc & 0xfff6 == -0xc (0xfff4) +__uint 0xfffc & 0xfff6 == -0xc (0xfff4) +char 0xfffc & 0xfff6 == -0xc (0xfff4) +__uchar 0xfc & 0xf6 == 0xf4 (0xf4) +__longlong 0xfffc & 0xfff6 == -0xc (0xfff4) +__ulonglong 0xfffc & 0xfff6 == -0xc (0xfff4) +int 0xfffc | 0xfff6 == -0x2 (0xfffe) +__uint 0xfffc | 0xfff6 == -0x2 (0xfffe) +char 0xfffc | 0xfff6 == -0x2 (0xfffe) +__uchar 0xfc | 0xf6 == 0xfe (0xfe) +__longlong 0xfffc | 0xfff6 == -0x2 (0xfffe) +__ulonglong 0xfffc | 0xfff6 == -0x2 (0xfffe) +int 0xfffc << 0x8 == -0x400 (0xfc00) +__uint 0xfffc << 0x8 == -0x400 (0xfc00) +char 0xfffc << 0x8 == 0x0 (0x0) +__uchar 0xfc << 0x8 == 0x0 (0x0) +__longlong 0xfffc << 0x8 == -0x400 (0xfc00) +__ulonglong 0xfffc << 0x8 == -0x400 (0xfc00) +int 0xfffc >> 0x8 == -0x1 (0xffff) +__uint 0xfffc >> 0x8 == 0xff (0xff) +char 0xfffc >> 0x8 == -0x1 (0xffff) +__uchar 0xfc >> 0x8 == 0x0 (0x0) +__longlong 0xfffc >> 0x8 == -0x1 (0xffff) +__ulonglong 0xfffc >> 0x8 == -0x1 (0xffff) +int 0xfffc + 0xfff6 == -0xe (0xfff2) +__uint 0xfffc + 0xfff6 == -0xe (0xfff2) +char 0xfffc + 0xfff6 == -0xe (0xfff2) +__uchar 0xfc + 0xf6 == 0xf2 (0xf2) +__longlong 0xfffc + 0xfff6 == -0xe (0xfff2) +__ulonglong 0xfffc + 0xfff6 == -0xe (0xfff2) +float 0xfffc + 0xfff6 == -0xe (0xfff2) +int 0xfffc - 0xfff6 == 0x6 (0x6) +__uint 0xfffc - 0xfff6 == 0x6 (0x6) +char 0xfffc - 0xfff6 == 0x6 (0x6) +__uchar 0xfc - 0xf6 == 0x6 (0x6) +__longlong 0xfffc - 0xfff6 == 0x6 (0x6) +__ulonglong 0xfffc - 0xfff6 == 0x6 (0x6) +float 0xfffc - 0xfff6 == 0x6 (0x6) +int 0xfffc * 0xfff6 == 0x28 (0x28) +__uint 0xfffc * 0xfff6 == 0x28 (0x28) +char 0xfffc * 0xfff6 == 0x28 (0x28) +__uchar 0xfc * 0xf6 == 0x28 (0x28) +__longlong 0xfffc * 0xfff6 == 0x28 (0x28) +__ulonglong 0xfffc * 0xfff6 == 0x28 (0x28) +float 0xfffc * 0xfff6 == 0x28 (0x28) +int 0xfffc < 0xfff6 == 0x0 (0x0) +__uint 0xfffc < 0xfff6 == 0x0 (0x0) +char 0xfffc < 0xfff6 == 0x0 (0x0) +__uchar 0xfc < 0xf6 == 0x0 (0x0) +__longlong 0xfffc < 0xfff6 == 0x0 (0x0) +__ulonglong 0xfffc < 0xfff6 == 0x0 (0x0) +float 0xfffc < 0xfff6 == 0x0 (0x0) +int 0xfffc > 0xfff6 == 0x1 (0x1) +__uint 0xfffc > 0xfff6 == 0x1 (0x1) +char 0xfffc > 0xfff6 == 0x1 (0x1) +__uchar 0xfc > 0xf6 == 0x1 (0x1) +__longlong 0xfffc > 0xfff6 == 0x1 (0x1) +__ulonglong 0xfffc > 0xfff6 == 0x1 (0x1) +float 0xfffc > 0xfff6 == 0x1 (0x1) +int 0xfffc <= 0xfff6 == 0x0 (0x0) +__uint 0xfffc <= 0xfff6 == 0x0 (0x0) +char 0xfffc <= 0xfff6 == 0x0 (0x0) +__uchar 0xfc <= 0xf6 == 0x0 (0x0) +__longlong 0xfffc <= 0xfff6 == 0x0 (0x0) +__ulonglong 0xfffc <= 0xfff6 == 0x0 (0x0) +float 0xfffc <= 0xfff6 == 0x0 (0x0) +int 0xfffc == 0xfff6 == 0x0 (0x0) +__uint 0xfffc == 0xfff6 == 0x0 (0x0) +char 0xfffc == 0xfff6 == 0x0 (0x0) +__uchar 0xfc == 0xf6 == 0x0 (0x0) +__longlong 0xfffc == 0xfff6 == 0x0 (0x0) +__ulonglong 0xfffc == 0xfff6 == 0x0 (0x0) +float 0xfffc == 0xfff6 == 0x0 (0x0) +int 0xfffc != 0xfff6 == 0x1 (0x1) +__uint 0xfffc != 0xfff6 == 0x1 (0x1) +char 0xfffc != 0xfff6 == 0x1 (0x1) +__uchar 0xfc != 0xf6 == 0x1 (0x1) +__longlong 0xfffc != 0xfff6 == 0x1 (0x1) +__ulonglong 0xfffc != 0xfff6 == 0x1 (0x1) +float 0xfffc != 0xfff6 == 0x1 (0x1) +int 0xfffc >= 0xfff6 == 0x1 (0x1) +__uint 0xfffc >= 0xfff6 == 0x1 (0x1) +char 0xfffc >= 0xfff6 == 0x1 (0x1) +__uchar 0xfc >= 0xf6 == 0x1 (0x1) +__longlong 0xfffc >= 0xfff6 == 0x1 (0x1) +__ulonglong 0xfffc >= 0xfff6 == 0x1 (0x1) +float 0xfffc >= 0xfff6 == 0x1 (0x1) +int 0xfffc / 0xfff6 == 0x0 (0x0) +__uint 0xfffc / 0xfff6 == 0x1 (0x1) +char 0xfffc / 0xfff6 == 0x0 (0x0) +__uchar 0xfc / 0xf6 == 0x1 (0x1) +__longlong 0xfffc / 0xfff6 == 0x0 (0x0) +__ulonglong 0xfffc / 0xfff6 == 0x1 (0x1) +float 0xfffc / 0xfff6 == 0x0 (0x0) +int 0xfffc % 0xfff6 == -0x4 (0xfffc) +__uint 0xfffc % 0xfff6 == 0x6 (0x6) +char 0xfffc % 0xfff6 == -0x4 (0xfffc) +__uchar 0xfc % 0xf6 == 0x6 (0x6) +__longlong 0xfffc % 0xfff6 == -0x4 (0xfffc) +__ulonglong 0xfffc % 0xfff6 == 0x6 (0x6) +0xfffc * 0x5 == -0x14 +0xfffc / 0x5 == 0x0 +0xfffc % 0x5 == -0x4 +int 0xfffc ^ 0x5 == -0x7 (0xfff9) +__uint 0xfffc ^ 0x5 == -0x7 (0xfff9) +char 0xfffc ^ 0x5 == -0x7 (0xfff9) +__uchar 0xfc ^ 0x5 == 0xf9 (0xf9) +__longlong 0xfffc ^ 0x5 == -0x7 (0xfff9) +__ulonglong 0xfffc ^ 0x5 == -0x7 (0xfff9) +int 0xfffc && 0x5 == 0x1 (0x1) +__uint 0xfffc && 0x5 == 0x1 (0x1) +char 0xfffc && 0x5 == 0x1 (0x1) +__uchar 0xfc && 0x5 == 0x1 (0x1) +__longlong 0xfffc && 0x5 == 0x1 (0x1) +__ulonglong 0xfffc && 0x5 == 0x1 (0x1) +int 0xfffc || 0x5 == 0x1 (0x1) +__uint 0xfffc || 0x5 == 0x1 (0x1) +char 0xfffc || 0x5 == 0x1 (0x1) +__uchar 0xfc || 0x5 == 0x1 (0x1) +__longlong 0xfffc || 0x5 == 0x1 (0x1) +__ulonglong 0xfffc || 0x5 == 0x1 (0x1) +int 0xfffc & 0x5 == 0x4 (0x4) +__uint 0xfffc & 0x5 == 0x4 (0x4) +char 0xfffc & 0x5 == 0x4 (0x4) +__uchar 0xfc & 0x5 == 0x4 (0x4) +__longlong 0xfffc & 0x5 == 0x4 (0x4) +__ulonglong 0xfffc & 0x5 == 0x4 (0x4) +int 0xfffc | 0x5 == -0x3 (0xfffd) +__uint 0xfffc | 0x5 == -0x3 (0xfffd) +char 0xfffc | 0x5 == -0x3 (0xfffd) +__uchar 0xfc | 0x5 == 0xfd (0xfd) +__longlong 0xfffc | 0x5 == -0x3 (0xfffd) +__ulonglong 0xfffc | 0x5 == -0x3 (0xfffd) +int 0xfffc << 0x9 == -0x800 (0xf800) +__uint 0xfffc << 0x9 == -0x800 (0xf800) +char 0xfffc << 0x9 == 0x0 (0x0) +__uchar 0xfc << 0x9 == 0x0 (0x0) +__longlong 0xfffc << 0x9 == -0x800 (0xf800) +__ulonglong 0xfffc << 0x9 == -0x800 (0xf800) +int 0xfffc >> 0x9 == -0x1 (0xffff) +__uint 0xfffc >> 0x9 == 0x7f (0x7f) +char 0xfffc >> 0x9 == -0x1 (0xffff) +__uchar 0xfc >> 0x9 == 0x0 (0x0) +__longlong 0xfffc >> 0x9 == -0x1 (0xffff) +__ulonglong 0xfffc >> 0x9 == -0x1 (0xffff) +int 0xfffc + 0x5 == 0x1 (0x1) +__uint 0xfffc + 0x5 == 0x1 (0x1) +char 0xfffc + 0x5 == 0x1 (0x1) +__uchar 0xfc + 0x5 == 0x1 (0x1) +__longlong 0xfffc + 0x5 == 0x1 (0x1) +__ulonglong 0xfffc + 0x5 == 0x1 (0x1) +float 0xfffc + 0x5 == 0x1 (0x1) +int 0xfffc - 0x5 == -0x9 (0xfff7) +__uint 0xfffc - 0x5 == -0x9 (0xfff7) +char 0xfffc - 0x5 == -0x9 (0xfff7) +__uchar 0xfc - 0x5 == 0xf7 (0xf7) +__longlong 0xfffc - 0x5 == -0x9 (0xfff7) +__ulonglong 0xfffc - 0x5 == -0x9 (0xfff7) +float 0xfffc - 0x5 == -0x9 (0xfff7) +int 0xfffc * 0x5 == -0x14 (0xffec) +__uint 0xfffc * 0x5 == -0x14 (0xffec) +char 0xfffc * 0x5 == -0x14 (0xffec) +__uchar 0xfc * 0x5 == 0xec (0xec) +__longlong 0xfffc * 0x5 == -0x14 (0xffec) +__ulonglong 0xfffc * 0x5 == -0x14 (0xffec) +float 0xfffc * 0x5 == -0x14 (0xffec) +int 0xfffc < 0x5 == 0x1 (0x1) +__uint 0xfffc < 0x5 == 0x0 (0x0) +char 0xfffc < 0x5 == 0x1 (0x1) +__uchar 0xfc < 0x5 == 0x0 (0x0) +__longlong 0xfffc < 0x5 == 0x1 (0x1) +__ulonglong 0xfffc < 0x5 == 0x0 (0x0) +float 0xfffc < 0x5 == 0x1 (0x1) +int 0xfffc > 0x5 == 0x0 (0x0) +__uint 0xfffc > 0x5 == 0x1 (0x1) +char 0xfffc > 0x5 == 0x0 (0x0) +__uchar 0xfc > 0x5 == 0x1 (0x1) +__longlong 0xfffc > 0x5 == 0x0 (0x0) +__ulonglong 0xfffc > 0x5 == 0x1 (0x1) +float 0xfffc > 0x5 == 0x0 (0x0) +int 0xfffc <= 0x5 == 0x1 (0x1) +__uint 0xfffc <= 0x5 == 0x0 (0x0) +char 0xfffc <= 0x5 == 0x1 (0x1) +__uchar 0xfc <= 0x5 == 0x0 (0x0) +__longlong 0xfffc <= 0x5 == 0x1 (0x1) +__ulonglong 0xfffc <= 0x5 == 0x0 (0x0) +float 0xfffc <= 0x5 == 0x1 (0x1) +int 0xfffc == 0x5 == 0x0 (0x0) +__uint 0xfffc == 0x5 == 0x0 (0x0) +char 0xfffc == 0x5 == 0x0 (0x0) +__uchar 0xfc == 0x5 == 0x0 (0x0) +__longlong 0xfffc == 0x5 == 0x0 (0x0) +__ulonglong 0xfffc == 0x5 == 0x0 (0x0) +float 0xfffc == 0x5 == 0x0 (0x0) +int 0xfffc != 0x5 == 0x1 (0x1) +__uint 0xfffc != 0x5 == 0x1 (0x1) +char 0xfffc != 0x5 == 0x1 (0x1) +__uchar 0xfc != 0x5 == 0x1 (0x1) +__longlong 0xfffc != 0x5 == 0x1 (0x1) +__ulonglong 0xfffc != 0x5 == 0x1 (0x1) +float 0xfffc != 0x5 == 0x1 (0x1) +int 0xfffc >= 0x5 == 0x0 (0x0) +__uint 0xfffc >= 0x5 == 0x1 (0x1) +char 0xfffc >= 0x5 == 0x0 (0x0) +__uchar 0xfc >= 0x5 == 0x1 (0x1) +__longlong 0xfffc >= 0x5 == 0x0 (0x0) +__ulonglong 0xfffc >= 0x5 == 0x1 (0x1) +float 0xfffc >= 0x5 == 0x0 (0x0) +int 0xfffc / 0x5 == 0x0 (0x0) +__uint 0xfffc / 0x5 == 0x3332 (0x3332) +char 0xfffc / 0x5 == 0x0 (0x0) +__uchar 0xfc / 0x5 == 0x32 (0x32) +__longlong 0xfffc / 0x5 == 0x0 (0x0) +__ulonglong 0xfffc / 0x5 == 0x3332 (0x3332) +float 0xfffc / 0x5 == 0x0 (0x0) +int 0xfffc % 0x5 == -0x4 (0xfffc) +__uint 0xfffc % 0x5 == 0x2 (0x2) +char 0xfffc % 0x5 == -0x4 (0xfffc) +__uchar 0xfc % 0x5 == 0x2 (0x2) +__longlong 0xfffc % 0x5 == -0x4 (0xfffc) +__ulonglong 0xfffc % 0x5 == 0x2 (0x2) +0xfffc * 0x7 == -0x1c +0xfffc / 0x7 == 0x0 +0xfffc % 0x7 == -0x4 +int 0xfffc ^ 0x7 == -0x5 (0xfffb) +__uint 0xfffc ^ 0x7 == -0x5 (0xfffb) +char 0xfffc ^ 0x7 == -0x5 (0xfffb) +__uchar 0xfc ^ 0x7 == 0xfb (0xfb) +__longlong 0xfffc ^ 0x7 == -0x5 (0xfffb) +__ulonglong 0xfffc ^ 0x7 == -0x5 (0xfffb) +int 0xfffc && 0x7 == 0x1 (0x1) +__uint 0xfffc && 0x7 == 0x1 (0x1) +char 0xfffc && 0x7 == 0x1 (0x1) +__uchar 0xfc && 0x7 == 0x1 (0x1) +__longlong 0xfffc && 0x7 == 0x1 (0x1) +__ulonglong 0xfffc && 0x7 == 0x1 (0x1) +int 0xfffc || 0x7 == 0x1 (0x1) +__uint 0xfffc || 0x7 == 0x1 (0x1) +char 0xfffc || 0x7 == 0x1 (0x1) +__uchar 0xfc || 0x7 == 0x1 (0x1) +__longlong 0xfffc || 0x7 == 0x1 (0x1) +__ulonglong 0xfffc || 0x7 == 0x1 (0x1) +int 0xfffc & 0x7 == 0x4 (0x4) +__uint 0xfffc & 0x7 == 0x4 (0x4) +char 0xfffc & 0x7 == 0x4 (0x4) +__uchar 0xfc & 0x7 == 0x4 (0x4) +__longlong 0xfffc & 0x7 == 0x4 (0x4) +__ulonglong 0xfffc & 0x7 == 0x4 (0x4) +int 0xfffc | 0x7 == -0x1 (0xffff) +__uint 0xfffc | 0x7 == -0x1 (0xffff) +char 0xfffc | 0x7 == -0x1 (0xffff) +__uchar 0xfc | 0x7 == 0xff (0xff) +__longlong 0xfffc | 0x7 == -0x1 (0xffff) +__ulonglong 0xfffc | 0x7 == -0x1 (0xffff) +int 0xfffc << 0xa == -0x1000 (0xf000) +__uint 0xfffc << 0xa == -0x1000 (0xf000) +char 0xfffc << 0xa == 0x0 (0x0) +__uchar 0xfc << 0xa == 0x0 (0x0) +__longlong 0xfffc << 0xa == -0x1000 (0xf000) +__ulonglong 0xfffc << 0xa == -0x1000 (0xf000) +int 0xfffc >> 0xa == -0x1 (0xffff) +__uint 0xfffc >> 0xa == 0x3f (0x3f) +char 0xfffc >> 0xa == -0x1 (0xffff) +__uchar 0xfc >> 0xa == 0x0 (0x0) +__longlong 0xfffc >> 0xa == -0x1 (0xffff) +__ulonglong 0xfffc >> 0xa == -0x1 (0xffff) +int 0xfffc + 0x7 == 0x3 (0x3) +__uint 0xfffc + 0x7 == 0x3 (0x3) +char 0xfffc + 0x7 == 0x3 (0x3) +__uchar 0xfc + 0x7 == 0x3 (0x3) +__longlong 0xfffc + 0x7 == 0x3 (0x3) +__ulonglong 0xfffc + 0x7 == 0x3 (0x3) +float 0xfffc + 0x7 == 0x3 (0x3) +int 0xfffc - 0x7 == -0xb (0xfff5) +__uint 0xfffc - 0x7 == -0xb (0xfff5) +char 0xfffc - 0x7 == -0xb (0xfff5) +__uchar 0xfc - 0x7 == 0xf5 (0xf5) +__longlong 0xfffc - 0x7 == -0xb (0xfff5) +__ulonglong 0xfffc - 0x7 == -0xb (0xfff5) +float 0xfffc - 0x7 == -0xb (0xfff5) +int 0xfffc * 0x7 == -0x1c (0xffe4) +__uint 0xfffc * 0x7 == -0x1c (0xffe4) +char 0xfffc * 0x7 == -0x1c (0xffe4) +__uchar 0xfc * 0x7 == 0xe4 (0xe4) +__longlong 0xfffc * 0x7 == -0x1c (0xffe4) +__ulonglong 0xfffc * 0x7 == -0x1c (0xffe4) +float 0xfffc * 0x7 == -0x1c (0xffe4) +int 0xfffc < 0x7 == 0x1 (0x1) +__uint 0xfffc < 0x7 == 0x0 (0x0) +char 0xfffc < 0x7 == 0x1 (0x1) +__uchar 0xfc < 0x7 == 0x0 (0x0) +__longlong 0xfffc < 0x7 == 0x1 (0x1) +__ulonglong 0xfffc < 0x7 == 0x0 (0x0) +float 0xfffc < 0x7 == 0x1 (0x1) +int 0xfffc > 0x7 == 0x0 (0x0) +__uint 0xfffc > 0x7 == 0x1 (0x1) +char 0xfffc > 0x7 == 0x0 (0x0) +__uchar 0xfc > 0x7 == 0x1 (0x1) +__longlong 0xfffc > 0x7 == 0x0 (0x0) +__ulonglong 0xfffc > 0x7 == 0x1 (0x1) +float 0xfffc > 0x7 == 0x0 (0x0) +int 0xfffc <= 0x7 == 0x1 (0x1) +__uint 0xfffc <= 0x7 == 0x0 (0x0) +char 0xfffc <= 0x7 == 0x1 (0x1) +__uchar 0xfc <= 0x7 == 0x0 (0x0) +__longlong 0xfffc <= 0x7 == 0x1 (0x1) +__ulonglong 0xfffc <= 0x7 == 0x0 (0x0) +float 0xfffc <= 0x7 == 0x1 (0x1) +int 0xfffc == 0x7 == 0x0 (0x0) +__uint 0xfffc == 0x7 == 0x0 (0x0) +char 0xfffc == 0x7 == 0x0 (0x0) +__uchar 0xfc == 0x7 == 0x0 (0x0) +__longlong 0xfffc == 0x7 == 0x0 (0x0) +__ulonglong 0xfffc == 0x7 == 0x0 (0x0) +float 0xfffc == 0x7 == 0x0 (0x0) +int 0xfffc != 0x7 == 0x1 (0x1) +__uint 0xfffc != 0x7 == 0x1 (0x1) +char 0xfffc != 0x7 == 0x1 (0x1) +__uchar 0xfc != 0x7 == 0x1 (0x1) +__longlong 0xfffc != 0x7 == 0x1 (0x1) +__ulonglong 0xfffc != 0x7 == 0x1 (0x1) +float 0xfffc != 0x7 == 0x1 (0x1) +int 0xfffc >= 0x7 == 0x0 (0x0) +__uint 0xfffc >= 0x7 == 0x1 (0x1) +char 0xfffc >= 0x7 == 0x0 (0x0) +__uchar 0xfc >= 0x7 == 0x1 (0x1) +__longlong 0xfffc >= 0x7 == 0x0 (0x0) +__ulonglong 0xfffc >= 0x7 == 0x1 (0x1) +float 0xfffc >= 0x7 == 0x0 (0x0) +int 0xfffc / 0x7 == 0x0 (0x0) +__uint 0xfffc / 0x7 == 0x2491 (0x2491) +char 0xfffc / 0x7 == 0x0 (0x0) +__uchar 0xfc / 0x7 == 0x24 (0x24) +__longlong 0xfffc / 0x7 == 0x0 (0x0) +__ulonglong 0xfffc / 0x7 == 0x4924 (0x4924) +float 0xfffc / 0x7 == 0x0 (0x0) +int 0xfffc % 0x7 == -0x4 (0xfffc) +__uint 0xfffc % 0x7 == 0x5 (0x5) +char 0xfffc % 0x7 == -0x4 (0xfffc) +__uchar 0xfc % 0x7 == 0x0 (0x0) +__longlong 0xfffc % 0x7 == -0x4 (0xfffc) +__ulonglong 0xfffc % 0x7 == 0x0 (0x0) +0xfffc * 0x2a == -0xa8 +0xfffc / 0x2a == 0x0 +0xfffc % 0x2a == -0x4 +int 0xfffc ^ 0x2a == -0x2a (0xffd6) +__uint 0xfffc ^ 0x2a == -0x2a (0xffd6) +char 0xfffc ^ 0x2a == -0x2a (0xffd6) +__uchar 0xfc ^ 0x2a == 0xd6 (0xd6) +__longlong 0xfffc ^ 0x2a == -0x2a (0xffd6) +__ulonglong 0xfffc ^ 0x2a == -0x2a (0xffd6) +int 0xfffc && 0x2a == 0x1 (0x1) +__uint 0xfffc && 0x2a == 0x1 (0x1) +char 0xfffc && 0x2a == 0x1 (0x1) +__uchar 0xfc && 0x2a == 0x1 (0x1) +__longlong 0xfffc && 0x2a == 0x1 (0x1) +__ulonglong 0xfffc && 0x2a == 0x1 (0x1) +int 0xfffc || 0x2a == 0x1 (0x1) +__uint 0xfffc || 0x2a == 0x1 (0x1) +char 0xfffc || 0x2a == 0x1 (0x1) +__uchar 0xfc || 0x2a == 0x1 (0x1) +__longlong 0xfffc || 0x2a == 0x1 (0x1) +__ulonglong 0xfffc || 0x2a == 0x1 (0x1) +int 0xfffc & 0x2a == 0x28 (0x28) +__uint 0xfffc & 0x2a == 0x28 (0x28) +char 0xfffc & 0x2a == 0x28 (0x28) +__uchar 0xfc & 0x2a == 0x28 (0x28) +__longlong 0xfffc & 0x2a == 0x28 (0x28) +__ulonglong 0xfffc & 0x2a == 0x28 (0x28) +int 0xfffc | 0x2a == -0x2 (0xfffe) +__uint 0xfffc | 0x2a == -0x2 (0xfffe) +char 0xfffc | 0x2a == -0x2 (0xfffe) +__uchar 0xfc | 0x2a == 0xfe (0xfe) +__longlong 0xfffc | 0x2a == -0x2 (0xfffe) +__ulonglong 0xfffc | 0x2a == -0x2 (0xfffe) +int 0xfffc << 0xc == -0x4000 (0xc000) +__uint 0xfffc << 0xc == -0x4000 (0xc000) +char 0xfffc << 0xc == 0x0 (0x0) +__uchar 0xfc << 0xc == 0x0 (0x0) +__longlong 0xfffc << 0xc == -0x4000 (0xc000) +__ulonglong 0xfffc << 0xc == -0x4000 (0xc000) +int 0xfffc >> 0xc == -0x1 (0xffff) +__uint 0xfffc >> 0xc == 0xf (0xf) +char 0xfffc >> 0xc == -0x1 (0xffff) +__uchar 0xfc >> 0xc == 0x0 (0x0) +__longlong 0xfffc >> 0xc == -0x1 (0xffff) +__ulonglong 0xfffc >> 0xc == -0x1 (0xffff) +int 0xfffc + 0x2a == 0x26 (0x26) +__uint 0xfffc + 0x2a == 0x26 (0x26) +char 0xfffc + 0x2a == 0x26 (0x26) +__uchar 0xfc + 0x2a == 0x26 (0x26) +__longlong 0xfffc + 0x2a == 0x26 (0x26) +__ulonglong 0xfffc + 0x2a == 0x26 (0x26) +float 0xfffc + 0x2a == 0x26 (0x26) +int 0xfffc - 0x2a == -0x2e (0xffd2) +__uint 0xfffc - 0x2a == -0x2e (0xffd2) +char 0xfffc - 0x2a == -0x2e (0xffd2) +__uchar 0xfc - 0x2a == 0xd2 (0xd2) +__longlong 0xfffc - 0x2a == -0x2e (0xffd2) +__ulonglong 0xfffc - 0x2a == -0x2e (0xffd2) +float 0xfffc - 0x2a == -0x2e (0xffd2) +int 0xfffc * 0x2a == -0xa8 (0xff58) +__uint 0xfffc * 0x2a == -0xa8 (0xff58) +char 0xfffc * 0x2a == 0x58 (0x58) +__uchar 0xfc * 0x2a == 0x58 (0x58) +__longlong 0xfffc * 0x2a == -0xa8 (0xff58) +__ulonglong 0xfffc * 0x2a == -0xa8 (0xff58) +float 0xfffc * 0x2a == -0xa8 (0xff58) +int 0xfffc < 0x2a == 0x1 (0x1) +__uint 0xfffc < 0x2a == 0x0 (0x0) +char 0xfffc < 0x2a == 0x1 (0x1) +__uchar 0xfc < 0x2a == 0x0 (0x0) +__longlong 0xfffc < 0x2a == 0x1 (0x1) +__ulonglong 0xfffc < 0x2a == 0x0 (0x0) +float 0xfffc < 0x2a == 0x1 (0x1) +int 0xfffc > 0x2a == 0x0 (0x0) +__uint 0xfffc > 0x2a == 0x1 (0x1) +char 0xfffc > 0x2a == 0x0 (0x0) +__uchar 0xfc > 0x2a == 0x1 (0x1) +__longlong 0xfffc > 0x2a == 0x0 (0x0) +__ulonglong 0xfffc > 0x2a == 0x1 (0x1) +float 0xfffc > 0x2a == 0x0 (0x0) +int 0xfffc <= 0x2a == 0x1 (0x1) +__uint 0xfffc <= 0x2a == 0x0 (0x0) +char 0xfffc <= 0x2a == 0x1 (0x1) +__uchar 0xfc <= 0x2a == 0x0 (0x0) +__longlong 0xfffc <= 0x2a == 0x1 (0x1) +__ulonglong 0xfffc <= 0x2a == 0x0 (0x0) +float 0xfffc <= 0x2a == 0x1 (0x1) +int 0xfffc == 0x2a == 0x0 (0x0) +__uint 0xfffc == 0x2a == 0x0 (0x0) +char 0xfffc == 0x2a == 0x0 (0x0) +__uchar 0xfc == 0x2a == 0x0 (0x0) +__longlong 0xfffc == 0x2a == 0x0 (0x0) +__ulonglong 0xfffc == 0x2a == 0x0 (0x0) +float 0xfffc == 0x2a == 0x0 (0x0) +int 0xfffc != 0x2a == 0x1 (0x1) +__uint 0xfffc != 0x2a == 0x1 (0x1) +char 0xfffc != 0x2a == 0x1 (0x1) +__uchar 0xfc != 0x2a == 0x1 (0x1) +__longlong 0xfffc != 0x2a == 0x1 (0x1) +__ulonglong 0xfffc != 0x2a == 0x1 (0x1) +float 0xfffc != 0x2a == 0x1 (0x1) +int 0xfffc >= 0x2a == 0x0 (0x0) +__uint 0xfffc >= 0x2a == 0x1 (0x1) +char 0xfffc >= 0x2a == 0x0 (0x0) +__uchar 0xfc >= 0x2a == 0x1 (0x1) +__longlong 0xfffc >= 0x2a == 0x0 (0x0) +__ulonglong 0xfffc >= 0x2a == 0x1 (0x1) +float 0xfffc >= 0x2a == 0x0 (0x0) +int 0xfffc / 0x2a == 0x0 (0x0) +__uint 0xfffc / 0x2a == 0x618 (0x618) +char 0xfffc / 0x2a == 0x0 (0x0) +__uchar 0xfc / 0x2a == 0x6 (0x6) +__longlong 0xfffc / 0x2a == 0x0 (0x0) +__ulonglong 0xfffc / 0x2a == 0x6186 (0x6186) +float 0xfffc / 0x2a == 0x0 (0x0) +int 0xfffc % 0x2a == -0x4 (0xfffc) +__uint 0xfffc % 0x2a == 0xc (0xc) +char 0xfffc % 0x2a == -0x4 (0xfffc) +__uchar 0xfc % 0x2a == 0x0 (0x0) +__longlong 0xfffc % 0x2a == -0x4 (0xfffc) +__ulonglong 0xfffc % 0x2a == 0x0 (0x0) +0xfffc * 0x17 == -0x5c +0xfffc / 0x17 == 0x0 +0xfffc % 0x17 == -0x4 +int 0xfffc ^ 0x17 == -0x15 (0xffeb) +__uint 0xfffc ^ 0x17 == -0x15 (0xffeb) +char 0xfffc ^ 0x17 == -0x15 (0xffeb) +__uchar 0xfc ^ 0x17 == 0xeb (0xeb) +__longlong 0xfffc ^ 0x17 == -0x15 (0xffeb) +__ulonglong 0xfffc ^ 0x17 == -0x15 (0xffeb) +int 0xfffc && 0x17 == 0x1 (0x1) +__uint 0xfffc && 0x17 == 0x1 (0x1) +char 0xfffc && 0x17 == 0x1 (0x1) +__uchar 0xfc && 0x17 == 0x1 (0x1) +__longlong 0xfffc && 0x17 == 0x1 (0x1) +__ulonglong 0xfffc && 0x17 == 0x1 (0x1) +int 0xfffc || 0x17 == 0x1 (0x1) +__uint 0xfffc || 0x17 == 0x1 (0x1) +char 0xfffc || 0x17 == 0x1 (0x1) +__uchar 0xfc || 0x17 == 0x1 (0x1) +__longlong 0xfffc || 0x17 == 0x1 (0x1) +__ulonglong 0xfffc || 0x17 == 0x1 (0x1) +int 0xfffc & 0x17 == 0x14 (0x14) +__uint 0xfffc & 0x17 == 0x14 (0x14) +char 0xfffc & 0x17 == 0x14 (0x14) +__uchar 0xfc & 0x17 == 0x14 (0x14) +__longlong 0xfffc & 0x17 == 0x14 (0x14) +__ulonglong 0xfffc & 0x17 == 0x14 (0x14) +int 0xfffc | 0x17 == -0x1 (0xffff) +__uint 0xfffc | 0x17 == -0x1 (0xffff) +char 0xfffc | 0x17 == -0x1 (0xffff) +__uchar 0xfc | 0x17 == 0xff (0xff) +__longlong 0xfffc | 0x17 == -0x1 (0xffff) +__ulonglong 0xfffc | 0x17 == -0x1 (0xffff) +int 0xfffc << 0xe == 0x0 (0x0) +__uint 0xfffc << 0xe == 0x0 (0x0) +char 0xfffc << 0xe == 0x0 (0x0) +__uchar 0xfc << 0xe == 0x0 (0x0) +__longlong 0xfffc << 0xe == 0x0 (0x0) +__ulonglong 0xfffc << 0xe == 0x0 (0x0) +int 0xfffc >> 0xe == -0x1 (0xffff) +__uint 0xfffc >> 0xe == 0x3 (0x3) +char 0xfffc >> 0xe == -0x1 (0xffff) +__uchar 0xfc >> 0xe == 0x0 (0x0) +__longlong 0xfffc >> 0xe == -0x1 (0xffff) +__ulonglong 0xfffc >> 0xe == -0x1 (0xffff) +int 0xfffc + 0x17 == 0x13 (0x13) +__uint 0xfffc + 0x17 == 0x13 (0x13) +char 0xfffc + 0x17 == 0x13 (0x13) +__uchar 0xfc + 0x17 == 0x13 (0x13) +__longlong 0xfffc + 0x17 == 0x13 (0x13) +__ulonglong 0xfffc + 0x17 == 0x13 (0x13) +float 0xfffc + 0x17 == 0x13 (0x13) +int 0xfffc - 0x17 == -0x1b (0xffe5) +__uint 0xfffc - 0x17 == -0x1b (0xffe5) +char 0xfffc - 0x17 == -0x1b (0xffe5) +__uchar 0xfc - 0x17 == 0xe5 (0xe5) +__longlong 0xfffc - 0x17 == -0x1b (0xffe5) +__ulonglong 0xfffc - 0x17 == -0x1b (0xffe5) +float 0xfffc - 0x17 == -0x1b (0xffe5) +int 0xfffc * 0x17 == -0x5c (0xffa4) +__uint 0xfffc * 0x17 == -0x5c (0xffa4) +char 0xfffc * 0x17 == -0x5c (0xffa4) +__uchar 0xfc * 0x17 == 0xa4 (0xa4) +__longlong 0xfffc * 0x17 == -0x5c (0xffa4) +__ulonglong 0xfffc * 0x17 == -0x5c (0xffa4) +float 0xfffc * 0x17 == -0x5c (0xffa4) +int 0xfffc < 0x17 == 0x1 (0x1) +__uint 0xfffc < 0x17 == 0x0 (0x0) +char 0xfffc < 0x17 == 0x1 (0x1) +__uchar 0xfc < 0x17 == 0x0 (0x0) +__longlong 0xfffc < 0x17 == 0x1 (0x1) +__ulonglong 0xfffc < 0x17 == 0x0 (0x0) +float 0xfffc < 0x17 == 0x1 (0x1) +int 0xfffc > 0x17 == 0x0 (0x0) +__uint 0xfffc > 0x17 == 0x1 (0x1) +char 0xfffc > 0x17 == 0x0 (0x0) +__uchar 0xfc > 0x17 == 0x1 (0x1) +__longlong 0xfffc > 0x17 == 0x0 (0x0) +__ulonglong 0xfffc > 0x17 == 0x1 (0x1) +float 0xfffc > 0x17 == 0x0 (0x0) +int 0xfffc <= 0x17 == 0x1 (0x1) +__uint 0xfffc <= 0x17 == 0x0 (0x0) +char 0xfffc <= 0x17 == 0x1 (0x1) +__uchar 0xfc <= 0x17 == 0x0 (0x0) +__longlong 0xfffc <= 0x17 == 0x1 (0x1) +__ulonglong 0xfffc <= 0x17 == 0x0 (0x0) +float 0xfffc <= 0x17 == 0x1 (0x1) +int 0xfffc == 0x17 == 0x0 (0x0) +__uint 0xfffc == 0x17 == 0x0 (0x0) +char 0xfffc == 0x17 == 0x0 (0x0) +__uchar 0xfc == 0x17 == 0x0 (0x0) +__longlong 0xfffc == 0x17 == 0x0 (0x0) +__ulonglong 0xfffc == 0x17 == 0x0 (0x0) +float 0xfffc == 0x17 == 0x0 (0x0) +int 0xfffc != 0x17 == 0x1 (0x1) +__uint 0xfffc != 0x17 == 0x1 (0x1) +char 0xfffc != 0x17 == 0x1 (0x1) +__uchar 0xfc != 0x17 == 0x1 (0x1) +__longlong 0xfffc != 0x17 == 0x1 (0x1) +__ulonglong 0xfffc != 0x17 == 0x1 (0x1) +float 0xfffc != 0x17 == 0x1 (0x1) +int 0xfffc >= 0x17 == 0x0 (0x0) +__uint 0xfffc >= 0x17 == 0x1 (0x1) +char 0xfffc >= 0x17 == 0x0 (0x0) +__uchar 0xfc >= 0x17 == 0x1 (0x1) +__longlong 0xfffc >= 0x17 == 0x0 (0x0) +__ulonglong 0xfffc >= 0x17 == 0x1 (0x1) +float 0xfffc >= 0x17 == 0x0 (0x0) +int 0xfffc / 0x17 == 0x0 (0x0) +__uint 0xfffc / 0x17 == 0xb21 (0xb21) +char 0xfffc / 0x17 == 0x0 (0x0) +__uchar 0xfc / 0x17 == 0xa (0xa) +__longlong 0xfffc / 0x17 == 0x0 (0x0) +__ulonglong 0xfffc / 0x17 == 0x642c (0x642c) +float 0xfffc / 0x17 == 0x0 (0x0) +int 0xfffc % 0x17 == -0x4 (0xfffc) +__uint 0xfffc % 0x17 == 0x5 (0x5) +char 0xfffc % 0x17 == -0x4 (0xfffc) +__uchar 0xfc % 0x17 == 0x16 (0x16) +__longlong 0xfffc % 0x17 == -0x4 (0xfffc) +__ulonglong 0xfffc % 0x17 == 0x8 (0x8) +0xfffc * 0x7fff == 0x4 +0xfffc / 0x7fff == 0x0 +0xfffc % 0x7fff == -0x4 +int 0xfffc ^ 0x7fff == -0x7ffd (0x8003) +__uint 0xfffc ^ 0x7fff == -0x7ffd (0x8003) +char 0xfffc ^ 0xffff == 0x3 (0x3) +__uchar 0xfc ^ 0xff == 0x3 (0x3) +__longlong 0xfffc ^ 0x7fff == -0x7ffd (0x8003) +__ulonglong 0xfffc ^ 0x7fff == -0x7ffd (0x8003) +int 0xfffc && 0x7fff == 0x1 (0x1) +__uint 0xfffc && 0x7fff == 0x1 (0x1) +char 0xfffc && 0xffff == 0x1 (0x1) +__uchar 0xfc && 0xff == 0x1 (0x1) +__longlong 0xfffc && 0x7fff == 0x1 (0x1) +__ulonglong 0xfffc && 0x7fff == 0x1 (0x1) +int 0xfffc || 0x7fff == 0x1 (0x1) +__uint 0xfffc || 0x7fff == 0x1 (0x1) +char 0xfffc || 0xffff == 0x1 (0x1) +__uchar 0xfc || 0xff == 0x1 (0x1) +__longlong 0xfffc || 0x7fff == 0x1 (0x1) +__ulonglong 0xfffc || 0x7fff == 0x1 (0x1) +int 0xfffc & 0x7fff == 0x7ffc (0x7ffc) +__uint 0xfffc & 0x7fff == 0x7ffc (0x7ffc) +char 0xfffc & 0xffff == -0x4 (0xfffc) +__uchar 0xfc & 0xff == 0xfc (0xfc) +__longlong 0xfffc & 0x7fff == 0x7ffc (0x7ffc) +__ulonglong 0xfffc & 0x7fff == 0x7ffc (0x7ffc) +int 0xfffc | 0x7fff == -0x1 (0xffff) +__uint 0xfffc | 0x7fff == -0x1 (0xffff) +char 0xfffc | 0xffff == -0x1 (0xffff) +__uchar 0xfc | 0xff == 0xff (0xff) +__longlong 0xfffc | 0x7fff == -0x1 (0xffff) +__ulonglong 0xfffc | 0x7fff == -0x1 (0xffff) +int 0xfffc << 0x10 == 0x0 (0x0) +__uint 0xfffc << 0x10 == 0x0 (0x0) +char 0xfffc << 0x10 == 0x0 (0x0) +__uchar 0xfc << 0x10 == 0x0 (0x0) +__longlong 0xfffc << 0x10 == 0x0 (0x0) +__ulonglong 0xfffc << 0x10 == 0x0 (0x0) +int 0xfffc >> 0x10 == -0x1 (0xffff) +__uint 0xfffc >> 0x10 == 0x0 (0x0) +char 0xfffc >> 0x10 == -0x1 (0xffff) +__uchar 0xfc >> 0x10 == 0x0 (0x0) +__longlong 0xfffc >> 0x10 == -0x1 (0xffff) +__ulonglong 0xfffc >> 0x10 == -0x1 (0xffff) +int 0xfffc + 0x7fff == 0x7ffb (0x7ffb) +__uint 0xfffc + 0x7fff == 0x7ffb (0x7ffb) +char 0xfffc + 0xffff == -0x5 (0xfffb) +__uchar 0xfc + 0xff == 0xfb (0xfb) +__longlong 0xfffc + 0x7fff == 0x7ffb (0x7ffb) +__ulonglong 0xfffc + 0x7fff == 0x7ffb (0x7ffb) +float 0xfffc + 0x7fff == 0x7ffb (0x7ffb) +int 0xfffc - 0x7fff == 0x7ffd (0x7ffd) +__uint 0xfffc - 0x7fff == 0x7ffd (0x7ffd) +char 0xfffc - 0xffff == -0x3 (0xfffd) +__uchar 0xfc - 0xff == 0xfd (0xfd) +__longlong 0xfffc - 0x7fff == 0x7ffd (0x7ffd) +__ulonglong 0xfffc - 0x7fff == 0x7ffd (0x7ffd) +float 0xfffc - 0x7fff == -0x8000 (0x8000) +int 0xfffc * 0x7fff == 0x4 (0x4) +__uint 0xfffc * 0x7fff == 0x4 (0x4) +char 0xfffc * 0xffff == 0x4 (0x4) +__uchar 0xfc * 0xff == 0x4 (0x4) +__longlong 0xfffc * 0x7fff == 0x4 (0x4) +__ulonglong 0xfffc * 0x7fff == 0x4 (0x4) +float 0xfffc * 0x7fff == -0x8000 (0x8000) +int 0xfffc < 0x7fff == 0x1 (0x1) +__uint 0xfffc < 0x7fff == 0x0 (0x0) +char 0xfffc < 0xffff == 0x1 (0x1) +__uchar 0xfc < 0xff == 0x1 (0x1) +__longlong 0xfffc < 0x7fff == 0x1 (0x1) +__ulonglong 0xfffc < 0x7fff == 0x0 (0x0) +float 0xfffc < 0x7fff == 0x1 (0x1) +int 0xfffc > 0x7fff == 0x0 (0x0) +__uint 0xfffc > 0x7fff == 0x1 (0x1) +char 0xfffc > 0xffff == 0x0 (0x0) +__uchar 0xfc > 0xff == 0x0 (0x0) +__longlong 0xfffc > 0x7fff == 0x0 (0x0) +__ulonglong 0xfffc > 0x7fff == 0x1 (0x1) +float 0xfffc > 0x7fff == 0x0 (0x0) +int 0xfffc <= 0x7fff == 0x1 (0x1) +__uint 0xfffc <= 0x7fff == 0x0 (0x0) +char 0xfffc <= 0xffff == 0x1 (0x1) +__uchar 0xfc <= 0xff == 0x1 (0x1) +__longlong 0xfffc <= 0x7fff == 0x1 (0x1) +__ulonglong 0xfffc <= 0x7fff == 0x0 (0x0) +float 0xfffc <= 0x7fff == 0x1 (0x1) +int 0xfffc == 0x7fff == 0x0 (0x0) +__uint 0xfffc == 0x7fff == 0x0 (0x0) +char 0xfffc == 0xffff == 0x0 (0x0) +__uchar 0xfc == 0xff == 0x0 (0x0) +__longlong 0xfffc == 0x7fff == 0x0 (0x0) +__ulonglong 0xfffc == 0x7fff == 0x0 (0x0) +float 0xfffc == 0x7fff == 0x0 (0x0) +int 0xfffc != 0x7fff == 0x1 (0x1) +__uint 0xfffc != 0x7fff == 0x1 (0x1) +char 0xfffc != 0xffff == 0x1 (0x1) +__uchar 0xfc != 0xff == 0x1 (0x1) +__longlong 0xfffc != 0x7fff == 0x1 (0x1) +__ulonglong 0xfffc != 0x7fff == 0x1 (0x1) +float 0xfffc != 0x7fff == 0x1 (0x1) +int 0xfffc >= 0x7fff == 0x0 (0x0) +__uint 0xfffc >= 0x7fff == 0x1 (0x1) +char 0xfffc >= 0xffff == 0x0 (0x0) +__uchar 0xfc >= 0xff == 0x0 (0x0) +__longlong 0xfffc >= 0x7fff == 0x0 (0x0) +__ulonglong 0xfffc >= 0x7fff == 0x1 (0x1) +float 0xfffc >= 0x7fff == 0x0 (0x0) +int 0xfffc / 0x7fff == 0x0 (0x0) +__uint 0xfffc / 0x7fff == 0x1 (0x1) +char 0xfffc / 0xffff == 0x4 (0x4) +__uchar 0xfc / 0xff == 0x0 (0x0) +__longlong 0xfffc / 0x7fff == 0x0 (0x0) +__ulonglong 0xfffc / 0x7fff == 0x4 (0x4) +float 0xfffc / 0x7fff == 0x0 (0x0) +int 0xfffc % 0x7fff == -0x4 (0xfffc) +__uint 0xfffc % 0x7fff == 0x7ffd (0x7ffd) +char 0xfffc % 0xffff == 0x0 (0x0) +__uchar 0xfc % 0xff == 0xfc (0xfc) +__longlong 0xfffc % 0x7fff == -0x4 (0xfffc) +__ulonglong 0xfffc % 0x7fff == 0x0 (0x0) +0xfffc * 0x8000 == 0x0 +0xfffc / 0x8000 == 0x0 +0xfffc % 0x8000 == -0x4 +int 0xfffc ^ 0x8000 == 0x7ffc (0x7ffc) +__uint 0xfffc ^ 0x8000 == 0x7ffc (0x7ffc) +char 0xfffc ^ 0x0 == -0x4 (0xfffc) +__uchar 0xfc ^ 0x0 == 0xfc (0xfc) +__longlong 0xfffc ^ 0x8000 == 0x7ffc (0x7ffc) +__ulonglong 0xfffc ^ 0x8000 == 0x7ffc (0x7ffc) +int 0xfffc && 0x8000 == 0x1 (0x1) +__uint 0xfffc && 0x8000 == 0x1 (0x1) +char 0xfffc && 0x0 == 0x0 (0x0) +__uchar 0xfc && 0x0 == 0x0 (0x0) +__longlong 0xfffc && 0x8000 == 0x1 (0x1) +__ulonglong 0xfffc && 0x8000 == 0x1 (0x1) +int 0xfffc || 0x8000 == 0x1 (0x1) +__uint 0xfffc || 0x8000 == 0x1 (0x1) +char 0xfffc || 0x0 == 0x1 (0x1) +__uchar 0xfc || 0x0 == 0x1 (0x1) +__longlong 0xfffc || 0x8000 == 0x1 (0x1) +__ulonglong 0xfffc || 0x8000 == 0x1 (0x1) +int 0xfffc & 0x8000 == -0x8000 (0x8000) +__uint 0xfffc & 0x8000 == -0x8000 (0x8000) +char 0xfffc & 0x0 == 0x0 (0x0) +__uchar 0xfc & 0x0 == 0x0 (0x0) +__longlong 0xfffc & 0x8000 == -0x8000 (0x8000) +__ulonglong 0xfffc & 0x8000 == -0x8000 (0x8000) +int 0xfffc | 0x8000 == -0x4 (0xfffc) +__uint 0xfffc | 0x8000 == -0x4 (0xfffc) +char 0xfffc | 0x0 == -0x4 (0xfffc) +__uchar 0xfc | 0x0 == 0xfc (0xfc) +__longlong 0xfffc | 0x8000 == -0x4 (0xfffc) +__ulonglong 0xfffc | 0x8000 == -0x4 (0xfffc) +int 0xfffc << 0x12 == 0x0 (0x0) +__uint 0xfffc << 0x12 == 0x0 (0x0) +char 0xfffc << 0x12 == 0x0 (0x0) +__uchar 0xfc << 0x12 == 0x0 (0x0) +__longlong 0xfffc << 0x12 == 0x0 (0x0) +__ulonglong 0xfffc << 0x12 == 0x0 (0x0) +int 0xfffc >> 0x12 == -0x1 (0xffff) +__uint 0xfffc >> 0x12 == 0x0 (0x0) +char 0xfffc >> 0x12 == -0x1 (0xffff) +__uchar 0xfc >> 0x12 == 0x0 (0x0) +__longlong 0xfffc >> 0x12 == -0x1 (0xffff) +__ulonglong 0xfffc >> 0x12 == 0x3fff (0x3fff) +int 0xfffc + 0x8000 == 0x7ffc (0x7ffc) +__uint 0xfffc + 0x8000 == 0x7ffc (0x7ffc) +char 0xfffc + 0x0 == -0x4 (0xfffc) +__uchar 0xfc + 0x0 == 0xfc (0xfc) +__longlong 0xfffc + 0x8000 == 0x7ffc (0x7ffc) +__ulonglong 0xfffc + 0x8000 == 0x7ffc (0x7ffc) +float 0xfffc + 0x8000 == -0x8000 (0x8000) +int 0xfffc - 0x8000 == 0x7ffc (0x7ffc) +__uint 0xfffc - 0x8000 == 0x7ffc (0x7ffc) +char 0xfffc - 0x0 == -0x4 (0xfffc) +__uchar 0xfc - 0x0 == 0xfc (0xfc) +__longlong 0xfffc - 0x8000 == 0x7ffc (0x7ffc) +__ulonglong 0xfffc - 0x8000 == 0x7ffc (0x7ffc) +float 0xfffc - 0x8000 == 0x7ffc (0x7ffc) +int 0xfffc * 0x8000 == 0x0 (0x0) +__uint 0xfffc * 0x8000 == 0x0 (0x0) +char 0xfffc * 0x0 == 0x0 (0x0) +__uchar 0xfc * 0x0 == 0x0 (0x0) +__longlong 0xfffc * 0x8000 == 0x0 (0x0) +__ulonglong 0xfffc * 0x8000 == 0x0 (0x0) +float 0xfffc * 0x8000 == -0x8000 (0x8000) +int 0xfffc < 0x8000 == 0x0 (0x0) +__uint 0xfffc < 0x8000 == 0x0 (0x0) +char 0xfffc < 0x0 == 0x1 (0x1) +__uchar 0xfc < 0x0 == 0x0 (0x0) +__longlong 0xfffc < 0x8000 == 0x0 (0x0) +__ulonglong 0xfffc < 0x8000 == 0x0 (0x0) +float 0xfffc < 0x8000 == 0x0 (0x0) +int 0xfffc > 0x8000 == 0x1 (0x1) +__uint 0xfffc > 0x8000 == 0x1 (0x1) +char 0xfffc > 0x0 == 0x0 (0x0) +__uchar 0xfc > 0x0 == 0x1 (0x1) +__longlong 0xfffc > 0x8000 == 0x1 (0x1) +__ulonglong 0xfffc > 0x8000 == 0x1 (0x1) +float 0xfffc > 0x8000 == 0x1 (0x1) +int 0xfffc <= 0x8000 == 0x0 (0x0) +__uint 0xfffc <= 0x8000 == 0x0 (0x0) +char 0xfffc <= 0x0 == 0x1 (0x1) +__uchar 0xfc <= 0x0 == 0x0 (0x0) +__longlong 0xfffc <= 0x8000 == 0x0 (0x0) +__ulonglong 0xfffc <= 0x8000 == 0x0 (0x0) +float 0xfffc <= 0x8000 == 0x0 (0x0) +int 0xfffc == 0x8000 == 0x0 (0x0) +__uint 0xfffc == 0x8000 == 0x0 (0x0) +char 0xfffc == 0x0 == 0x0 (0x0) +__uchar 0xfc == 0x0 == 0x0 (0x0) +__longlong 0xfffc == 0x8000 == 0x0 (0x0) +__ulonglong 0xfffc == 0x8000 == 0x0 (0x0) +float 0xfffc == 0x8000 == 0x0 (0x0) +int 0xfffc != 0x8000 == 0x1 (0x1) +__uint 0xfffc != 0x8000 == 0x1 (0x1) +char 0xfffc != 0x0 == 0x1 (0x1) +__uchar 0xfc != 0x0 == 0x1 (0x1) +__longlong 0xfffc != 0x8000 == 0x1 (0x1) +__ulonglong 0xfffc != 0x8000 == 0x1 (0x1) +float 0xfffc != 0x8000 == 0x1 (0x1) +int 0xfffc >= 0x8000 == 0x1 (0x1) +__uint 0xfffc >= 0x8000 == 0x1 (0x1) +char 0xfffc >= 0x0 == 0x0 (0x0) +__uchar 0xfc >= 0x0 == 0x1 (0x1) +__longlong 0xfffc >= 0x8000 == 0x1 (0x1) +__ulonglong 0xfffc >= 0x8000 == 0x1 (0x1) +float 0xfffc >= 0x8000 == 0x1 (0x1) +int 0xfffc / 0x8000 == 0x0 (0x0) +__uint 0xfffc / 0x8000 == 0x1 (0x1) +__longlong 0xfffc / 0x8000 == 0x0 (0x0) +__ulonglong 0xfffc / 0x8000 == 0x1 (0x1) +float 0xfffc / 0x8000 == 0x0 (0x0) +int 0xfffc % 0x8000 == -0x4 (0xfffc) +__uint 0xfffc % 0x8000 == 0x7ffc (0x7ffc) +__longlong 0xfffc % 0x8000 == -0x4 (0xfffc) +__ulonglong 0xfffc % 0x8000 == 0x7ffc (0x7ffc) +0xfffc * 0x3e8 == -0xfa0 +0xfffc / 0x3e8 == 0x0 +0xfffc % 0x3e8 == -0x4 +int 0xfffc ^ 0x3e8 == -0x3ec (0xfc14) +__uint 0xfffc ^ 0x3e8 == -0x3ec (0xfc14) +char 0xfffc ^ 0xffe8 == 0x14 (0x14) +__uchar 0xfc ^ 0xe8 == 0x14 (0x14) +__longlong 0xfffc ^ 0x3e8 == -0x3ec (0xfc14) +__ulonglong 0xfffc ^ 0x3e8 == -0x3ec (0xfc14) +int 0xfffc && 0x3e8 == 0x1 (0x1) +__uint 0xfffc && 0x3e8 == 0x1 (0x1) +char 0xfffc && 0xffe8 == 0x1 (0x1) +__uchar 0xfc && 0xe8 == 0x1 (0x1) +__longlong 0xfffc && 0x3e8 == 0x1 (0x1) +__ulonglong 0xfffc && 0x3e8 == 0x1 (0x1) +int 0xfffc || 0x3e8 == 0x1 (0x1) +__uint 0xfffc || 0x3e8 == 0x1 (0x1) +char 0xfffc || 0xffe8 == 0x1 (0x1) +__uchar 0xfc || 0xe8 == 0x1 (0x1) +__longlong 0xfffc || 0x3e8 == 0x1 (0x1) +__ulonglong 0xfffc || 0x3e8 == 0x1 (0x1) +int 0xfffc & 0x3e8 == 0x3e8 (0x3e8) +__uint 0xfffc & 0x3e8 == 0x3e8 (0x3e8) +char 0xfffc & 0xffe8 == -0x18 (0xffe8) +__uchar 0xfc & 0xe8 == 0xe8 (0xe8) +__longlong 0xfffc & 0x3e8 == 0x3e8 (0x3e8) +__ulonglong 0xfffc & 0x3e8 == 0x3e8 (0x3e8) +int 0xfffc | 0x3e8 == -0x4 (0xfffc) +__uint 0xfffc | 0x3e8 == -0x4 (0xfffc) +char 0xfffc | 0xffe8 == -0x4 (0xfffc) +__uchar 0xfc | 0xe8 == 0xfc (0xfc) +__longlong 0xfffc | 0x3e8 == -0x4 (0xfffc) +__ulonglong 0xfffc | 0x3e8 == -0x4 (0xfffc) +int 0xfffc << 0x14 == 0x0 (0x0) +__uint 0xfffc << 0x14 == 0x0 (0x0) +char 0xfffc << 0x14 == 0x0 (0x0) +__uchar 0xfc << 0x14 == 0x0 (0x0) +__longlong 0xfffc << 0x14 == 0x0 (0x0) +__ulonglong 0xfffc << 0x14 == 0x0 (0x0) +int 0xfffc >> 0x14 == -0x1 (0xffff) +__uint 0xfffc >> 0x14 == 0x0 (0x0) +char 0xfffc >> 0x14 == -0x1 (0xffff) +__uchar 0xfc >> 0x14 == 0x0 (0x0) +__longlong 0xfffc >> 0x14 == -0x1 (0xffff) +__ulonglong 0xfffc >> 0x14 == 0xfff (0xfff) +int 0xfffc + 0x3e8 == 0x3e4 (0x3e4) +__uint 0xfffc + 0x3e8 == 0x3e4 (0x3e4) +char 0xfffc + 0xffe8 == -0x1c (0xffe4) +__uchar 0xfc + 0xe8 == 0xe4 (0xe4) +__longlong 0xfffc + 0x3e8 == 0x3e4 (0x3e4) +__ulonglong 0xfffc + 0x3e8 == 0x3e4 (0x3e4) +float 0xfffc + 0x3e8 == 0x3e4 (0x3e4) +int 0xfffc - 0x3e8 == -0x3ec (0xfc14) +__uint 0xfffc - 0x3e8 == -0x3ec (0xfc14) +char 0xfffc - 0xffe8 == 0x14 (0x14) +__uchar 0xfc - 0xe8 == 0x14 (0x14) +__longlong 0xfffc - 0x3e8 == -0x3ec (0xfc14) +__ulonglong 0xfffc - 0x3e8 == -0x3ec (0xfc14) +float 0xfffc - 0x3e8 == -0x3ec (0xfc14) +int 0xfffc * 0x3e8 == -0xfa0 (0xf060) +__uint 0xfffc * 0x3e8 == -0xfa0 (0xf060) +char 0xfffc * 0xffe8 == 0x60 (0x60) +__uchar 0xfc * 0xe8 == 0x60 (0x60) +__longlong 0xfffc * 0x3e8 == -0xfa0 (0xf060) +__ulonglong 0xfffc * 0x3e8 == -0xfa0 (0xf060) +float 0xfffc * 0x3e8 == -0xfa0 (0xf060) +int 0xfffc < 0x3e8 == 0x1 (0x1) +__uint 0xfffc < 0x3e8 == 0x0 (0x0) +char 0xfffc < 0xffe8 == 0x0 (0x0) +__uchar 0xfc < 0xe8 == 0x0 (0x0) +__longlong 0xfffc < 0x3e8 == 0x1 (0x1) +__ulonglong 0xfffc < 0x3e8 == 0x0 (0x0) +float 0xfffc < 0x3e8 == 0x1 (0x1) +int 0xfffc > 0x3e8 == 0x0 (0x0) +__uint 0xfffc > 0x3e8 == 0x1 (0x1) +char 0xfffc > 0xffe8 == 0x1 (0x1) +__uchar 0xfc > 0xe8 == 0x1 (0x1) +__longlong 0xfffc > 0x3e8 == 0x0 (0x0) +__ulonglong 0xfffc > 0x3e8 == 0x1 (0x1) +float 0xfffc > 0x3e8 == 0x0 (0x0) +int 0xfffc <= 0x3e8 == 0x1 (0x1) +__uint 0xfffc <= 0x3e8 == 0x0 (0x0) +char 0xfffc <= 0xffe8 == 0x0 (0x0) +__uchar 0xfc <= 0xe8 == 0x0 (0x0) +__longlong 0xfffc <= 0x3e8 == 0x1 (0x1) +__ulonglong 0xfffc <= 0x3e8 == 0x0 (0x0) +float 0xfffc <= 0x3e8 == 0x1 (0x1) +int 0xfffc == 0x3e8 == 0x0 (0x0) +__uint 0xfffc == 0x3e8 == 0x0 (0x0) +char 0xfffc == 0xffe8 == 0x0 (0x0) +__uchar 0xfc == 0xe8 == 0x0 (0x0) +__longlong 0xfffc == 0x3e8 == 0x0 (0x0) +__ulonglong 0xfffc == 0x3e8 == 0x0 (0x0) +float 0xfffc == 0x3e8 == 0x0 (0x0) +int 0xfffc != 0x3e8 == 0x1 (0x1) +__uint 0xfffc != 0x3e8 == 0x1 (0x1) +char 0xfffc != 0xffe8 == 0x1 (0x1) +__uchar 0xfc != 0xe8 == 0x1 (0x1) +__longlong 0xfffc != 0x3e8 == 0x1 (0x1) +__ulonglong 0xfffc != 0x3e8 == 0x1 (0x1) +float 0xfffc != 0x3e8 == 0x1 (0x1) +int 0xfffc >= 0x3e8 == 0x0 (0x0) +__uint 0xfffc >= 0x3e8 == 0x1 (0x1) +char 0xfffc >= 0xffe8 == 0x1 (0x1) +__uchar 0xfc >= 0xe8 == 0x1 (0x1) +__longlong 0xfffc >= 0x3e8 == 0x0 (0x0) +__ulonglong 0xfffc >= 0x3e8 == 0x1 (0x1) +float 0xfffc >= 0x3e8 == 0x0 (0x0) +int 0xfffc / 0x3e8 == 0x0 (0x0) +__uint 0xfffc / 0x3e8 == 0x41 (0x41) +char 0xfffc / 0xffe8 == 0x0 (0x0) +__uchar 0xfc / 0xe8 == 0x1 (0x1) +__longlong 0xfffc / 0x3e8 == 0x0 (0x0) +__ulonglong 0xfffc / 0x3e8 == -0x76c9 (0x8937) +float 0xfffc / 0x3e8 == 0x0 (0x0) +int 0xfffc % 0x3e8 == -0x4 (0xfffc) +__uint 0xfffc % 0x3e8 == 0x214 (0x214) +char 0xfffc % 0xffe8 == -0x4 (0xfffc) +__uchar 0xfc % 0xe8 == 0x14 (0x14) +__longlong 0xfffc % 0x3e8 == -0x4 (0xfffc) +__ulonglong 0xfffc % 0x3e8 == 0x124 (0x124) +0xfffc * 0x2710 == 0x63c0 +0xfffc / 0x2710 == 0x0 +0xfffc % 0x2710 == -0x4 +int 0xfffc ^ 0x2710 == -0x2714 (0xd8ec) +__uint 0xfffc ^ 0x2710 == -0x2714 (0xd8ec) +char 0xfffc ^ 0x10 == -0x14 (0xffec) +__uchar 0xfc ^ 0x10 == 0xec (0xec) +__longlong 0xfffc ^ 0x2710 == -0x2714 (0xd8ec) +__ulonglong 0xfffc ^ 0x2710 == -0x2714 (0xd8ec) +int 0xfffc && 0x2710 == 0x1 (0x1) +__uint 0xfffc && 0x2710 == 0x1 (0x1) +char 0xfffc && 0x10 == 0x1 (0x1) +__uchar 0xfc && 0x10 == 0x1 (0x1) +__longlong 0xfffc && 0x2710 == 0x1 (0x1) +__ulonglong 0xfffc && 0x2710 == 0x1 (0x1) +int 0xfffc || 0x2710 == 0x1 (0x1) +__uint 0xfffc || 0x2710 == 0x1 (0x1) +char 0xfffc || 0x10 == 0x1 (0x1) +__uchar 0xfc || 0x10 == 0x1 (0x1) +__longlong 0xfffc || 0x2710 == 0x1 (0x1) +__ulonglong 0xfffc || 0x2710 == 0x1 (0x1) +int 0xfffc & 0x2710 == 0x2710 (0x2710) +__uint 0xfffc & 0x2710 == 0x2710 (0x2710) +char 0xfffc & 0x10 == 0x10 (0x10) +__uchar 0xfc & 0x10 == 0x10 (0x10) +__longlong 0xfffc & 0x2710 == 0x2710 (0x2710) +__ulonglong 0xfffc & 0x2710 == 0x2710 (0x2710) +int 0xfffc | 0x2710 == -0x4 (0xfffc) +__uint 0xfffc | 0x2710 == -0x4 (0xfffc) +char 0xfffc | 0x10 == -0x4 (0xfffc) +__uchar 0xfc | 0x10 == 0xfc (0xfc) +__longlong 0xfffc | 0x2710 == -0x4 (0xfffc) +__ulonglong 0xfffc | 0x2710 == -0x4 (0xfffc) +int 0xfffc << 0x16 == 0x0 (0x0) +__uint 0xfffc << 0x16 == 0x0 (0x0) +char 0xfffc << 0x16 == 0x0 (0x0) +__uchar 0xfc << 0x16 == 0x0 (0x0) +__longlong 0xfffc << 0x16 == 0x0 (0x0) +__ulonglong 0xfffc << 0x16 == 0x0 (0x0) +int 0xfffc >> 0x16 == -0x1 (0xffff) +__uint 0xfffc >> 0x16 == 0x0 (0x0) +char 0xfffc >> 0x16 == -0x1 (0xffff) +__uchar 0xfc >> 0x16 == 0x0 (0x0) +__longlong 0xfffc >> 0x16 == -0x1 (0xffff) +__ulonglong 0xfffc >> 0x16 == 0x3ff (0x3ff) +int 0xfffc + 0x2710 == 0x270c (0x270c) +__uint 0xfffc + 0x2710 == 0x270c (0x270c) +char 0xfffc + 0x10 == 0xc (0xc) +__uchar 0xfc + 0x10 == 0xc (0xc) +__longlong 0xfffc + 0x2710 == 0x270c (0x270c) +__ulonglong 0xfffc + 0x2710 == 0x270c (0x270c) +float 0xfffc + 0x2710 == 0x270c (0x270c) +int 0xfffc - 0x2710 == -0x2714 (0xd8ec) +__uint 0xfffc - 0x2710 == -0x2714 (0xd8ec) +char 0xfffc - 0x10 == -0x14 (0xffec) +__uchar 0xfc - 0x10 == 0xec (0xec) +__longlong 0xfffc - 0x2710 == -0x2714 (0xd8ec) +__ulonglong 0xfffc - 0x2710 == -0x2714 (0xd8ec) +float 0xfffc - 0x2710 == -0x2714 (0xd8ec) +int 0xfffc * 0x2710 == 0x63c0 (0x63c0) +__uint 0xfffc * 0x2710 == 0x63c0 (0x63c0) +char 0xfffc * 0x10 == -0x40 (0xffc0) +__uchar 0xfc * 0x10 == 0xc0 (0xc0) +__longlong 0xfffc * 0x2710 == 0x63c0 (0x63c0) +__ulonglong 0xfffc * 0x2710 == 0x63c0 (0x63c0) +float 0xfffc * 0x2710 == -0x8000 (0x8000) +int 0xfffc < 0x2710 == 0x1 (0x1) +__uint 0xfffc < 0x2710 == 0x0 (0x0) +char 0xfffc < 0x10 == 0x1 (0x1) +__uchar 0xfc < 0x10 == 0x0 (0x0) +__longlong 0xfffc < 0x2710 == 0x1 (0x1) +__ulonglong 0xfffc < 0x2710 == 0x0 (0x0) +float 0xfffc < 0x2710 == 0x1 (0x1) +int 0xfffc > 0x2710 == 0x0 (0x0) +__uint 0xfffc > 0x2710 == 0x1 (0x1) +char 0xfffc > 0x10 == 0x0 (0x0) +__uchar 0xfc > 0x10 == 0x1 (0x1) +__longlong 0xfffc > 0x2710 == 0x0 (0x0) +__ulonglong 0xfffc > 0x2710 == 0x1 (0x1) +float 0xfffc > 0x2710 == 0x0 (0x0) +int 0xfffc <= 0x2710 == 0x1 (0x1) +__uint 0xfffc <= 0x2710 == 0x0 (0x0) +char 0xfffc <= 0x10 == 0x1 (0x1) +__uchar 0xfc <= 0x10 == 0x0 (0x0) +__longlong 0xfffc <= 0x2710 == 0x1 (0x1) +__ulonglong 0xfffc <= 0x2710 == 0x0 (0x0) +float 0xfffc <= 0x2710 == 0x1 (0x1) +int 0xfffc == 0x2710 == 0x0 (0x0) +__uint 0xfffc == 0x2710 == 0x0 (0x0) +char 0xfffc == 0x10 == 0x0 (0x0) +__uchar 0xfc == 0x10 == 0x0 (0x0) +__longlong 0xfffc == 0x2710 == 0x0 (0x0) +__ulonglong 0xfffc == 0x2710 == 0x0 (0x0) +float 0xfffc == 0x2710 == 0x0 (0x0) +int 0xfffc != 0x2710 == 0x1 (0x1) +__uint 0xfffc != 0x2710 == 0x1 (0x1) +char 0xfffc != 0x10 == 0x1 (0x1) +__uchar 0xfc != 0x10 == 0x1 (0x1) +__longlong 0xfffc != 0x2710 == 0x1 (0x1) +__ulonglong 0xfffc != 0x2710 == 0x1 (0x1) +float 0xfffc != 0x2710 == 0x1 (0x1) +int 0xfffc >= 0x2710 == 0x0 (0x0) +__uint 0xfffc >= 0x2710 == 0x1 (0x1) +char 0xfffc >= 0x10 == 0x0 (0x0) +__uchar 0xfc >= 0x10 == 0x1 (0x1) +__longlong 0xfffc >= 0x2710 == 0x0 (0x0) +__ulonglong 0xfffc >= 0x2710 == 0x1 (0x1) +float 0xfffc >= 0x2710 == 0x0 (0x0) +int 0xfffc / 0x2710 == 0x0 (0x0) +__uint 0xfffc / 0x2710 == 0x6 (0x6) +char 0xfffc / 0x10 == 0x0 (0x0) +__uchar 0xfc / 0x10 == 0xf (0xf) +__longlong 0xfffc / 0x2710 == 0x0 (0x0) +__ulonglong 0xfffc / 0x2710 == -0x7248 (0x8db8) +float 0xfffc / 0x2710 == 0x0 (0x0) +int 0xfffc % 0x2710 == -0x4 (0xfffc) +__uint 0xfffc % 0x2710 == 0x159c (0x159c) +char 0xfffc % 0x10 == -0x4 (0xfffc) +__uchar 0xfc % 0x10 == 0xc (0xc) +__longlong 0xfffc % 0x2710 == -0x4 (0xfffc) +__ulonglong 0xfffc % 0x2710 == 0x1c7c (0x1c7c) +int xor42-0x4 xor42 -0x2a +__uint xor42-0x4 xor42 -0x2a +char xor42-0x4 xor42 -0x2a +__uchar xor420xfc xor42 0xd6 +__longlong xor42-0x4 xor42 -0x2a +__ulonglong xor42-0x4 xor42 -0x2a +int land1-0x4 land1 0x1 +__uint land1-0x4 land1 0x1 +char land1-0x4 land1 0x1 +__uchar land10xfc land1 0x1 +__longlong land1-0x4 land1 0x1 +__ulonglong land1-0x4 land1 0x1 +int lor1-0x4 lor1 0x1 +__uint lor1-0x4 lor1 0x1 +char lor1-0x4 lor1 0x1 +__uchar lor10xfc lor1 0x1 +__longlong lor1-0x4 lor1 0x1 +__ulonglong lor1-0x4 lor1 0x1 +int and42-0x4 and42 0x28 +__uint and42-0x4 and42 0x28 +char and42-0x4 and42 0x28 +__uchar and420xfc and42 0x28 +__longlong and42-0x4 and42 0x28 +__ulonglong and42-0x4 and42 0x28 +int or42-0x4 or42 -0x2 +__uint or42-0x4 or42 -0x2 +char or42-0x4 or42 -0x2 +__uchar or420xfc or42 0xfe +__longlong or42-0x4 or42 -0x2 +__ulonglong or42-0x4 or42 -0x2 +int shl5-0x4 shl5 -0x80 +__uint shl5-0x4 shl5 -0x80 +char shl5-0x4 shl5 -0x80 +__uchar shl50xfc shl5 0x80 +__longlong shl5-0x4 shl5 -0x80 +__ulonglong shl5-0x4 shl5 -0x80 +int shr5-0x4 shr5 -0x1 +__uint shr5-0x4 shr5 0x7ff +char shr5-0x4 shr5 -0x1 +__uchar shr50xfc shr5 0x7 +__longlong shr5-0x4 shr5 -0x1 +__ulonglong shr5-0x4 shr5 -0x1 +int add42-0x4 add42 0x26 +__uint add42-0x4 add42 0x26 +char add42-0x4 add42 0x26 +__uchar add420xfc add42 0x26 +__longlong add42-0x4 add42 0x26 +__ulonglong add42-0x4 add42 0x26 +float add42-0x4 add42 0x26 +int sub42-0x4 sub42 -0x2e +__uint sub42-0x4 sub42 -0x2e +char sub42-0x4 sub42 -0x2e +__uchar sub420xfc sub42 0xd2 +__longlong sub42-0x4 sub42 -0x2e +__ulonglong sub42-0x4 sub42 -0x2e +float sub42-0x4 sub42 -0x2e +int mul42-0x4 mul42 -0xa8 +__uint mul42-0x4 mul42 -0xa8 +char mul42-0x4 mul42 0x58 +__uchar mul420xfc mul42 0x58 +__longlong mul42-0x4 mul42 -0xa8 +__ulonglong mul42-0x4 mul42 -0xa8 +float mul42-0x4 mul42 -0xa8 +int lt42-0x4 lt42 0x1 +__uint lt42-0x4 lt42 0x0 +char lt42-0x4 lt42 0x1 +__uchar lt420xfc lt42 0x0 +__longlong lt42-0x4 lt42 0x1 +__ulonglong lt42-0x4 lt42 0x0 +float lt42-0x4 lt42 0x1 +int gt42-0x4 gt42 0x0 +__uint gt42-0x4 gt42 0x1 +char gt42-0x4 gt42 0x0 +__uchar gt420xfc gt42 0x1 +__longlong gt42-0x4 gt42 0x0 +__ulonglong gt42-0x4 gt42 0x1 +float gt42-0x4 gt42 0x0 +int le42-0x4 le42 0x1 +__uint le42-0x4 le42 0x0 +char le42-0x4 le42 0x1 +__uchar le420xfc le42 0x0 +__longlong le42-0x4 le42 0x1 +__ulonglong le42-0x4 le42 0x0 +float le42-0x4 le42 0x1 +int eq42-0x4 eq42 0x0 +__uint eq42-0x4 eq42 0x0 +char eq42-0x4 eq42 0x0 +__uchar eq420xfc eq42 0x0 +__longlong eq42-0x4 eq42 0x0 +__ulonglong eq42-0x4 eq42 0x0 +float eq42-0x4 eq42 0x0 +int ne42-0x4 ne42 0x1 +__uint ne42-0x4 ne42 0x1 +char ne42-0x4 ne42 0x1 +__uchar ne420xfc ne42 0x1 +__longlong ne42-0x4 ne42 0x1 +__ulonglong ne42-0x4 ne42 0x1 +float ne42-0x4 ne42 0x1 +int ge42-0x4 ge42 0x0 +__uint ge42-0x4 ge42 0x1 +char ge42-0x4 ge42 0x0 +__uchar ge420xfc ge42 0x1 +__longlong ge42-0x4 ge42 0x0 +__ulonglong ge42-0x4 ge42 0x1 +float ge42-0x4 ge42 0x0 +int div42-0x4 div42 0x0 +__uint div42-0x4 div42 0x618 +char div42-0x4 div42 0x0 +__uchar div420xfc div42 0x6 +__longlong div42-0x4 div42 0x0 +__ulonglong div42-0x4 div42 0x6186 +float div42-0x4 div42 0x0 +int mod23-0x4 mod23 -0x4 +__uint mod23-0x4 mod23 0x5 +char mod23-0x4 mod23 -0x4 +__uchar mod230xfc mod23 0x16 +__longlong mod23-0x4 mod23 -0x4 +__ulonglong mod23-0x4 mod23 0x8 +0xa * 0xffff == -0xa +0xa / 0xffff == -0xa +0xa % 0xffff == 0x0 +int 0xa ^ 0xffff == -0xb (0xfff5) +__uint 0xa ^ 0xffff == -0xb (0xfff5) +char 0xa ^ 0xffff == -0xb (0xfff5) +__uchar 0xa ^ 0xff == 0xf5 (0xf5) +__longlong 0xa ^ 0xffff == -0xb (0xfff5) +__ulonglong 0xa ^ 0xffff == -0xb (0xfff5) +int 0xa && 0xffff == 0x1 (0x1) +__uint 0xa && 0xffff == 0x1 (0x1) +char 0xa && 0xffff == 0x1 (0x1) +__uchar 0xa && 0xff == 0x1 (0x1) +__longlong 0xa && 0xffff == 0x1 (0x1) +__ulonglong 0xa && 0xffff == 0x1 (0x1) +int 0xa || 0xffff == 0x1 (0x1) +__uint 0xa || 0xffff == 0x1 (0x1) +char 0xa || 0xffff == 0x1 (0x1) +__uchar 0xa || 0xff == 0x1 (0x1) +__longlong 0xa || 0xffff == 0x1 (0x1) +__ulonglong 0xa || 0xffff == 0x1 (0x1) +int 0xa & 0xffff == 0xa (0xa) +__uint 0xa & 0xffff == 0xa (0xa) +char 0xa & 0xffff == 0xa (0xa) +__uchar 0xa & 0xff == 0xa (0xa) +__longlong 0xa & 0xffff == 0xa (0xa) +__ulonglong 0xa & 0xffff == 0xa (0xa) +int 0xa | 0xffff == -0x1 (0xffff) +__uint 0xa | 0xffff == -0x1 (0xffff) +char 0xa | 0xffff == -0x1 (0xffff) +__uchar 0xa | 0xff == 0xff (0xff) +__longlong 0xa | 0xffff == -0x1 (0xffff) +__ulonglong 0xa | 0xffff == -0x1 (0xffff) +int 0xa << 0x1 == 0x14 (0x14) +__uint 0xa << 0x1 == 0x14 (0x14) +char 0xa << 0x1 == 0x14 (0x14) +__uchar 0xa << 0x1 == 0x14 (0x14) +__longlong 0xa << 0x1 == 0x14 (0x14) +__ulonglong 0xa << 0x1 == 0x14 (0x14) +int 0xa >> 0x1 == 0x5 (0x5) +__uint 0xa >> 0x1 == 0x5 (0x5) +char 0xa >> 0x1 == 0x5 (0x5) +__uchar 0xa >> 0x1 == 0x5 (0x5) +__longlong 0xa >> 0x1 == 0x5 (0x5) +__ulonglong 0xa >> 0x1 == 0x5 (0x5) +int 0xa + 0xffff == 0x9 (0x9) +__uint 0xa + 0xffff == 0x9 (0x9) +char 0xa + 0xffff == 0x9 (0x9) +__uchar 0xa + 0xff == 0x9 (0x9) +__longlong 0xa + 0xffff == 0x9 (0x9) +__ulonglong 0xa + 0xffff == 0x9 (0x9) +float 0xa + 0xffff == 0x9 (0x9) +int 0xa - 0xffff == 0xb (0xb) +__uint 0xa - 0xffff == 0xb (0xb) +char 0xa - 0xffff == 0xb (0xb) +__uchar 0xa - 0xff == 0xb (0xb) +__longlong 0xa - 0xffff == 0xb (0xb) +__ulonglong 0xa - 0xffff == 0xb (0xb) +float 0xa - 0xffff == 0xb (0xb) +int 0xa * 0xffff == -0xa (0xfff6) +__uint 0xa * 0xffff == -0xa (0xfff6) +char 0xa * 0xffff == -0xa (0xfff6) +__uchar 0xa * 0xff == 0xf6 (0xf6) +__longlong 0xa * 0xffff == -0xa (0xfff6) +__ulonglong 0xa * 0xffff == -0xa (0xfff6) +float 0xa * 0xffff == -0xa (0xfff6) +int 0xa < 0xffff == 0x0 (0x0) +__uint 0xa < 0xffff == 0x1 (0x1) +char 0xa < 0xffff == 0x0 (0x0) +__uchar 0xa < 0xff == 0x1 (0x1) +__longlong 0xa < 0xffff == 0x0 (0x0) +__ulonglong 0xa < 0xffff == 0x1 (0x1) +float 0xa < 0xffff == 0x0 (0x0) +int 0xa > 0xffff == 0x1 (0x1) +__uint 0xa > 0xffff == 0x0 (0x0) +char 0xa > 0xffff == 0x1 (0x1) +__uchar 0xa > 0xff == 0x0 (0x0) +__longlong 0xa > 0xffff == 0x1 (0x1) +__ulonglong 0xa > 0xffff == 0x0 (0x0) +float 0xa > 0xffff == 0x1 (0x1) +int 0xa <= 0xffff == 0x0 (0x0) +__uint 0xa <= 0xffff == 0x1 (0x1) +char 0xa <= 0xffff == 0x0 (0x0) +__uchar 0xa <= 0xff == 0x1 (0x1) +__longlong 0xa <= 0xffff == 0x0 (0x0) +__ulonglong 0xa <= 0xffff == 0x1 (0x1) +float 0xa <= 0xffff == 0x0 (0x0) +int 0xa == 0xffff == 0x0 (0x0) +__uint 0xa == 0xffff == 0x0 (0x0) +char 0xa == 0xffff == 0x0 (0x0) +__uchar 0xa == 0xff == 0x0 (0x0) +__longlong 0xa == 0xffff == 0x0 (0x0) +__ulonglong 0xa == 0xffff == 0x0 (0x0) +float 0xa == 0xffff == 0x0 (0x0) +int 0xa != 0xffff == 0x1 (0x1) +__uint 0xa != 0xffff == 0x1 (0x1) +char 0xa != 0xffff == 0x1 (0x1) +__uchar 0xa != 0xff == 0x1 (0x1) +__longlong 0xa != 0xffff == 0x1 (0x1) +__ulonglong 0xa != 0xffff == 0x1 (0x1) +float 0xa != 0xffff == 0x1 (0x1) +int 0xa >= 0xffff == 0x1 (0x1) +__uint 0xa >= 0xffff == 0x0 (0x0) +char 0xa >= 0xffff == 0x1 (0x1) +__uchar 0xa >= 0xff == 0x0 (0x0) +__longlong 0xa >= 0xffff == 0x1 (0x1) +__ulonglong 0xa >= 0xffff == 0x0 (0x0) +float 0xa >= 0xffff == 0x1 (0x1) +int 0xa / 0xffff == -0xa (0xfff6) +__uint 0xa / 0xffff == 0x0 (0x0) +char 0xa / 0xffff == -0xa (0xfff6) +__uchar 0xa / 0xff == 0x0 (0x0) +__longlong 0xa / 0xffff == -0xa (0xfff6) +__ulonglong 0xa / 0xffff == 0x0 (0x0) +float 0xa / 0xffff == -0xa (0xfff6) +int 0xa % 0xffff == 0x0 (0x0) +__uint 0xa % 0xffff == 0xa (0xa) +char 0xa % 0xffff == 0x0 (0x0) +__uchar 0xa % 0xff == 0xa (0xa) +__longlong 0xa % 0xffff == 0x0 (0x0) +__ulonglong 0xa % 0xffff == 0xa (0xa) +0xa * 0x1 == 0xa +0xa / 0x1 == 0xa +0xa % 0x1 == 0x0 +int 0xa ^ 0x1 == 0xb (0xb) +__uint 0xa ^ 0x1 == 0xb (0xb) +char 0xa ^ 0x1 == 0xb (0xb) +__uchar 0xa ^ 0x1 == 0xb (0xb) +__longlong 0xa ^ 0x1 == 0xb (0xb) +__ulonglong 0xa ^ 0x1 == 0xb (0xb) +int 0xa && 0x1 == 0x1 (0x1) +__uint 0xa && 0x1 == 0x1 (0x1) +char 0xa && 0x1 == 0x1 (0x1) +__uchar 0xa && 0x1 == 0x1 (0x1) +__longlong 0xa && 0x1 == 0x1 (0x1) +__ulonglong 0xa && 0x1 == 0x1 (0x1) +int 0xa || 0x1 == 0x1 (0x1) +__uint 0xa || 0x1 == 0x1 (0x1) +char 0xa || 0x1 == 0x1 (0x1) +__uchar 0xa || 0x1 == 0x1 (0x1) +__longlong 0xa || 0x1 == 0x1 (0x1) +__ulonglong 0xa || 0x1 == 0x1 (0x1) +int 0xa & 0x1 == 0x0 (0x0) +__uint 0xa & 0x1 == 0x0 (0x0) +char 0xa & 0x1 == 0x0 (0x0) +__uchar 0xa & 0x1 == 0x0 (0x0) +__longlong 0xa & 0x1 == 0x0 (0x0) +__ulonglong 0xa & 0x1 == 0x0 (0x0) +int 0xa | 0x1 == 0xb (0xb) +__uint 0xa | 0x1 == 0xb (0xb) +char 0xa | 0x1 == 0xb (0xb) +__uchar 0xa | 0x1 == 0xb (0xb) +__longlong 0xa | 0x1 == 0xb (0xb) +__ulonglong 0xa | 0x1 == 0xb (0xb) +int 0xa << 0x2 == 0x28 (0x28) +__uint 0xa << 0x2 == 0x28 (0x28) +char 0xa << 0x2 == 0x28 (0x28) +__uchar 0xa << 0x2 == 0x28 (0x28) +__longlong 0xa << 0x2 == 0x28 (0x28) +__ulonglong 0xa << 0x2 == 0x28 (0x28) +int 0xa >> 0x2 == 0x2 (0x2) +__uint 0xa >> 0x2 == 0x2 (0x2) +char 0xa >> 0x2 == 0x2 (0x2) +__uchar 0xa >> 0x2 == 0x2 (0x2) +__longlong 0xa >> 0x2 == 0x2 (0x2) +__ulonglong 0xa >> 0x2 == 0x2 (0x2) +int 0xa + 0x1 == 0xb (0xb) +__uint 0xa + 0x1 == 0xb (0xb) +char 0xa + 0x1 == 0xb (0xb) +__uchar 0xa + 0x1 == 0xb (0xb) +__longlong 0xa + 0x1 == 0xb (0xb) +__ulonglong 0xa + 0x1 == 0xb (0xb) +float 0xa + 0x1 == 0xb (0xb) +int 0xa - 0x1 == 0x9 (0x9) +__uint 0xa - 0x1 == 0x9 (0x9) +char 0xa - 0x1 == 0x9 (0x9) +__uchar 0xa - 0x1 == 0x9 (0x9) +__longlong 0xa - 0x1 == 0x9 (0x9) +__ulonglong 0xa - 0x1 == 0x9 (0x9) +float 0xa - 0x1 == 0x9 (0x9) +int 0xa * 0x1 == 0xa (0xa) +__uint 0xa * 0x1 == 0xa (0xa) +char 0xa * 0x1 == 0xa (0xa) +__uchar 0xa * 0x1 == 0xa (0xa) +__longlong 0xa * 0x1 == 0xa (0xa) +__ulonglong 0xa * 0x1 == 0xa (0xa) +float 0xa * 0x1 == 0xa (0xa) +int 0xa < 0x1 == 0x0 (0x0) +__uint 0xa < 0x1 == 0x0 (0x0) +char 0xa < 0x1 == 0x0 (0x0) +__uchar 0xa < 0x1 == 0x0 (0x0) +__longlong 0xa < 0x1 == 0x0 (0x0) +__ulonglong 0xa < 0x1 == 0x0 (0x0) +float 0xa < 0x1 == 0x0 (0x0) +int 0xa > 0x1 == 0x1 (0x1) +__uint 0xa > 0x1 == 0x1 (0x1) +char 0xa > 0x1 == 0x1 (0x1) +__uchar 0xa > 0x1 == 0x1 (0x1) +__longlong 0xa > 0x1 == 0x1 (0x1) +__ulonglong 0xa > 0x1 == 0x1 (0x1) +float 0xa > 0x1 == 0x1 (0x1) +int 0xa <= 0x1 == 0x0 (0x0) +__uint 0xa <= 0x1 == 0x0 (0x0) +char 0xa <= 0x1 == 0x0 (0x0) +__uchar 0xa <= 0x1 == 0x0 (0x0) +__longlong 0xa <= 0x1 == 0x0 (0x0) +__ulonglong 0xa <= 0x1 == 0x0 (0x0) +float 0xa <= 0x1 == 0x0 (0x0) +int 0xa == 0x1 == 0x0 (0x0) +__uint 0xa == 0x1 == 0x0 (0x0) +char 0xa == 0x1 == 0x0 (0x0) +__uchar 0xa == 0x1 == 0x0 (0x0) +__longlong 0xa == 0x1 == 0x0 (0x0) +__ulonglong 0xa == 0x1 == 0x0 (0x0) +float 0xa == 0x1 == 0x0 (0x0) +int 0xa != 0x1 == 0x1 (0x1) +__uint 0xa != 0x1 == 0x1 (0x1) +char 0xa != 0x1 == 0x1 (0x1) +__uchar 0xa != 0x1 == 0x1 (0x1) +__longlong 0xa != 0x1 == 0x1 (0x1) +__ulonglong 0xa != 0x1 == 0x1 (0x1) +float 0xa != 0x1 == 0x1 (0x1) +int 0xa >= 0x1 == 0x1 (0x1) +__uint 0xa >= 0x1 == 0x1 (0x1) +char 0xa >= 0x1 == 0x1 (0x1) +__uchar 0xa >= 0x1 == 0x1 (0x1) +__longlong 0xa >= 0x1 == 0x1 (0x1) +__ulonglong 0xa >= 0x1 == 0x1 (0x1) +float 0xa >= 0x1 == 0x1 (0x1) +int 0xa / 0x1 == 0xa (0xa) +__uint 0xa / 0x1 == 0xa (0xa) +char 0xa / 0x1 == 0xa (0xa) +__uchar 0xa / 0x1 == 0xa (0xa) +__longlong 0xa / 0x1 == 0xa (0xa) +__ulonglong 0xa / 0x1 == 0xa (0xa) +float 0xa / 0x1 == 0xa (0xa) +int 0xa % 0x1 == 0x0 (0x0) +__uint 0xa % 0x1 == 0x0 (0x0) +char 0xa % 0x1 == 0x0 (0x0) +__uchar 0xa % 0x1 == 0x0 (0x0) +__longlong 0xa % 0x1 == 0x0 (0x0) +__ulonglong 0xa % 0x1 == 0x0 (0x0) +0xa * 0x2 == 0x14 +0xa / 0x2 == 0x5 +0xa % 0x2 == 0x0 +int 0xa ^ 0x2 == 0x8 (0x8) +__uint 0xa ^ 0x2 == 0x8 (0x8) +char 0xa ^ 0x2 == 0x8 (0x8) +__uchar 0xa ^ 0x2 == 0x8 (0x8) +__longlong 0xa ^ 0x2 == 0x8 (0x8) +__ulonglong 0xa ^ 0x2 == 0x8 (0x8) +int 0xa && 0x2 == 0x1 (0x1) +__uint 0xa && 0x2 == 0x1 (0x1) +char 0xa && 0x2 == 0x1 (0x1) +__uchar 0xa && 0x2 == 0x1 (0x1) +__longlong 0xa && 0x2 == 0x1 (0x1) +__ulonglong 0xa && 0x2 == 0x1 (0x1) +int 0xa || 0x2 == 0x1 (0x1) +__uint 0xa || 0x2 == 0x1 (0x1) +char 0xa || 0x2 == 0x1 (0x1) +__uchar 0xa || 0x2 == 0x1 (0x1) +__longlong 0xa || 0x2 == 0x1 (0x1) +__ulonglong 0xa || 0x2 == 0x1 (0x1) +int 0xa & 0x2 == 0x2 (0x2) +__uint 0xa & 0x2 == 0x2 (0x2) +char 0xa & 0x2 == 0x2 (0x2) +__uchar 0xa & 0x2 == 0x2 (0x2) +__longlong 0xa & 0x2 == 0x2 (0x2) +__ulonglong 0xa & 0x2 == 0x2 (0x2) +int 0xa | 0x2 == 0xa (0xa) +__uint 0xa | 0x2 == 0xa (0xa) +char 0xa | 0x2 == 0xa (0xa) +__uchar 0xa | 0x2 == 0xa (0xa) +__longlong 0xa | 0x2 == 0xa (0xa) +__ulonglong 0xa | 0x2 == 0xa (0xa) +int 0xa << 0x3 == 0x50 (0x50) +__uint 0xa << 0x3 == 0x50 (0x50) +char 0xa << 0x3 == 0x50 (0x50) +__uchar 0xa << 0x3 == 0x50 (0x50) +__longlong 0xa << 0x3 == 0x50 (0x50) +__ulonglong 0xa << 0x3 == 0x50 (0x50) +int 0xa >> 0x3 == 0x1 (0x1) +__uint 0xa >> 0x3 == 0x1 (0x1) +char 0xa >> 0x3 == 0x1 (0x1) +__uchar 0xa >> 0x3 == 0x1 (0x1) +__longlong 0xa >> 0x3 == 0x1 (0x1) +__ulonglong 0xa >> 0x3 == 0x1 (0x1) +int 0xa + 0x2 == 0xc (0xc) +__uint 0xa + 0x2 == 0xc (0xc) +char 0xa + 0x2 == 0xc (0xc) +__uchar 0xa + 0x2 == 0xc (0xc) +__longlong 0xa + 0x2 == 0xc (0xc) +__ulonglong 0xa + 0x2 == 0xc (0xc) +float 0xa + 0x2 == 0xc (0xc) +int 0xa - 0x2 == 0x8 (0x8) +__uint 0xa - 0x2 == 0x8 (0x8) +char 0xa - 0x2 == 0x8 (0x8) +__uchar 0xa - 0x2 == 0x8 (0x8) +__longlong 0xa - 0x2 == 0x8 (0x8) +__ulonglong 0xa - 0x2 == 0x8 (0x8) +float 0xa - 0x2 == 0x8 (0x8) +int 0xa * 0x2 == 0x14 (0x14) +__uint 0xa * 0x2 == 0x14 (0x14) +char 0xa * 0x2 == 0x14 (0x14) +__uchar 0xa * 0x2 == 0x14 (0x14) +__longlong 0xa * 0x2 == 0x14 (0x14) +__ulonglong 0xa * 0x2 == 0x14 (0x14) +float 0xa * 0x2 == 0x14 (0x14) +int 0xa < 0x2 == 0x0 (0x0) +__uint 0xa < 0x2 == 0x0 (0x0) +char 0xa < 0x2 == 0x0 (0x0) +__uchar 0xa < 0x2 == 0x0 (0x0) +__longlong 0xa < 0x2 == 0x0 (0x0) +__ulonglong 0xa < 0x2 == 0x0 (0x0) +float 0xa < 0x2 == 0x0 (0x0) +int 0xa > 0x2 == 0x1 (0x1) +__uint 0xa > 0x2 == 0x1 (0x1) +char 0xa > 0x2 == 0x1 (0x1) +__uchar 0xa > 0x2 == 0x1 (0x1) +__longlong 0xa > 0x2 == 0x1 (0x1) +__ulonglong 0xa > 0x2 == 0x1 (0x1) +float 0xa > 0x2 == 0x1 (0x1) +int 0xa <= 0x2 == 0x0 (0x0) +__uint 0xa <= 0x2 == 0x0 (0x0) +char 0xa <= 0x2 == 0x0 (0x0) +__uchar 0xa <= 0x2 == 0x0 (0x0) +__longlong 0xa <= 0x2 == 0x0 (0x0) +__ulonglong 0xa <= 0x2 == 0x0 (0x0) +float 0xa <= 0x2 == 0x0 (0x0) +int 0xa == 0x2 == 0x0 (0x0) +__uint 0xa == 0x2 == 0x0 (0x0) +char 0xa == 0x2 == 0x0 (0x0) +__uchar 0xa == 0x2 == 0x0 (0x0) +__longlong 0xa == 0x2 == 0x0 (0x0) +__ulonglong 0xa == 0x2 == 0x0 (0x0) +float 0xa == 0x2 == 0x0 (0x0) +int 0xa != 0x2 == 0x1 (0x1) +__uint 0xa != 0x2 == 0x1 (0x1) +char 0xa != 0x2 == 0x1 (0x1) +__uchar 0xa != 0x2 == 0x1 (0x1) +__longlong 0xa != 0x2 == 0x1 (0x1) +__ulonglong 0xa != 0x2 == 0x1 (0x1) +float 0xa != 0x2 == 0x1 (0x1) +int 0xa >= 0x2 == 0x1 (0x1) +__uint 0xa >= 0x2 == 0x1 (0x1) +char 0xa >= 0x2 == 0x1 (0x1) +__uchar 0xa >= 0x2 == 0x1 (0x1) +__longlong 0xa >= 0x2 == 0x1 (0x1) +__ulonglong 0xa >= 0x2 == 0x1 (0x1) +float 0xa >= 0x2 == 0x1 (0x1) +int 0xa / 0x2 == 0x5 (0x5) +__uint 0xa / 0x2 == 0x5 (0x5) +char 0xa / 0x2 == 0x5 (0x5) +__uchar 0xa / 0x2 == 0x5 (0x5) +__longlong 0xa / 0x2 == 0x5 (0x5) +__ulonglong 0xa / 0x2 == 0x5 (0x5) +float 0xa / 0x2 == 0x5 (0x5) +int 0xa % 0x2 == 0x0 (0x0) +__uint 0xa % 0x2 == 0x0 (0x0) +char 0xa % 0x2 == 0x0 (0x0) +__uchar 0xa % 0x2 == 0x0 (0x0) +__longlong 0xa % 0x2 == 0x0 (0x0) +__ulonglong 0xa % 0x2 == 0x0 (0x0) +0xa * 0xfffe == -0x14 +0xa / 0xfffe == -0x5 +0xa % 0xfffe == 0x0 +int 0xa ^ 0xfffe == -0xc (0xfff4) +__uint 0xa ^ 0xfffe == -0xc (0xfff4) +char 0xa ^ 0xfffe == -0xc (0xfff4) +__uchar 0xa ^ 0xfe == 0xf4 (0xf4) +__longlong 0xa ^ 0xfffe == -0xc (0xfff4) +__ulonglong 0xa ^ 0xfffe == -0xc (0xfff4) +int 0xa && 0xfffe == 0x1 (0x1) +__uint 0xa && 0xfffe == 0x1 (0x1) +char 0xa && 0xfffe == 0x1 (0x1) +__uchar 0xa && 0xfe == 0x1 (0x1) +__longlong 0xa && 0xfffe == 0x1 (0x1) +__ulonglong 0xa && 0xfffe == 0x1 (0x1) +int 0xa || 0xfffe == 0x1 (0x1) +__uint 0xa || 0xfffe == 0x1 (0x1) +char 0xa || 0xfffe == 0x1 (0x1) +__uchar 0xa || 0xfe == 0x1 (0x1) +__longlong 0xa || 0xfffe == 0x1 (0x1) +__ulonglong 0xa || 0xfffe == 0x1 (0x1) +int 0xa & 0xfffe == 0xa (0xa) +__uint 0xa & 0xfffe == 0xa (0xa) +char 0xa & 0xfffe == 0xa (0xa) +__uchar 0xa & 0xfe == 0xa (0xa) +__longlong 0xa & 0xfffe == 0xa (0xa) +__ulonglong 0xa & 0xfffe == 0xa (0xa) +int 0xa | 0xfffe == -0x2 (0xfffe) +__uint 0xa | 0xfffe == -0x2 (0xfffe) +char 0xa | 0xfffe == -0x2 (0xfffe) +__uchar 0xa | 0xfe == 0xfe (0xfe) +__longlong 0xa | 0xfffe == -0x2 (0xfffe) +__ulonglong 0xa | 0xfffe == -0x2 (0xfffe) +int 0xa << 0x4 == 0xa0 (0xa0) +__uint 0xa << 0x4 == 0xa0 (0xa0) +char 0xa << 0x4 == -0x60 (0xffa0) +__uchar 0xa << 0x4 == 0xa0 (0xa0) +__longlong 0xa << 0x4 == 0xa0 (0xa0) +__ulonglong 0xa << 0x4 == 0xa0 (0xa0) +int 0xa >> 0x4 == 0x0 (0x0) +__uint 0xa >> 0x4 == 0x0 (0x0) +char 0xa >> 0x4 == 0x0 (0x0) +__uchar 0xa >> 0x4 == 0x0 (0x0) +__longlong 0xa >> 0x4 == 0x0 (0x0) +__ulonglong 0xa >> 0x4 == 0x0 (0x0) +int 0xa + 0xfffe == 0x8 (0x8) +__uint 0xa + 0xfffe == 0x8 (0x8) +char 0xa + 0xfffe == 0x8 (0x8) +__uchar 0xa + 0xfe == 0x8 (0x8) +__longlong 0xa + 0xfffe == 0x8 (0x8) +__ulonglong 0xa + 0xfffe == 0x8 (0x8) +float 0xa + 0xfffe == 0x8 (0x8) +int 0xa - 0xfffe == 0xc (0xc) +__uint 0xa - 0xfffe == 0xc (0xc) +char 0xa - 0xfffe == 0xc (0xc) +__uchar 0xa - 0xfe == 0xc (0xc) +__longlong 0xa - 0xfffe == 0xc (0xc) +__ulonglong 0xa - 0xfffe == 0xc (0xc) +float 0xa - 0xfffe == 0xc (0xc) +int 0xa * 0xfffe == -0x14 (0xffec) +__uint 0xa * 0xfffe == -0x14 (0xffec) +char 0xa * 0xfffe == -0x14 (0xffec) +__uchar 0xa * 0xfe == 0xec (0xec) +__longlong 0xa * 0xfffe == -0x14 (0xffec) +__ulonglong 0xa * 0xfffe == -0x14 (0xffec) +float 0xa * 0xfffe == -0x14 (0xffec) +int 0xa < 0xfffe == 0x0 (0x0) +__uint 0xa < 0xfffe == 0x1 (0x1) +char 0xa < 0xfffe == 0x0 (0x0) +__uchar 0xa < 0xfe == 0x1 (0x1) +__longlong 0xa < 0xfffe == 0x0 (0x0) +__ulonglong 0xa < 0xfffe == 0x1 (0x1) +float 0xa < 0xfffe == 0x0 (0x0) +int 0xa > 0xfffe == 0x1 (0x1) +__uint 0xa > 0xfffe == 0x0 (0x0) +char 0xa > 0xfffe == 0x1 (0x1) +__uchar 0xa > 0xfe == 0x0 (0x0) +__longlong 0xa > 0xfffe == 0x1 (0x1) +__ulonglong 0xa > 0xfffe == 0x0 (0x0) +float 0xa > 0xfffe == 0x1 (0x1) +int 0xa <= 0xfffe == 0x0 (0x0) +__uint 0xa <= 0xfffe == 0x1 (0x1) +char 0xa <= 0xfffe == 0x0 (0x0) +__uchar 0xa <= 0xfe == 0x1 (0x1) +__longlong 0xa <= 0xfffe == 0x0 (0x0) +__ulonglong 0xa <= 0xfffe == 0x1 (0x1) +float 0xa <= 0xfffe == 0x0 (0x0) +int 0xa == 0xfffe == 0x0 (0x0) +__uint 0xa == 0xfffe == 0x0 (0x0) +char 0xa == 0xfffe == 0x0 (0x0) +__uchar 0xa == 0xfe == 0x0 (0x0) +__longlong 0xa == 0xfffe == 0x0 (0x0) +__ulonglong 0xa == 0xfffe == 0x0 (0x0) +float 0xa == 0xfffe == 0x0 (0x0) +int 0xa != 0xfffe == 0x1 (0x1) +__uint 0xa != 0xfffe == 0x1 (0x1) +char 0xa != 0xfffe == 0x1 (0x1) +__uchar 0xa != 0xfe == 0x1 (0x1) +__longlong 0xa != 0xfffe == 0x1 (0x1) +__ulonglong 0xa != 0xfffe == 0x1 (0x1) +float 0xa != 0xfffe == 0x1 (0x1) +int 0xa >= 0xfffe == 0x1 (0x1) +__uint 0xa >= 0xfffe == 0x0 (0x0) +char 0xa >= 0xfffe == 0x1 (0x1) +__uchar 0xa >= 0xfe == 0x0 (0x0) +__longlong 0xa >= 0xfffe == 0x1 (0x1) +__ulonglong 0xa >= 0xfffe == 0x0 (0x0) +float 0xa >= 0xfffe == 0x1 (0x1) +int 0xa / 0xfffe == -0x5 (0xfffb) +__uint 0xa / 0xfffe == 0x0 (0x0) +char 0xa / 0xfffe == -0x5 (0xfffb) +__uchar 0xa / 0xfe == 0x0 (0x0) +__longlong 0xa / 0xfffe == -0x5 (0xfffb) +__ulonglong 0xa / 0xfffe == 0x0 (0x0) +float 0xa / 0xfffe == -0x5 (0xfffb) +int 0xa % 0xfffe == 0x0 (0x0) +__uint 0xa % 0xfffe == 0xa (0xa) +char 0xa % 0xfffe == 0x0 (0x0) +__uchar 0xa % 0xfe == 0xa (0xa) +__longlong 0xa % 0xfffe == 0x0 (0x0) +__ulonglong 0xa % 0xfffe == 0xa (0xa) +0xa * 0x4 == 0x28 +0xa / 0x4 == 0x2 +0xa % 0x4 == 0x2 +int 0xa ^ 0x4 == 0xe (0xe) +__uint 0xa ^ 0x4 == 0xe (0xe) +char 0xa ^ 0x4 == 0xe (0xe) +__uchar 0xa ^ 0x4 == 0xe (0xe) +__longlong 0xa ^ 0x4 == 0xe (0xe) +__ulonglong 0xa ^ 0x4 == 0xe (0xe) +int 0xa && 0x4 == 0x1 (0x1) +__uint 0xa && 0x4 == 0x1 (0x1) +char 0xa && 0x4 == 0x1 (0x1) +__uchar 0xa && 0x4 == 0x1 (0x1) +__longlong 0xa && 0x4 == 0x1 (0x1) +__ulonglong 0xa && 0x4 == 0x1 (0x1) +int 0xa || 0x4 == 0x1 (0x1) +__uint 0xa || 0x4 == 0x1 (0x1) +char 0xa || 0x4 == 0x1 (0x1) +__uchar 0xa || 0x4 == 0x1 (0x1) +__longlong 0xa || 0x4 == 0x1 (0x1) +__ulonglong 0xa || 0x4 == 0x1 (0x1) +int 0xa & 0x4 == 0x0 (0x0) +__uint 0xa & 0x4 == 0x0 (0x0) +char 0xa & 0x4 == 0x0 (0x0) +__uchar 0xa & 0x4 == 0x0 (0x0) +__longlong 0xa & 0x4 == 0x0 (0x0) +__ulonglong 0xa & 0x4 == 0x0 (0x0) +int 0xa | 0x4 == 0xe (0xe) +__uint 0xa | 0x4 == 0xe (0xe) +char 0xa | 0x4 == 0xe (0xe) +__uchar 0xa | 0x4 == 0xe (0xe) +__longlong 0xa | 0x4 == 0xe (0xe) +__ulonglong 0xa | 0x4 == 0xe (0xe) +int 0xa << 0x5 == 0x140 (0x140) +__uint 0xa << 0x5 == 0x140 (0x140) +char 0xa << 0x5 == 0x40 (0x40) +__uchar 0xa << 0x5 == 0x40 (0x40) +__longlong 0xa << 0x5 == 0x140 (0x140) +__ulonglong 0xa << 0x5 == 0x140 (0x140) +int 0xa >> 0x5 == 0x0 (0x0) +__uint 0xa >> 0x5 == 0x0 (0x0) +char 0xa >> 0x5 == 0x0 (0x0) +__uchar 0xa >> 0x5 == 0x0 (0x0) +__longlong 0xa >> 0x5 == 0x0 (0x0) +__ulonglong 0xa >> 0x5 == 0x0 (0x0) +int 0xa + 0x4 == 0xe (0xe) +__uint 0xa + 0x4 == 0xe (0xe) +char 0xa + 0x4 == 0xe (0xe) +__uchar 0xa + 0x4 == 0xe (0xe) +__longlong 0xa + 0x4 == 0xe (0xe) +__ulonglong 0xa + 0x4 == 0xe (0xe) +float 0xa + 0x4 == 0xe (0xe) +int 0xa - 0x4 == 0x6 (0x6) +__uint 0xa - 0x4 == 0x6 (0x6) +char 0xa - 0x4 == 0x6 (0x6) +__uchar 0xa - 0x4 == 0x6 (0x6) +__longlong 0xa - 0x4 == 0x6 (0x6) +__ulonglong 0xa - 0x4 == 0x6 (0x6) +float 0xa - 0x4 == 0x6 (0x6) +int 0xa * 0x4 == 0x28 (0x28) +__uint 0xa * 0x4 == 0x28 (0x28) +char 0xa * 0x4 == 0x28 (0x28) +__uchar 0xa * 0x4 == 0x28 (0x28) +__longlong 0xa * 0x4 == 0x28 (0x28) +__ulonglong 0xa * 0x4 == 0x28 (0x28) +float 0xa * 0x4 == 0x28 (0x28) +int 0xa < 0x4 == 0x0 (0x0) +__uint 0xa < 0x4 == 0x0 (0x0) +char 0xa < 0x4 == 0x0 (0x0) +__uchar 0xa < 0x4 == 0x0 (0x0) +__longlong 0xa < 0x4 == 0x0 (0x0) +__ulonglong 0xa < 0x4 == 0x0 (0x0) +float 0xa < 0x4 == 0x0 (0x0) +int 0xa > 0x4 == 0x1 (0x1) +__uint 0xa > 0x4 == 0x1 (0x1) +char 0xa > 0x4 == 0x1 (0x1) +__uchar 0xa > 0x4 == 0x1 (0x1) +__longlong 0xa > 0x4 == 0x1 (0x1) +__ulonglong 0xa > 0x4 == 0x1 (0x1) +float 0xa > 0x4 == 0x1 (0x1) +int 0xa <= 0x4 == 0x0 (0x0) +__uint 0xa <= 0x4 == 0x0 (0x0) +char 0xa <= 0x4 == 0x0 (0x0) +__uchar 0xa <= 0x4 == 0x0 (0x0) +__longlong 0xa <= 0x4 == 0x0 (0x0) +__ulonglong 0xa <= 0x4 == 0x0 (0x0) +float 0xa <= 0x4 == 0x0 (0x0) +int 0xa == 0x4 == 0x0 (0x0) +__uint 0xa == 0x4 == 0x0 (0x0) +char 0xa == 0x4 == 0x0 (0x0) +__uchar 0xa == 0x4 == 0x0 (0x0) +__longlong 0xa == 0x4 == 0x0 (0x0) +__ulonglong 0xa == 0x4 == 0x0 (0x0) +float 0xa == 0x4 == 0x0 (0x0) +int 0xa != 0x4 == 0x1 (0x1) +__uint 0xa != 0x4 == 0x1 (0x1) +char 0xa != 0x4 == 0x1 (0x1) +__uchar 0xa != 0x4 == 0x1 (0x1) +__longlong 0xa != 0x4 == 0x1 (0x1) +__ulonglong 0xa != 0x4 == 0x1 (0x1) +float 0xa != 0x4 == 0x1 (0x1) +int 0xa >= 0x4 == 0x1 (0x1) +__uint 0xa >= 0x4 == 0x1 (0x1) +char 0xa >= 0x4 == 0x1 (0x1) +__uchar 0xa >= 0x4 == 0x1 (0x1) +__longlong 0xa >= 0x4 == 0x1 (0x1) +__ulonglong 0xa >= 0x4 == 0x1 (0x1) +float 0xa >= 0x4 == 0x1 (0x1) +int 0xa / 0x4 == 0x2 (0x2) +__uint 0xa / 0x4 == 0x2 (0x2) +char 0xa / 0x4 == 0x2 (0x2) +__uchar 0xa / 0x4 == 0x2 (0x2) +__longlong 0xa / 0x4 == 0x2 (0x2) +__ulonglong 0xa / 0x4 == 0x2 (0x2) +float 0xa / 0x4 == 0x2 (0x2) +int 0xa % 0x4 == 0x2 (0x2) +__uint 0xa % 0x4 == 0x2 (0x2) +char 0xa % 0x4 == 0x2 (0x2) +__uchar 0xa % 0x4 == 0x2 (0x2) +__longlong 0xa % 0x4 == 0x2 (0x2) +__ulonglong 0xa % 0x4 == 0x2 (0x2) +0xa * 0xfffc == -0x28 +0xa / 0xfffc == -0x2 +0xa % 0xfffc == 0x2 +int 0xa ^ 0xfffc == -0xa (0xfff6) +__uint 0xa ^ 0xfffc == -0xa (0xfff6) +char 0xa ^ 0xfffc == -0xa (0xfff6) +__uchar 0xa ^ 0xfc == 0xf6 (0xf6) +__longlong 0xa ^ 0xfffc == -0xa (0xfff6) +__ulonglong 0xa ^ 0xfffc == -0xa (0xfff6) +int 0xa && 0xfffc == 0x1 (0x1) +__uint 0xa && 0xfffc == 0x1 (0x1) +char 0xa && 0xfffc == 0x1 (0x1) +__uchar 0xa && 0xfc == 0x1 (0x1) +__longlong 0xa && 0xfffc == 0x1 (0x1) +__ulonglong 0xa && 0xfffc == 0x1 (0x1) +int 0xa || 0xfffc == 0x1 (0x1) +__uint 0xa || 0xfffc == 0x1 (0x1) +char 0xa || 0xfffc == 0x1 (0x1) +__uchar 0xa || 0xfc == 0x1 (0x1) +__longlong 0xa || 0xfffc == 0x1 (0x1) +__ulonglong 0xa || 0xfffc == 0x1 (0x1) +int 0xa & 0xfffc == 0x8 (0x8) +__uint 0xa & 0xfffc == 0x8 (0x8) +char 0xa & 0xfffc == 0x8 (0x8) +__uchar 0xa & 0xfc == 0x8 (0x8) +__longlong 0xa & 0xfffc == 0x8 (0x8) +__ulonglong 0xa & 0xfffc == 0x8 (0x8) +int 0xa | 0xfffc == -0x2 (0xfffe) +__uint 0xa | 0xfffc == -0x2 (0xfffe) +char 0xa | 0xfffc == -0x2 (0xfffe) +__uchar 0xa | 0xfc == 0xfe (0xfe) +__longlong 0xa | 0xfffc == -0x2 (0xfffe) +__ulonglong 0xa | 0xfffc == -0x2 (0xfffe) +int 0xa << 0x6 == 0x280 (0x280) +__uint 0xa << 0x6 == 0x280 (0x280) +char 0xa << 0x6 == -0x80 (0xff80) +__uchar 0xa << 0x6 == 0x80 (0x80) +__longlong 0xa << 0x6 == 0x280 (0x280) +__ulonglong 0xa << 0x6 == 0x280 (0x280) +int 0xa >> 0x6 == 0x0 (0x0) +__uint 0xa >> 0x6 == 0x0 (0x0) +char 0xa >> 0x6 == 0x0 (0x0) +__uchar 0xa >> 0x6 == 0x0 (0x0) +__longlong 0xa >> 0x6 == 0x0 (0x0) +__ulonglong 0xa >> 0x6 == 0x0 (0x0) +int 0xa + 0xfffc == 0x6 (0x6) +__uint 0xa + 0xfffc == 0x6 (0x6) +char 0xa + 0xfffc == 0x6 (0x6) +__uchar 0xa + 0xfc == 0x6 (0x6) +__longlong 0xa + 0xfffc == 0x6 (0x6) +__ulonglong 0xa + 0xfffc == 0x6 (0x6) +float 0xa + 0xfffc == 0x6 (0x6) +int 0xa - 0xfffc == 0xe (0xe) +__uint 0xa - 0xfffc == 0xe (0xe) +char 0xa - 0xfffc == 0xe (0xe) +__uchar 0xa - 0xfc == 0xe (0xe) +__longlong 0xa - 0xfffc == 0xe (0xe) +__ulonglong 0xa - 0xfffc == 0xe (0xe) +float 0xa - 0xfffc == 0xe (0xe) +int 0xa * 0xfffc == -0x28 (0xffd8) +__uint 0xa * 0xfffc == -0x28 (0xffd8) +char 0xa * 0xfffc == -0x28 (0xffd8) +__uchar 0xa * 0xfc == 0xd8 (0xd8) +__longlong 0xa * 0xfffc == -0x28 (0xffd8) +__ulonglong 0xa * 0xfffc == -0x28 (0xffd8) +float 0xa * 0xfffc == -0x28 (0xffd8) +int 0xa < 0xfffc == 0x0 (0x0) +__uint 0xa < 0xfffc == 0x1 (0x1) +char 0xa < 0xfffc == 0x0 (0x0) +__uchar 0xa < 0xfc == 0x1 (0x1) +__longlong 0xa < 0xfffc == 0x0 (0x0) +__ulonglong 0xa < 0xfffc == 0x1 (0x1) +float 0xa < 0xfffc == 0x0 (0x0) +int 0xa > 0xfffc == 0x1 (0x1) +__uint 0xa > 0xfffc == 0x0 (0x0) +char 0xa > 0xfffc == 0x1 (0x1) +__uchar 0xa > 0xfc == 0x0 (0x0) +__longlong 0xa > 0xfffc == 0x1 (0x1) +__ulonglong 0xa > 0xfffc == 0x0 (0x0) +float 0xa > 0xfffc == 0x1 (0x1) +int 0xa <= 0xfffc == 0x0 (0x0) +__uint 0xa <= 0xfffc == 0x1 (0x1) +char 0xa <= 0xfffc == 0x0 (0x0) +__uchar 0xa <= 0xfc == 0x1 (0x1) +__longlong 0xa <= 0xfffc == 0x0 (0x0) +__ulonglong 0xa <= 0xfffc == 0x1 (0x1) +float 0xa <= 0xfffc == 0x0 (0x0) +int 0xa == 0xfffc == 0x0 (0x0) +__uint 0xa == 0xfffc == 0x0 (0x0) +char 0xa == 0xfffc == 0x0 (0x0) +__uchar 0xa == 0xfc == 0x0 (0x0) +__longlong 0xa == 0xfffc == 0x0 (0x0) +__ulonglong 0xa == 0xfffc == 0x0 (0x0) +float 0xa == 0xfffc == 0x0 (0x0) +int 0xa != 0xfffc == 0x1 (0x1) +__uint 0xa != 0xfffc == 0x1 (0x1) +char 0xa != 0xfffc == 0x1 (0x1) +__uchar 0xa != 0xfc == 0x1 (0x1) +__longlong 0xa != 0xfffc == 0x1 (0x1) +__ulonglong 0xa != 0xfffc == 0x1 (0x1) +float 0xa != 0xfffc == 0x1 (0x1) +int 0xa >= 0xfffc == 0x1 (0x1) +__uint 0xa >= 0xfffc == 0x0 (0x0) +char 0xa >= 0xfffc == 0x1 (0x1) +__uchar 0xa >= 0xfc == 0x0 (0x0) +__longlong 0xa >= 0xfffc == 0x1 (0x1) +__ulonglong 0xa >= 0xfffc == 0x0 (0x0) +float 0xa >= 0xfffc == 0x1 (0x1) +int 0xa / 0xfffc == -0x2 (0xfffe) +__uint 0xa / 0xfffc == 0x0 (0x0) +char 0xa / 0xfffc == -0x2 (0xfffe) +__uchar 0xa / 0xfc == 0x0 (0x0) +__longlong 0xa / 0xfffc == -0x2 (0xfffe) +__ulonglong 0xa / 0xfffc == 0x0 (0x0) +float 0xa / 0xfffc == -0x2 (0xfffe) +int 0xa % 0xfffc == 0x2 (0x2) +__uint 0xa % 0xfffc == 0xa (0xa) +char 0xa % 0xfffc == 0x2 (0x2) +__uchar 0xa % 0xfc == 0xa (0xa) +__longlong 0xa % 0xfffc == 0x2 (0x2) +__ulonglong 0xa % 0xfffc == 0xa (0xa) +0xa * 0xa == 0x64 +0xa / 0xa == 0x1 +0xa % 0xa == 0x0 +int 0xa ^ 0xa == 0x0 (0x0) +__uint 0xa ^ 0xa == 0x0 (0x0) +char 0xa ^ 0xa == 0x0 (0x0) +__uchar 0xa ^ 0xa == 0x0 (0x0) +__longlong 0xa ^ 0xa == 0x0 (0x0) +__ulonglong 0xa ^ 0xa == 0x0 (0x0) +int 0xa && 0xa == 0x1 (0x1) +__uint 0xa && 0xa == 0x1 (0x1) +char 0xa && 0xa == 0x1 (0x1) +__uchar 0xa && 0xa == 0x1 (0x1) +__longlong 0xa && 0xa == 0x1 (0x1) +__ulonglong 0xa && 0xa == 0x1 (0x1) +int 0xa || 0xa == 0x1 (0x1) +__uint 0xa || 0xa == 0x1 (0x1) +char 0xa || 0xa == 0x1 (0x1) +__uchar 0xa || 0xa == 0x1 (0x1) +__longlong 0xa || 0xa == 0x1 (0x1) +__ulonglong 0xa || 0xa == 0x1 (0x1) +int 0xa & 0xa == 0xa (0xa) +__uint 0xa & 0xa == 0xa (0xa) +char 0xa & 0xa == 0xa (0xa) +__uchar 0xa & 0xa == 0xa (0xa) +__longlong 0xa & 0xa == 0xa (0xa) +__ulonglong 0xa & 0xa == 0xa (0xa) +int 0xa | 0xa == 0xa (0xa) +__uint 0xa | 0xa == 0xa (0xa) +char 0xa | 0xa == 0xa (0xa) +__uchar 0xa | 0xa == 0xa (0xa) +__longlong 0xa | 0xa == 0xa (0xa) +__ulonglong 0xa | 0xa == 0xa (0xa) +int 0xa << 0x7 == 0x500 (0x500) +__uint 0xa << 0x7 == 0x500 (0x500) +char 0xa << 0x7 == 0x0 (0x0) +__uchar 0xa << 0x7 == 0x0 (0x0) +__longlong 0xa << 0x7 == 0x500 (0x500) +__ulonglong 0xa << 0x7 == 0x500 (0x500) +int 0xa >> 0x7 == 0x0 (0x0) +__uint 0xa >> 0x7 == 0x0 (0x0) +char 0xa >> 0x7 == 0x0 (0x0) +__uchar 0xa >> 0x7 == 0x0 (0x0) +__longlong 0xa >> 0x7 == 0x0 (0x0) +__ulonglong 0xa >> 0x7 == 0x0 (0x0) +int 0xa + 0xa == 0x14 (0x14) +__uint 0xa + 0xa == 0x14 (0x14) +char 0xa + 0xa == 0x14 (0x14) +__uchar 0xa + 0xa == 0x14 (0x14) +__longlong 0xa + 0xa == 0x14 (0x14) +__ulonglong 0xa + 0xa == 0x14 (0x14) +float 0xa + 0xa == 0x14 (0x14) +int 0xa - 0xa == 0x0 (0x0) +__uint 0xa - 0xa == 0x0 (0x0) +char 0xa - 0xa == 0x0 (0x0) +__uchar 0xa - 0xa == 0x0 (0x0) +__longlong 0xa - 0xa == 0x0 (0x0) +__ulonglong 0xa - 0xa == 0x0 (0x0) +float 0xa - 0xa == 0x0 (0x0) +int 0xa * 0xa == 0x64 (0x64) +__uint 0xa * 0xa == 0x64 (0x64) +char 0xa * 0xa == 0x64 (0x64) +__uchar 0xa * 0xa == 0x64 (0x64) +__longlong 0xa * 0xa == 0x64 (0x64) +__ulonglong 0xa * 0xa == 0x64 (0x64) +float 0xa * 0xa == 0x64 (0x64) +int 0xa < 0xa == 0x0 (0x0) +__uint 0xa < 0xa == 0x0 (0x0) +char 0xa < 0xa == 0x0 (0x0) +__uchar 0xa < 0xa == 0x0 (0x0) +__longlong 0xa < 0xa == 0x0 (0x0) +__ulonglong 0xa < 0xa == 0x0 (0x0) +float 0xa < 0xa == 0x0 (0x0) +int 0xa > 0xa == 0x0 (0x0) +__uint 0xa > 0xa == 0x0 (0x0) +char 0xa > 0xa == 0x0 (0x0) +__uchar 0xa > 0xa == 0x0 (0x0) +__longlong 0xa > 0xa == 0x0 (0x0) +__ulonglong 0xa > 0xa == 0x0 (0x0) +float 0xa > 0xa == 0x0 (0x0) +int 0xa <= 0xa == 0x1 (0x1) +__uint 0xa <= 0xa == 0x1 (0x1) +char 0xa <= 0xa == 0x1 (0x1) +__uchar 0xa <= 0xa == 0x1 (0x1) +__longlong 0xa <= 0xa == 0x1 (0x1) +__ulonglong 0xa <= 0xa == 0x1 (0x1) +float 0xa <= 0xa == 0x1 (0x1) +int 0xa == 0xa == 0x1 (0x1) +__uint 0xa == 0xa == 0x1 (0x1) +char 0xa == 0xa == 0x1 (0x1) +__uchar 0xa == 0xa == 0x1 (0x1) +__longlong 0xa == 0xa == 0x1 (0x1) +__ulonglong 0xa == 0xa == 0x1 (0x1) +float 0xa == 0xa == 0x1 (0x1) +int 0xa != 0xa == 0x0 (0x0) +__uint 0xa != 0xa == 0x0 (0x0) +char 0xa != 0xa == 0x0 (0x0) +__uchar 0xa != 0xa == 0x0 (0x0) +__longlong 0xa != 0xa == 0x0 (0x0) +__ulonglong 0xa != 0xa == 0x0 (0x0) +float 0xa != 0xa == 0x0 (0x0) +int 0xa >= 0xa == 0x1 (0x1) +__uint 0xa >= 0xa == 0x1 (0x1) +char 0xa >= 0xa == 0x1 (0x1) +__uchar 0xa >= 0xa == 0x1 (0x1) +__longlong 0xa >= 0xa == 0x1 (0x1) +__ulonglong 0xa >= 0xa == 0x1 (0x1) +float 0xa >= 0xa == 0x1 (0x1) +int 0xa / 0xa == 0x1 (0x1) +__uint 0xa / 0xa == 0x1 (0x1) +char 0xa / 0xa == 0x1 (0x1) +__uchar 0xa / 0xa == 0x1 (0x1) +__longlong 0xa / 0xa == 0x1 (0x1) +__ulonglong 0xa / 0xa == 0x1 (0x1) +float 0xa / 0xa == 0x1 (0x1) +int 0xa % 0xa == 0x0 (0x0) +__uint 0xa % 0xa == 0x0 (0x0) +char 0xa % 0xa == 0x0 (0x0) +__uchar 0xa % 0xa == 0x0 (0x0) +__longlong 0xa % 0xa == 0x0 (0x0) +__ulonglong 0xa % 0xa == 0x0 (0x0) +0xa * 0xfff6 == -0x64 +0xa / 0xfff6 == -0x1 +0xa % 0xfff6 == 0x0 +int 0xa ^ 0xfff6 == -0x4 (0xfffc) +__uint 0xa ^ 0xfff6 == -0x4 (0xfffc) +char 0xa ^ 0xfff6 == -0x4 (0xfffc) +__uchar 0xa ^ 0xf6 == 0xfc (0xfc) +__longlong 0xa ^ 0xfff6 == -0x4 (0xfffc) +__ulonglong 0xa ^ 0xfff6 == -0x4 (0xfffc) +int 0xa && 0xfff6 == 0x1 (0x1) +__uint 0xa && 0xfff6 == 0x1 (0x1) +char 0xa && 0xfff6 == 0x1 (0x1) +__uchar 0xa && 0xf6 == 0x1 (0x1) +__longlong 0xa && 0xfff6 == 0x1 (0x1) +__ulonglong 0xa && 0xfff6 == 0x1 (0x1) +int 0xa || 0xfff6 == 0x1 (0x1) +__uint 0xa || 0xfff6 == 0x1 (0x1) +char 0xa || 0xfff6 == 0x1 (0x1) +__uchar 0xa || 0xf6 == 0x1 (0x1) +__longlong 0xa || 0xfff6 == 0x1 (0x1) +__ulonglong 0xa || 0xfff6 == 0x1 (0x1) +int 0xa & 0xfff6 == 0x2 (0x2) +__uint 0xa & 0xfff6 == 0x2 (0x2) +char 0xa & 0xfff6 == 0x2 (0x2) +__uchar 0xa & 0xf6 == 0x2 (0x2) +__longlong 0xa & 0xfff6 == 0x2 (0x2) +__ulonglong 0xa & 0xfff6 == 0x2 (0x2) +int 0xa | 0xfff6 == -0x2 (0xfffe) +__uint 0xa | 0xfff6 == -0x2 (0xfffe) +char 0xa | 0xfff6 == -0x2 (0xfffe) +__uchar 0xa | 0xf6 == 0xfe (0xfe) +__longlong 0xa | 0xfff6 == -0x2 (0xfffe) +__ulonglong 0xa | 0xfff6 == -0x2 (0xfffe) +int 0xa << 0x8 == 0xa00 (0xa00) +__uint 0xa << 0x8 == 0xa00 (0xa00) +char 0xa << 0x8 == 0x0 (0x0) +__uchar 0xa << 0x8 == 0x0 (0x0) +__longlong 0xa << 0x8 == 0xa00 (0xa00) +__ulonglong 0xa << 0x8 == 0xa00 (0xa00) +int 0xa >> 0x8 == 0x0 (0x0) +__uint 0xa >> 0x8 == 0x0 (0x0) +char 0xa >> 0x8 == 0x0 (0x0) +__uchar 0xa >> 0x8 == 0x0 (0x0) +__longlong 0xa >> 0x8 == 0x0 (0x0) +__ulonglong 0xa >> 0x8 == 0x0 (0x0) +int 0xa + 0xfff6 == 0x0 (0x0) +__uint 0xa + 0xfff6 == 0x0 (0x0) +char 0xa + 0xfff6 == 0x0 (0x0) +__uchar 0xa + 0xf6 == 0x0 (0x0) +__longlong 0xa + 0xfff6 == 0x0 (0x0) +__ulonglong 0xa + 0xfff6 == 0x0 (0x0) +float 0xa + 0xfff6 == 0x0 (0x0) +int 0xa - 0xfff6 == 0x14 (0x14) +__uint 0xa - 0xfff6 == 0x14 (0x14) +char 0xa - 0xfff6 == 0x14 (0x14) +__uchar 0xa - 0xf6 == 0x14 (0x14) +__longlong 0xa - 0xfff6 == 0x14 (0x14) +__ulonglong 0xa - 0xfff6 == 0x14 (0x14) +float 0xa - 0xfff6 == 0x14 (0x14) +int 0xa * 0xfff6 == -0x64 (0xff9c) +__uint 0xa * 0xfff6 == -0x64 (0xff9c) +char 0xa * 0xfff6 == -0x64 (0xff9c) +__uchar 0xa * 0xf6 == 0x9c (0x9c) +__longlong 0xa * 0xfff6 == -0x64 (0xff9c) +__ulonglong 0xa * 0xfff6 == -0x64 (0xff9c) +float 0xa * 0xfff6 == -0x64 (0xff9c) +int 0xa < 0xfff6 == 0x0 (0x0) +__uint 0xa < 0xfff6 == 0x1 (0x1) +char 0xa < 0xfff6 == 0x0 (0x0) +__uchar 0xa < 0xf6 == 0x1 (0x1) +__longlong 0xa < 0xfff6 == 0x0 (0x0) +__ulonglong 0xa < 0xfff6 == 0x1 (0x1) +float 0xa < 0xfff6 == 0x0 (0x0) +int 0xa > 0xfff6 == 0x1 (0x1) +__uint 0xa > 0xfff6 == 0x0 (0x0) +char 0xa > 0xfff6 == 0x1 (0x1) +__uchar 0xa > 0xf6 == 0x0 (0x0) +__longlong 0xa > 0xfff6 == 0x1 (0x1) +__ulonglong 0xa > 0xfff6 == 0x0 (0x0) +float 0xa > 0xfff6 == 0x1 (0x1) +int 0xa <= 0xfff6 == 0x0 (0x0) +__uint 0xa <= 0xfff6 == 0x1 (0x1) +char 0xa <= 0xfff6 == 0x0 (0x0) +__uchar 0xa <= 0xf6 == 0x1 (0x1) +__longlong 0xa <= 0xfff6 == 0x0 (0x0) +__ulonglong 0xa <= 0xfff6 == 0x1 (0x1) +float 0xa <= 0xfff6 == 0x0 (0x0) +int 0xa == 0xfff6 == 0x0 (0x0) +__uint 0xa == 0xfff6 == 0x0 (0x0) +char 0xa == 0xfff6 == 0x0 (0x0) +__uchar 0xa == 0xf6 == 0x0 (0x0) +__longlong 0xa == 0xfff6 == 0x0 (0x0) +__ulonglong 0xa == 0xfff6 == 0x0 (0x0) +float 0xa == 0xfff6 == 0x0 (0x0) +int 0xa != 0xfff6 == 0x1 (0x1) +__uint 0xa != 0xfff6 == 0x1 (0x1) +char 0xa != 0xfff6 == 0x1 (0x1) +__uchar 0xa != 0xf6 == 0x1 (0x1) +__longlong 0xa != 0xfff6 == 0x1 (0x1) +__ulonglong 0xa != 0xfff6 == 0x1 (0x1) +float 0xa != 0xfff6 == 0x1 (0x1) +int 0xa >= 0xfff6 == 0x1 (0x1) +__uint 0xa >= 0xfff6 == 0x0 (0x0) +char 0xa >= 0xfff6 == 0x1 (0x1) +__uchar 0xa >= 0xf6 == 0x0 (0x0) +__longlong 0xa >= 0xfff6 == 0x1 (0x1) +__ulonglong 0xa >= 0xfff6 == 0x0 (0x0) +float 0xa >= 0xfff6 == 0x1 (0x1) +int 0xa / 0xfff6 == -0x1 (0xffff) +__uint 0xa / 0xfff6 == 0x0 (0x0) +char 0xa / 0xfff6 == -0x1 (0xffff) +__uchar 0xa / 0xf6 == 0x0 (0x0) +__longlong 0xa / 0xfff6 == -0x1 (0xffff) +__ulonglong 0xa / 0xfff6 == 0x0 (0x0) +float 0xa / 0xfff6 == -0x1 (0xffff) +int 0xa % 0xfff6 == 0x0 (0x0) +__uint 0xa % 0xfff6 == 0xa (0xa) +char 0xa % 0xfff6 == 0x0 (0x0) +__uchar 0xa % 0xf6 == 0xa (0xa) +__longlong 0xa % 0xfff6 == 0x0 (0x0) +__ulonglong 0xa % 0xfff6 == 0xa (0xa) +0xa * 0x5 == 0x32 +0xa / 0x5 == 0x2 +0xa % 0x5 == 0x0 +int 0xa ^ 0x5 == 0xf (0xf) +__uint 0xa ^ 0x5 == 0xf (0xf) +char 0xa ^ 0x5 == 0xf (0xf) +__uchar 0xa ^ 0x5 == 0xf (0xf) +__longlong 0xa ^ 0x5 == 0xf (0xf) +__ulonglong 0xa ^ 0x5 == 0xf (0xf) +int 0xa && 0x5 == 0x1 (0x1) +__uint 0xa && 0x5 == 0x1 (0x1) +char 0xa && 0x5 == 0x1 (0x1) +__uchar 0xa && 0x5 == 0x1 (0x1) +__longlong 0xa && 0x5 == 0x1 (0x1) +__ulonglong 0xa && 0x5 == 0x1 (0x1) +int 0xa || 0x5 == 0x1 (0x1) +__uint 0xa || 0x5 == 0x1 (0x1) +char 0xa || 0x5 == 0x1 (0x1) +__uchar 0xa || 0x5 == 0x1 (0x1) +__longlong 0xa || 0x5 == 0x1 (0x1) +__ulonglong 0xa || 0x5 == 0x1 (0x1) +int 0xa & 0x5 == 0x0 (0x0) +__uint 0xa & 0x5 == 0x0 (0x0) +char 0xa & 0x5 == 0x0 (0x0) +__uchar 0xa & 0x5 == 0x0 (0x0) +__longlong 0xa & 0x5 == 0x0 (0x0) +__ulonglong 0xa & 0x5 == 0x0 (0x0) +int 0xa | 0x5 == 0xf (0xf) +__uint 0xa | 0x5 == 0xf (0xf) +char 0xa | 0x5 == 0xf (0xf) +__uchar 0xa | 0x5 == 0xf (0xf) +__longlong 0xa | 0x5 == 0xf (0xf) +__ulonglong 0xa | 0x5 == 0xf (0xf) +int 0xa << 0x9 == 0x1400 (0x1400) +__uint 0xa << 0x9 == 0x1400 (0x1400) +char 0xa << 0x9 == 0x0 (0x0) +__uchar 0xa << 0x9 == 0x0 (0x0) +__longlong 0xa << 0x9 == 0x1400 (0x1400) +__ulonglong 0xa << 0x9 == 0x1400 (0x1400) +int 0xa >> 0x9 == 0x0 (0x0) +__uint 0xa >> 0x9 == 0x0 (0x0) +char 0xa >> 0x9 == 0x0 (0x0) +__uchar 0xa >> 0x9 == 0x0 (0x0) +__longlong 0xa >> 0x9 == 0x0 (0x0) +__ulonglong 0xa >> 0x9 == 0x0 (0x0) +int 0xa + 0x5 == 0xf (0xf) +__uint 0xa + 0x5 == 0xf (0xf) +char 0xa + 0x5 == 0xf (0xf) +__uchar 0xa + 0x5 == 0xf (0xf) +__longlong 0xa + 0x5 == 0xf (0xf) +__ulonglong 0xa + 0x5 == 0xf (0xf) +float 0xa + 0x5 == 0xf (0xf) +int 0xa - 0x5 == 0x5 (0x5) +__uint 0xa - 0x5 == 0x5 (0x5) +char 0xa - 0x5 == 0x5 (0x5) +__uchar 0xa - 0x5 == 0x5 (0x5) +__longlong 0xa - 0x5 == 0x5 (0x5) +__ulonglong 0xa - 0x5 == 0x5 (0x5) +float 0xa - 0x5 == 0x5 (0x5) +int 0xa * 0x5 == 0x32 (0x32) +__uint 0xa * 0x5 == 0x32 (0x32) +char 0xa * 0x5 == 0x32 (0x32) +__uchar 0xa * 0x5 == 0x32 (0x32) +__longlong 0xa * 0x5 == 0x32 (0x32) +__ulonglong 0xa * 0x5 == 0x32 (0x32) +float 0xa * 0x5 == 0x32 (0x32) +int 0xa < 0x5 == 0x0 (0x0) +__uint 0xa < 0x5 == 0x0 (0x0) +char 0xa < 0x5 == 0x0 (0x0) +__uchar 0xa < 0x5 == 0x0 (0x0) +__longlong 0xa < 0x5 == 0x0 (0x0) +__ulonglong 0xa < 0x5 == 0x0 (0x0) +float 0xa < 0x5 == 0x0 (0x0) +int 0xa > 0x5 == 0x1 (0x1) +__uint 0xa > 0x5 == 0x1 (0x1) +char 0xa > 0x5 == 0x1 (0x1) +__uchar 0xa > 0x5 == 0x1 (0x1) +__longlong 0xa > 0x5 == 0x1 (0x1) +__ulonglong 0xa > 0x5 == 0x1 (0x1) +float 0xa > 0x5 == 0x1 (0x1) +int 0xa <= 0x5 == 0x0 (0x0) +__uint 0xa <= 0x5 == 0x0 (0x0) +char 0xa <= 0x5 == 0x0 (0x0) +__uchar 0xa <= 0x5 == 0x0 (0x0) +__longlong 0xa <= 0x5 == 0x0 (0x0) +__ulonglong 0xa <= 0x5 == 0x0 (0x0) +float 0xa <= 0x5 == 0x0 (0x0) +int 0xa == 0x5 == 0x0 (0x0) +__uint 0xa == 0x5 == 0x0 (0x0) +char 0xa == 0x5 == 0x0 (0x0) +__uchar 0xa == 0x5 == 0x0 (0x0) +__longlong 0xa == 0x5 == 0x0 (0x0) +__ulonglong 0xa == 0x5 == 0x0 (0x0) +float 0xa == 0x5 == 0x0 (0x0) +int 0xa != 0x5 == 0x1 (0x1) +__uint 0xa != 0x5 == 0x1 (0x1) +char 0xa != 0x5 == 0x1 (0x1) +__uchar 0xa != 0x5 == 0x1 (0x1) +__longlong 0xa != 0x5 == 0x1 (0x1) +__ulonglong 0xa != 0x5 == 0x1 (0x1) +float 0xa != 0x5 == 0x1 (0x1) +int 0xa >= 0x5 == 0x1 (0x1) +__uint 0xa >= 0x5 == 0x1 (0x1) +char 0xa >= 0x5 == 0x1 (0x1) +__uchar 0xa >= 0x5 == 0x1 (0x1) +__longlong 0xa >= 0x5 == 0x1 (0x1) +__ulonglong 0xa >= 0x5 == 0x1 (0x1) +float 0xa >= 0x5 == 0x1 (0x1) +int 0xa / 0x5 == 0x2 (0x2) +__uint 0xa / 0x5 == 0x2 (0x2) +char 0xa / 0x5 == 0x2 (0x2) +__uchar 0xa / 0x5 == 0x2 (0x2) +__longlong 0xa / 0x5 == 0x2 (0x2) +__ulonglong 0xa / 0x5 == 0x2 (0x2) +float 0xa / 0x5 == 0x2 (0x2) +int 0xa % 0x5 == 0x0 (0x0) +__uint 0xa % 0x5 == 0x0 (0x0) +char 0xa % 0x5 == 0x0 (0x0) +__uchar 0xa % 0x5 == 0x0 (0x0) +__longlong 0xa % 0x5 == 0x0 (0x0) +__ulonglong 0xa % 0x5 == 0x0 (0x0) +0xa * 0x7 == 0x46 +0xa / 0x7 == 0x1 +0xa % 0x7 == 0x3 +int 0xa ^ 0x7 == 0xd (0xd) +__uint 0xa ^ 0x7 == 0xd (0xd) +char 0xa ^ 0x7 == 0xd (0xd) +__uchar 0xa ^ 0x7 == 0xd (0xd) +__longlong 0xa ^ 0x7 == 0xd (0xd) +__ulonglong 0xa ^ 0x7 == 0xd (0xd) +int 0xa && 0x7 == 0x1 (0x1) +__uint 0xa && 0x7 == 0x1 (0x1) +char 0xa && 0x7 == 0x1 (0x1) +__uchar 0xa && 0x7 == 0x1 (0x1) +__longlong 0xa && 0x7 == 0x1 (0x1) +__ulonglong 0xa && 0x7 == 0x1 (0x1) +int 0xa || 0x7 == 0x1 (0x1) +__uint 0xa || 0x7 == 0x1 (0x1) +char 0xa || 0x7 == 0x1 (0x1) +__uchar 0xa || 0x7 == 0x1 (0x1) +__longlong 0xa || 0x7 == 0x1 (0x1) +__ulonglong 0xa || 0x7 == 0x1 (0x1) +int 0xa & 0x7 == 0x2 (0x2) +__uint 0xa & 0x7 == 0x2 (0x2) +char 0xa & 0x7 == 0x2 (0x2) +__uchar 0xa & 0x7 == 0x2 (0x2) +__longlong 0xa & 0x7 == 0x2 (0x2) +__ulonglong 0xa & 0x7 == 0x2 (0x2) +int 0xa | 0x7 == 0xf (0xf) +__uint 0xa | 0x7 == 0xf (0xf) +char 0xa | 0x7 == 0xf (0xf) +__uchar 0xa | 0x7 == 0xf (0xf) +__longlong 0xa | 0x7 == 0xf (0xf) +__ulonglong 0xa | 0x7 == 0xf (0xf) +int 0xa << 0xa == 0x2800 (0x2800) +__uint 0xa << 0xa == 0x2800 (0x2800) +char 0xa << 0xa == 0x0 (0x0) +__uchar 0xa << 0xa == 0x0 (0x0) +__longlong 0xa << 0xa == 0x2800 (0x2800) +__ulonglong 0xa << 0xa == 0x2800 (0x2800) +int 0xa >> 0xa == 0x0 (0x0) +__uint 0xa >> 0xa == 0x0 (0x0) +char 0xa >> 0xa == 0x0 (0x0) +__uchar 0xa >> 0xa == 0x0 (0x0) +__longlong 0xa >> 0xa == 0x0 (0x0) +__ulonglong 0xa >> 0xa == 0x0 (0x0) +int 0xa + 0x7 == 0x11 (0x11) +__uint 0xa + 0x7 == 0x11 (0x11) +char 0xa + 0x7 == 0x11 (0x11) +__uchar 0xa + 0x7 == 0x11 (0x11) +__longlong 0xa + 0x7 == 0x11 (0x11) +__ulonglong 0xa + 0x7 == 0x11 (0x11) +float 0xa + 0x7 == 0x11 (0x11) +int 0xa - 0x7 == 0x3 (0x3) +__uint 0xa - 0x7 == 0x3 (0x3) +char 0xa - 0x7 == 0x3 (0x3) +__uchar 0xa - 0x7 == 0x3 (0x3) +__longlong 0xa - 0x7 == 0x3 (0x3) +__ulonglong 0xa - 0x7 == 0x3 (0x3) +float 0xa - 0x7 == 0x3 (0x3) +int 0xa * 0x7 == 0x46 (0x46) +__uint 0xa * 0x7 == 0x46 (0x46) +char 0xa * 0x7 == 0x46 (0x46) +__uchar 0xa * 0x7 == 0x46 (0x46) +__longlong 0xa * 0x7 == 0x46 (0x46) +__ulonglong 0xa * 0x7 == 0x46 (0x46) +float 0xa * 0x7 == 0x46 (0x46) +int 0xa < 0x7 == 0x0 (0x0) +__uint 0xa < 0x7 == 0x0 (0x0) +char 0xa < 0x7 == 0x0 (0x0) +__uchar 0xa < 0x7 == 0x0 (0x0) +__longlong 0xa < 0x7 == 0x0 (0x0) +__ulonglong 0xa < 0x7 == 0x0 (0x0) +float 0xa < 0x7 == 0x0 (0x0) +int 0xa > 0x7 == 0x1 (0x1) +__uint 0xa > 0x7 == 0x1 (0x1) +char 0xa > 0x7 == 0x1 (0x1) +__uchar 0xa > 0x7 == 0x1 (0x1) +__longlong 0xa > 0x7 == 0x1 (0x1) +__ulonglong 0xa > 0x7 == 0x1 (0x1) +float 0xa > 0x7 == 0x1 (0x1) +int 0xa <= 0x7 == 0x0 (0x0) +__uint 0xa <= 0x7 == 0x0 (0x0) +char 0xa <= 0x7 == 0x0 (0x0) +__uchar 0xa <= 0x7 == 0x0 (0x0) +__longlong 0xa <= 0x7 == 0x0 (0x0) +__ulonglong 0xa <= 0x7 == 0x0 (0x0) +float 0xa <= 0x7 == 0x0 (0x0) +int 0xa == 0x7 == 0x0 (0x0) +__uint 0xa == 0x7 == 0x0 (0x0) +char 0xa == 0x7 == 0x0 (0x0) +__uchar 0xa == 0x7 == 0x0 (0x0) +__longlong 0xa == 0x7 == 0x0 (0x0) +__ulonglong 0xa == 0x7 == 0x0 (0x0) +float 0xa == 0x7 == 0x0 (0x0) +int 0xa != 0x7 == 0x1 (0x1) +__uint 0xa != 0x7 == 0x1 (0x1) +char 0xa != 0x7 == 0x1 (0x1) +__uchar 0xa != 0x7 == 0x1 (0x1) +__longlong 0xa != 0x7 == 0x1 (0x1) +__ulonglong 0xa != 0x7 == 0x1 (0x1) +float 0xa != 0x7 == 0x1 (0x1) +int 0xa >= 0x7 == 0x1 (0x1) +__uint 0xa >= 0x7 == 0x1 (0x1) +char 0xa >= 0x7 == 0x1 (0x1) +__uchar 0xa >= 0x7 == 0x1 (0x1) +__longlong 0xa >= 0x7 == 0x1 (0x1) +__ulonglong 0xa >= 0x7 == 0x1 (0x1) +float 0xa >= 0x7 == 0x1 (0x1) +int 0xa / 0x7 == 0x1 (0x1) +__uint 0xa / 0x7 == 0x1 (0x1) +char 0xa / 0x7 == 0x1 (0x1) +__uchar 0xa / 0x7 == 0x1 (0x1) +__longlong 0xa / 0x7 == 0x1 (0x1) +__ulonglong 0xa / 0x7 == 0x1 (0x1) +float 0xa / 0x7 == 0x1 (0x1) +int 0xa % 0x7 == 0x3 (0x3) +__uint 0xa % 0x7 == 0x3 (0x3) +char 0xa % 0x7 == 0x3 (0x3) +__uchar 0xa % 0x7 == 0x3 (0x3) +__longlong 0xa % 0x7 == 0x3 (0x3) +__ulonglong 0xa % 0x7 == 0x3 (0x3) +0xa * 0x2a == 0x1a4 +0xa / 0x2a == 0x0 +0xa % 0x2a == 0xa +int 0xa ^ 0x2a == 0x20 (0x20) +__uint 0xa ^ 0x2a == 0x20 (0x20) +char 0xa ^ 0x2a == 0x20 (0x20) +__uchar 0xa ^ 0x2a == 0x20 (0x20) +__longlong 0xa ^ 0x2a == 0x20 (0x20) +__ulonglong 0xa ^ 0x2a == 0x20 (0x20) +int 0xa && 0x2a == 0x1 (0x1) +__uint 0xa && 0x2a == 0x1 (0x1) +char 0xa && 0x2a == 0x1 (0x1) +__uchar 0xa && 0x2a == 0x1 (0x1) +__longlong 0xa && 0x2a == 0x1 (0x1) +__ulonglong 0xa && 0x2a == 0x1 (0x1) +int 0xa || 0x2a == 0x1 (0x1) +__uint 0xa || 0x2a == 0x1 (0x1) +char 0xa || 0x2a == 0x1 (0x1) +__uchar 0xa || 0x2a == 0x1 (0x1) +__longlong 0xa || 0x2a == 0x1 (0x1) +__ulonglong 0xa || 0x2a == 0x1 (0x1) +int 0xa & 0x2a == 0xa (0xa) +__uint 0xa & 0x2a == 0xa (0xa) +char 0xa & 0x2a == 0xa (0xa) +__uchar 0xa & 0x2a == 0xa (0xa) +__longlong 0xa & 0x2a == 0xa (0xa) +__ulonglong 0xa & 0x2a == 0xa (0xa) +int 0xa | 0x2a == 0x2a (0x2a) +__uint 0xa | 0x2a == 0x2a (0x2a) +char 0xa | 0x2a == 0x2a (0x2a) +__uchar 0xa | 0x2a == 0x2a (0x2a) +__longlong 0xa | 0x2a == 0x2a (0x2a) +__ulonglong 0xa | 0x2a == 0x2a (0x2a) +int 0xa << 0xc == -0x6000 (0xa000) +__uint 0xa << 0xc == -0x6000 (0xa000) +char 0xa << 0xc == 0x0 (0x0) +__uchar 0xa << 0xc == 0x0 (0x0) +__longlong 0xa << 0xc == -0x6000 (0xa000) +__ulonglong 0xa << 0xc == -0x6000 (0xa000) +int 0xa >> 0xc == 0x0 (0x0) +__uint 0xa >> 0xc == 0x0 (0x0) +char 0xa >> 0xc == 0x0 (0x0) +__uchar 0xa >> 0xc == 0x0 (0x0) +__longlong 0xa >> 0xc == 0x0 (0x0) +__ulonglong 0xa >> 0xc == 0x0 (0x0) +int 0xa + 0x2a == 0x34 (0x34) +__uint 0xa + 0x2a == 0x34 (0x34) +char 0xa + 0x2a == 0x34 (0x34) +__uchar 0xa + 0x2a == 0x34 (0x34) +__longlong 0xa + 0x2a == 0x34 (0x34) +__ulonglong 0xa + 0x2a == 0x34 (0x34) +float 0xa + 0x2a == 0x34 (0x34) +int 0xa - 0x2a == -0x20 (0xffe0) +__uint 0xa - 0x2a == -0x20 (0xffe0) +char 0xa - 0x2a == -0x20 (0xffe0) +__uchar 0xa - 0x2a == 0xe0 (0xe0) +__longlong 0xa - 0x2a == -0x20 (0xffe0) +__ulonglong 0xa - 0x2a == -0x20 (0xffe0) +float 0xa - 0x2a == -0x20 (0xffe0) +int 0xa * 0x2a == 0x1a4 (0x1a4) +__uint 0xa * 0x2a == 0x1a4 (0x1a4) +char 0xa * 0x2a == -0x5c (0xffa4) +__uchar 0xa * 0x2a == 0xa4 (0xa4) +__longlong 0xa * 0x2a == 0x1a4 (0x1a4) +__ulonglong 0xa * 0x2a == 0x1a4 (0x1a4) +float 0xa * 0x2a == 0x1a4 (0x1a4) +int 0xa < 0x2a == 0x1 (0x1) +__uint 0xa < 0x2a == 0x1 (0x1) +char 0xa < 0x2a == 0x1 (0x1) +__uchar 0xa < 0x2a == 0x1 (0x1) +__longlong 0xa < 0x2a == 0x1 (0x1) +__ulonglong 0xa < 0x2a == 0x1 (0x1) +float 0xa < 0x2a == 0x1 (0x1) +int 0xa > 0x2a == 0x0 (0x0) +__uint 0xa > 0x2a == 0x0 (0x0) +char 0xa > 0x2a == 0x0 (0x0) +__uchar 0xa > 0x2a == 0x0 (0x0) +__longlong 0xa > 0x2a == 0x0 (0x0) +__ulonglong 0xa > 0x2a == 0x0 (0x0) +float 0xa > 0x2a == 0x0 (0x0) +int 0xa <= 0x2a == 0x1 (0x1) +__uint 0xa <= 0x2a == 0x1 (0x1) +char 0xa <= 0x2a == 0x1 (0x1) +__uchar 0xa <= 0x2a == 0x1 (0x1) +__longlong 0xa <= 0x2a == 0x1 (0x1) +__ulonglong 0xa <= 0x2a == 0x1 (0x1) +float 0xa <= 0x2a == 0x1 (0x1) +int 0xa == 0x2a == 0x0 (0x0) +__uint 0xa == 0x2a == 0x0 (0x0) +char 0xa == 0x2a == 0x0 (0x0) +__uchar 0xa == 0x2a == 0x0 (0x0) +__longlong 0xa == 0x2a == 0x0 (0x0) +__ulonglong 0xa == 0x2a == 0x0 (0x0) +float 0xa == 0x2a == 0x0 (0x0) +int 0xa != 0x2a == 0x1 (0x1) +__uint 0xa != 0x2a == 0x1 (0x1) +char 0xa != 0x2a == 0x1 (0x1) +__uchar 0xa != 0x2a == 0x1 (0x1) +__longlong 0xa != 0x2a == 0x1 (0x1) +__ulonglong 0xa != 0x2a == 0x1 (0x1) +float 0xa != 0x2a == 0x1 (0x1) +int 0xa >= 0x2a == 0x0 (0x0) +__uint 0xa >= 0x2a == 0x0 (0x0) +char 0xa >= 0x2a == 0x0 (0x0) +__uchar 0xa >= 0x2a == 0x0 (0x0) +__longlong 0xa >= 0x2a == 0x0 (0x0) +__ulonglong 0xa >= 0x2a == 0x0 (0x0) +float 0xa >= 0x2a == 0x0 (0x0) +int 0xa / 0x2a == 0x0 (0x0) +__uint 0xa / 0x2a == 0x0 (0x0) +char 0xa / 0x2a == 0x0 (0x0) +__uchar 0xa / 0x2a == 0x0 (0x0) +__longlong 0xa / 0x2a == 0x0 (0x0) +__ulonglong 0xa / 0x2a == 0x0 (0x0) +float 0xa / 0x2a == 0x0 (0x0) +int 0xa % 0x2a == 0xa (0xa) +__uint 0xa % 0x2a == 0xa (0xa) +char 0xa % 0x2a == 0xa (0xa) +__uchar 0xa % 0x2a == 0xa (0xa) +__longlong 0xa % 0x2a == 0xa (0xa) +__ulonglong 0xa % 0x2a == 0xa (0xa) +0xa * 0x17 == 0xe6 +0xa / 0x17 == 0x0 +0xa % 0x17 == 0xa +int 0xa ^ 0x17 == 0x1d (0x1d) +__uint 0xa ^ 0x17 == 0x1d (0x1d) +char 0xa ^ 0x17 == 0x1d (0x1d) +__uchar 0xa ^ 0x17 == 0x1d (0x1d) +__longlong 0xa ^ 0x17 == 0x1d (0x1d) +__ulonglong 0xa ^ 0x17 == 0x1d (0x1d) +int 0xa && 0x17 == 0x1 (0x1) +__uint 0xa && 0x17 == 0x1 (0x1) +char 0xa && 0x17 == 0x1 (0x1) +__uchar 0xa && 0x17 == 0x1 (0x1) +__longlong 0xa && 0x17 == 0x1 (0x1) +__ulonglong 0xa && 0x17 == 0x1 (0x1) +int 0xa || 0x17 == 0x1 (0x1) +__uint 0xa || 0x17 == 0x1 (0x1) +char 0xa || 0x17 == 0x1 (0x1) +__uchar 0xa || 0x17 == 0x1 (0x1) +__longlong 0xa || 0x17 == 0x1 (0x1) +__ulonglong 0xa || 0x17 == 0x1 (0x1) +int 0xa & 0x17 == 0x2 (0x2) +__uint 0xa & 0x17 == 0x2 (0x2) +char 0xa & 0x17 == 0x2 (0x2) +__uchar 0xa & 0x17 == 0x2 (0x2) +__longlong 0xa & 0x17 == 0x2 (0x2) +__ulonglong 0xa & 0x17 == 0x2 (0x2) +int 0xa | 0x17 == 0x1f (0x1f) +__uint 0xa | 0x17 == 0x1f (0x1f) +char 0xa | 0x17 == 0x1f (0x1f) +__uchar 0xa | 0x17 == 0x1f (0x1f) +__longlong 0xa | 0x17 == 0x1f (0x1f) +__ulonglong 0xa | 0x17 == 0x1f (0x1f) +int 0xa << 0xe == -0x8000 (0x8000) +__uint 0xa << 0xe == -0x8000 (0x8000) +char 0xa << 0xe == 0x0 (0x0) +__uchar 0xa << 0xe == 0x0 (0x0) +__longlong 0xa << 0xe == -0x8000 (0x8000) +__ulonglong 0xa << 0xe == -0x8000 (0x8000) +int 0xa >> 0xe == 0x0 (0x0) +__uint 0xa >> 0xe == 0x0 (0x0) +char 0xa >> 0xe == 0x0 (0x0) +__uchar 0xa >> 0xe == 0x0 (0x0) +__longlong 0xa >> 0xe == 0x0 (0x0) +__ulonglong 0xa >> 0xe == 0x0 (0x0) +int 0xa + 0x17 == 0x21 (0x21) +__uint 0xa + 0x17 == 0x21 (0x21) +char 0xa + 0x17 == 0x21 (0x21) +__uchar 0xa + 0x17 == 0x21 (0x21) +__longlong 0xa + 0x17 == 0x21 (0x21) +__ulonglong 0xa + 0x17 == 0x21 (0x21) +float 0xa + 0x17 == 0x21 (0x21) +int 0xa - 0x17 == -0xd (0xfff3) +__uint 0xa - 0x17 == -0xd (0xfff3) +char 0xa - 0x17 == -0xd (0xfff3) +__uchar 0xa - 0x17 == 0xf3 (0xf3) +__longlong 0xa - 0x17 == -0xd (0xfff3) +__ulonglong 0xa - 0x17 == -0xd (0xfff3) +float 0xa - 0x17 == -0xd (0xfff3) +int 0xa * 0x17 == 0xe6 (0xe6) +__uint 0xa * 0x17 == 0xe6 (0xe6) +char 0xa * 0x17 == -0x1a (0xffe6) +__uchar 0xa * 0x17 == 0xe6 (0xe6) +__longlong 0xa * 0x17 == 0xe6 (0xe6) +__ulonglong 0xa * 0x17 == 0xe6 (0xe6) +float 0xa * 0x17 == 0xe6 (0xe6) +int 0xa < 0x17 == 0x1 (0x1) +__uint 0xa < 0x17 == 0x1 (0x1) +char 0xa < 0x17 == 0x1 (0x1) +__uchar 0xa < 0x17 == 0x1 (0x1) +__longlong 0xa < 0x17 == 0x1 (0x1) +__ulonglong 0xa < 0x17 == 0x1 (0x1) +float 0xa < 0x17 == 0x1 (0x1) +int 0xa > 0x17 == 0x0 (0x0) +__uint 0xa > 0x17 == 0x0 (0x0) +char 0xa > 0x17 == 0x0 (0x0) +__uchar 0xa > 0x17 == 0x0 (0x0) +__longlong 0xa > 0x17 == 0x0 (0x0) +__ulonglong 0xa > 0x17 == 0x0 (0x0) +float 0xa > 0x17 == 0x0 (0x0) +int 0xa <= 0x17 == 0x1 (0x1) +__uint 0xa <= 0x17 == 0x1 (0x1) +char 0xa <= 0x17 == 0x1 (0x1) +__uchar 0xa <= 0x17 == 0x1 (0x1) +__longlong 0xa <= 0x17 == 0x1 (0x1) +__ulonglong 0xa <= 0x17 == 0x1 (0x1) +float 0xa <= 0x17 == 0x1 (0x1) +int 0xa == 0x17 == 0x0 (0x0) +__uint 0xa == 0x17 == 0x0 (0x0) +char 0xa == 0x17 == 0x0 (0x0) +__uchar 0xa == 0x17 == 0x0 (0x0) +__longlong 0xa == 0x17 == 0x0 (0x0) +__ulonglong 0xa == 0x17 == 0x0 (0x0) +float 0xa == 0x17 == 0x0 (0x0) +int 0xa != 0x17 == 0x1 (0x1) +__uint 0xa != 0x17 == 0x1 (0x1) +char 0xa != 0x17 == 0x1 (0x1) +__uchar 0xa != 0x17 == 0x1 (0x1) +__longlong 0xa != 0x17 == 0x1 (0x1) +__ulonglong 0xa != 0x17 == 0x1 (0x1) +float 0xa != 0x17 == 0x1 (0x1) +int 0xa >= 0x17 == 0x0 (0x0) +__uint 0xa >= 0x17 == 0x0 (0x0) +char 0xa >= 0x17 == 0x0 (0x0) +__uchar 0xa >= 0x17 == 0x0 (0x0) +__longlong 0xa >= 0x17 == 0x0 (0x0) +__ulonglong 0xa >= 0x17 == 0x0 (0x0) +float 0xa >= 0x17 == 0x0 (0x0) +int 0xa / 0x17 == 0x0 (0x0) +__uint 0xa / 0x17 == 0x0 (0x0) +char 0xa / 0x17 == 0x0 (0x0) +__uchar 0xa / 0x17 == 0x0 (0x0) +__longlong 0xa / 0x17 == 0x0 (0x0) +__ulonglong 0xa / 0x17 == 0x0 (0x0) +float 0xa / 0x17 == 0x0 (0x0) +int 0xa % 0x17 == 0xa (0xa) +__uint 0xa % 0x17 == 0xa (0xa) +char 0xa % 0x17 == 0xa (0xa) +__uchar 0xa % 0x17 == 0xa (0xa) +__longlong 0xa % 0x17 == 0xa (0xa) +__ulonglong 0xa % 0x17 == 0xa (0xa) +0xa * 0x7fff == -0xa +0xa / 0x7fff == 0x0 +0xa % 0x7fff == 0xa +int 0xa ^ 0x7fff == 0x7ff5 (0x7ff5) +__uint 0xa ^ 0x7fff == 0x7ff5 (0x7ff5) +char 0xa ^ 0xffff == -0xb (0xfff5) +__uchar 0xa ^ 0xff == 0xf5 (0xf5) +__longlong 0xa ^ 0x7fff == 0x7ff5 (0x7ff5) +__ulonglong 0xa ^ 0x7fff == 0x7ff5 (0x7ff5) +int 0xa && 0x7fff == 0x1 (0x1) +__uint 0xa && 0x7fff == 0x1 (0x1) +char 0xa && 0xffff == 0x1 (0x1) +__uchar 0xa && 0xff == 0x1 (0x1) +__longlong 0xa && 0x7fff == 0x1 (0x1) +__ulonglong 0xa && 0x7fff == 0x1 (0x1) +int 0xa || 0x7fff == 0x1 (0x1) +__uint 0xa || 0x7fff == 0x1 (0x1) +char 0xa || 0xffff == 0x1 (0x1) +__uchar 0xa || 0xff == 0x1 (0x1) +__longlong 0xa || 0x7fff == 0x1 (0x1) +__ulonglong 0xa || 0x7fff == 0x1 (0x1) +int 0xa & 0x7fff == 0xa (0xa) +__uint 0xa & 0x7fff == 0xa (0xa) +char 0xa & 0xffff == 0xa (0xa) +__uchar 0xa & 0xff == 0xa (0xa) +__longlong 0xa & 0x7fff == 0xa (0xa) +__ulonglong 0xa & 0x7fff == 0xa (0xa) +int 0xa | 0x7fff == 0x7fff (0x7fff) +__uint 0xa | 0x7fff == 0x7fff (0x7fff) +char 0xa | 0xffff == -0x1 (0xffff) +__uchar 0xa | 0xff == 0xff (0xff) +__longlong 0xa | 0x7fff == 0x7fff (0x7fff) +__ulonglong 0xa | 0x7fff == 0x7fff (0x7fff) +int 0xa << 0x10 == 0x0 (0x0) +__uint 0xa << 0x10 == 0x0 (0x0) +char 0xa << 0x10 == 0x0 (0x0) +__uchar 0xa << 0x10 == 0x0 (0x0) +__longlong 0xa << 0x10 == 0x0 (0x0) +__ulonglong 0xa << 0x10 == 0x0 (0x0) +int 0xa >> 0x10 == 0x0 (0x0) +__uint 0xa >> 0x10 == 0x0 (0x0) +char 0xa >> 0x10 == 0x0 (0x0) +__uchar 0xa >> 0x10 == 0x0 (0x0) +__longlong 0xa >> 0x10 == 0x0 (0x0) +__ulonglong 0xa >> 0x10 == 0x0 (0x0) +int 0xa + 0x7fff == -0x7ff7 (0x8009) +__uint 0xa + 0x7fff == -0x7ff7 (0x8009) +char 0xa + 0xffff == 0x9 (0x9) +__uchar 0xa + 0xff == 0x9 (0x9) +__longlong 0xa + 0x7fff == -0x7ff7 (0x8009) +__ulonglong 0xa + 0x7fff == -0x7ff7 (0x8009) +float 0xa + 0x7fff == -0x8000 (0x8000) +int 0xa - 0x7fff == -0x7ff5 (0x800b) +__uint 0xa - 0x7fff == -0x7ff5 (0x800b) +char 0xa - 0xffff == 0xb (0xb) +__uchar 0xa - 0xff == 0xb (0xb) +__longlong 0xa - 0x7fff == -0x7ff5 (0x800b) +__ulonglong 0xa - 0x7fff == -0x7ff5 (0x800b) +float 0xa - 0x7fff == -0x7ff5 (0x800b) +int 0xa * 0x7fff == -0xa (0xfff6) +__uint 0xa * 0x7fff == -0xa (0xfff6) +char 0xa * 0xffff == -0xa (0xfff6) +__uchar 0xa * 0xff == 0xf6 (0xf6) +__longlong 0xa * 0x7fff == -0xa (0xfff6) +__ulonglong 0xa * 0x7fff == -0xa (0xfff6) +float 0xa * 0x7fff == -0x8000 (0x8000) +int 0xa < 0x7fff == 0x1 (0x1) +__uint 0xa < 0x7fff == 0x1 (0x1) +char 0xa < 0xffff == 0x0 (0x0) +__uchar 0xa < 0xff == 0x1 (0x1) +__longlong 0xa < 0x7fff == 0x1 (0x1) +__ulonglong 0xa < 0x7fff == 0x1 (0x1) +float 0xa < 0x7fff == 0x1 (0x1) +int 0xa > 0x7fff == 0x0 (0x0) +__uint 0xa > 0x7fff == 0x0 (0x0) +char 0xa > 0xffff == 0x1 (0x1) +__uchar 0xa > 0xff == 0x0 (0x0) +__longlong 0xa > 0x7fff == 0x0 (0x0) +__ulonglong 0xa > 0x7fff == 0x0 (0x0) +float 0xa > 0x7fff == 0x0 (0x0) +int 0xa <= 0x7fff == 0x1 (0x1) +__uint 0xa <= 0x7fff == 0x1 (0x1) +char 0xa <= 0xffff == 0x0 (0x0) +__uchar 0xa <= 0xff == 0x1 (0x1) +__longlong 0xa <= 0x7fff == 0x1 (0x1) +__ulonglong 0xa <= 0x7fff == 0x1 (0x1) +float 0xa <= 0x7fff == 0x1 (0x1) +int 0xa == 0x7fff == 0x0 (0x0) +__uint 0xa == 0x7fff == 0x0 (0x0) +char 0xa == 0xffff == 0x0 (0x0) +__uchar 0xa == 0xff == 0x0 (0x0) +__longlong 0xa == 0x7fff == 0x0 (0x0) +__ulonglong 0xa == 0x7fff == 0x0 (0x0) +float 0xa == 0x7fff == 0x0 (0x0) +int 0xa != 0x7fff == 0x1 (0x1) +__uint 0xa != 0x7fff == 0x1 (0x1) +char 0xa != 0xffff == 0x1 (0x1) +__uchar 0xa != 0xff == 0x1 (0x1) +__longlong 0xa != 0x7fff == 0x1 (0x1) +__ulonglong 0xa != 0x7fff == 0x1 (0x1) +float 0xa != 0x7fff == 0x1 (0x1) +int 0xa >= 0x7fff == 0x0 (0x0) +__uint 0xa >= 0x7fff == 0x0 (0x0) +char 0xa >= 0xffff == 0x1 (0x1) +__uchar 0xa >= 0xff == 0x0 (0x0) +__longlong 0xa >= 0x7fff == 0x0 (0x0) +__ulonglong 0xa >= 0x7fff == 0x0 (0x0) +float 0xa >= 0x7fff == 0x0 (0x0) +int 0xa / 0x7fff == 0x0 (0x0) +__uint 0xa / 0x7fff == 0x0 (0x0) +char 0xa / 0xffff == -0xa (0xfff6) +__uchar 0xa / 0xff == 0x0 (0x0) +__longlong 0xa / 0x7fff == 0x0 (0x0) +__ulonglong 0xa / 0x7fff == 0x0 (0x0) +float 0xa / 0x7fff == 0x0 (0x0) +int 0xa % 0x7fff == 0xa (0xa) +__uint 0xa % 0x7fff == 0xa (0xa) +char 0xa % 0xffff == 0x0 (0x0) +__uchar 0xa % 0xff == 0xa (0xa) +__longlong 0xa % 0x7fff == 0xa (0xa) +__ulonglong 0xa % 0x7fff == 0xa (0xa) +0xa * 0x8000 == 0x0 +0xa / 0x8000 == 0x0 +0xa % 0x8000 == 0xa +int 0xa ^ 0x8000 == -0x7ff6 (0x800a) +__uint 0xa ^ 0x8000 == -0x7ff6 (0x800a) +char 0xa ^ 0x0 == 0xa (0xa) +__uchar 0xa ^ 0x0 == 0xa (0xa) +__longlong 0xa ^ 0x8000 == -0x7ff6 (0x800a) +__ulonglong 0xa ^ 0x8000 == -0x7ff6 (0x800a) +int 0xa && 0x8000 == 0x1 (0x1) +__uint 0xa && 0x8000 == 0x1 (0x1) +char 0xa && 0x0 == 0x0 (0x0) +__uchar 0xa && 0x0 == 0x0 (0x0) +__longlong 0xa && 0x8000 == 0x1 (0x1) +__ulonglong 0xa && 0x8000 == 0x1 (0x1) +int 0xa || 0x8000 == 0x1 (0x1) +__uint 0xa || 0x8000 == 0x1 (0x1) +char 0xa || 0x0 == 0x1 (0x1) +__uchar 0xa || 0x0 == 0x1 (0x1) +__longlong 0xa || 0x8000 == 0x1 (0x1) +__ulonglong 0xa || 0x8000 == 0x1 (0x1) +int 0xa & 0x8000 == 0x0 (0x0) +__uint 0xa & 0x8000 == 0x0 (0x0) +char 0xa & 0x0 == 0x0 (0x0) +__uchar 0xa & 0x0 == 0x0 (0x0) +__longlong 0xa & 0x8000 == 0x0 (0x0) +__ulonglong 0xa & 0x8000 == 0x0 (0x0) +int 0xa | 0x8000 == -0x7ff6 (0x800a) +__uint 0xa | 0x8000 == -0x7ff6 (0x800a) +char 0xa | 0x0 == 0xa (0xa) +__uchar 0xa | 0x0 == 0xa (0xa) +__longlong 0xa | 0x8000 == -0x7ff6 (0x800a) +__ulonglong 0xa | 0x8000 == -0x7ff6 (0x800a) +int 0xa << 0x12 == 0x0 (0x0) +__uint 0xa << 0x12 == 0x0 (0x0) +char 0xa << 0x12 == 0x0 (0x0) +__uchar 0xa << 0x12 == 0x0 (0x0) +__longlong 0xa << 0x12 == 0x0 (0x0) +__ulonglong 0xa << 0x12 == 0x0 (0x0) +int 0xa >> 0x12 == 0x0 (0x0) +__uint 0xa >> 0x12 == 0x0 (0x0) +char 0xa >> 0x12 == 0x0 (0x0) +__uchar 0xa >> 0x12 == 0x0 (0x0) +__longlong 0xa >> 0x12 == 0x0 (0x0) +__ulonglong 0xa >> 0x12 == 0x0 (0x0) +int 0xa + 0x8000 == -0x7ff6 (0x800a) +__uint 0xa + 0x8000 == -0x7ff6 (0x800a) +char 0xa + 0x0 == 0xa (0xa) +__uchar 0xa + 0x0 == 0xa (0xa) +__longlong 0xa + 0x8000 == -0x7ff6 (0x800a) +__ulonglong 0xa + 0x8000 == -0x7ff6 (0x800a) +float 0xa + 0x8000 == -0x7ff6 (0x800a) +int 0xa - 0x8000 == -0x7ff6 (0x800a) +__uint 0xa - 0x8000 == -0x7ff6 (0x800a) +char 0xa - 0x0 == 0xa (0xa) +__uchar 0xa - 0x0 == 0xa (0xa) +__longlong 0xa - 0x8000 == -0x7ff6 (0x800a) +__ulonglong 0xa - 0x8000 == -0x7ff6 (0x800a) +float 0xa - 0x8000 == -0x8000 (0x8000) +int 0xa * 0x8000 == 0x0 (0x0) +__uint 0xa * 0x8000 == 0x0 (0x0) +char 0xa * 0x0 == 0x0 (0x0) +__uchar 0xa * 0x0 == 0x0 (0x0) +__longlong 0xa * 0x8000 == 0x0 (0x0) +__ulonglong 0xa * 0x8000 == 0x0 (0x0) +float 0xa * 0x8000 == -0x8000 (0x8000) +int 0xa < 0x8000 == 0x0 (0x0) +__uint 0xa < 0x8000 == 0x1 (0x1) +char 0xa < 0x0 == 0x0 (0x0) +__uchar 0xa < 0x0 == 0x0 (0x0) +__longlong 0xa < 0x8000 == 0x0 (0x0) +__ulonglong 0xa < 0x8000 == 0x1 (0x1) +float 0xa < 0x8000 == 0x0 (0x0) +int 0xa > 0x8000 == 0x1 (0x1) +__uint 0xa > 0x8000 == 0x0 (0x0) +char 0xa > 0x0 == 0x1 (0x1) +__uchar 0xa > 0x0 == 0x1 (0x1) +__longlong 0xa > 0x8000 == 0x1 (0x1) +__ulonglong 0xa > 0x8000 == 0x0 (0x0) +float 0xa > 0x8000 == 0x1 (0x1) +int 0xa <= 0x8000 == 0x0 (0x0) +__uint 0xa <= 0x8000 == 0x1 (0x1) +char 0xa <= 0x0 == 0x0 (0x0) +__uchar 0xa <= 0x0 == 0x0 (0x0) +__longlong 0xa <= 0x8000 == 0x0 (0x0) +__ulonglong 0xa <= 0x8000 == 0x1 (0x1) +float 0xa <= 0x8000 == 0x0 (0x0) +int 0xa == 0x8000 == 0x0 (0x0) +__uint 0xa == 0x8000 == 0x0 (0x0) +char 0xa == 0x0 == 0x0 (0x0) +__uchar 0xa == 0x0 == 0x0 (0x0) +__longlong 0xa == 0x8000 == 0x0 (0x0) +__ulonglong 0xa == 0x8000 == 0x0 (0x0) +float 0xa == 0x8000 == 0x0 (0x0) +int 0xa != 0x8000 == 0x1 (0x1) +__uint 0xa != 0x8000 == 0x1 (0x1) +char 0xa != 0x0 == 0x1 (0x1) +__uchar 0xa != 0x0 == 0x1 (0x1) +__longlong 0xa != 0x8000 == 0x1 (0x1) +__ulonglong 0xa != 0x8000 == 0x1 (0x1) +float 0xa != 0x8000 == 0x1 (0x1) +int 0xa >= 0x8000 == 0x1 (0x1) +__uint 0xa >= 0x8000 == 0x0 (0x0) +char 0xa >= 0x0 == 0x1 (0x1) +__uchar 0xa >= 0x0 == 0x1 (0x1) +__longlong 0xa >= 0x8000 == 0x1 (0x1) +__ulonglong 0xa >= 0x8000 == 0x0 (0x0) +float 0xa >= 0x8000 == 0x1 (0x1) +int 0xa / 0x8000 == 0x0 (0x0) +__uint 0xa / 0x8000 == 0x0 (0x0) +__longlong 0xa / 0x8000 == 0x0 (0x0) +__ulonglong 0xa / 0x8000 == 0x0 (0x0) +float 0xa / 0x8000 == 0x0 (0x0) +int 0xa % 0x8000 == 0xa (0xa) +__uint 0xa % 0x8000 == 0xa (0xa) +__longlong 0xa % 0x8000 == 0xa (0xa) +__ulonglong 0xa % 0x8000 == 0xa (0xa) +0xa * 0x3e8 == 0x2710 +0xa / 0x3e8 == 0x0 +0xa % 0x3e8 == 0xa +int 0xa ^ 0x3e8 == 0x3e2 (0x3e2) +__uint 0xa ^ 0x3e8 == 0x3e2 (0x3e2) +char 0xa ^ 0xffe8 == -0x1e (0xffe2) +__uchar 0xa ^ 0xe8 == 0xe2 (0xe2) +__longlong 0xa ^ 0x3e8 == 0x3e2 (0x3e2) +__ulonglong 0xa ^ 0x3e8 == 0x3e2 (0x3e2) +int 0xa && 0x3e8 == 0x1 (0x1) +__uint 0xa && 0x3e8 == 0x1 (0x1) +char 0xa && 0xffe8 == 0x1 (0x1) +__uchar 0xa && 0xe8 == 0x1 (0x1) +__longlong 0xa && 0x3e8 == 0x1 (0x1) +__ulonglong 0xa && 0x3e8 == 0x1 (0x1) +int 0xa || 0x3e8 == 0x1 (0x1) +__uint 0xa || 0x3e8 == 0x1 (0x1) +char 0xa || 0xffe8 == 0x1 (0x1) +__uchar 0xa || 0xe8 == 0x1 (0x1) +__longlong 0xa || 0x3e8 == 0x1 (0x1) +__ulonglong 0xa || 0x3e8 == 0x1 (0x1) +int 0xa & 0x3e8 == 0x8 (0x8) +__uint 0xa & 0x3e8 == 0x8 (0x8) +char 0xa & 0xffe8 == 0x8 (0x8) +__uchar 0xa & 0xe8 == 0x8 (0x8) +__longlong 0xa & 0x3e8 == 0x8 (0x8) +__ulonglong 0xa & 0x3e8 == 0x8 (0x8) +int 0xa | 0x3e8 == 0x3ea (0x3ea) +__uint 0xa | 0x3e8 == 0x3ea (0x3ea) +char 0xa | 0xffe8 == -0x16 (0xffea) +__uchar 0xa | 0xe8 == 0xea (0xea) +__longlong 0xa | 0x3e8 == 0x3ea (0x3ea) +__ulonglong 0xa | 0x3e8 == 0x3ea (0x3ea) +int 0xa << 0x14 == 0x0 (0x0) +__uint 0xa << 0x14 == 0x0 (0x0) +char 0xa << 0x14 == 0x0 (0x0) +__uchar 0xa << 0x14 == 0x0 (0x0) +__longlong 0xa << 0x14 == 0x0 (0x0) +__ulonglong 0xa << 0x14 == 0x0 (0x0) +int 0xa >> 0x14 == 0x0 (0x0) +__uint 0xa >> 0x14 == 0x0 (0x0) +char 0xa >> 0x14 == 0x0 (0x0) +__uchar 0xa >> 0x14 == 0x0 (0x0) +__longlong 0xa >> 0x14 == 0x0 (0x0) +__ulonglong 0xa >> 0x14 == 0x0 (0x0) +int 0xa + 0x3e8 == 0x3f2 (0x3f2) +__uint 0xa + 0x3e8 == 0x3f2 (0x3f2) +char 0xa + 0xffe8 == -0xe (0xfff2) +__uchar 0xa + 0xe8 == 0xf2 (0xf2) +__longlong 0xa + 0x3e8 == 0x3f2 (0x3f2) +__ulonglong 0xa + 0x3e8 == 0x3f2 (0x3f2) +float 0xa + 0x3e8 == 0x3f2 (0x3f2) +int 0xa - 0x3e8 == -0x3de (0xfc22) +__uint 0xa - 0x3e8 == -0x3de (0xfc22) +char 0xa - 0xffe8 == 0x22 (0x22) +__uchar 0xa - 0xe8 == 0x22 (0x22) +__longlong 0xa - 0x3e8 == -0x3de (0xfc22) +__ulonglong 0xa - 0x3e8 == -0x3de (0xfc22) +float 0xa - 0x3e8 == -0x3de (0xfc22) +int 0xa * 0x3e8 == 0x2710 (0x2710) +__uint 0xa * 0x3e8 == 0x2710 (0x2710) +char 0xa * 0xffe8 == 0x10 (0x10) +__uchar 0xa * 0xe8 == 0x10 (0x10) +__longlong 0xa * 0x3e8 == 0x2710 (0x2710) +__ulonglong 0xa * 0x3e8 == 0x2710 (0x2710) +float 0xa * 0x3e8 == 0x2710 (0x2710) +int 0xa < 0x3e8 == 0x1 (0x1) +__uint 0xa < 0x3e8 == 0x1 (0x1) +char 0xa < 0xffe8 == 0x0 (0x0) +__uchar 0xa < 0xe8 == 0x1 (0x1) +__longlong 0xa < 0x3e8 == 0x1 (0x1) +__ulonglong 0xa < 0x3e8 == 0x1 (0x1) +float 0xa < 0x3e8 == 0x1 (0x1) +int 0xa > 0x3e8 == 0x0 (0x0) +__uint 0xa > 0x3e8 == 0x0 (0x0) +char 0xa > 0xffe8 == 0x1 (0x1) +__uchar 0xa > 0xe8 == 0x0 (0x0) +__longlong 0xa > 0x3e8 == 0x0 (0x0) +__ulonglong 0xa > 0x3e8 == 0x0 (0x0) +float 0xa > 0x3e8 == 0x0 (0x0) +int 0xa <= 0x3e8 == 0x1 (0x1) +__uint 0xa <= 0x3e8 == 0x1 (0x1) +char 0xa <= 0xffe8 == 0x0 (0x0) +__uchar 0xa <= 0xe8 == 0x1 (0x1) +__longlong 0xa <= 0x3e8 == 0x1 (0x1) +__ulonglong 0xa <= 0x3e8 == 0x1 (0x1) +float 0xa <= 0x3e8 == 0x1 (0x1) +int 0xa == 0x3e8 == 0x0 (0x0) +__uint 0xa == 0x3e8 == 0x0 (0x0) +char 0xa == 0xffe8 == 0x0 (0x0) +__uchar 0xa == 0xe8 == 0x0 (0x0) +__longlong 0xa == 0x3e8 == 0x0 (0x0) +__ulonglong 0xa == 0x3e8 == 0x0 (0x0) +float 0xa == 0x3e8 == 0x0 (0x0) +int 0xa != 0x3e8 == 0x1 (0x1) +__uint 0xa != 0x3e8 == 0x1 (0x1) +char 0xa != 0xffe8 == 0x1 (0x1) +__uchar 0xa != 0xe8 == 0x1 (0x1) +__longlong 0xa != 0x3e8 == 0x1 (0x1) +__ulonglong 0xa != 0x3e8 == 0x1 (0x1) +float 0xa != 0x3e8 == 0x1 (0x1) +int 0xa >= 0x3e8 == 0x0 (0x0) +__uint 0xa >= 0x3e8 == 0x0 (0x0) +char 0xa >= 0xffe8 == 0x1 (0x1) +__uchar 0xa >= 0xe8 == 0x0 (0x0) +__longlong 0xa >= 0x3e8 == 0x0 (0x0) +__ulonglong 0xa >= 0x3e8 == 0x0 (0x0) +float 0xa >= 0x3e8 == 0x0 (0x0) +int 0xa / 0x3e8 == 0x0 (0x0) +__uint 0xa / 0x3e8 == 0x0 (0x0) +char 0xa / 0xffe8 == 0x0 (0x0) +__uchar 0xa / 0xe8 == 0x0 (0x0) +__longlong 0xa / 0x3e8 == 0x0 (0x0) +__ulonglong 0xa / 0x3e8 == 0x0 (0x0) +float 0xa / 0x3e8 == 0x0 (0x0) +int 0xa % 0x3e8 == 0xa (0xa) +__uint 0xa % 0x3e8 == 0xa (0xa) +char 0xa % 0xffe8 == 0xa (0xa) +__uchar 0xa % 0xe8 == 0xa (0xa) +__longlong 0xa % 0x3e8 == 0xa (0xa) +__ulonglong 0xa % 0x3e8 == 0xa (0xa) +0xa * 0x2710 == -0x7960 +0xa / 0x2710 == 0x0 +0xa % 0x2710 == 0xa +int 0xa ^ 0x2710 == 0x271a (0x271a) +__uint 0xa ^ 0x2710 == 0x271a (0x271a) +char 0xa ^ 0x10 == 0x1a (0x1a) +__uchar 0xa ^ 0x10 == 0x1a (0x1a) +__longlong 0xa ^ 0x2710 == 0x271a (0x271a) +__ulonglong 0xa ^ 0x2710 == 0x271a (0x271a) +int 0xa && 0x2710 == 0x1 (0x1) +__uint 0xa && 0x2710 == 0x1 (0x1) +char 0xa && 0x10 == 0x1 (0x1) +__uchar 0xa && 0x10 == 0x1 (0x1) +__longlong 0xa && 0x2710 == 0x1 (0x1) +__ulonglong 0xa && 0x2710 == 0x1 (0x1) +int 0xa || 0x2710 == 0x1 (0x1) +__uint 0xa || 0x2710 == 0x1 (0x1) +char 0xa || 0x10 == 0x1 (0x1) +__uchar 0xa || 0x10 == 0x1 (0x1) +__longlong 0xa || 0x2710 == 0x1 (0x1) +__ulonglong 0xa || 0x2710 == 0x1 (0x1) +int 0xa & 0x2710 == 0x0 (0x0) +__uint 0xa & 0x2710 == 0x0 (0x0) +char 0xa & 0x10 == 0x0 (0x0) +__uchar 0xa & 0x10 == 0x0 (0x0) +__longlong 0xa & 0x2710 == 0x0 (0x0) +__ulonglong 0xa & 0x2710 == 0x0 (0x0) +int 0xa | 0x2710 == 0x271a (0x271a) +__uint 0xa | 0x2710 == 0x271a (0x271a) +char 0xa | 0x10 == 0x1a (0x1a) +__uchar 0xa | 0x10 == 0x1a (0x1a) +__longlong 0xa | 0x2710 == 0x271a (0x271a) +__ulonglong 0xa | 0x2710 == 0x271a (0x271a) +int 0xa << 0x16 == 0x0 (0x0) +__uint 0xa << 0x16 == 0x0 (0x0) +char 0xa << 0x16 == 0x0 (0x0) +__uchar 0xa << 0x16 == 0x0 (0x0) +__longlong 0xa << 0x16 == 0x0 (0x0) +__ulonglong 0xa << 0x16 == 0x0 (0x0) +int 0xa >> 0x16 == 0x0 (0x0) +__uint 0xa >> 0x16 == 0x0 (0x0) +char 0xa >> 0x16 == 0x0 (0x0) +__uchar 0xa >> 0x16 == 0x0 (0x0) +__longlong 0xa >> 0x16 == 0x0 (0x0) +__ulonglong 0xa >> 0x16 == 0x0 (0x0) +int 0xa + 0x2710 == 0x271a (0x271a) +__uint 0xa + 0x2710 == 0x271a (0x271a) +char 0xa + 0x10 == 0x1a (0x1a) +__uchar 0xa + 0x10 == 0x1a (0x1a) +__longlong 0xa + 0x2710 == 0x271a (0x271a) +__ulonglong 0xa + 0x2710 == 0x271a (0x271a) +float 0xa + 0x2710 == 0x271a (0x271a) +int 0xa - 0x2710 == -0x2706 (0xd8fa) +__uint 0xa - 0x2710 == -0x2706 (0xd8fa) +char 0xa - 0x10 == -0x6 (0xfffa) +__uchar 0xa - 0x10 == 0xfa (0xfa) +__longlong 0xa - 0x2710 == -0x2706 (0xd8fa) +__ulonglong 0xa - 0x2710 == -0x2706 (0xd8fa) +float 0xa - 0x2710 == -0x2706 (0xd8fa) +int 0xa * 0x2710 == -0x7960 (0x86a0) +__uint 0xa * 0x2710 == -0x7960 (0x86a0) +char 0xa * 0x10 == -0x60 (0xffa0) +__uchar 0xa * 0x10 == 0xa0 (0xa0) +__longlong 0xa * 0x2710 == -0x7960 (0x86a0) +__ulonglong 0xa * 0x2710 == -0x7960 (0x86a0) +float 0xa * 0x2710 == -0x8000 (0x8000) +int 0xa < 0x2710 == 0x1 (0x1) +__uint 0xa < 0x2710 == 0x1 (0x1) +char 0xa < 0x10 == 0x1 (0x1) +__uchar 0xa < 0x10 == 0x1 (0x1) +__longlong 0xa < 0x2710 == 0x1 (0x1) +__ulonglong 0xa < 0x2710 == 0x1 (0x1) +float 0xa < 0x2710 == 0x1 (0x1) +int 0xa > 0x2710 == 0x0 (0x0) +__uint 0xa > 0x2710 == 0x0 (0x0) +char 0xa > 0x10 == 0x0 (0x0) +__uchar 0xa > 0x10 == 0x0 (0x0) +__longlong 0xa > 0x2710 == 0x0 (0x0) +__ulonglong 0xa > 0x2710 == 0x0 (0x0) +float 0xa > 0x2710 == 0x0 (0x0) +int 0xa <= 0x2710 == 0x1 (0x1) +__uint 0xa <= 0x2710 == 0x1 (0x1) +char 0xa <= 0x10 == 0x1 (0x1) +__uchar 0xa <= 0x10 == 0x1 (0x1) +__longlong 0xa <= 0x2710 == 0x1 (0x1) +__ulonglong 0xa <= 0x2710 == 0x1 (0x1) +float 0xa <= 0x2710 == 0x1 (0x1) +int 0xa == 0x2710 == 0x0 (0x0) +__uint 0xa == 0x2710 == 0x0 (0x0) +char 0xa == 0x10 == 0x0 (0x0) +__uchar 0xa == 0x10 == 0x0 (0x0) +__longlong 0xa == 0x2710 == 0x0 (0x0) +__ulonglong 0xa == 0x2710 == 0x0 (0x0) +float 0xa == 0x2710 == 0x0 (0x0) +int 0xa != 0x2710 == 0x1 (0x1) +__uint 0xa != 0x2710 == 0x1 (0x1) +char 0xa != 0x10 == 0x1 (0x1) +__uchar 0xa != 0x10 == 0x1 (0x1) +__longlong 0xa != 0x2710 == 0x1 (0x1) +__ulonglong 0xa != 0x2710 == 0x1 (0x1) +float 0xa != 0x2710 == 0x1 (0x1) +int 0xa >= 0x2710 == 0x0 (0x0) +__uint 0xa >= 0x2710 == 0x0 (0x0) +char 0xa >= 0x10 == 0x0 (0x0) +__uchar 0xa >= 0x10 == 0x0 (0x0) +__longlong 0xa >= 0x2710 == 0x0 (0x0) +__ulonglong 0xa >= 0x2710 == 0x0 (0x0) +float 0xa >= 0x2710 == 0x0 (0x0) +int 0xa / 0x2710 == 0x0 (0x0) +__uint 0xa / 0x2710 == 0x0 (0x0) +char 0xa / 0x10 == 0x0 (0x0) +__uchar 0xa / 0x10 == 0x0 (0x0) +__longlong 0xa / 0x2710 == 0x0 (0x0) +__ulonglong 0xa / 0x2710 == 0x0 (0x0) +float 0xa / 0x2710 == 0x0 (0x0) +int 0xa % 0x2710 == 0xa (0xa) +__uint 0xa % 0x2710 == 0xa (0xa) +char 0xa % 0x10 == 0xa (0xa) +__uchar 0xa % 0x10 == 0xa (0xa) +__longlong 0xa % 0x2710 == 0xa (0xa) +__ulonglong 0xa % 0x2710 == 0xa (0xa) +int xor420xa xor42 0x20 +__uint xor420xa xor42 0x20 +char xor420xa xor42 0x20 +__uchar xor420xa xor42 0x20 +__longlong xor420xa xor42 0x20 +__ulonglong xor420xa xor42 0x20 +int land10xa land1 0x1 +__uint land10xa land1 0x1 +char land10xa land1 0x1 +__uchar land10xa land1 0x1 +__longlong land10xa land1 0x1 +__ulonglong land10xa land1 0x1 +int lor10xa lor1 0x1 +__uint lor10xa lor1 0x1 +char lor10xa lor1 0x1 +__uchar lor10xa lor1 0x1 +__longlong lor10xa lor1 0x1 +__ulonglong lor10xa lor1 0x1 +int and420xa and42 0xa +__uint and420xa and42 0xa +char and420xa and42 0xa +__uchar and420xa and42 0xa +__longlong and420xa and42 0xa +__ulonglong and420xa and42 0xa +int or420xa or42 0x2a +__uint or420xa or42 0x2a +char or420xa or42 0x2a +__uchar or420xa or42 0x2a +__longlong or420xa or42 0x2a +__ulonglong or420xa or42 0x2a +int shl50xa shl5 0x140 +__uint shl50xa shl5 0x140 +char shl50xa shl5 0x40 +__uchar shl50xa shl5 0x40 +__longlong shl50xa shl5 0x140 +__ulonglong shl50xa shl5 0x140 +int shr50xa shr5 0x0 +__uint shr50xa shr5 0x0 +char shr50xa shr5 0x0 +__uchar shr50xa shr5 0x0 +__longlong shr50xa shr5 0x0 +__ulonglong shr50xa shr5 0x0 +int add420xa add42 0x34 +__uint add420xa add42 0x34 +char add420xa add42 0x34 +__uchar add420xa add42 0x34 +__longlong add420xa add42 0x34 +__ulonglong add420xa add42 0x34 +float add420xa add42 0x34 +int sub420xa sub42 -0x20 +__uint sub420xa sub42 -0x20 +char sub420xa sub42 -0x20 +__uchar sub420xa sub42 0xe0 +__longlong sub420xa sub42 -0x20 +__ulonglong sub420xa sub42 -0x20 +float sub420xa sub42 -0x20 +int mul420xa mul42 0x1a4 +__uint mul420xa mul42 0x1a4 +char mul420xa mul42 -0x5c +__uchar mul420xa mul42 0xa4 +__longlong mul420xa mul42 0x1a4 +__ulonglong mul420xa mul42 0x1a4 +float mul420xa mul42 0x1a4 +int lt420xa lt42 0x1 +__uint lt420xa lt42 0x1 +char lt420xa lt42 0x1 +__uchar lt420xa lt42 0x1 +__longlong lt420xa lt42 0x1 +__ulonglong lt420xa lt42 0x1 +float lt420xa lt42 0x1 +int gt420xa gt42 0x0 +__uint gt420xa gt42 0x0 +char gt420xa gt42 0x0 +__uchar gt420xa gt42 0x0 +__longlong gt420xa gt42 0x0 +__ulonglong gt420xa gt42 0x0 +float gt420xa gt42 0x0 +int le420xa le42 0x1 +__uint le420xa le42 0x1 +char le420xa le42 0x1 +__uchar le420xa le42 0x1 +__longlong le420xa le42 0x1 +__ulonglong le420xa le42 0x1 +float le420xa le42 0x1 +int eq420xa eq42 0x0 +__uint eq420xa eq42 0x0 +char eq420xa eq42 0x0 +__uchar eq420xa eq42 0x0 +__longlong eq420xa eq42 0x0 +__ulonglong eq420xa eq42 0x0 +float eq420xa eq42 0x0 +int ne420xa ne42 0x1 +__uint ne420xa ne42 0x1 +char ne420xa ne42 0x1 +__uchar ne420xa ne42 0x1 +__longlong ne420xa ne42 0x1 +__ulonglong ne420xa ne42 0x1 +float ne420xa ne42 0x1 +int ge420xa ge42 0x0 +__uint ge420xa ge42 0x0 +char ge420xa ge42 0x0 +__uchar ge420xa ge42 0x0 +__longlong ge420xa ge42 0x0 +__ulonglong ge420xa ge42 0x0 +float ge420xa ge42 0x0 +int div420xa div42 0x0 +__uint div420xa div42 0x0 +char div420xa div42 0x0 +__uchar div420xa div42 0x0 +__longlong div420xa div42 0x0 +__ulonglong div420xa div42 0x0 +float div420xa div42 0x0 +int mod230xa mod23 0xa +__uint mod230xa mod23 0xa +char mod230xa mod23 0xa +__uchar mod230xa mod23 0xa +__longlong mod230xa mod23 0xa +__ulonglong mod230xa mod23 0xa +0xfff6 * 0xffff == 0xa +0xfff6 / 0xffff == 0xa +0xfff6 % 0xffff == 0x0 +int 0xfff6 ^ 0xffff == 0x9 (0x9) +__uint 0xfff6 ^ 0xffff == 0x9 (0x9) +char 0xfff6 ^ 0xffff == 0x9 (0x9) +__uchar 0xf6 ^ 0xff == 0x9 (0x9) +__longlong 0xfff6 ^ 0xffff == 0x9 (0x9) +__ulonglong 0xfff6 ^ 0xffff == 0x9 (0x9) +int 0xfff6 && 0xffff == 0x1 (0x1) +__uint 0xfff6 && 0xffff == 0x1 (0x1) +char 0xfff6 && 0xffff == 0x1 (0x1) +__uchar 0xf6 && 0xff == 0x1 (0x1) +__longlong 0xfff6 && 0xffff == 0x1 (0x1) +__ulonglong 0xfff6 && 0xffff == 0x1 (0x1) +int 0xfff6 || 0xffff == 0x1 (0x1) +__uint 0xfff6 || 0xffff == 0x1 (0x1) +char 0xfff6 || 0xffff == 0x1 (0x1) +__uchar 0xf6 || 0xff == 0x1 (0x1) +__longlong 0xfff6 || 0xffff == 0x1 (0x1) +__ulonglong 0xfff6 || 0xffff == 0x1 (0x1) +int 0xfff6 & 0xffff == -0xa (0xfff6) +__uint 0xfff6 & 0xffff == -0xa (0xfff6) +char 0xfff6 & 0xffff == -0xa (0xfff6) +__uchar 0xf6 & 0xff == 0xf6 (0xf6) +__longlong 0xfff6 & 0xffff == -0xa (0xfff6) +__ulonglong 0xfff6 & 0xffff == -0xa (0xfff6) +int 0xfff6 | 0xffff == -0x1 (0xffff) +__uint 0xfff6 | 0xffff == -0x1 (0xffff) +char 0xfff6 | 0xffff == -0x1 (0xffff) +__uchar 0xf6 | 0xff == 0xff (0xff) +__longlong 0xfff6 | 0xffff == -0x1 (0xffff) +__ulonglong 0xfff6 | 0xffff == -0x1 (0xffff) +int 0xfff6 << 0x1 == -0x14 (0xffec) +__uint 0xfff6 << 0x1 == -0x14 (0xffec) +char 0xfff6 << 0x1 == -0x14 (0xffec) +__uchar 0xf6 << 0x1 == 0xec (0xec) +__longlong 0xfff6 << 0x1 == -0x14 (0xffec) +__ulonglong 0xfff6 << 0x1 == -0x14 (0xffec) +int 0xfff6 >> 0x1 == -0x5 (0xfffb) +__uint 0xfff6 >> 0x1 == 0x7ffb (0x7ffb) +char 0xfff6 >> 0x1 == -0x5 (0xfffb) +__uchar 0xf6 >> 0x1 == 0x7b (0x7b) +__longlong 0xfff6 >> 0x1 == -0x5 (0xfffb) +__ulonglong 0xfff6 >> 0x1 == -0x5 (0xfffb) +int 0xfff6 + 0xffff == -0xb (0xfff5) +__uint 0xfff6 + 0xffff == -0xb (0xfff5) +char 0xfff6 + 0xffff == -0xb (0xfff5) +__uchar 0xf6 + 0xff == 0xf5 (0xf5) +__longlong 0xfff6 + 0xffff == -0xb (0xfff5) +__ulonglong 0xfff6 + 0xffff == -0xb (0xfff5) +float 0xfff6 + 0xffff == -0xb (0xfff5) +int 0xfff6 - 0xffff == -0x9 (0xfff7) +__uint 0xfff6 - 0xffff == -0x9 (0xfff7) +char 0xfff6 - 0xffff == -0x9 (0xfff7) +__uchar 0xf6 - 0xff == 0xf7 (0xf7) +__longlong 0xfff6 - 0xffff == -0x9 (0xfff7) +__ulonglong 0xfff6 - 0xffff == -0x9 (0xfff7) +float 0xfff6 - 0xffff == -0x9 (0xfff7) +int 0xfff6 * 0xffff == 0xa (0xa) +__uint 0xfff6 * 0xffff == 0xa (0xa) +char 0xfff6 * 0xffff == 0xa (0xa) +__uchar 0xf6 * 0xff == 0xa (0xa) +__longlong 0xfff6 * 0xffff == 0xa (0xa) +__ulonglong 0xfff6 * 0xffff == 0xa (0xa) +float 0xfff6 * 0xffff == 0xa (0xa) +int 0xfff6 < 0xffff == 0x1 (0x1) +__uint 0xfff6 < 0xffff == 0x1 (0x1) +char 0xfff6 < 0xffff == 0x1 (0x1) +__uchar 0xf6 < 0xff == 0x1 (0x1) +__longlong 0xfff6 < 0xffff == 0x1 (0x1) +__ulonglong 0xfff6 < 0xffff == 0x1 (0x1) +float 0xfff6 < 0xffff == 0x1 (0x1) +int 0xfff6 > 0xffff == 0x0 (0x0) +__uint 0xfff6 > 0xffff == 0x0 (0x0) +char 0xfff6 > 0xffff == 0x0 (0x0) +__uchar 0xf6 > 0xff == 0x0 (0x0) +__longlong 0xfff6 > 0xffff == 0x0 (0x0) +__ulonglong 0xfff6 > 0xffff == 0x0 (0x0) +float 0xfff6 > 0xffff == 0x0 (0x0) +int 0xfff6 <= 0xffff == 0x1 (0x1) +__uint 0xfff6 <= 0xffff == 0x1 (0x1) +char 0xfff6 <= 0xffff == 0x1 (0x1) +__uchar 0xf6 <= 0xff == 0x1 (0x1) +__longlong 0xfff6 <= 0xffff == 0x1 (0x1) +__ulonglong 0xfff6 <= 0xffff == 0x1 (0x1) +float 0xfff6 <= 0xffff == 0x1 (0x1) +int 0xfff6 == 0xffff == 0x0 (0x0) +__uint 0xfff6 == 0xffff == 0x0 (0x0) +char 0xfff6 == 0xffff == 0x0 (0x0) +__uchar 0xf6 == 0xff == 0x0 (0x0) +__longlong 0xfff6 == 0xffff == 0x0 (0x0) +__ulonglong 0xfff6 == 0xffff == 0x0 (0x0) +float 0xfff6 == 0xffff == 0x0 (0x0) +int 0xfff6 != 0xffff == 0x1 (0x1) +__uint 0xfff6 != 0xffff == 0x1 (0x1) +char 0xfff6 != 0xffff == 0x1 (0x1) +__uchar 0xf6 != 0xff == 0x1 (0x1) +__longlong 0xfff6 != 0xffff == 0x1 (0x1) +__ulonglong 0xfff6 != 0xffff == 0x1 (0x1) +float 0xfff6 != 0xffff == 0x1 (0x1) +int 0xfff6 >= 0xffff == 0x0 (0x0) +__uint 0xfff6 >= 0xffff == 0x0 (0x0) +char 0xfff6 >= 0xffff == 0x0 (0x0) +__uchar 0xf6 >= 0xff == 0x0 (0x0) +__longlong 0xfff6 >= 0xffff == 0x0 (0x0) +__ulonglong 0xfff6 >= 0xffff == 0x0 (0x0) +float 0xfff6 >= 0xffff == 0x0 (0x0) +int 0xfff6 / 0xffff == 0xa (0xa) +__uint 0xfff6 / 0xffff == 0x0 (0x0) +char 0xfff6 / 0xffff == 0xa (0xa) +__uchar 0xf6 / 0xff == 0x0 (0x0) +__longlong 0xfff6 / 0xffff == 0xa (0xa) +__ulonglong 0xfff6 / 0xffff == 0x0 (0x0) +float 0xfff6 / 0xffff == 0xa (0xa) +int 0xfff6 % 0xffff == 0x0 (0x0) +__uint 0xfff6 % 0xffff == -0xa (0xfff6) +char 0xfff6 % 0xffff == 0x0 (0x0) +__uchar 0xf6 % 0xff == 0xf6 (0xf6) +__longlong 0xfff6 % 0xffff == 0x0 (0x0) +__ulonglong 0xfff6 % 0xffff == -0xa (0xfff6) +0xfff6 * 0x1 == -0xa +0xfff6 / 0x1 == -0xa +0xfff6 % 0x1 == 0x0 +int 0xfff6 ^ 0x1 == -0x9 (0xfff7) +__uint 0xfff6 ^ 0x1 == -0x9 (0xfff7) +char 0xfff6 ^ 0x1 == -0x9 (0xfff7) +__uchar 0xf6 ^ 0x1 == 0xf7 (0xf7) +__longlong 0xfff6 ^ 0x1 == -0x9 (0xfff7) +__ulonglong 0xfff6 ^ 0x1 == -0x9 (0xfff7) +int 0xfff6 && 0x1 == 0x1 (0x1) +__uint 0xfff6 && 0x1 == 0x1 (0x1) +char 0xfff6 && 0x1 == 0x1 (0x1) +__uchar 0xf6 && 0x1 == 0x1 (0x1) +__longlong 0xfff6 && 0x1 == 0x1 (0x1) +__ulonglong 0xfff6 && 0x1 == 0x1 (0x1) +int 0xfff6 || 0x1 == 0x1 (0x1) +__uint 0xfff6 || 0x1 == 0x1 (0x1) +char 0xfff6 || 0x1 == 0x1 (0x1) +__uchar 0xf6 || 0x1 == 0x1 (0x1) +__longlong 0xfff6 || 0x1 == 0x1 (0x1) +__ulonglong 0xfff6 || 0x1 == 0x1 (0x1) +int 0xfff6 & 0x1 == 0x0 (0x0) +__uint 0xfff6 & 0x1 == 0x0 (0x0) +char 0xfff6 & 0x1 == 0x0 (0x0) +__uchar 0xf6 & 0x1 == 0x0 (0x0) +__longlong 0xfff6 & 0x1 == 0x0 (0x0) +__ulonglong 0xfff6 & 0x1 == 0x0 (0x0) +int 0xfff6 | 0x1 == -0x9 (0xfff7) +__uint 0xfff6 | 0x1 == -0x9 (0xfff7) +char 0xfff6 | 0x1 == -0x9 (0xfff7) +__uchar 0xf6 | 0x1 == 0xf7 (0xf7) +__longlong 0xfff6 | 0x1 == -0x9 (0xfff7) +__ulonglong 0xfff6 | 0x1 == -0x9 (0xfff7) +int 0xfff6 << 0x2 == -0x28 (0xffd8) +__uint 0xfff6 << 0x2 == -0x28 (0xffd8) +char 0xfff6 << 0x2 == -0x28 (0xffd8) +__uchar 0xf6 << 0x2 == 0xd8 (0xd8) +__longlong 0xfff6 << 0x2 == -0x28 (0xffd8) +__ulonglong 0xfff6 << 0x2 == -0x28 (0xffd8) +int 0xfff6 >> 0x2 == -0x3 (0xfffd) +__uint 0xfff6 >> 0x2 == 0x3ffd (0x3ffd) +char 0xfff6 >> 0x2 == -0x3 (0xfffd) +__uchar 0xf6 >> 0x2 == 0x3d (0x3d) +__longlong 0xfff6 >> 0x2 == -0x3 (0xfffd) +__ulonglong 0xfff6 >> 0x2 == -0x3 (0xfffd) +int 0xfff6 + 0x1 == -0x9 (0xfff7) +__uint 0xfff6 + 0x1 == -0x9 (0xfff7) +char 0xfff6 + 0x1 == -0x9 (0xfff7) +__uchar 0xf6 + 0x1 == 0xf7 (0xf7) +__longlong 0xfff6 + 0x1 == -0x9 (0xfff7) +__ulonglong 0xfff6 + 0x1 == -0x9 (0xfff7) +float 0xfff6 + 0x1 == -0x9 (0xfff7) +int 0xfff6 - 0x1 == -0xb (0xfff5) +__uint 0xfff6 - 0x1 == -0xb (0xfff5) +char 0xfff6 - 0x1 == -0xb (0xfff5) +__uchar 0xf6 - 0x1 == 0xf5 (0xf5) +__longlong 0xfff6 - 0x1 == -0xb (0xfff5) +__ulonglong 0xfff6 - 0x1 == -0xb (0xfff5) +float 0xfff6 - 0x1 == -0xb (0xfff5) +int 0xfff6 * 0x1 == -0xa (0xfff6) +__uint 0xfff6 * 0x1 == -0xa (0xfff6) +char 0xfff6 * 0x1 == -0xa (0xfff6) +__uchar 0xf6 * 0x1 == 0xf6 (0xf6) +__longlong 0xfff6 * 0x1 == -0xa (0xfff6) +__ulonglong 0xfff6 * 0x1 == -0xa (0xfff6) +float 0xfff6 * 0x1 == -0xa (0xfff6) +int 0xfff6 < 0x1 == 0x1 (0x1) +__uint 0xfff6 < 0x1 == 0x0 (0x0) +char 0xfff6 < 0x1 == 0x1 (0x1) +__uchar 0xf6 < 0x1 == 0x0 (0x0) +__longlong 0xfff6 < 0x1 == 0x1 (0x1) +__ulonglong 0xfff6 < 0x1 == 0x0 (0x0) +float 0xfff6 < 0x1 == 0x1 (0x1) +int 0xfff6 > 0x1 == 0x0 (0x0) +__uint 0xfff6 > 0x1 == 0x1 (0x1) +char 0xfff6 > 0x1 == 0x0 (0x0) +__uchar 0xf6 > 0x1 == 0x1 (0x1) +__longlong 0xfff6 > 0x1 == 0x0 (0x0) +__ulonglong 0xfff6 > 0x1 == 0x1 (0x1) +float 0xfff6 > 0x1 == 0x0 (0x0) +int 0xfff6 <= 0x1 == 0x1 (0x1) +__uint 0xfff6 <= 0x1 == 0x0 (0x0) +char 0xfff6 <= 0x1 == 0x1 (0x1) +__uchar 0xf6 <= 0x1 == 0x0 (0x0) +__longlong 0xfff6 <= 0x1 == 0x1 (0x1) +__ulonglong 0xfff6 <= 0x1 == 0x0 (0x0) +float 0xfff6 <= 0x1 == 0x1 (0x1) +int 0xfff6 == 0x1 == 0x0 (0x0) +__uint 0xfff6 == 0x1 == 0x0 (0x0) +char 0xfff6 == 0x1 == 0x0 (0x0) +__uchar 0xf6 == 0x1 == 0x0 (0x0) +__longlong 0xfff6 == 0x1 == 0x0 (0x0) +__ulonglong 0xfff6 == 0x1 == 0x0 (0x0) +float 0xfff6 == 0x1 == 0x0 (0x0) +int 0xfff6 != 0x1 == 0x1 (0x1) +__uint 0xfff6 != 0x1 == 0x1 (0x1) +char 0xfff6 != 0x1 == 0x1 (0x1) +__uchar 0xf6 != 0x1 == 0x1 (0x1) +__longlong 0xfff6 != 0x1 == 0x1 (0x1) +__ulonglong 0xfff6 != 0x1 == 0x1 (0x1) +float 0xfff6 != 0x1 == 0x1 (0x1) +int 0xfff6 >= 0x1 == 0x0 (0x0) +__uint 0xfff6 >= 0x1 == 0x1 (0x1) +char 0xfff6 >= 0x1 == 0x0 (0x0) +__uchar 0xf6 >= 0x1 == 0x1 (0x1) +__longlong 0xfff6 >= 0x1 == 0x0 (0x0) +__ulonglong 0xfff6 >= 0x1 == 0x1 (0x1) +float 0xfff6 >= 0x1 == 0x0 (0x0) +int 0xfff6 / 0x1 == -0xa (0xfff6) +__uint 0xfff6 / 0x1 == -0xa (0xfff6) +char 0xfff6 / 0x1 == -0xa (0xfff6) +__uchar 0xf6 / 0x1 == 0xf6 (0xf6) +__longlong 0xfff6 / 0x1 == -0xa (0xfff6) +__ulonglong 0xfff6 / 0x1 == -0xa (0xfff6) +float 0xfff6 / 0x1 == -0xa (0xfff6) +int 0xfff6 % 0x1 == 0x0 (0x0) +__uint 0xfff6 % 0x1 == 0x0 (0x0) +char 0xfff6 % 0x1 == 0x0 (0x0) +__uchar 0xf6 % 0x1 == 0x0 (0x0) +__longlong 0xfff6 % 0x1 == 0x0 (0x0) +__ulonglong 0xfff6 % 0x1 == 0x0 (0x0) +0xfff6 * 0x2 == -0x14 +0xfff6 / 0x2 == -0x5 +0xfff6 % 0x2 == 0x0 +int 0xfff6 ^ 0x2 == -0xc (0xfff4) +__uint 0xfff6 ^ 0x2 == -0xc (0xfff4) +char 0xfff6 ^ 0x2 == -0xc (0xfff4) +__uchar 0xf6 ^ 0x2 == 0xf4 (0xf4) +__longlong 0xfff6 ^ 0x2 == -0xc (0xfff4) +__ulonglong 0xfff6 ^ 0x2 == -0xc (0xfff4) +int 0xfff6 && 0x2 == 0x1 (0x1) +__uint 0xfff6 && 0x2 == 0x1 (0x1) +char 0xfff6 && 0x2 == 0x1 (0x1) +__uchar 0xf6 && 0x2 == 0x1 (0x1) +__longlong 0xfff6 && 0x2 == 0x1 (0x1) +__ulonglong 0xfff6 && 0x2 == 0x1 (0x1) +int 0xfff6 || 0x2 == 0x1 (0x1) +__uint 0xfff6 || 0x2 == 0x1 (0x1) +char 0xfff6 || 0x2 == 0x1 (0x1) +__uchar 0xf6 || 0x2 == 0x1 (0x1) +__longlong 0xfff6 || 0x2 == 0x1 (0x1) +__ulonglong 0xfff6 || 0x2 == 0x1 (0x1) +int 0xfff6 & 0x2 == 0x2 (0x2) +__uint 0xfff6 & 0x2 == 0x2 (0x2) +char 0xfff6 & 0x2 == 0x2 (0x2) +__uchar 0xf6 & 0x2 == 0x2 (0x2) +__longlong 0xfff6 & 0x2 == 0x2 (0x2) +__ulonglong 0xfff6 & 0x2 == 0x2 (0x2) +int 0xfff6 | 0x2 == -0xa (0xfff6) +__uint 0xfff6 | 0x2 == -0xa (0xfff6) +char 0xfff6 | 0x2 == -0xa (0xfff6) +__uchar 0xf6 | 0x2 == 0xf6 (0xf6) +__longlong 0xfff6 | 0x2 == -0xa (0xfff6) +__ulonglong 0xfff6 | 0x2 == -0xa (0xfff6) +int 0xfff6 << 0x3 == -0x50 (0xffb0) +__uint 0xfff6 << 0x3 == -0x50 (0xffb0) +char 0xfff6 << 0x3 == -0x50 (0xffb0) +__uchar 0xf6 << 0x3 == 0xb0 (0xb0) +__longlong 0xfff6 << 0x3 == -0x50 (0xffb0) +__ulonglong 0xfff6 << 0x3 == -0x50 (0xffb0) +int 0xfff6 >> 0x3 == -0x2 (0xfffe) +__uint 0xfff6 >> 0x3 == 0x1ffe (0x1ffe) +char 0xfff6 >> 0x3 == -0x2 (0xfffe) +__uchar 0xf6 >> 0x3 == 0x1e (0x1e) +__longlong 0xfff6 >> 0x3 == -0x2 (0xfffe) +__ulonglong 0xfff6 >> 0x3 == -0x2 (0xfffe) +int 0xfff6 + 0x2 == -0x8 (0xfff8) +__uint 0xfff6 + 0x2 == -0x8 (0xfff8) +char 0xfff6 + 0x2 == -0x8 (0xfff8) +__uchar 0xf6 + 0x2 == 0xf8 (0xf8) +__longlong 0xfff6 + 0x2 == -0x8 (0xfff8) +__ulonglong 0xfff6 + 0x2 == -0x8 (0xfff8) +float 0xfff6 + 0x2 == -0x8 (0xfff8) +int 0xfff6 - 0x2 == -0xc (0xfff4) +__uint 0xfff6 - 0x2 == -0xc (0xfff4) +char 0xfff6 - 0x2 == -0xc (0xfff4) +__uchar 0xf6 - 0x2 == 0xf4 (0xf4) +__longlong 0xfff6 - 0x2 == -0xc (0xfff4) +__ulonglong 0xfff6 - 0x2 == -0xc (0xfff4) +float 0xfff6 - 0x2 == -0xc (0xfff4) +int 0xfff6 * 0x2 == -0x14 (0xffec) +__uint 0xfff6 * 0x2 == -0x14 (0xffec) +char 0xfff6 * 0x2 == -0x14 (0xffec) +__uchar 0xf6 * 0x2 == 0xec (0xec) +__longlong 0xfff6 * 0x2 == -0x14 (0xffec) +__ulonglong 0xfff6 * 0x2 == -0x14 (0xffec) +float 0xfff6 * 0x2 == -0x14 (0xffec) +int 0xfff6 < 0x2 == 0x1 (0x1) +__uint 0xfff6 < 0x2 == 0x0 (0x0) +char 0xfff6 < 0x2 == 0x1 (0x1) +__uchar 0xf6 < 0x2 == 0x0 (0x0) +__longlong 0xfff6 < 0x2 == 0x1 (0x1) +__ulonglong 0xfff6 < 0x2 == 0x0 (0x0) +float 0xfff6 < 0x2 == 0x1 (0x1) +int 0xfff6 > 0x2 == 0x0 (0x0) +__uint 0xfff6 > 0x2 == 0x1 (0x1) +char 0xfff6 > 0x2 == 0x0 (0x0) +__uchar 0xf6 > 0x2 == 0x1 (0x1) +__longlong 0xfff6 > 0x2 == 0x0 (0x0) +__ulonglong 0xfff6 > 0x2 == 0x1 (0x1) +float 0xfff6 > 0x2 == 0x0 (0x0) +int 0xfff6 <= 0x2 == 0x1 (0x1) +__uint 0xfff6 <= 0x2 == 0x0 (0x0) +char 0xfff6 <= 0x2 == 0x1 (0x1) +__uchar 0xf6 <= 0x2 == 0x0 (0x0) +__longlong 0xfff6 <= 0x2 == 0x1 (0x1) +__ulonglong 0xfff6 <= 0x2 == 0x0 (0x0) +float 0xfff6 <= 0x2 == 0x1 (0x1) +int 0xfff6 == 0x2 == 0x0 (0x0) +__uint 0xfff6 == 0x2 == 0x0 (0x0) +char 0xfff6 == 0x2 == 0x0 (0x0) +__uchar 0xf6 == 0x2 == 0x0 (0x0) +__longlong 0xfff6 == 0x2 == 0x0 (0x0) +__ulonglong 0xfff6 == 0x2 == 0x0 (0x0) +float 0xfff6 == 0x2 == 0x0 (0x0) +int 0xfff6 != 0x2 == 0x1 (0x1) +__uint 0xfff6 != 0x2 == 0x1 (0x1) +char 0xfff6 != 0x2 == 0x1 (0x1) +__uchar 0xf6 != 0x2 == 0x1 (0x1) +__longlong 0xfff6 != 0x2 == 0x1 (0x1) +__ulonglong 0xfff6 != 0x2 == 0x1 (0x1) +float 0xfff6 != 0x2 == 0x1 (0x1) +int 0xfff6 >= 0x2 == 0x0 (0x0) +__uint 0xfff6 >= 0x2 == 0x1 (0x1) +char 0xfff6 >= 0x2 == 0x0 (0x0) +__uchar 0xf6 >= 0x2 == 0x1 (0x1) +__longlong 0xfff6 >= 0x2 == 0x0 (0x0) +__ulonglong 0xfff6 >= 0x2 == 0x1 (0x1) +float 0xfff6 >= 0x2 == 0x0 (0x0) +int 0xfff6 / 0x2 == -0x5 (0xfffb) +__uint 0xfff6 / 0x2 == 0x7ffb (0x7ffb) +char 0xfff6 / 0x2 == -0x5 (0xfffb) +__uchar 0xf6 / 0x2 == 0x7b (0x7b) +__longlong 0xfff6 / 0x2 == -0x5 (0xfffb) +__ulonglong 0xfff6 / 0x2 == -0x5 (0xfffb) +float 0xfff6 / 0x2 == -0x5 (0xfffb) +int 0xfff6 % 0x2 == 0x0 (0x0) +__uint 0xfff6 % 0x2 == 0x0 (0x0) +char 0xfff6 % 0x2 == 0x0 (0x0) +__uchar 0xf6 % 0x2 == 0x0 (0x0) +__longlong 0xfff6 % 0x2 == 0x0 (0x0) +__ulonglong 0xfff6 % 0x2 == 0x0 (0x0) +0xfff6 * 0xfffe == 0x14 +0xfff6 / 0xfffe == 0x5 +0xfff6 % 0xfffe == 0x0 +int 0xfff6 ^ 0xfffe == 0x8 (0x8) +__uint 0xfff6 ^ 0xfffe == 0x8 (0x8) +char 0xfff6 ^ 0xfffe == 0x8 (0x8) +__uchar 0xf6 ^ 0xfe == 0x8 (0x8) +__longlong 0xfff6 ^ 0xfffe == 0x8 (0x8) +__ulonglong 0xfff6 ^ 0xfffe == 0x8 (0x8) +int 0xfff6 && 0xfffe == 0x1 (0x1) +__uint 0xfff6 && 0xfffe == 0x1 (0x1) +char 0xfff6 && 0xfffe == 0x1 (0x1) +__uchar 0xf6 && 0xfe == 0x1 (0x1) +__longlong 0xfff6 && 0xfffe == 0x1 (0x1) +__ulonglong 0xfff6 && 0xfffe == 0x1 (0x1) +int 0xfff6 || 0xfffe == 0x1 (0x1) +__uint 0xfff6 || 0xfffe == 0x1 (0x1) +char 0xfff6 || 0xfffe == 0x1 (0x1) +__uchar 0xf6 || 0xfe == 0x1 (0x1) +__longlong 0xfff6 || 0xfffe == 0x1 (0x1) +__ulonglong 0xfff6 || 0xfffe == 0x1 (0x1) +int 0xfff6 & 0xfffe == -0xa (0xfff6) +__uint 0xfff6 & 0xfffe == -0xa (0xfff6) +char 0xfff6 & 0xfffe == -0xa (0xfff6) +__uchar 0xf6 & 0xfe == 0xf6 (0xf6) +__longlong 0xfff6 & 0xfffe == -0xa (0xfff6) +__ulonglong 0xfff6 & 0xfffe == -0xa (0xfff6) +int 0xfff6 | 0xfffe == -0x2 (0xfffe) +__uint 0xfff6 | 0xfffe == -0x2 (0xfffe) +char 0xfff6 | 0xfffe == -0x2 (0xfffe) +__uchar 0xf6 | 0xfe == 0xfe (0xfe) +__longlong 0xfff6 | 0xfffe == -0x2 (0xfffe) +__ulonglong 0xfff6 | 0xfffe == -0x2 (0xfffe) +int 0xfff6 << 0x4 == -0xa0 (0xff60) +__uint 0xfff6 << 0x4 == -0xa0 (0xff60) +char 0xfff6 << 0x4 == 0x60 (0x60) +__uchar 0xf6 << 0x4 == 0x60 (0x60) +__longlong 0xfff6 << 0x4 == -0xa0 (0xff60) +__ulonglong 0xfff6 << 0x4 == -0xa0 (0xff60) +int 0xfff6 >> 0x4 == -0x1 (0xffff) +__uint 0xfff6 >> 0x4 == 0xfff (0xfff) +char 0xfff6 >> 0x4 == -0x1 (0xffff) +__uchar 0xf6 >> 0x4 == 0xf (0xf) +__longlong 0xfff6 >> 0x4 == -0x1 (0xffff) +__ulonglong 0xfff6 >> 0x4 == -0x1 (0xffff) +int 0xfff6 + 0xfffe == -0xc (0xfff4) +__uint 0xfff6 + 0xfffe == -0xc (0xfff4) +char 0xfff6 + 0xfffe == -0xc (0xfff4) +__uchar 0xf6 + 0xfe == 0xf4 (0xf4) +__longlong 0xfff6 + 0xfffe == -0xc (0xfff4) +__ulonglong 0xfff6 + 0xfffe == -0xc (0xfff4) +float 0xfff6 + 0xfffe == -0xc (0xfff4) +int 0xfff6 - 0xfffe == -0x8 (0xfff8) +__uint 0xfff6 - 0xfffe == -0x8 (0xfff8) +char 0xfff6 - 0xfffe == -0x8 (0xfff8) +__uchar 0xf6 - 0xfe == 0xf8 (0xf8) +__longlong 0xfff6 - 0xfffe == -0x8 (0xfff8) +__ulonglong 0xfff6 - 0xfffe == -0x8 (0xfff8) +float 0xfff6 - 0xfffe == -0x8 (0xfff8) +int 0xfff6 * 0xfffe == 0x14 (0x14) +__uint 0xfff6 * 0xfffe == 0x14 (0x14) +char 0xfff6 * 0xfffe == 0x14 (0x14) +__uchar 0xf6 * 0xfe == 0x14 (0x14) +__longlong 0xfff6 * 0xfffe == 0x14 (0x14) +__ulonglong 0xfff6 * 0xfffe == 0x14 (0x14) +float 0xfff6 * 0xfffe == 0x14 (0x14) +int 0xfff6 < 0xfffe == 0x1 (0x1) +__uint 0xfff6 < 0xfffe == 0x1 (0x1) +char 0xfff6 < 0xfffe == 0x1 (0x1) +__uchar 0xf6 < 0xfe == 0x1 (0x1) +__longlong 0xfff6 < 0xfffe == 0x1 (0x1) +__ulonglong 0xfff6 < 0xfffe == 0x1 (0x1) +float 0xfff6 < 0xfffe == 0x1 (0x1) +int 0xfff6 > 0xfffe == 0x0 (0x0) +__uint 0xfff6 > 0xfffe == 0x0 (0x0) +char 0xfff6 > 0xfffe == 0x0 (0x0) +__uchar 0xf6 > 0xfe == 0x0 (0x0) +__longlong 0xfff6 > 0xfffe == 0x0 (0x0) +__ulonglong 0xfff6 > 0xfffe == 0x0 (0x0) +float 0xfff6 > 0xfffe == 0x0 (0x0) +int 0xfff6 <= 0xfffe == 0x1 (0x1) +__uint 0xfff6 <= 0xfffe == 0x1 (0x1) +char 0xfff6 <= 0xfffe == 0x1 (0x1) +__uchar 0xf6 <= 0xfe == 0x1 (0x1) +__longlong 0xfff6 <= 0xfffe == 0x1 (0x1) +__ulonglong 0xfff6 <= 0xfffe == 0x1 (0x1) +float 0xfff6 <= 0xfffe == 0x1 (0x1) +int 0xfff6 == 0xfffe == 0x0 (0x0) +__uint 0xfff6 == 0xfffe == 0x0 (0x0) +char 0xfff6 == 0xfffe == 0x0 (0x0) +__uchar 0xf6 == 0xfe == 0x0 (0x0) +__longlong 0xfff6 == 0xfffe == 0x0 (0x0) +__ulonglong 0xfff6 == 0xfffe == 0x0 (0x0) +float 0xfff6 == 0xfffe == 0x0 (0x0) +int 0xfff6 != 0xfffe == 0x1 (0x1) +__uint 0xfff6 != 0xfffe == 0x1 (0x1) +char 0xfff6 != 0xfffe == 0x1 (0x1) +__uchar 0xf6 != 0xfe == 0x1 (0x1) +__longlong 0xfff6 != 0xfffe == 0x1 (0x1) +__ulonglong 0xfff6 != 0xfffe == 0x1 (0x1) +float 0xfff6 != 0xfffe == 0x1 (0x1) +int 0xfff6 >= 0xfffe == 0x0 (0x0) +__uint 0xfff6 >= 0xfffe == 0x0 (0x0) +char 0xfff6 >= 0xfffe == 0x0 (0x0) +__uchar 0xf6 >= 0xfe == 0x0 (0x0) +__longlong 0xfff6 >= 0xfffe == 0x0 (0x0) +__ulonglong 0xfff6 >= 0xfffe == 0x0 (0x0) +float 0xfff6 >= 0xfffe == 0x0 (0x0) +int 0xfff6 / 0xfffe == 0x5 (0x5) +__uint 0xfff6 / 0xfffe == 0x0 (0x0) +char 0xfff6 / 0xfffe == 0x5 (0x5) +__uchar 0xf6 / 0xfe == 0x0 (0x0) +__longlong 0xfff6 / 0xfffe == 0x5 (0x5) +__ulonglong 0xfff6 / 0xfffe == 0x0 (0x0) +float 0xfff6 / 0xfffe == 0x5 (0x5) +int 0xfff6 % 0xfffe == 0x0 (0x0) +__uint 0xfff6 % 0xfffe == -0xa (0xfff6) +char 0xfff6 % 0xfffe == 0x0 (0x0) +__uchar 0xf6 % 0xfe == 0xf6 (0xf6) +__longlong 0xfff6 % 0xfffe == 0x0 (0x0) +__ulonglong 0xfff6 % 0xfffe == -0xa (0xfff6) +0xfff6 * 0x4 == -0x28 +0xfff6 / 0x4 == -0x2 +0xfff6 % 0x4 == -0x2 +int 0xfff6 ^ 0x4 == -0xe (0xfff2) +__uint 0xfff6 ^ 0x4 == -0xe (0xfff2) +char 0xfff6 ^ 0x4 == -0xe (0xfff2) +__uchar 0xf6 ^ 0x4 == 0xf2 (0xf2) +__longlong 0xfff6 ^ 0x4 == -0xe (0xfff2) +__ulonglong 0xfff6 ^ 0x4 == -0xe (0xfff2) +int 0xfff6 && 0x4 == 0x1 (0x1) +__uint 0xfff6 && 0x4 == 0x1 (0x1) +char 0xfff6 && 0x4 == 0x1 (0x1) +__uchar 0xf6 && 0x4 == 0x1 (0x1) +__longlong 0xfff6 && 0x4 == 0x1 (0x1) +__ulonglong 0xfff6 && 0x4 == 0x1 (0x1) +int 0xfff6 || 0x4 == 0x1 (0x1) +__uint 0xfff6 || 0x4 == 0x1 (0x1) +char 0xfff6 || 0x4 == 0x1 (0x1) +__uchar 0xf6 || 0x4 == 0x1 (0x1) +__longlong 0xfff6 || 0x4 == 0x1 (0x1) +__ulonglong 0xfff6 || 0x4 == 0x1 (0x1) +int 0xfff6 & 0x4 == 0x4 (0x4) +__uint 0xfff6 & 0x4 == 0x4 (0x4) +char 0xfff6 & 0x4 == 0x4 (0x4) +__uchar 0xf6 & 0x4 == 0x4 (0x4) +__longlong 0xfff6 & 0x4 == 0x4 (0x4) +__ulonglong 0xfff6 & 0x4 == 0x4 (0x4) +int 0xfff6 | 0x4 == -0xa (0xfff6) +__uint 0xfff6 | 0x4 == -0xa (0xfff6) +char 0xfff6 | 0x4 == -0xa (0xfff6) +__uchar 0xf6 | 0x4 == 0xf6 (0xf6) +__longlong 0xfff6 | 0x4 == -0xa (0xfff6) +__ulonglong 0xfff6 | 0x4 == -0xa (0xfff6) +int 0xfff6 << 0x5 == -0x140 (0xfec0) +__uint 0xfff6 << 0x5 == -0x140 (0xfec0) +char 0xfff6 << 0x5 == -0x40 (0xffc0) +__uchar 0xf6 << 0x5 == 0xc0 (0xc0) +__longlong 0xfff6 << 0x5 == -0x140 (0xfec0) +__ulonglong 0xfff6 << 0x5 == -0x140 (0xfec0) +int 0xfff6 >> 0x5 == -0x1 (0xffff) +__uint 0xfff6 >> 0x5 == 0x7ff (0x7ff) +char 0xfff6 >> 0x5 == -0x1 (0xffff) +__uchar 0xf6 >> 0x5 == 0x7 (0x7) +__longlong 0xfff6 >> 0x5 == -0x1 (0xffff) +__ulonglong 0xfff6 >> 0x5 == -0x1 (0xffff) +int 0xfff6 + 0x4 == -0x6 (0xfffa) +__uint 0xfff6 + 0x4 == -0x6 (0xfffa) +char 0xfff6 + 0x4 == -0x6 (0xfffa) +__uchar 0xf6 + 0x4 == 0xfa (0xfa) +__longlong 0xfff6 + 0x4 == -0x6 (0xfffa) +__ulonglong 0xfff6 + 0x4 == -0x6 (0xfffa) +float 0xfff6 + 0x4 == -0x6 (0xfffa) +int 0xfff6 - 0x4 == -0xe (0xfff2) +__uint 0xfff6 - 0x4 == -0xe (0xfff2) +char 0xfff6 - 0x4 == -0xe (0xfff2) +__uchar 0xf6 - 0x4 == 0xf2 (0xf2) +__longlong 0xfff6 - 0x4 == -0xe (0xfff2) +__ulonglong 0xfff6 - 0x4 == -0xe (0xfff2) +float 0xfff6 - 0x4 == -0xe (0xfff2) +int 0xfff6 * 0x4 == -0x28 (0xffd8) +__uint 0xfff6 * 0x4 == -0x28 (0xffd8) +char 0xfff6 * 0x4 == -0x28 (0xffd8) +__uchar 0xf6 * 0x4 == 0xd8 (0xd8) +__longlong 0xfff6 * 0x4 == -0x28 (0xffd8) +__ulonglong 0xfff6 * 0x4 == -0x28 (0xffd8) +float 0xfff6 * 0x4 == -0x28 (0xffd8) +int 0xfff6 < 0x4 == 0x1 (0x1) +__uint 0xfff6 < 0x4 == 0x0 (0x0) +char 0xfff6 < 0x4 == 0x1 (0x1) +__uchar 0xf6 < 0x4 == 0x0 (0x0) +__longlong 0xfff6 < 0x4 == 0x1 (0x1) +__ulonglong 0xfff6 < 0x4 == 0x0 (0x0) +float 0xfff6 < 0x4 == 0x1 (0x1) +int 0xfff6 > 0x4 == 0x0 (0x0) +__uint 0xfff6 > 0x4 == 0x1 (0x1) +char 0xfff6 > 0x4 == 0x0 (0x0) +__uchar 0xf6 > 0x4 == 0x1 (0x1) +__longlong 0xfff6 > 0x4 == 0x0 (0x0) +__ulonglong 0xfff6 > 0x4 == 0x1 (0x1) +float 0xfff6 > 0x4 == 0x0 (0x0) +int 0xfff6 <= 0x4 == 0x1 (0x1) +__uint 0xfff6 <= 0x4 == 0x0 (0x0) +char 0xfff6 <= 0x4 == 0x1 (0x1) +__uchar 0xf6 <= 0x4 == 0x0 (0x0) +__longlong 0xfff6 <= 0x4 == 0x1 (0x1) +__ulonglong 0xfff6 <= 0x4 == 0x0 (0x0) +float 0xfff6 <= 0x4 == 0x1 (0x1) +int 0xfff6 == 0x4 == 0x0 (0x0) +__uint 0xfff6 == 0x4 == 0x0 (0x0) +char 0xfff6 == 0x4 == 0x0 (0x0) +__uchar 0xf6 == 0x4 == 0x0 (0x0) +__longlong 0xfff6 == 0x4 == 0x0 (0x0) +__ulonglong 0xfff6 == 0x4 == 0x0 (0x0) +float 0xfff6 == 0x4 == 0x0 (0x0) +int 0xfff6 != 0x4 == 0x1 (0x1) +__uint 0xfff6 != 0x4 == 0x1 (0x1) +char 0xfff6 != 0x4 == 0x1 (0x1) +__uchar 0xf6 != 0x4 == 0x1 (0x1) +__longlong 0xfff6 != 0x4 == 0x1 (0x1) +__ulonglong 0xfff6 != 0x4 == 0x1 (0x1) +float 0xfff6 != 0x4 == 0x1 (0x1) +int 0xfff6 >= 0x4 == 0x0 (0x0) +__uint 0xfff6 >= 0x4 == 0x1 (0x1) +char 0xfff6 >= 0x4 == 0x0 (0x0) +__uchar 0xf6 >= 0x4 == 0x1 (0x1) +__longlong 0xfff6 >= 0x4 == 0x0 (0x0) +__ulonglong 0xfff6 >= 0x4 == 0x1 (0x1) +float 0xfff6 >= 0x4 == 0x0 (0x0) +int 0xfff6 / 0x4 == -0x2 (0xfffe) +__uint 0xfff6 / 0x4 == 0x3ffd (0x3ffd) +char 0xfff6 / 0x4 == -0x2 (0xfffe) +__uchar 0xf6 / 0x4 == 0x3d (0x3d) +__longlong 0xfff6 / 0x4 == -0x2 (0xfffe) +__ulonglong 0xfff6 / 0x4 == -0x3 (0xfffd) +float 0xfff6 / 0x4 == -0x2 (0xfffe) +int 0xfff6 % 0x4 == -0x2 (0xfffe) +__uint 0xfff6 % 0x4 == 0x2 (0x2) +char 0xfff6 % 0x4 == -0x2 (0xfffe) +__uchar 0xf6 % 0x4 == 0x2 (0x2) +__longlong 0xfff6 % 0x4 == -0x2 (0xfffe) +__ulonglong 0xfff6 % 0x4 == 0x2 (0x2) +0xfff6 * 0xfffc == 0x28 +0xfff6 / 0xfffc == 0x2 +0xfff6 % 0xfffc == -0x2 +int 0xfff6 ^ 0xfffc == 0xa (0xa) +__uint 0xfff6 ^ 0xfffc == 0xa (0xa) +char 0xfff6 ^ 0xfffc == 0xa (0xa) +__uchar 0xf6 ^ 0xfc == 0xa (0xa) +__longlong 0xfff6 ^ 0xfffc == 0xa (0xa) +__ulonglong 0xfff6 ^ 0xfffc == 0xa (0xa) +int 0xfff6 && 0xfffc == 0x1 (0x1) +__uint 0xfff6 && 0xfffc == 0x1 (0x1) +char 0xfff6 && 0xfffc == 0x1 (0x1) +__uchar 0xf6 && 0xfc == 0x1 (0x1) +__longlong 0xfff6 && 0xfffc == 0x1 (0x1) +__ulonglong 0xfff6 && 0xfffc == 0x1 (0x1) +int 0xfff6 || 0xfffc == 0x1 (0x1) +__uint 0xfff6 || 0xfffc == 0x1 (0x1) +char 0xfff6 || 0xfffc == 0x1 (0x1) +__uchar 0xf6 || 0xfc == 0x1 (0x1) +__longlong 0xfff6 || 0xfffc == 0x1 (0x1) +__ulonglong 0xfff6 || 0xfffc == 0x1 (0x1) +int 0xfff6 & 0xfffc == -0xc (0xfff4) +__uint 0xfff6 & 0xfffc == -0xc (0xfff4) +char 0xfff6 & 0xfffc == -0xc (0xfff4) +__uchar 0xf6 & 0xfc == 0xf4 (0xf4) +__longlong 0xfff6 & 0xfffc == -0xc (0xfff4) +__ulonglong 0xfff6 & 0xfffc == -0xc (0xfff4) +int 0xfff6 | 0xfffc == -0x2 (0xfffe) +__uint 0xfff6 | 0xfffc == -0x2 (0xfffe) +char 0xfff6 | 0xfffc == -0x2 (0xfffe) +__uchar 0xf6 | 0xfc == 0xfe (0xfe) +__longlong 0xfff6 | 0xfffc == -0x2 (0xfffe) +__ulonglong 0xfff6 | 0xfffc == -0x2 (0xfffe) +int 0xfff6 << 0x6 == -0x280 (0xfd80) +__uint 0xfff6 << 0x6 == -0x280 (0xfd80) +char 0xfff6 << 0x6 == -0x80 (0xff80) +__uchar 0xf6 << 0x6 == 0x80 (0x80) +__longlong 0xfff6 << 0x6 == -0x280 (0xfd80) +__ulonglong 0xfff6 << 0x6 == -0x280 (0xfd80) +int 0xfff6 >> 0x6 == -0x1 (0xffff) +__uint 0xfff6 >> 0x6 == 0x3ff (0x3ff) +char 0xfff6 >> 0x6 == -0x1 (0xffff) +__uchar 0xf6 >> 0x6 == 0x3 (0x3) +__longlong 0xfff6 >> 0x6 == -0x1 (0xffff) +__ulonglong 0xfff6 >> 0x6 == -0x1 (0xffff) +int 0xfff6 + 0xfffc == -0xe (0xfff2) +__uint 0xfff6 + 0xfffc == -0xe (0xfff2) +char 0xfff6 + 0xfffc == -0xe (0xfff2) +__uchar 0xf6 + 0xfc == 0xf2 (0xf2) +__longlong 0xfff6 + 0xfffc == -0xe (0xfff2) +__ulonglong 0xfff6 + 0xfffc == -0xe (0xfff2) +float 0xfff6 + 0xfffc == -0xe (0xfff2) +int 0xfff6 - 0xfffc == -0x6 (0xfffa) +__uint 0xfff6 - 0xfffc == -0x6 (0xfffa) +char 0xfff6 - 0xfffc == -0x6 (0xfffa) +__uchar 0xf6 - 0xfc == 0xfa (0xfa) +__longlong 0xfff6 - 0xfffc == -0x6 (0xfffa) +__ulonglong 0xfff6 - 0xfffc == -0x6 (0xfffa) +float 0xfff6 - 0xfffc == -0x6 (0xfffa) +int 0xfff6 * 0xfffc == 0x28 (0x28) +__uint 0xfff6 * 0xfffc == 0x28 (0x28) +char 0xfff6 * 0xfffc == 0x28 (0x28) +__uchar 0xf6 * 0xfc == 0x28 (0x28) +__longlong 0xfff6 * 0xfffc == 0x28 (0x28) +__ulonglong 0xfff6 * 0xfffc == 0x28 (0x28) +float 0xfff6 * 0xfffc == 0x28 (0x28) +int 0xfff6 < 0xfffc == 0x1 (0x1) +__uint 0xfff6 < 0xfffc == 0x1 (0x1) +char 0xfff6 < 0xfffc == 0x1 (0x1) +__uchar 0xf6 < 0xfc == 0x1 (0x1) +__longlong 0xfff6 < 0xfffc == 0x1 (0x1) +__ulonglong 0xfff6 < 0xfffc == 0x1 (0x1) +float 0xfff6 < 0xfffc == 0x1 (0x1) +int 0xfff6 > 0xfffc == 0x0 (0x0) +__uint 0xfff6 > 0xfffc == 0x0 (0x0) +char 0xfff6 > 0xfffc == 0x0 (0x0) +__uchar 0xf6 > 0xfc == 0x0 (0x0) +__longlong 0xfff6 > 0xfffc == 0x0 (0x0) +__ulonglong 0xfff6 > 0xfffc == 0x0 (0x0) +float 0xfff6 > 0xfffc == 0x0 (0x0) +int 0xfff6 <= 0xfffc == 0x1 (0x1) +__uint 0xfff6 <= 0xfffc == 0x1 (0x1) +char 0xfff6 <= 0xfffc == 0x1 (0x1) +__uchar 0xf6 <= 0xfc == 0x1 (0x1) +__longlong 0xfff6 <= 0xfffc == 0x1 (0x1) +__ulonglong 0xfff6 <= 0xfffc == 0x1 (0x1) +float 0xfff6 <= 0xfffc == 0x1 (0x1) +int 0xfff6 == 0xfffc == 0x0 (0x0) +__uint 0xfff6 == 0xfffc == 0x0 (0x0) +char 0xfff6 == 0xfffc == 0x0 (0x0) +__uchar 0xf6 == 0xfc == 0x0 (0x0) +__longlong 0xfff6 == 0xfffc == 0x0 (0x0) +__ulonglong 0xfff6 == 0xfffc == 0x0 (0x0) +float 0xfff6 == 0xfffc == 0x0 (0x0) +int 0xfff6 != 0xfffc == 0x1 (0x1) +__uint 0xfff6 != 0xfffc == 0x1 (0x1) +char 0xfff6 != 0xfffc == 0x1 (0x1) +__uchar 0xf6 != 0xfc == 0x1 (0x1) +__longlong 0xfff6 != 0xfffc == 0x1 (0x1) +__ulonglong 0xfff6 != 0xfffc == 0x1 (0x1) +float 0xfff6 != 0xfffc == 0x1 (0x1) +int 0xfff6 >= 0xfffc == 0x0 (0x0) +__uint 0xfff6 >= 0xfffc == 0x0 (0x0) +char 0xfff6 >= 0xfffc == 0x0 (0x0) +__uchar 0xf6 >= 0xfc == 0x0 (0x0) +__longlong 0xfff6 >= 0xfffc == 0x0 (0x0) +__ulonglong 0xfff6 >= 0xfffc == 0x0 (0x0) +float 0xfff6 >= 0xfffc == 0x0 (0x0) +int 0xfff6 / 0xfffc == 0x2 (0x2) +__uint 0xfff6 / 0xfffc == 0x0 (0x0) +char 0xfff6 / 0xfffc == 0x2 (0x2) +__uchar 0xf6 / 0xfc == 0x0 (0x0) +__longlong 0xfff6 / 0xfffc == 0x2 (0x2) +__ulonglong 0xfff6 / 0xfffc == 0x0 (0x0) +float 0xfff6 / 0xfffc == 0x2 (0x2) +int 0xfff6 % 0xfffc == -0x2 (0xfffe) +__uint 0xfff6 % 0xfffc == -0xa (0xfff6) +char 0xfff6 % 0xfffc == -0x2 (0xfffe) +__uchar 0xf6 % 0xfc == 0xf6 (0xf6) +__longlong 0xfff6 % 0xfffc == -0x2 (0xfffe) +__ulonglong 0xfff6 % 0xfffc == -0xa (0xfff6) +0xfff6 * 0xa == -0x64 +0xfff6 / 0xa == -0x1 +0xfff6 % 0xa == 0x0 +int 0xfff6 ^ 0xa == -0x4 (0xfffc) +__uint 0xfff6 ^ 0xa == -0x4 (0xfffc) +char 0xfff6 ^ 0xa == -0x4 (0xfffc) +__uchar 0xf6 ^ 0xa == 0xfc (0xfc) +__longlong 0xfff6 ^ 0xa == -0x4 (0xfffc) +__ulonglong 0xfff6 ^ 0xa == -0x4 (0xfffc) +int 0xfff6 && 0xa == 0x1 (0x1) +__uint 0xfff6 && 0xa == 0x1 (0x1) +char 0xfff6 && 0xa == 0x1 (0x1) +__uchar 0xf6 && 0xa == 0x1 (0x1) +__longlong 0xfff6 && 0xa == 0x1 (0x1) +__ulonglong 0xfff6 && 0xa == 0x1 (0x1) +int 0xfff6 || 0xa == 0x1 (0x1) +__uint 0xfff6 || 0xa == 0x1 (0x1) +char 0xfff6 || 0xa == 0x1 (0x1) +__uchar 0xf6 || 0xa == 0x1 (0x1) +__longlong 0xfff6 || 0xa == 0x1 (0x1) +__ulonglong 0xfff6 || 0xa == 0x1 (0x1) +int 0xfff6 & 0xa == 0x2 (0x2) +__uint 0xfff6 & 0xa == 0x2 (0x2) +char 0xfff6 & 0xa == 0x2 (0x2) +__uchar 0xf6 & 0xa == 0x2 (0x2) +__longlong 0xfff6 & 0xa == 0x2 (0x2) +__ulonglong 0xfff6 & 0xa == 0x2 (0x2) +int 0xfff6 | 0xa == -0x2 (0xfffe) +__uint 0xfff6 | 0xa == -0x2 (0xfffe) +char 0xfff6 | 0xa == -0x2 (0xfffe) +__uchar 0xf6 | 0xa == 0xfe (0xfe) +__longlong 0xfff6 | 0xa == -0x2 (0xfffe) +__ulonglong 0xfff6 | 0xa == -0x2 (0xfffe) +int 0xfff6 << 0x7 == -0x500 (0xfb00) +__uint 0xfff6 << 0x7 == -0x500 (0xfb00) +char 0xfff6 << 0x7 == 0x0 (0x0) +__uchar 0xf6 << 0x7 == 0x0 (0x0) +__longlong 0xfff6 << 0x7 == -0x500 (0xfb00) +__ulonglong 0xfff6 << 0x7 == -0x500 (0xfb00) +int 0xfff6 >> 0x7 == -0x1 (0xffff) +__uint 0xfff6 >> 0x7 == 0x1ff (0x1ff) +char 0xfff6 >> 0x7 == -0x1 (0xffff) +__uchar 0xf6 >> 0x7 == 0x1 (0x1) +__longlong 0xfff6 >> 0x7 == -0x1 (0xffff) +__ulonglong 0xfff6 >> 0x7 == -0x1 (0xffff) +int 0xfff6 + 0xa == 0x0 (0x0) +__uint 0xfff6 + 0xa == 0x0 (0x0) +char 0xfff6 + 0xa == 0x0 (0x0) +__uchar 0xf6 + 0xa == 0x0 (0x0) +__longlong 0xfff6 + 0xa == 0x0 (0x0) +__ulonglong 0xfff6 + 0xa == 0x0 (0x0) +float 0xfff6 + 0xa == 0x0 (0x0) +int 0xfff6 - 0xa == -0x14 (0xffec) +__uint 0xfff6 - 0xa == -0x14 (0xffec) +char 0xfff6 - 0xa == -0x14 (0xffec) +__uchar 0xf6 - 0xa == 0xec (0xec) +__longlong 0xfff6 - 0xa == -0x14 (0xffec) +__ulonglong 0xfff6 - 0xa == -0x14 (0xffec) +float 0xfff6 - 0xa == -0x14 (0xffec) +int 0xfff6 * 0xa == -0x64 (0xff9c) +__uint 0xfff6 * 0xa == -0x64 (0xff9c) +char 0xfff6 * 0xa == -0x64 (0xff9c) +__uchar 0xf6 * 0xa == 0x9c (0x9c) +__longlong 0xfff6 * 0xa == -0x64 (0xff9c) +__ulonglong 0xfff6 * 0xa == -0x64 (0xff9c) +float 0xfff6 * 0xa == -0x64 (0xff9c) +int 0xfff6 < 0xa == 0x1 (0x1) +__uint 0xfff6 < 0xa == 0x0 (0x0) +char 0xfff6 < 0xa == 0x1 (0x1) +__uchar 0xf6 < 0xa == 0x0 (0x0) +__longlong 0xfff6 < 0xa == 0x1 (0x1) +__ulonglong 0xfff6 < 0xa == 0x0 (0x0) +float 0xfff6 < 0xa == 0x1 (0x1) +int 0xfff6 > 0xa == 0x0 (0x0) +__uint 0xfff6 > 0xa == 0x1 (0x1) +char 0xfff6 > 0xa == 0x0 (0x0) +__uchar 0xf6 > 0xa == 0x1 (0x1) +__longlong 0xfff6 > 0xa == 0x0 (0x0) +__ulonglong 0xfff6 > 0xa == 0x1 (0x1) +float 0xfff6 > 0xa == 0x0 (0x0) +int 0xfff6 <= 0xa == 0x1 (0x1) +__uint 0xfff6 <= 0xa == 0x0 (0x0) +char 0xfff6 <= 0xa == 0x1 (0x1) +__uchar 0xf6 <= 0xa == 0x0 (0x0) +__longlong 0xfff6 <= 0xa == 0x1 (0x1) +__ulonglong 0xfff6 <= 0xa == 0x0 (0x0) +float 0xfff6 <= 0xa == 0x1 (0x1) +int 0xfff6 == 0xa == 0x0 (0x0) +__uint 0xfff6 == 0xa == 0x0 (0x0) +char 0xfff6 == 0xa == 0x0 (0x0) +__uchar 0xf6 == 0xa == 0x0 (0x0) +__longlong 0xfff6 == 0xa == 0x0 (0x0) +__ulonglong 0xfff6 == 0xa == 0x0 (0x0) +float 0xfff6 == 0xa == 0x0 (0x0) +int 0xfff6 != 0xa == 0x1 (0x1) +__uint 0xfff6 != 0xa == 0x1 (0x1) +char 0xfff6 != 0xa == 0x1 (0x1) +__uchar 0xf6 != 0xa == 0x1 (0x1) +__longlong 0xfff6 != 0xa == 0x1 (0x1) +__ulonglong 0xfff6 != 0xa == 0x1 (0x1) +float 0xfff6 != 0xa == 0x1 (0x1) +int 0xfff6 >= 0xa == 0x0 (0x0) +__uint 0xfff6 >= 0xa == 0x1 (0x1) +char 0xfff6 >= 0xa == 0x0 (0x0) +__uchar 0xf6 >= 0xa == 0x1 (0x1) +__longlong 0xfff6 >= 0xa == 0x0 (0x0) +__ulonglong 0xfff6 >= 0xa == 0x1 (0x1) +float 0xfff6 >= 0xa == 0x0 (0x0) +int 0xfff6 / 0xa == -0x1 (0xffff) +__uint 0xfff6 / 0xa == 0x1998 (0x1998) +char 0xfff6 / 0xa == -0x1 (0xffff) +__uchar 0xf6 / 0xa == 0x18 (0x18) +__longlong 0xfff6 / 0xa == -0x1 (0xffff) +__ulonglong 0xfff6 / 0xa == -0x6668 (0x9998) +float 0xfff6 / 0xa == -0x1 (0xffff) +int 0xfff6 % 0xa == 0x0 (0x0) +__uint 0xfff6 % 0xa == 0x6 (0x6) +char 0xfff6 % 0xa == 0x0 (0x0) +__uchar 0xf6 % 0xa == 0x6 (0x6) +__longlong 0xfff6 % 0xa == 0x0 (0x0) +__ulonglong 0xfff6 % 0xa == 0x6 (0x6) +0xfff6 * 0xfff6 == 0x64 +0xfff6 / 0xfff6 == 0x1 +0xfff6 % 0xfff6 == 0x0 +int 0xfff6 ^ 0xfff6 == 0x0 (0x0) +__uint 0xfff6 ^ 0xfff6 == 0x0 (0x0) +char 0xfff6 ^ 0xfff6 == 0x0 (0x0) +__uchar 0xf6 ^ 0xf6 == 0x0 (0x0) +__longlong 0xfff6 ^ 0xfff6 == 0x0 (0x0) +__ulonglong 0xfff6 ^ 0xfff6 == 0x0 (0x0) +int 0xfff6 && 0xfff6 == 0x1 (0x1) +__uint 0xfff6 && 0xfff6 == 0x1 (0x1) +char 0xfff6 && 0xfff6 == 0x1 (0x1) +__uchar 0xf6 && 0xf6 == 0x1 (0x1) +__longlong 0xfff6 && 0xfff6 == 0x1 (0x1) +__ulonglong 0xfff6 && 0xfff6 == 0x1 (0x1) +int 0xfff6 || 0xfff6 == 0x1 (0x1) +__uint 0xfff6 || 0xfff6 == 0x1 (0x1) +char 0xfff6 || 0xfff6 == 0x1 (0x1) +__uchar 0xf6 || 0xf6 == 0x1 (0x1) +__longlong 0xfff6 || 0xfff6 == 0x1 (0x1) +__ulonglong 0xfff6 || 0xfff6 == 0x1 (0x1) +int 0xfff6 & 0xfff6 == -0xa (0xfff6) +__uint 0xfff6 & 0xfff6 == -0xa (0xfff6) +char 0xfff6 & 0xfff6 == -0xa (0xfff6) +__uchar 0xf6 & 0xf6 == 0xf6 (0xf6) +__longlong 0xfff6 & 0xfff6 == -0xa (0xfff6) +__ulonglong 0xfff6 & 0xfff6 == -0xa (0xfff6) +int 0xfff6 | 0xfff6 == -0xa (0xfff6) +__uint 0xfff6 | 0xfff6 == -0xa (0xfff6) +char 0xfff6 | 0xfff6 == -0xa (0xfff6) +__uchar 0xf6 | 0xf6 == 0xf6 (0xf6) +__longlong 0xfff6 | 0xfff6 == -0xa (0xfff6) +__ulonglong 0xfff6 | 0xfff6 == -0xa (0xfff6) +int 0xfff6 << 0x8 == -0xa00 (0xf600) +__uint 0xfff6 << 0x8 == -0xa00 (0xf600) +char 0xfff6 << 0x8 == 0x0 (0x0) +__uchar 0xf6 << 0x8 == 0x0 (0x0) +__longlong 0xfff6 << 0x8 == -0xa00 (0xf600) +__ulonglong 0xfff6 << 0x8 == -0xa00 (0xf600) +int 0xfff6 >> 0x8 == -0x1 (0xffff) +__uint 0xfff6 >> 0x8 == 0xff (0xff) +char 0xfff6 >> 0x8 == -0x1 (0xffff) +__uchar 0xf6 >> 0x8 == 0x0 (0x0) +__longlong 0xfff6 >> 0x8 == -0x1 (0xffff) +__ulonglong 0xfff6 >> 0x8 == -0x1 (0xffff) +int 0xfff6 + 0xfff6 == -0x14 (0xffec) +__uint 0xfff6 + 0xfff6 == -0x14 (0xffec) +char 0xfff6 + 0xfff6 == -0x14 (0xffec) +__uchar 0xf6 + 0xf6 == 0xec (0xec) +__longlong 0xfff6 + 0xfff6 == -0x14 (0xffec) +__ulonglong 0xfff6 + 0xfff6 == -0x14 (0xffec) +float 0xfff6 + 0xfff6 == -0x14 (0xffec) +int 0xfff6 - 0xfff6 == 0x0 (0x0) +__uint 0xfff6 - 0xfff6 == 0x0 (0x0) +char 0xfff6 - 0xfff6 == 0x0 (0x0) +__uchar 0xf6 - 0xf6 == 0x0 (0x0) +__longlong 0xfff6 - 0xfff6 == 0x0 (0x0) +__ulonglong 0xfff6 - 0xfff6 == 0x0 (0x0) +float 0xfff6 - 0xfff6 == 0x0 (0x0) +int 0xfff6 * 0xfff6 == 0x64 (0x64) +__uint 0xfff6 * 0xfff6 == 0x64 (0x64) +char 0xfff6 * 0xfff6 == 0x64 (0x64) +__uchar 0xf6 * 0xf6 == 0x64 (0x64) +__longlong 0xfff6 * 0xfff6 == 0x64 (0x64) +__ulonglong 0xfff6 * 0xfff6 == 0x64 (0x64) +float 0xfff6 * 0xfff6 == 0x64 (0x64) +int 0xfff6 < 0xfff6 == 0x0 (0x0) +__uint 0xfff6 < 0xfff6 == 0x0 (0x0) +char 0xfff6 < 0xfff6 == 0x0 (0x0) +__uchar 0xf6 < 0xf6 == 0x0 (0x0) +__longlong 0xfff6 < 0xfff6 == 0x0 (0x0) +__ulonglong 0xfff6 < 0xfff6 == 0x0 (0x0) +float 0xfff6 < 0xfff6 == 0x0 (0x0) +int 0xfff6 > 0xfff6 == 0x0 (0x0) +__uint 0xfff6 > 0xfff6 == 0x0 (0x0) +char 0xfff6 > 0xfff6 == 0x0 (0x0) +__uchar 0xf6 > 0xf6 == 0x0 (0x0) +__longlong 0xfff6 > 0xfff6 == 0x0 (0x0) +__ulonglong 0xfff6 > 0xfff6 == 0x0 (0x0) +float 0xfff6 > 0xfff6 == 0x0 (0x0) +int 0xfff6 <= 0xfff6 == 0x1 (0x1) +__uint 0xfff6 <= 0xfff6 == 0x1 (0x1) +char 0xfff6 <= 0xfff6 == 0x1 (0x1) +__uchar 0xf6 <= 0xf6 == 0x1 (0x1) +__longlong 0xfff6 <= 0xfff6 == 0x1 (0x1) +__ulonglong 0xfff6 <= 0xfff6 == 0x1 (0x1) +float 0xfff6 <= 0xfff6 == 0x1 (0x1) +int 0xfff6 == 0xfff6 == 0x1 (0x1) +__uint 0xfff6 == 0xfff6 == 0x1 (0x1) +char 0xfff6 == 0xfff6 == 0x1 (0x1) +__uchar 0xf6 == 0xf6 == 0x1 (0x1) +__longlong 0xfff6 == 0xfff6 == 0x1 (0x1) +__ulonglong 0xfff6 == 0xfff6 == 0x1 (0x1) +float 0xfff6 == 0xfff6 == 0x1 (0x1) +int 0xfff6 != 0xfff6 == 0x0 (0x0) +__uint 0xfff6 != 0xfff6 == 0x0 (0x0) +char 0xfff6 != 0xfff6 == 0x0 (0x0) +__uchar 0xf6 != 0xf6 == 0x0 (0x0) +__longlong 0xfff6 != 0xfff6 == 0x0 (0x0) +__ulonglong 0xfff6 != 0xfff6 == 0x0 (0x0) +float 0xfff6 != 0xfff6 == 0x0 (0x0) +int 0xfff6 >= 0xfff6 == 0x1 (0x1) +__uint 0xfff6 >= 0xfff6 == 0x1 (0x1) +char 0xfff6 >= 0xfff6 == 0x1 (0x1) +__uchar 0xf6 >= 0xf6 == 0x1 (0x1) +__longlong 0xfff6 >= 0xfff6 == 0x1 (0x1) +__ulonglong 0xfff6 >= 0xfff6 == 0x1 (0x1) +float 0xfff6 >= 0xfff6 == 0x1 (0x1) +int 0xfff6 / 0xfff6 == 0x1 (0x1) +__uint 0xfff6 / 0xfff6 == 0x1 (0x1) +char 0xfff6 / 0xfff6 == 0x1 (0x1) +__uchar 0xf6 / 0xf6 == 0x1 (0x1) +__longlong 0xfff6 / 0xfff6 == 0x1 (0x1) +__ulonglong 0xfff6 / 0xfff6 == 0x1 (0x1) +float 0xfff6 / 0xfff6 == 0x1 (0x1) +int 0xfff6 % 0xfff6 == 0x0 (0x0) +__uint 0xfff6 % 0xfff6 == 0x0 (0x0) +char 0xfff6 % 0xfff6 == 0x0 (0x0) +__uchar 0xf6 % 0xf6 == 0x0 (0x0) +__longlong 0xfff6 % 0xfff6 == 0x0 (0x0) +__ulonglong 0xfff6 % 0xfff6 == 0x0 (0x0) +0xfff6 * 0x5 == -0x32 +0xfff6 / 0x5 == -0x2 +0xfff6 % 0x5 == 0x0 +int 0xfff6 ^ 0x5 == -0xd (0xfff3) +__uint 0xfff6 ^ 0x5 == -0xd (0xfff3) +char 0xfff6 ^ 0x5 == -0xd (0xfff3) +__uchar 0xf6 ^ 0x5 == 0xf3 (0xf3) +__longlong 0xfff6 ^ 0x5 == -0xd (0xfff3) +__ulonglong 0xfff6 ^ 0x5 == -0xd (0xfff3) +int 0xfff6 && 0x5 == 0x1 (0x1) +__uint 0xfff6 && 0x5 == 0x1 (0x1) +char 0xfff6 && 0x5 == 0x1 (0x1) +__uchar 0xf6 && 0x5 == 0x1 (0x1) +__longlong 0xfff6 && 0x5 == 0x1 (0x1) +__ulonglong 0xfff6 && 0x5 == 0x1 (0x1) +int 0xfff6 || 0x5 == 0x1 (0x1) +__uint 0xfff6 || 0x5 == 0x1 (0x1) +char 0xfff6 || 0x5 == 0x1 (0x1) +__uchar 0xf6 || 0x5 == 0x1 (0x1) +__longlong 0xfff6 || 0x5 == 0x1 (0x1) +__ulonglong 0xfff6 || 0x5 == 0x1 (0x1) +int 0xfff6 & 0x5 == 0x4 (0x4) +__uint 0xfff6 & 0x5 == 0x4 (0x4) +char 0xfff6 & 0x5 == 0x4 (0x4) +__uchar 0xf6 & 0x5 == 0x4 (0x4) +__longlong 0xfff6 & 0x5 == 0x4 (0x4) +__ulonglong 0xfff6 & 0x5 == 0x4 (0x4) +int 0xfff6 | 0x5 == -0x9 (0xfff7) +__uint 0xfff6 | 0x5 == -0x9 (0xfff7) +char 0xfff6 | 0x5 == -0x9 (0xfff7) +__uchar 0xf6 | 0x5 == 0xf7 (0xf7) +__longlong 0xfff6 | 0x5 == -0x9 (0xfff7) +__ulonglong 0xfff6 | 0x5 == -0x9 (0xfff7) +int 0xfff6 << 0x9 == -0x1400 (0xec00) +__uint 0xfff6 << 0x9 == -0x1400 (0xec00) +char 0xfff6 << 0x9 == 0x0 (0x0) +__uchar 0xf6 << 0x9 == 0x0 (0x0) +__longlong 0xfff6 << 0x9 == -0x1400 (0xec00) +__ulonglong 0xfff6 << 0x9 == -0x1400 (0xec00) +int 0xfff6 >> 0x9 == -0x1 (0xffff) +__uint 0xfff6 >> 0x9 == 0x7f (0x7f) +char 0xfff6 >> 0x9 == -0x1 (0xffff) +__uchar 0xf6 >> 0x9 == 0x0 (0x0) +__longlong 0xfff6 >> 0x9 == -0x1 (0xffff) +__ulonglong 0xfff6 >> 0x9 == -0x1 (0xffff) +int 0xfff6 + 0x5 == -0x5 (0xfffb) +__uint 0xfff6 + 0x5 == -0x5 (0xfffb) +char 0xfff6 + 0x5 == -0x5 (0xfffb) +__uchar 0xf6 + 0x5 == 0xfb (0xfb) +__longlong 0xfff6 + 0x5 == -0x5 (0xfffb) +__ulonglong 0xfff6 + 0x5 == -0x5 (0xfffb) +float 0xfff6 + 0x5 == -0x5 (0xfffb) +int 0xfff6 - 0x5 == -0xf (0xfff1) +__uint 0xfff6 - 0x5 == -0xf (0xfff1) +char 0xfff6 - 0x5 == -0xf (0xfff1) +__uchar 0xf6 - 0x5 == 0xf1 (0xf1) +__longlong 0xfff6 - 0x5 == -0xf (0xfff1) +__ulonglong 0xfff6 - 0x5 == -0xf (0xfff1) +float 0xfff6 - 0x5 == -0xf (0xfff1) +int 0xfff6 * 0x5 == -0x32 (0xffce) +__uint 0xfff6 * 0x5 == -0x32 (0xffce) +char 0xfff6 * 0x5 == -0x32 (0xffce) +__uchar 0xf6 * 0x5 == 0xce (0xce) +__longlong 0xfff6 * 0x5 == -0x32 (0xffce) +__ulonglong 0xfff6 * 0x5 == -0x32 (0xffce) +float 0xfff6 * 0x5 == -0x32 (0xffce) +int 0xfff6 < 0x5 == 0x1 (0x1) +__uint 0xfff6 < 0x5 == 0x0 (0x0) +char 0xfff6 < 0x5 == 0x1 (0x1) +__uchar 0xf6 < 0x5 == 0x0 (0x0) +__longlong 0xfff6 < 0x5 == 0x1 (0x1) +__ulonglong 0xfff6 < 0x5 == 0x0 (0x0) +float 0xfff6 < 0x5 == 0x1 (0x1) +int 0xfff6 > 0x5 == 0x0 (0x0) +__uint 0xfff6 > 0x5 == 0x1 (0x1) +char 0xfff6 > 0x5 == 0x0 (0x0) +__uchar 0xf6 > 0x5 == 0x1 (0x1) +__longlong 0xfff6 > 0x5 == 0x0 (0x0) +__ulonglong 0xfff6 > 0x5 == 0x1 (0x1) +float 0xfff6 > 0x5 == 0x0 (0x0) +int 0xfff6 <= 0x5 == 0x1 (0x1) +__uint 0xfff6 <= 0x5 == 0x0 (0x0) +char 0xfff6 <= 0x5 == 0x1 (0x1) +__uchar 0xf6 <= 0x5 == 0x0 (0x0) +__longlong 0xfff6 <= 0x5 == 0x1 (0x1) +__ulonglong 0xfff6 <= 0x5 == 0x0 (0x0) +float 0xfff6 <= 0x5 == 0x1 (0x1) +int 0xfff6 == 0x5 == 0x0 (0x0) +__uint 0xfff6 == 0x5 == 0x0 (0x0) +char 0xfff6 == 0x5 == 0x0 (0x0) +__uchar 0xf6 == 0x5 == 0x0 (0x0) +__longlong 0xfff6 == 0x5 == 0x0 (0x0) +__ulonglong 0xfff6 == 0x5 == 0x0 (0x0) +float 0xfff6 == 0x5 == 0x0 (0x0) +int 0xfff6 != 0x5 == 0x1 (0x1) +__uint 0xfff6 != 0x5 == 0x1 (0x1) +char 0xfff6 != 0x5 == 0x1 (0x1) +__uchar 0xf6 != 0x5 == 0x1 (0x1) +__longlong 0xfff6 != 0x5 == 0x1 (0x1) +__ulonglong 0xfff6 != 0x5 == 0x1 (0x1) +float 0xfff6 != 0x5 == 0x1 (0x1) +int 0xfff6 >= 0x5 == 0x0 (0x0) +__uint 0xfff6 >= 0x5 == 0x1 (0x1) +char 0xfff6 >= 0x5 == 0x0 (0x0) +__uchar 0xf6 >= 0x5 == 0x1 (0x1) +__longlong 0xfff6 >= 0x5 == 0x0 (0x0) +__ulonglong 0xfff6 >= 0x5 == 0x1 (0x1) +float 0xfff6 >= 0x5 == 0x0 (0x0) +int 0xfff6 / 0x5 == -0x2 (0xfffe) +__uint 0xfff6 / 0x5 == 0x3331 (0x3331) +char 0xfff6 / 0x5 == -0x2 (0xfffe) +__uchar 0xf6 / 0x5 == 0x31 (0x31) +__longlong 0xfff6 / 0x5 == -0x2 (0xfffe) +__ulonglong 0xfff6 / 0x5 == 0x3331 (0x3331) +float 0xfff6 / 0x5 == -0x2 (0xfffe) +int 0xfff6 % 0x5 == 0x0 (0x0) +__uint 0xfff6 % 0x5 == 0x1 (0x1) +char 0xfff6 % 0x5 == 0x0 (0x0) +__uchar 0xf6 % 0x5 == 0x1 (0x1) +__longlong 0xfff6 % 0x5 == 0x0 (0x0) +__ulonglong 0xfff6 % 0x5 == 0x1 (0x1) +0xfff6 * 0x7 == -0x46 +0xfff6 / 0x7 == -0x1 +0xfff6 % 0x7 == -0x3 +int 0xfff6 ^ 0x7 == -0xf (0xfff1) +__uint 0xfff6 ^ 0x7 == -0xf (0xfff1) +char 0xfff6 ^ 0x7 == -0xf (0xfff1) +__uchar 0xf6 ^ 0x7 == 0xf1 (0xf1) +__longlong 0xfff6 ^ 0x7 == -0xf (0xfff1) +__ulonglong 0xfff6 ^ 0x7 == -0xf (0xfff1) +int 0xfff6 && 0x7 == 0x1 (0x1) +__uint 0xfff6 && 0x7 == 0x1 (0x1) +char 0xfff6 && 0x7 == 0x1 (0x1) +__uchar 0xf6 && 0x7 == 0x1 (0x1) +__longlong 0xfff6 && 0x7 == 0x1 (0x1) +__ulonglong 0xfff6 && 0x7 == 0x1 (0x1) +int 0xfff6 || 0x7 == 0x1 (0x1) +__uint 0xfff6 || 0x7 == 0x1 (0x1) +char 0xfff6 || 0x7 == 0x1 (0x1) +__uchar 0xf6 || 0x7 == 0x1 (0x1) +__longlong 0xfff6 || 0x7 == 0x1 (0x1) +__ulonglong 0xfff6 || 0x7 == 0x1 (0x1) +int 0xfff6 & 0x7 == 0x6 (0x6) +__uint 0xfff6 & 0x7 == 0x6 (0x6) +char 0xfff6 & 0x7 == 0x6 (0x6) +__uchar 0xf6 & 0x7 == 0x6 (0x6) +__longlong 0xfff6 & 0x7 == 0x6 (0x6) +__ulonglong 0xfff6 & 0x7 == 0x6 (0x6) +int 0xfff6 | 0x7 == -0x9 (0xfff7) +__uint 0xfff6 | 0x7 == -0x9 (0xfff7) +char 0xfff6 | 0x7 == -0x9 (0xfff7) +__uchar 0xf6 | 0x7 == 0xf7 (0xf7) +__longlong 0xfff6 | 0x7 == -0x9 (0xfff7) +__ulonglong 0xfff6 | 0x7 == -0x9 (0xfff7) +int 0xfff6 << 0xa == -0x2800 (0xd800) +__uint 0xfff6 << 0xa == -0x2800 (0xd800) +char 0xfff6 << 0xa == 0x0 (0x0) +__uchar 0xf6 << 0xa == 0x0 (0x0) +__longlong 0xfff6 << 0xa == -0x2800 (0xd800) +__ulonglong 0xfff6 << 0xa == -0x2800 (0xd800) +int 0xfff6 >> 0xa == -0x1 (0xffff) +__uint 0xfff6 >> 0xa == 0x3f (0x3f) +char 0xfff6 >> 0xa == -0x1 (0xffff) +__uchar 0xf6 >> 0xa == 0x0 (0x0) +__longlong 0xfff6 >> 0xa == -0x1 (0xffff) +__ulonglong 0xfff6 >> 0xa == -0x1 (0xffff) +int 0xfff6 + 0x7 == -0x3 (0xfffd) +__uint 0xfff6 + 0x7 == -0x3 (0xfffd) +char 0xfff6 + 0x7 == -0x3 (0xfffd) +__uchar 0xf6 + 0x7 == 0xfd (0xfd) +__longlong 0xfff6 + 0x7 == -0x3 (0xfffd) +__ulonglong 0xfff6 + 0x7 == -0x3 (0xfffd) +float 0xfff6 + 0x7 == -0x3 (0xfffd) +int 0xfff6 - 0x7 == -0x11 (0xffef) +__uint 0xfff6 - 0x7 == -0x11 (0xffef) +char 0xfff6 - 0x7 == -0x11 (0xffef) +__uchar 0xf6 - 0x7 == 0xef (0xef) +__longlong 0xfff6 - 0x7 == -0x11 (0xffef) +__ulonglong 0xfff6 - 0x7 == -0x11 (0xffef) +float 0xfff6 - 0x7 == -0x11 (0xffef) +int 0xfff6 * 0x7 == -0x46 (0xffba) +__uint 0xfff6 * 0x7 == -0x46 (0xffba) +char 0xfff6 * 0x7 == -0x46 (0xffba) +__uchar 0xf6 * 0x7 == 0xba (0xba) +__longlong 0xfff6 * 0x7 == -0x46 (0xffba) +__ulonglong 0xfff6 * 0x7 == -0x46 (0xffba) +float 0xfff6 * 0x7 == -0x46 (0xffba) +int 0xfff6 < 0x7 == 0x1 (0x1) +__uint 0xfff6 < 0x7 == 0x0 (0x0) +char 0xfff6 < 0x7 == 0x1 (0x1) +__uchar 0xf6 < 0x7 == 0x0 (0x0) +__longlong 0xfff6 < 0x7 == 0x1 (0x1) +__ulonglong 0xfff6 < 0x7 == 0x0 (0x0) +float 0xfff6 < 0x7 == 0x1 (0x1) +int 0xfff6 > 0x7 == 0x0 (0x0) +__uint 0xfff6 > 0x7 == 0x1 (0x1) +char 0xfff6 > 0x7 == 0x0 (0x0) +__uchar 0xf6 > 0x7 == 0x1 (0x1) +__longlong 0xfff6 > 0x7 == 0x0 (0x0) +__ulonglong 0xfff6 > 0x7 == 0x1 (0x1) +float 0xfff6 > 0x7 == 0x0 (0x0) +int 0xfff6 <= 0x7 == 0x1 (0x1) +__uint 0xfff6 <= 0x7 == 0x0 (0x0) +char 0xfff6 <= 0x7 == 0x1 (0x1) +__uchar 0xf6 <= 0x7 == 0x0 (0x0) +__longlong 0xfff6 <= 0x7 == 0x1 (0x1) +__ulonglong 0xfff6 <= 0x7 == 0x0 (0x0) +float 0xfff6 <= 0x7 == 0x1 (0x1) +int 0xfff6 == 0x7 == 0x0 (0x0) +__uint 0xfff6 == 0x7 == 0x0 (0x0) +char 0xfff6 == 0x7 == 0x0 (0x0) +__uchar 0xf6 == 0x7 == 0x0 (0x0) +__longlong 0xfff6 == 0x7 == 0x0 (0x0) +__ulonglong 0xfff6 == 0x7 == 0x0 (0x0) +float 0xfff6 == 0x7 == 0x0 (0x0) +int 0xfff6 != 0x7 == 0x1 (0x1) +__uint 0xfff6 != 0x7 == 0x1 (0x1) +char 0xfff6 != 0x7 == 0x1 (0x1) +__uchar 0xf6 != 0x7 == 0x1 (0x1) +__longlong 0xfff6 != 0x7 == 0x1 (0x1) +__ulonglong 0xfff6 != 0x7 == 0x1 (0x1) +float 0xfff6 != 0x7 == 0x1 (0x1) +int 0xfff6 >= 0x7 == 0x0 (0x0) +__uint 0xfff6 >= 0x7 == 0x1 (0x1) +char 0xfff6 >= 0x7 == 0x0 (0x0) +__uchar 0xf6 >= 0x7 == 0x1 (0x1) +__longlong 0xfff6 >= 0x7 == 0x0 (0x0) +__ulonglong 0xfff6 >= 0x7 == 0x1 (0x1) +float 0xfff6 >= 0x7 == 0x0 (0x0) +int 0xfff6 / 0x7 == -0x1 (0xffff) +__uint 0xfff6 / 0x7 == 0x2490 (0x2490) +char 0xfff6 / 0x7 == -0x1 (0xffff) +__uchar 0xf6 / 0x7 == 0x23 (0x23) +__longlong 0xfff6 / 0x7 == -0x1 (0xffff) +__ulonglong 0xfff6 / 0x7 == 0x4923 (0x4923) +float 0xfff6 / 0x7 == -0x1 (0xffff) +int 0xfff6 % 0x7 == -0x3 (0xfffd) +__uint 0xfff6 % 0x7 == 0x6 (0x6) +char 0xfff6 % 0x7 == -0x3 (0xfffd) +__uchar 0xf6 % 0x7 == 0x1 (0x1) +__longlong 0xfff6 % 0x7 == -0x3 (0xfffd) +__ulonglong 0xfff6 % 0x7 == 0x1 (0x1) +0xfff6 * 0x2a == -0x1a4 +0xfff6 / 0x2a == 0x0 +0xfff6 % 0x2a == -0xa +int 0xfff6 ^ 0x2a == -0x24 (0xffdc) +__uint 0xfff6 ^ 0x2a == -0x24 (0xffdc) +char 0xfff6 ^ 0x2a == -0x24 (0xffdc) +__uchar 0xf6 ^ 0x2a == 0xdc (0xdc) +__longlong 0xfff6 ^ 0x2a == -0x24 (0xffdc) +__ulonglong 0xfff6 ^ 0x2a == -0x24 (0xffdc) +int 0xfff6 && 0x2a == 0x1 (0x1) +__uint 0xfff6 && 0x2a == 0x1 (0x1) +char 0xfff6 && 0x2a == 0x1 (0x1) +__uchar 0xf6 && 0x2a == 0x1 (0x1) +__longlong 0xfff6 && 0x2a == 0x1 (0x1) +__ulonglong 0xfff6 && 0x2a == 0x1 (0x1) +int 0xfff6 || 0x2a == 0x1 (0x1) +__uint 0xfff6 || 0x2a == 0x1 (0x1) +char 0xfff6 || 0x2a == 0x1 (0x1) +__uchar 0xf6 || 0x2a == 0x1 (0x1) +__longlong 0xfff6 || 0x2a == 0x1 (0x1) +__ulonglong 0xfff6 || 0x2a == 0x1 (0x1) +int 0xfff6 & 0x2a == 0x22 (0x22) +__uint 0xfff6 & 0x2a == 0x22 (0x22) +char 0xfff6 & 0x2a == 0x22 (0x22) +__uchar 0xf6 & 0x2a == 0x22 (0x22) +__longlong 0xfff6 & 0x2a == 0x22 (0x22) +__ulonglong 0xfff6 & 0x2a == 0x22 (0x22) +int 0xfff6 | 0x2a == -0x2 (0xfffe) +__uint 0xfff6 | 0x2a == -0x2 (0xfffe) +char 0xfff6 | 0x2a == -0x2 (0xfffe) +__uchar 0xf6 | 0x2a == 0xfe (0xfe) +__longlong 0xfff6 | 0x2a == -0x2 (0xfffe) +__ulonglong 0xfff6 | 0x2a == -0x2 (0xfffe) +int 0xfff6 << 0xc == 0x6000 (0x6000) +__uint 0xfff6 << 0xc == 0x6000 (0x6000) +char 0xfff6 << 0xc == 0x0 (0x0) +__uchar 0xf6 << 0xc == 0x0 (0x0) +__longlong 0xfff6 << 0xc == 0x6000 (0x6000) +__ulonglong 0xfff6 << 0xc == 0x6000 (0x6000) +int 0xfff6 >> 0xc == -0x1 (0xffff) +__uint 0xfff6 >> 0xc == 0xf (0xf) +char 0xfff6 >> 0xc == -0x1 (0xffff) +__uchar 0xf6 >> 0xc == 0x0 (0x0) +__longlong 0xfff6 >> 0xc == -0x1 (0xffff) +__ulonglong 0xfff6 >> 0xc == -0x1 (0xffff) +int 0xfff6 + 0x2a == 0x20 (0x20) +__uint 0xfff6 + 0x2a == 0x20 (0x20) +char 0xfff6 + 0x2a == 0x20 (0x20) +__uchar 0xf6 + 0x2a == 0x20 (0x20) +__longlong 0xfff6 + 0x2a == 0x20 (0x20) +__ulonglong 0xfff6 + 0x2a == 0x20 (0x20) +float 0xfff6 + 0x2a == 0x20 (0x20) +int 0xfff6 - 0x2a == -0x34 (0xffcc) +__uint 0xfff6 - 0x2a == -0x34 (0xffcc) +char 0xfff6 - 0x2a == -0x34 (0xffcc) +__uchar 0xf6 - 0x2a == 0xcc (0xcc) +__longlong 0xfff6 - 0x2a == -0x34 (0xffcc) +__ulonglong 0xfff6 - 0x2a == -0x34 (0xffcc) +float 0xfff6 - 0x2a == -0x34 (0xffcc) +int 0xfff6 * 0x2a == -0x1a4 (0xfe5c) +__uint 0xfff6 * 0x2a == -0x1a4 (0xfe5c) +char 0xfff6 * 0x2a == 0x5c (0x5c) +__uchar 0xf6 * 0x2a == 0x5c (0x5c) +__longlong 0xfff6 * 0x2a == -0x1a4 (0xfe5c) +__ulonglong 0xfff6 * 0x2a == -0x1a4 (0xfe5c) +float 0xfff6 * 0x2a == -0x1a4 (0xfe5c) +int 0xfff6 < 0x2a == 0x1 (0x1) +__uint 0xfff6 < 0x2a == 0x0 (0x0) +char 0xfff6 < 0x2a == 0x1 (0x1) +__uchar 0xf6 < 0x2a == 0x0 (0x0) +__longlong 0xfff6 < 0x2a == 0x1 (0x1) +__ulonglong 0xfff6 < 0x2a == 0x0 (0x0) +float 0xfff6 < 0x2a == 0x1 (0x1) +int 0xfff6 > 0x2a == 0x0 (0x0) +__uint 0xfff6 > 0x2a == 0x1 (0x1) +char 0xfff6 > 0x2a == 0x0 (0x0) +__uchar 0xf6 > 0x2a == 0x1 (0x1) +__longlong 0xfff6 > 0x2a == 0x0 (0x0) +__ulonglong 0xfff6 > 0x2a == 0x1 (0x1) +float 0xfff6 > 0x2a == 0x0 (0x0) +int 0xfff6 <= 0x2a == 0x1 (0x1) +__uint 0xfff6 <= 0x2a == 0x0 (0x0) +char 0xfff6 <= 0x2a == 0x1 (0x1) +__uchar 0xf6 <= 0x2a == 0x0 (0x0) +__longlong 0xfff6 <= 0x2a == 0x1 (0x1) +__ulonglong 0xfff6 <= 0x2a == 0x0 (0x0) +float 0xfff6 <= 0x2a == 0x1 (0x1) +int 0xfff6 == 0x2a == 0x0 (0x0) +__uint 0xfff6 == 0x2a == 0x0 (0x0) +char 0xfff6 == 0x2a == 0x0 (0x0) +__uchar 0xf6 == 0x2a == 0x0 (0x0) +__longlong 0xfff6 == 0x2a == 0x0 (0x0) +__ulonglong 0xfff6 == 0x2a == 0x0 (0x0) +float 0xfff6 == 0x2a == 0x0 (0x0) +int 0xfff6 != 0x2a == 0x1 (0x1) +__uint 0xfff6 != 0x2a == 0x1 (0x1) +char 0xfff6 != 0x2a == 0x1 (0x1) +__uchar 0xf6 != 0x2a == 0x1 (0x1) +__longlong 0xfff6 != 0x2a == 0x1 (0x1) +__ulonglong 0xfff6 != 0x2a == 0x1 (0x1) +float 0xfff6 != 0x2a == 0x1 (0x1) +int 0xfff6 >= 0x2a == 0x0 (0x0) +__uint 0xfff6 >= 0x2a == 0x1 (0x1) +char 0xfff6 >= 0x2a == 0x0 (0x0) +__uchar 0xf6 >= 0x2a == 0x1 (0x1) +__longlong 0xfff6 >= 0x2a == 0x0 (0x0) +__ulonglong 0xfff6 >= 0x2a == 0x1 (0x1) +float 0xfff6 >= 0x2a == 0x0 (0x0) +int 0xfff6 / 0x2a == 0x0 (0x0) +__uint 0xfff6 / 0x2a == 0x618 (0x618) +char 0xfff6 / 0x2a == 0x0 (0x0) +__uchar 0xf6 / 0x2a == 0x5 (0x5) +__longlong 0xfff6 / 0x2a == 0x0 (0x0) +__ulonglong 0xfff6 / 0x2a == 0x6185 (0x6185) +float 0xfff6 / 0x2a == 0x0 (0x0) +int 0xfff6 % 0x2a == -0xa (0xfff6) +__uint 0xfff6 % 0x2a == 0x6 (0x6) +char 0xfff6 % 0x2a == -0xa (0xfff6) +__uchar 0xf6 % 0x2a == 0x24 (0x24) +__longlong 0xfff6 % 0x2a == -0xa (0xfff6) +__ulonglong 0xfff6 % 0x2a == 0x24 (0x24) +0xfff6 * 0x17 == -0xe6 +0xfff6 / 0x17 == 0x0 +0xfff6 % 0x17 == -0xa +int 0xfff6 ^ 0x17 == -0x1f (0xffe1) +__uint 0xfff6 ^ 0x17 == -0x1f (0xffe1) +char 0xfff6 ^ 0x17 == -0x1f (0xffe1) +__uchar 0xf6 ^ 0x17 == 0xe1 (0xe1) +__longlong 0xfff6 ^ 0x17 == -0x1f (0xffe1) +__ulonglong 0xfff6 ^ 0x17 == -0x1f (0xffe1) +int 0xfff6 && 0x17 == 0x1 (0x1) +__uint 0xfff6 && 0x17 == 0x1 (0x1) +char 0xfff6 && 0x17 == 0x1 (0x1) +__uchar 0xf6 && 0x17 == 0x1 (0x1) +__longlong 0xfff6 && 0x17 == 0x1 (0x1) +__ulonglong 0xfff6 && 0x17 == 0x1 (0x1) +int 0xfff6 || 0x17 == 0x1 (0x1) +__uint 0xfff6 || 0x17 == 0x1 (0x1) +char 0xfff6 || 0x17 == 0x1 (0x1) +__uchar 0xf6 || 0x17 == 0x1 (0x1) +__longlong 0xfff6 || 0x17 == 0x1 (0x1) +__ulonglong 0xfff6 || 0x17 == 0x1 (0x1) +int 0xfff6 & 0x17 == 0x16 (0x16) +__uint 0xfff6 & 0x17 == 0x16 (0x16) +char 0xfff6 & 0x17 == 0x16 (0x16) +__uchar 0xf6 & 0x17 == 0x16 (0x16) +__longlong 0xfff6 & 0x17 == 0x16 (0x16) +__ulonglong 0xfff6 & 0x17 == 0x16 (0x16) +int 0xfff6 | 0x17 == -0x9 (0xfff7) +__uint 0xfff6 | 0x17 == -0x9 (0xfff7) +char 0xfff6 | 0x17 == -0x9 (0xfff7) +__uchar 0xf6 | 0x17 == 0xf7 (0xf7) +__longlong 0xfff6 | 0x17 == -0x9 (0xfff7) +__ulonglong 0xfff6 | 0x17 == -0x9 (0xfff7) +int 0xfff6 << 0xe == -0x8000 (0x8000) +__uint 0xfff6 << 0xe == -0x8000 (0x8000) +char 0xfff6 << 0xe == 0x0 (0x0) +__uchar 0xf6 << 0xe == 0x0 (0x0) +__longlong 0xfff6 << 0xe == -0x8000 (0x8000) +__ulonglong 0xfff6 << 0xe == -0x8000 (0x8000) +int 0xfff6 >> 0xe == -0x1 (0xffff) +__uint 0xfff6 >> 0xe == 0x3 (0x3) +char 0xfff6 >> 0xe == -0x1 (0xffff) +__uchar 0xf6 >> 0xe == 0x0 (0x0) +__longlong 0xfff6 >> 0xe == -0x1 (0xffff) +__ulonglong 0xfff6 >> 0xe == -0x1 (0xffff) +int 0xfff6 + 0x17 == 0xd (0xd) +__uint 0xfff6 + 0x17 == 0xd (0xd) +char 0xfff6 + 0x17 == 0xd (0xd) +__uchar 0xf6 + 0x17 == 0xd (0xd) +__longlong 0xfff6 + 0x17 == 0xd (0xd) +__ulonglong 0xfff6 + 0x17 == 0xd (0xd) +float 0xfff6 + 0x17 == 0xd (0xd) +int 0xfff6 - 0x17 == -0x21 (0xffdf) +__uint 0xfff6 - 0x17 == -0x21 (0xffdf) +char 0xfff6 - 0x17 == -0x21 (0xffdf) +__uchar 0xf6 - 0x17 == 0xdf (0xdf) +__longlong 0xfff6 - 0x17 == -0x21 (0xffdf) +__ulonglong 0xfff6 - 0x17 == -0x21 (0xffdf) +float 0xfff6 - 0x17 == -0x21 (0xffdf) +int 0xfff6 * 0x17 == -0xe6 (0xff1a) +__uint 0xfff6 * 0x17 == -0xe6 (0xff1a) +char 0xfff6 * 0x17 == 0x1a (0x1a) +__uchar 0xf6 * 0x17 == 0x1a (0x1a) +__longlong 0xfff6 * 0x17 == -0xe6 (0xff1a) +__ulonglong 0xfff6 * 0x17 == -0xe6 (0xff1a) +float 0xfff6 * 0x17 == -0xe6 (0xff1a) +int 0xfff6 < 0x17 == 0x1 (0x1) +__uint 0xfff6 < 0x17 == 0x0 (0x0) +char 0xfff6 < 0x17 == 0x1 (0x1) +__uchar 0xf6 < 0x17 == 0x0 (0x0) +__longlong 0xfff6 < 0x17 == 0x1 (0x1) +__ulonglong 0xfff6 < 0x17 == 0x0 (0x0) +float 0xfff6 < 0x17 == 0x1 (0x1) +int 0xfff6 > 0x17 == 0x0 (0x0) +__uint 0xfff6 > 0x17 == 0x1 (0x1) +char 0xfff6 > 0x17 == 0x0 (0x0) +__uchar 0xf6 > 0x17 == 0x1 (0x1) +__longlong 0xfff6 > 0x17 == 0x0 (0x0) +__ulonglong 0xfff6 > 0x17 == 0x1 (0x1) +float 0xfff6 > 0x17 == 0x0 (0x0) +int 0xfff6 <= 0x17 == 0x1 (0x1) +__uint 0xfff6 <= 0x17 == 0x0 (0x0) +char 0xfff6 <= 0x17 == 0x1 (0x1) +__uchar 0xf6 <= 0x17 == 0x0 (0x0) +__longlong 0xfff6 <= 0x17 == 0x1 (0x1) +__ulonglong 0xfff6 <= 0x17 == 0x0 (0x0) +float 0xfff6 <= 0x17 == 0x1 (0x1) +int 0xfff6 == 0x17 == 0x0 (0x0) +__uint 0xfff6 == 0x17 == 0x0 (0x0) +char 0xfff6 == 0x17 == 0x0 (0x0) +__uchar 0xf6 == 0x17 == 0x0 (0x0) +__longlong 0xfff6 == 0x17 == 0x0 (0x0) +__ulonglong 0xfff6 == 0x17 == 0x0 (0x0) +float 0xfff6 == 0x17 == 0x0 (0x0) +int 0xfff6 != 0x17 == 0x1 (0x1) +__uint 0xfff6 != 0x17 == 0x1 (0x1) +char 0xfff6 != 0x17 == 0x1 (0x1) +__uchar 0xf6 != 0x17 == 0x1 (0x1) +__longlong 0xfff6 != 0x17 == 0x1 (0x1) +__ulonglong 0xfff6 != 0x17 == 0x1 (0x1) +float 0xfff6 != 0x17 == 0x1 (0x1) +int 0xfff6 >= 0x17 == 0x0 (0x0) +__uint 0xfff6 >= 0x17 == 0x1 (0x1) +char 0xfff6 >= 0x17 == 0x0 (0x0) +__uchar 0xf6 >= 0x17 == 0x1 (0x1) +__longlong 0xfff6 >= 0x17 == 0x0 (0x0) +__ulonglong 0xfff6 >= 0x17 == 0x1 (0x1) +float 0xfff6 >= 0x17 == 0x0 (0x0) +int 0xfff6 / 0x17 == 0x0 (0x0) +__uint 0xfff6 / 0x17 == 0xb20 (0xb20) +char 0xfff6 / 0x17 == 0x0 (0x0) +__uchar 0xf6 / 0x17 == 0xa (0xa) +__longlong 0xfff6 / 0x17 == 0x0 (0x0) +__ulonglong 0xfff6 / 0x17 == 0x642c (0x642c) +float 0xfff6 / 0x17 == 0x0 (0x0) +int 0xfff6 % 0x17 == -0xa (0xfff6) +__uint 0xfff6 % 0x17 == 0x16 (0x16) +char 0xfff6 % 0x17 == -0xa (0xfff6) +__uchar 0xf6 % 0x17 == 0x10 (0x10) +__longlong 0xfff6 % 0x17 == -0xa (0xfff6) +__ulonglong 0xfff6 % 0x17 == 0x2 (0x2) +0xfff6 * 0x7fff == 0xa +0xfff6 / 0x7fff == 0x0 +0xfff6 % 0x7fff == -0xa +int 0xfff6 ^ 0x7fff == -0x7ff7 (0x8009) +__uint 0xfff6 ^ 0x7fff == -0x7ff7 (0x8009) +char 0xfff6 ^ 0xffff == 0x9 (0x9) +__uchar 0xf6 ^ 0xff == 0x9 (0x9) +__longlong 0xfff6 ^ 0x7fff == -0x7ff7 (0x8009) +__ulonglong 0xfff6 ^ 0x7fff == -0x7ff7 (0x8009) +int 0xfff6 && 0x7fff == 0x1 (0x1) +__uint 0xfff6 && 0x7fff == 0x1 (0x1) +char 0xfff6 && 0xffff == 0x1 (0x1) +__uchar 0xf6 && 0xff == 0x1 (0x1) +__longlong 0xfff6 && 0x7fff == 0x1 (0x1) +__ulonglong 0xfff6 && 0x7fff == 0x1 (0x1) +int 0xfff6 || 0x7fff == 0x1 (0x1) +__uint 0xfff6 || 0x7fff == 0x1 (0x1) +char 0xfff6 || 0xffff == 0x1 (0x1) +__uchar 0xf6 || 0xff == 0x1 (0x1) +__longlong 0xfff6 || 0x7fff == 0x1 (0x1) +__ulonglong 0xfff6 || 0x7fff == 0x1 (0x1) +int 0xfff6 & 0x7fff == 0x7ff6 (0x7ff6) +__uint 0xfff6 & 0x7fff == 0x7ff6 (0x7ff6) +char 0xfff6 & 0xffff == -0xa (0xfff6) +__uchar 0xf6 & 0xff == 0xf6 (0xf6) +__longlong 0xfff6 & 0x7fff == 0x7ff6 (0x7ff6) +__ulonglong 0xfff6 & 0x7fff == 0x7ff6 (0x7ff6) +int 0xfff6 | 0x7fff == -0x1 (0xffff) +__uint 0xfff6 | 0x7fff == -0x1 (0xffff) +char 0xfff6 | 0xffff == -0x1 (0xffff) +__uchar 0xf6 | 0xff == 0xff (0xff) +__longlong 0xfff6 | 0x7fff == -0x1 (0xffff) +__ulonglong 0xfff6 | 0x7fff == -0x1 (0xffff) +int 0xfff6 << 0x10 == 0x0 (0x0) +__uint 0xfff6 << 0x10 == 0x0 (0x0) +char 0xfff6 << 0x10 == 0x0 (0x0) +__uchar 0xf6 << 0x10 == 0x0 (0x0) +__longlong 0xfff6 << 0x10 == 0x0 (0x0) +__ulonglong 0xfff6 << 0x10 == 0x0 (0x0) +int 0xfff6 >> 0x10 == -0x1 (0xffff) +__uint 0xfff6 >> 0x10 == 0x0 (0x0) +char 0xfff6 >> 0x10 == -0x1 (0xffff) +__uchar 0xf6 >> 0x10 == 0x0 (0x0) +__longlong 0xfff6 >> 0x10 == -0x1 (0xffff) +__ulonglong 0xfff6 >> 0x10 == -0x1 (0xffff) +int 0xfff6 + 0x7fff == 0x7ff5 (0x7ff5) +__uint 0xfff6 + 0x7fff == 0x7ff5 (0x7ff5) +char 0xfff6 + 0xffff == -0xb (0xfff5) +__uchar 0xf6 + 0xff == 0xf5 (0xf5) +__longlong 0xfff6 + 0x7fff == 0x7ff5 (0x7ff5) +__ulonglong 0xfff6 + 0x7fff == 0x7ff5 (0x7ff5) +float 0xfff6 + 0x7fff == 0x7ff5 (0x7ff5) +int 0xfff6 - 0x7fff == 0x7ff7 (0x7ff7) +__uint 0xfff6 - 0x7fff == 0x7ff7 (0x7ff7) +char 0xfff6 - 0xffff == -0x9 (0xfff7) +__uchar 0xf6 - 0xff == 0xf7 (0xf7) +__longlong 0xfff6 - 0x7fff == 0x7ff7 (0x7ff7) +__ulonglong 0xfff6 - 0x7fff == 0x7ff7 (0x7ff7) +float 0xfff6 - 0x7fff == -0x8000 (0x8000) +int 0xfff6 * 0x7fff == 0xa (0xa) +__uint 0xfff6 * 0x7fff == 0xa (0xa) +char 0xfff6 * 0xffff == 0xa (0xa) +__uchar 0xf6 * 0xff == 0xa (0xa) +__longlong 0xfff6 * 0x7fff == 0xa (0xa) +__ulonglong 0xfff6 * 0x7fff == 0xa (0xa) +float 0xfff6 * 0x7fff == -0x8000 (0x8000) +int 0xfff6 < 0x7fff == 0x1 (0x1) +__uint 0xfff6 < 0x7fff == 0x0 (0x0) +char 0xfff6 < 0xffff == 0x1 (0x1) +__uchar 0xf6 < 0xff == 0x1 (0x1) +__longlong 0xfff6 < 0x7fff == 0x1 (0x1) +__ulonglong 0xfff6 < 0x7fff == 0x0 (0x0) +float 0xfff6 < 0x7fff == 0x1 (0x1) +int 0xfff6 > 0x7fff == 0x0 (0x0) +__uint 0xfff6 > 0x7fff == 0x1 (0x1) +char 0xfff6 > 0xffff == 0x0 (0x0) +__uchar 0xf6 > 0xff == 0x0 (0x0) +__longlong 0xfff6 > 0x7fff == 0x0 (0x0) +__ulonglong 0xfff6 > 0x7fff == 0x1 (0x1) +float 0xfff6 > 0x7fff == 0x0 (0x0) +int 0xfff6 <= 0x7fff == 0x1 (0x1) +__uint 0xfff6 <= 0x7fff == 0x0 (0x0) +char 0xfff6 <= 0xffff == 0x1 (0x1) +__uchar 0xf6 <= 0xff == 0x1 (0x1) +__longlong 0xfff6 <= 0x7fff == 0x1 (0x1) +__ulonglong 0xfff6 <= 0x7fff == 0x0 (0x0) +float 0xfff6 <= 0x7fff == 0x1 (0x1) +int 0xfff6 == 0x7fff == 0x0 (0x0) +__uint 0xfff6 == 0x7fff == 0x0 (0x0) +char 0xfff6 == 0xffff == 0x0 (0x0) +__uchar 0xf6 == 0xff == 0x0 (0x0) +__longlong 0xfff6 == 0x7fff == 0x0 (0x0) +__ulonglong 0xfff6 == 0x7fff == 0x0 (0x0) +float 0xfff6 == 0x7fff == 0x0 (0x0) +int 0xfff6 != 0x7fff == 0x1 (0x1) +__uint 0xfff6 != 0x7fff == 0x1 (0x1) +char 0xfff6 != 0xffff == 0x1 (0x1) +__uchar 0xf6 != 0xff == 0x1 (0x1) +__longlong 0xfff6 != 0x7fff == 0x1 (0x1) +__ulonglong 0xfff6 != 0x7fff == 0x1 (0x1) +float 0xfff6 != 0x7fff == 0x1 (0x1) +int 0xfff6 >= 0x7fff == 0x0 (0x0) +__uint 0xfff6 >= 0x7fff == 0x1 (0x1) +char 0xfff6 >= 0xffff == 0x0 (0x0) +__uchar 0xf6 >= 0xff == 0x0 (0x0) +__longlong 0xfff6 >= 0x7fff == 0x0 (0x0) +__ulonglong 0xfff6 >= 0x7fff == 0x1 (0x1) +float 0xfff6 >= 0x7fff == 0x0 (0x0) +int 0xfff6 / 0x7fff == 0x0 (0x0) +__uint 0xfff6 / 0x7fff == 0x1 (0x1) +char 0xfff6 / 0xffff == 0xa (0xa) +__uchar 0xf6 / 0xff == 0x0 (0x0) +__longlong 0xfff6 / 0x7fff == 0x0 (0x0) +__ulonglong 0xfff6 / 0x7fff == 0x3 (0x3) +float 0xfff6 / 0x7fff == 0x0 (0x0) +int 0xfff6 % 0x7fff == -0xa (0xfff6) +__uint 0xfff6 % 0x7fff == 0x7ff7 (0x7ff7) +char 0xfff6 % 0xffff == 0x0 (0x0) +__uchar 0xf6 % 0xff == 0xf6 (0xf6) +__longlong 0xfff6 % 0x7fff == -0xa (0xfff6) +__ulonglong 0xfff6 % 0x7fff == 0x7ff9 (0x7ff9) +0xfff6 * 0x8000 == 0x0 +0xfff6 / 0x8000 == 0x0 +0xfff6 % 0x8000 == -0xa +int 0xfff6 ^ 0x8000 == 0x7ff6 (0x7ff6) +__uint 0xfff6 ^ 0x8000 == 0x7ff6 (0x7ff6) +char 0xfff6 ^ 0x0 == -0xa (0xfff6) +__uchar 0xf6 ^ 0x0 == 0xf6 (0xf6) +__longlong 0xfff6 ^ 0x8000 == 0x7ff6 (0x7ff6) +__ulonglong 0xfff6 ^ 0x8000 == 0x7ff6 (0x7ff6) +int 0xfff6 && 0x8000 == 0x1 (0x1) +__uint 0xfff6 && 0x8000 == 0x1 (0x1) +char 0xfff6 && 0x0 == 0x0 (0x0) +__uchar 0xf6 && 0x0 == 0x0 (0x0) +__longlong 0xfff6 && 0x8000 == 0x1 (0x1) +__ulonglong 0xfff6 && 0x8000 == 0x1 (0x1) +int 0xfff6 || 0x8000 == 0x1 (0x1) +__uint 0xfff6 || 0x8000 == 0x1 (0x1) +char 0xfff6 || 0x0 == 0x1 (0x1) +__uchar 0xf6 || 0x0 == 0x1 (0x1) +__longlong 0xfff6 || 0x8000 == 0x1 (0x1) +__ulonglong 0xfff6 || 0x8000 == 0x1 (0x1) +int 0xfff6 & 0x8000 == -0x8000 (0x8000) +__uint 0xfff6 & 0x8000 == -0x8000 (0x8000) +char 0xfff6 & 0x0 == 0x0 (0x0) +__uchar 0xf6 & 0x0 == 0x0 (0x0) +__longlong 0xfff6 & 0x8000 == -0x8000 (0x8000) +__ulonglong 0xfff6 & 0x8000 == -0x8000 (0x8000) +int 0xfff6 | 0x8000 == -0xa (0xfff6) +__uint 0xfff6 | 0x8000 == -0xa (0xfff6) +char 0xfff6 | 0x0 == -0xa (0xfff6) +__uchar 0xf6 | 0x0 == 0xf6 (0xf6) +__longlong 0xfff6 | 0x8000 == -0xa (0xfff6) +__ulonglong 0xfff6 | 0x8000 == -0xa (0xfff6) +int 0xfff6 << 0x12 == 0x0 (0x0) +__uint 0xfff6 << 0x12 == 0x0 (0x0) +char 0xfff6 << 0x12 == 0x0 (0x0) +__uchar 0xf6 << 0x12 == 0x0 (0x0) +__longlong 0xfff6 << 0x12 == 0x0 (0x0) +__ulonglong 0xfff6 << 0x12 == 0x0 (0x0) +int 0xfff6 >> 0x12 == -0x1 (0xffff) +__uint 0xfff6 >> 0x12 == 0x0 (0x0) +char 0xfff6 >> 0x12 == -0x1 (0xffff) +__uchar 0xf6 >> 0x12 == 0x0 (0x0) +__longlong 0xfff6 >> 0x12 == -0x1 (0xffff) +__ulonglong 0xfff6 >> 0x12 == 0x3fff (0x3fff) +int 0xfff6 + 0x8000 == 0x7ff6 (0x7ff6) +__uint 0xfff6 + 0x8000 == 0x7ff6 (0x7ff6) +char 0xfff6 + 0x0 == -0xa (0xfff6) +__uchar 0xf6 + 0x0 == 0xf6 (0xf6) +__longlong 0xfff6 + 0x8000 == 0x7ff6 (0x7ff6) +__ulonglong 0xfff6 + 0x8000 == 0x7ff6 (0x7ff6) +float 0xfff6 + 0x8000 == -0x8000 (0x8000) +int 0xfff6 - 0x8000 == 0x7ff6 (0x7ff6) +__uint 0xfff6 - 0x8000 == 0x7ff6 (0x7ff6) +char 0xfff6 - 0x0 == -0xa (0xfff6) +__uchar 0xf6 - 0x0 == 0xf6 (0xf6) +__longlong 0xfff6 - 0x8000 == 0x7ff6 (0x7ff6) +__ulonglong 0xfff6 - 0x8000 == 0x7ff6 (0x7ff6) +float 0xfff6 - 0x8000 == 0x7ff6 (0x7ff6) +int 0xfff6 * 0x8000 == 0x0 (0x0) +__uint 0xfff6 * 0x8000 == 0x0 (0x0) +char 0xfff6 * 0x0 == 0x0 (0x0) +__uchar 0xf6 * 0x0 == 0x0 (0x0) +__longlong 0xfff6 * 0x8000 == 0x0 (0x0) +__ulonglong 0xfff6 * 0x8000 == 0x0 (0x0) +float 0xfff6 * 0x8000 == -0x8000 (0x8000) +int 0xfff6 < 0x8000 == 0x0 (0x0) +__uint 0xfff6 < 0x8000 == 0x0 (0x0) +char 0xfff6 < 0x0 == 0x1 (0x1) +__uchar 0xf6 < 0x0 == 0x0 (0x0) +__longlong 0xfff6 < 0x8000 == 0x0 (0x0) +__ulonglong 0xfff6 < 0x8000 == 0x0 (0x0) +float 0xfff6 < 0x8000 == 0x0 (0x0) +int 0xfff6 > 0x8000 == 0x1 (0x1) +__uint 0xfff6 > 0x8000 == 0x1 (0x1) +char 0xfff6 > 0x0 == 0x0 (0x0) +__uchar 0xf6 > 0x0 == 0x1 (0x1) +__longlong 0xfff6 > 0x8000 == 0x1 (0x1) +__ulonglong 0xfff6 > 0x8000 == 0x1 (0x1) +float 0xfff6 > 0x8000 == 0x1 (0x1) +int 0xfff6 <= 0x8000 == 0x0 (0x0) +__uint 0xfff6 <= 0x8000 == 0x0 (0x0) +char 0xfff6 <= 0x0 == 0x1 (0x1) +__uchar 0xf6 <= 0x0 == 0x0 (0x0) +__longlong 0xfff6 <= 0x8000 == 0x0 (0x0) +__ulonglong 0xfff6 <= 0x8000 == 0x0 (0x0) +float 0xfff6 <= 0x8000 == 0x0 (0x0) +int 0xfff6 == 0x8000 == 0x0 (0x0) +__uint 0xfff6 == 0x8000 == 0x0 (0x0) +char 0xfff6 == 0x0 == 0x0 (0x0) +__uchar 0xf6 == 0x0 == 0x0 (0x0) +__longlong 0xfff6 == 0x8000 == 0x0 (0x0) +__ulonglong 0xfff6 == 0x8000 == 0x0 (0x0) +float 0xfff6 == 0x8000 == 0x0 (0x0) +int 0xfff6 != 0x8000 == 0x1 (0x1) +__uint 0xfff6 != 0x8000 == 0x1 (0x1) +char 0xfff6 != 0x0 == 0x1 (0x1) +__uchar 0xf6 != 0x0 == 0x1 (0x1) +__longlong 0xfff6 != 0x8000 == 0x1 (0x1) +__ulonglong 0xfff6 != 0x8000 == 0x1 (0x1) +float 0xfff6 != 0x8000 == 0x1 (0x1) +int 0xfff6 >= 0x8000 == 0x1 (0x1) +__uint 0xfff6 >= 0x8000 == 0x1 (0x1) +char 0xfff6 >= 0x0 == 0x0 (0x0) +__uchar 0xf6 >= 0x0 == 0x1 (0x1) +__longlong 0xfff6 >= 0x8000 == 0x1 (0x1) +__ulonglong 0xfff6 >= 0x8000 == 0x1 (0x1) +float 0xfff6 >= 0x8000 == 0x1 (0x1) +int 0xfff6 / 0x8000 == 0x0 (0x0) +__uint 0xfff6 / 0x8000 == 0x1 (0x1) +__longlong 0xfff6 / 0x8000 == 0x0 (0x0) +__ulonglong 0xfff6 / 0x8000 == 0x1 (0x1) +float 0xfff6 / 0x8000 == 0x0 (0x0) +int 0xfff6 % 0x8000 == -0xa (0xfff6) +__uint 0xfff6 % 0x8000 == 0x7ff6 (0x7ff6) +__longlong 0xfff6 % 0x8000 == -0xa (0xfff6) +__ulonglong 0xfff6 % 0x8000 == 0x7ff6 (0x7ff6) +0xfff6 * 0x3e8 == -0x2710 +0xfff6 / 0x3e8 == 0x0 +0xfff6 % 0x3e8 == -0xa +int 0xfff6 ^ 0x3e8 == -0x3e2 (0xfc1e) +__uint 0xfff6 ^ 0x3e8 == -0x3e2 (0xfc1e) +char 0xfff6 ^ 0xffe8 == 0x1e (0x1e) +__uchar 0xf6 ^ 0xe8 == 0x1e (0x1e) +__longlong 0xfff6 ^ 0x3e8 == -0x3e2 (0xfc1e) +__ulonglong 0xfff6 ^ 0x3e8 == -0x3e2 (0xfc1e) +int 0xfff6 && 0x3e8 == 0x1 (0x1) +__uint 0xfff6 && 0x3e8 == 0x1 (0x1) +char 0xfff6 && 0xffe8 == 0x1 (0x1) +__uchar 0xf6 && 0xe8 == 0x1 (0x1) +__longlong 0xfff6 && 0x3e8 == 0x1 (0x1) +__ulonglong 0xfff6 && 0x3e8 == 0x1 (0x1) +int 0xfff6 || 0x3e8 == 0x1 (0x1) +__uint 0xfff6 || 0x3e8 == 0x1 (0x1) +char 0xfff6 || 0xffe8 == 0x1 (0x1) +__uchar 0xf6 || 0xe8 == 0x1 (0x1) +__longlong 0xfff6 || 0x3e8 == 0x1 (0x1) +__ulonglong 0xfff6 || 0x3e8 == 0x1 (0x1) +int 0xfff6 & 0x3e8 == 0x3e0 (0x3e0) +__uint 0xfff6 & 0x3e8 == 0x3e0 (0x3e0) +char 0xfff6 & 0xffe8 == -0x20 (0xffe0) +__uchar 0xf6 & 0xe8 == 0xe0 (0xe0) +__longlong 0xfff6 & 0x3e8 == 0x3e0 (0x3e0) +__ulonglong 0xfff6 & 0x3e8 == 0x3e0 (0x3e0) +int 0xfff6 | 0x3e8 == -0x2 (0xfffe) +__uint 0xfff6 | 0x3e8 == -0x2 (0xfffe) +char 0xfff6 | 0xffe8 == -0x2 (0xfffe) +__uchar 0xf6 | 0xe8 == 0xfe (0xfe) +__longlong 0xfff6 | 0x3e8 == -0x2 (0xfffe) +__ulonglong 0xfff6 | 0x3e8 == -0x2 (0xfffe) +int 0xfff6 << 0x14 == 0x0 (0x0) +__uint 0xfff6 << 0x14 == 0x0 (0x0) +char 0xfff6 << 0x14 == 0x0 (0x0) +__uchar 0xf6 << 0x14 == 0x0 (0x0) +__longlong 0xfff6 << 0x14 == 0x0 (0x0) +__ulonglong 0xfff6 << 0x14 == 0x0 (0x0) +int 0xfff6 >> 0x14 == -0x1 (0xffff) +__uint 0xfff6 >> 0x14 == 0x0 (0x0) +char 0xfff6 >> 0x14 == -0x1 (0xffff) +__uchar 0xf6 >> 0x14 == 0x0 (0x0) +__longlong 0xfff6 >> 0x14 == -0x1 (0xffff) +__ulonglong 0xfff6 >> 0x14 == 0xfff (0xfff) +int 0xfff6 + 0x3e8 == 0x3de (0x3de) +__uint 0xfff6 + 0x3e8 == 0x3de (0x3de) +char 0xfff6 + 0xffe8 == -0x22 (0xffde) +__uchar 0xf6 + 0xe8 == 0xde (0xde) +__longlong 0xfff6 + 0x3e8 == 0x3de (0x3de) +__ulonglong 0xfff6 + 0x3e8 == 0x3de (0x3de) +float 0xfff6 + 0x3e8 == 0x3de (0x3de) +int 0xfff6 - 0x3e8 == -0x3f2 (0xfc0e) +__uint 0xfff6 - 0x3e8 == -0x3f2 (0xfc0e) +char 0xfff6 - 0xffe8 == 0xe (0xe) +__uchar 0xf6 - 0xe8 == 0xe (0xe) +__longlong 0xfff6 - 0x3e8 == -0x3f2 (0xfc0e) +__ulonglong 0xfff6 - 0x3e8 == -0x3f2 (0xfc0e) +float 0xfff6 - 0x3e8 == -0x3f2 (0xfc0e) +int 0xfff6 * 0x3e8 == -0x2710 (0xd8f0) +__uint 0xfff6 * 0x3e8 == -0x2710 (0xd8f0) +char 0xfff6 * 0xffe8 == -0x10 (0xfff0) +__uchar 0xf6 * 0xe8 == 0xf0 (0xf0) +__longlong 0xfff6 * 0x3e8 == -0x2710 (0xd8f0) +__ulonglong 0xfff6 * 0x3e8 == -0x2710 (0xd8f0) +float 0xfff6 * 0x3e8 == -0x2710 (0xd8f0) +int 0xfff6 < 0x3e8 == 0x1 (0x1) +__uint 0xfff6 < 0x3e8 == 0x0 (0x0) +char 0xfff6 < 0xffe8 == 0x0 (0x0) +__uchar 0xf6 < 0xe8 == 0x0 (0x0) +__longlong 0xfff6 < 0x3e8 == 0x1 (0x1) +__ulonglong 0xfff6 < 0x3e8 == 0x0 (0x0) +float 0xfff6 < 0x3e8 == 0x1 (0x1) +int 0xfff6 > 0x3e8 == 0x0 (0x0) +__uint 0xfff6 > 0x3e8 == 0x1 (0x1) +char 0xfff6 > 0xffe8 == 0x1 (0x1) +__uchar 0xf6 > 0xe8 == 0x1 (0x1) +__longlong 0xfff6 > 0x3e8 == 0x0 (0x0) +__ulonglong 0xfff6 > 0x3e8 == 0x1 (0x1) +float 0xfff6 > 0x3e8 == 0x0 (0x0) +int 0xfff6 <= 0x3e8 == 0x1 (0x1) +__uint 0xfff6 <= 0x3e8 == 0x0 (0x0) +char 0xfff6 <= 0xffe8 == 0x0 (0x0) +__uchar 0xf6 <= 0xe8 == 0x0 (0x0) +__longlong 0xfff6 <= 0x3e8 == 0x1 (0x1) +__ulonglong 0xfff6 <= 0x3e8 == 0x0 (0x0) +float 0xfff6 <= 0x3e8 == 0x1 (0x1) +int 0xfff6 == 0x3e8 == 0x0 (0x0) +__uint 0xfff6 == 0x3e8 == 0x0 (0x0) +char 0xfff6 == 0xffe8 == 0x0 (0x0) +__uchar 0xf6 == 0xe8 == 0x0 (0x0) +__longlong 0xfff6 == 0x3e8 == 0x0 (0x0) +__ulonglong 0xfff6 == 0x3e8 == 0x0 (0x0) +float 0xfff6 == 0x3e8 == 0x0 (0x0) +int 0xfff6 != 0x3e8 == 0x1 (0x1) +__uint 0xfff6 != 0x3e8 == 0x1 (0x1) +char 0xfff6 != 0xffe8 == 0x1 (0x1) +__uchar 0xf6 != 0xe8 == 0x1 (0x1) +__longlong 0xfff6 != 0x3e8 == 0x1 (0x1) +__ulonglong 0xfff6 != 0x3e8 == 0x1 (0x1) +float 0xfff6 != 0x3e8 == 0x1 (0x1) +int 0xfff6 >= 0x3e8 == 0x0 (0x0) +__uint 0xfff6 >= 0x3e8 == 0x1 (0x1) +char 0xfff6 >= 0xffe8 == 0x1 (0x1) +__uchar 0xf6 >= 0xe8 == 0x1 (0x1) +__longlong 0xfff6 >= 0x3e8 == 0x0 (0x0) +__ulonglong 0xfff6 >= 0x3e8 == 0x1 (0x1) +float 0xfff6 >= 0x3e8 == 0x0 (0x0) +int 0xfff6 / 0x3e8 == 0x0 (0x0) +__uint 0xfff6 / 0x3e8 == 0x41 (0x41) +char 0xfff6 / 0xffe8 == 0x0 (0x0) +__uchar 0xf6 / 0xe8 == 0x1 (0x1) +__longlong 0xfff6 / 0x3e8 == 0x0 (0x0) +__ulonglong 0xfff6 / 0x3e8 == -0x76c9 (0x8937) +float 0xfff6 / 0x3e8 == 0x0 (0x0) +int 0xfff6 % 0x3e8 == -0xa (0xfff6) +__uint 0xfff6 % 0x3e8 == 0x20e (0x20e) +char 0xfff6 % 0xffe8 == -0xa (0xfff6) +__uchar 0xf6 % 0xe8 == 0xe (0xe) +__longlong 0xfff6 % 0x3e8 == -0xa (0xfff6) +__ulonglong 0xfff6 % 0x3e8 == 0x11e (0x11e) +0xfff6 * 0x2710 == 0x7960 +0xfff6 / 0x2710 == 0x0 +0xfff6 % 0x2710 == -0xa +int 0xfff6 ^ 0x2710 == -0x271a (0xd8e6) +__uint 0xfff6 ^ 0x2710 == -0x271a (0xd8e6) +char 0xfff6 ^ 0x10 == -0x1a (0xffe6) +__uchar 0xf6 ^ 0x10 == 0xe6 (0xe6) +__longlong 0xfff6 ^ 0x2710 == -0x271a (0xd8e6) +__ulonglong 0xfff6 ^ 0x2710 == -0x271a (0xd8e6) +int 0xfff6 && 0x2710 == 0x1 (0x1) +__uint 0xfff6 && 0x2710 == 0x1 (0x1) +char 0xfff6 && 0x10 == 0x1 (0x1) +__uchar 0xf6 && 0x10 == 0x1 (0x1) +__longlong 0xfff6 && 0x2710 == 0x1 (0x1) +__ulonglong 0xfff6 && 0x2710 == 0x1 (0x1) +int 0xfff6 || 0x2710 == 0x1 (0x1) +__uint 0xfff6 || 0x2710 == 0x1 (0x1) +char 0xfff6 || 0x10 == 0x1 (0x1) +__uchar 0xf6 || 0x10 == 0x1 (0x1) +__longlong 0xfff6 || 0x2710 == 0x1 (0x1) +__ulonglong 0xfff6 || 0x2710 == 0x1 (0x1) +int 0xfff6 & 0x2710 == 0x2710 (0x2710) +__uint 0xfff6 & 0x2710 == 0x2710 (0x2710) +char 0xfff6 & 0x10 == 0x10 (0x10) +__uchar 0xf6 & 0x10 == 0x10 (0x10) +__longlong 0xfff6 & 0x2710 == 0x2710 (0x2710) +__ulonglong 0xfff6 & 0x2710 == 0x2710 (0x2710) +int 0xfff6 | 0x2710 == -0xa (0xfff6) +__uint 0xfff6 | 0x2710 == -0xa (0xfff6) +char 0xfff6 | 0x10 == -0xa (0xfff6) +__uchar 0xf6 | 0x10 == 0xf6 (0xf6) +__longlong 0xfff6 | 0x2710 == -0xa (0xfff6) +__ulonglong 0xfff6 | 0x2710 == -0xa (0xfff6) +int 0xfff6 << 0x16 == 0x0 (0x0) +__uint 0xfff6 << 0x16 == 0x0 (0x0) +char 0xfff6 << 0x16 == 0x0 (0x0) +__uchar 0xf6 << 0x16 == 0x0 (0x0) +__longlong 0xfff6 << 0x16 == 0x0 (0x0) +__ulonglong 0xfff6 << 0x16 == 0x0 (0x0) +int 0xfff6 >> 0x16 == -0x1 (0xffff) +__uint 0xfff6 >> 0x16 == 0x0 (0x0) +char 0xfff6 >> 0x16 == -0x1 (0xffff) +__uchar 0xf6 >> 0x16 == 0x0 (0x0) +__longlong 0xfff6 >> 0x16 == -0x1 (0xffff) +__ulonglong 0xfff6 >> 0x16 == 0x3ff (0x3ff) +int 0xfff6 + 0x2710 == 0x2706 (0x2706) +__uint 0xfff6 + 0x2710 == 0x2706 (0x2706) +char 0xfff6 + 0x10 == 0x6 (0x6) +__uchar 0xf6 + 0x10 == 0x6 (0x6) +__longlong 0xfff6 + 0x2710 == 0x2706 (0x2706) +__ulonglong 0xfff6 + 0x2710 == 0x2706 (0x2706) +float 0xfff6 + 0x2710 == 0x2706 (0x2706) +int 0xfff6 - 0x2710 == -0x271a (0xd8e6) +__uint 0xfff6 - 0x2710 == -0x271a (0xd8e6) +char 0xfff6 - 0x10 == -0x1a (0xffe6) +__uchar 0xf6 - 0x10 == 0xe6 (0xe6) +__longlong 0xfff6 - 0x2710 == -0x271a (0xd8e6) +__ulonglong 0xfff6 - 0x2710 == -0x271a (0xd8e6) +float 0xfff6 - 0x2710 == -0x271a (0xd8e6) +int 0xfff6 * 0x2710 == 0x7960 (0x7960) +__uint 0xfff6 * 0x2710 == 0x7960 (0x7960) +char 0xfff6 * 0x10 == 0x60 (0x60) +__uchar 0xf6 * 0x10 == 0x60 (0x60) +__longlong 0xfff6 * 0x2710 == 0x7960 (0x7960) +__ulonglong 0xfff6 * 0x2710 == 0x7960 (0x7960) +float 0xfff6 * 0x2710 == -0x8000 (0x8000) +int 0xfff6 < 0x2710 == 0x1 (0x1) +__uint 0xfff6 < 0x2710 == 0x0 (0x0) +char 0xfff6 < 0x10 == 0x1 (0x1) +__uchar 0xf6 < 0x10 == 0x0 (0x0) +__longlong 0xfff6 < 0x2710 == 0x1 (0x1) +__ulonglong 0xfff6 < 0x2710 == 0x0 (0x0) +float 0xfff6 < 0x2710 == 0x1 (0x1) +int 0xfff6 > 0x2710 == 0x0 (0x0) +__uint 0xfff6 > 0x2710 == 0x1 (0x1) +char 0xfff6 > 0x10 == 0x0 (0x0) +__uchar 0xf6 > 0x10 == 0x1 (0x1) +__longlong 0xfff6 > 0x2710 == 0x0 (0x0) +__ulonglong 0xfff6 > 0x2710 == 0x1 (0x1) +float 0xfff6 > 0x2710 == 0x0 (0x0) +int 0xfff6 <= 0x2710 == 0x1 (0x1) +__uint 0xfff6 <= 0x2710 == 0x0 (0x0) +char 0xfff6 <= 0x10 == 0x1 (0x1) +__uchar 0xf6 <= 0x10 == 0x0 (0x0) +__longlong 0xfff6 <= 0x2710 == 0x1 (0x1) +__ulonglong 0xfff6 <= 0x2710 == 0x0 (0x0) +float 0xfff6 <= 0x2710 == 0x1 (0x1) +int 0xfff6 == 0x2710 == 0x0 (0x0) +__uint 0xfff6 == 0x2710 == 0x0 (0x0) +char 0xfff6 == 0x10 == 0x0 (0x0) +__uchar 0xf6 == 0x10 == 0x0 (0x0) +__longlong 0xfff6 == 0x2710 == 0x0 (0x0) +__ulonglong 0xfff6 == 0x2710 == 0x0 (0x0) +float 0xfff6 == 0x2710 == 0x0 (0x0) +int 0xfff6 != 0x2710 == 0x1 (0x1) +__uint 0xfff6 != 0x2710 == 0x1 (0x1) +char 0xfff6 != 0x10 == 0x1 (0x1) +__uchar 0xf6 != 0x10 == 0x1 (0x1) +__longlong 0xfff6 != 0x2710 == 0x1 (0x1) +__ulonglong 0xfff6 != 0x2710 == 0x1 (0x1) +float 0xfff6 != 0x2710 == 0x1 (0x1) +int 0xfff6 >= 0x2710 == 0x0 (0x0) +__uint 0xfff6 >= 0x2710 == 0x1 (0x1) +char 0xfff6 >= 0x10 == 0x0 (0x0) +__uchar 0xf6 >= 0x10 == 0x1 (0x1) +__longlong 0xfff6 >= 0x2710 == 0x0 (0x0) +__ulonglong 0xfff6 >= 0x2710 == 0x1 (0x1) +float 0xfff6 >= 0x2710 == 0x0 (0x0) +int 0xfff6 / 0x2710 == 0x0 (0x0) +__uint 0xfff6 / 0x2710 == 0x6 (0x6) +char 0xfff6 / 0x10 == 0x0 (0x0) +__uchar 0xf6 / 0x10 == 0xf (0xf) +__longlong 0xfff6 / 0x2710 == 0x0 (0x0) +__ulonglong 0xfff6 / 0x2710 == -0x7248 (0x8db8) +float 0xfff6 / 0x2710 == 0x0 (0x0) +int 0xfff6 % 0x2710 == -0xa (0xfff6) +__uint 0xfff6 % 0x2710 == 0x1596 (0x1596) +char 0xfff6 % 0x10 == -0xa (0xfff6) +__uchar 0xf6 % 0x10 == 0x6 (0x6) +__longlong 0xfff6 % 0x2710 == -0xa (0xfff6) +__ulonglong 0xfff6 % 0x2710 == 0x1c76 (0x1c76) +int xor42-0xa xor42 -0x24 +__uint xor42-0xa xor42 -0x24 +char xor42-0xa xor42 -0x24 +__uchar xor420xf6 xor42 0xdc +__longlong xor42-0xa xor42 -0x24 +__ulonglong xor42-0xa xor42 -0x24 +int land1-0xa land1 0x1 +__uint land1-0xa land1 0x1 +char land1-0xa land1 0x1 +__uchar land10xf6 land1 0x1 +__longlong land1-0xa land1 0x1 +__ulonglong land1-0xa land1 0x1 +int lor1-0xa lor1 0x1 +__uint lor1-0xa lor1 0x1 +char lor1-0xa lor1 0x1 +__uchar lor10xf6 lor1 0x1 +__longlong lor1-0xa lor1 0x1 +__ulonglong lor1-0xa lor1 0x1 +int and42-0xa and42 0x22 +__uint and42-0xa and42 0x22 +char and42-0xa and42 0x22 +__uchar and420xf6 and42 0x22 +__longlong and42-0xa and42 0x22 +__ulonglong and42-0xa and42 0x22 +int or42-0xa or42 -0x2 +__uint or42-0xa or42 -0x2 +char or42-0xa or42 -0x2 +__uchar or420xf6 or42 0xfe +__longlong or42-0xa or42 -0x2 +__ulonglong or42-0xa or42 -0x2 +int shl5-0xa shl5 -0x140 +__uint shl5-0xa shl5 -0x140 +char shl5-0xa shl5 -0x40 +__uchar shl50xf6 shl5 0xc0 +__longlong shl5-0xa shl5 -0x140 +__ulonglong shl5-0xa shl5 -0x140 +int shr5-0xa shr5 -0x1 +__uint shr5-0xa shr5 0x7ff +char shr5-0xa shr5 -0x1 +__uchar shr50xf6 shr5 0x7 +__longlong shr5-0xa shr5 -0x1 +__ulonglong shr5-0xa shr5 -0x1 +int add42-0xa add42 0x20 +__uint add42-0xa add42 0x20 +char add42-0xa add42 0x20 +__uchar add420xf6 add42 0x20 +__longlong add42-0xa add42 0x20 +__ulonglong add42-0xa add42 0x20 +float add42-0xa add42 0x20 +int sub42-0xa sub42 -0x34 +__uint sub42-0xa sub42 -0x34 +char sub42-0xa sub42 -0x34 +__uchar sub420xf6 sub42 0xcc +__longlong sub42-0xa sub42 -0x34 +__ulonglong sub42-0xa sub42 -0x34 +float sub42-0xa sub42 -0x34 +int mul42-0xa mul42 -0x1a4 +__uint mul42-0xa mul42 -0x1a4 +char mul42-0xa mul42 0x5c +__uchar mul420xf6 mul42 0x5c +__longlong mul42-0xa mul42 -0x1a4 +__ulonglong mul42-0xa mul42 -0x1a4 +float mul42-0xa mul42 -0x1a4 +int lt42-0xa lt42 0x1 +__uint lt42-0xa lt42 0x0 +char lt42-0xa lt42 0x1 +__uchar lt420xf6 lt42 0x0 +__longlong lt42-0xa lt42 0x1 +__ulonglong lt42-0xa lt42 0x0 +float lt42-0xa lt42 0x1 +int gt42-0xa gt42 0x0 +__uint gt42-0xa gt42 0x1 +char gt42-0xa gt42 0x0 +__uchar gt420xf6 gt42 0x1 +__longlong gt42-0xa gt42 0x0 +__ulonglong gt42-0xa gt42 0x1 +float gt42-0xa gt42 0x0 +int le42-0xa le42 0x1 +__uint le42-0xa le42 0x0 +char le42-0xa le42 0x1 +__uchar le420xf6 le42 0x0 +__longlong le42-0xa le42 0x1 +__ulonglong le42-0xa le42 0x0 +float le42-0xa le42 0x1 +int eq42-0xa eq42 0x0 +__uint eq42-0xa eq42 0x0 +char eq42-0xa eq42 0x0 +__uchar eq420xf6 eq42 0x0 +__longlong eq42-0xa eq42 0x0 +__ulonglong eq42-0xa eq42 0x0 +float eq42-0xa eq42 0x0 +int ne42-0xa ne42 0x1 +__uint ne42-0xa ne42 0x1 +char ne42-0xa ne42 0x1 +__uchar ne420xf6 ne42 0x1 +__longlong ne42-0xa ne42 0x1 +__ulonglong ne42-0xa ne42 0x1 +float ne42-0xa ne42 0x1 +int ge42-0xa ge42 0x0 +__uint ge42-0xa ge42 0x1 +char ge42-0xa ge42 0x0 +__uchar ge420xf6 ge42 0x1 +__longlong ge42-0xa ge42 0x0 +__ulonglong ge42-0xa ge42 0x1 +float ge42-0xa ge42 0x0 +int div42-0xa div42 0x0 +__uint div42-0xa div42 0x618 +char div42-0xa div42 0x0 +__uchar div420xf6 div42 0x5 +__longlong div42-0xa div42 0x0 +__ulonglong div42-0xa div42 0x6185 +float div42-0xa div42 0x0 +int mod23-0xa mod23 -0xa +__uint mod23-0xa mod23 0x16 +char mod23-0xa mod23 -0xa +__uchar mod230xf6 mod23 0x10 +__longlong mod23-0xa mod23 -0xa +__ulonglong mod23-0xa mod23 0x2 +0x5 * 0xffff == -0x5 +0x5 / 0xffff == -0x5 +0x5 % 0xffff == 0x0 +int 0x5 ^ 0xffff == -0x6 (0xfffa) +__uint 0x5 ^ 0xffff == -0x6 (0xfffa) +char 0x5 ^ 0xffff == -0x6 (0xfffa) +__uchar 0x5 ^ 0xff == 0xfa (0xfa) +__longlong 0x5 ^ 0xffff == -0x6 (0xfffa) +__ulonglong 0x5 ^ 0xffff == -0x6 (0xfffa) +int 0x5 && 0xffff == 0x1 (0x1) +__uint 0x5 && 0xffff == 0x1 (0x1) +char 0x5 && 0xffff == 0x1 (0x1) +__uchar 0x5 && 0xff == 0x1 (0x1) +__longlong 0x5 && 0xffff == 0x1 (0x1) +__ulonglong 0x5 && 0xffff == 0x1 (0x1) +int 0x5 || 0xffff == 0x1 (0x1) +__uint 0x5 || 0xffff == 0x1 (0x1) +char 0x5 || 0xffff == 0x1 (0x1) +__uchar 0x5 || 0xff == 0x1 (0x1) +__longlong 0x5 || 0xffff == 0x1 (0x1) +__ulonglong 0x5 || 0xffff == 0x1 (0x1) +int 0x5 & 0xffff == 0x5 (0x5) +__uint 0x5 & 0xffff == 0x5 (0x5) +char 0x5 & 0xffff == 0x5 (0x5) +__uchar 0x5 & 0xff == 0x5 (0x5) +__longlong 0x5 & 0xffff == 0x5 (0x5) +__ulonglong 0x5 & 0xffff == 0x5 (0x5) +int 0x5 | 0xffff == -0x1 (0xffff) +__uint 0x5 | 0xffff == -0x1 (0xffff) +char 0x5 | 0xffff == -0x1 (0xffff) +__uchar 0x5 | 0xff == 0xff (0xff) +__longlong 0x5 | 0xffff == -0x1 (0xffff) +__ulonglong 0x5 | 0xffff == -0x1 (0xffff) +int 0x5 << 0x1 == 0xa (0xa) +__uint 0x5 << 0x1 == 0xa (0xa) +char 0x5 << 0x1 == 0xa (0xa) +__uchar 0x5 << 0x1 == 0xa (0xa) +__longlong 0x5 << 0x1 == 0xa (0xa) +__ulonglong 0x5 << 0x1 == 0xa (0xa) +int 0x5 >> 0x1 == 0x2 (0x2) +__uint 0x5 >> 0x1 == 0x2 (0x2) +char 0x5 >> 0x1 == 0x2 (0x2) +__uchar 0x5 >> 0x1 == 0x2 (0x2) +__longlong 0x5 >> 0x1 == 0x2 (0x2) +__ulonglong 0x5 >> 0x1 == 0x2 (0x2) +int 0x5 + 0xffff == 0x4 (0x4) +__uint 0x5 + 0xffff == 0x4 (0x4) +char 0x5 + 0xffff == 0x4 (0x4) +__uchar 0x5 + 0xff == 0x4 (0x4) +__longlong 0x5 + 0xffff == 0x4 (0x4) +__ulonglong 0x5 + 0xffff == 0x4 (0x4) +float 0x5 + 0xffff == 0x4 (0x4) +int 0x5 - 0xffff == 0x6 (0x6) +__uint 0x5 - 0xffff == 0x6 (0x6) +char 0x5 - 0xffff == 0x6 (0x6) +__uchar 0x5 - 0xff == 0x6 (0x6) +__longlong 0x5 - 0xffff == 0x6 (0x6) +__ulonglong 0x5 - 0xffff == 0x6 (0x6) +float 0x5 - 0xffff == 0x6 (0x6) +int 0x5 * 0xffff == -0x5 (0xfffb) +__uint 0x5 * 0xffff == -0x5 (0xfffb) +char 0x5 * 0xffff == -0x5 (0xfffb) +__uchar 0x5 * 0xff == 0xfb (0xfb) +__longlong 0x5 * 0xffff == -0x5 (0xfffb) +__ulonglong 0x5 * 0xffff == -0x5 (0xfffb) +float 0x5 * 0xffff == -0x5 (0xfffb) +int 0x5 < 0xffff == 0x0 (0x0) +__uint 0x5 < 0xffff == 0x1 (0x1) +char 0x5 < 0xffff == 0x0 (0x0) +__uchar 0x5 < 0xff == 0x1 (0x1) +__longlong 0x5 < 0xffff == 0x0 (0x0) +__ulonglong 0x5 < 0xffff == 0x1 (0x1) +float 0x5 < 0xffff == 0x0 (0x0) +int 0x5 > 0xffff == 0x1 (0x1) +__uint 0x5 > 0xffff == 0x0 (0x0) +char 0x5 > 0xffff == 0x1 (0x1) +__uchar 0x5 > 0xff == 0x0 (0x0) +__longlong 0x5 > 0xffff == 0x1 (0x1) +__ulonglong 0x5 > 0xffff == 0x0 (0x0) +float 0x5 > 0xffff == 0x1 (0x1) +int 0x5 <= 0xffff == 0x0 (0x0) +__uint 0x5 <= 0xffff == 0x1 (0x1) +char 0x5 <= 0xffff == 0x0 (0x0) +__uchar 0x5 <= 0xff == 0x1 (0x1) +__longlong 0x5 <= 0xffff == 0x0 (0x0) +__ulonglong 0x5 <= 0xffff == 0x1 (0x1) +float 0x5 <= 0xffff == 0x0 (0x0) +int 0x5 == 0xffff == 0x0 (0x0) +__uint 0x5 == 0xffff == 0x0 (0x0) +char 0x5 == 0xffff == 0x0 (0x0) +__uchar 0x5 == 0xff == 0x0 (0x0) +__longlong 0x5 == 0xffff == 0x0 (0x0) +__ulonglong 0x5 == 0xffff == 0x0 (0x0) +float 0x5 == 0xffff == 0x0 (0x0) +int 0x5 != 0xffff == 0x1 (0x1) +__uint 0x5 != 0xffff == 0x1 (0x1) +char 0x5 != 0xffff == 0x1 (0x1) +__uchar 0x5 != 0xff == 0x1 (0x1) +__longlong 0x5 != 0xffff == 0x1 (0x1) +__ulonglong 0x5 != 0xffff == 0x1 (0x1) +float 0x5 != 0xffff == 0x1 (0x1) +int 0x5 >= 0xffff == 0x1 (0x1) +__uint 0x5 >= 0xffff == 0x0 (0x0) +char 0x5 >= 0xffff == 0x1 (0x1) +__uchar 0x5 >= 0xff == 0x0 (0x0) +__longlong 0x5 >= 0xffff == 0x1 (0x1) +__ulonglong 0x5 >= 0xffff == 0x0 (0x0) +float 0x5 >= 0xffff == 0x1 (0x1) +int 0x5 / 0xffff == -0x5 (0xfffb) +__uint 0x5 / 0xffff == 0x0 (0x0) +char 0x5 / 0xffff == -0x5 (0xfffb) +__uchar 0x5 / 0xff == 0x0 (0x0) +__longlong 0x5 / 0xffff == -0x5 (0xfffb) +__ulonglong 0x5 / 0xffff == 0x0 (0x0) +float 0x5 / 0xffff == -0x5 (0xfffb) +int 0x5 % 0xffff == 0x0 (0x0) +__uint 0x5 % 0xffff == 0x5 (0x5) +char 0x5 % 0xffff == 0x0 (0x0) +__uchar 0x5 % 0xff == 0x5 (0x5) +__longlong 0x5 % 0xffff == 0x0 (0x0) +__ulonglong 0x5 % 0xffff == 0x5 (0x5) +0x5 * 0x1 == 0x5 +0x5 / 0x1 == 0x5 +0x5 % 0x1 == 0x0 +int 0x5 ^ 0x1 == 0x4 (0x4) +__uint 0x5 ^ 0x1 == 0x4 (0x4) +char 0x5 ^ 0x1 == 0x4 (0x4) +__uchar 0x5 ^ 0x1 == 0x4 (0x4) +__longlong 0x5 ^ 0x1 == 0x4 (0x4) +__ulonglong 0x5 ^ 0x1 == 0x4 (0x4) +int 0x5 && 0x1 == 0x1 (0x1) +__uint 0x5 && 0x1 == 0x1 (0x1) +char 0x5 && 0x1 == 0x1 (0x1) +__uchar 0x5 && 0x1 == 0x1 (0x1) +__longlong 0x5 && 0x1 == 0x1 (0x1) +__ulonglong 0x5 && 0x1 == 0x1 (0x1) +int 0x5 || 0x1 == 0x1 (0x1) +__uint 0x5 || 0x1 == 0x1 (0x1) +char 0x5 || 0x1 == 0x1 (0x1) +__uchar 0x5 || 0x1 == 0x1 (0x1) +__longlong 0x5 || 0x1 == 0x1 (0x1) +__ulonglong 0x5 || 0x1 == 0x1 (0x1) +int 0x5 & 0x1 == 0x1 (0x1) +__uint 0x5 & 0x1 == 0x1 (0x1) +char 0x5 & 0x1 == 0x1 (0x1) +__uchar 0x5 & 0x1 == 0x1 (0x1) +__longlong 0x5 & 0x1 == 0x1 (0x1) +__ulonglong 0x5 & 0x1 == 0x1 (0x1) +int 0x5 | 0x1 == 0x5 (0x5) +__uint 0x5 | 0x1 == 0x5 (0x5) +char 0x5 | 0x1 == 0x5 (0x5) +__uchar 0x5 | 0x1 == 0x5 (0x5) +__longlong 0x5 | 0x1 == 0x5 (0x5) +__ulonglong 0x5 | 0x1 == 0x5 (0x5) +int 0x5 << 0x2 == 0x14 (0x14) +__uint 0x5 << 0x2 == 0x14 (0x14) +char 0x5 << 0x2 == 0x14 (0x14) +__uchar 0x5 << 0x2 == 0x14 (0x14) +__longlong 0x5 << 0x2 == 0x14 (0x14) +__ulonglong 0x5 << 0x2 == 0x14 (0x14) +int 0x5 >> 0x2 == 0x1 (0x1) +__uint 0x5 >> 0x2 == 0x1 (0x1) +char 0x5 >> 0x2 == 0x1 (0x1) +__uchar 0x5 >> 0x2 == 0x1 (0x1) +__longlong 0x5 >> 0x2 == 0x1 (0x1) +__ulonglong 0x5 >> 0x2 == 0x1 (0x1) +int 0x5 + 0x1 == 0x6 (0x6) +__uint 0x5 + 0x1 == 0x6 (0x6) +char 0x5 + 0x1 == 0x6 (0x6) +__uchar 0x5 + 0x1 == 0x6 (0x6) +__longlong 0x5 + 0x1 == 0x6 (0x6) +__ulonglong 0x5 + 0x1 == 0x6 (0x6) +float 0x5 + 0x1 == 0x6 (0x6) +int 0x5 - 0x1 == 0x4 (0x4) +__uint 0x5 - 0x1 == 0x4 (0x4) +char 0x5 - 0x1 == 0x4 (0x4) +__uchar 0x5 - 0x1 == 0x4 (0x4) +__longlong 0x5 - 0x1 == 0x4 (0x4) +__ulonglong 0x5 - 0x1 == 0x4 (0x4) +float 0x5 - 0x1 == 0x4 (0x4) +int 0x5 * 0x1 == 0x5 (0x5) +__uint 0x5 * 0x1 == 0x5 (0x5) +char 0x5 * 0x1 == 0x5 (0x5) +__uchar 0x5 * 0x1 == 0x5 (0x5) +__longlong 0x5 * 0x1 == 0x5 (0x5) +__ulonglong 0x5 * 0x1 == 0x5 (0x5) +float 0x5 * 0x1 == 0x5 (0x5) +int 0x5 < 0x1 == 0x0 (0x0) +__uint 0x5 < 0x1 == 0x0 (0x0) +char 0x5 < 0x1 == 0x0 (0x0) +__uchar 0x5 < 0x1 == 0x0 (0x0) +__longlong 0x5 < 0x1 == 0x0 (0x0) +__ulonglong 0x5 < 0x1 == 0x0 (0x0) +float 0x5 < 0x1 == 0x0 (0x0) +int 0x5 > 0x1 == 0x1 (0x1) +__uint 0x5 > 0x1 == 0x1 (0x1) +char 0x5 > 0x1 == 0x1 (0x1) +__uchar 0x5 > 0x1 == 0x1 (0x1) +__longlong 0x5 > 0x1 == 0x1 (0x1) +__ulonglong 0x5 > 0x1 == 0x1 (0x1) +float 0x5 > 0x1 == 0x1 (0x1) +int 0x5 <= 0x1 == 0x0 (0x0) +__uint 0x5 <= 0x1 == 0x0 (0x0) +char 0x5 <= 0x1 == 0x0 (0x0) +__uchar 0x5 <= 0x1 == 0x0 (0x0) +__longlong 0x5 <= 0x1 == 0x0 (0x0) +__ulonglong 0x5 <= 0x1 == 0x0 (0x0) +float 0x5 <= 0x1 == 0x0 (0x0) +int 0x5 == 0x1 == 0x0 (0x0) +__uint 0x5 == 0x1 == 0x0 (0x0) +char 0x5 == 0x1 == 0x0 (0x0) +__uchar 0x5 == 0x1 == 0x0 (0x0) +__longlong 0x5 == 0x1 == 0x0 (0x0) +__ulonglong 0x5 == 0x1 == 0x0 (0x0) +float 0x5 == 0x1 == 0x0 (0x0) +int 0x5 != 0x1 == 0x1 (0x1) +__uint 0x5 != 0x1 == 0x1 (0x1) +char 0x5 != 0x1 == 0x1 (0x1) +__uchar 0x5 != 0x1 == 0x1 (0x1) +__longlong 0x5 != 0x1 == 0x1 (0x1) +__ulonglong 0x5 != 0x1 == 0x1 (0x1) +float 0x5 != 0x1 == 0x1 (0x1) +int 0x5 >= 0x1 == 0x1 (0x1) +__uint 0x5 >= 0x1 == 0x1 (0x1) +char 0x5 >= 0x1 == 0x1 (0x1) +__uchar 0x5 >= 0x1 == 0x1 (0x1) +__longlong 0x5 >= 0x1 == 0x1 (0x1) +__ulonglong 0x5 >= 0x1 == 0x1 (0x1) +float 0x5 >= 0x1 == 0x1 (0x1) +int 0x5 / 0x1 == 0x5 (0x5) +__uint 0x5 / 0x1 == 0x5 (0x5) +char 0x5 / 0x1 == 0x5 (0x5) +__uchar 0x5 / 0x1 == 0x5 (0x5) +__longlong 0x5 / 0x1 == 0x5 (0x5) +__ulonglong 0x5 / 0x1 == 0x5 (0x5) +float 0x5 / 0x1 == 0x5 (0x5) +int 0x5 % 0x1 == 0x0 (0x0) +__uint 0x5 % 0x1 == 0x0 (0x0) +char 0x5 % 0x1 == 0x0 (0x0) +__uchar 0x5 % 0x1 == 0x0 (0x0) +__longlong 0x5 % 0x1 == 0x0 (0x0) +__ulonglong 0x5 % 0x1 == 0x0 (0x0) +0x5 * 0x2 == 0xa +0x5 / 0x2 == 0x2 +0x5 % 0x2 == 0x1 +int 0x5 ^ 0x2 == 0x7 (0x7) +__uint 0x5 ^ 0x2 == 0x7 (0x7) +char 0x5 ^ 0x2 == 0x7 (0x7) +__uchar 0x5 ^ 0x2 == 0x7 (0x7) +__longlong 0x5 ^ 0x2 == 0x7 (0x7) +__ulonglong 0x5 ^ 0x2 == 0x7 (0x7) +int 0x5 && 0x2 == 0x1 (0x1) +__uint 0x5 && 0x2 == 0x1 (0x1) +char 0x5 && 0x2 == 0x1 (0x1) +__uchar 0x5 && 0x2 == 0x1 (0x1) +__longlong 0x5 && 0x2 == 0x1 (0x1) +__ulonglong 0x5 && 0x2 == 0x1 (0x1) +int 0x5 || 0x2 == 0x1 (0x1) +__uint 0x5 || 0x2 == 0x1 (0x1) +char 0x5 || 0x2 == 0x1 (0x1) +__uchar 0x5 || 0x2 == 0x1 (0x1) +__longlong 0x5 || 0x2 == 0x1 (0x1) +__ulonglong 0x5 || 0x2 == 0x1 (0x1) +int 0x5 & 0x2 == 0x0 (0x0) +__uint 0x5 & 0x2 == 0x0 (0x0) +char 0x5 & 0x2 == 0x0 (0x0) +__uchar 0x5 & 0x2 == 0x0 (0x0) +__longlong 0x5 & 0x2 == 0x0 (0x0) +__ulonglong 0x5 & 0x2 == 0x0 (0x0) +int 0x5 | 0x2 == 0x7 (0x7) +__uint 0x5 | 0x2 == 0x7 (0x7) +char 0x5 | 0x2 == 0x7 (0x7) +__uchar 0x5 | 0x2 == 0x7 (0x7) +__longlong 0x5 | 0x2 == 0x7 (0x7) +__ulonglong 0x5 | 0x2 == 0x7 (0x7) +int 0x5 << 0x3 == 0x28 (0x28) +__uint 0x5 << 0x3 == 0x28 (0x28) +char 0x5 << 0x3 == 0x28 (0x28) +__uchar 0x5 << 0x3 == 0x28 (0x28) +__longlong 0x5 << 0x3 == 0x28 (0x28) +__ulonglong 0x5 << 0x3 == 0x28 (0x28) +int 0x5 >> 0x3 == 0x0 (0x0) +__uint 0x5 >> 0x3 == 0x0 (0x0) +char 0x5 >> 0x3 == 0x0 (0x0) +__uchar 0x5 >> 0x3 == 0x0 (0x0) +__longlong 0x5 >> 0x3 == 0x0 (0x0) +__ulonglong 0x5 >> 0x3 == 0x0 (0x0) +int 0x5 + 0x2 == 0x7 (0x7) +__uint 0x5 + 0x2 == 0x7 (0x7) +char 0x5 + 0x2 == 0x7 (0x7) +__uchar 0x5 + 0x2 == 0x7 (0x7) +__longlong 0x5 + 0x2 == 0x7 (0x7) +__ulonglong 0x5 + 0x2 == 0x7 (0x7) +float 0x5 + 0x2 == 0x7 (0x7) +int 0x5 - 0x2 == 0x3 (0x3) +__uint 0x5 - 0x2 == 0x3 (0x3) +char 0x5 - 0x2 == 0x3 (0x3) +__uchar 0x5 - 0x2 == 0x3 (0x3) +__longlong 0x5 - 0x2 == 0x3 (0x3) +__ulonglong 0x5 - 0x2 == 0x3 (0x3) +float 0x5 - 0x2 == 0x3 (0x3) +int 0x5 * 0x2 == 0xa (0xa) +__uint 0x5 * 0x2 == 0xa (0xa) +char 0x5 * 0x2 == 0xa (0xa) +__uchar 0x5 * 0x2 == 0xa (0xa) +__longlong 0x5 * 0x2 == 0xa (0xa) +__ulonglong 0x5 * 0x2 == 0xa (0xa) +float 0x5 * 0x2 == 0xa (0xa) +int 0x5 < 0x2 == 0x0 (0x0) +__uint 0x5 < 0x2 == 0x0 (0x0) +char 0x5 < 0x2 == 0x0 (0x0) +__uchar 0x5 < 0x2 == 0x0 (0x0) +__longlong 0x5 < 0x2 == 0x0 (0x0) +__ulonglong 0x5 < 0x2 == 0x0 (0x0) +float 0x5 < 0x2 == 0x0 (0x0) +int 0x5 > 0x2 == 0x1 (0x1) +__uint 0x5 > 0x2 == 0x1 (0x1) +char 0x5 > 0x2 == 0x1 (0x1) +__uchar 0x5 > 0x2 == 0x1 (0x1) +__longlong 0x5 > 0x2 == 0x1 (0x1) +__ulonglong 0x5 > 0x2 == 0x1 (0x1) +float 0x5 > 0x2 == 0x1 (0x1) +int 0x5 <= 0x2 == 0x0 (0x0) +__uint 0x5 <= 0x2 == 0x0 (0x0) +char 0x5 <= 0x2 == 0x0 (0x0) +__uchar 0x5 <= 0x2 == 0x0 (0x0) +__longlong 0x5 <= 0x2 == 0x0 (0x0) +__ulonglong 0x5 <= 0x2 == 0x0 (0x0) +float 0x5 <= 0x2 == 0x0 (0x0) +int 0x5 == 0x2 == 0x0 (0x0) +__uint 0x5 == 0x2 == 0x0 (0x0) +char 0x5 == 0x2 == 0x0 (0x0) +__uchar 0x5 == 0x2 == 0x0 (0x0) +__longlong 0x5 == 0x2 == 0x0 (0x0) +__ulonglong 0x5 == 0x2 == 0x0 (0x0) +float 0x5 == 0x2 == 0x0 (0x0) +int 0x5 != 0x2 == 0x1 (0x1) +__uint 0x5 != 0x2 == 0x1 (0x1) +char 0x5 != 0x2 == 0x1 (0x1) +__uchar 0x5 != 0x2 == 0x1 (0x1) +__longlong 0x5 != 0x2 == 0x1 (0x1) +__ulonglong 0x5 != 0x2 == 0x1 (0x1) +float 0x5 != 0x2 == 0x1 (0x1) +int 0x5 >= 0x2 == 0x1 (0x1) +__uint 0x5 >= 0x2 == 0x1 (0x1) +char 0x5 >= 0x2 == 0x1 (0x1) +__uchar 0x5 >= 0x2 == 0x1 (0x1) +__longlong 0x5 >= 0x2 == 0x1 (0x1) +__ulonglong 0x5 >= 0x2 == 0x1 (0x1) +float 0x5 >= 0x2 == 0x1 (0x1) +int 0x5 / 0x2 == 0x2 (0x2) +__uint 0x5 / 0x2 == 0x2 (0x2) +char 0x5 / 0x2 == 0x2 (0x2) +__uchar 0x5 / 0x2 == 0x2 (0x2) +__longlong 0x5 / 0x2 == 0x2 (0x2) +__ulonglong 0x5 / 0x2 == 0x2 (0x2) +float 0x5 / 0x2 == 0x2 (0x2) +int 0x5 % 0x2 == 0x1 (0x1) +__uint 0x5 % 0x2 == 0x1 (0x1) +char 0x5 % 0x2 == 0x1 (0x1) +__uchar 0x5 % 0x2 == 0x1 (0x1) +__longlong 0x5 % 0x2 == 0x1 (0x1) +__ulonglong 0x5 % 0x2 == 0x1 (0x1) +0x5 * 0xfffe == -0xa +0x5 / 0xfffe == -0x2 +0x5 % 0xfffe == 0x1 +int 0x5 ^ 0xfffe == -0x5 (0xfffb) +__uint 0x5 ^ 0xfffe == -0x5 (0xfffb) +char 0x5 ^ 0xfffe == -0x5 (0xfffb) +__uchar 0x5 ^ 0xfe == 0xfb (0xfb) +__longlong 0x5 ^ 0xfffe == -0x5 (0xfffb) +__ulonglong 0x5 ^ 0xfffe == -0x5 (0xfffb) +int 0x5 && 0xfffe == 0x1 (0x1) +__uint 0x5 && 0xfffe == 0x1 (0x1) +char 0x5 && 0xfffe == 0x1 (0x1) +__uchar 0x5 && 0xfe == 0x1 (0x1) +__longlong 0x5 && 0xfffe == 0x1 (0x1) +__ulonglong 0x5 && 0xfffe == 0x1 (0x1) +int 0x5 || 0xfffe == 0x1 (0x1) +__uint 0x5 || 0xfffe == 0x1 (0x1) +char 0x5 || 0xfffe == 0x1 (0x1) +__uchar 0x5 || 0xfe == 0x1 (0x1) +__longlong 0x5 || 0xfffe == 0x1 (0x1) +__ulonglong 0x5 || 0xfffe == 0x1 (0x1) +int 0x5 & 0xfffe == 0x4 (0x4) +__uint 0x5 & 0xfffe == 0x4 (0x4) +char 0x5 & 0xfffe == 0x4 (0x4) +__uchar 0x5 & 0xfe == 0x4 (0x4) +__longlong 0x5 & 0xfffe == 0x4 (0x4) +__ulonglong 0x5 & 0xfffe == 0x4 (0x4) +int 0x5 | 0xfffe == -0x1 (0xffff) +__uint 0x5 | 0xfffe == -0x1 (0xffff) +char 0x5 | 0xfffe == -0x1 (0xffff) +__uchar 0x5 | 0xfe == 0xff (0xff) +__longlong 0x5 | 0xfffe == -0x1 (0xffff) +__ulonglong 0x5 | 0xfffe == -0x1 (0xffff) +int 0x5 << 0x4 == 0x50 (0x50) +__uint 0x5 << 0x4 == 0x50 (0x50) +char 0x5 << 0x4 == 0x50 (0x50) +__uchar 0x5 << 0x4 == 0x50 (0x50) +__longlong 0x5 << 0x4 == 0x50 (0x50) +__ulonglong 0x5 << 0x4 == 0x50 (0x50) +int 0x5 >> 0x4 == 0x0 (0x0) +__uint 0x5 >> 0x4 == 0x0 (0x0) +char 0x5 >> 0x4 == 0x0 (0x0) +__uchar 0x5 >> 0x4 == 0x0 (0x0) +__longlong 0x5 >> 0x4 == 0x0 (0x0) +__ulonglong 0x5 >> 0x4 == 0x0 (0x0) +int 0x5 + 0xfffe == 0x3 (0x3) +__uint 0x5 + 0xfffe == 0x3 (0x3) +char 0x5 + 0xfffe == 0x3 (0x3) +__uchar 0x5 + 0xfe == 0x3 (0x3) +__longlong 0x5 + 0xfffe == 0x3 (0x3) +__ulonglong 0x5 + 0xfffe == 0x3 (0x3) +float 0x5 + 0xfffe == 0x3 (0x3) +int 0x5 - 0xfffe == 0x7 (0x7) +__uint 0x5 - 0xfffe == 0x7 (0x7) +char 0x5 - 0xfffe == 0x7 (0x7) +__uchar 0x5 - 0xfe == 0x7 (0x7) +__longlong 0x5 - 0xfffe == 0x7 (0x7) +__ulonglong 0x5 - 0xfffe == 0x7 (0x7) +float 0x5 - 0xfffe == 0x7 (0x7) +int 0x5 * 0xfffe == -0xa (0xfff6) +__uint 0x5 * 0xfffe == -0xa (0xfff6) +char 0x5 * 0xfffe == -0xa (0xfff6) +__uchar 0x5 * 0xfe == 0xf6 (0xf6) +__longlong 0x5 * 0xfffe == -0xa (0xfff6) +__ulonglong 0x5 * 0xfffe == -0xa (0xfff6) +float 0x5 * 0xfffe == -0xa (0xfff6) +int 0x5 < 0xfffe == 0x0 (0x0) +__uint 0x5 < 0xfffe == 0x1 (0x1) +char 0x5 < 0xfffe == 0x0 (0x0) +__uchar 0x5 < 0xfe == 0x1 (0x1) +__longlong 0x5 < 0xfffe == 0x0 (0x0) +__ulonglong 0x5 < 0xfffe == 0x1 (0x1) +float 0x5 < 0xfffe == 0x0 (0x0) +int 0x5 > 0xfffe == 0x1 (0x1) +__uint 0x5 > 0xfffe == 0x0 (0x0) +char 0x5 > 0xfffe == 0x1 (0x1) +__uchar 0x5 > 0xfe == 0x0 (0x0) +__longlong 0x5 > 0xfffe == 0x1 (0x1) +__ulonglong 0x5 > 0xfffe == 0x0 (0x0) +float 0x5 > 0xfffe == 0x1 (0x1) +int 0x5 <= 0xfffe == 0x0 (0x0) +__uint 0x5 <= 0xfffe == 0x1 (0x1) +char 0x5 <= 0xfffe == 0x0 (0x0) +__uchar 0x5 <= 0xfe == 0x1 (0x1) +__longlong 0x5 <= 0xfffe == 0x0 (0x0) +__ulonglong 0x5 <= 0xfffe == 0x1 (0x1) +float 0x5 <= 0xfffe == 0x0 (0x0) +int 0x5 == 0xfffe == 0x0 (0x0) +__uint 0x5 == 0xfffe == 0x0 (0x0) +char 0x5 == 0xfffe == 0x0 (0x0) +__uchar 0x5 == 0xfe == 0x0 (0x0) +__longlong 0x5 == 0xfffe == 0x0 (0x0) +__ulonglong 0x5 == 0xfffe == 0x0 (0x0) +float 0x5 == 0xfffe == 0x0 (0x0) +int 0x5 != 0xfffe == 0x1 (0x1) +__uint 0x5 != 0xfffe == 0x1 (0x1) +char 0x5 != 0xfffe == 0x1 (0x1) +__uchar 0x5 != 0xfe == 0x1 (0x1) +__longlong 0x5 != 0xfffe == 0x1 (0x1) +__ulonglong 0x5 != 0xfffe == 0x1 (0x1) +float 0x5 != 0xfffe == 0x1 (0x1) +int 0x5 >= 0xfffe == 0x1 (0x1) +__uint 0x5 >= 0xfffe == 0x0 (0x0) +char 0x5 >= 0xfffe == 0x1 (0x1) +__uchar 0x5 >= 0xfe == 0x0 (0x0) +__longlong 0x5 >= 0xfffe == 0x1 (0x1) +__ulonglong 0x5 >= 0xfffe == 0x0 (0x0) +float 0x5 >= 0xfffe == 0x1 (0x1) +int 0x5 / 0xfffe == -0x2 (0xfffe) +__uint 0x5 / 0xfffe == 0x0 (0x0) +char 0x5 / 0xfffe == -0x2 (0xfffe) +__uchar 0x5 / 0xfe == 0x0 (0x0) +__longlong 0x5 / 0xfffe == -0x2 (0xfffe) +__ulonglong 0x5 / 0xfffe == 0x0 (0x0) +float 0x5 / 0xfffe == -0x2 (0xfffe) +int 0x5 % 0xfffe == 0x1 (0x1) +__uint 0x5 % 0xfffe == 0x5 (0x5) +char 0x5 % 0xfffe == 0x1 (0x1) +__uchar 0x5 % 0xfe == 0x5 (0x5) +__longlong 0x5 % 0xfffe == 0x1 (0x1) +__ulonglong 0x5 % 0xfffe == 0x5 (0x5) +0x5 * 0x4 == 0x14 +0x5 / 0x4 == 0x1 +0x5 % 0x4 == 0x1 +int 0x5 ^ 0x4 == 0x1 (0x1) +__uint 0x5 ^ 0x4 == 0x1 (0x1) +char 0x5 ^ 0x4 == 0x1 (0x1) +__uchar 0x5 ^ 0x4 == 0x1 (0x1) +__longlong 0x5 ^ 0x4 == 0x1 (0x1) +__ulonglong 0x5 ^ 0x4 == 0x1 (0x1) +int 0x5 && 0x4 == 0x1 (0x1) +__uint 0x5 && 0x4 == 0x1 (0x1) +char 0x5 && 0x4 == 0x1 (0x1) +__uchar 0x5 && 0x4 == 0x1 (0x1) +__longlong 0x5 && 0x4 == 0x1 (0x1) +__ulonglong 0x5 && 0x4 == 0x1 (0x1) +int 0x5 || 0x4 == 0x1 (0x1) +__uint 0x5 || 0x4 == 0x1 (0x1) +char 0x5 || 0x4 == 0x1 (0x1) +__uchar 0x5 || 0x4 == 0x1 (0x1) +__longlong 0x5 || 0x4 == 0x1 (0x1) +__ulonglong 0x5 || 0x4 == 0x1 (0x1) +int 0x5 & 0x4 == 0x4 (0x4) +__uint 0x5 & 0x4 == 0x4 (0x4) +char 0x5 & 0x4 == 0x4 (0x4) +__uchar 0x5 & 0x4 == 0x4 (0x4) +__longlong 0x5 & 0x4 == 0x4 (0x4) +__ulonglong 0x5 & 0x4 == 0x4 (0x4) +int 0x5 | 0x4 == 0x5 (0x5) +__uint 0x5 | 0x4 == 0x5 (0x5) +char 0x5 | 0x4 == 0x5 (0x5) +__uchar 0x5 | 0x4 == 0x5 (0x5) +__longlong 0x5 | 0x4 == 0x5 (0x5) +__ulonglong 0x5 | 0x4 == 0x5 (0x5) +int 0x5 << 0x5 == 0xa0 (0xa0) +__uint 0x5 << 0x5 == 0xa0 (0xa0) +char 0x5 << 0x5 == -0x60 (0xffa0) +__uchar 0x5 << 0x5 == 0xa0 (0xa0) +__longlong 0x5 << 0x5 == 0xa0 (0xa0) +__ulonglong 0x5 << 0x5 == 0xa0 (0xa0) +int 0x5 >> 0x5 == 0x0 (0x0) +__uint 0x5 >> 0x5 == 0x0 (0x0) +char 0x5 >> 0x5 == 0x0 (0x0) +__uchar 0x5 >> 0x5 == 0x0 (0x0) +__longlong 0x5 >> 0x5 == 0x0 (0x0) +__ulonglong 0x5 >> 0x5 == 0x0 (0x0) +int 0x5 + 0x4 == 0x9 (0x9) +__uint 0x5 + 0x4 == 0x9 (0x9) +char 0x5 + 0x4 == 0x9 (0x9) +__uchar 0x5 + 0x4 == 0x9 (0x9) +__longlong 0x5 + 0x4 == 0x9 (0x9) +__ulonglong 0x5 + 0x4 == 0x9 (0x9) +float 0x5 + 0x4 == 0x9 (0x9) +int 0x5 - 0x4 == 0x1 (0x1) +__uint 0x5 - 0x4 == 0x1 (0x1) +char 0x5 - 0x4 == 0x1 (0x1) +__uchar 0x5 - 0x4 == 0x1 (0x1) +__longlong 0x5 - 0x4 == 0x1 (0x1) +__ulonglong 0x5 - 0x4 == 0x1 (0x1) +float 0x5 - 0x4 == 0x1 (0x1) +int 0x5 * 0x4 == 0x14 (0x14) +__uint 0x5 * 0x4 == 0x14 (0x14) +char 0x5 * 0x4 == 0x14 (0x14) +__uchar 0x5 * 0x4 == 0x14 (0x14) +__longlong 0x5 * 0x4 == 0x14 (0x14) +__ulonglong 0x5 * 0x4 == 0x14 (0x14) +float 0x5 * 0x4 == 0x14 (0x14) +int 0x5 < 0x4 == 0x0 (0x0) +__uint 0x5 < 0x4 == 0x0 (0x0) +char 0x5 < 0x4 == 0x0 (0x0) +__uchar 0x5 < 0x4 == 0x0 (0x0) +__longlong 0x5 < 0x4 == 0x0 (0x0) +__ulonglong 0x5 < 0x4 == 0x0 (0x0) +float 0x5 < 0x4 == 0x0 (0x0) +int 0x5 > 0x4 == 0x1 (0x1) +__uint 0x5 > 0x4 == 0x1 (0x1) +char 0x5 > 0x4 == 0x1 (0x1) +__uchar 0x5 > 0x4 == 0x1 (0x1) +__longlong 0x5 > 0x4 == 0x1 (0x1) +__ulonglong 0x5 > 0x4 == 0x1 (0x1) +float 0x5 > 0x4 == 0x1 (0x1) +int 0x5 <= 0x4 == 0x0 (0x0) +__uint 0x5 <= 0x4 == 0x0 (0x0) +char 0x5 <= 0x4 == 0x0 (0x0) +__uchar 0x5 <= 0x4 == 0x0 (0x0) +__longlong 0x5 <= 0x4 == 0x0 (0x0) +__ulonglong 0x5 <= 0x4 == 0x0 (0x0) +float 0x5 <= 0x4 == 0x0 (0x0) +int 0x5 == 0x4 == 0x0 (0x0) +__uint 0x5 == 0x4 == 0x0 (0x0) +char 0x5 == 0x4 == 0x0 (0x0) +__uchar 0x5 == 0x4 == 0x0 (0x0) +__longlong 0x5 == 0x4 == 0x0 (0x0) +__ulonglong 0x5 == 0x4 == 0x0 (0x0) +float 0x5 == 0x4 == 0x0 (0x0) +int 0x5 != 0x4 == 0x1 (0x1) +__uint 0x5 != 0x4 == 0x1 (0x1) +char 0x5 != 0x4 == 0x1 (0x1) +__uchar 0x5 != 0x4 == 0x1 (0x1) +__longlong 0x5 != 0x4 == 0x1 (0x1) +__ulonglong 0x5 != 0x4 == 0x1 (0x1) +float 0x5 != 0x4 == 0x1 (0x1) +int 0x5 >= 0x4 == 0x1 (0x1) +__uint 0x5 >= 0x4 == 0x1 (0x1) +char 0x5 >= 0x4 == 0x1 (0x1) +__uchar 0x5 >= 0x4 == 0x1 (0x1) +__longlong 0x5 >= 0x4 == 0x1 (0x1) +__ulonglong 0x5 >= 0x4 == 0x1 (0x1) +float 0x5 >= 0x4 == 0x1 (0x1) +int 0x5 / 0x4 == 0x1 (0x1) +__uint 0x5 / 0x4 == 0x1 (0x1) +char 0x5 / 0x4 == 0x1 (0x1) +__uchar 0x5 / 0x4 == 0x1 (0x1) +__longlong 0x5 / 0x4 == 0x1 (0x1) +__ulonglong 0x5 / 0x4 == 0x1 (0x1) +float 0x5 / 0x4 == 0x1 (0x1) +int 0x5 % 0x4 == 0x1 (0x1) +__uint 0x5 % 0x4 == 0x1 (0x1) +char 0x5 % 0x4 == 0x1 (0x1) +__uchar 0x5 % 0x4 == 0x1 (0x1) +__longlong 0x5 % 0x4 == 0x1 (0x1) +__ulonglong 0x5 % 0x4 == 0x1 (0x1) +0x5 * 0xfffc == -0x14 +0x5 / 0xfffc == -0x1 +0x5 % 0xfffc == 0x1 +int 0x5 ^ 0xfffc == -0x7 (0xfff9) +__uint 0x5 ^ 0xfffc == -0x7 (0xfff9) +char 0x5 ^ 0xfffc == -0x7 (0xfff9) +__uchar 0x5 ^ 0xfc == 0xf9 (0xf9) +__longlong 0x5 ^ 0xfffc == -0x7 (0xfff9) +__ulonglong 0x5 ^ 0xfffc == -0x7 (0xfff9) +int 0x5 && 0xfffc == 0x1 (0x1) +__uint 0x5 && 0xfffc == 0x1 (0x1) +char 0x5 && 0xfffc == 0x1 (0x1) +__uchar 0x5 && 0xfc == 0x1 (0x1) +__longlong 0x5 && 0xfffc == 0x1 (0x1) +__ulonglong 0x5 && 0xfffc == 0x1 (0x1) +int 0x5 || 0xfffc == 0x1 (0x1) +__uint 0x5 || 0xfffc == 0x1 (0x1) +char 0x5 || 0xfffc == 0x1 (0x1) +__uchar 0x5 || 0xfc == 0x1 (0x1) +__longlong 0x5 || 0xfffc == 0x1 (0x1) +__ulonglong 0x5 || 0xfffc == 0x1 (0x1) +int 0x5 & 0xfffc == 0x4 (0x4) +__uint 0x5 & 0xfffc == 0x4 (0x4) +char 0x5 & 0xfffc == 0x4 (0x4) +__uchar 0x5 & 0xfc == 0x4 (0x4) +__longlong 0x5 & 0xfffc == 0x4 (0x4) +__ulonglong 0x5 & 0xfffc == 0x4 (0x4) +int 0x5 | 0xfffc == -0x3 (0xfffd) +__uint 0x5 | 0xfffc == -0x3 (0xfffd) +char 0x5 | 0xfffc == -0x3 (0xfffd) +__uchar 0x5 | 0xfc == 0xfd (0xfd) +__longlong 0x5 | 0xfffc == -0x3 (0xfffd) +__ulonglong 0x5 | 0xfffc == -0x3 (0xfffd) +int 0x5 << 0x6 == 0x140 (0x140) +__uint 0x5 << 0x6 == 0x140 (0x140) +char 0x5 << 0x6 == 0x40 (0x40) +__uchar 0x5 << 0x6 == 0x40 (0x40) +__longlong 0x5 << 0x6 == 0x140 (0x140) +__ulonglong 0x5 << 0x6 == 0x140 (0x140) +int 0x5 >> 0x6 == 0x0 (0x0) +__uint 0x5 >> 0x6 == 0x0 (0x0) +char 0x5 >> 0x6 == 0x0 (0x0) +__uchar 0x5 >> 0x6 == 0x0 (0x0) +__longlong 0x5 >> 0x6 == 0x0 (0x0) +__ulonglong 0x5 >> 0x6 == 0x0 (0x0) +int 0x5 + 0xfffc == 0x1 (0x1) +__uint 0x5 + 0xfffc == 0x1 (0x1) +char 0x5 + 0xfffc == 0x1 (0x1) +__uchar 0x5 + 0xfc == 0x1 (0x1) +__longlong 0x5 + 0xfffc == 0x1 (0x1) +__ulonglong 0x5 + 0xfffc == 0x1 (0x1) +float 0x5 + 0xfffc == 0x1 (0x1) +int 0x5 - 0xfffc == 0x9 (0x9) +__uint 0x5 - 0xfffc == 0x9 (0x9) +char 0x5 - 0xfffc == 0x9 (0x9) +__uchar 0x5 - 0xfc == 0x9 (0x9) +__longlong 0x5 - 0xfffc == 0x9 (0x9) +__ulonglong 0x5 - 0xfffc == 0x9 (0x9) +float 0x5 - 0xfffc == 0x9 (0x9) +int 0x5 * 0xfffc == -0x14 (0xffec) +__uint 0x5 * 0xfffc == -0x14 (0xffec) +char 0x5 * 0xfffc == -0x14 (0xffec) +__uchar 0x5 * 0xfc == 0xec (0xec) +__longlong 0x5 * 0xfffc == -0x14 (0xffec) +__ulonglong 0x5 * 0xfffc == -0x14 (0xffec) +float 0x5 * 0xfffc == -0x14 (0xffec) +int 0x5 < 0xfffc == 0x0 (0x0) +__uint 0x5 < 0xfffc == 0x1 (0x1) +char 0x5 < 0xfffc == 0x0 (0x0) +__uchar 0x5 < 0xfc == 0x1 (0x1) +__longlong 0x5 < 0xfffc == 0x0 (0x0) +__ulonglong 0x5 < 0xfffc == 0x1 (0x1) +float 0x5 < 0xfffc == 0x0 (0x0) +int 0x5 > 0xfffc == 0x1 (0x1) +__uint 0x5 > 0xfffc == 0x0 (0x0) +char 0x5 > 0xfffc == 0x1 (0x1) +__uchar 0x5 > 0xfc == 0x0 (0x0) +__longlong 0x5 > 0xfffc == 0x1 (0x1) +__ulonglong 0x5 > 0xfffc == 0x0 (0x0) +float 0x5 > 0xfffc == 0x1 (0x1) +int 0x5 <= 0xfffc == 0x0 (0x0) +__uint 0x5 <= 0xfffc == 0x1 (0x1) +char 0x5 <= 0xfffc == 0x0 (0x0) +__uchar 0x5 <= 0xfc == 0x1 (0x1) +__longlong 0x5 <= 0xfffc == 0x0 (0x0) +__ulonglong 0x5 <= 0xfffc == 0x1 (0x1) +float 0x5 <= 0xfffc == 0x0 (0x0) +int 0x5 == 0xfffc == 0x0 (0x0) +__uint 0x5 == 0xfffc == 0x0 (0x0) +char 0x5 == 0xfffc == 0x0 (0x0) +__uchar 0x5 == 0xfc == 0x0 (0x0) +__longlong 0x5 == 0xfffc == 0x0 (0x0) +__ulonglong 0x5 == 0xfffc == 0x0 (0x0) +float 0x5 == 0xfffc == 0x0 (0x0) +int 0x5 != 0xfffc == 0x1 (0x1) +__uint 0x5 != 0xfffc == 0x1 (0x1) +char 0x5 != 0xfffc == 0x1 (0x1) +__uchar 0x5 != 0xfc == 0x1 (0x1) +__longlong 0x5 != 0xfffc == 0x1 (0x1) +__ulonglong 0x5 != 0xfffc == 0x1 (0x1) +float 0x5 != 0xfffc == 0x1 (0x1) +int 0x5 >= 0xfffc == 0x1 (0x1) +__uint 0x5 >= 0xfffc == 0x0 (0x0) +char 0x5 >= 0xfffc == 0x1 (0x1) +__uchar 0x5 >= 0xfc == 0x0 (0x0) +__longlong 0x5 >= 0xfffc == 0x1 (0x1) +__ulonglong 0x5 >= 0xfffc == 0x0 (0x0) +float 0x5 >= 0xfffc == 0x1 (0x1) +int 0x5 / 0xfffc == -0x1 (0xffff) +__uint 0x5 / 0xfffc == 0x0 (0x0) +char 0x5 / 0xfffc == -0x1 (0xffff) +__uchar 0x5 / 0xfc == 0x0 (0x0) +__longlong 0x5 / 0xfffc == -0x1 (0xffff) +__ulonglong 0x5 / 0xfffc == 0x0 (0x0) +float 0x5 / 0xfffc == -0x1 (0xffff) +int 0x5 % 0xfffc == 0x1 (0x1) +__uint 0x5 % 0xfffc == 0x5 (0x5) +char 0x5 % 0xfffc == 0x1 (0x1) +__uchar 0x5 % 0xfc == 0x5 (0x5) +__longlong 0x5 % 0xfffc == 0x1 (0x1) +__ulonglong 0x5 % 0xfffc == 0x5 (0x5) +0x5 * 0xa == 0x32 +0x5 / 0xa == 0x0 +0x5 % 0xa == 0x5 +int 0x5 ^ 0xa == 0xf (0xf) +__uint 0x5 ^ 0xa == 0xf (0xf) +char 0x5 ^ 0xa == 0xf (0xf) +__uchar 0x5 ^ 0xa == 0xf (0xf) +__longlong 0x5 ^ 0xa == 0xf (0xf) +__ulonglong 0x5 ^ 0xa == 0xf (0xf) +int 0x5 && 0xa == 0x1 (0x1) +__uint 0x5 && 0xa == 0x1 (0x1) +char 0x5 && 0xa == 0x1 (0x1) +__uchar 0x5 && 0xa == 0x1 (0x1) +__longlong 0x5 && 0xa == 0x1 (0x1) +__ulonglong 0x5 && 0xa == 0x1 (0x1) +int 0x5 || 0xa == 0x1 (0x1) +__uint 0x5 || 0xa == 0x1 (0x1) +char 0x5 || 0xa == 0x1 (0x1) +__uchar 0x5 || 0xa == 0x1 (0x1) +__longlong 0x5 || 0xa == 0x1 (0x1) +__ulonglong 0x5 || 0xa == 0x1 (0x1) +int 0x5 & 0xa == 0x0 (0x0) +__uint 0x5 & 0xa == 0x0 (0x0) +char 0x5 & 0xa == 0x0 (0x0) +__uchar 0x5 & 0xa == 0x0 (0x0) +__longlong 0x5 & 0xa == 0x0 (0x0) +__ulonglong 0x5 & 0xa == 0x0 (0x0) +int 0x5 | 0xa == 0xf (0xf) +__uint 0x5 | 0xa == 0xf (0xf) +char 0x5 | 0xa == 0xf (0xf) +__uchar 0x5 | 0xa == 0xf (0xf) +__longlong 0x5 | 0xa == 0xf (0xf) +__ulonglong 0x5 | 0xa == 0xf (0xf) +int 0x5 << 0x7 == 0x280 (0x280) +__uint 0x5 << 0x7 == 0x280 (0x280) +char 0x5 << 0x7 == -0x80 (0xff80) +__uchar 0x5 << 0x7 == 0x80 (0x80) +__longlong 0x5 << 0x7 == 0x280 (0x280) +__ulonglong 0x5 << 0x7 == 0x280 (0x280) +int 0x5 >> 0x7 == 0x0 (0x0) +__uint 0x5 >> 0x7 == 0x0 (0x0) +char 0x5 >> 0x7 == 0x0 (0x0) +__uchar 0x5 >> 0x7 == 0x0 (0x0) +__longlong 0x5 >> 0x7 == 0x0 (0x0) +__ulonglong 0x5 >> 0x7 == 0x0 (0x0) +int 0x5 + 0xa == 0xf (0xf) +__uint 0x5 + 0xa == 0xf (0xf) +char 0x5 + 0xa == 0xf (0xf) +__uchar 0x5 + 0xa == 0xf (0xf) +__longlong 0x5 + 0xa == 0xf (0xf) +__ulonglong 0x5 + 0xa == 0xf (0xf) +float 0x5 + 0xa == 0xf (0xf) +int 0x5 - 0xa == -0x5 (0xfffb) +__uint 0x5 - 0xa == -0x5 (0xfffb) +char 0x5 - 0xa == -0x5 (0xfffb) +__uchar 0x5 - 0xa == 0xfb (0xfb) +__longlong 0x5 - 0xa == -0x5 (0xfffb) +__ulonglong 0x5 - 0xa == -0x5 (0xfffb) +float 0x5 - 0xa == -0x5 (0xfffb) +int 0x5 * 0xa == 0x32 (0x32) +__uint 0x5 * 0xa == 0x32 (0x32) +char 0x5 * 0xa == 0x32 (0x32) +__uchar 0x5 * 0xa == 0x32 (0x32) +__longlong 0x5 * 0xa == 0x32 (0x32) +__ulonglong 0x5 * 0xa == 0x32 (0x32) +float 0x5 * 0xa == 0x32 (0x32) +int 0x5 < 0xa == 0x1 (0x1) +__uint 0x5 < 0xa == 0x1 (0x1) +char 0x5 < 0xa == 0x1 (0x1) +__uchar 0x5 < 0xa == 0x1 (0x1) +__longlong 0x5 < 0xa == 0x1 (0x1) +__ulonglong 0x5 < 0xa == 0x1 (0x1) +float 0x5 < 0xa == 0x1 (0x1) +int 0x5 > 0xa == 0x0 (0x0) +__uint 0x5 > 0xa == 0x0 (0x0) +char 0x5 > 0xa == 0x0 (0x0) +__uchar 0x5 > 0xa == 0x0 (0x0) +__longlong 0x5 > 0xa == 0x0 (0x0) +__ulonglong 0x5 > 0xa == 0x0 (0x0) +float 0x5 > 0xa == 0x0 (0x0) +int 0x5 <= 0xa == 0x1 (0x1) +__uint 0x5 <= 0xa == 0x1 (0x1) +char 0x5 <= 0xa == 0x1 (0x1) +__uchar 0x5 <= 0xa == 0x1 (0x1) +__longlong 0x5 <= 0xa == 0x1 (0x1) +__ulonglong 0x5 <= 0xa == 0x1 (0x1) +float 0x5 <= 0xa == 0x1 (0x1) +int 0x5 == 0xa == 0x0 (0x0) +__uint 0x5 == 0xa == 0x0 (0x0) +char 0x5 == 0xa == 0x0 (0x0) +__uchar 0x5 == 0xa == 0x0 (0x0) +__longlong 0x5 == 0xa == 0x0 (0x0) +__ulonglong 0x5 == 0xa == 0x0 (0x0) +float 0x5 == 0xa == 0x0 (0x0) +int 0x5 != 0xa == 0x1 (0x1) +__uint 0x5 != 0xa == 0x1 (0x1) +char 0x5 != 0xa == 0x1 (0x1) +__uchar 0x5 != 0xa == 0x1 (0x1) +__longlong 0x5 != 0xa == 0x1 (0x1) +__ulonglong 0x5 != 0xa == 0x1 (0x1) +float 0x5 != 0xa == 0x1 (0x1) +int 0x5 >= 0xa == 0x0 (0x0) +__uint 0x5 >= 0xa == 0x0 (0x0) +char 0x5 >= 0xa == 0x0 (0x0) +__uchar 0x5 >= 0xa == 0x0 (0x0) +__longlong 0x5 >= 0xa == 0x0 (0x0) +__ulonglong 0x5 >= 0xa == 0x0 (0x0) +float 0x5 >= 0xa == 0x0 (0x0) +int 0x5 / 0xa == 0x0 (0x0) +__uint 0x5 / 0xa == 0x0 (0x0) +char 0x5 / 0xa == 0x0 (0x0) +__uchar 0x5 / 0xa == 0x0 (0x0) +__longlong 0x5 / 0xa == 0x0 (0x0) +__ulonglong 0x5 / 0xa == 0x0 (0x0) +float 0x5 / 0xa == 0x0 (0x0) +int 0x5 % 0xa == 0x5 (0x5) +__uint 0x5 % 0xa == 0x5 (0x5) +char 0x5 % 0xa == 0x5 (0x5) +__uchar 0x5 % 0xa == 0x5 (0x5) +__longlong 0x5 % 0xa == 0x5 (0x5) +__ulonglong 0x5 % 0xa == 0x5 (0x5) +0x5 * 0xfff6 == -0x32 +0x5 / 0xfff6 == 0x0 +0x5 % 0xfff6 == 0x5 +int 0x5 ^ 0xfff6 == -0xd (0xfff3) +__uint 0x5 ^ 0xfff6 == -0xd (0xfff3) +char 0x5 ^ 0xfff6 == -0xd (0xfff3) +__uchar 0x5 ^ 0xf6 == 0xf3 (0xf3) +__longlong 0x5 ^ 0xfff6 == -0xd (0xfff3) +__ulonglong 0x5 ^ 0xfff6 == -0xd (0xfff3) +int 0x5 && 0xfff6 == 0x1 (0x1) +__uint 0x5 && 0xfff6 == 0x1 (0x1) +char 0x5 && 0xfff6 == 0x1 (0x1) +__uchar 0x5 && 0xf6 == 0x1 (0x1) +__longlong 0x5 && 0xfff6 == 0x1 (0x1) +__ulonglong 0x5 && 0xfff6 == 0x1 (0x1) +int 0x5 || 0xfff6 == 0x1 (0x1) +__uint 0x5 || 0xfff6 == 0x1 (0x1) +char 0x5 || 0xfff6 == 0x1 (0x1) +__uchar 0x5 || 0xf6 == 0x1 (0x1) +__longlong 0x5 || 0xfff6 == 0x1 (0x1) +__ulonglong 0x5 || 0xfff6 == 0x1 (0x1) +int 0x5 & 0xfff6 == 0x4 (0x4) +__uint 0x5 & 0xfff6 == 0x4 (0x4) +char 0x5 & 0xfff6 == 0x4 (0x4) +__uchar 0x5 & 0xf6 == 0x4 (0x4) +__longlong 0x5 & 0xfff6 == 0x4 (0x4) +__ulonglong 0x5 & 0xfff6 == 0x4 (0x4) +int 0x5 | 0xfff6 == -0x9 (0xfff7) +__uint 0x5 | 0xfff6 == -0x9 (0xfff7) +char 0x5 | 0xfff6 == -0x9 (0xfff7) +__uchar 0x5 | 0xf6 == 0xf7 (0xf7) +__longlong 0x5 | 0xfff6 == -0x9 (0xfff7) +__ulonglong 0x5 | 0xfff6 == -0x9 (0xfff7) +int 0x5 << 0x8 == 0x500 (0x500) +__uint 0x5 << 0x8 == 0x500 (0x500) +char 0x5 << 0x8 == 0x0 (0x0) +__uchar 0x5 << 0x8 == 0x0 (0x0) +__longlong 0x5 << 0x8 == 0x500 (0x500) +__ulonglong 0x5 << 0x8 == 0x500 (0x500) +int 0x5 >> 0x8 == 0x0 (0x0) +__uint 0x5 >> 0x8 == 0x0 (0x0) +char 0x5 >> 0x8 == 0x0 (0x0) +__uchar 0x5 >> 0x8 == 0x0 (0x0) +__longlong 0x5 >> 0x8 == 0x0 (0x0) +__ulonglong 0x5 >> 0x8 == 0x0 (0x0) +int 0x5 + 0xfff6 == -0x5 (0xfffb) +__uint 0x5 + 0xfff6 == -0x5 (0xfffb) +char 0x5 + 0xfff6 == -0x5 (0xfffb) +__uchar 0x5 + 0xf6 == 0xfb (0xfb) +__longlong 0x5 + 0xfff6 == -0x5 (0xfffb) +__ulonglong 0x5 + 0xfff6 == -0x5 (0xfffb) +float 0x5 + 0xfff6 == -0x5 (0xfffb) +int 0x5 - 0xfff6 == 0xf (0xf) +__uint 0x5 - 0xfff6 == 0xf (0xf) +char 0x5 - 0xfff6 == 0xf (0xf) +__uchar 0x5 - 0xf6 == 0xf (0xf) +__longlong 0x5 - 0xfff6 == 0xf (0xf) +__ulonglong 0x5 - 0xfff6 == 0xf (0xf) +float 0x5 - 0xfff6 == 0xf (0xf) +int 0x5 * 0xfff6 == -0x32 (0xffce) +__uint 0x5 * 0xfff6 == -0x32 (0xffce) +char 0x5 * 0xfff6 == -0x32 (0xffce) +__uchar 0x5 * 0xf6 == 0xce (0xce) +__longlong 0x5 * 0xfff6 == -0x32 (0xffce) +__ulonglong 0x5 * 0xfff6 == -0x32 (0xffce) +float 0x5 * 0xfff6 == -0x32 (0xffce) +int 0x5 < 0xfff6 == 0x0 (0x0) +__uint 0x5 < 0xfff6 == 0x1 (0x1) +char 0x5 < 0xfff6 == 0x0 (0x0) +__uchar 0x5 < 0xf6 == 0x1 (0x1) +__longlong 0x5 < 0xfff6 == 0x0 (0x0) +__ulonglong 0x5 < 0xfff6 == 0x1 (0x1) +float 0x5 < 0xfff6 == 0x0 (0x0) +int 0x5 > 0xfff6 == 0x1 (0x1) +__uint 0x5 > 0xfff6 == 0x0 (0x0) +char 0x5 > 0xfff6 == 0x1 (0x1) +__uchar 0x5 > 0xf6 == 0x0 (0x0) +__longlong 0x5 > 0xfff6 == 0x1 (0x1) +__ulonglong 0x5 > 0xfff6 == 0x0 (0x0) +float 0x5 > 0xfff6 == 0x1 (0x1) +int 0x5 <= 0xfff6 == 0x0 (0x0) +__uint 0x5 <= 0xfff6 == 0x1 (0x1) +char 0x5 <= 0xfff6 == 0x0 (0x0) +__uchar 0x5 <= 0xf6 == 0x1 (0x1) +__longlong 0x5 <= 0xfff6 == 0x0 (0x0) +__ulonglong 0x5 <= 0xfff6 == 0x1 (0x1) +float 0x5 <= 0xfff6 == 0x0 (0x0) +int 0x5 == 0xfff6 == 0x0 (0x0) +__uint 0x5 == 0xfff6 == 0x0 (0x0) +char 0x5 == 0xfff6 == 0x0 (0x0) +__uchar 0x5 == 0xf6 == 0x0 (0x0) +__longlong 0x5 == 0xfff6 == 0x0 (0x0) +__ulonglong 0x5 == 0xfff6 == 0x0 (0x0) +float 0x5 == 0xfff6 == 0x0 (0x0) +int 0x5 != 0xfff6 == 0x1 (0x1) +__uint 0x5 != 0xfff6 == 0x1 (0x1) +char 0x5 != 0xfff6 == 0x1 (0x1) +__uchar 0x5 != 0xf6 == 0x1 (0x1) +__longlong 0x5 != 0xfff6 == 0x1 (0x1) +__ulonglong 0x5 != 0xfff6 == 0x1 (0x1) +float 0x5 != 0xfff6 == 0x1 (0x1) +int 0x5 >= 0xfff6 == 0x1 (0x1) +__uint 0x5 >= 0xfff6 == 0x0 (0x0) +char 0x5 >= 0xfff6 == 0x1 (0x1) +__uchar 0x5 >= 0xf6 == 0x0 (0x0) +__longlong 0x5 >= 0xfff6 == 0x1 (0x1) +__ulonglong 0x5 >= 0xfff6 == 0x0 (0x0) +float 0x5 >= 0xfff6 == 0x1 (0x1) +int 0x5 / 0xfff6 == 0x0 (0x0) +__uint 0x5 / 0xfff6 == 0x0 (0x0) +char 0x5 / 0xfff6 == 0x0 (0x0) +__uchar 0x5 / 0xf6 == 0x0 (0x0) +__longlong 0x5 / 0xfff6 == 0x0 (0x0) +__ulonglong 0x5 / 0xfff6 == 0x0 (0x0) +float 0x5 / 0xfff6 == 0x0 (0x0) +int 0x5 % 0xfff6 == 0x5 (0x5) +__uint 0x5 % 0xfff6 == 0x5 (0x5) +char 0x5 % 0xfff6 == 0x5 (0x5) +__uchar 0x5 % 0xf6 == 0x5 (0x5) +__longlong 0x5 % 0xfff6 == 0x5 (0x5) +__ulonglong 0x5 % 0xfff6 == 0x5 (0x5) +0x5 * 0x5 == 0x19 +0x5 / 0x5 == 0x1 +0x5 % 0x5 == 0x0 +int 0x5 ^ 0x5 == 0x0 (0x0) +__uint 0x5 ^ 0x5 == 0x0 (0x0) +char 0x5 ^ 0x5 == 0x0 (0x0) +__uchar 0x5 ^ 0x5 == 0x0 (0x0) +__longlong 0x5 ^ 0x5 == 0x0 (0x0) +__ulonglong 0x5 ^ 0x5 == 0x0 (0x0) +int 0x5 && 0x5 == 0x1 (0x1) +__uint 0x5 && 0x5 == 0x1 (0x1) +char 0x5 && 0x5 == 0x1 (0x1) +__uchar 0x5 && 0x5 == 0x1 (0x1) +__longlong 0x5 && 0x5 == 0x1 (0x1) +__ulonglong 0x5 && 0x5 == 0x1 (0x1) +int 0x5 || 0x5 == 0x1 (0x1) +__uint 0x5 || 0x5 == 0x1 (0x1) +char 0x5 || 0x5 == 0x1 (0x1) +__uchar 0x5 || 0x5 == 0x1 (0x1) +__longlong 0x5 || 0x5 == 0x1 (0x1) +__ulonglong 0x5 || 0x5 == 0x1 (0x1) +int 0x5 & 0x5 == 0x5 (0x5) +__uint 0x5 & 0x5 == 0x5 (0x5) +char 0x5 & 0x5 == 0x5 (0x5) +__uchar 0x5 & 0x5 == 0x5 (0x5) +__longlong 0x5 & 0x5 == 0x5 (0x5) +__ulonglong 0x5 & 0x5 == 0x5 (0x5) +int 0x5 | 0x5 == 0x5 (0x5) +__uint 0x5 | 0x5 == 0x5 (0x5) +char 0x5 | 0x5 == 0x5 (0x5) +__uchar 0x5 | 0x5 == 0x5 (0x5) +__longlong 0x5 | 0x5 == 0x5 (0x5) +__ulonglong 0x5 | 0x5 == 0x5 (0x5) +int 0x5 << 0x9 == 0xa00 (0xa00) +__uint 0x5 << 0x9 == 0xa00 (0xa00) +char 0x5 << 0x9 == 0x0 (0x0) +__uchar 0x5 << 0x9 == 0x0 (0x0) +__longlong 0x5 << 0x9 == 0xa00 (0xa00) +__ulonglong 0x5 << 0x9 == 0xa00 (0xa00) +int 0x5 >> 0x9 == 0x0 (0x0) +__uint 0x5 >> 0x9 == 0x0 (0x0) +char 0x5 >> 0x9 == 0x0 (0x0) +__uchar 0x5 >> 0x9 == 0x0 (0x0) +__longlong 0x5 >> 0x9 == 0x0 (0x0) +__ulonglong 0x5 >> 0x9 == 0x0 (0x0) +int 0x5 + 0x5 == 0xa (0xa) +__uint 0x5 + 0x5 == 0xa (0xa) +char 0x5 + 0x5 == 0xa (0xa) +__uchar 0x5 + 0x5 == 0xa (0xa) +__longlong 0x5 + 0x5 == 0xa (0xa) +__ulonglong 0x5 + 0x5 == 0xa (0xa) +float 0x5 + 0x5 == 0xa (0xa) +int 0x5 - 0x5 == 0x0 (0x0) +__uint 0x5 - 0x5 == 0x0 (0x0) +char 0x5 - 0x5 == 0x0 (0x0) +__uchar 0x5 - 0x5 == 0x0 (0x0) +__longlong 0x5 - 0x5 == 0x0 (0x0) +__ulonglong 0x5 - 0x5 == 0x0 (0x0) +float 0x5 - 0x5 == 0x0 (0x0) +int 0x5 * 0x5 == 0x19 (0x19) +__uint 0x5 * 0x5 == 0x19 (0x19) +char 0x5 * 0x5 == 0x19 (0x19) +__uchar 0x5 * 0x5 == 0x19 (0x19) +__longlong 0x5 * 0x5 == 0x19 (0x19) +__ulonglong 0x5 * 0x5 == 0x19 (0x19) +float 0x5 * 0x5 == 0x19 (0x19) +int 0x5 < 0x5 == 0x0 (0x0) +__uint 0x5 < 0x5 == 0x0 (0x0) +char 0x5 < 0x5 == 0x0 (0x0) +__uchar 0x5 < 0x5 == 0x0 (0x0) +__longlong 0x5 < 0x5 == 0x0 (0x0) +__ulonglong 0x5 < 0x5 == 0x0 (0x0) +float 0x5 < 0x5 == 0x0 (0x0) +int 0x5 > 0x5 == 0x0 (0x0) +__uint 0x5 > 0x5 == 0x0 (0x0) +char 0x5 > 0x5 == 0x0 (0x0) +__uchar 0x5 > 0x5 == 0x0 (0x0) +__longlong 0x5 > 0x5 == 0x0 (0x0) +__ulonglong 0x5 > 0x5 == 0x0 (0x0) +float 0x5 > 0x5 == 0x0 (0x0) +int 0x5 <= 0x5 == 0x1 (0x1) +__uint 0x5 <= 0x5 == 0x1 (0x1) +char 0x5 <= 0x5 == 0x1 (0x1) +__uchar 0x5 <= 0x5 == 0x1 (0x1) +__longlong 0x5 <= 0x5 == 0x1 (0x1) +__ulonglong 0x5 <= 0x5 == 0x1 (0x1) +float 0x5 <= 0x5 == 0x1 (0x1) +int 0x5 == 0x5 == 0x1 (0x1) +__uint 0x5 == 0x5 == 0x1 (0x1) +char 0x5 == 0x5 == 0x1 (0x1) +__uchar 0x5 == 0x5 == 0x1 (0x1) +__longlong 0x5 == 0x5 == 0x1 (0x1) +__ulonglong 0x5 == 0x5 == 0x1 (0x1) +float 0x5 == 0x5 == 0x1 (0x1) +int 0x5 != 0x5 == 0x0 (0x0) +__uint 0x5 != 0x5 == 0x0 (0x0) +char 0x5 != 0x5 == 0x0 (0x0) +__uchar 0x5 != 0x5 == 0x0 (0x0) +__longlong 0x5 != 0x5 == 0x0 (0x0) +__ulonglong 0x5 != 0x5 == 0x0 (0x0) +float 0x5 != 0x5 == 0x0 (0x0) +int 0x5 >= 0x5 == 0x1 (0x1) +__uint 0x5 >= 0x5 == 0x1 (0x1) +char 0x5 >= 0x5 == 0x1 (0x1) +__uchar 0x5 >= 0x5 == 0x1 (0x1) +__longlong 0x5 >= 0x5 == 0x1 (0x1) +__ulonglong 0x5 >= 0x5 == 0x1 (0x1) +float 0x5 >= 0x5 == 0x1 (0x1) +int 0x5 / 0x5 == 0x1 (0x1) +__uint 0x5 / 0x5 == 0x1 (0x1) +char 0x5 / 0x5 == 0x1 (0x1) +__uchar 0x5 / 0x5 == 0x1 (0x1) +__longlong 0x5 / 0x5 == 0x1 (0x1) +__ulonglong 0x5 / 0x5 == 0x1 (0x1) +float 0x5 / 0x5 == 0x1 (0x1) +int 0x5 % 0x5 == 0x0 (0x0) +__uint 0x5 % 0x5 == 0x0 (0x0) +char 0x5 % 0x5 == 0x0 (0x0) +__uchar 0x5 % 0x5 == 0x0 (0x0) +__longlong 0x5 % 0x5 == 0x0 (0x0) +__ulonglong 0x5 % 0x5 == 0x0 (0x0) +0x5 * 0x7 == 0x23 +0x5 / 0x7 == 0x0 +0x5 % 0x7 == 0x5 +int 0x5 ^ 0x7 == 0x2 (0x2) +__uint 0x5 ^ 0x7 == 0x2 (0x2) +char 0x5 ^ 0x7 == 0x2 (0x2) +__uchar 0x5 ^ 0x7 == 0x2 (0x2) +__longlong 0x5 ^ 0x7 == 0x2 (0x2) +__ulonglong 0x5 ^ 0x7 == 0x2 (0x2) +int 0x5 && 0x7 == 0x1 (0x1) +__uint 0x5 && 0x7 == 0x1 (0x1) +char 0x5 && 0x7 == 0x1 (0x1) +__uchar 0x5 && 0x7 == 0x1 (0x1) +__longlong 0x5 && 0x7 == 0x1 (0x1) +__ulonglong 0x5 && 0x7 == 0x1 (0x1) +int 0x5 || 0x7 == 0x1 (0x1) +__uint 0x5 || 0x7 == 0x1 (0x1) +char 0x5 || 0x7 == 0x1 (0x1) +__uchar 0x5 || 0x7 == 0x1 (0x1) +__longlong 0x5 || 0x7 == 0x1 (0x1) +__ulonglong 0x5 || 0x7 == 0x1 (0x1) +int 0x5 & 0x7 == 0x5 (0x5) +__uint 0x5 & 0x7 == 0x5 (0x5) +char 0x5 & 0x7 == 0x5 (0x5) +__uchar 0x5 & 0x7 == 0x5 (0x5) +__longlong 0x5 & 0x7 == 0x5 (0x5) +__ulonglong 0x5 & 0x7 == 0x5 (0x5) +int 0x5 | 0x7 == 0x7 (0x7) +__uint 0x5 | 0x7 == 0x7 (0x7) +char 0x5 | 0x7 == 0x7 (0x7) +__uchar 0x5 | 0x7 == 0x7 (0x7) +__longlong 0x5 | 0x7 == 0x7 (0x7) +__ulonglong 0x5 | 0x7 == 0x7 (0x7) +int 0x5 << 0xa == 0x1400 (0x1400) +__uint 0x5 << 0xa == 0x1400 (0x1400) +char 0x5 << 0xa == 0x0 (0x0) +__uchar 0x5 << 0xa == 0x0 (0x0) +__longlong 0x5 << 0xa == 0x1400 (0x1400) +__ulonglong 0x5 << 0xa == 0x1400 (0x1400) +int 0x5 >> 0xa == 0x0 (0x0) +__uint 0x5 >> 0xa == 0x0 (0x0) +char 0x5 >> 0xa == 0x0 (0x0) +__uchar 0x5 >> 0xa == 0x0 (0x0) +__longlong 0x5 >> 0xa == 0x0 (0x0) +__ulonglong 0x5 >> 0xa == 0x0 (0x0) +int 0x5 + 0x7 == 0xc (0xc) +__uint 0x5 + 0x7 == 0xc (0xc) +char 0x5 + 0x7 == 0xc (0xc) +__uchar 0x5 + 0x7 == 0xc (0xc) +__longlong 0x5 + 0x7 == 0xc (0xc) +__ulonglong 0x5 + 0x7 == 0xc (0xc) +float 0x5 + 0x7 == 0xc (0xc) +int 0x5 - 0x7 == -0x2 (0xfffe) +__uint 0x5 - 0x7 == -0x2 (0xfffe) +char 0x5 - 0x7 == -0x2 (0xfffe) +__uchar 0x5 - 0x7 == 0xfe (0xfe) +__longlong 0x5 - 0x7 == -0x2 (0xfffe) +__ulonglong 0x5 - 0x7 == -0x2 (0xfffe) +float 0x5 - 0x7 == -0x2 (0xfffe) +int 0x5 * 0x7 == 0x23 (0x23) +__uint 0x5 * 0x7 == 0x23 (0x23) +char 0x5 * 0x7 == 0x23 (0x23) +__uchar 0x5 * 0x7 == 0x23 (0x23) +__longlong 0x5 * 0x7 == 0x23 (0x23) +__ulonglong 0x5 * 0x7 == 0x23 (0x23) +float 0x5 * 0x7 == 0x23 (0x23) +int 0x5 < 0x7 == 0x1 (0x1) +__uint 0x5 < 0x7 == 0x1 (0x1) +char 0x5 < 0x7 == 0x1 (0x1) +__uchar 0x5 < 0x7 == 0x1 (0x1) +__longlong 0x5 < 0x7 == 0x1 (0x1) +__ulonglong 0x5 < 0x7 == 0x1 (0x1) +float 0x5 < 0x7 == 0x1 (0x1) +int 0x5 > 0x7 == 0x0 (0x0) +__uint 0x5 > 0x7 == 0x0 (0x0) +char 0x5 > 0x7 == 0x0 (0x0) +__uchar 0x5 > 0x7 == 0x0 (0x0) +__longlong 0x5 > 0x7 == 0x0 (0x0) +__ulonglong 0x5 > 0x7 == 0x0 (0x0) +float 0x5 > 0x7 == 0x0 (0x0) +int 0x5 <= 0x7 == 0x1 (0x1) +__uint 0x5 <= 0x7 == 0x1 (0x1) +char 0x5 <= 0x7 == 0x1 (0x1) +__uchar 0x5 <= 0x7 == 0x1 (0x1) +__longlong 0x5 <= 0x7 == 0x1 (0x1) +__ulonglong 0x5 <= 0x7 == 0x1 (0x1) +float 0x5 <= 0x7 == 0x1 (0x1) +int 0x5 == 0x7 == 0x0 (0x0) +__uint 0x5 == 0x7 == 0x0 (0x0) +char 0x5 == 0x7 == 0x0 (0x0) +__uchar 0x5 == 0x7 == 0x0 (0x0) +__longlong 0x5 == 0x7 == 0x0 (0x0) +__ulonglong 0x5 == 0x7 == 0x0 (0x0) +float 0x5 == 0x7 == 0x0 (0x0) +int 0x5 != 0x7 == 0x1 (0x1) +__uint 0x5 != 0x7 == 0x1 (0x1) +char 0x5 != 0x7 == 0x1 (0x1) +__uchar 0x5 != 0x7 == 0x1 (0x1) +__longlong 0x5 != 0x7 == 0x1 (0x1) +__ulonglong 0x5 != 0x7 == 0x1 (0x1) +float 0x5 != 0x7 == 0x1 (0x1) +int 0x5 >= 0x7 == 0x0 (0x0) +__uint 0x5 >= 0x7 == 0x0 (0x0) +char 0x5 >= 0x7 == 0x0 (0x0) +__uchar 0x5 >= 0x7 == 0x0 (0x0) +__longlong 0x5 >= 0x7 == 0x0 (0x0) +__ulonglong 0x5 >= 0x7 == 0x0 (0x0) +float 0x5 >= 0x7 == 0x0 (0x0) +int 0x5 / 0x7 == 0x0 (0x0) +__uint 0x5 / 0x7 == 0x0 (0x0) +char 0x5 / 0x7 == 0x0 (0x0) +__uchar 0x5 / 0x7 == 0x0 (0x0) +__longlong 0x5 / 0x7 == 0x0 (0x0) +__ulonglong 0x5 / 0x7 == 0x0 (0x0) +float 0x5 / 0x7 == 0x0 (0x0) +int 0x5 % 0x7 == 0x5 (0x5) +__uint 0x5 % 0x7 == 0x5 (0x5) +char 0x5 % 0x7 == 0x5 (0x5) +__uchar 0x5 % 0x7 == 0x5 (0x5) +__longlong 0x5 % 0x7 == 0x5 (0x5) +__ulonglong 0x5 % 0x7 == 0x5 (0x5) +0x5 * 0x2a == 0xd2 +0x5 / 0x2a == 0x0 +0x5 % 0x2a == 0x5 +int 0x5 ^ 0x2a == 0x2f (0x2f) +__uint 0x5 ^ 0x2a == 0x2f (0x2f) +char 0x5 ^ 0x2a == 0x2f (0x2f) +__uchar 0x5 ^ 0x2a == 0x2f (0x2f) +__longlong 0x5 ^ 0x2a == 0x2f (0x2f) +__ulonglong 0x5 ^ 0x2a == 0x2f (0x2f) +int 0x5 && 0x2a == 0x1 (0x1) +__uint 0x5 && 0x2a == 0x1 (0x1) +char 0x5 && 0x2a == 0x1 (0x1) +__uchar 0x5 && 0x2a == 0x1 (0x1) +__longlong 0x5 && 0x2a == 0x1 (0x1) +__ulonglong 0x5 && 0x2a == 0x1 (0x1) +int 0x5 || 0x2a == 0x1 (0x1) +__uint 0x5 || 0x2a == 0x1 (0x1) +char 0x5 || 0x2a == 0x1 (0x1) +__uchar 0x5 || 0x2a == 0x1 (0x1) +__longlong 0x5 || 0x2a == 0x1 (0x1) +__ulonglong 0x5 || 0x2a == 0x1 (0x1) +int 0x5 & 0x2a == 0x0 (0x0) +__uint 0x5 & 0x2a == 0x0 (0x0) +char 0x5 & 0x2a == 0x0 (0x0) +__uchar 0x5 & 0x2a == 0x0 (0x0) +__longlong 0x5 & 0x2a == 0x0 (0x0) +__ulonglong 0x5 & 0x2a == 0x0 (0x0) +int 0x5 | 0x2a == 0x2f (0x2f) +__uint 0x5 | 0x2a == 0x2f (0x2f) +char 0x5 | 0x2a == 0x2f (0x2f) +__uchar 0x5 | 0x2a == 0x2f (0x2f) +__longlong 0x5 | 0x2a == 0x2f (0x2f) +__ulonglong 0x5 | 0x2a == 0x2f (0x2f) +int 0x5 << 0xc == 0x5000 (0x5000) +__uint 0x5 << 0xc == 0x5000 (0x5000) +char 0x5 << 0xc == 0x0 (0x0) +__uchar 0x5 << 0xc == 0x0 (0x0) +__longlong 0x5 << 0xc == 0x5000 (0x5000) +__ulonglong 0x5 << 0xc == 0x5000 (0x5000) +int 0x5 >> 0xc == 0x0 (0x0) +__uint 0x5 >> 0xc == 0x0 (0x0) +char 0x5 >> 0xc == 0x0 (0x0) +__uchar 0x5 >> 0xc == 0x0 (0x0) +__longlong 0x5 >> 0xc == 0x0 (0x0) +__ulonglong 0x5 >> 0xc == 0x0 (0x0) +int 0x5 + 0x2a == 0x2f (0x2f) +__uint 0x5 + 0x2a == 0x2f (0x2f) +char 0x5 + 0x2a == 0x2f (0x2f) +__uchar 0x5 + 0x2a == 0x2f (0x2f) +__longlong 0x5 + 0x2a == 0x2f (0x2f) +__ulonglong 0x5 + 0x2a == 0x2f (0x2f) +float 0x5 + 0x2a == 0x2f (0x2f) +int 0x5 - 0x2a == -0x25 (0xffdb) +__uint 0x5 - 0x2a == -0x25 (0xffdb) +char 0x5 - 0x2a == -0x25 (0xffdb) +__uchar 0x5 - 0x2a == 0xdb (0xdb) +__longlong 0x5 - 0x2a == -0x25 (0xffdb) +__ulonglong 0x5 - 0x2a == -0x25 (0xffdb) +float 0x5 - 0x2a == -0x25 (0xffdb) +int 0x5 * 0x2a == 0xd2 (0xd2) +__uint 0x5 * 0x2a == 0xd2 (0xd2) +char 0x5 * 0x2a == -0x2e (0xffd2) +__uchar 0x5 * 0x2a == 0xd2 (0xd2) +__longlong 0x5 * 0x2a == 0xd2 (0xd2) +__ulonglong 0x5 * 0x2a == 0xd2 (0xd2) +float 0x5 * 0x2a == 0xd2 (0xd2) +int 0x5 < 0x2a == 0x1 (0x1) +__uint 0x5 < 0x2a == 0x1 (0x1) +char 0x5 < 0x2a == 0x1 (0x1) +__uchar 0x5 < 0x2a == 0x1 (0x1) +__longlong 0x5 < 0x2a == 0x1 (0x1) +__ulonglong 0x5 < 0x2a == 0x1 (0x1) +float 0x5 < 0x2a == 0x1 (0x1) +int 0x5 > 0x2a == 0x0 (0x0) +__uint 0x5 > 0x2a == 0x0 (0x0) +char 0x5 > 0x2a == 0x0 (0x0) +__uchar 0x5 > 0x2a == 0x0 (0x0) +__longlong 0x5 > 0x2a == 0x0 (0x0) +__ulonglong 0x5 > 0x2a == 0x0 (0x0) +float 0x5 > 0x2a == 0x0 (0x0) +int 0x5 <= 0x2a == 0x1 (0x1) +__uint 0x5 <= 0x2a == 0x1 (0x1) +char 0x5 <= 0x2a == 0x1 (0x1) +__uchar 0x5 <= 0x2a == 0x1 (0x1) +__longlong 0x5 <= 0x2a == 0x1 (0x1) +__ulonglong 0x5 <= 0x2a == 0x1 (0x1) +float 0x5 <= 0x2a == 0x1 (0x1) +int 0x5 == 0x2a == 0x0 (0x0) +__uint 0x5 == 0x2a == 0x0 (0x0) +char 0x5 == 0x2a == 0x0 (0x0) +__uchar 0x5 == 0x2a == 0x0 (0x0) +__longlong 0x5 == 0x2a == 0x0 (0x0) +__ulonglong 0x5 == 0x2a == 0x0 (0x0) +float 0x5 == 0x2a == 0x0 (0x0) +int 0x5 != 0x2a == 0x1 (0x1) +__uint 0x5 != 0x2a == 0x1 (0x1) +char 0x5 != 0x2a == 0x1 (0x1) +__uchar 0x5 != 0x2a == 0x1 (0x1) +__longlong 0x5 != 0x2a == 0x1 (0x1) +__ulonglong 0x5 != 0x2a == 0x1 (0x1) +float 0x5 != 0x2a == 0x1 (0x1) +int 0x5 >= 0x2a == 0x0 (0x0) +__uint 0x5 >= 0x2a == 0x0 (0x0) +char 0x5 >= 0x2a == 0x0 (0x0) +__uchar 0x5 >= 0x2a == 0x0 (0x0) +__longlong 0x5 >= 0x2a == 0x0 (0x0) +__ulonglong 0x5 >= 0x2a == 0x0 (0x0) +float 0x5 >= 0x2a == 0x0 (0x0) +int 0x5 / 0x2a == 0x0 (0x0) +__uint 0x5 / 0x2a == 0x0 (0x0) +char 0x5 / 0x2a == 0x0 (0x0) +__uchar 0x5 / 0x2a == 0x0 (0x0) +__longlong 0x5 / 0x2a == 0x0 (0x0) +__ulonglong 0x5 / 0x2a == 0x0 (0x0) +float 0x5 / 0x2a == 0x0 (0x0) +int 0x5 % 0x2a == 0x5 (0x5) +__uint 0x5 % 0x2a == 0x5 (0x5) +char 0x5 % 0x2a == 0x5 (0x5) +__uchar 0x5 % 0x2a == 0x5 (0x5) +__longlong 0x5 % 0x2a == 0x5 (0x5) +__ulonglong 0x5 % 0x2a == 0x5 (0x5) +0x5 * 0x17 == 0x73 +0x5 / 0x17 == 0x0 +0x5 % 0x17 == 0x5 +int 0x5 ^ 0x17 == 0x12 (0x12) +__uint 0x5 ^ 0x17 == 0x12 (0x12) +char 0x5 ^ 0x17 == 0x12 (0x12) +__uchar 0x5 ^ 0x17 == 0x12 (0x12) +__longlong 0x5 ^ 0x17 == 0x12 (0x12) +__ulonglong 0x5 ^ 0x17 == 0x12 (0x12) +int 0x5 && 0x17 == 0x1 (0x1) +__uint 0x5 && 0x17 == 0x1 (0x1) +char 0x5 && 0x17 == 0x1 (0x1) +__uchar 0x5 && 0x17 == 0x1 (0x1) +__longlong 0x5 && 0x17 == 0x1 (0x1) +__ulonglong 0x5 && 0x17 == 0x1 (0x1) +int 0x5 || 0x17 == 0x1 (0x1) +__uint 0x5 || 0x17 == 0x1 (0x1) +char 0x5 || 0x17 == 0x1 (0x1) +__uchar 0x5 || 0x17 == 0x1 (0x1) +__longlong 0x5 || 0x17 == 0x1 (0x1) +__ulonglong 0x5 || 0x17 == 0x1 (0x1) +int 0x5 & 0x17 == 0x5 (0x5) +__uint 0x5 & 0x17 == 0x5 (0x5) +char 0x5 & 0x17 == 0x5 (0x5) +__uchar 0x5 & 0x17 == 0x5 (0x5) +__longlong 0x5 & 0x17 == 0x5 (0x5) +__ulonglong 0x5 & 0x17 == 0x5 (0x5) +int 0x5 | 0x17 == 0x17 (0x17) +__uint 0x5 | 0x17 == 0x17 (0x17) +char 0x5 | 0x17 == 0x17 (0x17) +__uchar 0x5 | 0x17 == 0x17 (0x17) +__longlong 0x5 | 0x17 == 0x17 (0x17) +__ulonglong 0x5 | 0x17 == 0x17 (0x17) +int 0x5 << 0xe == 0x4000 (0x4000) +__uint 0x5 << 0xe == 0x4000 (0x4000) +char 0x5 << 0xe == 0x0 (0x0) +__uchar 0x5 << 0xe == 0x0 (0x0) +__longlong 0x5 << 0xe == 0x4000 (0x4000) +__ulonglong 0x5 << 0xe == 0x4000 (0x4000) +int 0x5 >> 0xe == 0x0 (0x0) +__uint 0x5 >> 0xe == 0x0 (0x0) +char 0x5 >> 0xe == 0x0 (0x0) +__uchar 0x5 >> 0xe == 0x0 (0x0) +__longlong 0x5 >> 0xe == 0x0 (0x0) +__ulonglong 0x5 >> 0xe == 0x0 (0x0) +int 0x5 + 0x17 == 0x1c (0x1c) +__uint 0x5 + 0x17 == 0x1c (0x1c) +char 0x5 + 0x17 == 0x1c (0x1c) +__uchar 0x5 + 0x17 == 0x1c (0x1c) +__longlong 0x5 + 0x17 == 0x1c (0x1c) +__ulonglong 0x5 + 0x17 == 0x1c (0x1c) +float 0x5 + 0x17 == 0x1c (0x1c) +int 0x5 - 0x17 == -0x12 (0xffee) +__uint 0x5 - 0x17 == -0x12 (0xffee) +char 0x5 - 0x17 == -0x12 (0xffee) +__uchar 0x5 - 0x17 == 0xee (0xee) +__longlong 0x5 - 0x17 == -0x12 (0xffee) +__ulonglong 0x5 - 0x17 == -0x12 (0xffee) +float 0x5 - 0x17 == -0x12 (0xffee) +int 0x5 * 0x17 == 0x73 (0x73) +__uint 0x5 * 0x17 == 0x73 (0x73) +char 0x5 * 0x17 == 0x73 (0x73) +__uchar 0x5 * 0x17 == 0x73 (0x73) +__longlong 0x5 * 0x17 == 0x73 (0x73) +__ulonglong 0x5 * 0x17 == 0x73 (0x73) +float 0x5 * 0x17 == 0x73 (0x73) +int 0x5 < 0x17 == 0x1 (0x1) +__uint 0x5 < 0x17 == 0x1 (0x1) +char 0x5 < 0x17 == 0x1 (0x1) +__uchar 0x5 < 0x17 == 0x1 (0x1) +__longlong 0x5 < 0x17 == 0x1 (0x1) +__ulonglong 0x5 < 0x17 == 0x1 (0x1) +float 0x5 < 0x17 == 0x1 (0x1) +int 0x5 > 0x17 == 0x0 (0x0) +__uint 0x5 > 0x17 == 0x0 (0x0) +char 0x5 > 0x17 == 0x0 (0x0) +__uchar 0x5 > 0x17 == 0x0 (0x0) +__longlong 0x5 > 0x17 == 0x0 (0x0) +__ulonglong 0x5 > 0x17 == 0x0 (0x0) +float 0x5 > 0x17 == 0x0 (0x0) +int 0x5 <= 0x17 == 0x1 (0x1) +__uint 0x5 <= 0x17 == 0x1 (0x1) +char 0x5 <= 0x17 == 0x1 (0x1) +__uchar 0x5 <= 0x17 == 0x1 (0x1) +__longlong 0x5 <= 0x17 == 0x1 (0x1) +__ulonglong 0x5 <= 0x17 == 0x1 (0x1) +float 0x5 <= 0x17 == 0x1 (0x1) +int 0x5 == 0x17 == 0x0 (0x0) +__uint 0x5 == 0x17 == 0x0 (0x0) +char 0x5 == 0x17 == 0x0 (0x0) +__uchar 0x5 == 0x17 == 0x0 (0x0) +__longlong 0x5 == 0x17 == 0x0 (0x0) +__ulonglong 0x5 == 0x17 == 0x0 (0x0) +float 0x5 == 0x17 == 0x0 (0x0) +int 0x5 != 0x17 == 0x1 (0x1) +__uint 0x5 != 0x17 == 0x1 (0x1) +char 0x5 != 0x17 == 0x1 (0x1) +__uchar 0x5 != 0x17 == 0x1 (0x1) +__longlong 0x5 != 0x17 == 0x1 (0x1) +__ulonglong 0x5 != 0x17 == 0x1 (0x1) +float 0x5 != 0x17 == 0x1 (0x1) +int 0x5 >= 0x17 == 0x0 (0x0) +__uint 0x5 >= 0x17 == 0x0 (0x0) +char 0x5 >= 0x17 == 0x0 (0x0) +__uchar 0x5 >= 0x17 == 0x0 (0x0) +__longlong 0x5 >= 0x17 == 0x0 (0x0) +__ulonglong 0x5 >= 0x17 == 0x0 (0x0) +float 0x5 >= 0x17 == 0x0 (0x0) +int 0x5 / 0x17 == 0x0 (0x0) +__uint 0x5 / 0x17 == 0x0 (0x0) +char 0x5 / 0x17 == 0x0 (0x0) +__uchar 0x5 / 0x17 == 0x0 (0x0) +__longlong 0x5 / 0x17 == 0x0 (0x0) +__ulonglong 0x5 / 0x17 == 0x0 (0x0) +float 0x5 / 0x17 == 0x0 (0x0) +int 0x5 % 0x17 == 0x5 (0x5) +__uint 0x5 % 0x17 == 0x5 (0x5) +char 0x5 % 0x17 == 0x5 (0x5) +__uchar 0x5 % 0x17 == 0x5 (0x5) +__longlong 0x5 % 0x17 == 0x5 (0x5) +__ulonglong 0x5 % 0x17 == 0x5 (0x5) +0x5 * 0x7fff == 0x7ffb +0x5 / 0x7fff == 0x0 +0x5 % 0x7fff == 0x5 +int 0x5 ^ 0x7fff == 0x7ffa (0x7ffa) +__uint 0x5 ^ 0x7fff == 0x7ffa (0x7ffa) +char 0x5 ^ 0xffff == -0x6 (0xfffa) +__uchar 0x5 ^ 0xff == 0xfa (0xfa) +__longlong 0x5 ^ 0x7fff == 0x7ffa (0x7ffa) +__ulonglong 0x5 ^ 0x7fff == 0x7ffa (0x7ffa) +int 0x5 && 0x7fff == 0x1 (0x1) +__uint 0x5 && 0x7fff == 0x1 (0x1) +char 0x5 && 0xffff == 0x1 (0x1) +__uchar 0x5 && 0xff == 0x1 (0x1) +__longlong 0x5 && 0x7fff == 0x1 (0x1) +__ulonglong 0x5 && 0x7fff == 0x1 (0x1) +int 0x5 || 0x7fff == 0x1 (0x1) +__uint 0x5 || 0x7fff == 0x1 (0x1) +char 0x5 || 0xffff == 0x1 (0x1) +__uchar 0x5 || 0xff == 0x1 (0x1) +__longlong 0x5 || 0x7fff == 0x1 (0x1) +__ulonglong 0x5 || 0x7fff == 0x1 (0x1) +int 0x5 & 0x7fff == 0x5 (0x5) +__uint 0x5 & 0x7fff == 0x5 (0x5) +char 0x5 & 0xffff == 0x5 (0x5) +__uchar 0x5 & 0xff == 0x5 (0x5) +__longlong 0x5 & 0x7fff == 0x5 (0x5) +__ulonglong 0x5 & 0x7fff == 0x5 (0x5) +int 0x5 | 0x7fff == 0x7fff (0x7fff) +__uint 0x5 | 0x7fff == 0x7fff (0x7fff) +char 0x5 | 0xffff == -0x1 (0xffff) +__uchar 0x5 | 0xff == 0xff (0xff) +__longlong 0x5 | 0x7fff == 0x7fff (0x7fff) +__ulonglong 0x5 | 0x7fff == 0x7fff (0x7fff) +int 0x5 << 0x10 == 0x0 (0x0) +__uint 0x5 << 0x10 == 0x0 (0x0) +char 0x5 << 0x10 == 0x0 (0x0) +__uchar 0x5 << 0x10 == 0x0 (0x0) +__longlong 0x5 << 0x10 == 0x0 (0x0) +__ulonglong 0x5 << 0x10 == 0x0 (0x0) +int 0x5 >> 0x10 == 0x0 (0x0) +__uint 0x5 >> 0x10 == 0x0 (0x0) +char 0x5 >> 0x10 == 0x0 (0x0) +__uchar 0x5 >> 0x10 == 0x0 (0x0) +__longlong 0x5 >> 0x10 == 0x0 (0x0) +__ulonglong 0x5 >> 0x10 == 0x0 (0x0) +int 0x5 + 0x7fff == -0x7ffc (0x8004) +__uint 0x5 + 0x7fff == -0x7ffc (0x8004) +char 0x5 + 0xffff == 0x4 (0x4) +__uchar 0x5 + 0xff == 0x4 (0x4) +__longlong 0x5 + 0x7fff == -0x7ffc (0x8004) +__ulonglong 0x5 + 0x7fff == -0x7ffc (0x8004) +float 0x5 + 0x7fff == -0x8000 (0x8000) +int 0x5 - 0x7fff == -0x7ffa (0x8006) +__uint 0x5 - 0x7fff == -0x7ffa (0x8006) +char 0x5 - 0xffff == 0x6 (0x6) +__uchar 0x5 - 0xff == 0x6 (0x6) +__longlong 0x5 - 0x7fff == -0x7ffa (0x8006) +__ulonglong 0x5 - 0x7fff == -0x7ffa (0x8006) +float 0x5 - 0x7fff == -0x7ffa (0x8006) +int 0x5 * 0x7fff == 0x7ffb (0x7ffb) +__uint 0x5 * 0x7fff == 0x7ffb (0x7ffb) +char 0x5 * 0xffff == -0x5 (0xfffb) +__uchar 0x5 * 0xff == 0xfb (0xfb) +__longlong 0x5 * 0x7fff == 0x7ffb (0x7ffb) +__ulonglong 0x5 * 0x7fff == 0x7ffb (0x7ffb) +float 0x5 * 0x7fff == -0x8000 (0x8000) +int 0x5 < 0x7fff == 0x1 (0x1) +__uint 0x5 < 0x7fff == 0x1 (0x1) +char 0x5 < 0xffff == 0x0 (0x0) +__uchar 0x5 < 0xff == 0x1 (0x1) +__longlong 0x5 < 0x7fff == 0x1 (0x1) +__ulonglong 0x5 < 0x7fff == 0x1 (0x1) +float 0x5 < 0x7fff == 0x1 (0x1) +int 0x5 > 0x7fff == 0x0 (0x0) +__uint 0x5 > 0x7fff == 0x0 (0x0) +char 0x5 > 0xffff == 0x1 (0x1) +__uchar 0x5 > 0xff == 0x0 (0x0) +__longlong 0x5 > 0x7fff == 0x0 (0x0) +__ulonglong 0x5 > 0x7fff == 0x0 (0x0) +float 0x5 > 0x7fff == 0x0 (0x0) +int 0x5 <= 0x7fff == 0x1 (0x1) +__uint 0x5 <= 0x7fff == 0x1 (0x1) +char 0x5 <= 0xffff == 0x0 (0x0) +__uchar 0x5 <= 0xff == 0x1 (0x1) +__longlong 0x5 <= 0x7fff == 0x1 (0x1) +__ulonglong 0x5 <= 0x7fff == 0x1 (0x1) +float 0x5 <= 0x7fff == 0x1 (0x1) +int 0x5 == 0x7fff == 0x0 (0x0) +__uint 0x5 == 0x7fff == 0x0 (0x0) +char 0x5 == 0xffff == 0x0 (0x0) +__uchar 0x5 == 0xff == 0x0 (0x0) +__longlong 0x5 == 0x7fff == 0x0 (0x0) +__ulonglong 0x5 == 0x7fff == 0x0 (0x0) +float 0x5 == 0x7fff == 0x0 (0x0) +int 0x5 != 0x7fff == 0x1 (0x1) +__uint 0x5 != 0x7fff == 0x1 (0x1) +char 0x5 != 0xffff == 0x1 (0x1) +__uchar 0x5 != 0xff == 0x1 (0x1) +__longlong 0x5 != 0x7fff == 0x1 (0x1) +__ulonglong 0x5 != 0x7fff == 0x1 (0x1) +float 0x5 != 0x7fff == 0x1 (0x1) +int 0x5 >= 0x7fff == 0x0 (0x0) +__uint 0x5 >= 0x7fff == 0x0 (0x0) +char 0x5 >= 0xffff == 0x1 (0x1) +__uchar 0x5 >= 0xff == 0x0 (0x0) +__longlong 0x5 >= 0x7fff == 0x0 (0x0) +__ulonglong 0x5 >= 0x7fff == 0x0 (0x0) +float 0x5 >= 0x7fff == 0x0 (0x0) +int 0x5 / 0x7fff == 0x0 (0x0) +__uint 0x5 / 0x7fff == 0x0 (0x0) +char 0x5 / 0xffff == -0x5 (0xfffb) +__uchar 0x5 / 0xff == 0x0 (0x0) +__longlong 0x5 / 0x7fff == 0x0 (0x0) +__ulonglong 0x5 / 0x7fff == 0x0 (0x0) +float 0x5 / 0x7fff == 0x0 (0x0) +int 0x5 % 0x7fff == 0x5 (0x5) +__uint 0x5 % 0x7fff == 0x5 (0x5) +char 0x5 % 0xffff == 0x0 (0x0) +__uchar 0x5 % 0xff == 0x5 (0x5) +__longlong 0x5 % 0x7fff == 0x5 (0x5) +__ulonglong 0x5 % 0x7fff == 0x5 (0x5) +0x5 * 0x8000 == -0x8000 +0x5 / 0x8000 == 0x0 +0x5 % 0x8000 == 0x5 +int 0x5 ^ 0x8000 == -0x7ffb (0x8005) +__uint 0x5 ^ 0x8000 == -0x7ffb (0x8005) +char 0x5 ^ 0x0 == 0x5 (0x5) +__uchar 0x5 ^ 0x0 == 0x5 (0x5) +__longlong 0x5 ^ 0x8000 == -0x7ffb (0x8005) +__ulonglong 0x5 ^ 0x8000 == -0x7ffb (0x8005) +int 0x5 && 0x8000 == 0x1 (0x1) +__uint 0x5 && 0x8000 == 0x1 (0x1) +char 0x5 && 0x0 == 0x0 (0x0) +__uchar 0x5 && 0x0 == 0x0 (0x0) +__longlong 0x5 && 0x8000 == 0x1 (0x1) +__ulonglong 0x5 && 0x8000 == 0x1 (0x1) +int 0x5 || 0x8000 == 0x1 (0x1) +__uint 0x5 || 0x8000 == 0x1 (0x1) +char 0x5 || 0x0 == 0x1 (0x1) +__uchar 0x5 || 0x0 == 0x1 (0x1) +__longlong 0x5 || 0x8000 == 0x1 (0x1) +__ulonglong 0x5 || 0x8000 == 0x1 (0x1) +int 0x5 & 0x8000 == 0x0 (0x0) +__uint 0x5 & 0x8000 == 0x0 (0x0) +char 0x5 & 0x0 == 0x0 (0x0) +__uchar 0x5 & 0x0 == 0x0 (0x0) +__longlong 0x5 & 0x8000 == 0x0 (0x0) +__ulonglong 0x5 & 0x8000 == 0x0 (0x0) +int 0x5 | 0x8000 == -0x7ffb (0x8005) +__uint 0x5 | 0x8000 == -0x7ffb (0x8005) +char 0x5 | 0x0 == 0x5 (0x5) +__uchar 0x5 | 0x0 == 0x5 (0x5) +__longlong 0x5 | 0x8000 == -0x7ffb (0x8005) +__ulonglong 0x5 | 0x8000 == -0x7ffb (0x8005) +int 0x5 << 0x12 == 0x0 (0x0) +__uint 0x5 << 0x12 == 0x0 (0x0) +char 0x5 << 0x12 == 0x0 (0x0) +__uchar 0x5 << 0x12 == 0x0 (0x0) +__longlong 0x5 << 0x12 == 0x0 (0x0) +__ulonglong 0x5 << 0x12 == 0x0 (0x0) +int 0x5 >> 0x12 == 0x0 (0x0) +__uint 0x5 >> 0x12 == 0x0 (0x0) +char 0x5 >> 0x12 == 0x0 (0x0) +__uchar 0x5 >> 0x12 == 0x0 (0x0) +__longlong 0x5 >> 0x12 == 0x0 (0x0) +__ulonglong 0x5 >> 0x12 == 0x0 (0x0) +int 0x5 + 0x8000 == -0x7ffb (0x8005) +__uint 0x5 + 0x8000 == -0x7ffb (0x8005) +char 0x5 + 0x0 == 0x5 (0x5) +__uchar 0x5 + 0x0 == 0x5 (0x5) +__longlong 0x5 + 0x8000 == -0x7ffb (0x8005) +__ulonglong 0x5 + 0x8000 == -0x7ffb (0x8005) +float 0x5 + 0x8000 == -0x7ffb (0x8005) +int 0x5 - 0x8000 == -0x7ffb (0x8005) +__uint 0x5 - 0x8000 == -0x7ffb (0x8005) +char 0x5 - 0x0 == 0x5 (0x5) +__uchar 0x5 - 0x0 == 0x5 (0x5) +__longlong 0x5 - 0x8000 == -0x7ffb (0x8005) +__ulonglong 0x5 - 0x8000 == -0x7ffb (0x8005) +float 0x5 - 0x8000 == -0x8000 (0x8000) +int 0x5 * 0x8000 == -0x8000 (0x8000) +__uint 0x5 * 0x8000 == -0x8000 (0x8000) +char 0x5 * 0x0 == 0x0 (0x0) +__uchar 0x5 * 0x0 == 0x0 (0x0) +__longlong 0x5 * 0x8000 == -0x8000 (0x8000) +__ulonglong 0x5 * 0x8000 == -0x8000 (0x8000) +float 0x5 * 0x8000 == -0x8000 (0x8000) +int 0x5 < 0x8000 == 0x0 (0x0) +__uint 0x5 < 0x8000 == 0x1 (0x1) +char 0x5 < 0x0 == 0x0 (0x0) +__uchar 0x5 < 0x0 == 0x0 (0x0) +__longlong 0x5 < 0x8000 == 0x0 (0x0) +__ulonglong 0x5 < 0x8000 == 0x1 (0x1) +float 0x5 < 0x8000 == 0x0 (0x0) +int 0x5 > 0x8000 == 0x1 (0x1) +__uint 0x5 > 0x8000 == 0x0 (0x0) +char 0x5 > 0x0 == 0x1 (0x1) +__uchar 0x5 > 0x0 == 0x1 (0x1) +__longlong 0x5 > 0x8000 == 0x1 (0x1) +__ulonglong 0x5 > 0x8000 == 0x0 (0x0) +float 0x5 > 0x8000 == 0x1 (0x1) +int 0x5 <= 0x8000 == 0x0 (0x0) +__uint 0x5 <= 0x8000 == 0x1 (0x1) +char 0x5 <= 0x0 == 0x0 (0x0) +__uchar 0x5 <= 0x0 == 0x0 (0x0) +__longlong 0x5 <= 0x8000 == 0x0 (0x0) +__ulonglong 0x5 <= 0x8000 == 0x1 (0x1) +float 0x5 <= 0x8000 == 0x0 (0x0) +int 0x5 == 0x8000 == 0x0 (0x0) +__uint 0x5 == 0x8000 == 0x0 (0x0) +char 0x5 == 0x0 == 0x0 (0x0) +__uchar 0x5 == 0x0 == 0x0 (0x0) +__longlong 0x5 == 0x8000 == 0x0 (0x0) +__ulonglong 0x5 == 0x8000 == 0x0 (0x0) +float 0x5 == 0x8000 == 0x0 (0x0) +int 0x5 != 0x8000 == 0x1 (0x1) +__uint 0x5 != 0x8000 == 0x1 (0x1) +char 0x5 != 0x0 == 0x1 (0x1) +__uchar 0x5 != 0x0 == 0x1 (0x1) +__longlong 0x5 != 0x8000 == 0x1 (0x1) +__ulonglong 0x5 != 0x8000 == 0x1 (0x1) +float 0x5 != 0x8000 == 0x1 (0x1) +int 0x5 >= 0x8000 == 0x1 (0x1) +__uint 0x5 >= 0x8000 == 0x0 (0x0) +char 0x5 >= 0x0 == 0x1 (0x1) +__uchar 0x5 >= 0x0 == 0x1 (0x1) +__longlong 0x5 >= 0x8000 == 0x1 (0x1) +__ulonglong 0x5 >= 0x8000 == 0x0 (0x0) +float 0x5 >= 0x8000 == 0x1 (0x1) +int 0x5 / 0x8000 == 0x0 (0x0) +__uint 0x5 / 0x8000 == 0x0 (0x0) +__longlong 0x5 / 0x8000 == 0x0 (0x0) +__ulonglong 0x5 / 0x8000 == 0x0 (0x0) +float 0x5 / 0x8000 == 0x0 (0x0) +int 0x5 % 0x8000 == 0x5 (0x5) +__uint 0x5 % 0x8000 == 0x5 (0x5) +__longlong 0x5 % 0x8000 == 0x5 (0x5) +__ulonglong 0x5 % 0x8000 == 0x5 (0x5) +0x5 * 0x3e8 == 0x1388 +0x5 / 0x3e8 == 0x0 +0x5 % 0x3e8 == 0x5 +int 0x5 ^ 0x3e8 == 0x3ed (0x3ed) +__uint 0x5 ^ 0x3e8 == 0x3ed (0x3ed) +char 0x5 ^ 0xffe8 == -0x13 (0xffed) +__uchar 0x5 ^ 0xe8 == 0xed (0xed) +__longlong 0x5 ^ 0x3e8 == 0x3ed (0x3ed) +__ulonglong 0x5 ^ 0x3e8 == 0x3ed (0x3ed) +int 0x5 && 0x3e8 == 0x1 (0x1) +__uint 0x5 && 0x3e8 == 0x1 (0x1) +char 0x5 && 0xffe8 == 0x1 (0x1) +__uchar 0x5 && 0xe8 == 0x1 (0x1) +__longlong 0x5 && 0x3e8 == 0x1 (0x1) +__ulonglong 0x5 && 0x3e8 == 0x1 (0x1) +int 0x5 || 0x3e8 == 0x1 (0x1) +__uint 0x5 || 0x3e8 == 0x1 (0x1) +char 0x5 || 0xffe8 == 0x1 (0x1) +__uchar 0x5 || 0xe8 == 0x1 (0x1) +__longlong 0x5 || 0x3e8 == 0x1 (0x1) +__ulonglong 0x5 || 0x3e8 == 0x1 (0x1) +int 0x5 & 0x3e8 == 0x0 (0x0) +__uint 0x5 & 0x3e8 == 0x0 (0x0) +char 0x5 & 0xffe8 == 0x0 (0x0) +__uchar 0x5 & 0xe8 == 0x0 (0x0) +__longlong 0x5 & 0x3e8 == 0x0 (0x0) +__ulonglong 0x5 & 0x3e8 == 0x0 (0x0) +int 0x5 | 0x3e8 == 0x3ed (0x3ed) +__uint 0x5 | 0x3e8 == 0x3ed (0x3ed) +char 0x5 | 0xffe8 == -0x13 (0xffed) +__uchar 0x5 | 0xe8 == 0xed (0xed) +__longlong 0x5 | 0x3e8 == 0x3ed (0x3ed) +__ulonglong 0x5 | 0x3e8 == 0x3ed (0x3ed) +int 0x5 << 0x14 == 0x0 (0x0) +__uint 0x5 << 0x14 == 0x0 (0x0) +char 0x5 << 0x14 == 0x0 (0x0) +__uchar 0x5 << 0x14 == 0x0 (0x0) +__longlong 0x5 << 0x14 == 0x0 (0x0) +__ulonglong 0x5 << 0x14 == 0x0 (0x0) +int 0x5 >> 0x14 == 0x0 (0x0) +__uint 0x5 >> 0x14 == 0x0 (0x0) +char 0x5 >> 0x14 == 0x0 (0x0) +__uchar 0x5 >> 0x14 == 0x0 (0x0) +__longlong 0x5 >> 0x14 == 0x0 (0x0) +__ulonglong 0x5 >> 0x14 == 0x0 (0x0) +int 0x5 + 0x3e8 == 0x3ed (0x3ed) +__uint 0x5 + 0x3e8 == 0x3ed (0x3ed) +char 0x5 + 0xffe8 == -0x13 (0xffed) +__uchar 0x5 + 0xe8 == 0xed (0xed) +__longlong 0x5 + 0x3e8 == 0x3ed (0x3ed) +__ulonglong 0x5 + 0x3e8 == 0x3ed (0x3ed) +float 0x5 + 0x3e8 == 0x3ed (0x3ed) +int 0x5 - 0x3e8 == -0x3e3 (0xfc1d) +__uint 0x5 - 0x3e8 == -0x3e3 (0xfc1d) +char 0x5 - 0xffe8 == 0x1d (0x1d) +__uchar 0x5 - 0xe8 == 0x1d (0x1d) +__longlong 0x5 - 0x3e8 == -0x3e3 (0xfc1d) +__ulonglong 0x5 - 0x3e8 == -0x3e3 (0xfc1d) +float 0x5 - 0x3e8 == -0x3e3 (0xfc1d) +int 0x5 * 0x3e8 == 0x1388 (0x1388) +__uint 0x5 * 0x3e8 == 0x1388 (0x1388) +char 0x5 * 0xffe8 == -0x78 (0xff88) +__uchar 0x5 * 0xe8 == 0x88 (0x88) +__longlong 0x5 * 0x3e8 == 0x1388 (0x1388) +__ulonglong 0x5 * 0x3e8 == 0x1388 (0x1388) +float 0x5 * 0x3e8 == 0x1388 (0x1388) +int 0x5 < 0x3e8 == 0x1 (0x1) +__uint 0x5 < 0x3e8 == 0x1 (0x1) +char 0x5 < 0xffe8 == 0x0 (0x0) +__uchar 0x5 < 0xe8 == 0x1 (0x1) +__longlong 0x5 < 0x3e8 == 0x1 (0x1) +__ulonglong 0x5 < 0x3e8 == 0x1 (0x1) +float 0x5 < 0x3e8 == 0x1 (0x1) +int 0x5 > 0x3e8 == 0x0 (0x0) +__uint 0x5 > 0x3e8 == 0x0 (0x0) +char 0x5 > 0xffe8 == 0x1 (0x1) +__uchar 0x5 > 0xe8 == 0x0 (0x0) +__longlong 0x5 > 0x3e8 == 0x0 (0x0) +__ulonglong 0x5 > 0x3e8 == 0x0 (0x0) +float 0x5 > 0x3e8 == 0x0 (0x0) +int 0x5 <= 0x3e8 == 0x1 (0x1) +__uint 0x5 <= 0x3e8 == 0x1 (0x1) +char 0x5 <= 0xffe8 == 0x0 (0x0) +__uchar 0x5 <= 0xe8 == 0x1 (0x1) +__longlong 0x5 <= 0x3e8 == 0x1 (0x1) +__ulonglong 0x5 <= 0x3e8 == 0x1 (0x1) +float 0x5 <= 0x3e8 == 0x1 (0x1) +int 0x5 == 0x3e8 == 0x0 (0x0) +__uint 0x5 == 0x3e8 == 0x0 (0x0) +char 0x5 == 0xffe8 == 0x0 (0x0) +__uchar 0x5 == 0xe8 == 0x0 (0x0) +__longlong 0x5 == 0x3e8 == 0x0 (0x0) +__ulonglong 0x5 == 0x3e8 == 0x0 (0x0) +float 0x5 == 0x3e8 == 0x0 (0x0) +int 0x5 != 0x3e8 == 0x1 (0x1) +__uint 0x5 != 0x3e8 == 0x1 (0x1) +char 0x5 != 0xffe8 == 0x1 (0x1) +__uchar 0x5 != 0xe8 == 0x1 (0x1) +__longlong 0x5 != 0x3e8 == 0x1 (0x1) +__ulonglong 0x5 != 0x3e8 == 0x1 (0x1) +float 0x5 != 0x3e8 == 0x1 (0x1) +int 0x5 >= 0x3e8 == 0x0 (0x0) +__uint 0x5 >= 0x3e8 == 0x0 (0x0) +char 0x5 >= 0xffe8 == 0x1 (0x1) +__uchar 0x5 >= 0xe8 == 0x0 (0x0) +__longlong 0x5 >= 0x3e8 == 0x0 (0x0) +__ulonglong 0x5 >= 0x3e8 == 0x0 (0x0) +float 0x5 >= 0x3e8 == 0x0 (0x0) +int 0x5 / 0x3e8 == 0x0 (0x0) +__uint 0x5 / 0x3e8 == 0x0 (0x0) +char 0x5 / 0xffe8 == 0x0 (0x0) +__uchar 0x5 / 0xe8 == 0x0 (0x0) +__longlong 0x5 / 0x3e8 == 0x0 (0x0) +__ulonglong 0x5 / 0x3e8 == 0x0 (0x0) +float 0x5 / 0x3e8 == 0x0 (0x0) +int 0x5 % 0x3e8 == 0x5 (0x5) +__uint 0x5 % 0x3e8 == 0x5 (0x5) +char 0x5 % 0xffe8 == 0x5 (0x5) +__uchar 0x5 % 0xe8 == 0x5 (0x5) +__longlong 0x5 % 0x3e8 == 0x5 (0x5) +__ulonglong 0x5 % 0x3e8 == 0x5 (0x5) +0x5 * 0x2710 == -0x3cb0 +0x5 / 0x2710 == 0x0 +0x5 % 0x2710 == 0x5 +int 0x5 ^ 0x2710 == 0x2715 (0x2715) +__uint 0x5 ^ 0x2710 == 0x2715 (0x2715) +char 0x5 ^ 0x10 == 0x15 (0x15) +__uchar 0x5 ^ 0x10 == 0x15 (0x15) +__longlong 0x5 ^ 0x2710 == 0x2715 (0x2715) +__ulonglong 0x5 ^ 0x2710 == 0x2715 (0x2715) +int 0x5 && 0x2710 == 0x1 (0x1) +__uint 0x5 && 0x2710 == 0x1 (0x1) +char 0x5 && 0x10 == 0x1 (0x1) +__uchar 0x5 && 0x10 == 0x1 (0x1) +__longlong 0x5 && 0x2710 == 0x1 (0x1) +__ulonglong 0x5 && 0x2710 == 0x1 (0x1) +int 0x5 || 0x2710 == 0x1 (0x1) +__uint 0x5 || 0x2710 == 0x1 (0x1) +char 0x5 || 0x10 == 0x1 (0x1) +__uchar 0x5 || 0x10 == 0x1 (0x1) +__longlong 0x5 || 0x2710 == 0x1 (0x1) +__ulonglong 0x5 || 0x2710 == 0x1 (0x1) +int 0x5 & 0x2710 == 0x0 (0x0) +__uint 0x5 & 0x2710 == 0x0 (0x0) +char 0x5 & 0x10 == 0x0 (0x0) +__uchar 0x5 & 0x10 == 0x0 (0x0) +__longlong 0x5 & 0x2710 == 0x0 (0x0) +__ulonglong 0x5 & 0x2710 == 0x0 (0x0) +int 0x5 | 0x2710 == 0x2715 (0x2715) +__uint 0x5 | 0x2710 == 0x2715 (0x2715) +char 0x5 | 0x10 == 0x15 (0x15) +__uchar 0x5 | 0x10 == 0x15 (0x15) +__longlong 0x5 | 0x2710 == 0x2715 (0x2715) +__ulonglong 0x5 | 0x2710 == 0x2715 (0x2715) +int 0x5 << 0x16 == 0x0 (0x0) +__uint 0x5 << 0x16 == 0x0 (0x0) +char 0x5 << 0x16 == 0x0 (0x0) +__uchar 0x5 << 0x16 == 0x0 (0x0) +__longlong 0x5 << 0x16 == 0x0 (0x0) +__ulonglong 0x5 << 0x16 == 0x0 (0x0) +int 0x5 >> 0x16 == 0x0 (0x0) +__uint 0x5 >> 0x16 == 0x0 (0x0) +char 0x5 >> 0x16 == 0x0 (0x0) +__uchar 0x5 >> 0x16 == 0x0 (0x0) +__longlong 0x5 >> 0x16 == 0x0 (0x0) +__ulonglong 0x5 >> 0x16 == 0x0 (0x0) +int 0x5 + 0x2710 == 0x2715 (0x2715) +__uint 0x5 + 0x2710 == 0x2715 (0x2715) +char 0x5 + 0x10 == 0x15 (0x15) +__uchar 0x5 + 0x10 == 0x15 (0x15) +__longlong 0x5 + 0x2710 == 0x2715 (0x2715) +__ulonglong 0x5 + 0x2710 == 0x2715 (0x2715) +float 0x5 + 0x2710 == 0x2715 (0x2715) +int 0x5 - 0x2710 == -0x270b (0xd8f5) +__uint 0x5 - 0x2710 == -0x270b (0xd8f5) +char 0x5 - 0x10 == -0xb (0xfff5) +__uchar 0x5 - 0x10 == 0xf5 (0xf5) +__longlong 0x5 - 0x2710 == -0x270b (0xd8f5) +__ulonglong 0x5 - 0x2710 == -0x270b (0xd8f5) +float 0x5 - 0x2710 == -0x270b (0xd8f5) +int 0x5 * 0x2710 == -0x3cb0 (0xc350) +__uint 0x5 * 0x2710 == -0x3cb0 (0xc350) +char 0x5 * 0x10 == 0x50 (0x50) +__uchar 0x5 * 0x10 == 0x50 (0x50) +__longlong 0x5 * 0x2710 == -0x3cb0 (0xc350) +__ulonglong 0x5 * 0x2710 == -0x3cb0 (0xc350) +float 0x5 * 0x2710 == -0x8000 (0x8000) +int 0x5 < 0x2710 == 0x1 (0x1) +__uint 0x5 < 0x2710 == 0x1 (0x1) +char 0x5 < 0x10 == 0x1 (0x1) +__uchar 0x5 < 0x10 == 0x1 (0x1) +__longlong 0x5 < 0x2710 == 0x1 (0x1) +__ulonglong 0x5 < 0x2710 == 0x1 (0x1) +float 0x5 < 0x2710 == 0x1 (0x1) +int 0x5 > 0x2710 == 0x0 (0x0) +__uint 0x5 > 0x2710 == 0x0 (0x0) +char 0x5 > 0x10 == 0x0 (0x0) +__uchar 0x5 > 0x10 == 0x0 (0x0) +__longlong 0x5 > 0x2710 == 0x0 (0x0) +__ulonglong 0x5 > 0x2710 == 0x0 (0x0) +float 0x5 > 0x2710 == 0x0 (0x0) +int 0x5 <= 0x2710 == 0x1 (0x1) +__uint 0x5 <= 0x2710 == 0x1 (0x1) +char 0x5 <= 0x10 == 0x1 (0x1) +__uchar 0x5 <= 0x10 == 0x1 (0x1) +__longlong 0x5 <= 0x2710 == 0x1 (0x1) +__ulonglong 0x5 <= 0x2710 == 0x1 (0x1) +float 0x5 <= 0x2710 == 0x1 (0x1) +int 0x5 == 0x2710 == 0x0 (0x0) +__uint 0x5 == 0x2710 == 0x0 (0x0) +char 0x5 == 0x10 == 0x0 (0x0) +__uchar 0x5 == 0x10 == 0x0 (0x0) +__longlong 0x5 == 0x2710 == 0x0 (0x0) +__ulonglong 0x5 == 0x2710 == 0x0 (0x0) +float 0x5 == 0x2710 == 0x0 (0x0) +int 0x5 != 0x2710 == 0x1 (0x1) +__uint 0x5 != 0x2710 == 0x1 (0x1) +char 0x5 != 0x10 == 0x1 (0x1) +__uchar 0x5 != 0x10 == 0x1 (0x1) +__longlong 0x5 != 0x2710 == 0x1 (0x1) +__ulonglong 0x5 != 0x2710 == 0x1 (0x1) +float 0x5 != 0x2710 == 0x1 (0x1) +int 0x5 >= 0x2710 == 0x0 (0x0) +__uint 0x5 >= 0x2710 == 0x0 (0x0) +char 0x5 >= 0x10 == 0x0 (0x0) +__uchar 0x5 >= 0x10 == 0x0 (0x0) +__longlong 0x5 >= 0x2710 == 0x0 (0x0) +__ulonglong 0x5 >= 0x2710 == 0x0 (0x0) +float 0x5 >= 0x2710 == 0x0 (0x0) +int 0x5 / 0x2710 == 0x0 (0x0) +__uint 0x5 / 0x2710 == 0x0 (0x0) +char 0x5 / 0x10 == 0x0 (0x0) +__uchar 0x5 / 0x10 == 0x0 (0x0) +__longlong 0x5 / 0x2710 == 0x0 (0x0) +__ulonglong 0x5 / 0x2710 == 0x0 (0x0) +float 0x5 / 0x2710 == 0x0 (0x0) +int 0x5 % 0x2710 == 0x5 (0x5) +__uint 0x5 % 0x2710 == 0x5 (0x5) +char 0x5 % 0x10 == 0x5 (0x5) +__uchar 0x5 % 0x10 == 0x5 (0x5) +__longlong 0x5 % 0x2710 == 0x5 (0x5) +__ulonglong 0x5 % 0x2710 == 0x5 (0x5) +int xor420x5 xor42 0x2f +__uint xor420x5 xor42 0x2f +char xor420x5 xor42 0x2f +__uchar xor420x5 xor42 0x2f +__longlong xor420x5 xor42 0x2f +__ulonglong xor420x5 xor42 0x2f +int land10x5 land1 0x1 +__uint land10x5 land1 0x1 +char land10x5 land1 0x1 +__uchar land10x5 land1 0x1 +__longlong land10x5 land1 0x1 +__ulonglong land10x5 land1 0x1 +int lor10x5 lor1 0x1 +__uint lor10x5 lor1 0x1 +char lor10x5 lor1 0x1 +__uchar lor10x5 lor1 0x1 +__longlong lor10x5 lor1 0x1 +__ulonglong lor10x5 lor1 0x1 +int and420x5 and42 0x0 +__uint and420x5 and42 0x0 +char and420x5 and42 0x0 +__uchar and420x5 and42 0x0 +__longlong and420x5 and42 0x0 +__ulonglong and420x5 and42 0x0 +int or420x5 or42 0x2f +__uint or420x5 or42 0x2f +char or420x5 or42 0x2f +__uchar or420x5 or42 0x2f +__longlong or420x5 or42 0x2f +__ulonglong or420x5 or42 0x2f +int shl50x5 shl5 0xa0 +__uint shl50x5 shl5 0xa0 +char shl50x5 shl5 -0x60 +__uchar shl50x5 shl5 0xa0 +__longlong shl50x5 shl5 0xa0 +__ulonglong shl50x5 shl5 0xa0 +int shr50x5 shr5 0x0 +__uint shr50x5 shr5 0x0 +char shr50x5 shr5 0x0 +__uchar shr50x5 shr5 0x0 +__longlong shr50x5 shr5 0x0 +__ulonglong shr50x5 shr5 0x0 +int add420x5 add42 0x2f +__uint add420x5 add42 0x2f +char add420x5 add42 0x2f +__uchar add420x5 add42 0x2f +__longlong add420x5 add42 0x2f +__ulonglong add420x5 add42 0x2f +float add420x5 add42 0x2f +int sub420x5 sub42 -0x25 +__uint sub420x5 sub42 -0x25 +char sub420x5 sub42 -0x25 +__uchar sub420x5 sub42 0xdb +__longlong sub420x5 sub42 -0x25 +__ulonglong sub420x5 sub42 -0x25 +float sub420x5 sub42 -0x25 +int mul420x5 mul42 0xd2 +__uint mul420x5 mul42 0xd2 +char mul420x5 mul42 -0x2e +__uchar mul420x5 mul42 0xd2 +__longlong mul420x5 mul42 0xd2 +__ulonglong mul420x5 mul42 0xd2 +float mul420x5 mul42 0xd2 +int lt420x5 lt42 0x1 +__uint lt420x5 lt42 0x1 +char lt420x5 lt42 0x1 +__uchar lt420x5 lt42 0x1 +__longlong lt420x5 lt42 0x1 +__ulonglong lt420x5 lt42 0x1 +float lt420x5 lt42 0x1 +int gt420x5 gt42 0x0 +__uint gt420x5 gt42 0x0 +char gt420x5 gt42 0x0 +__uchar gt420x5 gt42 0x0 +__longlong gt420x5 gt42 0x0 +__ulonglong gt420x5 gt42 0x0 +float gt420x5 gt42 0x0 +int le420x5 le42 0x1 +__uint le420x5 le42 0x1 +char le420x5 le42 0x1 +__uchar le420x5 le42 0x1 +__longlong le420x5 le42 0x1 +__ulonglong le420x5 le42 0x1 +float le420x5 le42 0x1 +int eq420x5 eq42 0x0 +__uint eq420x5 eq42 0x0 +char eq420x5 eq42 0x0 +__uchar eq420x5 eq42 0x0 +__longlong eq420x5 eq42 0x0 +__ulonglong eq420x5 eq42 0x0 +float eq420x5 eq42 0x0 +int ne420x5 ne42 0x1 +__uint ne420x5 ne42 0x1 +char ne420x5 ne42 0x1 +__uchar ne420x5 ne42 0x1 +__longlong ne420x5 ne42 0x1 +__ulonglong ne420x5 ne42 0x1 +float ne420x5 ne42 0x1 +int ge420x5 ge42 0x0 +__uint ge420x5 ge42 0x0 +char ge420x5 ge42 0x0 +__uchar ge420x5 ge42 0x0 +__longlong ge420x5 ge42 0x0 +__ulonglong ge420x5 ge42 0x0 +float ge420x5 ge42 0x0 +int div420x5 div42 0x0 +__uint div420x5 div42 0x0 +char div420x5 div42 0x0 +__uchar div420x5 div42 0x0 +__longlong div420x5 div42 0x0 +__ulonglong div420x5 div42 0x0 +float div420x5 div42 0x0 +int mod230x5 mod23 0x5 +__uint mod230x5 mod23 0x5 +char mod230x5 mod23 0x5 +__uchar mod230x5 mod23 0x5 +__longlong mod230x5 mod23 0x5 +__ulonglong mod230x5 mod23 0x5 +0x7 * 0xffff == -0x7 +0x7 / 0xffff == -0x7 +0x7 % 0xffff == 0x0 +int 0x7 ^ 0xffff == -0x8 (0xfff8) +__uint 0x7 ^ 0xffff == -0x8 (0xfff8) +char 0x7 ^ 0xffff == -0x8 (0xfff8) +__uchar 0x7 ^ 0xff == 0xf8 (0xf8) +__longlong 0x7 ^ 0xffff == -0x8 (0xfff8) +__ulonglong 0x7 ^ 0xffff == -0x8 (0xfff8) +int 0x7 && 0xffff == 0x1 (0x1) +__uint 0x7 && 0xffff == 0x1 (0x1) +char 0x7 && 0xffff == 0x1 (0x1) +__uchar 0x7 && 0xff == 0x1 (0x1) +__longlong 0x7 && 0xffff == 0x1 (0x1) +__ulonglong 0x7 && 0xffff == 0x1 (0x1) +int 0x7 || 0xffff == 0x1 (0x1) +__uint 0x7 || 0xffff == 0x1 (0x1) +char 0x7 || 0xffff == 0x1 (0x1) +__uchar 0x7 || 0xff == 0x1 (0x1) +__longlong 0x7 || 0xffff == 0x1 (0x1) +__ulonglong 0x7 || 0xffff == 0x1 (0x1) +int 0x7 & 0xffff == 0x7 (0x7) +__uint 0x7 & 0xffff == 0x7 (0x7) +char 0x7 & 0xffff == 0x7 (0x7) +__uchar 0x7 & 0xff == 0x7 (0x7) +__longlong 0x7 & 0xffff == 0x7 (0x7) +__ulonglong 0x7 & 0xffff == 0x7 (0x7) +int 0x7 | 0xffff == -0x1 (0xffff) +__uint 0x7 | 0xffff == -0x1 (0xffff) +char 0x7 | 0xffff == -0x1 (0xffff) +__uchar 0x7 | 0xff == 0xff (0xff) +__longlong 0x7 | 0xffff == -0x1 (0xffff) +__ulonglong 0x7 | 0xffff == -0x1 (0xffff) +int 0x7 << 0x1 == 0xe (0xe) +__uint 0x7 << 0x1 == 0xe (0xe) +char 0x7 << 0x1 == 0xe (0xe) +__uchar 0x7 << 0x1 == 0xe (0xe) +__longlong 0x7 << 0x1 == 0xe (0xe) +__ulonglong 0x7 << 0x1 == 0xe (0xe) +int 0x7 >> 0x1 == 0x3 (0x3) +__uint 0x7 >> 0x1 == 0x3 (0x3) +char 0x7 >> 0x1 == 0x3 (0x3) +__uchar 0x7 >> 0x1 == 0x3 (0x3) +__longlong 0x7 >> 0x1 == 0x3 (0x3) +__ulonglong 0x7 >> 0x1 == 0x3 (0x3) +int 0x7 + 0xffff == 0x6 (0x6) +__uint 0x7 + 0xffff == 0x6 (0x6) +char 0x7 + 0xffff == 0x6 (0x6) +__uchar 0x7 + 0xff == 0x6 (0x6) +__longlong 0x7 + 0xffff == 0x6 (0x6) +__ulonglong 0x7 + 0xffff == 0x6 (0x6) +float 0x7 + 0xffff == 0x6 (0x6) +int 0x7 - 0xffff == 0x8 (0x8) +__uint 0x7 - 0xffff == 0x8 (0x8) +char 0x7 - 0xffff == 0x8 (0x8) +__uchar 0x7 - 0xff == 0x8 (0x8) +__longlong 0x7 - 0xffff == 0x8 (0x8) +__ulonglong 0x7 - 0xffff == 0x8 (0x8) +float 0x7 - 0xffff == 0x8 (0x8) +int 0x7 * 0xffff == -0x7 (0xfff9) +__uint 0x7 * 0xffff == -0x7 (0xfff9) +char 0x7 * 0xffff == -0x7 (0xfff9) +__uchar 0x7 * 0xff == 0xf9 (0xf9) +__longlong 0x7 * 0xffff == -0x7 (0xfff9) +__ulonglong 0x7 * 0xffff == -0x7 (0xfff9) +float 0x7 * 0xffff == -0x7 (0xfff9) +int 0x7 < 0xffff == 0x0 (0x0) +__uint 0x7 < 0xffff == 0x1 (0x1) +char 0x7 < 0xffff == 0x0 (0x0) +__uchar 0x7 < 0xff == 0x1 (0x1) +__longlong 0x7 < 0xffff == 0x0 (0x0) +__ulonglong 0x7 < 0xffff == 0x1 (0x1) +float 0x7 < 0xffff == 0x0 (0x0) +int 0x7 > 0xffff == 0x1 (0x1) +__uint 0x7 > 0xffff == 0x0 (0x0) +char 0x7 > 0xffff == 0x1 (0x1) +__uchar 0x7 > 0xff == 0x0 (0x0) +__longlong 0x7 > 0xffff == 0x1 (0x1) +__ulonglong 0x7 > 0xffff == 0x0 (0x0) +float 0x7 > 0xffff == 0x1 (0x1) +int 0x7 <= 0xffff == 0x0 (0x0) +__uint 0x7 <= 0xffff == 0x1 (0x1) +char 0x7 <= 0xffff == 0x0 (0x0) +__uchar 0x7 <= 0xff == 0x1 (0x1) +__longlong 0x7 <= 0xffff == 0x0 (0x0) +__ulonglong 0x7 <= 0xffff == 0x1 (0x1) +float 0x7 <= 0xffff == 0x0 (0x0) +int 0x7 == 0xffff == 0x0 (0x0) +__uint 0x7 == 0xffff == 0x0 (0x0) +char 0x7 == 0xffff == 0x0 (0x0) +__uchar 0x7 == 0xff == 0x0 (0x0) +__longlong 0x7 == 0xffff == 0x0 (0x0) +__ulonglong 0x7 == 0xffff == 0x0 (0x0) +float 0x7 == 0xffff == 0x0 (0x0) +int 0x7 != 0xffff == 0x1 (0x1) +__uint 0x7 != 0xffff == 0x1 (0x1) +char 0x7 != 0xffff == 0x1 (0x1) +__uchar 0x7 != 0xff == 0x1 (0x1) +__longlong 0x7 != 0xffff == 0x1 (0x1) +__ulonglong 0x7 != 0xffff == 0x1 (0x1) +float 0x7 != 0xffff == 0x1 (0x1) +int 0x7 >= 0xffff == 0x1 (0x1) +__uint 0x7 >= 0xffff == 0x0 (0x0) +char 0x7 >= 0xffff == 0x1 (0x1) +__uchar 0x7 >= 0xff == 0x0 (0x0) +__longlong 0x7 >= 0xffff == 0x1 (0x1) +__ulonglong 0x7 >= 0xffff == 0x0 (0x0) +float 0x7 >= 0xffff == 0x1 (0x1) +int 0x7 / 0xffff == -0x7 (0xfff9) +__uint 0x7 / 0xffff == 0x0 (0x0) +char 0x7 / 0xffff == -0x7 (0xfff9) +__uchar 0x7 / 0xff == 0x0 (0x0) +__longlong 0x7 / 0xffff == -0x7 (0xfff9) +__ulonglong 0x7 / 0xffff == 0x0 (0x0) +float 0x7 / 0xffff == -0x7 (0xfff9) +int 0x7 % 0xffff == 0x0 (0x0) +__uint 0x7 % 0xffff == 0x7 (0x7) +char 0x7 % 0xffff == 0x0 (0x0) +__uchar 0x7 % 0xff == 0x7 (0x7) +__longlong 0x7 % 0xffff == 0x0 (0x0) +__ulonglong 0x7 % 0xffff == 0x7 (0x7) +0x7 * 0x1 == 0x7 +0x7 / 0x1 == 0x7 +0x7 % 0x1 == 0x0 +int 0x7 ^ 0x1 == 0x6 (0x6) +__uint 0x7 ^ 0x1 == 0x6 (0x6) +char 0x7 ^ 0x1 == 0x6 (0x6) +__uchar 0x7 ^ 0x1 == 0x6 (0x6) +__longlong 0x7 ^ 0x1 == 0x6 (0x6) +__ulonglong 0x7 ^ 0x1 == 0x6 (0x6) +int 0x7 && 0x1 == 0x1 (0x1) +__uint 0x7 && 0x1 == 0x1 (0x1) +char 0x7 && 0x1 == 0x1 (0x1) +__uchar 0x7 && 0x1 == 0x1 (0x1) +__longlong 0x7 && 0x1 == 0x1 (0x1) +__ulonglong 0x7 && 0x1 == 0x1 (0x1) +int 0x7 || 0x1 == 0x1 (0x1) +__uint 0x7 || 0x1 == 0x1 (0x1) +char 0x7 || 0x1 == 0x1 (0x1) +__uchar 0x7 || 0x1 == 0x1 (0x1) +__longlong 0x7 || 0x1 == 0x1 (0x1) +__ulonglong 0x7 || 0x1 == 0x1 (0x1) +int 0x7 & 0x1 == 0x1 (0x1) +__uint 0x7 & 0x1 == 0x1 (0x1) +char 0x7 & 0x1 == 0x1 (0x1) +__uchar 0x7 & 0x1 == 0x1 (0x1) +__longlong 0x7 & 0x1 == 0x1 (0x1) +__ulonglong 0x7 & 0x1 == 0x1 (0x1) +int 0x7 | 0x1 == 0x7 (0x7) +__uint 0x7 | 0x1 == 0x7 (0x7) +char 0x7 | 0x1 == 0x7 (0x7) +__uchar 0x7 | 0x1 == 0x7 (0x7) +__longlong 0x7 | 0x1 == 0x7 (0x7) +__ulonglong 0x7 | 0x1 == 0x7 (0x7) +int 0x7 << 0x2 == 0x1c (0x1c) +__uint 0x7 << 0x2 == 0x1c (0x1c) +char 0x7 << 0x2 == 0x1c (0x1c) +__uchar 0x7 << 0x2 == 0x1c (0x1c) +__longlong 0x7 << 0x2 == 0x1c (0x1c) +__ulonglong 0x7 << 0x2 == 0x1c (0x1c) +int 0x7 >> 0x2 == 0x1 (0x1) +__uint 0x7 >> 0x2 == 0x1 (0x1) +char 0x7 >> 0x2 == 0x1 (0x1) +__uchar 0x7 >> 0x2 == 0x1 (0x1) +__longlong 0x7 >> 0x2 == 0x1 (0x1) +__ulonglong 0x7 >> 0x2 == 0x1 (0x1) +int 0x7 + 0x1 == 0x8 (0x8) +__uint 0x7 + 0x1 == 0x8 (0x8) +char 0x7 + 0x1 == 0x8 (0x8) +__uchar 0x7 + 0x1 == 0x8 (0x8) +__longlong 0x7 + 0x1 == 0x8 (0x8) +__ulonglong 0x7 + 0x1 == 0x8 (0x8) +float 0x7 + 0x1 == 0x8 (0x8) +int 0x7 - 0x1 == 0x6 (0x6) +__uint 0x7 - 0x1 == 0x6 (0x6) +char 0x7 - 0x1 == 0x6 (0x6) +__uchar 0x7 - 0x1 == 0x6 (0x6) +__longlong 0x7 - 0x1 == 0x6 (0x6) +__ulonglong 0x7 - 0x1 == 0x6 (0x6) +float 0x7 - 0x1 == 0x6 (0x6) +int 0x7 * 0x1 == 0x7 (0x7) +__uint 0x7 * 0x1 == 0x7 (0x7) +char 0x7 * 0x1 == 0x7 (0x7) +__uchar 0x7 * 0x1 == 0x7 (0x7) +__longlong 0x7 * 0x1 == 0x7 (0x7) +__ulonglong 0x7 * 0x1 == 0x7 (0x7) +float 0x7 * 0x1 == 0x7 (0x7) +int 0x7 < 0x1 == 0x0 (0x0) +__uint 0x7 < 0x1 == 0x0 (0x0) +char 0x7 < 0x1 == 0x0 (0x0) +__uchar 0x7 < 0x1 == 0x0 (0x0) +__longlong 0x7 < 0x1 == 0x0 (0x0) +__ulonglong 0x7 < 0x1 == 0x0 (0x0) +float 0x7 < 0x1 == 0x0 (0x0) +int 0x7 > 0x1 == 0x1 (0x1) +__uint 0x7 > 0x1 == 0x1 (0x1) +char 0x7 > 0x1 == 0x1 (0x1) +__uchar 0x7 > 0x1 == 0x1 (0x1) +__longlong 0x7 > 0x1 == 0x1 (0x1) +__ulonglong 0x7 > 0x1 == 0x1 (0x1) +float 0x7 > 0x1 == 0x1 (0x1) +int 0x7 <= 0x1 == 0x0 (0x0) +__uint 0x7 <= 0x1 == 0x0 (0x0) +char 0x7 <= 0x1 == 0x0 (0x0) +__uchar 0x7 <= 0x1 == 0x0 (0x0) +__longlong 0x7 <= 0x1 == 0x0 (0x0) +__ulonglong 0x7 <= 0x1 == 0x0 (0x0) +float 0x7 <= 0x1 == 0x0 (0x0) +int 0x7 == 0x1 == 0x0 (0x0) +__uint 0x7 == 0x1 == 0x0 (0x0) +char 0x7 == 0x1 == 0x0 (0x0) +__uchar 0x7 == 0x1 == 0x0 (0x0) +__longlong 0x7 == 0x1 == 0x0 (0x0) +__ulonglong 0x7 == 0x1 == 0x0 (0x0) +float 0x7 == 0x1 == 0x0 (0x0) +int 0x7 != 0x1 == 0x1 (0x1) +__uint 0x7 != 0x1 == 0x1 (0x1) +char 0x7 != 0x1 == 0x1 (0x1) +__uchar 0x7 != 0x1 == 0x1 (0x1) +__longlong 0x7 != 0x1 == 0x1 (0x1) +__ulonglong 0x7 != 0x1 == 0x1 (0x1) +float 0x7 != 0x1 == 0x1 (0x1) +int 0x7 >= 0x1 == 0x1 (0x1) +__uint 0x7 >= 0x1 == 0x1 (0x1) +char 0x7 >= 0x1 == 0x1 (0x1) +__uchar 0x7 >= 0x1 == 0x1 (0x1) +__longlong 0x7 >= 0x1 == 0x1 (0x1) +__ulonglong 0x7 >= 0x1 == 0x1 (0x1) +float 0x7 >= 0x1 == 0x1 (0x1) +int 0x7 / 0x1 == 0x7 (0x7) +__uint 0x7 / 0x1 == 0x7 (0x7) +char 0x7 / 0x1 == 0x7 (0x7) +__uchar 0x7 / 0x1 == 0x7 (0x7) +__longlong 0x7 / 0x1 == 0x7 (0x7) +__ulonglong 0x7 / 0x1 == 0x7 (0x7) +float 0x7 / 0x1 == 0x7 (0x7) +int 0x7 % 0x1 == 0x0 (0x0) +__uint 0x7 % 0x1 == 0x0 (0x0) +char 0x7 % 0x1 == 0x0 (0x0) +__uchar 0x7 % 0x1 == 0x0 (0x0) +__longlong 0x7 % 0x1 == 0x0 (0x0) +__ulonglong 0x7 % 0x1 == 0x0 (0x0) +0x7 * 0x2 == 0xe +0x7 / 0x2 == 0x3 +0x7 % 0x2 == 0x1 +int 0x7 ^ 0x2 == 0x5 (0x5) +__uint 0x7 ^ 0x2 == 0x5 (0x5) +char 0x7 ^ 0x2 == 0x5 (0x5) +__uchar 0x7 ^ 0x2 == 0x5 (0x5) +__longlong 0x7 ^ 0x2 == 0x5 (0x5) +__ulonglong 0x7 ^ 0x2 == 0x5 (0x5) +int 0x7 && 0x2 == 0x1 (0x1) +__uint 0x7 && 0x2 == 0x1 (0x1) +char 0x7 && 0x2 == 0x1 (0x1) +__uchar 0x7 && 0x2 == 0x1 (0x1) +__longlong 0x7 && 0x2 == 0x1 (0x1) +__ulonglong 0x7 && 0x2 == 0x1 (0x1) +int 0x7 || 0x2 == 0x1 (0x1) +__uint 0x7 || 0x2 == 0x1 (0x1) +char 0x7 || 0x2 == 0x1 (0x1) +__uchar 0x7 || 0x2 == 0x1 (0x1) +__longlong 0x7 || 0x2 == 0x1 (0x1) +__ulonglong 0x7 || 0x2 == 0x1 (0x1) +int 0x7 & 0x2 == 0x2 (0x2) +__uint 0x7 & 0x2 == 0x2 (0x2) +char 0x7 & 0x2 == 0x2 (0x2) +__uchar 0x7 & 0x2 == 0x2 (0x2) +__longlong 0x7 & 0x2 == 0x2 (0x2) +__ulonglong 0x7 & 0x2 == 0x2 (0x2) +int 0x7 | 0x2 == 0x7 (0x7) +__uint 0x7 | 0x2 == 0x7 (0x7) +char 0x7 | 0x2 == 0x7 (0x7) +__uchar 0x7 | 0x2 == 0x7 (0x7) +__longlong 0x7 | 0x2 == 0x7 (0x7) +__ulonglong 0x7 | 0x2 == 0x7 (0x7) +int 0x7 << 0x3 == 0x38 (0x38) +__uint 0x7 << 0x3 == 0x38 (0x38) +char 0x7 << 0x3 == 0x38 (0x38) +__uchar 0x7 << 0x3 == 0x38 (0x38) +__longlong 0x7 << 0x3 == 0x38 (0x38) +__ulonglong 0x7 << 0x3 == 0x38 (0x38) +int 0x7 >> 0x3 == 0x0 (0x0) +__uint 0x7 >> 0x3 == 0x0 (0x0) +char 0x7 >> 0x3 == 0x0 (0x0) +__uchar 0x7 >> 0x3 == 0x0 (0x0) +__longlong 0x7 >> 0x3 == 0x0 (0x0) +__ulonglong 0x7 >> 0x3 == 0x0 (0x0) +int 0x7 + 0x2 == 0x9 (0x9) +__uint 0x7 + 0x2 == 0x9 (0x9) +char 0x7 + 0x2 == 0x9 (0x9) +__uchar 0x7 + 0x2 == 0x9 (0x9) +__longlong 0x7 + 0x2 == 0x9 (0x9) +__ulonglong 0x7 + 0x2 == 0x9 (0x9) +float 0x7 + 0x2 == 0x9 (0x9) +int 0x7 - 0x2 == 0x5 (0x5) +__uint 0x7 - 0x2 == 0x5 (0x5) +char 0x7 - 0x2 == 0x5 (0x5) +__uchar 0x7 - 0x2 == 0x5 (0x5) +__longlong 0x7 - 0x2 == 0x5 (0x5) +__ulonglong 0x7 - 0x2 == 0x5 (0x5) +float 0x7 - 0x2 == 0x5 (0x5) +int 0x7 * 0x2 == 0xe (0xe) +__uint 0x7 * 0x2 == 0xe (0xe) +char 0x7 * 0x2 == 0xe (0xe) +__uchar 0x7 * 0x2 == 0xe (0xe) +__longlong 0x7 * 0x2 == 0xe (0xe) +__ulonglong 0x7 * 0x2 == 0xe (0xe) +float 0x7 * 0x2 == 0xe (0xe) +int 0x7 < 0x2 == 0x0 (0x0) +__uint 0x7 < 0x2 == 0x0 (0x0) +char 0x7 < 0x2 == 0x0 (0x0) +__uchar 0x7 < 0x2 == 0x0 (0x0) +__longlong 0x7 < 0x2 == 0x0 (0x0) +__ulonglong 0x7 < 0x2 == 0x0 (0x0) +float 0x7 < 0x2 == 0x0 (0x0) +int 0x7 > 0x2 == 0x1 (0x1) +__uint 0x7 > 0x2 == 0x1 (0x1) +char 0x7 > 0x2 == 0x1 (0x1) +__uchar 0x7 > 0x2 == 0x1 (0x1) +__longlong 0x7 > 0x2 == 0x1 (0x1) +__ulonglong 0x7 > 0x2 == 0x1 (0x1) +float 0x7 > 0x2 == 0x1 (0x1) +int 0x7 <= 0x2 == 0x0 (0x0) +__uint 0x7 <= 0x2 == 0x0 (0x0) +char 0x7 <= 0x2 == 0x0 (0x0) +__uchar 0x7 <= 0x2 == 0x0 (0x0) +__longlong 0x7 <= 0x2 == 0x0 (0x0) +__ulonglong 0x7 <= 0x2 == 0x0 (0x0) +float 0x7 <= 0x2 == 0x0 (0x0) +int 0x7 == 0x2 == 0x0 (0x0) +__uint 0x7 == 0x2 == 0x0 (0x0) +char 0x7 == 0x2 == 0x0 (0x0) +__uchar 0x7 == 0x2 == 0x0 (0x0) +__longlong 0x7 == 0x2 == 0x0 (0x0) +__ulonglong 0x7 == 0x2 == 0x0 (0x0) +float 0x7 == 0x2 == 0x0 (0x0) +int 0x7 != 0x2 == 0x1 (0x1) +__uint 0x7 != 0x2 == 0x1 (0x1) +char 0x7 != 0x2 == 0x1 (0x1) +__uchar 0x7 != 0x2 == 0x1 (0x1) +__longlong 0x7 != 0x2 == 0x1 (0x1) +__ulonglong 0x7 != 0x2 == 0x1 (0x1) +float 0x7 != 0x2 == 0x1 (0x1) +int 0x7 >= 0x2 == 0x1 (0x1) +__uint 0x7 >= 0x2 == 0x1 (0x1) +char 0x7 >= 0x2 == 0x1 (0x1) +__uchar 0x7 >= 0x2 == 0x1 (0x1) +__longlong 0x7 >= 0x2 == 0x1 (0x1) +__ulonglong 0x7 >= 0x2 == 0x1 (0x1) +float 0x7 >= 0x2 == 0x1 (0x1) +int 0x7 / 0x2 == 0x3 (0x3) +__uint 0x7 / 0x2 == 0x3 (0x3) +char 0x7 / 0x2 == 0x3 (0x3) +__uchar 0x7 / 0x2 == 0x3 (0x3) +__longlong 0x7 / 0x2 == 0x3 (0x3) +__ulonglong 0x7 / 0x2 == 0x3 (0x3) +float 0x7 / 0x2 == 0x3 (0x3) +int 0x7 % 0x2 == 0x1 (0x1) +__uint 0x7 % 0x2 == 0x1 (0x1) +char 0x7 % 0x2 == 0x1 (0x1) +__uchar 0x7 % 0x2 == 0x1 (0x1) +__longlong 0x7 % 0x2 == 0x1 (0x1) +__ulonglong 0x7 % 0x2 == 0x1 (0x1) +0x7 * 0xfffe == -0xe +0x7 / 0xfffe == -0x3 +0x7 % 0xfffe == 0x1 +int 0x7 ^ 0xfffe == -0x7 (0xfff9) +__uint 0x7 ^ 0xfffe == -0x7 (0xfff9) +char 0x7 ^ 0xfffe == -0x7 (0xfff9) +__uchar 0x7 ^ 0xfe == 0xf9 (0xf9) +__longlong 0x7 ^ 0xfffe == -0x7 (0xfff9) +__ulonglong 0x7 ^ 0xfffe == -0x7 (0xfff9) +int 0x7 && 0xfffe == 0x1 (0x1) +__uint 0x7 && 0xfffe == 0x1 (0x1) +char 0x7 && 0xfffe == 0x1 (0x1) +__uchar 0x7 && 0xfe == 0x1 (0x1) +__longlong 0x7 && 0xfffe == 0x1 (0x1) +__ulonglong 0x7 && 0xfffe == 0x1 (0x1) +int 0x7 || 0xfffe == 0x1 (0x1) +__uint 0x7 || 0xfffe == 0x1 (0x1) +char 0x7 || 0xfffe == 0x1 (0x1) +__uchar 0x7 || 0xfe == 0x1 (0x1) +__longlong 0x7 || 0xfffe == 0x1 (0x1) +__ulonglong 0x7 || 0xfffe == 0x1 (0x1) +int 0x7 & 0xfffe == 0x6 (0x6) +__uint 0x7 & 0xfffe == 0x6 (0x6) +char 0x7 & 0xfffe == 0x6 (0x6) +__uchar 0x7 & 0xfe == 0x6 (0x6) +__longlong 0x7 & 0xfffe == 0x6 (0x6) +__ulonglong 0x7 & 0xfffe == 0x6 (0x6) +int 0x7 | 0xfffe == -0x1 (0xffff) +__uint 0x7 | 0xfffe == -0x1 (0xffff) +char 0x7 | 0xfffe == -0x1 (0xffff) +__uchar 0x7 | 0xfe == 0xff (0xff) +__longlong 0x7 | 0xfffe == -0x1 (0xffff) +__ulonglong 0x7 | 0xfffe == -0x1 (0xffff) +int 0x7 << 0x4 == 0x70 (0x70) +__uint 0x7 << 0x4 == 0x70 (0x70) +char 0x7 << 0x4 == 0x70 (0x70) +__uchar 0x7 << 0x4 == 0x70 (0x70) +__longlong 0x7 << 0x4 == 0x70 (0x70) +__ulonglong 0x7 << 0x4 == 0x70 (0x70) +int 0x7 >> 0x4 == 0x0 (0x0) +__uint 0x7 >> 0x4 == 0x0 (0x0) +char 0x7 >> 0x4 == 0x0 (0x0) +__uchar 0x7 >> 0x4 == 0x0 (0x0) +__longlong 0x7 >> 0x4 == 0x0 (0x0) +__ulonglong 0x7 >> 0x4 == 0x0 (0x0) +int 0x7 + 0xfffe == 0x5 (0x5) +__uint 0x7 + 0xfffe == 0x5 (0x5) +char 0x7 + 0xfffe == 0x5 (0x5) +__uchar 0x7 + 0xfe == 0x5 (0x5) +__longlong 0x7 + 0xfffe == 0x5 (0x5) +__ulonglong 0x7 + 0xfffe == 0x5 (0x5) +float 0x7 + 0xfffe == 0x5 (0x5) +int 0x7 - 0xfffe == 0x9 (0x9) +__uint 0x7 - 0xfffe == 0x9 (0x9) +char 0x7 - 0xfffe == 0x9 (0x9) +__uchar 0x7 - 0xfe == 0x9 (0x9) +__longlong 0x7 - 0xfffe == 0x9 (0x9) +__ulonglong 0x7 - 0xfffe == 0x9 (0x9) +float 0x7 - 0xfffe == 0x9 (0x9) +int 0x7 * 0xfffe == -0xe (0xfff2) +__uint 0x7 * 0xfffe == -0xe (0xfff2) +char 0x7 * 0xfffe == -0xe (0xfff2) +__uchar 0x7 * 0xfe == 0xf2 (0xf2) +__longlong 0x7 * 0xfffe == -0xe (0xfff2) +__ulonglong 0x7 * 0xfffe == -0xe (0xfff2) +float 0x7 * 0xfffe == -0xe (0xfff2) +int 0x7 < 0xfffe == 0x0 (0x0) +__uint 0x7 < 0xfffe == 0x1 (0x1) +char 0x7 < 0xfffe == 0x0 (0x0) +__uchar 0x7 < 0xfe == 0x1 (0x1) +__longlong 0x7 < 0xfffe == 0x0 (0x0) +__ulonglong 0x7 < 0xfffe == 0x1 (0x1) +float 0x7 < 0xfffe == 0x0 (0x0) +int 0x7 > 0xfffe == 0x1 (0x1) +__uint 0x7 > 0xfffe == 0x0 (0x0) +char 0x7 > 0xfffe == 0x1 (0x1) +__uchar 0x7 > 0xfe == 0x0 (0x0) +__longlong 0x7 > 0xfffe == 0x1 (0x1) +__ulonglong 0x7 > 0xfffe == 0x0 (0x0) +float 0x7 > 0xfffe == 0x1 (0x1) +int 0x7 <= 0xfffe == 0x0 (0x0) +__uint 0x7 <= 0xfffe == 0x1 (0x1) +char 0x7 <= 0xfffe == 0x0 (0x0) +__uchar 0x7 <= 0xfe == 0x1 (0x1) +__longlong 0x7 <= 0xfffe == 0x0 (0x0) +__ulonglong 0x7 <= 0xfffe == 0x1 (0x1) +float 0x7 <= 0xfffe == 0x0 (0x0) +int 0x7 == 0xfffe == 0x0 (0x0) +__uint 0x7 == 0xfffe == 0x0 (0x0) +char 0x7 == 0xfffe == 0x0 (0x0) +__uchar 0x7 == 0xfe == 0x0 (0x0) +__longlong 0x7 == 0xfffe == 0x0 (0x0) +__ulonglong 0x7 == 0xfffe == 0x0 (0x0) +float 0x7 == 0xfffe == 0x0 (0x0) +int 0x7 != 0xfffe == 0x1 (0x1) +__uint 0x7 != 0xfffe == 0x1 (0x1) +char 0x7 != 0xfffe == 0x1 (0x1) +__uchar 0x7 != 0xfe == 0x1 (0x1) +__longlong 0x7 != 0xfffe == 0x1 (0x1) +__ulonglong 0x7 != 0xfffe == 0x1 (0x1) +float 0x7 != 0xfffe == 0x1 (0x1) +int 0x7 >= 0xfffe == 0x1 (0x1) +__uint 0x7 >= 0xfffe == 0x0 (0x0) +char 0x7 >= 0xfffe == 0x1 (0x1) +__uchar 0x7 >= 0xfe == 0x0 (0x0) +__longlong 0x7 >= 0xfffe == 0x1 (0x1) +__ulonglong 0x7 >= 0xfffe == 0x0 (0x0) +float 0x7 >= 0xfffe == 0x1 (0x1) +int 0x7 / 0xfffe == -0x3 (0xfffd) +__uint 0x7 / 0xfffe == 0x0 (0x0) +char 0x7 / 0xfffe == -0x3 (0xfffd) +__uchar 0x7 / 0xfe == 0x0 (0x0) +__longlong 0x7 / 0xfffe == -0x3 (0xfffd) +__ulonglong 0x7 / 0xfffe == 0x0 (0x0) +float 0x7 / 0xfffe == -0x3 (0xfffd) +int 0x7 % 0xfffe == 0x1 (0x1) +__uint 0x7 % 0xfffe == 0x7 (0x7) +char 0x7 % 0xfffe == 0x1 (0x1) +__uchar 0x7 % 0xfe == 0x7 (0x7) +__longlong 0x7 % 0xfffe == 0x1 (0x1) +__ulonglong 0x7 % 0xfffe == 0x7 (0x7) +0x7 * 0x4 == 0x1c +0x7 / 0x4 == 0x1 +0x7 % 0x4 == 0x3 +int 0x7 ^ 0x4 == 0x3 (0x3) +__uint 0x7 ^ 0x4 == 0x3 (0x3) +char 0x7 ^ 0x4 == 0x3 (0x3) +__uchar 0x7 ^ 0x4 == 0x3 (0x3) +__longlong 0x7 ^ 0x4 == 0x3 (0x3) +__ulonglong 0x7 ^ 0x4 == 0x3 (0x3) +int 0x7 && 0x4 == 0x1 (0x1) +__uint 0x7 && 0x4 == 0x1 (0x1) +char 0x7 && 0x4 == 0x1 (0x1) +__uchar 0x7 && 0x4 == 0x1 (0x1) +__longlong 0x7 && 0x4 == 0x1 (0x1) +__ulonglong 0x7 && 0x4 == 0x1 (0x1) +int 0x7 || 0x4 == 0x1 (0x1) +__uint 0x7 || 0x4 == 0x1 (0x1) +char 0x7 || 0x4 == 0x1 (0x1) +__uchar 0x7 || 0x4 == 0x1 (0x1) +__longlong 0x7 || 0x4 == 0x1 (0x1) +__ulonglong 0x7 || 0x4 == 0x1 (0x1) +int 0x7 & 0x4 == 0x4 (0x4) +__uint 0x7 & 0x4 == 0x4 (0x4) +char 0x7 & 0x4 == 0x4 (0x4) +__uchar 0x7 & 0x4 == 0x4 (0x4) +__longlong 0x7 & 0x4 == 0x4 (0x4) +__ulonglong 0x7 & 0x4 == 0x4 (0x4) +int 0x7 | 0x4 == 0x7 (0x7) +__uint 0x7 | 0x4 == 0x7 (0x7) +char 0x7 | 0x4 == 0x7 (0x7) +__uchar 0x7 | 0x4 == 0x7 (0x7) +__longlong 0x7 | 0x4 == 0x7 (0x7) +__ulonglong 0x7 | 0x4 == 0x7 (0x7) +int 0x7 << 0x5 == 0xe0 (0xe0) +__uint 0x7 << 0x5 == 0xe0 (0xe0) +char 0x7 << 0x5 == -0x20 (0xffe0) +__uchar 0x7 << 0x5 == 0xe0 (0xe0) +__longlong 0x7 << 0x5 == 0xe0 (0xe0) +__ulonglong 0x7 << 0x5 == 0xe0 (0xe0) +int 0x7 >> 0x5 == 0x0 (0x0) +__uint 0x7 >> 0x5 == 0x0 (0x0) +char 0x7 >> 0x5 == 0x0 (0x0) +__uchar 0x7 >> 0x5 == 0x0 (0x0) +__longlong 0x7 >> 0x5 == 0x0 (0x0) +__ulonglong 0x7 >> 0x5 == 0x0 (0x0) +int 0x7 + 0x4 == 0xb (0xb) +__uint 0x7 + 0x4 == 0xb (0xb) +char 0x7 + 0x4 == 0xb (0xb) +__uchar 0x7 + 0x4 == 0xb (0xb) +__longlong 0x7 + 0x4 == 0xb (0xb) +__ulonglong 0x7 + 0x4 == 0xb (0xb) +float 0x7 + 0x4 == 0xb (0xb) +int 0x7 - 0x4 == 0x3 (0x3) +__uint 0x7 - 0x4 == 0x3 (0x3) +char 0x7 - 0x4 == 0x3 (0x3) +__uchar 0x7 - 0x4 == 0x3 (0x3) +__longlong 0x7 - 0x4 == 0x3 (0x3) +__ulonglong 0x7 - 0x4 == 0x3 (0x3) +float 0x7 - 0x4 == 0x3 (0x3) +int 0x7 * 0x4 == 0x1c (0x1c) +__uint 0x7 * 0x4 == 0x1c (0x1c) +char 0x7 * 0x4 == 0x1c (0x1c) +__uchar 0x7 * 0x4 == 0x1c (0x1c) +__longlong 0x7 * 0x4 == 0x1c (0x1c) +__ulonglong 0x7 * 0x4 == 0x1c (0x1c) +float 0x7 * 0x4 == 0x1c (0x1c) +int 0x7 < 0x4 == 0x0 (0x0) +__uint 0x7 < 0x4 == 0x0 (0x0) +char 0x7 < 0x4 == 0x0 (0x0) +__uchar 0x7 < 0x4 == 0x0 (0x0) +__longlong 0x7 < 0x4 == 0x0 (0x0) +__ulonglong 0x7 < 0x4 == 0x0 (0x0) +float 0x7 < 0x4 == 0x0 (0x0) +int 0x7 > 0x4 == 0x1 (0x1) +__uint 0x7 > 0x4 == 0x1 (0x1) +char 0x7 > 0x4 == 0x1 (0x1) +__uchar 0x7 > 0x4 == 0x1 (0x1) +__longlong 0x7 > 0x4 == 0x1 (0x1) +__ulonglong 0x7 > 0x4 == 0x1 (0x1) +float 0x7 > 0x4 == 0x1 (0x1) +int 0x7 <= 0x4 == 0x0 (0x0) +__uint 0x7 <= 0x4 == 0x0 (0x0) +char 0x7 <= 0x4 == 0x0 (0x0) +__uchar 0x7 <= 0x4 == 0x0 (0x0) +__longlong 0x7 <= 0x4 == 0x0 (0x0) +__ulonglong 0x7 <= 0x4 == 0x0 (0x0) +float 0x7 <= 0x4 == 0x0 (0x0) +int 0x7 == 0x4 == 0x0 (0x0) +__uint 0x7 == 0x4 == 0x0 (0x0) +char 0x7 == 0x4 == 0x0 (0x0) +__uchar 0x7 == 0x4 == 0x0 (0x0) +__longlong 0x7 == 0x4 == 0x0 (0x0) +__ulonglong 0x7 == 0x4 == 0x0 (0x0) +float 0x7 == 0x4 == 0x0 (0x0) +int 0x7 != 0x4 == 0x1 (0x1) +__uint 0x7 != 0x4 == 0x1 (0x1) +char 0x7 != 0x4 == 0x1 (0x1) +__uchar 0x7 != 0x4 == 0x1 (0x1) +__longlong 0x7 != 0x4 == 0x1 (0x1) +__ulonglong 0x7 != 0x4 == 0x1 (0x1) +float 0x7 != 0x4 == 0x1 (0x1) +int 0x7 >= 0x4 == 0x1 (0x1) +__uint 0x7 >= 0x4 == 0x1 (0x1) +char 0x7 >= 0x4 == 0x1 (0x1) +__uchar 0x7 >= 0x4 == 0x1 (0x1) +__longlong 0x7 >= 0x4 == 0x1 (0x1) +__ulonglong 0x7 >= 0x4 == 0x1 (0x1) +float 0x7 >= 0x4 == 0x1 (0x1) +int 0x7 / 0x4 == 0x1 (0x1) +__uint 0x7 / 0x4 == 0x1 (0x1) +char 0x7 / 0x4 == 0x1 (0x1) +__uchar 0x7 / 0x4 == 0x1 (0x1) +__longlong 0x7 / 0x4 == 0x1 (0x1) +__ulonglong 0x7 / 0x4 == 0x1 (0x1) +float 0x7 / 0x4 == 0x1 (0x1) +int 0x7 % 0x4 == 0x3 (0x3) +__uint 0x7 % 0x4 == 0x3 (0x3) +char 0x7 % 0x4 == 0x3 (0x3) +__uchar 0x7 % 0x4 == 0x3 (0x3) +__longlong 0x7 % 0x4 == 0x3 (0x3) +__ulonglong 0x7 % 0x4 == 0x3 (0x3) +0x7 * 0xfffc == -0x1c +0x7 / 0xfffc == -0x1 +0x7 % 0xfffc == 0x3 +int 0x7 ^ 0xfffc == -0x5 (0xfffb) +__uint 0x7 ^ 0xfffc == -0x5 (0xfffb) +char 0x7 ^ 0xfffc == -0x5 (0xfffb) +__uchar 0x7 ^ 0xfc == 0xfb (0xfb) +__longlong 0x7 ^ 0xfffc == -0x5 (0xfffb) +__ulonglong 0x7 ^ 0xfffc == -0x5 (0xfffb) +int 0x7 && 0xfffc == 0x1 (0x1) +__uint 0x7 && 0xfffc == 0x1 (0x1) +char 0x7 && 0xfffc == 0x1 (0x1) +__uchar 0x7 && 0xfc == 0x1 (0x1) +__longlong 0x7 && 0xfffc == 0x1 (0x1) +__ulonglong 0x7 && 0xfffc == 0x1 (0x1) +int 0x7 || 0xfffc == 0x1 (0x1) +__uint 0x7 || 0xfffc == 0x1 (0x1) +char 0x7 || 0xfffc == 0x1 (0x1) +__uchar 0x7 || 0xfc == 0x1 (0x1) +__longlong 0x7 || 0xfffc == 0x1 (0x1) +__ulonglong 0x7 || 0xfffc == 0x1 (0x1) +int 0x7 & 0xfffc == 0x4 (0x4) +__uint 0x7 & 0xfffc == 0x4 (0x4) +char 0x7 & 0xfffc == 0x4 (0x4) +__uchar 0x7 & 0xfc == 0x4 (0x4) +__longlong 0x7 & 0xfffc == 0x4 (0x4) +__ulonglong 0x7 & 0xfffc == 0x4 (0x4) +int 0x7 | 0xfffc == -0x1 (0xffff) +__uint 0x7 | 0xfffc == -0x1 (0xffff) +char 0x7 | 0xfffc == -0x1 (0xffff) +__uchar 0x7 | 0xfc == 0xff (0xff) +__longlong 0x7 | 0xfffc == -0x1 (0xffff) +__ulonglong 0x7 | 0xfffc == -0x1 (0xffff) +int 0x7 << 0x6 == 0x1c0 (0x1c0) +__uint 0x7 << 0x6 == 0x1c0 (0x1c0) +char 0x7 << 0x6 == -0x40 (0xffc0) +__uchar 0x7 << 0x6 == 0xc0 (0xc0) +__longlong 0x7 << 0x6 == 0x1c0 (0x1c0) +__ulonglong 0x7 << 0x6 == 0x1c0 (0x1c0) +int 0x7 >> 0x6 == 0x0 (0x0) +__uint 0x7 >> 0x6 == 0x0 (0x0) +char 0x7 >> 0x6 == 0x0 (0x0) +__uchar 0x7 >> 0x6 == 0x0 (0x0) +__longlong 0x7 >> 0x6 == 0x0 (0x0) +__ulonglong 0x7 >> 0x6 == 0x0 (0x0) +int 0x7 + 0xfffc == 0x3 (0x3) +__uint 0x7 + 0xfffc == 0x3 (0x3) +char 0x7 + 0xfffc == 0x3 (0x3) +__uchar 0x7 + 0xfc == 0x3 (0x3) +__longlong 0x7 + 0xfffc == 0x3 (0x3) +__ulonglong 0x7 + 0xfffc == 0x3 (0x3) +float 0x7 + 0xfffc == 0x3 (0x3) +int 0x7 - 0xfffc == 0xb (0xb) +__uint 0x7 - 0xfffc == 0xb (0xb) +char 0x7 - 0xfffc == 0xb (0xb) +__uchar 0x7 - 0xfc == 0xb (0xb) +__longlong 0x7 - 0xfffc == 0xb (0xb) +__ulonglong 0x7 - 0xfffc == 0xb (0xb) +float 0x7 - 0xfffc == 0xb (0xb) +int 0x7 * 0xfffc == -0x1c (0xffe4) +__uint 0x7 * 0xfffc == -0x1c (0xffe4) +char 0x7 * 0xfffc == -0x1c (0xffe4) +__uchar 0x7 * 0xfc == 0xe4 (0xe4) +__longlong 0x7 * 0xfffc == -0x1c (0xffe4) +__ulonglong 0x7 * 0xfffc == -0x1c (0xffe4) +float 0x7 * 0xfffc == -0x1c (0xffe4) +int 0x7 < 0xfffc == 0x0 (0x0) +__uint 0x7 < 0xfffc == 0x1 (0x1) +char 0x7 < 0xfffc == 0x0 (0x0) +__uchar 0x7 < 0xfc == 0x1 (0x1) +__longlong 0x7 < 0xfffc == 0x0 (0x0) +__ulonglong 0x7 < 0xfffc == 0x1 (0x1) +float 0x7 < 0xfffc == 0x0 (0x0) +int 0x7 > 0xfffc == 0x1 (0x1) +__uint 0x7 > 0xfffc == 0x0 (0x0) +char 0x7 > 0xfffc == 0x1 (0x1) +__uchar 0x7 > 0xfc == 0x0 (0x0) +__longlong 0x7 > 0xfffc == 0x1 (0x1) +__ulonglong 0x7 > 0xfffc == 0x0 (0x0) +float 0x7 > 0xfffc == 0x1 (0x1) +int 0x7 <= 0xfffc == 0x0 (0x0) +__uint 0x7 <= 0xfffc == 0x1 (0x1) +char 0x7 <= 0xfffc == 0x0 (0x0) +__uchar 0x7 <= 0xfc == 0x1 (0x1) +__longlong 0x7 <= 0xfffc == 0x0 (0x0) +__ulonglong 0x7 <= 0xfffc == 0x1 (0x1) +float 0x7 <= 0xfffc == 0x0 (0x0) +int 0x7 == 0xfffc == 0x0 (0x0) +__uint 0x7 == 0xfffc == 0x0 (0x0) +char 0x7 == 0xfffc == 0x0 (0x0) +__uchar 0x7 == 0xfc == 0x0 (0x0) +__longlong 0x7 == 0xfffc == 0x0 (0x0) +__ulonglong 0x7 == 0xfffc == 0x0 (0x0) +float 0x7 == 0xfffc == 0x0 (0x0) +int 0x7 != 0xfffc == 0x1 (0x1) +__uint 0x7 != 0xfffc == 0x1 (0x1) +char 0x7 != 0xfffc == 0x1 (0x1) +__uchar 0x7 != 0xfc == 0x1 (0x1) +__longlong 0x7 != 0xfffc == 0x1 (0x1) +__ulonglong 0x7 != 0xfffc == 0x1 (0x1) +float 0x7 != 0xfffc == 0x1 (0x1) +int 0x7 >= 0xfffc == 0x1 (0x1) +__uint 0x7 >= 0xfffc == 0x0 (0x0) +char 0x7 >= 0xfffc == 0x1 (0x1) +__uchar 0x7 >= 0xfc == 0x0 (0x0) +__longlong 0x7 >= 0xfffc == 0x1 (0x1) +__ulonglong 0x7 >= 0xfffc == 0x0 (0x0) +float 0x7 >= 0xfffc == 0x1 (0x1) +int 0x7 / 0xfffc == -0x1 (0xffff) +__uint 0x7 / 0xfffc == 0x0 (0x0) +char 0x7 / 0xfffc == -0x1 (0xffff) +__uchar 0x7 / 0xfc == 0x0 (0x0) +__longlong 0x7 / 0xfffc == -0x1 (0xffff) +__ulonglong 0x7 / 0xfffc == 0x0 (0x0) +float 0x7 / 0xfffc == -0x1 (0xffff) +int 0x7 % 0xfffc == 0x3 (0x3) +__uint 0x7 % 0xfffc == 0x7 (0x7) +char 0x7 % 0xfffc == 0x3 (0x3) +__uchar 0x7 % 0xfc == 0x7 (0x7) +__longlong 0x7 % 0xfffc == 0x3 (0x3) +__ulonglong 0x7 % 0xfffc == 0x7 (0x7) +0x7 * 0xa == 0x46 +0x7 / 0xa == 0x0 +0x7 % 0xa == 0x7 +int 0x7 ^ 0xa == 0xd (0xd) +__uint 0x7 ^ 0xa == 0xd (0xd) +char 0x7 ^ 0xa == 0xd (0xd) +__uchar 0x7 ^ 0xa == 0xd (0xd) +__longlong 0x7 ^ 0xa == 0xd (0xd) +__ulonglong 0x7 ^ 0xa == 0xd (0xd) +int 0x7 && 0xa == 0x1 (0x1) +__uint 0x7 && 0xa == 0x1 (0x1) +char 0x7 && 0xa == 0x1 (0x1) +__uchar 0x7 && 0xa == 0x1 (0x1) +__longlong 0x7 && 0xa == 0x1 (0x1) +__ulonglong 0x7 && 0xa == 0x1 (0x1) +int 0x7 || 0xa == 0x1 (0x1) +__uint 0x7 || 0xa == 0x1 (0x1) +char 0x7 || 0xa == 0x1 (0x1) +__uchar 0x7 || 0xa == 0x1 (0x1) +__longlong 0x7 || 0xa == 0x1 (0x1) +__ulonglong 0x7 || 0xa == 0x1 (0x1) +int 0x7 & 0xa == 0x2 (0x2) +__uint 0x7 & 0xa == 0x2 (0x2) +char 0x7 & 0xa == 0x2 (0x2) +__uchar 0x7 & 0xa == 0x2 (0x2) +__longlong 0x7 & 0xa == 0x2 (0x2) +__ulonglong 0x7 & 0xa == 0x2 (0x2) +int 0x7 | 0xa == 0xf (0xf) +__uint 0x7 | 0xa == 0xf (0xf) +char 0x7 | 0xa == 0xf (0xf) +__uchar 0x7 | 0xa == 0xf (0xf) +__longlong 0x7 | 0xa == 0xf (0xf) +__ulonglong 0x7 | 0xa == 0xf (0xf) +int 0x7 << 0x7 == 0x380 (0x380) +__uint 0x7 << 0x7 == 0x380 (0x380) +char 0x7 << 0x7 == -0x80 (0xff80) +__uchar 0x7 << 0x7 == 0x80 (0x80) +__longlong 0x7 << 0x7 == 0x380 (0x380) +__ulonglong 0x7 << 0x7 == 0x380 (0x380) +int 0x7 >> 0x7 == 0x0 (0x0) +__uint 0x7 >> 0x7 == 0x0 (0x0) +char 0x7 >> 0x7 == 0x0 (0x0) +__uchar 0x7 >> 0x7 == 0x0 (0x0) +__longlong 0x7 >> 0x7 == 0x0 (0x0) +__ulonglong 0x7 >> 0x7 == 0x0 (0x0) +int 0x7 + 0xa == 0x11 (0x11) +__uint 0x7 + 0xa == 0x11 (0x11) +char 0x7 + 0xa == 0x11 (0x11) +__uchar 0x7 + 0xa == 0x11 (0x11) +__longlong 0x7 + 0xa == 0x11 (0x11) +__ulonglong 0x7 + 0xa == 0x11 (0x11) +float 0x7 + 0xa == 0x11 (0x11) +int 0x7 - 0xa == -0x3 (0xfffd) +__uint 0x7 - 0xa == -0x3 (0xfffd) +char 0x7 - 0xa == -0x3 (0xfffd) +__uchar 0x7 - 0xa == 0xfd (0xfd) +__longlong 0x7 - 0xa == -0x3 (0xfffd) +__ulonglong 0x7 - 0xa == -0x3 (0xfffd) +float 0x7 - 0xa == -0x3 (0xfffd) +int 0x7 * 0xa == 0x46 (0x46) +__uint 0x7 * 0xa == 0x46 (0x46) +char 0x7 * 0xa == 0x46 (0x46) +__uchar 0x7 * 0xa == 0x46 (0x46) +__longlong 0x7 * 0xa == 0x46 (0x46) +__ulonglong 0x7 * 0xa == 0x46 (0x46) +float 0x7 * 0xa == 0x46 (0x46) +int 0x7 < 0xa == 0x1 (0x1) +__uint 0x7 < 0xa == 0x1 (0x1) +char 0x7 < 0xa == 0x1 (0x1) +__uchar 0x7 < 0xa == 0x1 (0x1) +__longlong 0x7 < 0xa == 0x1 (0x1) +__ulonglong 0x7 < 0xa == 0x1 (0x1) +float 0x7 < 0xa == 0x1 (0x1) +int 0x7 > 0xa == 0x0 (0x0) +__uint 0x7 > 0xa == 0x0 (0x0) +char 0x7 > 0xa == 0x0 (0x0) +__uchar 0x7 > 0xa == 0x0 (0x0) +__longlong 0x7 > 0xa == 0x0 (0x0) +__ulonglong 0x7 > 0xa == 0x0 (0x0) +float 0x7 > 0xa == 0x0 (0x0) +int 0x7 <= 0xa == 0x1 (0x1) +__uint 0x7 <= 0xa == 0x1 (0x1) +char 0x7 <= 0xa == 0x1 (0x1) +__uchar 0x7 <= 0xa == 0x1 (0x1) +__longlong 0x7 <= 0xa == 0x1 (0x1) +__ulonglong 0x7 <= 0xa == 0x1 (0x1) +float 0x7 <= 0xa == 0x1 (0x1) +int 0x7 == 0xa == 0x0 (0x0) +__uint 0x7 == 0xa == 0x0 (0x0) +char 0x7 == 0xa == 0x0 (0x0) +__uchar 0x7 == 0xa == 0x0 (0x0) +__longlong 0x7 == 0xa == 0x0 (0x0) +__ulonglong 0x7 == 0xa == 0x0 (0x0) +float 0x7 == 0xa == 0x0 (0x0) +int 0x7 != 0xa == 0x1 (0x1) +__uint 0x7 != 0xa == 0x1 (0x1) +char 0x7 != 0xa == 0x1 (0x1) +__uchar 0x7 != 0xa == 0x1 (0x1) +__longlong 0x7 != 0xa == 0x1 (0x1) +__ulonglong 0x7 != 0xa == 0x1 (0x1) +float 0x7 != 0xa == 0x1 (0x1) +int 0x7 >= 0xa == 0x0 (0x0) +__uint 0x7 >= 0xa == 0x0 (0x0) +char 0x7 >= 0xa == 0x0 (0x0) +__uchar 0x7 >= 0xa == 0x0 (0x0) +__longlong 0x7 >= 0xa == 0x0 (0x0) +__ulonglong 0x7 >= 0xa == 0x0 (0x0) +float 0x7 >= 0xa == 0x0 (0x0) +int 0x7 / 0xa == 0x0 (0x0) +__uint 0x7 / 0xa == 0x0 (0x0) +char 0x7 / 0xa == 0x0 (0x0) +__uchar 0x7 / 0xa == 0x0 (0x0) +__longlong 0x7 / 0xa == 0x0 (0x0) +__ulonglong 0x7 / 0xa == 0x0 (0x0) +float 0x7 / 0xa == 0x0 (0x0) +int 0x7 % 0xa == 0x7 (0x7) +__uint 0x7 % 0xa == 0x7 (0x7) +char 0x7 % 0xa == 0x7 (0x7) +__uchar 0x7 % 0xa == 0x7 (0x7) +__longlong 0x7 % 0xa == 0x7 (0x7) +__ulonglong 0x7 % 0xa == 0x7 (0x7) +0x7 * 0xfff6 == -0x46 +0x7 / 0xfff6 == 0x0 +0x7 % 0xfff6 == 0x7 +int 0x7 ^ 0xfff6 == -0xf (0xfff1) +__uint 0x7 ^ 0xfff6 == -0xf (0xfff1) +char 0x7 ^ 0xfff6 == -0xf (0xfff1) +__uchar 0x7 ^ 0xf6 == 0xf1 (0xf1) +__longlong 0x7 ^ 0xfff6 == -0xf (0xfff1) +__ulonglong 0x7 ^ 0xfff6 == -0xf (0xfff1) +int 0x7 && 0xfff6 == 0x1 (0x1) +__uint 0x7 && 0xfff6 == 0x1 (0x1) +char 0x7 && 0xfff6 == 0x1 (0x1) +__uchar 0x7 && 0xf6 == 0x1 (0x1) +__longlong 0x7 && 0xfff6 == 0x1 (0x1) +__ulonglong 0x7 && 0xfff6 == 0x1 (0x1) +int 0x7 || 0xfff6 == 0x1 (0x1) +__uint 0x7 || 0xfff6 == 0x1 (0x1) +char 0x7 || 0xfff6 == 0x1 (0x1) +__uchar 0x7 || 0xf6 == 0x1 (0x1) +__longlong 0x7 || 0xfff6 == 0x1 (0x1) +__ulonglong 0x7 || 0xfff6 == 0x1 (0x1) +int 0x7 & 0xfff6 == 0x6 (0x6) +__uint 0x7 & 0xfff6 == 0x6 (0x6) +char 0x7 & 0xfff6 == 0x6 (0x6) +__uchar 0x7 & 0xf6 == 0x6 (0x6) +__longlong 0x7 & 0xfff6 == 0x6 (0x6) +__ulonglong 0x7 & 0xfff6 == 0x6 (0x6) +int 0x7 | 0xfff6 == -0x9 (0xfff7) +__uint 0x7 | 0xfff6 == -0x9 (0xfff7) +char 0x7 | 0xfff6 == -0x9 (0xfff7) +__uchar 0x7 | 0xf6 == 0xf7 (0xf7) +__longlong 0x7 | 0xfff6 == -0x9 (0xfff7) +__ulonglong 0x7 | 0xfff6 == -0x9 (0xfff7) +int 0x7 << 0x8 == 0x700 (0x700) +__uint 0x7 << 0x8 == 0x700 (0x700) +char 0x7 << 0x8 == 0x0 (0x0) +__uchar 0x7 << 0x8 == 0x0 (0x0) +__longlong 0x7 << 0x8 == 0x700 (0x700) +__ulonglong 0x7 << 0x8 == 0x700 (0x700) +int 0x7 >> 0x8 == 0x0 (0x0) +__uint 0x7 >> 0x8 == 0x0 (0x0) +char 0x7 >> 0x8 == 0x0 (0x0) +__uchar 0x7 >> 0x8 == 0x0 (0x0) +__longlong 0x7 >> 0x8 == 0x0 (0x0) +__ulonglong 0x7 >> 0x8 == 0x0 (0x0) +int 0x7 + 0xfff6 == -0x3 (0xfffd) +__uint 0x7 + 0xfff6 == -0x3 (0xfffd) +char 0x7 + 0xfff6 == -0x3 (0xfffd) +__uchar 0x7 + 0xf6 == 0xfd (0xfd) +__longlong 0x7 + 0xfff6 == -0x3 (0xfffd) +__ulonglong 0x7 + 0xfff6 == -0x3 (0xfffd) +float 0x7 + 0xfff6 == -0x3 (0xfffd) +int 0x7 - 0xfff6 == 0x11 (0x11) +__uint 0x7 - 0xfff6 == 0x11 (0x11) +char 0x7 - 0xfff6 == 0x11 (0x11) +__uchar 0x7 - 0xf6 == 0x11 (0x11) +__longlong 0x7 - 0xfff6 == 0x11 (0x11) +__ulonglong 0x7 - 0xfff6 == 0x11 (0x11) +float 0x7 - 0xfff6 == 0x11 (0x11) +int 0x7 * 0xfff6 == -0x46 (0xffba) +__uint 0x7 * 0xfff6 == -0x46 (0xffba) +char 0x7 * 0xfff6 == -0x46 (0xffba) +__uchar 0x7 * 0xf6 == 0xba (0xba) +__longlong 0x7 * 0xfff6 == -0x46 (0xffba) +__ulonglong 0x7 * 0xfff6 == -0x46 (0xffba) +float 0x7 * 0xfff6 == -0x46 (0xffba) +int 0x7 < 0xfff6 == 0x0 (0x0) +__uint 0x7 < 0xfff6 == 0x1 (0x1) +char 0x7 < 0xfff6 == 0x0 (0x0) +__uchar 0x7 < 0xf6 == 0x1 (0x1) +__longlong 0x7 < 0xfff6 == 0x0 (0x0) +__ulonglong 0x7 < 0xfff6 == 0x1 (0x1) +float 0x7 < 0xfff6 == 0x0 (0x0) +int 0x7 > 0xfff6 == 0x1 (0x1) +__uint 0x7 > 0xfff6 == 0x0 (0x0) +char 0x7 > 0xfff6 == 0x1 (0x1) +__uchar 0x7 > 0xf6 == 0x0 (0x0) +__longlong 0x7 > 0xfff6 == 0x1 (0x1) +__ulonglong 0x7 > 0xfff6 == 0x0 (0x0) +float 0x7 > 0xfff6 == 0x1 (0x1) +int 0x7 <= 0xfff6 == 0x0 (0x0) +__uint 0x7 <= 0xfff6 == 0x1 (0x1) +char 0x7 <= 0xfff6 == 0x0 (0x0) +__uchar 0x7 <= 0xf6 == 0x1 (0x1) +__longlong 0x7 <= 0xfff6 == 0x0 (0x0) +__ulonglong 0x7 <= 0xfff6 == 0x1 (0x1) +float 0x7 <= 0xfff6 == 0x0 (0x0) +int 0x7 == 0xfff6 == 0x0 (0x0) +__uint 0x7 == 0xfff6 == 0x0 (0x0) +char 0x7 == 0xfff6 == 0x0 (0x0) +__uchar 0x7 == 0xf6 == 0x0 (0x0) +__longlong 0x7 == 0xfff6 == 0x0 (0x0) +__ulonglong 0x7 == 0xfff6 == 0x0 (0x0) +float 0x7 == 0xfff6 == 0x0 (0x0) +int 0x7 != 0xfff6 == 0x1 (0x1) +__uint 0x7 != 0xfff6 == 0x1 (0x1) +char 0x7 != 0xfff6 == 0x1 (0x1) +__uchar 0x7 != 0xf6 == 0x1 (0x1) +__longlong 0x7 != 0xfff6 == 0x1 (0x1) +__ulonglong 0x7 != 0xfff6 == 0x1 (0x1) +float 0x7 != 0xfff6 == 0x1 (0x1) +int 0x7 >= 0xfff6 == 0x1 (0x1) +__uint 0x7 >= 0xfff6 == 0x0 (0x0) +char 0x7 >= 0xfff6 == 0x1 (0x1) +__uchar 0x7 >= 0xf6 == 0x0 (0x0) +__longlong 0x7 >= 0xfff6 == 0x1 (0x1) +__ulonglong 0x7 >= 0xfff6 == 0x0 (0x0) +float 0x7 >= 0xfff6 == 0x1 (0x1) +int 0x7 / 0xfff6 == 0x0 (0x0) +__uint 0x7 / 0xfff6 == 0x0 (0x0) +char 0x7 / 0xfff6 == 0x0 (0x0) +__uchar 0x7 / 0xf6 == 0x0 (0x0) +__longlong 0x7 / 0xfff6 == 0x0 (0x0) +__ulonglong 0x7 / 0xfff6 == 0x0 (0x0) +float 0x7 / 0xfff6 == 0x0 (0x0) +int 0x7 % 0xfff6 == 0x7 (0x7) +__uint 0x7 % 0xfff6 == 0x7 (0x7) +char 0x7 % 0xfff6 == 0x7 (0x7) +__uchar 0x7 % 0xf6 == 0x7 (0x7) +__longlong 0x7 % 0xfff6 == 0x7 (0x7) +__ulonglong 0x7 % 0xfff6 == 0x7 (0x7) +0x7 * 0x5 == 0x23 +0x7 / 0x5 == 0x1 +0x7 % 0x5 == 0x2 +int 0x7 ^ 0x5 == 0x2 (0x2) +__uint 0x7 ^ 0x5 == 0x2 (0x2) +char 0x7 ^ 0x5 == 0x2 (0x2) +__uchar 0x7 ^ 0x5 == 0x2 (0x2) +__longlong 0x7 ^ 0x5 == 0x2 (0x2) +__ulonglong 0x7 ^ 0x5 == 0x2 (0x2) +int 0x7 && 0x5 == 0x1 (0x1) +__uint 0x7 && 0x5 == 0x1 (0x1) +char 0x7 && 0x5 == 0x1 (0x1) +__uchar 0x7 && 0x5 == 0x1 (0x1) +__longlong 0x7 && 0x5 == 0x1 (0x1) +__ulonglong 0x7 && 0x5 == 0x1 (0x1) +int 0x7 || 0x5 == 0x1 (0x1) +__uint 0x7 || 0x5 == 0x1 (0x1) +char 0x7 || 0x5 == 0x1 (0x1) +__uchar 0x7 || 0x5 == 0x1 (0x1) +__longlong 0x7 || 0x5 == 0x1 (0x1) +__ulonglong 0x7 || 0x5 == 0x1 (0x1) +int 0x7 & 0x5 == 0x5 (0x5) +__uint 0x7 & 0x5 == 0x5 (0x5) +char 0x7 & 0x5 == 0x5 (0x5) +__uchar 0x7 & 0x5 == 0x5 (0x5) +__longlong 0x7 & 0x5 == 0x5 (0x5) +__ulonglong 0x7 & 0x5 == 0x5 (0x5) +int 0x7 | 0x5 == 0x7 (0x7) +__uint 0x7 | 0x5 == 0x7 (0x7) +char 0x7 | 0x5 == 0x7 (0x7) +__uchar 0x7 | 0x5 == 0x7 (0x7) +__longlong 0x7 | 0x5 == 0x7 (0x7) +__ulonglong 0x7 | 0x5 == 0x7 (0x7) +int 0x7 << 0x9 == 0xe00 (0xe00) +__uint 0x7 << 0x9 == 0xe00 (0xe00) +char 0x7 << 0x9 == 0x0 (0x0) +__uchar 0x7 << 0x9 == 0x0 (0x0) +__longlong 0x7 << 0x9 == 0xe00 (0xe00) +__ulonglong 0x7 << 0x9 == 0xe00 (0xe00) +int 0x7 >> 0x9 == 0x0 (0x0) +__uint 0x7 >> 0x9 == 0x0 (0x0) +char 0x7 >> 0x9 == 0x0 (0x0) +__uchar 0x7 >> 0x9 == 0x0 (0x0) +__longlong 0x7 >> 0x9 == 0x0 (0x0) +__ulonglong 0x7 >> 0x9 == 0x0 (0x0) +int 0x7 + 0x5 == 0xc (0xc) +__uint 0x7 + 0x5 == 0xc (0xc) +char 0x7 + 0x5 == 0xc (0xc) +__uchar 0x7 + 0x5 == 0xc (0xc) +__longlong 0x7 + 0x5 == 0xc (0xc) +__ulonglong 0x7 + 0x5 == 0xc (0xc) +float 0x7 + 0x5 == 0xc (0xc) +int 0x7 - 0x5 == 0x2 (0x2) +__uint 0x7 - 0x5 == 0x2 (0x2) +char 0x7 - 0x5 == 0x2 (0x2) +__uchar 0x7 - 0x5 == 0x2 (0x2) +__longlong 0x7 - 0x5 == 0x2 (0x2) +__ulonglong 0x7 - 0x5 == 0x2 (0x2) +float 0x7 - 0x5 == 0x2 (0x2) +int 0x7 * 0x5 == 0x23 (0x23) +__uint 0x7 * 0x5 == 0x23 (0x23) +char 0x7 * 0x5 == 0x23 (0x23) +__uchar 0x7 * 0x5 == 0x23 (0x23) +__longlong 0x7 * 0x5 == 0x23 (0x23) +__ulonglong 0x7 * 0x5 == 0x23 (0x23) +float 0x7 * 0x5 == 0x23 (0x23) +int 0x7 < 0x5 == 0x0 (0x0) +__uint 0x7 < 0x5 == 0x0 (0x0) +char 0x7 < 0x5 == 0x0 (0x0) +__uchar 0x7 < 0x5 == 0x0 (0x0) +__longlong 0x7 < 0x5 == 0x0 (0x0) +__ulonglong 0x7 < 0x5 == 0x0 (0x0) +float 0x7 < 0x5 == 0x0 (0x0) +int 0x7 > 0x5 == 0x1 (0x1) +__uint 0x7 > 0x5 == 0x1 (0x1) +char 0x7 > 0x5 == 0x1 (0x1) +__uchar 0x7 > 0x5 == 0x1 (0x1) +__longlong 0x7 > 0x5 == 0x1 (0x1) +__ulonglong 0x7 > 0x5 == 0x1 (0x1) +float 0x7 > 0x5 == 0x1 (0x1) +int 0x7 <= 0x5 == 0x0 (0x0) +__uint 0x7 <= 0x5 == 0x0 (0x0) +char 0x7 <= 0x5 == 0x0 (0x0) +__uchar 0x7 <= 0x5 == 0x0 (0x0) +__longlong 0x7 <= 0x5 == 0x0 (0x0) +__ulonglong 0x7 <= 0x5 == 0x0 (0x0) +float 0x7 <= 0x5 == 0x0 (0x0) +int 0x7 == 0x5 == 0x0 (0x0) +__uint 0x7 == 0x5 == 0x0 (0x0) +char 0x7 == 0x5 == 0x0 (0x0) +__uchar 0x7 == 0x5 == 0x0 (0x0) +__longlong 0x7 == 0x5 == 0x0 (0x0) +__ulonglong 0x7 == 0x5 == 0x0 (0x0) +float 0x7 == 0x5 == 0x0 (0x0) +int 0x7 != 0x5 == 0x1 (0x1) +__uint 0x7 != 0x5 == 0x1 (0x1) +char 0x7 != 0x5 == 0x1 (0x1) +__uchar 0x7 != 0x5 == 0x1 (0x1) +__longlong 0x7 != 0x5 == 0x1 (0x1) +__ulonglong 0x7 != 0x5 == 0x1 (0x1) +float 0x7 != 0x5 == 0x1 (0x1) +int 0x7 >= 0x5 == 0x1 (0x1) +__uint 0x7 >= 0x5 == 0x1 (0x1) +char 0x7 >= 0x5 == 0x1 (0x1) +__uchar 0x7 >= 0x5 == 0x1 (0x1) +__longlong 0x7 >= 0x5 == 0x1 (0x1) +__ulonglong 0x7 >= 0x5 == 0x1 (0x1) +float 0x7 >= 0x5 == 0x1 (0x1) +int 0x7 / 0x5 == 0x1 (0x1) +__uint 0x7 / 0x5 == 0x1 (0x1) +char 0x7 / 0x5 == 0x1 (0x1) +__uchar 0x7 / 0x5 == 0x1 (0x1) +__longlong 0x7 / 0x5 == 0x1 (0x1) +__ulonglong 0x7 / 0x5 == 0x1 (0x1) +float 0x7 / 0x5 == 0x1 (0x1) +int 0x7 % 0x5 == 0x2 (0x2) +__uint 0x7 % 0x5 == 0x2 (0x2) +char 0x7 % 0x5 == 0x2 (0x2) +__uchar 0x7 % 0x5 == 0x2 (0x2) +__longlong 0x7 % 0x5 == 0x2 (0x2) +__ulonglong 0x7 % 0x5 == 0x2 (0x2) +0x7 * 0x7 == 0x31 +0x7 / 0x7 == 0x1 +0x7 % 0x7 == 0x0 +int 0x7 ^ 0x7 == 0x0 (0x0) +__uint 0x7 ^ 0x7 == 0x0 (0x0) +char 0x7 ^ 0x7 == 0x0 (0x0) +__uchar 0x7 ^ 0x7 == 0x0 (0x0) +__longlong 0x7 ^ 0x7 == 0x0 (0x0) +__ulonglong 0x7 ^ 0x7 == 0x0 (0x0) +int 0x7 && 0x7 == 0x1 (0x1) +__uint 0x7 && 0x7 == 0x1 (0x1) +char 0x7 && 0x7 == 0x1 (0x1) +__uchar 0x7 && 0x7 == 0x1 (0x1) +__longlong 0x7 && 0x7 == 0x1 (0x1) +__ulonglong 0x7 && 0x7 == 0x1 (0x1) +int 0x7 || 0x7 == 0x1 (0x1) +__uint 0x7 || 0x7 == 0x1 (0x1) +char 0x7 || 0x7 == 0x1 (0x1) +__uchar 0x7 || 0x7 == 0x1 (0x1) +__longlong 0x7 || 0x7 == 0x1 (0x1) +__ulonglong 0x7 || 0x7 == 0x1 (0x1) +int 0x7 & 0x7 == 0x7 (0x7) +__uint 0x7 & 0x7 == 0x7 (0x7) +char 0x7 & 0x7 == 0x7 (0x7) +__uchar 0x7 & 0x7 == 0x7 (0x7) +__longlong 0x7 & 0x7 == 0x7 (0x7) +__ulonglong 0x7 & 0x7 == 0x7 (0x7) +int 0x7 | 0x7 == 0x7 (0x7) +__uint 0x7 | 0x7 == 0x7 (0x7) +char 0x7 | 0x7 == 0x7 (0x7) +__uchar 0x7 | 0x7 == 0x7 (0x7) +__longlong 0x7 | 0x7 == 0x7 (0x7) +__ulonglong 0x7 | 0x7 == 0x7 (0x7) +int 0x7 << 0xa == 0x1c00 (0x1c00) +__uint 0x7 << 0xa == 0x1c00 (0x1c00) +char 0x7 << 0xa == 0x0 (0x0) +__uchar 0x7 << 0xa == 0x0 (0x0) +__longlong 0x7 << 0xa == 0x1c00 (0x1c00) +__ulonglong 0x7 << 0xa == 0x1c00 (0x1c00) +int 0x7 >> 0xa == 0x0 (0x0) +__uint 0x7 >> 0xa == 0x0 (0x0) +char 0x7 >> 0xa == 0x0 (0x0) +__uchar 0x7 >> 0xa == 0x0 (0x0) +__longlong 0x7 >> 0xa == 0x0 (0x0) +__ulonglong 0x7 >> 0xa == 0x0 (0x0) +int 0x7 + 0x7 == 0xe (0xe) +__uint 0x7 + 0x7 == 0xe (0xe) +char 0x7 + 0x7 == 0xe (0xe) +__uchar 0x7 + 0x7 == 0xe (0xe) +__longlong 0x7 + 0x7 == 0xe (0xe) +__ulonglong 0x7 + 0x7 == 0xe (0xe) +float 0x7 + 0x7 == 0xe (0xe) +int 0x7 - 0x7 == 0x0 (0x0) +__uint 0x7 - 0x7 == 0x0 (0x0) +char 0x7 - 0x7 == 0x0 (0x0) +__uchar 0x7 - 0x7 == 0x0 (0x0) +__longlong 0x7 - 0x7 == 0x0 (0x0) +__ulonglong 0x7 - 0x7 == 0x0 (0x0) +float 0x7 - 0x7 == 0x0 (0x0) +int 0x7 * 0x7 == 0x31 (0x31) +__uint 0x7 * 0x7 == 0x31 (0x31) +char 0x7 * 0x7 == 0x31 (0x31) +__uchar 0x7 * 0x7 == 0x31 (0x31) +__longlong 0x7 * 0x7 == 0x31 (0x31) +__ulonglong 0x7 * 0x7 == 0x31 (0x31) +float 0x7 * 0x7 == 0x31 (0x31) +int 0x7 < 0x7 == 0x0 (0x0) +__uint 0x7 < 0x7 == 0x0 (0x0) +char 0x7 < 0x7 == 0x0 (0x0) +__uchar 0x7 < 0x7 == 0x0 (0x0) +__longlong 0x7 < 0x7 == 0x0 (0x0) +__ulonglong 0x7 < 0x7 == 0x0 (0x0) +float 0x7 < 0x7 == 0x0 (0x0) +int 0x7 > 0x7 == 0x0 (0x0) +__uint 0x7 > 0x7 == 0x0 (0x0) +char 0x7 > 0x7 == 0x0 (0x0) +__uchar 0x7 > 0x7 == 0x0 (0x0) +__longlong 0x7 > 0x7 == 0x0 (0x0) +__ulonglong 0x7 > 0x7 == 0x0 (0x0) +float 0x7 > 0x7 == 0x0 (0x0) +int 0x7 <= 0x7 == 0x1 (0x1) +__uint 0x7 <= 0x7 == 0x1 (0x1) +char 0x7 <= 0x7 == 0x1 (0x1) +__uchar 0x7 <= 0x7 == 0x1 (0x1) +__longlong 0x7 <= 0x7 == 0x1 (0x1) +__ulonglong 0x7 <= 0x7 == 0x1 (0x1) +float 0x7 <= 0x7 == 0x1 (0x1) +int 0x7 == 0x7 == 0x1 (0x1) +__uint 0x7 == 0x7 == 0x1 (0x1) +char 0x7 == 0x7 == 0x1 (0x1) +__uchar 0x7 == 0x7 == 0x1 (0x1) +__longlong 0x7 == 0x7 == 0x1 (0x1) +__ulonglong 0x7 == 0x7 == 0x1 (0x1) +float 0x7 == 0x7 == 0x1 (0x1) +int 0x7 != 0x7 == 0x0 (0x0) +__uint 0x7 != 0x7 == 0x0 (0x0) +char 0x7 != 0x7 == 0x0 (0x0) +__uchar 0x7 != 0x7 == 0x0 (0x0) +__longlong 0x7 != 0x7 == 0x0 (0x0) +__ulonglong 0x7 != 0x7 == 0x0 (0x0) +float 0x7 != 0x7 == 0x0 (0x0) +int 0x7 >= 0x7 == 0x1 (0x1) +__uint 0x7 >= 0x7 == 0x1 (0x1) +char 0x7 >= 0x7 == 0x1 (0x1) +__uchar 0x7 >= 0x7 == 0x1 (0x1) +__longlong 0x7 >= 0x7 == 0x1 (0x1) +__ulonglong 0x7 >= 0x7 == 0x1 (0x1) +float 0x7 >= 0x7 == 0x1 (0x1) +int 0x7 / 0x7 == 0x1 (0x1) +__uint 0x7 / 0x7 == 0x1 (0x1) +char 0x7 / 0x7 == 0x1 (0x1) +__uchar 0x7 / 0x7 == 0x1 (0x1) +__longlong 0x7 / 0x7 == 0x1 (0x1) +__ulonglong 0x7 / 0x7 == 0x1 (0x1) +float 0x7 / 0x7 == 0x1 (0x1) +int 0x7 % 0x7 == 0x0 (0x0) +__uint 0x7 % 0x7 == 0x0 (0x0) +char 0x7 % 0x7 == 0x0 (0x0) +__uchar 0x7 % 0x7 == 0x0 (0x0) +__longlong 0x7 % 0x7 == 0x0 (0x0) +__ulonglong 0x7 % 0x7 == 0x0 (0x0) +0x7 * 0x2a == 0x126 +0x7 / 0x2a == 0x0 +0x7 % 0x2a == 0x7 +int 0x7 ^ 0x2a == 0x2d (0x2d) +__uint 0x7 ^ 0x2a == 0x2d (0x2d) +char 0x7 ^ 0x2a == 0x2d (0x2d) +__uchar 0x7 ^ 0x2a == 0x2d (0x2d) +__longlong 0x7 ^ 0x2a == 0x2d (0x2d) +__ulonglong 0x7 ^ 0x2a == 0x2d (0x2d) +int 0x7 && 0x2a == 0x1 (0x1) +__uint 0x7 && 0x2a == 0x1 (0x1) +char 0x7 && 0x2a == 0x1 (0x1) +__uchar 0x7 && 0x2a == 0x1 (0x1) +__longlong 0x7 && 0x2a == 0x1 (0x1) +__ulonglong 0x7 && 0x2a == 0x1 (0x1) +int 0x7 || 0x2a == 0x1 (0x1) +__uint 0x7 || 0x2a == 0x1 (0x1) +char 0x7 || 0x2a == 0x1 (0x1) +__uchar 0x7 || 0x2a == 0x1 (0x1) +__longlong 0x7 || 0x2a == 0x1 (0x1) +__ulonglong 0x7 || 0x2a == 0x1 (0x1) +int 0x7 & 0x2a == 0x2 (0x2) +__uint 0x7 & 0x2a == 0x2 (0x2) +char 0x7 & 0x2a == 0x2 (0x2) +__uchar 0x7 & 0x2a == 0x2 (0x2) +__longlong 0x7 & 0x2a == 0x2 (0x2) +__ulonglong 0x7 & 0x2a == 0x2 (0x2) +int 0x7 | 0x2a == 0x2f (0x2f) +__uint 0x7 | 0x2a == 0x2f (0x2f) +char 0x7 | 0x2a == 0x2f (0x2f) +__uchar 0x7 | 0x2a == 0x2f (0x2f) +__longlong 0x7 | 0x2a == 0x2f (0x2f) +__ulonglong 0x7 | 0x2a == 0x2f (0x2f) +int 0x7 << 0xc == 0x7000 (0x7000) +__uint 0x7 << 0xc == 0x7000 (0x7000) +char 0x7 << 0xc == 0x0 (0x0) +__uchar 0x7 << 0xc == 0x0 (0x0) +__longlong 0x7 << 0xc == 0x7000 (0x7000) +__ulonglong 0x7 << 0xc == 0x7000 (0x7000) +int 0x7 >> 0xc == 0x0 (0x0) +__uint 0x7 >> 0xc == 0x0 (0x0) +char 0x7 >> 0xc == 0x0 (0x0) +__uchar 0x7 >> 0xc == 0x0 (0x0) +__longlong 0x7 >> 0xc == 0x0 (0x0) +__ulonglong 0x7 >> 0xc == 0x0 (0x0) +int 0x7 + 0x2a == 0x31 (0x31) +__uint 0x7 + 0x2a == 0x31 (0x31) +char 0x7 + 0x2a == 0x31 (0x31) +__uchar 0x7 + 0x2a == 0x31 (0x31) +__longlong 0x7 + 0x2a == 0x31 (0x31) +__ulonglong 0x7 + 0x2a == 0x31 (0x31) +float 0x7 + 0x2a == 0x31 (0x31) +int 0x7 - 0x2a == -0x23 (0xffdd) +__uint 0x7 - 0x2a == -0x23 (0xffdd) +char 0x7 - 0x2a == -0x23 (0xffdd) +__uchar 0x7 - 0x2a == 0xdd (0xdd) +__longlong 0x7 - 0x2a == -0x23 (0xffdd) +__ulonglong 0x7 - 0x2a == -0x23 (0xffdd) +float 0x7 - 0x2a == -0x23 (0xffdd) +int 0x7 * 0x2a == 0x126 (0x126) +__uint 0x7 * 0x2a == 0x126 (0x126) +char 0x7 * 0x2a == 0x26 (0x26) +__uchar 0x7 * 0x2a == 0x26 (0x26) +__longlong 0x7 * 0x2a == 0x126 (0x126) +__ulonglong 0x7 * 0x2a == 0x126 (0x126) +float 0x7 * 0x2a == 0x126 (0x126) +int 0x7 < 0x2a == 0x1 (0x1) +__uint 0x7 < 0x2a == 0x1 (0x1) +char 0x7 < 0x2a == 0x1 (0x1) +__uchar 0x7 < 0x2a == 0x1 (0x1) +__longlong 0x7 < 0x2a == 0x1 (0x1) +__ulonglong 0x7 < 0x2a == 0x1 (0x1) +float 0x7 < 0x2a == 0x1 (0x1) +int 0x7 > 0x2a == 0x0 (0x0) +__uint 0x7 > 0x2a == 0x0 (0x0) +char 0x7 > 0x2a == 0x0 (0x0) +__uchar 0x7 > 0x2a == 0x0 (0x0) +__longlong 0x7 > 0x2a == 0x0 (0x0) +__ulonglong 0x7 > 0x2a == 0x0 (0x0) +float 0x7 > 0x2a == 0x0 (0x0) +int 0x7 <= 0x2a == 0x1 (0x1) +__uint 0x7 <= 0x2a == 0x1 (0x1) +char 0x7 <= 0x2a == 0x1 (0x1) +__uchar 0x7 <= 0x2a == 0x1 (0x1) +__longlong 0x7 <= 0x2a == 0x1 (0x1) +__ulonglong 0x7 <= 0x2a == 0x1 (0x1) +float 0x7 <= 0x2a == 0x1 (0x1) +int 0x7 == 0x2a == 0x0 (0x0) +__uint 0x7 == 0x2a == 0x0 (0x0) +char 0x7 == 0x2a == 0x0 (0x0) +__uchar 0x7 == 0x2a == 0x0 (0x0) +__longlong 0x7 == 0x2a == 0x0 (0x0) +__ulonglong 0x7 == 0x2a == 0x0 (0x0) +float 0x7 == 0x2a == 0x0 (0x0) +int 0x7 != 0x2a == 0x1 (0x1) +__uint 0x7 != 0x2a == 0x1 (0x1) +char 0x7 != 0x2a == 0x1 (0x1) +__uchar 0x7 != 0x2a == 0x1 (0x1) +__longlong 0x7 != 0x2a == 0x1 (0x1) +__ulonglong 0x7 != 0x2a == 0x1 (0x1) +float 0x7 != 0x2a == 0x1 (0x1) +int 0x7 >= 0x2a == 0x0 (0x0) +__uint 0x7 >= 0x2a == 0x0 (0x0) +char 0x7 >= 0x2a == 0x0 (0x0) +__uchar 0x7 >= 0x2a == 0x0 (0x0) +__longlong 0x7 >= 0x2a == 0x0 (0x0) +__ulonglong 0x7 >= 0x2a == 0x0 (0x0) +float 0x7 >= 0x2a == 0x0 (0x0) +int 0x7 / 0x2a == 0x0 (0x0) +__uint 0x7 / 0x2a == 0x0 (0x0) +char 0x7 / 0x2a == 0x0 (0x0) +__uchar 0x7 / 0x2a == 0x0 (0x0) +__longlong 0x7 / 0x2a == 0x0 (0x0) +__ulonglong 0x7 / 0x2a == 0x0 (0x0) +float 0x7 / 0x2a == 0x0 (0x0) +int 0x7 % 0x2a == 0x7 (0x7) +__uint 0x7 % 0x2a == 0x7 (0x7) +char 0x7 % 0x2a == 0x7 (0x7) +__uchar 0x7 % 0x2a == 0x7 (0x7) +__longlong 0x7 % 0x2a == 0x7 (0x7) +__ulonglong 0x7 % 0x2a == 0x7 (0x7) +0x7 * 0x17 == 0xa1 +0x7 / 0x17 == 0x0 +0x7 % 0x17 == 0x7 +int 0x7 ^ 0x17 == 0x10 (0x10) +__uint 0x7 ^ 0x17 == 0x10 (0x10) +char 0x7 ^ 0x17 == 0x10 (0x10) +__uchar 0x7 ^ 0x17 == 0x10 (0x10) +__longlong 0x7 ^ 0x17 == 0x10 (0x10) +__ulonglong 0x7 ^ 0x17 == 0x10 (0x10) +int 0x7 && 0x17 == 0x1 (0x1) +__uint 0x7 && 0x17 == 0x1 (0x1) +char 0x7 && 0x17 == 0x1 (0x1) +__uchar 0x7 && 0x17 == 0x1 (0x1) +__longlong 0x7 && 0x17 == 0x1 (0x1) +__ulonglong 0x7 && 0x17 == 0x1 (0x1) +int 0x7 || 0x17 == 0x1 (0x1) +__uint 0x7 || 0x17 == 0x1 (0x1) +char 0x7 || 0x17 == 0x1 (0x1) +__uchar 0x7 || 0x17 == 0x1 (0x1) +__longlong 0x7 || 0x17 == 0x1 (0x1) +__ulonglong 0x7 || 0x17 == 0x1 (0x1) +int 0x7 & 0x17 == 0x7 (0x7) +__uint 0x7 & 0x17 == 0x7 (0x7) +char 0x7 & 0x17 == 0x7 (0x7) +__uchar 0x7 & 0x17 == 0x7 (0x7) +__longlong 0x7 & 0x17 == 0x7 (0x7) +__ulonglong 0x7 & 0x17 == 0x7 (0x7) +int 0x7 | 0x17 == 0x17 (0x17) +__uint 0x7 | 0x17 == 0x17 (0x17) +char 0x7 | 0x17 == 0x17 (0x17) +__uchar 0x7 | 0x17 == 0x17 (0x17) +__longlong 0x7 | 0x17 == 0x17 (0x17) +__ulonglong 0x7 | 0x17 == 0x17 (0x17) +int 0x7 << 0xe == -0x4000 (0xc000) +__uint 0x7 << 0xe == -0x4000 (0xc000) +char 0x7 << 0xe == 0x0 (0x0) +__uchar 0x7 << 0xe == 0x0 (0x0) +__longlong 0x7 << 0xe == -0x4000 (0xc000) +__ulonglong 0x7 << 0xe == -0x4000 (0xc000) +int 0x7 >> 0xe == 0x0 (0x0) +__uint 0x7 >> 0xe == 0x0 (0x0) +char 0x7 >> 0xe == 0x0 (0x0) +__uchar 0x7 >> 0xe == 0x0 (0x0) +__longlong 0x7 >> 0xe == 0x0 (0x0) +__ulonglong 0x7 >> 0xe == 0x0 (0x0) +int 0x7 + 0x17 == 0x1e (0x1e) +__uint 0x7 + 0x17 == 0x1e (0x1e) +char 0x7 + 0x17 == 0x1e (0x1e) +__uchar 0x7 + 0x17 == 0x1e (0x1e) +__longlong 0x7 + 0x17 == 0x1e (0x1e) +__ulonglong 0x7 + 0x17 == 0x1e (0x1e) +float 0x7 + 0x17 == 0x1e (0x1e) +int 0x7 - 0x17 == -0x10 (0xfff0) +__uint 0x7 - 0x17 == -0x10 (0xfff0) +char 0x7 - 0x17 == -0x10 (0xfff0) +__uchar 0x7 - 0x17 == 0xf0 (0xf0) +__longlong 0x7 - 0x17 == -0x10 (0xfff0) +__ulonglong 0x7 - 0x17 == -0x10 (0xfff0) +float 0x7 - 0x17 == -0x10 (0xfff0) +int 0x7 * 0x17 == 0xa1 (0xa1) +__uint 0x7 * 0x17 == 0xa1 (0xa1) +char 0x7 * 0x17 == -0x5f (0xffa1) +__uchar 0x7 * 0x17 == 0xa1 (0xa1) +__longlong 0x7 * 0x17 == 0xa1 (0xa1) +__ulonglong 0x7 * 0x17 == 0xa1 (0xa1) +float 0x7 * 0x17 == 0xa1 (0xa1) +int 0x7 < 0x17 == 0x1 (0x1) +__uint 0x7 < 0x17 == 0x1 (0x1) +char 0x7 < 0x17 == 0x1 (0x1) +__uchar 0x7 < 0x17 == 0x1 (0x1) +__longlong 0x7 < 0x17 == 0x1 (0x1) +__ulonglong 0x7 < 0x17 == 0x1 (0x1) +float 0x7 < 0x17 == 0x1 (0x1) +int 0x7 > 0x17 == 0x0 (0x0) +__uint 0x7 > 0x17 == 0x0 (0x0) +char 0x7 > 0x17 == 0x0 (0x0) +__uchar 0x7 > 0x17 == 0x0 (0x0) +__longlong 0x7 > 0x17 == 0x0 (0x0) +__ulonglong 0x7 > 0x17 == 0x0 (0x0) +float 0x7 > 0x17 == 0x0 (0x0) +int 0x7 <= 0x17 == 0x1 (0x1) +__uint 0x7 <= 0x17 == 0x1 (0x1) +char 0x7 <= 0x17 == 0x1 (0x1) +__uchar 0x7 <= 0x17 == 0x1 (0x1) +__longlong 0x7 <= 0x17 == 0x1 (0x1) +__ulonglong 0x7 <= 0x17 == 0x1 (0x1) +float 0x7 <= 0x17 == 0x1 (0x1) +int 0x7 == 0x17 == 0x0 (0x0) +__uint 0x7 == 0x17 == 0x0 (0x0) +char 0x7 == 0x17 == 0x0 (0x0) +__uchar 0x7 == 0x17 == 0x0 (0x0) +__longlong 0x7 == 0x17 == 0x0 (0x0) +__ulonglong 0x7 == 0x17 == 0x0 (0x0) +float 0x7 == 0x17 == 0x0 (0x0) +int 0x7 != 0x17 == 0x1 (0x1) +__uint 0x7 != 0x17 == 0x1 (0x1) +char 0x7 != 0x17 == 0x1 (0x1) +__uchar 0x7 != 0x17 == 0x1 (0x1) +__longlong 0x7 != 0x17 == 0x1 (0x1) +__ulonglong 0x7 != 0x17 == 0x1 (0x1) +float 0x7 != 0x17 == 0x1 (0x1) +int 0x7 >= 0x17 == 0x0 (0x0) +__uint 0x7 >= 0x17 == 0x0 (0x0) +char 0x7 >= 0x17 == 0x0 (0x0) +__uchar 0x7 >= 0x17 == 0x0 (0x0) +__longlong 0x7 >= 0x17 == 0x0 (0x0) +__ulonglong 0x7 >= 0x17 == 0x0 (0x0) +float 0x7 >= 0x17 == 0x0 (0x0) +int 0x7 / 0x17 == 0x0 (0x0) +__uint 0x7 / 0x17 == 0x0 (0x0) +char 0x7 / 0x17 == 0x0 (0x0) +__uchar 0x7 / 0x17 == 0x0 (0x0) +__longlong 0x7 / 0x17 == 0x0 (0x0) +__ulonglong 0x7 / 0x17 == 0x0 (0x0) +float 0x7 / 0x17 == 0x0 (0x0) +int 0x7 % 0x17 == 0x7 (0x7) +__uint 0x7 % 0x17 == 0x7 (0x7) +char 0x7 % 0x17 == 0x7 (0x7) +__uchar 0x7 % 0x17 == 0x7 (0x7) +__longlong 0x7 % 0x17 == 0x7 (0x7) +__ulonglong 0x7 % 0x17 == 0x7 (0x7) +0x7 * 0x7fff == 0x7ff9 +0x7 / 0x7fff == 0x0 +0x7 % 0x7fff == 0x7 +int 0x7 ^ 0x7fff == 0x7ff8 (0x7ff8) +__uint 0x7 ^ 0x7fff == 0x7ff8 (0x7ff8) +char 0x7 ^ 0xffff == -0x8 (0xfff8) +__uchar 0x7 ^ 0xff == 0xf8 (0xf8) +__longlong 0x7 ^ 0x7fff == 0x7ff8 (0x7ff8) +__ulonglong 0x7 ^ 0x7fff == 0x7ff8 (0x7ff8) +int 0x7 && 0x7fff == 0x1 (0x1) +__uint 0x7 && 0x7fff == 0x1 (0x1) +char 0x7 && 0xffff == 0x1 (0x1) +__uchar 0x7 && 0xff == 0x1 (0x1) +__longlong 0x7 && 0x7fff == 0x1 (0x1) +__ulonglong 0x7 && 0x7fff == 0x1 (0x1) +int 0x7 || 0x7fff == 0x1 (0x1) +__uint 0x7 || 0x7fff == 0x1 (0x1) +char 0x7 || 0xffff == 0x1 (0x1) +__uchar 0x7 || 0xff == 0x1 (0x1) +__longlong 0x7 || 0x7fff == 0x1 (0x1) +__ulonglong 0x7 || 0x7fff == 0x1 (0x1) +int 0x7 & 0x7fff == 0x7 (0x7) +__uint 0x7 & 0x7fff == 0x7 (0x7) +char 0x7 & 0xffff == 0x7 (0x7) +__uchar 0x7 & 0xff == 0x7 (0x7) +__longlong 0x7 & 0x7fff == 0x7 (0x7) +__ulonglong 0x7 & 0x7fff == 0x7 (0x7) +int 0x7 | 0x7fff == 0x7fff (0x7fff) +__uint 0x7 | 0x7fff == 0x7fff (0x7fff) +char 0x7 | 0xffff == -0x1 (0xffff) +__uchar 0x7 | 0xff == 0xff (0xff) +__longlong 0x7 | 0x7fff == 0x7fff (0x7fff) +__ulonglong 0x7 | 0x7fff == 0x7fff (0x7fff) +int 0x7 << 0x10 == 0x0 (0x0) +__uint 0x7 << 0x10 == 0x0 (0x0) +char 0x7 << 0x10 == 0x0 (0x0) +__uchar 0x7 << 0x10 == 0x0 (0x0) +__longlong 0x7 << 0x10 == 0x0 (0x0) +__ulonglong 0x7 << 0x10 == 0x0 (0x0) +int 0x7 >> 0x10 == 0x0 (0x0) +__uint 0x7 >> 0x10 == 0x0 (0x0) +char 0x7 >> 0x10 == 0x0 (0x0) +__uchar 0x7 >> 0x10 == 0x0 (0x0) +__longlong 0x7 >> 0x10 == 0x0 (0x0) +__ulonglong 0x7 >> 0x10 == 0x0 (0x0) +int 0x7 + 0x7fff == -0x7ffa (0x8006) +__uint 0x7 + 0x7fff == -0x7ffa (0x8006) +char 0x7 + 0xffff == 0x6 (0x6) +__uchar 0x7 + 0xff == 0x6 (0x6) +__longlong 0x7 + 0x7fff == -0x7ffa (0x8006) +__ulonglong 0x7 + 0x7fff == -0x7ffa (0x8006) +float 0x7 + 0x7fff == -0x8000 (0x8000) +int 0x7 - 0x7fff == -0x7ff8 (0x8008) +__uint 0x7 - 0x7fff == -0x7ff8 (0x8008) +char 0x7 - 0xffff == 0x8 (0x8) +__uchar 0x7 - 0xff == 0x8 (0x8) +__longlong 0x7 - 0x7fff == -0x7ff8 (0x8008) +__ulonglong 0x7 - 0x7fff == -0x7ff8 (0x8008) +float 0x7 - 0x7fff == -0x7ff8 (0x8008) +int 0x7 * 0x7fff == 0x7ff9 (0x7ff9) +__uint 0x7 * 0x7fff == 0x7ff9 (0x7ff9) +char 0x7 * 0xffff == -0x7 (0xfff9) +__uchar 0x7 * 0xff == 0xf9 (0xf9) +__longlong 0x7 * 0x7fff == 0x7ff9 (0x7ff9) +__ulonglong 0x7 * 0x7fff == 0x7ff9 (0x7ff9) +float 0x7 * 0x7fff == -0x8000 (0x8000) +int 0x7 < 0x7fff == 0x1 (0x1) +__uint 0x7 < 0x7fff == 0x1 (0x1) +char 0x7 < 0xffff == 0x0 (0x0) +__uchar 0x7 < 0xff == 0x1 (0x1) +__longlong 0x7 < 0x7fff == 0x1 (0x1) +__ulonglong 0x7 < 0x7fff == 0x1 (0x1) +float 0x7 < 0x7fff == 0x1 (0x1) +int 0x7 > 0x7fff == 0x0 (0x0) +__uint 0x7 > 0x7fff == 0x0 (0x0) +char 0x7 > 0xffff == 0x1 (0x1) +__uchar 0x7 > 0xff == 0x0 (0x0) +__longlong 0x7 > 0x7fff == 0x0 (0x0) +__ulonglong 0x7 > 0x7fff == 0x0 (0x0) +float 0x7 > 0x7fff == 0x0 (0x0) +int 0x7 <= 0x7fff == 0x1 (0x1) +__uint 0x7 <= 0x7fff == 0x1 (0x1) +char 0x7 <= 0xffff == 0x0 (0x0) +__uchar 0x7 <= 0xff == 0x1 (0x1) +__longlong 0x7 <= 0x7fff == 0x1 (0x1) +__ulonglong 0x7 <= 0x7fff == 0x1 (0x1) +float 0x7 <= 0x7fff == 0x1 (0x1) +int 0x7 == 0x7fff == 0x0 (0x0) +__uint 0x7 == 0x7fff == 0x0 (0x0) +char 0x7 == 0xffff == 0x0 (0x0) +__uchar 0x7 == 0xff == 0x0 (0x0) +__longlong 0x7 == 0x7fff == 0x0 (0x0) +__ulonglong 0x7 == 0x7fff == 0x0 (0x0) +float 0x7 == 0x7fff == 0x0 (0x0) +int 0x7 != 0x7fff == 0x1 (0x1) +__uint 0x7 != 0x7fff == 0x1 (0x1) +char 0x7 != 0xffff == 0x1 (0x1) +__uchar 0x7 != 0xff == 0x1 (0x1) +__longlong 0x7 != 0x7fff == 0x1 (0x1) +__ulonglong 0x7 != 0x7fff == 0x1 (0x1) +float 0x7 != 0x7fff == 0x1 (0x1) +int 0x7 >= 0x7fff == 0x0 (0x0) +__uint 0x7 >= 0x7fff == 0x0 (0x0) +char 0x7 >= 0xffff == 0x1 (0x1) +__uchar 0x7 >= 0xff == 0x0 (0x0) +__longlong 0x7 >= 0x7fff == 0x0 (0x0) +__ulonglong 0x7 >= 0x7fff == 0x0 (0x0) +float 0x7 >= 0x7fff == 0x0 (0x0) +int 0x7 / 0x7fff == 0x0 (0x0) +__uint 0x7 / 0x7fff == 0x0 (0x0) +char 0x7 / 0xffff == -0x7 (0xfff9) +__uchar 0x7 / 0xff == 0x0 (0x0) +__longlong 0x7 / 0x7fff == 0x0 (0x0) +__ulonglong 0x7 / 0x7fff == 0x0 (0x0) +float 0x7 / 0x7fff == 0x0 (0x0) +int 0x7 % 0x7fff == 0x7 (0x7) +__uint 0x7 % 0x7fff == 0x7 (0x7) +char 0x7 % 0xffff == 0x0 (0x0) +__uchar 0x7 % 0xff == 0x7 (0x7) +__longlong 0x7 % 0x7fff == 0x7 (0x7) +__ulonglong 0x7 % 0x7fff == 0x7 (0x7) +0x7 * 0x8000 == -0x8000 +0x7 / 0x8000 == 0x0 +0x7 % 0x8000 == 0x7 +int 0x7 ^ 0x8000 == -0x7ff9 (0x8007) +__uint 0x7 ^ 0x8000 == -0x7ff9 (0x8007) +char 0x7 ^ 0x0 == 0x7 (0x7) +__uchar 0x7 ^ 0x0 == 0x7 (0x7) +__longlong 0x7 ^ 0x8000 == -0x7ff9 (0x8007) +__ulonglong 0x7 ^ 0x8000 == -0x7ff9 (0x8007) +int 0x7 && 0x8000 == 0x1 (0x1) +__uint 0x7 && 0x8000 == 0x1 (0x1) +char 0x7 && 0x0 == 0x0 (0x0) +__uchar 0x7 && 0x0 == 0x0 (0x0) +__longlong 0x7 && 0x8000 == 0x1 (0x1) +__ulonglong 0x7 && 0x8000 == 0x1 (0x1) +int 0x7 || 0x8000 == 0x1 (0x1) +__uint 0x7 || 0x8000 == 0x1 (0x1) +char 0x7 || 0x0 == 0x1 (0x1) +__uchar 0x7 || 0x0 == 0x1 (0x1) +__longlong 0x7 || 0x8000 == 0x1 (0x1) +__ulonglong 0x7 || 0x8000 == 0x1 (0x1) +int 0x7 & 0x8000 == 0x0 (0x0) +__uint 0x7 & 0x8000 == 0x0 (0x0) +char 0x7 & 0x0 == 0x0 (0x0) +__uchar 0x7 & 0x0 == 0x0 (0x0) +__longlong 0x7 & 0x8000 == 0x0 (0x0) +__ulonglong 0x7 & 0x8000 == 0x0 (0x0) +int 0x7 | 0x8000 == -0x7ff9 (0x8007) +__uint 0x7 | 0x8000 == -0x7ff9 (0x8007) +char 0x7 | 0x0 == 0x7 (0x7) +__uchar 0x7 | 0x0 == 0x7 (0x7) +__longlong 0x7 | 0x8000 == -0x7ff9 (0x8007) +__ulonglong 0x7 | 0x8000 == -0x7ff9 (0x8007) +int 0x7 << 0x12 == 0x0 (0x0) +__uint 0x7 << 0x12 == 0x0 (0x0) +char 0x7 << 0x12 == 0x0 (0x0) +__uchar 0x7 << 0x12 == 0x0 (0x0) +__longlong 0x7 << 0x12 == 0x0 (0x0) +__ulonglong 0x7 << 0x12 == 0x0 (0x0) +int 0x7 >> 0x12 == 0x0 (0x0) +__uint 0x7 >> 0x12 == 0x0 (0x0) +char 0x7 >> 0x12 == 0x0 (0x0) +__uchar 0x7 >> 0x12 == 0x0 (0x0) +__longlong 0x7 >> 0x12 == 0x0 (0x0) +__ulonglong 0x7 >> 0x12 == 0x0 (0x0) +int 0x7 + 0x8000 == -0x7ff9 (0x8007) +__uint 0x7 + 0x8000 == -0x7ff9 (0x8007) +char 0x7 + 0x0 == 0x7 (0x7) +__uchar 0x7 + 0x0 == 0x7 (0x7) +__longlong 0x7 + 0x8000 == -0x7ff9 (0x8007) +__ulonglong 0x7 + 0x8000 == -0x7ff9 (0x8007) +float 0x7 + 0x8000 == -0x7ff9 (0x8007) +int 0x7 - 0x8000 == -0x7ff9 (0x8007) +__uint 0x7 - 0x8000 == -0x7ff9 (0x8007) +char 0x7 - 0x0 == 0x7 (0x7) +__uchar 0x7 - 0x0 == 0x7 (0x7) +__longlong 0x7 - 0x8000 == -0x7ff9 (0x8007) +__ulonglong 0x7 - 0x8000 == -0x7ff9 (0x8007) +float 0x7 - 0x8000 == -0x8000 (0x8000) +int 0x7 * 0x8000 == -0x8000 (0x8000) +__uint 0x7 * 0x8000 == -0x8000 (0x8000) +char 0x7 * 0x0 == 0x0 (0x0) +__uchar 0x7 * 0x0 == 0x0 (0x0) +__longlong 0x7 * 0x8000 == -0x8000 (0x8000) +__ulonglong 0x7 * 0x8000 == -0x8000 (0x8000) +float 0x7 * 0x8000 == -0x8000 (0x8000) +int 0x7 < 0x8000 == 0x0 (0x0) +__uint 0x7 < 0x8000 == 0x1 (0x1) +char 0x7 < 0x0 == 0x0 (0x0) +__uchar 0x7 < 0x0 == 0x0 (0x0) +__longlong 0x7 < 0x8000 == 0x0 (0x0) +__ulonglong 0x7 < 0x8000 == 0x1 (0x1) +float 0x7 < 0x8000 == 0x0 (0x0) +int 0x7 > 0x8000 == 0x1 (0x1) +__uint 0x7 > 0x8000 == 0x0 (0x0) +char 0x7 > 0x0 == 0x1 (0x1) +__uchar 0x7 > 0x0 == 0x1 (0x1) +__longlong 0x7 > 0x8000 == 0x1 (0x1) +__ulonglong 0x7 > 0x8000 == 0x0 (0x0) +float 0x7 > 0x8000 == 0x1 (0x1) +int 0x7 <= 0x8000 == 0x0 (0x0) +__uint 0x7 <= 0x8000 == 0x1 (0x1) +char 0x7 <= 0x0 == 0x0 (0x0) +__uchar 0x7 <= 0x0 == 0x0 (0x0) +__longlong 0x7 <= 0x8000 == 0x0 (0x0) +__ulonglong 0x7 <= 0x8000 == 0x1 (0x1) +float 0x7 <= 0x8000 == 0x0 (0x0) +int 0x7 == 0x8000 == 0x0 (0x0) +__uint 0x7 == 0x8000 == 0x0 (0x0) +char 0x7 == 0x0 == 0x0 (0x0) +__uchar 0x7 == 0x0 == 0x0 (0x0) +__longlong 0x7 == 0x8000 == 0x0 (0x0) +__ulonglong 0x7 == 0x8000 == 0x0 (0x0) +float 0x7 == 0x8000 == 0x0 (0x0) +int 0x7 != 0x8000 == 0x1 (0x1) +__uint 0x7 != 0x8000 == 0x1 (0x1) +char 0x7 != 0x0 == 0x1 (0x1) +__uchar 0x7 != 0x0 == 0x1 (0x1) +__longlong 0x7 != 0x8000 == 0x1 (0x1) +__ulonglong 0x7 != 0x8000 == 0x1 (0x1) +float 0x7 != 0x8000 == 0x1 (0x1) +int 0x7 >= 0x8000 == 0x1 (0x1) +__uint 0x7 >= 0x8000 == 0x0 (0x0) +char 0x7 >= 0x0 == 0x1 (0x1) +__uchar 0x7 >= 0x0 == 0x1 (0x1) +__longlong 0x7 >= 0x8000 == 0x1 (0x1) +__ulonglong 0x7 >= 0x8000 == 0x0 (0x0) +float 0x7 >= 0x8000 == 0x1 (0x1) +int 0x7 / 0x8000 == 0x0 (0x0) +__uint 0x7 / 0x8000 == 0x0 (0x0) +__longlong 0x7 / 0x8000 == 0x0 (0x0) +__ulonglong 0x7 / 0x8000 == 0x0 (0x0) +float 0x7 / 0x8000 == 0x0 (0x0) +int 0x7 % 0x8000 == 0x7 (0x7) +__uint 0x7 % 0x8000 == 0x7 (0x7) +__longlong 0x7 % 0x8000 == 0x7 (0x7) +__ulonglong 0x7 % 0x8000 == 0x7 (0x7) +0x7 * 0x3e8 == 0x1b58 +0x7 / 0x3e8 == 0x0 +0x7 % 0x3e8 == 0x7 +int 0x7 ^ 0x3e8 == 0x3ef (0x3ef) +__uint 0x7 ^ 0x3e8 == 0x3ef (0x3ef) +char 0x7 ^ 0xffe8 == -0x11 (0xffef) +__uchar 0x7 ^ 0xe8 == 0xef (0xef) +__longlong 0x7 ^ 0x3e8 == 0x3ef (0x3ef) +__ulonglong 0x7 ^ 0x3e8 == 0x3ef (0x3ef) +int 0x7 && 0x3e8 == 0x1 (0x1) +__uint 0x7 && 0x3e8 == 0x1 (0x1) +char 0x7 && 0xffe8 == 0x1 (0x1) +__uchar 0x7 && 0xe8 == 0x1 (0x1) +__longlong 0x7 && 0x3e8 == 0x1 (0x1) +__ulonglong 0x7 && 0x3e8 == 0x1 (0x1) +int 0x7 || 0x3e8 == 0x1 (0x1) +__uint 0x7 || 0x3e8 == 0x1 (0x1) +char 0x7 || 0xffe8 == 0x1 (0x1) +__uchar 0x7 || 0xe8 == 0x1 (0x1) +__longlong 0x7 || 0x3e8 == 0x1 (0x1) +__ulonglong 0x7 || 0x3e8 == 0x1 (0x1) +int 0x7 & 0x3e8 == 0x0 (0x0) +__uint 0x7 & 0x3e8 == 0x0 (0x0) +char 0x7 & 0xffe8 == 0x0 (0x0) +__uchar 0x7 & 0xe8 == 0x0 (0x0) +__longlong 0x7 & 0x3e8 == 0x0 (0x0) +__ulonglong 0x7 & 0x3e8 == 0x0 (0x0) +int 0x7 | 0x3e8 == 0x3ef (0x3ef) +__uint 0x7 | 0x3e8 == 0x3ef (0x3ef) +char 0x7 | 0xffe8 == -0x11 (0xffef) +__uchar 0x7 | 0xe8 == 0xef (0xef) +__longlong 0x7 | 0x3e8 == 0x3ef (0x3ef) +__ulonglong 0x7 | 0x3e8 == 0x3ef (0x3ef) +int 0x7 << 0x14 == 0x0 (0x0) +__uint 0x7 << 0x14 == 0x0 (0x0) +char 0x7 << 0x14 == 0x0 (0x0) +__uchar 0x7 << 0x14 == 0x0 (0x0) +__longlong 0x7 << 0x14 == 0x0 (0x0) +__ulonglong 0x7 << 0x14 == 0x0 (0x0) +int 0x7 >> 0x14 == 0x0 (0x0) +__uint 0x7 >> 0x14 == 0x0 (0x0) +char 0x7 >> 0x14 == 0x0 (0x0) +__uchar 0x7 >> 0x14 == 0x0 (0x0) +__longlong 0x7 >> 0x14 == 0x0 (0x0) +__ulonglong 0x7 >> 0x14 == 0x0 (0x0) +int 0x7 + 0x3e8 == 0x3ef (0x3ef) +__uint 0x7 + 0x3e8 == 0x3ef (0x3ef) +char 0x7 + 0xffe8 == -0x11 (0xffef) +__uchar 0x7 + 0xe8 == 0xef (0xef) +__longlong 0x7 + 0x3e8 == 0x3ef (0x3ef) +__ulonglong 0x7 + 0x3e8 == 0x3ef (0x3ef) +float 0x7 + 0x3e8 == 0x3ef (0x3ef) +int 0x7 - 0x3e8 == -0x3e1 (0xfc1f) +__uint 0x7 - 0x3e8 == -0x3e1 (0xfc1f) +char 0x7 - 0xffe8 == 0x1f (0x1f) +__uchar 0x7 - 0xe8 == 0x1f (0x1f) +__longlong 0x7 - 0x3e8 == -0x3e1 (0xfc1f) +__ulonglong 0x7 - 0x3e8 == -0x3e1 (0xfc1f) +float 0x7 - 0x3e8 == -0x3e1 (0xfc1f) +int 0x7 * 0x3e8 == 0x1b58 (0x1b58) +__uint 0x7 * 0x3e8 == 0x1b58 (0x1b58) +char 0x7 * 0xffe8 == 0x58 (0x58) +__uchar 0x7 * 0xe8 == 0x58 (0x58) +__longlong 0x7 * 0x3e8 == 0x1b58 (0x1b58) +__ulonglong 0x7 * 0x3e8 == 0x1b58 (0x1b58) +float 0x7 * 0x3e8 == 0x1b58 (0x1b58) +int 0x7 < 0x3e8 == 0x1 (0x1) +__uint 0x7 < 0x3e8 == 0x1 (0x1) +char 0x7 < 0xffe8 == 0x0 (0x0) +__uchar 0x7 < 0xe8 == 0x1 (0x1) +__longlong 0x7 < 0x3e8 == 0x1 (0x1) +__ulonglong 0x7 < 0x3e8 == 0x1 (0x1) +float 0x7 < 0x3e8 == 0x1 (0x1) +int 0x7 > 0x3e8 == 0x0 (0x0) +__uint 0x7 > 0x3e8 == 0x0 (0x0) +char 0x7 > 0xffe8 == 0x1 (0x1) +__uchar 0x7 > 0xe8 == 0x0 (0x0) +__longlong 0x7 > 0x3e8 == 0x0 (0x0) +__ulonglong 0x7 > 0x3e8 == 0x0 (0x0) +float 0x7 > 0x3e8 == 0x0 (0x0) +int 0x7 <= 0x3e8 == 0x1 (0x1) +__uint 0x7 <= 0x3e8 == 0x1 (0x1) +char 0x7 <= 0xffe8 == 0x0 (0x0) +__uchar 0x7 <= 0xe8 == 0x1 (0x1) +__longlong 0x7 <= 0x3e8 == 0x1 (0x1) +__ulonglong 0x7 <= 0x3e8 == 0x1 (0x1) +float 0x7 <= 0x3e8 == 0x1 (0x1) +int 0x7 == 0x3e8 == 0x0 (0x0) +__uint 0x7 == 0x3e8 == 0x0 (0x0) +char 0x7 == 0xffe8 == 0x0 (0x0) +__uchar 0x7 == 0xe8 == 0x0 (0x0) +__longlong 0x7 == 0x3e8 == 0x0 (0x0) +__ulonglong 0x7 == 0x3e8 == 0x0 (0x0) +float 0x7 == 0x3e8 == 0x0 (0x0) +int 0x7 != 0x3e8 == 0x1 (0x1) +__uint 0x7 != 0x3e8 == 0x1 (0x1) +char 0x7 != 0xffe8 == 0x1 (0x1) +__uchar 0x7 != 0xe8 == 0x1 (0x1) +__longlong 0x7 != 0x3e8 == 0x1 (0x1) +__ulonglong 0x7 != 0x3e8 == 0x1 (0x1) +float 0x7 != 0x3e8 == 0x1 (0x1) +int 0x7 >= 0x3e8 == 0x0 (0x0) +__uint 0x7 >= 0x3e8 == 0x0 (0x0) +char 0x7 >= 0xffe8 == 0x1 (0x1) +__uchar 0x7 >= 0xe8 == 0x0 (0x0) +__longlong 0x7 >= 0x3e8 == 0x0 (0x0) +__ulonglong 0x7 >= 0x3e8 == 0x0 (0x0) +float 0x7 >= 0x3e8 == 0x0 (0x0) +int 0x7 / 0x3e8 == 0x0 (0x0) +__uint 0x7 / 0x3e8 == 0x0 (0x0) +char 0x7 / 0xffe8 == 0x0 (0x0) +__uchar 0x7 / 0xe8 == 0x0 (0x0) +__longlong 0x7 / 0x3e8 == 0x0 (0x0) +__ulonglong 0x7 / 0x3e8 == 0x0 (0x0) +float 0x7 / 0x3e8 == 0x0 (0x0) +int 0x7 % 0x3e8 == 0x7 (0x7) +__uint 0x7 % 0x3e8 == 0x7 (0x7) +char 0x7 % 0xffe8 == 0x7 (0x7) +__uchar 0x7 % 0xe8 == 0x7 (0x7) +__longlong 0x7 % 0x3e8 == 0x7 (0x7) +__ulonglong 0x7 % 0x3e8 == 0x7 (0x7) +0x7 * 0x2710 == 0x1170 +0x7 / 0x2710 == 0x0 +0x7 % 0x2710 == 0x7 +int 0x7 ^ 0x2710 == 0x2717 (0x2717) +__uint 0x7 ^ 0x2710 == 0x2717 (0x2717) +char 0x7 ^ 0x10 == 0x17 (0x17) +__uchar 0x7 ^ 0x10 == 0x17 (0x17) +__longlong 0x7 ^ 0x2710 == 0x2717 (0x2717) +__ulonglong 0x7 ^ 0x2710 == 0x2717 (0x2717) +int 0x7 && 0x2710 == 0x1 (0x1) +__uint 0x7 && 0x2710 == 0x1 (0x1) +char 0x7 && 0x10 == 0x1 (0x1) +__uchar 0x7 && 0x10 == 0x1 (0x1) +__longlong 0x7 && 0x2710 == 0x1 (0x1) +__ulonglong 0x7 && 0x2710 == 0x1 (0x1) +int 0x7 || 0x2710 == 0x1 (0x1) +__uint 0x7 || 0x2710 == 0x1 (0x1) +char 0x7 || 0x10 == 0x1 (0x1) +__uchar 0x7 || 0x10 == 0x1 (0x1) +__longlong 0x7 || 0x2710 == 0x1 (0x1) +__ulonglong 0x7 || 0x2710 == 0x1 (0x1) +int 0x7 & 0x2710 == 0x0 (0x0) +__uint 0x7 & 0x2710 == 0x0 (0x0) +char 0x7 & 0x10 == 0x0 (0x0) +__uchar 0x7 & 0x10 == 0x0 (0x0) +__longlong 0x7 & 0x2710 == 0x0 (0x0) +__ulonglong 0x7 & 0x2710 == 0x0 (0x0) +int 0x7 | 0x2710 == 0x2717 (0x2717) +__uint 0x7 | 0x2710 == 0x2717 (0x2717) +char 0x7 | 0x10 == 0x17 (0x17) +__uchar 0x7 | 0x10 == 0x17 (0x17) +__longlong 0x7 | 0x2710 == 0x2717 (0x2717) +__ulonglong 0x7 | 0x2710 == 0x2717 (0x2717) +int 0x7 << 0x16 == 0x0 (0x0) +__uint 0x7 << 0x16 == 0x0 (0x0) +char 0x7 << 0x16 == 0x0 (0x0) +__uchar 0x7 << 0x16 == 0x0 (0x0) +__longlong 0x7 << 0x16 == 0x0 (0x0) +__ulonglong 0x7 << 0x16 == 0x0 (0x0) +int 0x7 >> 0x16 == 0x0 (0x0) +__uint 0x7 >> 0x16 == 0x0 (0x0) +char 0x7 >> 0x16 == 0x0 (0x0) +__uchar 0x7 >> 0x16 == 0x0 (0x0) +__longlong 0x7 >> 0x16 == 0x0 (0x0) +__ulonglong 0x7 >> 0x16 == 0x0 (0x0) +int 0x7 + 0x2710 == 0x2717 (0x2717) +__uint 0x7 + 0x2710 == 0x2717 (0x2717) +char 0x7 + 0x10 == 0x17 (0x17) +__uchar 0x7 + 0x10 == 0x17 (0x17) +__longlong 0x7 + 0x2710 == 0x2717 (0x2717) +__ulonglong 0x7 + 0x2710 == 0x2717 (0x2717) +float 0x7 + 0x2710 == 0x2717 (0x2717) +int 0x7 - 0x2710 == -0x2709 (0xd8f7) +__uint 0x7 - 0x2710 == -0x2709 (0xd8f7) +char 0x7 - 0x10 == -0x9 (0xfff7) +__uchar 0x7 - 0x10 == 0xf7 (0xf7) +__longlong 0x7 - 0x2710 == -0x2709 (0xd8f7) +__ulonglong 0x7 - 0x2710 == -0x2709 (0xd8f7) +float 0x7 - 0x2710 == -0x2709 (0xd8f7) +int 0x7 * 0x2710 == 0x1170 (0x1170) +__uint 0x7 * 0x2710 == 0x1170 (0x1170) +char 0x7 * 0x10 == 0x70 (0x70) +__uchar 0x7 * 0x10 == 0x70 (0x70) +__longlong 0x7 * 0x2710 == 0x1170 (0x1170) +__ulonglong 0x7 * 0x2710 == 0x1170 (0x1170) +float 0x7 * 0x2710 == -0x8000 (0x8000) +int 0x7 < 0x2710 == 0x1 (0x1) +__uint 0x7 < 0x2710 == 0x1 (0x1) +char 0x7 < 0x10 == 0x1 (0x1) +__uchar 0x7 < 0x10 == 0x1 (0x1) +__longlong 0x7 < 0x2710 == 0x1 (0x1) +__ulonglong 0x7 < 0x2710 == 0x1 (0x1) +float 0x7 < 0x2710 == 0x1 (0x1) +int 0x7 > 0x2710 == 0x0 (0x0) +__uint 0x7 > 0x2710 == 0x0 (0x0) +char 0x7 > 0x10 == 0x0 (0x0) +__uchar 0x7 > 0x10 == 0x0 (0x0) +__longlong 0x7 > 0x2710 == 0x0 (0x0) +__ulonglong 0x7 > 0x2710 == 0x0 (0x0) +float 0x7 > 0x2710 == 0x0 (0x0) +int 0x7 <= 0x2710 == 0x1 (0x1) +__uint 0x7 <= 0x2710 == 0x1 (0x1) +char 0x7 <= 0x10 == 0x1 (0x1) +__uchar 0x7 <= 0x10 == 0x1 (0x1) +__longlong 0x7 <= 0x2710 == 0x1 (0x1) +__ulonglong 0x7 <= 0x2710 == 0x1 (0x1) +float 0x7 <= 0x2710 == 0x1 (0x1) +int 0x7 == 0x2710 == 0x0 (0x0) +__uint 0x7 == 0x2710 == 0x0 (0x0) +char 0x7 == 0x10 == 0x0 (0x0) +__uchar 0x7 == 0x10 == 0x0 (0x0) +__longlong 0x7 == 0x2710 == 0x0 (0x0) +__ulonglong 0x7 == 0x2710 == 0x0 (0x0) +float 0x7 == 0x2710 == 0x0 (0x0) +int 0x7 != 0x2710 == 0x1 (0x1) +__uint 0x7 != 0x2710 == 0x1 (0x1) +char 0x7 != 0x10 == 0x1 (0x1) +__uchar 0x7 != 0x10 == 0x1 (0x1) +__longlong 0x7 != 0x2710 == 0x1 (0x1) +__ulonglong 0x7 != 0x2710 == 0x1 (0x1) +float 0x7 != 0x2710 == 0x1 (0x1) +int 0x7 >= 0x2710 == 0x0 (0x0) +__uint 0x7 >= 0x2710 == 0x0 (0x0) +char 0x7 >= 0x10 == 0x0 (0x0) +__uchar 0x7 >= 0x10 == 0x0 (0x0) +__longlong 0x7 >= 0x2710 == 0x0 (0x0) +__ulonglong 0x7 >= 0x2710 == 0x0 (0x0) +float 0x7 >= 0x2710 == 0x0 (0x0) +int 0x7 / 0x2710 == 0x0 (0x0) +__uint 0x7 / 0x2710 == 0x0 (0x0) +char 0x7 / 0x10 == 0x0 (0x0) +__uchar 0x7 / 0x10 == 0x0 (0x0) +__longlong 0x7 / 0x2710 == 0x0 (0x0) +__ulonglong 0x7 / 0x2710 == 0x0 (0x0) +float 0x7 / 0x2710 == 0x0 (0x0) +int 0x7 % 0x2710 == 0x7 (0x7) +__uint 0x7 % 0x2710 == 0x7 (0x7) +char 0x7 % 0x10 == 0x7 (0x7) +__uchar 0x7 % 0x10 == 0x7 (0x7) +__longlong 0x7 % 0x2710 == 0x7 (0x7) +__ulonglong 0x7 % 0x2710 == 0x7 (0x7) +int xor420x7 xor42 0x2d +__uint xor420x7 xor42 0x2d +char xor420x7 xor42 0x2d +__uchar xor420x7 xor42 0x2d +__longlong xor420x7 xor42 0x2d +__ulonglong xor420x7 xor42 0x2d +int land10x7 land1 0x1 +__uint land10x7 land1 0x1 +char land10x7 land1 0x1 +__uchar land10x7 land1 0x1 +__longlong land10x7 land1 0x1 +__ulonglong land10x7 land1 0x1 +int lor10x7 lor1 0x1 +__uint lor10x7 lor1 0x1 +char lor10x7 lor1 0x1 +__uchar lor10x7 lor1 0x1 +__longlong lor10x7 lor1 0x1 +__ulonglong lor10x7 lor1 0x1 +int and420x7 and42 0x2 +__uint and420x7 and42 0x2 +char and420x7 and42 0x2 +__uchar and420x7 and42 0x2 +__longlong and420x7 and42 0x2 +__ulonglong and420x7 and42 0x2 +int or420x7 or42 0x2f +__uint or420x7 or42 0x2f +char or420x7 or42 0x2f +__uchar or420x7 or42 0x2f +__longlong or420x7 or42 0x2f +__ulonglong or420x7 or42 0x2f +int shl50x7 shl5 0xe0 +__uint shl50x7 shl5 0xe0 +char shl50x7 shl5 -0x20 +__uchar shl50x7 shl5 0xe0 +__longlong shl50x7 shl5 0xe0 +__ulonglong shl50x7 shl5 0xe0 +int shr50x7 shr5 0x0 +__uint shr50x7 shr5 0x0 +char shr50x7 shr5 0x0 +__uchar shr50x7 shr5 0x0 +__longlong shr50x7 shr5 0x0 +__ulonglong shr50x7 shr5 0x0 +int add420x7 add42 0x31 +__uint add420x7 add42 0x31 +char add420x7 add42 0x31 +__uchar add420x7 add42 0x31 +__longlong add420x7 add42 0x31 +__ulonglong add420x7 add42 0x31 +float add420x7 add42 0x31 +int sub420x7 sub42 -0x23 +__uint sub420x7 sub42 -0x23 +char sub420x7 sub42 -0x23 +__uchar sub420x7 sub42 0xdd +__longlong sub420x7 sub42 -0x23 +__ulonglong sub420x7 sub42 -0x23 +float sub420x7 sub42 -0x23 +int mul420x7 mul42 0x126 +__uint mul420x7 mul42 0x126 +char mul420x7 mul42 0x26 +__uchar mul420x7 mul42 0x26 +__longlong mul420x7 mul42 0x126 +__ulonglong mul420x7 mul42 0x126 +float mul420x7 mul42 0x126 +int lt420x7 lt42 0x1 +__uint lt420x7 lt42 0x1 +char lt420x7 lt42 0x1 +__uchar lt420x7 lt42 0x1 +__longlong lt420x7 lt42 0x1 +__ulonglong lt420x7 lt42 0x1 +float lt420x7 lt42 0x1 +int gt420x7 gt42 0x0 +__uint gt420x7 gt42 0x0 +char gt420x7 gt42 0x0 +__uchar gt420x7 gt42 0x0 +__longlong gt420x7 gt42 0x0 +__ulonglong gt420x7 gt42 0x0 +float gt420x7 gt42 0x0 +int le420x7 le42 0x1 +__uint le420x7 le42 0x1 +char le420x7 le42 0x1 +__uchar le420x7 le42 0x1 +__longlong le420x7 le42 0x1 +__ulonglong le420x7 le42 0x1 +float le420x7 le42 0x1 +int eq420x7 eq42 0x0 +__uint eq420x7 eq42 0x0 +char eq420x7 eq42 0x0 +__uchar eq420x7 eq42 0x0 +__longlong eq420x7 eq42 0x0 +__ulonglong eq420x7 eq42 0x0 +float eq420x7 eq42 0x0 +int ne420x7 ne42 0x1 +__uint ne420x7 ne42 0x1 +char ne420x7 ne42 0x1 +__uchar ne420x7 ne42 0x1 +__longlong ne420x7 ne42 0x1 +__ulonglong ne420x7 ne42 0x1 +float ne420x7 ne42 0x1 +int ge420x7 ge42 0x0 +__uint ge420x7 ge42 0x0 +char ge420x7 ge42 0x0 +__uchar ge420x7 ge42 0x0 +__longlong ge420x7 ge42 0x0 +__ulonglong ge420x7 ge42 0x0 +float ge420x7 ge42 0x0 +int div420x7 div42 0x0 +__uint div420x7 div42 0x0 +char div420x7 div42 0x0 +__uchar div420x7 div42 0x0 +__longlong div420x7 div42 0x0 +__ulonglong div420x7 div42 0x0 +float div420x7 div42 0x0 +int mod230x7 mod23 0x7 +__uint mod230x7 mod23 0x7 +char mod230x7 mod23 0x7 +__uchar mod230x7 mod23 0x7 +__longlong mod230x7 mod23 0x7 +__ulonglong mod230x7 mod23 0x7 +0x2a * 0xffff == -0x2a +0x2a / 0xffff == -0x2a +0x2a % 0xffff == 0x0 +int 0x2a ^ 0xffff == -0x2b (0xffd5) +__uint 0x2a ^ 0xffff == -0x2b (0xffd5) +char 0x2a ^ 0xffff == -0x2b (0xffd5) +__uchar 0x2a ^ 0xff == 0xd5 (0xd5) +__longlong 0x2a ^ 0xffff == -0x2b (0xffd5) +__ulonglong 0x2a ^ 0xffff == -0x2b (0xffd5) +int 0x2a && 0xffff == 0x1 (0x1) +__uint 0x2a && 0xffff == 0x1 (0x1) +char 0x2a && 0xffff == 0x1 (0x1) +__uchar 0x2a && 0xff == 0x1 (0x1) +__longlong 0x2a && 0xffff == 0x1 (0x1) +__ulonglong 0x2a && 0xffff == 0x1 (0x1) +int 0x2a || 0xffff == 0x1 (0x1) +__uint 0x2a || 0xffff == 0x1 (0x1) +char 0x2a || 0xffff == 0x1 (0x1) +__uchar 0x2a || 0xff == 0x1 (0x1) +__longlong 0x2a || 0xffff == 0x1 (0x1) +__ulonglong 0x2a || 0xffff == 0x1 (0x1) +int 0x2a & 0xffff == 0x2a (0x2a) +__uint 0x2a & 0xffff == 0x2a (0x2a) +char 0x2a & 0xffff == 0x2a (0x2a) +__uchar 0x2a & 0xff == 0x2a (0x2a) +__longlong 0x2a & 0xffff == 0x2a (0x2a) +__ulonglong 0x2a & 0xffff == 0x2a (0x2a) +int 0x2a | 0xffff == -0x1 (0xffff) +__uint 0x2a | 0xffff == -0x1 (0xffff) +char 0x2a | 0xffff == -0x1 (0xffff) +__uchar 0x2a | 0xff == 0xff (0xff) +__longlong 0x2a | 0xffff == -0x1 (0xffff) +__ulonglong 0x2a | 0xffff == -0x1 (0xffff) +int 0x2a << 0x1 == 0x54 (0x54) +__uint 0x2a << 0x1 == 0x54 (0x54) +char 0x2a << 0x1 == 0x54 (0x54) +__uchar 0x2a << 0x1 == 0x54 (0x54) +__longlong 0x2a << 0x1 == 0x54 (0x54) +__ulonglong 0x2a << 0x1 == 0x54 (0x54) +int 0x2a >> 0x1 == 0x15 (0x15) +__uint 0x2a >> 0x1 == 0x15 (0x15) +char 0x2a >> 0x1 == 0x15 (0x15) +__uchar 0x2a >> 0x1 == 0x15 (0x15) +__longlong 0x2a >> 0x1 == 0x15 (0x15) +__ulonglong 0x2a >> 0x1 == 0x15 (0x15) +int 0x2a + 0xffff == 0x29 (0x29) +__uint 0x2a + 0xffff == 0x29 (0x29) +char 0x2a + 0xffff == 0x29 (0x29) +__uchar 0x2a + 0xff == 0x29 (0x29) +__longlong 0x2a + 0xffff == 0x29 (0x29) +__ulonglong 0x2a + 0xffff == 0x29 (0x29) +float 0x2a + 0xffff == 0x29 (0x29) +int 0x2a - 0xffff == 0x2b (0x2b) +__uint 0x2a - 0xffff == 0x2b (0x2b) +char 0x2a - 0xffff == 0x2b (0x2b) +__uchar 0x2a - 0xff == 0x2b (0x2b) +__longlong 0x2a - 0xffff == 0x2b (0x2b) +__ulonglong 0x2a - 0xffff == 0x2b (0x2b) +float 0x2a - 0xffff == 0x2b (0x2b) +int 0x2a * 0xffff == -0x2a (0xffd6) +__uint 0x2a * 0xffff == -0x2a (0xffd6) +char 0x2a * 0xffff == -0x2a (0xffd6) +__uchar 0x2a * 0xff == 0xd6 (0xd6) +__longlong 0x2a * 0xffff == -0x2a (0xffd6) +__ulonglong 0x2a * 0xffff == -0x2a (0xffd6) +float 0x2a * 0xffff == -0x2a (0xffd6) +int 0x2a < 0xffff == 0x0 (0x0) +__uint 0x2a < 0xffff == 0x1 (0x1) +char 0x2a < 0xffff == 0x0 (0x0) +__uchar 0x2a < 0xff == 0x1 (0x1) +__longlong 0x2a < 0xffff == 0x0 (0x0) +__ulonglong 0x2a < 0xffff == 0x1 (0x1) +float 0x2a < 0xffff == 0x0 (0x0) +int 0x2a > 0xffff == 0x1 (0x1) +__uint 0x2a > 0xffff == 0x0 (0x0) +char 0x2a > 0xffff == 0x1 (0x1) +__uchar 0x2a > 0xff == 0x0 (0x0) +__longlong 0x2a > 0xffff == 0x1 (0x1) +__ulonglong 0x2a > 0xffff == 0x0 (0x0) +float 0x2a > 0xffff == 0x1 (0x1) +int 0x2a <= 0xffff == 0x0 (0x0) +__uint 0x2a <= 0xffff == 0x1 (0x1) +char 0x2a <= 0xffff == 0x0 (0x0) +__uchar 0x2a <= 0xff == 0x1 (0x1) +__longlong 0x2a <= 0xffff == 0x0 (0x0) +__ulonglong 0x2a <= 0xffff == 0x1 (0x1) +float 0x2a <= 0xffff == 0x0 (0x0) +int 0x2a == 0xffff == 0x0 (0x0) +__uint 0x2a == 0xffff == 0x0 (0x0) +char 0x2a == 0xffff == 0x0 (0x0) +__uchar 0x2a == 0xff == 0x0 (0x0) +__longlong 0x2a == 0xffff == 0x0 (0x0) +__ulonglong 0x2a == 0xffff == 0x0 (0x0) +float 0x2a == 0xffff == 0x0 (0x0) +int 0x2a != 0xffff == 0x1 (0x1) +__uint 0x2a != 0xffff == 0x1 (0x1) +char 0x2a != 0xffff == 0x1 (0x1) +__uchar 0x2a != 0xff == 0x1 (0x1) +__longlong 0x2a != 0xffff == 0x1 (0x1) +__ulonglong 0x2a != 0xffff == 0x1 (0x1) +float 0x2a != 0xffff == 0x1 (0x1) +int 0x2a >= 0xffff == 0x1 (0x1) +__uint 0x2a >= 0xffff == 0x0 (0x0) +char 0x2a >= 0xffff == 0x1 (0x1) +__uchar 0x2a >= 0xff == 0x0 (0x0) +__longlong 0x2a >= 0xffff == 0x1 (0x1) +__ulonglong 0x2a >= 0xffff == 0x0 (0x0) +float 0x2a >= 0xffff == 0x1 (0x1) +int 0x2a / 0xffff == -0x2a (0xffd6) +__uint 0x2a / 0xffff == 0x0 (0x0) +char 0x2a / 0xffff == -0x2a (0xffd6) +__uchar 0x2a / 0xff == 0x0 (0x0) +__longlong 0x2a / 0xffff == -0x2a (0xffd6) +__ulonglong 0x2a / 0xffff == 0x0 (0x0) +float 0x2a / 0xffff == -0x2a (0xffd6) +int 0x2a % 0xffff == 0x0 (0x0) +__uint 0x2a % 0xffff == 0x2a (0x2a) +char 0x2a % 0xffff == 0x0 (0x0) +__uchar 0x2a % 0xff == 0x2a (0x2a) +__longlong 0x2a % 0xffff == 0x0 (0x0) +__ulonglong 0x2a % 0xffff == 0x2a (0x2a) +0x2a * 0x1 == 0x2a +0x2a / 0x1 == 0x2a +0x2a % 0x1 == 0x0 +int 0x2a ^ 0x1 == 0x2b (0x2b) +__uint 0x2a ^ 0x1 == 0x2b (0x2b) +char 0x2a ^ 0x1 == 0x2b (0x2b) +__uchar 0x2a ^ 0x1 == 0x2b (0x2b) +__longlong 0x2a ^ 0x1 == 0x2b (0x2b) +__ulonglong 0x2a ^ 0x1 == 0x2b (0x2b) +int 0x2a && 0x1 == 0x1 (0x1) +__uint 0x2a && 0x1 == 0x1 (0x1) +char 0x2a && 0x1 == 0x1 (0x1) +__uchar 0x2a && 0x1 == 0x1 (0x1) +__longlong 0x2a && 0x1 == 0x1 (0x1) +__ulonglong 0x2a && 0x1 == 0x1 (0x1) +int 0x2a || 0x1 == 0x1 (0x1) +__uint 0x2a || 0x1 == 0x1 (0x1) +char 0x2a || 0x1 == 0x1 (0x1) +__uchar 0x2a || 0x1 == 0x1 (0x1) +__longlong 0x2a || 0x1 == 0x1 (0x1) +__ulonglong 0x2a || 0x1 == 0x1 (0x1) +int 0x2a & 0x1 == 0x0 (0x0) +__uint 0x2a & 0x1 == 0x0 (0x0) +char 0x2a & 0x1 == 0x0 (0x0) +__uchar 0x2a & 0x1 == 0x0 (0x0) +__longlong 0x2a & 0x1 == 0x0 (0x0) +__ulonglong 0x2a & 0x1 == 0x0 (0x0) +int 0x2a | 0x1 == 0x2b (0x2b) +__uint 0x2a | 0x1 == 0x2b (0x2b) +char 0x2a | 0x1 == 0x2b (0x2b) +__uchar 0x2a | 0x1 == 0x2b (0x2b) +__longlong 0x2a | 0x1 == 0x2b (0x2b) +__ulonglong 0x2a | 0x1 == 0x2b (0x2b) +int 0x2a << 0x2 == 0xa8 (0xa8) +__uint 0x2a << 0x2 == 0xa8 (0xa8) +char 0x2a << 0x2 == -0x58 (0xffa8) +__uchar 0x2a << 0x2 == 0xa8 (0xa8) +__longlong 0x2a << 0x2 == 0xa8 (0xa8) +__ulonglong 0x2a << 0x2 == 0xa8 (0xa8) +int 0x2a >> 0x2 == 0xa (0xa) +__uint 0x2a >> 0x2 == 0xa (0xa) +char 0x2a >> 0x2 == 0xa (0xa) +__uchar 0x2a >> 0x2 == 0xa (0xa) +__longlong 0x2a >> 0x2 == 0xa (0xa) +__ulonglong 0x2a >> 0x2 == 0xa (0xa) +int 0x2a + 0x1 == 0x2b (0x2b) +__uint 0x2a + 0x1 == 0x2b (0x2b) +char 0x2a + 0x1 == 0x2b (0x2b) +__uchar 0x2a + 0x1 == 0x2b (0x2b) +__longlong 0x2a + 0x1 == 0x2b (0x2b) +__ulonglong 0x2a + 0x1 == 0x2b (0x2b) +float 0x2a + 0x1 == 0x2b (0x2b) +int 0x2a - 0x1 == 0x29 (0x29) +__uint 0x2a - 0x1 == 0x29 (0x29) +char 0x2a - 0x1 == 0x29 (0x29) +__uchar 0x2a - 0x1 == 0x29 (0x29) +__longlong 0x2a - 0x1 == 0x29 (0x29) +__ulonglong 0x2a - 0x1 == 0x29 (0x29) +float 0x2a - 0x1 == 0x29 (0x29) +int 0x2a * 0x1 == 0x2a (0x2a) +__uint 0x2a * 0x1 == 0x2a (0x2a) +char 0x2a * 0x1 == 0x2a (0x2a) +__uchar 0x2a * 0x1 == 0x2a (0x2a) +__longlong 0x2a * 0x1 == 0x2a (0x2a) +__ulonglong 0x2a * 0x1 == 0x2a (0x2a) +float 0x2a * 0x1 == 0x2a (0x2a) +int 0x2a < 0x1 == 0x0 (0x0) +__uint 0x2a < 0x1 == 0x0 (0x0) +char 0x2a < 0x1 == 0x0 (0x0) +__uchar 0x2a < 0x1 == 0x0 (0x0) +__longlong 0x2a < 0x1 == 0x0 (0x0) +__ulonglong 0x2a < 0x1 == 0x0 (0x0) +float 0x2a < 0x1 == 0x0 (0x0) +int 0x2a > 0x1 == 0x1 (0x1) +__uint 0x2a > 0x1 == 0x1 (0x1) +char 0x2a > 0x1 == 0x1 (0x1) +__uchar 0x2a > 0x1 == 0x1 (0x1) +__longlong 0x2a > 0x1 == 0x1 (0x1) +__ulonglong 0x2a > 0x1 == 0x1 (0x1) +float 0x2a > 0x1 == 0x1 (0x1) +int 0x2a <= 0x1 == 0x0 (0x0) +__uint 0x2a <= 0x1 == 0x0 (0x0) +char 0x2a <= 0x1 == 0x0 (0x0) +__uchar 0x2a <= 0x1 == 0x0 (0x0) +__longlong 0x2a <= 0x1 == 0x0 (0x0) +__ulonglong 0x2a <= 0x1 == 0x0 (0x0) +float 0x2a <= 0x1 == 0x0 (0x0) +int 0x2a == 0x1 == 0x0 (0x0) +__uint 0x2a == 0x1 == 0x0 (0x0) +char 0x2a == 0x1 == 0x0 (0x0) +__uchar 0x2a == 0x1 == 0x0 (0x0) +__longlong 0x2a == 0x1 == 0x0 (0x0) +__ulonglong 0x2a == 0x1 == 0x0 (0x0) +float 0x2a == 0x1 == 0x0 (0x0) +int 0x2a != 0x1 == 0x1 (0x1) +__uint 0x2a != 0x1 == 0x1 (0x1) +char 0x2a != 0x1 == 0x1 (0x1) +__uchar 0x2a != 0x1 == 0x1 (0x1) +__longlong 0x2a != 0x1 == 0x1 (0x1) +__ulonglong 0x2a != 0x1 == 0x1 (0x1) +float 0x2a != 0x1 == 0x1 (0x1) +int 0x2a >= 0x1 == 0x1 (0x1) +__uint 0x2a >= 0x1 == 0x1 (0x1) +char 0x2a >= 0x1 == 0x1 (0x1) +__uchar 0x2a >= 0x1 == 0x1 (0x1) +__longlong 0x2a >= 0x1 == 0x1 (0x1) +__ulonglong 0x2a >= 0x1 == 0x1 (0x1) +float 0x2a >= 0x1 == 0x1 (0x1) +int 0x2a / 0x1 == 0x2a (0x2a) +__uint 0x2a / 0x1 == 0x2a (0x2a) +char 0x2a / 0x1 == 0x2a (0x2a) +__uchar 0x2a / 0x1 == 0x2a (0x2a) +__longlong 0x2a / 0x1 == 0x2a (0x2a) +__ulonglong 0x2a / 0x1 == 0x2a (0x2a) +float 0x2a / 0x1 == 0x2a (0x2a) +int 0x2a % 0x1 == 0x0 (0x0) +__uint 0x2a % 0x1 == 0x0 (0x0) +char 0x2a % 0x1 == 0x0 (0x0) +__uchar 0x2a % 0x1 == 0x0 (0x0) +__longlong 0x2a % 0x1 == 0x0 (0x0) +__ulonglong 0x2a % 0x1 == 0x0 (0x0) +0x2a * 0x2 == 0x54 +0x2a / 0x2 == 0x15 +0x2a % 0x2 == 0x0 +int 0x2a ^ 0x2 == 0x28 (0x28) +__uint 0x2a ^ 0x2 == 0x28 (0x28) +char 0x2a ^ 0x2 == 0x28 (0x28) +__uchar 0x2a ^ 0x2 == 0x28 (0x28) +__longlong 0x2a ^ 0x2 == 0x28 (0x28) +__ulonglong 0x2a ^ 0x2 == 0x28 (0x28) +int 0x2a && 0x2 == 0x1 (0x1) +__uint 0x2a && 0x2 == 0x1 (0x1) +char 0x2a && 0x2 == 0x1 (0x1) +__uchar 0x2a && 0x2 == 0x1 (0x1) +__longlong 0x2a && 0x2 == 0x1 (0x1) +__ulonglong 0x2a && 0x2 == 0x1 (0x1) +int 0x2a || 0x2 == 0x1 (0x1) +__uint 0x2a || 0x2 == 0x1 (0x1) +char 0x2a || 0x2 == 0x1 (0x1) +__uchar 0x2a || 0x2 == 0x1 (0x1) +__longlong 0x2a || 0x2 == 0x1 (0x1) +__ulonglong 0x2a || 0x2 == 0x1 (0x1) +int 0x2a & 0x2 == 0x2 (0x2) +__uint 0x2a & 0x2 == 0x2 (0x2) +char 0x2a & 0x2 == 0x2 (0x2) +__uchar 0x2a & 0x2 == 0x2 (0x2) +__longlong 0x2a & 0x2 == 0x2 (0x2) +__ulonglong 0x2a & 0x2 == 0x2 (0x2) +int 0x2a | 0x2 == 0x2a (0x2a) +__uint 0x2a | 0x2 == 0x2a (0x2a) +char 0x2a | 0x2 == 0x2a (0x2a) +__uchar 0x2a | 0x2 == 0x2a (0x2a) +__longlong 0x2a | 0x2 == 0x2a (0x2a) +__ulonglong 0x2a | 0x2 == 0x2a (0x2a) +int 0x2a << 0x3 == 0x150 (0x150) +__uint 0x2a << 0x3 == 0x150 (0x150) +char 0x2a << 0x3 == 0x50 (0x50) +__uchar 0x2a << 0x3 == 0x50 (0x50) +__longlong 0x2a << 0x3 == 0x150 (0x150) +__ulonglong 0x2a << 0x3 == 0x150 (0x150) +int 0x2a >> 0x3 == 0x5 (0x5) +__uint 0x2a >> 0x3 == 0x5 (0x5) +char 0x2a >> 0x3 == 0x5 (0x5) +__uchar 0x2a >> 0x3 == 0x5 (0x5) +__longlong 0x2a >> 0x3 == 0x5 (0x5) +__ulonglong 0x2a >> 0x3 == 0x5 (0x5) +int 0x2a + 0x2 == 0x2c (0x2c) +__uint 0x2a + 0x2 == 0x2c (0x2c) +char 0x2a + 0x2 == 0x2c (0x2c) +__uchar 0x2a + 0x2 == 0x2c (0x2c) +__longlong 0x2a + 0x2 == 0x2c (0x2c) +__ulonglong 0x2a + 0x2 == 0x2c (0x2c) +float 0x2a + 0x2 == 0x2c (0x2c) +int 0x2a - 0x2 == 0x28 (0x28) +__uint 0x2a - 0x2 == 0x28 (0x28) +char 0x2a - 0x2 == 0x28 (0x28) +__uchar 0x2a - 0x2 == 0x28 (0x28) +__longlong 0x2a - 0x2 == 0x28 (0x28) +__ulonglong 0x2a - 0x2 == 0x28 (0x28) +float 0x2a - 0x2 == 0x28 (0x28) +int 0x2a * 0x2 == 0x54 (0x54) +__uint 0x2a * 0x2 == 0x54 (0x54) +char 0x2a * 0x2 == 0x54 (0x54) +__uchar 0x2a * 0x2 == 0x54 (0x54) +__longlong 0x2a * 0x2 == 0x54 (0x54) +__ulonglong 0x2a * 0x2 == 0x54 (0x54) +float 0x2a * 0x2 == 0x54 (0x54) +int 0x2a < 0x2 == 0x0 (0x0) +__uint 0x2a < 0x2 == 0x0 (0x0) +char 0x2a < 0x2 == 0x0 (0x0) +__uchar 0x2a < 0x2 == 0x0 (0x0) +__longlong 0x2a < 0x2 == 0x0 (0x0) +__ulonglong 0x2a < 0x2 == 0x0 (0x0) +float 0x2a < 0x2 == 0x0 (0x0) +int 0x2a > 0x2 == 0x1 (0x1) +__uint 0x2a > 0x2 == 0x1 (0x1) +char 0x2a > 0x2 == 0x1 (0x1) +__uchar 0x2a > 0x2 == 0x1 (0x1) +__longlong 0x2a > 0x2 == 0x1 (0x1) +__ulonglong 0x2a > 0x2 == 0x1 (0x1) +float 0x2a > 0x2 == 0x1 (0x1) +int 0x2a <= 0x2 == 0x0 (0x0) +__uint 0x2a <= 0x2 == 0x0 (0x0) +char 0x2a <= 0x2 == 0x0 (0x0) +__uchar 0x2a <= 0x2 == 0x0 (0x0) +__longlong 0x2a <= 0x2 == 0x0 (0x0) +__ulonglong 0x2a <= 0x2 == 0x0 (0x0) +float 0x2a <= 0x2 == 0x0 (0x0) +int 0x2a == 0x2 == 0x0 (0x0) +__uint 0x2a == 0x2 == 0x0 (0x0) +char 0x2a == 0x2 == 0x0 (0x0) +__uchar 0x2a == 0x2 == 0x0 (0x0) +__longlong 0x2a == 0x2 == 0x0 (0x0) +__ulonglong 0x2a == 0x2 == 0x0 (0x0) +float 0x2a == 0x2 == 0x0 (0x0) +int 0x2a != 0x2 == 0x1 (0x1) +__uint 0x2a != 0x2 == 0x1 (0x1) +char 0x2a != 0x2 == 0x1 (0x1) +__uchar 0x2a != 0x2 == 0x1 (0x1) +__longlong 0x2a != 0x2 == 0x1 (0x1) +__ulonglong 0x2a != 0x2 == 0x1 (0x1) +float 0x2a != 0x2 == 0x1 (0x1) +int 0x2a >= 0x2 == 0x1 (0x1) +__uint 0x2a >= 0x2 == 0x1 (0x1) +char 0x2a >= 0x2 == 0x1 (0x1) +__uchar 0x2a >= 0x2 == 0x1 (0x1) +__longlong 0x2a >= 0x2 == 0x1 (0x1) +__ulonglong 0x2a >= 0x2 == 0x1 (0x1) +float 0x2a >= 0x2 == 0x1 (0x1) +int 0x2a / 0x2 == 0x15 (0x15) +__uint 0x2a / 0x2 == 0x15 (0x15) +char 0x2a / 0x2 == 0x15 (0x15) +__uchar 0x2a / 0x2 == 0x15 (0x15) +__longlong 0x2a / 0x2 == 0x15 (0x15) +__ulonglong 0x2a / 0x2 == 0x15 (0x15) +float 0x2a / 0x2 == 0x15 (0x15) +int 0x2a % 0x2 == 0x0 (0x0) +__uint 0x2a % 0x2 == 0x0 (0x0) +char 0x2a % 0x2 == 0x0 (0x0) +__uchar 0x2a % 0x2 == 0x0 (0x0) +__longlong 0x2a % 0x2 == 0x0 (0x0) +__ulonglong 0x2a % 0x2 == 0x0 (0x0) +0x2a * 0xfffe == -0x54 +0x2a / 0xfffe == -0x15 +0x2a % 0xfffe == 0x0 +int 0x2a ^ 0xfffe == -0x2c (0xffd4) +__uint 0x2a ^ 0xfffe == -0x2c (0xffd4) +char 0x2a ^ 0xfffe == -0x2c (0xffd4) +__uchar 0x2a ^ 0xfe == 0xd4 (0xd4) +__longlong 0x2a ^ 0xfffe == -0x2c (0xffd4) +__ulonglong 0x2a ^ 0xfffe == -0x2c (0xffd4) +int 0x2a && 0xfffe == 0x1 (0x1) +__uint 0x2a && 0xfffe == 0x1 (0x1) +char 0x2a && 0xfffe == 0x1 (0x1) +__uchar 0x2a && 0xfe == 0x1 (0x1) +__longlong 0x2a && 0xfffe == 0x1 (0x1) +__ulonglong 0x2a && 0xfffe == 0x1 (0x1) +int 0x2a || 0xfffe == 0x1 (0x1) +__uint 0x2a || 0xfffe == 0x1 (0x1) +char 0x2a || 0xfffe == 0x1 (0x1) +__uchar 0x2a || 0xfe == 0x1 (0x1) +__longlong 0x2a || 0xfffe == 0x1 (0x1) +__ulonglong 0x2a || 0xfffe == 0x1 (0x1) +int 0x2a & 0xfffe == 0x2a (0x2a) +__uint 0x2a & 0xfffe == 0x2a (0x2a) +char 0x2a & 0xfffe == 0x2a (0x2a) +__uchar 0x2a & 0xfe == 0x2a (0x2a) +__longlong 0x2a & 0xfffe == 0x2a (0x2a) +__ulonglong 0x2a & 0xfffe == 0x2a (0x2a) +int 0x2a | 0xfffe == -0x2 (0xfffe) +__uint 0x2a | 0xfffe == -0x2 (0xfffe) +char 0x2a | 0xfffe == -0x2 (0xfffe) +__uchar 0x2a | 0xfe == 0xfe (0xfe) +__longlong 0x2a | 0xfffe == -0x2 (0xfffe) +__ulonglong 0x2a | 0xfffe == -0x2 (0xfffe) +int 0x2a << 0x4 == 0x2a0 (0x2a0) +__uint 0x2a << 0x4 == 0x2a0 (0x2a0) +char 0x2a << 0x4 == -0x60 (0xffa0) +__uchar 0x2a << 0x4 == 0xa0 (0xa0) +__longlong 0x2a << 0x4 == 0x2a0 (0x2a0) +__ulonglong 0x2a << 0x4 == 0x2a0 (0x2a0) +int 0x2a >> 0x4 == 0x2 (0x2) +__uint 0x2a >> 0x4 == 0x2 (0x2) +char 0x2a >> 0x4 == 0x2 (0x2) +__uchar 0x2a >> 0x4 == 0x2 (0x2) +__longlong 0x2a >> 0x4 == 0x2 (0x2) +__ulonglong 0x2a >> 0x4 == 0x2 (0x2) +int 0x2a + 0xfffe == 0x28 (0x28) +__uint 0x2a + 0xfffe == 0x28 (0x28) +char 0x2a + 0xfffe == 0x28 (0x28) +__uchar 0x2a + 0xfe == 0x28 (0x28) +__longlong 0x2a + 0xfffe == 0x28 (0x28) +__ulonglong 0x2a + 0xfffe == 0x28 (0x28) +float 0x2a + 0xfffe == 0x28 (0x28) +int 0x2a - 0xfffe == 0x2c (0x2c) +__uint 0x2a - 0xfffe == 0x2c (0x2c) +char 0x2a - 0xfffe == 0x2c (0x2c) +__uchar 0x2a - 0xfe == 0x2c (0x2c) +__longlong 0x2a - 0xfffe == 0x2c (0x2c) +__ulonglong 0x2a - 0xfffe == 0x2c (0x2c) +float 0x2a - 0xfffe == 0x2c (0x2c) +int 0x2a * 0xfffe == -0x54 (0xffac) +__uint 0x2a * 0xfffe == -0x54 (0xffac) +char 0x2a * 0xfffe == -0x54 (0xffac) +__uchar 0x2a * 0xfe == 0xac (0xac) +__longlong 0x2a * 0xfffe == -0x54 (0xffac) +__ulonglong 0x2a * 0xfffe == -0x54 (0xffac) +float 0x2a * 0xfffe == -0x54 (0xffac) +int 0x2a < 0xfffe == 0x0 (0x0) +__uint 0x2a < 0xfffe == 0x1 (0x1) +char 0x2a < 0xfffe == 0x0 (0x0) +__uchar 0x2a < 0xfe == 0x1 (0x1) +__longlong 0x2a < 0xfffe == 0x0 (0x0) +__ulonglong 0x2a < 0xfffe == 0x1 (0x1) +float 0x2a < 0xfffe == 0x0 (0x0) +int 0x2a > 0xfffe == 0x1 (0x1) +__uint 0x2a > 0xfffe == 0x0 (0x0) +char 0x2a > 0xfffe == 0x1 (0x1) +__uchar 0x2a > 0xfe == 0x0 (0x0) +__longlong 0x2a > 0xfffe == 0x1 (0x1) +__ulonglong 0x2a > 0xfffe == 0x0 (0x0) +float 0x2a > 0xfffe == 0x1 (0x1) +int 0x2a <= 0xfffe == 0x0 (0x0) +__uint 0x2a <= 0xfffe == 0x1 (0x1) +char 0x2a <= 0xfffe == 0x0 (0x0) +__uchar 0x2a <= 0xfe == 0x1 (0x1) +__longlong 0x2a <= 0xfffe == 0x0 (0x0) +__ulonglong 0x2a <= 0xfffe == 0x1 (0x1) +float 0x2a <= 0xfffe == 0x0 (0x0) +int 0x2a == 0xfffe == 0x0 (0x0) +__uint 0x2a == 0xfffe == 0x0 (0x0) +char 0x2a == 0xfffe == 0x0 (0x0) +__uchar 0x2a == 0xfe == 0x0 (0x0) +__longlong 0x2a == 0xfffe == 0x0 (0x0) +__ulonglong 0x2a == 0xfffe == 0x0 (0x0) +float 0x2a == 0xfffe == 0x0 (0x0) +int 0x2a != 0xfffe == 0x1 (0x1) +__uint 0x2a != 0xfffe == 0x1 (0x1) +char 0x2a != 0xfffe == 0x1 (0x1) +__uchar 0x2a != 0xfe == 0x1 (0x1) +__longlong 0x2a != 0xfffe == 0x1 (0x1) +__ulonglong 0x2a != 0xfffe == 0x1 (0x1) +float 0x2a != 0xfffe == 0x1 (0x1) +int 0x2a >= 0xfffe == 0x1 (0x1) +__uint 0x2a >= 0xfffe == 0x0 (0x0) +char 0x2a >= 0xfffe == 0x1 (0x1) +__uchar 0x2a >= 0xfe == 0x0 (0x0) +__longlong 0x2a >= 0xfffe == 0x1 (0x1) +__ulonglong 0x2a >= 0xfffe == 0x0 (0x0) +float 0x2a >= 0xfffe == 0x1 (0x1) +int 0x2a / 0xfffe == -0x15 (0xffeb) +__uint 0x2a / 0xfffe == 0x0 (0x0) +char 0x2a / 0xfffe == -0x15 (0xffeb) +__uchar 0x2a / 0xfe == 0x0 (0x0) +__longlong 0x2a / 0xfffe == -0x15 (0xffeb) +__ulonglong 0x2a / 0xfffe == 0x0 (0x0) +float 0x2a / 0xfffe == -0x15 (0xffeb) +int 0x2a % 0xfffe == 0x0 (0x0) +__uint 0x2a % 0xfffe == 0x2a (0x2a) +char 0x2a % 0xfffe == 0x0 (0x0) +__uchar 0x2a % 0xfe == 0x2a (0x2a) +__longlong 0x2a % 0xfffe == 0x0 (0x0) +__ulonglong 0x2a % 0xfffe == 0x2a (0x2a) +0x2a * 0x4 == 0xa8 +0x2a / 0x4 == 0xa +0x2a % 0x4 == 0x2 +int 0x2a ^ 0x4 == 0x2e (0x2e) +__uint 0x2a ^ 0x4 == 0x2e (0x2e) +char 0x2a ^ 0x4 == 0x2e (0x2e) +__uchar 0x2a ^ 0x4 == 0x2e (0x2e) +__longlong 0x2a ^ 0x4 == 0x2e (0x2e) +__ulonglong 0x2a ^ 0x4 == 0x2e (0x2e) +int 0x2a && 0x4 == 0x1 (0x1) +__uint 0x2a && 0x4 == 0x1 (0x1) +char 0x2a && 0x4 == 0x1 (0x1) +__uchar 0x2a && 0x4 == 0x1 (0x1) +__longlong 0x2a && 0x4 == 0x1 (0x1) +__ulonglong 0x2a && 0x4 == 0x1 (0x1) +int 0x2a || 0x4 == 0x1 (0x1) +__uint 0x2a || 0x4 == 0x1 (0x1) +char 0x2a || 0x4 == 0x1 (0x1) +__uchar 0x2a || 0x4 == 0x1 (0x1) +__longlong 0x2a || 0x4 == 0x1 (0x1) +__ulonglong 0x2a || 0x4 == 0x1 (0x1) +int 0x2a & 0x4 == 0x0 (0x0) +__uint 0x2a & 0x4 == 0x0 (0x0) +char 0x2a & 0x4 == 0x0 (0x0) +__uchar 0x2a & 0x4 == 0x0 (0x0) +__longlong 0x2a & 0x4 == 0x0 (0x0) +__ulonglong 0x2a & 0x4 == 0x0 (0x0) +int 0x2a | 0x4 == 0x2e (0x2e) +__uint 0x2a | 0x4 == 0x2e (0x2e) +char 0x2a | 0x4 == 0x2e (0x2e) +__uchar 0x2a | 0x4 == 0x2e (0x2e) +__longlong 0x2a | 0x4 == 0x2e (0x2e) +__ulonglong 0x2a | 0x4 == 0x2e (0x2e) +int 0x2a << 0x5 == 0x540 (0x540) +__uint 0x2a << 0x5 == 0x540 (0x540) +char 0x2a << 0x5 == 0x40 (0x40) +__uchar 0x2a << 0x5 == 0x40 (0x40) +__longlong 0x2a << 0x5 == 0x540 (0x540) +__ulonglong 0x2a << 0x5 == 0x540 (0x540) +int 0x2a >> 0x5 == 0x1 (0x1) +__uint 0x2a >> 0x5 == 0x1 (0x1) +char 0x2a >> 0x5 == 0x1 (0x1) +__uchar 0x2a >> 0x5 == 0x1 (0x1) +__longlong 0x2a >> 0x5 == 0x1 (0x1) +__ulonglong 0x2a >> 0x5 == 0x1 (0x1) +int 0x2a + 0x4 == 0x2e (0x2e) +__uint 0x2a + 0x4 == 0x2e (0x2e) +char 0x2a + 0x4 == 0x2e (0x2e) +__uchar 0x2a + 0x4 == 0x2e (0x2e) +__longlong 0x2a + 0x4 == 0x2e (0x2e) +__ulonglong 0x2a + 0x4 == 0x2e (0x2e) +float 0x2a + 0x4 == 0x2e (0x2e) +int 0x2a - 0x4 == 0x26 (0x26) +__uint 0x2a - 0x4 == 0x26 (0x26) +char 0x2a - 0x4 == 0x26 (0x26) +__uchar 0x2a - 0x4 == 0x26 (0x26) +__longlong 0x2a - 0x4 == 0x26 (0x26) +__ulonglong 0x2a - 0x4 == 0x26 (0x26) +float 0x2a - 0x4 == 0x26 (0x26) +int 0x2a * 0x4 == 0xa8 (0xa8) +__uint 0x2a * 0x4 == 0xa8 (0xa8) +char 0x2a * 0x4 == -0x58 (0xffa8) +__uchar 0x2a * 0x4 == 0xa8 (0xa8) +__longlong 0x2a * 0x4 == 0xa8 (0xa8) +__ulonglong 0x2a * 0x4 == 0xa8 (0xa8) +float 0x2a * 0x4 == 0xa8 (0xa8) +int 0x2a < 0x4 == 0x0 (0x0) +__uint 0x2a < 0x4 == 0x0 (0x0) +char 0x2a < 0x4 == 0x0 (0x0) +__uchar 0x2a < 0x4 == 0x0 (0x0) +__longlong 0x2a < 0x4 == 0x0 (0x0) +__ulonglong 0x2a < 0x4 == 0x0 (0x0) +float 0x2a < 0x4 == 0x0 (0x0) +int 0x2a > 0x4 == 0x1 (0x1) +__uint 0x2a > 0x4 == 0x1 (0x1) +char 0x2a > 0x4 == 0x1 (0x1) +__uchar 0x2a > 0x4 == 0x1 (0x1) +__longlong 0x2a > 0x4 == 0x1 (0x1) +__ulonglong 0x2a > 0x4 == 0x1 (0x1) +float 0x2a > 0x4 == 0x1 (0x1) +int 0x2a <= 0x4 == 0x0 (0x0) +__uint 0x2a <= 0x4 == 0x0 (0x0) +char 0x2a <= 0x4 == 0x0 (0x0) +__uchar 0x2a <= 0x4 == 0x0 (0x0) +__longlong 0x2a <= 0x4 == 0x0 (0x0) +__ulonglong 0x2a <= 0x4 == 0x0 (0x0) +float 0x2a <= 0x4 == 0x0 (0x0) +int 0x2a == 0x4 == 0x0 (0x0) +__uint 0x2a == 0x4 == 0x0 (0x0) +char 0x2a == 0x4 == 0x0 (0x0) +__uchar 0x2a == 0x4 == 0x0 (0x0) +__longlong 0x2a == 0x4 == 0x0 (0x0) +__ulonglong 0x2a == 0x4 == 0x0 (0x0) +float 0x2a == 0x4 == 0x0 (0x0) +int 0x2a != 0x4 == 0x1 (0x1) +__uint 0x2a != 0x4 == 0x1 (0x1) +char 0x2a != 0x4 == 0x1 (0x1) +__uchar 0x2a != 0x4 == 0x1 (0x1) +__longlong 0x2a != 0x4 == 0x1 (0x1) +__ulonglong 0x2a != 0x4 == 0x1 (0x1) +float 0x2a != 0x4 == 0x1 (0x1) +int 0x2a >= 0x4 == 0x1 (0x1) +__uint 0x2a >= 0x4 == 0x1 (0x1) +char 0x2a >= 0x4 == 0x1 (0x1) +__uchar 0x2a >= 0x4 == 0x1 (0x1) +__longlong 0x2a >= 0x4 == 0x1 (0x1) +__ulonglong 0x2a >= 0x4 == 0x1 (0x1) +float 0x2a >= 0x4 == 0x1 (0x1) +int 0x2a / 0x4 == 0xa (0xa) +__uint 0x2a / 0x4 == 0xa (0xa) +char 0x2a / 0x4 == 0xa (0xa) +__uchar 0x2a / 0x4 == 0xa (0xa) +__longlong 0x2a / 0x4 == 0xa (0xa) +__ulonglong 0x2a / 0x4 == 0xa (0xa) +float 0x2a / 0x4 == 0xa (0xa) +int 0x2a % 0x4 == 0x2 (0x2) +__uint 0x2a % 0x4 == 0x2 (0x2) +char 0x2a % 0x4 == 0x2 (0x2) +__uchar 0x2a % 0x4 == 0x2 (0x2) +__longlong 0x2a % 0x4 == 0x2 (0x2) +__ulonglong 0x2a % 0x4 == 0x2 (0x2) +0x2a * 0xfffc == -0xa8 +0x2a / 0xfffc == -0xa +0x2a % 0xfffc == 0x2 +int 0x2a ^ 0xfffc == -0x2a (0xffd6) +__uint 0x2a ^ 0xfffc == -0x2a (0xffd6) +char 0x2a ^ 0xfffc == -0x2a (0xffd6) +__uchar 0x2a ^ 0xfc == 0xd6 (0xd6) +__longlong 0x2a ^ 0xfffc == -0x2a (0xffd6) +__ulonglong 0x2a ^ 0xfffc == -0x2a (0xffd6) +int 0x2a && 0xfffc == 0x1 (0x1) +__uint 0x2a && 0xfffc == 0x1 (0x1) +char 0x2a && 0xfffc == 0x1 (0x1) +__uchar 0x2a && 0xfc == 0x1 (0x1) +__longlong 0x2a && 0xfffc == 0x1 (0x1) +__ulonglong 0x2a && 0xfffc == 0x1 (0x1) +int 0x2a || 0xfffc == 0x1 (0x1) +__uint 0x2a || 0xfffc == 0x1 (0x1) +char 0x2a || 0xfffc == 0x1 (0x1) +__uchar 0x2a || 0xfc == 0x1 (0x1) +__longlong 0x2a || 0xfffc == 0x1 (0x1) +__ulonglong 0x2a || 0xfffc == 0x1 (0x1) +int 0x2a & 0xfffc == 0x28 (0x28) +__uint 0x2a & 0xfffc == 0x28 (0x28) +char 0x2a & 0xfffc == 0x28 (0x28) +__uchar 0x2a & 0xfc == 0x28 (0x28) +__longlong 0x2a & 0xfffc == 0x28 (0x28) +__ulonglong 0x2a & 0xfffc == 0x28 (0x28) +int 0x2a | 0xfffc == -0x2 (0xfffe) +__uint 0x2a | 0xfffc == -0x2 (0xfffe) +char 0x2a | 0xfffc == -0x2 (0xfffe) +__uchar 0x2a | 0xfc == 0xfe (0xfe) +__longlong 0x2a | 0xfffc == -0x2 (0xfffe) +__ulonglong 0x2a | 0xfffc == -0x2 (0xfffe) +int 0x2a << 0x6 == 0xa80 (0xa80) +__uint 0x2a << 0x6 == 0xa80 (0xa80) +char 0x2a << 0x6 == -0x80 (0xff80) +__uchar 0x2a << 0x6 == 0x80 (0x80) +__longlong 0x2a << 0x6 == 0xa80 (0xa80) +__ulonglong 0x2a << 0x6 == 0xa80 (0xa80) +int 0x2a >> 0x6 == 0x0 (0x0) +__uint 0x2a >> 0x6 == 0x0 (0x0) +char 0x2a >> 0x6 == 0x0 (0x0) +__uchar 0x2a >> 0x6 == 0x0 (0x0) +__longlong 0x2a >> 0x6 == 0x0 (0x0) +__ulonglong 0x2a >> 0x6 == 0x0 (0x0) +int 0x2a + 0xfffc == 0x26 (0x26) +__uint 0x2a + 0xfffc == 0x26 (0x26) +char 0x2a + 0xfffc == 0x26 (0x26) +__uchar 0x2a + 0xfc == 0x26 (0x26) +__longlong 0x2a + 0xfffc == 0x26 (0x26) +__ulonglong 0x2a + 0xfffc == 0x26 (0x26) +float 0x2a + 0xfffc == 0x26 (0x26) +int 0x2a - 0xfffc == 0x2e (0x2e) +__uint 0x2a - 0xfffc == 0x2e (0x2e) +char 0x2a - 0xfffc == 0x2e (0x2e) +__uchar 0x2a - 0xfc == 0x2e (0x2e) +__longlong 0x2a - 0xfffc == 0x2e (0x2e) +__ulonglong 0x2a - 0xfffc == 0x2e (0x2e) +float 0x2a - 0xfffc == 0x2e (0x2e) +int 0x2a * 0xfffc == -0xa8 (0xff58) +__uint 0x2a * 0xfffc == -0xa8 (0xff58) +char 0x2a * 0xfffc == 0x58 (0x58) +__uchar 0x2a * 0xfc == 0x58 (0x58) +__longlong 0x2a * 0xfffc == -0xa8 (0xff58) +__ulonglong 0x2a * 0xfffc == -0xa8 (0xff58) +float 0x2a * 0xfffc == -0xa8 (0xff58) +int 0x2a < 0xfffc == 0x0 (0x0) +__uint 0x2a < 0xfffc == 0x1 (0x1) +char 0x2a < 0xfffc == 0x0 (0x0) +__uchar 0x2a < 0xfc == 0x1 (0x1) +__longlong 0x2a < 0xfffc == 0x0 (0x0) +__ulonglong 0x2a < 0xfffc == 0x1 (0x1) +float 0x2a < 0xfffc == 0x0 (0x0) +int 0x2a > 0xfffc == 0x1 (0x1) +__uint 0x2a > 0xfffc == 0x0 (0x0) +char 0x2a > 0xfffc == 0x1 (0x1) +__uchar 0x2a > 0xfc == 0x0 (0x0) +__longlong 0x2a > 0xfffc == 0x1 (0x1) +__ulonglong 0x2a > 0xfffc == 0x0 (0x0) +float 0x2a > 0xfffc == 0x1 (0x1) +int 0x2a <= 0xfffc == 0x0 (0x0) +__uint 0x2a <= 0xfffc == 0x1 (0x1) +char 0x2a <= 0xfffc == 0x0 (0x0) +__uchar 0x2a <= 0xfc == 0x1 (0x1) +__longlong 0x2a <= 0xfffc == 0x0 (0x0) +__ulonglong 0x2a <= 0xfffc == 0x1 (0x1) +float 0x2a <= 0xfffc == 0x0 (0x0) +int 0x2a == 0xfffc == 0x0 (0x0) +__uint 0x2a == 0xfffc == 0x0 (0x0) +char 0x2a == 0xfffc == 0x0 (0x0) +__uchar 0x2a == 0xfc == 0x0 (0x0) +__longlong 0x2a == 0xfffc == 0x0 (0x0) +__ulonglong 0x2a == 0xfffc == 0x0 (0x0) +float 0x2a == 0xfffc == 0x0 (0x0) +int 0x2a != 0xfffc == 0x1 (0x1) +__uint 0x2a != 0xfffc == 0x1 (0x1) +char 0x2a != 0xfffc == 0x1 (0x1) +__uchar 0x2a != 0xfc == 0x1 (0x1) +__longlong 0x2a != 0xfffc == 0x1 (0x1) +__ulonglong 0x2a != 0xfffc == 0x1 (0x1) +float 0x2a != 0xfffc == 0x1 (0x1) +int 0x2a >= 0xfffc == 0x1 (0x1) +__uint 0x2a >= 0xfffc == 0x0 (0x0) +char 0x2a >= 0xfffc == 0x1 (0x1) +__uchar 0x2a >= 0xfc == 0x0 (0x0) +__longlong 0x2a >= 0xfffc == 0x1 (0x1) +__ulonglong 0x2a >= 0xfffc == 0x0 (0x0) +float 0x2a >= 0xfffc == 0x1 (0x1) +int 0x2a / 0xfffc == -0xa (0xfff6) +__uint 0x2a / 0xfffc == 0x0 (0x0) +char 0x2a / 0xfffc == -0xa (0xfff6) +__uchar 0x2a / 0xfc == 0x0 (0x0) +__longlong 0x2a / 0xfffc == -0xa (0xfff6) +__ulonglong 0x2a / 0xfffc == 0x0 (0x0) +float 0x2a / 0xfffc == -0xa (0xfff6) +int 0x2a % 0xfffc == 0x2 (0x2) +__uint 0x2a % 0xfffc == 0x2a (0x2a) +char 0x2a % 0xfffc == 0x2 (0x2) +__uchar 0x2a % 0xfc == 0x2a (0x2a) +__longlong 0x2a % 0xfffc == 0x2 (0x2) +__ulonglong 0x2a % 0xfffc == 0x2a (0x2a) +0x2a * 0xa == 0x1a4 +0x2a / 0xa == 0x4 +0x2a % 0xa == 0x2 +int 0x2a ^ 0xa == 0x20 (0x20) +__uint 0x2a ^ 0xa == 0x20 (0x20) +char 0x2a ^ 0xa == 0x20 (0x20) +__uchar 0x2a ^ 0xa == 0x20 (0x20) +__longlong 0x2a ^ 0xa == 0x20 (0x20) +__ulonglong 0x2a ^ 0xa == 0x20 (0x20) +int 0x2a && 0xa == 0x1 (0x1) +__uint 0x2a && 0xa == 0x1 (0x1) +char 0x2a && 0xa == 0x1 (0x1) +__uchar 0x2a && 0xa == 0x1 (0x1) +__longlong 0x2a && 0xa == 0x1 (0x1) +__ulonglong 0x2a && 0xa == 0x1 (0x1) +int 0x2a || 0xa == 0x1 (0x1) +__uint 0x2a || 0xa == 0x1 (0x1) +char 0x2a || 0xa == 0x1 (0x1) +__uchar 0x2a || 0xa == 0x1 (0x1) +__longlong 0x2a || 0xa == 0x1 (0x1) +__ulonglong 0x2a || 0xa == 0x1 (0x1) +int 0x2a & 0xa == 0xa (0xa) +__uint 0x2a & 0xa == 0xa (0xa) +char 0x2a & 0xa == 0xa (0xa) +__uchar 0x2a & 0xa == 0xa (0xa) +__longlong 0x2a & 0xa == 0xa (0xa) +__ulonglong 0x2a & 0xa == 0xa (0xa) +int 0x2a | 0xa == 0x2a (0x2a) +__uint 0x2a | 0xa == 0x2a (0x2a) +char 0x2a | 0xa == 0x2a (0x2a) +__uchar 0x2a | 0xa == 0x2a (0x2a) +__longlong 0x2a | 0xa == 0x2a (0x2a) +__ulonglong 0x2a | 0xa == 0x2a (0x2a) +int 0x2a << 0x7 == 0x1500 (0x1500) +__uint 0x2a << 0x7 == 0x1500 (0x1500) +char 0x2a << 0x7 == 0x0 (0x0) +__uchar 0x2a << 0x7 == 0x0 (0x0) +__longlong 0x2a << 0x7 == 0x1500 (0x1500) +__ulonglong 0x2a << 0x7 == 0x1500 (0x1500) +int 0x2a >> 0x7 == 0x0 (0x0) +__uint 0x2a >> 0x7 == 0x0 (0x0) +char 0x2a >> 0x7 == 0x0 (0x0) +__uchar 0x2a >> 0x7 == 0x0 (0x0) +__longlong 0x2a >> 0x7 == 0x0 (0x0) +__ulonglong 0x2a >> 0x7 == 0x0 (0x0) +int 0x2a + 0xa == 0x34 (0x34) +__uint 0x2a + 0xa == 0x34 (0x34) +char 0x2a + 0xa == 0x34 (0x34) +__uchar 0x2a + 0xa == 0x34 (0x34) +__longlong 0x2a + 0xa == 0x34 (0x34) +__ulonglong 0x2a + 0xa == 0x34 (0x34) +float 0x2a + 0xa == 0x34 (0x34) +int 0x2a - 0xa == 0x20 (0x20) +__uint 0x2a - 0xa == 0x20 (0x20) +char 0x2a - 0xa == 0x20 (0x20) +__uchar 0x2a - 0xa == 0x20 (0x20) +__longlong 0x2a - 0xa == 0x20 (0x20) +__ulonglong 0x2a - 0xa == 0x20 (0x20) +float 0x2a - 0xa == 0x20 (0x20) +int 0x2a * 0xa == 0x1a4 (0x1a4) +__uint 0x2a * 0xa == 0x1a4 (0x1a4) +char 0x2a * 0xa == -0x5c (0xffa4) +__uchar 0x2a * 0xa == 0xa4 (0xa4) +__longlong 0x2a * 0xa == 0x1a4 (0x1a4) +__ulonglong 0x2a * 0xa == 0x1a4 (0x1a4) +float 0x2a * 0xa == 0x1a4 (0x1a4) +int 0x2a < 0xa == 0x0 (0x0) +__uint 0x2a < 0xa == 0x0 (0x0) +char 0x2a < 0xa == 0x0 (0x0) +__uchar 0x2a < 0xa == 0x0 (0x0) +__longlong 0x2a < 0xa == 0x0 (0x0) +__ulonglong 0x2a < 0xa == 0x0 (0x0) +float 0x2a < 0xa == 0x0 (0x0) +int 0x2a > 0xa == 0x1 (0x1) +__uint 0x2a > 0xa == 0x1 (0x1) +char 0x2a > 0xa == 0x1 (0x1) +__uchar 0x2a > 0xa == 0x1 (0x1) +__longlong 0x2a > 0xa == 0x1 (0x1) +__ulonglong 0x2a > 0xa == 0x1 (0x1) +float 0x2a > 0xa == 0x1 (0x1) +int 0x2a <= 0xa == 0x0 (0x0) +__uint 0x2a <= 0xa == 0x0 (0x0) +char 0x2a <= 0xa == 0x0 (0x0) +__uchar 0x2a <= 0xa == 0x0 (0x0) +__longlong 0x2a <= 0xa == 0x0 (0x0) +__ulonglong 0x2a <= 0xa == 0x0 (0x0) +float 0x2a <= 0xa == 0x0 (0x0) +int 0x2a == 0xa == 0x0 (0x0) +__uint 0x2a == 0xa == 0x0 (0x0) +char 0x2a == 0xa == 0x0 (0x0) +__uchar 0x2a == 0xa == 0x0 (0x0) +__longlong 0x2a == 0xa == 0x0 (0x0) +__ulonglong 0x2a == 0xa == 0x0 (0x0) +float 0x2a == 0xa == 0x0 (0x0) +int 0x2a != 0xa == 0x1 (0x1) +__uint 0x2a != 0xa == 0x1 (0x1) +char 0x2a != 0xa == 0x1 (0x1) +__uchar 0x2a != 0xa == 0x1 (0x1) +__longlong 0x2a != 0xa == 0x1 (0x1) +__ulonglong 0x2a != 0xa == 0x1 (0x1) +float 0x2a != 0xa == 0x1 (0x1) +int 0x2a >= 0xa == 0x1 (0x1) +__uint 0x2a >= 0xa == 0x1 (0x1) +char 0x2a >= 0xa == 0x1 (0x1) +__uchar 0x2a >= 0xa == 0x1 (0x1) +__longlong 0x2a >= 0xa == 0x1 (0x1) +__ulonglong 0x2a >= 0xa == 0x1 (0x1) +float 0x2a >= 0xa == 0x1 (0x1) +int 0x2a / 0xa == 0x4 (0x4) +__uint 0x2a / 0xa == 0x4 (0x4) +char 0x2a / 0xa == 0x4 (0x4) +__uchar 0x2a / 0xa == 0x4 (0x4) +__longlong 0x2a / 0xa == 0x4 (0x4) +__ulonglong 0x2a / 0xa == 0x4 (0x4) +float 0x2a / 0xa == 0x4 (0x4) +int 0x2a % 0xa == 0x2 (0x2) +__uint 0x2a % 0xa == 0x2 (0x2) +char 0x2a % 0xa == 0x2 (0x2) +__uchar 0x2a % 0xa == 0x2 (0x2) +__longlong 0x2a % 0xa == 0x2 (0x2) +__ulonglong 0x2a % 0xa == 0x2 (0x2) +0x2a * 0xfff6 == -0x1a4 +0x2a / 0xfff6 == -0x4 +0x2a % 0xfff6 == 0x2 +int 0x2a ^ 0xfff6 == -0x24 (0xffdc) +__uint 0x2a ^ 0xfff6 == -0x24 (0xffdc) +char 0x2a ^ 0xfff6 == -0x24 (0xffdc) +__uchar 0x2a ^ 0xf6 == 0xdc (0xdc) +__longlong 0x2a ^ 0xfff6 == -0x24 (0xffdc) +__ulonglong 0x2a ^ 0xfff6 == -0x24 (0xffdc) +int 0x2a && 0xfff6 == 0x1 (0x1) +__uint 0x2a && 0xfff6 == 0x1 (0x1) +char 0x2a && 0xfff6 == 0x1 (0x1) +__uchar 0x2a && 0xf6 == 0x1 (0x1) +__longlong 0x2a && 0xfff6 == 0x1 (0x1) +__ulonglong 0x2a && 0xfff6 == 0x1 (0x1) +int 0x2a || 0xfff6 == 0x1 (0x1) +__uint 0x2a || 0xfff6 == 0x1 (0x1) +char 0x2a || 0xfff6 == 0x1 (0x1) +__uchar 0x2a || 0xf6 == 0x1 (0x1) +__longlong 0x2a || 0xfff6 == 0x1 (0x1) +__ulonglong 0x2a || 0xfff6 == 0x1 (0x1) +int 0x2a & 0xfff6 == 0x22 (0x22) +__uint 0x2a & 0xfff6 == 0x22 (0x22) +char 0x2a & 0xfff6 == 0x22 (0x22) +__uchar 0x2a & 0xf6 == 0x22 (0x22) +__longlong 0x2a & 0xfff6 == 0x22 (0x22) +__ulonglong 0x2a & 0xfff6 == 0x22 (0x22) +int 0x2a | 0xfff6 == -0x2 (0xfffe) +__uint 0x2a | 0xfff6 == -0x2 (0xfffe) +char 0x2a | 0xfff6 == -0x2 (0xfffe) +__uchar 0x2a | 0xf6 == 0xfe (0xfe) +__longlong 0x2a | 0xfff6 == -0x2 (0xfffe) +__ulonglong 0x2a | 0xfff6 == -0x2 (0xfffe) +int 0x2a << 0x8 == 0x2a00 (0x2a00) +__uint 0x2a << 0x8 == 0x2a00 (0x2a00) +char 0x2a << 0x8 == 0x0 (0x0) +__uchar 0x2a << 0x8 == 0x0 (0x0) +__longlong 0x2a << 0x8 == 0x2a00 (0x2a00) +__ulonglong 0x2a << 0x8 == 0x2a00 (0x2a00) +int 0x2a >> 0x8 == 0x0 (0x0) +__uint 0x2a >> 0x8 == 0x0 (0x0) +char 0x2a >> 0x8 == 0x0 (0x0) +__uchar 0x2a >> 0x8 == 0x0 (0x0) +__longlong 0x2a >> 0x8 == 0x0 (0x0) +__ulonglong 0x2a >> 0x8 == 0x0 (0x0) +int 0x2a + 0xfff6 == 0x20 (0x20) +__uint 0x2a + 0xfff6 == 0x20 (0x20) +char 0x2a + 0xfff6 == 0x20 (0x20) +__uchar 0x2a + 0xf6 == 0x20 (0x20) +__longlong 0x2a + 0xfff6 == 0x20 (0x20) +__ulonglong 0x2a + 0xfff6 == 0x20 (0x20) +float 0x2a + 0xfff6 == 0x20 (0x20) +int 0x2a - 0xfff6 == 0x34 (0x34) +__uint 0x2a - 0xfff6 == 0x34 (0x34) +char 0x2a - 0xfff6 == 0x34 (0x34) +__uchar 0x2a - 0xf6 == 0x34 (0x34) +__longlong 0x2a - 0xfff6 == 0x34 (0x34) +__ulonglong 0x2a - 0xfff6 == 0x34 (0x34) +float 0x2a - 0xfff6 == 0x34 (0x34) +int 0x2a * 0xfff6 == -0x1a4 (0xfe5c) +__uint 0x2a * 0xfff6 == -0x1a4 (0xfe5c) +char 0x2a * 0xfff6 == 0x5c (0x5c) +__uchar 0x2a * 0xf6 == 0x5c (0x5c) +__longlong 0x2a * 0xfff6 == -0x1a4 (0xfe5c) +__ulonglong 0x2a * 0xfff6 == -0x1a4 (0xfe5c) +float 0x2a * 0xfff6 == -0x1a4 (0xfe5c) +int 0x2a < 0xfff6 == 0x0 (0x0) +__uint 0x2a < 0xfff6 == 0x1 (0x1) +char 0x2a < 0xfff6 == 0x0 (0x0) +__uchar 0x2a < 0xf6 == 0x1 (0x1) +__longlong 0x2a < 0xfff6 == 0x0 (0x0) +__ulonglong 0x2a < 0xfff6 == 0x1 (0x1) +float 0x2a < 0xfff6 == 0x0 (0x0) +int 0x2a > 0xfff6 == 0x1 (0x1) +__uint 0x2a > 0xfff6 == 0x0 (0x0) +char 0x2a > 0xfff6 == 0x1 (0x1) +__uchar 0x2a > 0xf6 == 0x0 (0x0) +__longlong 0x2a > 0xfff6 == 0x1 (0x1) +__ulonglong 0x2a > 0xfff6 == 0x0 (0x0) +float 0x2a > 0xfff6 == 0x1 (0x1) +int 0x2a <= 0xfff6 == 0x0 (0x0) +__uint 0x2a <= 0xfff6 == 0x1 (0x1) +char 0x2a <= 0xfff6 == 0x0 (0x0) +__uchar 0x2a <= 0xf6 == 0x1 (0x1) +__longlong 0x2a <= 0xfff6 == 0x0 (0x0) +__ulonglong 0x2a <= 0xfff6 == 0x1 (0x1) +float 0x2a <= 0xfff6 == 0x0 (0x0) +int 0x2a == 0xfff6 == 0x0 (0x0) +__uint 0x2a == 0xfff6 == 0x0 (0x0) +char 0x2a == 0xfff6 == 0x0 (0x0) +__uchar 0x2a == 0xf6 == 0x0 (0x0) +__longlong 0x2a == 0xfff6 == 0x0 (0x0) +__ulonglong 0x2a == 0xfff6 == 0x0 (0x0) +float 0x2a == 0xfff6 == 0x0 (0x0) +int 0x2a != 0xfff6 == 0x1 (0x1) +__uint 0x2a != 0xfff6 == 0x1 (0x1) +char 0x2a != 0xfff6 == 0x1 (0x1) +__uchar 0x2a != 0xf6 == 0x1 (0x1) +__longlong 0x2a != 0xfff6 == 0x1 (0x1) +__ulonglong 0x2a != 0xfff6 == 0x1 (0x1) +float 0x2a != 0xfff6 == 0x1 (0x1) +int 0x2a >= 0xfff6 == 0x1 (0x1) +__uint 0x2a >= 0xfff6 == 0x0 (0x0) +char 0x2a >= 0xfff6 == 0x1 (0x1) +__uchar 0x2a >= 0xf6 == 0x0 (0x0) +__longlong 0x2a >= 0xfff6 == 0x1 (0x1) +__ulonglong 0x2a >= 0xfff6 == 0x0 (0x0) +float 0x2a >= 0xfff6 == 0x1 (0x1) +int 0x2a / 0xfff6 == -0x4 (0xfffc) +__uint 0x2a / 0xfff6 == 0x0 (0x0) +char 0x2a / 0xfff6 == -0x4 (0xfffc) +__uchar 0x2a / 0xf6 == 0x0 (0x0) +__longlong 0x2a / 0xfff6 == -0x4 (0xfffc) +__ulonglong 0x2a / 0xfff6 == 0x0 (0x0) +float 0x2a / 0xfff6 == -0x4 (0xfffc) +int 0x2a % 0xfff6 == 0x2 (0x2) +__uint 0x2a % 0xfff6 == 0x2a (0x2a) +char 0x2a % 0xfff6 == 0x2 (0x2) +__uchar 0x2a % 0xf6 == 0x2a (0x2a) +__longlong 0x2a % 0xfff6 == 0x2 (0x2) +__ulonglong 0x2a % 0xfff6 == 0x2a (0x2a) +0x2a * 0x5 == 0xd2 +0x2a / 0x5 == 0x8 +0x2a % 0x5 == 0x2 +int 0x2a ^ 0x5 == 0x2f (0x2f) +__uint 0x2a ^ 0x5 == 0x2f (0x2f) +char 0x2a ^ 0x5 == 0x2f (0x2f) +__uchar 0x2a ^ 0x5 == 0x2f (0x2f) +__longlong 0x2a ^ 0x5 == 0x2f (0x2f) +__ulonglong 0x2a ^ 0x5 == 0x2f (0x2f) +int 0x2a && 0x5 == 0x1 (0x1) +__uint 0x2a && 0x5 == 0x1 (0x1) +char 0x2a && 0x5 == 0x1 (0x1) +__uchar 0x2a && 0x5 == 0x1 (0x1) +__longlong 0x2a && 0x5 == 0x1 (0x1) +__ulonglong 0x2a && 0x5 == 0x1 (0x1) +int 0x2a || 0x5 == 0x1 (0x1) +__uint 0x2a || 0x5 == 0x1 (0x1) +char 0x2a || 0x5 == 0x1 (0x1) +__uchar 0x2a || 0x5 == 0x1 (0x1) +__longlong 0x2a || 0x5 == 0x1 (0x1) +__ulonglong 0x2a || 0x5 == 0x1 (0x1) +int 0x2a & 0x5 == 0x0 (0x0) +__uint 0x2a & 0x5 == 0x0 (0x0) +char 0x2a & 0x5 == 0x0 (0x0) +__uchar 0x2a & 0x5 == 0x0 (0x0) +__longlong 0x2a & 0x5 == 0x0 (0x0) +__ulonglong 0x2a & 0x5 == 0x0 (0x0) +int 0x2a | 0x5 == 0x2f (0x2f) +__uint 0x2a | 0x5 == 0x2f (0x2f) +char 0x2a | 0x5 == 0x2f (0x2f) +__uchar 0x2a | 0x5 == 0x2f (0x2f) +__longlong 0x2a | 0x5 == 0x2f (0x2f) +__ulonglong 0x2a | 0x5 == 0x2f (0x2f) +int 0x2a << 0x9 == 0x5400 (0x5400) +__uint 0x2a << 0x9 == 0x5400 (0x5400) +char 0x2a << 0x9 == 0x0 (0x0) +__uchar 0x2a << 0x9 == 0x0 (0x0) +__longlong 0x2a << 0x9 == 0x5400 (0x5400) +__ulonglong 0x2a << 0x9 == 0x5400 (0x5400) +int 0x2a >> 0x9 == 0x0 (0x0) +__uint 0x2a >> 0x9 == 0x0 (0x0) +char 0x2a >> 0x9 == 0x0 (0x0) +__uchar 0x2a >> 0x9 == 0x0 (0x0) +__longlong 0x2a >> 0x9 == 0x0 (0x0) +__ulonglong 0x2a >> 0x9 == 0x0 (0x0) +int 0x2a + 0x5 == 0x2f (0x2f) +__uint 0x2a + 0x5 == 0x2f (0x2f) +char 0x2a + 0x5 == 0x2f (0x2f) +__uchar 0x2a + 0x5 == 0x2f (0x2f) +__longlong 0x2a + 0x5 == 0x2f (0x2f) +__ulonglong 0x2a + 0x5 == 0x2f (0x2f) +float 0x2a + 0x5 == 0x2f (0x2f) +int 0x2a - 0x5 == 0x25 (0x25) +__uint 0x2a - 0x5 == 0x25 (0x25) +char 0x2a - 0x5 == 0x25 (0x25) +__uchar 0x2a - 0x5 == 0x25 (0x25) +__longlong 0x2a - 0x5 == 0x25 (0x25) +__ulonglong 0x2a - 0x5 == 0x25 (0x25) +float 0x2a - 0x5 == 0x25 (0x25) +int 0x2a * 0x5 == 0xd2 (0xd2) +__uint 0x2a * 0x5 == 0xd2 (0xd2) +char 0x2a * 0x5 == -0x2e (0xffd2) +__uchar 0x2a * 0x5 == 0xd2 (0xd2) +__longlong 0x2a * 0x5 == 0xd2 (0xd2) +__ulonglong 0x2a * 0x5 == 0xd2 (0xd2) +float 0x2a * 0x5 == 0xd2 (0xd2) +int 0x2a < 0x5 == 0x0 (0x0) +__uint 0x2a < 0x5 == 0x0 (0x0) +char 0x2a < 0x5 == 0x0 (0x0) +__uchar 0x2a < 0x5 == 0x0 (0x0) +__longlong 0x2a < 0x5 == 0x0 (0x0) +__ulonglong 0x2a < 0x5 == 0x0 (0x0) +float 0x2a < 0x5 == 0x0 (0x0) +int 0x2a > 0x5 == 0x1 (0x1) +__uint 0x2a > 0x5 == 0x1 (0x1) +char 0x2a > 0x5 == 0x1 (0x1) +__uchar 0x2a > 0x5 == 0x1 (0x1) +__longlong 0x2a > 0x5 == 0x1 (0x1) +__ulonglong 0x2a > 0x5 == 0x1 (0x1) +float 0x2a > 0x5 == 0x1 (0x1) +int 0x2a <= 0x5 == 0x0 (0x0) +__uint 0x2a <= 0x5 == 0x0 (0x0) +char 0x2a <= 0x5 == 0x0 (0x0) +__uchar 0x2a <= 0x5 == 0x0 (0x0) +__longlong 0x2a <= 0x5 == 0x0 (0x0) +__ulonglong 0x2a <= 0x5 == 0x0 (0x0) +float 0x2a <= 0x5 == 0x0 (0x0) +int 0x2a == 0x5 == 0x0 (0x0) +__uint 0x2a == 0x5 == 0x0 (0x0) +char 0x2a == 0x5 == 0x0 (0x0) +__uchar 0x2a == 0x5 == 0x0 (0x0) +__longlong 0x2a == 0x5 == 0x0 (0x0) +__ulonglong 0x2a == 0x5 == 0x0 (0x0) +float 0x2a == 0x5 == 0x0 (0x0) +int 0x2a != 0x5 == 0x1 (0x1) +__uint 0x2a != 0x5 == 0x1 (0x1) +char 0x2a != 0x5 == 0x1 (0x1) +__uchar 0x2a != 0x5 == 0x1 (0x1) +__longlong 0x2a != 0x5 == 0x1 (0x1) +__ulonglong 0x2a != 0x5 == 0x1 (0x1) +float 0x2a != 0x5 == 0x1 (0x1) +int 0x2a >= 0x5 == 0x1 (0x1) +__uint 0x2a >= 0x5 == 0x1 (0x1) +char 0x2a >= 0x5 == 0x1 (0x1) +__uchar 0x2a >= 0x5 == 0x1 (0x1) +__longlong 0x2a >= 0x5 == 0x1 (0x1) +__ulonglong 0x2a >= 0x5 == 0x1 (0x1) +float 0x2a >= 0x5 == 0x1 (0x1) +int 0x2a / 0x5 == 0x8 (0x8) +__uint 0x2a / 0x5 == 0x8 (0x8) +char 0x2a / 0x5 == 0x8 (0x8) +__uchar 0x2a / 0x5 == 0x8 (0x8) +__longlong 0x2a / 0x5 == 0x8 (0x8) +__ulonglong 0x2a / 0x5 == 0x8 (0x8) +float 0x2a / 0x5 == 0x8 (0x8) +int 0x2a % 0x5 == 0x2 (0x2) +__uint 0x2a % 0x5 == 0x2 (0x2) +char 0x2a % 0x5 == 0x2 (0x2) +__uchar 0x2a % 0x5 == 0x2 (0x2) +__longlong 0x2a % 0x5 == 0x2 (0x2) +__ulonglong 0x2a % 0x5 == 0x2 (0x2) +0x2a * 0x7 == 0x126 +0x2a / 0x7 == 0x6 +0x2a % 0x7 == 0x0 +int 0x2a ^ 0x7 == 0x2d (0x2d) +__uint 0x2a ^ 0x7 == 0x2d (0x2d) +char 0x2a ^ 0x7 == 0x2d (0x2d) +__uchar 0x2a ^ 0x7 == 0x2d (0x2d) +__longlong 0x2a ^ 0x7 == 0x2d (0x2d) +__ulonglong 0x2a ^ 0x7 == 0x2d (0x2d) +int 0x2a && 0x7 == 0x1 (0x1) +__uint 0x2a && 0x7 == 0x1 (0x1) +char 0x2a && 0x7 == 0x1 (0x1) +__uchar 0x2a && 0x7 == 0x1 (0x1) +__longlong 0x2a && 0x7 == 0x1 (0x1) +__ulonglong 0x2a && 0x7 == 0x1 (0x1) +int 0x2a || 0x7 == 0x1 (0x1) +__uint 0x2a || 0x7 == 0x1 (0x1) +char 0x2a || 0x7 == 0x1 (0x1) +__uchar 0x2a || 0x7 == 0x1 (0x1) +__longlong 0x2a || 0x7 == 0x1 (0x1) +__ulonglong 0x2a || 0x7 == 0x1 (0x1) +int 0x2a & 0x7 == 0x2 (0x2) +__uint 0x2a & 0x7 == 0x2 (0x2) +char 0x2a & 0x7 == 0x2 (0x2) +__uchar 0x2a & 0x7 == 0x2 (0x2) +__longlong 0x2a & 0x7 == 0x2 (0x2) +__ulonglong 0x2a & 0x7 == 0x2 (0x2) +int 0x2a | 0x7 == 0x2f (0x2f) +__uint 0x2a | 0x7 == 0x2f (0x2f) +char 0x2a | 0x7 == 0x2f (0x2f) +__uchar 0x2a | 0x7 == 0x2f (0x2f) +__longlong 0x2a | 0x7 == 0x2f (0x2f) +__ulonglong 0x2a | 0x7 == 0x2f (0x2f) +int 0x2a << 0xa == -0x5800 (0xa800) +__uint 0x2a << 0xa == -0x5800 (0xa800) +char 0x2a << 0xa == 0x0 (0x0) +__uchar 0x2a << 0xa == 0x0 (0x0) +__longlong 0x2a << 0xa == -0x5800 (0xa800) +__ulonglong 0x2a << 0xa == -0x5800 (0xa800) +int 0x2a >> 0xa == 0x0 (0x0) +__uint 0x2a >> 0xa == 0x0 (0x0) +char 0x2a >> 0xa == 0x0 (0x0) +__uchar 0x2a >> 0xa == 0x0 (0x0) +__longlong 0x2a >> 0xa == 0x0 (0x0) +__ulonglong 0x2a >> 0xa == 0x0 (0x0) +int 0x2a + 0x7 == 0x31 (0x31) +__uint 0x2a + 0x7 == 0x31 (0x31) +char 0x2a + 0x7 == 0x31 (0x31) +__uchar 0x2a + 0x7 == 0x31 (0x31) +__longlong 0x2a + 0x7 == 0x31 (0x31) +__ulonglong 0x2a + 0x7 == 0x31 (0x31) +float 0x2a + 0x7 == 0x31 (0x31) +int 0x2a - 0x7 == 0x23 (0x23) +__uint 0x2a - 0x7 == 0x23 (0x23) +char 0x2a - 0x7 == 0x23 (0x23) +__uchar 0x2a - 0x7 == 0x23 (0x23) +__longlong 0x2a - 0x7 == 0x23 (0x23) +__ulonglong 0x2a - 0x7 == 0x23 (0x23) +float 0x2a - 0x7 == 0x23 (0x23) +int 0x2a * 0x7 == 0x126 (0x126) +__uint 0x2a * 0x7 == 0x126 (0x126) +char 0x2a * 0x7 == 0x26 (0x26) +__uchar 0x2a * 0x7 == 0x26 (0x26) +__longlong 0x2a * 0x7 == 0x126 (0x126) +__ulonglong 0x2a * 0x7 == 0x126 (0x126) +float 0x2a * 0x7 == 0x126 (0x126) +int 0x2a < 0x7 == 0x0 (0x0) +__uint 0x2a < 0x7 == 0x0 (0x0) +char 0x2a < 0x7 == 0x0 (0x0) +__uchar 0x2a < 0x7 == 0x0 (0x0) +__longlong 0x2a < 0x7 == 0x0 (0x0) +__ulonglong 0x2a < 0x7 == 0x0 (0x0) +float 0x2a < 0x7 == 0x0 (0x0) +int 0x2a > 0x7 == 0x1 (0x1) +__uint 0x2a > 0x7 == 0x1 (0x1) +char 0x2a > 0x7 == 0x1 (0x1) +__uchar 0x2a > 0x7 == 0x1 (0x1) +__longlong 0x2a > 0x7 == 0x1 (0x1) +__ulonglong 0x2a > 0x7 == 0x1 (0x1) +float 0x2a > 0x7 == 0x1 (0x1) +int 0x2a <= 0x7 == 0x0 (0x0) +__uint 0x2a <= 0x7 == 0x0 (0x0) +char 0x2a <= 0x7 == 0x0 (0x0) +__uchar 0x2a <= 0x7 == 0x0 (0x0) +__longlong 0x2a <= 0x7 == 0x0 (0x0) +__ulonglong 0x2a <= 0x7 == 0x0 (0x0) +float 0x2a <= 0x7 == 0x0 (0x0) +int 0x2a == 0x7 == 0x0 (0x0) +__uint 0x2a == 0x7 == 0x0 (0x0) +char 0x2a == 0x7 == 0x0 (0x0) +__uchar 0x2a == 0x7 == 0x0 (0x0) +__longlong 0x2a == 0x7 == 0x0 (0x0) +__ulonglong 0x2a == 0x7 == 0x0 (0x0) +float 0x2a == 0x7 == 0x0 (0x0) +int 0x2a != 0x7 == 0x1 (0x1) +__uint 0x2a != 0x7 == 0x1 (0x1) +char 0x2a != 0x7 == 0x1 (0x1) +__uchar 0x2a != 0x7 == 0x1 (0x1) +__longlong 0x2a != 0x7 == 0x1 (0x1) +__ulonglong 0x2a != 0x7 == 0x1 (0x1) +float 0x2a != 0x7 == 0x1 (0x1) +int 0x2a >= 0x7 == 0x1 (0x1) +__uint 0x2a >= 0x7 == 0x1 (0x1) +char 0x2a >= 0x7 == 0x1 (0x1) +__uchar 0x2a >= 0x7 == 0x1 (0x1) +__longlong 0x2a >= 0x7 == 0x1 (0x1) +__ulonglong 0x2a >= 0x7 == 0x1 (0x1) +float 0x2a >= 0x7 == 0x1 (0x1) +int 0x2a / 0x7 == 0x6 (0x6) +__uint 0x2a / 0x7 == 0x6 (0x6) +char 0x2a / 0x7 == 0x6 (0x6) +__uchar 0x2a / 0x7 == 0x6 (0x6) +__longlong 0x2a / 0x7 == 0x6 (0x6) +__ulonglong 0x2a / 0x7 == 0x6 (0x6) +float 0x2a / 0x7 == 0x6 (0x6) +int 0x2a % 0x7 == 0x0 (0x0) +__uint 0x2a % 0x7 == 0x0 (0x0) +char 0x2a % 0x7 == 0x0 (0x0) +__uchar 0x2a % 0x7 == 0x0 (0x0) +__longlong 0x2a % 0x7 == 0x0 (0x0) +__ulonglong 0x2a % 0x7 == 0x0 (0x0) +0x2a * 0x2a == 0x6e4 +0x2a / 0x2a == 0x1 +0x2a % 0x2a == 0x0 +int 0x2a ^ 0x2a == 0x0 (0x0) +__uint 0x2a ^ 0x2a == 0x0 (0x0) +char 0x2a ^ 0x2a == 0x0 (0x0) +__uchar 0x2a ^ 0x2a == 0x0 (0x0) +__longlong 0x2a ^ 0x2a == 0x0 (0x0) +__ulonglong 0x2a ^ 0x2a == 0x0 (0x0) +int 0x2a && 0x2a == 0x1 (0x1) +__uint 0x2a && 0x2a == 0x1 (0x1) +char 0x2a && 0x2a == 0x1 (0x1) +__uchar 0x2a && 0x2a == 0x1 (0x1) +__longlong 0x2a && 0x2a == 0x1 (0x1) +__ulonglong 0x2a && 0x2a == 0x1 (0x1) +int 0x2a || 0x2a == 0x1 (0x1) +__uint 0x2a || 0x2a == 0x1 (0x1) +char 0x2a || 0x2a == 0x1 (0x1) +__uchar 0x2a || 0x2a == 0x1 (0x1) +__longlong 0x2a || 0x2a == 0x1 (0x1) +__ulonglong 0x2a || 0x2a == 0x1 (0x1) +int 0x2a & 0x2a == 0x2a (0x2a) +__uint 0x2a & 0x2a == 0x2a (0x2a) +char 0x2a & 0x2a == 0x2a (0x2a) +__uchar 0x2a & 0x2a == 0x2a (0x2a) +__longlong 0x2a & 0x2a == 0x2a (0x2a) +__ulonglong 0x2a & 0x2a == 0x2a (0x2a) +int 0x2a | 0x2a == 0x2a (0x2a) +__uint 0x2a | 0x2a == 0x2a (0x2a) +char 0x2a | 0x2a == 0x2a (0x2a) +__uchar 0x2a | 0x2a == 0x2a (0x2a) +__longlong 0x2a | 0x2a == 0x2a (0x2a) +__ulonglong 0x2a | 0x2a == 0x2a (0x2a) +int 0x2a << 0xc == -0x6000 (0xa000) +__uint 0x2a << 0xc == -0x6000 (0xa000) +char 0x2a << 0xc == 0x0 (0x0) +__uchar 0x2a << 0xc == 0x0 (0x0) +__longlong 0x2a << 0xc == -0x6000 (0xa000) +__ulonglong 0x2a << 0xc == -0x6000 (0xa000) +int 0x2a >> 0xc == 0x0 (0x0) +__uint 0x2a >> 0xc == 0x0 (0x0) +char 0x2a >> 0xc == 0x0 (0x0) +__uchar 0x2a >> 0xc == 0x0 (0x0) +__longlong 0x2a >> 0xc == 0x0 (0x0) +__ulonglong 0x2a >> 0xc == 0x0 (0x0) +int 0x2a + 0x2a == 0x54 (0x54) +__uint 0x2a + 0x2a == 0x54 (0x54) +char 0x2a + 0x2a == 0x54 (0x54) +__uchar 0x2a + 0x2a == 0x54 (0x54) +__longlong 0x2a + 0x2a == 0x54 (0x54) +__ulonglong 0x2a + 0x2a == 0x54 (0x54) +float 0x2a + 0x2a == 0x54 (0x54) +int 0x2a - 0x2a == 0x0 (0x0) +__uint 0x2a - 0x2a == 0x0 (0x0) +char 0x2a - 0x2a == 0x0 (0x0) +__uchar 0x2a - 0x2a == 0x0 (0x0) +__longlong 0x2a - 0x2a == 0x0 (0x0) +__ulonglong 0x2a - 0x2a == 0x0 (0x0) +float 0x2a - 0x2a == 0x0 (0x0) +int 0x2a * 0x2a == 0x6e4 (0x6e4) +__uint 0x2a * 0x2a == 0x6e4 (0x6e4) +char 0x2a * 0x2a == -0x1c (0xffe4) +__uchar 0x2a * 0x2a == 0xe4 (0xe4) +__longlong 0x2a * 0x2a == 0x6e4 (0x6e4) +__ulonglong 0x2a * 0x2a == 0x6e4 (0x6e4) +float 0x2a * 0x2a == 0x6e4 (0x6e4) +int 0x2a < 0x2a == 0x0 (0x0) +__uint 0x2a < 0x2a == 0x0 (0x0) +char 0x2a < 0x2a == 0x0 (0x0) +__uchar 0x2a < 0x2a == 0x0 (0x0) +__longlong 0x2a < 0x2a == 0x0 (0x0) +__ulonglong 0x2a < 0x2a == 0x0 (0x0) +float 0x2a < 0x2a == 0x0 (0x0) +int 0x2a > 0x2a == 0x0 (0x0) +__uint 0x2a > 0x2a == 0x0 (0x0) +char 0x2a > 0x2a == 0x0 (0x0) +__uchar 0x2a > 0x2a == 0x0 (0x0) +__longlong 0x2a > 0x2a == 0x0 (0x0) +__ulonglong 0x2a > 0x2a == 0x0 (0x0) +float 0x2a > 0x2a == 0x0 (0x0) +int 0x2a <= 0x2a == 0x1 (0x1) +__uint 0x2a <= 0x2a == 0x1 (0x1) +char 0x2a <= 0x2a == 0x1 (0x1) +__uchar 0x2a <= 0x2a == 0x1 (0x1) +__longlong 0x2a <= 0x2a == 0x1 (0x1) +__ulonglong 0x2a <= 0x2a == 0x1 (0x1) +float 0x2a <= 0x2a == 0x1 (0x1) +int 0x2a == 0x2a == 0x1 (0x1) +__uint 0x2a == 0x2a == 0x1 (0x1) +char 0x2a == 0x2a == 0x1 (0x1) +__uchar 0x2a == 0x2a == 0x1 (0x1) +__longlong 0x2a == 0x2a == 0x1 (0x1) +__ulonglong 0x2a == 0x2a == 0x1 (0x1) +float 0x2a == 0x2a == 0x1 (0x1) +int 0x2a != 0x2a == 0x0 (0x0) +__uint 0x2a != 0x2a == 0x0 (0x0) +char 0x2a != 0x2a == 0x0 (0x0) +__uchar 0x2a != 0x2a == 0x0 (0x0) +__longlong 0x2a != 0x2a == 0x0 (0x0) +__ulonglong 0x2a != 0x2a == 0x0 (0x0) +float 0x2a != 0x2a == 0x0 (0x0) +int 0x2a >= 0x2a == 0x1 (0x1) +__uint 0x2a >= 0x2a == 0x1 (0x1) +char 0x2a >= 0x2a == 0x1 (0x1) +__uchar 0x2a >= 0x2a == 0x1 (0x1) +__longlong 0x2a >= 0x2a == 0x1 (0x1) +__ulonglong 0x2a >= 0x2a == 0x1 (0x1) +float 0x2a >= 0x2a == 0x1 (0x1) +int 0x2a / 0x2a == 0x1 (0x1) +__uint 0x2a / 0x2a == 0x1 (0x1) +char 0x2a / 0x2a == 0x1 (0x1) +__uchar 0x2a / 0x2a == 0x1 (0x1) +__longlong 0x2a / 0x2a == 0x1 (0x1) +__ulonglong 0x2a / 0x2a == 0x1 (0x1) +float 0x2a / 0x2a == 0x1 (0x1) +int 0x2a % 0x2a == 0x0 (0x0) +__uint 0x2a % 0x2a == 0x0 (0x0) +char 0x2a % 0x2a == 0x0 (0x0) +__uchar 0x2a % 0x2a == 0x0 (0x0) +__longlong 0x2a % 0x2a == 0x0 (0x0) +__ulonglong 0x2a % 0x2a == 0x0 (0x0) +0x2a * 0x17 == 0x3c6 +0x2a / 0x17 == 0x1 +0x2a % 0x17 == 0x13 +int 0x2a ^ 0x17 == 0x3d (0x3d) +__uint 0x2a ^ 0x17 == 0x3d (0x3d) +char 0x2a ^ 0x17 == 0x3d (0x3d) +__uchar 0x2a ^ 0x17 == 0x3d (0x3d) +__longlong 0x2a ^ 0x17 == 0x3d (0x3d) +__ulonglong 0x2a ^ 0x17 == 0x3d (0x3d) +int 0x2a && 0x17 == 0x1 (0x1) +__uint 0x2a && 0x17 == 0x1 (0x1) +char 0x2a && 0x17 == 0x1 (0x1) +__uchar 0x2a && 0x17 == 0x1 (0x1) +__longlong 0x2a && 0x17 == 0x1 (0x1) +__ulonglong 0x2a && 0x17 == 0x1 (0x1) +int 0x2a || 0x17 == 0x1 (0x1) +__uint 0x2a || 0x17 == 0x1 (0x1) +char 0x2a || 0x17 == 0x1 (0x1) +__uchar 0x2a || 0x17 == 0x1 (0x1) +__longlong 0x2a || 0x17 == 0x1 (0x1) +__ulonglong 0x2a || 0x17 == 0x1 (0x1) +int 0x2a & 0x17 == 0x2 (0x2) +__uint 0x2a & 0x17 == 0x2 (0x2) +char 0x2a & 0x17 == 0x2 (0x2) +__uchar 0x2a & 0x17 == 0x2 (0x2) +__longlong 0x2a & 0x17 == 0x2 (0x2) +__ulonglong 0x2a & 0x17 == 0x2 (0x2) +int 0x2a | 0x17 == 0x3f (0x3f) +__uint 0x2a | 0x17 == 0x3f (0x3f) +char 0x2a | 0x17 == 0x3f (0x3f) +__uchar 0x2a | 0x17 == 0x3f (0x3f) +__longlong 0x2a | 0x17 == 0x3f (0x3f) +__ulonglong 0x2a | 0x17 == 0x3f (0x3f) +int 0x2a << 0xe == -0x8000 (0x8000) +__uint 0x2a << 0xe == -0x8000 (0x8000) +char 0x2a << 0xe == 0x0 (0x0) +__uchar 0x2a << 0xe == 0x0 (0x0) +__longlong 0x2a << 0xe == -0x8000 (0x8000) +__ulonglong 0x2a << 0xe == -0x8000 (0x8000) +int 0x2a >> 0xe == 0x0 (0x0) +__uint 0x2a >> 0xe == 0x0 (0x0) +char 0x2a >> 0xe == 0x0 (0x0) +__uchar 0x2a >> 0xe == 0x0 (0x0) +__longlong 0x2a >> 0xe == 0x0 (0x0) +__ulonglong 0x2a >> 0xe == 0x0 (0x0) +int 0x2a + 0x17 == 0x41 (0x41) +__uint 0x2a + 0x17 == 0x41 (0x41) +char 0x2a + 0x17 == 0x41 (0x41) +__uchar 0x2a + 0x17 == 0x41 (0x41) +__longlong 0x2a + 0x17 == 0x41 (0x41) +__ulonglong 0x2a + 0x17 == 0x41 (0x41) +float 0x2a + 0x17 == 0x41 (0x41) +int 0x2a - 0x17 == 0x13 (0x13) +__uint 0x2a - 0x17 == 0x13 (0x13) +char 0x2a - 0x17 == 0x13 (0x13) +__uchar 0x2a - 0x17 == 0x13 (0x13) +__longlong 0x2a - 0x17 == 0x13 (0x13) +__ulonglong 0x2a - 0x17 == 0x13 (0x13) +float 0x2a - 0x17 == 0x13 (0x13) +int 0x2a * 0x17 == 0x3c6 (0x3c6) +__uint 0x2a * 0x17 == 0x3c6 (0x3c6) +char 0x2a * 0x17 == -0x3a (0xffc6) +__uchar 0x2a * 0x17 == 0xc6 (0xc6) +__longlong 0x2a * 0x17 == 0x3c6 (0x3c6) +__ulonglong 0x2a * 0x17 == 0x3c6 (0x3c6) +float 0x2a * 0x17 == 0x3c6 (0x3c6) +int 0x2a < 0x17 == 0x0 (0x0) +__uint 0x2a < 0x17 == 0x0 (0x0) +char 0x2a < 0x17 == 0x0 (0x0) +__uchar 0x2a < 0x17 == 0x0 (0x0) +__longlong 0x2a < 0x17 == 0x0 (0x0) +__ulonglong 0x2a < 0x17 == 0x0 (0x0) +float 0x2a < 0x17 == 0x0 (0x0) +int 0x2a > 0x17 == 0x1 (0x1) +__uint 0x2a > 0x17 == 0x1 (0x1) +char 0x2a > 0x17 == 0x1 (0x1) +__uchar 0x2a > 0x17 == 0x1 (0x1) +__longlong 0x2a > 0x17 == 0x1 (0x1) +__ulonglong 0x2a > 0x17 == 0x1 (0x1) +float 0x2a > 0x17 == 0x1 (0x1) +int 0x2a <= 0x17 == 0x0 (0x0) +__uint 0x2a <= 0x17 == 0x0 (0x0) +char 0x2a <= 0x17 == 0x0 (0x0) +__uchar 0x2a <= 0x17 == 0x0 (0x0) +__longlong 0x2a <= 0x17 == 0x0 (0x0) +__ulonglong 0x2a <= 0x17 == 0x0 (0x0) +float 0x2a <= 0x17 == 0x0 (0x0) +int 0x2a == 0x17 == 0x0 (0x0) +__uint 0x2a == 0x17 == 0x0 (0x0) +char 0x2a == 0x17 == 0x0 (0x0) +__uchar 0x2a == 0x17 == 0x0 (0x0) +__longlong 0x2a == 0x17 == 0x0 (0x0) +__ulonglong 0x2a == 0x17 == 0x0 (0x0) +float 0x2a == 0x17 == 0x0 (0x0) +int 0x2a != 0x17 == 0x1 (0x1) +__uint 0x2a != 0x17 == 0x1 (0x1) +char 0x2a != 0x17 == 0x1 (0x1) +__uchar 0x2a != 0x17 == 0x1 (0x1) +__longlong 0x2a != 0x17 == 0x1 (0x1) +__ulonglong 0x2a != 0x17 == 0x1 (0x1) +float 0x2a != 0x17 == 0x1 (0x1) +int 0x2a >= 0x17 == 0x1 (0x1) +__uint 0x2a >= 0x17 == 0x1 (0x1) +char 0x2a >= 0x17 == 0x1 (0x1) +__uchar 0x2a >= 0x17 == 0x1 (0x1) +__longlong 0x2a >= 0x17 == 0x1 (0x1) +__ulonglong 0x2a >= 0x17 == 0x1 (0x1) +float 0x2a >= 0x17 == 0x1 (0x1) +int 0x2a / 0x17 == 0x1 (0x1) +__uint 0x2a / 0x17 == 0x1 (0x1) +char 0x2a / 0x17 == 0x1 (0x1) +__uchar 0x2a / 0x17 == 0x1 (0x1) +__longlong 0x2a / 0x17 == 0x1 (0x1) +__ulonglong 0x2a / 0x17 == 0x1 (0x1) +float 0x2a / 0x17 == 0x1 (0x1) +int 0x2a % 0x17 == 0x13 (0x13) +__uint 0x2a % 0x17 == 0x13 (0x13) +char 0x2a % 0x17 == 0x13 (0x13) +__uchar 0x2a % 0x17 == 0x13 (0x13) +__longlong 0x2a % 0x17 == 0x13 (0x13) +__ulonglong 0x2a % 0x17 == 0x13 (0x13) +0x2a * 0x7fff == -0x2a +0x2a / 0x7fff == 0x0 +0x2a % 0x7fff == 0x2a +int 0x2a ^ 0x7fff == 0x7fd5 (0x7fd5) +__uint 0x2a ^ 0x7fff == 0x7fd5 (0x7fd5) +char 0x2a ^ 0xffff == -0x2b (0xffd5) +__uchar 0x2a ^ 0xff == 0xd5 (0xd5) +__longlong 0x2a ^ 0x7fff == 0x7fd5 (0x7fd5) +__ulonglong 0x2a ^ 0x7fff == 0x7fd5 (0x7fd5) +int 0x2a && 0x7fff == 0x1 (0x1) +__uint 0x2a && 0x7fff == 0x1 (0x1) +char 0x2a && 0xffff == 0x1 (0x1) +__uchar 0x2a && 0xff == 0x1 (0x1) +__longlong 0x2a && 0x7fff == 0x1 (0x1) +__ulonglong 0x2a && 0x7fff == 0x1 (0x1) +int 0x2a || 0x7fff == 0x1 (0x1) +__uint 0x2a || 0x7fff == 0x1 (0x1) +char 0x2a || 0xffff == 0x1 (0x1) +__uchar 0x2a || 0xff == 0x1 (0x1) +__longlong 0x2a || 0x7fff == 0x1 (0x1) +__ulonglong 0x2a || 0x7fff == 0x1 (0x1) +int 0x2a & 0x7fff == 0x2a (0x2a) +__uint 0x2a & 0x7fff == 0x2a (0x2a) +char 0x2a & 0xffff == 0x2a (0x2a) +__uchar 0x2a & 0xff == 0x2a (0x2a) +__longlong 0x2a & 0x7fff == 0x2a (0x2a) +__ulonglong 0x2a & 0x7fff == 0x2a (0x2a) +int 0x2a | 0x7fff == 0x7fff (0x7fff) +__uint 0x2a | 0x7fff == 0x7fff (0x7fff) +char 0x2a | 0xffff == -0x1 (0xffff) +__uchar 0x2a | 0xff == 0xff (0xff) +__longlong 0x2a | 0x7fff == 0x7fff (0x7fff) +__ulonglong 0x2a | 0x7fff == 0x7fff (0x7fff) +int 0x2a << 0x10 == 0x0 (0x0) +__uint 0x2a << 0x10 == 0x0 (0x0) +char 0x2a << 0x10 == 0x0 (0x0) +__uchar 0x2a << 0x10 == 0x0 (0x0) +__longlong 0x2a << 0x10 == 0x0 (0x0) +__ulonglong 0x2a << 0x10 == 0x0 (0x0) +int 0x2a >> 0x10 == 0x0 (0x0) +__uint 0x2a >> 0x10 == 0x0 (0x0) +char 0x2a >> 0x10 == 0x0 (0x0) +__uchar 0x2a >> 0x10 == 0x0 (0x0) +__longlong 0x2a >> 0x10 == 0x0 (0x0) +__ulonglong 0x2a >> 0x10 == 0x0 (0x0) +int 0x2a + 0x7fff == -0x7fd7 (0x8029) +__uint 0x2a + 0x7fff == -0x7fd7 (0x8029) +char 0x2a + 0xffff == 0x29 (0x29) +__uchar 0x2a + 0xff == 0x29 (0x29) +__longlong 0x2a + 0x7fff == -0x7fd7 (0x8029) +__ulonglong 0x2a + 0x7fff == -0x7fd7 (0x8029) +float 0x2a + 0x7fff == -0x8000 (0x8000) +int 0x2a - 0x7fff == -0x7fd5 (0x802b) +__uint 0x2a - 0x7fff == -0x7fd5 (0x802b) +char 0x2a - 0xffff == 0x2b (0x2b) +__uchar 0x2a - 0xff == 0x2b (0x2b) +__longlong 0x2a - 0x7fff == -0x7fd5 (0x802b) +__ulonglong 0x2a - 0x7fff == -0x7fd5 (0x802b) +float 0x2a - 0x7fff == -0x7fd5 (0x802b) +int 0x2a * 0x7fff == -0x2a (0xffd6) +__uint 0x2a * 0x7fff == -0x2a (0xffd6) +char 0x2a * 0xffff == -0x2a (0xffd6) +__uchar 0x2a * 0xff == 0xd6 (0xd6) +__longlong 0x2a * 0x7fff == -0x2a (0xffd6) +__ulonglong 0x2a * 0x7fff == -0x2a (0xffd6) +float 0x2a * 0x7fff == -0x8000 (0x8000) +int 0x2a < 0x7fff == 0x1 (0x1) +__uint 0x2a < 0x7fff == 0x1 (0x1) +char 0x2a < 0xffff == 0x0 (0x0) +__uchar 0x2a < 0xff == 0x1 (0x1) +__longlong 0x2a < 0x7fff == 0x1 (0x1) +__ulonglong 0x2a < 0x7fff == 0x1 (0x1) +float 0x2a < 0x7fff == 0x1 (0x1) +int 0x2a > 0x7fff == 0x0 (0x0) +__uint 0x2a > 0x7fff == 0x0 (0x0) +char 0x2a > 0xffff == 0x1 (0x1) +__uchar 0x2a > 0xff == 0x0 (0x0) +__longlong 0x2a > 0x7fff == 0x0 (0x0) +__ulonglong 0x2a > 0x7fff == 0x0 (0x0) +float 0x2a > 0x7fff == 0x0 (0x0) +int 0x2a <= 0x7fff == 0x1 (0x1) +__uint 0x2a <= 0x7fff == 0x1 (0x1) +char 0x2a <= 0xffff == 0x0 (0x0) +__uchar 0x2a <= 0xff == 0x1 (0x1) +__longlong 0x2a <= 0x7fff == 0x1 (0x1) +__ulonglong 0x2a <= 0x7fff == 0x1 (0x1) +float 0x2a <= 0x7fff == 0x1 (0x1) +int 0x2a == 0x7fff == 0x0 (0x0) +__uint 0x2a == 0x7fff == 0x0 (0x0) +char 0x2a == 0xffff == 0x0 (0x0) +__uchar 0x2a == 0xff == 0x0 (0x0) +__longlong 0x2a == 0x7fff == 0x0 (0x0) +__ulonglong 0x2a == 0x7fff == 0x0 (0x0) +float 0x2a == 0x7fff == 0x0 (0x0) +int 0x2a != 0x7fff == 0x1 (0x1) +__uint 0x2a != 0x7fff == 0x1 (0x1) +char 0x2a != 0xffff == 0x1 (0x1) +__uchar 0x2a != 0xff == 0x1 (0x1) +__longlong 0x2a != 0x7fff == 0x1 (0x1) +__ulonglong 0x2a != 0x7fff == 0x1 (0x1) +float 0x2a != 0x7fff == 0x1 (0x1) +int 0x2a >= 0x7fff == 0x0 (0x0) +__uint 0x2a >= 0x7fff == 0x0 (0x0) +char 0x2a >= 0xffff == 0x1 (0x1) +__uchar 0x2a >= 0xff == 0x0 (0x0) +__longlong 0x2a >= 0x7fff == 0x0 (0x0) +__ulonglong 0x2a >= 0x7fff == 0x0 (0x0) +float 0x2a >= 0x7fff == 0x0 (0x0) +int 0x2a / 0x7fff == 0x0 (0x0) +__uint 0x2a / 0x7fff == 0x0 (0x0) +char 0x2a / 0xffff == -0x2a (0xffd6) +__uchar 0x2a / 0xff == 0x0 (0x0) +__longlong 0x2a / 0x7fff == 0x0 (0x0) +__ulonglong 0x2a / 0x7fff == 0x0 (0x0) +float 0x2a / 0x7fff == 0x0 (0x0) +int 0x2a % 0x7fff == 0x2a (0x2a) +__uint 0x2a % 0x7fff == 0x2a (0x2a) +char 0x2a % 0xffff == 0x0 (0x0) +__uchar 0x2a % 0xff == 0x2a (0x2a) +__longlong 0x2a % 0x7fff == 0x2a (0x2a) +__ulonglong 0x2a % 0x7fff == 0x2a (0x2a) +0x2a * 0x8000 == 0x0 +0x2a / 0x8000 == 0x0 +0x2a % 0x8000 == 0x2a +int 0x2a ^ 0x8000 == -0x7fd6 (0x802a) +__uint 0x2a ^ 0x8000 == -0x7fd6 (0x802a) +char 0x2a ^ 0x0 == 0x2a (0x2a) +__uchar 0x2a ^ 0x0 == 0x2a (0x2a) +__longlong 0x2a ^ 0x8000 == -0x7fd6 (0x802a) +__ulonglong 0x2a ^ 0x8000 == -0x7fd6 (0x802a) +int 0x2a && 0x8000 == 0x1 (0x1) +__uint 0x2a && 0x8000 == 0x1 (0x1) +char 0x2a && 0x0 == 0x0 (0x0) +__uchar 0x2a && 0x0 == 0x0 (0x0) +__longlong 0x2a && 0x8000 == 0x1 (0x1) +__ulonglong 0x2a && 0x8000 == 0x1 (0x1) +int 0x2a || 0x8000 == 0x1 (0x1) +__uint 0x2a || 0x8000 == 0x1 (0x1) +char 0x2a || 0x0 == 0x1 (0x1) +__uchar 0x2a || 0x0 == 0x1 (0x1) +__longlong 0x2a || 0x8000 == 0x1 (0x1) +__ulonglong 0x2a || 0x8000 == 0x1 (0x1) +int 0x2a & 0x8000 == 0x0 (0x0) +__uint 0x2a & 0x8000 == 0x0 (0x0) +char 0x2a & 0x0 == 0x0 (0x0) +__uchar 0x2a & 0x0 == 0x0 (0x0) +__longlong 0x2a & 0x8000 == 0x0 (0x0) +__ulonglong 0x2a & 0x8000 == 0x0 (0x0) +int 0x2a | 0x8000 == -0x7fd6 (0x802a) +__uint 0x2a | 0x8000 == -0x7fd6 (0x802a) +char 0x2a | 0x0 == 0x2a (0x2a) +__uchar 0x2a | 0x0 == 0x2a (0x2a) +__longlong 0x2a | 0x8000 == -0x7fd6 (0x802a) +__ulonglong 0x2a | 0x8000 == -0x7fd6 (0x802a) +int 0x2a << 0x12 == 0x0 (0x0) +__uint 0x2a << 0x12 == 0x0 (0x0) +char 0x2a << 0x12 == 0x0 (0x0) +__uchar 0x2a << 0x12 == 0x0 (0x0) +__longlong 0x2a << 0x12 == 0x0 (0x0) +__ulonglong 0x2a << 0x12 == 0x0 (0x0) +int 0x2a >> 0x12 == 0x0 (0x0) +__uint 0x2a >> 0x12 == 0x0 (0x0) +char 0x2a >> 0x12 == 0x0 (0x0) +__uchar 0x2a >> 0x12 == 0x0 (0x0) +__longlong 0x2a >> 0x12 == 0x0 (0x0) +__ulonglong 0x2a >> 0x12 == 0x0 (0x0) +int 0x2a + 0x8000 == -0x7fd6 (0x802a) +__uint 0x2a + 0x8000 == -0x7fd6 (0x802a) +char 0x2a + 0x0 == 0x2a (0x2a) +__uchar 0x2a + 0x0 == 0x2a (0x2a) +__longlong 0x2a + 0x8000 == -0x7fd6 (0x802a) +__ulonglong 0x2a + 0x8000 == -0x7fd6 (0x802a) +float 0x2a + 0x8000 == -0x7fd6 (0x802a) +int 0x2a - 0x8000 == -0x7fd6 (0x802a) +__uint 0x2a - 0x8000 == -0x7fd6 (0x802a) +char 0x2a - 0x0 == 0x2a (0x2a) +__uchar 0x2a - 0x0 == 0x2a (0x2a) +__longlong 0x2a - 0x8000 == -0x7fd6 (0x802a) +__ulonglong 0x2a - 0x8000 == -0x7fd6 (0x802a) +float 0x2a - 0x8000 == -0x8000 (0x8000) +int 0x2a * 0x8000 == 0x0 (0x0) +__uint 0x2a * 0x8000 == 0x0 (0x0) +char 0x2a * 0x0 == 0x0 (0x0) +__uchar 0x2a * 0x0 == 0x0 (0x0) +__longlong 0x2a * 0x8000 == 0x0 (0x0) +__ulonglong 0x2a * 0x8000 == 0x0 (0x0) +float 0x2a * 0x8000 == -0x8000 (0x8000) +int 0x2a < 0x8000 == 0x0 (0x0) +__uint 0x2a < 0x8000 == 0x1 (0x1) +char 0x2a < 0x0 == 0x0 (0x0) +__uchar 0x2a < 0x0 == 0x0 (0x0) +__longlong 0x2a < 0x8000 == 0x0 (0x0) +__ulonglong 0x2a < 0x8000 == 0x1 (0x1) +float 0x2a < 0x8000 == 0x0 (0x0) +int 0x2a > 0x8000 == 0x1 (0x1) +__uint 0x2a > 0x8000 == 0x0 (0x0) +char 0x2a > 0x0 == 0x1 (0x1) +__uchar 0x2a > 0x0 == 0x1 (0x1) +__longlong 0x2a > 0x8000 == 0x1 (0x1) +__ulonglong 0x2a > 0x8000 == 0x0 (0x0) +float 0x2a > 0x8000 == 0x1 (0x1) +int 0x2a <= 0x8000 == 0x0 (0x0) +__uint 0x2a <= 0x8000 == 0x1 (0x1) +char 0x2a <= 0x0 == 0x0 (0x0) +__uchar 0x2a <= 0x0 == 0x0 (0x0) +__longlong 0x2a <= 0x8000 == 0x0 (0x0) +__ulonglong 0x2a <= 0x8000 == 0x1 (0x1) +float 0x2a <= 0x8000 == 0x0 (0x0) +int 0x2a == 0x8000 == 0x0 (0x0) +__uint 0x2a == 0x8000 == 0x0 (0x0) +char 0x2a == 0x0 == 0x0 (0x0) +__uchar 0x2a == 0x0 == 0x0 (0x0) +__longlong 0x2a == 0x8000 == 0x0 (0x0) +__ulonglong 0x2a == 0x8000 == 0x0 (0x0) +float 0x2a == 0x8000 == 0x0 (0x0) +int 0x2a != 0x8000 == 0x1 (0x1) +__uint 0x2a != 0x8000 == 0x1 (0x1) +char 0x2a != 0x0 == 0x1 (0x1) +__uchar 0x2a != 0x0 == 0x1 (0x1) +__longlong 0x2a != 0x8000 == 0x1 (0x1) +__ulonglong 0x2a != 0x8000 == 0x1 (0x1) +float 0x2a != 0x8000 == 0x1 (0x1) +int 0x2a >= 0x8000 == 0x1 (0x1) +__uint 0x2a >= 0x8000 == 0x0 (0x0) +char 0x2a >= 0x0 == 0x1 (0x1) +__uchar 0x2a >= 0x0 == 0x1 (0x1) +__longlong 0x2a >= 0x8000 == 0x1 (0x1) +__ulonglong 0x2a >= 0x8000 == 0x0 (0x0) +float 0x2a >= 0x8000 == 0x1 (0x1) +int 0x2a / 0x8000 == 0x0 (0x0) +__uint 0x2a / 0x8000 == 0x0 (0x0) +__longlong 0x2a / 0x8000 == 0x0 (0x0) +__ulonglong 0x2a / 0x8000 == 0x0 (0x0) +float 0x2a / 0x8000 == 0x0 (0x0) +int 0x2a % 0x8000 == 0x2a (0x2a) +__uint 0x2a % 0x8000 == 0x2a (0x2a) +__longlong 0x2a % 0x8000 == 0x2a (0x2a) +__ulonglong 0x2a % 0x8000 == 0x2a (0x2a) +0x2a * 0x3e8 == -0x5bf0 +0x2a / 0x3e8 == 0x0 +0x2a % 0x3e8 == 0x2a +int 0x2a ^ 0x3e8 == 0x3c2 (0x3c2) +__uint 0x2a ^ 0x3e8 == 0x3c2 (0x3c2) +char 0x2a ^ 0xffe8 == -0x3e (0xffc2) +__uchar 0x2a ^ 0xe8 == 0xc2 (0xc2) +__longlong 0x2a ^ 0x3e8 == 0x3c2 (0x3c2) +__ulonglong 0x2a ^ 0x3e8 == 0x3c2 (0x3c2) +int 0x2a && 0x3e8 == 0x1 (0x1) +__uint 0x2a && 0x3e8 == 0x1 (0x1) +char 0x2a && 0xffe8 == 0x1 (0x1) +__uchar 0x2a && 0xe8 == 0x1 (0x1) +__longlong 0x2a && 0x3e8 == 0x1 (0x1) +__ulonglong 0x2a && 0x3e8 == 0x1 (0x1) +int 0x2a || 0x3e8 == 0x1 (0x1) +__uint 0x2a || 0x3e8 == 0x1 (0x1) +char 0x2a || 0xffe8 == 0x1 (0x1) +__uchar 0x2a || 0xe8 == 0x1 (0x1) +__longlong 0x2a || 0x3e8 == 0x1 (0x1) +__ulonglong 0x2a || 0x3e8 == 0x1 (0x1) +int 0x2a & 0x3e8 == 0x28 (0x28) +__uint 0x2a & 0x3e8 == 0x28 (0x28) +char 0x2a & 0xffe8 == 0x28 (0x28) +__uchar 0x2a & 0xe8 == 0x28 (0x28) +__longlong 0x2a & 0x3e8 == 0x28 (0x28) +__ulonglong 0x2a & 0x3e8 == 0x28 (0x28) +int 0x2a | 0x3e8 == 0x3ea (0x3ea) +__uint 0x2a | 0x3e8 == 0x3ea (0x3ea) +char 0x2a | 0xffe8 == -0x16 (0xffea) +__uchar 0x2a | 0xe8 == 0xea (0xea) +__longlong 0x2a | 0x3e8 == 0x3ea (0x3ea) +__ulonglong 0x2a | 0x3e8 == 0x3ea (0x3ea) +int 0x2a << 0x14 == 0x0 (0x0) +__uint 0x2a << 0x14 == 0x0 (0x0) +char 0x2a << 0x14 == 0x0 (0x0) +__uchar 0x2a << 0x14 == 0x0 (0x0) +__longlong 0x2a << 0x14 == 0x0 (0x0) +__ulonglong 0x2a << 0x14 == 0x0 (0x0) +int 0x2a >> 0x14 == 0x0 (0x0) +__uint 0x2a >> 0x14 == 0x0 (0x0) +char 0x2a >> 0x14 == 0x0 (0x0) +__uchar 0x2a >> 0x14 == 0x0 (0x0) +__longlong 0x2a >> 0x14 == 0x0 (0x0) +__ulonglong 0x2a >> 0x14 == 0x0 (0x0) +int 0x2a + 0x3e8 == 0x412 (0x412) +__uint 0x2a + 0x3e8 == 0x412 (0x412) +char 0x2a + 0xffe8 == 0x12 (0x12) +__uchar 0x2a + 0xe8 == 0x12 (0x12) +__longlong 0x2a + 0x3e8 == 0x412 (0x412) +__ulonglong 0x2a + 0x3e8 == 0x412 (0x412) +float 0x2a + 0x3e8 == 0x412 (0x412) +int 0x2a - 0x3e8 == -0x3be (0xfc42) +__uint 0x2a - 0x3e8 == -0x3be (0xfc42) +char 0x2a - 0xffe8 == 0x42 (0x42) +__uchar 0x2a - 0xe8 == 0x42 (0x42) +__longlong 0x2a - 0x3e8 == -0x3be (0xfc42) +__ulonglong 0x2a - 0x3e8 == -0x3be (0xfc42) +float 0x2a - 0x3e8 == -0x3be (0xfc42) +int 0x2a * 0x3e8 == -0x5bf0 (0xa410) +__uint 0x2a * 0x3e8 == -0x5bf0 (0xa410) +char 0x2a * 0xffe8 == 0x10 (0x10) +__uchar 0x2a * 0xe8 == 0x10 (0x10) +__longlong 0x2a * 0x3e8 == -0x5bf0 (0xa410) +__ulonglong 0x2a * 0x3e8 == -0x5bf0 (0xa410) +float 0x2a * 0x3e8 == -0x8000 (0x8000) +int 0x2a < 0x3e8 == 0x1 (0x1) +__uint 0x2a < 0x3e8 == 0x1 (0x1) +char 0x2a < 0xffe8 == 0x0 (0x0) +__uchar 0x2a < 0xe8 == 0x1 (0x1) +__longlong 0x2a < 0x3e8 == 0x1 (0x1) +__ulonglong 0x2a < 0x3e8 == 0x1 (0x1) +float 0x2a < 0x3e8 == 0x1 (0x1) +int 0x2a > 0x3e8 == 0x0 (0x0) +__uint 0x2a > 0x3e8 == 0x0 (0x0) +char 0x2a > 0xffe8 == 0x1 (0x1) +__uchar 0x2a > 0xe8 == 0x0 (0x0) +__longlong 0x2a > 0x3e8 == 0x0 (0x0) +__ulonglong 0x2a > 0x3e8 == 0x0 (0x0) +float 0x2a > 0x3e8 == 0x0 (0x0) +int 0x2a <= 0x3e8 == 0x1 (0x1) +__uint 0x2a <= 0x3e8 == 0x1 (0x1) +char 0x2a <= 0xffe8 == 0x0 (0x0) +__uchar 0x2a <= 0xe8 == 0x1 (0x1) +__longlong 0x2a <= 0x3e8 == 0x1 (0x1) +__ulonglong 0x2a <= 0x3e8 == 0x1 (0x1) +float 0x2a <= 0x3e8 == 0x1 (0x1) +int 0x2a == 0x3e8 == 0x0 (0x0) +__uint 0x2a == 0x3e8 == 0x0 (0x0) +char 0x2a == 0xffe8 == 0x0 (0x0) +__uchar 0x2a == 0xe8 == 0x0 (0x0) +__longlong 0x2a == 0x3e8 == 0x0 (0x0) +__ulonglong 0x2a == 0x3e8 == 0x0 (0x0) +float 0x2a == 0x3e8 == 0x0 (0x0) +int 0x2a != 0x3e8 == 0x1 (0x1) +__uint 0x2a != 0x3e8 == 0x1 (0x1) +char 0x2a != 0xffe8 == 0x1 (0x1) +__uchar 0x2a != 0xe8 == 0x1 (0x1) +__longlong 0x2a != 0x3e8 == 0x1 (0x1) +__ulonglong 0x2a != 0x3e8 == 0x1 (0x1) +float 0x2a != 0x3e8 == 0x1 (0x1) +int 0x2a >= 0x3e8 == 0x0 (0x0) +__uint 0x2a >= 0x3e8 == 0x0 (0x0) +char 0x2a >= 0xffe8 == 0x1 (0x1) +__uchar 0x2a >= 0xe8 == 0x0 (0x0) +__longlong 0x2a >= 0x3e8 == 0x0 (0x0) +__ulonglong 0x2a >= 0x3e8 == 0x0 (0x0) +float 0x2a >= 0x3e8 == 0x0 (0x0) +int 0x2a / 0x3e8 == 0x0 (0x0) +__uint 0x2a / 0x3e8 == 0x0 (0x0) +char 0x2a / 0xffe8 == -0x1 (0xffff) +__uchar 0x2a / 0xe8 == 0x0 (0x0) +__longlong 0x2a / 0x3e8 == 0x0 (0x0) +__ulonglong 0x2a / 0x3e8 == 0x0 (0x0) +float 0x2a / 0x3e8 == 0x0 (0x0) +int 0x2a % 0x3e8 == 0x2a (0x2a) +__uint 0x2a % 0x3e8 == 0x2a (0x2a) +char 0x2a % 0xffe8 == 0x12 (0x12) +__uchar 0x2a % 0xe8 == 0x2a (0x2a) +__longlong 0x2a % 0x3e8 == 0x2a (0x2a) +__ulonglong 0x2a % 0x3e8 == 0x2a (0x2a) +0x2a * 0x2710 == 0x68a0 +0x2a / 0x2710 == 0x0 +0x2a % 0x2710 == 0x2a +int 0x2a ^ 0x2710 == 0x273a (0x273a) +__uint 0x2a ^ 0x2710 == 0x273a (0x273a) +char 0x2a ^ 0x10 == 0x3a (0x3a) +__uchar 0x2a ^ 0x10 == 0x3a (0x3a) +__longlong 0x2a ^ 0x2710 == 0x273a (0x273a) +__ulonglong 0x2a ^ 0x2710 == 0x273a (0x273a) +int 0x2a && 0x2710 == 0x1 (0x1) +__uint 0x2a && 0x2710 == 0x1 (0x1) +char 0x2a && 0x10 == 0x1 (0x1) +__uchar 0x2a && 0x10 == 0x1 (0x1) +__longlong 0x2a && 0x2710 == 0x1 (0x1) +__ulonglong 0x2a && 0x2710 == 0x1 (0x1) +int 0x2a || 0x2710 == 0x1 (0x1) +__uint 0x2a || 0x2710 == 0x1 (0x1) +char 0x2a || 0x10 == 0x1 (0x1) +__uchar 0x2a || 0x10 == 0x1 (0x1) +__longlong 0x2a || 0x2710 == 0x1 (0x1) +__ulonglong 0x2a || 0x2710 == 0x1 (0x1) +int 0x2a & 0x2710 == 0x0 (0x0) +__uint 0x2a & 0x2710 == 0x0 (0x0) +char 0x2a & 0x10 == 0x0 (0x0) +__uchar 0x2a & 0x10 == 0x0 (0x0) +__longlong 0x2a & 0x2710 == 0x0 (0x0) +__ulonglong 0x2a & 0x2710 == 0x0 (0x0) +int 0x2a | 0x2710 == 0x273a (0x273a) +__uint 0x2a | 0x2710 == 0x273a (0x273a) +char 0x2a | 0x10 == 0x3a (0x3a) +__uchar 0x2a | 0x10 == 0x3a (0x3a) +__longlong 0x2a | 0x2710 == 0x273a (0x273a) +__ulonglong 0x2a | 0x2710 == 0x273a (0x273a) +int 0x2a << 0x16 == 0x0 (0x0) +__uint 0x2a << 0x16 == 0x0 (0x0) +char 0x2a << 0x16 == 0x0 (0x0) +__uchar 0x2a << 0x16 == 0x0 (0x0) +__longlong 0x2a << 0x16 == 0x0 (0x0) +__ulonglong 0x2a << 0x16 == 0x0 (0x0) +int 0x2a >> 0x16 == 0x0 (0x0) +__uint 0x2a >> 0x16 == 0x0 (0x0) +char 0x2a >> 0x16 == 0x0 (0x0) +__uchar 0x2a >> 0x16 == 0x0 (0x0) +__longlong 0x2a >> 0x16 == 0x0 (0x0) +__ulonglong 0x2a >> 0x16 == 0x0 (0x0) +int 0x2a + 0x2710 == 0x273a (0x273a) +__uint 0x2a + 0x2710 == 0x273a (0x273a) +char 0x2a + 0x10 == 0x3a (0x3a) +__uchar 0x2a + 0x10 == 0x3a (0x3a) +__longlong 0x2a + 0x2710 == 0x273a (0x273a) +__ulonglong 0x2a + 0x2710 == 0x273a (0x273a) +float 0x2a + 0x2710 == 0x273a (0x273a) +int 0x2a - 0x2710 == -0x26e6 (0xd91a) +__uint 0x2a - 0x2710 == -0x26e6 (0xd91a) +char 0x2a - 0x10 == 0x1a (0x1a) +__uchar 0x2a - 0x10 == 0x1a (0x1a) +__longlong 0x2a - 0x2710 == -0x26e6 (0xd91a) +__ulonglong 0x2a - 0x2710 == -0x26e6 (0xd91a) +float 0x2a - 0x2710 == -0x26e6 (0xd91a) +int 0x2a * 0x2710 == 0x68a0 (0x68a0) +__uint 0x2a * 0x2710 == 0x68a0 (0x68a0) +char 0x2a * 0x10 == -0x60 (0xffa0) +__uchar 0x2a * 0x10 == 0xa0 (0xa0) +__longlong 0x2a * 0x2710 == 0x68a0 (0x68a0) +__ulonglong 0x2a * 0x2710 == 0x68a0 (0x68a0) +float 0x2a * 0x2710 == -0x8000 (0x8000) +int 0x2a < 0x2710 == 0x1 (0x1) +__uint 0x2a < 0x2710 == 0x1 (0x1) +char 0x2a < 0x10 == 0x0 (0x0) +__uchar 0x2a < 0x10 == 0x0 (0x0) +__longlong 0x2a < 0x2710 == 0x1 (0x1) +__ulonglong 0x2a < 0x2710 == 0x1 (0x1) +float 0x2a < 0x2710 == 0x1 (0x1) +int 0x2a > 0x2710 == 0x0 (0x0) +__uint 0x2a > 0x2710 == 0x0 (0x0) +char 0x2a > 0x10 == 0x1 (0x1) +__uchar 0x2a > 0x10 == 0x1 (0x1) +__longlong 0x2a > 0x2710 == 0x0 (0x0) +__ulonglong 0x2a > 0x2710 == 0x0 (0x0) +float 0x2a > 0x2710 == 0x0 (0x0) +int 0x2a <= 0x2710 == 0x1 (0x1) +__uint 0x2a <= 0x2710 == 0x1 (0x1) +char 0x2a <= 0x10 == 0x0 (0x0) +__uchar 0x2a <= 0x10 == 0x0 (0x0) +__longlong 0x2a <= 0x2710 == 0x1 (0x1) +__ulonglong 0x2a <= 0x2710 == 0x1 (0x1) +float 0x2a <= 0x2710 == 0x1 (0x1) +int 0x2a == 0x2710 == 0x0 (0x0) +__uint 0x2a == 0x2710 == 0x0 (0x0) +char 0x2a == 0x10 == 0x0 (0x0) +__uchar 0x2a == 0x10 == 0x0 (0x0) +__longlong 0x2a == 0x2710 == 0x0 (0x0) +__ulonglong 0x2a == 0x2710 == 0x0 (0x0) +float 0x2a == 0x2710 == 0x0 (0x0) +int 0x2a != 0x2710 == 0x1 (0x1) +__uint 0x2a != 0x2710 == 0x1 (0x1) +char 0x2a != 0x10 == 0x1 (0x1) +__uchar 0x2a != 0x10 == 0x1 (0x1) +__longlong 0x2a != 0x2710 == 0x1 (0x1) +__ulonglong 0x2a != 0x2710 == 0x1 (0x1) +float 0x2a != 0x2710 == 0x1 (0x1) +int 0x2a >= 0x2710 == 0x0 (0x0) +__uint 0x2a >= 0x2710 == 0x0 (0x0) +char 0x2a >= 0x10 == 0x1 (0x1) +__uchar 0x2a >= 0x10 == 0x1 (0x1) +__longlong 0x2a >= 0x2710 == 0x0 (0x0) +__ulonglong 0x2a >= 0x2710 == 0x0 (0x0) +float 0x2a >= 0x2710 == 0x0 (0x0) +int 0x2a / 0x2710 == 0x0 (0x0) +__uint 0x2a / 0x2710 == 0x0 (0x0) +char 0x2a / 0x10 == 0x2 (0x2) +__uchar 0x2a / 0x10 == 0x2 (0x2) +__longlong 0x2a / 0x2710 == 0x0 (0x0) +__ulonglong 0x2a / 0x2710 == 0x0 (0x0) +float 0x2a / 0x2710 == 0x0 (0x0) +int 0x2a % 0x2710 == 0x2a (0x2a) +__uint 0x2a % 0x2710 == 0x2a (0x2a) +char 0x2a % 0x10 == 0xa (0xa) +__uchar 0x2a % 0x10 == 0xa (0xa) +__longlong 0x2a % 0x2710 == 0x2a (0x2a) +__ulonglong 0x2a % 0x2710 == 0x2a (0x2a) +int xor420x2a xor42 0x0 +__uint xor420x2a xor42 0x0 +char xor420x2a xor42 0x0 +__uchar xor420x2a xor42 0x0 +__longlong xor420x2a xor42 0x0 +__ulonglong xor420x2a xor42 0x0 +int land10x2a land1 0x1 +__uint land10x2a land1 0x1 +char land10x2a land1 0x1 +__uchar land10x2a land1 0x1 +__longlong land10x2a land1 0x1 +__ulonglong land10x2a land1 0x1 +int lor10x2a lor1 0x1 +__uint lor10x2a lor1 0x1 +char lor10x2a lor1 0x1 +__uchar lor10x2a lor1 0x1 +__longlong lor10x2a lor1 0x1 +__ulonglong lor10x2a lor1 0x1 +int and420x2a and42 0x2a +__uint and420x2a and42 0x2a +char and420x2a and42 0x2a +__uchar and420x2a and42 0x2a +__longlong and420x2a and42 0x2a +__ulonglong and420x2a and42 0x2a +int or420x2a or42 0x2a +__uint or420x2a or42 0x2a +char or420x2a or42 0x2a +__uchar or420x2a or42 0x2a +__longlong or420x2a or42 0x2a +__ulonglong or420x2a or42 0x2a +int shl50x2a shl5 0x540 +__uint shl50x2a shl5 0x540 +char shl50x2a shl5 0x40 +__uchar shl50x2a shl5 0x40 +__longlong shl50x2a shl5 0x540 +__ulonglong shl50x2a shl5 0x540 +int shr50x2a shr5 0x1 +__uint shr50x2a shr5 0x1 +char shr50x2a shr5 0x1 +__uchar shr50x2a shr5 0x1 +__longlong shr50x2a shr5 0x1 +__ulonglong shr50x2a shr5 0x1 +int add420x2a add42 0x54 +__uint add420x2a add42 0x54 +char add420x2a add42 0x54 +__uchar add420x2a add42 0x54 +__longlong add420x2a add42 0x54 +__ulonglong add420x2a add42 0x54 +float add420x2a add42 0x54 +int sub420x2a sub42 0x0 +__uint sub420x2a sub42 0x0 +char sub420x2a sub42 0x0 +__uchar sub420x2a sub42 0x0 +__longlong sub420x2a sub42 0x0 +__ulonglong sub420x2a sub42 0x0 +float sub420x2a sub42 0x0 +int mul420x2a mul42 0x6e4 +__uint mul420x2a mul42 0x6e4 +char mul420x2a mul42 -0x1c +__uchar mul420x2a mul42 0xe4 +__longlong mul420x2a mul42 0x6e4 +__ulonglong mul420x2a mul42 0x6e4 +float mul420x2a mul42 0x6e4 +int lt420x2a lt42 0x0 +__uint lt420x2a lt42 0x0 +char lt420x2a lt42 0x0 +__uchar lt420x2a lt42 0x0 +__longlong lt420x2a lt42 0x0 +__ulonglong lt420x2a lt42 0x0 +float lt420x2a lt42 0x0 +int gt420x2a gt42 0x0 +__uint gt420x2a gt42 0x0 +char gt420x2a gt42 0x0 +__uchar gt420x2a gt42 0x0 +__longlong gt420x2a gt42 0x0 +__ulonglong gt420x2a gt42 0x0 +float gt420x2a gt42 0x0 +int le420x2a le42 0x1 +__uint le420x2a le42 0x1 +char le420x2a le42 0x1 +__uchar le420x2a le42 0x1 +__longlong le420x2a le42 0x1 +__ulonglong le420x2a le42 0x1 +float le420x2a le42 0x1 +int eq420x2a eq42 0x1 +__uint eq420x2a eq42 0x1 +char eq420x2a eq42 0x1 +__uchar eq420x2a eq42 0x1 +__longlong eq420x2a eq42 0x1 +__ulonglong eq420x2a eq42 0x1 +float eq420x2a eq42 0x1 +int ne420x2a ne42 0x0 +__uint ne420x2a ne42 0x0 +char ne420x2a ne42 0x0 +__uchar ne420x2a ne42 0x0 +__longlong ne420x2a ne42 0x0 +__ulonglong ne420x2a ne42 0x0 +float ne420x2a ne42 0x0 +int ge420x2a ge42 0x1 +__uint ge420x2a ge42 0x1 +char ge420x2a ge42 0x1 +__uchar ge420x2a ge42 0x1 +__longlong ge420x2a ge42 0x1 +__ulonglong ge420x2a ge42 0x1 +float ge420x2a ge42 0x1 +int div420x2a div42 0x1 +__uint div420x2a div42 0x1 +char div420x2a div42 0x1 +__uchar div420x2a div42 0x1 +__longlong div420x2a div42 0x1 +__ulonglong div420x2a div42 0x1 +float div420x2a div42 0x1 +int mod230x2a mod23 0x13 +__uint mod230x2a mod23 0x13 +char mod230x2a mod23 0x13 +__uchar mod230x2a mod23 0x13 +__longlong mod230x2a mod23 0x13 +__ulonglong mod230x2a mod23 0x13 +0x17 * 0xffff == -0x17 +0x17 / 0xffff == -0x17 +0x17 % 0xffff == 0x0 +int 0x17 ^ 0xffff == -0x18 (0xffe8) +__uint 0x17 ^ 0xffff == -0x18 (0xffe8) +char 0x17 ^ 0xffff == -0x18 (0xffe8) +__uchar 0x17 ^ 0xff == 0xe8 (0xe8) +__longlong 0x17 ^ 0xffff == -0x18 (0xffe8) +__ulonglong 0x17 ^ 0xffff == -0x18 (0xffe8) +int 0x17 && 0xffff == 0x1 (0x1) +__uint 0x17 && 0xffff == 0x1 (0x1) +char 0x17 && 0xffff == 0x1 (0x1) +__uchar 0x17 && 0xff == 0x1 (0x1) +__longlong 0x17 && 0xffff == 0x1 (0x1) +__ulonglong 0x17 && 0xffff == 0x1 (0x1) +int 0x17 || 0xffff == 0x1 (0x1) +__uint 0x17 || 0xffff == 0x1 (0x1) +char 0x17 || 0xffff == 0x1 (0x1) +__uchar 0x17 || 0xff == 0x1 (0x1) +__longlong 0x17 || 0xffff == 0x1 (0x1) +__ulonglong 0x17 || 0xffff == 0x1 (0x1) +int 0x17 & 0xffff == 0x17 (0x17) +__uint 0x17 & 0xffff == 0x17 (0x17) +char 0x17 & 0xffff == 0x17 (0x17) +__uchar 0x17 & 0xff == 0x17 (0x17) +__longlong 0x17 & 0xffff == 0x17 (0x17) +__ulonglong 0x17 & 0xffff == 0x17 (0x17) +int 0x17 | 0xffff == -0x1 (0xffff) +__uint 0x17 | 0xffff == -0x1 (0xffff) +char 0x17 | 0xffff == -0x1 (0xffff) +__uchar 0x17 | 0xff == 0xff (0xff) +__longlong 0x17 | 0xffff == -0x1 (0xffff) +__ulonglong 0x17 | 0xffff == -0x1 (0xffff) +int 0x17 << 0x1 == 0x2e (0x2e) +__uint 0x17 << 0x1 == 0x2e (0x2e) +char 0x17 << 0x1 == 0x2e (0x2e) +__uchar 0x17 << 0x1 == 0x2e (0x2e) +__longlong 0x17 << 0x1 == 0x2e (0x2e) +__ulonglong 0x17 << 0x1 == 0x2e (0x2e) +int 0x17 >> 0x1 == 0xb (0xb) +__uint 0x17 >> 0x1 == 0xb (0xb) +char 0x17 >> 0x1 == 0xb (0xb) +__uchar 0x17 >> 0x1 == 0xb (0xb) +__longlong 0x17 >> 0x1 == 0xb (0xb) +__ulonglong 0x17 >> 0x1 == 0xb (0xb) +int 0x17 + 0xffff == 0x16 (0x16) +__uint 0x17 + 0xffff == 0x16 (0x16) +char 0x17 + 0xffff == 0x16 (0x16) +__uchar 0x17 + 0xff == 0x16 (0x16) +__longlong 0x17 + 0xffff == 0x16 (0x16) +__ulonglong 0x17 + 0xffff == 0x16 (0x16) +float 0x17 + 0xffff == 0x16 (0x16) +int 0x17 - 0xffff == 0x18 (0x18) +__uint 0x17 - 0xffff == 0x18 (0x18) +char 0x17 - 0xffff == 0x18 (0x18) +__uchar 0x17 - 0xff == 0x18 (0x18) +__longlong 0x17 - 0xffff == 0x18 (0x18) +__ulonglong 0x17 - 0xffff == 0x18 (0x18) +float 0x17 - 0xffff == 0x18 (0x18) +int 0x17 * 0xffff == -0x17 (0xffe9) +__uint 0x17 * 0xffff == -0x17 (0xffe9) +char 0x17 * 0xffff == -0x17 (0xffe9) +__uchar 0x17 * 0xff == 0xe9 (0xe9) +__longlong 0x17 * 0xffff == -0x17 (0xffe9) +__ulonglong 0x17 * 0xffff == -0x17 (0xffe9) +float 0x17 * 0xffff == -0x17 (0xffe9) +int 0x17 < 0xffff == 0x0 (0x0) +__uint 0x17 < 0xffff == 0x1 (0x1) +char 0x17 < 0xffff == 0x0 (0x0) +__uchar 0x17 < 0xff == 0x1 (0x1) +__longlong 0x17 < 0xffff == 0x0 (0x0) +__ulonglong 0x17 < 0xffff == 0x1 (0x1) +float 0x17 < 0xffff == 0x0 (0x0) +int 0x17 > 0xffff == 0x1 (0x1) +__uint 0x17 > 0xffff == 0x0 (0x0) +char 0x17 > 0xffff == 0x1 (0x1) +__uchar 0x17 > 0xff == 0x0 (0x0) +__longlong 0x17 > 0xffff == 0x1 (0x1) +__ulonglong 0x17 > 0xffff == 0x0 (0x0) +float 0x17 > 0xffff == 0x1 (0x1) +int 0x17 <= 0xffff == 0x0 (0x0) +__uint 0x17 <= 0xffff == 0x1 (0x1) +char 0x17 <= 0xffff == 0x0 (0x0) +__uchar 0x17 <= 0xff == 0x1 (0x1) +__longlong 0x17 <= 0xffff == 0x0 (0x0) +__ulonglong 0x17 <= 0xffff == 0x1 (0x1) +float 0x17 <= 0xffff == 0x0 (0x0) +int 0x17 == 0xffff == 0x0 (0x0) +__uint 0x17 == 0xffff == 0x0 (0x0) +char 0x17 == 0xffff == 0x0 (0x0) +__uchar 0x17 == 0xff == 0x0 (0x0) +__longlong 0x17 == 0xffff == 0x0 (0x0) +__ulonglong 0x17 == 0xffff == 0x0 (0x0) +float 0x17 == 0xffff == 0x0 (0x0) +int 0x17 != 0xffff == 0x1 (0x1) +__uint 0x17 != 0xffff == 0x1 (0x1) +char 0x17 != 0xffff == 0x1 (0x1) +__uchar 0x17 != 0xff == 0x1 (0x1) +__longlong 0x17 != 0xffff == 0x1 (0x1) +__ulonglong 0x17 != 0xffff == 0x1 (0x1) +float 0x17 != 0xffff == 0x1 (0x1) +int 0x17 >= 0xffff == 0x1 (0x1) +__uint 0x17 >= 0xffff == 0x0 (0x0) +char 0x17 >= 0xffff == 0x1 (0x1) +__uchar 0x17 >= 0xff == 0x0 (0x0) +__longlong 0x17 >= 0xffff == 0x1 (0x1) +__ulonglong 0x17 >= 0xffff == 0x0 (0x0) +float 0x17 >= 0xffff == 0x1 (0x1) +int 0x17 / 0xffff == -0x17 (0xffe9) +__uint 0x17 / 0xffff == 0x0 (0x0) +char 0x17 / 0xffff == -0x17 (0xffe9) +__uchar 0x17 / 0xff == 0x0 (0x0) +__longlong 0x17 / 0xffff == -0x17 (0xffe9) +__ulonglong 0x17 / 0xffff == 0x0 (0x0) +float 0x17 / 0xffff == -0x17 (0xffe9) +int 0x17 % 0xffff == 0x0 (0x0) +__uint 0x17 % 0xffff == 0x17 (0x17) +char 0x17 % 0xffff == 0x0 (0x0) +__uchar 0x17 % 0xff == 0x17 (0x17) +__longlong 0x17 % 0xffff == 0x0 (0x0) +__ulonglong 0x17 % 0xffff == 0x17 (0x17) +0x17 * 0x1 == 0x17 +0x17 / 0x1 == 0x17 +0x17 % 0x1 == 0x0 +int 0x17 ^ 0x1 == 0x16 (0x16) +__uint 0x17 ^ 0x1 == 0x16 (0x16) +char 0x17 ^ 0x1 == 0x16 (0x16) +__uchar 0x17 ^ 0x1 == 0x16 (0x16) +__longlong 0x17 ^ 0x1 == 0x16 (0x16) +__ulonglong 0x17 ^ 0x1 == 0x16 (0x16) +int 0x17 && 0x1 == 0x1 (0x1) +__uint 0x17 && 0x1 == 0x1 (0x1) +char 0x17 && 0x1 == 0x1 (0x1) +__uchar 0x17 && 0x1 == 0x1 (0x1) +__longlong 0x17 && 0x1 == 0x1 (0x1) +__ulonglong 0x17 && 0x1 == 0x1 (0x1) +int 0x17 || 0x1 == 0x1 (0x1) +__uint 0x17 || 0x1 == 0x1 (0x1) +char 0x17 || 0x1 == 0x1 (0x1) +__uchar 0x17 || 0x1 == 0x1 (0x1) +__longlong 0x17 || 0x1 == 0x1 (0x1) +__ulonglong 0x17 || 0x1 == 0x1 (0x1) +int 0x17 & 0x1 == 0x1 (0x1) +__uint 0x17 & 0x1 == 0x1 (0x1) +char 0x17 & 0x1 == 0x1 (0x1) +__uchar 0x17 & 0x1 == 0x1 (0x1) +__longlong 0x17 & 0x1 == 0x1 (0x1) +__ulonglong 0x17 & 0x1 == 0x1 (0x1) +int 0x17 | 0x1 == 0x17 (0x17) +__uint 0x17 | 0x1 == 0x17 (0x17) +char 0x17 | 0x1 == 0x17 (0x17) +__uchar 0x17 | 0x1 == 0x17 (0x17) +__longlong 0x17 | 0x1 == 0x17 (0x17) +__ulonglong 0x17 | 0x1 == 0x17 (0x17) +int 0x17 << 0x2 == 0x5c (0x5c) +__uint 0x17 << 0x2 == 0x5c (0x5c) +char 0x17 << 0x2 == 0x5c (0x5c) +__uchar 0x17 << 0x2 == 0x5c (0x5c) +__longlong 0x17 << 0x2 == 0x5c (0x5c) +__ulonglong 0x17 << 0x2 == 0x5c (0x5c) +int 0x17 >> 0x2 == 0x5 (0x5) +__uint 0x17 >> 0x2 == 0x5 (0x5) +char 0x17 >> 0x2 == 0x5 (0x5) +__uchar 0x17 >> 0x2 == 0x5 (0x5) +__longlong 0x17 >> 0x2 == 0x5 (0x5) +__ulonglong 0x17 >> 0x2 == 0x5 (0x5) +int 0x17 + 0x1 == 0x18 (0x18) +__uint 0x17 + 0x1 == 0x18 (0x18) +char 0x17 + 0x1 == 0x18 (0x18) +__uchar 0x17 + 0x1 == 0x18 (0x18) +__longlong 0x17 + 0x1 == 0x18 (0x18) +__ulonglong 0x17 + 0x1 == 0x18 (0x18) +float 0x17 + 0x1 == 0x18 (0x18) +int 0x17 - 0x1 == 0x16 (0x16) +__uint 0x17 - 0x1 == 0x16 (0x16) +char 0x17 - 0x1 == 0x16 (0x16) +__uchar 0x17 - 0x1 == 0x16 (0x16) +__longlong 0x17 - 0x1 == 0x16 (0x16) +__ulonglong 0x17 - 0x1 == 0x16 (0x16) +float 0x17 - 0x1 == 0x16 (0x16) +int 0x17 * 0x1 == 0x17 (0x17) +__uint 0x17 * 0x1 == 0x17 (0x17) +char 0x17 * 0x1 == 0x17 (0x17) +__uchar 0x17 * 0x1 == 0x17 (0x17) +__longlong 0x17 * 0x1 == 0x17 (0x17) +__ulonglong 0x17 * 0x1 == 0x17 (0x17) +float 0x17 * 0x1 == 0x17 (0x17) +int 0x17 < 0x1 == 0x0 (0x0) +__uint 0x17 < 0x1 == 0x0 (0x0) +char 0x17 < 0x1 == 0x0 (0x0) +__uchar 0x17 < 0x1 == 0x0 (0x0) +__longlong 0x17 < 0x1 == 0x0 (0x0) +__ulonglong 0x17 < 0x1 == 0x0 (0x0) +float 0x17 < 0x1 == 0x0 (0x0) +int 0x17 > 0x1 == 0x1 (0x1) +__uint 0x17 > 0x1 == 0x1 (0x1) +char 0x17 > 0x1 == 0x1 (0x1) +__uchar 0x17 > 0x1 == 0x1 (0x1) +__longlong 0x17 > 0x1 == 0x1 (0x1) +__ulonglong 0x17 > 0x1 == 0x1 (0x1) +float 0x17 > 0x1 == 0x1 (0x1) +int 0x17 <= 0x1 == 0x0 (0x0) +__uint 0x17 <= 0x1 == 0x0 (0x0) +char 0x17 <= 0x1 == 0x0 (0x0) +__uchar 0x17 <= 0x1 == 0x0 (0x0) +__longlong 0x17 <= 0x1 == 0x0 (0x0) +__ulonglong 0x17 <= 0x1 == 0x0 (0x0) +float 0x17 <= 0x1 == 0x0 (0x0) +int 0x17 == 0x1 == 0x0 (0x0) +__uint 0x17 == 0x1 == 0x0 (0x0) +char 0x17 == 0x1 == 0x0 (0x0) +__uchar 0x17 == 0x1 == 0x0 (0x0) +__longlong 0x17 == 0x1 == 0x0 (0x0) +__ulonglong 0x17 == 0x1 == 0x0 (0x0) +float 0x17 == 0x1 == 0x0 (0x0) +int 0x17 != 0x1 == 0x1 (0x1) +__uint 0x17 != 0x1 == 0x1 (0x1) +char 0x17 != 0x1 == 0x1 (0x1) +__uchar 0x17 != 0x1 == 0x1 (0x1) +__longlong 0x17 != 0x1 == 0x1 (0x1) +__ulonglong 0x17 != 0x1 == 0x1 (0x1) +float 0x17 != 0x1 == 0x1 (0x1) +int 0x17 >= 0x1 == 0x1 (0x1) +__uint 0x17 >= 0x1 == 0x1 (0x1) +char 0x17 >= 0x1 == 0x1 (0x1) +__uchar 0x17 >= 0x1 == 0x1 (0x1) +__longlong 0x17 >= 0x1 == 0x1 (0x1) +__ulonglong 0x17 >= 0x1 == 0x1 (0x1) +float 0x17 >= 0x1 == 0x1 (0x1) +int 0x17 / 0x1 == 0x17 (0x17) +__uint 0x17 / 0x1 == 0x17 (0x17) +char 0x17 / 0x1 == 0x17 (0x17) +__uchar 0x17 / 0x1 == 0x17 (0x17) +__longlong 0x17 / 0x1 == 0x17 (0x17) +__ulonglong 0x17 / 0x1 == 0x17 (0x17) +float 0x17 / 0x1 == 0x17 (0x17) +int 0x17 % 0x1 == 0x0 (0x0) +__uint 0x17 % 0x1 == 0x0 (0x0) +char 0x17 % 0x1 == 0x0 (0x0) +__uchar 0x17 % 0x1 == 0x0 (0x0) +__longlong 0x17 % 0x1 == 0x0 (0x0) +__ulonglong 0x17 % 0x1 == 0x0 (0x0) +0x17 * 0x2 == 0x2e +0x17 / 0x2 == 0xb +0x17 % 0x2 == 0x1 +int 0x17 ^ 0x2 == 0x15 (0x15) +__uint 0x17 ^ 0x2 == 0x15 (0x15) +char 0x17 ^ 0x2 == 0x15 (0x15) +__uchar 0x17 ^ 0x2 == 0x15 (0x15) +__longlong 0x17 ^ 0x2 == 0x15 (0x15) +__ulonglong 0x17 ^ 0x2 == 0x15 (0x15) +int 0x17 && 0x2 == 0x1 (0x1) +__uint 0x17 && 0x2 == 0x1 (0x1) +char 0x17 && 0x2 == 0x1 (0x1) +__uchar 0x17 && 0x2 == 0x1 (0x1) +__longlong 0x17 && 0x2 == 0x1 (0x1) +__ulonglong 0x17 && 0x2 == 0x1 (0x1) +int 0x17 || 0x2 == 0x1 (0x1) +__uint 0x17 || 0x2 == 0x1 (0x1) +char 0x17 || 0x2 == 0x1 (0x1) +__uchar 0x17 || 0x2 == 0x1 (0x1) +__longlong 0x17 || 0x2 == 0x1 (0x1) +__ulonglong 0x17 || 0x2 == 0x1 (0x1) +int 0x17 & 0x2 == 0x2 (0x2) +__uint 0x17 & 0x2 == 0x2 (0x2) +char 0x17 & 0x2 == 0x2 (0x2) +__uchar 0x17 & 0x2 == 0x2 (0x2) +__longlong 0x17 & 0x2 == 0x2 (0x2) +__ulonglong 0x17 & 0x2 == 0x2 (0x2) +int 0x17 | 0x2 == 0x17 (0x17) +__uint 0x17 | 0x2 == 0x17 (0x17) +char 0x17 | 0x2 == 0x17 (0x17) +__uchar 0x17 | 0x2 == 0x17 (0x17) +__longlong 0x17 | 0x2 == 0x17 (0x17) +__ulonglong 0x17 | 0x2 == 0x17 (0x17) +int 0x17 << 0x3 == 0xb8 (0xb8) +__uint 0x17 << 0x3 == 0xb8 (0xb8) +char 0x17 << 0x3 == -0x48 (0xffb8) +__uchar 0x17 << 0x3 == 0xb8 (0xb8) +__longlong 0x17 << 0x3 == 0xb8 (0xb8) +__ulonglong 0x17 << 0x3 == 0xb8 (0xb8) +int 0x17 >> 0x3 == 0x2 (0x2) +__uint 0x17 >> 0x3 == 0x2 (0x2) +char 0x17 >> 0x3 == 0x2 (0x2) +__uchar 0x17 >> 0x3 == 0x2 (0x2) +__longlong 0x17 >> 0x3 == 0x2 (0x2) +__ulonglong 0x17 >> 0x3 == 0x2 (0x2) +int 0x17 + 0x2 == 0x19 (0x19) +__uint 0x17 + 0x2 == 0x19 (0x19) +char 0x17 + 0x2 == 0x19 (0x19) +__uchar 0x17 + 0x2 == 0x19 (0x19) +__longlong 0x17 + 0x2 == 0x19 (0x19) +__ulonglong 0x17 + 0x2 == 0x19 (0x19) +float 0x17 + 0x2 == 0x19 (0x19) +int 0x17 - 0x2 == 0x15 (0x15) +__uint 0x17 - 0x2 == 0x15 (0x15) +char 0x17 - 0x2 == 0x15 (0x15) +__uchar 0x17 - 0x2 == 0x15 (0x15) +__longlong 0x17 - 0x2 == 0x15 (0x15) +__ulonglong 0x17 - 0x2 == 0x15 (0x15) +float 0x17 - 0x2 == 0x15 (0x15) +int 0x17 * 0x2 == 0x2e (0x2e) +__uint 0x17 * 0x2 == 0x2e (0x2e) +char 0x17 * 0x2 == 0x2e (0x2e) +__uchar 0x17 * 0x2 == 0x2e (0x2e) +__longlong 0x17 * 0x2 == 0x2e (0x2e) +__ulonglong 0x17 * 0x2 == 0x2e (0x2e) +float 0x17 * 0x2 == 0x2e (0x2e) +int 0x17 < 0x2 == 0x0 (0x0) +__uint 0x17 < 0x2 == 0x0 (0x0) +char 0x17 < 0x2 == 0x0 (0x0) +__uchar 0x17 < 0x2 == 0x0 (0x0) +__longlong 0x17 < 0x2 == 0x0 (0x0) +__ulonglong 0x17 < 0x2 == 0x0 (0x0) +float 0x17 < 0x2 == 0x0 (0x0) +int 0x17 > 0x2 == 0x1 (0x1) +__uint 0x17 > 0x2 == 0x1 (0x1) +char 0x17 > 0x2 == 0x1 (0x1) +__uchar 0x17 > 0x2 == 0x1 (0x1) +__longlong 0x17 > 0x2 == 0x1 (0x1) +__ulonglong 0x17 > 0x2 == 0x1 (0x1) +float 0x17 > 0x2 == 0x1 (0x1) +int 0x17 <= 0x2 == 0x0 (0x0) +__uint 0x17 <= 0x2 == 0x0 (0x0) +char 0x17 <= 0x2 == 0x0 (0x0) +__uchar 0x17 <= 0x2 == 0x0 (0x0) +__longlong 0x17 <= 0x2 == 0x0 (0x0) +__ulonglong 0x17 <= 0x2 == 0x0 (0x0) +float 0x17 <= 0x2 == 0x0 (0x0) +int 0x17 == 0x2 == 0x0 (0x0) +__uint 0x17 == 0x2 == 0x0 (0x0) +char 0x17 == 0x2 == 0x0 (0x0) +__uchar 0x17 == 0x2 == 0x0 (0x0) +__longlong 0x17 == 0x2 == 0x0 (0x0) +__ulonglong 0x17 == 0x2 == 0x0 (0x0) +float 0x17 == 0x2 == 0x0 (0x0) +int 0x17 != 0x2 == 0x1 (0x1) +__uint 0x17 != 0x2 == 0x1 (0x1) +char 0x17 != 0x2 == 0x1 (0x1) +__uchar 0x17 != 0x2 == 0x1 (0x1) +__longlong 0x17 != 0x2 == 0x1 (0x1) +__ulonglong 0x17 != 0x2 == 0x1 (0x1) +float 0x17 != 0x2 == 0x1 (0x1) +int 0x17 >= 0x2 == 0x1 (0x1) +__uint 0x17 >= 0x2 == 0x1 (0x1) +char 0x17 >= 0x2 == 0x1 (0x1) +__uchar 0x17 >= 0x2 == 0x1 (0x1) +__longlong 0x17 >= 0x2 == 0x1 (0x1) +__ulonglong 0x17 >= 0x2 == 0x1 (0x1) +float 0x17 >= 0x2 == 0x1 (0x1) +int 0x17 / 0x2 == 0xb (0xb) +__uint 0x17 / 0x2 == 0xb (0xb) +char 0x17 / 0x2 == 0xb (0xb) +__uchar 0x17 / 0x2 == 0xb (0xb) +__longlong 0x17 / 0x2 == 0xb (0xb) +__ulonglong 0x17 / 0x2 == 0xb (0xb) +float 0x17 / 0x2 == 0xb (0xb) +int 0x17 % 0x2 == 0x1 (0x1) +__uint 0x17 % 0x2 == 0x1 (0x1) +char 0x17 % 0x2 == 0x1 (0x1) +__uchar 0x17 % 0x2 == 0x1 (0x1) +__longlong 0x17 % 0x2 == 0x1 (0x1) +__ulonglong 0x17 % 0x2 == 0x1 (0x1) +0x17 * 0xfffe == -0x2e +0x17 / 0xfffe == -0xb +0x17 % 0xfffe == 0x1 +int 0x17 ^ 0xfffe == -0x17 (0xffe9) +__uint 0x17 ^ 0xfffe == -0x17 (0xffe9) +char 0x17 ^ 0xfffe == -0x17 (0xffe9) +__uchar 0x17 ^ 0xfe == 0xe9 (0xe9) +__longlong 0x17 ^ 0xfffe == -0x17 (0xffe9) +__ulonglong 0x17 ^ 0xfffe == -0x17 (0xffe9) +int 0x17 && 0xfffe == 0x1 (0x1) +__uint 0x17 && 0xfffe == 0x1 (0x1) +char 0x17 && 0xfffe == 0x1 (0x1) +__uchar 0x17 && 0xfe == 0x1 (0x1) +__longlong 0x17 && 0xfffe == 0x1 (0x1) +__ulonglong 0x17 && 0xfffe == 0x1 (0x1) +int 0x17 || 0xfffe == 0x1 (0x1) +__uint 0x17 || 0xfffe == 0x1 (0x1) +char 0x17 || 0xfffe == 0x1 (0x1) +__uchar 0x17 || 0xfe == 0x1 (0x1) +__longlong 0x17 || 0xfffe == 0x1 (0x1) +__ulonglong 0x17 || 0xfffe == 0x1 (0x1) +int 0x17 & 0xfffe == 0x16 (0x16) +__uint 0x17 & 0xfffe == 0x16 (0x16) +char 0x17 & 0xfffe == 0x16 (0x16) +__uchar 0x17 & 0xfe == 0x16 (0x16) +__longlong 0x17 & 0xfffe == 0x16 (0x16) +__ulonglong 0x17 & 0xfffe == 0x16 (0x16) +int 0x17 | 0xfffe == -0x1 (0xffff) +__uint 0x17 | 0xfffe == -0x1 (0xffff) +char 0x17 | 0xfffe == -0x1 (0xffff) +__uchar 0x17 | 0xfe == 0xff (0xff) +__longlong 0x17 | 0xfffe == -0x1 (0xffff) +__ulonglong 0x17 | 0xfffe == -0x1 (0xffff) +int 0x17 << 0x4 == 0x170 (0x170) +__uint 0x17 << 0x4 == 0x170 (0x170) +char 0x17 << 0x4 == 0x70 (0x70) +__uchar 0x17 << 0x4 == 0x70 (0x70) +__longlong 0x17 << 0x4 == 0x170 (0x170) +__ulonglong 0x17 << 0x4 == 0x170 (0x170) +int 0x17 >> 0x4 == 0x1 (0x1) +__uint 0x17 >> 0x4 == 0x1 (0x1) +char 0x17 >> 0x4 == 0x1 (0x1) +__uchar 0x17 >> 0x4 == 0x1 (0x1) +__longlong 0x17 >> 0x4 == 0x1 (0x1) +__ulonglong 0x17 >> 0x4 == 0x1 (0x1) +int 0x17 + 0xfffe == 0x15 (0x15) +__uint 0x17 + 0xfffe == 0x15 (0x15) +char 0x17 + 0xfffe == 0x15 (0x15) +__uchar 0x17 + 0xfe == 0x15 (0x15) +__longlong 0x17 + 0xfffe == 0x15 (0x15) +__ulonglong 0x17 + 0xfffe == 0x15 (0x15) +float 0x17 + 0xfffe == 0x15 (0x15) +int 0x17 - 0xfffe == 0x19 (0x19) +__uint 0x17 - 0xfffe == 0x19 (0x19) +char 0x17 - 0xfffe == 0x19 (0x19) +__uchar 0x17 - 0xfe == 0x19 (0x19) +__longlong 0x17 - 0xfffe == 0x19 (0x19) +__ulonglong 0x17 - 0xfffe == 0x19 (0x19) +float 0x17 - 0xfffe == 0x19 (0x19) +int 0x17 * 0xfffe == -0x2e (0xffd2) +__uint 0x17 * 0xfffe == -0x2e (0xffd2) +char 0x17 * 0xfffe == -0x2e (0xffd2) +__uchar 0x17 * 0xfe == 0xd2 (0xd2) +__longlong 0x17 * 0xfffe == -0x2e (0xffd2) +__ulonglong 0x17 * 0xfffe == -0x2e (0xffd2) +float 0x17 * 0xfffe == -0x2e (0xffd2) +int 0x17 < 0xfffe == 0x0 (0x0) +__uint 0x17 < 0xfffe == 0x1 (0x1) +char 0x17 < 0xfffe == 0x0 (0x0) +__uchar 0x17 < 0xfe == 0x1 (0x1) +__longlong 0x17 < 0xfffe == 0x0 (0x0) +__ulonglong 0x17 < 0xfffe == 0x1 (0x1) +float 0x17 < 0xfffe == 0x0 (0x0) +int 0x17 > 0xfffe == 0x1 (0x1) +__uint 0x17 > 0xfffe == 0x0 (0x0) +char 0x17 > 0xfffe == 0x1 (0x1) +__uchar 0x17 > 0xfe == 0x0 (0x0) +__longlong 0x17 > 0xfffe == 0x1 (0x1) +__ulonglong 0x17 > 0xfffe == 0x0 (0x0) +float 0x17 > 0xfffe == 0x1 (0x1) +int 0x17 <= 0xfffe == 0x0 (0x0) +__uint 0x17 <= 0xfffe == 0x1 (0x1) +char 0x17 <= 0xfffe == 0x0 (0x0) +__uchar 0x17 <= 0xfe == 0x1 (0x1) +__longlong 0x17 <= 0xfffe == 0x0 (0x0) +__ulonglong 0x17 <= 0xfffe == 0x1 (0x1) +float 0x17 <= 0xfffe == 0x0 (0x0) +int 0x17 == 0xfffe == 0x0 (0x0) +__uint 0x17 == 0xfffe == 0x0 (0x0) +char 0x17 == 0xfffe == 0x0 (0x0) +__uchar 0x17 == 0xfe == 0x0 (0x0) +__longlong 0x17 == 0xfffe == 0x0 (0x0) +__ulonglong 0x17 == 0xfffe == 0x0 (0x0) +float 0x17 == 0xfffe == 0x0 (0x0) +int 0x17 != 0xfffe == 0x1 (0x1) +__uint 0x17 != 0xfffe == 0x1 (0x1) +char 0x17 != 0xfffe == 0x1 (0x1) +__uchar 0x17 != 0xfe == 0x1 (0x1) +__longlong 0x17 != 0xfffe == 0x1 (0x1) +__ulonglong 0x17 != 0xfffe == 0x1 (0x1) +float 0x17 != 0xfffe == 0x1 (0x1) +int 0x17 >= 0xfffe == 0x1 (0x1) +__uint 0x17 >= 0xfffe == 0x0 (0x0) +char 0x17 >= 0xfffe == 0x1 (0x1) +__uchar 0x17 >= 0xfe == 0x0 (0x0) +__longlong 0x17 >= 0xfffe == 0x1 (0x1) +__ulonglong 0x17 >= 0xfffe == 0x0 (0x0) +float 0x17 >= 0xfffe == 0x1 (0x1) +int 0x17 / 0xfffe == -0xb (0xfff5) +__uint 0x17 / 0xfffe == 0x0 (0x0) +char 0x17 / 0xfffe == -0xb (0xfff5) +__uchar 0x17 / 0xfe == 0x0 (0x0) +__longlong 0x17 / 0xfffe == -0xb (0xfff5) +__ulonglong 0x17 / 0xfffe == 0x0 (0x0) +float 0x17 / 0xfffe == -0xb (0xfff5) +int 0x17 % 0xfffe == 0x1 (0x1) +__uint 0x17 % 0xfffe == 0x17 (0x17) +char 0x17 % 0xfffe == 0x1 (0x1) +__uchar 0x17 % 0xfe == 0x17 (0x17) +__longlong 0x17 % 0xfffe == 0x1 (0x1) +__ulonglong 0x17 % 0xfffe == 0x17 (0x17) +0x17 * 0x4 == 0x5c +0x17 / 0x4 == 0x5 +0x17 % 0x4 == 0x3 +int 0x17 ^ 0x4 == 0x13 (0x13) +__uint 0x17 ^ 0x4 == 0x13 (0x13) +char 0x17 ^ 0x4 == 0x13 (0x13) +__uchar 0x17 ^ 0x4 == 0x13 (0x13) +__longlong 0x17 ^ 0x4 == 0x13 (0x13) +__ulonglong 0x17 ^ 0x4 == 0x13 (0x13) +int 0x17 && 0x4 == 0x1 (0x1) +__uint 0x17 && 0x4 == 0x1 (0x1) +char 0x17 && 0x4 == 0x1 (0x1) +__uchar 0x17 && 0x4 == 0x1 (0x1) +__longlong 0x17 && 0x4 == 0x1 (0x1) +__ulonglong 0x17 && 0x4 == 0x1 (0x1) +int 0x17 || 0x4 == 0x1 (0x1) +__uint 0x17 || 0x4 == 0x1 (0x1) +char 0x17 || 0x4 == 0x1 (0x1) +__uchar 0x17 || 0x4 == 0x1 (0x1) +__longlong 0x17 || 0x4 == 0x1 (0x1) +__ulonglong 0x17 || 0x4 == 0x1 (0x1) +int 0x17 & 0x4 == 0x4 (0x4) +__uint 0x17 & 0x4 == 0x4 (0x4) +char 0x17 & 0x4 == 0x4 (0x4) +__uchar 0x17 & 0x4 == 0x4 (0x4) +__longlong 0x17 & 0x4 == 0x4 (0x4) +__ulonglong 0x17 & 0x4 == 0x4 (0x4) +int 0x17 | 0x4 == 0x17 (0x17) +__uint 0x17 | 0x4 == 0x17 (0x17) +char 0x17 | 0x4 == 0x17 (0x17) +__uchar 0x17 | 0x4 == 0x17 (0x17) +__longlong 0x17 | 0x4 == 0x17 (0x17) +__ulonglong 0x17 | 0x4 == 0x17 (0x17) +int 0x17 << 0x5 == 0x2e0 (0x2e0) +__uint 0x17 << 0x5 == 0x2e0 (0x2e0) +char 0x17 << 0x5 == -0x20 (0xffe0) +__uchar 0x17 << 0x5 == 0xe0 (0xe0) +__longlong 0x17 << 0x5 == 0x2e0 (0x2e0) +__ulonglong 0x17 << 0x5 == 0x2e0 (0x2e0) +int 0x17 >> 0x5 == 0x0 (0x0) +__uint 0x17 >> 0x5 == 0x0 (0x0) +char 0x17 >> 0x5 == 0x0 (0x0) +__uchar 0x17 >> 0x5 == 0x0 (0x0) +__longlong 0x17 >> 0x5 == 0x0 (0x0) +__ulonglong 0x17 >> 0x5 == 0x0 (0x0) +int 0x17 + 0x4 == 0x1b (0x1b) +__uint 0x17 + 0x4 == 0x1b (0x1b) +char 0x17 + 0x4 == 0x1b (0x1b) +__uchar 0x17 + 0x4 == 0x1b (0x1b) +__longlong 0x17 + 0x4 == 0x1b (0x1b) +__ulonglong 0x17 + 0x4 == 0x1b (0x1b) +float 0x17 + 0x4 == 0x1b (0x1b) +int 0x17 - 0x4 == 0x13 (0x13) +__uint 0x17 - 0x4 == 0x13 (0x13) +char 0x17 - 0x4 == 0x13 (0x13) +__uchar 0x17 - 0x4 == 0x13 (0x13) +__longlong 0x17 - 0x4 == 0x13 (0x13) +__ulonglong 0x17 - 0x4 == 0x13 (0x13) +float 0x17 - 0x4 == 0x13 (0x13) +int 0x17 * 0x4 == 0x5c (0x5c) +__uint 0x17 * 0x4 == 0x5c (0x5c) +char 0x17 * 0x4 == 0x5c (0x5c) +__uchar 0x17 * 0x4 == 0x5c (0x5c) +__longlong 0x17 * 0x4 == 0x5c (0x5c) +__ulonglong 0x17 * 0x4 == 0x5c (0x5c) +float 0x17 * 0x4 == 0x5c (0x5c) +int 0x17 < 0x4 == 0x0 (0x0) +__uint 0x17 < 0x4 == 0x0 (0x0) +char 0x17 < 0x4 == 0x0 (0x0) +__uchar 0x17 < 0x4 == 0x0 (0x0) +__longlong 0x17 < 0x4 == 0x0 (0x0) +__ulonglong 0x17 < 0x4 == 0x0 (0x0) +float 0x17 < 0x4 == 0x0 (0x0) +int 0x17 > 0x4 == 0x1 (0x1) +__uint 0x17 > 0x4 == 0x1 (0x1) +char 0x17 > 0x4 == 0x1 (0x1) +__uchar 0x17 > 0x4 == 0x1 (0x1) +__longlong 0x17 > 0x4 == 0x1 (0x1) +__ulonglong 0x17 > 0x4 == 0x1 (0x1) +float 0x17 > 0x4 == 0x1 (0x1) +int 0x17 <= 0x4 == 0x0 (0x0) +__uint 0x17 <= 0x4 == 0x0 (0x0) +char 0x17 <= 0x4 == 0x0 (0x0) +__uchar 0x17 <= 0x4 == 0x0 (0x0) +__longlong 0x17 <= 0x4 == 0x0 (0x0) +__ulonglong 0x17 <= 0x4 == 0x0 (0x0) +float 0x17 <= 0x4 == 0x0 (0x0) +int 0x17 == 0x4 == 0x0 (0x0) +__uint 0x17 == 0x4 == 0x0 (0x0) +char 0x17 == 0x4 == 0x0 (0x0) +__uchar 0x17 == 0x4 == 0x0 (0x0) +__longlong 0x17 == 0x4 == 0x0 (0x0) +__ulonglong 0x17 == 0x4 == 0x0 (0x0) +float 0x17 == 0x4 == 0x0 (0x0) +int 0x17 != 0x4 == 0x1 (0x1) +__uint 0x17 != 0x4 == 0x1 (0x1) +char 0x17 != 0x4 == 0x1 (0x1) +__uchar 0x17 != 0x4 == 0x1 (0x1) +__longlong 0x17 != 0x4 == 0x1 (0x1) +__ulonglong 0x17 != 0x4 == 0x1 (0x1) +float 0x17 != 0x4 == 0x1 (0x1) +int 0x17 >= 0x4 == 0x1 (0x1) +__uint 0x17 >= 0x4 == 0x1 (0x1) +char 0x17 >= 0x4 == 0x1 (0x1) +__uchar 0x17 >= 0x4 == 0x1 (0x1) +__longlong 0x17 >= 0x4 == 0x1 (0x1) +__ulonglong 0x17 >= 0x4 == 0x1 (0x1) +float 0x17 >= 0x4 == 0x1 (0x1) +int 0x17 / 0x4 == 0x5 (0x5) +__uint 0x17 / 0x4 == 0x5 (0x5) +char 0x17 / 0x4 == 0x5 (0x5) +__uchar 0x17 / 0x4 == 0x5 (0x5) +__longlong 0x17 / 0x4 == 0x5 (0x5) +__ulonglong 0x17 / 0x4 == 0x5 (0x5) +float 0x17 / 0x4 == 0x5 (0x5) +int 0x17 % 0x4 == 0x3 (0x3) +__uint 0x17 % 0x4 == 0x3 (0x3) +char 0x17 % 0x4 == 0x3 (0x3) +__uchar 0x17 % 0x4 == 0x3 (0x3) +__longlong 0x17 % 0x4 == 0x3 (0x3) +__ulonglong 0x17 % 0x4 == 0x3 (0x3) +0x17 * 0xfffc == -0x5c +0x17 / 0xfffc == -0x5 +0x17 % 0xfffc == 0x3 +int 0x17 ^ 0xfffc == -0x15 (0xffeb) +__uint 0x17 ^ 0xfffc == -0x15 (0xffeb) +char 0x17 ^ 0xfffc == -0x15 (0xffeb) +__uchar 0x17 ^ 0xfc == 0xeb (0xeb) +__longlong 0x17 ^ 0xfffc == -0x15 (0xffeb) +__ulonglong 0x17 ^ 0xfffc == -0x15 (0xffeb) +int 0x17 && 0xfffc == 0x1 (0x1) +__uint 0x17 && 0xfffc == 0x1 (0x1) +char 0x17 && 0xfffc == 0x1 (0x1) +__uchar 0x17 && 0xfc == 0x1 (0x1) +__longlong 0x17 && 0xfffc == 0x1 (0x1) +__ulonglong 0x17 && 0xfffc == 0x1 (0x1) +int 0x17 || 0xfffc == 0x1 (0x1) +__uint 0x17 || 0xfffc == 0x1 (0x1) +char 0x17 || 0xfffc == 0x1 (0x1) +__uchar 0x17 || 0xfc == 0x1 (0x1) +__longlong 0x17 || 0xfffc == 0x1 (0x1) +__ulonglong 0x17 || 0xfffc == 0x1 (0x1) +int 0x17 & 0xfffc == 0x14 (0x14) +__uint 0x17 & 0xfffc == 0x14 (0x14) +char 0x17 & 0xfffc == 0x14 (0x14) +__uchar 0x17 & 0xfc == 0x14 (0x14) +__longlong 0x17 & 0xfffc == 0x14 (0x14) +__ulonglong 0x17 & 0xfffc == 0x14 (0x14) +int 0x17 | 0xfffc == -0x1 (0xffff) +__uint 0x17 | 0xfffc == -0x1 (0xffff) +char 0x17 | 0xfffc == -0x1 (0xffff) +__uchar 0x17 | 0xfc == 0xff (0xff) +__longlong 0x17 | 0xfffc == -0x1 (0xffff) +__ulonglong 0x17 | 0xfffc == -0x1 (0xffff) +int 0x17 << 0x6 == 0x5c0 (0x5c0) +__uint 0x17 << 0x6 == 0x5c0 (0x5c0) +char 0x17 << 0x6 == -0x40 (0xffc0) +__uchar 0x17 << 0x6 == 0xc0 (0xc0) +__longlong 0x17 << 0x6 == 0x5c0 (0x5c0) +__ulonglong 0x17 << 0x6 == 0x5c0 (0x5c0) +int 0x17 >> 0x6 == 0x0 (0x0) +__uint 0x17 >> 0x6 == 0x0 (0x0) +char 0x17 >> 0x6 == 0x0 (0x0) +__uchar 0x17 >> 0x6 == 0x0 (0x0) +__longlong 0x17 >> 0x6 == 0x0 (0x0) +__ulonglong 0x17 >> 0x6 == 0x0 (0x0) +int 0x17 + 0xfffc == 0x13 (0x13) +__uint 0x17 + 0xfffc == 0x13 (0x13) +char 0x17 + 0xfffc == 0x13 (0x13) +__uchar 0x17 + 0xfc == 0x13 (0x13) +__longlong 0x17 + 0xfffc == 0x13 (0x13) +__ulonglong 0x17 + 0xfffc == 0x13 (0x13) +float 0x17 + 0xfffc == 0x13 (0x13) +int 0x17 - 0xfffc == 0x1b (0x1b) +__uint 0x17 - 0xfffc == 0x1b (0x1b) +char 0x17 - 0xfffc == 0x1b (0x1b) +__uchar 0x17 - 0xfc == 0x1b (0x1b) +__longlong 0x17 - 0xfffc == 0x1b (0x1b) +__ulonglong 0x17 - 0xfffc == 0x1b (0x1b) +float 0x17 - 0xfffc == 0x1b (0x1b) +int 0x17 * 0xfffc == -0x5c (0xffa4) +__uint 0x17 * 0xfffc == -0x5c (0xffa4) +char 0x17 * 0xfffc == -0x5c (0xffa4) +__uchar 0x17 * 0xfc == 0xa4 (0xa4) +__longlong 0x17 * 0xfffc == -0x5c (0xffa4) +__ulonglong 0x17 * 0xfffc == -0x5c (0xffa4) +float 0x17 * 0xfffc == -0x5c (0xffa4) +int 0x17 < 0xfffc == 0x0 (0x0) +__uint 0x17 < 0xfffc == 0x1 (0x1) +char 0x17 < 0xfffc == 0x0 (0x0) +__uchar 0x17 < 0xfc == 0x1 (0x1) +__longlong 0x17 < 0xfffc == 0x0 (0x0) +__ulonglong 0x17 < 0xfffc == 0x1 (0x1) +float 0x17 < 0xfffc == 0x0 (0x0) +int 0x17 > 0xfffc == 0x1 (0x1) +__uint 0x17 > 0xfffc == 0x0 (0x0) +char 0x17 > 0xfffc == 0x1 (0x1) +__uchar 0x17 > 0xfc == 0x0 (0x0) +__longlong 0x17 > 0xfffc == 0x1 (0x1) +__ulonglong 0x17 > 0xfffc == 0x0 (0x0) +float 0x17 > 0xfffc == 0x1 (0x1) +int 0x17 <= 0xfffc == 0x0 (0x0) +__uint 0x17 <= 0xfffc == 0x1 (0x1) +char 0x17 <= 0xfffc == 0x0 (0x0) +__uchar 0x17 <= 0xfc == 0x1 (0x1) +__longlong 0x17 <= 0xfffc == 0x0 (0x0) +__ulonglong 0x17 <= 0xfffc == 0x1 (0x1) +float 0x17 <= 0xfffc == 0x0 (0x0) +int 0x17 == 0xfffc == 0x0 (0x0) +__uint 0x17 == 0xfffc == 0x0 (0x0) +char 0x17 == 0xfffc == 0x0 (0x0) +__uchar 0x17 == 0xfc == 0x0 (0x0) +__longlong 0x17 == 0xfffc == 0x0 (0x0) +__ulonglong 0x17 == 0xfffc == 0x0 (0x0) +float 0x17 == 0xfffc == 0x0 (0x0) +int 0x17 != 0xfffc == 0x1 (0x1) +__uint 0x17 != 0xfffc == 0x1 (0x1) +char 0x17 != 0xfffc == 0x1 (0x1) +__uchar 0x17 != 0xfc == 0x1 (0x1) +__longlong 0x17 != 0xfffc == 0x1 (0x1) +__ulonglong 0x17 != 0xfffc == 0x1 (0x1) +float 0x17 != 0xfffc == 0x1 (0x1) +int 0x17 >= 0xfffc == 0x1 (0x1) +__uint 0x17 >= 0xfffc == 0x0 (0x0) +char 0x17 >= 0xfffc == 0x1 (0x1) +__uchar 0x17 >= 0xfc == 0x0 (0x0) +__longlong 0x17 >= 0xfffc == 0x1 (0x1) +__ulonglong 0x17 >= 0xfffc == 0x0 (0x0) +float 0x17 >= 0xfffc == 0x1 (0x1) +int 0x17 / 0xfffc == -0x5 (0xfffb) +__uint 0x17 / 0xfffc == 0x0 (0x0) +char 0x17 / 0xfffc == -0x5 (0xfffb) +__uchar 0x17 / 0xfc == 0x0 (0x0) +__longlong 0x17 / 0xfffc == -0x5 (0xfffb) +__ulonglong 0x17 / 0xfffc == 0x0 (0x0) +float 0x17 / 0xfffc == -0x5 (0xfffb) +int 0x17 % 0xfffc == 0x3 (0x3) +__uint 0x17 % 0xfffc == 0x17 (0x17) +char 0x17 % 0xfffc == 0x3 (0x3) +__uchar 0x17 % 0xfc == 0x17 (0x17) +__longlong 0x17 % 0xfffc == 0x3 (0x3) +__ulonglong 0x17 % 0xfffc == 0x17 (0x17) +0x17 * 0xa == 0xe6 +0x17 / 0xa == 0x2 +0x17 % 0xa == 0x3 +int 0x17 ^ 0xa == 0x1d (0x1d) +__uint 0x17 ^ 0xa == 0x1d (0x1d) +char 0x17 ^ 0xa == 0x1d (0x1d) +__uchar 0x17 ^ 0xa == 0x1d (0x1d) +__longlong 0x17 ^ 0xa == 0x1d (0x1d) +__ulonglong 0x17 ^ 0xa == 0x1d (0x1d) +int 0x17 && 0xa == 0x1 (0x1) +__uint 0x17 && 0xa == 0x1 (0x1) +char 0x17 && 0xa == 0x1 (0x1) +__uchar 0x17 && 0xa == 0x1 (0x1) +__longlong 0x17 && 0xa == 0x1 (0x1) +__ulonglong 0x17 && 0xa == 0x1 (0x1) +int 0x17 || 0xa == 0x1 (0x1) +__uint 0x17 || 0xa == 0x1 (0x1) +char 0x17 || 0xa == 0x1 (0x1) +__uchar 0x17 || 0xa == 0x1 (0x1) +__longlong 0x17 || 0xa == 0x1 (0x1) +__ulonglong 0x17 || 0xa == 0x1 (0x1) +int 0x17 & 0xa == 0x2 (0x2) +__uint 0x17 & 0xa == 0x2 (0x2) +char 0x17 & 0xa == 0x2 (0x2) +__uchar 0x17 & 0xa == 0x2 (0x2) +__longlong 0x17 & 0xa == 0x2 (0x2) +__ulonglong 0x17 & 0xa == 0x2 (0x2) +int 0x17 | 0xa == 0x1f (0x1f) +__uint 0x17 | 0xa == 0x1f (0x1f) +char 0x17 | 0xa == 0x1f (0x1f) +__uchar 0x17 | 0xa == 0x1f (0x1f) +__longlong 0x17 | 0xa == 0x1f (0x1f) +__ulonglong 0x17 | 0xa == 0x1f (0x1f) +int 0x17 << 0x7 == 0xb80 (0xb80) +__uint 0x17 << 0x7 == 0xb80 (0xb80) +char 0x17 << 0x7 == -0x80 (0xff80) +__uchar 0x17 << 0x7 == 0x80 (0x80) +__longlong 0x17 << 0x7 == 0xb80 (0xb80) +__ulonglong 0x17 << 0x7 == 0xb80 (0xb80) +int 0x17 >> 0x7 == 0x0 (0x0) +__uint 0x17 >> 0x7 == 0x0 (0x0) +char 0x17 >> 0x7 == 0x0 (0x0) +__uchar 0x17 >> 0x7 == 0x0 (0x0) +__longlong 0x17 >> 0x7 == 0x0 (0x0) +__ulonglong 0x17 >> 0x7 == 0x0 (0x0) +int 0x17 + 0xa == 0x21 (0x21) +__uint 0x17 + 0xa == 0x21 (0x21) +char 0x17 + 0xa == 0x21 (0x21) +__uchar 0x17 + 0xa == 0x21 (0x21) +__longlong 0x17 + 0xa == 0x21 (0x21) +__ulonglong 0x17 + 0xa == 0x21 (0x21) +float 0x17 + 0xa == 0x21 (0x21) +int 0x17 - 0xa == 0xd (0xd) +__uint 0x17 - 0xa == 0xd (0xd) +char 0x17 - 0xa == 0xd (0xd) +__uchar 0x17 - 0xa == 0xd (0xd) +__longlong 0x17 - 0xa == 0xd (0xd) +__ulonglong 0x17 - 0xa == 0xd (0xd) +float 0x17 - 0xa == 0xd (0xd) +int 0x17 * 0xa == 0xe6 (0xe6) +__uint 0x17 * 0xa == 0xe6 (0xe6) +char 0x17 * 0xa == -0x1a (0xffe6) +__uchar 0x17 * 0xa == 0xe6 (0xe6) +__longlong 0x17 * 0xa == 0xe6 (0xe6) +__ulonglong 0x17 * 0xa == 0xe6 (0xe6) +float 0x17 * 0xa == 0xe6 (0xe6) +int 0x17 < 0xa == 0x0 (0x0) +__uint 0x17 < 0xa == 0x0 (0x0) +char 0x17 < 0xa == 0x0 (0x0) +__uchar 0x17 < 0xa == 0x0 (0x0) +__longlong 0x17 < 0xa == 0x0 (0x0) +__ulonglong 0x17 < 0xa == 0x0 (0x0) +float 0x17 < 0xa == 0x0 (0x0) +int 0x17 > 0xa == 0x1 (0x1) +__uint 0x17 > 0xa == 0x1 (0x1) +char 0x17 > 0xa == 0x1 (0x1) +__uchar 0x17 > 0xa == 0x1 (0x1) +__longlong 0x17 > 0xa == 0x1 (0x1) +__ulonglong 0x17 > 0xa == 0x1 (0x1) +float 0x17 > 0xa == 0x1 (0x1) +int 0x17 <= 0xa == 0x0 (0x0) +__uint 0x17 <= 0xa == 0x0 (0x0) +char 0x17 <= 0xa == 0x0 (0x0) +__uchar 0x17 <= 0xa == 0x0 (0x0) +__longlong 0x17 <= 0xa == 0x0 (0x0) +__ulonglong 0x17 <= 0xa == 0x0 (0x0) +float 0x17 <= 0xa == 0x0 (0x0) +int 0x17 == 0xa == 0x0 (0x0) +__uint 0x17 == 0xa == 0x0 (0x0) +char 0x17 == 0xa == 0x0 (0x0) +__uchar 0x17 == 0xa == 0x0 (0x0) +__longlong 0x17 == 0xa == 0x0 (0x0) +__ulonglong 0x17 == 0xa == 0x0 (0x0) +float 0x17 == 0xa == 0x0 (0x0) +int 0x17 != 0xa == 0x1 (0x1) +__uint 0x17 != 0xa == 0x1 (0x1) +char 0x17 != 0xa == 0x1 (0x1) +__uchar 0x17 != 0xa == 0x1 (0x1) +__longlong 0x17 != 0xa == 0x1 (0x1) +__ulonglong 0x17 != 0xa == 0x1 (0x1) +float 0x17 != 0xa == 0x1 (0x1) +int 0x17 >= 0xa == 0x1 (0x1) +__uint 0x17 >= 0xa == 0x1 (0x1) +char 0x17 >= 0xa == 0x1 (0x1) +__uchar 0x17 >= 0xa == 0x1 (0x1) +__longlong 0x17 >= 0xa == 0x1 (0x1) +__ulonglong 0x17 >= 0xa == 0x1 (0x1) +float 0x17 >= 0xa == 0x1 (0x1) +int 0x17 / 0xa == 0x2 (0x2) +__uint 0x17 / 0xa == 0x2 (0x2) +char 0x17 / 0xa == 0x2 (0x2) +__uchar 0x17 / 0xa == 0x2 (0x2) +__longlong 0x17 / 0xa == 0x2 (0x2) +__ulonglong 0x17 / 0xa == 0x2 (0x2) +float 0x17 / 0xa == 0x2 (0x2) +int 0x17 % 0xa == 0x3 (0x3) +__uint 0x17 % 0xa == 0x3 (0x3) +char 0x17 % 0xa == 0x3 (0x3) +__uchar 0x17 % 0xa == 0x3 (0x3) +__longlong 0x17 % 0xa == 0x3 (0x3) +__ulonglong 0x17 % 0xa == 0x3 (0x3) +0x17 * 0xfff6 == -0xe6 +0x17 / 0xfff6 == -0x2 +0x17 % 0xfff6 == 0x3 +int 0x17 ^ 0xfff6 == -0x1f (0xffe1) +__uint 0x17 ^ 0xfff6 == -0x1f (0xffe1) +char 0x17 ^ 0xfff6 == -0x1f (0xffe1) +__uchar 0x17 ^ 0xf6 == 0xe1 (0xe1) +__longlong 0x17 ^ 0xfff6 == -0x1f (0xffe1) +__ulonglong 0x17 ^ 0xfff6 == -0x1f (0xffe1) +int 0x17 && 0xfff6 == 0x1 (0x1) +__uint 0x17 && 0xfff6 == 0x1 (0x1) +char 0x17 && 0xfff6 == 0x1 (0x1) +__uchar 0x17 && 0xf6 == 0x1 (0x1) +__longlong 0x17 && 0xfff6 == 0x1 (0x1) +__ulonglong 0x17 && 0xfff6 == 0x1 (0x1) +int 0x17 || 0xfff6 == 0x1 (0x1) +__uint 0x17 || 0xfff6 == 0x1 (0x1) +char 0x17 || 0xfff6 == 0x1 (0x1) +__uchar 0x17 || 0xf6 == 0x1 (0x1) +__longlong 0x17 || 0xfff6 == 0x1 (0x1) +__ulonglong 0x17 || 0xfff6 == 0x1 (0x1) +int 0x17 & 0xfff6 == 0x16 (0x16) +__uint 0x17 & 0xfff6 == 0x16 (0x16) +char 0x17 & 0xfff6 == 0x16 (0x16) +__uchar 0x17 & 0xf6 == 0x16 (0x16) +__longlong 0x17 & 0xfff6 == 0x16 (0x16) +__ulonglong 0x17 & 0xfff6 == 0x16 (0x16) +int 0x17 | 0xfff6 == -0x9 (0xfff7) +__uint 0x17 | 0xfff6 == -0x9 (0xfff7) +char 0x17 | 0xfff6 == -0x9 (0xfff7) +__uchar 0x17 | 0xf6 == 0xf7 (0xf7) +__longlong 0x17 | 0xfff6 == -0x9 (0xfff7) +__ulonglong 0x17 | 0xfff6 == -0x9 (0xfff7) +int 0x17 << 0x8 == 0x1700 (0x1700) +__uint 0x17 << 0x8 == 0x1700 (0x1700) +char 0x17 << 0x8 == 0x0 (0x0) +__uchar 0x17 << 0x8 == 0x0 (0x0) +__longlong 0x17 << 0x8 == 0x1700 (0x1700) +__ulonglong 0x17 << 0x8 == 0x1700 (0x1700) +int 0x17 >> 0x8 == 0x0 (0x0) +__uint 0x17 >> 0x8 == 0x0 (0x0) +char 0x17 >> 0x8 == 0x0 (0x0) +__uchar 0x17 >> 0x8 == 0x0 (0x0) +__longlong 0x17 >> 0x8 == 0x0 (0x0) +__ulonglong 0x17 >> 0x8 == 0x0 (0x0) +int 0x17 + 0xfff6 == 0xd (0xd) +__uint 0x17 + 0xfff6 == 0xd (0xd) +char 0x17 + 0xfff6 == 0xd (0xd) +__uchar 0x17 + 0xf6 == 0xd (0xd) +__longlong 0x17 + 0xfff6 == 0xd (0xd) +__ulonglong 0x17 + 0xfff6 == 0xd (0xd) +float 0x17 + 0xfff6 == 0xd (0xd) +int 0x17 - 0xfff6 == 0x21 (0x21) +__uint 0x17 - 0xfff6 == 0x21 (0x21) +char 0x17 - 0xfff6 == 0x21 (0x21) +__uchar 0x17 - 0xf6 == 0x21 (0x21) +__longlong 0x17 - 0xfff6 == 0x21 (0x21) +__ulonglong 0x17 - 0xfff6 == 0x21 (0x21) +float 0x17 - 0xfff6 == 0x21 (0x21) +int 0x17 * 0xfff6 == -0xe6 (0xff1a) +__uint 0x17 * 0xfff6 == -0xe6 (0xff1a) +char 0x17 * 0xfff6 == 0x1a (0x1a) +__uchar 0x17 * 0xf6 == 0x1a (0x1a) +__longlong 0x17 * 0xfff6 == -0xe6 (0xff1a) +__ulonglong 0x17 * 0xfff6 == -0xe6 (0xff1a) +float 0x17 * 0xfff6 == -0xe6 (0xff1a) +int 0x17 < 0xfff6 == 0x0 (0x0) +__uint 0x17 < 0xfff6 == 0x1 (0x1) +char 0x17 < 0xfff6 == 0x0 (0x0) +__uchar 0x17 < 0xf6 == 0x1 (0x1) +__longlong 0x17 < 0xfff6 == 0x0 (0x0) +__ulonglong 0x17 < 0xfff6 == 0x1 (0x1) +float 0x17 < 0xfff6 == 0x0 (0x0) +int 0x17 > 0xfff6 == 0x1 (0x1) +__uint 0x17 > 0xfff6 == 0x0 (0x0) +char 0x17 > 0xfff6 == 0x1 (0x1) +__uchar 0x17 > 0xf6 == 0x0 (0x0) +__longlong 0x17 > 0xfff6 == 0x1 (0x1) +__ulonglong 0x17 > 0xfff6 == 0x0 (0x0) +float 0x17 > 0xfff6 == 0x1 (0x1) +int 0x17 <= 0xfff6 == 0x0 (0x0) +__uint 0x17 <= 0xfff6 == 0x1 (0x1) +char 0x17 <= 0xfff6 == 0x0 (0x0) +__uchar 0x17 <= 0xf6 == 0x1 (0x1) +__longlong 0x17 <= 0xfff6 == 0x0 (0x0) +__ulonglong 0x17 <= 0xfff6 == 0x1 (0x1) +float 0x17 <= 0xfff6 == 0x0 (0x0) +int 0x17 == 0xfff6 == 0x0 (0x0) +__uint 0x17 == 0xfff6 == 0x0 (0x0) +char 0x17 == 0xfff6 == 0x0 (0x0) +__uchar 0x17 == 0xf6 == 0x0 (0x0) +__longlong 0x17 == 0xfff6 == 0x0 (0x0) +__ulonglong 0x17 == 0xfff6 == 0x0 (0x0) +float 0x17 == 0xfff6 == 0x0 (0x0) +int 0x17 != 0xfff6 == 0x1 (0x1) +__uint 0x17 != 0xfff6 == 0x1 (0x1) +char 0x17 != 0xfff6 == 0x1 (0x1) +__uchar 0x17 != 0xf6 == 0x1 (0x1) +__longlong 0x17 != 0xfff6 == 0x1 (0x1) +__ulonglong 0x17 != 0xfff6 == 0x1 (0x1) +float 0x17 != 0xfff6 == 0x1 (0x1) +int 0x17 >= 0xfff6 == 0x1 (0x1) +__uint 0x17 >= 0xfff6 == 0x0 (0x0) +char 0x17 >= 0xfff6 == 0x1 (0x1) +__uchar 0x17 >= 0xf6 == 0x0 (0x0) +__longlong 0x17 >= 0xfff6 == 0x1 (0x1) +__ulonglong 0x17 >= 0xfff6 == 0x0 (0x0) +float 0x17 >= 0xfff6 == 0x1 (0x1) +int 0x17 / 0xfff6 == -0x2 (0xfffe) +__uint 0x17 / 0xfff6 == 0x0 (0x0) +char 0x17 / 0xfff6 == -0x2 (0xfffe) +__uchar 0x17 / 0xf6 == 0x0 (0x0) +__longlong 0x17 / 0xfff6 == -0x2 (0xfffe) +__ulonglong 0x17 / 0xfff6 == 0x0 (0x0) +float 0x17 / 0xfff6 == -0x2 (0xfffe) +int 0x17 % 0xfff6 == 0x3 (0x3) +__uint 0x17 % 0xfff6 == 0x17 (0x17) +char 0x17 % 0xfff6 == 0x3 (0x3) +__uchar 0x17 % 0xf6 == 0x17 (0x17) +__longlong 0x17 % 0xfff6 == 0x3 (0x3) +__ulonglong 0x17 % 0xfff6 == 0x17 (0x17) +0x17 * 0x5 == 0x73 +0x17 / 0x5 == 0x4 +0x17 % 0x5 == 0x3 +int 0x17 ^ 0x5 == 0x12 (0x12) +__uint 0x17 ^ 0x5 == 0x12 (0x12) +char 0x17 ^ 0x5 == 0x12 (0x12) +__uchar 0x17 ^ 0x5 == 0x12 (0x12) +__longlong 0x17 ^ 0x5 == 0x12 (0x12) +__ulonglong 0x17 ^ 0x5 == 0x12 (0x12) +int 0x17 && 0x5 == 0x1 (0x1) +__uint 0x17 && 0x5 == 0x1 (0x1) +char 0x17 && 0x5 == 0x1 (0x1) +__uchar 0x17 && 0x5 == 0x1 (0x1) +__longlong 0x17 && 0x5 == 0x1 (0x1) +__ulonglong 0x17 && 0x5 == 0x1 (0x1) +int 0x17 || 0x5 == 0x1 (0x1) +__uint 0x17 || 0x5 == 0x1 (0x1) +char 0x17 || 0x5 == 0x1 (0x1) +__uchar 0x17 || 0x5 == 0x1 (0x1) +__longlong 0x17 || 0x5 == 0x1 (0x1) +__ulonglong 0x17 || 0x5 == 0x1 (0x1) +int 0x17 & 0x5 == 0x5 (0x5) +__uint 0x17 & 0x5 == 0x5 (0x5) +char 0x17 & 0x5 == 0x5 (0x5) +__uchar 0x17 & 0x5 == 0x5 (0x5) +__longlong 0x17 & 0x5 == 0x5 (0x5) +__ulonglong 0x17 & 0x5 == 0x5 (0x5) +int 0x17 | 0x5 == 0x17 (0x17) +__uint 0x17 | 0x5 == 0x17 (0x17) +char 0x17 | 0x5 == 0x17 (0x17) +__uchar 0x17 | 0x5 == 0x17 (0x17) +__longlong 0x17 | 0x5 == 0x17 (0x17) +__ulonglong 0x17 | 0x5 == 0x17 (0x17) +int 0x17 << 0x9 == 0x2e00 (0x2e00) +__uint 0x17 << 0x9 == 0x2e00 (0x2e00) +char 0x17 << 0x9 == 0x0 (0x0) +__uchar 0x17 << 0x9 == 0x0 (0x0) +__longlong 0x17 << 0x9 == 0x2e00 (0x2e00) +__ulonglong 0x17 << 0x9 == 0x2e00 (0x2e00) +int 0x17 >> 0x9 == 0x0 (0x0) +__uint 0x17 >> 0x9 == 0x0 (0x0) +char 0x17 >> 0x9 == 0x0 (0x0) +__uchar 0x17 >> 0x9 == 0x0 (0x0) +__longlong 0x17 >> 0x9 == 0x0 (0x0) +__ulonglong 0x17 >> 0x9 == 0x0 (0x0) +int 0x17 + 0x5 == 0x1c (0x1c) +__uint 0x17 + 0x5 == 0x1c (0x1c) +char 0x17 + 0x5 == 0x1c (0x1c) +__uchar 0x17 + 0x5 == 0x1c (0x1c) +__longlong 0x17 + 0x5 == 0x1c (0x1c) +__ulonglong 0x17 + 0x5 == 0x1c (0x1c) +float 0x17 + 0x5 == 0x1c (0x1c) +int 0x17 - 0x5 == 0x12 (0x12) +__uint 0x17 - 0x5 == 0x12 (0x12) +char 0x17 - 0x5 == 0x12 (0x12) +__uchar 0x17 - 0x5 == 0x12 (0x12) +__longlong 0x17 - 0x5 == 0x12 (0x12) +__ulonglong 0x17 - 0x5 == 0x12 (0x12) +float 0x17 - 0x5 == 0x12 (0x12) +int 0x17 * 0x5 == 0x73 (0x73) +__uint 0x17 * 0x5 == 0x73 (0x73) +char 0x17 * 0x5 == 0x73 (0x73) +__uchar 0x17 * 0x5 == 0x73 (0x73) +__longlong 0x17 * 0x5 == 0x73 (0x73) +__ulonglong 0x17 * 0x5 == 0x73 (0x73) +float 0x17 * 0x5 == 0x73 (0x73) +int 0x17 < 0x5 == 0x0 (0x0) +__uint 0x17 < 0x5 == 0x0 (0x0) +char 0x17 < 0x5 == 0x0 (0x0) +__uchar 0x17 < 0x5 == 0x0 (0x0) +__longlong 0x17 < 0x5 == 0x0 (0x0) +__ulonglong 0x17 < 0x5 == 0x0 (0x0) +float 0x17 < 0x5 == 0x0 (0x0) +int 0x17 > 0x5 == 0x1 (0x1) +__uint 0x17 > 0x5 == 0x1 (0x1) +char 0x17 > 0x5 == 0x1 (0x1) +__uchar 0x17 > 0x5 == 0x1 (0x1) +__longlong 0x17 > 0x5 == 0x1 (0x1) +__ulonglong 0x17 > 0x5 == 0x1 (0x1) +float 0x17 > 0x5 == 0x1 (0x1) +int 0x17 <= 0x5 == 0x0 (0x0) +__uint 0x17 <= 0x5 == 0x0 (0x0) +char 0x17 <= 0x5 == 0x0 (0x0) +__uchar 0x17 <= 0x5 == 0x0 (0x0) +__longlong 0x17 <= 0x5 == 0x0 (0x0) +__ulonglong 0x17 <= 0x5 == 0x0 (0x0) +float 0x17 <= 0x5 == 0x0 (0x0) +int 0x17 == 0x5 == 0x0 (0x0) +__uint 0x17 == 0x5 == 0x0 (0x0) +char 0x17 == 0x5 == 0x0 (0x0) +__uchar 0x17 == 0x5 == 0x0 (0x0) +__longlong 0x17 == 0x5 == 0x0 (0x0) +__ulonglong 0x17 == 0x5 == 0x0 (0x0) +float 0x17 == 0x5 == 0x0 (0x0) +int 0x17 != 0x5 == 0x1 (0x1) +__uint 0x17 != 0x5 == 0x1 (0x1) +char 0x17 != 0x5 == 0x1 (0x1) +__uchar 0x17 != 0x5 == 0x1 (0x1) +__longlong 0x17 != 0x5 == 0x1 (0x1) +__ulonglong 0x17 != 0x5 == 0x1 (0x1) +float 0x17 != 0x5 == 0x1 (0x1) +int 0x17 >= 0x5 == 0x1 (0x1) +__uint 0x17 >= 0x5 == 0x1 (0x1) +char 0x17 >= 0x5 == 0x1 (0x1) +__uchar 0x17 >= 0x5 == 0x1 (0x1) +__longlong 0x17 >= 0x5 == 0x1 (0x1) +__ulonglong 0x17 >= 0x5 == 0x1 (0x1) +float 0x17 >= 0x5 == 0x1 (0x1) +int 0x17 / 0x5 == 0x4 (0x4) +__uint 0x17 / 0x5 == 0x4 (0x4) +char 0x17 / 0x5 == 0x4 (0x4) +__uchar 0x17 / 0x5 == 0x4 (0x4) +__longlong 0x17 / 0x5 == 0x4 (0x4) +__ulonglong 0x17 / 0x5 == 0x4 (0x4) +float 0x17 / 0x5 == 0x4 (0x4) +int 0x17 % 0x5 == 0x3 (0x3) +__uint 0x17 % 0x5 == 0x3 (0x3) +char 0x17 % 0x5 == 0x3 (0x3) +__uchar 0x17 % 0x5 == 0x3 (0x3) +__longlong 0x17 % 0x5 == 0x3 (0x3) +__ulonglong 0x17 % 0x5 == 0x3 (0x3) +0x17 * 0x7 == 0xa1 +0x17 / 0x7 == 0x3 +0x17 % 0x7 == 0x2 +int 0x17 ^ 0x7 == 0x10 (0x10) +__uint 0x17 ^ 0x7 == 0x10 (0x10) +char 0x17 ^ 0x7 == 0x10 (0x10) +__uchar 0x17 ^ 0x7 == 0x10 (0x10) +__longlong 0x17 ^ 0x7 == 0x10 (0x10) +__ulonglong 0x17 ^ 0x7 == 0x10 (0x10) +int 0x17 && 0x7 == 0x1 (0x1) +__uint 0x17 && 0x7 == 0x1 (0x1) +char 0x17 && 0x7 == 0x1 (0x1) +__uchar 0x17 && 0x7 == 0x1 (0x1) +__longlong 0x17 && 0x7 == 0x1 (0x1) +__ulonglong 0x17 && 0x7 == 0x1 (0x1) +int 0x17 || 0x7 == 0x1 (0x1) +__uint 0x17 || 0x7 == 0x1 (0x1) +char 0x17 || 0x7 == 0x1 (0x1) +__uchar 0x17 || 0x7 == 0x1 (0x1) +__longlong 0x17 || 0x7 == 0x1 (0x1) +__ulonglong 0x17 || 0x7 == 0x1 (0x1) +int 0x17 & 0x7 == 0x7 (0x7) +__uint 0x17 & 0x7 == 0x7 (0x7) +char 0x17 & 0x7 == 0x7 (0x7) +__uchar 0x17 & 0x7 == 0x7 (0x7) +__longlong 0x17 & 0x7 == 0x7 (0x7) +__ulonglong 0x17 & 0x7 == 0x7 (0x7) +int 0x17 | 0x7 == 0x17 (0x17) +__uint 0x17 | 0x7 == 0x17 (0x17) +char 0x17 | 0x7 == 0x17 (0x17) +__uchar 0x17 | 0x7 == 0x17 (0x17) +__longlong 0x17 | 0x7 == 0x17 (0x17) +__ulonglong 0x17 | 0x7 == 0x17 (0x17) +int 0x17 << 0xa == 0x5c00 (0x5c00) +__uint 0x17 << 0xa == 0x5c00 (0x5c00) +char 0x17 << 0xa == 0x0 (0x0) +__uchar 0x17 << 0xa == 0x0 (0x0) +__longlong 0x17 << 0xa == 0x5c00 (0x5c00) +__ulonglong 0x17 << 0xa == 0x5c00 (0x5c00) +int 0x17 >> 0xa == 0x0 (0x0) +__uint 0x17 >> 0xa == 0x0 (0x0) +char 0x17 >> 0xa == 0x0 (0x0) +__uchar 0x17 >> 0xa == 0x0 (0x0) +__longlong 0x17 >> 0xa == 0x0 (0x0) +__ulonglong 0x17 >> 0xa == 0x0 (0x0) +int 0x17 + 0x7 == 0x1e (0x1e) +__uint 0x17 + 0x7 == 0x1e (0x1e) +char 0x17 + 0x7 == 0x1e (0x1e) +__uchar 0x17 + 0x7 == 0x1e (0x1e) +__longlong 0x17 + 0x7 == 0x1e (0x1e) +__ulonglong 0x17 + 0x7 == 0x1e (0x1e) +float 0x17 + 0x7 == 0x1e (0x1e) +int 0x17 - 0x7 == 0x10 (0x10) +__uint 0x17 - 0x7 == 0x10 (0x10) +char 0x17 - 0x7 == 0x10 (0x10) +__uchar 0x17 - 0x7 == 0x10 (0x10) +__longlong 0x17 - 0x7 == 0x10 (0x10) +__ulonglong 0x17 - 0x7 == 0x10 (0x10) +float 0x17 - 0x7 == 0x10 (0x10) +int 0x17 * 0x7 == 0xa1 (0xa1) +__uint 0x17 * 0x7 == 0xa1 (0xa1) +char 0x17 * 0x7 == -0x5f (0xffa1) +__uchar 0x17 * 0x7 == 0xa1 (0xa1) +__longlong 0x17 * 0x7 == 0xa1 (0xa1) +__ulonglong 0x17 * 0x7 == 0xa1 (0xa1) +float 0x17 * 0x7 == 0xa1 (0xa1) +int 0x17 < 0x7 == 0x0 (0x0) +__uint 0x17 < 0x7 == 0x0 (0x0) +char 0x17 < 0x7 == 0x0 (0x0) +__uchar 0x17 < 0x7 == 0x0 (0x0) +__longlong 0x17 < 0x7 == 0x0 (0x0) +__ulonglong 0x17 < 0x7 == 0x0 (0x0) +float 0x17 < 0x7 == 0x0 (0x0) +int 0x17 > 0x7 == 0x1 (0x1) +__uint 0x17 > 0x7 == 0x1 (0x1) +char 0x17 > 0x7 == 0x1 (0x1) +__uchar 0x17 > 0x7 == 0x1 (0x1) +__longlong 0x17 > 0x7 == 0x1 (0x1) +__ulonglong 0x17 > 0x7 == 0x1 (0x1) +float 0x17 > 0x7 == 0x1 (0x1) +int 0x17 <= 0x7 == 0x0 (0x0) +__uint 0x17 <= 0x7 == 0x0 (0x0) +char 0x17 <= 0x7 == 0x0 (0x0) +__uchar 0x17 <= 0x7 == 0x0 (0x0) +__longlong 0x17 <= 0x7 == 0x0 (0x0) +__ulonglong 0x17 <= 0x7 == 0x0 (0x0) +float 0x17 <= 0x7 == 0x0 (0x0) +int 0x17 == 0x7 == 0x0 (0x0) +__uint 0x17 == 0x7 == 0x0 (0x0) +char 0x17 == 0x7 == 0x0 (0x0) +__uchar 0x17 == 0x7 == 0x0 (0x0) +__longlong 0x17 == 0x7 == 0x0 (0x0) +__ulonglong 0x17 == 0x7 == 0x0 (0x0) +float 0x17 == 0x7 == 0x0 (0x0) +int 0x17 != 0x7 == 0x1 (0x1) +__uint 0x17 != 0x7 == 0x1 (0x1) +char 0x17 != 0x7 == 0x1 (0x1) +__uchar 0x17 != 0x7 == 0x1 (0x1) +__longlong 0x17 != 0x7 == 0x1 (0x1) +__ulonglong 0x17 != 0x7 == 0x1 (0x1) +float 0x17 != 0x7 == 0x1 (0x1) +int 0x17 >= 0x7 == 0x1 (0x1) +__uint 0x17 >= 0x7 == 0x1 (0x1) +char 0x17 >= 0x7 == 0x1 (0x1) +__uchar 0x17 >= 0x7 == 0x1 (0x1) +__longlong 0x17 >= 0x7 == 0x1 (0x1) +__ulonglong 0x17 >= 0x7 == 0x1 (0x1) +float 0x17 >= 0x7 == 0x1 (0x1) +int 0x17 / 0x7 == 0x3 (0x3) +__uint 0x17 / 0x7 == 0x3 (0x3) +char 0x17 / 0x7 == 0x3 (0x3) +__uchar 0x17 / 0x7 == 0x3 (0x3) +__longlong 0x17 / 0x7 == 0x3 (0x3) +__ulonglong 0x17 / 0x7 == 0x3 (0x3) +float 0x17 / 0x7 == 0x3 (0x3) +int 0x17 % 0x7 == 0x2 (0x2) +__uint 0x17 % 0x7 == 0x2 (0x2) +char 0x17 % 0x7 == 0x2 (0x2) +__uchar 0x17 % 0x7 == 0x2 (0x2) +__longlong 0x17 % 0x7 == 0x2 (0x2) +__ulonglong 0x17 % 0x7 == 0x2 (0x2) +0x17 * 0x2a == 0x3c6 +0x17 / 0x2a == 0x0 +0x17 % 0x2a == 0x17 +int 0x17 ^ 0x2a == 0x3d (0x3d) +__uint 0x17 ^ 0x2a == 0x3d (0x3d) +char 0x17 ^ 0x2a == 0x3d (0x3d) +__uchar 0x17 ^ 0x2a == 0x3d (0x3d) +__longlong 0x17 ^ 0x2a == 0x3d (0x3d) +__ulonglong 0x17 ^ 0x2a == 0x3d (0x3d) +int 0x17 && 0x2a == 0x1 (0x1) +__uint 0x17 && 0x2a == 0x1 (0x1) +char 0x17 && 0x2a == 0x1 (0x1) +__uchar 0x17 && 0x2a == 0x1 (0x1) +__longlong 0x17 && 0x2a == 0x1 (0x1) +__ulonglong 0x17 && 0x2a == 0x1 (0x1) +int 0x17 || 0x2a == 0x1 (0x1) +__uint 0x17 || 0x2a == 0x1 (0x1) +char 0x17 || 0x2a == 0x1 (0x1) +__uchar 0x17 || 0x2a == 0x1 (0x1) +__longlong 0x17 || 0x2a == 0x1 (0x1) +__ulonglong 0x17 || 0x2a == 0x1 (0x1) +int 0x17 & 0x2a == 0x2 (0x2) +__uint 0x17 & 0x2a == 0x2 (0x2) +char 0x17 & 0x2a == 0x2 (0x2) +__uchar 0x17 & 0x2a == 0x2 (0x2) +__longlong 0x17 & 0x2a == 0x2 (0x2) +__ulonglong 0x17 & 0x2a == 0x2 (0x2) +int 0x17 | 0x2a == 0x3f (0x3f) +__uint 0x17 | 0x2a == 0x3f (0x3f) +char 0x17 | 0x2a == 0x3f (0x3f) +__uchar 0x17 | 0x2a == 0x3f (0x3f) +__longlong 0x17 | 0x2a == 0x3f (0x3f) +__ulonglong 0x17 | 0x2a == 0x3f (0x3f) +int 0x17 << 0xc == 0x7000 (0x7000) +__uint 0x17 << 0xc == 0x7000 (0x7000) +char 0x17 << 0xc == 0x0 (0x0) +__uchar 0x17 << 0xc == 0x0 (0x0) +__longlong 0x17 << 0xc == 0x7000 (0x7000) +__ulonglong 0x17 << 0xc == 0x7000 (0x7000) +int 0x17 >> 0xc == 0x0 (0x0) +__uint 0x17 >> 0xc == 0x0 (0x0) +char 0x17 >> 0xc == 0x0 (0x0) +__uchar 0x17 >> 0xc == 0x0 (0x0) +__longlong 0x17 >> 0xc == 0x0 (0x0) +__ulonglong 0x17 >> 0xc == 0x0 (0x0) +int 0x17 + 0x2a == 0x41 (0x41) +__uint 0x17 + 0x2a == 0x41 (0x41) +char 0x17 + 0x2a == 0x41 (0x41) +__uchar 0x17 + 0x2a == 0x41 (0x41) +__longlong 0x17 + 0x2a == 0x41 (0x41) +__ulonglong 0x17 + 0x2a == 0x41 (0x41) +float 0x17 + 0x2a == 0x41 (0x41) +int 0x17 - 0x2a == -0x13 (0xffed) +__uint 0x17 - 0x2a == -0x13 (0xffed) +char 0x17 - 0x2a == -0x13 (0xffed) +__uchar 0x17 - 0x2a == 0xed (0xed) +__longlong 0x17 - 0x2a == -0x13 (0xffed) +__ulonglong 0x17 - 0x2a == -0x13 (0xffed) +float 0x17 - 0x2a == -0x13 (0xffed) +int 0x17 * 0x2a == 0x3c6 (0x3c6) +__uint 0x17 * 0x2a == 0x3c6 (0x3c6) +char 0x17 * 0x2a == -0x3a (0xffc6) +__uchar 0x17 * 0x2a == 0xc6 (0xc6) +__longlong 0x17 * 0x2a == 0x3c6 (0x3c6) +__ulonglong 0x17 * 0x2a == 0x3c6 (0x3c6) +float 0x17 * 0x2a == 0x3c6 (0x3c6) +int 0x17 < 0x2a == 0x1 (0x1) +__uint 0x17 < 0x2a == 0x1 (0x1) +char 0x17 < 0x2a == 0x1 (0x1) +__uchar 0x17 < 0x2a == 0x1 (0x1) +__longlong 0x17 < 0x2a == 0x1 (0x1) +__ulonglong 0x17 < 0x2a == 0x1 (0x1) +float 0x17 < 0x2a == 0x1 (0x1) +int 0x17 > 0x2a == 0x0 (0x0) +__uint 0x17 > 0x2a == 0x0 (0x0) +char 0x17 > 0x2a == 0x0 (0x0) +__uchar 0x17 > 0x2a == 0x0 (0x0) +__longlong 0x17 > 0x2a == 0x0 (0x0) +__ulonglong 0x17 > 0x2a == 0x0 (0x0) +float 0x17 > 0x2a == 0x0 (0x0) +int 0x17 <= 0x2a == 0x1 (0x1) +__uint 0x17 <= 0x2a == 0x1 (0x1) +char 0x17 <= 0x2a == 0x1 (0x1) +__uchar 0x17 <= 0x2a == 0x1 (0x1) +__longlong 0x17 <= 0x2a == 0x1 (0x1) +__ulonglong 0x17 <= 0x2a == 0x1 (0x1) +float 0x17 <= 0x2a == 0x1 (0x1) +int 0x17 == 0x2a == 0x0 (0x0) +__uint 0x17 == 0x2a == 0x0 (0x0) +char 0x17 == 0x2a == 0x0 (0x0) +__uchar 0x17 == 0x2a == 0x0 (0x0) +__longlong 0x17 == 0x2a == 0x0 (0x0) +__ulonglong 0x17 == 0x2a == 0x0 (0x0) +float 0x17 == 0x2a == 0x0 (0x0) +int 0x17 != 0x2a == 0x1 (0x1) +__uint 0x17 != 0x2a == 0x1 (0x1) +char 0x17 != 0x2a == 0x1 (0x1) +__uchar 0x17 != 0x2a == 0x1 (0x1) +__longlong 0x17 != 0x2a == 0x1 (0x1) +__ulonglong 0x17 != 0x2a == 0x1 (0x1) +float 0x17 != 0x2a == 0x1 (0x1) +int 0x17 >= 0x2a == 0x0 (0x0) +__uint 0x17 >= 0x2a == 0x0 (0x0) +char 0x17 >= 0x2a == 0x0 (0x0) +__uchar 0x17 >= 0x2a == 0x0 (0x0) +__longlong 0x17 >= 0x2a == 0x0 (0x0) +__ulonglong 0x17 >= 0x2a == 0x0 (0x0) +float 0x17 >= 0x2a == 0x0 (0x0) +int 0x17 / 0x2a == 0x0 (0x0) +__uint 0x17 / 0x2a == 0x0 (0x0) +char 0x17 / 0x2a == 0x0 (0x0) +__uchar 0x17 / 0x2a == 0x0 (0x0) +__longlong 0x17 / 0x2a == 0x0 (0x0) +__ulonglong 0x17 / 0x2a == 0x0 (0x0) +float 0x17 / 0x2a == 0x0 (0x0) +int 0x17 % 0x2a == 0x17 (0x17) +__uint 0x17 % 0x2a == 0x17 (0x17) +char 0x17 % 0x2a == 0x17 (0x17) +__uchar 0x17 % 0x2a == 0x17 (0x17) +__longlong 0x17 % 0x2a == 0x17 (0x17) +__ulonglong 0x17 % 0x2a == 0x17 (0x17) +0x17 * 0x17 == 0x211 +0x17 / 0x17 == 0x1 +0x17 % 0x17 == 0x0 +int 0x17 ^ 0x17 == 0x0 (0x0) +__uint 0x17 ^ 0x17 == 0x0 (0x0) +char 0x17 ^ 0x17 == 0x0 (0x0) +__uchar 0x17 ^ 0x17 == 0x0 (0x0) +__longlong 0x17 ^ 0x17 == 0x0 (0x0) +__ulonglong 0x17 ^ 0x17 == 0x0 (0x0) +int 0x17 && 0x17 == 0x1 (0x1) +__uint 0x17 && 0x17 == 0x1 (0x1) +char 0x17 && 0x17 == 0x1 (0x1) +__uchar 0x17 && 0x17 == 0x1 (0x1) +__longlong 0x17 && 0x17 == 0x1 (0x1) +__ulonglong 0x17 && 0x17 == 0x1 (0x1) +int 0x17 || 0x17 == 0x1 (0x1) +__uint 0x17 || 0x17 == 0x1 (0x1) +char 0x17 || 0x17 == 0x1 (0x1) +__uchar 0x17 || 0x17 == 0x1 (0x1) +__longlong 0x17 || 0x17 == 0x1 (0x1) +__ulonglong 0x17 || 0x17 == 0x1 (0x1) +int 0x17 & 0x17 == 0x17 (0x17) +__uint 0x17 & 0x17 == 0x17 (0x17) +char 0x17 & 0x17 == 0x17 (0x17) +__uchar 0x17 & 0x17 == 0x17 (0x17) +__longlong 0x17 & 0x17 == 0x17 (0x17) +__ulonglong 0x17 & 0x17 == 0x17 (0x17) +int 0x17 | 0x17 == 0x17 (0x17) +__uint 0x17 | 0x17 == 0x17 (0x17) +char 0x17 | 0x17 == 0x17 (0x17) +__uchar 0x17 | 0x17 == 0x17 (0x17) +__longlong 0x17 | 0x17 == 0x17 (0x17) +__ulonglong 0x17 | 0x17 == 0x17 (0x17) +int 0x17 << 0xe == -0x4000 (0xc000) +__uint 0x17 << 0xe == -0x4000 (0xc000) +char 0x17 << 0xe == 0x0 (0x0) +__uchar 0x17 << 0xe == 0x0 (0x0) +__longlong 0x17 << 0xe == -0x4000 (0xc000) +__ulonglong 0x17 << 0xe == -0x4000 (0xc000) +int 0x17 >> 0xe == 0x0 (0x0) +__uint 0x17 >> 0xe == 0x0 (0x0) +char 0x17 >> 0xe == 0x0 (0x0) +__uchar 0x17 >> 0xe == 0x0 (0x0) +__longlong 0x17 >> 0xe == 0x0 (0x0) +__ulonglong 0x17 >> 0xe == 0x0 (0x0) +int 0x17 + 0x17 == 0x2e (0x2e) +__uint 0x17 + 0x17 == 0x2e (0x2e) +char 0x17 + 0x17 == 0x2e (0x2e) +__uchar 0x17 + 0x17 == 0x2e (0x2e) +__longlong 0x17 + 0x17 == 0x2e (0x2e) +__ulonglong 0x17 + 0x17 == 0x2e (0x2e) +float 0x17 + 0x17 == 0x2e (0x2e) +int 0x17 - 0x17 == 0x0 (0x0) +__uint 0x17 - 0x17 == 0x0 (0x0) +char 0x17 - 0x17 == 0x0 (0x0) +__uchar 0x17 - 0x17 == 0x0 (0x0) +__longlong 0x17 - 0x17 == 0x0 (0x0) +__ulonglong 0x17 - 0x17 == 0x0 (0x0) +float 0x17 - 0x17 == 0x0 (0x0) +int 0x17 * 0x17 == 0x211 (0x211) +__uint 0x17 * 0x17 == 0x211 (0x211) +char 0x17 * 0x17 == 0x11 (0x11) +__uchar 0x17 * 0x17 == 0x11 (0x11) +__longlong 0x17 * 0x17 == 0x211 (0x211) +__ulonglong 0x17 * 0x17 == 0x211 (0x211) +float 0x17 * 0x17 == 0x211 (0x211) +int 0x17 < 0x17 == 0x0 (0x0) +__uint 0x17 < 0x17 == 0x0 (0x0) +char 0x17 < 0x17 == 0x0 (0x0) +__uchar 0x17 < 0x17 == 0x0 (0x0) +__longlong 0x17 < 0x17 == 0x0 (0x0) +__ulonglong 0x17 < 0x17 == 0x0 (0x0) +float 0x17 < 0x17 == 0x0 (0x0) +int 0x17 > 0x17 == 0x0 (0x0) +__uint 0x17 > 0x17 == 0x0 (0x0) +char 0x17 > 0x17 == 0x0 (0x0) +__uchar 0x17 > 0x17 == 0x0 (0x0) +__longlong 0x17 > 0x17 == 0x0 (0x0) +__ulonglong 0x17 > 0x17 == 0x0 (0x0) +float 0x17 > 0x17 == 0x0 (0x0) +int 0x17 <= 0x17 == 0x1 (0x1) +__uint 0x17 <= 0x17 == 0x1 (0x1) +char 0x17 <= 0x17 == 0x1 (0x1) +__uchar 0x17 <= 0x17 == 0x1 (0x1) +__longlong 0x17 <= 0x17 == 0x1 (0x1) +__ulonglong 0x17 <= 0x17 == 0x1 (0x1) +float 0x17 <= 0x17 == 0x1 (0x1) +int 0x17 == 0x17 == 0x1 (0x1) +__uint 0x17 == 0x17 == 0x1 (0x1) +char 0x17 == 0x17 == 0x1 (0x1) +__uchar 0x17 == 0x17 == 0x1 (0x1) +__longlong 0x17 == 0x17 == 0x1 (0x1) +__ulonglong 0x17 == 0x17 == 0x1 (0x1) +float 0x17 == 0x17 == 0x1 (0x1) +int 0x17 != 0x17 == 0x0 (0x0) +__uint 0x17 != 0x17 == 0x0 (0x0) +char 0x17 != 0x17 == 0x0 (0x0) +__uchar 0x17 != 0x17 == 0x0 (0x0) +__longlong 0x17 != 0x17 == 0x0 (0x0) +__ulonglong 0x17 != 0x17 == 0x0 (0x0) +float 0x17 != 0x17 == 0x0 (0x0) +int 0x17 >= 0x17 == 0x1 (0x1) +__uint 0x17 >= 0x17 == 0x1 (0x1) +char 0x17 >= 0x17 == 0x1 (0x1) +__uchar 0x17 >= 0x17 == 0x1 (0x1) +__longlong 0x17 >= 0x17 == 0x1 (0x1) +__ulonglong 0x17 >= 0x17 == 0x1 (0x1) +float 0x17 >= 0x17 == 0x1 (0x1) +int 0x17 / 0x17 == 0x1 (0x1) +__uint 0x17 / 0x17 == 0x1 (0x1) +char 0x17 / 0x17 == 0x1 (0x1) +__uchar 0x17 / 0x17 == 0x1 (0x1) +__longlong 0x17 / 0x17 == 0x1 (0x1) +__ulonglong 0x17 / 0x17 == 0x1 (0x1) +float 0x17 / 0x17 == 0x1 (0x1) +int 0x17 % 0x17 == 0x0 (0x0) +__uint 0x17 % 0x17 == 0x0 (0x0) +char 0x17 % 0x17 == 0x0 (0x0) +__uchar 0x17 % 0x17 == 0x0 (0x0) +__longlong 0x17 % 0x17 == 0x0 (0x0) +__ulonglong 0x17 % 0x17 == 0x0 (0x0) +0x17 * 0x7fff == 0x7fe9 +0x17 / 0x7fff == 0x0 +0x17 % 0x7fff == 0x17 +int 0x17 ^ 0x7fff == 0x7fe8 (0x7fe8) +__uint 0x17 ^ 0x7fff == 0x7fe8 (0x7fe8) +char 0x17 ^ 0xffff == -0x18 (0xffe8) +__uchar 0x17 ^ 0xff == 0xe8 (0xe8) +__longlong 0x17 ^ 0x7fff == 0x7fe8 (0x7fe8) +__ulonglong 0x17 ^ 0x7fff == 0x7fe8 (0x7fe8) +int 0x17 && 0x7fff == 0x1 (0x1) +__uint 0x17 && 0x7fff == 0x1 (0x1) +char 0x17 && 0xffff == 0x1 (0x1) +__uchar 0x17 && 0xff == 0x1 (0x1) +__longlong 0x17 && 0x7fff == 0x1 (0x1) +__ulonglong 0x17 && 0x7fff == 0x1 (0x1) +int 0x17 || 0x7fff == 0x1 (0x1) +__uint 0x17 || 0x7fff == 0x1 (0x1) +char 0x17 || 0xffff == 0x1 (0x1) +__uchar 0x17 || 0xff == 0x1 (0x1) +__longlong 0x17 || 0x7fff == 0x1 (0x1) +__ulonglong 0x17 || 0x7fff == 0x1 (0x1) +int 0x17 & 0x7fff == 0x17 (0x17) +__uint 0x17 & 0x7fff == 0x17 (0x17) +char 0x17 & 0xffff == 0x17 (0x17) +__uchar 0x17 & 0xff == 0x17 (0x17) +__longlong 0x17 & 0x7fff == 0x17 (0x17) +__ulonglong 0x17 & 0x7fff == 0x17 (0x17) +int 0x17 | 0x7fff == 0x7fff (0x7fff) +__uint 0x17 | 0x7fff == 0x7fff (0x7fff) +char 0x17 | 0xffff == -0x1 (0xffff) +__uchar 0x17 | 0xff == 0xff (0xff) +__longlong 0x17 | 0x7fff == 0x7fff (0x7fff) +__ulonglong 0x17 | 0x7fff == 0x7fff (0x7fff) +int 0x17 << 0x10 == 0x0 (0x0) +__uint 0x17 << 0x10 == 0x0 (0x0) +char 0x17 << 0x10 == 0x0 (0x0) +__uchar 0x17 << 0x10 == 0x0 (0x0) +__longlong 0x17 << 0x10 == 0x0 (0x0) +__ulonglong 0x17 << 0x10 == 0x0 (0x0) +int 0x17 >> 0x10 == 0x0 (0x0) +__uint 0x17 >> 0x10 == 0x0 (0x0) +char 0x17 >> 0x10 == 0x0 (0x0) +__uchar 0x17 >> 0x10 == 0x0 (0x0) +__longlong 0x17 >> 0x10 == 0x0 (0x0) +__ulonglong 0x17 >> 0x10 == 0x0 (0x0) +int 0x17 + 0x7fff == -0x7fea (0x8016) +__uint 0x17 + 0x7fff == -0x7fea (0x8016) +char 0x17 + 0xffff == 0x16 (0x16) +__uchar 0x17 + 0xff == 0x16 (0x16) +__longlong 0x17 + 0x7fff == -0x7fea (0x8016) +__ulonglong 0x17 + 0x7fff == -0x7fea (0x8016) +float 0x17 + 0x7fff == -0x8000 (0x8000) +int 0x17 - 0x7fff == -0x7fe8 (0x8018) +__uint 0x17 - 0x7fff == -0x7fe8 (0x8018) +char 0x17 - 0xffff == 0x18 (0x18) +__uchar 0x17 - 0xff == 0x18 (0x18) +__longlong 0x17 - 0x7fff == -0x7fe8 (0x8018) +__ulonglong 0x17 - 0x7fff == -0x7fe8 (0x8018) +float 0x17 - 0x7fff == -0x7fe8 (0x8018) +int 0x17 * 0x7fff == 0x7fe9 (0x7fe9) +__uint 0x17 * 0x7fff == 0x7fe9 (0x7fe9) +char 0x17 * 0xffff == -0x17 (0xffe9) +__uchar 0x17 * 0xff == 0xe9 (0xe9) +__longlong 0x17 * 0x7fff == 0x7fe9 (0x7fe9) +__ulonglong 0x17 * 0x7fff == 0x7fe9 (0x7fe9) +float 0x17 * 0x7fff == -0x8000 (0x8000) +int 0x17 < 0x7fff == 0x1 (0x1) +__uint 0x17 < 0x7fff == 0x1 (0x1) +char 0x17 < 0xffff == 0x0 (0x0) +__uchar 0x17 < 0xff == 0x1 (0x1) +__longlong 0x17 < 0x7fff == 0x1 (0x1) +__ulonglong 0x17 < 0x7fff == 0x1 (0x1) +float 0x17 < 0x7fff == 0x1 (0x1) +int 0x17 > 0x7fff == 0x0 (0x0) +__uint 0x17 > 0x7fff == 0x0 (0x0) +char 0x17 > 0xffff == 0x1 (0x1) +__uchar 0x17 > 0xff == 0x0 (0x0) +__longlong 0x17 > 0x7fff == 0x0 (0x0) +__ulonglong 0x17 > 0x7fff == 0x0 (0x0) +float 0x17 > 0x7fff == 0x0 (0x0) +int 0x17 <= 0x7fff == 0x1 (0x1) +__uint 0x17 <= 0x7fff == 0x1 (0x1) +char 0x17 <= 0xffff == 0x0 (0x0) +__uchar 0x17 <= 0xff == 0x1 (0x1) +__longlong 0x17 <= 0x7fff == 0x1 (0x1) +__ulonglong 0x17 <= 0x7fff == 0x1 (0x1) +float 0x17 <= 0x7fff == 0x1 (0x1) +int 0x17 == 0x7fff == 0x0 (0x0) +__uint 0x17 == 0x7fff == 0x0 (0x0) +char 0x17 == 0xffff == 0x0 (0x0) +__uchar 0x17 == 0xff == 0x0 (0x0) +__longlong 0x17 == 0x7fff == 0x0 (0x0) +__ulonglong 0x17 == 0x7fff == 0x0 (0x0) +float 0x17 == 0x7fff == 0x0 (0x0) +int 0x17 != 0x7fff == 0x1 (0x1) +__uint 0x17 != 0x7fff == 0x1 (0x1) +char 0x17 != 0xffff == 0x1 (0x1) +__uchar 0x17 != 0xff == 0x1 (0x1) +__longlong 0x17 != 0x7fff == 0x1 (0x1) +__ulonglong 0x17 != 0x7fff == 0x1 (0x1) +float 0x17 != 0x7fff == 0x1 (0x1) +int 0x17 >= 0x7fff == 0x0 (0x0) +__uint 0x17 >= 0x7fff == 0x0 (0x0) +char 0x17 >= 0xffff == 0x1 (0x1) +__uchar 0x17 >= 0xff == 0x0 (0x0) +__longlong 0x17 >= 0x7fff == 0x0 (0x0) +__ulonglong 0x17 >= 0x7fff == 0x0 (0x0) +float 0x17 >= 0x7fff == 0x0 (0x0) +int 0x17 / 0x7fff == 0x0 (0x0) +__uint 0x17 / 0x7fff == 0x0 (0x0) +char 0x17 / 0xffff == -0x17 (0xffe9) +__uchar 0x17 / 0xff == 0x0 (0x0) +__longlong 0x17 / 0x7fff == 0x0 (0x0) +__ulonglong 0x17 / 0x7fff == 0x0 (0x0) +float 0x17 / 0x7fff == 0x0 (0x0) +int 0x17 % 0x7fff == 0x17 (0x17) +__uint 0x17 % 0x7fff == 0x17 (0x17) +char 0x17 % 0xffff == 0x0 (0x0) +__uchar 0x17 % 0xff == 0x17 (0x17) +__longlong 0x17 % 0x7fff == 0x17 (0x17) +__ulonglong 0x17 % 0x7fff == 0x17 (0x17) +0x17 * 0x8000 == -0x8000 +0x17 / 0x8000 == 0x0 +0x17 % 0x8000 == 0x17 +int 0x17 ^ 0x8000 == -0x7fe9 (0x8017) +__uint 0x17 ^ 0x8000 == -0x7fe9 (0x8017) +char 0x17 ^ 0x0 == 0x17 (0x17) +__uchar 0x17 ^ 0x0 == 0x17 (0x17) +__longlong 0x17 ^ 0x8000 == -0x7fe9 (0x8017) +__ulonglong 0x17 ^ 0x8000 == -0x7fe9 (0x8017) +int 0x17 && 0x8000 == 0x1 (0x1) +__uint 0x17 && 0x8000 == 0x1 (0x1) +char 0x17 && 0x0 == 0x0 (0x0) +__uchar 0x17 && 0x0 == 0x0 (0x0) +__longlong 0x17 && 0x8000 == 0x1 (0x1) +__ulonglong 0x17 && 0x8000 == 0x1 (0x1) +int 0x17 || 0x8000 == 0x1 (0x1) +__uint 0x17 || 0x8000 == 0x1 (0x1) +char 0x17 || 0x0 == 0x1 (0x1) +__uchar 0x17 || 0x0 == 0x1 (0x1) +__longlong 0x17 || 0x8000 == 0x1 (0x1) +__ulonglong 0x17 || 0x8000 == 0x1 (0x1) +int 0x17 & 0x8000 == 0x0 (0x0) +__uint 0x17 & 0x8000 == 0x0 (0x0) +char 0x17 & 0x0 == 0x0 (0x0) +__uchar 0x17 & 0x0 == 0x0 (0x0) +__longlong 0x17 & 0x8000 == 0x0 (0x0) +__ulonglong 0x17 & 0x8000 == 0x0 (0x0) +int 0x17 | 0x8000 == -0x7fe9 (0x8017) +__uint 0x17 | 0x8000 == -0x7fe9 (0x8017) +char 0x17 | 0x0 == 0x17 (0x17) +__uchar 0x17 | 0x0 == 0x17 (0x17) +__longlong 0x17 | 0x8000 == -0x7fe9 (0x8017) +__ulonglong 0x17 | 0x8000 == -0x7fe9 (0x8017) +int 0x17 << 0x12 == 0x0 (0x0) +__uint 0x17 << 0x12 == 0x0 (0x0) +char 0x17 << 0x12 == 0x0 (0x0) +__uchar 0x17 << 0x12 == 0x0 (0x0) +__longlong 0x17 << 0x12 == 0x0 (0x0) +__ulonglong 0x17 << 0x12 == 0x0 (0x0) +int 0x17 >> 0x12 == 0x0 (0x0) +__uint 0x17 >> 0x12 == 0x0 (0x0) +char 0x17 >> 0x12 == 0x0 (0x0) +__uchar 0x17 >> 0x12 == 0x0 (0x0) +__longlong 0x17 >> 0x12 == 0x0 (0x0) +__ulonglong 0x17 >> 0x12 == 0x0 (0x0) +int 0x17 + 0x8000 == -0x7fe9 (0x8017) +__uint 0x17 + 0x8000 == -0x7fe9 (0x8017) +char 0x17 + 0x0 == 0x17 (0x17) +__uchar 0x17 + 0x0 == 0x17 (0x17) +__longlong 0x17 + 0x8000 == -0x7fe9 (0x8017) +__ulonglong 0x17 + 0x8000 == -0x7fe9 (0x8017) +float 0x17 + 0x8000 == -0x7fe9 (0x8017) +int 0x17 - 0x8000 == -0x7fe9 (0x8017) +__uint 0x17 - 0x8000 == -0x7fe9 (0x8017) +char 0x17 - 0x0 == 0x17 (0x17) +__uchar 0x17 - 0x0 == 0x17 (0x17) +__longlong 0x17 - 0x8000 == -0x7fe9 (0x8017) +__ulonglong 0x17 - 0x8000 == -0x7fe9 (0x8017) +float 0x17 - 0x8000 == -0x8000 (0x8000) +int 0x17 * 0x8000 == -0x8000 (0x8000) +__uint 0x17 * 0x8000 == -0x8000 (0x8000) +char 0x17 * 0x0 == 0x0 (0x0) +__uchar 0x17 * 0x0 == 0x0 (0x0) +__longlong 0x17 * 0x8000 == -0x8000 (0x8000) +__ulonglong 0x17 * 0x8000 == -0x8000 (0x8000) +float 0x17 * 0x8000 == -0x8000 (0x8000) +int 0x17 < 0x8000 == 0x0 (0x0) +__uint 0x17 < 0x8000 == 0x1 (0x1) +char 0x17 < 0x0 == 0x0 (0x0) +__uchar 0x17 < 0x0 == 0x0 (0x0) +__longlong 0x17 < 0x8000 == 0x0 (0x0) +__ulonglong 0x17 < 0x8000 == 0x1 (0x1) +float 0x17 < 0x8000 == 0x0 (0x0) +int 0x17 > 0x8000 == 0x1 (0x1) +__uint 0x17 > 0x8000 == 0x0 (0x0) +char 0x17 > 0x0 == 0x1 (0x1) +__uchar 0x17 > 0x0 == 0x1 (0x1) +__longlong 0x17 > 0x8000 == 0x1 (0x1) +__ulonglong 0x17 > 0x8000 == 0x0 (0x0) +float 0x17 > 0x8000 == 0x1 (0x1) +int 0x17 <= 0x8000 == 0x0 (0x0) +__uint 0x17 <= 0x8000 == 0x1 (0x1) +char 0x17 <= 0x0 == 0x0 (0x0) +__uchar 0x17 <= 0x0 == 0x0 (0x0) +__longlong 0x17 <= 0x8000 == 0x0 (0x0) +__ulonglong 0x17 <= 0x8000 == 0x1 (0x1) +float 0x17 <= 0x8000 == 0x0 (0x0) +int 0x17 == 0x8000 == 0x0 (0x0) +__uint 0x17 == 0x8000 == 0x0 (0x0) +char 0x17 == 0x0 == 0x0 (0x0) +__uchar 0x17 == 0x0 == 0x0 (0x0) +__longlong 0x17 == 0x8000 == 0x0 (0x0) +__ulonglong 0x17 == 0x8000 == 0x0 (0x0) +float 0x17 == 0x8000 == 0x0 (0x0) +int 0x17 != 0x8000 == 0x1 (0x1) +__uint 0x17 != 0x8000 == 0x1 (0x1) +char 0x17 != 0x0 == 0x1 (0x1) +__uchar 0x17 != 0x0 == 0x1 (0x1) +__longlong 0x17 != 0x8000 == 0x1 (0x1) +__ulonglong 0x17 != 0x8000 == 0x1 (0x1) +float 0x17 != 0x8000 == 0x1 (0x1) +int 0x17 >= 0x8000 == 0x1 (0x1) +__uint 0x17 >= 0x8000 == 0x0 (0x0) +char 0x17 >= 0x0 == 0x1 (0x1) +__uchar 0x17 >= 0x0 == 0x1 (0x1) +__longlong 0x17 >= 0x8000 == 0x1 (0x1) +__ulonglong 0x17 >= 0x8000 == 0x0 (0x0) +float 0x17 >= 0x8000 == 0x1 (0x1) +int 0x17 / 0x8000 == 0x0 (0x0) +__uint 0x17 / 0x8000 == 0x0 (0x0) +__longlong 0x17 / 0x8000 == 0x0 (0x0) +__ulonglong 0x17 / 0x8000 == 0x0 (0x0) +float 0x17 / 0x8000 == 0x0 (0x0) +int 0x17 % 0x8000 == 0x17 (0x17) +__uint 0x17 % 0x8000 == 0x17 (0x17) +__longlong 0x17 % 0x8000 == 0x17 (0x17) +__ulonglong 0x17 % 0x8000 == 0x17 (0x17) +0x17 * 0x3e8 == 0x59d8 +0x17 / 0x3e8 == 0x0 +0x17 % 0x3e8 == 0x17 +int 0x17 ^ 0x3e8 == 0x3ff (0x3ff) +__uint 0x17 ^ 0x3e8 == 0x3ff (0x3ff) +char 0x17 ^ 0xffe8 == -0x1 (0xffff) +__uchar 0x17 ^ 0xe8 == 0xff (0xff) +__longlong 0x17 ^ 0x3e8 == 0x3ff (0x3ff) +__ulonglong 0x17 ^ 0x3e8 == 0x3ff (0x3ff) +int 0x17 && 0x3e8 == 0x1 (0x1) +__uint 0x17 && 0x3e8 == 0x1 (0x1) +char 0x17 && 0xffe8 == 0x1 (0x1) +__uchar 0x17 && 0xe8 == 0x1 (0x1) +__longlong 0x17 && 0x3e8 == 0x1 (0x1) +__ulonglong 0x17 && 0x3e8 == 0x1 (0x1) +int 0x17 || 0x3e8 == 0x1 (0x1) +__uint 0x17 || 0x3e8 == 0x1 (0x1) +char 0x17 || 0xffe8 == 0x1 (0x1) +__uchar 0x17 || 0xe8 == 0x1 (0x1) +__longlong 0x17 || 0x3e8 == 0x1 (0x1) +__ulonglong 0x17 || 0x3e8 == 0x1 (0x1) +int 0x17 & 0x3e8 == 0x0 (0x0) +__uint 0x17 & 0x3e8 == 0x0 (0x0) +char 0x17 & 0xffe8 == 0x0 (0x0) +__uchar 0x17 & 0xe8 == 0x0 (0x0) +__longlong 0x17 & 0x3e8 == 0x0 (0x0) +__ulonglong 0x17 & 0x3e8 == 0x0 (0x0) +int 0x17 | 0x3e8 == 0x3ff (0x3ff) +__uint 0x17 | 0x3e8 == 0x3ff (0x3ff) +char 0x17 | 0xffe8 == -0x1 (0xffff) +__uchar 0x17 | 0xe8 == 0xff (0xff) +__longlong 0x17 | 0x3e8 == 0x3ff (0x3ff) +__ulonglong 0x17 | 0x3e8 == 0x3ff (0x3ff) +int 0x17 << 0x14 == 0x0 (0x0) +__uint 0x17 << 0x14 == 0x0 (0x0) +char 0x17 << 0x14 == 0x0 (0x0) +__uchar 0x17 << 0x14 == 0x0 (0x0) +__longlong 0x17 << 0x14 == 0x0 (0x0) +__ulonglong 0x17 << 0x14 == 0x0 (0x0) +int 0x17 >> 0x14 == 0x0 (0x0) +__uint 0x17 >> 0x14 == 0x0 (0x0) +char 0x17 >> 0x14 == 0x0 (0x0) +__uchar 0x17 >> 0x14 == 0x0 (0x0) +__longlong 0x17 >> 0x14 == 0x0 (0x0) +__ulonglong 0x17 >> 0x14 == 0x0 (0x0) +int 0x17 + 0x3e8 == 0x3ff (0x3ff) +__uint 0x17 + 0x3e8 == 0x3ff (0x3ff) +char 0x17 + 0xffe8 == -0x1 (0xffff) +__uchar 0x17 + 0xe8 == 0xff (0xff) +__longlong 0x17 + 0x3e8 == 0x3ff (0x3ff) +__ulonglong 0x17 + 0x3e8 == 0x3ff (0x3ff) +float 0x17 + 0x3e8 == 0x3ff (0x3ff) +int 0x17 - 0x3e8 == -0x3d1 (0xfc2f) +__uint 0x17 - 0x3e8 == -0x3d1 (0xfc2f) +char 0x17 - 0xffe8 == 0x2f (0x2f) +__uchar 0x17 - 0xe8 == 0x2f (0x2f) +__longlong 0x17 - 0x3e8 == -0x3d1 (0xfc2f) +__ulonglong 0x17 - 0x3e8 == -0x3d1 (0xfc2f) +float 0x17 - 0x3e8 == -0x3d1 (0xfc2f) +int 0x17 * 0x3e8 == 0x59d8 (0x59d8) +__uint 0x17 * 0x3e8 == 0x59d8 (0x59d8) +char 0x17 * 0xffe8 == -0x28 (0xffd8) +__uchar 0x17 * 0xe8 == 0xd8 (0xd8) +__longlong 0x17 * 0x3e8 == 0x59d8 (0x59d8) +__ulonglong 0x17 * 0x3e8 == 0x59d8 (0x59d8) +float 0x17 * 0x3e8 == 0x59d8 (0x59d8) +int 0x17 < 0x3e8 == 0x1 (0x1) +__uint 0x17 < 0x3e8 == 0x1 (0x1) +char 0x17 < 0xffe8 == 0x0 (0x0) +__uchar 0x17 < 0xe8 == 0x1 (0x1) +__longlong 0x17 < 0x3e8 == 0x1 (0x1) +__ulonglong 0x17 < 0x3e8 == 0x1 (0x1) +float 0x17 < 0x3e8 == 0x1 (0x1) +int 0x17 > 0x3e8 == 0x0 (0x0) +__uint 0x17 > 0x3e8 == 0x0 (0x0) +char 0x17 > 0xffe8 == 0x1 (0x1) +__uchar 0x17 > 0xe8 == 0x0 (0x0) +__longlong 0x17 > 0x3e8 == 0x0 (0x0) +__ulonglong 0x17 > 0x3e8 == 0x0 (0x0) +float 0x17 > 0x3e8 == 0x0 (0x0) +int 0x17 <= 0x3e8 == 0x1 (0x1) +__uint 0x17 <= 0x3e8 == 0x1 (0x1) +char 0x17 <= 0xffe8 == 0x0 (0x0) +__uchar 0x17 <= 0xe8 == 0x1 (0x1) +__longlong 0x17 <= 0x3e8 == 0x1 (0x1) +__ulonglong 0x17 <= 0x3e8 == 0x1 (0x1) +float 0x17 <= 0x3e8 == 0x1 (0x1) +int 0x17 == 0x3e8 == 0x0 (0x0) +__uint 0x17 == 0x3e8 == 0x0 (0x0) +char 0x17 == 0xffe8 == 0x0 (0x0) +__uchar 0x17 == 0xe8 == 0x0 (0x0) +__longlong 0x17 == 0x3e8 == 0x0 (0x0) +__ulonglong 0x17 == 0x3e8 == 0x0 (0x0) +float 0x17 == 0x3e8 == 0x0 (0x0) +int 0x17 != 0x3e8 == 0x1 (0x1) +__uint 0x17 != 0x3e8 == 0x1 (0x1) +char 0x17 != 0xffe8 == 0x1 (0x1) +__uchar 0x17 != 0xe8 == 0x1 (0x1) +__longlong 0x17 != 0x3e8 == 0x1 (0x1) +__ulonglong 0x17 != 0x3e8 == 0x1 (0x1) +float 0x17 != 0x3e8 == 0x1 (0x1) +int 0x17 >= 0x3e8 == 0x0 (0x0) +__uint 0x17 >= 0x3e8 == 0x0 (0x0) +char 0x17 >= 0xffe8 == 0x1 (0x1) +__uchar 0x17 >= 0xe8 == 0x0 (0x0) +__longlong 0x17 >= 0x3e8 == 0x0 (0x0) +__ulonglong 0x17 >= 0x3e8 == 0x0 (0x0) +float 0x17 >= 0x3e8 == 0x0 (0x0) +int 0x17 / 0x3e8 == 0x0 (0x0) +__uint 0x17 / 0x3e8 == 0x0 (0x0) +char 0x17 / 0xffe8 == 0x0 (0x0) +__uchar 0x17 / 0xe8 == 0x0 (0x0) +__longlong 0x17 / 0x3e8 == 0x0 (0x0) +__ulonglong 0x17 / 0x3e8 == 0x0 (0x0) +float 0x17 / 0x3e8 == 0x0 (0x0) +int 0x17 % 0x3e8 == 0x17 (0x17) +__uint 0x17 % 0x3e8 == 0x17 (0x17) +char 0x17 % 0xffe8 == 0x17 (0x17) +__uchar 0x17 % 0xe8 == 0x17 (0x17) +__longlong 0x17 % 0x3e8 == 0x17 (0x17) +__ulonglong 0x17 % 0x3e8 == 0x17 (0x17) +0x17 * 0x2710 == -0x7d90 +0x17 / 0x2710 == 0x0 +0x17 % 0x2710 == 0x17 +int 0x17 ^ 0x2710 == 0x2707 (0x2707) +__uint 0x17 ^ 0x2710 == 0x2707 (0x2707) +char 0x17 ^ 0x10 == 0x7 (0x7) +__uchar 0x17 ^ 0x10 == 0x7 (0x7) +__longlong 0x17 ^ 0x2710 == 0x2707 (0x2707) +__ulonglong 0x17 ^ 0x2710 == 0x2707 (0x2707) +int 0x17 && 0x2710 == 0x1 (0x1) +__uint 0x17 && 0x2710 == 0x1 (0x1) +char 0x17 && 0x10 == 0x1 (0x1) +__uchar 0x17 && 0x10 == 0x1 (0x1) +__longlong 0x17 && 0x2710 == 0x1 (0x1) +__ulonglong 0x17 && 0x2710 == 0x1 (0x1) +int 0x17 || 0x2710 == 0x1 (0x1) +__uint 0x17 || 0x2710 == 0x1 (0x1) +char 0x17 || 0x10 == 0x1 (0x1) +__uchar 0x17 || 0x10 == 0x1 (0x1) +__longlong 0x17 || 0x2710 == 0x1 (0x1) +__ulonglong 0x17 || 0x2710 == 0x1 (0x1) +int 0x17 & 0x2710 == 0x10 (0x10) +__uint 0x17 & 0x2710 == 0x10 (0x10) +char 0x17 & 0x10 == 0x10 (0x10) +__uchar 0x17 & 0x10 == 0x10 (0x10) +__longlong 0x17 & 0x2710 == 0x10 (0x10) +__ulonglong 0x17 & 0x2710 == 0x10 (0x10) +int 0x17 | 0x2710 == 0x2717 (0x2717) +__uint 0x17 | 0x2710 == 0x2717 (0x2717) +char 0x17 | 0x10 == 0x17 (0x17) +__uchar 0x17 | 0x10 == 0x17 (0x17) +__longlong 0x17 | 0x2710 == 0x2717 (0x2717) +__ulonglong 0x17 | 0x2710 == 0x2717 (0x2717) +int 0x17 << 0x16 == 0x0 (0x0) +__uint 0x17 << 0x16 == 0x0 (0x0) +char 0x17 << 0x16 == 0x0 (0x0) +__uchar 0x17 << 0x16 == 0x0 (0x0) +__longlong 0x17 << 0x16 == 0x0 (0x0) +__ulonglong 0x17 << 0x16 == 0x0 (0x0) +int 0x17 >> 0x16 == 0x0 (0x0) +__uint 0x17 >> 0x16 == 0x0 (0x0) +char 0x17 >> 0x16 == 0x0 (0x0) +__uchar 0x17 >> 0x16 == 0x0 (0x0) +__longlong 0x17 >> 0x16 == 0x0 (0x0) +__ulonglong 0x17 >> 0x16 == 0x0 (0x0) +int 0x17 + 0x2710 == 0x2727 (0x2727) +__uint 0x17 + 0x2710 == 0x2727 (0x2727) +char 0x17 + 0x10 == 0x27 (0x27) +__uchar 0x17 + 0x10 == 0x27 (0x27) +__longlong 0x17 + 0x2710 == 0x2727 (0x2727) +__ulonglong 0x17 + 0x2710 == 0x2727 (0x2727) +float 0x17 + 0x2710 == 0x2727 (0x2727) +int 0x17 - 0x2710 == -0x26f9 (0xd907) +__uint 0x17 - 0x2710 == -0x26f9 (0xd907) +char 0x17 - 0x10 == 0x7 (0x7) +__uchar 0x17 - 0x10 == 0x7 (0x7) +__longlong 0x17 - 0x2710 == -0x26f9 (0xd907) +__ulonglong 0x17 - 0x2710 == -0x26f9 (0xd907) +float 0x17 - 0x2710 == -0x26f9 (0xd907) +int 0x17 * 0x2710 == -0x7d90 (0x8270) +__uint 0x17 * 0x2710 == -0x7d90 (0x8270) +char 0x17 * 0x10 == 0x70 (0x70) +__uchar 0x17 * 0x10 == 0x70 (0x70) +__longlong 0x17 * 0x2710 == -0x7d90 (0x8270) +__ulonglong 0x17 * 0x2710 == -0x7d90 (0x8270) +float 0x17 * 0x2710 == -0x8000 (0x8000) +int 0x17 < 0x2710 == 0x1 (0x1) +__uint 0x17 < 0x2710 == 0x1 (0x1) +char 0x17 < 0x10 == 0x0 (0x0) +__uchar 0x17 < 0x10 == 0x0 (0x0) +__longlong 0x17 < 0x2710 == 0x1 (0x1) +__ulonglong 0x17 < 0x2710 == 0x1 (0x1) +float 0x17 < 0x2710 == 0x1 (0x1) +int 0x17 > 0x2710 == 0x0 (0x0) +__uint 0x17 > 0x2710 == 0x0 (0x0) +char 0x17 > 0x10 == 0x1 (0x1) +__uchar 0x17 > 0x10 == 0x1 (0x1) +__longlong 0x17 > 0x2710 == 0x0 (0x0) +__ulonglong 0x17 > 0x2710 == 0x0 (0x0) +float 0x17 > 0x2710 == 0x0 (0x0) +int 0x17 <= 0x2710 == 0x1 (0x1) +__uint 0x17 <= 0x2710 == 0x1 (0x1) +char 0x17 <= 0x10 == 0x0 (0x0) +__uchar 0x17 <= 0x10 == 0x0 (0x0) +__longlong 0x17 <= 0x2710 == 0x1 (0x1) +__ulonglong 0x17 <= 0x2710 == 0x1 (0x1) +float 0x17 <= 0x2710 == 0x1 (0x1) +int 0x17 == 0x2710 == 0x0 (0x0) +__uint 0x17 == 0x2710 == 0x0 (0x0) +char 0x17 == 0x10 == 0x0 (0x0) +__uchar 0x17 == 0x10 == 0x0 (0x0) +__longlong 0x17 == 0x2710 == 0x0 (0x0) +__ulonglong 0x17 == 0x2710 == 0x0 (0x0) +float 0x17 == 0x2710 == 0x0 (0x0) +int 0x17 != 0x2710 == 0x1 (0x1) +__uint 0x17 != 0x2710 == 0x1 (0x1) +char 0x17 != 0x10 == 0x1 (0x1) +__uchar 0x17 != 0x10 == 0x1 (0x1) +__longlong 0x17 != 0x2710 == 0x1 (0x1) +__ulonglong 0x17 != 0x2710 == 0x1 (0x1) +float 0x17 != 0x2710 == 0x1 (0x1) +int 0x17 >= 0x2710 == 0x0 (0x0) +__uint 0x17 >= 0x2710 == 0x0 (0x0) +char 0x17 >= 0x10 == 0x1 (0x1) +__uchar 0x17 >= 0x10 == 0x1 (0x1) +__longlong 0x17 >= 0x2710 == 0x0 (0x0) +__ulonglong 0x17 >= 0x2710 == 0x0 (0x0) +float 0x17 >= 0x2710 == 0x0 (0x0) +int 0x17 / 0x2710 == 0x0 (0x0) +__uint 0x17 / 0x2710 == 0x0 (0x0) +char 0x17 / 0x10 == 0x1 (0x1) +__uchar 0x17 / 0x10 == 0x1 (0x1) +__longlong 0x17 / 0x2710 == 0x0 (0x0) +__ulonglong 0x17 / 0x2710 == 0x0 (0x0) +float 0x17 / 0x2710 == 0x0 (0x0) +int 0x17 % 0x2710 == 0x17 (0x17) +__uint 0x17 % 0x2710 == 0x17 (0x17) +char 0x17 % 0x10 == 0x7 (0x7) +__uchar 0x17 % 0x10 == 0x7 (0x7) +__longlong 0x17 % 0x2710 == 0x17 (0x17) +__ulonglong 0x17 % 0x2710 == 0x17 (0x17) +int xor420x17 xor42 0x3d +__uint xor420x17 xor42 0x3d +char xor420x17 xor42 0x3d +__uchar xor420x17 xor42 0x3d +__longlong xor420x17 xor42 0x3d +__ulonglong xor420x17 xor42 0x3d +int land10x17 land1 0x1 +__uint land10x17 land1 0x1 +char land10x17 land1 0x1 +__uchar land10x17 land1 0x1 +__longlong land10x17 land1 0x1 +__ulonglong land10x17 land1 0x1 +int lor10x17 lor1 0x1 +__uint lor10x17 lor1 0x1 +char lor10x17 lor1 0x1 +__uchar lor10x17 lor1 0x1 +__longlong lor10x17 lor1 0x1 +__ulonglong lor10x17 lor1 0x1 +int and420x17 and42 0x2 +__uint and420x17 and42 0x2 +char and420x17 and42 0x2 +__uchar and420x17 and42 0x2 +__longlong and420x17 and42 0x2 +__ulonglong and420x17 and42 0x2 +int or420x17 or42 0x3f +__uint or420x17 or42 0x3f +char or420x17 or42 0x3f +__uchar or420x17 or42 0x3f +__longlong or420x17 or42 0x3f +__ulonglong or420x17 or42 0x3f +int shl50x17 shl5 0x2e0 +__uint shl50x17 shl5 0x2e0 +char shl50x17 shl5 -0x20 +__uchar shl50x17 shl5 0xe0 +__longlong shl50x17 shl5 0x2e0 +__ulonglong shl50x17 shl5 0x2e0 +int shr50x17 shr5 0x0 +__uint shr50x17 shr5 0x0 +char shr50x17 shr5 0x0 +__uchar shr50x17 shr5 0x0 +__longlong shr50x17 shr5 0x0 +__ulonglong shr50x17 shr5 0x0 +int add420x17 add42 0x41 +__uint add420x17 add42 0x41 +char add420x17 add42 0x41 +__uchar add420x17 add42 0x41 +__longlong add420x17 add42 0x41 +__ulonglong add420x17 add42 0x41 +float add420x17 add42 0x41 +int sub420x17 sub42 -0x13 +__uint sub420x17 sub42 -0x13 +char sub420x17 sub42 -0x13 +__uchar sub420x17 sub42 0xed +__longlong sub420x17 sub42 -0x13 +__ulonglong sub420x17 sub42 -0x13 +float sub420x17 sub42 -0x13 +int mul420x17 mul42 0x3c6 +__uint mul420x17 mul42 0x3c6 +char mul420x17 mul42 -0x3a +__uchar mul420x17 mul42 0xc6 +__longlong mul420x17 mul42 0x3c6 +__ulonglong mul420x17 mul42 0x3c6 +float mul420x17 mul42 0x3c6 +int lt420x17 lt42 0x1 +__uint lt420x17 lt42 0x1 +char lt420x17 lt42 0x1 +__uchar lt420x17 lt42 0x1 +__longlong lt420x17 lt42 0x1 +__ulonglong lt420x17 lt42 0x1 +float lt420x17 lt42 0x1 +int gt420x17 gt42 0x0 +__uint gt420x17 gt42 0x0 +char gt420x17 gt42 0x0 +__uchar gt420x17 gt42 0x0 +__longlong gt420x17 gt42 0x0 +__ulonglong gt420x17 gt42 0x0 +float gt420x17 gt42 0x0 +int le420x17 le42 0x1 +__uint le420x17 le42 0x1 +char le420x17 le42 0x1 +__uchar le420x17 le42 0x1 +__longlong le420x17 le42 0x1 +__ulonglong le420x17 le42 0x1 +float le420x17 le42 0x1 +int eq420x17 eq42 0x0 +__uint eq420x17 eq42 0x0 +char eq420x17 eq42 0x0 +__uchar eq420x17 eq42 0x0 +__longlong eq420x17 eq42 0x0 +__ulonglong eq420x17 eq42 0x0 +float eq420x17 eq42 0x0 +int ne420x17 ne42 0x1 +__uint ne420x17 ne42 0x1 +char ne420x17 ne42 0x1 +__uchar ne420x17 ne42 0x1 +__longlong ne420x17 ne42 0x1 +__ulonglong ne420x17 ne42 0x1 +float ne420x17 ne42 0x1 +int ge420x17 ge42 0x0 +__uint ge420x17 ge42 0x0 +char ge420x17 ge42 0x0 +__uchar ge420x17 ge42 0x0 +__longlong ge420x17 ge42 0x0 +__ulonglong ge420x17 ge42 0x0 +float ge420x17 ge42 0x0 +int div420x17 div42 0x0 +__uint div420x17 div42 0x0 +char div420x17 div42 0x0 +__uchar div420x17 div42 0x0 +__longlong div420x17 div42 0x0 +__ulonglong div420x17 div42 0x0 +float div420x17 div42 0x0 +int mod230x17 mod23 0x0 +__uint mod230x17 mod23 0x0 +char mod230x17 mod23 0x0 +__uchar mod230x17 mod23 0x0 +__longlong mod230x17 mod23 0x0 +__ulonglong mod230x17 mod23 0x0 +0x7fff * 0xffff == -0x7fff +0x7fff / 0xffff == -0x7fff +0x7fff % 0xffff == 0x0 +int 0x7fff ^ 0xffff == -0x8000 (0x8000) +__uint 0x7fff ^ 0xffff == -0x8000 (0x8000) +char 0xffff ^ 0xffff == 0x0 (0x0) +__uchar 0xff ^ 0xff == 0x0 (0x0) +__longlong 0x7fff ^ 0xffff == -0x8000 (0x8000) +__ulonglong 0x7fff ^ 0xffff == -0x8000 (0x8000) +int 0x7fff && 0xffff == 0x1 (0x1) +__uint 0x7fff && 0xffff == 0x1 (0x1) +char 0xffff && 0xffff == 0x1 (0x1) +__uchar 0xff && 0xff == 0x1 (0x1) +__longlong 0x7fff && 0xffff == 0x1 (0x1) +__ulonglong 0x7fff && 0xffff == 0x1 (0x1) +int 0x7fff || 0xffff == 0x1 (0x1) +__uint 0x7fff || 0xffff == 0x1 (0x1) +char 0xffff || 0xffff == 0x1 (0x1) +__uchar 0xff || 0xff == 0x1 (0x1) +__longlong 0x7fff || 0xffff == 0x1 (0x1) +__ulonglong 0x7fff || 0xffff == 0x1 (0x1) +int 0x7fff & 0xffff == 0x7fff (0x7fff) +__uint 0x7fff & 0xffff == 0x7fff (0x7fff) +char 0xffff & 0xffff == -0x1 (0xffff) +__uchar 0xff & 0xff == 0xff (0xff) +__longlong 0x7fff & 0xffff == 0x7fff (0x7fff) +__ulonglong 0x7fff & 0xffff == 0x7fff (0x7fff) +int 0x7fff | 0xffff == -0x1 (0xffff) +__uint 0x7fff | 0xffff == -0x1 (0xffff) +char 0xffff | 0xffff == -0x1 (0xffff) +__uchar 0xff | 0xff == 0xff (0xff) +__longlong 0x7fff | 0xffff == -0x1 (0xffff) +__ulonglong 0x7fff | 0xffff == -0x1 (0xffff) +int 0x7fff << 0x1 == -0x2 (0xfffe) +__uint 0x7fff << 0x1 == -0x2 (0xfffe) +char 0xffff << 0x1 == -0x2 (0xfffe) +__uchar 0xff << 0x1 == 0xfe (0xfe) +__longlong 0x7fff << 0x1 == -0x2 (0xfffe) +__ulonglong 0x7fff << 0x1 == -0x2 (0xfffe) +int 0x7fff >> 0x1 == 0x3fff (0x3fff) +__uint 0x7fff >> 0x1 == 0x3fff (0x3fff) +char 0xffff >> 0x1 == -0x1 (0xffff) +__uchar 0xff >> 0x1 == 0x7f (0x7f) +__longlong 0x7fff >> 0x1 == 0x3fff (0x3fff) +__ulonglong 0x7fff >> 0x1 == 0x3fff (0x3fff) +int 0x7fff + 0xffff == 0x7ffe (0x7ffe) +__uint 0x7fff + 0xffff == 0x7ffe (0x7ffe) +char 0xffff + 0xffff == -0x2 (0xfffe) +__uchar 0xff + 0xff == 0xfe (0xfe) +__longlong 0x7fff + 0xffff == 0x7ffe (0x7ffe) +__ulonglong 0x7fff + 0xffff == 0x7ffe (0x7ffe) +float 0x7fff + 0xffff == 0x7ffe (0x7ffe) +int 0x7fff - 0xffff == -0x8000 (0x8000) +__uint 0x7fff - 0xffff == -0x8000 (0x8000) +char 0xffff - 0xffff == 0x0 (0x0) +__uchar 0xff - 0xff == 0x0 (0x0) +__longlong 0x7fff - 0xffff == -0x8000 (0x8000) +__ulonglong 0x7fff - 0xffff == -0x8000 (0x8000) +float 0x7fff - 0xffff == -0x8000 (0x8000) +int 0x7fff * 0xffff == -0x7fff (0x8001) +__uint 0x7fff * 0xffff == -0x7fff (0x8001) +char 0xffff * 0xffff == 0x1 (0x1) +__uchar 0xff * 0xff == 0x1 (0x1) +__longlong 0x7fff * 0xffff == -0x7fff (0x8001) +__ulonglong 0x7fff * 0xffff == -0x7fff (0x8001) +float 0x7fff * 0xffff == -0x7fff (0x8001) +int 0x7fff < 0xffff == 0x0 (0x0) +__uint 0x7fff < 0xffff == 0x1 (0x1) +char 0xffff < 0xffff == 0x0 (0x0) +__uchar 0xff < 0xff == 0x0 (0x0) +__longlong 0x7fff < 0xffff == 0x0 (0x0) +__ulonglong 0x7fff < 0xffff == 0x1 (0x1) +float 0x7fff < 0xffff == 0x0 (0x0) +int 0x7fff > 0xffff == 0x1 (0x1) +__uint 0x7fff > 0xffff == 0x0 (0x0) +char 0xffff > 0xffff == 0x0 (0x0) +__uchar 0xff > 0xff == 0x0 (0x0) +__longlong 0x7fff > 0xffff == 0x1 (0x1) +__ulonglong 0x7fff > 0xffff == 0x0 (0x0) +float 0x7fff > 0xffff == 0x1 (0x1) +int 0x7fff <= 0xffff == 0x0 (0x0) +__uint 0x7fff <= 0xffff == 0x1 (0x1) +char 0xffff <= 0xffff == 0x1 (0x1) +__uchar 0xff <= 0xff == 0x1 (0x1) +__longlong 0x7fff <= 0xffff == 0x0 (0x0) +__ulonglong 0x7fff <= 0xffff == 0x1 (0x1) +float 0x7fff <= 0xffff == 0x0 (0x0) +int 0x7fff == 0xffff == 0x0 (0x0) +__uint 0x7fff == 0xffff == 0x0 (0x0) +char 0xffff == 0xffff == 0x1 (0x1) +__uchar 0xff == 0xff == 0x1 (0x1) +__longlong 0x7fff == 0xffff == 0x0 (0x0) +__ulonglong 0x7fff == 0xffff == 0x0 (0x0) +float 0x7fff == 0xffff == 0x0 (0x0) +int 0x7fff != 0xffff == 0x1 (0x1) +__uint 0x7fff != 0xffff == 0x1 (0x1) +char 0xffff != 0xffff == 0x0 (0x0) +__uchar 0xff != 0xff == 0x0 (0x0) +__longlong 0x7fff != 0xffff == 0x1 (0x1) +__ulonglong 0x7fff != 0xffff == 0x1 (0x1) +float 0x7fff != 0xffff == 0x1 (0x1) +int 0x7fff >= 0xffff == 0x1 (0x1) +__uint 0x7fff >= 0xffff == 0x0 (0x0) +char 0xffff >= 0xffff == 0x1 (0x1) +__uchar 0xff >= 0xff == 0x1 (0x1) +__longlong 0x7fff >= 0xffff == 0x1 (0x1) +__ulonglong 0x7fff >= 0xffff == 0x0 (0x0) +float 0x7fff >= 0xffff == 0x1 (0x1) +int 0x7fff / 0xffff == -0x7fff (0x8001) +__uint 0x7fff / 0xffff == 0x0 (0x0) +char 0xffff / 0xffff == 0x1 (0x1) +__uchar 0xff / 0xff == 0x1 (0x1) +__longlong 0x7fff / 0xffff == -0x7fff (0x8001) +__ulonglong 0x7fff / 0xffff == 0x0 (0x0) +float 0x7fff / 0xffff == -0x7fff (0x8001) +int 0x7fff % 0xffff == 0x0 (0x0) +__uint 0x7fff % 0xffff == 0x7fff (0x7fff) +char 0xffff % 0xffff == 0x0 (0x0) +__uchar 0xff % 0xff == 0x0 (0x0) +__longlong 0x7fff % 0xffff == 0x0 (0x0) +__ulonglong 0x7fff % 0xffff == 0x7fff (0x7fff) +0x7fff * 0x1 == 0x7fff +0x7fff / 0x1 == 0x7fff +0x7fff % 0x1 == 0x0 +int 0x7fff ^ 0x1 == 0x7ffe (0x7ffe) +__uint 0x7fff ^ 0x1 == 0x7ffe (0x7ffe) +char 0xffff ^ 0x1 == -0x2 (0xfffe) +__uchar 0xff ^ 0x1 == 0xfe (0xfe) +__longlong 0x7fff ^ 0x1 == 0x7ffe (0x7ffe) +__ulonglong 0x7fff ^ 0x1 == 0x7ffe (0x7ffe) +int 0x7fff && 0x1 == 0x1 (0x1) +__uint 0x7fff && 0x1 == 0x1 (0x1) +char 0xffff && 0x1 == 0x1 (0x1) +__uchar 0xff && 0x1 == 0x1 (0x1) +__longlong 0x7fff && 0x1 == 0x1 (0x1) +__ulonglong 0x7fff && 0x1 == 0x1 (0x1) +int 0x7fff || 0x1 == 0x1 (0x1) +__uint 0x7fff || 0x1 == 0x1 (0x1) +char 0xffff || 0x1 == 0x1 (0x1) +__uchar 0xff || 0x1 == 0x1 (0x1) +__longlong 0x7fff || 0x1 == 0x1 (0x1) +__ulonglong 0x7fff || 0x1 == 0x1 (0x1) +int 0x7fff & 0x1 == 0x1 (0x1) +__uint 0x7fff & 0x1 == 0x1 (0x1) +char 0xffff & 0x1 == 0x1 (0x1) +__uchar 0xff & 0x1 == 0x1 (0x1) +__longlong 0x7fff & 0x1 == 0x1 (0x1) +__ulonglong 0x7fff & 0x1 == 0x1 (0x1) +int 0x7fff | 0x1 == 0x7fff (0x7fff) +__uint 0x7fff | 0x1 == 0x7fff (0x7fff) +char 0xffff | 0x1 == -0x1 (0xffff) +__uchar 0xff | 0x1 == 0xff (0xff) +__longlong 0x7fff | 0x1 == 0x7fff (0x7fff) +__ulonglong 0x7fff | 0x1 == 0x7fff (0x7fff) +int 0x7fff << 0x2 == -0x4 (0xfffc) +__uint 0x7fff << 0x2 == -0x4 (0xfffc) +char 0xffff << 0x2 == -0x4 (0xfffc) +__uchar 0xff << 0x2 == 0xfc (0xfc) +__longlong 0x7fff << 0x2 == -0x4 (0xfffc) +__ulonglong 0x7fff << 0x2 == -0x4 (0xfffc) +int 0x7fff >> 0x2 == 0x1fff (0x1fff) +__uint 0x7fff >> 0x2 == 0x1fff (0x1fff) +char 0xffff >> 0x2 == -0x1 (0xffff) +__uchar 0xff >> 0x2 == 0x3f (0x3f) +__longlong 0x7fff >> 0x2 == 0x1fff (0x1fff) +__ulonglong 0x7fff >> 0x2 == 0x1fff (0x1fff) +int 0x7fff + 0x1 == -0x8000 (0x8000) +__uint 0x7fff + 0x1 == -0x8000 (0x8000) +char 0xffff + 0x1 == 0x0 (0x0) +__uchar 0xff + 0x1 == 0x0 (0x0) +__longlong 0x7fff + 0x1 == -0x8000 (0x8000) +__ulonglong 0x7fff + 0x1 == -0x8000 (0x8000) +float 0x7fff + 0x1 == -0x8000 (0x8000) +int 0x7fff - 0x1 == 0x7ffe (0x7ffe) +__uint 0x7fff - 0x1 == 0x7ffe (0x7ffe) +char 0xffff - 0x1 == -0x2 (0xfffe) +__uchar 0xff - 0x1 == 0xfe (0xfe) +__longlong 0x7fff - 0x1 == 0x7ffe (0x7ffe) +__ulonglong 0x7fff - 0x1 == 0x7ffe (0x7ffe) +float 0x7fff - 0x1 == 0x7ffe (0x7ffe) +int 0x7fff * 0x1 == 0x7fff (0x7fff) +__uint 0x7fff * 0x1 == 0x7fff (0x7fff) +char 0xffff * 0x1 == -0x1 (0xffff) +__uchar 0xff * 0x1 == 0xff (0xff) +__longlong 0x7fff * 0x1 == 0x7fff (0x7fff) +__ulonglong 0x7fff * 0x1 == 0x7fff (0x7fff) +float 0x7fff * 0x1 == 0x7fff (0x7fff) +int 0x7fff < 0x1 == 0x0 (0x0) +__uint 0x7fff < 0x1 == 0x0 (0x0) +char 0xffff < 0x1 == 0x1 (0x1) +__uchar 0xff < 0x1 == 0x0 (0x0) +__longlong 0x7fff < 0x1 == 0x0 (0x0) +__ulonglong 0x7fff < 0x1 == 0x0 (0x0) +float 0x7fff < 0x1 == 0x0 (0x0) +int 0x7fff > 0x1 == 0x1 (0x1) +__uint 0x7fff > 0x1 == 0x1 (0x1) +char 0xffff > 0x1 == 0x0 (0x0) +__uchar 0xff > 0x1 == 0x1 (0x1) +__longlong 0x7fff > 0x1 == 0x1 (0x1) +__ulonglong 0x7fff > 0x1 == 0x1 (0x1) +float 0x7fff > 0x1 == 0x1 (0x1) +int 0x7fff <= 0x1 == 0x0 (0x0) +__uint 0x7fff <= 0x1 == 0x0 (0x0) +char 0xffff <= 0x1 == 0x1 (0x1) +__uchar 0xff <= 0x1 == 0x0 (0x0) +__longlong 0x7fff <= 0x1 == 0x0 (0x0) +__ulonglong 0x7fff <= 0x1 == 0x0 (0x0) +float 0x7fff <= 0x1 == 0x0 (0x0) +int 0x7fff == 0x1 == 0x0 (0x0) +__uint 0x7fff == 0x1 == 0x0 (0x0) +char 0xffff == 0x1 == 0x0 (0x0) +__uchar 0xff == 0x1 == 0x0 (0x0) +__longlong 0x7fff == 0x1 == 0x0 (0x0) +__ulonglong 0x7fff == 0x1 == 0x0 (0x0) +float 0x7fff == 0x1 == 0x0 (0x0) +int 0x7fff != 0x1 == 0x1 (0x1) +__uint 0x7fff != 0x1 == 0x1 (0x1) +char 0xffff != 0x1 == 0x1 (0x1) +__uchar 0xff != 0x1 == 0x1 (0x1) +__longlong 0x7fff != 0x1 == 0x1 (0x1) +__ulonglong 0x7fff != 0x1 == 0x1 (0x1) +float 0x7fff != 0x1 == 0x1 (0x1) +int 0x7fff >= 0x1 == 0x1 (0x1) +__uint 0x7fff >= 0x1 == 0x1 (0x1) +char 0xffff >= 0x1 == 0x0 (0x0) +__uchar 0xff >= 0x1 == 0x1 (0x1) +__longlong 0x7fff >= 0x1 == 0x1 (0x1) +__ulonglong 0x7fff >= 0x1 == 0x1 (0x1) +float 0x7fff >= 0x1 == 0x1 (0x1) +int 0x7fff / 0x1 == 0x7fff (0x7fff) +__uint 0x7fff / 0x1 == 0x7fff (0x7fff) +char 0xffff / 0x1 == -0x1 (0xffff) +__uchar 0xff / 0x1 == 0xff (0xff) +__longlong 0x7fff / 0x1 == 0x7fff (0x7fff) +__ulonglong 0x7fff / 0x1 == 0x7fff (0x7fff) +float 0x7fff / 0x1 == 0x7fff (0x7fff) +int 0x7fff % 0x1 == 0x0 (0x0) +__uint 0x7fff % 0x1 == 0x0 (0x0) +char 0xffff % 0x1 == 0x0 (0x0) +__uchar 0xff % 0x1 == 0x0 (0x0) +__longlong 0x7fff % 0x1 == 0x0 (0x0) +__ulonglong 0x7fff % 0x1 == 0x0 (0x0) +0x7fff * 0x2 == -0x2 +0x7fff / 0x2 == 0x3fff +0x7fff % 0x2 == 0x1 +int 0x7fff ^ 0x2 == 0x7ffd (0x7ffd) +__uint 0x7fff ^ 0x2 == 0x7ffd (0x7ffd) +char 0xffff ^ 0x2 == -0x3 (0xfffd) +__uchar 0xff ^ 0x2 == 0xfd (0xfd) +__longlong 0x7fff ^ 0x2 == 0x7ffd (0x7ffd) +__ulonglong 0x7fff ^ 0x2 == 0x7ffd (0x7ffd) +int 0x7fff && 0x2 == 0x1 (0x1) +__uint 0x7fff && 0x2 == 0x1 (0x1) +char 0xffff && 0x2 == 0x1 (0x1) +__uchar 0xff && 0x2 == 0x1 (0x1) +__longlong 0x7fff && 0x2 == 0x1 (0x1) +__ulonglong 0x7fff && 0x2 == 0x1 (0x1) +int 0x7fff || 0x2 == 0x1 (0x1) +__uint 0x7fff || 0x2 == 0x1 (0x1) +char 0xffff || 0x2 == 0x1 (0x1) +__uchar 0xff || 0x2 == 0x1 (0x1) +__longlong 0x7fff || 0x2 == 0x1 (0x1) +__ulonglong 0x7fff || 0x2 == 0x1 (0x1) +int 0x7fff & 0x2 == 0x2 (0x2) +__uint 0x7fff & 0x2 == 0x2 (0x2) +char 0xffff & 0x2 == 0x2 (0x2) +__uchar 0xff & 0x2 == 0x2 (0x2) +__longlong 0x7fff & 0x2 == 0x2 (0x2) +__ulonglong 0x7fff & 0x2 == 0x2 (0x2) +int 0x7fff | 0x2 == 0x7fff (0x7fff) +__uint 0x7fff | 0x2 == 0x7fff (0x7fff) +char 0xffff | 0x2 == -0x1 (0xffff) +__uchar 0xff | 0x2 == 0xff (0xff) +__longlong 0x7fff | 0x2 == 0x7fff (0x7fff) +__ulonglong 0x7fff | 0x2 == 0x7fff (0x7fff) +int 0x7fff << 0x3 == -0x8 (0xfff8) +__uint 0x7fff << 0x3 == -0x8 (0xfff8) +char 0xffff << 0x3 == -0x8 (0xfff8) +__uchar 0xff << 0x3 == 0xf8 (0xf8) +__longlong 0x7fff << 0x3 == -0x8 (0xfff8) +__ulonglong 0x7fff << 0x3 == -0x8 (0xfff8) +int 0x7fff >> 0x3 == 0xfff (0xfff) +__uint 0x7fff >> 0x3 == 0xfff (0xfff) +char 0xffff >> 0x3 == -0x1 (0xffff) +__uchar 0xff >> 0x3 == 0x1f (0x1f) +__longlong 0x7fff >> 0x3 == 0xfff (0xfff) +__ulonglong 0x7fff >> 0x3 == 0xfff (0xfff) +int 0x7fff + 0x2 == -0x7fff (0x8001) +__uint 0x7fff + 0x2 == -0x7fff (0x8001) +char 0xffff + 0x2 == 0x1 (0x1) +__uchar 0xff + 0x2 == 0x1 (0x1) +__longlong 0x7fff + 0x2 == -0x7fff (0x8001) +__ulonglong 0x7fff + 0x2 == -0x7fff (0x8001) +float 0x7fff + 0x2 == -0x8000 (0x8000) +int 0x7fff - 0x2 == 0x7ffd (0x7ffd) +__uint 0x7fff - 0x2 == 0x7ffd (0x7ffd) +char 0xffff - 0x2 == -0x3 (0xfffd) +__uchar 0xff - 0x2 == 0xfd (0xfd) +__longlong 0x7fff - 0x2 == 0x7ffd (0x7ffd) +__ulonglong 0x7fff - 0x2 == 0x7ffd (0x7ffd) +float 0x7fff - 0x2 == 0x7ffd (0x7ffd) +int 0x7fff * 0x2 == -0x2 (0xfffe) +__uint 0x7fff * 0x2 == -0x2 (0xfffe) +char 0xffff * 0x2 == -0x2 (0xfffe) +__uchar 0xff * 0x2 == 0xfe (0xfe) +__longlong 0x7fff * 0x2 == -0x2 (0xfffe) +__ulonglong 0x7fff * 0x2 == -0x2 (0xfffe) +float 0x7fff * 0x2 == -0x8000 (0x8000) +int 0x7fff < 0x2 == 0x0 (0x0) +__uint 0x7fff < 0x2 == 0x0 (0x0) +char 0xffff < 0x2 == 0x1 (0x1) +__uchar 0xff < 0x2 == 0x0 (0x0) +__longlong 0x7fff < 0x2 == 0x0 (0x0) +__ulonglong 0x7fff < 0x2 == 0x0 (0x0) +float 0x7fff < 0x2 == 0x0 (0x0) +int 0x7fff > 0x2 == 0x1 (0x1) +__uint 0x7fff > 0x2 == 0x1 (0x1) +char 0xffff > 0x2 == 0x0 (0x0) +__uchar 0xff > 0x2 == 0x1 (0x1) +__longlong 0x7fff > 0x2 == 0x1 (0x1) +__ulonglong 0x7fff > 0x2 == 0x1 (0x1) +float 0x7fff > 0x2 == 0x1 (0x1) +int 0x7fff <= 0x2 == 0x0 (0x0) +__uint 0x7fff <= 0x2 == 0x0 (0x0) +char 0xffff <= 0x2 == 0x1 (0x1) +__uchar 0xff <= 0x2 == 0x0 (0x0) +__longlong 0x7fff <= 0x2 == 0x0 (0x0) +__ulonglong 0x7fff <= 0x2 == 0x0 (0x0) +float 0x7fff <= 0x2 == 0x0 (0x0) +int 0x7fff == 0x2 == 0x0 (0x0) +__uint 0x7fff == 0x2 == 0x0 (0x0) +char 0xffff == 0x2 == 0x0 (0x0) +__uchar 0xff == 0x2 == 0x0 (0x0) +__longlong 0x7fff == 0x2 == 0x0 (0x0) +__ulonglong 0x7fff == 0x2 == 0x0 (0x0) +float 0x7fff == 0x2 == 0x0 (0x0) +int 0x7fff != 0x2 == 0x1 (0x1) +__uint 0x7fff != 0x2 == 0x1 (0x1) +char 0xffff != 0x2 == 0x1 (0x1) +__uchar 0xff != 0x2 == 0x1 (0x1) +__longlong 0x7fff != 0x2 == 0x1 (0x1) +__ulonglong 0x7fff != 0x2 == 0x1 (0x1) +float 0x7fff != 0x2 == 0x1 (0x1) +int 0x7fff >= 0x2 == 0x1 (0x1) +__uint 0x7fff >= 0x2 == 0x1 (0x1) +char 0xffff >= 0x2 == 0x0 (0x0) +__uchar 0xff >= 0x2 == 0x1 (0x1) +__longlong 0x7fff >= 0x2 == 0x1 (0x1) +__ulonglong 0x7fff >= 0x2 == 0x1 (0x1) +float 0x7fff >= 0x2 == 0x1 (0x1) +int 0x7fff / 0x2 == 0x3fff (0x3fff) +__uint 0x7fff / 0x2 == 0x3fff (0x3fff) +char 0xffff / 0x2 == 0x0 (0x0) +__uchar 0xff / 0x2 == 0x7f (0x7f) +__longlong 0x7fff / 0x2 == 0x3fff (0x3fff) +__ulonglong 0x7fff / 0x2 == 0x3fff (0x3fff) +float 0x7fff / 0x2 == 0x3fff (0x3fff) +int 0x7fff % 0x2 == 0x1 (0x1) +__uint 0x7fff % 0x2 == 0x1 (0x1) +char 0xffff % 0x2 == -0x1 (0xffff) +__uchar 0xff % 0x2 == 0x1 (0x1) +__longlong 0x7fff % 0x2 == 0x1 (0x1) +__ulonglong 0x7fff % 0x2 == 0x1 (0x1) +0x7fff * 0xfffe == 0x2 +0x7fff / 0xfffe == -0x3fff +0x7fff % 0xfffe == 0x1 +int 0x7fff ^ 0xfffe == -0x7fff (0x8001) +__uint 0x7fff ^ 0xfffe == -0x7fff (0x8001) +char 0xffff ^ 0xfffe == 0x1 (0x1) +__uchar 0xff ^ 0xfe == 0x1 (0x1) +__longlong 0x7fff ^ 0xfffe == -0x7fff (0x8001) +__ulonglong 0x7fff ^ 0xfffe == -0x7fff (0x8001) +int 0x7fff && 0xfffe == 0x1 (0x1) +__uint 0x7fff && 0xfffe == 0x1 (0x1) +char 0xffff && 0xfffe == 0x1 (0x1) +__uchar 0xff && 0xfe == 0x1 (0x1) +__longlong 0x7fff && 0xfffe == 0x1 (0x1) +__ulonglong 0x7fff && 0xfffe == 0x1 (0x1) +int 0x7fff || 0xfffe == 0x1 (0x1) +__uint 0x7fff || 0xfffe == 0x1 (0x1) +char 0xffff || 0xfffe == 0x1 (0x1) +__uchar 0xff || 0xfe == 0x1 (0x1) +__longlong 0x7fff || 0xfffe == 0x1 (0x1) +__ulonglong 0x7fff || 0xfffe == 0x1 (0x1) +int 0x7fff & 0xfffe == 0x7ffe (0x7ffe) +__uint 0x7fff & 0xfffe == 0x7ffe (0x7ffe) +char 0xffff & 0xfffe == -0x2 (0xfffe) +__uchar 0xff & 0xfe == 0xfe (0xfe) +__longlong 0x7fff & 0xfffe == 0x7ffe (0x7ffe) +__ulonglong 0x7fff & 0xfffe == 0x7ffe (0x7ffe) +int 0x7fff | 0xfffe == -0x1 (0xffff) +__uint 0x7fff | 0xfffe == -0x1 (0xffff) +char 0xffff | 0xfffe == -0x1 (0xffff) +__uchar 0xff | 0xfe == 0xff (0xff) +__longlong 0x7fff | 0xfffe == -0x1 (0xffff) +__ulonglong 0x7fff | 0xfffe == -0x1 (0xffff) +int 0x7fff << 0x4 == -0x10 (0xfff0) +__uint 0x7fff << 0x4 == -0x10 (0xfff0) +char 0xffff << 0x4 == -0x10 (0xfff0) +__uchar 0xff << 0x4 == 0xf0 (0xf0) +__longlong 0x7fff << 0x4 == -0x10 (0xfff0) +__ulonglong 0x7fff << 0x4 == -0x10 (0xfff0) +int 0x7fff >> 0x4 == 0x7ff (0x7ff) +__uint 0x7fff >> 0x4 == 0x7ff (0x7ff) +char 0xffff >> 0x4 == -0x1 (0xffff) +__uchar 0xff >> 0x4 == 0xf (0xf) +__longlong 0x7fff >> 0x4 == 0x7ff (0x7ff) +__ulonglong 0x7fff >> 0x4 == 0x7ff (0x7ff) +int 0x7fff + 0xfffe == 0x7ffd (0x7ffd) +__uint 0x7fff + 0xfffe == 0x7ffd (0x7ffd) +char 0xffff + 0xfffe == -0x3 (0xfffd) +__uchar 0xff + 0xfe == 0xfd (0xfd) +__longlong 0x7fff + 0xfffe == 0x7ffd (0x7ffd) +__ulonglong 0x7fff + 0xfffe == 0x7ffd (0x7ffd) +float 0x7fff + 0xfffe == 0x7ffd (0x7ffd) +int 0x7fff - 0xfffe == -0x7fff (0x8001) +__uint 0x7fff - 0xfffe == -0x7fff (0x8001) +char 0xffff - 0xfffe == 0x1 (0x1) +__uchar 0xff - 0xfe == 0x1 (0x1) +__longlong 0x7fff - 0xfffe == -0x7fff (0x8001) +__ulonglong 0x7fff - 0xfffe == -0x7fff (0x8001) +float 0x7fff - 0xfffe == -0x8000 (0x8000) +int 0x7fff * 0xfffe == 0x2 (0x2) +__uint 0x7fff * 0xfffe == 0x2 (0x2) +char 0xffff * 0xfffe == 0x2 (0x2) +__uchar 0xff * 0xfe == 0x2 (0x2) +__longlong 0x7fff * 0xfffe == 0x2 (0x2) +__ulonglong 0x7fff * 0xfffe == 0x2 (0x2) +float 0x7fff * 0xfffe == -0x8000 (0x8000) +int 0x7fff < 0xfffe == 0x0 (0x0) +__uint 0x7fff < 0xfffe == 0x1 (0x1) +char 0xffff < 0xfffe == 0x0 (0x0) +__uchar 0xff < 0xfe == 0x0 (0x0) +__longlong 0x7fff < 0xfffe == 0x0 (0x0) +__ulonglong 0x7fff < 0xfffe == 0x1 (0x1) +float 0x7fff < 0xfffe == 0x0 (0x0) +int 0x7fff > 0xfffe == 0x1 (0x1) +__uint 0x7fff > 0xfffe == 0x0 (0x0) +char 0xffff > 0xfffe == 0x1 (0x1) +__uchar 0xff > 0xfe == 0x1 (0x1) +__longlong 0x7fff > 0xfffe == 0x1 (0x1) +__ulonglong 0x7fff > 0xfffe == 0x0 (0x0) +float 0x7fff > 0xfffe == 0x1 (0x1) +int 0x7fff <= 0xfffe == 0x0 (0x0) +__uint 0x7fff <= 0xfffe == 0x1 (0x1) +char 0xffff <= 0xfffe == 0x0 (0x0) +__uchar 0xff <= 0xfe == 0x0 (0x0) +__longlong 0x7fff <= 0xfffe == 0x0 (0x0) +__ulonglong 0x7fff <= 0xfffe == 0x1 (0x1) +float 0x7fff <= 0xfffe == 0x0 (0x0) +int 0x7fff == 0xfffe == 0x0 (0x0) +__uint 0x7fff == 0xfffe == 0x0 (0x0) +char 0xffff == 0xfffe == 0x0 (0x0) +__uchar 0xff == 0xfe == 0x0 (0x0) +__longlong 0x7fff == 0xfffe == 0x0 (0x0) +__ulonglong 0x7fff == 0xfffe == 0x0 (0x0) +float 0x7fff == 0xfffe == 0x0 (0x0) +int 0x7fff != 0xfffe == 0x1 (0x1) +__uint 0x7fff != 0xfffe == 0x1 (0x1) +char 0xffff != 0xfffe == 0x1 (0x1) +__uchar 0xff != 0xfe == 0x1 (0x1) +__longlong 0x7fff != 0xfffe == 0x1 (0x1) +__ulonglong 0x7fff != 0xfffe == 0x1 (0x1) +float 0x7fff != 0xfffe == 0x1 (0x1) +int 0x7fff >= 0xfffe == 0x1 (0x1) +__uint 0x7fff >= 0xfffe == 0x0 (0x0) +char 0xffff >= 0xfffe == 0x1 (0x1) +__uchar 0xff >= 0xfe == 0x1 (0x1) +__longlong 0x7fff >= 0xfffe == 0x1 (0x1) +__ulonglong 0x7fff >= 0xfffe == 0x0 (0x0) +float 0x7fff >= 0xfffe == 0x1 (0x1) +int 0x7fff / 0xfffe == -0x3fff (0xc001) +__uint 0x7fff / 0xfffe == 0x0 (0x0) +char 0xffff / 0xfffe == 0x0 (0x0) +__uchar 0xff / 0xfe == 0x1 (0x1) +__longlong 0x7fff / 0xfffe == -0x3fff (0xc001) +__ulonglong 0x7fff / 0xfffe == 0x0 (0x0) +float 0x7fff / 0xfffe == -0x3fff (0xc001) +int 0x7fff % 0xfffe == 0x1 (0x1) +__uint 0x7fff % 0xfffe == 0x7fff (0x7fff) +char 0xffff % 0xfffe == -0x1 (0xffff) +__uchar 0xff % 0xfe == 0x1 (0x1) +__longlong 0x7fff % 0xfffe == 0x1 (0x1) +__ulonglong 0x7fff % 0xfffe == 0x7fff (0x7fff) +0x7fff * 0x4 == -0x4 +0x7fff / 0x4 == 0x1fff +0x7fff % 0x4 == 0x3 +int 0x7fff ^ 0x4 == 0x7ffb (0x7ffb) +__uint 0x7fff ^ 0x4 == 0x7ffb (0x7ffb) +char 0xffff ^ 0x4 == -0x5 (0xfffb) +__uchar 0xff ^ 0x4 == 0xfb (0xfb) +__longlong 0x7fff ^ 0x4 == 0x7ffb (0x7ffb) +__ulonglong 0x7fff ^ 0x4 == 0x7ffb (0x7ffb) +int 0x7fff && 0x4 == 0x1 (0x1) +__uint 0x7fff && 0x4 == 0x1 (0x1) +char 0xffff && 0x4 == 0x1 (0x1) +__uchar 0xff && 0x4 == 0x1 (0x1) +__longlong 0x7fff && 0x4 == 0x1 (0x1) +__ulonglong 0x7fff && 0x4 == 0x1 (0x1) +int 0x7fff || 0x4 == 0x1 (0x1) +__uint 0x7fff || 0x4 == 0x1 (0x1) +char 0xffff || 0x4 == 0x1 (0x1) +__uchar 0xff || 0x4 == 0x1 (0x1) +__longlong 0x7fff || 0x4 == 0x1 (0x1) +__ulonglong 0x7fff || 0x4 == 0x1 (0x1) +int 0x7fff & 0x4 == 0x4 (0x4) +__uint 0x7fff & 0x4 == 0x4 (0x4) +char 0xffff & 0x4 == 0x4 (0x4) +__uchar 0xff & 0x4 == 0x4 (0x4) +__longlong 0x7fff & 0x4 == 0x4 (0x4) +__ulonglong 0x7fff & 0x4 == 0x4 (0x4) +int 0x7fff | 0x4 == 0x7fff (0x7fff) +__uint 0x7fff | 0x4 == 0x7fff (0x7fff) +char 0xffff | 0x4 == -0x1 (0xffff) +__uchar 0xff | 0x4 == 0xff (0xff) +__longlong 0x7fff | 0x4 == 0x7fff (0x7fff) +__ulonglong 0x7fff | 0x4 == 0x7fff (0x7fff) +int 0x7fff << 0x5 == -0x20 (0xffe0) +__uint 0x7fff << 0x5 == -0x20 (0xffe0) +char 0xffff << 0x5 == -0x20 (0xffe0) +__uchar 0xff << 0x5 == 0xe0 (0xe0) +__longlong 0x7fff << 0x5 == -0x20 (0xffe0) +__ulonglong 0x7fff << 0x5 == -0x20 (0xffe0) +int 0x7fff >> 0x5 == 0x3ff (0x3ff) +__uint 0x7fff >> 0x5 == 0x3ff (0x3ff) +char 0xffff >> 0x5 == -0x1 (0xffff) +__uchar 0xff >> 0x5 == 0x7 (0x7) +__longlong 0x7fff >> 0x5 == 0x3ff (0x3ff) +__ulonglong 0x7fff >> 0x5 == 0x3ff (0x3ff) +int 0x7fff + 0x4 == -0x7ffd (0x8003) +__uint 0x7fff + 0x4 == -0x7ffd (0x8003) +char 0xffff + 0x4 == 0x3 (0x3) +__uchar 0xff + 0x4 == 0x3 (0x3) +__longlong 0x7fff + 0x4 == -0x7ffd (0x8003) +__ulonglong 0x7fff + 0x4 == -0x7ffd (0x8003) +float 0x7fff + 0x4 == -0x8000 (0x8000) +int 0x7fff - 0x4 == 0x7ffb (0x7ffb) +__uint 0x7fff - 0x4 == 0x7ffb (0x7ffb) +char 0xffff - 0x4 == -0x5 (0xfffb) +__uchar 0xff - 0x4 == 0xfb (0xfb) +__longlong 0x7fff - 0x4 == 0x7ffb (0x7ffb) +__ulonglong 0x7fff - 0x4 == 0x7ffb (0x7ffb) +float 0x7fff - 0x4 == 0x7ffb (0x7ffb) +int 0x7fff * 0x4 == -0x4 (0xfffc) +__uint 0x7fff * 0x4 == -0x4 (0xfffc) +char 0xffff * 0x4 == -0x4 (0xfffc) +__uchar 0xff * 0x4 == 0xfc (0xfc) +__longlong 0x7fff * 0x4 == -0x4 (0xfffc) +__ulonglong 0x7fff * 0x4 == -0x4 (0xfffc) +float 0x7fff * 0x4 == -0x8000 (0x8000) +int 0x7fff < 0x4 == 0x0 (0x0) +__uint 0x7fff < 0x4 == 0x0 (0x0) +char 0xffff < 0x4 == 0x1 (0x1) +__uchar 0xff < 0x4 == 0x0 (0x0) +__longlong 0x7fff < 0x4 == 0x0 (0x0) +__ulonglong 0x7fff < 0x4 == 0x0 (0x0) +float 0x7fff < 0x4 == 0x0 (0x0) +int 0x7fff > 0x4 == 0x1 (0x1) +__uint 0x7fff > 0x4 == 0x1 (0x1) +char 0xffff > 0x4 == 0x0 (0x0) +__uchar 0xff > 0x4 == 0x1 (0x1) +__longlong 0x7fff > 0x4 == 0x1 (0x1) +__ulonglong 0x7fff > 0x4 == 0x1 (0x1) +float 0x7fff > 0x4 == 0x1 (0x1) +int 0x7fff <= 0x4 == 0x0 (0x0) +__uint 0x7fff <= 0x4 == 0x0 (0x0) +char 0xffff <= 0x4 == 0x1 (0x1) +__uchar 0xff <= 0x4 == 0x0 (0x0) +__longlong 0x7fff <= 0x4 == 0x0 (0x0) +__ulonglong 0x7fff <= 0x4 == 0x0 (0x0) +float 0x7fff <= 0x4 == 0x0 (0x0) +int 0x7fff == 0x4 == 0x0 (0x0) +__uint 0x7fff == 0x4 == 0x0 (0x0) +char 0xffff == 0x4 == 0x0 (0x0) +__uchar 0xff == 0x4 == 0x0 (0x0) +__longlong 0x7fff == 0x4 == 0x0 (0x0) +__ulonglong 0x7fff == 0x4 == 0x0 (0x0) +float 0x7fff == 0x4 == 0x0 (0x0) +int 0x7fff != 0x4 == 0x1 (0x1) +__uint 0x7fff != 0x4 == 0x1 (0x1) +char 0xffff != 0x4 == 0x1 (0x1) +__uchar 0xff != 0x4 == 0x1 (0x1) +__longlong 0x7fff != 0x4 == 0x1 (0x1) +__ulonglong 0x7fff != 0x4 == 0x1 (0x1) +float 0x7fff != 0x4 == 0x1 (0x1) +int 0x7fff >= 0x4 == 0x1 (0x1) +__uint 0x7fff >= 0x4 == 0x1 (0x1) +char 0xffff >= 0x4 == 0x0 (0x0) +__uchar 0xff >= 0x4 == 0x1 (0x1) +__longlong 0x7fff >= 0x4 == 0x1 (0x1) +__ulonglong 0x7fff >= 0x4 == 0x1 (0x1) +float 0x7fff >= 0x4 == 0x1 (0x1) +int 0x7fff / 0x4 == 0x1fff (0x1fff) +__uint 0x7fff / 0x4 == 0x1fff (0x1fff) +char 0xffff / 0x4 == 0x0 (0x0) +__uchar 0xff / 0x4 == 0x3f (0x3f) +__longlong 0x7fff / 0x4 == 0x1fff (0x1fff) +__ulonglong 0x7fff / 0x4 == 0x1fff (0x1fff) +float 0x7fff / 0x4 == 0x1fff (0x1fff) +int 0x7fff % 0x4 == 0x3 (0x3) +__uint 0x7fff % 0x4 == 0x3 (0x3) +char 0xffff % 0x4 == -0x1 (0xffff) +__uchar 0xff % 0x4 == 0x3 (0x3) +__longlong 0x7fff % 0x4 == 0x3 (0x3) +__ulonglong 0x7fff % 0x4 == 0x3 (0x3) +0x7fff * 0xfffc == 0x4 +0x7fff / 0xfffc == -0x1fff +0x7fff % 0xfffc == 0x3 +int 0x7fff ^ 0xfffc == -0x7ffd (0x8003) +__uint 0x7fff ^ 0xfffc == -0x7ffd (0x8003) +char 0xffff ^ 0xfffc == 0x3 (0x3) +__uchar 0xff ^ 0xfc == 0x3 (0x3) +__longlong 0x7fff ^ 0xfffc == -0x7ffd (0x8003) +__ulonglong 0x7fff ^ 0xfffc == -0x7ffd (0x8003) +int 0x7fff && 0xfffc == 0x1 (0x1) +__uint 0x7fff && 0xfffc == 0x1 (0x1) +char 0xffff && 0xfffc == 0x1 (0x1) +__uchar 0xff && 0xfc == 0x1 (0x1) +__longlong 0x7fff && 0xfffc == 0x1 (0x1) +__ulonglong 0x7fff && 0xfffc == 0x1 (0x1) +int 0x7fff || 0xfffc == 0x1 (0x1) +__uint 0x7fff || 0xfffc == 0x1 (0x1) +char 0xffff || 0xfffc == 0x1 (0x1) +__uchar 0xff || 0xfc == 0x1 (0x1) +__longlong 0x7fff || 0xfffc == 0x1 (0x1) +__ulonglong 0x7fff || 0xfffc == 0x1 (0x1) +int 0x7fff & 0xfffc == 0x7ffc (0x7ffc) +__uint 0x7fff & 0xfffc == 0x7ffc (0x7ffc) +char 0xffff & 0xfffc == -0x4 (0xfffc) +__uchar 0xff & 0xfc == 0xfc (0xfc) +__longlong 0x7fff & 0xfffc == 0x7ffc (0x7ffc) +__ulonglong 0x7fff & 0xfffc == 0x7ffc (0x7ffc) +int 0x7fff | 0xfffc == -0x1 (0xffff) +__uint 0x7fff | 0xfffc == -0x1 (0xffff) +char 0xffff | 0xfffc == -0x1 (0xffff) +__uchar 0xff | 0xfc == 0xff (0xff) +__longlong 0x7fff | 0xfffc == -0x1 (0xffff) +__ulonglong 0x7fff | 0xfffc == -0x1 (0xffff) +int 0x7fff << 0x6 == -0x40 (0xffc0) +__uint 0x7fff << 0x6 == -0x40 (0xffc0) +char 0xffff << 0x6 == -0x40 (0xffc0) +__uchar 0xff << 0x6 == 0xc0 (0xc0) +__longlong 0x7fff << 0x6 == -0x40 (0xffc0) +__ulonglong 0x7fff << 0x6 == -0x40 (0xffc0) +int 0x7fff >> 0x6 == 0x1ff (0x1ff) +__uint 0x7fff >> 0x6 == 0x1ff (0x1ff) +char 0xffff >> 0x6 == -0x1 (0xffff) +__uchar 0xff >> 0x6 == 0x3 (0x3) +__longlong 0x7fff >> 0x6 == 0x1ff (0x1ff) +__ulonglong 0x7fff >> 0x6 == 0x1ff (0x1ff) +int 0x7fff + 0xfffc == 0x7ffb (0x7ffb) +__uint 0x7fff + 0xfffc == 0x7ffb (0x7ffb) +char 0xffff + 0xfffc == -0x5 (0xfffb) +__uchar 0xff + 0xfc == 0xfb (0xfb) +__longlong 0x7fff + 0xfffc == 0x7ffb (0x7ffb) +__ulonglong 0x7fff + 0xfffc == 0x7ffb (0x7ffb) +float 0x7fff + 0xfffc == 0x7ffb (0x7ffb) +int 0x7fff - 0xfffc == -0x7ffd (0x8003) +__uint 0x7fff - 0xfffc == -0x7ffd (0x8003) +char 0xffff - 0xfffc == 0x3 (0x3) +__uchar 0xff - 0xfc == 0x3 (0x3) +__longlong 0x7fff - 0xfffc == -0x7ffd (0x8003) +__ulonglong 0x7fff - 0xfffc == -0x7ffd (0x8003) +float 0x7fff - 0xfffc == -0x8000 (0x8000) +int 0x7fff * 0xfffc == 0x4 (0x4) +__uint 0x7fff * 0xfffc == 0x4 (0x4) +char 0xffff * 0xfffc == 0x4 (0x4) +__uchar 0xff * 0xfc == 0x4 (0x4) +__longlong 0x7fff * 0xfffc == 0x4 (0x4) +__ulonglong 0x7fff * 0xfffc == 0x4 (0x4) +float 0x7fff * 0xfffc == -0x8000 (0x8000) +int 0x7fff < 0xfffc == 0x0 (0x0) +__uint 0x7fff < 0xfffc == 0x1 (0x1) +char 0xffff < 0xfffc == 0x0 (0x0) +__uchar 0xff < 0xfc == 0x0 (0x0) +__longlong 0x7fff < 0xfffc == 0x0 (0x0) +__ulonglong 0x7fff < 0xfffc == 0x1 (0x1) +float 0x7fff < 0xfffc == 0x0 (0x0) +int 0x7fff > 0xfffc == 0x1 (0x1) +__uint 0x7fff > 0xfffc == 0x0 (0x0) +char 0xffff > 0xfffc == 0x1 (0x1) +__uchar 0xff > 0xfc == 0x1 (0x1) +__longlong 0x7fff > 0xfffc == 0x1 (0x1) +__ulonglong 0x7fff > 0xfffc == 0x0 (0x0) +float 0x7fff > 0xfffc == 0x1 (0x1) +int 0x7fff <= 0xfffc == 0x0 (0x0) +__uint 0x7fff <= 0xfffc == 0x1 (0x1) +char 0xffff <= 0xfffc == 0x0 (0x0) +__uchar 0xff <= 0xfc == 0x0 (0x0) +__longlong 0x7fff <= 0xfffc == 0x0 (0x0) +__ulonglong 0x7fff <= 0xfffc == 0x1 (0x1) +float 0x7fff <= 0xfffc == 0x0 (0x0) +int 0x7fff == 0xfffc == 0x0 (0x0) +__uint 0x7fff == 0xfffc == 0x0 (0x0) +char 0xffff == 0xfffc == 0x0 (0x0) +__uchar 0xff == 0xfc == 0x0 (0x0) +__longlong 0x7fff == 0xfffc == 0x0 (0x0) +__ulonglong 0x7fff == 0xfffc == 0x0 (0x0) +float 0x7fff == 0xfffc == 0x0 (0x0) +int 0x7fff != 0xfffc == 0x1 (0x1) +__uint 0x7fff != 0xfffc == 0x1 (0x1) +char 0xffff != 0xfffc == 0x1 (0x1) +__uchar 0xff != 0xfc == 0x1 (0x1) +__longlong 0x7fff != 0xfffc == 0x1 (0x1) +__ulonglong 0x7fff != 0xfffc == 0x1 (0x1) +float 0x7fff != 0xfffc == 0x1 (0x1) +int 0x7fff >= 0xfffc == 0x1 (0x1) +__uint 0x7fff >= 0xfffc == 0x0 (0x0) +char 0xffff >= 0xfffc == 0x1 (0x1) +__uchar 0xff >= 0xfc == 0x1 (0x1) +__longlong 0x7fff >= 0xfffc == 0x1 (0x1) +__ulonglong 0x7fff >= 0xfffc == 0x0 (0x0) +float 0x7fff >= 0xfffc == 0x1 (0x1) +int 0x7fff / 0xfffc == -0x1fff (0xe001) +__uint 0x7fff / 0xfffc == 0x0 (0x0) +char 0xffff / 0xfffc == 0x0 (0x0) +__uchar 0xff / 0xfc == 0x1 (0x1) +__longlong 0x7fff / 0xfffc == -0x1fff (0xe001) +__ulonglong 0x7fff / 0xfffc == 0x0 (0x0) +float 0x7fff / 0xfffc == -0x1fff (0xe001) +int 0x7fff % 0xfffc == 0x3 (0x3) +__uint 0x7fff % 0xfffc == 0x7fff (0x7fff) +char 0xffff % 0xfffc == -0x1 (0xffff) +__uchar 0xff % 0xfc == 0x3 (0x3) +__longlong 0x7fff % 0xfffc == 0x3 (0x3) +__ulonglong 0x7fff % 0xfffc == 0x7fff (0x7fff) +0x7fff * 0xa == -0xa +0x7fff / 0xa == 0xccc +0x7fff % 0xa == 0x7 +int 0x7fff ^ 0xa == 0x7ff5 (0x7ff5) +__uint 0x7fff ^ 0xa == 0x7ff5 (0x7ff5) +char 0xffff ^ 0xa == -0xb (0xfff5) +__uchar 0xff ^ 0xa == 0xf5 (0xf5) +__longlong 0x7fff ^ 0xa == 0x7ff5 (0x7ff5) +__ulonglong 0x7fff ^ 0xa == 0x7ff5 (0x7ff5) +int 0x7fff && 0xa == 0x1 (0x1) +__uint 0x7fff && 0xa == 0x1 (0x1) +char 0xffff && 0xa == 0x1 (0x1) +__uchar 0xff && 0xa == 0x1 (0x1) +__longlong 0x7fff && 0xa == 0x1 (0x1) +__ulonglong 0x7fff && 0xa == 0x1 (0x1) +int 0x7fff || 0xa == 0x1 (0x1) +__uint 0x7fff || 0xa == 0x1 (0x1) +char 0xffff || 0xa == 0x1 (0x1) +__uchar 0xff || 0xa == 0x1 (0x1) +__longlong 0x7fff || 0xa == 0x1 (0x1) +__ulonglong 0x7fff || 0xa == 0x1 (0x1) +int 0x7fff & 0xa == 0xa (0xa) +__uint 0x7fff & 0xa == 0xa (0xa) +char 0xffff & 0xa == 0xa (0xa) +__uchar 0xff & 0xa == 0xa (0xa) +__longlong 0x7fff & 0xa == 0xa (0xa) +__ulonglong 0x7fff & 0xa == 0xa (0xa) +int 0x7fff | 0xa == 0x7fff (0x7fff) +__uint 0x7fff | 0xa == 0x7fff (0x7fff) +char 0xffff | 0xa == -0x1 (0xffff) +__uchar 0xff | 0xa == 0xff (0xff) +__longlong 0x7fff | 0xa == 0x7fff (0x7fff) +__ulonglong 0x7fff | 0xa == 0x7fff (0x7fff) +int 0x7fff << 0x7 == -0x80 (0xff80) +__uint 0x7fff << 0x7 == -0x80 (0xff80) +char 0xffff << 0x7 == -0x80 (0xff80) +__uchar 0xff << 0x7 == 0x80 (0x80) +__longlong 0x7fff << 0x7 == -0x80 (0xff80) +__ulonglong 0x7fff << 0x7 == -0x80 (0xff80) +int 0x7fff >> 0x7 == 0xff (0xff) +__uint 0x7fff >> 0x7 == 0xff (0xff) +char 0xffff >> 0x7 == -0x1 (0xffff) +__uchar 0xff >> 0x7 == 0x1 (0x1) +__longlong 0x7fff >> 0x7 == 0xff (0xff) +__ulonglong 0x7fff >> 0x7 == 0xff (0xff) +int 0x7fff + 0xa == -0x7ff7 (0x8009) +__uint 0x7fff + 0xa == -0x7ff7 (0x8009) +char 0xffff + 0xa == 0x9 (0x9) +__uchar 0xff + 0xa == 0x9 (0x9) +__longlong 0x7fff + 0xa == -0x7ff7 (0x8009) +__ulonglong 0x7fff + 0xa == -0x7ff7 (0x8009) +float 0x7fff + 0xa == -0x8000 (0x8000) +int 0x7fff - 0xa == 0x7ff5 (0x7ff5) +__uint 0x7fff - 0xa == 0x7ff5 (0x7ff5) +char 0xffff - 0xa == -0xb (0xfff5) +__uchar 0xff - 0xa == 0xf5 (0xf5) +__longlong 0x7fff - 0xa == 0x7ff5 (0x7ff5) +__ulonglong 0x7fff - 0xa == 0x7ff5 (0x7ff5) +float 0x7fff - 0xa == 0x7ff5 (0x7ff5) +int 0x7fff * 0xa == -0xa (0xfff6) +__uint 0x7fff * 0xa == -0xa (0xfff6) +char 0xffff * 0xa == -0xa (0xfff6) +__uchar 0xff * 0xa == 0xf6 (0xf6) +__longlong 0x7fff * 0xa == -0xa (0xfff6) +__ulonglong 0x7fff * 0xa == -0xa (0xfff6) +float 0x7fff * 0xa == -0x8000 (0x8000) +int 0x7fff < 0xa == 0x0 (0x0) +__uint 0x7fff < 0xa == 0x0 (0x0) +char 0xffff < 0xa == 0x1 (0x1) +__uchar 0xff < 0xa == 0x0 (0x0) +__longlong 0x7fff < 0xa == 0x0 (0x0) +__ulonglong 0x7fff < 0xa == 0x0 (0x0) +float 0x7fff < 0xa == 0x0 (0x0) +int 0x7fff > 0xa == 0x1 (0x1) +__uint 0x7fff > 0xa == 0x1 (0x1) +char 0xffff > 0xa == 0x0 (0x0) +__uchar 0xff > 0xa == 0x1 (0x1) +__longlong 0x7fff > 0xa == 0x1 (0x1) +__ulonglong 0x7fff > 0xa == 0x1 (0x1) +float 0x7fff > 0xa == 0x1 (0x1) +int 0x7fff <= 0xa == 0x0 (0x0) +__uint 0x7fff <= 0xa == 0x0 (0x0) +char 0xffff <= 0xa == 0x1 (0x1) +__uchar 0xff <= 0xa == 0x0 (0x0) +__longlong 0x7fff <= 0xa == 0x0 (0x0) +__ulonglong 0x7fff <= 0xa == 0x0 (0x0) +float 0x7fff <= 0xa == 0x0 (0x0) +int 0x7fff == 0xa == 0x0 (0x0) +__uint 0x7fff == 0xa == 0x0 (0x0) +char 0xffff == 0xa == 0x0 (0x0) +__uchar 0xff == 0xa == 0x0 (0x0) +__longlong 0x7fff == 0xa == 0x0 (0x0) +__ulonglong 0x7fff == 0xa == 0x0 (0x0) +float 0x7fff == 0xa == 0x0 (0x0) +int 0x7fff != 0xa == 0x1 (0x1) +__uint 0x7fff != 0xa == 0x1 (0x1) +char 0xffff != 0xa == 0x1 (0x1) +__uchar 0xff != 0xa == 0x1 (0x1) +__longlong 0x7fff != 0xa == 0x1 (0x1) +__ulonglong 0x7fff != 0xa == 0x1 (0x1) +float 0x7fff != 0xa == 0x1 (0x1) +int 0x7fff >= 0xa == 0x1 (0x1) +__uint 0x7fff >= 0xa == 0x1 (0x1) +char 0xffff >= 0xa == 0x0 (0x0) +__uchar 0xff >= 0xa == 0x1 (0x1) +__longlong 0x7fff >= 0xa == 0x1 (0x1) +__ulonglong 0x7fff >= 0xa == 0x1 (0x1) +float 0x7fff >= 0xa == 0x1 (0x1) +int 0x7fff / 0xa == 0xccc (0xccc) +__uint 0x7fff / 0xa == 0xccc (0xccc) +char 0xffff / 0xa == 0x0 (0x0) +__uchar 0xff / 0xa == 0x19 (0x19) +__longlong 0x7fff / 0xa == 0xccc (0xccc) +__ulonglong 0x7fff / 0xa == 0xccc (0xccc) +float 0x7fff / 0xa == 0xccc (0xccc) +int 0x7fff % 0xa == 0x7 (0x7) +__uint 0x7fff % 0xa == 0x7 (0x7) +char 0xffff % 0xa == -0x1 (0xffff) +__uchar 0xff % 0xa == 0x5 (0x5) +__longlong 0x7fff % 0xa == 0x7 (0x7) +__ulonglong 0x7fff % 0xa == 0x7 (0x7) +0x7fff * 0xfff6 == 0xa +0x7fff / 0xfff6 == -0xccc +0x7fff % 0xfff6 == 0x7 +int 0x7fff ^ 0xfff6 == -0x7ff7 (0x8009) +__uint 0x7fff ^ 0xfff6 == -0x7ff7 (0x8009) +char 0xffff ^ 0xfff6 == 0x9 (0x9) +__uchar 0xff ^ 0xf6 == 0x9 (0x9) +__longlong 0x7fff ^ 0xfff6 == -0x7ff7 (0x8009) +__ulonglong 0x7fff ^ 0xfff6 == -0x7ff7 (0x8009) +int 0x7fff && 0xfff6 == 0x1 (0x1) +__uint 0x7fff && 0xfff6 == 0x1 (0x1) +char 0xffff && 0xfff6 == 0x1 (0x1) +__uchar 0xff && 0xf6 == 0x1 (0x1) +__longlong 0x7fff && 0xfff6 == 0x1 (0x1) +__ulonglong 0x7fff && 0xfff6 == 0x1 (0x1) +int 0x7fff || 0xfff6 == 0x1 (0x1) +__uint 0x7fff || 0xfff6 == 0x1 (0x1) +char 0xffff || 0xfff6 == 0x1 (0x1) +__uchar 0xff || 0xf6 == 0x1 (0x1) +__longlong 0x7fff || 0xfff6 == 0x1 (0x1) +__ulonglong 0x7fff || 0xfff6 == 0x1 (0x1) +int 0x7fff & 0xfff6 == 0x7ff6 (0x7ff6) +__uint 0x7fff & 0xfff6 == 0x7ff6 (0x7ff6) +char 0xffff & 0xfff6 == -0xa (0xfff6) +__uchar 0xff & 0xf6 == 0xf6 (0xf6) +__longlong 0x7fff & 0xfff6 == 0x7ff6 (0x7ff6) +__ulonglong 0x7fff & 0xfff6 == 0x7ff6 (0x7ff6) +int 0x7fff | 0xfff6 == -0x1 (0xffff) +__uint 0x7fff | 0xfff6 == -0x1 (0xffff) +char 0xffff | 0xfff6 == -0x1 (0xffff) +__uchar 0xff | 0xf6 == 0xff (0xff) +__longlong 0x7fff | 0xfff6 == -0x1 (0xffff) +__ulonglong 0x7fff | 0xfff6 == -0x1 (0xffff) +int 0x7fff << 0x8 == -0x100 (0xff00) +__uint 0x7fff << 0x8 == -0x100 (0xff00) +char 0xffff << 0x8 == 0x0 (0x0) +__uchar 0xff << 0x8 == 0x0 (0x0) +__longlong 0x7fff << 0x8 == -0x100 (0xff00) +__ulonglong 0x7fff << 0x8 == -0x100 (0xff00) +int 0x7fff >> 0x8 == 0x7f (0x7f) +__uint 0x7fff >> 0x8 == 0x7f (0x7f) +char 0xffff >> 0x8 == -0x1 (0xffff) +__uchar 0xff >> 0x8 == 0x0 (0x0) +__longlong 0x7fff >> 0x8 == 0x7f (0x7f) +__ulonglong 0x7fff >> 0x8 == 0x7f (0x7f) +int 0x7fff + 0xfff6 == 0x7ff5 (0x7ff5) +__uint 0x7fff + 0xfff6 == 0x7ff5 (0x7ff5) +char 0xffff + 0xfff6 == -0xb (0xfff5) +__uchar 0xff + 0xf6 == 0xf5 (0xf5) +__longlong 0x7fff + 0xfff6 == 0x7ff5 (0x7ff5) +__ulonglong 0x7fff + 0xfff6 == 0x7ff5 (0x7ff5) +float 0x7fff + 0xfff6 == 0x7ff5 (0x7ff5) +int 0x7fff - 0xfff6 == -0x7ff7 (0x8009) +__uint 0x7fff - 0xfff6 == -0x7ff7 (0x8009) +char 0xffff - 0xfff6 == 0x9 (0x9) +__uchar 0xff - 0xf6 == 0x9 (0x9) +__longlong 0x7fff - 0xfff6 == -0x7ff7 (0x8009) +__ulonglong 0x7fff - 0xfff6 == -0x7ff7 (0x8009) +float 0x7fff - 0xfff6 == -0x8000 (0x8000) +int 0x7fff * 0xfff6 == 0xa (0xa) +__uint 0x7fff * 0xfff6 == 0xa (0xa) +char 0xffff * 0xfff6 == 0xa (0xa) +__uchar 0xff * 0xf6 == 0xa (0xa) +__longlong 0x7fff * 0xfff6 == 0xa (0xa) +__ulonglong 0x7fff * 0xfff6 == 0xa (0xa) +float 0x7fff * 0xfff6 == -0x8000 (0x8000) +int 0x7fff < 0xfff6 == 0x0 (0x0) +__uint 0x7fff < 0xfff6 == 0x1 (0x1) +char 0xffff < 0xfff6 == 0x0 (0x0) +__uchar 0xff < 0xf6 == 0x0 (0x0) +__longlong 0x7fff < 0xfff6 == 0x0 (0x0) +__ulonglong 0x7fff < 0xfff6 == 0x1 (0x1) +float 0x7fff < 0xfff6 == 0x0 (0x0) +int 0x7fff > 0xfff6 == 0x1 (0x1) +__uint 0x7fff > 0xfff6 == 0x0 (0x0) +char 0xffff > 0xfff6 == 0x1 (0x1) +__uchar 0xff > 0xf6 == 0x1 (0x1) +__longlong 0x7fff > 0xfff6 == 0x1 (0x1) +__ulonglong 0x7fff > 0xfff6 == 0x0 (0x0) +float 0x7fff > 0xfff6 == 0x1 (0x1) +int 0x7fff <= 0xfff6 == 0x0 (0x0) +__uint 0x7fff <= 0xfff6 == 0x1 (0x1) +char 0xffff <= 0xfff6 == 0x0 (0x0) +__uchar 0xff <= 0xf6 == 0x0 (0x0) +__longlong 0x7fff <= 0xfff6 == 0x0 (0x0) +__ulonglong 0x7fff <= 0xfff6 == 0x1 (0x1) +float 0x7fff <= 0xfff6 == 0x0 (0x0) +int 0x7fff == 0xfff6 == 0x0 (0x0) +__uint 0x7fff == 0xfff6 == 0x0 (0x0) +char 0xffff == 0xfff6 == 0x0 (0x0) +__uchar 0xff == 0xf6 == 0x0 (0x0) +__longlong 0x7fff == 0xfff6 == 0x0 (0x0) +__ulonglong 0x7fff == 0xfff6 == 0x0 (0x0) +float 0x7fff == 0xfff6 == 0x0 (0x0) +int 0x7fff != 0xfff6 == 0x1 (0x1) +__uint 0x7fff != 0xfff6 == 0x1 (0x1) +char 0xffff != 0xfff6 == 0x1 (0x1) +__uchar 0xff != 0xf6 == 0x1 (0x1) +__longlong 0x7fff != 0xfff6 == 0x1 (0x1) +__ulonglong 0x7fff != 0xfff6 == 0x1 (0x1) +float 0x7fff != 0xfff6 == 0x1 (0x1) +int 0x7fff >= 0xfff6 == 0x1 (0x1) +__uint 0x7fff >= 0xfff6 == 0x0 (0x0) +char 0xffff >= 0xfff6 == 0x1 (0x1) +__uchar 0xff >= 0xf6 == 0x1 (0x1) +__longlong 0x7fff >= 0xfff6 == 0x1 (0x1) +__ulonglong 0x7fff >= 0xfff6 == 0x0 (0x0) +float 0x7fff >= 0xfff6 == 0x1 (0x1) +int 0x7fff / 0xfff6 == -0xccc (0xf334) +__uint 0x7fff / 0xfff6 == 0x0 (0x0) +char 0xffff / 0xfff6 == 0x0 (0x0) +__uchar 0xff / 0xf6 == 0x1 (0x1) +__longlong 0x7fff / 0xfff6 == -0xccc (0xf334) +__ulonglong 0x7fff / 0xfff6 == 0x0 (0x0) +float 0x7fff / 0xfff6 == -0xccc (0xf334) +int 0x7fff % 0xfff6 == 0x7 (0x7) +__uint 0x7fff % 0xfff6 == 0x7fff (0x7fff) +char 0xffff % 0xfff6 == -0x1 (0xffff) +__uchar 0xff % 0xf6 == 0x9 (0x9) +__longlong 0x7fff % 0xfff6 == 0x7 (0x7) +__ulonglong 0x7fff % 0xfff6 == 0x7fff (0x7fff) +0x7fff * 0x5 == 0x7ffb +0x7fff / 0x5 == 0x1999 +0x7fff % 0x5 == 0x2 +int 0x7fff ^ 0x5 == 0x7ffa (0x7ffa) +__uint 0x7fff ^ 0x5 == 0x7ffa (0x7ffa) +char 0xffff ^ 0x5 == -0x6 (0xfffa) +__uchar 0xff ^ 0x5 == 0xfa (0xfa) +__longlong 0x7fff ^ 0x5 == 0x7ffa (0x7ffa) +__ulonglong 0x7fff ^ 0x5 == 0x7ffa (0x7ffa) +int 0x7fff && 0x5 == 0x1 (0x1) +__uint 0x7fff && 0x5 == 0x1 (0x1) +char 0xffff && 0x5 == 0x1 (0x1) +__uchar 0xff && 0x5 == 0x1 (0x1) +__longlong 0x7fff && 0x5 == 0x1 (0x1) +__ulonglong 0x7fff && 0x5 == 0x1 (0x1) +int 0x7fff || 0x5 == 0x1 (0x1) +__uint 0x7fff || 0x5 == 0x1 (0x1) +char 0xffff || 0x5 == 0x1 (0x1) +__uchar 0xff || 0x5 == 0x1 (0x1) +__longlong 0x7fff || 0x5 == 0x1 (0x1) +__ulonglong 0x7fff || 0x5 == 0x1 (0x1) +int 0x7fff & 0x5 == 0x5 (0x5) +__uint 0x7fff & 0x5 == 0x5 (0x5) +char 0xffff & 0x5 == 0x5 (0x5) +__uchar 0xff & 0x5 == 0x5 (0x5) +__longlong 0x7fff & 0x5 == 0x5 (0x5) +__ulonglong 0x7fff & 0x5 == 0x5 (0x5) +int 0x7fff | 0x5 == 0x7fff (0x7fff) +__uint 0x7fff | 0x5 == 0x7fff (0x7fff) +char 0xffff | 0x5 == -0x1 (0xffff) +__uchar 0xff | 0x5 == 0xff (0xff) +__longlong 0x7fff | 0x5 == 0x7fff (0x7fff) +__ulonglong 0x7fff | 0x5 == 0x7fff (0x7fff) +int 0x7fff << 0x9 == -0x200 (0xfe00) +__uint 0x7fff << 0x9 == -0x200 (0xfe00) +char 0xffff << 0x9 == 0x0 (0x0) +__uchar 0xff << 0x9 == 0x0 (0x0) +__longlong 0x7fff << 0x9 == -0x200 (0xfe00) +__ulonglong 0x7fff << 0x9 == -0x200 (0xfe00) +int 0x7fff >> 0x9 == 0x3f (0x3f) +__uint 0x7fff >> 0x9 == 0x3f (0x3f) +char 0xffff >> 0x9 == -0x1 (0xffff) +__uchar 0xff >> 0x9 == 0x0 (0x0) +__longlong 0x7fff >> 0x9 == 0x3f (0x3f) +__ulonglong 0x7fff >> 0x9 == 0x3f (0x3f) +int 0x7fff + 0x5 == -0x7ffc (0x8004) +__uint 0x7fff + 0x5 == -0x7ffc (0x8004) +char 0xffff + 0x5 == 0x4 (0x4) +__uchar 0xff + 0x5 == 0x4 (0x4) +__longlong 0x7fff + 0x5 == -0x7ffc (0x8004) +__ulonglong 0x7fff + 0x5 == -0x7ffc (0x8004) +float 0x7fff + 0x5 == -0x8000 (0x8000) +int 0x7fff - 0x5 == 0x7ffa (0x7ffa) +__uint 0x7fff - 0x5 == 0x7ffa (0x7ffa) +char 0xffff - 0x5 == -0x6 (0xfffa) +__uchar 0xff - 0x5 == 0xfa (0xfa) +__longlong 0x7fff - 0x5 == 0x7ffa (0x7ffa) +__ulonglong 0x7fff - 0x5 == 0x7ffa (0x7ffa) +float 0x7fff - 0x5 == 0x7ffa (0x7ffa) +int 0x7fff * 0x5 == 0x7ffb (0x7ffb) +__uint 0x7fff * 0x5 == 0x7ffb (0x7ffb) +char 0xffff * 0x5 == -0x5 (0xfffb) +__uchar 0xff * 0x5 == 0xfb (0xfb) +__longlong 0x7fff * 0x5 == 0x7ffb (0x7ffb) +__ulonglong 0x7fff * 0x5 == 0x7ffb (0x7ffb) +float 0x7fff * 0x5 == -0x8000 (0x8000) +int 0x7fff < 0x5 == 0x0 (0x0) +__uint 0x7fff < 0x5 == 0x0 (0x0) +char 0xffff < 0x5 == 0x1 (0x1) +__uchar 0xff < 0x5 == 0x0 (0x0) +__longlong 0x7fff < 0x5 == 0x0 (0x0) +__ulonglong 0x7fff < 0x5 == 0x0 (0x0) +float 0x7fff < 0x5 == 0x0 (0x0) +int 0x7fff > 0x5 == 0x1 (0x1) +__uint 0x7fff > 0x5 == 0x1 (0x1) +char 0xffff > 0x5 == 0x0 (0x0) +__uchar 0xff > 0x5 == 0x1 (0x1) +__longlong 0x7fff > 0x5 == 0x1 (0x1) +__ulonglong 0x7fff > 0x5 == 0x1 (0x1) +float 0x7fff > 0x5 == 0x1 (0x1) +int 0x7fff <= 0x5 == 0x0 (0x0) +__uint 0x7fff <= 0x5 == 0x0 (0x0) +char 0xffff <= 0x5 == 0x1 (0x1) +__uchar 0xff <= 0x5 == 0x0 (0x0) +__longlong 0x7fff <= 0x5 == 0x0 (0x0) +__ulonglong 0x7fff <= 0x5 == 0x0 (0x0) +float 0x7fff <= 0x5 == 0x0 (0x0) +int 0x7fff == 0x5 == 0x0 (0x0) +__uint 0x7fff == 0x5 == 0x0 (0x0) +char 0xffff == 0x5 == 0x0 (0x0) +__uchar 0xff == 0x5 == 0x0 (0x0) +__longlong 0x7fff == 0x5 == 0x0 (0x0) +__ulonglong 0x7fff == 0x5 == 0x0 (0x0) +float 0x7fff == 0x5 == 0x0 (0x0) +int 0x7fff != 0x5 == 0x1 (0x1) +__uint 0x7fff != 0x5 == 0x1 (0x1) +char 0xffff != 0x5 == 0x1 (0x1) +__uchar 0xff != 0x5 == 0x1 (0x1) +__longlong 0x7fff != 0x5 == 0x1 (0x1) +__ulonglong 0x7fff != 0x5 == 0x1 (0x1) +float 0x7fff != 0x5 == 0x1 (0x1) +int 0x7fff >= 0x5 == 0x1 (0x1) +__uint 0x7fff >= 0x5 == 0x1 (0x1) +char 0xffff >= 0x5 == 0x0 (0x0) +__uchar 0xff >= 0x5 == 0x1 (0x1) +__longlong 0x7fff >= 0x5 == 0x1 (0x1) +__ulonglong 0x7fff >= 0x5 == 0x1 (0x1) +float 0x7fff >= 0x5 == 0x1 (0x1) +int 0x7fff / 0x5 == 0x1999 (0x1999) +__uint 0x7fff / 0x5 == 0x1999 (0x1999) +char 0xffff / 0x5 == 0x0 (0x0) +__uchar 0xff / 0x5 == 0x33 (0x33) +__longlong 0x7fff / 0x5 == 0x1999 (0x1999) +__ulonglong 0x7fff / 0x5 == 0x1999 (0x1999) +float 0x7fff / 0x5 == 0x1999 (0x1999) +int 0x7fff % 0x5 == 0x2 (0x2) +__uint 0x7fff % 0x5 == 0x2 (0x2) +char 0xffff % 0x5 == -0x1 (0xffff) +__uchar 0xff % 0x5 == 0x0 (0x0) +__longlong 0x7fff % 0x5 == 0x2 (0x2) +__ulonglong 0x7fff % 0x5 == 0x2 (0x2) +0x7fff * 0x7 == 0x7ff9 +0x7fff / 0x7 == 0x1249 +0x7fff % 0x7 == 0x0 +int 0x7fff ^ 0x7 == 0x7ff8 (0x7ff8) +__uint 0x7fff ^ 0x7 == 0x7ff8 (0x7ff8) +char 0xffff ^ 0x7 == -0x8 (0xfff8) +__uchar 0xff ^ 0x7 == 0xf8 (0xf8) +__longlong 0x7fff ^ 0x7 == 0x7ff8 (0x7ff8) +__ulonglong 0x7fff ^ 0x7 == 0x7ff8 (0x7ff8) +int 0x7fff && 0x7 == 0x1 (0x1) +__uint 0x7fff && 0x7 == 0x1 (0x1) +char 0xffff && 0x7 == 0x1 (0x1) +__uchar 0xff && 0x7 == 0x1 (0x1) +__longlong 0x7fff && 0x7 == 0x1 (0x1) +__ulonglong 0x7fff && 0x7 == 0x1 (0x1) +int 0x7fff || 0x7 == 0x1 (0x1) +__uint 0x7fff || 0x7 == 0x1 (0x1) +char 0xffff || 0x7 == 0x1 (0x1) +__uchar 0xff || 0x7 == 0x1 (0x1) +__longlong 0x7fff || 0x7 == 0x1 (0x1) +__ulonglong 0x7fff || 0x7 == 0x1 (0x1) +int 0x7fff & 0x7 == 0x7 (0x7) +__uint 0x7fff & 0x7 == 0x7 (0x7) +char 0xffff & 0x7 == 0x7 (0x7) +__uchar 0xff & 0x7 == 0x7 (0x7) +__longlong 0x7fff & 0x7 == 0x7 (0x7) +__ulonglong 0x7fff & 0x7 == 0x7 (0x7) +int 0x7fff | 0x7 == 0x7fff (0x7fff) +__uint 0x7fff | 0x7 == 0x7fff (0x7fff) +char 0xffff | 0x7 == -0x1 (0xffff) +__uchar 0xff | 0x7 == 0xff (0xff) +__longlong 0x7fff | 0x7 == 0x7fff (0x7fff) +__ulonglong 0x7fff | 0x7 == 0x7fff (0x7fff) +int 0x7fff << 0xa == -0x400 (0xfc00) +__uint 0x7fff << 0xa == -0x400 (0xfc00) +char 0xffff << 0xa == 0x0 (0x0) +__uchar 0xff << 0xa == 0x0 (0x0) +__longlong 0x7fff << 0xa == -0x400 (0xfc00) +__ulonglong 0x7fff << 0xa == -0x400 (0xfc00) +int 0x7fff >> 0xa == 0x1f (0x1f) +__uint 0x7fff >> 0xa == 0x1f (0x1f) +char 0xffff >> 0xa == -0x1 (0xffff) +__uchar 0xff >> 0xa == 0x0 (0x0) +__longlong 0x7fff >> 0xa == 0x1f (0x1f) +__ulonglong 0x7fff >> 0xa == 0x1f (0x1f) +int 0x7fff + 0x7 == -0x7ffa (0x8006) +__uint 0x7fff + 0x7 == -0x7ffa (0x8006) +char 0xffff + 0x7 == 0x6 (0x6) +__uchar 0xff + 0x7 == 0x6 (0x6) +__longlong 0x7fff + 0x7 == -0x7ffa (0x8006) +__ulonglong 0x7fff + 0x7 == -0x7ffa (0x8006) +float 0x7fff + 0x7 == -0x8000 (0x8000) +int 0x7fff - 0x7 == 0x7ff8 (0x7ff8) +__uint 0x7fff - 0x7 == 0x7ff8 (0x7ff8) +char 0xffff - 0x7 == -0x8 (0xfff8) +__uchar 0xff - 0x7 == 0xf8 (0xf8) +__longlong 0x7fff - 0x7 == 0x7ff8 (0x7ff8) +__ulonglong 0x7fff - 0x7 == 0x7ff8 (0x7ff8) +float 0x7fff - 0x7 == 0x7ff8 (0x7ff8) +int 0x7fff * 0x7 == 0x7ff9 (0x7ff9) +__uint 0x7fff * 0x7 == 0x7ff9 (0x7ff9) +char 0xffff * 0x7 == -0x7 (0xfff9) +__uchar 0xff * 0x7 == 0xf9 (0xf9) +__longlong 0x7fff * 0x7 == 0x7ff9 (0x7ff9) +__ulonglong 0x7fff * 0x7 == 0x7ff9 (0x7ff9) +float 0x7fff * 0x7 == -0x8000 (0x8000) +int 0x7fff < 0x7 == 0x0 (0x0) +__uint 0x7fff < 0x7 == 0x0 (0x0) +char 0xffff < 0x7 == 0x1 (0x1) +__uchar 0xff < 0x7 == 0x0 (0x0) +__longlong 0x7fff < 0x7 == 0x0 (0x0) +__ulonglong 0x7fff < 0x7 == 0x0 (0x0) +float 0x7fff < 0x7 == 0x0 (0x0) +int 0x7fff > 0x7 == 0x1 (0x1) +__uint 0x7fff > 0x7 == 0x1 (0x1) +char 0xffff > 0x7 == 0x0 (0x0) +__uchar 0xff > 0x7 == 0x1 (0x1) +__longlong 0x7fff > 0x7 == 0x1 (0x1) +__ulonglong 0x7fff > 0x7 == 0x1 (0x1) +float 0x7fff > 0x7 == 0x1 (0x1) +int 0x7fff <= 0x7 == 0x0 (0x0) +__uint 0x7fff <= 0x7 == 0x0 (0x0) +char 0xffff <= 0x7 == 0x1 (0x1) +__uchar 0xff <= 0x7 == 0x0 (0x0) +__longlong 0x7fff <= 0x7 == 0x0 (0x0) +__ulonglong 0x7fff <= 0x7 == 0x0 (0x0) +float 0x7fff <= 0x7 == 0x0 (0x0) +int 0x7fff == 0x7 == 0x0 (0x0) +__uint 0x7fff == 0x7 == 0x0 (0x0) +char 0xffff == 0x7 == 0x0 (0x0) +__uchar 0xff == 0x7 == 0x0 (0x0) +__longlong 0x7fff == 0x7 == 0x0 (0x0) +__ulonglong 0x7fff == 0x7 == 0x0 (0x0) +float 0x7fff == 0x7 == 0x0 (0x0) +int 0x7fff != 0x7 == 0x1 (0x1) +__uint 0x7fff != 0x7 == 0x1 (0x1) +char 0xffff != 0x7 == 0x1 (0x1) +__uchar 0xff != 0x7 == 0x1 (0x1) +__longlong 0x7fff != 0x7 == 0x1 (0x1) +__ulonglong 0x7fff != 0x7 == 0x1 (0x1) +float 0x7fff != 0x7 == 0x1 (0x1) +int 0x7fff >= 0x7 == 0x1 (0x1) +__uint 0x7fff >= 0x7 == 0x1 (0x1) +char 0xffff >= 0x7 == 0x0 (0x0) +__uchar 0xff >= 0x7 == 0x1 (0x1) +__longlong 0x7fff >= 0x7 == 0x1 (0x1) +__ulonglong 0x7fff >= 0x7 == 0x1 (0x1) +float 0x7fff >= 0x7 == 0x1 (0x1) +int 0x7fff / 0x7 == 0x1249 (0x1249) +__uint 0x7fff / 0x7 == 0x1249 (0x1249) +char 0xffff / 0x7 == 0x0 (0x0) +__uchar 0xff / 0x7 == 0x24 (0x24) +__longlong 0x7fff / 0x7 == 0x1249 (0x1249) +__ulonglong 0x7fff / 0x7 == 0x1249 (0x1249) +float 0x7fff / 0x7 == 0x1249 (0x1249) +int 0x7fff % 0x7 == 0x0 (0x0) +__uint 0x7fff % 0x7 == 0x0 (0x0) +char 0xffff % 0x7 == -0x1 (0xffff) +__uchar 0xff % 0x7 == 0x3 (0x3) +__longlong 0x7fff % 0x7 == 0x0 (0x0) +__ulonglong 0x7fff % 0x7 == 0x0 (0x0) +0x7fff * 0x2a == -0x2a +0x7fff / 0x2a == 0x30c +0x7fff % 0x2a == 0x7 +int 0x7fff ^ 0x2a == 0x7fd5 (0x7fd5) +__uint 0x7fff ^ 0x2a == 0x7fd5 (0x7fd5) +char 0xffff ^ 0x2a == -0x2b (0xffd5) +__uchar 0xff ^ 0x2a == 0xd5 (0xd5) +__longlong 0x7fff ^ 0x2a == 0x7fd5 (0x7fd5) +__ulonglong 0x7fff ^ 0x2a == 0x7fd5 (0x7fd5) +int 0x7fff && 0x2a == 0x1 (0x1) +__uint 0x7fff && 0x2a == 0x1 (0x1) +char 0xffff && 0x2a == 0x1 (0x1) +__uchar 0xff && 0x2a == 0x1 (0x1) +__longlong 0x7fff && 0x2a == 0x1 (0x1) +__ulonglong 0x7fff && 0x2a == 0x1 (0x1) +int 0x7fff || 0x2a == 0x1 (0x1) +__uint 0x7fff || 0x2a == 0x1 (0x1) +char 0xffff || 0x2a == 0x1 (0x1) +__uchar 0xff || 0x2a == 0x1 (0x1) +__longlong 0x7fff || 0x2a == 0x1 (0x1) +__ulonglong 0x7fff || 0x2a == 0x1 (0x1) +int 0x7fff & 0x2a == 0x2a (0x2a) +__uint 0x7fff & 0x2a == 0x2a (0x2a) +char 0xffff & 0x2a == 0x2a (0x2a) +__uchar 0xff & 0x2a == 0x2a (0x2a) +__longlong 0x7fff & 0x2a == 0x2a (0x2a) +__ulonglong 0x7fff & 0x2a == 0x2a (0x2a) +int 0x7fff | 0x2a == 0x7fff (0x7fff) +__uint 0x7fff | 0x2a == 0x7fff (0x7fff) +char 0xffff | 0x2a == -0x1 (0xffff) +__uchar 0xff | 0x2a == 0xff (0xff) +__longlong 0x7fff | 0x2a == 0x7fff (0x7fff) +__ulonglong 0x7fff | 0x2a == 0x7fff (0x7fff) +int 0x7fff << 0xc == -0x1000 (0xf000) +__uint 0x7fff << 0xc == -0x1000 (0xf000) +char 0xffff << 0xc == 0x0 (0x0) +__uchar 0xff << 0xc == 0x0 (0x0) +__longlong 0x7fff << 0xc == -0x1000 (0xf000) +__ulonglong 0x7fff << 0xc == -0x1000 (0xf000) +int 0x7fff >> 0xc == 0x7 (0x7) +__uint 0x7fff >> 0xc == 0x7 (0x7) +char 0xffff >> 0xc == -0x1 (0xffff) +__uchar 0xff >> 0xc == 0x0 (0x0) +__longlong 0x7fff >> 0xc == 0x7 (0x7) +__ulonglong 0x7fff >> 0xc == 0x7 (0x7) +int 0x7fff + 0x2a == -0x7fd7 (0x8029) +__uint 0x7fff + 0x2a == -0x7fd7 (0x8029) +char 0xffff + 0x2a == 0x29 (0x29) +__uchar 0xff + 0x2a == 0x29 (0x29) +__longlong 0x7fff + 0x2a == -0x7fd7 (0x8029) +__ulonglong 0x7fff + 0x2a == -0x7fd7 (0x8029) +float 0x7fff + 0x2a == -0x8000 (0x8000) +int 0x7fff - 0x2a == 0x7fd5 (0x7fd5) +__uint 0x7fff - 0x2a == 0x7fd5 (0x7fd5) +char 0xffff - 0x2a == -0x2b (0xffd5) +__uchar 0xff - 0x2a == 0xd5 (0xd5) +__longlong 0x7fff - 0x2a == 0x7fd5 (0x7fd5) +__ulonglong 0x7fff - 0x2a == 0x7fd5 (0x7fd5) +float 0x7fff - 0x2a == 0x7fd5 (0x7fd5) +int 0x7fff * 0x2a == -0x2a (0xffd6) +__uint 0x7fff * 0x2a == -0x2a (0xffd6) +char 0xffff * 0x2a == -0x2a (0xffd6) +__uchar 0xff * 0x2a == 0xd6 (0xd6) +__longlong 0x7fff * 0x2a == -0x2a (0xffd6) +__ulonglong 0x7fff * 0x2a == -0x2a (0xffd6) +float 0x7fff * 0x2a == -0x8000 (0x8000) +int 0x7fff < 0x2a == 0x0 (0x0) +__uint 0x7fff < 0x2a == 0x0 (0x0) +char 0xffff < 0x2a == 0x1 (0x1) +__uchar 0xff < 0x2a == 0x0 (0x0) +__longlong 0x7fff < 0x2a == 0x0 (0x0) +__ulonglong 0x7fff < 0x2a == 0x0 (0x0) +float 0x7fff < 0x2a == 0x0 (0x0) +int 0x7fff > 0x2a == 0x1 (0x1) +__uint 0x7fff > 0x2a == 0x1 (0x1) +char 0xffff > 0x2a == 0x0 (0x0) +__uchar 0xff > 0x2a == 0x1 (0x1) +__longlong 0x7fff > 0x2a == 0x1 (0x1) +__ulonglong 0x7fff > 0x2a == 0x1 (0x1) +float 0x7fff > 0x2a == 0x1 (0x1) +int 0x7fff <= 0x2a == 0x0 (0x0) +__uint 0x7fff <= 0x2a == 0x0 (0x0) +char 0xffff <= 0x2a == 0x1 (0x1) +__uchar 0xff <= 0x2a == 0x0 (0x0) +__longlong 0x7fff <= 0x2a == 0x0 (0x0) +__ulonglong 0x7fff <= 0x2a == 0x0 (0x0) +float 0x7fff <= 0x2a == 0x0 (0x0) +int 0x7fff == 0x2a == 0x0 (0x0) +__uint 0x7fff == 0x2a == 0x0 (0x0) +char 0xffff == 0x2a == 0x0 (0x0) +__uchar 0xff == 0x2a == 0x0 (0x0) +__longlong 0x7fff == 0x2a == 0x0 (0x0) +__ulonglong 0x7fff == 0x2a == 0x0 (0x0) +float 0x7fff == 0x2a == 0x0 (0x0) +int 0x7fff != 0x2a == 0x1 (0x1) +__uint 0x7fff != 0x2a == 0x1 (0x1) +char 0xffff != 0x2a == 0x1 (0x1) +__uchar 0xff != 0x2a == 0x1 (0x1) +__longlong 0x7fff != 0x2a == 0x1 (0x1) +__ulonglong 0x7fff != 0x2a == 0x1 (0x1) +float 0x7fff != 0x2a == 0x1 (0x1) +int 0x7fff >= 0x2a == 0x1 (0x1) +__uint 0x7fff >= 0x2a == 0x1 (0x1) +char 0xffff >= 0x2a == 0x0 (0x0) +__uchar 0xff >= 0x2a == 0x1 (0x1) +__longlong 0x7fff >= 0x2a == 0x1 (0x1) +__ulonglong 0x7fff >= 0x2a == 0x1 (0x1) +float 0x7fff >= 0x2a == 0x1 (0x1) +int 0x7fff / 0x2a == 0x30c (0x30c) +__uint 0x7fff / 0x2a == 0x30c (0x30c) +char 0xffff / 0x2a == 0x0 (0x0) +__uchar 0xff / 0x2a == 0x6 (0x6) +__longlong 0x7fff / 0x2a == 0x30c (0x30c) +__ulonglong 0x7fff / 0x2a == 0x30c (0x30c) +float 0x7fff / 0x2a == 0x30c (0x30c) +int 0x7fff % 0x2a == 0x7 (0x7) +__uint 0x7fff % 0x2a == 0x7 (0x7) +char 0xffff % 0x2a == -0x1 (0xffff) +__uchar 0xff % 0x2a == 0x3 (0x3) +__longlong 0x7fff % 0x2a == 0x7 (0x7) +__ulonglong 0x7fff % 0x2a == 0x7 (0x7) +0x7fff * 0x17 == 0x7fe9 +0x7fff / 0x17 == 0x590 +0x7fff % 0x17 == 0xf +int 0x7fff ^ 0x17 == 0x7fe8 (0x7fe8) +__uint 0x7fff ^ 0x17 == 0x7fe8 (0x7fe8) +char 0xffff ^ 0x17 == -0x18 (0xffe8) +__uchar 0xff ^ 0x17 == 0xe8 (0xe8) +__longlong 0x7fff ^ 0x17 == 0x7fe8 (0x7fe8) +__ulonglong 0x7fff ^ 0x17 == 0x7fe8 (0x7fe8) +int 0x7fff && 0x17 == 0x1 (0x1) +__uint 0x7fff && 0x17 == 0x1 (0x1) +char 0xffff && 0x17 == 0x1 (0x1) +__uchar 0xff && 0x17 == 0x1 (0x1) +__longlong 0x7fff && 0x17 == 0x1 (0x1) +__ulonglong 0x7fff && 0x17 == 0x1 (0x1) +int 0x7fff || 0x17 == 0x1 (0x1) +__uint 0x7fff || 0x17 == 0x1 (0x1) +char 0xffff || 0x17 == 0x1 (0x1) +__uchar 0xff || 0x17 == 0x1 (0x1) +__longlong 0x7fff || 0x17 == 0x1 (0x1) +__ulonglong 0x7fff || 0x17 == 0x1 (0x1) +int 0x7fff & 0x17 == 0x17 (0x17) +__uint 0x7fff & 0x17 == 0x17 (0x17) +char 0xffff & 0x17 == 0x17 (0x17) +__uchar 0xff & 0x17 == 0x17 (0x17) +__longlong 0x7fff & 0x17 == 0x17 (0x17) +__ulonglong 0x7fff & 0x17 == 0x17 (0x17) +int 0x7fff | 0x17 == 0x7fff (0x7fff) +__uint 0x7fff | 0x17 == 0x7fff (0x7fff) +char 0xffff | 0x17 == -0x1 (0xffff) +__uchar 0xff | 0x17 == 0xff (0xff) +__longlong 0x7fff | 0x17 == 0x7fff (0x7fff) +__ulonglong 0x7fff | 0x17 == 0x7fff (0x7fff) +int 0x7fff << 0xe == -0x4000 (0xc000) +__uint 0x7fff << 0xe == -0x4000 (0xc000) +char 0xffff << 0xe == 0x0 (0x0) +__uchar 0xff << 0xe == 0x0 (0x0) +__longlong 0x7fff << 0xe == -0x4000 (0xc000) +__ulonglong 0x7fff << 0xe == -0x4000 (0xc000) +int 0x7fff >> 0xe == 0x1 (0x1) +__uint 0x7fff >> 0xe == 0x1 (0x1) +char 0xffff >> 0xe == -0x1 (0xffff) +__uchar 0xff >> 0xe == 0x0 (0x0) +__longlong 0x7fff >> 0xe == 0x1 (0x1) +__ulonglong 0x7fff >> 0xe == 0x1 (0x1) +int 0x7fff + 0x17 == -0x7fea (0x8016) +__uint 0x7fff + 0x17 == -0x7fea (0x8016) +char 0xffff + 0x17 == 0x16 (0x16) +__uchar 0xff + 0x17 == 0x16 (0x16) +__longlong 0x7fff + 0x17 == -0x7fea (0x8016) +__ulonglong 0x7fff + 0x17 == -0x7fea (0x8016) +float 0x7fff + 0x17 == -0x8000 (0x8000) +int 0x7fff - 0x17 == 0x7fe8 (0x7fe8) +__uint 0x7fff - 0x17 == 0x7fe8 (0x7fe8) +char 0xffff - 0x17 == -0x18 (0xffe8) +__uchar 0xff - 0x17 == 0xe8 (0xe8) +__longlong 0x7fff - 0x17 == 0x7fe8 (0x7fe8) +__ulonglong 0x7fff - 0x17 == 0x7fe8 (0x7fe8) +float 0x7fff - 0x17 == 0x7fe8 (0x7fe8) +int 0x7fff * 0x17 == 0x7fe9 (0x7fe9) +__uint 0x7fff * 0x17 == 0x7fe9 (0x7fe9) +char 0xffff * 0x17 == -0x17 (0xffe9) +__uchar 0xff * 0x17 == 0xe9 (0xe9) +__longlong 0x7fff * 0x17 == 0x7fe9 (0x7fe9) +__ulonglong 0x7fff * 0x17 == 0x7fe9 (0x7fe9) +float 0x7fff * 0x17 == -0x8000 (0x8000) +int 0x7fff < 0x17 == 0x0 (0x0) +__uint 0x7fff < 0x17 == 0x0 (0x0) +char 0xffff < 0x17 == 0x1 (0x1) +__uchar 0xff < 0x17 == 0x0 (0x0) +__longlong 0x7fff < 0x17 == 0x0 (0x0) +__ulonglong 0x7fff < 0x17 == 0x0 (0x0) +float 0x7fff < 0x17 == 0x0 (0x0) +int 0x7fff > 0x17 == 0x1 (0x1) +__uint 0x7fff > 0x17 == 0x1 (0x1) +char 0xffff > 0x17 == 0x0 (0x0) +__uchar 0xff > 0x17 == 0x1 (0x1) +__longlong 0x7fff > 0x17 == 0x1 (0x1) +__ulonglong 0x7fff > 0x17 == 0x1 (0x1) +float 0x7fff > 0x17 == 0x1 (0x1) +int 0x7fff <= 0x17 == 0x0 (0x0) +__uint 0x7fff <= 0x17 == 0x0 (0x0) +char 0xffff <= 0x17 == 0x1 (0x1) +__uchar 0xff <= 0x17 == 0x0 (0x0) +__longlong 0x7fff <= 0x17 == 0x0 (0x0) +__ulonglong 0x7fff <= 0x17 == 0x0 (0x0) +float 0x7fff <= 0x17 == 0x0 (0x0) +int 0x7fff == 0x17 == 0x0 (0x0) +__uint 0x7fff == 0x17 == 0x0 (0x0) +char 0xffff == 0x17 == 0x0 (0x0) +__uchar 0xff == 0x17 == 0x0 (0x0) +__longlong 0x7fff == 0x17 == 0x0 (0x0) +__ulonglong 0x7fff == 0x17 == 0x0 (0x0) +float 0x7fff == 0x17 == 0x0 (0x0) +int 0x7fff != 0x17 == 0x1 (0x1) +__uint 0x7fff != 0x17 == 0x1 (0x1) +char 0xffff != 0x17 == 0x1 (0x1) +__uchar 0xff != 0x17 == 0x1 (0x1) +__longlong 0x7fff != 0x17 == 0x1 (0x1) +__ulonglong 0x7fff != 0x17 == 0x1 (0x1) +float 0x7fff != 0x17 == 0x1 (0x1) +int 0x7fff >= 0x17 == 0x1 (0x1) +__uint 0x7fff >= 0x17 == 0x1 (0x1) +char 0xffff >= 0x17 == 0x0 (0x0) +__uchar 0xff >= 0x17 == 0x1 (0x1) +__longlong 0x7fff >= 0x17 == 0x1 (0x1) +__ulonglong 0x7fff >= 0x17 == 0x1 (0x1) +float 0x7fff >= 0x17 == 0x1 (0x1) +int 0x7fff / 0x17 == 0x590 (0x590) +__uint 0x7fff / 0x17 == 0x590 (0x590) +char 0xffff / 0x17 == 0x0 (0x0) +__uchar 0xff / 0x17 == 0xb (0xb) +__longlong 0x7fff / 0x17 == 0x590 (0x590) +__ulonglong 0x7fff / 0x17 == 0x590 (0x590) +float 0x7fff / 0x17 == 0x590 (0x590) +int 0x7fff % 0x17 == 0xf (0xf) +__uint 0x7fff % 0x17 == 0xf (0xf) +char 0xffff % 0x17 == -0x1 (0xffff) +__uchar 0xff % 0x17 == 0x2 (0x2) +__longlong 0x7fff % 0x17 == 0xf (0xf) +__ulonglong 0x7fff % 0x17 == 0xf (0xf) +0x7fff * 0x7fff == 0x1 +0x7fff / 0x7fff == 0x1 +0x7fff % 0x7fff == 0x0 +int 0x7fff ^ 0x7fff == 0x0 (0x0) +__uint 0x7fff ^ 0x7fff == 0x0 (0x0) +char 0xffff ^ 0xffff == 0x0 (0x0) +__uchar 0xff ^ 0xff == 0x0 (0x0) +__longlong 0x7fff ^ 0x7fff == 0x0 (0x0) +__ulonglong 0x7fff ^ 0x7fff == 0x0 (0x0) +int 0x7fff && 0x7fff == 0x1 (0x1) +__uint 0x7fff && 0x7fff == 0x1 (0x1) +char 0xffff && 0xffff == 0x1 (0x1) +__uchar 0xff && 0xff == 0x1 (0x1) +__longlong 0x7fff && 0x7fff == 0x1 (0x1) +__ulonglong 0x7fff && 0x7fff == 0x1 (0x1) +int 0x7fff || 0x7fff == 0x1 (0x1) +__uint 0x7fff || 0x7fff == 0x1 (0x1) +char 0xffff || 0xffff == 0x1 (0x1) +__uchar 0xff || 0xff == 0x1 (0x1) +__longlong 0x7fff || 0x7fff == 0x1 (0x1) +__ulonglong 0x7fff || 0x7fff == 0x1 (0x1) +int 0x7fff & 0x7fff == 0x7fff (0x7fff) +__uint 0x7fff & 0x7fff == 0x7fff (0x7fff) +char 0xffff & 0xffff == -0x1 (0xffff) +__uchar 0xff & 0xff == 0xff (0xff) +__longlong 0x7fff & 0x7fff == 0x7fff (0x7fff) +__ulonglong 0x7fff & 0x7fff == 0x7fff (0x7fff) +int 0x7fff | 0x7fff == 0x7fff (0x7fff) +__uint 0x7fff | 0x7fff == 0x7fff (0x7fff) +char 0xffff | 0xffff == -0x1 (0xffff) +__uchar 0xff | 0xff == 0xff (0xff) +__longlong 0x7fff | 0x7fff == 0x7fff (0x7fff) +__ulonglong 0x7fff | 0x7fff == 0x7fff (0x7fff) +int 0x7fff << 0x10 == 0x0 (0x0) +__uint 0x7fff << 0x10 == 0x0 (0x0) +char 0xffff << 0x10 == 0x0 (0x0) +__uchar 0xff << 0x10 == 0x0 (0x0) +__longlong 0x7fff << 0x10 == 0x0 (0x0) +__ulonglong 0x7fff << 0x10 == 0x0 (0x0) +int 0x7fff >> 0x10 == 0x0 (0x0) +__uint 0x7fff >> 0x10 == 0x0 (0x0) +char 0xffff >> 0x10 == -0x1 (0xffff) +__uchar 0xff >> 0x10 == 0x0 (0x0) +__longlong 0x7fff >> 0x10 == 0x0 (0x0) +__ulonglong 0x7fff >> 0x10 == 0x0 (0x0) +int 0x7fff + 0x7fff == -0x2 (0xfffe) +__uint 0x7fff + 0x7fff == -0x2 (0xfffe) +char 0xffff + 0xffff == -0x2 (0xfffe) +__uchar 0xff + 0xff == 0xfe (0xfe) +__longlong 0x7fff + 0x7fff == -0x2 (0xfffe) +__ulonglong 0x7fff + 0x7fff == -0x2 (0xfffe) +float 0x7fff + 0x7fff == -0x8000 (0x8000) +int 0x7fff - 0x7fff == 0x0 (0x0) +__uint 0x7fff - 0x7fff == 0x0 (0x0) +char 0xffff - 0xffff == 0x0 (0x0) +__uchar 0xff - 0xff == 0x0 (0x0) +__longlong 0x7fff - 0x7fff == 0x0 (0x0) +__ulonglong 0x7fff - 0x7fff == 0x0 (0x0) +float 0x7fff - 0x7fff == 0x0 (0x0) +int 0x7fff * 0x7fff == 0x1 (0x1) +__uint 0x7fff * 0x7fff == 0x1 (0x1) +char 0xffff * 0xffff == 0x1 (0x1) +__uchar 0xff * 0xff == 0x1 (0x1) +__longlong 0x7fff * 0x7fff == 0x1 (0x1) +__ulonglong 0x7fff * 0x7fff == 0x1 (0x1) +float 0x7fff * 0x7fff == -0x8000 (0x8000) +int 0x7fff < 0x7fff == 0x0 (0x0) +__uint 0x7fff < 0x7fff == 0x0 (0x0) +char 0xffff < 0xffff == 0x0 (0x0) +__uchar 0xff < 0xff == 0x0 (0x0) +__longlong 0x7fff < 0x7fff == 0x0 (0x0) +__ulonglong 0x7fff < 0x7fff == 0x0 (0x0) +float 0x7fff < 0x7fff == 0x0 (0x0) +int 0x7fff > 0x7fff == 0x0 (0x0) +__uint 0x7fff > 0x7fff == 0x0 (0x0) +char 0xffff > 0xffff == 0x0 (0x0) +__uchar 0xff > 0xff == 0x0 (0x0) +__longlong 0x7fff > 0x7fff == 0x0 (0x0) +__ulonglong 0x7fff > 0x7fff == 0x0 (0x0) +float 0x7fff > 0x7fff == 0x0 (0x0) +int 0x7fff <= 0x7fff == 0x1 (0x1) +__uint 0x7fff <= 0x7fff == 0x1 (0x1) +char 0xffff <= 0xffff == 0x1 (0x1) +__uchar 0xff <= 0xff == 0x1 (0x1) +__longlong 0x7fff <= 0x7fff == 0x1 (0x1) +__ulonglong 0x7fff <= 0x7fff == 0x1 (0x1) +float 0x7fff <= 0x7fff == 0x1 (0x1) +int 0x7fff == 0x7fff == 0x1 (0x1) +__uint 0x7fff == 0x7fff == 0x1 (0x1) +char 0xffff == 0xffff == 0x1 (0x1) +__uchar 0xff == 0xff == 0x1 (0x1) +__longlong 0x7fff == 0x7fff == 0x1 (0x1) +__ulonglong 0x7fff == 0x7fff == 0x1 (0x1) +float 0x7fff == 0x7fff == 0x1 (0x1) +int 0x7fff != 0x7fff == 0x0 (0x0) +__uint 0x7fff != 0x7fff == 0x0 (0x0) +char 0xffff != 0xffff == 0x0 (0x0) +__uchar 0xff != 0xff == 0x0 (0x0) +__longlong 0x7fff != 0x7fff == 0x0 (0x0) +__ulonglong 0x7fff != 0x7fff == 0x0 (0x0) +float 0x7fff != 0x7fff == 0x0 (0x0) +int 0x7fff >= 0x7fff == 0x1 (0x1) +__uint 0x7fff >= 0x7fff == 0x1 (0x1) +char 0xffff >= 0xffff == 0x1 (0x1) +__uchar 0xff >= 0xff == 0x1 (0x1) +__longlong 0x7fff >= 0x7fff == 0x1 (0x1) +__ulonglong 0x7fff >= 0x7fff == 0x1 (0x1) +float 0x7fff >= 0x7fff == 0x1 (0x1) +int 0x7fff / 0x7fff == 0x1 (0x1) +__uint 0x7fff / 0x7fff == 0x1 (0x1) +char 0xffff / 0xffff == 0x1 (0x1) +__uchar 0xff / 0xff == 0x1 (0x1) +__longlong 0x7fff / 0x7fff == 0x1 (0x1) +__ulonglong 0x7fff / 0x7fff == 0x1 (0x1) +float 0x7fff / 0x7fff == 0x1 (0x1) +int 0x7fff % 0x7fff == 0x0 (0x0) +__uint 0x7fff % 0x7fff == 0x0 (0x0) +char 0xffff % 0xffff == 0x0 (0x0) +__uchar 0xff % 0xff == 0x0 (0x0) +__longlong 0x7fff % 0x7fff == 0x0 (0x0) +__ulonglong 0x7fff % 0x7fff == 0x0 (0x0) +0x7fff * 0x8000 == -0x8000 +0x7fff / 0x8000 == 0x0 +0x7fff % 0x8000 == 0x7fff +int 0x7fff ^ 0x8000 == -0x1 (0xffff) +__uint 0x7fff ^ 0x8000 == -0x1 (0xffff) +char 0xffff ^ 0x0 == -0x1 (0xffff) +__uchar 0xff ^ 0x0 == 0xff (0xff) +__longlong 0x7fff ^ 0x8000 == -0x1 (0xffff) +__ulonglong 0x7fff ^ 0x8000 == -0x1 (0xffff) +int 0x7fff && 0x8000 == 0x1 (0x1) +__uint 0x7fff && 0x8000 == 0x1 (0x1) +char 0xffff && 0x0 == 0x0 (0x0) +__uchar 0xff && 0x0 == 0x0 (0x0) +__longlong 0x7fff && 0x8000 == 0x1 (0x1) +__ulonglong 0x7fff && 0x8000 == 0x1 (0x1) +int 0x7fff || 0x8000 == 0x1 (0x1) +__uint 0x7fff || 0x8000 == 0x1 (0x1) +char 0xffff || 0x0 == 0x1 (0x1) +__uchar 0xff || 0x0 == 0x1 (0x1) +__longlong 0x7fff || 0x8000 == 0x1 (0x1) +__ulonglong 0x7fff || 0x8000 == 0x1 (0x1) +int 0x7fff & 0x8000 == 0x0 (0x0) +__uint 0x7fff & 0x8000 == 0x0 (0x0) +char 0xffff & 0x0 == 0x0 (0x0) +__uchar 0xff & 0x0 == 0x0 (0x0) +__longlong 0x7fff & 0x8000 == 0x0 (0x0) +__ulonglong 0x7fff & 0x8000 == 0x0 (0x0) +int 0x7fff | 0x8000 == -0x1 (0xffff) +__uint 0x7fff | 0x8000 == -0x1 (0xffff) +char 0xffff | 0x0 == -0x1 (0xffff) +__uchar 0xff | 0x0 == 0xff (0xff) +__longlong 0x7fff | 0x8000 == -0x1 (0xffff) +__ulonglong 0x7fff | 0x8000 == -0x1 (0xffff) +int 0x7fff << 0x12 == 0x0 (0x0) +__uint 0x7fff << 0x12 == 0x0 (0x0) +char 0xffff << 0x12 == 0x0 (0x0) +__uchar 0xff << 0x12 == 0x0 (0x0) +__longlong 0x7fff << 0x12 == 0x0 (0x0) +__ulonglong 0x7fff << 0x12 == 0x0 (0x0) +int 0x7fff >> 0x12 == 0x0 (0x0) +__uint 0x7fff >> 0x12 == 0x0 (0x0) +char 0xffff >> 0x12 == -0x1 (0xffff) +__uchar 0xff >> 0x12 == 0x0 (0x0) +__longlong 0x7fff >> 0x12 == 0x0 (0x0) +__ulonglong 0x7fff >> 0x12 == 0x0 (0x0) +int 0x7fff + 0x8000 == -0x1 (0xffff) +__uint 0x7fff + 0x8000 == -0x1 (0xffff) +char 0xffff + 0x0 == -0x1 (0xffff) +__uchar 0xff + 0x0 == 0xff (0xff) +__longlong 0x7fff + 0x8000 == -0x1 (0xffff) +__ulonglong 0x7fff + 0x8000 == -0x1 (0xffff) +float 0x7fff + 0x8000 == -0x1 (0xffff) +int 0x7fff - 0x8000 == -0x1 (0xffff) +__uint 0x7fff - 0x8000 == -0x1 (0xffff) +char 0xffff - 0x0 == -0x1 (0xffff) +__uchar 0xff - 0x0 == 0xff (0xff) +__longlong 0x7fff - 0x8000 == -0x1 (0xffff) +__ulonglong 0x7fff - 0x8000 == -0x1 (0xffff) +float 0x7fff - 0x8000 == -0x8000 (0x8000) +int 0x7fff * 0x8000 == -0x8000 (0x8000) +__uint 0x7fff * 0x8000 == -0x8000 (0x8000) +char 0xffff * 0x0 == 0x0 (0x0) +__uchar 0xff * 0x0 == 0x0 (0x0) +__longlong 0x7fff * 0x8000 == -0x8000 (0x8000) +__ulonglong 0x7fff * 0x8000 == -0x8000 (0x8000) +float 0x7fff * 0x8000 == -0x8000 (0x8000) +int 0x7fff < 0x8000 == 0x0 (0x0) +__uint 0x7fff < 0x8000 == 0x1 (0x1) +char 0xffff < 0x0 == 0x1 (0x1) +__uchar 0xff < 0x0 == 0x0 (0x0) +__longlong 0x7fff < 0x8000 == 0x0 (0x0) +__ulonglong 0x7fff < 0x8000 == 0x1 (0x1) +float 0x7fff < 0x8000 == 0x0 (0x0) +int 0x7fff > 0x8000 == 0x1 (0x1) +__uint 0x7fff > 0x8000 == 0x0 (0x0) +char 0xffff > 0x0 == 0x0 (0x0) +__uchar 0xff > 0x0 == 0x1 (0x1) +__longlong 0x7fff > 0x8000 == 0x1 (0x1) +__ulonglong 0x7fff > 0x8000 == 0x0 (0x0) +float 0x7fff > 0x8000 == 0x1 (0x1) +int 0x7fff <= 0x8000 == 0x0 (0x0) +__uint 0x7fff <= 0x8000 == 0x1 (0x1) +char 0xffff <= 0x0 == 0x1 (0x1) +__uchar 0xff <= 0x0 == 0x0 (0x0) +__longlong 0x7fff <= 0x8000 == 0x0 (0x0) +__ulonglong 0x7fff <= 0x8000 == 0x1 (0x1) +float 0x7fff <= 0x8000 == 0x0 (0x0) +int 0x7fff == 0x8000 == 0x0 (0x0) +__uint 0x7fff == 0x8000 == 0x0 (0x0) +char 0xffff == 0x0 == 0x0 (0x0) +__uchar 0xff == 0x0 == 0x0 (0x0) +__longlong 0x7fff == 0x8000 == 0x0 (0x0) +__ulonglong 0x7fff == 0x8000 == 0x0 (0x0) +float 0x7fff == 0x8000 == 0x0 (0x0) +int 0x7fff != 0x8000 == 0x1 (0x1) +__uint 0x7fff != 0x8000 == 0x1 (0x1) +char 0xffff != 0x0 == 0x1 (0x1) +__uchar 0xff != 0x0 == 0x1 (0x1) +__longlong 0x7fff != 0x8000 == 0x1 (0x1) +__ulonglong 0x7fff != 0x8000 == 0x1 (0x1) +float 0x7fff != 0x8000 == 0x1 (0x1) +int 0x7fff >= 0x8000 == 0x1 (0x1) +__uint 0x7fff >= 0x8000 == 0x0 (0x0) +char 0xffff >= 0x0 == 0x0 (0x0) +__uchar 0xff >= 0x0 == 0x1 (0x1) +__longlong 0x7fff >= 0x8000 == 0x1 (0x1) +__ulonglong 0x7fff >= 0x8000 == 0x0 (0x0) +float 0x7fff >= 0x8000 == 0x1 (0x1) +int 0x7fff / 0x8000 == 0x0 (0x0) +__uint 0x7fff / 0x8000 == 0x0 (0x0) +__longlong 0x7fff / 0x8000 == 0x0 (0x0) +__ulonglong 0x7fff / 0x8000 == 0x0 (0x0) +float 0x7fff / 0x8000 == 0x0 (0x0) +int 0x7fff % 0x8000 == 0x7fff (0x7fff) +__uint 0x7fff % 0x8000 == 0x7fff (0x7fff) +__longlong 0x7fff % 0x8000 == 0x7fff (0x7fff) +__ulonglong 0x7fff % 0x8000 == 0x7fff (0x7fff) +0x7fff * 0x3e8 == -0x3e8 +0x7fff / 0x3e8 == 0x20 +0x7fff % 0x3e8 == 0x2ff +int 0x7fff ^ 0x3e8 == 0x7c17 (0x7c17) +__uint 0x7fff ^ 0x3e8 == 0x7c17 (0x7c17) +char 0xffff ^ 0xffe8 == 0x17 (0x17) +__uchar 0xff ^ 0xe8 == 0x17 (0x17) +__longlong 0x7fff ^ 0x3e8 == 0x7c17 (0x7c17) +__ulonglong 0x7fff ^ 0x3e8 == 0x7c17 (0x7c17) +int 0x7fff && 0x3e8 == 0x1 (0x1) +__uint 0x7fff && 0x3e8 == 0x1 (0x1) +char 0xffff && 0xffe8 == 0x1 (0x1) +__uchar 0xff && 0xe8 == 0x1 (0x1) +__longlong 0x7fff && 0x3e8 == 0x1 (0x1) +__ulonglong 0x7fff && 0x3e8 == 0x1 (0x1) +int 0x7fff || 0x3e8 == 0x1 (0x1) +__uint 0x7fff || 0x3e8 == 0x1 (0x1) +char 0xffff || 0xffe8 == 0x1 (0x1) +__uchar 0xff || 0xe8 == 0x1 (0x1) +__longlong 0x7fff || 0x3e8 == 0x1 (0x1) +__ulonglong 0x7fff || 0x3e8 == 0x1 (0x1) +int 0x7fff & 0x3e8 == 0x3e8 (0x3e8) +__uint 0x7fff & 0x3e8 == 0x3e8 (0x3e8) +char 0xffff & 0xffe8 == -0x18 (0xffe8) +__uchar 0xff & 0xe8 == 0xe8 (0xe8) +__longlong 0x7fff & 0x3e8 == 0x3e8 (0x3e8) +__ulonglong 0x7fff & 0x3e8 == 0x3e8 (0x3e8) +int 0x7fff | 0x3e8 == 0x7fff (0x7fff) +__uint 0x7fff | 0x3e8 == 0x7fff (0x7fff) +char 0xffff | 0xffe8 == -0x1 (0xffff) +__uchar 0xff | 0xe8 == 0xff (0xff) +__longlong 0x7fff | 0x3e8 == 0x7fff (0x7fff) +__ulonglong 0x7fff | 0x3e8 == 0x7fff (0x7fff) +int 0x7fff << 0x14 == 0x0 (0x0) +__uint 0x7fff << 0x14 == 0x0 (0x0) +char 0xffff << 0x14 == 0x0 (0x0) +__uchar 0xff << 0x14 == 0x0 (0x0) +__longlong 0x7fff << 0x14 == 0x0 (0x0) +__ulonglong 0x7fff << 0x14 == 0x0 (0x0) +int 0x7fff >> 0x14 == 0x0 (0x0) +__uint 0x7fff >> 0x14 == 0x0 (0x0) +char 0xffff >> 0x14 == -0x1 (0xffff) +__uchar 0xff >> 0x14 == 0x0 (0x0) +__longlong 0x7fff >> 0x14 == 0x0 (0x0) +__ulonglong 0x7fff >> 0x14 == 0x0 (0x0) +int 0x7fff + 0x3e8 == -0x7c19 (0x83e7) +__uint 0x7fff + 0x3e8 == -0x7c19 (0x83e7) +char 0xffff + 0xffe8 == -0x19 (0xffe7) +__uchar 0xff + 0xe8 == 0xe7 (0xe7) +__longlong 0x7fff + 0x3e8 == -0x7c19 (0x83e7) +__ulonglong 0x7fff + 0x3e8 == -0x7c19 (0x83e7) +float 0x7fff + 0x3e8 == -0x8000 (0x8000) +int 0x7fff - 0x3e8 == 0x7c17 (0x7c17) +__uint 0x7fff - 0x3e8 == 0x7c17 (0x7c17) +char 0xffff - 0xffe8 == 0x17 (0x17) +__uchar 0xff - 0xe8 == 0x17 (0x17) +__longlong 0x7fff - 0x3e8 == 0x7c17 (0x7c17) +__ulonglong 0x7fff - 0x3e8 == 0x7c17 (0x7c17) +float 0x7fff - 0x3e8 == 0x7c17 (0x7c17) +int 0x7fff * 0x3e8 == -0x3e8 (0xfc18) +__uint 0x7fff * 0x3e8 == -0x3e8 (0xfc18) +char 0xffff * 0xffe8 == 0x18 (0x18) +__uchar 0xff * 0xe8 == 0x18 (0x18) +__longlong 0x7fff * 0x3e8 == -0x3e8 (0xfc18) +__ulonglong 0x7fff * 0x3e8 == -0x3e8 (0xfc18) +float 0x7fff * 0x3e8 == -0x8000 (0x8000) +int 0x7fff < 0x3e8 == 0x0 (0x0) +__uint 0x7fff < 0x3e8 == 0x0 (0x0) +char 0xffff < 0xffe8 == 0x0 (0x0) +__uchar 0xff < 0xe8 == 0x0 (0x0) +__longlong 0x7fff < 0x3e8 == 0x0 (0x0) +__ulonglong 0x7fff < 0x3e8 == 0x0 (0x0) +float 0x7fff < 0x3e8 == 0x0 (0x0) +int 0x7fff > 0x3e8 == 0x1 (0x1) +__uint 0x7fff > 0x3e8 == 0x1 (0x1) +char 0xffff > 0xffe8 == 0x1 (0x1) +__uchar 0xff > 0xe8 == 0x1 (0x1) +__longlong 0x7fff > 0x3e8 == 0x1 (0x1) +__ulonglong 0x7fff > 0x3e8 == 0x1 (0x1) +float 0x7fff > 0x3e8 == 0x1 (0x1) +int 0x7fff <= 0x3e8 == 0x0 (0x0) +__uint 0x7fff <= 0x3e8 == 0x0 (0x0) +char 0xffff <= 0xffe8 == 0x0 (0x0) +__uchar 0xff <= 0xe8 == 0x0 (0x0) +__longlong 0x7fff <= 0x3e8 == 0x0 (0x0) +__ulonglong 0x7fff <= 0x3e8 == 0x0 (0x0) +float 0x7fff <= 0x3e8 == 0x0 (0x0) +int 0x7fff == 0x3e8 == 0x0 (0x0) +__uint 0x7fff == 0x3e8 == 0x0 (0x0) +char 0xffff == 0xffe8 == 0x0 (0x0) +__uchar 0xff == 0xe8 == 0x0 (0x0) +__longlong 0x7fff == 0x3e8 == 0x0 (0x0) +__ulonglong 0x7fff == 0x3e8 == 0x0 (0x0) +float 0x7fff == 0x3e8 == 0x0 (0x0) +int 0x7fff != 0x3e8 == 0x1 (0x1) +__uint 0x7fff != 0x3e8 == 0x1 (0x1) +char 0xffff != 0xffe8 == 0x1 (0x1) +__uchar 0xff != 0xe8 == 0x1 (0x1) +__longlong 0x7fff != 0x3e8 == 0x1 (0x1) +__ulonglong 0x7fff != 0x3e8 == 0x1 (0x1) +float 0x7fff != 0x3e8 == 0x1 (0x1) +int 0x7fff >= 0x3e8 == 0x1 (0x1) +__uint 0x7fff >= 0x3e8 == 0x1 (0x1) +char 0xffff >= 0xffe8 == 0x1 (0x1) +__uchar 0xff >= 0xe8 == 0x1 (0x1) +__longlong 0x7fff >= 0x3e8 == 0x1 (0x1) +__ulonglong 0x7fff >= 0x3e8 == 0x1 (0x1) +float 0x7fff >= 0x3e8 == 0x1 (0x1) +int 0x7fff / 0x3e8 == 0x20 (0x20) +__uint 0x7fff / 0x3e8 == 0x20 (0x20) +char 0xffff / 0xffe8 == 0x0 (0x0) +__uchar 0xff / 0xe8 == 0x1 (0x1) +__longlong 0x7fff / 0x3e8 == 0x20 (0x20) +__ulonglong 0x7fff / 0x3e8 == 0x20 (0x20) +float 0x7fff / 0x3e8 == 0x20 (0x20) +int 0x7fff % 0x3e8 == 0x2ff (0x2ff) +__uint 0x7fff % 0x3e8 == 0x2ff (0x2ff) +char 0xffff % 0xffe8 == -0x1 (0xffff) +__uchar 0xff % 0xe8 == 0x17 (0x17) +__longlong 0x7fff % 0x3e8 == 0x2ff (0x2ff) +__ulonglong 0x7fff % 0x3e8 == 0x2ff (0x2ff) +0x7fff * 0x2710 == -0x2710 +0x7fff / 0x2710 == 0x3 +0x7fff % 0x2710 == 0xacf +int 0x7fff ^ 0x2710 == 0x58ef (0x58ef) +__uint 0x7fff ^ 0x2710 == 0x58ef (0x58ef) +char 0xffff ^ 0x10 == -0x11 (0xffef) +__uchar 0xff ^ 0x10 == 0xef (0xef) +__longlong 0x7fff ^ 0x2710 == 0x58ef (0x58ef) +__ulonglong 0x7fff ^ 0x2710 == 0x58ef (0x58ef) +int 0x7fff && 0x2710 == 0x1 (0x1) +__uint 0x7fff && 0x2710 == 0x1 (0x1) +char 0xffff && 0x10 == 0x1 (0x1) +__uchar 0xff && 0x10 == 0x1 (0x1) +__longlong 0x7fff && 0x2710 == 0x1 (0x1) +__ulonglong 0x7fff && 0x2710 == 0x1 (0x1) +int 0x7fff || 0x2710 == 0x1 (0x1) +__uint 0x7fff || 0x2710 == 0x1 (0x1) +char 0xffff || 0x10 == 0x1 (0x1) +__uchar 0xff || 0x10 == 0x1 (0x1) +__longlong 0x7fff || 0x2710 == 0x1 (0x1) +__ulonglong 0x7fff || 0x2710 == 0x1 (0x1) +int 0x7fff & 0x2710 == 0x2710 (0x2710) +__uint 0x7fff & 0x2710 == 0x2710 (0x2710) +char 0xffff & 0x10 == 0x10 (0x10) +__uchar 0xff & 0x10 == 0x10 (0x10) +__longlong 0x7fff & 0x2710 == 0x2710 (0x2710) +__ulonglong 0x7fff & 0x2710 == 0x2710 (0x2710) +int 0x7fff | 0x2710 == 0x7fff (0x7fff) +__uint 0x7fff | 0x2710 == 0x7fff (0x7fff) +char 0xffff | 0x10 == -0x1 (0xffff) +__uchar 0xff | 0x10 == 0xff (0xff) +__longlong 0x7fff | 0x2710 == 0x7fff (0x7fff) +__ulonglong 0x7fff | 0x2710 == 0x7fff (0x7fff) +int 0x7fff << 0x16 == 0x0 (0x0) +__uint 0x7fff << 0x16 == 0x0 (0x0) +char 0xffff << 0x16 == 0x0 (0x0) +__uchar 0xff << 0x16 == 0x0 (0x0) +__longlong 0x7fff << 0x16 == 0x0 (0x0) +__ulonglong 0x7fff << 0x16 == 0x0 (0x0) +int 0x7fff >> 0x16 == 0x0 (0x0) +__uint 0x7fff >> 0x16 == 0x0 (0x0) +char 0xffff >> 0x16 == -0x1 (0xffff) +__uchar 0xff >> 0x16 == 0x0 (0x0) +__longlong 0x7fff >> 0x16 == 0x0 (0x0) +__ulonglong 0x7fff >> 0x16 == 0x0 (0x0) +int 0x7fff + 0x2710 == -0x58f1 (0xa70f) +__uint 0x7fff + 0x2710 == -0x58f1 (0xa70f) +char 0xffff + 0x10 == 0xf (0xf) +__uchar 0xff + 0x10 == 0xf (0xf) +__longlong 0x7fff + 0x2710 == -0x58f1 (0xa70f) +__ulonglong 0x7fff + 0x2710 == -0x58f1 (0xa70f) +float 0x7fff + 0x2710 == -0x8000 (0x8000) +int 0x7fff - 0x2710 == 0x58ef (0x58ef) +__uint 0x7fff - 0x2710 == 0x58ef (0x58ef) +char 0xffff - 0x10 == -0x11 (0xffef) +__uchar 0xff - 0x10 == 0xef (0xef) +__longlong 0x7fff - 0x2710 == 0x58ef (0x58ef) +__ulonglong 0x7fff - 0x2710 == 0x58ef (0x58ef) +float 0x7fff - 0x2710 == 0x58ef (0x58ef) +int 0x7fff * 0x2710 == -0x2710 (0xd8f0) +__uint 0x7fff * 0x2710 == -0x2710 (0xd8f0) +char 0xffff * 0x10 == -0x10 (0xfff0) +__uchar 0xff * 0x10 == 0xf0 (0xf0) +__longlong 0x7fff * 0x2710 == -0x2710 (0xd8f0) +__ulonglong 0x7fff * 0x2710 == -0x2710 (0xd8f0) +float 0x7fff * 0x2710 == -0x8000 (0x8000) +int 0x7fff < 0x2710 == 0x0 (0x0) +__uint 0x7fff < 0x2710 == 0x0 (0x0) +char 0xffff < 0x10 == 0x1 (0x1) +__uchar 0xff < 0x10 == 0x0 (0x0) +__longlong 0x7fff < 0x2710 == 0x0 (0x0) +__ulonglong 0x7fff < 0x2710 == 0x0 (0x0) +float 0x7fff < 0x2710 == 0x0 (0x0) +int 0x7fff > 0x2710 == 0x1 (0x1) +__uint 0x7fff > 0x2710 == 0x1 (0x1) +char 0xffff > 0x10 == 0x0 (0x0) +__uchar 0xff > 0x10 == 0x1 (0x1) +__longlong 0x7fff > 0x2710 == 0x1 (0x1) +__ulonglong 0x7fff > 0x2710 == 0x1 (0x1) +float 0x7fff > 0x2710 == 0x1 (0x1) +int 0x7fff <= 0x2710 == 0x0 (0x0) +__uint 0x7fff <= 0x2710 == 0x0 (0x0) +char 0xffff <= 0x10 == 0x1 (0x1) +__uchar 0xff <= 0x10 == 0x0 (0x0) +__longlong 0x7fff <= 0x2710 == 0x0 (0x0) +__ulonglong 0x7fff <= 0x2710 == 0x0 (0x0) +float 0x7fff <= 0x2710 == 0x0 (0x0) +int 0x7fff == 0x2710 == 0x0 (0x0) +__uint 0x7fff == 0x2710 == 0x0 (0x0) +char 0xffff == 0x10 == 0x0 (0x0) +__uchar 0xff == 0x10 == 0x0 (0x0) +__longlong 0x7fff == 0x2710 == 0x0 (0x0) +__ulonglong 0x7fff == 0x2710 == 0x0 (0x0) +float 0x7fff == 0x2710 == 0x0 (0x0) +int 0x7fff != 0x2710 == 0x1 (0x1) +__uint 0x7fff != 0x2710 == 0x1 (0x1) +char 0xffff != 0x10 == 0x1 (0x1) +__uchar 0xff != 0x10 == 0x1 (0x1) +__longlong 0x7fff != 0x2710 == 0x1 (0x1) +__ulonglong 0x7fff != 0x2710 == 0x1 (0x1) +float 0x7fff != 0x2710 == 0x1 (0x1) +int 0x7fff >= 0x2710 == 0x1 (0x1) +__uint 0x7fff >= 0x2710 == 0x1 (0x1) +char 0xffff >= 0x10 == 0x0 (0x0) +__uchar 0xff >= 0x10 == 0x1 (0x1) +__longlong 0x7fff >= 0x2710 == 0x1 (0x1) +__ulonglong 0x7fff >= 0x2710 == 0x1 (0x1) +float 0x7fff >= 0x2710 == 0x1 (0x1) +int 0x7fff / 0x2710 == 0x3 (0x3) +__uint 0x7fff / 0x2710 == 0x3 (0x3) +char 0xffff / 0x10 == 0x0 (0x0) +__uchar 0xff / 0x10 == 0xf (0xf) +__longlong 0x7fff / 0x2710 == 0x3 (0x3) +__ulonglong 0x7fff / 0x2710 == 0x3 (0x3) +float 0x7fff / 0x2710 == 0x3 (0x3) +int 0x7fff % 0x2710 == 0xacf (0xacf) +__uint 0x7fff % 0x2710 == 0xacf (0xacf) +char 0xffff % 0x10 == -0x1 (0xffff) +__uchar 0xff % 0x10 == 0xf (0xf) +__longlong 0x7fff % 0x2710 == 0xacf (0xacf) +__ulonglong 0x7fff % 0x2710 == 0xacf (0xacf) +int xor420x7fff xor42 0x7fd5 +__uint xor420x7fff xor42 0x7fd5 +char xor42-0x1 xor42 -0x2b +__uchar xor420xff xor42 0xd5 +__longlong xor420x7fff xor42 0x7fd5 +__ulonglong xor420x7fff xor42 0x7fd5 +int land10x7fff land1 0x1 +__uint land10x7fff land1 0x1 +char land1-0x1 land1 0x1 +__uchar land10xff land1 0x1 +__longlong land10x7fff land1 0x1 +__ulonglong land10x7fff land1 0x1 +int lor10x7fff lor1 0x1 +__uint lor10x7fff lor1 0x1 +char lor1-0x1 lor1 0x1 +__uchar lor10xff lor1 0x1 +__longlong lor10x7fff lor1 0x1 +__ulonglong lor10x7fff lor1 0x1 +int and420x7fff and42 0x2a +__uint and420x7fff and42 0x2a +char and42-0x1 and42 0x2a +__uchar and420xff and42 0x2a +__longlong and420x7fff and42 0x2a +__ulonglong and420x7fff and42 0x2a +int or420x7fff or42 0x7fff +__uint or420x7fff or42 0x7fff +char or42-0x1 or42 -0x1 +__uchar or420xff or42 0xff +__longlong or420x7fff or42 0x7fff +__ulonglong or420x7fff or42 0x7fff +int shl50x7fff shl5 -0x20 +__uint shl50x7fff shl5 -0x20 +char shl5-0x1 shl5 -0x20 +__uchar shl50xff shl5 0xe0 +__longlong shl50x7fff shl5 -0x20 +__ulonglong shl50x7fff shl5 -0x20 +int shr50x7fff shr5 0x3ff +__uint shr50x7fff shr5 0x3ff +char shr5-0x1 shr5 -0x1 +__uchar shr50xff shr5 0x7 +__longlong shr50x7fff shr5 0x3ff +__ulonglong shr50x7fff shr5 0x3ff +int add420x7fff add42 -0x7fd7 +__uint add420x7fff add42 -0x7fd7 +char add42-0x1 add42 0x29 +__uchar add420xff add42 0x29 +__longlong add420x7fff add42 -0x7fd7 +__ulonglong add420x7fff add42 -0x7fd7 +float add420x7fff add42 -0x8000 +int sub420x7fff sub42 0x7fd5 +__uint sub420x7fff sub42 0x7fd5 +char sub42-0x1 sub42 -0x2b +__uchar sub420xff sub42 0xd5 +__longlong sub420x7fff sub42 0x7fd5 +__ulonglong sub420x7fff sub42 0x7fd5 +float sub420x7fff sub42 0x7fd5 +int mul420x7fff mul42 -0x2a +__uint mul420x7fff mul42 -0x2a +char mul42-0x1 mul42 -0x2a +__uchar mul420xff mul42 0xd6 +__longlong mul420x7fff mul42 -0x2a +__ulonglong mul420x7fff mul42 -0x2a +float mul420x7fff mul42 -0x8000 +int lt420x7fff lt42 0x0 +__uint lt420x7fff lt42 0x0 +char lt42-0x1 lt42 0x1 +__uchar lt420xff lt42 0x0 +__longlong lt420x7fff lt42 0x0 +__ulonglong lt420x7fff lt42 0x0 +float lt420x7fff lt42 0x0 +int gt420x7fff gt42 0x1 +__uint gt420x7fff gt42 0x1 +char gt42-0x1 gt42 0x0 +__uchar gt420xff gt42 0x1 +__longlong gt420x7fff gt42 0x1 +__ulonglong gt420x7fff gt42 0x1 +float gt420x7fff gt42 0x1 +int le420x7fff le42 0x0 +__uint le420x7fff le42 0x0 +char le42-0x1 le42 0x1 +__uchar le420xff le42 0x0 +__longlong le420x7fff le42 0x0 +__ulonglong le420x7fff le42 0x0 +float le420x7fff le42 0x0 +int eq420x7fff eq42 0x0 +__uint eq420x7fff eq42 0x0 +char eq42-0x1 eq42 0x0 +__uchar eq420xff eq42 0x0 +__longlong eq420x7fff eq42 0x0 +__ulonglong eq420x7fff eq42 0x0 +float eq420x7fff eq42 0x0 +int ne420x7fff ne42 0x1 +__uint ne420x7fff ne42 0x1 +char ne42-0x1 ne42 0x1 +__uchar ne420xff ne42 0x1 +__longlong ne420x7fff ne42 0x1 +__ulonglong ne420x7fff ne42 0x1 +float ne420x7fff ne42 0x1 +int ge420x7fff ge42 0x1 +__uint ge420x7fff ge42 0x1 +char ge42-0x1 ge42 0x0 +__uchar ge420xff ge42 0x1 +__longlong ge420x7fff ge42 0x1 +__ulonglong ge420x7fff ge42 0x1 +float ge420x7fff ge42 0x1 +int div420x7fff div42 0x30c +__uint div420x7fff div42 0x30c +char div42-0x1 div42 0x0 +__uchar div420xff div42 0x6 +__longlong div420x7fff div42 0x30c +__ulonglong div420x7fff div42 0x30c +float div420x7fff div42 0x30c +int mod230x7fff mod23 0xf +__uint mod230x7fff mod23 0xf +char mod23-0x1 mod23 -0x1 +__uchar mod230xff mod23 0x2 +__longlong mod230x7fff mod23 0xf +__ulonglong mod230x7fff mod23 0xf +0x8000 * 0xffff == -0x8000 +0x8000 / 0xffff == -0x8000 +0x8000 % 0xffff == 0x0 +int 0x8000 ^ 0xffff == 0x7fff (0x7fff) +__uint 0x8000 ^ 0xffff == 0x7fff (0x7fff) +char 0x0 ^ 0xffff == -0x1 (0xffff) +__uchar 0x0 ^ 0xff == 0xff (0xff) +__longlong 0x8000 ^ 0xffff == 0x7fff (0x7fff) +__ulonglong 0x8000 ^ 0xffff == 0x7fff (0x7fff) +int 0x8000 && 0xffff == 0x1 (0x1) +__uint 0x8000 && 0xffff == 0x1 (0x1) +char 0x0 && 0xffff == 0x0 (0x0) +__uchar 0x0 && 0xff == 0x0 (0x0) +__longlong 0x8000 && 0xffff == 0x1 (0x1) +__ulonglong 0x8000 && 0xffff == 0x1 (0x1) +int 0x8000 || 0xffff == 0x1 (0x1) +__uint 0x8000 || 0xffff == 0x1 (0x1) +char 0x0 || 0xffff == 0x1 (0x1) +__uchar 0x0 || 0xff == 0x1 (0x1) +__longlong 0x8000 || 0xffff == 0x1 (0x1) +__ulonglong 0x8000 || 0xffff == 0x1 (0x1) +int 0x8000 & 0xffff == -0x8000 (0x8000) +__uint 0x8000 & 0xffff == -0x8000 (0x8000) +char 0x0 & 0xffff == 0x0 (0x0) +__uchar 0x0 & 0xff == 0x0 (0x0) +__longlong 0x8000 & 0xffff == -0x8000 (0x8000) +__ulonglong 0x8000 & 0xffff == -0x8000 (0x8000) +int 0x8000 | 0xffff == -0x1 (0xffff) +__uint 0x8000 | 0xffff == -0x1 (0xffff) +char 0x0 | 0xffff == -0x1 (0xffff) +__uchar 0x0 | 0xff == 0xff (0xff) +__longlong 0x8000 | 0xffff == -0x1 (0xffff) +__ulonglong 0x8000 | 0xffff == -0x1 (0xffff) +int 0x8000 << 0x1 == 0x0 (0x0) +__uint 0x8000 << 0x1 == 0x0 (0x0) +char 0x0 << 0x1 == 0x0 (0x0) +__uchar 0x0 << 0x1 == 0x0 (0x0) +__longlong 0x8000 << 0x1 == 0x0 (0x0) +__ulonglong 0x8000 << 0x1 == 0x0 (0x0) +int 0x8000 >> 0x1 == -0x4000 (0xc000) +__uint 0x8000 >> 0x1 == 0x4000 (0x4000) +char 0x0 >> 0x1 == 0x0 (0x0) +__uchar 0x0 >> 0x1 == 0x0 (0x0) +__longlong 0x8000 >> 0x1 == -0x4000 (0xc000) +__ulonglong 0x8000 >> 0x1 == -0x4000 (0xc000) +int 0x8000 + 0xffff == 0x7fff (0x7fff) +__uint 0x8000 + 0xffff == 0x7fff (0x7fff) +char 0x0 + 0xffff == -0x1 (0xffff) +__uchar 0x0 + 0xff == 0xff (0xff) +__longlong 0x8000 + 0xffff == 0x7fff (0x7fff) +__ulonglong 0x8000 + 0xffff == 0x7fff (0x7fff) +float 0x8000 + 0xffff == -0x8000 (0x8000) +int 0x8000 - 0xffff == -0x7fff (0x8001) +__uint 0x8000 - 0xffff == -0x7fff (0x8001) +char 0x0 - 0xffff == 0x1 (0x1) +__uchar 0x0 - 0xff == 0x1 (0x1) +__longlong 0x8000 - 0xffff == -0x7fff (0x8001) +__ulonglong 0x8000 - 0xffff == -0x7fff (0x8001) +float 0x8000 - 0xffff == -0x7fff (0x8001) +int 0x8000 * 0xffff == -0x8000 (0x8000) +__uint 0x8000 * 0xffff == -0x8000 (0x8000) +char 0x0 * 0xffff == 0x0 (0x0) +__uchar 0x0 * 0xff == 0x0 (0x0) +__longlong 0x8000 * 0xffff == -0x8000 (0x8000) +__ulonglong 0x8000 * 0xffff == -0x8000 (0x8000) +float 0x8000 * 0xffff == -0x8000 (0x8000) +int 0x8000 < 0xffff == 0x1 (0x1) +__uint 0x8000 < 0xffff == 0x1 (0x1) +char 0x0 < 0xffff == 0x0 (0x0) +__uchar 0x0 < 0xff == 0x1 (0x1) +__longlong 0x8000 < 0xffff == 0x1 (0x1) +__ulonglong 0x8000 < 0xffff == 0x1 (0x1) +float 0x8000 < 0xffff == 0x1 (0x1) +int 0x8000 > 0xffff == 0x0 (0x0) +__uint 0x8000 > 0xffff == 0x0 (0x0) +char 0x0 > 0xffff == 0x1 (0x1) +__uchar 0x0 > 0xff == 0x0 (0x0) +__longlong 0x8000 > 0xffff == 0x0 (0x0) +__ulonglong 0x8000 > 0xffff == 0x0 (0x0) +float 0x8000 > 0xffff == 0x0 (0x0) +int 0x8000 <= 0xffff == 0x1 (0x1) +__uint 0x8000 <= 0xffff == 0x1 (0x1) +char 0x0 <= 0xffff == 0x0 (0x0) +__uchar 0x0 <= 0xff == 0x1 (0x1) +__longlong 0x8000 <= 0xffff == 0x1 (0x1) +__ulonglong 0x8000 <= 0xffff == 0x1 (0x1) +float 0x8000 <= 0xffff == 0x1 (0x1) +int 0x8000 == 0xffff == 0x0 (0x0) +__uint 0x8000 == 0xffff == 0x0 (0x0) +char 0x0 == 0xffff == 0x0 (0x0) +__uchar 0x0 == 0xff == 0x0 (0x0) +__longlong 0x8000 == 0xffff == 0x0 (0x0) +__ulonglong 0x8000 == 0xffff == 0x0 (0x0) +float 0x8000 == 0xffff == 0x0 (0x0) +int 0x8000 != 0xffff == 0x1 (0x1) +__uint 0x8000 != 0xffff == 0x1 (0x1) +char 0x0 != 0xffff == 0x1 (0x1) +__uchar 0x0 != 0xff == 0x1 (0x1) +__longlong 0x8000 != 0xffff == 0x1 (0x1) +__ulonglong 0x8000 != 0xffff == 0x1 (0x1) +float 0x8000 != 0xffff == 0x1 (0x1) +int 0x8000 >= 0xffff == 0x0 (0x0) +__uint 0x8000 >= 0xffff == 0x0 (0x0) +char 0x0 >= 0xffff == 0x1 (0x1) +__uchar 0x0 >= 0xff == 0x0 (0x0) +__longlong 0x8000 >= 0xffff == 0x0 (0x0) +__ulonglong 0x8000 >= 0xffff == 0x0 (0x0) +float 0x8000 >= 0xffff == 0x0 (0x0) +int 0x8000 / 0xffff == -0x8000 (0x8000) +__uint 0x8000 / 0xffff == 0x0 (0x0) +char 0x0 / 0xffff == 0x0 (0x0) +__uchar 0x0 / 0xff == 0x0 (0x0) +__longlong 0x8000 / 0xffff == -0x8000 (0x8000) +__ulonglong 0x8000 / 0xffff == 0x0 (0x0) +float 0x8000 / 0xffff == -0x8000 (0x8000) +int 0x8000 % 0xffff == 0x0 (0x0) +__uint 0x8000 % 0xffff == -0x8000 (0x8000) +char 0x0 % 0xffff == 0x0 (0x0) +__uchar 0x0 % 0xff == 0x0 (0x0) +__longlong 0x8000 % 0xffff == 0x0 (0x0) +__ulonglong 0x8000 % 0xffff == -0x8000 (0x8000) +0x8000 * 0x1 == -0x8000 +0x8000 / 0x1 == -0x8000 +0x8000 % 0x1 == 0x0 +int 0x8000 ^ 0x1 == -0x7fff (0x8001) +__uint 0x8000 ^ 0x1 == -0x7fff (0x8001) +char 0x0 ^ 0x1 == 0x1 (0x1) +__uchar 0x0 ^ 0x1 == 0x1 (0x1) +__longlong 0x8000 ^ 0x1 == -0x7fff (0x8001) +__ulonglong 0x8000 ^ 0x1 == -0x7fff (0x8001) +int 0x8000 && 0x1 == 0x1 (0x1) +__uint 0x8000 && 0x1 == 0x1 (0x1) +char 0x0 && 0x1 == 0x0 (0x0) +__uchar 0x0 && 0x1 == 0x0 (0x0) +__longlong 0x8000 && 0x1 == 0x1 (0x1) +__ulonglong 0x8000 && 0x1 == 0x1 (0x1) +int 0x8000 || 0x1 == 0x1 (0x1) +__uint 0x8000 || 0x1 == 0x1 (0x1) +char 0x0 || 0x1 == 0x1 (0x1) +__uchar 0x0 || 0x1 == 0x1 (0x1) +__longlong 0x8000 || 0x1 == 0x1 (0x1) +__ulonglong 0x8000 || 0x1 == 0x1 (0x1) +int 0x8000 & 0x1 == 0x0 (0x0) +__uint 0x8000 & 0x1 == 0x0 (0x0) +char 0x0 & 0x1 == 0x0 (0x0) +__uchar 0x0 & 0x1 == 0x0 (0x0) +__longlong 0x8000 & 0x1 == 0x0 (0x0) +__ulonglong 0x8000 & 0x1 == 0x0 (0x0) +int 0x8000 | 0x1 == -0x7fff (0x8001) +__uint 0x8000 | 0x1 == -0x7fff (0x8001) +char 0x0 | 0x1 == 0x1 (0x1) +__uchar 0x0 | 0x1 == 0x1 (0x1) +__longlong 0x8000 | 0x1 == -0x7fff (0x8001) +__ulonglong 0x8000 | 0x1 == -0x7fff (0x8001) +int 0x8000 << 0x2 == 0x0 (0x0) +__uint 0x8000 << 0x2 == 0x0 (0x0) +char 0x0 << 0x2 == 0x0 (0x0) +__uchar 0x0 << 0x2 == 0x0 (0x0) +__longlong 0x8000 << 0x2 == 0x0 (0x0) +__ulonglong 0x8000 << 0x2 == 0x0 (0x0) +int 0x8000 >> 0x2 == -0x2000 (0xe000) +__uint 0x8000 >> 0x2 == 0x2000 (0x2000) +char 0x0 >> 0x2 == 0x0 (0x0) +__uchar 0x0 >> 0x2 == 0x0 (0x0) +__longlong 0x8000 >> 0x2 == -0x2000 (0xe000) +__ulonglong 0x8000 >> 0x2 == -0x2000 (0xe000) +int 0x8000 + 0x1 == -0x7fff (0x8001) +__uint 0x8000 + 0x1 == -0x7fff (0x8001) +char 0x0 + 0x1 == 0x1 (0x1) +__uchar 0x0 + 0x1 == 0x1 (0x1) +__longlong 0x8000 + 0x1 == -0x7fff (0x8001) +__ulonglong 0x8000 + 0x1 == -0x7fff (0x8001) +float 0x8000 + 0x1 == -0x7fff (0x8001) +int 0x8000 - 0x1 == 0x7fff (0x7fff) +__uint 0x8000 - 0x1 == 0x7fff (0x7fff) +char 0x0 - 0x1 == -0x1 (0xffff) +__uchar 0x0 - 0x1 == 0xff (0xff) +__longlong 0x8000 - 0x1 == 0x7fff (0x7fff) +__ulonglong 0x8000 - 0x1 == 0x7fff (0x7fff) +float 0x8000 - 0x1 == -0x8000 (0x8000) +int 0x8000 * 0x1 == -0x8000 (0x8000) +__uint 0x8000 * 0x1 == -0x8000 (0x8000) +char 0x0 * 0x1 == 0x0 (0x0) +__uchar 0x0 * 0x1 == 0x0 (0x0) +__longlong 0x8000 * 0x1 == -0x8000 (0x8000) +__ulonglong 0x8000 * 0x1 == -0x8000 (0x8000) +float 0x8000 * 0x1 == -0x8000 (0x8000) +int 0x8000 < 0x1 == 0x1 (0x1) +__uint 0x8000 < 0x1 == 0x0 (0x0) +char 0x0 < 0x1 == 0x1 (0x1) +__uchar 0x0 < 0x1 == 0x1 (0x1) +__longlong 0x8000 < 0x1 == 0x1 (0x1) +__ulonglong 0x8000 < 0x1 == 0x0 (0x0) +float 0x8000 < 0x1 == 0x1 (0x1) +int 0x8000 > 0x1 == 0x0 (0x0) +__uint 0x8000 > 0x1 == 0x1 (0x1) +char 0x0 > 0x1 == 0x0 (0x0) +__uchar 0x0 > 0x1 == 0x0 (0x0) +__longlong 0x8000 > 0x1 == 0x0 (0x0) +__ulonglong 0x8000 > 0x1 == 0x1 (0x1) +float 0x8000 > 0x1 == 0x0 (0x0) +int 0x8000 <= 0x1 == 0x1 (0x1) +__uint 0x8000 <= 0x1 == 0x0 (0x0) +char 0x0 <= 0x1 == 0x1 (0x1) +__uchar 0x0 <= 0x1 == 0x1 (0x1) +__longlong 0x8000 <= 0x1 == 0x1 (0x1) +__ulonglong 0x8000 <= 0x1 == 0x0 (0x0) +float 0x8000 <= 0x1 == 0x1 (0x1) +int 0x8000 == 0x1 == 0x0 (0x0) +__uint 0x8000 == 0x1 == 0x0 (0x0) +char 0x0 == 0x1 == 0x0 (0x0) +__uchar 0x0 == 0x1 == 0x0 (0x0) +__longlong 0x8000 == 0x1 == 0x0 (0x0) +__ulonglong 0x8000 == 0x1 == 0x0 (0x0) +float 0x8000 == 0x1 == 0x0 (0x0) +int 0x8000 != 0x1 == 0x1 (0x1) +__uint 0x8000 != 0x1 == 0x1 (0x1) +char 0x0 != 0x1 == 0x1 (0x1) +__uchar 0x0 != 0x1 == 0x1 (0x1) +__longlong 0x8000 != 0x1 == 0x1 (0x1) +__ulonglong 0x8000 != 0x1 == 0x1 (0x1) +float 0x8000 != 0x1 == 0x1 (0x1) +int 0x8000 >= 0x1 == 0x0 (0x0) +__uint 0x8000 >= 0x1 == 0x1 (0x1) +char 0x0 >= 0x1 == 0x0 (0x0) +__uchar 0x0 >= 0x1 == 0x0 (0x0) +__longlong 0x8000 >= 0x1 == 0x0 (0x0) +__ulonglong 0x8000 >= 0x1 == 0x1 (0x1) +float 0x8000 >= 0x1 == 0x0 (0x0) +int 0x8000 / 0x1 == -0x8000 (0x8000) +__uint 0x8000 / 0x1 == -0x8000 (0x8000) +char 0x0 / 0x1 == 0x0 (0x0) +__uchar 0x0 / 0x1 == 0x0 (0x0) +__longlong 0x8000 / 0x1 == -0x8000 (0x8000) +__ulonglong 0x8000 / 0x1 == -0x8000 (0x8000) +float 0x8000 / 0x1 == -0x8000 (0x8000) +int 0x8000 % 0x1 == 0x0 (0x0) +__uint 0x8000 % 0x1 == 0x0 (0x0) +char 0x0 % 0x1 == 0x0 (0x0) +__uchar 0x0 % 0x1 == 0x0 (0x0) +__longlong 0x8000 % 0x1 == 0x0 (0x0) +__ulonglong 0x8000 % 0x1 == 0x0 (0x0) +0x8000 * 0x2 == 0x0 +0x8000 / 0x2 == -0x4000 +0x8000 % 0x2 == 0x0 +int 0x8000 ^ 0x2 == -0x7ffe (0x8002) +__uint 0x8000 ^ 0x2 == -0x7ffe (0x8002) +char 0x0 ^ 0x2 == 0x2 (0x2) +__uchar 0x0 ^ 0x2 == 0x2 (0x2) +__longlong 0x8000 ^ 0x2 == -0x7ffe (0x8002) +__ulonglong 0x8000 ^ 0x2 == -0x7ffe (0x8002) +int 0x8000 && 0x2 == 0x1 (0x1) +__uint 0x8000 && 0x2 == 0x1 (0x1) +char 0x0 && 0x2 == 0x0 (0x0) +__uchar 0x0 && 0x2 == 0x0 (0x0) +__longlong 0x8000 && 0x2 == 0x1 (0x1) +__ulonglong 0x8000 && 0x2 == 0x1 (0x1) +int 0x8000 || 0x2 == 0x1 (0x1) +__uint 0x8000 || 0x2 == 0x1 (0x1) +char 0x0 || 0x2 == 0x1 (0x1) +__uchar 0x0 || 0x2 == 0x1 (0x1) +__longlong 0x8000 || 0x2 == 0x1 (0x1) +__ulonglong 0x8000 || 0x2 == 0x1 (0x1) +int 0x8000 & 0x2 == 0x0 (0x0) +__uint 0x8000 & 0x2 == 0x0 (0x0) +char 0x0 & 0x2 == 0x0 (0x0) +__uchar 0x0 & 0x2 == 0x0 (0x0) +__longlong 0x8000 & 0x2 == 0x0 (0x0) +__ulonglong 0x8000 & 0x2 == 0x0 (0x0) +int 0x8000 | 0x2 == -0x7ffe (0x8002) +__uint 0x8000 | 0x2 == -0x7ffe (0x8002) +char 0x0 | 0x2 == 0x2 (0x2) +__uchar 0x0 | 0x2 == 0x2 (0x2) +__longlong 0x8000 | 0x2 == -0x7ffe (0x8002) +__ulonglong 0x8000 | 0x2 == -0x7ffe (0x8002) +int 0x8000 << 0x3 == 0x0 (0x0) +__uint 0x8000 << 0x3 == 0x0 (0x0) +char 0x0 << 0x3 == 0x0 (0x0) +__uchar 0x0 << 0x3 == 0x0 (0x0) +__longlong 0x8000 << 0x3 == 0x0 (0x0) +__ulonglong 0x8000 << 0x3 == 0x0 (0x0) +int 0x8000 >> 0x3 == -0x1000 (0xf000) +__uint 0x8000 >> 0x3 == 0x1000 (0x1000) +char 0x0 >> 0x3 == 0x0 (0x0) +__uchar 0x0 >> 0x3 == 0x0 (0x0) +__longlong 0x8000 >> 0x3 == -0x1000 (0xf000) +__ulonglong 0x8000 >> 0x3 == -0x1000 (0xf000) +int 0x8000 + 0x2 == -0x7ffe (0x8002) +__uint 0x8000 + 0x2 == -0x7ffe (0x8002) +char 0x0 + 0x2 == 0x2 (0x2) +__uchar 0x0 + 0x2 == 0x2 (0x2) +__longlong 0x8000 + 0x2 == -0x7ffe (0x8002) +__ulonglong 0x8000 + 0x2 == -0x7ffe (0x8002) +float 0x8000 + 0x2 == -0x7ffe (0x8002) +int 0x8000 - 0x2 == 0x7ffe (0x7ffe) +__uint 0x8000 - 0x2 == 0x7ffe (0x7ffe) +char 0x0 - 0x2 == -0x2 (0xfffe) +__uchar 0x0 - 0x2 == 0xfe (0xfe) +__longlong 0x8000 - 0x2 == 0x7ffe (0x7ffe) +__ulonglong 0x8000 - 0x2 == 0x7ffe (0x7ffe) +float 0x8000 - 0x2 == -0x8000 (0x8000) +int 0x8000 * 0x2 == 0x0 (0x0) +__uint 0x8000 * 0x2 == 0x0 (0x0) +char 0x0 * 0x2 == 0x0 (0x0) +__uchar 0x0 * 0x2 == 0x0 (0x0) +__longlong 0x8000 * 0x2 == 0x0 (0x0) +__ulonglong 0x8000 * 0x2 == 0x0 (0x0) +float 0x8000 * 0x2 == -0x8000 (0x8000) +int 0x8000 < 0x2 == 0x1 (0x1) +__uint 0x8000 < 0x2 == 0x0 (0x0) +char 0x0 < 0x2 == 0x1 (0x1) +__uchar 0x0 < 0x2 == 0x1 (0x1) +__longlong 0x8000 < 0x2 == 0x1 (0x1) +__ulonglong 0x8000 < 0x2 == 0x0 (0x0) +float 0x8000 < 0x2 == 0x1 (0x1) +int 0x8000 > 0x2 == 0x0 (0x0) +__uint 0x8000 > 0x2 == 0x1 (0x1) +char 0x0 > 0x2 == 0x0 (0x0) +__uchar 0x0 > 0x2 == 0x0 (0x0) +__longlong 0x8000 > 0x2 == 0x0 (0x0) +__ulonglong 0x8000 > 0x2 == 0x1 (0x1) +float 0x8000 > 0x2 == 0x0 (0x0) +int 0x8000 <= 0x2 == 0x1 (0x1) +__uint 0x8000 <= 0x2 == 0x0 (0x0) +char 0x0 <= 0x2 == 0x1 (0x1) +__uchar 0x0 <= 0x2 == 0x1 (0x1) +__longlong 0x8000 <= 0x2 == 0x1 (0x1) +__ulonglong 0x8000 <= 0x2 == 0x0 (0x0) +float 0x8000 <= 0x2 == 0x1 (0x1) +int 0x8000 == 0x2 == 0x0 (0x0) +__uint 0x8000 == 0x2 == 0x0 (0x0) +char 0x0 == 0x2 == 0x0 (0x0) +__uchar 0x0 == 0x2 == 0x0 (0x0) +__longlong 0x8000 == 0x2 == 0x0 (0x0) +__ulonglong 0x8000 == 0x2 == 0x0 (0x0) +float 0x8000 == 0x2 == 0x0 (0x0) +int 0x8000 != 0x2 == 0x1 (0x1) +__uint 0x8000 != 0x2 == 0x1 (0x1) +char 0x0 != 0x2 == 0x1 (0x1) +__uchar 0x0 != 0x2 == 0x1 (0x1) +__longlong 0x8000 != 0x2 == 0x1 (0x1) +__ulonglong 0x8000 != 0x2 == 0x1 (0x1) +float 0x8000 != 0x2 == 0x1 (0x1) +int 0x8000 >= 0x2 == 0x0 (0x0) +__uint 0x8000 >= 0x2 == 0x1 (0x1) +char 0x0 >= 0x2 == 0x0 (0x0) +__uchar 0x0 >= 0x2 == 0x0 (0x0) +__longlong 0x8000 >= 0x2 == 0x0 (0x0) +__ulonglong 0x8000 >= 0x2 == 0x1 (0x1) +float 0x8000 >= 0x2 == 0x0 (0x0) +int 0x8000 / 0x2 == -0x4000 (0xc000) +__uint 0x8000 / 0x2 == 0x4000 (0x4000) +char 0x0 / 0x2 == 0x0 (0x0) +__uchar 0x0 / 0x2 == 0x0 (0x0) +__longlong 0x8000 / 0x2 == -0x4000 (0xc000) +__ulonglong 0x8000 / 0x2 == -0x4000 (0xc000) +float 0x8000 / 0x2 == -0x4000 (0xc000) +int 0x8000 % 0x2 == 0x0 (0x0) +__uint 0x8000 % 0x2 == 0x0 (0x0) +char 0x0 % 0x2 == 0x0 (0x0) +__uchar 0x0 % 0x2 == 0x0 (0x0) +__longlong 0x8000 % 0x2 == 0x0 (0x0) +__ulonglong 0x8000 % 0x2 == 0x0 (0x0) +0x8000 * 0xfffe == 0x0 +0x8000 / 0xfffe == 0x4000 +0x8000 % 0xfffe == 0x0 +int 0x8000 ^ 0xfffe == 0x7ffe (0x7ffe) +__uint 0x8000 ^ 0xfffe == 0x7ffe (0x7ffe) +char 0x0 ^ 0xfffe == -0x2 (0xfffe) +__uchar 0x0 ^ 0xfe == 0xfe (0xfe) +__longlong 0x8000 ^ 0xfffe == 0x7ffe (0x7ffe) +__ulonglong 0x8000 ^ 0xfffe == 0x7ffe (0x7ffe) +int 0x8000 && 0xfffe == 0x1 (0x1) +__uint 0x8000 && 0xfffe == 0x1 (0x1) +char 0x0 && 0xfffe == 0x0 (0x0) +__uchar 0x0 && 0xfe == 0x0 (0x0) +__longlong 0x8000 && 0xfffe == 0x1 (0x1) +__ulonglong 0x8000 && 0xfffe == 0x1 (0x1) +int 0x8000 || 0xfffe == 0x1 (0x1) +__uint 0x8000 || 0xfffe == 0x1 (0x1) +char 0x0 || 0xfffe == 0x1 (0x1) +__uchar 0x0 || 0xfe == 0x1 (0x1) +__longlong 0x8000 || 0xfffe == 0x1 (0x1) +__ulonglong 0x8000 || 0xfffe == 0x1 (0x1) +int 0x8000 & 0xfffe == -0x8000 (0x8000) +__uint 0x8000 & 0xfffe == -0x8000 (0x8000) +char 0x0 & 0xfffe == 0x0 (0x0) +__uchar 0x0 & 0xfe == 0x0 (0x0) +__longlong 0x8000 & 0xfffe == -0x8000 (0x8000) +__ulonglong 0x8000 & 0xfffe == -0x8000 (0x8000) +int 0x8000 | 0xfffe == -0x2 (0xfffe) +__uint 0x8000 | 0xfffe == -0x2 (0xfffe) +char 0x0 | 0xfffe == -0x2 (0xfffe) +__uchar 0x0 | 0xfe == 0xfe (0xfe) +__longlong 0x8000 | 0xfffe == -0x2 (0xfffe) +__ulonglong 0x8000 | 0xfffe == -0x2 (0xfffe) +int 0x8000 << 0x4 == 0x0 (0x0) +__uint 0x8000 << 0x4 == 0x0 (0x0) +char 0x0 << 0x4 == 0x0 (0x0) +__uchar 0x0 << 0x4 == 0x0 (0x0) +__longlong 0x8000 << 0x4 == 0x0 (0x0) +__ulonglong 0x8000 << 0x4 == 0x0 (0x0) +int 0x8000 >> 0x4 == -0x800 (0xf800) +__uint 0x8000 >> 0x4 == 0x800 (0x800) +char 0x0 >> 0x4 == 0x0 (0x0) +__uchar 0x0 >> 0x4 == 0x0 (0x0) +__longlong 0x8000 >> 0x4 == -0x800 (0xf800) +__ulonglong 0x8000 >> 0x4 == -0x800 (0xf800) +int 0x8000 + 0xfffe == 0x7ffe (0x7ffe) +__uint 0x8000 + 0xfffe == 0x7ffe (0x7ffe) +char 0x0 + 0xfffe == -0x2 (0xfffe) +__uchar 0x0 + 0xfe == 0xfe (0xfe) +__longlong 0x8000 + 0xfffe == 0x7ffe (0x7ffe) +__ulonglong 0x8000 + 0xfffe == 0x7ffe (0x7ffe) +float 0x8000 + 0xfffe == -0x8000 (0x8000) +int 0x8000 - 0xfffe == -0x7ffe (0x8002) +__uint 0x8000 - 0xfffe == -0x7ffe (0x8002) +char 0x0 - 0xfffe == 0x2 (0x2) +__uchar 0x0 - 0xfe == 0x2 (0x2) +__longlong 0x8000 - 0xfffe == -0x7ffe (0x8002) +__ulonglong 0x8000 - 0xfffe == -0x7ffe (0x8002) +float 0x8000 - 0xfffe == -0x7ffe (0x8002) +int 0x8000 * 0xfffe == 0x0 (0x0) +__uint 0x8000 * 0xfffe == 0x0 (0x0) +char 0x0 * 0xfffe == 0x0 (0x0) +__uchar 0x0 * 0xfe == 0x0 (0x0) +__longlong 0x8000 * 0xfffe == 0x0 (0x0) +__ulonglong 0x8000 * 0xfffe == 0x0 (0x0) +float 0x8000 * 0xfffe == -0x8000 (0x8000) +int 0x8000 < 0xfffe == 0x1 (0x1) +__uint 0x8000 < 0xfffe == 0x1 (0x1) +char 0x0 < 0xfffe == 0x0 (0x0) +__uchar 0x0 < 0xfe == 0x1 (0x1) +__longlong 0x8000 < 0xfffe == 0x1 (0x1) +__ulonglong 0x8000 < 0xfffe == 0x1 (0x1) +float 0x8000 < 0xfffe == 0x1 (0x1) +int 0x8000 > 0xfffe == 0x0 (0x0) +__uint 0x8000 > 0xfffe == 0x0 (0x0) +char 0x0 > 0xfffe == 0x1 (0x1) +__uchar 0x0 > 0xfe == 0x0 (0x0) +__longlong 0x8000 > 0xfffe == 0x0 (0x0) +__ulonglong 0x8000 > 0xfffe == 0x0 (0x0) +float 0x8000 > 0xfffe == 0x0 (0x0) +int 0x8000 <= 0xfffe == 0x1 (0x1) +__uint 0x8000 <= 0xfffe == 0x1 (0x1) +char 0x0 <= 0xfffe == 0x0 (0x0) +__uchar 0x0 <= 0xfe == 0x1 (0x1) +__longlong 0x8000 <= 0xfffe == 0x1 (0x1) +__ulonglong 0x8000 <= 0xfffe == 0x1 (0x1) +float 0x8000 <= 0xfffe == 0x1 (0x1) +int 0x8000 == 0xfffe == 0x0 (0x0) +__uint 0x8000 == 0xfffe == 0x0 (0x0) +char 0x0 == 0xfffe == 0x0 (0x0) +__uchar 0x0 == 0xfe == 0x0 (0x0) +__longlong 0x8000 == 0xfffe == 0x0 (0x0) +__ulonglong 0x8000 == 0xfffe == 0x0 (0x0) +float 0x8000 == 0xfffe == 0x0 (0x0) +int 0x8000 != 0xfffe == 0x1 (0x1) +__uint 0x8000 != 0xfffe == 0x1 (0x1) +char 0x0 != 0xfffe == 0x1 (0x1) +__uchar 0x0 != 0xfe == 0x1 (0x1) +__longlong 0x8000 != 0xfffe == 0x1 (0x1) +__ulonglong 0x8000 != 0xfffe == 0x1 (0x1) +float 0x8000 != 0xfffe == 0x1 (0x1) +int 0x8000 >= 0xfffe == 0x0 (0x0) +__uint 0x8000 >= 0xfffe == 0x0 (0x0) +char 0x0 >= 0xfffe == 0x1 (0x1) +__uchar 0x0 >= 0xfe == 0x0 (0x0) +__longlong 0x8000 >= 0xfffe == 0x0 (0x0) +__ulonglong 0x8000 >= 0xfffe == 0x0 (0x0) +float 0x8000 >= 0xfffe == 0x0 (0x0) +int 0x8000 / 0xfffe == 0x4000 (0x4000) +__uint 0x8000 / 0xfffe == 0x0 (0x0) +char 0x0 / 0xfffe == 0x0 (0x0) +__uchar 0x0 / 0xfe == 0x0 (0x0) +__longlong 0x8000 / 0xfffe == 0x4000 (0x4000) +__ulonglong 0x8000 / 0xfffe == 0x0 (0x0) +float 0x8000 / 0xfffe == 0x4000 (0x4000) +int 0x8000 % 0xfffe == 0x0 (0x0) +__uint 0x8000 % 0xfffe == -0x8000 (0x8000) +char 0x0 % 0xfffe == 0x0 (0x0) +__uchar 0x0 % 0xfe == 0x0 (0x0) +__longlong 0x8000 % 0xfffe == 0x0 (0x0) +__ulonglong 0x8000 % 0xfffe == -0x8000 (0x8000) +0x8000 * 0x4 == 0x0 +0x8000 / 0x4 == -0x2000 +0x8000 % 0x4 == 0x0 +int 0x8000 ^ 0x4 == -0x7ffc (0x8004) +__uint 0x8000 ^ 0x4 == -0x7ffc (0x8004) +char 0x0 ^ 0x4 == 0x4 (0x4) +__uchar 0x0 ^ 0x4 == 0x4 (0x4) +__longlong 0x8000 ^ 0x4 == -0x7ffc (0x8004) +__ulonglong 0x8000 ^ 0x4 == -0x7ffc (0x8004) +int 0x8000 && 0x4 == 0x1 (0x1) +__uint 0x8000 && 0x4 == 0x1 (0x1) +char 0x0 && 0x4 == 0x0 (0x0) +__uchar 0x0 && 0x4 == 0x0 (0x0) +__longlong 0x8000 && 0x4 == 0x1 (0x1) +__ulonglong 0x8000 && 0x4 == 0x1 (0x1) +int 0x8000 || 0x4 == 0x1 (0x1) +__uint 0x8000 || 0x4 == 0x1 (0x1) +char 0x0 || 0x4 == 0x1 (0x1) +__uchar 0x0 || 0x4 == 0x1 (0x1) +__longlong 0x8000 || 0x4 == 0x1 (0x1) +__ulonglong 0x8000 || 0x4 == 0x1 (0x1) +int 0x8000 & 0x4 == 0x0 (0x0) +__uint 0x8000 & 0x4 == 0x0 (0x0) +char 0x0 & 0x4 == 0x0 (0x0) +__uchar 0x0 & 0x4 == 0x0 (0x0) +__longlong 0x8000 & 0x4 == 0x0 (0x0) +__ulonglong 0x8000 & 0x4 == 0x0 (0x0) +int 0x8000 | 0x4 == -0x7ffc (0x8004) +__uint 0x8000 | 0x4 == -0x7ffc (0x8004) +char 0x0 | 0x4 == 0x4 (0x4) +__uchar 0x0 | 0x4 == 0x4 (0x4) +__longlong 0x8000 | 0x4 == -0x7ffc (0x8004) +__ulonglong 0x8000 | 0x4 == -0x7ffc (0x8004) +int 0x8000 << 0x5 == 0x0 (0x0) +__uint 0x8000 << 0x5 == 0x0 (0x0) +char 0x0 << 0x5 == 0x0 (0x0) +__uchar 0x0 << 0x5 == 0x0 (0x0) +__longlong 0x8000 << 0x5 == 0x0 (0x0) +__ulonglong 0x8000 << 0x5 == 0x0 (0x0) +int 0x8000 >> 0x5 == -0x400 (0xfc00) +__uint 0x8000 >> 0x5 == 0x400 (0x400) +char 0x0 >> 0x5 == 0x0 (0x0) +__uchar 0x0 >> 0x5 == 0x0 (0x0) +__longlong 0x8000 >> 0x5 == -0x400 (0xfc00) +__ulonglong 0x8000 >> 0x5 == -0x400 (0xfc00) +int 0x8000 + 0x4 == -0x7ffc (0x8004) +__uint 0x8000 + 0x4 == -0x7ffc (0x8004) +char 0x0 + 0x4 == 0x4 (0x4) +__uchar 0x0 + 0x4 == 0x4 (0x4) +__longlong 0x8000 + 0x4 == -0x7ffc (0x8004) +__ulonglong 0x8000 + 0x4 == -0x7ffc (0x8004) +float 0x8000 + 0x4 == -0x7ffc (0x8004) +int 0x8000 - 0x4 == 0x7ffc (0x7ffc) +__uint 0x8000 - 0x4 == 0x7ffc (0x7ffc) +char 0x0 - 0x4 == -0x4 (0xfffc) +__uchar 0x0 - 0x4 == 0xfc (0xfc) +__longlong 0x8000 - 0x4 == 0x7ffc (0x7ffc) +__ulonglong 0x8000 - 0x4 == 0x7ffc (0x7ffc) +float 0x8000 - 0x4 == -0x8000 (0x8000) +int 0x8000 * 0x4 == 0x0 (0x0) +__uint 0x8000 * 0x4 == 0x0 (0x0) +char 0x0 * 0x4 == 0x0 (0x0) +__uchar 0x0 * 0x4 == 0x0 (0x0) +__longlong 0x8000 * 0x4 == 0x0 (0x0) +__ulonglong 0x8000 * 0x4 == 0x0 (0x0) +float 0x8000 * 0x4 == -0x8000 (0x8000) +int 0x8000 < 0x4 == 0x1 (0x1) +__uint 0x8000 < 0x4 == 0x0 (0x0) +char 0x0 < 0x4 == 0x1 (0x1) +__uchar 0x0 < 0x4 == 0x1 (0x1) +__longlong 0x8000 < 0x4 == 0x1 (0x1) +__ulonglong 0x8000 < 0x4 == 0x0 (0x0) +float 0x8000 < 0x4 == 0x1 (0x1) +int 0x8000 > 0x4 == 0x0 (0x0) +__uint 0x8000 > 0x4 == 0x1 (0x1) +char 0x0 > 0x4 == 0x0 (0x0) +__uchar 0x0 > 0x4 == 0x0 (0x0) +__longlong 0x8000 > 0x4 == 0x0 (0x0) +__ulonglong 0x8000 > 0x4 == 0x1 (0x1) +float 0x8000 > 0x4 == 0x0 (0x0) +int 0x8000 <= 0x4 == 0x1 (0x1) +__uint 0x8000 <= 0x4 == 0x0 (0x0) +char 0x0 <= 0x4 == 0x1 (0x1) +__uchar 0x0 <= 0x4 == 0x1 (0x1) +__longlong 0x8000 <= 0x4 == 0x1 (0x1) +__ulonglong 0x8000 <= 0x4 == 0x0 (0x0) +float 0x8000 <= 0x4 == 0x1 (0x1) +int 0x8000 == 0x4 == 0x0 (0x0) +__uint 0x8000 == 0x4 == 0x0 (0x0) +char 0x0 == 0x4 == 0x0 (0x0) +__uchar 0x0 == 0x4 == 0x0 (0x0) +__longlong 0x8000 == 0x4 == 0x0 (0x0) +__ulonglong 0x8000 == 0x4 == 0x0 (0x0) +float 0x8000 == 0x4 == 0x0 (0x0) +int 0x8000 != 0x4 == 0x1 (0x1) +__uint 0x8000 != 0x4 == 0x1 (0x1) +char 0x0 != 0x4 == 0x1 (0x1) +__uchar 0x0 != 0x4 == 0x1 (0x1) +__longlong 0x8000 != 0x4 == 0x1 (0x1) +__ulonglong 0x8000 != 0x4 == 0x1 (0x1) +float 0x8000 != 0x4 == 0x1 (0x1) +int 0x8000 >= 0x4 == 0x0 (0x0) +__uint 0x8000 >= 0x4 == 0x1 (0x1) +char 0x0 >= 0x4 == 0x0 (0x0) +__uchar 0x0 >= 0x4 == 0x0 (0x0) +__longlong 0x8000 >= 0x4 == 0x0 (0x0) +__ulonglong 0x8000 >= 0x4 == 0x1 (0x1) +float 0x8000 >= 0x4 == 0x0 (0x0) +int 0x8000 / 0x4 == -0x2000 (0xe000) +__uint 0x8000 / 0x4 == 0x2000 (0x2000) +char 0x0 / 0x4 == 0x0 (0x0) +__uchar 0x0 / 0x4 == 0x0 (0x0) +__longlong 0x8000 / 0x4 == -0x2000 (0xe000) +__ulonglong 0x8000 / 0x4 == -0x2000 (0xe000) +float 0x8000 / 0x4 == -0x2000 (0xe000) +int 0x8000 % 0x4 == 0x0 (0x0) +__uint 0x8000 % 0x4 == 0x0 (0x0) +char 0x0 % 0x4 == 0x0 (0x0) +__uchar 0x0 % 0x4 == 0x0 (0x0) +__longlong 0x8000 % 0x4 == 0x0 (0x0) +__ulonglong 0x8000 % 0x4 == 0x0 (0x0) +0x8000 * 0xfffc == 0x0 +0x8000 / 0xfffc == 0x2000 +0x8000 % 0xfffc == 0x0 +int 0x8000 ^ 0xfffc == 0x7ffc (0x7ffc) +__uint 0x8000 ^ 0xfffc == 0x7ffc (0x7ffc) +char 0x0 ^ 0xfffc == -0x4 (0xfffc) +__uchar 0x0 ^ 0xfc == 0xfc (0xfc) +__longlong 0x8000 ^ 0xfffc == 0x7ffc (0x7ffc) +__ulonglong 0x8000 ^ 0xfffc == 0x7ffc (0x7ffc) +int 0x8000 && 0xfffc == 0x1 (0x1) +__uint 0x8000 && 0xfffc == 0x1 (0x1) +char 0x0 && 0xfffc == 0x0 (0x0) +__uchar 0x0 && 0xfc == 0x0 (0x0) +__longlong 0x8000 && 0xfffc == 0x1 (0x1) +__ulonglong 0x8000 && 0xfffc == 0x1 (0x1) +int 0x8000 || 0xfffc == 0x1 (0x1) +__uint 0x8000 || 0xfffc == 0x1 (0x1) +char 0x0 || 0xfffc == 0x1 (0x1) +__uchar 0x0 || 0xfc == 0x1 (0x1) +__longlong 0x8000 || 0xfffc == 0x1 (0x1) +__ulonglong 0x8000 || 0xfffc == 0x1 (0x1) +int 0x8000 & 0xfffc == -0x8000 (0x8000) +__uint 0x8000 & 0xfffc == -0x8000 (0x8000) +char 0x0 & 0xfffc == 0x0 (0x0) +__uchar 0x0 & 0xfc == 0x0 (0x0) +__longlong 0x8000 & 0xfffc == -0x8000 (0x8000) +__ulonglong 0x8000 & 0xfffc == -0x8000 (0x8000) +int 0x8000 | 0xfffc == -0x4 (0xfffc) +__uint 0x8000 | 0xfffc == -0x4 (0xfffc) +char 0x0 | 0xfffc == -0x4 (0xfffc) +__uchar 0x0 | 0xfc == 0xfc (0xfc) +__longlong 0x8000 | 0xfffc == -0x4 (0xfffc) +__ulonglong 0x8000 | 0xfffc == -0x4 (0xfffc) +int 0x8000 << 0x6 == 0x0 (0x0) +__uint 0x8000 << 0x6 == 0x0 (0x0) +char 0x0 << 0x6 == 0x0 (0x0) +__uchar 0x0 << 0x6 == 0x0 (0x0) +__longlong 0x8000 << 0x6 == 0x0 (0x0) +__ulonglong 0x8000 << 0x6 == 0x0 (0x0) +int 0x8000 >> 0x6 == -0x200 (0xfe00) +__uint 0x8000 >> 0x6 == 0x200 (0x200) +char 0x0 >> 0x6 == 0x0 (0x0) +__uchar 0x0 >> 0x6 == 0x0 (0x0) +__longlong 0x8000 >> 0x6 == -0x200 (0xfe00) +__ulonglong 0x8000 >> 0x6 == -0x200 (0xfe00) +int 0x8000 + 0xfffc == 0x7ffc (0x7ffc) +__uint 0x8000 + 0xfffc == 0x7ffc (0x7ffc) +char 0x0 + 0xfffc == -0x4 (0xfffc) +__uchar 0x0 + 0xfc == 0xfc (0xfc) +__longlong 0x8000 + 0xfffc == 0x7ffc (0x7ffc) +__ulonglong 0x8000 + 0xfffc == 0x7ffc (0x7ffc) +float 0x8000 + 0xfffc == -0x8000 (0x8000) +int 0x8000 - 0xfffc == -0x7ffc (0x8004) +__uint 0x8000 - 0xfffc == -0x7ffc (0x8004) +char 0x0 - 0xfffc == 0x4 (0x4) +__uchar 0x0 - 0xfc == 0x4 (0x4) +__longlong 0x8000 - 0xfffc == -0x7ffc (0x8004) +__ulonglong 0x8000 - 0xfffc == -0x7ffc (0x8004) +float 0x8000 - 0xfffc == -0x7ffc (0x8004) +int 0x8000 * 0xfffc == 0x0 (0x0) +__uint 0x8000 * 0xfffc == 0x0 (0x0) +char 0x0 * 0xfffc == 0x0 (0x0) +__uchar 0x0 * 0xfc == 0x0 (0x0) +__longlong 0x8000 * 0xfffc == 0x0 (0x0) +__ulonglong 0x8000 * 0xfffc == 0x0 (0x0) +float 0x8000 * 0xfffc == -0x8000 (0x8000) +int 0x8000 < 0xfffc == 0x1 (0x1) +__uint 0x8000 < 0xfffc == 0x1 (0x1) +char 0x0 < 0xfffc == 0x0 (0x0) +__uchar 0x0 < 0xfc == 0x1 (0x1) +__longlong 0x8000 < 0xfffc == 0x1 (0x1) +__ulonglong 0x8000 < 0xfffc == 0x1 (0x1) +float 0x8000 < 0xfffc == 0x1 (0x1) +int 0x8000 > 0xfffc == 0x0 (0x0) +__uint 0x8000 > 0xfffc == 0x0 (0x0) +char 0x0 > 0xfffc == 0x1 (0x1) +__uchar 0x0 > 0xfc == 0x0 (0x0) +__longlong 0x8000 > 0xfffc == 0x0 (0x0) +__ulonglong 0x8000 > 0xfffc == 0x0 (0x0) +float 0x8000 > 0xfffc == 0x0 (0x0) +int 0x8000 <= 0xfffc == 0x1 (0x1) +__uint 0x8000 <= 0xfffc == 0x1 (0x1) +char 0x0 <= 0xfffc == 0x0 (0x0) +__uchar 0x0 <= 0xfc == 0x1 (0x1) +__longlong 0x8000 <= 0xfffc == 0x1 (0x1) +__ulonglong 0x8000 <= 0xfffc == 0x1 (0x1) +float 0x8000 <= 0xfffc == 0x1 (0x1) +int 0x8000 == 0xfffc == 0x0 (0x0) +__uint 0x8000 == 0xfffc == 0x0 (0x0) +char 0x0 == 0xfffc == 0x0 (0x0) +__uchar 0x0 == 0xfc == 0x0 (0x0) +__longlong 0x8000 == 0xfffc == 0x0 (0x0) +__ulonglong 0x8000 == 0xfffc == 0x0 (0x0) +float 0x8000 == 0xfffc == 0x0 (0x0) +int 0x8000 != 0xfffc == 0x1 (0x1) +__uint 0x8000 != 0xfffc == 0x1 (0x1) +char 0x0 != 0xfffc == 0x1 (0x1) +__uchar 0x0 != 0xfc == 0x1 (0x1) +__longlong 0x8000 != 0xfffc == 0x1 (0x1) +__ulonglong 0x8000 != 0xfffc == 0x1 (0x1) +float 0x8000 != 0xfffc == 0x1 (0x1) +int 0x8000 >= 0xfffc == 0x0 (0x0) +__uint 0x8000 >= 0xfffc == 0x0 (0x0) +char 0x0 >= 0xfffc == 0x1 (0x1) +__uchar 0x0 >= 0xfc == 0x0 (0x0) +__longlong 0x8000 >= 0xfffc == 0x0 (0x0) +__ulonglong 0x8000 >= 0xfffc == 0x0 (0x0) +float 0x8000 >= 0xfffc == 0x0 (0x0) +int 0x8000 / 0xfffc == 0x2000 (0x2000) +__uint 0x8000 / 0xfffc == 0x0 (0x0) +char 0x0 / 0xfffc == 0x0 (0x0) +__uchar 0x0 / 0xfc == 0x0 (0x0) +__longlong 0x8000 / 0xfffc == 0x2000 (0x2000) +__ulonglong 0x8000 / 0xfffc == 0x0 (0x0) +float 0x8000 / 0xfffc == 0x2000 (0x2000) +int 0x8000 % 0xfffc == 0x0 (0x0) +__uint 0x8000 % 0xfffc == -0x8000 (0x8000) +char 0x0 % 0xfffc == 0x0 (0x0) +__uchar 0x0 % 0xfc == 0x0 (0x0) +__longlong 0x8000 % 0xfffc == 0x0 (0x0) +__ulonglong 0x8000 % 0xfffc == -0x8000 (0x8000) +0x8000 * 0xa == 0x0 +0x8000 / 0xa == -0xccc +0x8000 % 0xa == -0x8 +int 0x8000 ^ 0xa == -0x7ff6 (0x800a) +__uint 0x8000 ^ 0xa == -0x7ff6 (0x800a) +char 0x0 ^ 0xa == 0xa (0xa) +__uchar 0x0 ^ 0xa == 0xa (0xa) +__longlong 0x8000 ^ 0xa == -0x7ff6 (0x800a) +__ulonglong 0x8000 ^ 0xa == -0x7ff6 (0x800a) +int 0x8000 && 0xa == 0x1 (0x1) +__uint 0x8000 && 0xa == 0x1 (0x1) +char 0x0 && 0xa == 0x0 (0x0) +__uchar 0x0 && 0xa == 0x0 (0x0) +__longlong 0x8000 && 0xa == 0x1 (0x1) +__ulonglong 0x8000 && 0xa == 0x1 (0x1) +int 0x8000 || 0xa == 0x1 (0x1) +__uint 0x8000 || 0xa == 0x1 (0x1) +char 0x0 || 0xa == 0x1 (0x1) +__uchar 0x0 || 0xa == 0x1 (0x1) +__longlong 0x8000 || 0xa == 0x1 (0x1) +__ulonglong 0x8000 || 0xa == 0x1 (0x1) +int 0x8000 & 0xa == 0x0 (0x0) +__uint 0x8000 & 0xa == 0x0 (0x0) +char 0x0 & 0xa == 0x0 (0x0) +__uchar 0x0 & 0xa == 0x0 (0x0) +__longlong 0x8000 & 0xa == 0x0 (0x0) +__ulonglong 0x8000 & 0xa == 0x0 (0x0) +int 0x8000 | 0xa == -0x7ff6 (0x800a) +__uint 0x8000 | 0xa == -0x7ff6 (0x800a) +char 0x0 | 0xa == 0xa (0xa) +__uchar 0x0 | 0xa == 0xa (0xa) +__longlong 0x8000 | 0xa == -0x7ff6 (0x800a) +__ulonglong 0x8000 | 0xa == -0x7ff6 (0x800a) +int 0x8000 << 0x7 == 0x0 (0x0) +__uint 0x8000 << 0x7 == 0x0 (0x0) +char 0x0 << 0x7 == 0x0 (0x0) +__uchar 0x0 << 0x7 == 0x0 (0x0) +__longlong 0x8000 << 0x7 == 0x0 (0x0) +__ulonglong 0x8000 << 0x7 == 0x0 (0x0) +int 0x8000 >> 0x7 == -0x100 (0xff00) +__uint 0x8000 >> 0x7 == 0x100 (0x100) +char 0x0 >> 0x7 == 0x0 (0x0) +__uchar 0x0 >> 0x7 == 0x0 (0x0) +__longlong 0x8000 >> 0x7 == -0x100 (0xff00) +__ulonglong 0x8000 >> 0x7 == -0x100 (0xff00) +int 0x8000 + 0xa == -0x7ff6 (0x800a) +__uint 0x8000 + 0xa == -0x7ff6 (0x800a) +char 0x0 + 0xa == 0xa (0xa) +__uchar 0x0 + 0xa == 0xa (0xa) +__longlong 0x8000 + 0xa == -0x7ff6 (0x800a) +__ulonglong 0x8000 + 0xa == -0x7ff6 (0x800a) +float 0x8000 + 0xa == -0x7ff6 (0x800a) +int 0x8000 - 0xa == 0x7ff6 (0x7ff6) +__uint 0x8000 - 0xa == 0x7ff6 (0x7ff6) +char 0x0 - 0xa == -0xa (0xfff6) +__uchar 0x0 - 0xa == 0xf6 (0xf6) +__longlong 0x8000 - 0xa == 0x7ff6 (0x7ff6) +__ulonglong 0x8000 - 0xa == 0x7ff6 (0x7ff6) +float 0x8000 - 0xa == -0x8000 (0x8000) +int 0x8000 * 0xa == 0x0 (0x0) +__uint 0x8000 * 0xa == 0x0 (0x0) +char 0x0 * 0xa == 0x0 (0x0) +__uchar 0x0 * 0xa == 0x0 (0x0) +__longlong 0x8000 * 0xa == 0x0 (0x0) +__ulonglong 0x8000 * 0xa == 0x0 (0x0) +float 0x8000 * 0xa == -0x8000 (0x8000) +int 0x8000 < 0xa == 0x1 (0x1) +__uint 0x8000 < 0xa == 0x0 (0x0) +char 0x0 < 0xa == 0x1 (0x1) +__uchar 0x0 < 0xa == 0x1 (0x1) +__longlong 0x8000 < 0xa == 0x1 (0x1) +__ulonglong 0x8000 < 0xa == 0x0 (0x0) +float 0x8000 < 0xa == 0x1 (0x1) +int 0x8000 > 0xa == 0x0 (0x0) +__uint 0x8000 > 0xa == 0x1 (0x1) +char 0x0 > 0xa == 0x0 (0x0) +__uchar 0x0 > 0xa == 0x0 (0x0) +__longlong 0x8000 > 0xa == 0x0 (0x0) +__ulonglong 0x8000 > 0xa == 0x1 (0x1) +float 0x8000 > 0xa == 0x0 (0x0) +int 0x8000 <= 0xa == 0x1 (0x1) +__uint 0x8000 <= 0xa == 0x0 (0x0) +char 0x0 <= 0xa == 0x1 (0x1) +__uchar 0x0 <= 0xa == 0x1 (0x1) +__longlong 0x8000 <= 0xa == 0x1 (0x1) +__ulonglong 0x8000 <= 0xa == 0x0 (0x0) +float 0x8000 <= 0xa == 0x1 (0x1) +int 0x8000 == 0xa == 0x0 (0x0) +__uint 0x8000 == 0xa == 0x0 (0x0) +char 0x0 == 0xa == 0x0 (0x0) +__uchar 0x0 == 0xa == 0x0 (0x0) +__longlong 0x8000 == 0xa == 0x0 (0x0) +__ulonglong 0x8000 == 0xa == 0x0 (0x0) +float 0x8000 == 0xa == 0x0 (0x0) +int 0x8000 != 0xa == 0x1 (0x1) +__uint 0x8000 != 0xa == 0x1 (0x1) +char 0x0 != 0xa == 0x1 (0x1) +__uchar 0x0 != 0xa == 0x1 (0x1) +__longlong 0x8000 != 0xa == 0x1 (0x1) +__ulonglong 0x8000 != 0xa == 0x1 (0x1) +float 0x8000 != 0xa == 0x1 (0x1) +int 0x8000 >= 0xa == 0x0 (0x0) +__uint 0x8000 >= 0xa == 0x1 (0x1) +char 0x0 >= 0xa == 0x0 (0x0) +__uchar 0x0 >= 0xa == 0x0 (0x0) +__longlong 0x8000 >= 0xa == 0x0 (0x0) +__ulonglong 0x8000 >= 0xa == 0x1 (0x1) +float 0x8000 >= 0xa == 0x0 (0x0) +int 0x8000 / 0xa == -0xccc (0xf334) +__uint 0x8000 / 0xa == 0xccc (0xccc) +char 0x0 / 0xa == 0x0 (0x0) +__uchar 0x0 / 0xa == 0x0 (0x0) +__longlong 0x8000 / 0xa == -0xccc (0xf334) +__ulonglong 0x8000 / 0xa == -0x7334 (0x8ccc) +float 0x8000 / 0xa == -0xccc (0xf334) +int 0x8000 % 0xa == -0x8 (0xfff8) +__uint 0x8000 % 0xa == 0x8 (0x8) +char 0x0 % 0xa == 0x0 (0x0) +__uchar 0x0 % 0xa == 0x0 (0x0) +__longlong 0x8000 % 0xa == -0x8 (0xfff8) +__ulonglong 0x8000 % 0xa == 0x8 (0x8) +0x8000 * 0xfff6 == 0x0 +0x8000 / 0xfff6 == 0xccc +0x8000 % 0xfff6 == -0x8 +int 0x8000 ^ 0xfff6 == 0x7ff6 (0x7ff6) +__uint 0x8000 ^ 0xfff6 == 0x7ff6 (0x7ff6) +char 0x0 ^ 0xfff6 == -0xa (0xfff6) +__uchar 0x0 ^ 0xf6 == 0xf6 (0xf6) +__longlong 0x8000 ^ 0xfff6 == 0x7ff6 (0x7ff6) +__ulonglong 0x8000 ^ 0xfff6 == 0x7ff6 (0x7ff6) +int 0x8000 && 0xfff6 == 0x1 (0x1) +__uint 0x8000 && 0xfff6 == 0x1 (0x1) +char 0x0 && 0xfff6 == 0x0 (0x0) +__uchar 0x0 && 0xf6 == 0x0 (0x0) +__longlong 0x8000 && 0xfff6 == 0x1 (0x1) +__ulonglong 0x8000 && 0xfff6 == 0x1 (0x1) +int 0x8000 || 0xfff6 == 0x1 (0x1) +__uint 0x8000 || 0xfff6 == 0x1 (0x1) +char 0x0 || 0xfff6 == 0x1 (0x1) +__uchar 0x0 || 0xf6 == 0x1 (0x1) +__longlong 0x8000 || 0xfff6 == 0x1 (0x1) +__ulonglong 0x8000 || 0xfff6 == 0x1 (0x1) +int 0x8000 & 0xfff6 == -0x8000 (0x8000) +__uint 0x8000 & 0xfff6 == -0x8000 (0x8000) +char 0x0 & 0xfff6 == 0x0 (0x0) +__uchar 0x0 & 0xf6 == 0x0 (0x0) +__longlong 0x8000 & 0xfff6 == -0x8000 (0x8000) +__ulonglong 0x8000 & 0xfff6 == -0x8000 (0x8000) +int 0x8000 | 0xfff6 == -0xa (0xfff6) +__uint 0x8000 | 0xfff6 == -0xa (0xfff6) +char 0x0 | 0xfff6 == -0xa (0xfff6) +__uchar 0x0 | 0xf6 == 0xf6 (0xf6) +__longlong 0x8000 | 0xfff6 == -0xa (0xfff6) +__ulonglong 0x8000 | 0xfff6 == -0xa (0xfff6) +int 0x8000 << 0x8 == 0x0 (0x0) +__uint 0x8000 << 0x8 == 0x0 (0x0) +char 0x0 << 0x8 == 0x0 (0x0) +__uchar 0x0 << 0x8 == 0x0 (0x0) +__longlong 0x8000 << 0x8 == 0x0 (0x0) +__ulonglong 0x8000 << 0x8 == 0x0 (0x0) +int 0x8000 >> 0x8 == -0x80 (0xff80) +__uint 0x8000 >> 0x8 == 0x80 (0x80) +char 0x0 >> 0x8 == 0x0 (0x0) +__uchar 0x0 >> 0x8 == 0x0 (0x0) +__longlong 0x8000 >> 0x8 == -0x80 (0xff80) +__ulonglong 0x8000 >> 0x8 == -0x80 (0xff80) +int 0x8000 + 0xfff6 == 0x7ff6 (0x7ff6) +__uint 0x8000 + 0xfff6 == 0x7ff6 (0x7ff6) +char 0x0 + 0xfff6 == -0xa (0xfff6) +__uchar 0x0 + 0xf6 == 0xf6 (0xf6) +__longlong 0x8000 + 0xfff6 == 0x7ff6 (0x7ff6) +__ulonglong 0x8000 + 0xfff6 == 0x7ff6 (0x7ff6) +float 0x8000 + 0xfff6 == -0x8000 (0x8000) +int 0x8000 - 0xfff6 == -0x7ff6 (0x800a) +__uint 0x8000 - 0xfff6 == -0x7ff6 (0x800a) +char 0x0 - 0xfff6 == 0xa (0xa) +__uchar 0x0 - 0xf6 == 0xa (0xa) +__longlong 0x8000 - 0xfff6 == -0x7ff6 (0x800a) +__ulonglong 0x8000 - 0xfff6 == -0x7ff6 (0x800a) +float 0x8000 - 0xfff6 == -0x7ff6 (0x800a) +int 0x8000 * 0xfff6 == 0x0 (0x0) +__uint 0x8000 * 0xfff6 == 0x0 (0x0) +char 0x0 * 0xfff6 == 0x0 (0x0) +__uchar 0x0 * 0xf6 == 0x0 (0x0) +__longlong 0x8000 * 0xfff6 == 0x0 (0x0) +__ulonglong 0x8000 * 0xfff6 == 0x0 (0x0) +float 0x8000 * 0xfff6 == -0x8000 (0x8000) +int 0x8000 < 0xfff6 == 0x1 (0x1) +__uint 0x8000 < 0xfff6 == 0x1 (0x1) +char 0x0 < 0xfff6 == 0x0 (0x0) +__uchar 0x0 < 0xf6 == 0x1 (0x1) +__longlong 0x8000 < 0xfff6 == 0x1 (0x1) +__ulonglong 0x8000 < 0xfff6 == 0x1 (0x1) +float 0x8000 < 0xfff6 == 0x1 (0x1) +int 0x8000 > 0xfff6 == 0x0 (0x0) +__uint 0x8000 > 0xfff6 == 0x0 (0x0) +char 0x0 > 0xfff6 == 0x1 (0x1) +__uchar 0x0 > 0xf6 == 0x0 (0x0) +__longlong 0x8000 > 0xfff6 == 0x0 (0x0) +__ulonglong 0x8000 > 0xfff6 == 0x0 (0x0) +float 0x8000 > 0xfff6 == 0x0 (0x0) +int 0x8000 <= 0xfff6 == 0x1 (0x1) +__uint 0x8000 <= 0xfff6 == 0x1 (0x1) +char 0x0 <= 0xfff6 == 0x0 (0x0) +__uchar 0x0 <= 0xf6 == 0x1 (0x1) +__longlong 0x8000 <= 0xfff6 == 0x1 (0x1) +__ulonglong 0x8000 <= 0xfff6 == 0x1 (0x1) +float 0x8000 <= 0xfff6 == 0x1 (0x1) +int 0x8000 == 0xfff6 == 0x0 (0x0) +__uint 0x8000 == 0xfff6 == 0x0 (0x0) +char 0x0 == 0xfff6 == 0x0 (0x0) +__uchar 0x0 == 0xf6 == 0x0 (0x0) +__longlong 0x8000 == 0xfff6 == 0x0 (0x0) +__ulonglong 0x8000 == 0xfff6 == 0x0 (0x0) +float 0x8000 == 0xfff6 == 0x0 (0x0) +int 0x8000 != 0xfff6 == 0x1 (0x1) +__uint 0x8000 != 0xfff6 == 0x1 (0x1) +char 0x0 != 0xfff6 == 0x1 (0x1) +__uchar 0x0 != 0xf6 == 0x1 (0x1) +__longlong 0x8000 != 0xfff6 == 0x1 (0x1) +__ulonglong 0x8000 != 0xfff6 == 0x1 (0x1) +float 0x8000 != 0xfff6 == 0x1 (0x1) +int 0x8000 >= 0xfff6 == 0x0 (0x0) +__uint 0x8000 >= 0xfff6 == 0x0 (0x0) +char 0x0 >= 0xfff6 == 0x1 (0x1) +__uchar 0x0 >= 0xf6 == 0x0 (0x0) +__longlong 0x8000 >= 0xfff6 == 0x0 (0x0) +__ulonglong 0x8000 >= 0xfff6 == 0x0 (0x0) +float 0x8000 >= 0xfff6 == 0x0 (0x0) +int 0x8000 / 0xfff6 == 0xccc (0xccc) +__uint 0x8000 / 0xfff6 == 0x0 (0x0) +char 0x0 / 0xfff6 == 0x0 (0x0) +__uchar 0x0 / 0xf6 == 0x0 (0x0) +__longlong 0x8000 / 0xfff6 == 0xccc (0xccc) +__ulonglong 0x8000 / 0xfff6 == 0x0 (0x0) +float 0x8000 / 0xfff6 == 0xccc (0xccc) +int 0x8000 % 0xfff6 == -0x8 (0xfff8) +__uint 0x8000 % 0xfff6 == -0x8000 (0x8000) +char 0x0 % 0xfff6 == 0x0 (0x0) +__uchar 0x0 % 0xf6 == 0x0 (0x0) +__longlong 0x8000 % 0xfff6 == -0x8 (0xfff8) +__ulonglong 0x8000 % 0xfff6 == -0x8000 (0x8000) +0x8000 * 0x5 == -0x8000 +0x8000 / 0x5 == -0x1999 +0x8000 % 0x5 == -0x3 +int 0x8000 ^ 0x5 == -0x7ffb (0x8005) +__uint 0x8000 ^ 0x5 == -0x7ffb (0x8005) +char 0x0 ^ 0x5 == 0x5 (0x5) +__uchar 0x0 ^ 0x5 == 0x5 (0x5) +__longlong 0x8000 ^ 0x5 == -0x7ffb (0x8005) +__ulonglong 0x8000 ^ 0x5 == -0x7ffb (0x8005) +int 0x8000 && 0x5 == 0x1 (0x1) +__uint 0x8000 && 0x5 == 0x1 (0x1) +char 0x0 && 0x5 == 0x0 (0x0) +__uchar 0x0 && 0x5 == 0x0 (0x0) +__longlong 0x8000 && 0x5 == 0x1 (0x1) +__ulonglong 0x8000 && 0x5 == 0x1 (0x1) +int 0x8000 || 0x5 == 0x1 (0x1) +__uint 0x8000 || 0x5 == 0x1 (0x1) +char 0x0 || 0x5 == 0x1 (0x1) +__uchar 0x0 || 0x5 == 0x1 (0x1) +__longlong 0x8000 || 0x5 == 0x1 (0x1) +__ulonglong 0x8000 || 0x5 == 0x1 (0x1) +int 0x8000 & 0x5 == 0x0 (0x0) +__uint 0x8000 & 0x5 == 0x0 (0x0) +char 0x0 & 0x5 == 0x0 (0x0) +__uchar 0x0 & 0x5 == 0x0 (0x0) +__longlong 0x8000 & 0x5 == 0x0 (0x0) +__ulonglong 0x8000 & 0x5 == 0x0 (0x0) +int 0x8000 | 0x5 == -0x7ffb (0x8005) +__uint 0x8000 | 0x5 == -0x7ffb (0x8005) +char 0x0 | 0x5 == 0x5 (0x5) +__uchar 0x0 | 0x5 == 0x5 (0x5) +__longlong 0x8000 | 0x5 == -0x7ffb (0x8005) +__ulonglong 0x8000 | 0x5 == -0x7ffb (0x8005) +int 0x8000 << 0x9 == 0x0 (0x0) +__uint 0x8000 << 0x9 == 0x0 (0x0) +char 0x0 << 0x9 == 0x0 (0x0) +__uchar 0x0 << 0x9 == 0x0 (0x0) +__longlong 0x8000 << 0x9 == 0x0 (0x0) +__ulonglong 0x8000 << 0x9 == 0x0 (0x0) +int 0x8000 >> 0x9 == -0x40 (0xffc0) +__uint 0x8000 >> 0x9 == 0x40 (0x40) +char 0x0 >> 0x9 == 0x0 (0x0) +__uchar 0x0 >> 0x9 == 0x0 (0x0) +__longlong 0x8000 >> 0x9 == -0x40 (0xffc0) +__ulonglong 0x8000 >> 0x9 == -0x40 (0xffc0) +int 0x8000 + 0x5 == -0x7ffb (0x8005) +__uint 0x8000 + 0x5 == -0x7ffb (0x8005) +char 0x0 + 0x5 == 0x5 (0x5) +__uchar 0x0 + 0x5 == 0x5 (0x5) +__longlong 0x8000 + 0x5 == -0x7ffb (0x8005) +__ulonglong 0x8000 + 0x5 == -0x7ffb (0x8005) +float 0x8000 + 0x5 == -0x7ffb (0x8005) +int 0x8000 - 0x5 == 0x7ffb (0x7ffb) +__uint 0x8000 - 0x5 == 0x7ffb (0x7ffb) +char 0x0 - 0x5 == -0x5 (0xfffb) +__uchar 0x0 - 0x5 == 0xfb (0xfb) +__longlong 0x8000 - 0x5 == 0x7ffb (0x7ffb) +__ulonglong 0x8000 - 0x5 == 0x7ffb (0x7ffb) +float 0x8000 - 0x5 == -0x8000 (0x8000) +int 0x8000 * 0x5 == -0x8000 (0x8000) +__uint 0x8000 * 0x5 == -0x8000 (0x8000) +char 0x0 * 0x5 == 0x0 (0x0) +__uchar 0x0 * 0x5 == 0x0 (0x0) +__longlong 0x8000 * 0x5 == -0x8000 (0x8000) +__ulonglong 0x8000 * 0x5 == -0x8000 (0x8000) +float 0x8000 * 0x5 == -0x8000 (0x8000) +int 0x8000 < 0x5 == 0x1 (0x1) +__uint 0x8000 < 0x5 == 0x0 (0x0) +char 0x0 < 0x5 == 0x1 (0x1) +__uchar 0x0 < 0x5 == 0x1 (0x1) +__longlong 0x8000 < 0x5 == 0x1 (0x1) +__ulonglong 0x8000 < 0x5 == 0x0 (0x0) +float 0x8000 < 0x5 == 0x1 (0x1) +int 0x8000 > 0x5 == 0x0 (0x0) +__uint 0x8000 > 0x5 == 0x1 (0x1) +char 0x0 > 0x5 == 0x0 (0x0) +__uchar 0x0 > 0x5 == 0x0 (0x0) +__longlong 0x8000 > 0x5 == 0x0 (0x0) +__ulonglong 0x8000 > 0x5 == 0x1 (0x1) +float 0x8000 > 0x5 == 0x0 (0x0) +int 0x8000 <= 0x5 == 0x1 (0x1) +__uint 0x8000 <= 0x5 == 0x0 (0x0) +char 0x0 <= 0x5 == 0x1 (0x1) +__uchar 0x0 <= 0x5 == 0x1 (0x1) +__longlong 0x8000 <= 0x5 == 0x1 (0x1) +__ulonglong 0x8000 <= 0x5 == 0x0 (0x0) +float 0x8000 <= 0x5 == 0x1 (0x1) +int 0x8000 == 0x5 == 0x0 (0x0) +__uint 0x8000 == 0x5 == 0x0 (0x0) +char 0x0 == 0x5 == 0x0 (0x0) +__uchar 0x0 == 0x5 == 0x0 (0x0) +__longlong 0x8000 == 0x5 == 0x0 (0x0) +__ulonglong 0x8000 == 0x5 == 0x0 (0x0) +float 0x8000 == 0x5 == 0x0 (0x0) +int 0x8000 != 0x5 == 0x1 (0x1) +__uint 0x8000 != 0x5 == 0x1 (0x1) +char 0x0 != 0x5 == 0x1 (0x1) +__uchar 0x0 != 0x5 == 0x1 (0x1) +__longlong 0x8000 != 0x5 == 0x1 (0x1) +__ulonglong 0x8000 != 0x5 == 0x1 (0x1) +float 0x8000 != 0x5 == 0x1 (0x1) +int 0x8000 >= 0x5 == 0x0 (0x0) +__uint 0x8000 >= 0x5 == 0x1 (0x1) +char 0x0 >= 0x5 == 0x0 (0x0) +__uchar 0x0 >= 0x5 == 0x0 (0x0) +__longlong 0x8000 >= 0x5 == 0x0 (0x0) +__ulonglong 0x8000 >= 0x5 == 0x1 (0x1) +float 0x8000 >= 0x5 == 0x0 (0x0) +int 0x8000 / 0x5 == -0x1999 (0xe667) +__uint 0x8000 / 0x5 == 0x1999 (0x1999) +char 0x0 / 0x5 == 0x0 (0x0) +__uchar 0x0 / 0x5 == 0x0 (0x0) +__longlong 0x8000 / 0x5 == -0x1999 (0xe667) +__ulonglong 0x8000 / 0x5 == 0x1999 (0x1999) +float 0x8000 / 0x5 == -0x1999 (0xe667) +int 0x8000 % 0x5 == -0x3 (0xfffd) +__uint 0x8000 % 0x5 == 0x3 (0x3) +char 0x0 % 0x5 == 0x0 (0x0) +__uchar 0x0 % 0x5 == 0x0 (0x0) +__longlong 0x8000 % 0x5 == -0x3 (0xfffd) +__ulonglong 0x8000 % 0x5 == 0x3 (0x3) +0x8000 * 0x7 == -0x8000 +0x8000 / 0x7 == -0x1249 +0x8000 % 0x7 == -0x1 +int 0x8000 ^ 0x7 == -0x7ff9 (0x8007) +__uint 0x8000 ^ 0x7 == -0x7ff9 (0x8007) +char 0x0 ^ 0x7 == 0x7 (0x7) +__uchar 0x0 ^ 0x7 == 0x7 (0x7) +__longlong 0x8000 ^ 0x7 == -0x7ff9 (0x8007) +__ulonglong 0x8000 ^ 0x7 == -0x7ff9 (0x8007) +int 0x8000 && 0x7 == 0x1 (0x1) +__uint 0x8000 && 0x7 == 0x1 (0x1) +char 0x0 && 0x7 == 0x0 (0x0) +__uchar 0x0 && 0x7 == 0x0 (0x0) +__longlong 0x8000 && 0x7 == 0x1 (0x1) +__ulonglong 0x8000 && 0x7 == 0x1 (0x1) +int 0x8000 || 0x7 == 0x1 (0x1) +__uint 0x8000 || 0x7 == 0x1 (0x1) +char 0x0 || 0x7 == 0x1 (0x1) +__uchar 0x0 || 0x7 == 0x1 (0x1) +__longlong 0x8000 || 0x7 == 0x1 (0x1) +__ulonglong 0x8000 || 0x7 == 0x1 (0x1) +int 0x8000 & 0x7 == 0x0 (0x0) +__uint 0x8000 & 0x7 == 0x0 (0x0) +char 0x0 & 0x7 == 0x0 (0x0) +__uchar 0x0 & 0x7 == 0x0 (0x0) +__longlong 0x8000 & 0x7 == 0x0 (0x0) +__ulonglong 0x8000 & 0x7 == 0x0 (0x0) +int 0x8000 | 0x7 == -0x7ff9 (0x8007) +__uint 0x8000 | 0x7 == -0x7ff9 (0x8007) +char 0x0 | 0x7 == 0x7 (0x7) +__uchar 0x0 | 0x7 == 0x7 (0x7) +__longlong 0x8000 | 0x7 == -0x7ff9 (0x8007) +__ulonglong 0x8000 | 0x7 == -0x7ff9 (0x8007) +int 0x8000 << 0xa == 0x0 (0x0) +__uint 0x8000 << 0xa == 0x0 (0x0) +char 0x0 << 0xa == 0x0 (0x0) +__uchar 0x0 << 0xa == 0x0 (0x0) +__longlong 0x8000 << 0xa == 0x0 (0x0) +__ulonglong 0x8000 << 0xa == 0x0 (0x0) +int 0x8000 >> 0xa == -0x20 (0xffe0) +__uint 0x8000 >> 0xa == 0x20 (0x20) +char 0x0 >> 0xa == 0x0 (0x0) +__uchar 0x0 >> 0xa == 0x0 (0x0) +__longlong 0x8000 >> 0xa == -0x20 (0xffe0) +__ulonglong 0x8000 >> 0xa == -0x20 (0xffe0) +int 0x8000 + 0x7 == -0x7ff9 (0x8007) +__uint 0x8000 + 0x7 == -0x7ff9 (0x8007) +char 0x0 + 0x7 == 0x7 (0x7) +__uchar 0x0 + 0x7 == 0x7 (0x7) +__longlong 0x8000 + 0x7 == -0x7ff9 (0x8007) +__ulonglong 0x8000 + 0x7 == -0x7ff9 (0x8007) +float 0x8000 + 0x7 == -0x7ff9 (0x8007) +int 0x8000 - 0x7 == 0x7ff9 (0x7ff9) +__uint 0x8000 - 0x7 == 0x7ff9 (0x7ff9) +char 0x0 - 0x7 == -0x7 (0xfff9) +__uchar 0x0 - 0x7 == 0xf9 (0xf9) +__longlong 0x8000 - 0x7 == 0x7ff9 (0x7ff9) +__ulonglong 0x8000 - 0x7 == 0x7ff9 (0x7ff9) +float 0x8000 - 0x7 == -0x8000 (0x8000) +int 0x8000 * 0x7 == -0x8000 (0x8000) +__uint 0x8000 * 0x7 == -0x8000 (0x8000) +char 0x0 * 0x7 == 0x0 (0x0) +__uchar 0x0 * 0x7 == 0x0 (0x0) +__longlong 0x8000 * 0x7 == -0x8000 (0x8000) +__ulonglong 0x8000 * 0x7 == -0x8000 (0x8000) +float 0x8000 * 0x7 == -0x8000 (0x8000) +int 0x8000 < 0x7 == 0x1 (0x1) +__uint 0x8000 < 0x7 == 0x0 (0x0) +char 0x0 < 0x7 == 0x1 (0x1) +__uchar 0x0 < 0x7 == 0x1 (0x1) +__longlong 0x8000 < 0x7 == 0x1 (0x1) +__ulonglong 0x8000 < 0x7 == 0x0 (0x0) +float 0x8000 < 0x7 == 0x1 (0x1) +int 0x8000 > 0x7 == 0x0 (0x0) +__uint 0x8000 > 0x7 == 0x1 (0x1) +char 0x0 > 0x7 == 0x0 (0x0) +__uchar 0x0 > 0x7 == 0x0 (0x0) +__longlong 0x8000 > 0x7 == 0x0 (0x0) +__ulonglong 0x8000 > 0x7 == 0x1 (0x1) +float 0x8000 > 0x7 == 0x0 (0x0) +int 0x8000 <= 0x7 == 0x1 (0x1) +__uint 0x8000 <= 0x7 == 0x0 (0x0) +char 0x0 <= 0x7 == 0x1 (0x1) +__uchar 0x0 <= 0x7 == 0x1 (0x1) +__longlong 0x8000 <= 0x7 == 0x1 (0x1) +__ulonglong 0x8000 <= 0x7 == 0x0 (0x0) +float 0x8000 <= 0x7 == 0x1 (0x1) +int 0x8000 == 0x7 == 0x0 (0x0) +__uint 0x8000 == 0x7 == 0x0 (0x0) +char 0x0 == 0x7 == 0x0 (0x0) +__uchar 0x0 == 0x7 == 0x0 (0x0) +__longlong 0x8000 == 0x7 == 0x0 (0x0) +__ulonglong 0x8000 == 0x7 == 0x0 (0x0) +float 0x8000 == 0x7 == 0x0 (0x0) +int 0x8000 != 0x7 == 0x1 (0x1) +__uint 0x8000 != 0x7 == 0x1 (0x1) +char 0x0 != 0x7 == 0x1 (0x1) +__uchar 0x0 != 0x7 == 0x1 (0x1) +__longlong 0x8000 != 0x7 == 0x1 (0x1) +__ulonglong 0x8000 != 0x7 == 0x1 (0x1) +float 0x8000 != 0x7 == 0x1 (0x1) +int 0x8000 >= 0x7 == 0x0 (0x0) +__uint 0x8000 >= 0x7 == 0x1 (0x1) +char 0x0 >= 0x7 == 0x0 (0x0) +__uchar 0x0 >= 0x7 == 0x0 (0x0) +__longlong 0x8000 >= 0x7 == 0x0 (0x0) +__ulonglong 0x8000 >= 0x7 == 0x1 (0x1) +float 0x8000 >= 0x7 == 0x0 (0x0) +int 0x8000 / 0x7 == -0x1249 (0xedb7) +__uint 0x8000 / 0x7 == 0x1249 (0x1249) +char 0x0 / 0x7 == 0x0 (0x0) +__uchar 0x0 / 0x7 == 0x0 (0x0) +__longlong 0x8000 / 0x7 == -0x1249 (0xedb7) +__ulonglong 0x8000 / 0x7 == 0x36db (0x36db) +float 0x8000 / 0x7 == -0x1249 (0xedb7) +int 0x8000 % 0x7 == -0x1 (0xffff) +__uint 0x8000 % 0x7 == 0x1 (0x1) +char 0x0 % 0x7 == 0x0 (0x0) +__uchar 0x0 % 0x7 == 0x0 (0x0) +__longlong 0x8000 % 0x7 == -0x1 (0xffff) +__ulonglong 0x8000 % 0x7 == 0x3 (0x3) +0x8000 * 0x2a == 0x0 +0x8000 / 0x2a == -0x30c +0x8000 % 0x2a == -0x8 +int 0x8000 ^ 0x2a == -0x7fd6 (0x802a) +__uint 0x8000 ^ 0x2a == -0x7fd6 (0x802a) +char 0x0 ^ 0x2a == 0x2a (0x2a) +__uchar 0x0 ^ 0x2a == 0x2a (0x2a) +__longlong 0x8000 ^ 0x2a == -0x7fd6 (0x802a) +__ulonglong 0x8000 ^ 0x2a == -0x7fd6 (0x802a) +int 0x8000 && 0x2a == 0x1 (0x1) +__uint 0x8000 && 0x2a == 0x1 (0x1) +char 0x0 && 0x2a == 0x0 (0x0) +__uchar 0x0 && 0x2a == 0x0 (0x0) +__longlong 0x8000 && 0x2a == 0x1 (0x1) +__ulonglong 0x8000 && 0x2a == 0x1 (0x1) +int 0x8000 || 0x2a == 0x1 (0x1) +__uint 0x8000 || 0x2a == 0x1 (0x1) +char 0x0 || 0x2a == 0x1 (0x1) +__uchar 0x0 || 0x2a == 0x1 (0x1) +__longlong 0x8000 || 0x2a == 0x1 (0x1) +__ulonglong 0x8000 || 0x2a == 0x1 (0x1) +int 0x8000 & 0x2a == 0x0 (0x0) +__uint 0x8000 & 0x2a == 0x0 (0x0) +char 0x0 & 0x2a == 0x0 (0x0) +__uchar 0x0 & 0x2a == 0x0 (0x0) +__longlong 0x8000 & 0x2a == 0x0 (0x0) +__ulonglong 0x8000 & 0x2a == 0x0 (0x0) +int 0x8000 | 0x2a == -0x7fd6 (0x802a) +__uint 0x8000 | 0x2a == -0x7fd6 (0x802a) +char 0x0 | 0x2a == 0x2a (0x2a) +__uchar 0x0 | 0x2a == 0x2a (0x2a) +__longlong 0x8000 | 0x2a == -0x7fd6 (0x802a) +__ulonglong 0x8000 | 0x2a == -0x7fd6 (0x802a) +int 0x8000 << 0xc == 0x0 (0x0) +__uint 0x8000 << 0xc == 0x0 (0x0) +char 0x0 << 0xc == 0x0 (0x0) +__uchar 0x0 << 0xc == 0x0 (0x0) +__longlong 0x8000 << 0xc == 0x0 (0x0) +__ulonglong 0x8000 << 0xc == 0x0 (0x0) +int 0x8000 >> 0xc == -0x8 (0xfff8) +__uint 0x8000 >> 0xc == 0x8 (0x8) +char 0x0 >> 0xc == 0x0 (0x0) +__uchar 0x0 >> 0xc == 0x0 (0x0) +__longlong 0x8000 >> 0xc == -0x8 (0xfff8) +__ulonglong 0x8000 >> 0xc == -0x8 (0xfff8) +int 0x8000 + 0x2a == -0x7fd6 (0x802a) +__uint 0x8000 + 0x2a == -0x7fd6 (0x802a) +char 0x0 + 0x2a == 0x2a (0x2a) +__uchar 0x0 + 0x2a == 0x2a (0x2a) +__longlong 0x8000 + 0x2a == -0x7fd6 (0x802a) +__ulonglong 0x8000 + 0x2a == -0x7fd6 (0x802a) +float 0x8000 + 0x2a == -0x7fd6 (0x802a) +int 0x8000 - 0x2a == 0x7fd6 (0x7fd6) +__uint 0x8000 - 0x2a == 0x7fd6 (0x7fd6) +char 0x0 - 0x2a == -0x2a (0xffd6) +__uchar 0x0 - 0x2a == 0xd6 (0xd6) +__longlong 0x8000 - 0x2a == 0x7fd6 (0x7fd6) +__ulonglong 0x8000 - 0x2a == 0x7fd6 (0x7fd6) +float 0x8000 - 0x2a == -0x8000 (0x8000) +int 0x8000 * 0x2a == 0x0 (0x0) +__uint 0x8000 * 0x2a == 0x0 (0x0) +char 0x0 * 0x2a == 0x0 (0x0) +__uchar 0x0 * 0x2a == 0x0 (0x0) +__longlong 0x8000 * 0x2a == 0x0 (0x0) +__ulonglong 0x8000 * 0x2a == 0x0 (0x0) +float 0x8000 * 0x2a == -0x8000 (0x8000) +int 0x8000 < 0x2a == 0x1 (0x1) +__uint 0x8000 < 0x2a == 0x0 (0x0) +char 0x0 < 0x2a == 0x1 (0x1) +__uchar 0x0 < 0x2a == 0x1 (0x1) +__longlong 0x8000 < 0x2a == 0x1 (0x1) +__ulonglong 0x8000 < 0x2a == 0x0 (0x0) +float 0x8000 < 0x2a == 0x1 (0x1) +int 0x8000 > 0x2a == 0x0 (0x0) +__uint 0x8000 > 0x2a == 0x1 (0x1) +char 0x0 > 0x2a == 0x0 (0x0) +__uchar 0x0 > 0x2a == 0x0 (0x0) +__longlong 0x8000 > 0x2a == 0x0 (0x0) +__ulonglong 0x8000 > 0x2a == 0x1 (0x1) +float 0x8000 > 0x2a == 0x0 (0x0) +int 0x8000 <= 0x2a == 0x1 (0x1) +__uint 0x8000 <= 0x2a == 0x0 (0x0) +char 0x0 <= 0x2a == 0x1 (0x1) +__uchar 0x0 <= 0x2a == 0x1 (0x1) +__longlong 0x8000 <= 0x2a == 0x1 (0x1) +__ulonglong 0x8000 <= 0x2a == 0x0 (0x0) +float 0x8000 <= 0x2a == 0x1 (0x1) +int 0x8000 == 0x2a == 0x0 (0x0) +__uint 0x8000 == 0x2a == 0x0 (0x0) +char 0x0 == 0x2a == 0x0 (0x0) +__uchar 0x0 == 0x2a == 0x0 (0x0) +__longlong 0x8000 == 0x2a == 0x0 (0x0) +__ulonglong 0x8000 == 0x2a == 0x0 (0x0) +float 0x8000 == 0x2a == 0x0 (0x0) +int 0x8000 != 0x2a == 0x1 (0x1) +__uint 0x8000 != 0x2a == 0x1 (0x1) +char 0x0 != 0x2a == 0x1 (0x1) +__uchar 0x0 != 0x2a == 0x1 (0x1) +__longlong 0x8000 != 0x2a == 0x1 (0x1) +__ulonglong 0x8000 != 0x2a == 0x1 (0x1) +float 0x8000 != 0x2a == 0x1 (0x1) +int 0x8000 >= 0x2a == 0x0 (0x0) +__uint 0x8000 >= 0x2a == 0x1 (0x1) +char 0x0 >= 0x2a == 0x0 (0x0) +__uchar 0x0 >= 0x2a == 0x0 (0x0) +__longlong 0x8000 >= 0x2a == 0x0 (0x0) +__ulonglong 0x8000 >= 0x2a == 0x1 (0x1) +float 0x8000 >= 0x2a == 0x0 (0x0) +int 0x8000 / 0x2a == -0x30c (0xfcf4) +__uint 0x8000 / 0x2a == 0x30c (0x30c) +char 0x0 / 0x2a == 0x0 (0x0) +__uchar 0x0 / 0x2a == 0x0 (0x0) +__longlong 0x8000 / 0x2a == -0x30c (0xfcf4) +__ulonglong 0x8000 / 0x2a == 0x5e79 (0x5e79) +float 0x8000 / 0x2a == -0x30c (0xfcf4) +int 0x8000 % 0x2a == -0x8 (0xfff8) +__uint 0x8000 % 0x2a == 0x8 (0x8) +char 0x0 % 0x2a == 0x0 (0x0) +__uchar 0x0 % 0x2a == 0x0 (0x0) +__longlong 0x8000 % 0x2a == -0x8 (0xfff8) +__ulonglong 0x8000 % 0x2a == 0x26 (0x26) +0x8000 * 0x17 == -0x8000 +0x8000 / 0x17 == -0x590 +0x8000 % 0x17 == -0x10 +int 0x8000 ^ 0x17 == -0x7fe9 (0x8017) +__uint 0x8000 ^ 0x17 == -0x7fe9 (0x8017) +char 0x0 ^ 0x17 == 0x17 (0x17) +__uchar 0x0 ^ 0x17 == 0x17 (0x17) +__longlong 0x8000 ^ 0x17 == -0x7fe9 (0x8017) +__ulonglong 0x8000 ^ 0x17 == -0x7fe9 (0x8017) +int 0x8000 && 0x17 == 0x1 (0x1) +__uint 0x8000 && 0x17 == 0x1 (0x1) +char 0x0 && 0x17 == 0x0 (0x0) +__uchar 0x0 && 0x17 == 0x0 (0x0) +__longlong 0x8000 && 0x17 == 0x1 (0x1) +__ulonglong 0x8000 && 0x17 == 0x1 (0x1) +int 0x8000 || 0x17 == 0x1 (0x1) +__uint 0x8000 || 0x17 == 0x1 (0x1) +char 0x0 || 0x17 == 0x1 (0x1) +__uchar 0x0 || 0x17 == 0x1 (0x1) +__longlong 0x8000 || 0x17 == 0x1 (0x1) +__ulonglong 0x8000 || 0x17 == 0x1 (0x1) +int 0x8000 & 0x17 == 0x0 (0x0) +__uint 0x8000 & 0x17 == 0x0 (0x0) +char 0x0 & 0x17 == 0x0 (0x0) +__uchar 0x0 & 0x17 == 0x0 (0x0) +__longlong 0x8000 & 0x17 == 0x0 (0x0) +__ulonglong 0x8000 & 0x17 == 0x0 (0x0) +int 0x8000 | 0x17 == -0x7fe9 (0x8017) +__uint 0x8000 | 0x17 == -0x7fe9 (0x8017) +char 0x0 | 0x17 == 0x17 (0x17) +__uchar 0x0 | 0x17 == 0x17 (0x17) +__longlong 0x8000 | 0x17 == -0x7fe9 (0x8017) +__ulonglong 0x8000 | 0x17 == -0x7fe9 (0x8017) +int 0x8000 << 0xe == 0x0 (0x0) +__uint 0x8000 << 0xe == 0x0 (0x0) +char 0x0 << 0xe == 0x0 (0x0) +__uchar 0x0 << 0xe == 0x0 (0x0) +__longlong 0x8000 << 0xe == 0x0 (0x0) +__ulonglong 0x8000 << 0xe == 0x0 (0x0) +int 0x8000 >> 0xe == -0x2 (0xfffe) +__uint 0x8000 >> 0xe == 0x2 (0x2) +char 0x0 >> 0xe == 0x0 (0x0) +__uchar 0x0 >> 0xe == 0x0 (0x0) +__longlong 0x8000 >> 0xe == -0x2 (0xfffe) +__ulonglong 0x8000 >> 0xe == -0x2 (0xfffe) +int 0x8000 + 0x17 == -0x7fe9 (0x8017) +__uint 0x8000 + 0x17 == -0x7fe9 (0x8017) +char 0x0 + 0x17 == 0x17 (0x17) +__uchar 0x0 + 0x17 == 0x17 (0x17) +__longlong 0x8000 + 0x17 == -0x7fe9 (0x8017) +__ulonglong 0x8000 + 0x17 == -0x7fe9 (0x8017) +float 0x8000 + 0x17 == -0x7fe9 (0x8017) +int 0x8000 - 0x17 == 0x7fe9 (0x7fe9) +__uint 0x8000 - 0x17 == 0x7fe9 (0x7fe9) +char 0x0 - 0x17 == -0x17 (0xffe9) +__uchar 0x0 - 0x17 == 0xe9 (0xe9) +__longlong 0x8000 - 0x17 == 0x7fe9 (0x7fe9) +__ulonglong 0x8000 - 0x17 == 0x7fe9 (0x7fe9) +float 0x8000 - 0x17 == -0x8000 (0x8000) +int 0x8000 * 0x17 == -0x8000 (0x8000) +__uint 0x8000 * 0x17 == -0x8000 (0x8000) +char 0x0 * 0x17 == 0x0 (0x0) +__uchar 0x0 * 0x17 == 0x0 (0x0) +__longlong 0x8000 * 0x17 == -0x8000 (0x8000) +__ulonglong 0x8000 * 0x17 == -0x8000 (0x8000) +float 0x8000 * 0x17 == -0x8000 (0x8000) +int 0x8000 < 0x17 == 0x1 (0x1) +__uint 0x8000 < 0x17 == 0x0 (0x0) +char 0x0 < 0x17 == 0x1 (0x1) +__uchar 0x0 < 0x17 == 0x1 (0x1) +__longlong 0x8000 < 0x17 == 0x1 (0x1) +__ulonglong 0x8000 < 0x17 == 0x0 (0x0) +float 0x8000 < 0x17 == 0x1 (0x1) +int 0x8000 > 0x17 == 0x0 (0x0) +__uint 0x8000 > 0x17 == 0x1 (0x1) +char 0x0 > 0x17 == 0x0 (0x0) +__uchar 0x0 > 0x17 == 0x0 (0x0) +__longlong 0x8000 > 0x17 == 0x0 (0x0) +__ulonglong 0x8000 > 0x17 == 0x1 (0x1) +float 0x8000 > 0x17 == 0x0 (0x0) +int 0x8000 <= 0x17 == 0x1 (0x1) +__uint 0x8000 <= 0x17 == 0x0 (0x0) +char 0x0 <= 0x17 == 0x1 (0x1) +__uchar 0x0 <= 0x17 == 0x1 (0x1) +__longlong 0x8000 <= 0x17 == 0x1 (0x1) +__ulonglong 0x8000 <= 0x17 == 0x0 (0x0) +float 0x8000 <= 0x17 == 0x1 (0x1) +int 0x8000 == 0x17 == 0x0 (0x0) +__uint 0x8000 == 0x17 == 0x0 (0x0) +char 0x0 == 0x17 == 0x0 (0x0) +__uchar 0x0 == 0x17 == 0x0 (0x0) +__longlong 0x8000 == 0x17 == 0x0 (0x0) +__ulonglong 0x8000 == 0x17 == 0x0 (0x0) +float 0x8000 == 0x17 == 0x0 (0x0) +int 0x8000 != 0x17 == 0x1 (0x1) +__uint 0x8000 != 0x17 == 0x1 (0x1) +char 0x0 != 0x17 == 0x1 (0x1) +__uchar 0x0 != 0x17 == 0x1 (0x1) +__longlong 0x8000 != 0x17 == 0x1 (0x1) +__ulonglong 0x8000 != 0x17 == 0x1 (0x1) +float 0x8000 != 0x17 == 0x1 (0x1) +int 0x8000 >= 0x17 == 0x0 (0x0) +__uint 0x8000 >= 0x17 == 0x1 (0x1) +char 0x0 >= 0x17 == 0x0 (0x0) +__uchar 0x0 >= 0x17 == 0x0 (0x0) +__longlong 0x8000 >= 0x17 == 0x0 (0x0) +__ulonglong 0x8000 >= 0x17 == 0x1 (0x1) +float 0x8000 >= 0x17 == 0x0 (0x0) +int 0x8000 / 0x17 == -0x590 (0xfa70) +__uint 0x8000 / 0x17 == 0x590 (0x590) +char 0x0 / 0x17 == 0x0 (0x0) +__uchar 0x0 / 0x17 == 0x0 (0x0) +__longlong 0x8000 / 0x17 == -0x590 (0xfa70) +__ulonglong 0x8000 / 0x17 == 0x5e9b (0x5e9b) +float 0x8000 / 0x17 == -0x590 (0xfa70) +int 0x8000 % 0x17 == -0x10 (0xfff0) +__uint 0x8000 % 0x17 == 0x10 (0x10) +char 0x0 % 0x17 == 0x0 (0x0) +__uchar 0x0 % 0x17 == 0x0 (0x0) +__longlong 0x8000 % 0x17 == -0x10 (0xfff0) +__ulonglong 0x8000 % 0x17 == 0x13 (0x13) +0x8000 * 0x7fff == -0x8000 +0x8000 / 0x7fff == -0x1 +0x8000 % 0x7fff == -0x1 +int 0x8000 ^ 0x7fff == -0x1 (0xffff) +__uint 0x8000 ^ 0x7fff == -0x1 (0xffff) +char 0x0 ^ 0xffff == -0x1 (0xffff) +__uchar 0x0 ^ 0xff == 0xff (0xff) +__longlong 0x8000 ^ 0x7fff == -0x1 (0xffff) +__ulonglong 0x8000 ^ 0x7fff == -0x1 (0xffff) +int 0x8000 && 0x7fff == 0x1 (0x1) +__uint 0x8000 && 0x7fff == 0x1 (0x1) +char 0x0 && 0xffff == 0x0 (0x0) +__uchar 0x0 && 0xff == 0x0 (0x0) +__longlong 0x8000 && 0x7fff == 0x1 (0x1) +__ulonglong 0x8000 && 0x7fff == 0x1 (0x1) +int 0x8000 || 0x7fff == 0x1 (0x1) +__uint 0x8000 || 0x7fff == 0x1 (0x1) +char 0x0 || 0xffff == 0x1 (0x1) +__uchar 0x0 || 0xff == 0x1 (0x1) +__longlong 0x8000 || 0x7fff == 0x1 (0x1) +__ulonglong 0x8000 || 0x7fff == 0x1 (0x1) +int 0x8000 & 0x7fff == 0x0 (0x0) +__uint 0x8000 & 0x7fff == 0x0 (0x0) +char 0x0 & 0xffff == 0x0 (0x0) +__uchar 0x0 & 0xff == 0x0 (0x0) +__longlong 0x8000 & 0x7fff == 0x0 (0x0) +__ulonglong 0x8000 & 0x7fff == 0x0 (0x0) +int 0x8000 | 0x7fff == -0x1 (0xffff) +__uint 0x8000 | 0x7fff == -0x1 (0xffff) +char 0x0 | 0xffff == -0x1 (0xffff) +__uchar 0x0 | 0xff == 0xff (0xff) +__longlong 0x8000 | 0x7fff == -0x1 (0xffff) +__ulonglong 0x8000 | 0x7fff == -0x1 (0xffff) +int 0x8000 << 0x10 == 0x0 (0x0) +__uint 0x8000 << 0x10 == 0x0 (0x0) +char 0x0 << 0x10 == 0x0 (0x0) +__uchar 0x0 << 0x10 == 0x0 (0x0) +__longlong 0x8000 << 0x10 == 0x0 (0x0) +__ulonglong 0x8000 << 0x10 == 0x0 (0x0) +int 0x8000 >> 0x10 == -0x1 (0xffff) +__uint 0x8000 >> 0x10 == 0x0 (0x0) +char 0x0 >> 0x10 == 0x0 (0x0) +__uchar 0x0 >> 0x10 == 0x0 (0x0) +__longlong 0x8000 >> 0x10 == -0x1 (0xffff) +__ulonglong 0x8000 >> 0x10 == -0x1 (0xffff) +int 0x8000 + 0x7fff == -0x1 (0xffff) +__uint 0x8000 + 0x7fff == -0x1 (0xffff) +char 0x0 + 0xffff == -0x1 (0xffff) +__uchar 0x0 + 0xff == 0xff (0xff) +__longlong 0x8000 + 0x7fff == -0x1 (0xffff) +__ulonglong 0x8000 + 0x7fff == -0x1 (0xffff) +float 0x8000 + 0x7fff == -0x1 (0xffff) +int 0x8000 - 0x7fff == 0x1 (0x1) +__uint 0x8000 - 0x7fff == 0x1 (0x1) +char 0x0 - 0xffff == 0x1 (0x1) +__uchar 0x0 - 0xff == 0x1 (0x1) +__longlong 0x8000 - 0x7fff == 0x1 (0x1) +__ulonglong 0x8000 - 0x7fff == 0x1 (0x1) +float 0x8000 - 0x7fff == -0x8000 (0x8000) +int 0x8000 * 0x7fff == -0x8000 (0x8000) +__uint 0x8000 * 0x7fff == -0x8000 (0x8000) +char 0x0 * 0xffff == 0x0 (0x0) +__uchar 0x0 * 0xff == 0x0 (0x0) +__longlong 0x8000 * 0x7fff == -0x8000 (0x8000) +__ulonglong 0x8000 * 0x7fff == -0x8000 (0x8000) +float 0x8000 * 0x7fff == -0x8000 (0x8000) +int 0x8000 < 0x7fff == 0x1 (0x1) +__uint 0x8000 < 0x7fff == 0x0 (0x0) +char 0x0 < 0xffff == 0x0 (0x0) +__uchar 0x0 < 0xff == 0x1 (0x1) +__longlong 0x8000 < 0x7fff == 0x1 (0x1) +__ulonglong 0x8000 < 0x7fff == 0x0 (0x0) +float 0x8000 < 0x7fff == 0x1 (0x1) +int 0x8000 > 0x7fff == 0x0 (0x0) +__uint 0x8000 > 0x7fff == 0x1 (0x1) +char 0x0 > 0xffff == 0x1 (0x1) +__uchar 0x0 > 0xff == 0x0 (0x0) +__longlong 0x8000 > 0x7fff == 0x0 (0x0) +__ulonglong 0x8000 > 0x7fff == 0x1 (0x1) +float 0x8000 > 0x7fff == 0x0 (0x0) +int 0x8000 <= 0x7fff == 0x1 (0x1) +__uint 0x8000 <= 0x7fff == 0x0 (0x0) +char 0x0 <= 0xffff == 0x0 (0x0) +__uchar 0x0 <= 0xff == 0x1 (0x1) +__longlong 0x8000 <= 0x7fff == 0x1 (0x1) +__ulonglong 0x8000 <= 0x7fff == 0x0 (0x0) +float 0x8000 <= 0x7fff == 0x1 (0x1) +int 0x8000 == 0x7fff == 0x0 (0x0) +__uint 0x8000 == 0x7fff == 0x0 (0x0) +char 0x0 == 0xffff == 0x0 (0x0) +__uchar 0x0 == 0xff == 0x0 (0x0) +__longlong 0x8000 == 0x7fff == 0x0 (0x0) +__ulonglong 0x8000 == 0x7fff == 0x0 (0x0) +float 0x8000 == 0x7fff == 0x0 (0x0) +int 0x8000 != 0x7fff == 0x1 (0x1) +__uint 0x8000 != 0x7fff == 0x1 (0x1) +char 0x0 != 0xffff == 0x1 (0x1) +__uchar 0x0 != 0xff == 0x1 (0x1) +__longlong 0x8000 != 0x7fff == 0x1 (0x1) +__ulonglong 0x8000 != 0x7fff == 0x1 (0x1) +float 0x8000 != 0x7fff == 0x1 (0x1) +int 0x8000 >= 0x7fff == 0x0 (0x0) +__uint 0x8000 >= 0x7fff == 0x1 (0x1) +char 0x0 >= 0xffff == 0x1 (0x1) +__uchar 0x0 >= 0xff == 0x0 (0x0) +__longlong 0x8000 >= 0x7fff == 0x0 (0x0) +__ulonglong 0x8000 >= 0x7fff == 0x1 (0x1) +float 0x8000 >= 0x7fff == 0x0 (0x0) +int 0x8000 / 0x7fff == -0x1 (0xffff) +__uint 0x8000 / 0x7fff == 0x1 (0x1) +char 0x0 / 0xffff == 0x0 (0x0) +__uchar 0x0 / 0xff == 0x0 (0x0) +__longlong 0x8000 / 0x7fff == -0x1 (0xffff) +__ulonglong 0x8000 / 0x7fff == 0x3 (0x3) +float 0x8000 / 0x7fff == -0x1 (0xffff) +int 0x8000 % 0x7fff == -0x1 (0xffff) +__uint 0x8000 % 0x7fff == 0x1 (0x1) +char 0x0 % 0xffff == 0x0 (0x0) +__uchar 0x0 % 0xff == 0x0 (0x0) +__longlong 0x8000 % 0x7fff == -0x1 (0xffff) +__ulonglong 0x8000 % 0x7fff == 0x3 (0x3) +0x8000 * 0x8000 == 0x0 +0x8000 / 0x8000 == 0x1 +0x8000 % 0x8000 == 0x0 +int 0x8000 ^ 0x8000 == 0x0 (0x0) +__uint 0x8000 ^ 0x8000 == 0x0 (0x0) +char 0x0 ^ 0x0 == 0x0 (0x0) +__uchar 0x0 ^ 0x0 == 0x0 (0x0) +__longlong 0x8000 ^ 0x8000 == 0x0 (0x0) +__ulonglong 0x8000 ^ 0x8000 == 0x0 (0x0) +int 0x8000 && 0x8000 == 0x1 (0x1) +__uint 0x8000 && 0x8000 == 0x1 (0x1) +char 0x0 && 0x0 == 0x0 (0x0) +__uchar 0x0 && 0x0 == 0x0 (0x0) +__longlong 0x8000 && 0x8000 == 0x1 (0x1) +__ulonglong 0x8000 && 0x8000 == 0x1 (0x1) +int 0x8000 || 0x8000 == 0x1 (0x1) +__uint 0x8000 || 0x8000 == 0x1 (0x1) +char 0x0 || 0x0 == 0x0 (0x0) +__uchar 0x0 || 0x0 == 0x0 (0x0) +__longlong 0x8000 || 0x8000 == 0x1 (0x1) +__ulonglong 0x8000 || 0x8000 == 0x1 (0x1) +int 0x8000 & 0x8000 == -0x8000 (0x8000) +__uint 0x8000 & 0x8000 == -0x8000 (0x8000) +char 0x0 & 0x0 == 0x0 (0x0) +__uchar 0x0 & 0x0 == 0x0 (0x0) +__longlong 0x8000 & 0x8000 == -0x8000 (0x8000) +__ulonglong 0x8000 & 0x8000 == -0x8000 (0x8000) +int 0x8000 | 0x8000 == -0x8000 (0x8000) +__uint 0x8000 | 0x8000 == -0x8000 (0x8000) +char 0x0 | 0x0 == 0x0 (0x0) +__uchar 0x0 | 0x0 == 0x0 (0x0) +__longlong 0x8000 | 0x8000 == -0x8000 (0x8000) +__ulonglong 0x8000 | 0x8000 == -0x8000 (0x8000) +int 0x8000 << 0x12 == 0x0 (0x0) +__uint 0x8000 << 0x12 == 0x0 (0x0) +char 0x0 << 0x12 == 0x0 (0x0) +__uchar 0x0 << 0x12 == 0x0 (0x0) +__longlong 0x8000 << 0x12 == 0x0 (0x0) +__ulonglong 0x8000 << 0x12 == 0x0 (0x0) +int 0x8000 >> 0x12 == -0x1 (0xffff) +__uint 0x8000 >> 0x12 == 0x0 (0x0) +char 0x0 >> 0x12 == 0x0 (0x0) +__uchar 0x0 >> 0x12 == 0x0 (0x0) +__longlong 0x8000 >> 0x12 == -0x1 (0xffff) +__ulonglong 0x8000 >> 0x12 == 0x3fff (0x3fff) +int 0x8000 + 0x8000 == 0x0 (0x0) +__uint 0x8000 + 0x8000 == 0x0 (0x0) +char 0x0 + 0x0 == 0x0 (0x0) +__uchar 0x0 + 0x0 == 0x0 (0x0) +__longlong 0x8000 + 0x8000 == 0x0 (0x0) +__ulonglong 0x8000 + 0x8000 == 0x0 (0x0) +float 0x8000 + 0x8000 == -0x8000 (0x8000) +int 0x8000 - 0x8000 == 0x0 (0x0) +__uint 0x8000 - 0x8000 == 0x0 (0x0) +char 0x0 - 0x0 == 0x0 (0x0) +__uchar 0x0 - 0x0 == 0x0 (0x0) +__longlong 0x8000 - 0x8000 == 0x0 (0x0) +__ulonglong 0x8000 - 0x8000 == 0x0 (0x0) +float 0x8000 - 0x8000 == 0x0 (0x0) +int 0x8000 * 0x8000 == 0x0 (0x0) +__uint 0x8000 * 0x8000 == 0x0 (0x0) +char 0x0 * 0x0 == 0x0 (0x0) +__uchar 0x0 * 0x0 == 0x0 (0x0) +__longlong 0x8000 * 0x8000 == 0x0 (0x0) +__ulonglong 0x8000 * 0x8000 == 0x0 (0x0) +float 0x8000 * 0x8000 == -0x8000 (0x8000) +int 0x8000 < 0x8000 == 0x0 (0x0) +__uint 0x8000 < 0x8000 == 0x0 (0x0) +char 0x0 < 0x0 == 0x0 (0x0) +__uchar 0x0 < 0x0 == 0x0 (0x0) +__longlong 0x8000 < 0x8000 == 0x0 (0x0) +__ulonglong 0x8000 < 0x8000 == 0x0 (0x0) +float 0x8000 < 0x8000 == 0x0 (0x0) +int 0x8000 > 0x8000 == 0x0 (0x0) +__uint 0x8000 > 0x8000 == 0x0 (0x0) +char 0x0 > 0x0 == 0x0 (0x0) +__uchar 0x0 > 0x0 == 0x0 (0x0) +__longlong 0x8000 > 0x8000 == 0x0 (0x0) +__ulonglong 0x8000 > 0x8000 == 0x0 (0x0) +float 0x8000 > 0x8000 == 0x0 (0x0) +int 0x8000 <= 0x8000 == 0x1 (0x1) +__uint 0x8000 <= 0x8000 == 0x1 (0x1) +char 0x0 <= 0x0 == 0x1 (0x1) +__uchar 0x0 <= 0x0 == 0x1 (0x1) +__longlong 0x8000 <= 0x8000 == 0x1 (0x1) +__ulonglong 0x8000 <= 0x8000 == 0x1 (0x1) +float 0x8000 <= 0x8000 == 0x1 (0x1) +int 0x8000 == 0x8000 == 0x1 (0x1) +__uint 0x8000 == 0x8000 == 0x1 (0x1) +char 0x0 == 0x0 == 0x1 (0x1) +__uchar 0x0 == 0x0 == 0x1 (0x1) +__longlong 0x8000 == 0x8000 == 0x1 (0x1) +__ulonglong 0x8000 == 0x8000 == 0x1 (0x1) +float 0x8000 == 0x8000 == 0x1 (0x1) +int 0x8000 != 0x8000 == 0x0 (0x0) +__uint 0x8000 != 0x8000 == 0x0 (0x0) +char 0x0 != 0x0 == 0x0 (0x0) +__uchar 0x0 != 0x0 == 0x0 (0x0) +__longlong 0x8000 != 0x8000 == 0x0 (0x0) +__ulonglong 0x8000 != 0x8000 == 0x0 (0x0) +float 0x8000 != 0x8000 == 0x0 (0x0) +int 0x8000 >= 0x8000 == 0x1 (0x1) +__uint 0x8000 >= 0x8000 == 0x1 (0x1) +char 0x0 >= 0x0 == 0x1 (0x1) +__uchar 0x0 >= 0x0 == 0x1 (0x1) +__longlong 0x8000 >= 0x8000 == 0x1 (0x1) +__ulonglong 0x8000 >= 0x8000 == 0x1 (0x1) +float 0x8000 >= 0x8000 == 0x1 (0x1) +int 0x8000 / 0x8000 == 0x1 (0x1) +__uint 0x8000 / 0x8000 == 0x1 (0x1) +__longlong 0x8000 / 0x8000 == 0x1 (0x1) +__ulonglong 0x8000 / 0x8000 == 0x1 (0x1) +float 0x8000 / 0x8000 == 0x1 (0x1) +int 0x8000 % 0x8000 == 0x0 (0x0) +__uint 0x8000 % 0x8000 == 0x0 (0x0) +__longlong 0x8000 % 0x8000 == 0x0 (0x0) +__ulonglong 0x8000 % 0x8000 == 0x0 (0x0) +0x8000 * 0x3e8 == 0x0 +0x8000 / 0x3e8 == -0x20 +0x8000 % 0x3e8 == -0x300 +int 0x8000 ^ 0x3e8 == -0x7c18 (0x83e8) +__uint 0x8000 ^ 0x3e8 == -0x7c18 (0x83e8) +char 0x0 ^ 0xffe8 == -0x18 (0xffe8) +__uchar 0x0 ^ 0xe8 == 0xe8 (0xe8) +__longlong 0x8000 ^ 0x3e8 == -0x7c18 (0x83e8) +__ulonglong 0x8000 ^ 0x3e8 == -0x7c18 (0x83e8) +int 0x8000 && 0x3e8 == 0x1 (0x1) +__uint 0x8000 && 0x3e8 == 0x1 (0x1) +char 0x0 && 0xffe8 == 0x0 (0x0) +__uchar 0x0 && 0xe8 == 0x0 (0x0) +__longlong 0x8000 && 0x3e8 == 0x1 (0x1) +__ulonglong 0x8000 && 0x3e8 == 0x1 (0x1) +int 0x8000 || 0x3e8 == 0x1 (0x1) +__uint 0x8000 || 0x3e8 == 0x1 (0x1) +char 0x0 || 0xffe8 == 0x1 (0x1) +__uchar 0x0 || 0xe8 == 0x1 (0x1) +__longlong 0x8000 || 0x3e8 == 0x1 (0x1) +__ulonglong 0x8000 || 0x3e8 == 0x1 (0x1) +int 0x8000 & 0x3e8 == 0x0 (0x0) +__uint 0x8000 & 0x3e8 == 0x0 (0x0) +char 0x0 & 0xffe8 == 0x0 (0x0) +__uchar 0x0 & 0xe8 == 0x0 (0x0) +__longlong 0x8000 & 0x3e8 == 0x0 (0x0) +__ulonglong 0x8000 & 0x3e8 == 0x0 (0x0) +int 0x8000 | 0x3e8 == -0x7c18 (0x83e8) +__uint 0x8000 | 0x3e8 == -0x7c18 (0x83e8) +char 0x0 | 0xffe8 == -0x18 (0xffe8) +__uchar 0x0 | 0xe8 == 0xe8 (0xe8) +__longlong 0x8000 | 0x3e8 == -0x7c18 (0x83e8) +__ulonglong 0x8000 | 0x3e8 == -0x7c18 (0x83e8) +int 0x8000 << 0x14 == 0x0 (0x0) +__uint 0x8000 << 0x14 == 0x0 (0x0) +char 0x0 << 0x14 == 0x0 (0x0) +__uchar 0x0 << 0x14 == 0x0 (0x0) +__longlong 0x8000 << 0x14 == 0x0 (0x0) +__ulonglong 0x8000 << 0x14 == 0x0 (0x0) +int 0x8000 >> 0x14 == -0x1 (0xffff) +__uint 0x8000 >> 0x14 == 0x0 (0x0) +char 0x0 >> 0x14 == 0x0 (0x0) +__uchar 0x0 >> 0x14 == 0x0 (0x0) +__longlong 0x8000 >> 0x14 == -0x1 (0xffff) +__ulonglong 0x8000 >> 0x14 == 0xfff (0xfff) +int 0x8000 + 0x3e8 == -0x7c18 (0x83e8) +__uint 0x8000 + 0x3e8 == -0x7c18 (0x83e8) +char 0x0 + 0xffe8 == -0x18 (0xffe8) +__uchar 0x0 + 0xe8 == 0xe8 (0xe8) +__longlong 0x8000 + 0x3e8 == -0x7c18 (0x83e8) +__ulonglong 0x8000 + 0x3e8 == -0x7c18 (0x83e8) +float 0x8000 + 0x3e8 == -0x7c18 (0x83e8) +int 0x8000 - 0x3e8 == 0x7c18 (0x7c18) +__uint 0x8000 - 0x3e8 == 0x7c18 (0x7c18) +char 0x0 - 0xffe8 == 0x18 (0x18) +__uchar 0x0 - 0xe8 == 0x18 (0x18) +__longlong 0x8000 - 0x3e8 == 0x7c18 (0x7c18) +__ulonglong 0x8000 - 0x3e8 == 0x7c18 (0x7c18) +float 0x8000 - 0x3e8 == -0x8000 (0x8000) +int 0x8000 * 0x3e8 == 0x0 (0x0) +__uint 0x8000 * 0x3e8 == 0x0 (0x0) +char 0x0 * 0xffe8 == 0x0 (0x0) +__uchar 0x0 * 0xe8 == 0x0 (0x0) +__longlong 0x8000 * 0x3e8 == 0x0 (0x0) +__ulonglong 0x8000 * 0x3e8 == 0x0 (0x0) +float 0x8000 * 0x3e8 == -0x8000 (0x8000) +int 0x8000 < 0x3e8 == 0x1 (0x1) +__uint 0x8000 < 0x3e8 == 0x0 (0x0) +char 0x0 < 0xffe8 == 0x0 (0x0) +__uchar 0x0 < 0xe8 == 0x1 (0x1) +__longlong 0x8000 < 0x3e8 == 0x1 (0x1) +__ulonglong 0x8000 < 0x3e8 == 0x0 (0x0) +float 0x8000 < 0x3e8 == 0x1 (0x1) +int 0x8000 > 0x3e8 == 0x0 (0x0) +__uint 0x8000 > 0x3e8 == 0x1 (0x1) +char 0x0 > 0xffe8 == 0x1 (0x1) +__uchar 0x0 > 0xe8 == 0x0 (0x0) +__longlong 0x8000 > 0x3e8 == 0x0 (0x0) +__ulonglong 0x8000 > 0x3e8 == 0x1 (0x1) +float 0x8000 > 0x3e8 == 0x0 (0x0) +int 0x8000 <= 0x3e8 == 0x1 (0x1) +__uint 0x8000 <= 0x3e8 == 0x0 (0x0) +char 0x0 <= 0xffe8 == 0x0 (0x0) +__uchar 0x0 <= 0xe8 == 0x1 (0x1) +__longlong 0x8000 <= 0x3e8 == 0x1 (0x1) +__ulonglong 0x8000 <= 0x3e8 == 0x0 (0x0) +float 0x8000 <= 0x3e8 == 0x1 (0x1) +int 0x8000 == 0x3e8 == 0x0 (0x0) +__uint 0x8000 == 0x3e8 == 0x0 (0x0) +char 0x0 == 0xffe8 == 0x0 (0x0) +__uchar 0x0 == 0xe8 == 0x0 (0x0) +__longlong 0x8000 == 0x3e8 == 0x0 (0x0) +__ulonglong 0x8000 == 0x3e8 == 0x0 (0x0) +float 0x8000 == 0x3e8 == 0x0 (0x0) +int 0x8000 != 0x3e8 == 0x1 (0x1) +__uint 0x8000 != 0x3e8 == 0x1 (0x1) +char 0x0 != 0xffe8 == 0x1 (0x1) +__uchar 0x0 != 0xe8 == 0x1 (0x1) +__longlong 0x8000 != 0x3e8 == 0x1 (0x1) +__ulonglong 0x8000 != 0x3e8 == 0x1 (0x1) +float 0x8000 != 0x3e8 == 0x1 (0x1) +int 0x8000 >= 0x3e8 == 0x0 (0x0) +__uint 0x8000 >= 0x3e8 == 0x1 (0x1) +char 0x0 >= 0xffe8 == 0x1 (0x1) +__uchar 0x0 >= 0xe8 == 0x0 (0x0) +__longlong 0x8000 >= 0x3e8 == 0x0 (0x0) +__ulonglong 0x8000 >= 0x3e8 == 0x1 (0x1) +float 0x8000 >= 0x3e8 == 0x0 (0x0) +int 0x8000 / 0x3e8 == -0x20 (0xffe0) +__uint 0x8000 / 0x3e8 == 0x20 (0x20) +char 0x0 / 0xffe8 == 0x0 (0x0) +__uchar 0x0 / 0xe8 == 0x0 (0x0) +__longlong 0x8000 / 0x3e8 == -0x20 (0xffe0) +__ulonglong 0x8000 / 0x3e8 == -0x76ea (0x8916) +float 0x8000 / 0x3e8 == -0x20 (0xffe0) +int 0x8000 % 0x3e8 == -0x300 (0xfd00) +__uint 0x8000 % 0x3e8 == 0x300 (0x300) +char 0x0 % 0xffe8 == 0x0 (0x0) +__uchar 0x0 % 0xe8 == 0x0 (0x0) +__longlong 0x8000 % 0x3e8 == -0x300 (0xfd00) +__ulonglong 0x8000 % 0x3e8 == 0x210 (0x210) +0x8000 * 0x2710 == 0x0 +0x8000 / 0x2710 == -0x3 +0x8000 % 0x2710 == -0xad0 +int 0x8000 ^ 0x2710 == -0x58f0 (0xa710) +__uint 0x8000 ^ 0x2710 == -0x58f0 (0xa710) +char 0x0 ^ 0x10 == 0x10 (0x10) +__uchar 0x0 ^ 0x10 == 0x10 (0x10) +__longlong 0x8000 ^ 0x2710 == -0x58f0 (0xa710) +__ulonglong 0x8000 ^ 0x2710 == -0x58f0 (0xa710) +int 0x8000 && 0x2710 == 0x1 (0x1) +__uint 0x8000 && 0x2710 == 0x1 (0x1) +char 0x0 && 0x10 == 0x0 (0x0) +__uchar 0x0 && 0x10 == 0x0 (0x0) +__longlong 0x8000 && 0x2710 == 0x1 (0x1) +__ulonglong 0x8000 && 0x2710 == 0x1 (0x1) +int 0x8000 || 0x2710 == 0x1 (0x1) +__uint 0x8000 || 0x2710 == 0x1 (0x1) +char 0x0 || 0x10 == 0x1 (0x1) +__uchar 0x0 || 0x10 == 0x1 (0x1) +__longlong 0x8000 || 0x2710 == 0x1 (0x1) +__ulonglong 0x8000 || 0x2710 == 0x1 (0x1) +int 0x8000 & 0x2710 == 0x0 (0x0) +__uint 0x8000 & 0x2710 == 0x0 (0x0) +char 0x0 & 0x10 == 0x0 (0x0) +__uchar 0x0 & 0x10 == 0x0 (0x0) +__longlong 0x8000 & 0x2710 == 0x0 (0x0) +__ulonglong 0x8000 & 0x2710 == 0x0 (0x0) +int 0x8000 | 0x2710 == -0x58f0 (0xa710) +__uint 0x8000 | 0x2710 == -0x58f0 (0xa710) +char 0x0 | 0x10 == 0x10 (0x10) +__uchar 0x0 | 0x10 == 0x10 (0x10) +__longlong 0x8000 | 0x2710 == -0x58f0 (0xa710) +__ulonglong 0x8000 | 0x2710 == -0x58f0 (0xa710) +int 0x8000 << 0x16 == 0x0 (0x0) +__uint 0x8000 << 0x16 == 0x0 (0x0) +char 0x0 << 0x16 == 0x0 (0x0) +__uchar 0x0 << 0x16 == 0x0 (0x0) +__longlong 0x8000 << 0x16 == 0x0 (0x0) +__ulonglong 0x8000 << 0x16 == 0x0 (0x0) +int 0x8000 >> 0x16 == -0x1 (0xffff) +__uint 0x8000 >> 0x16 == 0x0 (0x0) +char 0x0 >> 0x16 == 0x0 (0x0) +__uchar 0x0 >> 0x16 == 0x0 (0x0) +__longlong 0x8000 >> 0x16 == -0x1 (0xffff) +__ulonglong 0x8000 >> 0x16 == 0x3ff (0x3ff) +int 0x8000 + 0x2710 == -0x58f0 (0xa710) +__uint 0x8000 + 0x2710 == -0x58f0 (0xa710) +char 0x0 + 0x10 == 0x10 (0x10) +__uchar 0x0 + 0x10 == 0x10 (0x10) +__longlong 0x8000 + 0x2710 == -0x58f0 (0xa710) +__ulonglong 0x8000 + 0x2710 == -0x58f0 (0xa710) +float 0x8000 + 0x2710 == -0x58f0 (0xa710) +int 0x8000 - 0x2710 == 0x58f0 (0x58f0) +__uint 0x8000 - 0x2710 == 0x58f0 (0x58f0) +char 0x0 - 0x10 == -0x10 (0xfff0) +__uchar 0x0 - 0x10 == 0xf0 (0xf0) +__longlong 0x8000 - 0x2710 == 0x58f0 (0x58f0) +__ulonglong 0x8000 - 0x2710 == 0x58f0 (0x58f0) +float 0x8000 - 0x2710 == -0x8000 (0x8000) +int 0x8000 * 0x2710 == 0x0 (0x0) +__uint 0x8000 * 0x2710 == 0x0 (0x0) +char 0x0 * 0x10 == 0x0 (0x0) +__uchar 0x0 * 0x10 == 0x0 (0x0) +__longlong 0x8000 * 0x2710 == 0x0 (0x0) +__ulonglong 0x8000 * 0x2710 == 0x0 (0x0) +float 0x8000 * 0x2710 == -0x8000 (0x8000) +int 0x8000 < 0x2710 == 0x1 (0x1) +__uint 0x8000 < 0x2710 == 0x0 (0x0) +char 0x0 < 0x10 == 0x1 (0x1) +__uchar 0x0 < 0x10 == 0x1 (0x1) +__longlong 0x8000 < 0x2710 == 0x1 (0x1) +__ulonglong 0x8000 < 0x2710 == 0x0 (0x0) +float 0x8000 < 0x2710 == 0x1 (0x1) +int 0x8000 > 0x2710 == 0x0 (0x0) +__uint 0x8000 > 0x2710 == 0x1 (0x1) +char 0x0 > 0x10 == 0x0 (0x0) +__uchar 0x0 > 0x10 == 0x0 (0x0) +__longlong 0x8000 > 0x2710 == 0x0 (0x0) +__ulonglong 0x8000 > 0x2710 == 0x1 (0x1) +float 0x8000 > 0x2710 == 0x0 (0x0) +int 0x8000 <= 0x2710 == 0x1 (0x1) +__uint 0x8000 <= 0x2710 == 0x0 (0x0) +char 0x0 <= 0x10 == 0x1 (0x1) +__uchar 0x0 <= 0x10 == 0x1 (0x1) +__longlong 0x8000 <= 0x2710 == 0x1 (0x1) +__ulonglong 0x8000 <= 0x2710 == 0x0 (0x0) +float 0x8000 <= 0x2710 == 0x1 (0x1) +int 0x8000 == 0x2710 == 0x0 (0x0) +__uint 0x8000 == 0x2710 == 0x0 (0x0) +char 0x0 == 0x10 == 0x0 (0x0) +__uchar 0x0 == 0x10 == 0x0 (0x0) +__longlong 0x8000 == 0x2710 == 0x0 (0x0) +__ulonglong 0x8000 == 0x2710 == 0x0 (0x0) +float 0x8000 == 0x2710 == 0x0 (0x0) +int 0x8000 != 0x2710 == 0x1 (0x1) +__uint 0x8000 != 0x2710 == 0x1 (0x1) +char 0x0 != 0x10 == 0x1 (0x1) +__uchar 0x0 != 0x10 == 0x1 (0x1) +__longlong 0x8000 != 0x2710 == 0x1 (0x1) +__ulonglong 0x8000 != 0x2710 == 0x1 (0x1) +float 0x8000 != 0x2710 == 0x1 (0x1) +int 0x8000 >= 0x2710 == 0x0 (0x0) +__uint 0x8000 >= 0x2710 == 0x1 (0x1) +char 0x0 >= 0x10 == 0x0 (0x0) +__uchar 0x0 >= 0x10 == 0x0 (0x0) +__longlong 0x8000 >= 0x2710 == 0x0 (0x0) +__ulonglong 0x8000 >= 0x2710 == 0x1 (0x1) +float 0x8000 >= 0x2710 == 0x0 (0x0) +int 0x8000 / 0x2710 == -0x3 (0xfffd) +__uint 0x8000 / 0x2710 == 0x3 (0x3) +char 0x0 / 0x10 == 0x0 (0x0) +__uchar 0x0 / 0x10 == 0x0 (0x0) +__longlong 0x8000 / 0x2710 == -0x3 (0xfffd) +__ulonglong 0x8000 / 0x2710 == -0x724b (0x8db5) +float 0x8000 / 0x2710 == -0x3 (0xfffd) +int 0x8000 % 0x2710 == -0xad0 (0xf530) +__uint 0x8000 % 0x2710 == 0xad0 (0xad0) +char 0x0 % 0x10 == 0x0 (0x0) +__uchar 0x0 % 0x10 == 0x0 (0x0) +__longlong 0x8000 % 0x2710 == -0xad0 (0xf530) +__ulonglong 0x8000 % 0x2710 == 0x11b0 (0x11b0) +int xor42-0x8000 xor42 -0x7fd6 +__uint xor42-0x8000 xor42 -0x7fd6 +char xor420x0 xor42 0x2a +__uchar xor420x0 xor42 0x2a +__longlong xor42-0x8000 xor42 -0x7fd6 +__ulonglong xor42-0x8000 xor42 -0x7fd6 +int land1-0x8000 land1 0x1 +__uint land1-0x8000 land1 0x1 +char land10x0 land1 0x0 +__uchar land10x0 land1 0x0 +__longlong land1-0x8000 land1 0x1 +__ulonglong land1-0x8000 land1 0x1 +int lor1-0x8000 lor1 0x1 +__uint lor1-0x8000 lor1 0x1 +char lor10x0 lor1 0x1 +__uchar lor10x0 lor1 0x1 +__longlong lor1-0x8000 lor1 0x1 +__ulonglong lor1-0x8000 lor1 0x1 +int and42-0x8000 and42 0x0 +__uint and42-0x8000 and42 0x0 +char and420x0 and42 0x0 +__uchar and420x0 and42 0x0 +__longlong and42-0x8000 and42 0x0 +__ulonglong and42-0x8000 and42 0x0 +int or42-0x8000 or42 -0x7fd6 +__uint or42-0x8000 or42 -0x7fd6 +char or420x0 or42 0x2a +__uchar or420x0 or42 0x2a +__longlong or42-0x8000 or42 -0x7fd6 +__ulonglong or42-0x8000 or42 -0x7fd6 +int shl5-0x8000 shl5 0x0 +__uint shl5-0x8000 shl5 0x0 +char shl50x0 shl5 0x0 +__uchar shl50x0 shl5 0x0 +__longlong shl5-0x8000 shl5 0x0 +__ulonglong shl5-0x8000 shl5 0x0 +int shr5-0x8000 shr5 -0x400 +__uint shr5-0x8000 shr5 0x400 +char shr50x0 shr5 0x0 +__uchar shr50x0 shr5 0x0 +__longlong shr5-0x8000 shr5 -0x400 +__ulonglong shr5-0x8000 shr5 -0x400 +int add42-0x8000 add42 -0x7fd6 +__uint add42-0x8000 add42 -0x7fd6 +char add420x0 add42 0x2a +__uchar add420x0 add42 0x2a +__longlong add42-0x8000 add42 -0x7fd6 +__ulonglong add42-0x8000 add42 -0x7fd6 +float add42-0x8000 add42 -0x7fd6 +int sub42-0x8000 sub42 0x7fd6 +__uint sub42-0x8000 sub42 0x7fd6 +char sub420x0 sub42 -0x2a +__uchar sub420x0 sub42 0xd6 +__longlong sub42-0x8000 sub42 0x7fd6 +__ulonglong sub42-0x8000 sub42 0x7fd6 +float sub42-0x8000 sub42 -0x8000 +int mul42-0x8000 mul42 0x0 +__uint mul42-0x8000 mul42 0x0 +char mul420x0 mul42 0x0 +__uchar mul420x0 mul42 0x0 +__longlong mul42-0x8000 mul42 0x0 +__ulonglong mul42-0x8000 mul42 0x0 +float mul42-0x8000 mul42 -0x8000 +int lt42-0x8000 lt42 0x1 +__uint lt42-0x8000 lt42 0x0 +char lt420x0 lt42 0x1 +__uchar lt420x0 lt42 0x1 +__longlong lt42-0x8000 lt42 0x1 +__ulonglong lt42-0x8000 lt42 0x0 +float lt42-0x8000 lt42 0x1 +int gt42-0x8000 gt42 0x0 +__uint gt42-0x8000 gt42 0x1 +char gt420x0 gt42 0x0 +__uchar gt420x0 gt42 0x0 +__longlong gt42-0x8000 gt42 0x0 +__ulonglong gt42-0x8000 gt42 0x1 +float gt42-0x8000 gt42 0x0 +int le42-0x8000 le42 0x1 +__uint le42-0x8000 le42 0x0 +char le420x0 le42 0x1 +__uchar le420x0 le42 0x1 +__longlong le42-0x8000 le42 0x1 +__ulonglong le42-0x8000 le42 0x0 +float le42-0x8000 le42 0x1 +int eq42-0x8000 eq42 0x0 +__uint eq42-0x8000 eq42 0x0 +char eq420x0 eq42 0x0 +__uchar eq420x0 eq42 0x0 +__longlong eq42-0x8000 eq42 0x0 +__ulonglong eq42-0x8000 eq42 0x0 +float eq42-0x8000 eq42 0x0 +int ne42-0x8000 ne42 0x1 +__uint ne42-0x8000 ne42 0x1 +char ne420x0 ne42 0x1 +__uchar ne420x0 ne42 0x1 +__longlong ne42-0x8000 ne42 0x1 +__ulonglong ne42-0x8000 ne42 0x1 +float ne42-0x8000 ne42 0x1 +int ge42-0x8000 ge42 0x0 +__uint ge42-0x8000 ge42 0x1 +char ge420x0 ge42 0x0 +__uchar ge420x0 ge42 0x0 +__longlong ge42-0x8000 ge42 0x0 +__ulonglong ge42-0x8000 ge42 0x1 +float ge42-0x8000 ge42 0x0 +int div42-0x8000 div42 -0x30c +__uint div42-0x8000 div42 0x30c +char div420x0 div42 0x0 +__uchar div420x0 div42 0x0 +__longlong div42-0x8000 div42 -0x30c +__ulonglong div42-0x8000 div42 0x5e79 +float div42-0x8000 div42 -0x30c +int mod23-0x8000 mod23 -0x10 +__uint mod23-0x8000 mod23 0x10 +char mod230x0 mod23 0x0 +__uchar mod230x0 mod23 0x0 +__longlong mod23-0x8000 mod23 -0x10 +__ulonglong mod23-0x8000 mod23 0x13 +0xfc18 * 0xffff == 0x3e8 +0xfc18 / 0xffff == 0x3e8 +0xfc18 % 0xffff == 0x0 +int 0xfc18 ^ 0xffff == 0x3e7 (0x3e7) +__uint 0xfc18 ^ 0xffff == 0x3e7 (0x3e7) +char 0x18 ^ 0xffff == -0x19 (0xffe7) +__uchar 0x18 ^ 0xff == 0xe7 (0xe7) +__longlong 0xfc18 ^ 0xffff == 0x3e7 (0x3e7) +__ulonglong 0xfc18 ^ 0xffff == 0x3e7 (0x3e7) +int 0xfc18 && 0xffff == 0x1 (0x1) +__uint 0xfc18 && 0xffff == 0x1 (0x1) +char 0x18 && 0xffff == 0x1 (0x1) +__uchar 0x18 && 0xff == 0x1 (0x1) +__longlong 0xfc18 && 0xffff == 0x1 (0x1) +__ulonglong 0xfc18 && 0xffff == 0x1 (0x1) +int 0xfc18 || 0xffff == 0x1 (0x1) +__uint 0xfc18 || 0xffff == 0x1 (0x1) +char 0x18 || 0xffff == 0x1 (0x1) +__uchar 0x18 || 0xff == 0x1 (0x1) +__longlong 0xfc18 || 0xffff == 0x1 (0x1) +__ulonglong 0xfc18 || 0xffff == 0x1 (0x1) +int 0xfc18 & 0xffff == -0x3e8 (0xfc18) +__uint 0xfc18 & 0xffff == -0x3e8 (0xfc18) +char 0x18 & 0xffff == 0x18 (0x18) +__uchar 0x18 & 0xff == 0x18 (0x18) +__longlong 0xfc18 & 0xffff == -0x3e8 (0xfc18) +__ulonglong 0xfc18 & 0xffff == -0x3e8 (0xfc18) +int 0xfc18 | 0xffff == -0x1 (0xffff) +__uint 0xfc18 | 0xffff == -0x1 (0xffff) +char 0x18 | 0xffff == -0x1 (0xffff) +__uchar 0x18 | 0xff == 0xff (0xff) +__longlong 0xfc18 | 0xffff == -0x1 (0xffff) +__ulonglong 0xfc18 | 0xffff == -0x1 (0xffff) +int 0xfc18 << 0x1 == -0x7d0 (0xf830) +__uint 0xfc18 << 0x1 == -0x7d0 (0xf830) +char 0x18 << 0x1 == 0x30 (0x30) +__uchar 0x18 << 0x1 == 0x30 (0x30) +__longlong 0xfc18 << 0x1 == -0x7d0 (0xf830) +__ulonglong 0xfc18 << 0x1 == -0x7d0 (0xf830) +int 0xfc18 >> 0x1 == -0x1f4 (0xfe0c) +__uint 0xfc18 >> 0x1 == 0x7e0c (0x7e0c) +char 0x18 >> 0x1 == 0xc (0xc) +__uchar 0x18 >> 0x1 == 0xc (0xc) +__longlong 0xfc18 >> 0x1 == -0x1f4 (0xfe0c) +__ulonglong 0xfc18 >> 0x1 == -0x1f4 (0xfe0c) +int 0xfc18 + 0xffff == -0x3e9 (0xfc17) +__uint 0xfc18 + 0xffff == -0x3e9 (0xfc17) +char 0x18 + 0xffff == 0x17 (0x17) +__uchar 0x18 + 0xff == 0x17 (0x17) +__longlong 0xfc18 + 0xffff == -0x3e9 (0xfc17) +__ulonglong 0xfc18 + 0xffff == -0x3e9 (0xfc17) +float 0xfc18 + 0xffff == -0x3e9 (0xfc17) +int 0xfc18 - 0xffff == -0x3e7 (0xfc19) +__uint 0xfc18 - 0xffff == -0x3e7 (0xfc19) +char 0x18 - 0xffff == 0x19 (0x19) +__uchar 0x18 - 0xff == 0x19 (0x19) +__longlong 0xfc18 - 0xffff == -0x3e7 (0xfc19) +__ulonglong 0xfc18 - 0xffff == -0x3e7 (0xfc19) +float 0xfc18 - 0xffff == -0x3e7 (0xfc19) +int 0xfc18 * 0xffff == 0x3e8 (0x3e8) +__uint 0xfc18 * 0xffff == 0x3e8 (0x3e8) +char 0x18 * 0xffff == -0x18 (0xffe8) +__uchar 0x18 * 0xff == 0xe8 (0xe8) +__longlong 0xfc18 * 0xffff == 0x3e8 (0x3e8) +__ulonglong 0xfc18 * 0xffff == 0x3e8 (0x3e8) +float 0xfc18 * 0xffff == 0x3e8 (0x3e8) +int 0xfc18 < 0xffff == 0x1 (0x1) +__uint 0xfc18 < 0xffff == 0x1 (0x1) +char 0x18 < 0xffff == 0x0 (0x0) +__uchar 0x18 < 0xff == 0x1 (0x1) +__longlong 0xfc18 < 0xffff == 0x1 (0x1) +__ulonglong 0xfc18 < 0xffff == 0x1 (0x1) +float 0xfc18 < 0xffff == 0x1 (0x1) +int 0xfc18 > 0xffff == 0x0 (0x0) +__uint 0xfc18 > 0xffff == 0x0 (0x0) +char 0x18 > 0xffff == 0x1 (0x1) +__uchar 0x18 > 0xff == 0x0 (0x0) +__longlong 0xfc18 > 0xffff == 0x0 (0x0) +__ulonglong 0xfc18 > 0xffff == 0x0 (0x0) +float 0xfc18 > 0xffff == 0x0 (0x0) +int 0xfc18 <= 0xffff == 0x1 (0x1) +__uint 0xfc18 <= 0xffff == 0x1 (0x1) +char 0x18 <= 0xffff == 0x0 (0x0) +__uchar 0x18 <= 0xff == 0x1 (0x1) +__longlong 0xfc18 <= 0xffff == 0x1 (0x1) +__ulonglong 0xfc18 <= 0xffff == 0x1 (0x1) +float 0xfc18 <= 0xffff == 0x1 (0x1) +int 0xfc18 == 0xffff == 0x0 (0x0) +__uint 0xfc18 == 0xffff == 0x0 (0x0) +char 0x18 == 0xffff == 0x0 (0x0) +__uchar 0x18 == 0xff == 0x0 (0x0) +__longlong 0xfc18 == 0xffff == 0x0 (0x0) +__ulonglong 0xfc18 == 0xffff == 0x0 (0x0) +float 0xfc18 == 0xffff == 0x0 (0x0) +int 0xfc18 != 0xffff == 0x1 (0x1) +__uint 0xfc18 != 0xffff == 0x1 (0x1) +char 0x18 != 0xffff == 0x1 (0x1) +__uchar 0x18 != 0xff == 0x1 (0x1) +__longlong 0xfc18 != 0xffff == 0x1 (0x1) +__ulonglong 0xfc18 != 0xffff == 0x1 (0x1) +float 0xfc18 != 0xffff == 0x1 (0x1) +int 0xfc18 >= 0xffff == 0x0 (0x0) +__uint 0xfc18 >= 0xffff == 0x0 (0x0) +char 0x18 >= 0xffff == 0x1 (0x1) +__uchar 0x18 >= 0xff == 0x0 (0x0) +__longlong 0xfc18 >= 0xffff == 0x0 (0x0) +__ulonglong 0xfc18 >= 0xffff == 0x0 (0x0) +float 0xfc18 >= 0xffff == 0x0 (0x0) +int 0xfc18 / 0xffff == 0x3e8 (0x3e8) +__uint 0xfc18 / 0xffff == 0x0 (0x0) +char 0x18 / 0xffff == -0x18 (0xffe8) +__uchar 0x18 / 0xff == 0x0 (0x0) +__longlong 0xfc18 / 0xffff == 0x3e8 (0x3e8) +__ulonglong 0xfc18 / 0xffff == 0x0 (0x0) +float 0xfc18 / 0xffff == 0x3e8 (0x3e8) +int 0xfc18 % 0xffff == 0x0 (0x0) +__uint 0xfc18 % 0xffff == -0x3e8 (0xfc18) +char 0x18 % 0xffff == 0x0 (0x0) +__uchar 0x18 % 0xff == 0x18 (0x18) +__longlong 0xfc18 % 0xffff == 0x0 (0x0) +__ulonglong 0xfc18 % 0xffff == -0x3e8 (0xfc18) +0xfc18 * 0x1 == -0x3e8 +0xfc18 / 0x1 == -0x3e8 +0xfc18 % 0x1 == 0x0 +int 0xfc18 ^ 0x1 == -0x3e7 (0xfc19) +__uint 0xfc18 ^ 0x1 == -0x3e7 (0xfc19) +char 0x18 ^ 0x1 == 0x19 (0x19) +__uchar 0x18 ^ 0x1 == 0x19 (0x19) +__longlong 0xfc18 ^ 0x1 == -0x3e7 (0xfc19) +__ulonglong 0xfc18 ^ 0x1 == -0x3e7 (0xfc19) +int 0xfc18 && 0x1 == 0x1 (0x1) +__uint 0xfc18 && 0x1 == 0x1 (0x1) +char 0x18 && 0x1 == 0x1 (0x1) +__uchar 0x18 && 0x1 == 0x1 (0x1) +__longlong 0xfc18 && 0x1 == 0x1 (0x1) +__ulonglong 0xfc18 && 0x1 == 0x1 (0x1) +int 0xfc18 || 0x1 == 0x1 (0x1) +__uint 0xfc18 || 0x1 == 0x1 (0x1) +char 0x18 || 0x1 == 0x1 (0x1) +__uchar 0x18 || 0x1 == 0x1 (0x1) +__longlong 0xfc18 || 0x1 == 0x1 (0x1) +__ulonglong 0xfc18 || 0x1 == 0x1 (0x1) +int 0xfc18 & 0x1 == 0x0 (0x0) +__uint 0xfc18 & 0x1 == 0x0 (0x0) +char 0x18 & 0x1 == 0x0 (0x0) +__uchar 0x18 & 0x1 == 0x0 (0x0) +__longlong 0xfc18 & 0x1 == 0x0 (0x0) +__ulonglong 0xfc18 & 0x1 == 0x0 (0x0) +int 0xfc18 | 0x1 == -0x3e7 (0xfc19) +__uint 0xfc18 | 0x1 == -0x3e7 (0xfc19) +char 0x18 | 0x1 == 0x19 (0x19) +__uchar 0x18 | 0x1 == 0x19 (0x19) +__longlong 0xfc18 | 0x1 == -0x3e7 (0xfc19) +__ulonglong 0xfc18 | 0x1 == -0x3e7 (0xfc19) +int 0xfc18 << 0x2 == -0xfa0 (0xf060) +__uint 0xfc18 << 0x2 == -0xfa0 (0xf060) +char 0x18 << 0x2 == 0x60 (0x60) +__uchar 0x18 << 0x2 == 0x60 (0x60) +__longlong 0xfc18 << 0x2 == -0xfa0 (0xf060) +__ulonglong 0xfc18 << 0x2 == -0xfa0 (0xf060) +int 0xfc18 >> 0x2 == -0xfa (0xff06) +__uint 0xfc18 >> 0x2 == 0x3f06 (0x3f06) +char 0x18 >> 0x2 == 0x6 (0x6) +__uchar 0x18 >> 0x2 == 0x6 (0x6) +__longlong 0xfc18 >> 0x2 == -0xfa (0xff06) +__ulonglong 0xfc18 >> 0x2 == -0xfa (0xff06) +int 0xfc18 + 0x1 == -0x3e7 (0xfc19) +__uint 0xfc18 + 0x1 == -0x3e7 (0xfc19) +char 0x18 + 0x1 == 0x19 (0x19) +__uchar 0x18 + 0x1 == 0x19 (0x19) +__longlong 0xfc18 + 0x1 == -0x3e7 (0xfc19) +__ulonglong 0xfc18 + 0x1 == -0x3e7 (0xfc19) +float 0xfc18 + 0x1 == -0x3e7 (0xfc19) +int 0xfc18 - 0x1 == -0x3e9 (0xfc17) +__uint 0xfc18 - 0x1 == -0x3e9 (0xfc17) +char 0x18 - 0x1 == 0x17 (0x17) +__uchar 0x18 - 0x1 == 0x17 (0x17) +__longlong 0xfc18 - 0x1 == -0x3e9 (0xfc17) +__ulonglong 0xfc18 - 0x1 == -0x3e9 (0xfc17) +float 0xfc18 - 0x1 == -0x3e9 (0xfc17) +int 0xfc18 * 0x1 == -0x3e8 (0xfc18) +__uint 0xfc18 * 0x1 == -0x3e8 (0xfc18) +char 0x18 * 0x1 == 0x18 (0x18) +__uchar 0x18 * 0x1 == 0x18 (0x18) +__longlong 0xfc18 * 0x1 == -0x3e8 (0xfc18) +__ulonglong 0xfc18 * 0x1 == -0x3e8 (0xfc18) +float 0xfc18 * 0x1 == -0x3e8 (0xfc18) +int 0xfc18 < 0x1 == 0x1 (0x1) +__uint 0xfc18 < 0x1 == 0x0 (0x0) +char 0x18 < 0x1 == 0x0 (0x0) +__uchar 0x18 < 0x1 == 0x0 (0x0) +__longlong 0xfc18 < 0x1 == 0x1 (0x1) +__ulonglong 0xfc18 < 0x1 == 0x0 (0x0) +float 0xfc18 < 0x1 == 0x1 (0x1) +int 0xfc18 > 0x1 == 0x0 (0x0) +__uint 0xfc18 > 0x1 == 0x1 (0x1) +char 0x18 > 0x1 == 0x1 (0x1) +__uchar 0x18 > 0x1 == 0x1 (0x1) +__longlong 0xfc18 > 0x1 == 0x0 (0x0) +__ulonglong 0xfc18 > 0x1 == 0x1 (0x1) +float 0xfc18 > 0x1 == 0x0 (0x0) +int 0xfc18 <= 0x1 == 0x1 (0x1) +__uint 0xfc18 <= 0x1 == 0x0 (0x0) +char 0x18 <= 0x1 == 0x0 (0x0) +__uchar 0x18 <= 0x1 == 0x0 (0x0) +__longlong 0xfc18 <= 0x1 == 0x1 (0x1) +__ulonglong 0xfc18 <= 0x1 == 0x0 (0x0) +float 0xfc18 <= 0x1 == 0x1 (0x1) +int 0xfc18 == 0x1 == 0x0 (0x0) +__uint 0xfc18 == 0x1 == 0x0 (0x0) +char 0x18 == 0x1 == 0x0 (0x0) +__uchar 0x18 == 0x1 == 0x0 (0x0) +__longlong 0xfc18 == 0x1 == 0x0 (0x0) +__ulonglong 0xfc18 == 0x1 == 0x0 (0x0) +float 0xfc18 == 0x1 == 0x0 (0x0) +int 0xfc18 != 0x1 == 0x1 (0x1) +__uint 0xfc18 != 0x1 == 0x1 (0x1) +char 0x18 != 0x1 == 0x1 (0x1) +__uchar 0x18 != 0x1 == 0x1 (0x1) +__longlong 0xfc18 != 0x1 == 0x1 (0x1) +__ulonglong 0xfc18 != 0x1 == 0x1 (0x1) +float 0xfc18 != 0x1 == 0x1 (0x1) +int 0xfc18 >= 0x1 == 0x0 (0x0) +__uint 0xfc18 >= 0x1 == 0x1 (0x1) +char 0x18 >= 0x1 == 0x1 (0x1) +__uchar 0x18 >= 0x1 == 0x1 (0x1) +__longlong 0xfc18 >= 0x1 == 0x0 (0x0) +__ulonglong 0xfc18 >= 0x1 == 0x1 (0x1) +float 0xfc18 >= 0x1 == 0x0 (0x0) +int 0xfc18 / 0x1 == -0x3e8 (0xfc18) +__uint 0xfc18 / 0x1 == -0x3e8 (0xfc18) +char 0x18 / 0x1 == 0x18 (0x18) +__uchar 0x18 / 0x1 == 0x18 (0x18) +__longlong 0xfc18 / 0x1 == -0x3e8 (0xfc18) +__ulonglong 0xfc18 / 0x1 == -0x3e8 (0xfc18) +float 0xfc18 / 0x1 == -0x3e8 (0xfc18) +int 0xfc18 % 0x1 == 0x0 (0x0) +__uint 0xfc18 % 0x1 == 0x0 (0x0) +char 0x18 % 0x1 == 0x0 (0x0) +__uchar 0x18 % 0x1 == 0x0 (0x0) +__longlong 0xfc18 % 0x1 == 0x0 (0x0) +__ulonglong 0xfc18 % 0x1 == 0x0 (0x0) +0xfc18 * 0x2 == -0x7d0 +0xfc18 / 0x2 == -0x1f4 +0xfc18 % 0x2 == 0x0 +int 0xfc18 ^ 0x2 == -0x3e6 (0xfc1a) +__uint 0xfc18 ^ 0x2 == -0x3e6 (0xfc1a) +char 0x18 ^ 0x2 == 0x1a (0x1a) +__uchar 0x18 ^ 0x2 == 0x1a (0x1a) +__longlong 0xfc18 ^ 0x2 == -0x3e6 (0xfc1a) +__ulonglong 0xfc18 ^ 0x2 == -0x3e6 (0xfc1a) +int 0xfc18 && 0x2 == 0x1 (0x1) +__uint 0xfc18 && 0x2 == 0x1 (0x1) +char 0x18 && 0x2 == 0x1 (0x1) +__uchar 0x18 && 0x2 == 0x1 (0x1) +__longlong 0xfc18 && 0x2 == 0x1 (0x1) +__ulonglong 0xfc18 && 0x2 == 0x1 (0x1) +int 0xfc18 || 0x2 == 0x1 (0x1) +__uint 0xfc18 || 0x2 == 0x1 (0x1) +char 0x18 || 0x2 == 0x1 (0x1) +__uchar 0x18 || 0x2 == 0x1 (0x1) +__longlong 0xfc18 || 0x2 == 0x1 (0x1) +__ulonglong 0xfc18 || 0x2 == 0x1 (0x1) +int 0xfc18 & 0x2 == 0x0 (0x0) +__uint 0xfc18 & 0x2 == 0x0 (0x0) +char 0x18 & 0x2 == 0x0 (0x0) +__uchar 0x18 & 0x2 == 0x0 (0x0) +__longlong 0xfc18 & 0x2 == 0x0 (0x0) +__ulonglong 0xfc18 & 0x2 == 0x0 (0x0) +int 0xfc18 | 0x2 == -0x3e6 (0xfc1a) +__uint 0xfc18 | 0x2 == -0x3e6 (0xfc1a) +char 0x18 | 0x2 == 0x1a (0x1a) +__uchar 0x18 | 0x2 == 0x1a (0x1a) +__longlong 0xfc18 | 0x2 == -0x3e6 (0xfc1a) +__ulonglong 0xfc18 | 0x2 == -0x3e6 (0xfc1a) +int 0xfc18 << 0x3 == -0x1f40 (0xe0c0) +__uint 0xfc18 << 0x3 == -0x1f40 (0xe0c0) +char 0x18 << 0x3 == -0x40 (0xffc0) +__uchar 0x18 << 0x3 == 0xc0 (0xc0) +__longlong 0xfc18 << 0x3 == -0x1f40 (0xe0c0) +__ulonglong 0xfc18 << 0x3 == -0x1f40 (0xe0c0) +int 0xfc18 >> 0x3 == -0x7d (0xff83) +__uint 0xfc18 >> 0x3 == 0x1f83 (0x1f83) +char 0x18 >> 0x3 == 0x3 (0x3) +__uchar 0x18 >> 0x3 == 0x3 (0x3) +__longlong 0xfc18 >> 0x3 == -0x7d (0xff83) +__ulonglong 0xfc18 >> 0x3 == -0x7d (0xff83) +int 0xfc18 + 0x2 == -0x3e6 (0xfc1a) +__uint 0xfc18 + 0x2 == -0x3e6 (0xfc1a) +char 0x18 + 0x2 == 0x1a (0x1a) +__uchar 0x18 + 0x2 == 0x1a (0x1a) +__longlong 0xfc18 + 0x2 == -0x3e6 (0xfc1a) +__ulonglong 0xfc18 + 0x2 == -0x3e6 (0xfc1a) +float 0xfc18 + 0x2 == -0x3e6 (0xfc1a) +int 0xfc18 - 0x2 == -0x3ea (0xfc16) +__uint 0xfc18 - 0x2 == -0x3ea (0xfc16) +char 0x18 - 0x2 == 0x16 (0x16) +__uchar 0x18 - 0x2 == 0x16 (0x16) +__longlong 0xfc18 - 0x2 == -0x3ea (0xfc16) +__ulonglong 0xfc18 - 0x2 == -0x3ea (0xfc16) +float 0xfc18 - 0x2 == -0x3ea (0xfc16) +int 0xfc18 * 0x2 == -0x7d0 (0xf830) +__uint 0xfc18 * 0x2 == -0x7d0 (0xf830) +char 0x18 * 0x2 == 0x30 (0x30) +__uchar 0x18 * 0x2 == 0x30 (0x30) +__longlong 0xfc18 * 0x2 == -0x7d0 (0xf830) +__ulonglong 0xfc18 * 0x2 == -0x7d0 (0xf830) +float 0xfc18 * 0x2 == -0x7d0 (0xf830) +int 0xfc18 < 0x2 == 0x1 (0x1) +__uint 0xfc18 < 0x2 == 0x0 (0x0) +char 0x18 < 0x2 == 0x0 (0x0) +__uchar 0x18 < 0x2 == 0x0 (0x0) +__longlong 0xfc18 < 0x2 == 0x1 (0x1) +__ulonglong 0xfc18 < 0x2 == 0x0 (0x0) +float 0xfc18 < 0x2 == 0x1 (0x1) +int 0xfc18 > 0x2 == 0x0 (0x0) +__uint 0xfc18 > 0x2 == 0x1 (0x1) +char 0x18 > 0x2 == 0x1 (0x1) +__uchar 0x18 > 0x2 == 0x1 (0x1) +__longlong 0xfc18 > 0x2 == 0x0 (0x0) +__ulonglong 0xfc18 > 0x2 == 0x1 (0x1) +float 0xfc18 > 0x2 == 0x0 (0x0) +int 0xfc18 <= 0x2 == 0x1 (0x1) +__uint 0xfc18 <= 0x2 == 0x0 (0x0) +char 0x18 <= 0x2 == 0x0 (0x0) +__uchar 0x18 <= 0x2 == 0x0 (0x0) +__longlong 0xfc18 <= 0x2 == 0x1 (0x1) +__ulonglong 0xfc18 <= 0x2 == 0x0 (0x0) +float 0xfc18 <= 0x2 == 0x1 (0x1) +int 0xfc18 == 0x2 == 0x0 (0x0) +__uint 0xfc18 == 0x2 == 0x0 (0x0) +char 0x18 == 0x2 == 0x0 (0x0) +__uchar 0x18 == 0x2 == 0x0 (0x0) +__longlong 0xfc18 == 0x2 == 0x0 (0x0) +__ulonglong 0xfc18 == 0x2 == 0x0 (0x0) +float 0xfc18 == 0x2 == 0x0 (0x0) +int 0xfc18 != 0x2 == 0x1 (0x1) +__uint 0xfc18 != 0x2 == 0x1 (0x1) +char 0x18 != 0x2 == 0x1 (0x1) +__uchar 0x18 != 0x2 == 0x1 (0x1) +__longlong 0xfc18 != 0x2 == 0x1 (0x1) +__ulonglong 0xfc18 != 0x2 == 0x1 (0x1) +float 0xfc18 != 0x2 == 0x1 (0x1) +int 0xfc18 >= 0x2 == 0x0 (0x0) +__uint 0xfc18 >= 0x2 == 0x1 (0x1) +char 0x18 >= 0x2 == 0x1 (0x1) +__uchar 0x18 >= 0x2 == 0x1 (0x1) +__longlong 0xfc18 >= 0x2 == 0x0 (0x0) +__ulonglong 0xfc18 >= 0x2 == 0x1 (0x1) +float 0xfc18 >= 0x2 == 0x0 (0x0) +int 0xfc18 / 0x2 == -0x1f4 (0xfe0c) +__uint 0xfc18 / 0x2 == 0x7e0c (0x7e0c) +char 0x18 / 0x2 == 0xc (0xc) +__uchar 0x18 / 0x2 == 0xc (0xc) +__longlong 0xfc18 / 0x2 == -0x1f4 (0xfe0c) +__ulonglong 0xfc18 / 0x2 == -0x1f4 (0xfe0c) +float 0xfc18 / 0x2 == -0x1f4 (0xfe0c) +int 0xfc18 % 0x2 == 0x0 (0x0) +__uint 0xfc18 % 0x2 == 0x0 (0x0) +char 0x18 % 0x2 == 0x0 (0x0) +__uchar 0x18 % 0x2 == 0x0 (0x0) +__longlong 0xfc18 % 0x2 == 0x0 (0x0) +__ulonglong 0xfc18 % 0x2 == 0x0 (0x0) +0xfc18 * 0xfffe == 0x7d0 +0xfc18 / 0xfffe == 0x1f4 +0xfc18 % 0xfffe == 0x0 +int 0xfc18 ^ 0xfffe == 0x3e6 (0x3e6) +__uint 0xfc18 ^ 0xfffe == 0x3e6 (0x3e6) +char 0x18 ^ 0xfffe == -0x1a (0xffe6) +__uchar 0x18 ^ 0xfe == 0xe6 (0xe6) +__longlong 0xfc18 ^ 0xfffe == 0x3e6 (0x3e6) +__ulonglong 0xfc18 ^ 0xfffe == 0x3e6 (0x3e6) +int 0xfc18 && 0xfffe == 0x1 (0x1) +__uint 0xfc18 && 0xfffe == 0x1 (0x1) +char 0x18 && 0xfffe == 0x1 (0x1) +__uchar 0x18 && 0xfe == 0x1 (0x1) +__longlong 0xfc18 && 0xfffe == 0x1 (0x1) +__ulonglong 0xfc18 && 0xfffe == 0x1 (0x1) +int 0xfc18 || 0xfffe == 0x1 (0x1) +__uint 0xfc18 || 0xfffe == 0x1 (0x1) +char 0x18 || 0xfffe == 0x1 (0x1) +__uchar 0x18 || 0xfe == 0x1 (0x1) +__longlong 0xfc18 || 0xfffe == 0x1 (0x1) +__ulonglong 0xfc18 || 0xfffe == 0x1 (0x1) +int 0xfc18 & 0xfffe == -0x3e8 (0xfc18) +__uint 0xfc18 & 0xfffe == -0x3e8 (0xfc18) +char 0x18 & 0xfffe == 0x18 (0x18) +__uchar 0x18 & 0xfe == 0x18 (0x18) +__longlong 0xfc18 & 0xfffe == -0x3e8 (0xfc18) +__ulonglong 0xfc18 & 0xfffe == -0x3e8 (0xfc18) +int 0xfc18 | 0xfffe == -0x2 (0xfffe) +__uint 0xfc18 | 0xfffe == -0x2 (0xfffe) +char 0x18 | 0xfffe == -0x2 (0xfffe) +__uchar 0x18 | 0xfe == 0xfe (0xfe) +__longlong 0xfc18 | 0xfffe == -0x2 (0xfffe) +__ulonglong 0xfc18 | 0xfffe == -0x2 (0xfffe) +int 0xfc18 << 0x4 == -0x3e80 (0xc180) +__uint 0xfc18 << 0x4 == -0x3e80 (0xc180) +char 0x18 << 0x4 == -0x80 (0xff80) +__uchar 0x18 << 0x4 == 0x80 (0x80) +__longlong 0xfc18 << 0x4 == -0x3e80 (0xc180) +__ulonglong 0xfc18 << 0x4 == -0x3e80 (0xc180) +int 0xfc18 >> 0x4 == -0x3f (0xffc1) +__uint 0xfc18 >> 0x4 == 0xfc1 (0xfc1) +char 0x18 >> 0x4 == 0x1 (0x1) +__uchar 0x18 >> 0x4 == 0x1 (0x1) +__longlong 0xfc18 >> 0x4 == -0x3f (0xffc1) +__ulonglong 0xfc18 >> 0x4 == -0x3f (0xffc1) +int 0xfc18 + 0xfffe == -0x3ea (0xfc16) +__uint 0xfc18 + 0xfffe == -0x3ea (0xfc16) +char 0x18 + 0xfffe == 0x16 (0x16) +__uchar 0x18 + 0xfe == 0x16 (0x16) +__longlong 0xfc18 + 0xfffe == -0x3ea (0xfc16) +__ulonglong 0xfc18 + 0xfffe == -0x3ea (0xfc16) +float 0xfc18 + 0xfffe == -0x3ea (0xfc16) +int 0xfc18 - 0xfffe == -0x3e6 (0xfc1a) +__uint 0xfc18 - 0xfffe == -0x3e6 (0xfc1a) +char 0x18 - 0xfffe == 0x1a (0x1a) +__uchar 0x18 - 0xfe == 0x1a (0x1a) +__longlong 0xfc18 - 0xfffe == -0x3e6 (0xfc1a) +__ulonglong 0xfc18 - 0xfffe == -0x3e6 (0xfc1a) +float 0xfc18 - 0xfffe == -0x3e6 (0xfc1a) +int 0xfc18 * 0xfffe == 0x7d0 (0x7d0) +__uint 0xfc18 * 0xfffe == 0x7d0 (0x7d0) +char 0x18 * 0xfffe == -0x30 (0xffd0) +__uchar 0x18 * 0xfe == 0xd0 (0xd0) +__longlong 0xfc18 * 0xfffe == 0x7d0 (0x7d0) +__ulonglong 0xfc18 * 0xfffe == 0x7d0 (0x7d0) +float 0xfc18 * 0xfffe == 0x7d0 (0x7d0) +int 0xfc18 < 0xfffe == 0x1 (0x1) +__uint 0xfc18 < 0xfffe == 0x1 (0x1) +char 0x18 < 0xfffe == 0x0 (0x0) +__uchar 0x18 < 0xfe == 0x1 (0x1) +__longlong 0xfc18 < 0xfffe == 0x1 (0x1) +__ulonglong 0xfc18 < 0xfffe == 0x1 (0x1) +float 0xfc18 < 0xfffe == 0x1 (0x1) +int 0xfc18 > 0xfffe == 0x0 (0x0) +__uint 0xfc18 > 0xfffe == 0x0 (0x0) +char 0x18 > 0xfffe == 0x1 (0x1) +__uchar 0x18 > 0xfe == 0x0 (0x0) +__longlong 0xfc18 > 0xfffe == 0x0 (0x0) +__ulonglong 0xfc18 > 0xfffe == 0x0 (0x0) +float 0xfc18 > 0xfffe == 0x0 (0x0) +int 0xfc18 <= 0xfffe == 0x1 (0x1) +__uint 0xfc18 <= 0xfffe == 0x1 (0x1) +char 0x18 <= 0xfffe == 0x0 (0x0) +__uchar 0x18 <= 0xfe == 0x1 (0x1) +__longlong 0xfc18 <= 0xfffe == 0x1 (0x1) +__ulonglong 0xfc18 <= 0xfffe == 0x1 (0x1) +float 0xfc18 <= 0xfffe == 0x1 (0x1) +int 0xfc18 == 0xfffe == 0x0 (0x0) +__uint 0xfc18 == 0xfffe == 0x0 (0x0) +char 0x18 == 0xfffe == 0x0 (0x0) +__uchar 0x18 == 0xfe == 0x0 (0x0) +__longlong 0xfc18 == 0xfffe == 0x0 (0x0) +__ulonglong 0xfc18 == 0xfffe == 0x0 (0x0) +float 0xfc18 == 0xfffe == 0x0 (0x0) +int 0xfc18 != 0xfffe == 0x1 (0x1) +__uint 0xfc18 != 0xfffe == 0x1 (0x1) +char 0x18 != 0xfffe == 0x1 (0x1) +__uchar 0x18 != 0xfe == 0x1 (0x1) +__longlong 0xfc18 != 0xfffe == 0x1 (0x1) +__ulonglong 0xfc18 != 0xfffe == 0x1 (0x1) +float 0xfc18 != 0xfffe == 0x1 (0x1) +int 0xfc18 >= 0xfffe == 0x0 (0x0) +__uint 0xfc18 >= 0xfffe == 0x0 (0x0) +char 0x18 >= 0xfffe == 0x1 (0x1) +__uchar 0x18 >= 0xfe == 0x0 (0x0) +__longlong 0xfc18 >= 0xfffe == 0x0 (0x0) +__ulonglong 0xfc18 >= 0xfffe == 0x0 (0x0) +float 0xfc18 >= 0xfffe == 0x0 (0x0) +int 0xfc18 / 0xfffe == 0x1f4 (0x1f4) +__uint 0xfc18 / 0xfffe == 0x0 (0x0) +char 0x18 / 0xfffe == -0xc (0xfff4) +__uchar 0x18 / 0xfe == 0x0 (0x0) +__longlong 0xfc18 / 0xfffe == 0x1f4 (0x1f4) +__ulonglong 0xfc18 / 0xfffe == 0x0 (0x0) +float 0xfc18 / 0xfffe == 0x1f4 (0x1f4) +int 0xfc18 % 0xfffe == 0x0 (0x0) +__uint 0xfc18 % 0xfffe == -0x3e8 (0xfc18) +char 0x18 % 0xfffe == 0x0 (0x0) +__uchar 0x18 % 0xfe == 0x18 (0x18) +__longlong 0xfc18 % 0xfffe == 0x0 (0x0) +__ulonglong 0xfc18 % 0xfffe == -0x3e8 (0xfc18) +0xfc18 * 0x4 == -0xfa0 +0xfc18 / 0x4 == -0xfa +0xfc18 % 0x4 == 0x0 +int 0xfc18 ^ 0x4 == -0x3e4 (0xfc1c) +__uint 0xfc18 ^ 0x4 == -0x3e4 (0xfc1c) +char 0x18 ^ 0x4 == 0x1c (0x1c) +__uchar 0x18 ^ 0x4 == 0x1c (0x1c) +__longlong 0xfc18 ^ 0x4 == -0x3e4 (0xfc1c) +__ulonglong 0xfc18 ^ 0x4 == -0x3e4 (0xfc1c) +int 0xfc18 && 0x4 == 0x1 (0x1) +__uint 0xfc18 && 0x4 == 0x1 (0x1) +char 0x18 && 0x4 == 0x1 (0x1) +__uchar 0x18 && 0x4 == 0x1 (0x1) +__longlong 0xfc18 && 0x4 == 0x1 (0x1) +__ulonglong 0xfc18 && 0x4 == 0x1 (0x1) +int 0xfc18 || 0x4 == 0x1 (0x1) +__uint 0xfc18 || 0x4 == 0x1 (0x1) +char 0x18 || 0x4 == 0x1 (0x1) +__uchar 0x18 || 0x4 == 0x1 (0x1) +__longlong 0xfc18 || 0x4 == 0x1 (0x1) +__ulonglong 0xfc18 || 0x4 == 0x1 (0x1) +int 0xfc18 & 0x4 == 0x0 (0x0) +__uint 0xfc18 & 0x4 == 0x0 (0x0) +char 0x18 & 0x4 == 0x0 (0x0) +__uchar 0x18 & 0x4 == 0x0 (0x0) +__longlong 0xfc18 & 0x4 == 0x0 (0x0) +__ulonglong 0xfc18 & 0x4 == 0x0 (0x0) +int 0xfc18 | 0x4 == -0x3e4 (0xfc1c) +__uint 0xfc18 | 0x4 == -0x3e4 (0xfc1c) +char 0x18 | 0x4 == 0x1c (0x1c) +__uchar 0x18 | 0x4 == 0x1c (0x1c) +__longlong 0xfc18 | 0x4 == -0x3e4 (0xfc1c) +__ulonglong 0xfc18 | 0x4 == -0x3e4 (0xfc1c) +int 0xfc18 << 0x5 == -0x7d00 (0x8300) +__uint 0xfc18 << 0x5 == -0x7d00 (0x8300) +char 0x18 << 0x5 == 0x0 (0x0) +__uchar 0x18 << 0x5 == 0x0 (0x0) +__longlong 0xfc18 << 0x5 == -0x7d00 (0x8300) +__ulonglong 0xfc18 << 0x5 == -0x7d00 (0x8300) +int 0xfc18 >> 0x5 == -0x20 (0xffe0) +__uint 0xfc18 >> 0x5 == 0x7e0 (0x7e0) +char 0x18 >> 0x5 == 0x0 (0x0) +__uchar 0x18 >> 0x5 == 0x0 (0x0) +__longlong 0xfc18 >> 0x5 == -0x20 (0xffe0) +__ulonglong 0xfc18 >> 0x5 == -0x20 (0xffe0) +int 0xfc18 + 0x4 == -0x3e4 (0xfc1c) +__uint 0xfc18 + 0x4 == -0x3e4 (0xfc1c) +char 0x18 + 0x4 == 0x1c (0x1c) +__uchar 0x18 + 0x4 == 0x1c (0x1c) +__longlong 0xfc18 + 0x4 == -0x3e4 (0xfc1c) +__ulonglong 0xfc18 + 0x4 == -0x3e4 (0xfc1c) +float 0xfc18 + 0x4 == -0x3e4 (0xfc1c) +int 0xfc18 - 0x4 == -0x3ec (0xfc14) +__uint 0xfc18 - 0x4 == -0x3ec (0xfc14) +char 0x18 - 0x4 == 0x14 (0x14) +__uchar 0x18 - 0x4 == 0x14 (0x14) +__longlong 0xfc18 - 0x4 == -0x3ec (0xfc14) +__ulonglong 0xfc18 - 0x4 == -0x3ec (0xfc14) +float 0xfc18 - 0x4 == -0x3ec (0xfc14) +int 0xfc18 * 0x4 == -0xfa0 (0xf060) +__uint 0xfc18 * 0x4 == -0xfa0 (0xf060) +char 0x18 * 0x4 == 0x60 (0x60) +__uchar 0x18 * 0x4 == 0x60 (0x60) +__longlong 0xfc18 * 0x4 == -0xfa0 (0xf060) +__ulonglong 0xfc18 * 0x4 == -0xfa0 (0xf060) +float 0xfc18 * 0x4 == -0xfa0 (0xf060) +int 0xfc18 < 0x4 == 0x1 (0x1) +__uint 0xfc18 < 0x4 == 0x0 (0x0) +char 0x18 < 0x4 == 0x0 (0x0) +__uchar 0x18 < 0x4 == 0x0 (0x0) +__longlong 0xfc18 < 0x4 == 0x1 (0x1) +__ulonglong 0xfc18 < 0x4 == 0x0 (0x0) +float 0xfc18 < 0x4 == 0x1 (0x1) +int 0xfc18 > 0x4 == 0x0 (0x0) +__uint 0xfc18 > 0x4 == 0x1 (0x1) +char 0x18 > 0x4 == 0x1 (0x1) +__uchar 0x18 > 0x4 == 0x1 (0x1) +__longlong 0xfc18 > 0x4 == 0x0 (0x0) +__ulonglong 0xfc18 > 0x4 == 0x1 (0x1) +float 0xfc18 > 0x4 == 0x0 (0x0) +int 0xfc18 <= 0x4 == 0x1 (0x1) +__uint 0xfc18 <= 0x4 == 0x0 (0x0) +char 0x18 <= 0x4 == 0x0 (0x0) +__uchar 0x18 <= 0x4 == 0x0 (0x0) +__longlong 0xfc18 <= 0x4 == 0x1 (0x1) +__ulonglong 0xfc18 <= 0x4 == 0x0 (0x0) +float 0xfc18 <= 0x4 == 0x1 (0x1) +int 0xfc18 == 0x4 == 0x0 (0x0) +__uint 0xfc18 == 0x4 == 0x0 (0x0) +char 0x18 == 0x4 == 0x0 (0x0) +__uchar 0x18 == 0x4 == 0x0 (0x0) +__longlong 0xfc18 == 0x4 == 0x0 (0x0) +__ulonglong 0xfc18 == 0x4 == 0x0 (0x0) +float 0xfc18 == 0x4 == 0x0 (0x0) +int 0xfc18 != 0x4 == 0x1 (0x1) +__uint 0xfc18 != 0x4 == 0x1 (0x1) +char 0x18 != 0x4 == 0x1 (0x1) +__uchar 0x18 != 0x4 == 0x1 (0x1) +__longlong 0xfc18 != 0x4 == 0x1 (0x1) +__ulonglong 0xfc18 != 0x4 == 0x1 (0x1) +float 0xfc18 != 0x4 == 0x1 (0x1) +int 0xfc18 >= 0x4 == 0x0 (0x0) +__uint 0xfc18 >= 0x4 == 0x1 (0x1) +char 0x18 >= 0x4 == 0x1 (0x1) +__uchar 0x18 >= 0x4 == 0x1 (0x1) +__longlong 0xfc18 >= 0x4 == 0x0 (0x0) +__ulonglong 0xfc18 >= 0x4 == 0x1 (0x1) +float 0xfc18 >= 0x4 == 0x0 (0x0) +int 0xfc18 / 0x4 == -0xfa (0xff06) +__uint 0xfc18 / 0x4 == 0x3f06 (0x3f06) +char 0x18 / 0x4 == 0x6 (0x6) +__uchar 0x18 / 0x4 == 0x6 (0x6) +__longlong 0xfc18 / 0x4 == -0xfa (0xff06) +__ulonglong 0xfc18 / 0x4 == -0xfa (0xff06) +float 0xfc18 / 0x4 == -0xfa (0xff06) +int 0xfc18 % 0x4 == 0x0 (0x0) +__uint 0xfc18 % 0x4 == 0x0 (0x0) +char 0x18 % 0x4 == 0x0 (0x0) +__uchar 0x18 % 0x4 == 0x0 (0x0) +__longlong 0xfc18 % 0x4 == 0x0 (0x0) +__ulonglong 0xfc18 % 0x4 == 0x0 (0x0) +0xfc18 * 0xfffc == 0xfa0 +0xfc18 / 0xfffc == 0xfa +0xfc18 % 0xfffc == 0x0 +int 0xfc18 ^ 0xfffc == 0x3e4 (0x3e4) +__uint 0xfc18 ^ 0xfffc == 0x3e4 (0x3e4) +char 0x18 ^ 0xfffc == -0x1c (0xffe4) +__uchar 0x18 ^ 0xfc == 0xe4 (0xe4) +__longlong 0xfc18 ^ 0xfffc == 0x3e4 (0x3e4) +__ulonglong 0xfc18 ^ 0xfffc == 0x3e4 (0x3e4) +int 0xfc18 && 0xfffc == 0x1 (0x1) +__uint 0xfc18 && 0xfffc == 0x1 (0x1) +char 0x18 && 0xfffc == 0x1 (0x1) +__uchar 0x18 && 0xfc == 0x1 (0x1) +__longlong 0xfc18 && 0xfffc == 0x1 (0x1) +__ulonglong 0xfc18 && 0xfffc == 0x1 (0x1) +int 0xfc18 || 0xfffc == 0x1 (0x1) +__uint 0xfc18 || 0xfffc == 0x1 (0x1) +char 0x18 || 0xfffc == 0x1 (0x1) +__uchar 0x18 || 0xfc == 0x1 (0x1) +__longlong 0xfc18 || 0xfffc == 0x1 (0x1) +__ulonglong 0xfc18 || 0xfffc == 0x1 (0x1) +int 0xfc18 & 0xfffc == -0x3e8 (0xfc18) +__uint 0xfc18 & 0xfffc == -0x3e8 (0xfc18) +char 0x18 & 0xfffc == 0x18 (0x18) +__uchar 0x18 & 0xfc == 0x18 (0x18) +__longlong 0xfc18 & 0xfffc == -0x3e8 (0xfc18) +__ulonglong 0xfc18 & 0xfffc == -0x3e8 (0xfc18) +int 0xfc18 | 0xfffc == -0x4 (0xfffc) +__uint 0xfc18 | 0xfffc == -0x4 (0xfffc) +char 0x18 | 0xfffc == -0x4 (0xfffc) +__uchar 0x18 | 0xfc == 0xfc (0xfc) +__longlong 0xfc18 | 0xfffc == -0x4 (0xfffc) +__ulonglong 0xfc18 | 0xfffc == -0x4 (0xfffc) +int 0xfc18 << 0x6 == 0x600 (0x600) +__uint 0xfc18 << 0x6 == 0x600 (0x600) +char 0x18 << 0x6 == 0x0 (0x0) +__uchar 0x18 << 0x6 == 0x0 (0x0) +__longlong 0xfc18 << 0x6 == 0x600 (0x600) +__ulonglong 0xfc18 << 0x6 == 0x600 (0x600) +int 0xfc18 >> 0x6 == -0x10 (0xfff0) +__uint 0xfc18 >> 0x6 == 0x3f0 (0x3f0) +char 0x18 >> 0x6 == 0x0 (0x0) +__uchar 0x18 >> 0x6 == 0x0 (0x0) +__longlong 0xfc18 >> 0x6 == -0x10 (0xfff0) +__ulonglong 0xfc18 >> 0x6 == -0x10 (0xfff0) +int 0xfc18 + 0xfffc == -0x3ec (0xfc14) +__uint 0xfc18 + 0xfffc == -0x3ec (0xfc14) +char 0x18 + 0xfffc == 0x14 (0x14) +__uchar 0x18 + 0xfc == 0x14 (0x14) +__longlong 0xfc18 + 0xfffc == -0x3ec (0xfc14) +__ulonglong 0xfc18 + 0xfffc == -0x3ec (0xfc14) +float 0xfc18 + 0xfffc == -0x3ec (0xfc14) +int 0xfc18 - 0xfffc == -0x3e4 (0xfc1c) +__uint 0xfc18 - 0xfffc == -0x3e4 (0xfc1c) +char 0x18 - 0xfffc == 0x1c (0x1c) +__uchar 0x18 - 0xfc == 0x1c (0x1c) +__longlong 0xfc18 - 0xfffc == -0x3e4 (0xfc1c) +__ulonglong 0xfc18 - 0xfffc == -0x3e4 (0xfc1c) +float 0xfc18 - 0xfffc == -0x3e4 (0xfc1c) +int 0xfc18 * 0xfffc == 0xfa0 (0xfa0) +__uint 0xfc18 * 0xfffc == 0xfa0 (0xfa0) +char 0x18 * 0xfffc == -0x60 (0xffa0) +__uchar 0x18 * 0xfc == 0xa0 (0xa0) +__longlong 0xfc18 * 0xfffc == 0xfa0 (0xfa0) +__ulonglong 0xfc18 * 0xfffc == 0xfa0 (0xfa0) +float 0xfc18 * 0xfffc == 0xfa0 (0xfa0) +int 0xfc18 < 0xfffc == 0x1 (0x1) +__uint 0xfc18 < 0xfffc == 0x1 (0x1) +char 0x18 < 0xfffc == 0x0 (0x0) +__uchar 0x18 < 0xfc == 0x1 (0x1) +__longlong 0xfc18 < 0xfffc == 0x1 (0x1) +__ulonglong 0xfc18 < 0xfffc == 0x1 (0x1) +float 0xfc18 < 0xfffc == 0x1 (0x1) +int 0xfc18 > 0xfffc == 0x0 (0x0) +__uint 0xfc18 > 0xfffc == 0x0 (0x0) +char 0x18 > 0xfffc == 0x1 (0x1) +__uchar 0x18 > 0xfc == 0x0 (0x0) +__longlong 0xfc18 > 0xfffc == 0x0 (0x0) +__ulonglong 0xfc18 > 0xfffc == 0x0 (0x0) +float 0xfc18 > 0xfffc == 0x0 (0x0) +int 0xfc18 <= 0xfffc == 0x1 (0x1) +__uint 0xfc18 <= 0xfffc == 0x1 (0x1) +char 0x18 <= 0xfffc == 0x0 (0x0) +__uchar 0x18 <= 0xfc == 0x1 (0x1) +__longlong 0xfc18 <= 0xfffc == 0x1 (0x1) +__ulonglong 0xfc18 <= 0xfffc == 0x1 (0x1) +float 0xfc18 <= 0xfffc == 0x1 (0x1) +int 0xfc18 == 0xfffc == 0x0 (0x0) +__uint 0xfc18 == 0xfffc == 0x0 (0x0) +char 0x18 == 0xfffc == 0x0 (0x0) +__uchar 0x18 == 0xfc == 0x0 (0x0) +__longlong 0xfc18 == 0xfffc == 0x0 (0x0) +__ulonglong 0xfc18 == 0xfffc == 0x0 (0x0) +float 0xfc18 == 0xfffc == 0x0 (0x0) +int 0xfc18 != 0xfffc == 0x1 (0x1) +__uint 0xfc18 != 0xfffc == 0x1 (0x1) +char 0x18 != 0xfffc == 0x1 (0x1) +__uchar 0x18 != 0xfc == 0x1 (0x1) +__longlong 0xfc18 != 0xfffc == 0x1 (0x1) +__ulonglong 0xfc18 != 0xfffc == 0x1 (0x1) +float 0xfc18 != 0xfffc == 0x1 (0x1) +int 0xfc18 >= 0xfffc == 0x0 (0x0) +__uint 0xfc18 >= 0xfffc == 0x0 (0x0) +char 0x18 >= 0xfffc == 0x1 (0x1) +__uchar 0x18 >= 0xfc == 0x0 (0x0) +__longlong 0xfc18 >= 0xfffc == 0x0 (0x0) +__ulonglong 0xfc18 >= 0xfffc == 0x0 (0x0) +float 0xfc18 >= 0xfffc == 0x0 (0x0) +int 0xfc18 / 0xfffc == 0xfa (0xfa) +__uint 0xfc18 / 0xfffc == 0x0 (0x0) +char 0x18 / 0xfffc == -0x6 (0xfffa) +__uchar 0x18 / 0xfc == 0x0 (0x0) +__longlong 0xfc18 / 0xfffc == 0xfa (0xfa) +__ulonglong 0xfc18 / 0xfffc == 0x0 (0x0) +float 0xfc18 / 0xfffc == 0xfa (0xfa) +int 0xfc18 % 0xfffc == 0x0 (0x0) +__uint 0xfc18 % 0xfffc == -0x3e8 (0xfc18) +char 0x18 % 0xfffc == 0x0 (0x0) +__uchar 0x18 % 0xfc == 0x18 (0x18) +__longlong 0xfc18 % 0xfffc == 0x0 (0x0) +__ulonglong 0xfc18 % 0xfffc == -0x3e8 (0xfc18) +0xfc18 * 0xa == -0x2710 +0xfc18 / 0xa == -0x64 +0xfc18 % 0xa == 0x0 +int 0xfc18 ^ 0xa == -0x3ee (0xfc12) +__uint 0xfc18 ^ 0xa == -0x3ee (0xfc12) +char 0x18 ^ 0xa == 0x12 (0x12) +__uchar 0x18 ^ 0xa == 0x12 (0x12) +__longlong 0xfc18 ^ 0xa == -0x3ee (0xfc12) +__ulonglong 0xfc18 ^ 0xa == -0x3ee (0xfc12) +int 0xfc18 && 0xa == 0x1 (0x1) +__uint 0xfc18 && 0xa == 0x1 (0x1) +char 0x18 && 0xa == 0x1 (0x1) +__uchar 0x18 && 0xa == 0x1 (0x1) +__longlong 0xfc18 && 0xa == 0x1 (0x1) +__ulonglong 0xfc18 && 0xa == 0x1 (0x1) +int 0xfc18 || 0xa == 0x1 (0x1) +__uint 0xfc18 || 0xa == 0x1 (0x1) +char 0x18 || 0xa == 0x1 (0x1) +__uchar 0x18 || 0xa == 0x1 (0x1) +__longlong 0xfc18 || 0xa == 0x1 (0x1) +__ulonglong 0xfc18 || 0xa == 0x1 (0x1) +int 0xfc18 & 0xa == 0x8 (0x8) +__uint 0xfc18 & 0xa == 0x8 (0x8) +char 0x18 & 0xa == 0x8 (0x8) +__uchar 0x18 & 0xa == 0x8 (0x8) +__longlong 0xfc18 & 0xa == 0x8 (0x8) +__ulonglong 0xfc18 & 0xa == 0x8 (0x8) +int 0xfc18 | 0xa == -0x3e6 (0xfc1a) +__uint 0xfc18 | 0xa == -0x3e6 (0xfc1a) +char 0x18 | 0xa == 0x1a (0x1a) +__uchar 0x18 | 0xa == 0x1a (0x1a) +__longlong 0xfc18 | 0xa == -0x3e6 (0xfc1a) +__ulonglong 0xfc18 | 0xa == -0x3e6 (0xfc1a) +int 0xfc18 << 0x7 == 0xc00 (0xc00) +__uint 0xfc18 << 0x7 == 0xc00 (0xc00) +char 0x18 << 0x7 == 0x0 (0x0) +__uchar 0x18 << 0x7 == 0x0 (0x0) +__longlong 0xfc18 << 0x7 == 0xc00 (0xc00) +__ulonglong 0xfc18 << 0x7 == 0xc00 (0xc00) +int 0xfc18 >> 0x7 == -0x8 (0xfff8) +__uint 0xfc18 >> 0x7 == 0x1f8 (0x1f8) +char 0x18 >> 0x7 == 0x0 (0x0) +__uchar 0x18 >> 0x7 == 0x0 (0x0) +__longlong 0xfc18 >> 0x7 == -0x8 (0xfff8) +__ulonglong 0xfc18 >> 0x7 == -0x8 (0xfff8) +int 0xfc18 + 0xa == -0x3de (0xfc22) +__uint 0xfc18 + 0xa == -0x3de (0xfc22) +char 0x18 + 0xa == 0x22 (0x22) +__uchar 0x18 + 0xa == 0x22 (0x22) +__longlong 0xfc18 + 0xa == -0x3de (0xfc22) +__ulonglong 0xfc18 + 0xa == -0x3de (0xfc22) +float 0xfc18 + 0xa == -0x3de (0xfc22) +int 0xfc18 - 0xa == -0x3f2 (0xfc0e) +__uint 0xfc18 - 0xa == -0x3f2 (0xfc0e) +char 0x18 - 0xa == 0xe (0xe) +__uchar 0x18 - 0xa == 0xe (0xe) +__longlong 0xfc18 - 0xa == -0x3f2 (0xfc0e) +__ulonglong 0xfc18 - 0xa == -0x3f2 (0xfc0e) +float 0xfc18 - 0xa == -0x3f2 (0xfc0e) +int 0xfc18 * 0xa == -0x2710 (0xd8f0) +__uint 0xfc18 * 0xa == -0x2710 (0xd8f0) +char 0x18 * 0xa == -0x10 (0xfff0) +__uchar 0x18 * 0xa == 0xf0 (0xf0) +__longlong 0xfc18 * 0xa == -0x2710 (0xd8f0) +__ulonglong 0xfc18 * 0xa == -0x2710 (0xd8f0) +float 0xfc18 * 0xa == -0x2710 (0xd8f0) +int 0xfc18 < 0xa == 0x1 (0x1) +__uint 0xfc18 < 0xa == 0x0 (0x0) +char 0x18 < 0xa == 0x0 (0x0) +__uchar 0x18 < 0xa == 0x0 (0x0) +__longlong 0xfc18 < 0xa == 0x1 (0x1) +__ulonglong 0xfc18 < 0xa == 0x0 (0x0) +float 0xfc18 < 0xa == 0x1 (0x1) +int 0xfc18 > 0xa == 0x0 (0x0) +__uint 0xfc18 > 0xa == 0x1 (0x1) +char 0x18 > 0xa == 0x1 (0x1) +__uchar 0x18 > 0xa == 0x1 (0x1) +__longlong 0xfc18 > 0xa == 0x0 (0x0) +__ulonglong 0xfc18 > 0xa == 0x1 (0x1) +float 0xfc18 > 0xa == 0x0 (0x0) +int 0xfc18 <= 0xa == 0x1 (0x1) +__uint 0xfc18 <= 0xa == 0x0 (0x0) +char 0x18 <= 0xa == 0x0 (0x0) +__uchar 0x18 <= 0xa == 0x0 (0x0) +__longlong 0xfc18 <= 0xa == 0x1 (0x1) +__ulonglong 0xfc18 <= 0xa == 0x0 (0x0) +float 0xfc18 <= 0xa == 0x1 (0x1) +int 0xfc18 == 0xa == 0x0 (0x0) +__uint 0xfc18 == 0xa == 0x0 (0x0) +char 0x18 == 0xa == 0x0 (0x0) +__uchar 0x18 == 0xa == 0x0 (0x0) +__longlong 0xfc18 == 0xa == 0x0 (0x0) +__ulonglong 0xfc18 == 0xa == 0x0 (0x0) +float 0xfc18 == 0xa == 0x0 (0x0) +int 0xfc18 != 0xa == 0x1 (0x1) +__uint 0xfc18 != 0xa == 0x1 (0x1) +char 0x18 != 0xa == 0x1 (0x1) +__uchar 0x18 != 0xa == 0x1 (0x1) +__longlong 0xfc18 != 0xa == 0x1 (0x1) +__ulonglong 0xfc18 != 0xa == 0x1 (0x1) +float 0xfc18 != 0xa == 0x1 (0x1) +int 0xfc18 >= 0xa == 0x0 (0x0) +__uint 0xfc18 >= 0xa == 0x1 (0x1) +char 0x18 >= 0xa == 0x1 (0x1) +__uchar 0x18 >= 0xa == 0x1 (0x1) +__longlong 0xfc18 >= 0xa == 0x0 (0x0) +__ulonglong 0xfc18 >= 0xa == 0x1 (0x1) +float 0xfc18 >= 0xa == 0x0 (0x0) +int 0xfc18 / 0xa == -0x64 (0xff9c) +__uint 0xfc18 / 0xa == 0x1935 (0x1935) +char 0x18 / 0xa == 0x2 (0x2) +__uchar 0x18 / 0xa == 0x2 (0x2) +__longlong 0xfc18 / 0xa == -0x64 (0xff9c) +__ulonglong 0xfc18 / 0xa == -0x66cb (0x9935) +float 0xfc18 / 0xa == -0x64 (0xff9c) +int 0xfc18 % 0xa == 0x0 (0x0) +__uint 0xfc18 % 0xa == 0x6 (0x6) +char 0x18 % 0xa == 0x4 (0x4) +__uchar 0x18 % 0xa == 0x4 (0x4) +__longlong 0xfc18 % 0xa == 0x0 (0x0) +__ulonglong 0xfc18 % 0xa == 0x6 (0x6) +0xfc18 * 0xfff6 == 0x2710 +0xfc18 / 0xfff6 == 0x64 +0xfc18 % 0xfff6 == 0x0 +int 0xfc18 ^ 0xfff6 == 0x3ee (0x3ee) +__uint 0xfc18 ^ 0xfff6 == 0x3ee (0x3ee) +char 0x18 ^ 0xfff6 == -0x12 (0xffee) +__uchar 0x18 ^ 0xf6 == 0xee (0xee) +__longlong 0xfc18 ^ 0xfff6 == 0x3ee (0x3ee) +__ulonglong 0xfc18 ^ 0xfff6 == 0x3ee (0x3ee) +int 0xfc18 && 0xfff6 == 0x1 (0x1) +__uint 0xfc18 && 0xfff6 == 0x1 (0x1) +char 0x18 && 0xfff6 == 0x1 (0x1) +__uchar 0x18 && 0xf6 == 0x1 (0x1) +__longlong 0xfc18 && 0xfff6 == 0x1 (0x1) +__ulonglong 0xfc18 && 0xfff6 == 0x1 (0x1) +int 0xfc18 || 0xfff6 == 0x1 (0x1) +__uint 0xfc18 || 0xfff6 == 0x1 (0x1) +char 0x18 || 0xfff6 == 0x1 (0x1) +__uchar 0x18 || 0xf6 == 0x1 (0x1) +__longlong 0xfc18 || 0xfff6 == 0x1 (0x1) +__ulonglong 0xfc18 || 0xfff6 == 0x1 (0x1) +int 0xfc18 & 0xfff6 == -0x3f0 (0xfc10) +__uint 0xfc18 & 0xfff6 == -0x3f0 (0xfc10) +char 0x18 & 0xfff6 == 0x10 (0x10) +__uchar 0x18 & 0xf6 == 0x10 (0x10) +__longlong 0xfc18 & 0xfff6 == -0x3f0 (0xfc10) +__ulonglong 0xfc18 & 0xfff6 == -0x3f0 (0xfc10) +int 0xfc18 | 0xfff6 == -0x2 (0xfffe) +__uint 0xfc18 | 0xfff6 == -0x2 (0xfffe) +char 0x18 | 0xfff6 == -0x2 (0xfffe) +__uchar 0x18 | 0xf6 == 0xfe (0xfe) +__longlong 0xfc18 | 0xfff6 == -0x2 (0xfffe) +__ulonglong 0xfc18 | 0xfff6 == -0x2 (0xfffe) +int 0xfc18 << 0x8 == 0x1800 (0x1800) +__uint 0xfc18 << 0x8 == 0x1800 (0x1800) +char 0x18 << 0x8 == 0x0 (0x0) +__uchar 0x18 << 0x8 == 0x0 (0x0) +__longlong 0xfc18 << 0x8 == 0x1800 (0x1800) +__ulonglong 0xfc18 << 0x8 == 0x1800 (0x1800) +int 0xfc18 >> 0x8 == -0x4 (0xfffc) +__uint 0xfc18 >> 0x8 == 0xfc (0xfc) +char 0x18 >> 0x8 == 0x0 (0x0) +__uchar 0x18 >> 0x8 == 0x0 (0x0) +__longlong 0xfc18 >> 0x8 == -0x4 (0xfffc) +__ulonglong 0xfc18 >> 0x8 == -0x4 (0xfffc) +int 0xfc18 + 0xfff6 == -0x3f2 (0xfc0e) +__uint 0xfc18 + 0xfff6 == -0x3f2 (0xfc0e) +char 0x18 + 0xfff6 == 0xe (0xe) +__uchar 0x18 + 0xf6 == 0xe (0xe) +__longlong 0xfc18 + 0xfff6 == -0x3f2 (0xfc0e) +__ulonglong 0xfc18 + 0xfff6 == -0x3f2 (0xfc0e) +float 0xfc18 + 0xfff6 == -0x3f2 (0xfc0e) +int 0xfc18 - 0xfff6 == -0x3de (0xfc22) +__uint 0xfc18 - 0xfff6 == -0x3de (0xfc22) +char 0x18 - 0xfff6 == 0x22 (0x22) +__uchar 0x18 - 0xf6 == 0x22 (0x22) +__longlong 0xfc18 - 0xfff6 == -0x3de (0xfc22) +__ulonglong 0xfc18 - 0xfff6 == -0x3de (0xfc22) +float 0xfc18 - 0xfff6 == -0x3de (0xfc22) +int 0xfc18 * 0xfff6 == 0x2710 (0x2710) +__uint 0xfc18 * 0xfff6 == 0x2710 (0x2710) +char 0x18 * 0xfff6 == 0x10 (0x10) +__uchar 0x18 * 0xf6 == 0x10 (0x10) +__longlong 0xfc18 * 0xfff6 == 0x2710 (0x2710) +__ulonglong 0xfc18 * 0xfff6 == 0x2710 (0x2710) +float 0xfc18 * 0xfff6 == 0x2710 (0x2710) +int 0xfc18 < 0xfff6 == 0x1 (0x1) +__uint 0xfc18 < 0xfff6 == 0x1 (0x1) +char 0x18 < 0xfff6 == 0x0 (0x0) +__uchar 0x18 < 0xf6 == 0x1 (0x1) +__longlong 0xfc18 < 0xfff6 == 0x1 (0x1) +__ulonglong 0xfc18 < 0xfff6 == 0x1 (0x1) +float 0xfc18 < 0xfff6 == 0x1 (0x1) +int 0xfc18 > 0xfff6 == 0x0 (0x0) +__uint 0xfc18 > 0xfff6 == 0x0 (0x0) +char 0x18 > 0xfff6 == 0x1 (0x1) +__uchar 0x18 > 0xf6 == 0x0 (0x0) +__longlong 0xfc18 > 0xfff6 == 0x0 (0x0) +__ulonglong 0xfc18 > 0xfff6 == 0x0 (0x0) +float 0xfc18 > 0xfff6 == 0x0 (0x0) +int 0xfc18 <= 0xfff6 == 0x1 (0x1) +__uint 0xfc18 <= 0xfff6 == 0x1 (0x1) +char 0x18 <= 0xfff6 == 0x0 (0x0) +__uchar 0x18 <= 0xf6 == 0x1 (0x1) +__longlong 0xfc18 <= 0xfff6 == 0x1 (0x1) +__ulonglong 0xfc18 <= 0xfff6 == 0x1 (0x1) +float 0xfc18 <= 0xfff6 == 0x1 (0x1) +int 0xfc18 == 0xfff6 == 0x0 (0x0) +__uint 0xfc18 == 0xfff6 == 0x0 (0x0) +char 0x18 == 0xfff6 == 0x0 (0x0) +__uchar 0x18 == 0xf6 == 0x0 (0x0) +__longlong 0xfc18 == 0xfff6 == 0x0 (0x0) +__ulonglong 0xfc18 == 0xfff6 == 0x0 (0x0) +float 0xfc18 == 0xfff6 == 0x0 (0x0) +int 0xfc18 != 0xfff6 == 0x1 (0x1) +__uint 0xfc18 != 0xfff6 == 0x1 (0x1) +char 0x18 != 0xfff6 == 0x1 (0x1) +__uchar 0x18 != 0xf6 == 0x1 (0x1) +__longlong 0xfc18 != 0xfff6 == 0x1 (0x1) +__ulonglong 0xfc18 != 0xfff6 == 0x1 (0x1) +float 0xfc18 != 0xfff6 == 0x1 (0x1) +int 0xfc18 >= 0xfff6 == 0x0 (0x0) +__uint 0xfc18 >= 0xfff6 == 0x0 (0x0) +char 0x18 >= 0xfff6 == 0x1 (0x1) +__uchar 0x18 >= 0xf6 == 0x0 (0x0) +__longlong 0xfc18 >= 0xfff6 == 0x0 (0x0) +__ulonglong 0xfc18 >= 0xfff6 == 0x0 (0x0) +float 0xfc18 >= 0xfff6 == 0x0 (0x0) +int 0xfc18 / 0xfff6 == 0x64 (0x64) +__uint 0xfc18 / 0xfff6 == 0x0 (0x0) +char 0x18 / 0xfff6 == -0x2 (0xfffe) +__uchar 0x18 / 0xf6 == 0x0 (0x0) +__longlong 0xfc18 / 0xfff6 == 0x64 (0x64) +__ulonglong 0xfc18 / 0xfff6 == 0x0 (0x0) +float 0xfc18 / 0xfff6 == 0x64 (0x64) +int 0xfc18 % 0xfff6 == 0x0 (0x0) +__uint 0xfc18 % 0xfff6 == -0x3e8 (0xfc18) +char 0x18 % 0xfff6 == 0x4 (0x4) +__uchar 0x18 % 0xf6 == 0x18 (0x18) +__longlong 0xfc18 % 0xfff6 == 0x0 (0x0) +__ulonglong 0xfc18 % 0xfff6 == -0x3e8 (0xfc18) +0xfc18 * 0x5 == -0x1388 +0xfc18 / 0x5 == -0xc8 +0xfc18 % 0x5 == 0x0 +int 0xfc18 ^ 0x5 == -0x3e3 (0xfc1d) +__uint 0xfc18 ^ 0x5 == -0x3e3 (0xfc1d) +char 0x18 ^ 0x5 == 0x1d (0x1d) +__uchar 0x18 ^ 0x5 == 0x1d (0x1d) +__longlong 0xfc18 ^ 0x5 == -0x3e3 (0xfc1d) +__ulonglong 0xfc18 ^ 0x5 == -0x3e3 (0xfc1d) +int 0xfc18 && 0x5 == 0x1 (0x1) +__uint 0xfc18 && 0x5 == 0x1 (0x1) +char 0x18 && 0x5 == 0x1 (0x1) +__uchar 0x18 && 0x5 == 0x1 (0x1) +__longlong 0xfc18 && 0x5 == 0x1 (0x1) +__ulonglong 0xfc18 && 0x5 == 0x1 (0x1) +int 0xfc18 || 0x5 == 0x1 (0x1) +__uint 0xfc18 || 0x5 == 0x1 (0x1) +char 0x18 || 0x5 == 0x1 (0x1) +__uchar 0x18 || 0x5 == 0x1 (0x1) +__longlong 0xfc18 || 0x5 == 0x1 (0x1) +__ulonglong 0xfc18 || 0x5 == 0x1 (0x1) +int 0xfc18 & 0x5 == 0x0 (0x0) +__uint 0xfc18 & 0x5 == 0x0 (0x0) +char 0x18 & 0x5 == 0x0 (0x0) +__uchar 0x18 & 0x5 == 0x0 (0x0) +__longlong 0xfc18 & 0x5 == 0x0 (0x0) +__ulonglong 0xfc18 & 0x5 == 0x0 (0x0) +int 0xfc18 | 0x5 == -0x3e3 (0xfc1d) +__uint 0xfc18 | 0x5 == -0x3e3 (0xfc1d) +char 0x18 | 0x5 == 0x1d (0x1d) +__uchar 0x18 | 0x5 == 0x1d (0x1d) +__longlong 0xfc18 | 0x5 == -0x3e3 (0xfc1d) +__ulonglong 0xfc18 | 0x5 == -0x3e3 (0xfc1d) +int 0xfc18 << 0x9 == 0x3000 (0x3000) +__uint 0xfc18 << 0x9 == 0x3000 (0x3000) +char 0x18 << 0x9 == 0x0 (0x0) +__uchar 0x18 << 0x9 == 0x0 (0x0) +__longlong 0xfc18 << 0x9 == 0x3000 (0x3000) +__ulonglong 0xfc18 << 0x9 == 0x3000 (0x3000) +int 0xfc18 >> 0x9 == -0x2 (0xfffe) +__uint 0xfc18 >> 0x9 == 0x7e (0x7e) +char 0x18 >> 0x9 == 0x0 (0x0) +__uchar 0x18 >> 0x9 == 0x0 (0x0) +__longlong 0xfc18 >> 0x9 == -0x2 (0xfffe) +__ulonglong 0xfc18 >> 0x9 == -0x2 (0xfffe) +int 0xfc18 + 0x5 == -0x3e3 (0xfc1d) +__uint 0xfc18 + 0x5 == -0x3e3 (0xfc1d) +char 0x18 + 0x5 == 0x1d (0x1d) +__uchar 0x18 + 0x5 == 0x1d (0x1d) +__longlong 0xfc18 + 0x5 == -0x3e3 (0xfc1d) +__ulonglong 0xfc18 + 0x5 == -0x3e3 (0xfc1d) +float 0xfc18 + 0x5 == -0x3e3 (0xfc1d) +int 0xfc18 - 0x5 == -0x3ed (0xfc13) +__uint 0xfc18 - 0x5 == -0x3ed (0xfc13) +char 0x18 - 0x5 == 0x13 (0x13) +__uchar 0x18 - 0x5 == 0x13 (0x13) +__longlong 0xfc18 - 0x5 == -0x3ed (0xfc13) +__ulonglong 0xfc18 - 0x5 == -0x3ed (0xfc13) +float 0xfc18 - 0x5 == -0x3ed (0xfc13) +int 0xfc18 * 0x5 == -0x1388 (0xec78) +__uint 0xfc18 * 0x5 == -0x1388 (0xec78) +char 0x18 * 0x5 == 0x78 (0x78) +__uchar 0x18 * 0x5 == 0x78 (0x78) +__longlong 0xfc18 * 0x5 == -0x1388 (0xec78) +__ulonglong 0xfc18 * 0x5 == -0x1388 (0xec78) +float 0xfc18 * 0x5 == -0x1388 (0xec78) +int 0xfc18 < 0x5 == 0x1 (0x1) +__uint 0xfc18 < 0x5 == 0x0 (0x0) +char 0x18 < 0x5 == 0x0 (0x0) +__uchar 0x18 < 0x5 == 0x0 (0x0) +__longlong 0xfc18 < 0x5 == 0x1 (0x1) +__ulonglong 0xfc18 < 0x5 == 0x0 (0x0) +float 0xfc18 < 0x5 == 0x1 (0x1) +int 0xfc18 > 0x5 == 0x0 (0x0) +__uint 0xfc18 > 0x5 == 0x1 (0x1) +char 0x18 > 0x5 == 0x1 (0x1) +__uchar 0x18 > 0x5 == 0x1 (0x1) +__longlong 0xfc18 > 0x5 == 0x0 (0x0) +__ulonglong 0xfc18 > 0x5 == 0x1 (0x1) +float 0xfc18 > 0x5 == 0x0 (0x0) +int 0xfc18 <= 0x5 == 0x1 (0x1) +__uint 0xfc18 <= 0x5 == 0x0 (0x0) +char 0x18 <= 0x5 == 0x0 (0x0) +__uchar 0x18 <= 0x5 == 0x0 (0x0) +__longlong 0xfc18 <= 0x5 == 0x1 (0x1) +__ulonglong 0xfc18 <= 0x5 == 0x0 (0x0) +float 0xfc18 <= 0x5 == 0x1 (0x1) +int 0xfc18 == 0x5 == 0x0 (0x0) +__uint 0xfc18 == 0x5 == 0x0 (0x0) +char 0x18 == 0x5 == 0x0 (0x0) +__uchar 0x18 == 0x5 == 0x0 (0x0) +__longlong 0xfc18 == 0x5 == 0x0 (0x0) +__ulonglong 0xfc18 == 0x5 == 0x0 (0x0) +float 0xfc18 == 0x5 == 0x0 (0x0) +int 0xfc18 != 0x5 == 0x1 (0x1) +__uint 0xfc18 != 0x5 == 0x1 (0x1) +char 0x18 != 0x5 == 0x1 (0x1) +__uchar 0x18 != 0x5 == 0x1 (0x1) +__longlong 0xfc18 != 0x5 == 0x1 (0x1) +__ulonglong 0xfc18 != 0x5 == 0x1 (0x1) +float 0xfc18 != 0x5 == 0x1 (0x1) +int 0xfc18 >= 0x5 == 0x0 (0x0) +__uint 0xfc18 >= 0x5 == 0x1 (0x1) +char 0x18 >= 0x5 == 0x1 (0x1) +__uchar 0x18 >= 0x5 == 0x1 (0x1) +__longlong 0xfc18 >= 0x5 == 0x0 (0x0) +__ulonglong 0xfc18 >= 0x5 == 0x1 (0x1) +float 0xfc18 >= 0x5 == 0x0 (0x0) +int 0xfc18 / 0x5 == -0xc8 (0xff38) +__uint 0xfc18 / 0x5 == 0x326b (0x326b) +char 0x18 / 0x5 == 0x4 (0x4) +__uchar 0x18 / 0x5 == 0x4 (0x4) +__longlong 0xfc18 / 0x5 == -0xc8 (0xff38) +__ulonglong 0xfc18 / 0x5 == 0x326b (0x326b) +float 0xfc18 / 0x5 == -0xc8 (0xff38) +int 0xfc18 % 0x5 == 0x0 (0x0) +__uint 0xfc18 % 0x5 == 0x1 (0x1) +char 0x18 % 0x5 == 0x4 (0x4) +__uchar 0x18 % 0x5 == 0x4 (0x4) +__longlong 0xfc18 % 0x5 == 0x0 (0x0) +__ulonglong 0xfc18 % 0x5 == 0x1 (0x1) +0xfc18 * 0x7 == -0x1b58 +0xfc18 / 0x7 == -0x8e +0xfc18 % 0x7 == -0x6 +int 0xfc18 ^ 0x7 == -0x3e1 (0xfc1f) +__uint 0xfc18 ^ 0x7 == -0x3e1 (0xfc1f) +char 0x18 ^ 0x7 == 0x1f (0x1f) +__uchar 0x18 ^ 0x7 == 0x1f (0x1f) +__longlong 0xfc18 ^ 0x7 == -0x3e1 (0xfc1f) +__ulonglong 0xfc18 ^ 0x7 == -0x3e1 (0xfc1f) +int 0xfc18 && 0x7 == 0x1 (0x1) +__uint 0xfc18 && 0x7 == 0x1 (0x1) +char 0x18 && 0x7 == 0x1 (0x1) +__uchar 0x18 && 0x7 == 0x1 (0x1) +__longlong 0xfc18 && 0x7 == 0x1 (0x1) +__ulonglong 0xfc18 && 0x7 == 0x1 (0x1) +int 0xfc18 || 0x7 == 0x1 (0x1) +__uint 0xfc18 || 0x7 == 0x1 (0x1) +char 0x18 || 0x7 == 0x1 (0x1) +__uchar 0x18 || 0x7 == 0x1 (0x1) +__longlong 0xfc18 || 0x7 == 0x1 (0x1) +__ulonglong 0xfc18 || 0x7 == 0x1 (0x1) +int 0xfc18 & 0x7 == 0x0 (0x0) +__uint 0xfc18 & 0x7 == 0x0 (0x0) +char 0x18 & 0x7 == 0x0 (0x0) +__uchar 0x18 & 0x7 == 0x0 (0x0) +__longlong 0xfc18 & 0x7 == 0x0 (0x0) +__ulonglong 0xfc18 & 0x7 == 0x0 (0x0) +int 0xfc18 | 0x7 == -0x3e1 (0xfc1f) +__uint 0xfc18 | 0x7 == -0x3e1 (0xfc1f) +char 0x18 | 0x7 == 0x1f (0x1f) +__uchar 0x18 | 0x7 == 0x1f (0x1f) +__longlong 0xfc18 | 0x7 == -0x3e1 (0xfc1f) +__ulonglong 0xfc18 | 0x7 == -0x3e1 (0xfc1f) +int 0xfc18 << 0xa == 0x6000 (0x6000) +__uint 0xfc18 << 0xa == 0x6000 (0x6000) +char 0x18 << 0xa == 0x0 (0x0) +__uchar 0x18 << 0xa == 0x0 (0x0) +__longlong 0xfc18 << 0xa == 0x6000 (0x6000) +__ulonglong 0xfc18 << 0xa == 0x6000 (0x6000) +int 0xfc18 >> 0xa == -0x1 (0xffff) +__uint 0xfc18 >> 0xa == 0x3f (0x3f) +char 0x18 >> 0xa == 0x0 (0x0) +__uchar 0x18 >> 0xa == 0x0 (0x0) +__longlong 0xfc18 >> 0xa == -0x1 (0xffff) +__ulonglong 0xfc18 >> 0xa == -0x1 (0xffff) +int 0xfc18 + 0x7 == -0x3e1 (0xfc1f) +__uint 0xfc18 + 0x7 == -0x3e1 (0xfc1f) +char 0x18 + 0x7 == 0x1f (0x1f) +__uchar 0x18 + 0x7 == 0x1f (0x1f) +__longlong 0xfc18 + 0x7 == -0x3e1 (0xfc1f) +__ulonglong 0xfc18 + 0x7 == -0x3e1 (0xfc1f) +float 0xfc18 + 0x7 == -0x3e1 (0xfc1f) +int 0xfc18 - 0x7 == -0x3ef (0xfc11) +__uint 0xfc18 - 0x7 == -0x3ef (0xfc11) +char 0x18 - 0x7 == 0x11 (0x11) +__uchar 0x18 - 0x7 == 0x11 (0x11) +__longlong 0xfc18 - 0x7 == -0x3ef (0xfc11) +__ulonglong 0xfc18 - 0x7 == -0x3ef (0xfc11) +float 0xfc18 - 0x7 == -0x3ef (0xfc11) +int 0xfc18 * 0x7 == -0x1b58 (0xe4a8) +__uint 0xfc18 * 0x7 == -0x1b58 (0xe4a8) +char 0x18 * 0x7 == -0x58 (0xffa8) +__uchar 0x18 * 0x7 == 0xa8 (0xa8) +__longlong 0xfc18 * 0x7 == -0x1b58 (0xe4a8) +__ulonglong 0xfc18 * 0x7 == -0x1b58 (0xe4a8) +float 0xfc18 * 0x7 == -0x1b58 (0xe4a8) +int 0xfc18 < 0x7 == 0x1 (0x1) +__uint 0xfc18 < 0x7 == 0x0 (0x0) +char 0x18 < 0x7 == 0x0 (0x0) +__uchar 0x18 < 0x7 == 0x0 (0x0) +__longlong 0xfc18 < 0x7 == 0x1 (0x1) +__ulonglong 0xfc18 < 0x7 == 0x0 (0x0) +float 0xfc18 < 0x7 == 0x1 (0x1) +int 0xfc18 > 0x7 == 0x0 (0x0) +__uint 0xfc18 > 0x7 == 0x1 (0x1) +char 0x18 > 0x7 == 0x1 (0x1) +__uchar 0x18 > 0x7 == 0x1 (0x1) +__longlong 0xfc18 > 0x7 == 0x0 (0x0) +__ulonglong 0xfc18 > 0x7 == 0x1 (0x1) +float 0xfc18 > 0x7 == 0x0 (0x0) +int 0xfc18 <= 0x7 == 0x1 (0x1) +__uint 0xfc18 <= 0x7 == 0x0 (0x0) +char 0x18 <= 0x7 == 0x0 (0x0) +__uchar 0x18 <= 0x7 == 0x0 (0x0) +__longlong 0xfc18 <= 0x7 == 0x1 (0x1) +__ulonglong 0xfc18 <= 0x7 == 0x0 (0x0) +float 0xfc18 <= 0x7 == 0x1 (0x1) +int 0xfc18 == 0x7 == 0x0 (0x0) +__uint 0xfc18 == 0x7 == 0x0 (0x0) +char 0x18 == 0x7 == 0x0 (0x0) +__uchar 0x18 == 0x7 == 0x0 (0x0) +__longlong 0xfc18 == 0x7 == 0x0 (0x0) +__ulonglong 0xfc18 == 0x7 == 0x0 (0x0) +float 0xfc18 == 0x7 == 0x0 (0x0) +int 0xfc18 != 0x7 == 0x1 (0x1) +__uint 0xfc18 != 0x7 == 0x1 (0x1) +char 0x18 != 0x7 == 0x1 (0x1) +__uchar 0x18 != 0x7 == 0x1 (0x1) +__longlong 0xfc18 != 0x7 == 0x1 (0x1) +__ulonglong 0xfc18 != 0x7 == 0x1 (0x1) +float 0xfc18 != 0x7 == 0x1 (0x1) +int 0xfc18 >= 0x7 == 0x0 (0x0) +__uint 0xfc18 >= 0x7 == 0x1 (0x1) +char 0x18 >= 0x7 == 0x1 (0x1) +__uchar 0x18 >= 0x7 == 0x1 (0x1) +__longlong 0xfc18 >= 0x7 == 0x0 (0x0) +__ulonglong 0xfc18 >= 0x7 == 0x1 (0x1) +float 0xfc18 >= 0x7 == 0x0 (0x0) +int 0xfc18 / 0x7 == -0x8e (0xff72) +__uint 0xfc18 / 0x7 == 0x2403 (0x2403) +char 0x18 / 0x7 == 0x3 (0x3) +__uchar 0x18 / 0x7 == 0x3 (0x3) +__longlong 0xfc18 / 0x7 == -0x8e (0xff72) +__ulonglong 0xfc18 / 0x7 == 0x4895 (0x4895) +float 0xfc18 / 0x7 == -0x8e (0xff72) +int 0xfc18 % 0x7 == -0x6 (0xfffa) +__uint 0xfc18 % 0x7 == 0x3 (0x3) +char 0x18 % 0x7 == 0x3 (0x3) +__uchar 0x18 % 0x7 == 0x3 (0x3) +__longlong 0xfc18 % 0x7 == -0x6 (0xfffa) +__ulonglong 0xfc18 % 0x7 == 0x5 (0x5) +0xfc18 * 0x2a == 0x5bf0 +0xfc18 / 0x2a == -0x17 +0xfc18 % 0x2a == -0x22 +int 0xfc18 ^ 0x2a == -0x3ce (0xfc32) +__uint 0xfc18 ^ 0x2a == -0x3ce (0xfc32) +char 0x18 ^ 0x2a == 0x32 (0x32) +__uchar 0x18 ^ 0x2a == 0x32 (0x32) +__longlong 0xfc18 ^ 0x2a == -0x3ce (0xfc32) +__ulonglong 0xfc18 ^ 0x2a == -0x3ce (0xfc32) +int 0xfc18 && 0x2a == 0x1 (0x1) +__uint 0xfc18 && 0x2a == 0x1 (0x1) +char 0x18 && 0x2a == 0x1 (0x1) +__uchar 0x18 && 0x2a == 0x1 (0x1) +__longlong 0xfc18 && 0x2a == 0x1 (0x1) +__ulonglong 0xfc18 && 0x2a == 0x1 (0x1) +int 0xfc18 || 0x2a == 0x1 (0x1) +__uint 0xfc18 || 0x2a == 0x1 (0x1) +char 0x18 || 0x2a == 0x1 (0x1) +__uchar 0x18 || 0x2a == 0x1 (0x1) +__longlong 0xfc18 || 0x2a == 0x1 (0x1) +__ulonglong 0xfc18 || 0x2a == 0x1 (0x1) +int 0xfc18 & 0x2a == 0x8 (0x8) +__uint 0xfc18 & 0x2a == 0x8 (0x8) +char 0x18 & 0x2a == 0x8 (0x8) +__uchar 0x18 & 0x2a == 0x8 (0x8) +__longlong 0xfc18 & 0x2a == 0x8 (0x8) +__ulonglong 0xfc18 & 0x2a == 0x8 (0x8) +int 0xfc18 | 0x2a == -0x3c6 (0xfc3a) +__uint 0xfc18 | 0x2a == -0x3c6 (0xfc3a) +char 0x18 | 0x2a == 0x3a (0x3a) +__uchar 0x18 | 0x2a == 0x3a (0x3a) +__longlong 0xfc18 | 0x2a == -0x3c6 (0xfc3a) +__ulonglong 0xfc18 | 0x2a == -0x3c6 (0xfc3a) +int 0xfc18 << 0xc == -0x8000 (0x8000) +__uint 0xfc18 << 0xc == -0x8000 (0x8000) +char 0x18 << 0xc == 0x0 (0x0) +__uchar 0x18 << 0xc == 0x0 (0x0) +__longlong 0xfc18 << 0xc == -0x8000 (0x8000) +__ulonglong 0xfc18 << 0xc == -0x8000 (0x8000) +int 0xfc18 >> 0xc == -0x1 (0xffff) +__uint 0xfc18 >> 0xc == 0xf (0xf) +char 0x18 >> 0xc == 0x0 (0x0) +__uchar 0x18 >> 0xc == 0x0 (0x0) +__longlong 0xfc18 >> 0xc == -0x1 (0xffff) +__ulonglong 0xfc18 >> 0xc == -0x1 (0xffff) +int 0xfc18 + 0x2a == -0x3be (0xfc42) +__uint 0xfc18 + 0x2a == -0x3be (0xfc42) +char 0x18 + 0x2a == 0x42 (0x42) +__uchar 0x18 + 0x2a == 0x42 (0x42) +__longlong 0xfc18 + 0x2a == -0x3be (0xfc42) +__ulonglong 0xfc18 + 0x2a == -0x3be (0xfc42) +float 0xfc18 + 0x2a == -0x3be (0xfc42) +int 0xfc18 - 0x2a == -0x412 (0xfbee) +__uint 0xfc18 - 0x2a == -0x412 (0xfbee) +char 0x18 - 0x2a == -0x12 (0xffee) +__uchar 0x18 - 0x2a == 0xee (0xee) +__longlong 0xfc18 - 0x2a == -0x412 (0xfbee) +__ulonglong 0xfc18 - 0x2a == -0x412 (0xfbee) +float 0xfc18 - 0x2a == -0x412 (0xfbee) +int 0xfc18 * 0x2a == 0x5bf0 (0x5bf0) +__uint 0xfc18 * 0x2a == 0x5bf0 (0x5bf0) +char 0x18 * 0x2a == -0x10 (0xfff0) +__uchar 0x18 * 0x2a == 0xf0 (0xf0) +__longlong 0xfc18 * 0x2a == 0x5bf0 (0x5bf0) +__ulonglong 0xfc18 * 0x2a == 0x5bf0 (0x5bf0) +float 0xfc18 * 0x2a == -0x8000 (0x8000) +int 0xfc18 < 0x2a == 0x1 (0x1) +__uint 0xfc18 < 0x2a == 0x0 (0x0) +char 0x18 < 0x2a == 0x1 (0x1) +__uchar 0x18 < 0x2a == 0x1 (0x1) +__longlong 0xfc18 < 0x2a == 0x1 (0x1) +__ulonglong 0xfc18 < 0x2a == 0x0 (0x0) +float 0xfc18 < 0x2a == 0x1 (0x1) +int 0xfc18 > 0x2a == 0x0 (0x0) +__uint 0xfc18 > 0x2a == 0x1 (0x1) +char 0x18 > 0x2a == 0x0 (0x0) +__uchar 0x18 > 0x2a == 0x0 (0x0) +__longlong 0xfc18 > 0x2a == 0x0 (0x0) +__ulonglong 0xfc18 > 0x2a == 0x1 (0x1) +float 0xfc18 > 0x2a == 0x0 (0x0) +int 0xfc18 <= 0x2a == 0x1 (0x1) +__uint 0xfc18 <= 0x2a == 0x0 (0x0) +char 0x18 <= 0x2a == 0x1 (0x1) +__uchar 0x18 <= 0x2a == 0x1 (0x1) +__longlong 0xfc18 <= 0x2a == 0x1 (0x1) +__ulonglong 0xfc18 <= 0x2a == 0x0 (0x0) +float 0xfc18 <= 0x2a == 0x1 (0x1) +int 0xfc18 == 0x2a == 0x0 (0x0) +__uint 0xfc18 == 0x2a == 0x0 (0x0) +char 0x18 == 0x2a == 0x0 (0x0) +__uchar 0x18 == 0x2a == 0x0 (0x0) +__longlong 0xfc18 == 0x2a == 0x0 (0x0) +__ulonglong 0xfc18 == 0x2a == 0x0 (0x0) +float 0xfc18 == 0x2a == 0x0 (0x0) +int 0xfc18 != 0x2a == 0x1 (0x1) +__uint 0xfc18 != 0x2a == 0x1 (0x1) +char 0x18 != 0x2a == 0x1 (0x1) +__uchar 0x18 != 0x2a == 0x1 (0x1) +__longlong 0xfc18 != 0x2a == 0x1 (0x1) +__ulonglong 0xfc18 != 0x2a == 0x1 (0x1) +float 0xfc18 != 0x2a == 0x1 (0x1) +int 0xfc18 >= 0x2a == 0x0 (0x0) +__uint 0xfc18 >= 0x2a == 0x1 (0x1) +char 0x18 >= 0x2a == 0x0 (0x0) +__uchar 0x18 >= 0x2a == 0x0 (0x0) +__longlong 0xfc18 >= 0x2a == 0x0 (0x0) +__ulonglong 0xfc18 >= 0x2a == 0x1 (0x1) +float 0xfc18 >= 0x2a == 0x0 (0x0) +int 0xfc18 / 0x2a == -0x17 (0xffe9) +__uint 0xfc18 / 0x2a == 0x600 (0x600) +char 0x18 / 0x2a == 0x0 (0x0) +__uchar 0x18 / 0x2a == 0x0 (0x0) +__longlong 0xfc18 / 0x2a == -0x17 (0xffe9) +__ulonglong 0xfc18 / 0x2a == 0x616e (0x616e) +float 0xfc18 / 0x2a == -0x17 (0xffe9) +int 0xfc18 % 0x2a == -0x22 (0xffde) +__uint 0xfc18 % 0x2a == 0x18 (0x18) +char 0x18 % 0x2a == 0x18 (0x18) +__uchar 0x18 % 0x2a == 0x18 (0x18) +__longlong 0xfc18 % 0x2a == -0x22 (0xffde) +__ulonglong 0xfc18 % 0x2a == 0xc (0xc) +0xfc18 * 0x17 == -0x59d8 +0xfc18 / 0x17 == -0x2b +0xfc18 % 0x17 == -0xb +int 0xfc18 ^ 0x17 == -0x3f1 (0xfc0f) +__uint 0xfc18 ^ 0x17 == -0x3f1 (0xfc0f) +char 0x18 ^ 0x17 == 0xf (0xf) +__uchar 0x18 ^ 0x17 == 0xf (0xf) +__longlong 0xfc18 ^ 0x17 == -0x3f1 (0xfc0f) +__ulonglong 0xfc18 ^ 0x17 == -0x3f1 (0xfc0f) +int 0xfc18 && 0x17 == 0x1 (0x1) +__uint 0xfc18 && 0x17 == 0x1 (0x1) +char 0x18 && 0x17 == 0x1 (0x1) +__uchar 0x18 && 0x17 == 0x1 (0x1) +__longlong 0xfc18 && 0x17 == 0x1 (0x1) +__ulonglong 0xfc18 && 0x17 == 0x1 (0x1) +int 0xfc18 || 0x17 == 0x1 (0x1) +__uint 0xfc18 || 0x17 == 0x1 (0x1) +char 0x18 || 0x17 == 0x1 (0x1) +__uchar 0x18 || 0x17 == 0x1 (0x1) +__longlong 0xfc18 || 0x17 == 0x1 (0x1) +__ulonglong 0xfc18 || 0x17 == 0x1 (0x1) +int 0xfc18 & 0x17 == 0x10 (0x10) +__uint 0xfc18 & 0x17 == 0x10 (0x10) +char 0x18 & 0x17 == 0x10 (0x10) +__uchar 0x18 & 0x17 == 0x10 (0x10) +__longlong 0xfc18 & 0x17 == 0x10 (0x10) +__ulonglong 0xfc18 & 0x17 == 0x10 (0x10) +int 0xfc18 | 0x17 == -0x3e1 (0xfc1f) +__uint 0xfc18 | 0x17 == -0x3e1 (0xfc1f) +char 0x18 | 0x17 == 0x1f (0x1f) +__uchar 0x18 | 0x17 == 0x1f (0x1f) +__longlong 0xfc18 | 0x17 == -0x3e1 (0xfc1f) +__ulonglong 0xfc18 | 0x17 == -0x3e1 (0xfc1f) +int 0xfc18 << 0xe == 0x0 (0x0) +__uint 0xfc18 << 0xe == 0x0 (0x0) +char 0x18 << 0xe == 0x0 (0x0) +__uchar 0x18 << 0xe == 0x0 (0x0) +__longlong 0xfc18 << 0xe == 0x0 (0x0) +__ulonglong 0xfc18 << 0xe == 0x0 (0x0) +int 0xfc18 >> 0xe == -0x1 (0xffff) +__uint 0xfc18 >> 0xe == 0x3 (0x3) +char 0x18 >> 0xe == 0x0 (0x0) +__uchar 0x18 >> 0xe == 0x0 (0x0) +__longlong 0xfc18 >> 0xe == -0x1 (0xffff) +__ulonglong 0xfc18 >> 0xe == -0x1 (0xffff) +int 0xfc18 + 0x17 == -0x3d1 (0xfc2f) +__uint 0xfc18 + 0x17 == -0x3d1 (0xfc2f) +char 0x18 + 0x17 == 0x2f (0x2f) +__uchar 0x18 + 0x17 == 0x2f (0x2f) +__longlong 0xfc18 + 0x17 == -0x3d1 (0xfc2f) +__ulonglong 0xfc18 + 0x17 == -0x3d1 (0xfc2f) +float 0xfc18 + 0x17 == -0x3d1 (0xfc2f) +int 0xfc18 - 0x17 == -0x3ff (0xfc01) +__uint 0xfc18 - 0x17 == -0x3ff (0xfc01) +char 0x18 - 0x17 == 0x1 (0x1) +__uchar 0x18 - 0x17 == 0x1 (0x1) +__longlong 0xfc18 - 0x17 == -0x3ff (0xfc01) +__ulonglong 0xfc18 - 0x17 == -0x3ff (0xfc01) +float 0xfc18 - 0x17 == -0x3ff (0xfc01) +int 0xfc18 * 0x17 == -0x59d8 (0xa628) +__uint 0xfc18 * 0x17 == -0x59d8 (0xa628) +char 0x18 * 0x17 == 0x28 (0x28) +__uchar 0x18 * 0x17 == 0x28 (0x28) +__longlong 0xfc18 * 0x17 == -0x59d8 (0xa628) +__ulonglong 0xfc18 * 0x17 == -0x59d8 (0xa628) +float 0xfc18 * 0x17 == -0x59d8 (0xa628) +int 0xfc18 < 0x17 == 0x1 (0x1) +__uint 0xfc18 < 0x17 == 0x0 (0x0) +char 0x18 < 0x17 == 0x0 (0x0) +__uchar 0x18 < 0x17 == 0x0 (0x0) +__longlong 0xfc18 < 0x17 == 0x1 (0x1) +__ulonglong 0xfc18 < 0x17 == 0x0 (0x0) +float 0xfc18 < 0x17 == 0x1 (0x1) +int 0xfc18 > 0x17 == 0x0 (0x0) +__uint 0xfc18 > 0x17 == 0x1 (0x1) +char 0x18 > 0x17 == 0x1 (0x1) +__uchar 0x18 > 0x17 == 0x1 (0x1) +__longlong 0xfc18 > 0x17 == 0x0 (0x0) +__ulonglong 0xfc18 > 0x17 == 0x1 (0x1) +float 0xfc18 > 0x17 == 0x0 (0x0) +int 0xfc18 <= 0x17 == 0x1 (0x1) +__uint 0xfc18 <= 0x17 == 0x0 (0x0) +char 0x18 <= 0x17 == 0x0 (0x0) +__uchar 0x18 <= 0x17 == 0x0 (0x0) +__longlong 0xfc18 <= 0x17 == 0x1 (0x1) +__ulonglong 0xfc18 <= 0x17 == 0x0 (0x0) +float 0xfc18 <= 0x17 == 0x1 (0x1) +int 0xfc18 == 0x17 == 0x0 (0x0) +__uint 0xfc18 == 0x17 == 0x0 (0x0) +char 0x18 == 0x17 == 0x0 (0x0) +__uchar 0x18 == 0x17 == 0x0 (0x0) +__longlong 0xfc18 == 0x17 == 0x0 (0x0) +__ulonglong 0xfc18 == 0x17 == 0x0 (0x0) +float 0xfc18 == 0x17 == 0x0 (0x0) +int 0xfc18 != 0x17 == 0x1 (0x1) +__uint 0xfc18 != 0x17 == 0x1 (0x1) +char 0x18 != 0x17 == 0x1 (0x1) +__uchar 0x18 != 0x17 == 0x1 (0x1) +__longlong 0xfc18 != 0x17 == 0x1 (0x1) +__ulonglong 0xfc18 != 0x17 == 0x1 (0x1) +float 0xfc18 != 0x17 == 0x1 (0x1) +int 0xfc18 >= 0x17 == 0x0 (0x0) +__uint 0xfc18 >= 0x17 == 0x1 (0x1) +char 0x18 >= 0x17 == 0x1 (0x1) +__uchar 0x18 >= 0x17 == 0x1 (0x1) +__longlong 0xfc18 >= 0x17 == 0x0 (0x0) +__ulonglong 0xfc18 >= 0x17 == 0x1 (0x1) +float 0xfc18 >= 0x17 == 0x0 (0x0) +int 0xfc18 / 0x17 == -0x2b (0xffd5) +__uint 0xfc18 / 0x17 == 0xaf5 (0xaf5) +char 0x18 / 0x17 == 0x1 (0x1) +__uchar 0x18 / 0x17 == 0x1 (0x1) +__longlong 0xfc18 / 0x17 == -0x2b (0xffd5) +__ulonglong 0xfc18 / 0x17 == 0x6401 (0x6401) +float 0xfc18 / 0x17 == -0x2b (0xffd5) +int 0xfc18 % 0x17 == -0xb (0xfff5) +__uint 0xfc18 % 0x17 == 0x15 (0x15) +char 0x18 % 0x17 == 0x1 (0x1) +__uchar 0x18 % 0x17 == 0x1 (0x1) +__longlong 0xfc18 % 0x17 == -0xb (0xfff5) +__ulonglong 0xfc18 % 0x17 == 0x1 (0x1) +0xfc18 * 0x7fff == 0x3e8 +0xfc18 / 0x7fff == 0x0 +0xfc18 % 0x7fff == -0x3e8 +int 0xfc18 ^ 0x7fff == -0x7c19 (0x83e7) +__uint 0xfc18 ^ 0x7fff == -0x7c19 (0x83e7) +char 0x18 ^ 0xffff == -0x19 (0xffe7) +__uchar 0x18 ^ 0xff == 0xe7 (0xe7) +__longlong 0xfc18 ^ 0x7fff == -0x7c19 (0x83e7) +__ulonglong 0xfc18 ^ 0x7fff == -0x7c19 (0x83e7) +int 0xfc18 && 0x7fff == 0x1 (0x1) +__uint 0xfc18 && 0x7fff == 0x1 (0x1) +char 0x18 && 0xffff == 0x1 (0x1) +__uchar 0x18 && 0xff == 0x1 (0x1) +__longlong 0xfc18 && 0x7fff == 0x1 (0x1) +__ulonglong 0xfc18 && 0x7fff == 0x1 (0x1) +int 0xfc18 || 0x7fff == 0x1 (0x1) +__uint 0xfc18 || 0x7fff == 0x1 (0x1) +char 0x18 || 0xffff == 0x1 (0x1) +__uchar 0x18 || 0xff == 0x1 (0x1) +__longlong 0xfc18 || 0x7fff == 0x1 (0x1) +__ulonglong 0xfc18 || 0x7fff == 0x1 (0x1) +int 0xfc18 & 0x7fff == 0x7c18 (0x7c18) +__uint 0xfc18 & 0x7fff == 0x7c18 (0x7c18) +char 0x18 & 0xffff == 0x18 (0x18) +__uchar 0x18 & 0xff == 0x18 (0x18) +__longlong 0xfc18 & 0x7fff == 0x7c18 (0x7c18) +__ulonglong 0xfc18 & 0x7fff == 0x7c18 (0x7c18) +int 0xfc18 | 0x7fff == -0x1 (0xffff) +__uint 0xfc18 | 0x7fff == -0x1 (0xffff) +char 0x18 | 0xffff == -0x1 (0xffff) +__uchar 0x18 | 0xff == 0xff (0xff) +__longlong 0xfc18 | 0x7fff == -0x1 (0xffff) +__ulonglong 0xfc18 | 0x7fff == -0x1 (0xffff) +int 0xfc18 << 0x10 == 0x0 (0x0) +__uint 0xfc18 << 0x10 == 0x0 (0x0) +char 0x18 << 0x10 == 0x0 (0x0) +__uchar 0x18 << 0x10 == 0x0 (0x0) +__longlong 0xfc18 << 0x10 == 0x0 (0x0) +__ulonglong 0xfc18 << 0x10 == 0x0 (0x0) +int 0xfc18 >> 0x10 == -0x1 (0xffff) +__uint 0xfc18 >> 0x10 == 0x0 (0x0) +char 0x18 >> 0x10 == 0x0 (0x0) +__uchar 0x18 >> 0x10 == 0x0 (0x0) +__longlong 0xfc18 >> 0x10 == -0x1 (0xffff) +__ulonglong 0xfc18 >> 0x10 == -0x1 (0xffff) +int 0xfc18 + 0x7fff == 0x7c17 (0x7c17) +__uint 0xfc18 + 0x7fff == 0x7c17 (0x7c17) +char 0x18 + 0xffff == 0x17 (0x17) +__uchar 0x18 + 0xff == 0x17 (0x17) +__longlong 0xfc18 + 0x7fff == 0x7c17 (0x7c17) +__ulonglong 0xfc18 + 0x7fff == 0x7c17 (0x7c17) +float 0xfc18 + 0x7fff == 0x7c17 (0x7c17) +int 0xfc18 - 0x7fff == 0x7c19 (0x7c19) +__uint 0xfc18 - 0x7fff == 0x7c19 (0x7c19) +char 0x18 - 0xffff == 0x19 (0x19) +__uchar 0x18 - 0xff == 0x19 (0x19) +__longlong 0xfc18 - 0x7fff == 0x7c19 (0x7c19) +__ulonglong 0xfc18 - 0x7fff == 0x7c19 (0x7c19) +float 0xfc18 - 0x7fff == -0x8000 (0x8000) +int 0xfc18 * 0x7fff == 0x3e8 (0x3e8) +__uint 0xfc18 * 0x7fff == 0x3e8 (0x3e8) +char 0x18 * 0xffff == -0x18 (0xffe8) +__uchar 0x18 * 0xff == 0xe8 (0xe8) +__longlong 0xfc18 * 0x7fff == 0x3e8 (0x3e8) +__ulonglong 0xfc18 * 0x7fff == 0x3e8 (0x3e8) +float 0xfc18 * 0x7fff == -0x8000 (0x8000) +int 0xfc18 < 0x7fff == 0x1 (0x1) +__uint 0xfc18 < 0x7fff == 0x0 (0x0) +char 0x18 < 0xffff == 0x0 (0x0) +__uchar 0x18 < 0xff == 0x1 (0x1) +__longlong 0xfc18 < 0x7fff == 0x1 (0x1) +__ulonglong 0xfc18 < 0x7fff == 0x0 (0x0) +float 0xfc18 < 0x7fff == 0x1 (0x1) +int 0xfc18 > 0x7fff == 0x0 (0x0) +__uint 0xfc18 > 0x7fff == 0x1 (0x1) +char 0x18 > 0xffff == 0x1 (0x1) +__uchar 0x18 > 0xff == 0x0 (0x0) +__longlong 0xfc18 > 0x7fff == 0x0 (0x0) +__ulonglong 0xfc18 > 0x7fff == 0x1 (0x1) +float 0xfc18 > 0x7fff == 0x0 (0x0) +int 0xfc18 <= 0x7fff == 0x1 (0x1) +__uint 0xfc18 <= 0x7fff == 0x0 (0x0) +char 0x18 <= 0xffff == 0x0 (0x0) +__uchar 0x18 <= 0xff == 0x1 (0x1) +__longlong 0xfc18 <= 0x7fff == 0x1 (0x1) +__ulonglong 0xfc18 <= 0x7fff == 0x0 (0x0) +float 0xfc18 <= 0x7fff == 0x1 (0x1) +int 0xfc18 == 0x7fff == 0x0 (0x0) +__uint 0xfc18 == 0x7fff == 0x0 (0x0) +char 0x18 == 0xffff == 0x0 (0x0) +__uchar 0x18 == 0xff == 0x0 (0x0) +__longlong 0xfc18 == 0x7fff == 0x0 (0x0) +__ulonglong 0xfc18 == 0x7fff == 0x0 (0x0) +float 0xfc18 == 0x7fff == 0x0 (0x0) +int 0xfc18 != 0x7fff == 0x1 (0x1) +__uint 0xfc18 != 0x7fff == 0x1 (0x1) +char 0x18 != 0xffff == 0x1 (0x1) +__uchar 0x18 != 0xff == 0x1 (0x1) +__longlong 0xfc18 != 0x7fff == 0x1 (0x1) +__ulonglong 0xfc18 != 0x7fff == 0x1 (0x1) +float 0xfc18 != 0x7fff == 0x1 (0x1) +int 0xfc18 >= 0x7fff == 0x0 (0x0) +__uint 0xfc18 >= 0x7fff == 0x1 (0x1) +char 0x18 >= 0xffff == 0x1 (0x1) +__uchar 0x18 >= 0xff == 0x0 (0x0) +__longlong 0xfc18 >= 0x7fff == 0x0 (0x0) +__ulonglong 0xfc18 >= 0x7fff == 0x1 (0x1) +float 0xfc18 >= 0x7fff == 0x0 (0x0) +int 0xfc18 / 0x7fff == 0x0 (0x0) +__uint 0xfc18 / 0x7fff == 0x1 (0x1) +char 0x18 / 0xffff == -0x18 (0xffe8) +__uchar 0x18 / 0xff == 0x0 (0x0) +__longlong 0xfc18 / 0x7fff == 0x0 (0x0) +__ulonglong 0xfc18 / 0x7fff == 0x3 (0x3) +float 0xfc18 / 0x7fff == 0x0 (0x0) +int 0xfc18 % 0x7fff == -0x3e8 (0xfc18) +__uint 0xfc18 % 0x7fff == 0x7c19 (0x7c19) +char 0x18 % 0xffff == 0x0 (0x0) +__uchar 0x18 % 0xff == 0x18 (0x18) +__longlong 0xfc18 % 0x7fff == -0x3e8 (0xfc18) +__ulonglong 0xfc18 % 0x7fff == 0x7c1b (0x7c1b) +0xfc18 * 0x8000 == 0x0 +0xfc18 / 0x8000 == 0x0 +0xfc18 % 0x8000 == -0x3e8 +int 0xfc18 ^ 0x8000 == 0x7c18 (0x7c18) +__uint 0xfc18 ^ 0x8000 == 0x7c18 (0x7c18) +char 0x18 ^ 0x0 == 0x18 (0x18) +__uchar 0x18 ^ 0x0 == 0x18 (0x18) +__longlong 0xfc18 ^ 0x8000 == 0x7c18 (0x7c18) +__ulonglong 0xfc18 ^ 0x8000 == 0x7c18 (0x7c18) +int 0xfc18 && 0x8000 == 0x1 (0x1) +__uint 0xfc18 && 0x8000 == 0x1 (0x1) +char 0x18 && 0x0 == 0x0 (0x0) +__uchar 0x18 && 0x0 == 0x0 (0x0) +__longlong 0xfc18 && 0x8000 == 0x1 (0x1) +__ulonglong 0xfc18 && 0x8000 == 0x1 (0x1) +int 0xfc18 || 0x8000 == 0x1 (0x1) +__uint 0xfc18 || 0x8000 == 0x1 (0x1) +char 0x18 || 0x0 == 0x1 (0x1) +__uchar 0x18 || 0x0 == 0x1 (0x1) +__longlong 0xfc18 || 0x8000 == 0x1 (0x1) +__ulonglong 0xfc18 || 0x8000 == 0x1 (0x1) +int 0xfc18 & 0x8000 == -0x8000 (0x8000) +__uint 0xfc18 & 0x8000 == -0x8000 (0x8000) +char 0x18 & 0x0 == 0x0 (0x0) +__uchar 0x18 & 0x0 == 0x0 (0x0) +__longlong 0xfc18 & 0x8000 == -0x8000 (0x8000) +__ulonglong 0xfc18 & 0x8000 == -0x8000 (0x8000) +int 0xfc18 | 0x8000 == -0x3e8 (0xfc18) +__uint 0xfc18 | 0x8000 == -0x3e8 (0xfc18) +char 0x18 | 0x0 == 0x18 (0x18) +__uchar 0x18 | 0x0 == 0x18 (0x18) +__longlong 0xfc18 | 0x8000 == -0x3e8 (0xfc18) +__ulonglong 0xfc18 | 0x8000 == -0x3e8 (0xfc18) +int 0xfc18 << 0x12 == 0x0 (0x0) +__uint 0xfc18 << 0x12 == 0x0 (0x0) +char 0x18 << 0x12 == 0x0 (0x0) +__uchar 0x18 << 0x12 == 0x0 (0x0) +__longlong 0xfc18 << 0x12 == 0x0 (0x0) +__ulonglong 0xfc18 << 0x12 == 0x0 (0x0) +int 0xfc18 >> 0x12 == -0x1 (0xffff) +__uint 0xfc18 >> 0x12 == 0x0 (0x0) +char 0x18 >> 0x12 == 0x0 (0x0) +__uchar 0x18 >> 0x12 == 0x0 (0x0) +__longlong 0xfc18 >> 0x12 == -0x1 (0xffff) +__ulonglong 0xfc18 >> 0x12 == 0x3fff (0x3fff) +int 0xfc18 + 0x8000 == 0x7c18 (0x7c18) +__uint 0xfc18 + 0x8000 == 0x7c18 (0x7c18) +char 0x18 + 0x0 == 0x18 (0x18) +__uchar 0x18 + 0x0 == 0x18 (0x18) +__longlong 0xfc18 + 0x8000 == 0x7c18 (0x7c18) +__ulonglong 0xfc18 + 0x8000 == 0x7c18 (0x7c18) +float 0xfc18 + 0x8000 == -0x8000 (0x8000) +int 0xfc18 - 0x8000 == 0x7c18 (0x7c18) +__uint 0xfc18 - 0x8000 == 0x7c18 (0x7c18) +char 0x18 - 0x0 == 0x18 (0x18) +__uchar 0x18 - 0x0 == 0x18 (0x18) +__longlong 0xfc18 - 0x8000 == 0x7c18 (0x7c18) +__ulonglong 0xfc18 - 0x8000 == 0x7c18 (0x7c18) +float 0xfc18 - 0x8000 == 0x7c18 (0x7c18) +int 0xfc18 * 0x8000 == 0x0 (0x0) +__uint 0xfc18 * 0x8000 == 0x0 (0x0) +char 0x18 * 0x0 == 0x0 (0x0) +__uchar 0x18 * 0x0 == 0x0 (0x0) +__longlong 0xfc18 * 0x8000 == 0x0 (0x0) +__ulonglong 0xfc18 * 0x8000 == 0x0 (0x0) +float 0xfc18 * 0x8000 == -0x8000 (0x8000) +int 0xfc18 < 0x8000 == 0x0 (0x0) +__uint 0xfc18 < 0x8000 == 0x0 (0x0) +char 0x18 < 0x0 == 0x0 (0x0) +__uchar 0x18 < 0x0 == 0x0 (0x0) +__longlong 0xfc18 < 0x8000 == 0x0 (0x0) +__ulonglong 0xfc18 < 0x8000 == 0x0 (0x0) +float 0xfc18 < 0x8000 == 0x0 (0x0) +int 0xfc18 > 0x8000 == 0x1 (0x1) +__uint 0xfc18 > 0x8000 == 0x1 (0x1) +char 0x18 > 0x0 == 0x1 (0x1) +__uchar 0x18 > 0x0 == 0x1 (0x1) +__longlong 0xfc18 > 0x8000 == 0x1 (0x1) +__ulonglong 0xfc18 > 0x8000 == 0x1 (0x1) +float 0xfc18 > 0x8000 == 0x1 (0x1) +int 0xfc18 <= 0x8000 == 0x0 (0x0) +__uint 0xfc18 <= 0x8000 == 0x0 (0x0) +char 0x18 <= 0x0 == 0x0 (0x0) +__uchar 0x18 <= 0x0 == 0x0 (0x0) +__longlong 0xfc18 <= 0x8000 == 0x0 (0x0) +__ulonglong 0xfc18 <= 0x8000 == 0x0 (0x0) +float 0xfc18 <= 0x8000 == 0x0 (0x0) +int 0xfc18 == 0x8000 == 0x0 (0x0) +__uint 0xfc18 == 0x8000 == 0x0 (0x0) +char 0x18 == 0x0 == 0x0 (0x0) +__uchar 0x18 == 0x0 == 0x0 (0x0) +__longlong 0xfc18 == 0x8000 == 0x0 (0x0) +__ulonglong 0xfc18 == 0x8000 == 0x0 (0x0) +float 0xfc18 == 0x8000 == 0x0 (0x0) +int 0xfc18 != 0x8000 == 0x1 (0x1) +__uint 0xfc18 != 0x8000 == 0x1 (0x1) +char 0x18 != 0x0 == 0x1 (0x1) +__uchar 0x18 != 0x0 == 0x1 (0x1) +__longlong 0xfc18 != 0x8000 == 0x1 (0x1) +__ulonglong 0xfc18 != 0x8000 == 0x1 (0x1) +float 0xfc18 != 0x8000 == 0x1 (0x1) +int 0xfc18 >= 0x8000 == 0x1 (0x1) +__uint 0xfc18 >= 0x8000 == 0x1 (0x1) +char 0x18 >= 0x0 == 0x1 (0x1) +__uchar 0x18 >= 0x0 == 0x1 (0x1) +__longlong 0xfc18 >= 0x8000 == 0x1 (0x1) +__ulonglong 0xfc18 >= 0x8000 == 0x1 (0x1) +float 0xfc18 >= 0x8000 == 0x1 (0x1) +int 0xfc18 / 0x8000 == 0x0 (0x0) +__uint 0xfc18 / 0x8000 == 0x1 (0x1) +__longlong 0xfc18 / 0x8000 == 0x0 (0x0) +__ulonglong 0xfc18 / 0x8000 == 0x1 (0x1) +float 0xfc18 / 0x8000 == 0x0 (0x0) +int 0xfc18 % 0x8000 == -0x3e8 (0xfc18) +__uint 0xfc18 % 0x8000 == 0x7c18 (0x7c18) +__longlong 0xfc18 % 0x8000 == -0x3e8 (0xfc18) +__ulonglong 0xfc18 % 0x8000 == 0x7c18 (0x7c18) +0xfc18 * 0x3e8 == -0x4240 +0xfc18 / 0x3e8 == -0x1 +0xfc18 % 0x3e8 == 0x0 +int 0xfc18 ^ 0x3e8 == -0x10 (0xfff0) +__uint 0xfc18 ^ 0x3e8 == -0x10 (0xfff0) +char 0x18 ^ 0xffe8 == -0x10 (0xfff0) +__uchar 0x18 ^ 0xe8 == 0xf0 (0xf0) +__longlong 0xfc18 ^ 0x3e8 == -0x10 (0xfff0) +__ulonglong 0xfc18 ^ 0x3e8 == -0x10 (0xfff0) +int 0xfc18 && 0x3e8 == 0x1 (0x1) +__uint 0xfc18 && 0x3e8 == 0x1 (0x1) +char 0x18 && 0xffe8 == 0x1 (0x1) +__uchar 0x18 && 0xe8 == 0x1 (0x1) +__longlong 0xfc18 && 0x3e8 == 0x1 (0x1) +__ulonglong 0xfc18 && 0x3e8 == 0x1 (0x1) +int 0xfc18 || 0x3e8 == 0x1 (0x1) +__uint 0xfc18 || 0x3e8 == 0x1 (0x1) +char 0x18 || 0xffe8 == 0x1 (0x1) +__uchar 0x18 || 0xe8 == 0x1 (0x1) +__longlong 0xfc18 || 0x3e8 == 0x1 (0x1) +__ulonglong 0xfc18 || 0x3e8 == 0x1 (0x1) +int 0xfc18 & 0x3e8 == 0x8 (0x8) +__uint 0xfc18 & 0x3e8 == 0x8 (0x8) +char 0x18 & 0xffe8 == 0x8 (0x8) +__uchar 0x18 & 0xe8 == 0x8 (0x8) +__longlong 0xfc18 & 0x3e8 == 0x8 (0x8) +__ulonglong 0xfc18 & 0x3e8 == 0x8 (0x8) +int 0xfc18 | 0x3e8 == -0x8 (0xfff8) +__uint 0xfc18 | 0x3e8 == -0x8 (0xfff8) +char 0x18 | 0xffe8 == -0x8 (0xfff8) +__uchar 0x18 | 0xe8 == 0xf8 (0xf8) +__longlong 0xfc18 | 0x3e8 == -0x8 (0xfff8) +__ulonglong 0xfc18 | 0x3e8 == -0x8 (0xfff8) +int 0xfc18 << 0x14 == 0x0 (0x0) +__uint 0xfc18 << 0x14 == 0x0 (0x0) +char 0x18 << 0x14 == 0x0 (0x0) +__uchar 0x18 << 0x14 == 0x0 (0x0) +__longlong 0xfc18 << 0x14 == 0x0 (0x0) +__ulonglong 0xfc18 << 0x14 == 0x0 (0x0) +int 0xfc18 >> 0x14 == -0x1 (0xffff) +__uint 0xfc18 >> 0x14 == 0x0 (0x0) +char 0x18 >> 0x14 == 0x0 (0x0) +__uchar 0x18 >> 0x14 == 0x0 (0x0) +__longlong 0xfc18 >> 0x14 == -0x1 (0xffff) +__ulonglong 0xfc18 >> 0x14 == 0xfff (0xfff) +int 0xfc18 + 0x3e8 == 0x0 (0x0) +__uint 0xfc18 + 0x3e8 == 0x0 (0x0) +char 0x18 + 0xffe8 == 0x0 (0x0) +__uchar 0x18 + 0xe8 == 0x0 (0x0) +__longlong 0xfc18 + 0x3e8 == 0x0 (0x0) +__ulonglong 0xfc18 + 0x3e8 == 0x0 (0x0) +float 0xfc18 + 0x3e8 == 0x0 (0x0) +int 0xfc18 - 0x3e8 == -0x7d0 (0xf830) +__uint 0xfc18 - 0x3e8 == -0x7d0 (0xf830) +char 0x18 - 0xffe8 == 0x30 (0x30) +__uchar 0x18 - 0xe8 == 0x30 (0x30) +__longlong 0xfc18 - 0x3e8 == -0x7d0 (0xf830) +__ulonglong 0xfc18 - 0x3e8 == -0x7d0 (0xf830) +float 0xfc18 - 0x3e8 == -0x7d0 (0xf830) +int 0xfc18 * 0x3e8 == -0x4240 (0xbdc0) +__uint 0xfc18 * 0x3e8 == -0x4240 (0xbdc0) +char 0x18 * 0xffe8 == -0x40 (0xffc0) +__uchar 0x18 * 0xe8 == 0xc0 (0xc0) +__longlong 0xfc18 * 0x3e8 == -0x4240 (0xbdc0) +__ulonglong 0xfc18 * 0x3e8 == -0x4240 (0xbdc0) +float 0xfc18 * 0x3e8 == -0x8000 (0x8000) +int 0xfc18 < 0x3e8 == 0x1 (0x1) +__uint 0xfc18 < 0x3e8 == 0x0 (0x0) +char 0x18 < 0xffe8 == 0x0 (0x0) +__uchar 0x18 < 0xe8 == 0x1 (0x1) +__longlong 0xfc18 < 0x3e8 == 0x1 (0x1) +__ulonglong 0xfc18 < 0x3e8 == 0x0 (0x0) +float 0xfc18 < 0x3e8 == 0x1 (0x1) +int 0xfc18 > 0x3e8 == 0x0 (0x0) +__uint 0xfc18 > 0x3e8 == 0x1 (0x1) +char 0x18 > 0xffe8 == 0x1 (0x1) +__uchar 0x18 > 0xe8 == 0x0 (0x0) +__longlong 0xfc18 > 0x3e8 == 0x0 (0x0) +__ulonglong 0xfc18 > 0x3e8 == 0x1 (0x1) +float 0xfc18 > 0x3e8 == 0x0 (0x0) +int 0xfc18 <= 0x3e8 == 0x1 (0x1) +__uint 0xfc18 <= 0x3e8 == 0x0 (0x0) +char 0x18 <= 0xffe8 == 0x0 (0x0) +__uchar 0x18 <= 0xe8 == 0x1 (0x1) +__longlong 0xfc18 <= 0x3e8 == 0x1 (0x1) +__ulonglong 0xfc18 <= 0x3e8 == 0x0 (0x0) +float 0xfc18 <= 0x3e8 == 0x1 (0x1) +int 0xfc18 == 0x3e8 == 0x0 (0x0) +__uint 0xfc18 == 0x3e8 == 0x0 (0x0) +char 0x18 == 0xffe8 == 0x0 (0x0) +__uchar 0x18 == 0xe8 == 0x0 (0x0) +__longlong 0xfc18 == 0x3e8 == 0x0 (0x0) +__ulonglong 0xfc18 == 0x3e8 == 0x0 (0x0) +float 0xfc18 == 0x3e8 == 0x0 (0x0) +int 0xfc18 != 0x3e8 == 0x1 (0x1) +__uint 0xfc18 != 0x3e8 == 0x1 (0x1) +char 0x18 != 0xffe8 == 0x1 (0x1) +__uchar 0x18 != 0xe8 == 0x1 (0x1) +__longlong 0xfc18 != 0x3e8 == 0x1 (0x1) +__ulonglong 0xfc18 != 0x3e8 == 0x1 (0x1) +float 0xfc18 != 0x3e8 == 0x1 (0x1) +int 0xfc18 >= 0x3e8 == 0x0 (0x0) +__uint 0xfc18 >= 0x3e8 == 0x1 (0x1) +char 0x18 >= 0xffe8 == 0x1 (0x1) +__uchar 0x18 >= 0xe8 == 0x0 (0x0) +__longlong 0xfc18 >= 0x3e8 == 0x0 (0x0) +__ulonglong 0xfc18 >= 0x3e8 == 0x1 (0x1) +float 0xfc18 >= 0x3e8 == 0x0 (0x0) +int 0xfc18 / 0x3e8 == -0x1 (0xffff) +__uint 0xfc18 / 0x3e8 == 0x40 (0x40) +char 0x18 / 0xffe8 == -0x1 (0xffff) +__uchar 0x18 / 0xe8 == 0x0 (0x0) +__longlong 0xfc18 / 0x3e8 == -0x1 (0xffff) +__ulonglong 0xfc18 / 0x3e8 == -0x76ca (0x8936) +float 0xfc18 / 0x3e8 == -0x1 (0xffff) +int 0xfc18 % 0x3e8 == 0x0 (0x0) +__uint 0xfc18 % 0x3e8 == 0x218 (0x218) +char 0x18 % 0xffe8 == 0x0 (0x0) +__uchar 0x18 % 0xe8 == 0x18 (0x18) +__longlong 0xfc18 % 0x3e8 == 0x0 (0x0) +__ulonglong 0xfc18 % 0x3e8 == 0x128 (0x128) +0xfc18 * 0x2710 == 0x6980 +0xfc18 / 0x2710 == 0x0 +0xfc18 % 0x2710 == -0x3e8 +int 0xfc18 ^ 0x2710 == -0x24f8 (0xdb08) +__uint 0xfc18 ^ 0x2710 == -0x24f8 (0xdb08) +char 0x18 ^ 0x10 == 0x8 (0x8) +__uchar 0x18 ^ 0x10 == 0x8 (0x8) +__longlong 0xfc18 ^ 0x2710 == -0x24f8 (0xdb08) +__ulonglong 0xfc18 ^ 0x2710 == -0x24f8 (0xdb08) +int 0xfc18 && 0x2710 == 0x1 (0x1) +__uint 0xfc18 && 0x2710 == 0x1 (0x1) +char 0x18 && 0x10 == 0x1 (0x1) +__uchar 0x18 && 0x10 == 0x1 (0x1) +__longlong 0xfc18 && 0x2710 == 0x1 (0x1) +__ulonglong 0xfc18 && 0x2710 == 0x1 (0x1) +int 0xfc18 || 0x2710 == 0x1 (0x1) +__uint 0xfc18 || 0x2710 == 0x1 (0x1) +char 0x18 || 0x10 == 0x1 (0x1) +__uchar 0x18 || 0x10 == 0x1 (0x1) +__longlong 0xfc18 || 0x2710 == 0x1 (0x1) +__ulonglong 0xfc18 || 0x2710 == 0x1 (0x1) +int 0xfc18 & 0x2710 == 0x2410 (0x2410) +__uint 0xfc18 & 0x2710 == 0x2410 (0x2410) +char 0x18 & 0x10 == 0x10 (0x10) +__uchar 0x18 & 0x10 == 0x10 (0x10) +__longlong 0xfc18 & 0x2710 == 0x2410 (0x2410) +__ulonglong 0xfc18 & 0x2710 == 0x2410 (0x2410) +int 0xfc18 | 0x2710 == -0xe8 (0xff18) +__uint 0xfc18 | 0x2710 == -0xe8 (0xff18) +char 0x18 | 0x10 == 0x18 (0x18) +__uchar 0x18 | 0x10 == 0x18 (0x18) +__longlong 0xfc18 | 0x2710 == -0xe8 (0xff18) +__ulonglong 0xfc18 | 0x2710 == -0xe8 (0xff18) +int 0xfc18 << 0x16 == 0x0 (0x0) +__uint 0xfc18 << 0x16 == 0x0 (0x0) +char 0x18 << 0x16 == 0x0 (0x0) +__uchar 0x18 << 0x16 == 0x0 (0x0) +__longlong 0xfc18 << 0x16 == 0x0 (0x0) +__ulonglong 0xfc18 << 0x16 == 0x0 (0x0) +int 0xfc18 >> 0x16 == -0x1 (0xffff) +__uint 0xfc18 >> 0x16 == 0x0 (0x0) +char 0x18 >> 0x16 == 0x0 (0x0) +__uchar 0x18 >> 0x16 == 0x0 (0x0) +__longlong 0xfc18 >> 0x16 == -0x1 (0xffff) +__ulonglong 0xfc18 >> 0x16 == 0x3ff (0x3ff) +int 0xfc18 + 0x2710 == 0x2328 (0x2328) +__uint 0xfc18 + 0x2710 == 0x2328 (0x2328) +char 0x18 + 0x10 == 0x28 (0x28) +__uchar 0x18 + 0x10 == 0x28 (0x28) +__longlong 0xfc18 + 0x2710 == 0x2328 (0x2328) +__ulonglong 0xfc18 + 0x2710 == 0x2328 (0x2328) +float 0xfc18 + 0x2710 == 0x2328 (0x2328) +int 0xfc18 - 0x2710 == -0x2af8 (0xd508) +__uint 0xfc18 - 0x2710 == -0x2af8 (0xd508) +char 0x18 - 0x10 == 0x8 (0x8) +__uchar 0x18 - 0x10 == 0x8 (0x8) +__longlong 0xfc18 - 0x2710 == -0x2af8 (0xd508) +__ulonglong 0xfc18 - 0x2710 == -0x2af8 (0xd508) +float 0xfc18 - 0x2710 == -0x2af8 (0xd508) +int 0xfc18 * 0x2710 == 0x6980 (0x6980) +__uint 0xfc18 * 0x2710 == 0x6980 (0x6980) +char 0x18 * 0x10 == -0x80 (0xff80) +__uchar 0x18 * 0x10 == 0x80 (0x80) +__longlong 0xfc18 * 0x2710 == 0x6980 (0x6980) +__ulonglong 0xfc18 * 0x2710 == 0x6980 (0x6980) +float 0xfc18 * 0x2710 == -0x8000 (0x8000) +int 0xfc18 < 0x2710 == 0x1 (0x1) +__uint 0xfc18 < 0x2710 == 0x0 (0x0) +char 0x18 < 0x10 == 0x0 (0x0) +__uchar 0x18 < 0x10 == 0x0 (0x0) +__longlong 0xfc18 < 0x2710 == 0x1 (0x1) +__ulonglong 0xfc18 < 0x2710 == 0x0 (0x0) +float 0xfc18 < 0x2710 == 0x1 (0x1) +int 0xfc18 > 0x2710 == 0x0 (0x0) +__uint 0xfc18 > 0x2710 == 0x1 (0x1) +char 0x18 > 0x10 == 0x1 (0x1) +__uchar 0x18 > 0x10 == 0x1 (0x1) +__longlong 0xfc18 > 0x2710 == 0x0 (0x0) +__ulonglong 0xfc18 > 0x2710 == 0x1 (0x1) +float 0xfc18 > 0x2710 == 0x0 (0x0) +int 0xfc18 <= 0x2710 == 0x1 (0x1) +__uint 0xfc18 <= 0x2710 == 0x0 (0x0) +char 0x18 <= 0x10 == 0x0 (0x0) +__uchar 0x18 <= 0x10 == 0x0 (0x0) +__longlong 0xfc18 <= 0x2710 == 0x1 (0x1) +__ulonglong 0xfc18 <= 0x2710 == 0x0 (0x0) +float 0xfc18 <= 0x2710 == 0x1 (0x1) +int 0xfc18 == 0x2710 == 0x0 (0x0) +__uint 0xfc18 == 0x2710 == 0x0 (0x0) +char 0x18 == 0x10 == 0x0 (0x0) +__uchar 0x18 == 0x10 == 0x0 (0x0) +__longlong 0xfc18 == 0x2710 == 0x0 (0x0) +__ulonglong 0xfc18 == 0x2710 == 0x0 (0x0) +float 0xfc18 == 0x2710 == 0x0 (0x0) +int 0xfc18 != 0x2710 == 0x1 (0x1) +__uint 0xfc18 != 0x2710 == 0x1 (0x1) +char 0x18 != 0x10 == 0x1 (0x1) +__uchar 0x18 != 0x10 == 0x1 (0x1) +__longlong 0xfc18 != 0x2710 == 0x1 (0x1) +__ulonglong 0xfc18 != 0x2710 == 0x1 (0x1) +float 0xfc18 != 0x2710 == 0x1 (0x1) +int 0xfc18 >= 0x2710 == 0x0 (0x0) +__uint 0xfc18 >= 0x2710 == 0x1 (0x1) +char 0x18 >= 0x10 == 0x1 (0x1) +__uchar 0x18 >= 0x10 == 0x1 (0x1) +__longlong 0xfc18 >= 0x2710 == 0x0 (0x0) +__ulonglong 0xfc18 >= 0x2710 == 0x1 (0x1) +float 0xfc18 >= 0x2710 == 0x0 (0x0) +int 0xfc18 / 0x2710 == 0x0 (0x0) +__uint 0xfc18 / 0x2710 == 0x6 (0x6) +char 0x18 / 0x10 == 0x1 (0x1) +__uchar 0x18 / 0x10 == 0x1 (0x1) +__longlong 0xfc18 / 0x2710 == 0x0 (0x0) +__ulonglong 0xfc18 / 0x2710 == -0x7248 (0x8db8) +float 0xfc18 / 0x2710 == 0x0 (0x0) +int 0xfc18 % 0x2710 == -0x3e8 (0xfc18) +__uint 0xfc18 % 0x2710 == 0x11b8 (0x11b8) +char 0x18 % 0x10 == 0x8 (0x8) +__uchar 0x18 % 0x10 == 0x8 (0x8) +__longlong 0xfc18 % 0x2710 == -0x3e8 (0xfc18) +__ulonglong 0xfc18 % 0x2710 == 0x1898 (0x1898) +int xor42-0x3e8 xor42 -0x3ce +__uint xor42-0x3e8 xor42 -0x3ce +char xor420x18 xor42 0x32 +__uchar xor420x18 xor42 0x32 +__longlong xor42-0x3e8 xor42 -0x3ce +__ulonglong xor42-0x3e8 xor42 -0x3ce +int land1-0x3e8 land1 0x1 +__uint land1-0x3e8 land1 0x1 +char land10x18 land1 0x1 +__uchar land10x18 land1 0x1 +__longlong land1-0x3e8 land1 0x1 +__ulonglong land1-0x3e8 land1 0x1 +int lor1-0x3e8 lor1 0x1 +__uint lor1-0x3e8 lor1 0x1 +char lor10x18 lor1 0x1 +__uchar lor10x18 lor1 0x1 +__longlong lor1-0x3e8 lor1 0x1 +__ulonglong lor1-0x3e8 lor1 0x1 +int and42-0x3e8 and42 0x8 +__uint and42-0x3e8 and42 0x8 +char and420x18 and42 0x8 +__uchar and420x18 and42 0x8 +__longlong and42-0x3e8 and42 0x8 +__ulonglong and42-0x3e8 and42 0x8 +int or42-0x3e8 or42 -0x3c6 +__uint or42-0x3e8 or42 -0x3c6 +char or420x18 or42 0x3a +__uchar or420x18 or42 0x3a +__longlong or42-0x3e8 or42 -0x3c6 +__ulonglong or42-0x3e8 or42 -0x3c6 +int shl5-0x3e8 shl5 -0x7d00 +__uint shl5-0x3e8 shl5 -0x7d00 +char shl50x18 shl5 0x0 +__uchar shl50x18 shl5 0x0 +__longlong shl5-0x3e8 shl5 -0x7d00 +__ulonglong shl5-0x3e8 shl5 -0x7d00 +int shr5-0x3e8 shr5 -0x20 +__uint shr5-0x3e8 shr5 0x7e0 +char shr50x18 shr5 0x0 +__uchar shr50x18 shr5 0x0 +__longlong shr5-0x3e8 shr5 -0x20 +__ulonglong shr5-0x3e8 shr5 -0x20 +int add42-0x3e8 add42 -0x3be +__uint add42-0x3e8 add42 -0x3be +char add420x18 add42 0x42 +__uchar add420x18 add42 0x42 +__longlong add42-0x3e8 add42 -0x3be +__ulonglong add42-0x3e8 add42 -0x3be +float add42-0x3e8 add42 -0x3be +int sub42-0x3e8 sub42 -0x412 +__uint sub42-0x3e8 sub42 -0x412 +char sub420x18 sub42 -0x12 +__uchar sub420x18 sub42 0xee +__longlong sub42-0x3e8 sub42 -0x412 +__ulonglong sub42-0x3e8 sub42 -0x412 +float sub42-0x3e8 sub42 -0x412 +int mul42-0x3e8 mul42 0x5bf0 +__uint mul42-0x3e8 mul42 0x5bf0 +char mul420x18 mul42 -0x10 +__uchar mul420x18 mul42 0xf0 +__longlong mul42-0x3e8 mul42 0x5bf0 +__ulonglong mul42-0x3e8 mul42 0x5bf0 +float mul42-0x3e8 mul42 -0x8000 +int lt42-0x3e8 lt42 0x1 +__uint lt42-0x3e8 lt42 0x0 +char lt420x18 lt42 0x1 +__uchar lt420x18 lt42 0x1 +__longlong lt42-0x3e8 lt42 0x1 +__ulonglong lt42-0x3e8 lt42 0x0 +float lt42-0x3e8 lt42 0x1 +int gt42-0x3e8 gt42 0x0 +__uint gt42-0x3e8 gt42 0x1 +char gt420x18 gt42 0x0 +__uchar gt420x18 gt42 0x0 +__longlong gt42-0x3e8 gt42 0x0 +__ulonglong gt42-0x3e8 gt42 0x1 +float gt42-0x3e8 gt42 0x0 +int le42-0x3e8 le42 0x1 +__uint le42-0x3e8 le42 0x0 +char le420x18 le42 0x1 +__uchar le420x18 le42 0x1 +__longlong le42-0x3e8 le42 0x1 +__ulonglong le42-0x3e8 le42 0x0 +float le42-0x3e8 le42 0x1 +int eq42-0x3e8 eq42 0x0 +__uint eq42-0x3e8 eq42 0x0 +char eq420x18 eq42 0x0 +__uchar eq420x18 eq42 0x0 +__longlong eq42-0x3e8 eq42 0x0 +__ulonglong eq42-0x3e8 eq42 0x0 +float eq42-0x3e8 eq42 0x0 +int ne42-0x3e8 ne42 0x1 +__uint ne42-0x3e8 ne42 0x1 +char ne420x18 ne42 0x1 +__uchar ne420x18 ne42 0x1 +__longlong ne42-0x3e8 ne42 0x1 +__ulonglong ne42-0x3e8 ne42 0x1 +float ne42-0x3e8 ne42 0x1 +int ge42-0x3e8 ge42 0x0 +__uint ge42-0x3e8 ge42 0x1 +char ge420x18 ge42 0x0 +__uchar ge420x18 ge42 0x0 +__longlong ge42-0x3e8 ge42 0x0 +__ulonglong ge42-0x3e8 ge42 0x1 +float ge42-0x3e8 ge42 0x0 +int div42-0x3e8 div42 -0x17 +__uint div42-0x3e8 div42 0x600 +char div420x18 div42 0x0 +__uchar div420x18 div42 0x0 +__longlong div42-0x3e8 div42 -0x17 +__ulonglong div42-0x3e8 div42 0x616e +float div42-0x3e8 div42 -0x17 +int mod23-0x3e8 mod23 -0xb +__uint mod23-0x3e8 mod23 0x15 +char mod230x18 mod23 0x1 +__uchar mod230x18 mod23 0x1 +__longlong mod23-0x3e8 mod23 -0xb +__ulonglong mod23-0x3e8 mod23 0x1 +0xd8f0 * 0xffff == 0x2710 +0xd8f0 / 0xffff == 0x2710 +0xd8f0 % 0xffff == 0x0 +int 0xd8f0 ^ 0xffff == 0x270f (0x270f) +__uint 0xd8f0 ^ 0xffff == 0x270f (0x270f) +char 0xfff0 ^ 0xffff == 0xf (0xf) +__uchar 0xf0 ^ 0xff == 0xf (0xf) +__longlong 0xd8f0 ^ 0xffff == 0x270f (0x270f) +__ulonglong 0xd8f0 ^ 0xffff == 0x270f (0x270f) +int 0xd8f0 && 0xffff == 0x1 (0x1) +__uint 0xd8f0 && 0xffff == 0x1 (0x1) +char 0xfff0 && 0xffff == 0x1 (0x1) +__uchar 0xf0 && 0xff == 0x1 (0x1) +__longlong 0xd8f0 && 0xffff == 0x1 (0x1) +__ulonglong 0xd8f0 && 0xffff == 0x1 (0x1) +int 0xd8f0 || 0xffff == 0x1 (0x1) +__uint 0xd8f0 || 0xffff == 0x1 (0x1) +char 0xfff0 || 0xffff == 0x1 (0x1) +__uchar 0xf0 || 0xff == 0x1 (0x1) +__longlong 0xd8f0 || 0xffff == 0x1 (0x1) +__ulonglong 0xd8f0 || 0xffff == 0x1 (0x1) +int 0xd8f0 & 0xffff == -0x2710 (0xd8f0) +__uint 0xd8f0 & 0xffff == -0x2710 (0xd8f0) +char 0xfff0 & 0xffff == -0x10 (0xfff0) +__uchar 0xf0 & 0xff == 0xf0 (0xf0) +__longlong 0xd8f0 & 0xffff == -0x2710 (0xd8f0) +__ulonglong 0xd8f0 & 0xffff == -0x2710 (0xd8f0) +int 0xd8f0 | 0xffff == -0x1 (0xffff) +__uint 0xd8f0 | 0xffff == -0x1 (0xffff) +char 0xfff0 | 0xffff == -0x1 (0xffff) +__uchar 0xf0 | 0xff == 0xff (0xff) +__longlong 0xd8f0 | 0xffff == -0x1 (0xffff) +__ulonglong 0xd8f0 | 0xffff == -0x1 (0xffff) +int 0xd8f0 << 0x1 == -0x4e20 (0xb1e0) +__uint 0xd8f0 << 0x1 == -0x4e20 (0xb1e0) +char 0xfff0 << 0x1 == -0x20 (0xffe0) +__uchar 0xf0 << 0x1 == 0xe0 (0xe0) +__longlong 0xd8f0 << 0x1 == -0x4e20 (0xb1e0) +__ulonglong 0xd8f0 << 0x1 == -0x4e20 (0xb1e0) +int 0xd8f0 >> 0x1 == -0x1388 (0xec78) +__uint 0xd8f0 >> 0x1 == 0x6c78 (0x6c78) +char 0xfff0 >> 0x1 == -0x8 (0xfff8) +__uchar 0xf0 >> 0x1 == 0x78 (0x78) +__longlong 0xd8f0 >> 0x1 == -0x1388 (0xec78) +__ulonglong 0xd8f0 >> 0x1 == -0x1388 (0xec78) +int 0xd8f0 + 0xffff == -0x2711 (0xd8ef) +__uint 0xd8f0 + 0xffff == -0x2711 (0xd8ef) +char 0xfff0 + 0xffff == -0x11 (0xffef) +__uchar 0xf0 + 0xff == 0xef (0xef) +__longlong 0xd8f0 + 0xffff == -0x2711 (0xd8ef) +__ulonglong 0xd8f0 + 0xffff == -0x2711 (0xd8ef) +float 0xd8f0 + 0xffff == -0x2711 (0xd8ef) +int 0xd8f0 - 0xffff == -0x270f (0xd8f1) +__uint 0xd8f0 - 0xffff == -0x270f (0xd8f1) +char 0xfff0 - 0xffff == -0xf (0xfff1) +__uchar 0xf0 - 0xff == 0xf1 (0xf1) +__longlong 0xd8f0 - 0xffff == -0x270f (0xd8f1) +__ulonglong 0xd8f0 - 0xffff == -0x270f (0xd8f1) +float 0xd8f0 - 0xffff == -0x270f (0xd8f1) +int 0xd8f0 * 0xffff == 0x2710 (0x2710) +__uint 0xd8f0 * 0xffff == 0x2710 (0x2710) +char 0xfff0 * 0xffff == 0x10 (0x10) +__uchar 0xf0 * 0xff == 0x10 (0x10) +__longlong 0xd8f0 * 0xffff == 0x2710 (0x2710) +__ulonglong 0xd8f0 * 0xffff == 0x2710 (0x2710) +float 0xd8f0 * 0xffff == 0x2710 (0x2710) +int 0xd8f0 < 0xffff == 0x1 (0x1) +__uint 0xd8f0 < 0xffff == 0x1 (0x1) +char 0xfff0 < 0xffff == 0x1 (0x1) +__uchar 0xf0 < 0xff == 0x1 (0x1) +__longlong 0xd8f0 < 0xffff == 0x1 (0x1) +__ulonglong 0xd8f0 < 0xffff == 0x1 (0x1) +float 0xd8f0 < 0xffff == 0x1 (0x1) +int 0xd8f0 > 0xffff == 0x0 (0x0) +__uint 0xd8f0 > 0xffff == 0x0 (0x0) +char 0xfff0 > 0xffff == 0x0 (0x0) +__uchar 0xf0 > 0xff == 0x0 (0x0) +__longlong 0xd8f0 > 0xffff == 0x0 (0x0) +__ulonglong 0xd8f0 > 0xffff == 0x0 (0x0) +float 0xd8f0 > 0xffff == 0x0 (0x0) +int 0xd8f0 <= 0xffff == 0x1 (0x1) +__uint 0xd8f0 <= 0xffff == 0x1 (0x1) +char 0xfff0 <= 0xffff == 0x1 (0x1) +__uchar 0xf0 <= 0xff == 0x1 (0x1) +__longlong 0xd8f0 <= 0xffff == 0x1 (0x1) +__ulonglong 0xd8f0 <= 0xffff == 0x1 (0x1) +float 0xd8f0 <= 0xffff == 0x1 (0x1) +int 0xd8f0 == 0xffff == 0x0 (0x0) +__uint 0xd8f0 == 0xffff == 0x0 (0x0) +char 0xfff0 == 0xffff == 0x0 (0x0) +__uchar 0xf0 == 0xff == 0x0 (0x0) +__longlong 0xd8f0 == 0xffff == 0x0 (0x0) +__ulonglong 0xd8f0 == 0xffff == 0x0 (0x0) +float 0xd8f0 == 0xffff == 0x0 (0x0) +int 0xd8f0 != 0xffff == 0x1 (0x1) +__uint 0xd8f0 != 0xffff == 0x1 (0x1) +char 0xfff0 != 0xffff == 0x1 (0x1) +__uchar 0xf0 != 0xff == 0x1 (0x1) +__longlong 0xd8f0 != 0xffff == 0x1 (0x1) +__ulonglong 0xd8f0 != 0xffff == 0x1 (0x1) +float 0xd8f0 != 0xffff == 0x1 (0x1) +int 0xd8f0 >= 0xffff == 0x0 (0x0) +__uint 0xd8f0 >= 0xffff == 0x0 (0x0) +char 0xfff0 >= 0xffff == 0x0 (0x0) +__uchar 0xf0 >= 0xff == 0x0 (0x0) +__longlong 0xd8f0 >= 0xffff == 0x0 (0x0) +__ulonglong 0xd8f0 >= 0xffff == 0x0 (0x0) +float 0xd8f0 >= 0xffff == 0x0 (0x0) +int 0xd8f0 / 0xffff == 0x2710 (0x2710) +__uint 0xd8f0 / 0xffff == 0x0 (0x0) +char 0xfff0 / 0xffff == 0x10 (0x10) +__uchar 0xf0 / 0xff == 0x0 (0x0) +__longlong 0xd8f0 / 0xffff == 0x2710 (0x2710) +__ulonglong 0xd8f0 / 0xffff == 0x0 (0x0) +float 0xd8f0 / 0xffff == 0x2710 (0x2710) +int 0xd8f0 % 0xffff == 0x0 (0x0) +__uint 0xd8f0 % 0xffff == -0x2710 (0xd8f0) +char 0xfff0 % 0xffff == 0x0 (0x0) +__uchar 0xf0 % 0xff == 0xf0 (0xf0) +__longlong 0xd8f0 % 0xffff == 0x0 (0x0) +__ulonglong 0xd8f0 % 0xffff == -0x2710 (0xd8f0) +0xd8f0 * 0x1 == -0x2710 +0xd8f0 / 0x1 == -0x2710 +0xd8f0 % 0x1 == 0x0 +int 0xd8f0 ^ 0x1 == -0x270f (0xd8f1) +__uint 0xd8f0 ^ 0x1 == -0x270f (0xd8f1) +char 0xfff0 ^ 0x1 == -0xf (0xfff1) +__uchar 0xf0 ^ 0x1 == 0xf1 (0xf1) +__longlong 0xd8f0 ^ 0x1 == -0x270f (0xd8f1) +__ulonglong 0xd8f0 ^ 0x1 == -0x270f (0xd8f1) +int 0xd8f0 && 0x1 == 0x1 (0x1) +__uint 0xd8f0 && 0x1 == 0x1 (0x1) +char 0xfff0 && 0x1 == 0x1 (0x1) +__uchar 0xf0 && 0x1 == 0x1 (0x1) +__longlong 0xd8f0 && 0x1 == 0x1 (0x1) +__ulonglong 0xd8f0 && 0x1 == 0x1 (0x1) +int 0xd8f0 || 0x1 == 0x1 (0x1) +__uint 0xd8f0 || 0x1 == 0x1 (0x1) +char 0xfff0 || 0x1 == 0x1 (0x1) +__uchar 0xf0 || 0x1 == 0x1 (0x1) +__longlong 0xd8f0 || 0x1 == 0x1 (0x1) +__ulonglong 0xd8f0 || 0x1 == 0x1 (0x1) +int 0xd8f0 & 0x1 == 0x0 (0x0) +__uint 0xd8f0 & 0x1 == 0x0 (0x0) +char 0xfff0 & 0x1 == 0x0 (0x0) +__uchar 0xf0 & 0x1 == 0x0 (0x0) +__longlong 0xd8f0 & 0x1 == 0x0 (0x0) +__ulonglong 0xd8f0 & 0x1 == 0x0 (0x0) +int 0xd8f0 | 0x1 == -0x270f (0xd8f1) +__uint 0xd8f0 | 0x1 == -0x270f (0xd8f1) +char 0xfff0 | 0x1 == -0xf (0xfff1) +__uchar 0xf0 | 0x1 == 0xf1 (0xf1) +__longlong 0xd8f0 | 0x1 == -0x270f (0xd8f1) +__ulonglong 0xd8f0 | 0x1 == -0x270f (0xd8f1) +int 0xd8f0 << 0x2 == 0x63c0 (0x63c0) +__uint 0xd8f0 << 0x2 == 0x63c0 (0x63c0) +char 0xfff0 << 0x2 == -0x40 (0xffc0) +__uchar 0xf0 << 0x2 == 0xc0 (0xc0) +__longlong 0xd8f0 << 0x2 == 0x63c0 (0x63c0) +__ulonglong 0xd8f0 << 0x2 == 0x63c0 (0x63c0) +int 0xd8f0 >> 0x2 == -0x9c4 (0xf63c) +__uint 0xd8f0 >> 0x2 == 0x363c (0x363c) +char 0xfff0 >> 0x2 == -0x4 (0xfffc) +__uchar 0xf0 >> 0x2 == 0x3c (0x3c) +__longlong 0xd8f0 >> 0x2 == -0x9c4 (0xf63c) +__ulonglong 0xd8f0 >> 0x2 == -0x9c4 (0xf63c) +int 0xd8f0 + 0x1 == -0x270f (0xd8f1) +__uint 0xd8f0 + 0x1 == -0x270f (0xd8f1) +char 0xfff0 + 0x1 == -0xf (0xfff1) +__uchar 0xf0 + 0x1 == 0xf1 (0xf1) +__longlong 0xd8f0 + 0x1 == -0x270f (0xd8f1) +__ulonglong 0xd8f0 + 0x1 == -0x270f (0xd8f1) +float 0xd8f0 + 0x1 == -0x270f (0xd8f1) +int 0xd8f0 - 0x1 == -0x2711 (0xd8ef) +__uint 0xd8f0 - 0x1 == -0x2711 (0xd8ef) +char 0xfff0 - 0x1 == -0x11 (0xffef) +__uchar 0xf0 - 0x1 == 0xef (0xef) +__longlong 0xd8f0 - 0x1 == -0x2711 (0xd8ef) +__ulonglong 0xd8f0 - 0x1 == -0x2711 (0xd8ef) +float 0xd8f0 - 0x1 == -0x2711 (0xd8ef) +int 0xd8f0 * 0x1 == -0x2710 (0xd8f0) +__uint 0xd8f0 * 0x1 == -0x2710 (0xd8f0) +char 0xfff0 * 0x1 == -0x10 (0xfff0) +__uchar 0xf0 * 0x1 == 0xf0 (0xf0) +__longlong 0xd8f0 * 0x1 == -0x2710 (0xd8f0) +__ulonglong 0xd8f0 * 0x1 == -0x2710 (0xd8f0) +float 0xd8f0 * 0x1 == -0x2710 (0xd8f0) +int 0xd8f0 < 0x1 == 0x1 (0x1) +__uint 0xd8f0 < 0x1 == 0x0 (0x0) +char 0xfff0 < 0x1 == 0x1 (0x1) +__uchar 0xf0 < 0x1 == 0x0 (0x0) +__longlong 0xd8f0 < 0x1 == 0x1 (0x1) +__ulonglong 0xd8f0 < 0x1 == 0x0 (0x0) +float 0xd8f0 < 0x1 == 0x1 (0x1) +int 0xd8f0 > 0x1 == 0x0 (0x0) +__uint 0xd8f0 > 0x1 == 0x1 (0x1) +char 0xfff0 > 0x1 == 0x0 (0x0) +__uchar 0xf0 > 0x1 == 0x1 (0x1) +__longlong 0xd8f0 > 0x1 == 0x0 (0x0) +__ulonglong 0xd8f0 > 0x1 == 0x1 (0x1) +float 0xd8f0 > 0x1 == 0x0 (0x0) +int 0xd8f0 <= 0x1 == 0x1 (0x1) +__uint 0xd8f0 <= 0x1 == 0x0 (0x0) +char 0xfff0 <= 0x1 == 0x1 (0x1) +__uchar 0xf0 <= 0x1 == 0x0 (0x0) +__longlong 0xd8f0 <= 0x1 == 0x1 (0x1) +__ulonglong 0xd8f0 <= 0x1 == 0x0 (0x0) +float 0xd8f0 <= 0x1 == 0x1 (0x1) +int 0xd8f0 == 0x1 == 0x0 (0x0) +__uint 0xd8f0 == 0x1 == 0x0 (0x0) +char 0xfff0 == 0x1 == 0x0 (0x0) +__uchar 0xf0 == 0x1 == 0x0 (0x0) +__longlong 0xd8f0 == 0x1 == 0x0 (0x0) +__ulonglong 0xd8f0 == 0x1 == 0x0 (0x0) +float 0xd8f0 == 0x1 == 0x0 (0x0) +int 0xd8f0 != 0x1 == 0x1 (0x1) +__uint 0xd8f0 != 0x1 == 0x1 (0x1) +char 0xfff0 != 0x1 == 0x1 (0x1) +__uchar 0xf0 != 0x1 == 0x1 (0x1) +__longlong 0xd8f0 != 0x1 == 0x1 (0x1) +__ulonglong 0xd8f0 != 0x1 == 0x1 (0x1) +float 0xd8f0 != 0x1 == 0x1 (0x1) +int 0xd8f0 >= 0x1 == 0x0 (0x0) +__uint 0xd8f0 >= 0x1 == 0x1 (0x1) +char 0xfff0 >= 0x1 == 0x0 (0x0) +__uchar 0xf0 >= 0x1 == 0x1 (0x1) +__longlong 0xd8f0 >= 0x1 == 0x0 (0x0) +__ulonglong 0xd8f0 >= 0x1 == 0x1 (0x1) +float 0xd8f0 >= 0x1 == 0x0 (0x0) +int 0xd8f0 / 0x1 == -0x2710 (0xd8f0) +__uint 0xd8f0 / 0x1 == -0x2710 (0xd8f0) +char 0xfff0 / 0x1 == -0x10 (0xfff0) +__uchar 0xf0 / 0x1 == 0xf0 (0xf0) +__longlong 0xd8f0 / 0x1 == -0x2710 (0xd8f0) +__ulonglong 0xd8f0 / 0x1 == -0x2710 (0xd8f0) +float 0xd8f0 / 0x1 == -0x2710 (0xd8f0) +int 0xd8f0 % 0x1 == 0x0 (0x0) +__uint 0xd8f0 % 0x1 == 0x0 (0x0) +char 0xfff0 % 0x1 == 0x0 (0x0) +__uchar 0xf0 % 0x1 == 0x0 (0x0) +__longlong 0xd8f0 % 0x1 == 0x0 (0x0) +__ulonglong 0xd8f0 % 0x1 == 0x0 (0x0) +0xd8f0 * 0x2 == -0x4e20 +0xd8f0 / 0x2 == -0x1388 +0xd8f0 % 0x2 == 0x0 +int 0xd8f0 ^ 0x2 == -0x270e (0xd8f2) +__uint 0xd8f0 ^ 0x2 == -0x270e (0xd8f2) +char 0xfff0 ^ 0x2 == -0xe (0xfff2) +__uchar 0xf0 ^ 0x2 == 0xf2 (0xf2) +__longlong 0xd8f0 ^ 0x2 == -0x270e (0xd8f2) +__ulonglong 0xd8f0 ^ 0x2 == -0x270e (0xd8f2) +int 0xd8f0 && 0x2 == 0x1 (0x1) +__uint 0xd8f0 && 0x2 == 0x1 (0x1) +char 0xfff0 && 0x2 == 0x1 (0x1) +__uchar 0xf0 && 0x2 == 0x1 (0x1) +__longlong 0xd8f0 && 0x2 == 0x1 (0x1) +__ulonglong 0xd8f0 && 0x2 == 0x1 (0x1) +int 0xd8f0 || 0x2 == 0x1 (0x1) +__uint 0xd8f0 || 0x2 == 0x1 (0x1) +char 0xfff0 || 0x2 == 0x1 (0x1) +__uchar 0xf0 || 0x2 == 0x1 (0x1) +__longlong 0xd8f0 || 0x2 == 0x1 (0x1) +__ulonglong 0xd8f0 || 0x2 == 0x1 (0x1) +int 0xd8f0 & 0x2 == 0x0 (0x0) +__uint 0xd8f0 & 0x2 == 0x0 (0x0) +char 0xfff0 & 0x2 == 0x0 (0x0) +__uchar 0xf0 & 0x2 == 0x0 (0x0) +__longlong 0xd8f0 & 0x2 == 0x0 (0x0) +__ulonglong 0xd8f0 & 0x2 == 0x0 (0x0) +int 0xd8f0 | 0x2 == -0x270e (0xd8f2) +__uint 0xd8f0 | 0x2 == -0x270e (0xd8f2) +char 0xfff0 | 0x2 == -0xe (0xfff2) +__uchar 0xf0 | 0x2 == 0xf2 (0xf2) +__longlong 0xd8f0 | 0x2 == -0x270e (0xd8f2) +__ulonglong 0xd8f0 | 0x2 == -0x270e (0xd8f2) +int 0xd8f0 << 0x3 == -0x3880 (0xc780) +__uint 0xd8f0 << 0x3 == -0x3880 (0xc780) +char 0xfff0 << 0x3 == -0x80 (0xff80) +__uchar 0xf0 << 0x3 == 0x80 (0x80) +__longlong 0xd8f0 << 0x3 == -0x3880 (0xc780) +__ulonglong 0xd8f0 << 0x3 == -0x3880 (0xc780) +int 0xd8f0 >> 0x3 == -0x4e2 (0xfb1e) +__uint 0xd8f0 >> 0x3 == 0x1b1e (0x1b1e) +char 0xfff0 >> 0x3 == -0x2 (0xfffe) +__uchar 0xf0 >> 0x3 == 0x1e (0x1e) +__longlong 0xd8f0 >> 0x3 == -0x4e2 (0xfb1e) +__ulonglong 0xd8f0 >> 0x3 == -0x4e2 (0xfb1e) +int 0xd8f0 + 0x2 == -0x270e (0xd8f2) +__uint 0xd8f0 + 0x2 == -0x270e (0xd8f2) +char 0xfff0 + 0x2 == -0xe (0xfff2) +__uchar 0xf0 + 0x2 == 0xf2 (0xf2) +__longlong 0xd8f0 + 0x2 == -0x270e (0xd8f2) +__ulonglong 0xd8f0 + 0x2 == -0x270e (0xd8f2) +float 0xd8f0 + 0x2 == -0x270e (0xd8f2) +int 0xd8f0 - 0x2 == -0x2712 (0xd8ee) +__uint 0xd8f0 - 0x2 == -0x2712 (0xd8ee) +char 0xfff0 - 0x2 == -0x12 (0xffee) +__uchar 0xf0 - 0x2 == 0xee (0xee) +__longlong 0xd8f0 - 0x2 == -0x2712 (0xd8ee) +__ulonglong 0xd8f0 - 0x2 == -0x2712 (0xd8ee) +float 0xd8f0 - 0x2 == -0x2712 (0xd8ee) +int 0xd8f0 * 0x2 == -0x4e20 (0xb1e0) +__uint 0xd8f0 * 0x2 == -0x4e20 (0xb1e0) +char 0xfff0 * 0x2 == -0x20 (0xffe0) +__uchar 0xf0 * 0x2 == 0xe0 (0xe0) +__longlong 0xd8f0 * 0x2 == -0x4e20 (0xb1e0) +__ulonglong 0xd8f0 * 0x2 == -0x4e20 (0xb1e0) +float 0xd8f0 * 0x2 == -0x4e20 (0xb1e0) +int 0xd8f0 < 0x2 == 0x1 (0x1) +__uint 0xd8f0 < 0x2 == 0x0 (0x0) +char 0xfff0 < 0x2 == 0x1 (0x1) +__uchar 0xf0 < 0x2 == 0x0 (0x0) +__longlong 0xd8f0 < 0x2 == 0x1 (0x1) +__ulonglong 0xd8f0 < 0x2 == 0x0 (0x0) +float 0xd8f0 < 0x2 == 0x1 (0x1) +int 0xd8f0 > 0x2 == 0x0 (0x0) +__uint 0xd8f0 > 0x2 == 0x1 (0x1) +char 0xfff0 > 0x2 == 0x0 (0x0) +__uchar 0xf0 > 0x2 == 0x1 (0x1) +__longlong 0xd8f0 > 0x2 == 0x0 (0x0) +__ulonglong 0xd8f0 > 0x2 == 0x1 (0x1) +float 0xd8f0 > 0x2 == 0x0 (0x0) +int 0xd8f0 <= 0x2 == 0x1 (0x1) +__uint 0xd8f0 <= 0x2 == 0x0 (0x0) +char 0xfff0 <= 0x2 == 0x1 (0x1) +__uchar 0xf0 <= 0x2 == 0x0 (0x0) +__longlong 0xd8f0 <= 0x2 == 0x1 (0x1) +__ulonglong 0xd8f0 <= 0x2 == 0x0 (0x0) +float 0xd8f0 <= 0x2 == 0x1 (0x1) +int 0xd8f0 == 0x2 == 0x0 (0x0) +__uint 0xd8f0 == 0x2 == 0x0 (0x0) +char 0xfff0 == 0x2 == 0x0 (0x0) +__uchar 0xf0 == 0x2 == 0x0 (0x0) +__longlong 0xd8f0 == 0x2 == 0x0 (0x0) +__ulonglong 0xd8f0 == 0x2 == 0x0 (0x0) +float 0xd8f0 == 0x2 == 0x0 (0x0) +int 0xd8f0 != 0x2 == 0x1 (0x1) +__uint 0xd8f0 != 0x2 == 0x1 (0x1) +char 0xfff0 != 0x2 == 0x1 (0x1) +__uchar 0xf0 != 0x2 == 0x1 (0x1) +__longlong 0xd8f0 != 0x2 == 0x1 (0x1) +__ulonglong 0xd8f0 != 0x2 == 0x1 (0x1) +float 0xd8f0 != 0x2 == 0x1 (0x1) +int 0xd8f0 >= 0x2 == 0x0 (0x0) +__uint 0xd8f0 >= 0x2 == 0x1 (0x1) +char 0xfff0 >= 0x2 == 0x0 (0x0) +__uchar 0xf0 >= 0x2 == 0x1 (0x1) +__longlong 0xd8f0 >= 0x2 == 0x0 (0x0) +__ulonglong 0xd8f0 >= 0x2 == 0x1 (0x1) +float 0xd8f0 >= 0x2 == 0x0 (0x0) +int 0xd8f0 / 0x2 == -0x1388 (0xec78) +__uint 0xd8f0 / 0x2 == 0x6c78 (0x6c78) +char 0xfff0 / 0x2 == -0x8 (0xfff8) +__uchar 0xf0 / 0x2 == 0x78 (0x78) +__longlong 0xd8f0 / 0x2 == -0x1388 (0xec78) +__ulonglong 0xd8f0 / 0x2 == -0x1388 (0xec78) +float 0xd8f0 / 0x2 == -0x1388 (0xec78) +int 0xd8f0 % 0x2 == 0x0 (0x0) +__uint 0xd8f0 % 0x2 == 0x0 (0x0) +char 0xfff0 % 0x2 == 0x0 (0x0) +__uchar 0xf0 % 0x2 == 0x0 (0x0) +__longlong 0xd8f0 % 0x2 == 0x0 (0x0) +__ulonglong 0xd8f0 % 0x2 == 0x0 (0x0) +0xd8f0 * 0xfffe == 0x4e20 +0xd8f0 / 0xfffe == 0x1388 +0xd8f0 % 0xfffe == 0x0 +int 0xd8f0 ^ 0xfffe == 0x270e (0x270e) +__uint 0xd8f0 ^ 0xfffe == 0x270e (0x270e) +char 0xfff0 ^ 0xfffe == 0xe (0xe) +__uchar 0xf0 ^ 0xfe == 0xe (0xe) +__longlong 0xd8f0 ^ 0xfffe == 0x270e (0x270e) +__ulonglong 0xd8f0 ^ 0xfffe == 0x270e (0x270e) +int 0xd8f0 && 0xfffe == 0x1 (0x1) +__uint 0xd8f0 && 0xfffe == 0x1 (0x1) +char 0xfff0 && 0xfffe == 0x1 (0x1) +__uchar 0xf0 && 0xfe == 0x1 (0x1) +__longlong 0xd8f0 && 0xfffe == 0x1 (0x1) +__ulonglong 0xd8f0 && 0xfffe == 0x1 (0x1) +int 0xd8f0 || 0xfffe == 0x1 (0x1) +__uint 0xd8f0 || 0xfffe == 0x1 (0x1) +char 0xfff0 || 0xfffe == 0x1 (0x1) +__uchar 0xf0 || 0xfe == 0x1 (0x1) +__longlong 0xd8f0 || 0xfffe == 0x1 (0x1) +__ulonglong 0xd8f0 || 0xfffe == 0x1 (0x1) +int 0xd8f0 & 0xfffe == -0x2710 (0xd8f0) +__uint 0xd8f0 & 0xfffe == -0x2710 (0xd8f0) +char 0xfff0 & 0xfffe == -0x10 (0xfff0) +__uchar 0xf0 & 0xfe == 0xf0 (0xf0) +__longlong 0xd8f0 & 0xfffe == -0x2710 (0xd8f0) +__ulonglong 0xd8f0 & 0xfffe == -0x2710 (0xd8f0) +int 0xd8f0 | 0xfffe == -0x2 (0xfffe) +__uint 0xd8f0 | 0xfffe == -0x2 (0xfffe) +char 0xfff0 | 0xfffe == -0x2 (0xfffe) +__uchar 0xf0 | 0xfe == 0xfe (0xfe) +__longlong 0xd8f0 | 0xfffe == -0x2 (0xfffe) +__ulonglong 0xd8f0 | 0xfffe == -0x2 (0xfffe) +int 0xd8f0 << 0x4 == -0x7100 (0x8f00) +__uint 0xd8f0 << 0x4 == -0x7100 (0x8f00) +char 0xfff0 << 0x4 == 0x0 (0x0) +__uchar 0xf0 << 0x4 == 0x0 (0x0) +__longlong 0xd8f0 << 0x4 == -0x7100 (0x8f00) +__ulonglong 0xd8f0 << 0x4 == -0x7100 (0x8f00) +int 0xd8f0 >> 0x4 == -0x271 (0xfd8f) +__uint 0xd8f0 >> 0x4 == 0xd8f (0xd8f) +char 0xfff0 >> 0x4 == -0x1 (0xffff) +__uchar 0xf0 >> 0x4 == 0xf (0xf) +__longlong 0xd8f0 >> 0x4 == -0x271 (0xfd8f) +__ulonglong 0xd8f0 >> 0x4 == -0x271 (0xfd8f) +int 0xd8f0 + 0xfffe == -0x2712 (0xd8ee) +__uint 0xd8f0 + 0xfffe == -0x2712 (0xd8ee) +char 0xfff0 + 0xfffe == -0x12 (0xffee) +__uchar 0xf0 + 0xfe == 0xee (0xee) +__longlong 0xd8f0 + 0xfffe == -0x2712 (0xd8ee) +__ulonglong 0xd8f0 + 0xfffe == -0x2712 (0xd8ee) +float 0xd8f0 + 0xfffe == -0x2712 (0xd8ee) +int 0xd8f0 - 0xfffe == -0x270e (0xd8f2) +__uint 0xd8f0 - 0xfffe == -0x270e (0xd8f2) +char 0xfff0 - 0xfffe == -0xe (0xfff2) +__uchar 0xf0 - 0xfe == 0xf2 (0xf2) +__longlong 0xd8f0 - 0xfffe == -0x270e (0xd8f2) +__ulonglong 0xd8f0 - 0xfffe == -0x270e (0xd8f2) +float 0xd8f0 - 0xfffe == -0x270e (0xd8f2) +int 0xd8f0 * 0xfffe == 0x4e20 (0x4e20) +__uint 0xd8f0 * 0xfffe == 0x4e20 (0x4e20) +char 0xfff0 * 0xfffe == 0x20 (0x20) +__uchar 0xf0 * 0xfe == 0x20 (0x20) +__longlong 0xd8f0 * 0xfffe == 0x4e20 (0x4e20) +__ulonglong 0xd8f0 * 0xfffe == 0x4e20 (0x4e20) +float 0xd8f0 * 0xfffe == 0x4e20 (0x4e20) +int 0xd8f0 < 0xfffe == 0x1 (0x1) +__uint 0xd8f0 < 0xfffe == 0x1 (0x1) +char 0xfff0 < 0xfffe == 0x1 (0x1) +__uchar 0xf0 < 0xfe == 0x1 (0x1) +__longlong 0xd8f0 < 0xfffe == 0x1 (0x1) +__ulonglong 0xd8f0 < 0xfffe == 0x1 (0x1) +float 0xd8f0 < 0xfffe == 0x1 (0x1) +int 0xd8f0 > 0xfffe == 0x0 (0x0) +__uint 0xd8f0 > 0xfffe == 0x0 (0x0) +char 0xfff0 > 0xfffe == 0x0 (0x0) +__uchar 0xf0 > 0xfe == 0x0 (0x0) +__longlong 0xd8f0 > 0xfffe == 0x0 (0x0) +__ulonglong 0xd8f0 > 0xfffe == 0x0 (0x0) +float 0xd8f0 > 0xfffe == 0x0 (0x0) +int 0xd8f0 <= 0xfffe == 0x1 (0x1) +__uint 0xd8f0 <= 0xfffe == 0x1 (0x1) +char 0xfff0 <= 0xfffe == 0x1 (0x1) +__uchar 0xf0 <= 0xfe == 0x1 (0x1) +__longlong 0xd8f0 <= 0xfffe == 0x1 (0x1) +__ulonglong 0xd8f0 <= 0xfffe == 0x1 (0x1) +float 0xd8f0 <= 0xfffe == 0x1 (0x1) +int 0xd8f0 == 0xfffe == 0x0 (0x0) +__uint 0xd8f0 == 0xfffe == 0x0 (0x0) +char 0xfff0 == 0xfffe == 0x0 (0x0) +__uchar 0xf0 == 0xfe == 0x0 (0x0) +__longlong 0xd8f0 == 0xfffe == 0x0 (0x0) +__ulonglong 0xd8f0 == 0xfffe == 0x0 (0x0) +float 0xd8f0 == 0xfffe == 0x0 (0x0) +int 0xd8f0 != 0xfffe == 0x1 (0x1) +__uint 0xd8f0 != 0xfffe == 0x1 (0x1) +char 0xfff0 != 0xfffe == 0x1 (0x1) +__uchar 0xf0 != 0xfe == 0x1 (0x1) +__longlong 0xd8f0 != 0xfffe == 0x1 (0x1) +__ulonglong 0xd8f0 != 0xfffe == 0x1 (0x1) +float 0xd8f0 != 0xfffe == 0x1 (0x1) +int 0xd8f0 >= 0xfffe == 0x0 (0x0) +__uint 0xd8f0 >= 0xfffe == 0x0 (0x0) +char 0xfff0 >= 0xfffe == 0x0 (0x0) +__uchar 0xf0 >= 0xfe == 0x0 (0x0) +__longlong 0xd8f0 >= 0xfffe == 0x0 (0x0) +__ulonglong 0xd8f0 >= 0xfffe == 0x0 (0x0) +float 0xd8f0 >= 0xfffe == 0x0 (0x0) +int 0xd8f0 / 0xfffe == 0x1388 (0x1388) +__uint 0xd8f0 / 0xfffe == 0x0 (0x0) +char 0xfff0 / 0xfffe == 0x8 (0x8) +__uchar 0xf0 / 0xfe == 0x0 (0x0) +__longlong 0xd8f0 / 0xfffe == 0x1388 (0x1388) +__ulonglong 0xd8f0 / 0xfffe == 0x0 (0x0) +float 0xd8f0 / 0xfffe == 0x1388 (0x1388) +int 0xd8f0 % 0xfffe == 0x0 (0x0) +__uint 0xd8f0 % 0xfffe == -0x2710 (0xd8f0) +char 0xfff0 % 0xfffe == 0x0 (0x0) +__uchar 0xf0 % 0xfe == 0xf0 (0xf0) +__longlong 0xd8f0 % 0xfffe == 0x0 (0x0) +__ulonglong 0xd8f0 % 0xfffe == -0x2710 (0xd8f0) +0xd8f0 * 0x4 == 0x63c0 +0xd8f0 / 0x4 == -0x9c4 +0xd8f0 % 0x4 == 0x0 +int 0xd8f0 ^ 0x4 == -0x270c (0xd8f4) +__uint 0xd8f0 ^ 0x4 == -0x270c (0xd8f4) +char 0xfff0 ^ 0x4 == -0xc (0xfff4) +__uchar 0xf0 ^ 0x4 == 0xf4 (0xf4) +__longlong 0xd8f0 ^ 0x4 == -0x270c (0xd8f4) +__ulonglong 0xd8f0 ^ 0x4 == -0x270c (0xd8f4) +int 0xd8f0 && 0x4 == 0x1 (0x1) +__uint 0xd8f0 && 0x4 == 0x1 (0x1) +char 0xfff0 && 0x4 == 0x1 (0x1) +__uchar 0xf0 && 0x4 == 0x1 (0x1) +__longlong 0xd8f0 && 0x4 == 0x1 (0x1) +__ulonglong 0xd8f0 && 0x4 == 0x1 (0x1) +int 0xd8f0 || 0x4 == 0x1 (0x1) +__uint 0xd8f0 || 0x4 == 0x1 (0x1) +char 0xfff0 || 0x4 == 0x1 (0x1) +__uchar 0xf0 || 0x4 == 0x1 (0x1) +__longlong 0xd8f0 || 0x4 == 0x1 (0x1) +__ulonglong 0xd8f0 || 0x4 == 0x1 (0x1) +int 0xd8f0 & 0x4 == 0x0 (0x0) +__uint 0xd8f0 & 0x4 == 0x0 (0x0) +char 0xfff0 & 0x4 == 0x0 (0x0) +__uchar 0xf0 & 0x4 == 0x0 (0x0) +__longlong 0xd8f0 & 0x4 == 0x0 (0x0) +__ulonglong 0xd8f0 & 0x4 == 0x0 (0x0) +int 0xd8f0 | 0x4 == -0x270c (0xd8f4) +__uint 0xd8f0 | 0x4 == -0x270c (0xd8f4) +char 0xfff0 | 0x4 == -0xc (0xfff4) +__uchar 0xf0 | 0x4 == 0xf4 (0xf4) +__longlong 0xd8f0 | 0x4 == -0x270c (0xd8f4) +__ulonglong 0xd8f0 | 0x4 == -0x270c (0xd8f4) +int 0xd8f0 << 0x5 == 0x1e00 (0x1e00) +__uint 0xd8f0 << 0x5 == 0x1e00 (0x1e00) +char 0xfff0 << 0x5 == 0x0 (0x0) +__uchar 0xf0 << 0x5 == 0x0 (0x0) +__longlong 0xd8f0 << 0x5 == 0x1e00 (0x1e00) +__ulonglong 0xd8f0 << 0x5 == 0x1e00 (0x1e00) +int 0xd8f0 >> 0x5 == -0x139 (0xfec7) +__uint 0xd8f0 >> 0x5 == 0x6c7 (0x6c7) +char 0xfff0 >> 0x5 == -0x1 (0xffff) +__uchar 0xf0 >> 0x5 == 0x7 (0x7) +__longlong 0xd8f0 >> 0x5 == -0x139 (0xfec7) +__ulonglong 0xd8f0 >> 0x5 == -0x139 (0xfec7) +int 0xd8f0 + 0x4 == -0x270c (0xd8f4) +__uint 0xd8f0 + 0x4 == -0x270c (0xd8f4) +char 0xfff0 + 0x4 == -0xc (0xfff4) +__uchar 0xf0 + 0x4 == 0xf4 (0xf4) +__longlong 0xd8f0 + 0x4 == -0x270c (0xd8f4) +__ulonglong 0xd8f0 + 0x4 == -0x270c (0xd8f4) +float 0xd8f0 + 0x4 == -0x270c (0xd8f4) +int 0xd8f0 - 0x4 == -0x2714 (0xd8ec) +__uint 0xd8f0 - 0x4 == -0x2714 (0xd8ec) +char 0xfff0 - 0x4 == -0x14 (0xffec) +__uchar 0xf0 - 0x4 == 0xec (0xec) +__longlong 0xd8f0 - 0x4 == -0x2714 (0xd8ec) +__ulonglong 0xd8f0 - 0x4 == -0x2714 (0xd8ec) +float 0xd8f0 - 0x4 == -0x2714 (0xd8ec) +int 0xd8f0 * 0x4 == 0x63c0 (0x63c0) +__uint 0xd8f0 * 0x4 == 0x63c0 (0x63c0) +char 0xfff0 * 0x4 == -0x40 (0xffc0) +__uchar 0xf0 * 0x4 == 0xc0 (0xc0) +__longlong 0xd8f0 * 0x4 == 0x63c0 (0x63c0) +__ulonglong 0xd8f0 * 0x4 == 0x63c0 (0x63c0) +float 0xd8f0 * 0x4 == -0x8000 (0x8000) +int 0xd8f0 < 0x4 == 0x1 (0x1) +__uint 0xd8f0 < 0x4 == 0x0 (0x0) +char 0xfff0 < 0x4 == 0x1 (0x1) +__uchar 0xf0 < 0x4 == 0x0 (0x0) +__longlong 0xd8f0 < 0x4 == 0x1 (0x1) +__ulonglong 0xd8f0 < 0x4 == 0x0 (0x0) +float 0xd8f0 < 0x4 == 0x1 (0x1) +int 0xd8f0 > 0x4 == 0x0 (0x0) +__uint 0xd8f0 > 0x4 == 0x1 (0x1) +char 0xfff0 > 0x4 == 0x0 (0x0) +__uchar 0xf0 > 0x4 == 0x1 (0x1) +__longlong 0xd8f0 > 0x4 == 0x0 (0x0) +__ulonglong 0xd8f0 > 0x4 == 0x1 (0x1) +float 0xd8f0 > 0x4 == 0x0 (0x0) +int 0xd8f0 <= 0x4 == 0x1 (0x1) +__uint 0xd8f0 <= 0x4 == 0x0 (0x0) +char 0xfff0 <= 0x4 == 0x1 (0x1) +__uchar 0xf0 <= 0x4 == 0x0 (0x0) +__longlong 0xd8f0 <= 0x4 == 0x1 (0x1) +__ulonglong 0xd8f0 <= 0x4 == 0x0 (0x0) +float 0xd8f0 <= 0x4 == 0x1 (0x1) +int 0xd8f0 == 0x4 == 0x0 (0x0) +__uint 0xd8f0 == 0x4 == 0x0 (0x0) +char 0xfff0 == 0x4 == 0x0 (0x0) +__uchar 0xf0 == 0x4 == 0x0 (0x0) +__longlong 0xd8f0 == 0x4 == 0x0 (0x0) +__ulonglong 0xd8f0 == 0x4 == 0x0 (0x0) +float 0xd8f0 == 0x4 == 0x0 (0x0) +int 0xd8f0 != 0x4 == 0x1 (0x1) +__uint 0xd8f0 != 0x4 == 0x1 (0x1) +char 0xfff0 != 0x4 == 0x1 (0x1) +__uchar 0xf0 != 0x4 == 0x1 (0x1) +__longlong 0xd8f0 != 0x4 == 0x1 (0x1) +__ulonglong 0xd8f0 != 0x4 == 0x1 (0x1) +float 0xd8f0 != 0x4 == 0x1 (0x1) +int 0xd8f0 >= 0x4 == 0x0 (0x0) +__uint 0xd8f0 >= 0x4 == 0x1 (0x1) +char 0xfff0 >= 0x4 == 0x0 (0x0) +__uchar 0xf0 >= 0x4 == 0x1 (0x1) +__longlong 0xd8f0 >= 0x4 == 0x0 (0x0) +__ulonglong 0xd8f0 >= 0x4 == 0x1 (0x1) +float 0xd8f0 >= 0x4 == 0x0 (0x0) +int 0xd8f0 / 0x4 == -0x9c4 (0xf63c) +__uint 0xd8f0 / 0x4 == 0x363c (0x363c) +char 0xfff0 / 0x4 == -0x4 (0xfffc) +__uchar 0xf0 / 0x4 == 0x3c (0x3c) +__longlong 0xd8f0 / 0x4 == -0x9c4 (0xf63c) +__ulonglong 0xd8f0 / 0x4 == -0x9c4 (0xf63c) +float 0xd8f0 / 0x4 == -0x9c4 (0xf63c) +int 0xd8f0 % 0x4 == 0x0 (0x0) +__uint 0xd8f0 % 0x4 == 0x0 (0x0) +char 0xfff0 % 0x4 == 0x0 (0x0) +__uchar 0xf0 % 0x4 == 0x0 (0x0) +__longlong 0xd8f0 % 0x4 == 0x0 (0x0) +__ulonglong 0xd8f0 % 0x4 == 0x0 (0x0) +0xd8f0 * 0xfffc == -0x63c0 +0xd8f0 / 0xfffc == 0x9c4 +0xd8f0 % 0xfffc == 0x0 +int 0xd8f0 ^ 0xfffc == 0x270c (0x270c) +__uint 0xd8f0 ^ 0xfffc == 0x270c (0x270c) +char 0xfff0 ^ 0xfffc == 0xc (0xc) +__uchar 0xf0 ^ 0xfc == 0xc (0xc) +__longlong 0xd8f0 ^ 0xfffc == 0x270c (0x270c) +__ulonglong 0xd8f0 ^ 0xfffc == 0x270c (0x270c) +int 0xd8f0 && 0xfffc == 0x1 (0x1) +__uint 0xd8f0 && 0xfffc == 0x1 (0x1) +char 0xfff0 && 0xfffc == 0x1 (0x1) +__uchar 0xf0 && 0xfc == 0x1 (0x1) +__longlong 0xd8f0 && 0xfffc == 0x1 (0x1) +__ulonglong 0xd8f0 && 0xfffc == 0x1 (0x1) +int 0xd8f0 || 0xfffc == 0x1 (0x1) +__uint 0xd8f0 || 0xfffc == 0x1 (0x1) +char 0xfff0 || 0xfffc == 0x1 (0x1) +__uchar 0xf0 || 0xfc == 0x1 (0x1) +__longlong 0xd8f0 || 0xfffc == 0x1 (0x1) +__ulonglong 0xd8f0 || 0xfffc == 0x1 (0x1) +int 0xd8f0 & 0xfffc == -0x2710 (0xd8f0) +__uint 0xd8f0 & 0xfffc == -0x2710 (0xd8f0) +char 0xfff0 & 0xfffc == -0x10 (0xfff0) +__uchar 0xf0 & 0xfc == 0xf0 (0xf0) +__longlong 0xd8f0 & 0xfffc == -0x2710 (0xd8f0) +__ulonglong 0xd8f0 & 0xfffc == -0x2710 (0xd8f0) +int 0xd8f0 | 0xfffc == -0x4 (0xfffc) +__uint 0xd8f0 | 0xfffc == -0x4 (0xfffc) +char 0xfff0 | 0xfffc == -0x4 (0xfffc) +__uchar 0xf0 | 0xfc == 0xfc (0xfc) +__longlong 0xd8f0 | 0xfffc == -0x4 (0xfffc) +__ulonglong 0xd8f0 | 0xfffc == -0x4 (0xfffc) +int 0xd8f0 << 0x6 == 0x3c00 (0x3c00) +__uint 0xd8f0 << 0x6 == 0x3c00 (0x3c00) +char 0xfff0 << 0x6 == 0x0 (0x0) +__uchar 0xf0 << 0x6 == 0x0 (0x0) +__longlong 0xd8f0 << 0x6 == 0x3c00 (0x3c00) +__ulonglong 0xd8f0 << 0x6 == 0x3c00 (0x3c00) +int 0xd8f0 >> 0x6 == -0x9d (0xff63) +__uint 0xd8f0 >> 0x6 == 0x363 (0x363) +char 0xfff0 >> 0x6 == -0x1 (0xffff) +__uchar 0xf0 >> 0x6 == 0x3 (0x3) +__longlong 0xd8f0 >> 0x6 == -0x9d (0xff63) +__ulonglong 0xd8f0 >> 0x6 == -0x9d (0xff63) +int 0xd8f0 + 0xfffc == -0x2714 (0xd8ec) +__uint 0xd8f0 + 0xfffc == -0x2714 (0xd8ec) +char 0xfff0 + 0xfffc == -0x14 (0xffec) +__uchar 0xf0 + 0xfc == 0xec (0xec) +__longlong 0xd8f0 + 0xfffc == -0x2714 (0xd8ec) +__ulonglong 0xd8f0 + 0xfffc == -0x2714 (0xd8ec) +float 0xd8f0 + 0xfffc == -0x2714 (0xd8ec) +int 0xd8f0 - 0xfffc == -0x270c (0xd8f4) +__uint 0xd8f0 - 0xfffc == -0x270c (0xd8f4) +char 0xfff0 - 0xfffc == -0xc (0xfff4) +__uchar 0xf0 - 0xfc == 0xf4 (0xf4) +__longlong 0xd8f0 - 0xfffc == -0x270c (0xd8f4) +__ulonglong 0xd8f0 - 0xfffc == -0x270c (0xd8f4) +float 0xd8f0 - 0xfffc == -0x270c (0xd8f4) +int 0xd8f0 * 0xfffc == -0x63c0 (0x9c40) +__uint 0xd8f0 * 0xfffc == -0x63c0 (0x9c40) +char 0xfff0 * 0xfffc == 0x40 (0x40) +__uchar 0xf0 * 0xfc == 0x40 (0x40) +__longlong 0xd8f0 * 0xfffc == -0x63c0 (0x9c40) +__ulonglong 0xd8f0 * 0xfffc == -0x63c0 (0x9c40) +float 0xd8f0 * 0xfffc == -0x8000 (0x8000) +int 0xd8f0 < 0xfffc == 0x1 (0x1) +__uint 0xd8f0 < 0xfffc == 0x1 (0x1) +char 0xfff0 < 0xfffc == 0x1 (0x1) +__uchar 0xf0 < 0xfc == 0x1 (0x1) +__longlong 0xd8f0 < 0xfffc == 0x1 (0x1) +__ulonglong 0xd8f0 < 0xfffc == 0x1 (0x1) +float 0xd8f0 < 0xfffc == 0x1 (0x1) +int 0xd8f0 > 0xfffc == 0x0 (0x0) +__uint 0xd8f0 > 0xfffc == 0x0 (0x0) +char 0xfff0 > 0xfffc == 0x0 (0x0) +__uchar 0xf0 > 0xfc == 0x0 (0x0) +__longlong 0xd8f0 > 0xfffc == 0x0 (0x0) +__ulonglong 0xd8f0 > 0xfffc == 0x0 (0x0) +float 0xd8f0 > 0xfffc == 0x0 (0x0) +int 0xd8f0 <= 0xfffc == 0x1 (0x1) +__uint 0xd8f0 <= 0xfffc == 0x1 (0x1) +char 0xfff0 <= 0xfffc == 0x1 (0x1) +__uchar 0xf0 <= 0xfc == 0x1 (0x1) +__longlong 0xd8f0 <= 0xfffc == 0x1 (0x1) +__ulonglong 0xd8f0 <= 0xfffc == 0x1 (0x1) +float 0xd8f0 <= 0xfffc == 0x1 (0x1) +int 0xd8f0 == 0xfffc == 0x0 (0x0) +__uint 0xd8f0 == 0xfffc == 0x0 (0x0) +char 0xfff0 == 0xfffc == 0x0 (0x0) +__uchar 0xf0 == 0xfc == 0x0 (0x0) +__longlong 0xd8f0 == 0xfffc == 0x0 (0x0) +__ulonglong 0xd8f0 == 0xfffc == 0x0 (0x0) +float 0xd8f0 == 0xfffc == 0x0 (0x0) +int 0xd8f0 != 0xfffc == 0x1 (0x1) +__uint 0xd8f0 != 0xfffc == 0x1 (0x1) +char 0xfff0 != 0xfffc == 0x1 (0x1) +__uchar 0xf0 != 0xfc == 0x1 (0x1) +__longlong 0xd8f0 != 0xfffc == 0x1 (0x1) +__ulonglong 0xd8f0 != 0xfffc == 0x1 (0x1) +float 0xd8f0 != 0xfffc == 0x1 (0x1) +int 0xd8f0 >= 0xfffc == 0x0 (0x0) +__uint 0xd8f0 >= 0xfffc == 0x0 (0x0) +char 0xfff0 >= 0xfffc == 0x0 (0x0) +__uchar 0xf0 >= 0xfc == 0x0 (0x0) +__longlong 0xd8f0 >= 0xfffc == 0x0 (0x0) +__ulonglong 0xd8f0 >= 0xfffc == 0x0 (0x0) +float 0xd8f0 >= 0xfffc == 0x0 (0x0) +int 0xd8f0 / 0xfffc == 0x9c4 (0x9c4) +__uint 0xd8f0 / 0xfffc == 0x0 (0x0) +char 0xfff0 / 0xfffc == 0x4 (0x4) +__uchar 0xf0 / 0xfc == 0x0 (0x0) +__longlong 0xd8f0 / 0xfffc == 0x9c4 (0x9c4) +__ulonglong 0xd8f0 / 0xfffc == 0x0 (0x0) +float 0xd8f0 / 0xfffc == 0x9c4 (0x9c4) +int 0xd8f0 % 0xfffc == 0x0 (0x0) +__uint 0xd8f0 % 0xfffc == -0x2710 (0xd8f0) +char 0xfff0 % 0xfffc == 0x0 (0x0) +__uchar 0xf0 % 0xfc == 0xf0 (0xf0) +__longlong 0xd8f0 % 0xfffc == 0x0 (0x0) +__ulonglong 0xd8f0 % 0xfffc == -0x2710 (0xd8f0) +0xd8f0 * 0xa == 0x7960 +0xd8f0 / 0xa == -0x3e8 +0xd8f0 % 0xa == 0x0 +int 0xd8f0 ^ 0xa == -0x2706 (0xd8fa) +__uint 0xd8f0 ^ 0xa == -0x2706 (0xd8fa) +char 0xfff0 ^ 0xa == -0x6 (0xfffa) +__uchar 0xf0 ^ 0xa == 0xfa (0xfa) +__longlong 0xd8f0 ^ 0xa == -0x2706 (0xd8fa) +__ulonglong 0xd8f0 ^ 0xa == -0x2706 (0xd8fa) +int 0xd8f0 && 0xa == 0x1 (0x1) +__uint 0xd8f0 && 0xa == 0x1 (0x1) +char 0xfff0 && 0xa == 0x1 (0x1) +__uchar 0xf0 && 0xa == 0x1 (0x1) +__longlong 0xd8f0 && 0xa == 0x1 (0x1) +__ulonglong 0xd8f0 && 0xa == 0x1 (0x1) +int 0xd8f0 || 0xa == 0x1 (0x1) +__uint 0xd8f0 || 0xa == 0x1 (0x1) +char 0xfff0 || 0xa == 0x1 (0x1) +__uchar 0xf0 || 0xa == 0x1 (0x1) +__longlong 0xd8f0 || 0xa == 0x1 (0x1) +__ulonglong 0xd8f0 || 0xa == 0x1 (0x1) +int 0xd8f0 & 0xa == 0x0 (0x0) +__uint 0xd8f0 & 0xa == 0x0 (0x0) +char 0xfff0 & 0xa == 0x0 (0x0) +__uchar 0xf0 & 0xa == 0x0 (0x0) +__longlong 0xd8f0 & 0xa == 0x0 (0x0) +__ulonglong 0xd8f0 & 0xa == 0x0 (0x0) +int 0xd8f0 | 0xa == -0x2706 (0xd8fa) +__uint 0xd8f0 | 0xa == -0x2706 (0xd8fa) +char 0xfff0 | 0xa == -0x6 (0xfffa) +__uchar 0xf0 | 0xa == 0xfa (0xfa) +__longlong 0xd8f0 | 0xa == -0x2706 (0xd8fa) +__ulonglong 0xd8f0 | 0xa == -0x2706 (0xd8fa) +int 0xd8f0 << 0x7 == 0x7800 (0x7800) +__uint 0xd8f0 << 0x7 == 0x7800 (0x7800) +char 0xfff0 << 0x7 == 0x0 (0x0) +__uchar 0xf0 << 0x7 == 0x0 (0x0) +__longlong 0xd8f0 << 0x7 == 0x7800 (0x7800) +__ulonglong 0xd8f0 << 0x7 == 0x7800 (0x7800) +int 0xd8f0 >> 0x7 == -0x4f (0xffb1) +__uint 0xd8f0 >> 0x7 == 0x1b1 (0x1b1) +char 0xfff0 >> 0x7 == -0x1 (0xffff) +__uchar 0xf0 >> 0x7 == 0x1 (0x1) +__longlong 0xd8f0 >> 0x7 == -0x4f (0xffb1) +__ulonglong 0xd8f0 >> 0x7 == -0x4f (0xffb1) +int 0xd8f0 + 0xa == -0x2706 (0xd8fa) +__uint 0xd8f0 + 0xa == -0x2706 (0xd8fa) +char 0xfff0 + 0xa == -0x6 (0xfffa) +__uchar 0xf0 + 0xa == 0xfa (0xfa) +__longlong 0xd8f0 + 0xa == -0x2706 (0xd8fa) +__ulonglong 0xd8f0 + 0xa == -0x2706 (0xd8fa) +float 0xd8f0 + 0xa == -0x2706 (0xd8fa) +int 0xd8f0 - 0xa == -0x271a (0xd8e6) +__uint 0xd8f0 - 0xa == -0x271a (0xd8e6) +char 0xfff0 - 0xa == -0x1a (0xffe6) +__uchar 0xf0 - 0xa == 0xe6 (0xe6) +__longlong 0xd8f0 - 0xa == -0x271a (0xd8e6) +__ulonglong 0xd8f0 - 0xa == -0x271a (0xd8e6) +float 0xd8f0 - 0xa == -0x271a (0xd8e6) +int 0xd8f0 * 0xa == 0x7960 (0x7960) +__uint 0xd8f0 * 0xa == 0x7960 (0x7960) +char 0xfff0 * 0xa == 0x60 (0x60) +__uchar 0xf0 * 0xa == 0x60 (0x60) +__longlong 0xd8f0 * 0xa == 0x7960 (0x7960) +__ulonglong 0xd8f0 * 0xa == 0x7960 (0x7960) +float 0xd8f0 * 0xa == -0x8000 (0x8000) +int 0xd8f0 < 0xa == 0x1 (0x1) +__uint 0xd8f0 < 0xa == 0x0 (0x0) +char 0xfff0 < 0xa == 0x1 (0x1) +__uchar 0xf0 < 0xa == 0x0 (0x0) +__longlong 0xd8f0 < 0xa == 0x1 (0x1) +__ulonglong 0xd8f0 < 0xa == 0x0 (0x0) +float 0xd8f0 < 0xa == 0x1 (0x1) +int 0xd8f0 > 0xa == 0x0 (0x0) +__uint 0xd8f0 > 0xa == 0x1 (0x1) +char 0xfff0 > 0xa == 0x0 (0x0) +__uchar 0xf0 > 0xa == 0x1 (0x1) +__longlong 0xd8f0 > 0xa == 0x0 (0x0) +__ulonglong 0xd8f0 > 0xa == 0x1 (0x1) +float 0xd8f0 > 0xa == 0x0 (0x0) +int 0xd8f0 <= 0xa == 0x1 (0x1) +__uint 0xd8f0 <= 0xa == 0x0 (0x0) +char 0xfff0 <= 0xa == 0x1 (0x1) +__uchar 0xf0 <= 0xa == 0x0 (0x0) +__longlong 0xd8f0 <= 0xa == 0x1 (0x1) +__ulonglong 0xd8f0 <= 0xa == 0x0 (0x0) +float 0xd8f0 <= 0xa == 0x1 (0x1) +int 0xd8f0 == 0xa == 0x0 (0x0) +__uint 0xd8f0 == 0xa == 0x0 (0x0) +char 0xfff0 == 0xa == 0x0 (0x0) +__uchar 0xf0 == 0xa == 0x0 (0x0) +__longlong 0xd8f0 == 0xa == 0x0 (0x0) +__ulonglong 0xd8f0 == 0xa == 0x0 (0x0) +float 0xd8f0 == 0xa == 0x0 (0x0) +int 0xd8f0 != 0xa == 0x1 (0x1) +__uint 0xd8f0 != 0xa == 0x1 (0x1) +char 0xfff0 != 0xa == 0x1 (0x1) +__uchar 0xf0 != 0xa == 0x1 (0x1) +__longlong 0xd8f0 != 0xa == 0x1 (0x1) +__ulonglong 0xd8f0 != 0xa == 0x1 (0x1) +float 0xd8f0 != 0xa == 0x1 (0x1) +int 0xd8f0 >= 0xa == 0x0 (0x0) +__uint 0xd8f0 >= 0xa == 0x1 (0x1) +char 0xfff0 >= 0xa == 0x0 (0x0) +__uchar 0xf0 >= 0xa == 0x1 (0x1) +__longlong 0xd8f0 >= 0xa == 0x0 (0x0) +__ulonglong 0xd8f0 >= 0xa == 0x1 (0x1) +float 0xd8f0 >= 0xa == 0x0 (0x0) +int 0xd8f0 / 0xa == -0x3e8 (0xfc18) +__uint 0xd8f0 / 0xa == 0x15b1 (0x15b1) +char 0xfff0 / 0xa == -0x1 (0xffff) +__uchar 0xf0 / 0xa == 0x18 (0x18) +__longlong 0xd8f0 / 0xa == -0x3e8 (0xfc18) +__ulonglong 0xd8f0 / 0xa == -0x6a4f (0x95b1) +float 0xd8f0 / 0xa == -0x3e8 (0xfc18) +int 0xd8f0 % 0xa == 0x0 (0x0) +__uint 0xd8f0 % 0xa == 0x6 (0x6) +char 0xfff0 % 0xa == -0x6 (0xfffa) +__uchar 0xf0 % 0xa == 0x0 (0x0) +__longlong 0xd8f0 % 0xa == 0x0 (0x0) +__ulonglong 0xd8f0 % 0xa == 0x6 (0x6) +0xd8f0 * 0xfff6 == -0x7960 +0xd8f0 / 0xfff6 == 0x3e8 +0xd8f0 % 0xfff6 == 0x0 +int 0xd8f0 ^ 0xfff6 == 0x2706 (0x2706) +__uint 0xd8f0 ^ 0xfff6 == 0x2706 (0x2706) +char 0xfff0 ^ 0xfff6 == 0x6 (0x6) +__uchar 0xf0 ^ 0xf6 == 0x6 (0x6) +__longlong 0xd8f0 ^ 0xfff6 == 0x2706 (0x2706) +__ulonglong 0xd8f0 ^ 0xfff6 == 0x2706 (0x2706) +int 0xd8f0 && 0xfff6 == 0x1 (0x1) +__uint 0xd8f0 && 0xfff6 == 0x1 (0x1) +char 0xfff0 && 0xfff6 == 0x1 (0x1) +__uchar 0xf0 && 0xf6 == 0x1 (0x1) +__longlong 0xd8f0 && 0xfff6 == 0x1 (0x1) +__ulonglong 0xd8f0 && 0xfff6 == 0x1 (0x1) +int 0xd8f0 || 0xfff6 == 0x1 (0x1) +__uint 0xd8f0 || 0xfff6 == 0x1 (0x1) +char 0xfff0 || 0xfff6 == 0x1 (0x1) +__uchar 0xf0 || 0xf6 == 0x1 (0x1) +__longlong 0xd8f0 || 0xfff6 == 0x1 (0x1) +__ulonglong 0xd8f0 || 0xfff6 == 0x1 (0x1) +int 0xd8f0 & 0xfff6 == -0x2710 (0xd8f0) +__uint 0xd8f0 & 0xfff6 == -0x2710 (0xd8f0) +char 0xfff0 & 0xfff6 == -0x10 (0xfff0) +__uchar 0xf0 & 0xf6 == 0xf0 (0xf0) +__longlong 0xd8f0 & 0xfff6 == -0x2710 (0xd8f0) +__ulonglong 0xd8f0 & 0xfff6 == -0x2710 (0xd8f0) +int 0xd8f0 | 0xfff6 == -0xa (0xfff6) +__uint 0xd8f0 | 0xfff6 == -0xa (0xfff6) +char 0xfff0 | 0xfff6 == -0xa (0xfff6) +__uchar 0xf0 | 0xf6 == 0xf6 (0xf6) +__longlong 0xd8f0 | 0xfff6 == -0xa (0xfff6) +__ulonglong 0xd8f0 | 0xfff6 == -0xa (0xfff6) +int 0xd8f0 << 0x8 == -0x1000 (0xf000) +__uint 0xd8f0 << 0x8 == -0x1000 (0xf000) +char 0xfff0 << 0x8 == 0x0 (0x0) +__uchar 0xf0 << 0x8 == 0x0 (0x0) +__longlong 0xd8f0 << 0x8 == -0x1000 (0xf000) +__ulonglong 0xd8f0 << 0x8 == -0x1000 (0xf000) +int 0xd8f0 >> 0x8 == -0x28 (0xffd8) +__uint 0xd8f0 >> 0x8 == 0xd8 (0xd8) +char 0xfff0 >> 0x8 == -0x1 (0xffff) +__uchar 0xf0 >> 0x8 == 0x0 (0x0) +__longlong 0xd8f0 >> 0x8 == -0x28 (0xffd8) +__ulonglong 0xd8f0 >> 0x8 == -0x28 (0xffd8) +int 0xd8f0 + 0xfff6 == -0x271a (0xd8e6) +__uint 0xd8f0 + 0xfff6 == -0x271a (0xd8e6) +char 0xfff0 + 0xfff6 == -0x1a (0xffe6) +__uchar 0xf0 + 0xf6 == 0xe6 (0xe6) +__longlong 0xd8f0 + 0xfff6 == -0x271a (0xd8e6) +__ulonglong 0xd8f0 + 0xfff6 == -0x271a (0xd8e6) +float 0xd8f0 + 0xfff6 == -0x271a (0xd8e6) +int 0xd8f0 - 0xfff6 == -0x2706 (0xd8fa) +__uint 0xd8f0 - 0xfff6 == -0x2706 (0xd8fa) +char 0xfff0 - 0xfff6 == -0x6 (0xfffa) +__uchar 0xf0 - 0xf6 == 0xfa (0xfa) +__longlong 0xd8f0 - 0xfff6 == -0x2706 (0xd8fa) +__ulonglong 0xd8f0 - 0xfff6 == -0x2706 (0xd8fa) +float 0xd8f0 - 0xfff6 == -0x2706 (0xd8fa) +int 0xd8f0 * 0xfff6 == -0x7960 (0x86a0) +__uint 0xd8f0 * 0xfff6 == -0x7960 (0x86a0) +char 0xfff0 * 0xfff6 == -0x60 (0xffa0) +__uchar 0xf0 * 0xf6 == 0xa0 (0xa0) +__longlong 0xd8f0 * 0xfff6 == -0x7960 (0x86a0) +__ulonglong 0xd8f0 * 0xfff6 == -0x7960 (0x86a0) +float 0xd8f0 * 0xfff6 == -0x8000 (0x8000) +int 0xd8f0 < 0xfff6 == 0x1 (0x1) +__uint 0xd8f0 < 0xfff6 == 0x1 (0x1) +char 0xfff0 < 0xfff6 == 0x1 (0x1) +__uchar 0xf0 < 0xf6 == 0x1 (0x1) +__longlong 0xd8f0 < 0xfff6 == 0x1 (0x1) +__ulonglong 0xd8f0 < 0xfff6 == 0x1 (0x1) +float 0xd8f0 < 0xfff6 == 0x1 (0x1) +int 0xd8f0 > 0xfff6 == 0x0 (0x0) +__uint 0xd8f0 > 0xfff6 == 0x0 (0x0) +char 0xfff0 > 0xfff6 == 0x0 (0x0) +__uchar 0xf0 > 0xf6 == 0x0 (0x0) +__longlong 0xd8f0 > 0xfff6 == 0x0 (0x0) +__ulonglong 0xd8f0 > 0xfff6 == 0x0 (0x0) +float 0xd8f0 > 0xfff6 == 0x0 (0x0) +int 0xd8f0 <= 0xfff6 == 0x1 (0x1) +__uint 0xd8f0 <= 0xfff6 == 0x1 (0x1) +char 0xfff0 <= 0xfff6 == 0x1 (0x1) +__uchar 0xf0 <= 0xf6 == 0x1 (0x1) +__longlong 0xd8f0 <= 0xfff6 == 0x1 (0x1) +__ulonglong 0xd8f0 <= 0xfff6 == 0x1 (0x1) +float 0xd8f0 <= 0xfff6 == 0x1 (0x1) +int 0xd8f0 == 0xfff6 == 0x0 (0x0) +__uint 0xd8f0 == 0xfff6 == 0x0 (0x0) +char 0xfff0 == 0xfff6 == 0x0 (0x0) +__uchar 0xf0 == 0xf6 == 0x0 (0x0) +__longlong 0xd8f0 == 0xfff6 == 0x0 (0x0) +__ulonglong 0xd8f0 == 0xfff6 == 0x0 (0x0) +float 0xd8f0 == 0xfff6 == 0x0 (0x0) +int 0xd8f0 != 0xfff6 == 0x1 (0x1) +__uint 0xd8f0 != 0xfff6 == 0x1 (0x1) +char 0xfff0 != 0xfff6 == 0x1 (0x1) +__uchar 0xf0 != 0xf6 == 0x1 (0x1) +__longlong 0xd8f0 != 0xfff6 == 0x1 (0x1) +__ulonglong 0xd8f0 != 0xfff6 == 0x1 (0x1) +float 0xd8f0 != 0xfff6 == 0x1 (0x1) +int 0xd8f0 >= 0xfff6 == 0x0 (0x0) +__uint 0xd8f0 >= 0xfff6 == 0x0 (0x0) +char 0xfff0 >= 0xfff6 == 0x0 (0x0) +__uchar 0xf0 >= 0xf6 == 0x0 (0x0) +__longlong 0xd8f0 >= 0xfff6 == 0x0 (0x0) +__ulonglong 0xd8f0 >= 0xfff6 == 0x0 (0x0) +float 0xd8f0 >= 0xfff6 == 0x0 (0x0) +int 0xd8f0 / 0xfff6 == 0x3e8 (0x3e8) +__uint 0xd8f0 / 0xfff6 == 0x0 (0x0) +char 0xfff0 / 0xfff6 == 0x1 (0x1) +__uchar 0xf0 / 0xf6 == 0x0 (0x0) +__longlong 0xd8f0 / 0xfff6 == 0x3e8 (0x3e8) +__ulonglong 0xd8f0 / 0xfff6 == 0x0 (0x0) +float 0xd8f0 / 0xfff6 == 0x3e8 (0x3e8) +int 0xd8f0 % 0xfff6 == 0x0 (0x0) +__uint 0xd8f0 % 0xfff6 == -0x2710 (0xd8f0) +char 0xfff0 % 0xfff6 == -0x6 (0xfffa) +__uchar 0xf0 % 0xf6 == 0xf0 (0xf0) +__longlong 0xd8f0 % 0xfff6 == 0x0 (0x0) +__ulonglong 0xd8f0 % 0xfff6 == -0x2710 (0xd8f0) +0xd8f0 * 0x5 == 0x3cb0 +0xd8f0 / 0x5 == -0x7d0 +0xd8f0 % 0x5 == 0x0 +int 0xd8f0 ^ 0x5 == -0x270b (0xd8f5) +__uint 0xd8f0 ^ 0x5 == -0x270b (0xd8f5) +char 0xfff0 ^ 0x5 == -0xb (0xfff5) +__uchar 0xf0 ^ 0x5 == 0xf5 (0xf5) +__longlong 0xd8f0 ^ 0x5 == -0x270b (0xd8f5) +__ulonglong 0xd8f0 ^ 0x5 == -0x270b (0xd8f5) +int 0xd8f0 && 0x5 == 0x1 (0x1) +__uint 0xd8f0 && 0x5 == 0x1 (0x1) +char 0xfff0 && 0x5 == 0x1 (0x1) +__uchar 0xf0 && 0x5 == 0x1 (0x1) +__longlong 0xd8f0 && 0x5 == 0x1 (0x1) +__ulonglong 0xd8f0 && 0x5 == 0x1 (0x1) +int 0xd8f0 || 0x5 == 0x1 (0x1) +__uint 0xd8f0 || 0x5 == 0x1 (0x1) +char 0xfff0 || 0x5 == 0x1 (0x1) +__uchar 0xf0 || 0x5 == 0x1 (0x1) +__longlong 0xd8f0 || 0x5 == 0x1 (0x1) +__ulonglong 0xd8f0 || 0x5 == 0x1 (0x1) +int 0xd8f0 & 0x5 == 0x0 (0x0) +__uint 0xd8f0 & 0x5 == 0x0 (0x0) +char 0xfff0 & 0x5 == 0x0 (0x0) +__uchar 0xf0 & 0x5 == 0x0 (0x0) +__longlong 0xd8f0 & 0x5 == 0x0 (0x0) +__ulonglong 0xd8f0 & 0x5 == 0x0 (0x0) +int 0xd8f0 | 0x5 == -0x270b (0xd8f5) +__uint 0xd8f0 | 0x5 == -0x270b (0xd8f5) +char 0xfff0 | 0x5 == -0xb (0xfff5) +__uchar 0xf0 | 0x5 == 0xf5 (0xf5) +__longlong 0xd8f0 | 0x5 == -0x270b (0xd8f5) +__ulonglong 0xd8f0 | 0x5 == -0x270b (0xd8f5) +int 0xd8f0 << 0x9 == -0x2000 (0xe000) +__uint 0xd8f0 << 0x9 == -0x2000 (0xe000) +char 0xfff0 << 0x9 == 0x0 (0x0) +__uchar 0xf0 << 0x9 == 0x0 (0x0) +__longlong 0xd8f0 << 0x9 == -0x2000 (0xe000) +__ulonglong 0xd8f0 << 0x9 == -0x2000 (0xe000) +int 0xd8f0 >> 0x9 == -0x14 (0xffec) +__uint 0xd8f0 >> 0x9 == 0x6c (0x6c) +char 0xfff0 >> 0x9 == -0x1 (0xffff) +__uchar 0xf0 >> 0x9 == 0x0 (0x0) +__longlong 0xd8f0 >> 0x9 == -0x14 (0xffec) +__ulonglong 0xd8f0 >> 0x9 == -0x14 (0xffec) +int 0xd8f0 + 0x5 == -0x270b (0xd8f5) +__uint 0xd8f0 + 0x5 == -0x270b (0xd8f5) +char 0xfff0 + 0x5 == -0xb (0xfff5) +__uchar 0xf0 + 0x5 == 0xf5 (0xf5) +__longlong 0xd8f0 + 0x5 == -0x270b (0xd8f5) +__ulonglong 0xd8f0 + 0x5 == -0x270b (0xd8f5) +float 0xd8f0 + 0x5 == -0x270b (0xd8f5) +int 0xd8f0 - 0x5 == -0x2715 (0xd8eb) +__uint 0xd8f0 - 0x5 == -0x2715 (0xd8eb) +char 0xfff0 - 0x5 == -0x15 (0xffeb) +__uchar 0xf0 - 0x5 == 0xeb (0xeb) +__longlong 0xd8f0 - 0x5 == -0x2715 (0xd8eb) +__ulonglong 0xd8f0 - 0x5 == -0x2715 (0xd8eb) +float 0xd8f0 - 0x5 == -0x2715 (0xd8eb) +int 0xd8f0 * 0x5 == 0x3cb0 (0x3cb0) +__uint 0xd8f0 * 0x5 == 0x3cb0 (0x3cb0) +char 0xfff0 * 0x5 == -0x50 (0xffb0) +__uchar 0xf0 * 0x5 == 0xb0 (0xb0) +__longlong 0xd8f0 * 0x5 == 0x3cb0 (0x3cb0) +__ulonglong 0xd8f0 * 0x5 == 0x3cb0 (0x3cb0) +float 0xd8f0 * 0x5 == -0x8000 (0x8000) +int 0xd8f0 < 0x5 == 0x1 (0x1) +__uint 0xd8f0 < 0x5 == 0x0 (0x0) +char 0xfff0 < 0x5 == 0x1 (0x1) +__uchar 0xf0 < 0x5 == 0x0 (0x0) +__longlong 0xd8f0 < 0x5 == 0x1 (0x1) +__ulonglong 0xd8f0 < 0x5 == 0x0 (0x0) +float 0xd8f0 < 0x5 == 0x1 (0x1) +int 0xd8f0 > 0x5 == 0x0 (0x0) +__uint 0xd8f0 > 0x5 == 0x1 (0x1) +char 0xfff0 > 0x5 == 0x0 (0x0) +__uchar 0xf0 > 0x5 == 0x1 (0x1) +__longlong 0xd8f0 > 0x5 == 0x0 (0x0) +__ulonglong 0xd8f0 > 0x5 == 0x1 (0x1) +float 0xd8f0 > 0x5 == 0x0 (0x0) +int 0xd8f0 <= 0x5 == 0x1 (0x1) +__uint 0xd8f0 <= 0x5 == 0x0 (0x0) +char 0xfff0 <= 0x5 == 0x1 (0x1) +__uchar 0xf0 <= 0x5 == 0x0 (0x0) +__longlong 0xd8f0 <= 0x5 == 0x1 (0x1) +__ulonglong 0xd8f0 <= 0x5 == 0x0 (0x0) +float 0xd8f0 <= 0x5 == 0x1 (0x1) +int 0xd8f0 == 0x5 == 0x0 (0x0) +__uint 0xd8f0 == 0x5 == 0x0 (0x0) +char 0xfff0 == 0x5 == 0x0 (0x0) +__uchar 0xf0 == 0x5 == 0x0 (0x0) +__longlong 0xd8f0 == 0x5 == 0x0 (0x0) +__ulonglong 0xd8f0 == 0x5 == 0x0 (0x0) +float 0xd8f0 == 0x5 == 0x0 (0x0) +int 0xd8f0 != 0x5 == 0x1 (0x1) +__uint 0xd8f0 != 0x5 == 0x1 (0x1) +char 0xfff0 != 0x5 == 0x1 (0x1) +__uchar 0xf0 != 0x5 == 0x1 (0x1) +__longlong 0xd8f0 != 0x5 == 0x1 (0x1) +__ulonglong 0xd8f0 != 0x5 == 0x1 (0x1) +float 0xd8f0 != 0x5 == 0x1 (0x1) +int 0xd8f0 >= 0x5 == 0x0 (0x0) +__uint 0xd8f0 >= 0x5 == 0x1 (0x1) +char 0xfff0 >= 0x5 == 0x0 (0x0) +__uchar 0xf0 >= 0x5 == 0x1 (0x1) +__longlong 0xd8f0 >= 0x5 == 0x0 (0x0) +__ulonglong 0xd8f0 >= 0x5 == 0x1 (0x1) +float 0xd8f0 >= 0x5 == 0x0 (0x0) +int 0xd8f0 / 0x5 == -0x7d0 (0xf830) +__uint 0xd8f0 / 0x5 == 0x2b63 (0x2b63) +char 0xfff0 / 0x5 == -0x3 (0xfffd) +__uchar 0xf0 / 0x5 == 0x30 (0x30) +__longlong 0xd8f0 / 0x5 == -0x7d0 (0xf830) +__ulonglong 0xd8f0 / 0x5 == 0x2b63 (0x2b63) +float 0xd8f0 / 0x5 == -0x7d0 (0xf830) +int 0xd8f0 % 0x5 == 0x0 (0x0) +__uint 0xd8f0 % 0x5 == 0x1 (0x1) +char 0xfff0 % 0x5 == -0x1 (0xffff) +__uchar 0xf0 % 0x5 == 0x0 (0x0) +__longlong 0xd8f0 % 0x5 == 0x0 (0x0) +__ulonglong 0xd8f0 % 0x5 == 0x1 (0x1) +0xd8f0 * 0x7 == -0x1170 +0xd8f0 / 0x7 == -0x594 +0xd8f0 % 0x7 == -0x4 +int 0xd8f0 ^ 0x7 == -0x2709 (0xd8f7) +__uint 0xd8f0 ^ 0x7 == -0x2709 (0xd8f7) +char 0xfff0 ^ 0x7 == -0x9 (0xfff7) +__uchar 0xf0 ^ 0x7 == 0xf7 (0xf7) +__longlong 0xd8f0 ^ 0x7 == -0x2709 (0xd8f7) +__ulonglong 0xd8f0 ^ 0x7 == -0x2709 (0xd8f7) +int 0xd8f0 && 0x7 == 0x1 (0x1) +__uint 0xd8f0 && 0x7 == 0x1 (0x1) +char 0xfff0 && 0x7 == 0x1 (0x1) +__uchar 0xf0 && 0x7 == 0x1 (0x1) +__longlong 0xd8f0 && 0x7 == 0x1 (0x1) +__ulonglong 0xd8f0 && 0x7 == 0x1 (0x1) +int 0xd8f0 || 0x7 == 0x1 (0x1) +__uint 0xd8f0 || 0x7 == 0x1 (0x1) +char 0xfff0 || 0x7 == 0x1 (0x1) +__uchar 0xf0 || 0x7 == 0x1 (0x1) +__longlong 0xd8f0 || 0x7 == 0x1 (0x1) +__ulonglong 0xd8f0 || 0x7 == 0x1 (0x1) +int 0xd8f0 & 0x7 == 0x0 (0x0) +__uint 0xd8f0 & 0x7 == 0x0 (0x0) +char 0xfff0 & 0x7 == 0x0 (0x0) +__uchar 0xf0 & 0x7 == 0x0 (0x0) +__longlong 0xd8f0 & 0x7 == 0x0 (0x0) +__ulonglong 0xd8f0 & 0x7 == 0x0 (0x0) +int 0xd8f0 | 0x7 == -0x2709 (0xd8f7) +__uint 0xd8f0 | 0x7 == -0x2709 (0xd8f7) +char 0xfff0 | 0x7 == -0x9 (0xfff7) +__uchar 0xf0 | 0x7 == 0xf7 (0xf7) +__longlong 0xd8f0 | 0x7 == -0x2709 (0xd8f7) +__ulonglong 0xd8f0 | 0x7 == -0x2709 (0xd8f7) +int 0xd8f0 << 0xa == -0x4000 (0xc000) +__uint 0xd8f0 << 0xa == -0x4000 (0xc000) +char 0xfff0 << 0xa == 0x0 (0x0) +__uchar 0xf0 << 0xa == 0x0 (0x0) +__longlong 0xd8f0 << 0xa == -0x4000 (0xc000) +__ulonglong 0xd8f0 << 0xa == -0x4000 (0xc000) +int 0xd8f0 >> 0xa == -0xa (0xfff6) +__uint 0xd8f0 >> 0xa == 0x36 (0x36) +char 0xfff0 >> 0xa == -0x1 (0xffff) +__uchar 0xf0 >> 0xa == 0x0 (0x0) +__longlong 0xd8f0 >> 0xa == -0xa (0xfff6) +__ulonglong 0xd8f0 >> 0xa == -0xa (0xfff6) +int 0xd8f0 + 0x7 == -0x2709 (0xd8f7) +__uint 0xd8f0 + 0x7 == -0x2709 (0xd8f7) +char 0xfff0 + 0x7 == -0x9 (0xfff7) +__uchar 0xf0 + 0x7 == 0xf7 (0xf7) +__longlong 0xd8f0 + 0x7 == -0x2709 (0xd8f7) +__ulonglong 0xd8f0 + 0x7 == -0x2709 (0xd8f7) +float 0xd8f0 + 0x7 == -0x2709 (0xd8f7) +int 0xd8f0 - 0x7 == -0x2717 (0xd8e9) +__uint 0xd8f0 - 0x7 == -0x2717 (0xd8e9) +char 0xfff0 - 0x7 == -0x17 (0xffe9) +__uchar 0xf0 - 0x7 == 0xe9 (0xe9) +__longlong 0xd8f0 - 0x7 == -0x2717 (0xd8e9) +__ulonglong 0xd8f0 - 0x7 == -0x2717 (0xd8e9) +float 0xd8f0 - 0x7 == -0x2717 (0xd8e9) +int 0xd8f0 * 0x7 == -0x1170 (0xee90) +__uint 0xd8f0 * 0x7 == -0x1170 (0xee90) +char 0xfff0 * 0x7 == -0x70 (0xff90) +__uchar 0xf0 * 0x7 == 0x90 (0x90) +__longlong 0xd8f0 * 0x7 == -0x1170 (0xee90) +__ulonglong 0xd8f0 * 0x7 == -0x1170 (0xee90) +float 0xd8f0 * 0x7 == -0x8000 (0x8000) +int 0xd8f0 < 0x7 == 0x1 (0x1) +__uint 0xd8f0 < 0x7 == 0x0 (0x0) +char 0xfff0 < 0x7 == 0x1 (0x1) +__uchar 0xf0 < 0x7 == 0x0 (0x0) +__longlong 0xd8f0 < 0x7 == 0x1 (0x1) +__ulonglong 0xd8f0 < 0x7 == 0x0 (0x0) +float 0xd8f0 < 0x7 == 0x1 (0x1) +int 0xd8f0 > 0x7 == 0x0 (0x0) +__uint 0xd8f0 > 0x7 == 0x1 (0x1) +char 0xfff0 > 0x7 == 0x0 (0x0) +__uchar 0xf0 > 0x7 == 0x1 (0x1) +__longlong 0xd8f0 > 0x7 == 0x0 (0x0) +__ulonglong 0xd8f0 > 0x7 == 0x1 (0x1) +float 0xd8f0 > 0x7 == 0x0 (0x0) +int 0xd8f0 <= 0x7 == 0x1 (0x1) +__uint 0xd8f0 <= 0x7 == 0x0 (0x0) +char 0xfff0 <= 0x7 == 0x1 (0x1) +__uchar 0xf0 <= 0x7 == 0x0 (0x0) +__longlong 0xd8f0 <= 0x7 == 0x1 (0x1) +__ulonglong 0xd8f0 <= 0x7 == 0x0 (0x0) +float 0xd8f0 <= 0x7 == 0x1 (0x1) +int 0xd8f0 == 0x7 == 0x0 (0x0) +__uint 0xd8f0 == 0x7 == 0x0 (0x0) +char 0xfff0 == 0x7 == 0x0 (0x0) +__uchar 0xf0 == 0x7 == 0x0 (0x0) +__longlong 0xd8f0 == 0x7 == 0x0 (0x0) +__ulonglong 0xd8f0 == 0x7 == 0x0 (0x0) +float 0xd8f0 == 0x7 == 0x0 (0x0) +int 0xd8f0 != 0x7 == 0x1 (0x1) +__uint 0xd8f0 != 0x7 == 0x1 (0x1) +char 0xfff0 != 0x7 == 0x1 (0x1) +__uchar 0xf0 != 0x7 == 0x1 (0x1) +__longlong 0xd8f0 != 0x7 == 0x1 (0x1) +__ulonglong 0xd8f0 != 0x7 == 0x1 (0x1) +float 0xd8f0 != 0x7 == 0x1 (0x1) +int 0xd8f0 >= 0x7 == 0x0 (0x0) +__uint 0xd8f0 >= 0x7 == 0x1 (0x1) +char 0xfff0 >= 0x7 == 0x0 (0x0) +__uchar 0xf0 >= 0x7 == 0x1 (0x1) +__longlong 0xd8f0 >= 0x7 == 0x0 (0x0) +__ulonglong 0xd8f0 >= 0x7 == 0x1 (0x1) +float 0xd8f0 >= 0x7 == 0x0 (0x0) +int 0xd8f0 / 0x7 == -0x594 (0xfa6c) +__uint 0xd8f0 / 0x7 == 0x1efd (0x1efd) +char 0xfff0 / 0x7 == -0x2 (0xfffe) +__uchar 0xf0 / 0x7 == 0x22 (0x22) +__longlong 0xd8f0 / 0x7 == -0x594 (0xfa6c) +__ulonglong 0xd8f0 / 0x7 == 0x4390 (0x4390) +float 0xd8f0 / 0x7 == -0x594 (0xfa6c) +int 0xd8f0 % 0x7 == -0x4 (0xfffc) +__uint 0xd8f0 % 0x7 == 0x5 (0x5) +char 0xfff0 % 0x7 == -0x2 (0xfffe) +__uchar 0xf0 % 0x7 == 0x2 (0x2) +__longlong 0xd8f0 % 0x7 == -0x4 (0xfffc) +__ulonglong 0xd8f0 % 0x7 == 0x0 (0x0) +0xd8f0 * 0x2a == -0x68a0 +0xd8f0 / 0x2a == -0xee +0xd8f0 % 0x2a == -0x4 +int 0xd8f0 ^ 0x2a == -0x2726 (0xd8da) +__uint 0xd8f0 ^ 0x2a == -0x2726 (0xd8da) +char 0xfff0 ^ 0x2a == -0x26 (0xffda) +__uchar 0xf0 ^ 0x2a == 0xda (0xda) +__longlong 0xd8f0 ^ 0x2a == -0x2726 (0xd8da) +__ulonglong 0xd8f0 ^ 0x2a == -0x2726 (0xd8da) +int 0xd8f0 && 0x2a == 0x1 (0x1) +__uint 0xd8f0 && 0x2a == 0x1 (0x1) +char 0xfff0 && 0x2a == 0x1 (0x1) +__uchar 0xf0 && 0x2a == 0x1 (0x1) +__longlong 0xd8f0 && 0x2a == 0x1 (0x1) +__ulonglong 0xd8f0 && 0x2a == 0x1 (0x1) +int 0xd8f0 || 0x2a == 0x1 (0x1) +__uint 0xd8f0 || 0x2a == 0x1 (0x1) +char 0xfff0 || 0x2a == 0x1 (0x1) +__uchar 0xf0 || 0x2a == 0x1 (0x1) +__longlong 0xd8f0 || 0x2a == 0x1 (0x1) +__ulonglong 0xd8f0 || 0x2a == 0x1 (0x1) +int 0xd8f0 & 0x2a == 0x20 (0x20) +__uint 0xd8f0 & 0x2a == 0x20 (0x20) +char 0xfff0 & 0x2a == 0x20 (0x20) +__uchar 0xf0 & 0x2a == 0x20 (0x20) +__longlong 0xd8f0 & 0x2a == 0x20 (0x20) +__ulonglong 0xd8f0 & 0x2a == 0x20 (0x20) +int 0xd8f0 | 0x2a == -0x2706 (0xd8fa) +__uint 0xd8f0 | 0x2a == -0x2706 (0xd8fa) +char 0xfff0 | 0x2a == -0x6 (0xfffa) +__uchar 0xf0 | 0x2a == 0xfa (0xfa) +__longlong 0xd8f0 | 0x2a == -0x2706 (0xd8fa) +__ulonglong 0xd8f0 | 0x2a == -0x2706 (0xd8fa) +int 0xd8f0 << 0xc == 0x0 (0x0) +__uint 0xd8f0 << 0xc == 0x0 (0x0) +char 0xfff0 << 0xc == 0x0 (0x0) +__uchar 0xf0 << 0xc == 0x0 (0x0) +__longlong 0xd8f0 << 0xc == 0x0 (0x0) +__ulonglong 0xd8f0 << 0xc == 0x0 (0x0) +int 0xd8f0 >> 0xc == -0x3 (0xfffd) +__uint 0xd8f0 >> 0xc == 0xd (0xd) +char 0xfff0 >> 0xc == -0x1 (0xffff) +__uchar 0xf0 >> 0xc == 0x0 (0x0) +__longlong 0xd8f0 >> 0xc == -0x3 (0xfffd) +__ulonglong 0xd8f0 >> 0xc == -0x3 (0xfffd) +int 0xd8f0 + 0x2a == -0x26e6 (0xd91a) +__uint 0xd8f0 + 0x2a == -0x26e6 (0xd91a) +char 0xfff0 + 0x2a == 0x1a (0x1a) +__uchar 0xf0 + 0x2a == 0x1a (0x1a) +__longlong 0xd8f0 + 0x2a == -0x26e6 (0xd91a) +__ulonglong 0xd8f0 + 0x2a == -0x26e6 (0xd91a) +float 0xd8f0 + 0x2a == -0x26e6 (0xd91a) +int 0xd8f0 - 0x2a == -0x273a (0xd8c6) +__uint 0xd8f0 - 0x2a == -0x273a (0xd8c6) +char 0xfff0 - 0x2a == -0x3a (0xffc6) +__uchar 0xf0 - 0x2a == 0xc6 (0xc6) +__longlong 0xd8f0 - 0x2a == -0x273a (0xd8c6) +__ulonglong 0xd8f0 - 0x2a == -0x273a (0xd8c6) +float 0xd8f0 - 0x2a == -0x273a (0xd8c6) +int 0xd8f0 * 0x2a == -0x68a0 (0x9760) +__uint 0xd8f0 * 0x2a == -0x68a0 (0x9760) +char 0xfff0 * 0x2a == 0x60 (0x60) +__uchar 0xf0 * 0x2a == 0x60 (0x60) +__longlong 0xd8f0 * 0x2a == -0x68a0 (0x9760) +__ulonglong 0xd8f0 * 0x2a == -0x68a0 (0x9760) +float 0xd8f0 * 0x2a == -0x8000 (0x8000) +int 0xd8f0 < 0x2a == 0x1 (0x1) +__uint 0xd8f0 < 0x2a == 0x0 (0x0) +char 0xfff0 < 0x2a == 0x1 (0x1) +__uchar 0xf0 < 0x2a == 0x0 (0x0) +__longlong 0xd8f0 < 0x2a == 0x1 (0x1) +__ulonglong 0xd8f0 < 0x2a == 0x0 (0x0) +float 0xd8f0 < 0x2a == 0x1 (0x1) +int 0xd8f0 > 0x2a == 0x0 (0x0) +__uint 0xd8f0 > 0x2a == 0x1 (0x1) +char 0xfff0 > 0x2a == 0x0 (0x0) +__uchar 0xf0 > 0x2a == 0x1 (0x1) +__longlong 0xd8f0 > 0x2a == 0x0 (0x0) +__ulonglong 0xd8f0 > 0x2a == 0x1 (0x1) +float 0xd8f0 > 0x2a == 0x0 (0x0) +int 0xd8f0 <= 0x2a == 0x1 (0x1) +__uint 0xd8f0 <= 0x2a == 0x0 (0x0) +char 0xfff0 <= 0x2a == 0x1 (0x1) +__uchar 0xf0 <= 0x2a == 0x0 (0x0) +__longlong 0xd8f0 <= 0x2a == 0x1 (0x1) +__ulonglong 0xd8f0 <= 0x2a == 0x0 (0x0) +float 0xd8f0 <= 0x2a == 0x1 (0x1) +int 0xd8f0 == 0x2a == 0x0 (0x0) +__uint 0xd8f0 == 0x2a == 0x0 (0x0) +char 0xfff0 == 0x2a == 0x0 (0x0) +__uchar 0xf0 == 0x2a == 0x0 (0x0) +__longlong 0xd8f0 == 0x2a == 0x0 (0x0) +__ulonglong 0xd8f0 == 0x2a == 0x0 (0x0) +float 0xd8f0 == 0x2a == 0x0 (0x0) +int 0xd8f0 != 0x2a == 0x1 (0x1) +__uint 0xd8f0 != 0x2a == 0x1 (0x1) +char 0xfff0 != 0x2a == 0x1 (0x1) +__uchar 0xf0 != 0x2a == 0x1 (0x1) +__longlong 0xd8f0 != 0x2a == 0x1 (0x1) +__ulonglong 0xd8f0 != 0x2a == 0x1 (0x1) +float 0xd8f0 != 0x2a == 0x1 (0x1) +int 0xd8f0 >= 0x2a == 0x0 (0x0) +__uint 0xd8f0 >= 0x2a == 0x1 (0x1) +char 0xfff0 >= 0x2a == 0x0 (0x0) +__uchar 0xf0 >= 0x2a == 0x1 (0x1) +__longlong 0xd8f0 >= 0x2a == 0x0 (0x0) +__ulonglong 0xd8f0 >= 0x2a == 0x1 (0x1) +float 0xd8f0 >= 0x2a == 0x0 (0x0) +int 0xd8f0 / 0x2a == -0xee (0xff12) +__uint 0xd8f0 / 0x2a == 0x52a (0x52a) +char 0xfff0 / 0x2a == 0x0 (0x0) +__uchar 0xf0 / 0x2a == 0x5 (0x5) +__longlong 0xd8f0 / 0x2a == -0xee (0xff12) +__ulonglong 0xd8f0 / 0x2a == 0x6098 (0x6098) +float 0xd8f0 / 0x2a == -0xee (0xff12) +int 0xd8f0 % 0x2a == -0x4 (0xfffc) +__uint 0xd8f0 % 0x2a == 0xc (0xc) +char 0xfff0 % 0x2a == -0x10 (0xfff0) +__uchar 0xf0 % 0x2a == 0x1e (0x1e) +__longlong 0xd8f0 % 0x2a == -0x4 (0xfffc) +__ulonglong 0xd8f0 % 0x2a == 0x0 (0x0) +0xd8f0 * 0x17 == 0x7d90 +0xd8f0 / 0x17 == -0x1b2 +0xd8f0 % 0x17 == -0x12 +int 0xd8f0 ^ 0x17 == -0x2719 (0xd8e7) +__uint 0xd8f0 ^ 0x17 == -0x2719 (0xd8e7) +char 0xfff0 ^ 0x17 == -0x19 (0xffe7) +__uchar 0xf0 ^ 0x17 == 0xe7 (0xe7) +__longlong 0xd8f0 ^ 0x17 == -0x2719 (0xd8e7) +__ulonglong 0xd8f0 ^ 0x17 == -0x2719 (0xd8e7) +int 0xd8f0 && 0x17 == 0x1 (0x1) +__uint 0xd8f0 && 0x17 == 0x1 (0x1) +char 0xfff0 && 0x17 == 0x1 (0x1) +__uchar 0xf0 && 0x17 == 0x1 (0x1) +__longlong 0xd8f0 && 0x17 == 0x1 (0x1) +__ulonglong 0xd8f0 && 0x17 == 0x1 (0x1) +int 0xd8f0 || 0x17 == 0x1 (0x1) +__uint 0xd8f0 || 0x17 == 0x1 (0x1) +char 0xfff0 || 0x17 == 0x1 (0x1) +__uchar 0xf0 || 0x17 == 0x1 (0x1) +__longlong 0xd8f0 || 0x17 == 0x1 (0x1) +__ulonglong 0xd8f0 || 0x17 == 0x1 (0x1) +int 0xd8f0 & 0x17 == 0x10 (0x10) +__uint 0xd8f0 & 0x17 == 0x10 (0x10) +char 0xfff0 & 0x17 == 0x10 (0x10) +__uchar 0xf0 & 0x17 == 0x10 (0x10) +__longlong 0xd8f0 & 0x17 == 0x10 (0x10) +__ulonglong 0xd8f0 & 0x17 == 0x10 (0x10) +int 0xd8f0 | 0x17 == -0x2709 (0xd8f7) +__uint 0xd8f0 | 0x17 == -0x2709 (0xd8f7) +char 0xfff0 | 0x17 == -0x9 (0xfff7) +__uchar 0xf0 | 0x17 == 0xf7 (0xf7) +__longlong 0xd8f0 | 0x17 == -0x2709 (0xd8f7) +__ulonglong 0xd8f0 | 0x17 == -0x2709 (0xd8f7) +int 0xd8f0 << 0xe == 0x0 (0x0) +__uint 0xd8f0 << 0xe == 0x0 (0x0) +char 0xfff0 << 0xe == 0x0 (0x0) +__uchar 0xf0 << 0xe == 0x0 (0x0) +__longlong 0xd8f0 << 0xe == 0x0 (0x0) +__ulonglong 0xd8f0 << 0xe == 0x0 (0x0) +int 0xd8f0 >> 0xe == -0x1 (0xffff) +__uint 0xd8f0 >> 0xe == 0x3 (0x3) +char 0xfff0 >> 0xe == -0x1 (0xffff) +__uchar 0xf0 >> 0xe == 0x0 (0x0) +__longlong 0xd8f0 >> 0xe == -0x1 (0xffff) +__ulonglong 0xd8f0 >> 0xe == -0x1 (0xffff) +int 0xd8f0 + 0x17 == -0x26f9 (0xd907) +__uint 0xd8f0 + 0x17 == -0x26f9 (0xd907) +char 0xfff0 + 0x17 == 0x7 (0x7) +__uchar 0xf0 + 0x17 == 0x7 (0x7) +__longlong 0xd8f0 + 0x17 == -0x26f9 (0xd907) +__ulonglong 0xd8f0 + 0x17 == -0x26f9 (0xd907) +float 0xd8f0 + 0x17 == -0x26f9 (0xd907) +int 0xd8f0 - 0x17 == -0x2727 (0xd8d9) +__uint 0xd8f0 - 0x17 == -0x2727 (0xd8d9) +char 0xfff0 - 0x17 == -0x27 (0xffd9) +__uchar 0xf0 - 0x17 == 0xd9 (0xd9) +__longlong 0xd8f0 - 0x17 == -0x2727 (0xd8d9) +__ulonglong 0xd8f0 - 0x17 == -0x2727 (0xd8d9) +float 0xd8f0 - 0x17 == -0x2727 (0xd8d9) +int 0xd8f0 * 0x17 == 0x7d90 (0x7d90) +__uint 0xd8f0 * 0x17 == 0x7d90 (0x7d90) +char 0xfff0 * 0x17 == -0x70 (0xff90) +__uchar 0xf0 * 0x17 == 0x90 (0x90) +__longlong 0xd8f0 * 0x17 == 0x7d90 (0x7d90) +__ulonglong 0xd8f0 * 0x17 == 0x7d90 (0x7d90) +float 0xd8f0 * 0x17 == -0x8000 (0x8000) +int 0xd8f0 < 0x17 == 0x1 (0x1) +__uint 0xd8f0 < 0x17 == 0x0 (0x0) +char 0xfff0 < 0x17 == 0x1 (0x1) +__uchar 0xf0 < 0x17 == 0x0 (0x0) +__longlong 0xd8f0 < 0x17 == 0x1 (0x1) +__ulonglong 0xd8f0 < 0x17 == 0x0 (0x0) +float 0xd8f0 < 0x17 == 0x1 (0x1) +int 0xd8f0 > 0x17 == 0x0 (0x0) +__uint 0xd8f0 > 0x17 == 0x1 (0x1) +char 0xfff0 > 0x17 == 0x0 (0x0) +__uchar 0xf0 > 0x17 == 0x1 (0x1) +__longlong 0xd8f0 > 0x17 == 0x0 (0x0) +__ulonglong 0xd8f0 > 0x17 == 0x1 (0x1) +float 0xd8f0 > 0x17 == 0x0 (0x0) +int 0xd8f0 <= 0x17 == 0x1 (0x1) +__uint 0xd8f0 <= 0x17 == 0x0 (0x0) +char 0xfff0 <= 0x17 == 0x1 (0x1) +__uchar 0xf0 <= 0x17 == 0x0 (0x0) +__longlong 0xd8f0 <= 0x17 == 0x1 (0x1) +__ulonglong 0xd8f0 <= 0x17 == 0x0 (0x0) +float 0xd8f0 <= 0x17 == 0x1 (0x1) +int 0xd8f0 == 0x17 == 0x0 (0x0) +__uint 0xd8f0 == 0x17 == 0x0 (0x0) +char 0xfff0 == 0x17 == 0x0 (0x0) +__uchar 0xf0 == 0x17 == 0x0 (0x0) +__longlong 0xd8f0 == 0x17 == 0x0 (0x0) +__ulonglong 0xd8f0 == 0x17 == 0x0 (0x0) +float 0xd8f0 == 0x17 == 0x0 (0x0) +int 0xd8f0 != 0x17 == 0x1 (0x1) +__uint 0xd8f0 != 0x17 == 0x1 (0x1) +char 0xfff0 != 0x17 == 0x1 (0x1) +__uchar 0xf0 != 0x17 == 0x1 (0x1) +__longlong 0xd8f0 != 0x17 == 0x1 (0x1) +__ulonglong 0xd8f0 != 0x17 == 0x1 (0x1) +float 0xd8f0 != 0x17 == 0x1 (0x1) +int 0xd8f0 >= 0x17 == 0x0 (0x0) +__uint 0xd8f0 >= 0x17 == 0x1 (0x1) +char 0xfff0 >= 0x17 == 0x0 (0x0) +__uchar 0xf0 >= 0x17 == 0x1 (0x1) +__longlong 0xd8f0 >= 0x17 == 0x0 (0x0) +__ulonglong 0xd8f0 >= 0x17 == 0x1 (0x1) +float 0xd8f0 >= 0x17 == 0x0 (0x0) +int 0xd8f0 / 0x17 == -0x1b2 (0xfe4e) +__uint 0xd8f0 / 0x17 == 0x96e (0x96e) +char 0xfff0 / 0x17 == 0x0 (0x0) +__uchar 0xf0 / 0x17 == 0xa (0xa) +__longlong 0xd8f0 / 0x17 == -0x1b2 (0xfe4e) +__ulonglong 0xd8f0 / 0x17 == 0x6279 (0x6279) +float 0xd8f0 / 0x17 == -0x1b2 (0xfe4e) +int 0xd8f0 % 0x17 == -0x12 (0xffee) +__uint 0xd8f0 % 0x17 == 0xe (0xe) +char 0xfff0 % 0x17 == -0x10 (0xfff0) +__uchar 0xf0 % 0x17 == 0xa (0xa) +__longlong 0xd8f0 % 0x17 == -0x12 (0xffee) +__ulonglong 0xd8f0 % 0x17 == 0x11 (0x11) +0xd8f0 * 0x7fff == 0x2710 +0xd8f0 / 0x7fff == 0x0 +0xd8f0 % 0x7fff == -0x2710 +int 0xd8f0 ^ 0x7fff == -0x58f1 (0xa70f) +__uint 0xd8f0 ^ 0x7fff == -0x58f1 (0xa70f) +char 0xfff0 ^ 0xffff == 0xf (0xf) +__uchar 0xf0 ^ 0xff == 0xf (0xf) +__longlong 0xd8f0 ^ 0x7fff == -0x58f1 (0xa70f) +__ulonglong 0xd8f0 ^ 0x7fff == -0x58f1 (0xa70f) +int 0xd8f0 && 0x7fff == 0x1 (0x1) +__uint 0xd8f0 && 0x7fff == 0x1 (0x1) +char 0xfff0 && 0xffff == 0x1 (0x1) +__uchar 0xf0 && 0xff == 0x1 (0x1) +__longlong 0xd8f0 && 0x7fff == 0x1 (0x1) +__ulonglong 0xd8f0 && 0x7fff == 0x1 (0x1) +int 0xd8f0 || 0x7fff == 0x1 (0x1) +__uint 0xd8f0 || 0x7fff == 0x1 (0x1) +char 0xfff0 || 0xffff == 0x1 (0x1) +__uchar 0xf0 || 0xff == 0x1 (0x1) +__longlong 0xd8f0 || 0x7fff == 0x1 (0x1) +__ulonglong 0xd8f0 || 0x7fff == 0x1 (0x1) +int 0xd8f0 & 0x7fff == 0x58f0 (0x58f0) +__uint 0xd8f0 & 0x7fff == 0x58f0 (0x58f0) +char 0xfff0 & 0xffff == -0x10 (0xfff0) +__uchar 0xf0 & 0xff == 0xf0 (0xf0) +__longlong 0xd8f0 & 0x7fff == 0x58f0 (0x58f0) +__ulonglong 0xd8f0 & 0x7fff == 0x58f0 (0x58f0) +int 0xd8f0 | 0x7fff == -0x1 (0xffff) +__uint 0xd8f0 | 0x7fff == -0x1 (0xffff) +char 0xfff0 | 0xffff == -0x1 (0xffff) +__uchar 0xf0 | 0xff == 0xff (0xff) +__longlong 0xd8f0 | 0x7fff == -0x1 (0xffff) +__ulonglong 0xd8f0 | 0x7fff == -0x1 (0xffff) +int 0xd8f0 << 0x10 == 0x0 (0x0) +__uint 0xd8f0 << 0x10 == 0x0 (0x0) +char 0xfff0 << 0x10 == 0x0 (0x0) +__uchar 0xf0 << 0x10 == 0x0 (0x0) +__longlong 0xd8f0 << 0x10 == 0x0 (0x0) +__ulonglong 0xd8f0 << 0x10 == 0x0 (0x0) +int 0xd8f0 >> 0x10 == -0x1 (0xffff) +__uint 0xd8f0 >> 0x10 == 0x0 (0x0) +char 0xfff0 >> 0x10 == -0x1 (0xffff) +__uchar 0xf0 >> 0x10 == 0x0 (0x0) +__longlong 0xd8f0 >> 0x10 == -0x1 (0xffff) +__ulonglong 0xd8f0 >> 0x10 == -0x1 (0xffff) +int 0xd8f0 + 0x7fff == 0x58ef (0x58ef) +__uint 0xd8f0 + 0x7fff == 0x58ef (0x58ef) +char 0xfff0 + 0xffff == -0x11 (0xffef) +__uchar 0xf0 + 0xff == 0xef (0xef) +__longlong 0xd8f0 + 0x7fff == 0x58ef (0x58ef) +__ulonglong 0xd8f0 + 0x7fff == 0x58ef (0x58ef) +float 0xd8f0 + 0x7fff == 0x58ef (0x58ef) +int 0xd8f0 - 0x7fff == 0x58f1 (0x58f1) +__uint 0xd8f0 - 0x7fff == 0x58f1 (0x58f1) +char 0xfff0 - 0xffff == -0xf (0xfff1) +__uchar 0xf0 - 0xff == 0xf1 (0xf1) +__longlong 0xd8f0 - 0x7fff == 0x58f1 (0x58f1) +__ulonglong 0xd8f0 - 0x7fff == 0x58f1 (0x58f1) +float 0xd8f0 - 0x7fff == -0x8000 (0x8000) +int 0xd8f0 * 0x7fff == 0x2710 (0x2710) +__uint 0xd8f0 * 0x7fff == 0x2710 (0x2710) +char 0xfff0 * 0xffff == 0x10 (0x10) +__uchar 0xf0 * 0xff == 0x10 (0x10) +__longlong 0xd8f0 * 0x7fff == 0x2710 (0x2710) +__ulonglong 0xd8f0 * 0x7fff == 0x2710 (0x2710) +float 0xd8f0 * 0x7fff == -0x8000 (0x8000) +int 0xd8f0 < 0x7fff == 0x1 (0x1) +__uint 0xd8f0 < 0x7fff == 0x0 (0x0) +char 0xfff0 < 0xffff == 0x1 (0x1) +__uchar 0xf0 < 0xff == 0x1 (0x1) +__longlong 0xd8f0 < 0x7fff == 0x1 (0x1) +__ulonglong 0xd8f0 < 0x7fff == 0x0 (0x0) +float 0xd8f0 < 0x7fff == 0x1 (0x1) +int 0xd8f0 > 0x7fff == 0x0 (0x0) +__uint 0xd8f0 > 0x7fff == 0x1 (0x1) +char 0xfff0 > 0xffff == 0x0 (0x0) +__uchar 0xf0 > 0xff == 0x0 (0x0) +__longlong 0xd8f0 > 0x7fff == 0x0 (0x0) +__ulonglong 0xd8f0 > 0x7fff == 0x1 (0x1) +float 0xd8f0 > 0x7fff == 0x0 (0x0) +int 0xd8f0 <= 0x7fff == 0x1 (0x1) +__uint 0xd8f0 <= 0x7fff == 0x0 (0x0) +char 0xfff0 <= 0xffff == 0x1 (0x1) +__uchar 0xf0 <= 0xff == 0x1 (0x1) +__longlong 0xd8f0 <= 0x7fff == 0x1 (0x1) +__ulonglong 0xd8f0 <= 0x7fff == 0x0 (0x0) +float 0xd8f0 <= 0x7fff == 0x1 (0x1) +int 0xd8f0 == 0x7fff == 0x0 (0x0) +__uint 0xd8f0 == 0x7fff == 0x0 (0x0) +char 0xfff0 == 0xffff == 0x0 (0x0) +__uchar 0xf0 == 0xff == 0x0 (0x0) +__longlong 0xd8f0 == 0x7fff == 0x0 (0x0) +__ulonglong 0xd8f0 == 0x7fff == 0x0 (0x0) +float 0xd8f0 == 0x7fff == 0x0 (0x0) +int 0xd8f0 != 0x7fff == 0x1 (0x1) +__uint 0xd8f0 != 0x7fff == 0x1 (0x1) +char 0xfff0 != 0xffff == 0x1 (0x1) +__uchar 0xf0 != 0xff == 0x1 (0x1) +__longlong 0xd8f0 != 0x7fff == 0x1 (0x1) +__ulonglong 0xd8f0 != 0x7fff == 0x1 (0x1) +float 0xd8f0 != 0x7fff == 0x1 (0x1) +int 0xd8f0 >= 0x7fff == 0x0 (0x0) +__uint 0xd8f0 >= 0x7fff == 0x1 (0x1) +char 0xfff0 >= 0xffff == 0x0 (0x0) +__uchar 0xf0 >= 0xff == 0x0 (0x0) +__longlong 0xd8f0 >= 0x7fff == 0x0 (0x0) +__ulonglong 0xd8f0 >= 0x7fff == 0x1 (0x1) +float 0xd8f0 >= 0x7fff == 0x0 (0x0) +int 0xd8f0 / 0x7fff == 0x0 (0x0) +__uint 0xd8f0 / 0x7fff == 0x1 (0x1) +char 0xfff0 / 0xffff == 0x10 (0x10) +__uchar 0xf0 / 0xff == 0x0 (0x0) +__longlong 0xd8f0 / 0x7fff == 0x0 (0x0) +__ulonglong 0xd8f0 / 0x7fff == 0x3 (0x3) +float 0xd8f0 / 0x7fff == 0x0 (0x0) +int 0xd8f0 % 0x7fff == -0x2710 (0xd8f0) +__uint 0xd8f0 % 0x7fff == 0x58f1 (0x58f1) +char 0xfff0 % 0xffff == 0x0 (0x0) +__uchar 0xf0 % 0xff == 0xf0 (0xf0) +__longlong 0xd8f0 % 0x7fff == -0x2710 (0xd8f0) +__ulonglong 0xd8f0 % 0x7fff == 0x58f3 (0x58f3) +0xd8f0 * 0x8000 == 0x0 +0xd8f0 / 0x8000 == 0x0 +0xd8f0 % 0x8000 == -0x2710 +int 0xd8f0 ^ 0x8000 == 0x58f0 (0x58f0) +__uint 0xd8f0 ^ 0x8000 == 0x58f0 (0x58f0) +char 0xfff0 ^ 0x0 == -0x10 (0xfff0) +__uchar 0xf0 ^ 0x0 == 0xf0 (0xf0) +__longlong 0xd8f0 ^ 0x8000 == 0x58f0 (0x58f0) +__ulonglong 0xd8f0 ^ 0x8000 == 0x58f0 (0x58f0) +int 0xd8f0 && 0x8000 == 0x1 (0x1) +__uint 0xd8f0 && 0x8000 == 0x1 (0x1) +char 0xfff0 && 0x0 == 0x0 (0x0) +__uchar 0xf0 && 0x0 == 0x0 (0x0) +__longlong 0xd8f0 && 0x8000 == 0x1 (0x1) +__ulonglong 0xd8f0 && 0x8000 == 0x1 (0x1) +int 0xd8f0 || 0x8000 == 0x1 (0x1) +__uint 0xd8f0 || 0x8000 == 0x1 (0x1) +char 0xfff0 || 0x0 == 0x1 (0x1) +__uchar 0xf0 || 0x0 == 0x1 (0x1) +__longlong 0xd8f0 || 0x8000 == 0x1 (0x1) +__ulonglong 0xd8f0 || 0x8000 == 0x1 (0x1) +int 0xd8f0 & 0x8000 == -0x8000 (0x8000) +__uint 0xd8f0 & 0x8000 == -0x8000 (0x8000) +char 0xfff0 & 0x0 == 0x0 (0x0) +__uchar 0xf0 & 0x0 == 0x0 (0x0) +__longlong 0xd8f0 & 0x8000 == -0x8000 (0x8000) +__ulonglong 0xd8f0 & 0x8000 == -0x8000 (0x8000) +int 0xd8f0 | 0x8000 == -0x2710 (0xd8f0) +__uint 0xd8f0 | 0x8000 == -0x2710 (0xd8f0) +char 0xfff0 | 0x0 == -0x10 (0xfff0) +__uchar 0xf0 | 0x0 == 0xf0 (0xf0) +__longlong 0xd8f0 | 0x8000 == -0x2710 (0xd8f0) +__ulonglong 0xd8f0 | 0x8000 == -0x2710 (0xd8f0) +int 0xd8f0 << 0x12 == 0x0 (0x0) +__uint 0xd8f0 << 0x12 == 0x0 (0x0) +char 0xfff0 << 0x12 == 0x0 (0x0) +__uchar 0xf0 << 0x12 == 0x0 (0x0) +__longlong 0xd8f0 << 0x12 == 0x0 (0x0) +__ulonglong 0xd8f0 << 0x12 == 0x0 (0x0) +int 0xd8f0 >> 0x12 == -0x1 (0xffff) +__uint 0xd8f0 >> 0x12 == 0x0 (0x0) +char 0xfff0 >> 0x12 == -0x1 (0xffff) +__uchar 0xf0 >> 0x12 == 0x0 (0x0) +__longlong 0xd8f0 >> 0x12 == -0x1 (0xffff) +__ulonglong 0xd8f0 >> 0x12 == 0x3fff (0x3fff) +int 0xd8f0 + 0x8000 == 0x58f0 (0x58f0) +__uint 0xd8f0 + 0x8000 == 0x58f0 (0x58f0) +char 0xfff0 + 0x0 == -0x10 (0xfff0) +__uchar 0xf0 + 0x0 == 0xf0 (0xf0) +__longlong 0xd8f0 + 0x8000 == 0x58f0 (0x58f0) +__ulonglong 0xd8f0 + 0x8000 == 0x58f0 (0x58f0) +float 0xd8f0 + 0x8000 == -0x8000 (0x8000) +int 0xd8f0 - 0x8000 == 0x58f0 (0x58f0) +__uint 0xd8f0 - 0x8000 == 0x58f0 (0x58f0) +char 0xfff0 - 0x0 == -0x10 (0xfff0) +__uchar 0xf0 - 0x0 == 0xf0 (0xf0) +__longlong 0xd8f0 - 0x8000 == 0x58f0 (0x58f0) +__ulonglong 0xd8f0 - 0x8000 == 0x58f0 (0x58f0) +float 0xd8f0 - 0x8000 == 0x58f0 (0x58f0) +int 0xd8f0 * 0x8000 == 0x0 (0x0) +__uint 0xd8f0 * 0x8000 == 0x0 (0x0) +char 0xfff0 * 0x0 == 0x0 (0x0) +__uchar 0xf0 * 0x0 == 0x0 (0x0) +__longlong 0xd8f0 * 0x8000 == 0x0 (0x0) +__ulonglong 0xd8f0 * 0x8000 == 0x0 (0x0) +float 0xd8f0 * 0x8000 == -0x8000 (0x8000) +int 0xd8f0 < 0x8000 == 0x0 (0x0) +__uint 0xd8f0 < 0x8000 == 0x0 (0x0) +char 0xfff0 < 0x0 == 0x1 (0x1) +__uchar 0xf0 < 0x0 == 0x0 (0x0) +__longlong 0xd8f0 < 0x8000 == 0x0 (0x0) +__ulonglong 0xd8f0 < 0x8000 == 0x0 (0x0) +float 0xd8f0 < 0x8000 == 0x0 (0x0) +int 0xd8f0 > 0x8000 == 0x1 (0x1) +__uint 0xd8f0 > 0x8000 == 0x1 (0x1) +char 0xfff0 > 0x0 == 0x0 (0x0) +__uchar 0xf0 > 0x0 == 0x1 (0x1) +__longlong 0xd8f0 > 0x8000 == 0x1 (0x1) +__ulonglong 0xd8f0 > 0x8000 == 0x1 (0x1) +float 0xd8f0 > 0x8000 == 0x1 (0x1) +int 0xd8f0 <= 0x8000 == 0x0 (0x0) +__uint 0xd8f0 <= 0x8000 == 0x0 (0x0) +char 0xfff0 <= 0x0 == 0x1 (0x1) +__uchar 0xf0 <= 0x0 == 0x0 (0x0) +__longlong 0xd8f0 <= 0x8000 == 0x0 (0x0) +__ulonglong 0xd8f0 <= 0x8000 == 0x0 (0x0) +float 0xd8f0 <= 0x8000 == 0x0 (0x0) +int 0xd8f0 == 0x8000 == 0x0 (0x0) +__uint 0xd8f0 == 0x8000 == 0x0 (0x0) +char 0xfff0 == 0x0 == 0x0 (0x0) +__uchar 0xf0 == 0x0 == 0x0 (0x0) +__longlong 0xd8f0 == 0x8000 == 0x0 (0x0) +__ulonglong 0xd8f0 == 0x8000 == 0x0 (0x0) +float 0xd8f0 == 0x8000 == 0x0 (0x0) +int 0xd8f0 != 0x8000 == 0x1 (0x1) +__uint 0xd8f0 != 0x8000 == 0x1 (0x1) +char 0xfff0 != 0x0 == 0x1 (0x1) +__uchar 0xf0 != 0x0 == 0x1 (0x1) +__longlong 0xd8f0 != 0x8000 == 0x1 (0x1) +__ulonglong 0xd8f0 != 0x8000 == 0x1 (0x1) +float 0xd8f0 != 0x8000 == 0x1 (0x1) +int 0xd8f0 >= 0x8000 == 0x1 (0x1) +__uint 0xd8f0 >= 0x8000 == 0x1 (0x1) +char 0xfff0 >= 0x0 == 0x0 (0x0) +__uchar 0xf0 >= 0x0 == 0x1 (0x1) +__longlong 0xd8f0 >= 0x8000 == 0x1 (0x1) +__ulonglong 0xd8f0 >= 0x8000 == 0x1 (0x1) +float 0xd8f0 >= 0x8000 == 0x1 (0x1) +int 0xd8f0 / 0x8000 == 0x0 (0x0) +__uint 0xd8f0 / 0x8000 == 0x1 (0x1) +__longlong 0xd8f0 / 0x8000 == 0x0 (0x0) +__ulonglong 0xd8f0 / 0x8000 == 0x1 (0x1) +float 0xd8f0 / 0x8000 == 0x0 (0x0) +int 0xd8f0 % 0x8000 == -0x2710 (0xd8f0) +__uint 0xd8f0 % 0x8000 == 0x58f0 (0x58f0) +__longlong 0xd8f0 % 0x8000 == -0x2710 (0xd8f0) +__ulonglong 0xd8f0 % 0x8000 == 0x58f0 (0x58f0) +0xd8f0 * 0x3e8 == 0x6980 +0xd8f0 / 0x3e8 == -0xa +0xd8f0 % 0x3e8 == 0x0 +int 0xd8f0 ^ 0x3e8 == -0x24e8 (0xdb18) +__uint 0xd8f0 ^ 0x3e8 == -0x24e8 (0xdb18) +char 0xfff0 ^ 0xffe8 == 0x18 (0x18) +__uchar 0xf0 ^ 0xe8 == 0x18 (0x18) +__longlong 0xd8f0 ^ 0x3e8 == -0x24e8 (0xdb18) +__ulonglong 0xd8f0 ^ 0x3e8 == -0x24e8 (0xdb18) +int 0xd8f0 && 0x3e8 == 0x1 (0x1) +__uint 0xd8f0 && 0x3e8 == 0x1 (0x1) +char 0xfff0 && 0xffe8 == 0x1 (0x1) +__uchar 0xf0 && 0xe8 == 0x1 (0x1) +__longlong 0xd8f0 && 0x3e8 == 0x1 (0x1) +__ulonglong 0xd8f0 && 0x3e8 == 0x1 (0x1) +int 0xd8f0 || 0x3e8 == 0x1 (0x1) +__uint 0xd8f0 || 0x3e8 == 0x1 (0x1) +char 0xfff0 || 0xffe8 == 0x1 (0x1) +__uchar 0xf0 || 0xe8 == 0x1 (0x1) +__longlong 0xd8f0 || 0x3e8 == 0x1 (0x1) +__ulonglong 0xd8f0 || 0x3e8 == 0x1 (0x1) +int 0xd8f0 & 0x3e8 == 0xe0 (0xe0) +__uint 0xd8f0 & 0x3e8 == 0xe0 (0xe0) +char 0xfff0 & 0xffe8 == -0x20 (0xffe0) +__uchar 0xf0 & 0xe8 == 0xe0 (0xe0) +__longlong 0xd8f0 & 0x3e8 == 0xe0 (0xe0) +__ulonglong 0xd8f0 & 0x3e8 == 0xe0 (0xe0) +int 0xd8f0 | 0x3e8 == -0x2408 (0xdbf8) +__uint 0xd8f0 | 0x3e8 == -0x2408 (0xdbf8) +char 0xfff0 | 0xffe8 == -0x8 (0xfff8) +__uchar 0xf0 | 0xe8 == 0xf8 (0xf8) +__longlong 0xd8f0 | 0x3e8 == -0x2408 (0xdbf8) +__ulonglong 0xd8f0 | 0x3e8 == -0x2408 (0xdbf8) +int 0xd8f0 << 0x14 == 0x0 (0x0) +__uint 0xd8f0 << 0x14 == 0x0 (0x0) +char 0xfff0 << 0x14 == 0x0 (0x0) +__uchar 0xf0 << 0x14 == 0x0 (0x0) +__longlong 0xd8f0 << 0x14 == 0x0 (0x0) +__ulonglong 0xd8f0 << 0x14 == 0x0 (0x0) +int 0xd8f0 >> 0x14 == -0x1 (0xffff) +__uint 0xd8f0 >> 0x14 == 0x0 (0x0) +char 0xfff0 >> 0x14 == -0x1 (0xffff) +__uchar 0xf0 >> 0x14 == 0x0 (0x0) +__longlong 0xd8f0 >> 0x14 == -0x1 (0xffff) +__ulonglong 0xd8f0 >> 0x14 == 0xfff (0xfff) +int 0xd8f0 + 0x3e8 == -0x2328 (0xdcd8) +__uint 0xd8f0 + 0x3e8 == -0x2328 (0xdcd8) +char 0xfff0 + 0xffe8 == -0x28 (0xffd8) +__uchar 0xf0 + 0xe8 == 0xd8 (0xd8) +__longlong 0xd8f0 + 0x3e8 == -0x2328 (0xdcd8) +__ulonglong 0xd8f0 + 0x3e8 == -0x2328 (0xdcd8) +float 0xd8f0 + 0x3e8 == -0x2328 (0xdcd8) +int 0xd8f0 - 0x3e8 == -0x2af8 (0xd508) +__uint 0xd8f0 - 0x3e8 == -0x2af8 (0xd508) +char 0xfff0 - 0xffe8 == 0x8 (0x8) +__uchar 0xf0 - 0xe8 == 0x8 (0x8) +__longlong 0xd8f0 - 0x3e8 == -0x2af8 (0xd508) +__ulonglong 0xd8f0 - 0x3e8 == -0x2af8 (0xd508) +float 0xd8f0 - 0x3e8 == -0x2af8 (0xd508) +int 0xd8f0 * 0x3e8 == 0x6980 (0x6980) +__uint 0xd8f0 * 0x3e8 == 0x6980 (0x6980) +char 0xfff0 * 0xffe8 == -0x80 (0xff80) +__uchar 0xf0 * 0xe8 == 0x80 (0x80) +__longlong 0xd8f0 * 0x3e8 == 0x6980 (0x6980) +__ulonglong 0xd8f0 * 0x3e8 == 0x6980 (0x6980) +float 0xd8f0 * 0x3e8 == -0x8000 (0x8000) +int 0xd8f0 < 0x3e8 == 0x1 (0x1) +__uint 0xd8f0 < 0x3e8 == 0x0 (0x0) +char 0xfff0 < 0xffe8 == 0x0 (0x0) +__uchar 0xf0 < 0xe8 == 0x0 (0x0) +__longlong 0xd8f0 < 0x3e8 == 0x1 (0x1) +__ulonglong 0xd8f0 < 0x3e8 == 0x0 (0x0) +float 0xd8f0 < 0x3e8 == 0x1 (0x1) +int 0xd8f0 > 0x3e8 == 0x0 (0x0) +__uint 0xd8f0 > 0x3e8 == 0x1 (0x1) +char 0xfff0 > 0xffe8 == 0x1 (0x1) +__uchar 0xf0 > 0xe8 == 0x1 (0x1) +__longlong 0xd8f0 > 0x3e8 == 0x0 (0x0) +__ulonglong 0xd8f0 > 0x3e8 == 0x1 (0x1) +float 0xd8f0 > 0x3e8 == 0x0 (0x0) +int 0xd8f0 <= 0x3e8 == 0x1 (0x1) +__uint 0xd8f0 <= 0x3e8 == 0x0 (0x0) +char 0xfff0 <= 0xffe8 == 0x0 (0x0) +__uchar 0xf0 <= 0xe8 == 0x0 (0x0) +__longlong 0xd8f0 <= 0x3e8 == 0x1 (0x1) +__ulonglong 0xd8f0 <= 0x3e8 == 0x0 (0x0) +float 0xd8f0 <= 0x3e8 == 0x1 (0x1) +int 0xd8f0 == 0x3e8 == 0x0 (0x0) +__uint 0xd8f0 == 0x3e8 == 0x0 (0x0) +char 0xfff0 == 0xffe8 == 0x0 (0x0) +__uchar 0xf0 == 0xe8 == 0x0 (0x0) +__longlong 0xd8f0 == 0x3e8 == 0x0 (0x0) +__ulonglong 0xd8f0 == 0x3e8 == 0x0 (0x0) +float 0xd8f0 == 0x3e8 == 0x0 (0x0) +int 0xd8f0 != 0x3e8 == 0x1 (0x1) +__uint 0xd8f0 != 0x3e8 == 0x1 (0x1) +char 0xfff0 != 0xffe8 == 0x1 (0x1) +__uchar 0xf0 != 0xe8 == 0x1 (0x1) +__longlong 0xd8f0 != 0x3e8 == 0x1 (0x1) +__ulonglong 0xd8f0 != 0x3e8 == 0x1 (0x1) +float 0xd8f0 != 0x3e8 == 0x1 (0x1) +int 0xd8f0 >= 0x3e8 == 0x0 (0x0) +__uint 0xd8f0 >= 0x3e8 == 0x1 (0x1) +char 0xfff0 >= 0xffe8 == 0x1 (0x1) +__uchar 0xf0 >= 0xe8 == 0x1 (0x1) +__longlong 0xd8f0 >= 0x3e8 == 0x0 (0x0) +__ulonglong 0xd8f0 >= 0x3e8 == 0x1 (0x1) +float 0xd8f0 >= 0x3e8 == 0x0 (0x0) +int 0xd8f0 / 0x3e8 == -0xa (0xfff6) +__uint 0xd8f0 / 0x3e8 == 0x37 (0x37) +char 0xfff0 / 0xffe8 == 0x0 (0x0) +__uchar 0xf0 / 0xe8 == 0x1 (0x1) +__longlong 0xd8f0 / 0x3e8 == -0xa (0xfff6) +__ulonglong 0xd8f0 / 0x3e8 == -0x76d3 (0x892d) +float 0xd8f0 / 0x3e8 == -0xa (0xfff6) +int 0xd8f0 % 0x3e8 == 0x0 (0x0) +__uint 0xd8f0 % 0x3e8 == 0x218 (0x218) +char 0xfff0 % 0xffe8 == -0x10 (0xfff0) +__uchar 0xf0 % 0xe8 == 0x8 (0x8) +__longlong 0xd8f0 % 0x3e8 == 0x0 (0x0) +__ulonglong 0xd8f0 % 0x3e8 == 0x128 (0x128) +0xd8f0 * 0x2710 == 0x1f00 +0xd8f0 / 0x2710 == -0x1 +0xd8f0 % 0x2710 == 0x0 +int 0xd8f0 ^ 0x2710 == -0x20 (0xffe0) +__uint 0xd8f0 ^ 0x2710 == -0x20 (0xffe0) +char 0xfff0 ^ 0x10 == -0x20 (0xffe0) +__uchar 0xf0 ^ 0x10 == 0xe0 (0xe0) +__longlong 0xd8f0 ^ 0x2710 == -0x20 (0xffe0) +__ulonglong 0xd8f0 ^ 0x2710 == -0x20 (0xffe0) +int 0xd8f0 && 0x2710 == 0x1 (0x1) +__uint 0xd8f0 && 0x2710 == 0x1 (0x1) +char 0xfff0 && 0x10 == 0x1 (0x1) +__uchar 0xf0 && 0x10 == 0x1 (0x1) +__longlong 0xd8f0 && 0x2710 == 0x1 (0x1) +__ulonglong 0xd8f0 && 0x2710 == 0x1 (0x1) +int 0xd8f0 || 0x2710 == 0x1 (0x1) +__uint 0xd8f0 || 0x2710 == 0x1 (0x1) +char 0xfff0 || 0x10 == 0x1 (0x1) +__uchar 0xf0 || 0x10 == 0x1 (0x1) +__longlong 0xd8f0 || 0x2710 == 0x1 (0x1) +__ulonglong 0xd8f0 || 0x2710 == 0x1 (0x1) +int 0xd8f0 & 0x2710 == 0x10 (0x10) +__uint 0xd8f0 & 0x2710 == 0x10 (0x10) +char 0xfff0 & 0x10 == 0x10 (0x10) +__uchar 0xf0 & 0x10 == 0x10 (0x10) +__longlong 0xd8f0 & 0x2710 == 0x10 (0x10) +__ulonglong 0xd8f0 & 0x2710 == 0x10 (0x10) +int 0xd8f0 | 0x2710 == -0x10 (0xfff0) +__uint 0xd8f0 | 0x2710 == -0x10 (0xfff0) +char 0xfff0 | 0x10 == -0x10 (0xfff0) +__uchar 0xf0 | 0x10 == 0xf0 (0xf0) +__longlong 0xd8f0 | 0x2710 == -0x10 (0xfff0) +__ulonglong 0xd8f0 | 0x2710 == -0x10 (0xfff0) +int 0xd8f0 << 0x16 == 0x0 (0x0) +__uint 0xd8f0 << 0x16 == 0x0 (0x0) +char 0xfff0 << 0x16 == 0x0 (0x0) +__uchar 0xf0 << 0x16 == 0x0 (0x0) +__longlong 0xd8f0 << 0x16 == 0x0 (0x0) +__ulonglong 0xd8f0 << 0x16 == 0x0 (0x0) +int 0xd8f0 >> 0x16 == -0x1 (0xffff) +__uint 0xd8f0 >> 0x16 == 0x0 (0x0) +char 0xfff0 >> 0x16 == -0x1 (0xffff) +__uchar 0xf0 >> 0x16 == 0x0 (0x0) +__longlong 0xd8f0 >> 0x16 == -0x1 (0xffff) +__ulonglong 0xd8f0 >> 0x16 == 0x3ff (0x3ff) +int 0xd8f0 + 0x2710 == 0x0 (0x0) +__uint 0xd8f0 + 0x2710 == 0x0 (0x0) +char 0xfff0 + 0x10 == 0x0 (0x0) +__uchar 0xf0 + 0x10 == 0x0 (0x0) +__longlong 0xd8f0 + 0x2710 == 0x0 (0x0) +__ulonglong 0xd8f0 + 0x2710 == 0x0 (0x0) +float 0xd8f0 + 0x2710 == 0x0 (0x0) +int 0xd8f0 - 0x2710 == -0x4e20 (0xb1e0) +__uint 0xd8f0 - 0x2710 == -0x4e20 (0xb1e0) +char 0xfff0 - 0x10 == -0x20 (0xffe0) +__uchar 0xf0 - 0x10 == 0xe0 (0xe0) +__longlong 0xd8f0 - 0x2710 == -0x4e20 (0xb1e0) +__ulonglong 0xd8f0 - 0x2710 == -0x4e20 (0xb1e0) +float 0xd8f0 - 0x2710 == -0x4e20 (0xb1e0) +int 0xd8f0 * 0x2710 == 0x1f00 (0x1f00) +__uint 0xd8f0 * 0x2710 == 0x1f00 (0x1f00) +char 0xfff0 * 0x10 == 0x0 (0x0) +__uchar 0xf0 * 0x10 == 0x0 (0x0) +__longlong 0xd8f0 * 0x2710 == 0x1f00 (0x1f00) +__ulonglong 0xd8f0 * 0x2710 == 0x1f00 (0x1f00) +float 0xd8f0 * 0x2710 == -0x8000 (0x8000) +int 0xd8f0 < 0x2710 == 0x1 (0x1) +__uint 0xd8f0 < 0x2710 == 0x0 (0x0) +char 0xfff0 < 0x10 == 0x1 (0x1) +__uchar 0xf0 < 0x10 == 0x0 (0x0) +__longlong 0xd8f0 < 0x2710 == 0x1 (0x1) +__ulonglong 0xd8f0 < 0x2710 == 0x0 (0x0) +float 0xd8f0 < 0x2710 == 0x1 (0x1) +int 0xd8f0 > 0x2710 == 0x0 (0x0) +__uint 0xd8f0 > 0x2710 == 0x1 (0x1) +char 0xfff0 > 0x10 == 0x0 (0x0) +__uchar 0xf0 > 0x10 == 0x1 (0x1) +__longlong 0xd8f0 > 0x2710 == 0x0 (0x0) +__ulonglong 0xd8f0 > 0x2710 == 0x1 (0x1) +float 0xd8f0 > 0x2710 == 0x0 (0x0) +int 0xd8f0 <= 0x2710 == 0x1 (0x1) +__uint 0xd8f0 <= 0x2710 == 0x0 (0x0) +char 0xfff0 <= 0x10 == 0x1 (0x1) +__uchar 0xf0 <= 0x10 == 0x0 (0x0) +__longlong 0xd8f0 <= 0x2710 == 0x1 (0x1) +__ulonglong 0xd8f0 <= 0x2710 == 0x0 (0x0) +float 0xd8f0 <= 0x2710 == 0x1 (0x1) +int 0xd8f0 == 0x2710 == 0x0 (0x0) +__uint 0xd8f0 == 0x2710 == 0x0 (0x0) +char 0xfff0 == 0x10 == 0x0 (0x0) +__uchar 0xf0 == 0x10 == 0x0 (0x0) +__longlong 0xd8f0 == 0x2710 == 0x0 (0x0) +__ulonglong 0xd8f0 == 0x2710 == 0x0 (0x0) +float 0xd8f0 == 0x2710 == 0x0 (0x0) +int 0xd8f0 != 0x2710 == 0x1 (0x1) +__uint 0xd8f0 != 0x2710 == 0x1 (0x1) +char 0xfff0 != 0x10 == 0x1 (0x1) +__uchar 0xf0 != 0x10 == 0x1 (0x1) +__longlong 0xd8f0 != 0x2710 == 0x1 (0x1) +__ulonglong 0xd8f0 != 0x2710 == 0x1 (0x1) +float 0xd8f0 != 0x2710 == 0x1 (0x1) +int 0xd8f0 >= 0x2710 == 0x0 (0x0) +__uint 0xd8f0 >= 0x2710 == 0x1 (0x1) +char 0xfff0 >= 0x10 == 0x0 (0x0) +__uchar 0xf0 >= 0x10 == 0x1 (0x1) +__longlong 0xd8f0 >= 0x2710 == 0x0 (0x0) +__ulonglong 0xd8f0 >= 0x2710 == 0x1 (0x1) +float 0xd8f0 >= 0x2710 == 0x0 (0x0) +int 0xd8f0 / 0x2710 == -0x1 (0xffff) +__uint 0xd8f0 / 0x2710 == 0x5 (0x5) +char 0xfff0 / 0x10 == -0x1 (0xffff) +__uchar 0xf0 / 0x10 == 0xf (0xf) +__longlong 0xd8f0 / 0x2710 == -0x1 (0xffff) +__ulonglong 0xd8f0 / 0x2710 == -0x7249 (0x8db7) +float 0xd8f0 / 0x2710 == -0x1 (0xffff) +int 0xd8f0 % 0x2710 == 0x0 (0x0) +__uint 0xd8f0 % 0x2710 == 0x15a0 (0x15a0) +char 0xfff0 % 0x10 == 0x0 (0x0) +__uchar 0xf0 % 0x10 == 0x0 (0x0) +__longlong 0xd8f0 % 0x2710 == 0x0 (0x0) +__ulonglong 0xd8f0 % 0x2710 == 0x1c80 (0x1c80) +int xor42-0x2710 xor42 -0x2726 +__uint xor42-0x2710 xor42 -0x2726 +char xor42-0x10 xor42 -0x26 +__uchar xor420xf0 xor42 0xda +__longlong xor42-0x2710 xor42 -0x2726 +__ulonglong xor42-0x2710 xor42 -0x2726 +int land1-0x2710 land1 0x1 +__uint land1-0x2710 land1 0x1 +char land1-0x10 land1 0x1 +__uchar land10xf0 land1 0x1 +__longlong land1-0x2710 land1 0x1 +__ulonglong land1-0x2710 land1 0x1 +int lor1-0x2710 lor1 0x1 +__uint lor1-0x2710 lor1 0x1 +char lor1-0x10 lor1 0x1 +__uchar lor10xf0 lor1 0x1 +__longlong lor1-0x2710 lor1 0x1 +__ulonglong lor1-0x2710 lor1 0x1 +int and42-0x2710 and42 0x20 +__uint and42-0x2710 and42 0x20 +char and42-0x10 and42 0x20 +__uchar and420xf0 and42 0x20 +__longlong and42-0x2710 and42 0x20 +__ulonglong and42-0x2710 and42 0x20 +int or42-0x2710 or42 -0x2706 +__uint or42-0x2710 or42 -0x2706 +char or42-0x10 or42 -0x6 +__uchar or420xf0 or42 0xfa +__longlong or42-0x2710 or42 -0x2706 +__ulonglong or42-0x2710 or42 -0x2706 +int shl5-0x2710 shl5 0x1e00 +__uint shl5-0x2710 shl5 0x1e00 +char shl5-0x10 shl5 0x0 +__uchar shl50xf0 shl5 0x0 +__longlong shl5-0x2710 shl5 0x1e00 +__ulonglong shl5-0x2710 shl5 0x1e00 +int shr5-0x2710 shr5 -0x139 +__uint shr5-0x2710 shr5 0x6c7 +char shr5-0x10 shr5 -0x1 +__uchar shr50xf0 shr5 0x7 +__longlong shr5-0x2710 shr5 -0x139 +__ulonglong shr5-0x2710 shr5 -0x139 +int add42-0x2710 add42 -0x26e6 +__uint add42-0x2710 add42 -0x26e6 +char add42-0x10 add42 0x1a +__uchar add420xf0 add42 0x1a +__longlong add42-0x2710 add42 -0x26e6 +__ulonglong add42-0x2710 add42 -0x26e6 +float add42-0x2710 add42 -0x26e6 +int sub42-0x2710 sub42 -0x273a +__uint sub42-0x2710 sub42 -0x273a +char sub42-0x10 sub42 -0x3a +__uchar sub420xf0 sub42 0xc6 +__longlong sub42-0x2710 sub42 -0x273a +__ulonglong sub42-0x2710 sub42 -0x273a +float sub42-0x2710 sub42 -0x273a +int mul42-0x2710 mul42 -0x68a0 +__uint mul42-0x2710 mul42 -0x68a0 +char mul42-0x10 mul42 0x60 +__uchar mul420xf0 mul42 0x60 +__longlong mul42-0x2710 mul42 -0x68a0 +__ulonglong mul42-0x2710 mul42 -0x68a0 +float mul42-0x2710 mul42 -0x8000 +int lt42-0x2710 lt42 0x1 +__uint lt42-0x2710 lt42 0x0 +char lt42-0x10 lt42 0x1 +__uchar lt420xf0 lt42 0x0 +__longlong lt42-0x2710 lt42 0x1 +__ulonglong lt42-0x2710 lt42 0x0 +float lt42-0x2710 lt42 0x1 +int gt42-0x2710 gt42 0x0 +__uint gt42-0x2710 gt42 0x1 +char gt42-0x10 gt42 0x0 +__uchar gt420xf0 gt42 0x1 +__longlong gt42-0x2710 gt42 0x0 +__ulonglong gt42-0x2710 gt42 0x1 +float gt42-0x2710 gt42 0x0 +int le42-0x2710 le42 0x1 +__uint le42-0x2710 le42 0x0 +char le42-0x10 le42 0x1 +__uchar le420xf0 le42 0x0 +__longlong le42-0x2710 le42 0x1 +__ulonglong le42-0x2710 le42 0x0 +float le42-0x2710 le42 0x1 +int eq42-0x2710 eq42 0x0 +__uint eq42-0x2710 eq42 0x0 +char eq42-0x10 eq42 0x0 +__uchar eq420xf0 eq42 0x0 +__longlong eq42-0x2710 eq42 0x0 +__ulonglong eq42-0x2710 eq42 0x0 +float eq42-0x2710 eq42 0x0 +int ne42-0x2710 ne42 0x1 +__uint ne42-0x2710 ne42 0x1 +char ne42-0x10 ne42 0x1 +__uchar ne420xf0 ne42 0x1 +__longlong ne42-0x2710 ne42 0x1 +__ulonglong ne42-0x2710 ne42 0x1 +float ne42-0x2710 ne42 0x1 +int ge42-0x2710 ge42 0x0 +__uint ge42-0x2710 ge42 0x1 +char ge42-0x10 ge42 0x0 +__uchar ge420xf0 ge42 0x1 +__longlong ge42-0x2710 ge42 0x0 +__ulonglong ge42-0x2710 ge42 0x1 +float ge42-0x2710 ge42 0x0 +int div42-0x2710 div42 -0xee +__uint div42-0x2710 div42 0x52a +char div42-0x10 div42 0x0 +__uchar div420xf0 div42 0x5 +__longlong div42-0x2710 div42 -0xee +__ulonglong div42-0x2710 div42 0x6098 +float div42-0x2710 div42 -0xee +int mod23-0x2710 mod23 -0x12 +__uint mod23-0x2710 mod23 0xe +char mod23-0x10 mod23 -0x10 +__uchar mod230xf0 mod23 0xa +__longlong mod23-0x2710 mod23 -0x12 +__ulonglong mod23-0x2710 mod23 0x11 +cast from char 0x0 to char 0x0 +cast from char 0x0 to __uchar 0x0 +cast from char 0x0 to __int 0x0 +cast from char 0x0 to __uint 0x0 +cast from char 0x0 to float 0x0 +cast from char 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from char 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __uchar 0x0 to char 0x0 +cast from __uchar 0x0 to __uchar 0x0 +cast from __uchar 0x0 to __int 0x0 +cast from __uchar 0x0 to __uint 0x0 +cast from __uchar 0x0 to float 0x0 +cast from __uchar 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __uchar 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __int 0x0 to char 0x0 +cast from __int 0x0 to __uchar 0x0 +cast from __int 0x0 to __int 0x0 +cast from __int 0x0 to __uint 0x0 +cast from __int 0x0 to float 0x0 +cast from __int 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __int 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __uint 0x0 to char 0x0 +cast from __uint 0x0 to __uchar 0x0 +cast from __uint 0x0 to __int 0x0 +cast from __uint 0x0 to __uint 0x0 +cast from __uint 0x0 to float 0x0 +cast from __uint 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __uint 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from float 0x0 to char 0x0 +cast from float 0x0 to __uchar 0x0 +cast from float 0x0 to __int 0x0 +cast from float 0x0 to __uint 0x0 +cast from float 0x0 to float 0x0 +cast from float 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from float 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __longlong 0x0 to char 0x0 +cast from __longlong 0x0 to __uchar 0x0 +cast from __longlong 0x0 to __int 0x0 +cast from __longlong 0x0 to __uint 0x0 +cast from __longlong 0x0 to float 0x0 +cast from __longlong 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __longlong 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __ulonglong 0x0 to char 0x0 +cast from __ulonglong 0x0 to __uchar 0x0 +cast from __ulonglong 0x0 to __int 0x0 +cast from __ulonglong 0x0 to __uint 0x0 +cast from __ulonglong 0x0 to float 0x0 +cast from __ulonglong 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __ulonglong 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from char -0x1 to char -0x1 +cast from char 0xffff to __uchar 0xff +cast from char -0x1 to __int -0x1 +cast from char 0xffff to __uint 0xffff +cast from char -0x1 to float -0x1 +cast from char 0xffffffff (0xffffffff) + to __longlong 0xffffffff (0xffffffff) + +cast from char 0xffffffff (0xffffffff) + to __ulonglong 0xffffffff (0xffffffff) + +cast from __uchar 0xff to char -0x1 +cast from __uchar 0xff to __uchar 0xff +cast from __uchar 0xff to __int 0xff +cast from __uchar 0xff to __uint 0xff +cast from __uchar 0xff to float 0xff +cast from __uchar 0xff (0xff) + to __longlong 0xff (0xff) + +cast from __uchar 0xff (0xff) + to __ulonglong 0xff (0xff) + +cast from __int -0x1 to char -0x1 +cast from __int 0xffff to __uchar 0xff +cast from __int -0x1 to __int -0x1 +cast from __int 0xffff to __uint 0xffff +cast from __int -0x1 to float -0x1 +cast from __int 0xffffffff (0xffffffff) + to __longlong 0xffffffff (0xffffffff) + +cast from __int 0xffffffff (0xffffffff) + to __ulonglong 0xffffffff (0xffffffff) + +cast from __uint -0x1 to char -0x1 +cast from __uint 0xffff to __uchar 0xff +cast from __uint -0x1 to __int -0x1 +cast from __uint 0xffff to __uint 0xffff +cast from __uint -0x1 to float -0x8000 +cast from __uint 0xffff (0xffff) + to __longlong 0xffff (0xffff) + +cast from __uint 0xffff (0xffff) + to __ulonglong 0xffff (0xffff) + +cast from float -0x1 to char -0x1 +cast from float 0xffff to __uchar 0xff +cast from float -0x1 to __int -0x1 +cast from float 0xffff to __uint 0xffff +cast from float -0x1 to float -0x1 +cast from float 0xffffffff (0xffffffff) + to __longlong 0xffffffff (0xffffffff) + +cast from float 0xffffffff (0xffffffff) + to __ulonglong 0xffffffff (0xffffffff) + +cast from __longlong -0x1 to char -0x1 +cast from __longlong 0xffff to __uchar 0xff +cast from __longlong -0x1 to __int -0x1 +cast from __longlong 0xffff to __uint 0xffff +cast from __longlong -0x1 to float -0x1 +cast from __longlong 0xffffffff (0xffffffff) + to __longlong 0xffffffff (0xffffffff) + +cast from __longlong 0xffffffff (0xffffffff) + to __ulonglong 0xffffffff (0xffffffff) + +cast from __ulonglong -0x1 to char -0x1 +cast from __ulonglong 0xffff to __uchar 0xff +cast from __ulonglong -0x1 to __int -0x1 +cast from __ulonglong 0xffff to __uint 0xffff +cast from __ulonglong -0x1 to float -0x8000 +cast from __ulonglong 0xffffffff (0xffffffff) + to __longlong 0xffffffff (0xffffffff) + +cast from __ulonglong 0xffffffff (0xffffffff) + to __ulonglong 0xffffffff (0xffffffff) + +cast from char 0x1 to char 0x1 +cast from char 0x1 to __uchar 0x1 +cast from char 0x1 to __int 0x1 +cast from char 0x1 to __uint 0x1 +cast from char 0x1 to float 0x1 +cast from char 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from char 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __uchar 0x1 to char 0x1 +cast from __uchar 0x1 to __uchar 0x1 +cast from __uchar 0x1 to __int 0x1 +cast from __uchar 0x1 to __uint 0x1 +cast from __uchar 0x1 to float 0x1 +cast from __uchar 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __uchar 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __int 0x1 to char 0x1 +cast from __int 0x1 to __uchar 0x1 +cast from __int 0x1 to __int 0x1 +cast from __int 0x1 to __uint 0x1 +cast from __int 0x1 to float 0x1 +cast from __int 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __int 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __uint 0x1 to char 0x1 +cast from __uint 0x1 to __uchar 0x1 +cast from __uint 0x1 to __int 0x1 +cast from __uint 0x1 to __uint 0x1 +cast from __uint 0x1 to float 0x1 +cast from __uint 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __uint 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from float 0x1 to char 0x1 +cast from float 0x1 to __uchar 0x1 +cast from float 0x1 to __int 0x1 +cast from float 0x1 to __uint 0x1 +cast from float 0x1 to float 0x1 +cast from float 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from float 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __longlong 0x1 to char 0x1 +cast from __longlong 0x1 to __uchar 0x1 +cast from __longlong 0x1 to __int 0x1 +cast from __longlong 0x1 to __uint 0x1 +cast from __longlong 0x1 to float 0x1 +cast from __longlong 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __longlong 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __ulonglong 0x1 to char 0x1 +cast from __ulonglong 0x1 to __uchar 0x1 +cast from __ulonglong 0x1 to __int 0x1 +cast from __ulonglong 0x1 to __uint 0x1 +cast from __ulonglong 0x1 to float 0x1 +cast from __ulonglong 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __ulonglong 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from char 0x2 to char 0x2 +cast from char 0x2 to __uchar 0x2 +cast from char 0x2 to __int 0x2 +cast from char 0x2 to __uint 0x2 +cast from char 0x2 to float 0x2 +cast from char 0x2 (0x2) + to __longlong 0x2 (0x2) + +cast from char 0x2 (0x2) + to __ulonglong 0x2 (0x2) + +cast from __uchar 0x2 to char 0x2 +cast from __uchar 0x2 to __uchar 0x2 +cast from __uchar 0x2 to __int 0x2 +cast from __uchar 0x2 to __uint 0x2 +cast from __uchar 0x2 to float 0x2 +cast from __uchar 0x2 (0x2) + to __longlong 0x2 (0x2) + +cast from __uchar 0x2 (0x2) + to __ulonglong 0x2 (0x2) + +cast from __int 0x2 to char 0x2 +cast from __int 0x2 to __uchar 0x2 +cast from __int 0x2 to __int 0x2 +cast from __int 0x2 to __uint 0x2 +cast from __int 0x2 to float 0x2 +cast from __int 0x2 (0x2) + to __longlong 0x2 (0x2) + +cast from __int 0x2 (0x2) + to __ulonglong 0x2 (0x2) + +cast from __uint 0x2 to char 0x2 +cast from __uint 0x2 to __uchar 0x2 +cast from __uint 0x2 to __int 0x2 +cast from __uint 0x2 to __uint 0x2 +cast from __uint 0x2 to float 0x2 +cast from __uint 0x2 (0x2) + to __longlong 0x2 (0x2) + +cast from __uint 0x2 (0x2) + to __ulonglong 0x2 (0x2) + +cast from float 0x2 to char 0x2 +cast from float 0x2 to __uchar 0x2 +cast from float 0x2 to __int 0x2 +cast from float 0x2 to __uint 0x2 +cast from float 0x2 to float 0x2 +cast from float 0x2 (0x2) + to __longlong 0x2 (0x2) + +cast from float 0x2 (0x2) + to __ulonglong 0x2 (0x2) + +cast from __longlong 0x2 to char 0x2 +cast from __longlong 0x2 to __uchar 0x2 +cast from __longlong 0x2 to __int 0x2 +cast from __longlong 0x2 to __uint 0x2 +cast from __longlong 0x2 to float 0x2 +cast from __longlong 0x2 (0x2) + to __longlong 0x2 (0x2) + +cast from __longlong 0x2 (0x2) + to __ulonglong 0x2 (0x2) + +cast from __ulonglong 0x2 to char 0x2 +cast from __ulonglong 0x2 to __uchar 0x2 +cast from __ulonglong 0x2 to __int 0x2 +cast from __ulonglong 0x2 to __uint 0x2 +cast from __ulonglong 0x2 to float 0x2 +cast from __ulonglong 0x2 (0x2) + to __longlong 0x2 (0x2) + +cast from __ulonglong 0x2 (0x2) + to __ulonglong 0x2 (0x2) + +cast from char -0x2 to char -0x2 +cast from char 0xfffe to __uchar 0xfe +cast from char -0x2 to __int -0x2 +cast from char 0xfffe to __uint 0xfffe +cast from char -0x2 to float -0x2 +cast from char 0xfffffffe (0xfffffffe) + to __longlong 0xfffffffe (0xfffffffe) + +cast from char 0xfffffffe (0xfffffffe) + to __ulonglong 0xfffffffe (0xfffffffe) + +cast from __uchar 0xfe to char -0x2 +cast from __uchar 0xfe to __uchar 0xfe +cast from __uchar 0xfe to __int 0xfe +cast from __uchar 0xfe to __uint 0xfe +cast from __uchar 0xfe to float 0xfe +cast from __uchar 0xfe (0xfe) + to __longlong 0xfe (0xfe) + +cast from __uchar 0xfe (0xfe) + to __ulonglong 0xfe (0xfe) + +cast from __int -0x2 to char -0x2 +cast from __int 0xfffe to __uchar 0xfe +cast from __int -0x2 to __int -0x2 +cast from __int 0xfffe to __uint 0xfffe +cast from __int -0x2 to float -0x2 +cast from __int 0xfffffffe (0xfffffffe) + to __longlong 0xfffffffe (0xfffffffe) + +cast from __int 0xfffffffe (0xfffffffe) + to __ulonglong 0xfffffffe (0xfffffffe) + +cast from __uint -0x2 to char -0x2 +cast from __uint 0xfffe to __uchar 0xfe +cast from __uint -0x2 to __int -0x2 +cast from __uint 0xfffe to __uint 0xfffe +cast from __uint -0x2 to float -0x8000 +cast from __uint 0xfffe (0xfffe) + to __longlong 0xfffe (0xfffe) + +cast from __uint 0xfffe (0xfffe) + to __ulonglong 0xfffe (0xfffe) + +cast from float -0x2 to char -0x2 +cast from float 0xfffe to __uchar 0xfe +cast from float -0x2 to __int -0x2 +cast from float 0xfffe to __uint 0xfffe +cast from float -0x2 to float -0x2 +cast from float 0xfffffffe (0xfffffffe) + to __longlong 0xfffffffe (0xfffffffe) + +cast from float 0xfffffffe (0xfffffffe) + to __ulonglong 0xfffffffe (0xfffffffe) + +cast from __longlong -0x2 to char -0x2 +cast from __longlong 0xfffe to __uchar 0xfe +cast from __longlong -0x2 to __int -0x2 +cast from __longlong 0xfffe to __uint 0xfffe +cast from __longlong -0x2 to float -0x2 +cast from __longlong 0xfffffffe (0xfffffffe) + to __longlong 0xfffffffe (0xfffffffe) + +cast from __longlong 0xfffffffe (0xfffffffe) + to __ulonglong 0xfffffffe (0xfffffffe) + +cast from __ulonglong -0x2 to char -0x2 +cast from __ulonglong 0xfffe to __uchar 0xfe +cast from __ulonglong -0x2 to __int -0x2 +cast from __ulonglong 0xfffe to __uint 0xfffe +cast from __ulonglong -0x2 to float -0x8000 +cast from __ulonglong 0xfffffffe (0xfffffffe) + to __longlong 0xfffffffe (0xfffffffe) + +cast from __ulonglong 0xfffffffe (0xfffffffe) + to __ulonglong 0xfffffffe (0xfffffffe) + +cast from char 0x4 to char 0x4 +cast from char 0x4 to __uchar 0x4 +cast from char 0x4 to __int 0x4 +cast from char 0x4 to __uint 0x4 +cast from char 0x4 to float 0x4 +cast from char 0x4 (0x4) + to __longlong 0x4 (0x4) + +cast from char 0x4 (0x4) + to __ulonglong 0x4 (0x4) + +cast from __uchar 0x4 to char 0x4 +cast from __uchar 0x4 to __uchar 0x4 +cast from __uchar 0x4 to __int 0x4 +cast from __uchar 0x4 to __uint 0x4 +cast from __uchar 0x4 to float 0x4 +cast from __uchar 0x4 (0x4) + to __longlong 0x4 (0x4) + +cast from __uchar 0x4 (0x4) + to __ulonglong 0x4 (0x4) + +cast from __int 0x4 to char 0x4 +cast from __int 0x4 to __uchar 0x4 +cast from __int 0x4 to __int 0x4 +cast from __int 0x4 to __uint 0x4 +cast from __int 0x4 to float 0x4 +cast from __int 0x4 (0x4) + to __longlong 0x4 (0x4) + +cast from __int 0x4 (0x4) + to __ulonglong 0x4 (0x4) + +cast from __uint 0x4 to char 0x4 +cast from __uint 0x4 to __uchar 0x4 +cast from __uint 0x4 to __int 0x4 +cast from __uint 0x4 to __uint 0x4 +cast from __uint 0x4 to float 0x4 +cast from __uint 0x4 (0x4) + to __longlong 0x4 (0x4) + +cast from __uint 0x4 (0x4) + to __ulonglong 0x4 (0x4) + +cast from float 0x4 to char 0x4 +cast from float 0x4 to __uchar 0x4 +cast from float 0x4 to __int 0x4 +cast from float 0x4 to __uint 0x4 +cast from float 0x4 to float 0x4 +cast from float 0x4 (0x4) + to __longlong 0x4 (0x4) + +cast from float 0x4 (0x4) + to __ulonglong 0x4 (0x4) + +cast from __longlong 0x4 to char 0x4 +cast from __longlong 0x4 to __uchar 0x4 +cast from __longlong 0x4 to __int 0x4 +cast from __longlong 0x4 to __uint 0x4 +cast from __longlong 0x4 to float 0x4 +cast from __longlong 0x4 (0x4) + to __longlong 0x4 (0x4) + +cast from __longlong 0x4 (0x4) + to __ulonglong 0x4 (0x4) + +cast from __ulonglong 0x4 to char 0x4 +cast from __ulonglong 0x4 to __uchar 0x4 +cast from __ulonglong 0x4 to __int 0x4 +cast from __ulonglong 0x4 to __uint 0x4 +cast from __ulonglong 0x4 to float 0x4 +cast from __ulonglong 0x4 (0x4) + to __longlong 0x4 (0x4) + +cast from __ulonglong 0x4 (0x4) + to __ulonglong 0x4 (0x4) + +cast from char -0x4 to char -0x4 +cast from char 0xfffc to __uchar 0xfc +cast from char -0x4 to __int -0x4 +cast from char 0xfffc to __uint 0xfffc +cast from char -0x4 to float -0x4 +cast from char 0xfffffffc (0xfffffffc) + to __longlong 0xfffffffc (0xfffffffc) + +cast from char 0xfffffffc (0xfffffffc) + to __ulonglong 0xfffffffc (0xfffffffc) + +cast from __uchar 0xfc to char -0x4 +cast from __uchar 0xfc to __uchar 0xfc +cast from __uchar 0xfc to __int 0xfc +cast from __uchar 0xfc to __uint 0xfc +cast from __uchar 0xfc to float 0xfc +cast from __uchar 0xfc (0xfc) + to __longlong 0xfc (0xfc) + +cast from __uchar 0xfc (0xfc) + to __ulonglong 0xfc (0xfc) + +cast from __int -0x4 to char -0x4 +cast from __int 0xfffc to __uchar 0xfc +cast from __int -0x4 to __int -0x4 +cast from __int 0xfffc to __uint 0xfffc +cast from __int -0x4 to float -0x4 +cast from __int 0xfffffffc (0xfffffffc) + to __longlong 0xfffffffc (0xfffffffc) + +cast from __int 0xfffffffc (0xfffffffc) + to __ulonglong 0xfffffffc (0xfffffffc) + +cast from __uint -0x4 to char -0x4 +cast from __uint 0xfffc to __uchar 0xfc +cast from __uint -0x4 to __int -0x4 +cast from __uint 0xfffc to __uint 0xfffc +cast from __uint -0x4 to float -0x8000 +cast from __uint 0xfffc (0xfffc) + to __longlong 0xfffc (0xfffc) + +cast from __uint 0xfffc (0xfffc) + to __ulonglong 0xfffc (0xfffc) + +cast from float -0x4 to char -0x4 +cast from float 0xfffc to __uchar 0xfc +cast from float -0x4 to __int -0x4 +cast from float 0xfffc to __uint 0xfffc +cast from float -0x4 to float -0x4 +cast from float 0xfffffffc (0xfffffffc) + to __longlong 0xfffffffc (0xfffffffc) + +cast from float 0xfffffffc (0xfffffffc) + to __ulonglong 0xfffffffc (0xfffffffc) + +cast from __longlong -0x4 to char -0x4 +cast from __longlong 0xfffc to __uchar 0xfc +cast from __longlong -0x4 to __int -0x4 +cast from __longlong 0xfffc to __uint 0xfffc +cast from __longlong -0x4 to float -0x4 +cast from __longlong 0xfffffffc (0xfffffffc) + to __longlong 0xfffffffc (0xfffffffc) + +cast from __longlong 0xfffffffc (0xfffffffc) + to __ulonglong 0xfffffffc (0xfffffffc) + +cast from __ulonglong -0x4 to char -0x4 +cast from __ulonglong 0xfffc to __uchar 0xfc +cast from __ulonglong -0x4 to __int -0x4 +cast from __ulonglong 0xfffc to __uint 0xfffc +cast from __ulonglong -0x4 to float -0x8000 +cast from __ulonglong 0xfffffffc (0xfffffffc) + to __longlong 0xfffffffc (0xfffffffc) + +cast from __ulonglong 0xfffffffc (0xfffffffc) + to __ulonglong 0xfffffffc (0xfffffffc) + +cast from char 0xa to char 0xa +cast from char 0xa to __uchar 0xa +cast from char 0xa to __int 0xa +cast from char 0xa to __uint 0xa +cast from char 0xa to float 0xa +cast from char 0xa (0xa) + to __longlong 0xa (0xa) + +cast from char 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from __uchar 0xa to char 0xa +cast from __uchar 0xa to __uchar 0xa +cast from __uchar 0xa to __int 0xa +cast from __uchar 0xa to __uint 0xa +cast from __uchar 0xa to float 0xa +cast from __uchar 0xa (0xa) + to __longlong 0xa (0xa) + +cast from __uchar 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from __int 0xa to char 0xa +cast from __int 0xa to __uchar 0xa +cast from __int 0xa to __int 0xa +cast from __int 0xa to __uint 0xa +cast from __int 0xa to float 0xa +cast from __int 0xa (0xa) + to __longlong 0xa (0xa) + +cast from __int 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from __uint 0xa to char 0xa +cast from __uint 0xa to __uchar 0xa +cast from __uint 0xa to __int 0xa +cast from __uint 0xa to __uint 0xa +cast from __uint 0xa to float 0xa +cast from __uint 0xa (0xa) + to __longlong 0xa (0xa) + +cast from __uint 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from float 0xa to char 0xa +cast from float 0xa to __uchar 0xa +cast from float 0xa to __int 0xa +cast from float 0xa to __uint 0xa +cast from float 0xa to float 0xa +cast from float 0xa (0xa) + to __longlong 0xa (0xa) + +cast from float 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from __longlong 0xa to char 0xa +cast from __longlong 0xa to __uchar 0xa +cast from __longlong 0xa to __int 0xa +cast from __longlong 0xa to __uint 0xa +cast from __longlong 0xa to float 0xa +cast from __longlong 0xa (0xa) + to __longlong 0xa (0xa) + +cast from __longlong 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from __ulonglong 0xa to char 0xa +cast from __ulonglong 0xa to __uchar 0xa +cast from __ulonglong 0xa to __int 0xa +cast from __ulonglong 0xa to __uint 0xa +cast from __ulonglong 0xa to float 0xa +cast from __ulonglong 0xa (0xa) + to __longlong 0xa (0xa) + +cast from __ulonglong 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from char -0xa to char -0xa +cast from char 0xfff6 to __uchar 0xf6 +cast from char -0xa to __int -0xa +cast from char 0xfff6 to __uint 0xfff6 +cast from char -0xa to float -0xa +cast from char 0xfffffff6 (0xfffffff6) + to __longlong 0xfffffff6 (0xfffffff6) + +cast from char 0xfffffff6 (0xfffffff6) + to __ulonglong 0xfffffff6 (0xfffffff6) + +cast from __uchar 0xf6 to char -0xa +cast from __uchar 0xf6 to __uchar 0xf6 +cast from __uchar 0xf6 to __int 0xf6 +cast from __uchar 0xf6 to __uint 0xf6 +cast from __uchar 0xf6 to float 0xf6 +cast from __uchar 0xf6 (0xf6) + to __longlong 0xf6 (0xf6) + +cast from __uchar 0xf6 (0xf6) + to __ulonglong 0xf6 (0xf6) + +cast from __int -0xa to char -0xa +cast from __int 0xfff6 to __uchar 0xf6 +cast from __int -0xa to __int -0xa +cast from __int 0xfff6 to __uint 0xfff6 +cast from __int -0xa to float -0xa +cast from __int 0xfffffff6 (0xfffffff6) + to __longlong 0xfffffff6 (0xfffffff6) + +cast from __int 0xfffffff6 (0xfffffff6) + to __ulonglong 0xfffffff6 (0xfffffff6) + +cast from __uint -0xa to char -0xa +cast from __uint 0xfff6 to __uchar 0xf6 +cast from __uint -0xa to __int -0xa +cast from __uint 0xfff6 to __uint 0xfff6 +cast from __uint -0xa to float -0x8000 +cast from __uint 0xfff6 (0xfff6) + to __longlong 0xfff6 (0xfff6) + +cast from __uint 0xfff6 (0xfff6) + to __ulonglong 0xfff6 (0xfff6) + +cast from float -0xa to char -0xa +cast from float 0xfff6 to __uchar 0xf6 +cast from float -0xa to __int -0xa +cast from float 0xfff6 to __uint 0xfff6 +cast from float -0xa to float -0xa +cast from float 0xfffffff6 (0xfffffff6) + to __longlong 0xfffffff6 (0xfffffff6) + +cast from float 0xfffffff6 (0xfffffff6) + to __ulonglong 0xfffffff6 (0xfffffff6) + +cast from __longlong -0xa to char -0xa +cast from __longlong 0xfff6 to __uchar 0xf6 +cast from __longlong -0xa to __int -0xa +cast from __longlong 0xfff6 to __uint 0xfff6 +cast from __longlong -0xa to float -0xa +cast from __longlong 0xfffffff6 (0xfffffff6) + to __longlong 0xfffffff6 (0xfffffff6) + +cast from __longlong 0xfffffff6 (0xfffffff6) + to __ulonglong 0xfffffff6 (0xfffffff6) + +cast from __ulonglong -0xa to char -0xa +cast from __ulonglong 0xfff6 to __uchar 0xf6 +cast from __ulonglong -0xa to __int -0xa +cast from __ulonglong 0xfff6 to __uint 0xfff6 +cast from __ulonglong -0xa to float -0x8000 +cast from __ulonglong 0xfffffff6 (0xfffffff6) + to __longlong 0xfffffff6 (0xfffffff6) + +cast from __ulonglong 0xfffffff6 (0xfffffff6) + to __ulonglong 0xfffffff6 (0xfffffff6) + +cast from char 0x5 to char 0x5 +cast from char 0x5 to __uchar 0x5 +cast from char 0x5 to __int 0x5 +cast from char 0x5 to __uint 0x5 +cast from char 0x5 to float 0x5 +cast from char 0x5 (0x5) + to __longlong 0x5 (0x5) + +cast from char 0x5 (0x5) + to __ulonglong 0x5 (0x5) + +cast from __uchar 0x5 to char 0x5 +cast from __uchar 0x5 to __uchar 0x5 +cast from __uchar 0x5 to __int 0x5 +cast from __uchar 0x5 to __uint 0x5 +cast from __uchar 0x5 to float 0x5 +cast from __uchar 0x5 (0x5) + to __longlong 0x5 (0x5) + +cast from __uchar 0x5 (0x5) + to __ulonglong 0x5 (0x5) + +cast from __int 0x5 to char 0x5 +cast from __int 0x5 to __uchar 0x5 +cast from __int 0x5 to __int 0x5 +cast from __int 0x5 to __uint 0x5 +cast from __int 0x5 to float 0x5 +cast from __int 0x5 (0x5) + to __longlong 0x5 (0x5) + +cast from __int 0x5 (0x5) + to __ulonglong 0x5 (0x5) + +cast from __uint 0x5 to char 0x5 +cast from __uint 0x5 to __uchar 0x5 +cast from __uint 0x5 to __int 0x5 +cast from __uint 0x5 to __uint 0x5 +cast from __uint 0x5 to float 0x5 +cast from __uint 0x5 (0x5) + to __longlong 0x5 (0x5) + +cast from __uint 0x5 (0x5) + to __ulonglong 0x5 (0x5) + +cast from float 0x5 to char 0x5 +cast from float 0x5 to __uchar 0x5 +cast from float 0x5 to __int 0x5 +cast from float 0x5 to __uint 0x5 +cast from float 0x5 to float 0x5 +cast from float 0x5 (0x5) + to __longlong 0x5 (0x5) + +cast from float 0x5 (0x5) + to __ulonglong 0x5 (0x5) + +cast from __longlong 0x5 to char 0x5 +cast from __longlong 0x5 to __uchar 0x5 +cast from __longlong 0x5 to __int 0x5 +cast from __longlong 0x5 to __uint 0x5 +cast from __longlong 0x5 to float 0x5 +cast from __longlong 0x5 (0x5) + to __longlong 0x5 (0x5) + +cast from __longlong 0x5 (0x5) + to __ulonglong 0x5 (0x5) + +cast from __ulonglong 0x5 to char 0x5 +cast from __ulonglong 0x5 to __uchar 0x5 +cast from __ulonglong 0x5 to __int 0x5 +cast from __ulonglong 0x5 to __uint 0x5 +cast from __ulonglong 0x5 to float 0x5 +cast from __ulonglong 0x5 (0x5) + to __longlong 0x5 (0x5) + +cast from __ulonglong 0x5 (0x5) + to __ulonglong 0x5 (0x5) + +cast from char 0x7 to char 0x7 +cast from char 0x7 to __uchar 0x7 +cast from char 0x7 to __int 0x7 +cast from char 0x7 to __uint 0x7 +cast from char 0x7 to float 0x7 +cast from char 0x7 (0x7) + to __longlong 0x7 (0x7) + +cast from char 0x7 (0x7) + to __ulonglong 0x7 (0x7) + +cast from __uchar 0x7 to char 0x7 +cast from __uchar 0x7 to __uchar 0x7 +cast from __uchar 0x7 to __int 0x7 +cast from __uchar 0x7 to __uint 0x7 +cast from __uchar 0x7 to float 0x7 +cast from __uchar 0x7 (0x7) + to __longlong 0x7 (0x7) + +cast from __uchar 0x7 (0x7) + to __ulonglong 0x7 (0x7) + +cast from __int 0x7 to char 0x7 +cast from __int 0x7 to __uchar 0x7 +cast from __int 0x7 to __int 0x7 +cast from __int 0x7 to __uint 0x7 +cast from __int 0x7 to float 0x7 +cast from __int 0x7 (0x7) + to __longlong 0x7 (0x7) + +cast from __int 0x7 (0x7) + to __ulonglong 0x7 (0x7) + +cast from __uint 0x7 to char 0x7 +cast from __uint 0x7 to __uchar 0x7 +cast from __uint 0x7 to __int 0x7 +cast from __uint 0x7 to __uint 0x7 +cast from __uint 0x7 to float 0x7 +cast from __uint 0x7 (0x7) + to __longlong 0x7 (0x7) + +cast from __uint 0x7 (0x7) + to __ulonglong 0x7 (0x7) + +cast from float 0x7 to char 0x7 +cast from float 0x7 to __uchar 0x7 +cast from float 0x7 to __int 0x7 +cast from float 0x7 to __uint 0x7 +cast from float 0x7 to float 0x7 +cast from float 0x7 (0x7) + to __longlong 0x7 (0x7) + +cast from float 0x7 (0x7) + to __ulonglong 0x7 (0x7) + +cast from __longlong 0x7 to char 0x7 +cast from __longlong 0x7 to __uchar 0x7 +cast from __longlong 0x7 to __int 0x7 +cast from __longlong 0x7 to __uint 0x7 +cast from __longlong 0x7 to float 0x7 +cast from __longlong 0x7 (0x7) + to __longlong 0x7 (0x7) + +cast from __longlong 0x7 (0x7) + to __ulonglong 0x7 (0x7) + +cast from __ulonglong 0x7 to char 0x7 +cast from __ulonglong 0x7 to __uchar 0x7 +cast from __ulonglong 0x7 to __int 0x7 +cast from __ulonglong 0x7 to __uint 0x7 +cast from __ulonglong 0x7 to float 0x7 +cast from __ulonglong 0x7 (0x7) + to __longlong 0x7 (0x7) + +cast from __ulonglong 0x7 (0x7) + to __ulonglong 0x7 (0x7) + +cast from char 0x2a to char 0x2a +cast from char 0x2a to __uchar 0x2a +cast from char 0x2a to __int 0x2a +cast from char 0x2a to __uint 0x2a +cast from char 0x2a to float 0x2a +cast from char 0x2a (0x2a) + to __longlong 0x2a (0x2a) + +cast from char 0x2a (0x2a) + to __ulonglong 0x2a (0x2a) + +cast from __uchar 0x2a to char 0x2a +cast from __uchar 0x2a to __uchar 0x2a +cast from __uchar 0x2a to __int 0x2a +cast from __uchar 0x2a to __uint 0x2a +cast from __uchar 0x2a to float 0x2a +cast from __uchar 0x2a (0x2a) + to __longlong 0x2a (0x2a) + +cast from __uchar 0x2a (0x2a) + to __ulonglong 0x2a (0x2a) + +cast from __int 0x2a to char 0x2a +cast from __int 0x2a to __uchar 0x2a +cast from __int 0x2a to __int 0x2a +cast from __int 0x2a to __uint 0x2a +cast from __int 0x2a to float 0x2a +cast from __int 0x2a (0x2a) + to __longlong 0x2a (0x2a) + +cast from __int 0x2a (0x2a) + to __ulonglong 0x2a (0x2a) + +cast from __uint 0x2a to char 0x2a +cast from __uint 0x2a to __uchar 0x2a +cast from __uint 0x2a to __int 0x2a +cast from __uint 0x2a to __uint 0x2a +cast from __uint 0x2a to float 0x2a +cast from __uint 0x2a (0x2a) + to __longlong 0x2a (0x2a) + +cast from __uint 0x2a (0x2a) + to __ulonglong 0x2a (0x2a) + +cast from float 0x2a to char 0x2a +cast from float 0x2a to __uchar 0x2a +cast from float 0x2a to __int 0x2a +cast from float 0x2a to __uint 0x2a +cast from float 0x2a to float 0x2a +cast from float 0x2a (0x2a) + to __longlong 0x2a (0x2a) + +cast from float 0x2a (0x2a) + to __ulonglong 0x2a (0x2a) + +cast from __longlong 0x2a to char 0x2a +cast from __longlong 0x2a to __uchar 0x2a +cast from __longlong 0x2a to __int 0x2a +cast from __longlong 0x2a to __uint 0x2a +cast from __longlong 0x2a to float 0x2a +cast from __longlong 0x2a (0x2a) + to __longlong 0x2a (0x2a) + +cast from __longlong 0x2a (0x2a) + to __ulonglong 0x2a (0x2a) + +cast from __ulonglong 0x2a to char 0x2a +cast from __ulonglong 0x2a to __uchar 0x2a +cast from __ulonglong 0x2a to __int 0x2a +cast from __ulonglong 0x2a to __uint 0x2a +cast from __ulonglong 0x2a to float 0x2a +cast from __ulonglong 0x2a (0x2a) + to __longlong 0x2a (0x2a) + +cast from __ulonglong 0x2a (0x2a) + to __ulonglong 0x2a (0x2a) + +cast from char 0x17 to char 0x17 +cast from char 0x17 to __uchar 0x17 +cast from char 0x17 to __int 0x17 +cast from char 0x17 to __uint 0x17 +cast from char 0x17 to float 0x17 +cast from char 0x17 (0x17) + to __longlong 0x17 (0x17) + +cast from char 0x17 (0x17) + to __ulonglong 0x17 (0x17) + +cast from __uchar 0x17 to char 0x17 +cast from __uchar 0x17 to __uchar 0x17 +cast from __uchar 0x17 to __int 0x17 +cast from __uchar 0x17 to __uint 0x17 +cast from __uchar 0x17 to float 0x17 +cast from __uchar 0x17 (0x17) + to __longlong 0x17 (0x17) + +cast from __uchar 0x17 (0x17) + to __ulonglong 0x17 (0x17) + +cast from __int 0x17 to char 0x17 +cast from __int 0x17 to __uchar 0x17 +cast from __int 0x17 to __int 0x17 +cast from __int 0x17 to __uint 0x17 +cast from __int 0x17 to float 0x17 +cast from __int 0x17 (0x17) + to __longlong 0x17 (0x17) + +cast from __int 0x17 (0x17) + to __ulonglong 0x17 (0x17) + +cast from __uint 0x17 to char 0x17 +cast from __uint 0x17 to __uchar 0x17 +cast from __uint 0x17 to __int 0x17 +cast from __uint 0x17 to __uint 0x17 +cast from __uint 0x17 to float 0x17 +cast from __uint 0x17 (0x17) + to __longlong 0x17 (0x17) + +cast from __uint 0x17 (0x17) + to __ulonglong 0x17 (0x17) + +cast from float 0x17 to char 0x17 +cast from float 0x17 to __uchar 0x17 +cast from float 0x17 to __int 0x17 +cast from float 0x17 to __uint 0x17 +cast from float 0x17 to float 0x17 +cast from float 0x17 (0x17) + to __longlong 0x17 (0x17) + +cast from float 0x17 (0x17) + to __ulonglong 0x17 (0x17) + +cast from __longlong 0x17 to char 0x17 +cast from __longlong 0x17 to __uchar 0x17 +cast from __longlong 0x17 to __int 0x17 +cast from __longlong 0x17 to __uint 0x17 +cast from __longlong 0x17 to float 0x17 +cast from __longlong 0x17 (0x17) + to __longlong 0x17 (0x17) + +cast from __longlong 0x17 (0x17) + to __ulonglong 0x17 (0x17) + +cast from __ulonglong 0x17 to char 0x17 +cast from __ulonglong 0x17 to __uchar 0x17 +cast from __ulonglong 0x17 to __int 0x17 +cast from __ulonglong 0x17 to __uint 0x17 +cast from __ulonglong 0x17 to float 0x17 +cast from __ulonglong 0x17 (0x17) + to __longlong 0x17 (0x17) + +cast from __ulonglong 0x17 (0x17) + to __ulonglong 0x17 (0x17) + +cast from char -0x1 to char -0x1 +cast from char 0xffff to __uchar 0xff +cast from char -0x1 to __int -0x1 +cast from char 0xffff to __uint 0xffff +cast from char -0x1 to float -0x1 +cast from char 0xffffffff (0xffffffff) + to __longlong 0xffffffff (0xffffffff) + +cast from char 0xffffffff (0xffffffff) + to __ulonglong 0xffffffff (0xffffffff) + +cast from __uchar 0xff to char -0x1 +cast from __uchar 0xff to __uchar 0xff +cast from __uchar 0xff to __int 0xff +cast from __uchar 0xff to __uint 0xff +cast from __uchar 0xff to float 0xff +cast from __uchar 0xff (0xff) + to __longlong 0xff (0xff) + +cast from __uchar 0xff (0xff) + to __ulonglong 0xff (0xff) + +cast from __int 0x7fff to char -0x1 +cast from __int 0x7fff to __uchar 0xff +cast from __int 0x7fff to __int 0x7fff +cast from __int 0x7fff to __uint 0x7fff +cast from __int 0x7fff to float 0x7fff +cast from __int 0x7fff (0x7fff) + to __longlong 0x7fff (0x7fff) + +cast from __int 0x7fff (0x7fff) + to __ulonglong 0x7fff (0x7fff) + +cast from __uint 0x7fff to char -0x1 +cast from __uint 0x7fff to __uchar 0xff +cast from __uint 0x7fff to __int 0x7fff +cast from __uint 0x7fff to __uint 0x7fff +cast from __uint 0x7fff to float 0x7fff +cast from __uint 0x7fff (0x7fff) + to __longlong 0x7fff (0x7fff) + +cast from __uint 0x7fff (0x7fff) + to __ulonglong 0x7fff (0x7fff) + +cast from float 0x7fff to char -0x1 +cast from float 0x7fff to __uchar 0xff +cast from float 0x7fff to __int 0x7fff +cast from float 0x7fff to __uint 0x7fff +cast from float 0x7fff to float 0x7fff +cast from float 0x7fff (0x7fff) + to __longlong 0x7fff (0x7fff) + +cast from float 0x7fff (0x7fff) + to __ulonglong 0x7fff (0x7fff) + +cast from __longlong 0x7fff to char -0x1 +cast from __longlong 0x7fff to __uchar 0xff +cast from __longlong 0x7fff to __int 0x7fff +cast from __longlong 0x7fff to __uint 0x7fff +cast from __longlong 0x7fff to float 0x7fff +cast from __longlong 0x7fff (0x7fff) + to __longlong 0x7fff (0x7fff) + +cast from __longlong 0x7fff (0x7fff) + to __ulonglong 0x7fff (0x7fff) + +cast from __ulonglong 0x7fff to char -0x1 +cast from __ulonglong 0x7fff to __uchar 0xff +cast from __ulonglong 0x7fff to __int 0x7fff +cast from __ulonglong 0x7fff to __uint 0x7fff +cast from __ulonglong 0x7fff to float 0x7fff +cast from __ulonglong 0x7fff (0x7fff) + to __longlong 0x7fff (0x7fff) + +cast from __ulonglong 0x7fff (0x7fff) + to __ulonglong 0x7fff (0x7fff) + +cast from char 0x0 to char 0x0 +cast from char 0x0 to __uchar 0x0 +cast from char 0x0 to __int 0x0 +cast from char 0x0 to __uint 0x0 +cast from char 0x0 to float 0x0 +cast from char 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from char 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __uchar 0x0 to char 0x0 +cast from __uchar 0x0 to __uchar 0x0 +cast from __uchar 0x0 to __int 0x0 +cast from __uchar 0x0 to __uint 0x0 +cast from __uchar 0x0 to float 0x0 +cast from __uchar 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __uchar 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __int -0x8000 to char 0x0 +cast from __int 0x8000 to __uchar 0x0 +cast from __int -0x8000 to __int -0x8000 +cast from __int 0x8000 to __uint 0x8000 +cast from __int -0x8000 to float -0x8000 +cast from __int 0xffff8000 (0xffff8000) + to __longlong 0xffff8000 (0xffff8000) + +cast from __int 0xffff8000 (0xffff8000) + to __ulonglong 0xffff8000 (0xffff8000) + +cast from __uint -0x8000 to char 0x0 +cast from __uint 0x8000 to __uchar 0x0 +cast from __uint -0x8000 to __int -0x8000 +cast from __uint 0x8000 to __uint 0x8000 +cast from __uint -0x8000 to float -0x8000 +cast from __uint 0x8000 (0x8000) + to __longlong 0x8000 (0x8000) + +cast from __uint 0x8000 (0x8000) + to __ulonglong 0x8000 (0x8000) + +cast from float -0x8000 to char 0x0 +cast from float 0x8000 to __uchar 0x0 +cast from float -0x8000 to __int -0x8000 +cast from float 0x8000 to __uint 0x8000 +cast from float -0x8000 to float -0x8000 +cast from float 0xffff8000 (0xffff8000) + to __longlong 0xffff8000 (0xffff8000) + +cast from float 0xffff8000 (0xffff8000) + to __ulonglong 0xffff8000 (0xffff8000) + +cast from __longlong -0x8000 to char 0x0 +cast from __longlong 0x8000 to __uchar 0x0 +cast from __longlong -0x8000 to __int -0x8000 +cast from __longlong 0x8000 to __uint 0x8000 +cast from __longlong -0x8000 to float -0x8000 +cast from __longlong 0xffff8000 (0xffff8000) + to __longlong 0xffff8000 (0xffff8000) + +cast from __longlong 0xffff8000 (0xffff8000) + to __ulonglong 0xffff8000 (0xffff8000) + +cast from __ulonglong -0x8000 to char 0x0 +cast from __ulonglong 0x8000 to __uchar 0x0 +cast from __ulonglong -0x8000 to __int -0x8000 +cast from __ulonglong 0x8000 to __uint 0x8000 +cast from __ulonglong -0x8000 to float -0x8000 +cast from __ulonglong 0xffff8000 (0xffff8000) + to __longlong 0xffff8000 (0xffff8000) + +cast from __ulonglong 0xffff8000 (0xffff8000) + to __ulonglong 0xffff8000 (0xffff8000) + +cast from char 0x18 to char 0x18 +cast from char 0x18 to __uchar 0x18 +cast from char 0x18 to __int 0x18 +cast from char 0x18 to __uint 0x18 +cast from char 0x18 to float 0x18 +cast from char 0x18 (0x18) + to __longlong 0x18 (0x18) + +cast from char 0x18 (0x18) + to __ulonglong 0x18 (0x18) + +cast from __uchar 0x18 to char 0x18 +cast from __uchar 0x18 to __uchar 0x18 +cast from __uchar 0x18 to __int 0x18 +cast from __uchar 0x18 to __uint 0x18 +cast from __uchar 0x18 to float 0x18 +cast from __uchar 0x18 (0x18) + to __longlong 0x18 (0x18) + +cast from __uchar 0x18 (0x18) + to __ulonglong 0x18 (0x18) + +cast from __int -0x3e8 to char 0x18 +cast from __int 0xfc18 to __uchar 0x18 +cast from __int -0x3e8 to __int -0x3e8 +cast from __int 0xfc18 to __uint 0xfc18 +cast from __int -0x3e8 to float -0x3e8 +cast from __int 0xfffffc18 (0xfffffc18) + to __longlong 0xfffffc18 (0xfffffc18) + +cast from __int 0xfffffc18 (0xfffffc18) + to __ulonglong 0xfffffc18 (0xfffffc18) + +cast from __uint -0x3e8 to char 0x18 +cast from __uint 0xfc18 to __uchar 0x18 +cast from __uint -0x3e8 to __int -0x3e8 +cast from __uint 0xfc18 to __uint 0xfc18 +cast from __uint -0x3e8 to float -0x8000 +cast from __uint 0xfc18 (0xfc18) + to __longlong 0xfc18 (0xfc18) + +cast from __uint 0xfc18 (0xfc18) + to __ulonglong 0xfc18 (0xfc18) + +cast from float -0x3e8 to char 0x18 +cast from float 0xfc18 to __uchar 0x18 +cast from float -0x3e8 to __int -0x3e8 +cast from float 0xfc18 to __uint 0xfc18 +cast from float -0x3e8 to float -0x3e8 +cast from float 0xfffffc18 (0xfffffc18) + to __longlong 0xfffffc18 (0xfffffc18) + +cast from float 0xfffffc18 (0xfffffc18) + to __ulonglong 0xfffffc18 (0xfffffc18) + +cast from __longlong -0x3e8 to char 0x18 +cast from __longlong 0xfc18 to __uchar 0x18 +cast from __longlong -0x3e8 to __int -0x3e8 +cast from __longlong 0xfc18 to __uint 0xfc18 +cast from __longlong -0x3e8 to float -0x3e8 +cast from __longlong 0xfffffc18 (0xfffffc18) + to __longlong 0xfffffc18 (0xfffffc18) + +cast from __longlong 0xfffffc18 (0xfffffc18) + to __ulonglong 0xfffffc18 (0xfffffc18) + +cast from __ulonglong -0x3e8 to char 0x18 +cast from __ulonglong 0xfc18 to __uchar 0x18 +cast from __ulonglong -0x3e8 to __int -0x3e8 +cast from __ulonglong 0xfc18 to __uint 0xfc18 +cast from __ulonglong -0x3e8 to float -0x8000 +cast from __ulonglong 0xfffffc18 (0xfffffc18) + to __longlong 0xfffffc18 (0xfffffc18) + +cast from __ulonglong 0xfffffc18 (0xfffffc18) + to __ulonglong 0xfffffc18 (0xfffffc18) + +cast from char -0x10 to char -0x10 +cast from char 0xfff0 to __uchar 0xf0 +cast from char -0x10 to __int -0x10 +cast from char 0xfff0 to __uint 0xfff0 +cast from char -0x10 to float -0x10 +cast from char 0xfffffff0 (0xfffffff0) + to __longlong 0xfffffff0 (0xfffffff0) + +cast from char 0xfffffff0 (0xfffffff0) + to __ulonglong 0xfffffff0 (0xfffffff0) + +cast from __uchar 0xf0 to char -0x10 +cast from __uchar 0xf0 to __uchar 0xf0 +cast from __uchar 0xf0 to __int 0xf0 +cast from __uchar 0xf0 to __uint 0xf0 +cast from __uchar 0xf0 to float 0xf0 +cast from __uchar 0xf0 (0xf0) + to __longlong 0xf0 (0xf0) + +cast from __uchar 0xf0 (0xf0) + to __ulonglong 0xf0 (0xf0) + +cast from __int -0x2710 to char -0x10 +cast from __int 0xd8f0 to __uchar 0xf0 +cast from __int -0x2710 to __int -0x2710 +cast from __int 0xd8f0 to __uint 0xd8f0 +cast from __int -0x2710 to float -0x2710 +cast from __int 0xffffd8f0 (0xffffd8f0) + to __longlong 0xffffd8f0 (0xffffd8f0) + +cast from __int 0xffffd8f0 (0xffffd8f0) + to __ulonglong 0xffffd8f0 (0xffffd8f0) + +cast from __uint -0x2710 to char -0x10 +cast from __uint 0xd8f0 to __uchar 0xf0 +cast from __uint -0x2710 to __int -0x2710 +cast from __uint 0xd8f0 to __uint 0xd8f0 +cast from __uint -0x2710 to float -0x8000 +cast from __uint 0xd8f0 (0xd8f0) + to __longlong 0xd8f0 (0xd8f0) + +cast from __uint 0xd8f0 (0xd8f0) + to __ulonglong 0xd8f0 (0xd8f0) + +cast from float -0x2710 to char -0x10 +cast from float 0xd8f0 to __uchar 0xf0 +cast from float -0x2710 to __int -0x2710 +cast from float 0xd8f0 to __uint 0xd8f0 +cast from float -0x2710 to float -0x2710 +cast from float 0xffffd8f0 (0xffffd8f0) + to __longlong 0xffffd8f0 (0xffffd8f0) + +cast from float 0xffffd8f0 (0xffffd8f0) + to __ulonglong 0xffffd8f0 (0xffffd8f0) + +cast from __longlong -0x2710 to char -0x10 +cast from __longlong 0xd8f0 to __uchar 0xf0 +cast from __longlong -0x2710 to __int -0x2710 +cast from __longlong 0xd8f0 to __uint 0xd8f0 +cast from __longlong -0x2710 to float -0x2710 +cast from __longlong 0xffffd8f0 (0xffffd8f0) + to __longlong 0xffffd8f0 (0xffffd8f0) + +cast from __longlong 0xffffd8f0 (0xffffd8f0) + to __ulonglong 0xffffd8f0 (0xffffd8f0) + +cast from __ulonglong -0x2710 to char -0x10 +cast from __ulonglong 0xd8f0 to __uchar 0xf0 +cast from __ulonglong -0x2710 to __int -0x2710 +cast from __ulonglong 0xd8f0 to __uint 0xd8f0 +cast from __ulonglong -0x2710 to float -0x8000 +cast from __ulonglong 0xffffd8f0 (0xffffd8f0) + to __longlong 0xffffd8f0 (0xffffd8f0) + +cast from __ulonglong 0xffffd8f0 (0xffffd8f0) + to __ulonglong 0xffffd8f0 (0xffffd8f0) + +(int)float1[0x0] == 0x1 +(int)float1[0x1] == -0x1 +(int)float1[0x2] == 0x0 +(int)float1[0x3] == 0x2 +(int)float1[0x4] == -0x8000 +cast from char 0x1 to char 0x1 +cast from char 0x1 to __uchar 0x1 +cast from char 0x1 to __int 0x1 +cast from char 0x1 to __uint 0x1 +cast from char 0x1 to float 0x1 +cast from char 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from char 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __uchar 0x1 to char 0x1 +cast from __uchar 0x1 to __uchar 0x1 +cast from __uchar 0x1 to __int 0x1 +cast from __uchar 0x1 to __uint 0x1 +cast from __uchar 0x1 to float 0x1 +cast from __uchar 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __uchar 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __int 0x1 to char 0x1 +cast from __int 0x1 to __uchar 0x1 +cast from __int 0x1 to __int 0x1 +cast from __int 0x1 to __uint 0x1 +cast from __int 0x1 to float 0x1 +cast from __int 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __int 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __uint 0x1 to char 0x1 +cast from __uint 0x1 to __uchar 0x1 +cast from __uint 0x1 to __int 0x1 +cast from __uint 0x1 to __uint 0x1 +cast from __uint 0x1 to float 0x1 +cast from __uint 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __uint 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from float 0x1 to char 0x1 +cast from float 0x1 to __uchar 0x1 +cast from float 0x1 to __int 0x1 +cast from float 0x1 to __uint 0x1 +cast from float 0x1 to float 0x1 +cast from float 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from float 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __longlong 0x1 to char 0x1 +cast from __longlong 0x1 to __uchar 0x1 +cast from __longlong 0x1 to __int 0x1 +cast from __longlong 0x1 to __uint 0x1 +cast from __longlong 0x1 to float 0x1 +cast from __longlong 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __longlong 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __ulonglong 0x1 to char 0x1 +cast from __ulonglong 0x1 to __uchar 0x1 +cast from __ulonglong 0x1 to __int 0x1 +cast from __ulonglong 0x1 to __uint 0x1 +cast from __ulonglong 0x1 to float 0x1 +cast from __ulonglong 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __ulonglong 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from char -0x1 to char -0x1 +cast from char 0xffff to __uchar 0xff +cast from char -0x1 to __int -0x1 +cast from char 0xffff to __uint 0xffff +cast from char -0x1 to float -0x1 +cast from char 0xffffffff (0xffffffff) + to __longlong 0xffffffff (0xffffffff) + +cast from char 0xffffffff (0xffffffff) + to __ulonglong 0xffffffff (0xffffffff) + +cast from __uchar 0xff to char -0x1 +cast from __uchar 0xff to __uchar 0xff +cast from __uchar 0xff to __int 0xff +cast from __uchar 0xff to __uint 0xff +cast from __uchar 0xff to float 0xff +cast from __uchar 0xff (0xff) + to __longlong 0xff (0xff) + +cast from __uchar 0xff (0xff) + to __ulonglong 0xff (0xff) + +cast from __int -0x1 to char -0x1 +cast from __int 0xffff to __uchar 0xff +cast from __int -0x1 to __int -0x1 +cast from __int 0xffff to __uint 0xffff +cast from __int -0x1 to float -0x1 +cast from __int 0xffffffff (0xffffffff) + to __longlong 0xffffffff (0xffffffff) + +cast from __int 0xffffffff (0xffffffff) + to __ulonglong 0xffffffff (0xffffffff) + +cast from __uint -0x1 to char -0x1 +cast from __uint 0xffff to __uchar 0xff +cast from __uint -0x1 to __int -0x1 +cast from __uint 0xffff to __uint 0xffff +cast from __uint -0x1 to float -0x8000 +cast from __uint 0xffff (0xffff) + to __longlong 0xffff (0xffff) + +cast from __uint 0xffff (0xffff) + to __ulonglong 0xffff (0xffff) + +cast from float -0x1 to char -0x1 +cast from float 0xffff to __uchar 0xff +cast from float -0x1 to __int -0x1 +cast from float 0xffff to __uint 0xffff +cast from float -0x1 to float -0x1 +cast from float 0xffffffff (0xffffffff) + to __longlong 0xffffffff (0xffffffff) + +cast from float 0xffffffff (0xffffffff) + to __ulonglong 0xffffffff (0xffffffff) + +cast from __longlong -0x1 to char -0x1 +cast from __longlong 0xffff to __uchar 0xff +cast from __longlong -0x1 to __int -0x1 +cast from __longlong 0xffff to __uint 0xffff +cast from __longlong -0x1 to float -0x1 +cast from __longlong 0xffffffff (0xffffffff) + to __longlong 0xffffffff (0xffffffff) + +cast from __longlong 0xffffffff (0xffffffff) + to __ulonglong 0xffffffff (0xffffffff) + +cast from __ulonglong -0x1 to char -0x1 +cast from __ulonglong 0xffff to __uchar 0xff +cast from __ulonglong -0x1 to __int -0x1 +cast from __ulonglong 0xffff to __uint 0xffff +cast from __ulonglong -0x1 to float -0x8000 +cast from __ulonglong 0xffffffff (0xffffffff) + to __longlong 0xffffffff (0xffffffff) + +cast from __ulonglong 0xffffffff (0xffffffff) + to __ulonglong 0xffffffff (0xffffffff) + +cast from char 0x0 to char 0x0 +cast from char 0x0 to __uchar 0x0 +cast from char 0x0 to __int 0x0 +cast from char 0x0 to __uint 0x0 +cast from char 0x0 to float 0x0 +cast from char 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from char 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __uchar 0x0 to char 0x0 +cast from __uchar 0x0 to __uchar 0x0 +cast from __uchar 0x0 to __int 0x0 +cast from __uchar 0x0 to __uint 0x0 +cast from __uchar 0x0 to float 0x0 +cast from __uchar 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __uchar 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __int 0x0 to char 0x0 +cast from __int 0x0 to __uchar 0x0 +cast from __int 0x0 to __int 0x0 +cast from __int 0x0 to __uint 0x0 +cast from __int 0x0 to float 0x0 +cast from __int 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __int 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __uint 0x0 to char 0x0 +cast from __uint 0x0 to __uchar 0x0 +cast from __uint 0x0 to __int 0x0 +cast from __uint 0x0 to __uint 0x0 +cast from __uint 0x0 to float 0x0 +cast from __uint 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __uint 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from float 0x0 to char 0x0 +cast from float 0x0 to __uchar 0x0 +cast from float 0x0 to __int 0x0 +cast from float 0x0 to __uint 0x0 +cast from float 0x0 to float 0x0 +cast from float 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from float 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __longlong 0x0 to char 0x0 +cast from __longlong 0x0 to __uchar 0x0 +cast from __longlong 0x0 to __int 0x0 +cast from __longlong 0x0 to __uint 0x0 +cast from __longlong 0x0 to float 0x0 +cast from __longlong 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __longlong 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __ulonglong 0x0 to char 0x0 +cast from __ulonglong 0x0 to __uchar 0x0 +cast from __ulonglong 0x0 to __int 0x0 +cast from __ulonglong 0x0 to __uint 0x0 +cast from __ulonglong 0x0 to float 0x0 +cast from __ulonglong 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __ulonglong 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from char 0x2 to char 0x2 +cast from char 0x2 to __uchar 0x2 +cast from char 0x2 to __int 0x2 +cast from char 0x2 to __uint 0x2 +cast from char 0x2 to float 0x2 +cast from char 0x2 (0x2) + to __longlong 0x2 (0x2) + +cast from char 0x2 (0x2) + to __ulonglong 0x2 (0x2) + +cast from __uchar 0x2 to char 0x2 +cast from __uchar 0x2 to __uchar 0x2 +cast from __uchar 0x2 to __int 0x2 +cast from __uchar 0x2 to __uint 0x2 +cast from __uchar 0x2 to float 0x2 +cast from __uchar 0x2 (0x2) + to __longlong 0x2 (0x2) + +cast from __uchar 0x2 (0x2) + to __ulonglong 0x2 (0x2) + +cast from __int 0x2 to char 0x2 +cast from __int 0x2 to __uchar 0x2 +cast from __int 0x2 to __int 0x2 +cast from __int 0x2 to __uint 0x2 +cast from __int 0x2 to float 0x2 +cast from __int 0x2 (0x2) + to __longlong 0x2 (0x2) + +cast from __int 0x2 (0x2) + to __ulonglong 0x2 (0x2) + +cast from __uint 0x2 to char 0x2 +cast from __uint 0x2 to __uchar 0x2 +cast from __uint 0x2 to __int 0x2 +cast from __uint 0x2 to __uint 0x2 +cast from __uint 0x2 to float 0x2 +cast from __uint 0x2 (0x2) + to __longlong 0x2 (0x2) + +cast from __uint 0x2 (0x2) + to __ulonglong 0x2 (0x2) + +cast from float 0x2 to char 0x2 +cast from float 0x2 to __uchar 0x2 +cast from float 0x2 to __int 0x2 +cast from float 0x2 to __uint 0x2 +cast from float 0x2 to float 0x2 +cast from float 0x2 (0x2) + to __longlong 0x2 (0x2) + +cast from float 0x2 (0x2) + to __ulonglong 0x2 (0x2) + +cast from __longlong 0x2 to char 0x2 +cast from __longlong 0x2 to __uchar 0x2 +cast from __longlong 0x2 to __int 0x2 +cast from __longlong 0x2 to __uint 0x2 +cast from __longlong 0x2 to float 0x2 +cast from __longlong 0x2 (0x2) + to __longlong 0x2 (0x2) + +cast from __longlong 0x2 (0x2) + to __ulonglong 0x2 (0x2) + +cast from __ulonglong 0x2 to char 0x2 +cast from __ulonglong 0x2 to __uchar 0x2 +cast from __ulonglong 0x2 to __int 0x2 +cast from __ulonglong 0x2 to __uint 0x2 +cast from __ulonglong 0x2 to float 0x2 +cast from __ulonglong 0x2 (0x2) + to __longlong 0x2 (0x2) + +cast from __ulonglong 0x2 (0x2) + to __ulonglong 0x2 (0x2) + +cast from char 0x0 to char 0x0 +cast from char 0x0 to __uchar 0x0 +cast from char 0x0 to __int 0x0 +cast from char 0x0 to __uint 0x0 +cast from char 0x0 to float 0x0 +cast from char 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from char 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __uchar 0x0 to char 0x0 +cast from __uchar 0x0 to __uchar 0x0 +cast from __uchar 0x0 to __int 0x0 +cast from __uchar 0x0 to __uint 0x0 +cast from __uchar 0x0 to float 0x0 +cast from __uchar 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __uchar 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __int -0x8000 to char 0x0 +cast from __int 0x8000 to __uchar 0x0 +cast from __int -0x8000 to __int -0x8000 +cast from __int 0x8000 to __uint 0x8000 +cast from __int -0x8000 to float -0x8000 +cast from __int 0xffff8000 (0xffff8000) + to __longlong 0xffff8000 (0xffff8000) + +cast from __int 0xffff8000 (0xffff8000) + to __ulonglong 0xffff8000 (0xffff8000) + +cast from __uint 0x4240 to char 0x40 +cast from __uint 0x4240 to __uchar 0x40 +cast from __uint 0x4240 to __int 0x4240 +cast from __uint 0x4240 to __uint 0x4240 +cast from __uint 0x4240 to float 0x4240 +cast from __uint 0x4240 (0x4240) + to __longlong 0x4240 (0x4240) + +cast from __uint 0x4240 (0x4240) + to __ulonglong 0x4240 (0x4240) + +cast from float -0x8000 to char 0x0 +cast from float 0x4240 to __uchar 0x0 +cast from float -0x8000 to __int -0x8000 +cast from float 0x4240 to __uint 0x4240 +cast from float -0x8000 to float -0x8000 +cast from float 0xf4240 (0xf4240) + to __longlong 0xf4240 (0xf4240) + +cast from float 0xf4240 (0xf4240) + to __ulonglong 0xf4240 (0xf4240) + +cast from __longlong 0x4240 to char 0x40 +cast from __longlong 0x4240 to __uchar 0x40 +cast from __longlong 0x4240 to __int 0x4240 +cast from __longlong 0x4240 to __uint 0x4240 +cast from __longlong 0x4240 to float -0x8000 +cast from __longlong 0xf4240 (0xf4240) + to __longlong 0xf4240 (0xf4240) + +cast from __longlong 0xf4240 (0xf4240) + to __ulonglong 0xf4240 (0xf4240) + +cast from __ulonglong 0x4240 to char 0x40 +cast from __ulonglong 0x4240 to __uchar 0x40 +cast from __ulonglong 0x4240 to __int 0x4240 +cast from __ulonglong 0x4240 to __uint 0x4240 +cast from __ulonglong 0x4240 to float -0x8000 +cast from __ulonglong 0xf4240 (0xf4240) + to __longlong 0xf4240 (0xf4240) + +cast from __ulonglong 0xf4240 (0xf4240) + to __ulonglong 0xf4240 (0xf4240) + +casting ll1[0x0] +cast from char -0x1 to char -0x1 +cast from char 0xffff to __uchar 0xff +cast from char -0x1 to __int -0x1 +cast from char 0xffff to __uint 0xffff +cast from char -0x1 to float -0x1 +cast from char 0xffffffff (0xffffffff) + to __longlong 0xffffffff (0xffffffff) + +cast from char 0xffffffff (0xffffffff) + to __ulonglong 0xffffffff (0xffffffff) + +cast from __uchar 0xff to char -0x1 +cast from __uchar 0xff to __uchar 0xff +cast from __uchar 0xff to __int 0xff +cast from __uchar 0xff to __uint 0xff +cast from __uchar 0xff to float 0xff +cast from __uchar 0xff (0xff) + to __longlong 0xff (0xff) + +cast from __uchar 0xff (0xff) + to __ulonglong 0xff (0xff) + +cast from __int -0x1 to char -0x1 +cast from __int 0xffff to __uchar 0xff +cast from __int -0x1 to __int -0x1 +cast from __int 0xffff to __uint 0xffff +cast from __int -0x1 to float -0x1 +cast from __int 0xffffffff (0xffffffff) + to __longlong 0xffffffff (0xffffffff) + +cast from __int 0xffffffff (0xffffffff) + to __ulonglong 0xffffffff (0xffffffff) + +cast from __uint -0x1 to char -0x1 +cast from __uint 0xffff to __uchar 0xff +cast from __uint -0x1 to __int -0x1 +cast from __uint 0xffff to __uint 0xffff +cast from __uint -0x1 to float -0x8000 +cast from __uint 0xffff (0xffff) + to __longlong 0xffff (0xffff) + +cast from __uint 0xffff (0xffff) + to __ulonglong 0xffff (0xffff) + +cast from float -0x1 to char -0x1 +cast from float 0xffff to __uchar 0xff +cast from float -0x1 to __int -0x1 +cast from float 0xffff to __uint 0xffff +cast from float -0x1 to float -0x1 +cast from float 0xffffffff (0xffffffff) + to __longlong 0xffffffff (0xffffffff) + +cast from float 0xffffffff (0xffffffff) + to __ulonglong 0xffffffff (0xffffffff) + +cast from __longlong -0x1 to char -0x1 +cast from __longlong 0xffff to __uchar 0xff +cast from __longlong -0x1 to __int -0x1 +cast from __longlong 0xffff to __uint 0xffff +cast from __longlong -0x1 to float -0x1 +cast from __longlong 0xffffffff (0xffffffff) + to __longlong 0xffffffff (0xffffffff) + +cast from __longlong 0xffffffff (0xffffffff) + to __ulonglong 0xffffffff (0xffffffff) + +cast from __ulonglong -0x1 to char -0x1 +cast from __ulonglong 0xffff to __uchar 0xff +cast from __ulonglong -0x1 to __int -0x1 +cast from __ulonglong 0xffff to __uint 0xffff +cast from __ulonglong -0x1 to float -0x8000 +cast from __ulonglong 0xffffffff (0xffffffff) + to __longlong 0xffffffff (0xffffffff) + +cast from __ulonglong 0xffffffff (0xffffffff) + to __ulonglong 0xffffffff (0xffffffff) + +cast from char -0x1 to char -0x1 +cast from char 0xffff to __uchar 0xff +cast from char -0x1 to __int -0x1 +cast from char 0xffff to __uint 0xffff +cast from char -0x1 to float -0x1 +cast from char 0xffffffff (0xffffffff) + to __longlong 0xffffffff (0xffffffff) + +cast from char 0xffffffff (0xffffffff) + to __ulonglong 0xffffffff (0xffffffff) + +cast from __uchar 0xff to char -0x1 +cast from __uchar 0xff to __uchar 0xff +cast from __uchar 0xff to __int 0xff +cast from __uchar 0xff to __uint 0xff +cast from __uchar 0xff to float 0xff +cast from __uchar 0xff (0xff) + to __longlong 0xff (0xff) + +cast from __uchar 0xff (0xff) + to __ulonglong 0xff (0xff) + +cast from __int -0x1 to char -0x1 +cast from __int 0xffff to __uchar 0xff +cast from __int -0x1 to __int -0x1 +cast from __int 0xffff to __uint 0xffff +cast from __int -0x1 to float -0x1 +cast from __int 0xffffffff (0xffffffff) + to __longlong 0xffffffff (0xffffffff) + +cast from __int 0xffffffff (0xffffffff) + to __ulonglong 0xffffffff (0xffffffff) + +cast from __uint -0x1 to char -0x1 +cast from __uint 0xffff to __uchar 0xff +cast from __uint -0x1 to __int -0x1 +cast from __uint 0xffff to __uint 0xffff +cast from __uint -0x1 to float -0x8000 +cast from __uint 0xffff (0xffff) + to __longlong 0xffff (0xffff) + +cast from __uint 0xffff (0xffff) + to __ulonglong 0xffff (0xffff) + +cast from float -0x8000 to char 0x0 +cast from float 0x0 to __uchar 0x0 +cast from float -0x8000 to __int -0x8000 +cast from float 0x0 to __uint 0x0 +cast from float -0x8000 to float -0x8000 +cast from float 0x80000000 (0x80000000) + to __longlong 0x80000000 (0x80000000) + +cast from float 0x80000000 (0x80000000) + to __ulonglong 0x0 (0x0) + +cast from __longlong -0x1 to char -0x1 +cast from __longlong 0xffff to __uchar 0xff +cast from __longlong -0x1 to __int -0x1 +cast from __longlong 0xffff to __uint 0xffff +cast from __longlong -0x1 to float -0x1 +cast from __longlong 0xffffffff (0xffffffff) + to __longlong 0xffffffff (0xffffffff) + +cast from __longlong 0xffffffff (0xffffffff) + to __ulonglong 0xffffffff (0xffffffff) + +cast from __ulonglong -0x1 to char -0x1 +cast from __ulonglong 0xffff to __uchar 0xff +cast from __ulonglong -0x1 to __int -0x1 +cast from __ulonglong 0xffff to __uint 0xffff +cast from __ulonglong -0x1 to float -0x8000 +cast from __ulonglong 0xffffffff (0xffffffff) + to __longlong 0xffffffff (0xffffffff) + +cast from __ulonglong 0xffffffff (0xffffffff) + to __ulonglong 0xffffffff (0xffffffff) + +casting ll1[0x1] +cast from char 0x0 to char 0x0 +cast from char 0x0 to __uchar 0x0 +cast from char 0x0 to __int 0x0 +cast from char 0x0 to __uint 0x0 +cast from char 0x0 to float 0x0 +cast from char 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from char 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __uchar 0x0 to char 0x0 +cast from __uchar 0x0 to __uchar 0x0 +cast from __uchar 0x0 to __int 0x0 +cast from __uchar 0x0 to __uint 0x0 +cast from __uchar 0x0 to float 0x0 +cast from __uchar 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __uchar 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __int 0x0 to char 0x0 +cast from __int 0x0 to __uchar 0x0 +cast from __int 0x0 to __int 0x0 +cast from __int 0x0 to __uint 0x0 +cast from __int 0x0 to float 0x0 +cast from __int 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __int 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __uint 0x0 to char 0x0 +cast from __uint 0x0 to __uchar 0x0 +cast from __uint 0x0 to __int 0x0 +cast from __uint 0x0 to __uint 0x0 +cast from __uint 0x0 to float 0x0 +cast from __uint 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __uint 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from float 0x0 to char 0x0 +cast from float 0x0 to __uchar 0x0 +cast from float 0x0 to __int 0x0 +cast from float 0x0 to __uint 0x0 +cast from float 0x0 to float 0x0 +cast from float 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from float 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __longlong 0x0 to char 0x0 +cast from __longlong 0x0 to __uchar 0x0 +cast from __longlong 0x0 to __int 0x0 +cast from __longlong 0x0 to __uint 0x0 +cast from __longlong 0x0 to float 0x0 +cast from __longlong 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __longlong 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __ulonglong 0x0 to char 0x0 +cast from __ulonglong 0x0 to __uchar 0x0 +cast from __ulonglong 0x0 to __int 0x0 +cast from __ulonglong 0x0 to __uint 0x0 +cast from __ulonglong 0x0 to float 0x0 +cast from __ulonglong 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __ulonglong 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from char 0x0 to char 0x0 +cast from char 0x0 to __uchar 0x0 +cast from char 0x0 to __int 0x0 +cast from char 0x0 to __uint 0x0 +cast from char 0x0 to float 0x0 +cast from char 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from char 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __uchar 0x0 to char 0x0 +cast from __uchar 0x0 to __uchar 0x0 +cast from __uchar 0x0 to __int 0x0 +cast from __uchar 0x0 to __uint 0x0 +cast from __uchar 0x0 to float 0x0 +cast from __uchar 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __uchar 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __int 0x0 to char 0x0 +cast from __int 0x0 to __uchar 0x0 +cast from __int 0x0 to __int 0x0 +cast from __int 0x0 to __uint 0x0 +cast from __int 0x0 to float 0x0 +cast from __int 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __int 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __uint 0x0 to char 0x0 +cast from __uint 0x0 to __uchar 0x0 +cast from __uint 0x0 to __int 0x0 +cast from __uint 0x0 to __uint 0x0 +cast from __uint 0x0 to float 0x0 +cast from __uint 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __uint 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from float 0x0 to char 0x0 +cast from float 0x0 to __uchar 0x0 +cast from float 0x0 to __int 0x0 +cast from float 0x0 to __uint 0x0 +cast from float 0x0 to float 0x0 +cast from float 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from float 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __longlong 0x0 to char 0x0 +cast from __longlong 0x0 to __uchar 0x0 +cast from __longlong 0x0 to __int 0x0 +cast from __longlong 0x0 to __uint 0x0 +cast from __longlong 0x0 to float 0x0 +cast from __longlong 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __longlong 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __ulonglong 0x0 to char 0x0 +cast from __ulonglong 0x0 to __uchar 0x0 +cast from __ulonglong 0x0 to __int 0x0 +cast from __ulonglong 0x0 to __uint 0x0 +cast from __ulonglong 0x0 to float 0x0 +cast from __ulonglong 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __ulonglong 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +casting ll1[0x2] +cast from char 0x1 to char 0x1 +cast from char 0x1 to __uchar 0x1 +cast from char 0x1 to __int 0x1 +cast from char 0x1 to __uint 0x1 +cast from char 0x1 to float 0x1 +cast from char 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from char 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __uchar 0x1 to char 0x1 +cast from __uchar 0x1 to __uchar 0x1 +cast from __uchar 0x1 to __int 0x1 +cast from __uchar 0x1 to __uint 0x1 +cast from __uchar 0x1 to float 0x1 +cast from __uchar 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __uchar 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __int 0x1 to char 0x1 +cast from __int 0x1 to __uchar 0x1 +cast from __int 0x1 to __int 0x1 +cast from __int 0x1 to __uint 0x1 +cast from __int 0x1 to float 0x1 +cast from __int 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __int 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __uint 0x1 to char 0x1 +cast from __uint 0x1 to __uchar 0x1 +cast from __uint 0x1 to __int 0x1 +cast from __uint 0x1 to __uint 0x1 +cast from __uint 0x1 to float 0x1 +cast from __uint 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __uint 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from float 0x1 to char 0x1 +cast from float 0x1 to __uchar 0x1 +cast from float 0x1 to __int 0x1 +cast from float 0x1 to __uint 0x1 +cast from float 0x1 to float 0x1 +cast from float 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from float 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __longlong 0x1 to char 0x1 +cast from __longlong 0x1 to __uchar 0x1 +cast from __longlong 0x1 to __int 0x1 +cast from __longlong 0x1 to __uint 0x1 +cast from __longlong 0x1 to float 0x1 +cast from __longlong 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __longlong 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __ulonglong 0x1 to char 0x1 +cast from __ulonglong 0x1 to __uchar 0x1 +cast from __ulonglong 0x1 to __int 0x1 +cast from __ulonglong 0x1 to __uint 0x1 +cast from __ulonglong 0x1 to float 0x1 +cast from __ulonglong 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __ulonglong 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from char 0x1 to char 0x1 +cast from char 0x1 to __uchar 0x1 +cast from char 0x1 to __int 0x1 +cast from char 0x1 to __uint 0x1 +cast from char 0x1 to float 0x1 +cast from char 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from char 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __uchar 0x1 to char 0x1 +cast from __uchar 0x1 to __uchar 0x1 +cast from __uchar 0x1 to __int 0x1 +cast from __uchar 0x1 to __uint 0x1 +cast from __uchar 0x1 to float 0x1 +cast from __uchar 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __uchar 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __int 0x1 to char 0x1 +cast from __int 0x1 to __uchar 0x1 +cast from __int 0x1 to __int 0x1 +cast from __int 0x1 to __uint 0x1 +cast from __int 0x1 to float 0x1 +cast from __int 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __int 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __uint 0x1 to char 0x1 +cast from __uint 0x1 to __uchar 0x1 +cast from __uint 0x1 to __int 0x1 +cast from __uint 0x1 to __uint 0x1 +cast from __uint 0x1 to float 0x1 +cast from __uint 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __uint 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from float 0x1 to char 0x1 +cast from float 0x1 to __uchar 0x1 +cast from float 0x1 to __int 0x1 +cast from float 0x1 to __uint 0x1 +cast from float 0x1 to float 0x1 +cast from float 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from float 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __longlong 0x1 to char 0x1 +cast from __longlong 0x1 to __uchar 0x1 +cast from __longlong 0x1 to __int 0x1 +cast from __longlong 0x1 to __uint 0x1 +cast from __longlong 0x1 to float 0x1 +cast from __longlong 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __longlong 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __ulonglong 0x1 to char 0x1 +cast from __ulonglong 0x1 to __uchar 0x1 +cast from __ulonglong 0x1 to __int 0x1 +cast from __ulonglong 0x1 to __uint 0x1 +cast from __ulonglong 0x1 to float 0x1 +cast from __ulonglong 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __ulonglong 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +casting ll1[0x3] +cast from char 0xa to char 0xa +cast from char 0xa to __uchar 0xa +cast from char 0xa to __int 0xa +cast from char 0xa to __uint 0xa +cast from char 0xa to float 0xa +cast from char 0xa (0xa) + to __longlong 0xa (0xa) + +cast from char 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from __uchar 0xa to char 0xa +cast from __uchar 0xa to __uchar 0xa +cast from __uchar 0xa to __int 0xa +cast from __uchar 0xa to __uint 0xa +cast from __uchar 0xa to float 0xa +cast from __uchar 0xa (0xa) + to __longlong 0xa (0xa) + +cast from __uchar 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from __int 0xa to char 0xa +cast from __int 0xa to __uchar 0xa +cast from __int 0xa to __int 0xa +cast from __int 0xa to __uint 0xa +cast from __int 0xa to float 0xa +cast from __int 0xa (0xa) + to __longlong 0xa (0xa) + +cast from __int 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from __uint 0xa to char 0xa +cast from __uint 0xa to __uchar 0xa +cast from __uint 0xa to __int 0xa +cast from __uint 0xa to __uint 0xa +cast from __uint 0xa to float 0xa +cast from __uint 0xa (0xa) + to __longlong 0xa (0xa) + +cast from __uint 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from float 0xa to char 0xa +cast from float 0xa to __uchar 0xa +cast from float 0xa to __int 0xa +cast from float 0xa to __uint 0xa +cast from float 0xa to float 0xa +cast from float 0xa (0xa) + to __longlong 0xa (0xa) + +cast from float 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from __longlong 0xa to char 0xa +cast from __longlong 0xa to __uchar 0xa +cast from __longlong 0xa to __int 0xa +cast from __longlong 0xa to __uint 0xa +cast from __longlong 0xa to float 0xa +cast from __longlong 0xa (0xa) + to __longlong 0xa (0xa) + +cast from __longlong 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from __ulonglong 0xa to char 0xa +cast from __ulonglong 0xa to __uchar 0xa +cast from __ulonglong 0xa to __int 0xa +cast from __ulonglong 0xa to __uint 0xa +cast from __ulonglong 0xa to float 0xa +cast from __ulonglong 0xa (0xa) + to __longlong 0xa (0xa) + +cast from __ulonglong 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from char 0xa to char 0xa +cast from char 0xa to __uchar 0xa +cast from char 0xa to __int 0xa +cast from char 0xa to __uint 0xa +cast from char 0xa to float 0xa +cast from char 0xa (0xa) + to __longlong 0xa (0xa) + +cast from char 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from __uchar 0xa to char 0xa +cast from __uchar 0xa to __uchar 0xa +cast from __uchar 0xa to __int 0xa +cast from __uchar 0xa to __uint 0xa +cast from __uchar 0xa to float 0xa +cast from __uchar 0xa (0xa) + to __longlong 0xa (0xa) + +cast from __uchar 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from __int 0xa to char 0xa +cast from __int 0xa to __uchar 0xa +cast from __int 0xa to __int 0xa +cast from __int 0xa to __uint 0xa +cast from __int 0xa to float 0xa +cast from __int 0xa (0xa) + to __longlong 0xa (0xa) + +cast from __int 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from __uint 0xa to char 0xa +cast from __uint 0xa to __uchar 0xa +cast from __uint 0xa to __int 0xa +cast from __uint 0xa to __uint 0xa +cast from __uint 0xa to float 0xa +cast from __uint 0xa (0xa) + to __longlong 0xa (0xa) + +cast from __uint 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from float 0xa to char 0xa +cast from float 0xa to __uchar 0xa +cast from float 0xa to __int 0xa +cast from float 0xa to __uint 0xa +cast from float 0xa to float 0xa +cast from float 0xa (0xa) + to __longlong 0xa (0xa) + +cast from float 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from __longlong 0xa to char 0xa +cast from __longlong 0xa to __uchar 0xa +cast from __longlong 0xa to __int 0xa +cast from __longlong 0xa to __uint 0xa +cast from __longlong 0xa to float 0xa +cast from __longlong 0xa (0xa) + to __longlong 0xa (0xa) + +cast from __longlong 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from __ulonglong 0xa to char 0xa +cast from __ulonglong 0xa to __uchar 0xa +cast from __ulonglong 0xa to __int 0xa +cast from __ulonglong 0xa to __uint 0xa +cast from __ulonglong 0xa to float 0xa +cast from __ulonglong 0xa (0xa) + to __longlong 0xa (0xa) + +cast from __ulonglong 0xa (0xa) + to __ulonglong 0xa (0xa) + +casting ll1[0x4] +cast from char 0x64 to char 0x64 +cast from char 0x64 to __uchar 0x64 +cast from char 0x64 to __int 0x64 +cast from char 0x64 to __uint 0x64 +cast from char 0x64 to float 0x64 +cast from char 0x64 (0x64) + to __longlong 0x64 (0x64) + +cast from char 0x64 (0x64) + to __ulonglong 0x64 (0x64) + +cast from __uchar 0x64 to char 0x64 +cast from __uchar 0x64 to __uchar 0x64 +cast from __uchar 0x64 to __int 0x64 +cast from __uchar 0x64 to __uint 0x64 +cast from __uchar 0x64 to float 0x64 +cast from __uchar 0x64 (0x64) + to __longlong 0x64 (0x64) + +cast from __uchar 0x64 (0x64) + to __ulonglong 0x64 (0x64) + +cast from __int 0x64 to char 0x64 +cast from __int 0x64 to __uchar 0x64 +cast from __int 0x64 to __int 0x64 +cast from __int 0x64 to __uint 0x64 +cast from __int 0x64 to float 0x64 +cast from __int 0x64 (0x64) + to __longlong 0x64 (0x64) + +cast from __int 0x64 (0x64) + to __ulonglong 0x64 (0x64) + +cast from __uint 0x64 to char 0x64 +cast from __uint 0x64 to __uchar 0x64 +cast from __uint 0x64 to __int 0x64 +cast from __uint 0x64 to __uint 0x64 +cast from __uint 0x64 to float 0x64 +cast from __uint 0x64 (0x64) + to __longlong 0x64 (0x64) + +cast from __uint 0x64 (0x64) + to __ulonglong 0x64 (0x64) + +cast from float 0x64 to char 0x64 +cast from float 0x64 to __uchar 0x64 +cast from float 0x64 to __int 0x64 +cast from float 0x64 to __uint 0x64 +cast from float 0x64 to float 0x64 +cast from float 0x64 (0x64) + to __longlong 0x64 (0x64) + +cast from float 0x64 (0x64) + to __ulonglong 0x64 (0x64) + +cast from __longlong 0x64 to char 0x64 +cast from __longlong 0x64 to __uchar 0x64 +cast from __longlong 0x64 to __int 0x64 +cast from __longlong 0x64 to __uint 0x64 +cast from __longlong 0x64 to float 0x64 +cast from __longlong 0x64 (0x64) + to __longlong 0x64 (0x64) + +cast from __longlong 0x64 (0x64) + to __ulonglong 0x64 (0x64) + +cast from __ulonglong 0x64 to char 0x64 +cast from __ulonglong 0x64 to __uchar 0x64 +cast from __ulonglong 0x64 to __int 0x64 +cast from __ulonglong 0x64 to __uint 0x64 +cast from __ulonglong 0x64 to float 0x64 +cast from __ulonglong 0x64 (0x64) + to __longlong 0x64 (0x64) + +cast from __ulonglong 0x64 (0x64) + to __ulonglong 0x64 (0x64) + +cast from char 0x64 to char 0x64 +cast from char 0x64 to __uchar 0x64 +cast from char 0x64 to __int 0x64 +cast from char 0x64 to __uint 0x64 +cast from char 0x64 to float 0x64 +cast from char 0x64 (0x64) + to __longlong 0x64 (0x64) + +cast from char 0x64 (0x64) + to __ulonglong 0x64 (0x64) + +cast from __uchar 0x64 to char 0x64 +cast from __uchar 0x64 to __uchar 0x64 +cast from __uchar 0x64 to __int 0x64 +cast from __uchar 0x64 to __uint 0x64 +cast from __uchar 0x64 to float 0x64 +cast from __uchar 0x64 (0x64) + to __longlong 0x64 (0x64) + +cast from __uchar 0x64 (0x64) + to __ulonglong 0x64 (0x64) + +cast from __int 0x64 to char 0x64 +cast from __int 0x64 to __uchar 0x64 +cast from __int 0x64 to __int 0x64 +cast from __int 0x64 to __uint 0x64 +cast from __int 0x64 to float 0x64 +cast from __int 0x64 (0x64) + to __longlong 0x64 (0x64) + +cast from __int 0x64 (0x64) + to __ulonglong 0x64 (0x64) + +cast from __uint 0x64 to char 0x64 +cast from __uint 0x64 to __uchar 0x64 +cast from __uint 0x64 to __int 0x64 +cast from __uint 0x64 to __uint 0x64 +cast from __uint 0x64 to float 0x64 +cast from __uint 0x64 (0x64) + to __longlong 0x64 (0x64) + +cast from __uint 0x64 (0x64) + to __ulonglong 0x64 (0x64) + +cast from float 0x64 to char 0x64 +cast from float 0x64 to __uchar 0x64 +cast from float 0x64 to __int 0x64 +cast from float 0x64 to __uint 0x64 +cast from float 0x64 to float 0x64 +cast from float 0x64 (0x64) + to __longlong 0x64 (0x64) + +cast from float 0x64 (0x64) + to __ulonglong 0x64 (0x64) + +cast from __longlong 0x64 to char 0x64 +cast from __longlong 0x64 to __uchar 0x64 +cast from __longlong 0x64 to __int 0x64 +cast from __longlong 0x64 to __uint 0x64 +cast from __longlong 0x64 to float 0x64 +cast from __longlong 0x64 (0x64) + to __longlong 0x64 (0x64) + +cast from __longlong 0x64 (0x64) + to __ulonglong 0x64 (0x64) + +cast from __ulonglong 0x64 to char 0x64 +cast from __ulonglong 0x64 to __uchar 0x64 +cast from __ulonglong 0x64 to __int 0x64 +cast from __ulonglong 0x64 to __uint 0x64 +cast from __ulonglong 0x64 to float 0x64 +cast from __ulonglong 0x64 (0x64) + to __longlong 0x64 (0x64) + +cast from __ulonglong 0x64 (0x64) + to __ulonglong 0x64 (0x64) + +casting ll1[0x5] +cast from char 0x40 to char 0x40 +cast from char 0x40 to __uchar 0x40 +cast from char 0x40 to __int 0x40 +cast from char 0x40 to __uint 0x40 +cast from char 0x40 to float 0x40 +cast from char 0x40 (0x40) + to __longlong 0x40 (0x40) + +cast from char 0x40 (0x40) + to __ulonglong 0x40 (0x40) + +cast from __uchar 0x40 to char 0x40 +cast from __uchar 0x40 to __uchar 0x40 +cast from __uchar 0x40 to __int 0x40 +cast from __uchar 0x40 to __uint 0x40 +cast from __uchar 0x40 to float 0x40 +cast from __uchar 0x40 (0x40) + to __longlong 0x40 (0x40) + +cast from __uchar 0x40 (0x40) + to __ulonglong 0x40 (0x40) + +cast from __int 0x4240 to char 0x40 +cast from __int 0x4240 to __uchar 0x40 +cast from __int 0x4240 to __int 0x4240 +cast from __int 0x4240 to __uint 0x4240 +cast from __int 0x4240 to float 0x4240 +cast from __int 0x4240 (0x4240) + to __longlong 0x4240 (0x4240) + +cast from __int 0x4240 (0x4240) + to __ulonglong 0x4240 (0x4240) + +cast from __uint 0x4240 to char 0x40 +cast from __uint 0x4240 to __uchar 0x40 +cast from __uint 0x4240 to __int 0x4240 +cast from __uint 0x4240 to __uint 0x4240 +cast from __uint 0x4240 to float 0x4240 +cast from __uint 0x4240 (0x4240) + to __longlong 0x4240 (0x4240) + +cast from __uint 0x4240 (0x4240) + to __ulonglong 0x4240 (0x4240) + +cast from float -0x8000 to char 0x0 +cast from float 0x4240 to __uchar 0x0 +cast from float -0x8000 to __int -0x8000 +cast from float 0x4240 to __uint 0x4240 +cast from float -0x8000 to float -0x8000 +cast from float 0xf4240 (0xf4240) + to __longlong 0xf4240 (0xf4240) + +cast from float 0xf4240 (0xf4240) + to __ulonglong 0xf4240 (0xf4240) + +cast from __longlong 0x4240 to char 0x40 +cast from __longlong 0x4240 to __uchar 0x40 +cast from __longlong 0x4240 to __int 0x4240 +cast from __longlong 0x4240 to __uint 0x4240 +cast from __longlong 0x4240 to float -0x8000 +cast from __longlong 0xf4240 (0xf4240) + to __longlong 0xf4240 (0xf4240) + +cast from __longlong 0xf4240 (0xf4240) + to __ulonglong 0xf4240 (0xf4240) + +cast from __ulonglong 0x4240 to char 0x40 +cast from __ulonglong 0x4240 to __uchar 0x40 +cast from __ulonglong 0x4240 to __int 0x4240 +cast from __ulonglong 0x4240 to __uint 0x4240 +cast from __ulonglong 0x4240 to float -0x8000 +cast from __ulonglong 0xf4240 (0xf4240) + to __longlong 0xf4240 (0xf4240) + +cast from __ulonglong 0xf4240 (0xf4240) + to __ulonglong 0xf4240 (0xf4240) + +cast from char 0x40 to char 0x40 +cast from char 0x40 to __uchar 0x40 +cast from char 0x40 to __int 0x40 +cast from char 0x40 to __uint 0x40 +cast from char 0x40 to float 0x40 +cast from char 0x40 (0x40) + to __longlong 0x40 (0x40) + +cast from char 0x40 (0x40) + to __ulonglong 0x40 (0x40) + +cast from __uchar 0x40 to char 0x40 +cast from __uchar 0x40 to __uchar 0x40 +cast from __uchar 0x40 to __int 0x40 +cast from __uchar 0x40 to __uint 0x40 +cast from __uchar 0x40 to float 0x40 +cast from __uchar 0x40 (0x40) + to __longlong 0x40 (0x40) + +cast from __uchar 0x40 (0x40) + to __ulonglong 0x40 (0x40) + +cast from __int 0x4240 to char 0x40 +cast from __int 0x4240 to __uchar 0x40 +cast from __int 0x4240 to __int 0x4240 +cast from __int 0x4240 to __uint 0x4240 +cast from __int 0x4240 to float 0x4240 +cast from __int 0x4240 (0x4240) + to __longlong 0x4240 (0x4240) + +cast from __int 0x4240 (0x4240) + to __ulonglong 0x4240 (0x4240) + +cast from __uint 0x4240 to char 0x40 +cast from __uint 0x4240 to __uchar 0x40 +cast from __uint 0x4240 to __int 0x4240 +cast from __uint 0x4240 to __uint 0x4240 +cast from __uint 0x4240 to float 0x4240 +cast from __uint 0x4240 (0x4240) + to __longlong 0x4240 (0x4240) + +cast from __uint 0x4240 (0x4240) + to __ulonglong 0x4240 (0x4240) + +cast from float -0x8000 to char 0x0 +cast from float 0x4240 to __uchar 0x0 +cast from float -0x8000 to __int -0x8000 +cast from float 0x4240 to __uint 0x4240 +cast from float -0x8000 to float -0x8000 +cast from float 0xf4240 (0xf4240) + to __longlong 0xf4240 (0xf4240) + +cast from float 0xf4240 (0xf4240) + to __ulonglong 0xf4240 (0xf4240) + +cast from __longlong 0x4240 to char 0x40 +cast from __longlong 0x4240 to __uchar 0x40 +cast from __longlong 0x4240 to __int 0x4240 +cast from __longlong 0x4240 to __uint 0x4240 +cast from __longlong 0x4240 to float -0x8000 +cast from __longlong 0xf4240 (0xf4240) + to __longlong 0xf4240 (0xf4240) + +cast from __longlong 0xf4240 (0xf4240) + to __ulonglong 0xf4240 (0xf4240) + +cast from __ulonglong 0x4240 to char 0x40 +cast from __ulonglong 0x4240 to __uchar 0x40 +cast from __ulonglong 0x4240 to __int 0x4240 +cast from __ulonglong 0x4240 to __uint 0x4240 +cast from __ulonglong 0x4240 to float -0x8000 +cast from __ulonglong 0xf4240 (0xf4240) + to __longlong 0xf4240 (0xf4240) + +cast from __ulonglong 0xf4240 (0xf4240) + to __ulonglong 0xf4240 (0xf4240) + +cast from char -0x1 to char -0x1 +cast from char 0xffff to __uchar 0xff +cast from char -0x1 to __int -0x1 +cast from char 0xffff to __uint 0xffff +cast from char -0x1 to float -0x1 +cast from char 0xffffffff (0xffffffff) + to __longlong 0xffffffff (0xffffffff) + +cast from char 0xffffffff (0xffffffff) + to __ulonglong 0xffffffff (0xffffffff) + +cast from __uchar 0xff to char -0x1 +cast from __uchar 0xff to __uchar 0xff +cast from __uchar 0xff to __int 0xff +cast from __uchar 0xff to __uint 0xff +cast from __uchar 0xff to float 0xff +cast from __uchar 0xff (0xff) + to __longlong 0xff (0xff) + +cast from __uchar 0xff (0xff) + to __ulonglong 0xff (0xff) + +cast from __int -0x1 to char -0x1 +cast from __int 0xffff to __uchar 0xff +cast from __int -0x1 to __int -0x1 +cast from __int 0xffff to __uint 0xffff +cast from __int -0x1 to float -0x1 +cast from __int 0xffffffff (0xffffffff) + to __longlong 0xffffffff (0xffffffff) + +cast from __int 0xffffffff (0xffffffff) + to __ulonglong 0xffffffff (0xffffffff) + +cast from __uint -0x1 to char -0x1 +cast from __uint 0xffff to __uchar 0xff +cast from __uint -0x1 to __int -0x1 +cast from __uint 0xffff to __uint 0xffff +cast from __uint -0x1 to float -0x8000 +cast from __uint 0xffff (0xffff) + to __longlong 0xffff (0xffff) + +cast from __uint 0xffff (0xffff) + to __ulonglong 0xffff (0xffff) + +cast from float -0x1 to char -0x1 +cast from float 0xffff to __uchar 0xff +cast from float -0x1 to __int -0x1 +cast from float 0xffff to __uint 0xffff +cast from float -0x1 to float -0x1 +cast from float 0xffffffff (0xffffffff) + to __longlong 0xffffffff (0xffffffff) + +cast from float 0xffffffff (0xffffffff) + to __ulonglong 0xffffffff (0xffffffff) + +cast from __longlong -0x1 to char -0x1 +cast from __longlong 0xffff to __uchar 0xff +cast from __longlong -0x1 to __int -0x1 +cast from __longlong 0xffff to __uint 0xffff +cast from __longlong -0x1 to float -0x1 +cast from __longlong 0xffffffff (0xffffffff) + to __longlong 0xffffffff (0xffffffff) + +cast from __longlong 0xffffffff (0xffffffff) + to __ulonglong 0xffffffff (0xffffffff) + +cast from __ulonglong -0x1 to char -0x1 +cast from __ulonglong 0xffff to __uchar 0xff +cast from __ulonglong -0x1 to __int -0x1 +cast from __ulonglong 0xffff to __uint 0xffff +cast from __ulonglong -0x1 to float -0x8000 +cast from __ulonglong 0xffffffff (0xffffffff) + to __longlong 0xffffffff (0xffffffff) + +cast from __ulonglong 0xffffffff (0xffffffff) + to __ulonglong 0xffffffff (0xffffffff) + +cast from char -0x1 to char -0x1 +cast from char 0xffff to __uchar 0xff +cast from char -0x1 to __int -0x1 +cast from char 0xffff to __uint 0xffff +cast from char -0x1 to float -0x1 +cast from char 0xffffffff (0xffffffff) + to __longlong 0xffffffff (0xffffffff) + +cast from char 0xffffffff (0xffffffff) + to __ulonglong 0xffffffff (0xffffffff) + +cast from __uchar 0xff to char -0x1 +cast from __uchar 0xff to __uchar 0xff +cast from __uchar 0xff to __int 0xff +cast from __uchar 0xff to __uint 0xff +cast from __uchar 0xff to float 0xff +cast from __uchar 0xff (0xff) + to __longlong 0xff (0xff) + +cast from __uchar 0xff (0xff) + to __ulonglong 0xff (0xff) + +cast from __int 0xff to char -0x1 +cast from __int 0xff to __uchar 0xff +cast from __int 0xff to __int 0xff +cast from __int 0xff to __uint 0xff +cast from __int 0xff to float 0xff +cast from __int 0xff (0xff) + to __longlong 0xff (0xff) + +cast from __int 0xff (0xff) + to __ulonglong 0xff (0xff) + +cast from __uint 0xff to char -0x1 +cast from __uint 0xff to __uchar 0xff +cast from __uint 0xff to __int 0xff +cast from __uint 0xff to __uint 0xff +cast from __uint 0xff to float 0xff +cast from __uint 0xff (0xff) + to __longlong 0xff (0xff) + +cast from __uint 0xff (0xff) + to __ulonglong 0xff (0xff) + +cast from float 0xff to char -0x1 +cast from float 0xff to __uchar 0xff +cast from float 0xff to __int 0xff +cast from float 0xff to __uint 0xff +cast from float 0xff to float 0xff +cast from float 0xff (0xff) + to __longlong 0xff (0xff) + +cast from float 0xff (0xff) + to __ulonglong 0xff (0xff) + +cast from __longlong 0xff to char -0x1 +cast from __longlong 0xff to __uchar 0xff +cast from __longlong 0xff to __int 0xff +cast from __longlong 0xff to __uint 0xff +cast from __longlong 0xff to float 0xff +cast from __longlong 0xff (0xff) + to __longlong 0xff (0xff) + +cast from __longlong 0xff (0xff) + to __ulonglong 0xff (0xff) + +cast from __ulonglong 0xff to char -0x1 +cast from __ulonglong 0xff to __uchar 0xff +cast from __ulonglong 0xff to __int 0xff +cast from __ulonglong 0xff to __uint 0xff +cast from __ulonglong 0xff to float 0xff +cast from __ulonglong 0xff (0xff) + to __longlong 0xff (0xff) + +cast from __ulonglong 0xff (0xff) + to __ulonglong 0xff (0xff) + +cast from char 0x0 to char 0x0 +cast from char 0x0 to __uchar 0x0 +cast from char 0x0 to __int 0x0 +cast from char 0x0 to __uint 0x0 +cast from char 0x0 to float 0x0 +cast from char 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from char 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __uchar 0x0 to char 0x0 +cast from __uchar 0x0 to __uchar 0x0 +cast from __uchar 0x0 to __int 0x0 +cast from __uchar 0x0 to __uint 0x0 +cast from __uchar 0x0 to float 0x0 +cast from __uchar 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __uchar 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __int 0x0 to char 0x0 +cast from __int 0x0 to __uchar 0x0 +cast from __int 0x0 to __int 0x0 +cast from __int 0x0 to __uint 0x0 +cast from __int 0x0 to float 0x0 +cast from __int 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __int 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __uint 0x0 to char 0x0 +cast from __uint 0x0 to __uchar 0x0 +cast from __uint 0x0 to __int 0x0 +cast from __uint 0x0 to __uint 0x0 +cast from __uint 0x0 to float 0x0 +cast from __uint 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __uint 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from float 0x0 to char 0x0 +cast from float 0x0 to __uchar 0x0 +cast from float 0x0 to __int 0x0 +cast from float 0x0 to __uint 0x0 +cast from float 0x0 to float 0x0 +cast from float 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from float 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __longlong 0x0 to char 0x0 +cast from __longlong 0x0 to __uchar 0x0 +cast from __longlong 0x0 to __int 0x0 +cast from __longlong 0x0 to __uint 0x0 +cast from __longlong 0x0 to float 0x0 +cast from __longlong 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __longlong 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __ulonglong 0x0 to char 0x0 +cast from __ulonglong 0x0 to __uchar 0x0 +cast from __ulonglong 0x0 to __int 0x0 +cast from __ulonglong 0x0 to __uint 0x0 +cast from __ulonglong 0x0 to float 0x0 +cast from __ulonglong 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __ulonglong 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from char 0x0 to char 0x0 +cast from char 0x0 to __uchar 0x0 +cast from char 0x0 to __int 0x0 +cast from char 0x0 to __uint 0x0 +cast from char 0x0 to float 0x0 +cast from char 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from char 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __uchar 0x0 to char 0x0 +cast from __uchar 0x0 to __uchar 0x0 +cast from __uchar 0x0 to __int 0x0 +cast from __uchar 0x0 to __uint 0x0 +cast from __uchar 0x0 to float 0x0 +cast from __uchar 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __uchar 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __int 0x0 to char 0x0 +cast from __int 0x0 to __uchar 0x0 +cast from __int 0x0 to __int 0x0 +cast from __int 0x0 to __uint 0x0 +cast from __int 0x0 to float 0x0 +cast from __int 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __int 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __uint 0x0 to char 0x0 +cast from __uint 0x0 to __uchar 0x0 +cast from __uint 0x0 to __int 0x0 +cast from __uint 0x0 to __uint 0x0 +cast from __uint 0x0 to float 0x0 +cast from __uint 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __uint 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from float 0x0 to char 0x0 +cast from float 0x0 to __uchar 0x0 +cast from float 0x0 to __int 0x0 +cast from float 0x0 to __uint 0x0 +cast from float 0x0 to float 0x0 +cast from float 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from float 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __longlong 0x0 to char 0x0 +cast from __longlong 0x0 to __uchar 0x0 +cast from __longlong 0x0 to __int 0x0 +cast from __longlong 0x0 to __uint 0x0 +cast from __longlong 0x0 to float 0x0 +cast from __longlong 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __longlong 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __ulonglong 0x0 to char 0x0 +cast from __ulonglong 0x0 to __uchar 0x0 +cast from __ulonglong 0x0 to __int 0x0 +cast from __ulonglong 0x0 to __uint 0x0 +cast from __ulonglong 0x0 to float 0x0 +cast from __ulonglong 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __ulonglong 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from char 0x1 to char 0x1 +cast from char 0x1 to __uchar 0x1 +cast from char 0x1 to __int 0x1 +cast from char 0x1 to __uint 0x1 +cast from char 0x1 to float 0x1 +cast from char 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from char 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __uchar 0x1 to char 0x1 +cast from __uchar 0x1 to __uchar 0x1 +cast from __uchar 0x1 to __int 0x1 +cast from __uchar 0x1 to __uint 0x1 +cast from __uchar 0x1 to float 0x1 +cast from __uchar 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __uchar 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __int 0x1 to char 0x1 +cast from __int 0x1 to __uchar 0x1 +cast from __int 0x1 to __int 0x1 +cast from __int 0x1 to __uint 0x1 +cast from __int 0x1 to float 0x1 +cast from __int 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __int 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __uint 0x1 to char 0x1 +cast from __uint 0x1 to __uchar 0x1 +cast from __uint 0x1 to __int 0x1 +cast from __uint 0x1 to __uint 0x1 +cast from __uint 0x1 to float 0x1 +cast from __uint 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __uint 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from float 0x1 to char 0x1 +cast from float 0x1 to __uchar 0x1 +cast from float 0x1 to __int 0x1 +cast from float 0x1 to __uint 0x1 +cast from float 0x1 to float 0x1 +cast from float 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from float 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __longlong 0x1 to char 0x1 +cast from __longlong 0x1 to __uchar 0x1 +cast from __longlong 0x1 to __int 0x1 +cast from __longlong 0x1 to __uint 0x1 +cast from __longlong 0x1 to float 0x1 +cast from __longlong 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __longlong 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __ulonglong 0x1 to char 0x1 +cast from __ulonglong 0x1 to __uchar 0x1 +cast from __ulonglong 0x1 to __int 0x1 +cast from __ulonglong 0x1 to __uint 0x1 +cast from __ulonglong 0x1 to float 0x1 +cast from __ulonglong 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __ulonglong 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from char 0x1 to char 0x1 +cast from char 0x1 to __uchar 0x1 +cast from char 0x1 to __int 0x1 +cast from char 0x1 to __uint 0x1 +cast from char 0x1 to float 0x1 +cast from char 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from char 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __uchar 0x1 to char 0x1 +cast from __uchar 0x1 to __uchar 0x1 +cast from __uchar 0x1 to __int 0x1 +cast from __uchar 0x1 to __uint 0x1 +cast from __uchar 0x1 to float 0x1 +cast from __uchar 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __uchar 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __int 0x1 to char 0x1 +cast from __int 0x1 to __uchar 0x1 +cast from __int 0x1 to __int 0x1 +cast from __int 0x1 to __uint 0x1 +cast from __int 0x1 to float 0x1 +cast from __int 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __int 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __uint 0x1 to char 0x1 +cast from __uint 0x1 to __uchar 0x1 +cast from __uint 0x1 to __int 0x1 +cast from __uint 0x1 to __uint 0x1 +cast from __uint 0x1 to float 0x1 +cast from __uint 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __uint 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from float 0x1 to char 0x1 +cast from float 0x1 to __uchar 0x1 +cast from float 0x1 to __int 0x1 +cast from float 0x1 to __uint 0x1 +cast from float 0x1 to float 0x1 +cast from float 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from float 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __longlong 0x1 to char 0x1 +cast from __longlong 0x1 to __uchar 0x1 +cast from __longlong 0x1 to __int 0x1 +cast from __longlong 0x1 to __uint 0x1 +cast from __longlong 0x1 to float 0x1 +cast from __longlong 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __longlong 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __ulonglong 0x1 to char 0x1 +cast from __ulonglong 0x1 to __uchar 0x1 +cast from __ulonglong 0x1 to __int 0x1 +cast from __ulonglong 0x1 to __uint 0x1 +cast from __ulonglong 0x1 to float 0x1 +cast from __ulonglong 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __ulonglong 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from char 0xa to char 0xa +cast from char 0xa to __uchar 0xa +cast from char 0xa to __int 0xa +cast from char 0xa to __uint 0xa +cast from char 0xa to float 0xa +cast from char 0xa (0xa) + to __longlong 0xa (0xa) + +cast from char 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from __uchar 0xa to char 0xa +cast from __uchar 0xa to __uchar 0xa +cast from __uchar 0xa to __int 0xa +cast from __uchar 0xa to __uint 0xa +cast from __uchar 0xa to float 0xa +cast from __uchar 0xa (0xa) + to __longlong 0xa (0xa) + +cast from __uchar 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from __int 0xa to char 0xa +cast from __int 0xa to __uchar 0xa +cast from __int 0xa to __int 0xa +cast from __int 0xa to __uint 0xa +cast from __int 0xa to float 0xa +cast from __int 0xa (0xa) + to __longlong 0xa (0xa) + +cast from __int 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from __uint 0xa to char 0xa +cast from __uint 0xa to __uchar 0xa +cast from __uint 0xa to __int 0xa +cast from __uint 0xa to __uint 0xa +cast from __uint 0xa to float 0xa +cast from __uint 0xa (0xa) + to __longlong 0xa (0xa) + +cast from __uint 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from float 0xa to char 0xa +cast from float 0xa to __uchar 0xa +cast from float 0xa to __int 0xa +cast from float 0xa to __uint 0xa +cast from float 0xa to float 0xa +cast from float 0xa (0xa) + to __longlong 0xa (0xa) + +cast from float 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from __longlong 0xa to char 0xa +cast from __longlong 0xa to __uchar 0xa +cast from __longlong 0xa to __int 0xa +cast from __longlong 0xa to __uint 0xa +cast from __longlong 0xa to float 0xa +cast from __longlong 0xa (0xa) + to __longlong 0xa (0xa) + +cast from __longlong 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from __ulonglong 0xa to char 0xa +cast from __ulonglong 0xa to __uchar 0xa +cast from __ulonglong 0xa to __int 0xa +cast from __ulonglong 0xa to __uint 0xa +cast from __ulonglong 0xa to float 0xa +cast from __ulonglong 0xa (0xa) + to __longlong 0xa (0xa) + +cast from __ulonglong 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from char 0xa to char 0xa +cast from char 0xa to __uchar 0xa +cast from char 0xa to __int 0xa +cast from char 0xa to __uint 0xa +cast from char 0xa to float 0xa +cast from char 0xa (0xa) + to __longlong 0xa (0xa) + +cast from char 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from __uchar 0xa to char 0xa +cast from __uchar 0xa to __uchar 0xa +cast from __uchar 0xa to __int 0xa +cast from __uchar 0xa to __uint 0xa +cast from __uchar 0xa to float 0xa +cast from __uchar 0xa (0xa) + to __longlong 0xa (0xa) + +cast from __uchar 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from __int 0xa to char 0xa +cast from __int 0xa to __uchar 0xa +cast from __int 0xa to __int 0xa +cast from __int 0xa to __uint 0xa +cast from __int 0xa to float 0xa +cast from __int 0xa (0xa) + to __longlong 0xa (0xa) + +cast from __int 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from __uint 0xa to char 0xa +cast from __uint 0xa to __uchar 0xa +cast from __uint 0xa to __int 0xa +cast from __uint 0xa to __uint 0xa +cast from __uint 0xa to float 0xa +cast from __uint 0xa (0xa) + to __longlong 0xa (0xa) + +cast from __uint 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from float 0xa to char 0xa +cast from float 0xa to __uchar 0xa +cast from float 0xa to __int 0xa +cast from float 0xa to __uint 0xa +cast from float 0xa to float 0xa +cast from float 0xa (0xa) + to __longlong 0xa (0xa) + +cast from float 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from __longlong 0xa to char 0xa +cast from __longlong 0xa to __uchar 0xa +cast from __longlong 0xa to __int 0xa +cast from __longlong 0xa to __uint 0xa +cast from __longlong 0xa to float 0xa +cast from __longlong 0xa (0xa) + to __longlong 0xa (0xa) + +cast from __longlong 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from __ulonglong 0xa to char 0xa +cast from __ulonglong 0xa to __uchar 0xa +cast from __ulonglong 0xa to __int 0xa +cast from __ulonglong 0xa to __uint 0xa +cast from __ulonglong 0xa to float 0xa +cast from __ulonglong 0xa (0xa) + to __longlong 0xa (0xa) + +cast from __ulonglong 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from char 0x17 to char 0x17 +cast from char 0x17 to __uchar 0x17 +cast from char 0x17 to __int 0x17 +cast from char 0x17 to __uint 0x17 +cast from char 0x17 to float 0x17 +cast from char 0x17 (0x17) + to __longlong 0x17 (0x17) + +cast from char 0x17 (0x17) + to __ulonglong 0x17 (0x17) + +cast from __uchar 0x17 to char 0x17 +cast from __uchar 0x17 to __uchar 0x17 +cast from __uchar 0x17 to __int 0x17 +cast from __uchar 0x17 to __uint 0x17 +cast from __uchar 0x17 to float 0x17 +cast from __uchar 0x17 (0x17) + to __longlong 0x17 (0x17) + +cast from __uchar 0x17 (0x17) + to __ulonglong 0x17 (0x17) + +cast from __int 0x17 to char 0x17 +cast from __int 0x17 to __uchar 0x17 +cast from __int 0x17 to __int 0x17 +cast from __int 0x17 to __uint 0x17 +cast from __int 0x17 to float 0x17 +cast from __int 0x17 (0x17) + to __longlong 0x17 (0x17) + +cast from __int 0x17 (0x17) + to __ulonglong 0x17 (0x17) + +cast from __uint 0x17 to char 0x17 +cast from __uint 0x17 to __uchar 0x17 +cast from __uint 0x17 to __int 0x17 +cast from __uint 0x17 to __uint 0x17 +cast from __uint 0x17 to float 0x17 +cast from __uint 0x17 (0x17) + to __longlong 0x17 (0x17) + +cast from __uint 0x17 (0x17) + to __ulonglong 0x17 (0x17) + +cast from float 0x17 to char 0x17 +cast from float 0x17 to __uchar 0x17 +cast from float 0x17 to __int 0x17 +cast from float 0x17 to __uint 0x17 +cast from float 0x17 to float 0x17 +cast from float 0x17 (0x17) + to __longlong 0x17 (0x17) + +cast from float 0x17 (0x17) + to __ulonglong 0x17 (0x17) + +cast from __longlong 0x17 to char 0x17 +cast from __longlong 0x17 to __uchar 0x17 +cast from __longlong 0x17 to __int 0x17 +cast from __longlong 0x17 to __uint 0x17 +cast from __longlong 0x17 to float 0x17 +cast from __longlong 0x17 (0x17) + to __longlong 0x17 (0x17) + +cast from __longlong 0x17 (0x17) + to __ulonglong 0x17 (0x17) + +cast from __ulonglong 0x17 to char 0x17 +cast from __ulonglong 0x17 to __uchar 0x17 +cast from __ulonglong 0x17 to __int 0x17 +cast from __ulonglong 0x17 to __uint 0x17 +cast from __ulonglong 0x17 to float 0x17 +cast from __ulonglong 0x17 (0x17) + to __longlong 0x17 (0x17) + +cast from __ulonglong 0x17 (0x17) + to __ulonglong 0x17 (0x17) + +cast from char 0x17 to char 0x17 +cast from char 0x17 to __uchar 0x17 +cast from char 0x17 to __int 0x17 +cast from char 0x17 to __uint 0x17 +cast from char 0x17 to float 0x17 +cast from char 0x17 (0x17) + to __longlong 0x17 (0x17) + +cast from char 0x17 (0x17) + to __ulonglong 0x17 (0x17) + +cast from __uchar 0x17 to char 0x17 +cast from __uchar 0x17 to __uchar 0x17 +cast from __uchar 0x17 to __int 0x17 +cast from __uchar 0x17 to __uint 0x17 +cast from __uchar 0x17 to float 0x17 +cast from __uchar 0x17 (0x17) + to __longlong 0x17 (0x17) + +cast from __uchar 0x17 (0x17) + to __ulonglong 0x17 (0x17) + +cast from __int 0x17 to char 0x17 +cast from __int 0x17 to __uchar 0x17 +cast from __int 0x17 to __int 0x17 +cast from __int 0x17 to __uint 0x17 +cast from __int 0x17 to float 0x17 +cast from __int 0x17 (0x17) + to __longlong 0x17 (0x17) + +cast from __int 0x17 (0x17) + to __ulonglong 0x17 (0x17) + +cast from __uint 0x17 to char 0x17 +cast from __uint 0x17 to __uchar 0x17 +cast from __uint 0x17 to __int 0x17 +cast from __uint 0x17 to __uint 0x17 +cast from __uint 0x17 to float 0x17 +cast from __uint 0x17 (0x17) + to __longlong 0x17 (0x17) + +cast from __uint 0x17 (0x17) + to __ulonglong 0x17 (0x17) + +cast from float 0x17 to char 0x17 +cast from float 0x17 to __uchar 0x17 +cast from float 0x17 to __int 0x17 +cast from float 0x17 to __uint 0x17 +cast from float 0x17 to float 0x17 +cast from float 0x17 (0x17) + to __longlong 0x17 (0x17) + +cast from float 0x17 (0x17) + to __ulonglong 0x17 (0x17) + +cast from __longlong 0x17 to char 0x17 +cast from __longlong 0x17 to __uchar 0x17 +cast from __longlong 0x17 to __int 0x17 +cast from __longlong 0x17 to __uint 0x17 +cast from __longlong 0x17 to float 0x17 +cast from __longlong 0x17 (0x17) + to __longlong 0x17 (0x17) + +cast from __longlong 0x17 (0x17) + to __ulonglong 0x17 (0x17) + +cast from __ulonglong 0x17 to char 0x17 +cast from __ulonglong 0x17 to __uchar 0x17 +cast from __ulonglong 0x17 to __int 0x17 +cast from __ulonglong 0x17 to __uint 0x17 +cast from __ulonglong 0x17 to float 0x17 +cast from __ulonglong 0x17 (0x17) + to __longlong 0x17 (0x17) + +cast from __ulonglong 0x17 (0x17) + to __ulonglong 0x17 (0x17) + +cast from char 0x2a to char 0x2a +cast from char 0x2a to __uchar 0x2a +cast from char 0x2a to __int 0x2a +cast from char 0x2a to __uint 0x2a +cast from char 0x2a to float 0x2a +cast from char 0x2a (0x2a) + to __longlong 0x2a (0x2a) + +cast from char 0x2a (0x2a) + to __ulonglong 0x2a (0x2a) + +cast from __uchar 0x2a to char 0x2a +cast from __uchar 0x2a to __uchar 0x2a +cast from __uchar 0x2a to __int 0x2a +cast from __uchar 0x2a to __uint 0x2a +cast from __uchar 0x2a to float 0x2a +cast from __uchar 0x2a (0x2a) + to __longlong 0x2a (0x2a) + +cast from __uchar 0x2a (0x2a) + to __ulonglong 0x2a (0x2a) + +cast from __int 0x2a to char 0x2a +cast from __int 0x2a to __uchar 0x2a +cast from __int 0x2a to __int 0x2a +cast from __int 0x2a to __uint 0x2a +cast from __int 0x2a to float 0x2a +cast from __int 0x2a (0x2a) + to __longlong 0x2a (0x2a) + +cast from __int 0x2a (0x2a) + to __ulonglong 0x2a (0x2a) + +cast from __uint 0x2a to char 0x2a +cast from __uint 0x2a to __uchar 0x2a +cast from __uint 0x2a to __int 0x2a +cast from __uint 0x2a to __uint 0x2a +cast from __uint 0x2a to float 0x2a +cast from __uint 0x2a (0x2a) + to __longlong 0x2a (0x2a) + +cast from __uint 0x2a (0x2a) + to __ulonglong 0x2a (0x2a) + +cast from float 0x2a to char 0x2a +cast from float 0x2a to __uchar 0x2a +cast from float 0x2a to __int 0x2a +cast from float 0x2a to __uint 0x2a +cast from float 0x2a to float 0x2a +cast from float 0x2a (0x2a) + to __longlong 0x2a (0x2a) + +cast from float 0x2a (0x2a) + to __ulonglong 0x2a (0x2a) + +cast from __longlong 0x2a to char 0x2a +cast from __longlong 0x2a to __uchar 0x2a +cast from __longlong 0x2a to __int 0x2a +cast from __longlong 0x2a to __uint 0x2a +cast from __longlong 0x2a to float 0x2a +cast from __longlong 0x2a (0x2a) + to __longlong 0x2a (0x2a) + +cast from __longlong 0x2a (0x2a) + to __ulonglong 0x2a (0x2a) + +cast from __ulonglong 0x2a to char 0x2a +cast from __ulonglong 0x2a to __uchar 0x2a +cast from __ulonglong 0x2a to __int 0x2a +cast from __ulonglong 0x2a to __uint 0x2a +cast from __ulonglong 0x2a to float 0x2a +cast from __ulonglong 0x2a (0x2a) + to __longlong 0x2a (0x2a) + +cast from __ulonglong 0x2a (0x2a) + to __ulonglong 0x2a (0x2a) + +cast from char 0x2a to char 0x2a +cast from char 0x2a to __uchar 0x2a +cast from char 0x2a to __int 0x2a +cast from char 0x2a to __uint 0x2a +cast from char 0x2a to float 0x2a +cast from char 0x2a (0x2a) + to __longlong 0x2a (0x2a) + +cast from char 0x2a (0x2a) + to __ulonglong 0x2a (0x2a) + +cast from __uchar 0x2a to char 0x2a +cast from __uchar 0x2a to __uchar 0x2a +cast from __uchar 0x2a to __int 0x2a +cast from __uchar 0x2a to __uint 0x2a +cast from __uchar 0x2a to float 0x2a +cast from __uchar 0x2a (0x2a) + to __longlong 0x2a (0x2a) + +cast from __uchar 0x2a (0x2a) + to __ulonglong 0x2a (0x2a) + +cast from __int 0x2a to char 0x2a +cast from __int 0x2a to __uchar 0x2a +cast from __int 0x2a to __int 0x2a +cast from __int 0x2a to __uint 0x2a +cast from __int 0x2a to float 0x2a +cast from __int 0x2a (0x2a) + to __longlong 0x2a (0x2a) + +cast from __int 0x2a (0x2a) + to __ulonglong 0x2a (0x2a) + +cast from __uint 0x2a to char 0x2a +cast from __uint 0x2a to __uchar 0x2a +cast from __uint 0x2a to __int 0x2a +cast from __uint 0x2a to __uint 0x2a +cast from __uint 0x2a to float 0x2a +cast from __uint 0x2a (0x2a) + to __longlong 0x2a (0x2a) + +cast from __uint 0x2a (0x2a) + to __ulonglong 0x2a (0x2a) + +cast from float 0x2a to char 0x2a +cast from float 0x2a to __uchar 0x2a +cast from float 0x2a to __int 0x2a +cast from float 0x2a to __uint 0x2a +cast from float 0x2a to float 0x2a +cast from float 0x2a (0x2a) + to __longlong 0x2a (0x2a) + +cast from float 0x2a (0x2a) + to __ulonglong 0x2a (0x2a) + +cast from __longlong 0x2a to char 0x2a +cast from __longlong 0x2a to __uchar 0x2a +cast from __longlong 0x2a to __int 0x2a +cast from __longlong 0x2a to __uint 0x2a +cast from __longlong 0x2a to float 0x2a +cast from __longlong 0x2a (0x2a) + to __longlong 0x2a (0x2a) + +cast from __longlong 0x2a (0x2a) + to __ulonglong 0x2a (0x2a) + +cast from __ulonglong 0x2a to char 0x2a +cast from __ulonglong 0x2a to __uchar 0x2a +cast from __ulonglong 0x2a to __int 0x2a +cast from __ulonglong 0x2a to __uint 0x2a +cast from __ulonglong 0x2a to float 0x2a +cast from __ulonglong 0x2a (0x2a) + to __longlong 0x2a (0x2a) + +cast from __ulonglong 0x2a (0x2a) + to __ulonglong 0x2a (0x2a) + +cast from char 0x7f to char 0x7f +cast from char 0x7f to __uchar 0x7f +cast from char 0x7f to __int 0x7f +cast from char 0x7f to __uint 0x7f +cast from char 0x7f to float 0x7f +cast from char 0x7f (0x7f) + to __longlong 0x7f (0x7f) + +cast from char 0x7f (0x7f) + to __ulonglong 0x7f (0x7f) + +cast from __uchar 0x7f to char 0x7f +cast from __uchar 0x7f to __uchar 0x7f +cast from __uchar 0x7f to __int 0x7f +cast from __uchar 0x7f to __uint 0x7f +cast from __uchar 0x7f to float 0x7f +cast from __uchar 0x7f (0x7f) + to __longlong 0x7f (0x7f) + +cast from __uchar 0x7f (0x7f) + to __ulonglong 0x7f (0x7f) + +cast from __int 0x7f to char 0x7f +cast from __int 0x7f to __uchar 0x7f +cast from __int 0x7f to __int 0x7f +cast from __int 0x7f to __uint 0x7f +cast from __int 0x7f to float 0x7f +cast from __int 0x7f (0x7f) + to __longlong 0x7f (0x7f) + +cast from __int 0x7f (0x7f) + to __ulonglong 0x7f (0x7f) + +cast from __uint 0x7f to char 0x7f +cast from __uint 0x7f to __uchar 0x7f +cast from __uint 0x7f to __int 0x7f +cast from __uint 0x7f to __uint 0x7f +cast from __uint 0x7f to float 0x7f +cast from __uint 0x7f (0x7f) + to __longlong 0x7f (0x7f) + +cast from __uint 0x7f (0x7f) + to __ulonglong 0x7f (0x7f) + +cast from float 0x7f to char 0x7f +cast from float 0x7f to __uchar 0x7f +cast from float 0x7f to __int 0x7f +cast from float 0x7f to __uint 0x7f +cast from float 0x7f to float 0x7f +cast from float 0x7f (0x7f) + to __longlong 0x7f (0x7f) + +cast from float 0x7f (0x7f) + to __ulonglong 0x7f (0x7f) + +cast from __longlong 0x7f to char 0x7f +cast from __longlong 0x7f to __uchar 0x7f +cast from __longlong 0x7f to __int 0x7f +cast from __longlong 0x7f to __uint 0x7f +cast from __longlong 0x7f to float 0x7f +cast from __longlong 0x7f (0x7f) + to __longlong 0x7f (0x7f) + +cast from __longlong 0x7f (0x7f) + to __ulonglong 0x7f (0x7f) + +cast from __ulonglong 0x7f to char 0x7f +cast from __ulonglong 0x7f to __uchar 0x7f +cast from __ulonglong 0x7f to __int 0x7f +cast from __ulonglong 0x7f to __uint 0x7f +cast from __ulonglong 0x7f to float 0x7f +cast from __ulonglong 0x7f (0x7f) + to __longlong 0x7f (0x7f) + +cast from __ulonglong 0x7f (0x7f) + to __ulonglong 0x7f (0x7f) + +cast from char 0x7f to char 0x7f +cast from char 0x7f to __uchar 0x7f +cast from char 0x7f to __int 0x7f +cast from char 0x7f to __uint 0x7f +cast from char 0x7f to float 0x7f +cast from char 0x7f (0x7f) + to __longlong 0x7f (0x7f) + +cast from char 0x7f (0x7f) + to __ulonglong 0x7f (0x7f) + +cast from __uchar 0x7f to char 0x7f +cast from __uchar 0x7f to __uchar 0x7f +cast from __uchar 0x7f to __int 0x7f +cast from __uchar 0x7f to __uint 0x7f +cast from __uchar 0x7f to float 0x7f +cast from __uchar 0x7f (0x7f) + to __longlong 0x7f (0x7f) + +cast from __uchar 0x7f (0x7f) + to __ulonglong 0x7f (0x7f) + +cast from __int 0x7f to char 0x7f +cast from __int 0x7f to __uchar 0x7f +cast from __int 0x7f to __int 0x7f +cast from __int 0x7f to __uint 0x7f +cast from __int 0x7f to float 0x7f +cast from __int 0x7f (0x7f) + to __longlong 0x7f (0x7f) + +cast from __int 0x7f (0x7f) + to __ulonglong 0x7f (0x7f) + +cast from __uint 0x7f to char 0x7f +cast from __uint 0x7f to __uchar 0x7f +cast from __uint 0x7f to __int 0x7f +cast from __uint 0x7f to __uint 0x7f +cast from __uint 0x7f to float 0x7f +cast from __uint 0x7f (0x7f) + to __longlong 0x7f (0x7f) + +cast from __uint 0x7f (0x7f) + to __ulonglong 0x7f (0x7f) + +cast from float 0x7f to char 0x7f +cast from float 0x7f to __uchar 0x7f +cast from float 0x7f to __int 0x7f +cast from float 0x7f to __uint 0x7f +cast from float 0x7f to float 0x7f +cast from float 0x7f (0x7f) + to __longlong 0x7f (0x7f) + +cast from float 0x7f (0x7f) + to __ulonglong 0x7f (0x7f) + +cast from __longlong 0x7f to char 0x7f +cast from __longlong 0x7f to __uchar 0x7f +cast from __longlong 0x7f to __int 0x7f +cast from __longlong 0x7f to __uint 0x7f +cast from __longlong 0x7f to float 0x7f +cast from __longlong 0x7f (0x7f) + to __longlong 0x7f (0x7f) + +cast from __longlong 0x7f (0x7f) + to __ulonglong 0x7f (0x7f) + +cast from __ulonglong 0x7f to char 0x7f +cast from __ulonglong 0x7f to __uchar 0x7f +cast from __ulonglong 0x7f to __int 0x7f +cast from __ulonglong 0x7f to __uint 0x7f +cast from __ulonglong 0x7f to float 0x7f +cast from __ulonglong 0x7f (0x7f) + to __longlong 0x7f (0x7f) + +cast from __ulonglong 0x7f (0x7f) + to __ulonglong 0x7f (0x7f) + +int ~0x0 ~ -0x1 +xchar int ~0x0 ~ -0x1 +int ~0x0 ~ -0x1 +__uint ~0x0 ~ -0x1 +char ~0x0 ~ -0x1 +__uchar ~0x0 ~ 0xff +__longlong ~0x0 ~ -0x1 +__ulonglong ~0x0 ~ -0x1 +int !0x0 ! 0x1 +__uint !0x0 ! 0x1 +char !0x0 ! 0x1 +__uchar !0x0 ! 0x1 +__longlong !0x0 ! 0x1 +__ulonglong !0x0 ! 0x1 +int -0x0 - 0x0 +__uint -0x0 - 0x0 +char -0x0 - 0x0 +__uchar -0x0 - 0x0 +__longlong -0x0 - 0x0 +__ulonglong -0x0 - 0x0 +int ~-0x1 ~ 0x0 +xchar int ~-0x1 ~ 0x0 +int ~-0x1 ~ 0x0 +__uint ~-0x1 ~ 0x0 +char ~-0x1 ~ 0x0 +__uchar ~0xff ~ 0x0 +__longlong ~-0x1 ~ 0x0 +__ulonglong ~-0x1 ~ 0x0 +int !-0x1 ! 0x0 +__uint !-0x1 ! 0x0 +char !-0x1 ! 0x0 +__uchar !0xff ! 0x0 +__longlong !-0x1 ! 0x0 +__ulonglong !-0x1 ! 0x0 +int --0x1 - 0x1 +__uint --0x1 - 0x1 +char --0x1 - 0x1 +__uchar -0xff - 0x1 +__longlong --0x1 - 0x1 +__ulonglong --0x1 - 0x1 +int ~0x1 ~ -0x2 +xchar int ~0x1 ~ -0x2 +int ~0x1 ~ -0x2 +__uint ~0x1 ~ -0x2 +char ~0x1 ~ -0x2 +__uchar ~0x1 ~ 0xfe +__longlong ~0x1 ~ -0x2 +__ulonglong ~0x1 ~ -0x2 +int !0x1 ! 0x0 +__uint !0x1 ! 0x0 +char !0x1 ! 0x0 +__uchar !0x1 ! 0x0 +__longlong !0x1 ! 0x0 +__ulonglong !0x1 ! 0x0 +int -0x1 - -0x1 +__uint -0x1 - -0x1 +char -0x1 - -0x1 +__uchar -0x1 - 0xff +__longlong -0x1 - -0x1 +__ulonglong -0x1 - -0x1 +int ~0x2 ~ -0x3 +xchar int ~0x2 ~ -0x3 +int ~0x2 ~ -0x3 +__uint ~0x2 ~ -0x3 +char ~0x2 ~ -0x3 +__uchar ~0x2 ~ 0xfd +__longlong ~0x2 ~ -0x3 +__ulonglong ~0x2 ~ -0x3 +int !0x2 ! 0x0 +__uint !0x2 ! 0x0 +char !0x2 ! 0x0 +__uchar !0x2 ! 0x0 +__longlong !0x2 ! 0x0 +__ulonglong !0x2 ! 0x0 +int -0x2 - -0x2 +__uint -0x2 - -0x2 +char -0x2 - -0x2 +__uchar -0x2 - 0xfe +__longlong -0x2 - -0x2 +__ulonglong -0x2 - -0x2 +int ~-0x2 ~ 0x1 +xchar int ~-0x2 ~ 0x1 +int ~-0x2 ~ 0x1 +__uint ~-0x2 ~ 0x1 +char ~-0x2 ~ 0x1 +__uchar ~0xfe ~ 0x1 +__longlong ~-0x2 ~ 0x1 +__ulonglong ~-0x2 ~ 0x1 +int !-0x2 ! 0x0 +__uint !-0x2 ! 0x0 +char !-0x2 ! 0x0 +__uchar !0xfe ! 0x0 +__longlong !-0x2 ! 0x0 +__ulonglong !-0x2 ! 0x0 +int --0x2 - 0x2 +__uint --0x2 - 0x2 +char --0x2 - 0x2 +__uchar -0xfe - 0x2 +__longlong --0x2 - 0x2 +__ulonglong --0x2 - 0x2 +int ~0x4 ~ -0x5 +xchar int ~0x4 ~ -0x5 +int ~0x4 ~ -0x5 +__uint ~0x4 ~ -0x5 +char ~0x4 ~ -0x5 +__uchar ~0x4 ~ 0xfb +__longlong ~0x4 ~ -0x5 +__ulonglong ~0x4 ~ -0x5 +int !0x4 ! 0x0 +__uint !0x4 ! 0x0 +char !0x4 ! 0x0 +__uchar !0x4 ! 0x0 +__longlong !0x4 ! 0x0 +__ulonglong !0x4 ! 0x0 +int -0x4 - -0x4 +__uint -0x4 - -0x4 +char -0x4 - -0x4 +__uchar -0x4 - 0xfc +__longlong -0x4 - -0x4 +__ulonglong -0x4 - -0x4 +int ~-0x4 ~ 0x3 +xchar int ~-0x4 ~ 0x3 +int ~-0x4 ~ 0x3 +__uint ~-0x4 ~ 0x3 +char ~-0x4 ~ 0x3 +__uchar ~0xfc ~ 0x3 +__longlong ~-0x4 ~ 0x3 +__ulonglong ~-0x4 ~ 0x3 +int !-0x4 ! 0x0 +__uint !-0x4 ! 0x0 +char !-0x4 ! 0x0 +__uchar !0xfc ! 0x0 +__longlong !-0x4 ! 0x0 +__ulonglong !-0x4 ! 0x0 +int --0x4 - 0x4 +__uint --0x4 - 0x4 +char --0x4 - 0x4 +__uchar -0xfc - 0x4 +__longlong --0x4 - 0x4 +__ulonglong --0x4 - 0x4 +int ~0xa ~ -0xb +xchar int ~0xa ~ -0xb +int ~0xa ~ -0xb +__uint ~0xa ~ -0xb +char ~0xa ~ -0xb +__uchar ~0xa ~ 0xf5 +__longlong ~0xa ~ -0xb +__ulonglong ~0xa ~ -0xb +int !0xa ! 0x0 +__uint !0xa ! 0x0 +char !0xa ! 0x0 +__uchar !0xa ! 0x0 +__longlong !0xa ! 0x0 +__ulonglong !0xa ! 0x0 +int -0xa - -0xa +__uint -0xa - -0xa +char -0xa - -0xa +__uchar -0xa - 0xf6 +__longlong -0xa - -0xa +__ulonglong -0xa - -0xa +int ~-0xa ~ 0x9 +xchar int ~-0xa ~ 0x9 +int ~-0xa ~ 0x9 +__uint ~-0xa ~ 0x9 +char ~-0xa ~ 0x9 +__uchar ~0xf6 ~ 0x9 +__longlong ~-0xa ~ 0x9 +__ulonglong ~-0xa ~ 0x9 +int !-0xa ! 0x0 +__uint !-0xa ! 0x0 +char !-0xa ! 0x0 +__uchar !0xf6 ! 0x0 +__longlong !-0xa ! 0x0 +__ulonglong !-0xa ! 0x0 +int --0xa - 0xa +__uint --0xa - 0xa +char --0xa - 0xa +__uchar -0xf6 - 0xa +__longlong --0xa - 0xa +__ulonglong --0xa - 0xa +int ~0x5 ~ -0x6 +xchar int ~0x5 ~ -0x6 +int ~0x5 ~ -0x6 +__uint ~0x5 ~ -0x6 +char ~0x5 ~ -0x6 +__uchar ~0x5 ~ 0xfa +__longlong ~0x5 ~ -0x6 +__ulonglong ~0x5 ~ -0x6 +int !0x5 ! 0x0 +__uint !0x5 ! 0x0 +char !0x5 ! 0x0 +__uchar !0x5 ! 0x0 +__longlong !0x5 ! 0x0 +__ulonglong !0x5 ! 0x0 +int -0x5 - -0x5 +__uint -0x5 - -0x5 +char -0x5 - -0x5 +__uchar -0x5 - 0xfb +__longlong -0x5 - -0x5 +__ulonglong -0x5 - -0x5 +int ~0x7 ~ -0x8 +xchar int ~0x7 ~ -0x8 +int ~0x7 ~ -0x8 +__uint ~0x7 ~ -0x8 +char ~0x7 ~ -0x8 +__uchar ~0x7 ~ 0xf8 +__longlong ~0x7 ~ -0x8 +__ulonglong ~0x7 ~ -0x8 +int !0x7 ! 0x0 +__uint !0x7 ! 0x0 +char !0x7 ! 0x0 +__uchar !0x7 ! 0x0 +__longlong !0x7 ! 0x0 +__ulonglong !0x7 ! 0x0 +int -0x7 - -0x7 +__uint -0x7 - -0x7 +char -0x7 - -0x7 +__uchar -0x7 - 0xf9 +__longlong -0x7 - -0x7 +__ulonglong -0x7 - -0x7 +int ~0x2a ~ -0x2b +xchar int ~0x2a ~ -0x2b +int ~0x2a ~ -0x2b +__uint ~0x2a ~ -0x2b +char ~0x2a ~ -0x2b +__uchar ~0x2a ~ 0xd5 +__longlong ~0x2a ~ -0x2b +__ulonglong ~0x2a ~ -0x2b +int !0x2a ! 0x0 +__uint !0x2a ! 0x0 +char !0x2a ! 0x0 +__uchar !0x2a ! 0x0 +__longlong !0x2a ! 0x0 +__ulonglong !0x2a ! 0x0 +int -0x2a - -0x2a +__uint -0x2a - -0x2a +char -0x2a - -0x2a +__uchar -0x2a - 0xd6 +__longlong -0x2a - -0x2a +__ulonglong -0x2a - -0x2a +int ~0x17 ~ -0x18 +xchar int ~0x17 ~ -0x18 +int ~0x17 ~ -0x18 +__uint ~0x17 ~ -0x18 +char ~0x17 ~ -0x18 +__uchar ~0x17 ~ 0xe8 +__longlong ~0x17 ~ -0x18 +__ulonglong ~0x17 ~ -0x18 +int !0x17 ! 0x0 +__uint !0x17 ! 0x0 +char !0x17 ! 0x0 +__uchar !0x17 ! 0x0 +__longlong !0x17 ! 0x0 +__ulonglong !0x17 ! 0x0 +int -0x17 - -0x17 +__uint -0x17 - -0x17 +char -0x17 - -0x17 +__uchar -0x17 - 0xe9 +__longlong -0x17 - -0x17 +__ulonglong -0x17 - -0x17 +int ~0x7fff ~ -0x8000 +xchar int ~-0x1 ~ 0x0 +int ~0x7fff ~ -0x8000 +__uint ~0x7fff ~ -0x8000 +char ~-0x1 ~ 0x0 +__uchar ~0xff ~ 0x0 +__longlong ~0x7fff ~ -0x8000 +__ulonglong ~0x7fff ~ -0x8000 +int !0x7fff ! 0x0 +__uint !0x7fff ! 0x0 +char !-0x1 ! 0x0 +__uchar !0xff ! 0x0 +__longlong !0x7fff ! 0x0 +__ulonglong !0x7fff ! 0x0 +int -0x7fff - -0x7fff +__uint -0x7fff - -0x7fff +char --0x1 - 0x1 +__uchar -0xff - 0x1 +__longlong -0x7fff - -0x7fff +__ulonglong -0x7fff - -0x7fff +int ~-0x8000 ~ 0x7fff +xchar int ~0x0 ~ -0x1 +int ~-0x8000 ~ 0x7fff +__uint ~-0x8000 ~ 0x7fff +char ~0x0 ~ -0x1 +__uchar ~0x0 ~ 0xff +__longlong ~-0x8000 ~ 0x7fff +__ulonglong ~-0x8000 ~ 0x7fff +int !-0x8000 ! 0x0 +__uint !-0x8000 ! 0x0 +char !0x0 ! 0x1 +__uchar !0x0 ! 0x1 +__longlong !-0x8000 ! 0x0 +__ulonglong !-0x8000 ! 0x0 +int --0x8000 - -0x8000 +__uint --0x8000 - -0x8000 +char -0x0 - 0x0 +__uchar -0x0 - 0x0 +__longlong --0x8000 - -0x8000 +__ulonglong --0x8000 - -0x8000 +int ~-0x3e8 ~ 0x3e7 +xchar int ~0x18 ~ -0x19 +int ~-0x3e8 ~ 0x3e7 +__uint ~-0x3e8 ~ 0x3e7 +char ~0x18 ~ -0x19 +__uchar ~0x18 ~ 0xe7 +__longlong ~-0x3e8 ~ 0x3e7 +__ulonglong ~-0x3e8 ~ 0x3e7 +int !-0x3e8 ! 0x0 +__uint !-0x3e8 ! 0x0 +char !0x18 ! 0x0 +__uchar !0x18 ! 0x0 +__longlong !-0x3e8 ! 0x0 +__ulonglong !-0x3e8 ! 0x0 +int --0x3e8 - 0x3e8 +__uint --0x3e8 - 0x3e8 +char -0x18 - -0x18 +__uchar -0x18 - 0xe8 +__longlong --0x3e8 - 0x3e8 +__ulonglong --0x3e8 - 0x3e8 +int ~-0x2710 ~ 0x270f +xchar int ~-0x10 ~ 0xf +int ~-0x2710 ~ 0x270f +__uint ~-0x2710 ~ 0x270f +char ~-0x10 ~ 0xf +__uchar ~0xf0 ~ 0xf +__longlong ~-0x2710 ~ 0x270f +__ulonglong ~-0x2710 ~ 0x270f +int !-0x2710 ! 0x0 +__uint !-0x2710 ! 0x0 +char !-0x10 ! 0x0 +__uchar !0xf0 ! 0x0 +__longlong !-0x2710 ! 0x0 +__ulonglong !-0x2710 ! 0x0 +int --0x2710 - 0x2710 +__uint --0x2710 - 0x2710 +char --0x10 - 0x10 +__uchar -0xf0 - 0x10 +__longlong --0x2710 - 0x2710 +__ulonglong --0x2710 - 0x2710 +int !0x0 ! 0x1 +xchar int !0x0 ! 0x1 +int ~0x0 ~ -0x1 +__uint ~0x0 ~ -0x1 +char ~0x0 ~ -0x1 +__uchar ~0x0 ~ 0xff +__longlong ~0x0 ~ -0x1 +__ulonglong ~0x0 ~ -0x1 +int !0x0 ! 0x1 +__uint !0x0 ! 0x1 +char !0x0 ! 0x1 +__uchar !0x0 ! 0x1 +__longlong !0x0 ! 0x1 +__ulonglong !0x0 ! 0x1 +int -0x0 - 0x0 +__uint -0x0 - 0x0 +char -0x0 - 0x0 +__uchar -0x0 - 0x0 +__longlong -0x0 - 0x0 +__ulonglong -0x0 - 0x0 +int !-0x1 ! 0x0 +xchar int !-0x1 ! 0x0 +int ~-0x1 ~ 0x0 +__uint ~-0x1 ~ 0x0 +char ~-0x1 ~ 0x0 +__uchar ~0xff ~ 0x0 +__longlong ~-0x1 ~ 0x0 +__ulonglong ~-0x1 ~ 0x0 +int !-0x1 ! 0x0 +__uint !-0x1 ! 0x0 +char !-0x1 ! 0x0 +__uchar !0xff ! 0x0 +__longlong !-0x1 ! 0x0 +__ulonglong !-0x1 ! 0x0 +int --0x1 - 0x1 +__uint --0x1 - 0x1 +char --0x1 - 0x1 +__uchar -0xff - 0x1 +__longlong --0x1 - 0x1 +__ulonglong --0x1 - 0x1 +int !0x1 ! 0x0 +xchar int !0x1 ! 0x0 +int ~0x1 ~ -0x2 +__uint ~0x1 ~ -0x2 +char ~0x1 ~ -0x2 +__uchar ~0x1 ~ 0xfe +__longlong ~0x1 ~ -0x2 +__ulonglong ~0x1 ~ -0x2 +int !0x1 ! 0x0 +__uint !0x1 ! 0x0 +char !0x1 ! 0x0 +__uchar !0x1 ! 0x0 +__longlong !0x1 ! 0x0 +__ulonglong !0x1 ! 0x0 +int -0x1 - -0x1 +__uint -0x1 - -0x1 +char -0x1 - -0x1 +__uchar -0x1 - 0xff +__longlong -0x1 - -0x1 +__ulonglong -0x1 - -0x1 +int !0x2 ! 0x0 +xchar int !0x2 ! 0x0 +int ~0x2 ~ -0x3 +__uint ~0x2 ~ -0x3 +char ~0x2 ~ -0x3 +__uchar ~0x2 ~ 0xfd +__longlong ~0x2 ~ -0x3 +__ulonglong ~0x2 ~ -0x3 +int !0x2 ! 0x0 +__uint !0x2 ! 0x0 +char !0x2 ! 0x0 +__uchar !0x2 ! 0x0 +__longlong !0x2 ! 0x0 +__ulonglong !0x2 ! 0x0 +int -0x2 - -0x2 +__uint -0x2 - -0x2 +char -0x2 - -0x2 +__uchar -0x2 - 0xfe +__longlong -0x2 - -0x2 +__ulonglong -0x2 - -0x2 +int !-0x2 ! 0x0 +xchar int !-0x2 ! 0x0 +int ~-0x2 ~ 0x1 +__uint ~-0x2 ~ 0x1 +char ~-0x2 ~ 0x1 +__uchar ~0xfe ~ 0x1 +__longlong ~-0x2 ~ 0x1 +__ulonglong ~-0x2 ~ 0x1 +int !-0x2 ! 0x0 +__uint !-0x2 ! 0x0 +char !-0x2 ! 0x0 +__uchar !0xfe ! 0x0 +__longlong !-0x2 ! 0x0 +__ulonglong !-0x2 ! 0x0 +int --0x2 - 0x2 +__uint --0x2 - 0x2 +char --0x2 - 0x2 +__uchar -0xfe - 0x2 +__longlong --0x2 - 0x2 +__ulonglong --0x2 - 0x2 +int !0x4 ! 0x0 +xchar int !0x4 ! 0x0 +int ~0x4 ~ -0x5 +__uint ~0x4 ~ -0x5 +char ~0x4 ~ -0x5 +__uchar ~0x4 ~ 0xfb +__longlong ~0x4 ~ -0x5 +__ulonglong ~0x4 ~ -0x5 +int !0x4 ! 0x0 +__uint !0x4 ! 0x0 +char !0x4 ! 0x0 +__uchar !0x4 ! 0x0 +__longlong !0x4 ! 0x0 +__ulonglong !0x4 ! 0x0 +int -0x4 - -0x4 +__uint -0x4 - -0x4 +char -0x4 - -0x4 +__uchar -0x4 - 0xfc +__longlong -0x4 - -0x4 +__ulonglong -0x4 - -0x4 +int !-0x4 ! 0x0 +xchar int !-0x4 ! 0x0 +int ~-0x4 ~ 0x3 +__uint ~-0x4 ~ 0x3 +char ~-0x4 ~ 0x3 +__uchar ~0xfc ~ 0x3 +__longlong ~-0x4 ~ 0x3 +__ulonglong ~-0x4 ~ 0x3 +int !-0x4 ! 0x0 +__uint !-0x4 ! 0x0 +char !-0x4 ! 0x0 +__uchar !0xfc ! 0x0 +__longlong !-0x4 ! 0x0 +__ulonglong !-0x4 ! 0x0 +int --0x4 - 0x4 +__uint --0x4 - 0x4 +char --0x4 - 0x4 +__uchar -0xfc - 0x4 +__longlong --0x4 - 0x4 +__ulonglong --0x4 - 0x4 +int !0xa ! 0x0 +xchar int !0xa ! 0x0 +int ~0xa ~ -0xb +__uint ~0xa ~ -0xb +char ~0xa ~ -0xb +__uchar ~0xa ~ 0xf5 +__longlong ~0xa ~ -0xb +__ulonglong ~0xa ~ -0xb +int !0xa ! 0x0 +__uint !0xa ! 0x0 +char !0xa ! 0x0 +__uchar !0xa ! 0x0 +__longlong !0xa ! 0x0 +__ulonglong !0xa ! 0x0 +int -0xa - -0xa +__uint -0xa - -0xa +char -0xa - -0xa +__uchar -0xa - 0xf6 +__longlong -0xa - -0xa +__ulonglong -0xa - -0xa +int !-0xa ! 0x0 +xchar int !-0xa ! 0x0 +int ~-0xa ~ 0x9 +__uint ~-0xa ~ 0x9 +char ~-0xa ~ 0x9 +__uchar ~0xf6 ~ 0x9 +__longlong ~-0xa ~ 0x9 +__ulonglong ~-0xa ~ 0x9 +int !-0xa ! 0x0 +__uint !-0xa ! 0x0 +char !-0xa ! 0x0 +__uchar !0xf6 ! 0x0 +__longlong !-0xa ! 0x0 +__ulonglong !-0xa ! 0x0 +int --0xa - 0xa +__uint --0xa - 0xa +char --0xa - 0xa +__uchar -0xf6 - 0xa +__longlong --0xa - 0xa +__ulonglong --0xa - 0xa +int !0x5 ! 0x0 +xchar int !0x5 ! 0x0 +int ~0x5 ~ -0x6 +__uint ~0x5 ~ -0x6 +char ~0x5 ~ -0x6 +__uchar ~0x5 ~ 0xfa +__longlong ~0x5 ~ -0x6 +__ulonglong ~0x5 ~ -0x6 +int !0x5 ! 0x0 +__uint !0x5 ! 0x0 +char !0x5 ! 0x0 +__uchar !0x5 ! 0x0 +__longlong !0x5 ! 0x0 +__ulonglong !0x5 ! 0x0 +int -0x5 - -0x5 +__uint -0x5 - -0x5 +char -0x5 - -0x5 +__uchar -0x5 - 0xfb +__longlong -0x5 - -0x5 +__ulonglong -0x5 - -0x5 +int !0x7 ! 0x0 +xchar int !0x7 ! 0x0 +int ~0x7 ~ -0x8 +__uint ~0x7 ~ -0x8 +char ~0x7 ~ -0x8 +__uchar ~0x7 ~ 0xf8 +__longlong ~0x7 ~ -0x8 +__ulonglong ~0x7 ~ -0x8 +int !0x7 ! 0x0 +__uint !0x7 ! 0x0 +char !0x7 ! 0x0 +__uchar !0x7 ! 0x0 +__longlong !0x7 ! 0x0 +__ulonglong !0x7 ! 0x0 +int -0x7 - -0x7 +__uint -0x7 - -0x7 +char -0x7 - -0x7 +__uchar -0x7 - 0xf9 +__longlong -0x7 - -0x7 +__ulonglong -0x7 - -0x7 +int !0x2a ! 0x0 +xchar int !0x2a ! 0x0 +int ~0x2a ~ -0x2b +__uint ~0x2a ~ -0x2b +char ~0x2a ~ -0x2b +__uchar ~0x2a ~ 0xd5 +__longlong ~0x2a ~ -0x2b +__ulonglong ~0x2a ~ -0x2b +int !0x2a ! 0x0 +__uint !0x2a ! 0x0 +char !0x2a ! 0x0 +__uchar !0x2a ! 0x0 +__longlong !0x2a ! 0x0 +__ulonglong !0x2a ! 0x0 +int -0x2a - -0x2a +__uint -0x2a - -0x2a +char -0x2a - -0x2a +__uchar -0x2a - 0xd6 +__longlong -0x2a - -0x2a +__ulonglong -0x2a - -0x2a +int !0x17 ! 0x0 +xchar int !0x17 ! 0x0 +int ~0x17 ~ -0x18 +__uint ~0x17 ~ -0x18 +char ~0x17 ~ -0x18 +__uchar ~0x17 ~ 0xe8 +__longlong ~0x17 ~ -0x18 +__ulonglong ~0x17 ~ -0x18 +int !0x17 ! 0x0 +__uint !0x17 ! 0x0 +char !0x17 ! 0x0 +__uchar !0x17 ! 0x0 +__longlong !0x17 ! 0x0 +__ulonglong !0x17 ! 0x0 +int -0x17 - -0x17 +__uint -0x17 - -0x17 +char -0x17 - -0x17 +__uchar -0x17 - 0xe9 +__longlong -0x17 - -0x17 +__ulonglong -0x17 - -0x17 +int !0x7fff ! 0x0 +xchar int !-0x1 ! 0x0 +int ~0x7fff ~ -0x8000 +__uint ~0x7fff ~ -0x8000 +char ~-0x1 ~ 0x0 +__uchar ~0xff ~ 0x0 +__longlong ~0x7fff ~ -0x8000 +__ulonglong ~0x7fff ~ -0x8000 +int !0x7fff ! 0x0 +__uint !0x7fff ! 0x0 +char !-0x1 ! 0x0 +__uchar !0xff ! 0x0 +__longlong !0x7fff ! 0x0 +__ulonglong !0x7fff ! 0x0 +int -0x7fff - -0x7fff +__uint -0x7fff - -0x7fff +char --0x1 - 0x1 +__uchar -0xff - 0x1 +__longlong -0x7fff - -0x7fff +__ulonglong -0x7fff - -0x7fff +int !-0x8000 ! 0x0 +xchar int !0x0 ! 0x1 +int ~-0x8000 ~ 0x7fff +__uint ~-0x8000 ~ 0x7fff +char ~0x0 ~ -0x1 +__uchar ~0x0 ~ 0xff +__longlong ~-0x8000 ~ 0x7fff +__ulonglong ~-0x8000 ~ 0x7fff +int !-0x8000 ! 0x0 +__uint !-0x8000 ! 0x0 +char !0x0 ! 0x1 +__uchar !0x0 ! 0x1 +__longlong !-0x8000 ! 0x0 +__ulonglong !-0x8000 ! 0x0 +int --0x8000 - -0x8000 +__uint --0x8000 - -0x8000 +char -0x0 - 0x0 +__uchar -0x0 - 0x0 +__longlong --0x8000 - -0x8000 +__ulonglong --0x8000 - -0x8000 +int !-0x3e8 ! 0x0 +xchar int !0x18 ! 0x0 +int ~-0x3e8 ~ 0x3e7 +__uint ~-0x3e8 ~ 0x3e7 +char ~0x18 ~ -0x19 +__uchar ~0x18 ~ 0xe7 +__longlong ~-0x3e8 ~ 0x3e7 +__ulonglong ~-0x3e8 ~ 0x3e7 +int !-0x3e8 ! 0x0 +__uint !-0x3e8 ! 0x0 +char !0x18 ! 0x0 +__uchar !0x18 ! 0x0 +__longlong !-0x3e8 ! 0x0 +__ulonglong !-0x3e8 ! 0x0 +int --0x3e8 - 0x3e8 +__uint --0x3e8 - 0x3e8 +char -0x18 - -0x18 +__uchar -0x18 - 0xe8 +__longlong --0x3e8 - 0x3e8 +__ulonglong --0x3e8 - 0x3e8 +int !-0x2710 ! 0x0 +xchar int !-0x10 ! 0x0 +int ~-0x2710 ~ 0x270f +__uint ~-0x2710 ~ 0x270f +char ~-0x10 ~ 0xf +__uchar ~0xf0 ~ 0xf +__longlong ~-0x2710 ~ 0x270f +__ulonglong ~-0x2710 ~ 0x270f +int !-0x2710 ! 0x0 +__uint !-0x2710 ! 0x0 +char !-0x10 ! 0x0 +__uchar !0xf0 ! 0x0 +__longlong !-0x2710 ! 0x0 +__ulonglong !-0x2710 ! 0x0 +int --0x2710 - 0x2710 +__uint --0x2710 - 0x2710 +char --0x10 - 0x10 +__uchar -0xf0 - 0x10 +__longlong --0x2710 - 0x2710 +__ulonglong --0x2710 - 0x2710 +int -0x0 - 0x0 +xchar int -0x0 - 0x0 +int ~0x0 ~ -0x1 +__uint ~0x0 ~ -0x1 +char ~0x0 ~ -0x1 +__uchar ~0x0 ~ 0xff +__longlong ~0x0 ~ -0x1 +__ulonglong ~0x0 ~ -0x1 +int !0x0 ! 0x1 +__uint !0x0 ! 0x1 +char !0x0 ! 0x1 +__uchar !0x0 ! 0x1 +__longlong !0x0 ! 0x1 +__ulonglong !0x0 ! 0x1 +int -0x0 - 0x0 +__uint -0x0 - 0x0 +char -0x0 - 0x0 +__uchar -0x0 - 0x0 +__longlong -0x0 - 0x0 +__ulonglong -0x0 - 0x0 +int --0x1 - 0x1 +xchar int --0x1 - 0x1 +int ~-0x1 ~ 0x0 +__uint ~-0x1 ~ 0x0 +char ~-0x1 ~ 0x0 +__uchar ~0xff ~ 0x0 +__longlong ~-0x1 ~ 0x0 +__ulonglong ~-0x1 ~ 0x0 +int !-0x1 ! 0x0 +__uint !-0x1 ! 0x0 +char !-0x1 ! 0x0 +__uchar !0xff ! 0x0 +__longlong !-0x1 ! 0x0 +__ulonglong !-0x1 ! 0x0 +int --0x1 - 0x1 +__uint --0x1 - 0x1 +char --0x1 - 0x1 +__uchar -0xff - 0x1 +__longlong --0x1 - 0x1 +__ulonglong --0x1 - 0x1 +int -0x1 - -0x1 +xchar int -0x1 - -0x1 +int ~0x1 ~ -0x2 +__uint ~0x1 ~ -0x2 +char ~0x1 ~ -0x2 +__uchar ~0x1 ~ 0xfe +__longlong ~0x1 ~ -0x2 +__ulonglong ~0x1 ~ -0x2 +int !0x1 ! 0x0 +__uint !0x1 ! 0x0 +char !0x1 ! 0x0 +__uchar !0x1 ! 0x0 +__longlong !0x1 ! 0x0 +__ulonglong !0x1 ! 0x0 +int -0x1 - -0x1 +__uint -0x1 - -0x1 +char -0x1 - -0x1 +__uchar -0x1 - 0xff +__longlong -0x1 - -0x1 +__ulonglong -0x1 - -0x1 +int -0x2 - -0x2 +xchar int -0x2 - -0x2 +int ~0x2 ~ -0x3 +__uint ~0x2 ~ -0x3 +char ~0x2 ~ -0x3 +__uchar ~0x2 ~ 0xfd +__longlong ~0x2 ~ -0x3 +__ulonglong ~0x2 ~ -0x3 +int !0x2 ! 0x0 +__uint !0x2 ! 0x0 +char !0x2 ! 0x0 +__uchar !0x2 ! 0x0 +__longlong !0x2 ! 0x0 +__ulonglong !0x2 ! 0x0 +int -0x2 - -0x2 +__uint -0x2 - -0x2 +char -0x2 - -0x2 +__uchar -0x2 - 0xfe +__longlong -0x2 - -0x2 +__ulonglong -0x2 - -0x2 +int --0x2 - 0x2 +xchar int --0x2 - 0x2 +int ~-0x2 ~ 0x1 +__uint ~-0x2 ~ 0x1 +char ~-0x2 ~ 0x1 +__uchar ~0xfe ~ 0x1 +__longlong ~-0x2 ~ 0x1 +__ulonglong ~-0x2 ~ 0x1 +int !-0x2 ! 0x0 +__uint !-0x2 ! 0x0 +char !-0x2 ! 0x0 +__uchar !0xfe ! 0x0 +__longlong !-0x2 ! 0x0 +__ulonglong !-0x2 ! 0x0 +int --0x2 - 0x2 +__uint --0x2 - 0x2 +char --0x2 - 0x2 +__uchar -0xfe - 0x2 +__longlong --0x2 - 0x2 +__ulonglong --0x2 - 0x2 +int -0x4 - -0x4 +xchar int -0x4 - -0x4 +int ~0x4 ~ -0x5 +__uint ~0x4 ~ -0x5 +char ~0x4 ~ -0x5 +__uchar ~0x4 ~ 0xfb +__longlong ~0x4 ~ -0x5 +__ulonglong ~0x4 ~ -0x5 +int !0x4 ! 0x0 +__uint !0x4 ! 0x0 +char !0x4 ! 0x0 +__uchar !0x4 ! 0x0 +__longlong !0x4 ! 0x0 +__ulonglong !0x4 ! 0x0 +int -0x4 - -0x4 +__uint -0x4 - -0x4 +char -0x4 - -0x4 +__uchar -0x4 - 0xfc +__longlong -0x4 - -0x4 +__ulonglong -0x4 - -0x4 +int --0x4 - 0x4 +xchar int --0x4 - 0x4 +int ~-0x4 ~ 0x3 +__uint ~-0x4 ~ 0x3 +char ~-0x4 ~ 0x3 +__uchar ~0xfc ~ 0x3 +__longlong ~-0x4 ~ 0x3 +__ulonglong ~-0x4 ~ 0x3 +int !-0x4 ! 0x0 +__uint !-0x4 ! 0x0 +char !-0x4 ! 0x0 +__uchar !0xfc ! 0x0 +__longlong !-0x4 ! 0x0 +__ulonglong !-0x4 ! 0x0 +int --0x4 - 0x4 +__uint --0x4 - 0x4 +char --0x4 - 0x4 +__uchar -0xfc - 0x4 +__longlong --0x4 - 0x4 +__ulonglong --0x4 - 0x4 +int -0xa - -0xa +xchar int -0xa - -0xa +int ~0xa ~ -0xb +__uint ~0xa ~ -0xb +char ~0xa ~ -0xb +__uchar ~0xa ~ 0xf5 +__longlong ~0xa ~ -0xb +__ulonglong ~0xa ~ -0xb +int !0xa ! 0x0 +__uint !0xa ! 0x0 +char !0xa ! 0x0 +__uchar !0xa ! 0x0 +__longlong !0xa ! 0x0 +__ulonglong !0xa ! 0x0 +int -0xa - -0xa +__uint -0xa - -0xa +char -0xa - -0xa +__uchar -0xa - 0xf6 +__longlong -0xa - -0xa +__ulonglong -0xa - -0xa +int --0xa - 0xa +xchar int --0xa - 0xa +int ~-0xa ~ 0x9 +__uint ~-0xa ~ 0x9 +char ~-0xa ~ 0x9 +__uchar ~0xf6 ~ 0x9 +__longlong ~-0xa ~ 0x9 +__ulonglong ~-0xa ~ 0x9 +int !-0xa ! 0x0 +__uint !-0xa ! 0x0 +char !-0xa ! 0x0 +__uchar !0xf6 ! 0x0 +__longlong !-0xa ! 0x0 +__ulonglong !-0xa ! 0x0 +int --0xa - 0xa +__uint --0xa - 0xa +char --0xa - 0xa +__uchar -0xf6 - 0xa +__longlong --0xa - 0xa +__ulonglong --0xa - 0xa +int -0x5 - -0x5 +xchar int -0x5 - -0x5 +int ~0x5 ~ -0x6 +__uint ~0x5 ~ -0x6 +char ~0x5 ~ -0x6 +__uchar ~0x5 ~ 0xfa +__longlong ~0x5 ~ -0x6 +__ulonglong ~0x5 ~ -0x6 +int !0x5 ! 0x0 +__uint !0x5 ! 0x0 +char !0x5 ! 0x0 +__uchar !0x5 ! 0x0 +__longlong !0x5 ! 0x0 +__ulonglong !0x5 ! 0x0 +int -0x5 - -0x5 +__uint -0x5 - -0x5 +char -0x5 - -0x5 +__uchar -0x5 - 0xfb +__longlong -0x5 - -0x5 +__ulonglong -0x5 - -0x5 +int -0x7 - -0x7 +xchar int -0x7 - -0x7 +int ~0x7 ~ -0x8 +__uint ~0x7 ~ -0x8 +char ~0x7 ~ -0x8 +__uchar ~0x7 ~ 0xf8 +__longlong ~0x7 ~ -0x8 +__ulonglong ~0x7 ~ -0x8 +int !0x7 ! 0x0 +__uint !0x7 ! 0x0 +char !0x7 ! 0x0 +__uchar !0x7 ! 0x0 +__longlong !0x7 ! 0x0 +__ulonglong !0x7 ! 0x0 +int -0x7 - -0x7 +__uint -0x7 - -0x7 +char -0x7 - -0x7 +__uchar -0x7 - 0xf9 +__longlong -0x7 - -0x7 +__ulonglong -0x7 - -0x7 +int -0x2a - -0x2a +xchar int -0x2a - -0x2a +int ~0x2a ~ -0x2b +__uint ~0x2a ~ -0x2b +char ~0x2a ~ -0x2b +__uchar ~0x2a ~ 0xd5 +__longlong ~0x2a ~ -0x2b +__ulonglong ~0x2a ~ -0x2b +int !0x2a ! 0x0 +__uint !0x2a ! 0x0 +char !0x2a ! 0x0 +__uchar !0x2a ! 0x0 +__longlong !0x2a ! 0x0 +__ulonglong !0x2a ! 0x0 +int -0x2a - -0x2a +__uint -0x2a - -0x2a +char -0x2a - -0x2a +__uchar -0x2a - 0xd6 +__longlong -0x2a - -0x2a +__ulonglong -0x2a - -0x2a +int -0x17 - -0x17 +xchar int -0x17 - -0x17 +int ~0x17 ~ -0x18 +__uint ~0x17 ~ -0x18 +char ~0x17 ~ -0x18 +__uchar ~0x17 ~ 0xe8 +__longlong ~0x17 ~ -0x18 +__ulonglong ~0x17 ~ -0x18 +int !0x17 ! 0x0 +__uint !0x17 ! 0x0 +char !0x17 ! 0x0 +__uchar !0x17 ! 0x0 +__longlong !0x17 ! 0x0 +__ulonglong !0x17 ! 0x0 +int -0x17 - -0x17 +__uint -0x17 - -0x17 +char -0x17 - -0x17 +__uchar -0x17 - 0xe9 +__longlong -0x17 - -0x17 +__ulonglong -0x17 - -0x17 +int -0x7fff - -0x7fff +xchar int --0x1 - 0x1 +int ~0x7fff ~ -0x8000 +__uint ~0x7fff ~ -0x8000 +char ~-0x1 ~ 0x0 +__uchar ~0xff ~ 0x0 +__longlong ~0x7fff ~ -0x8000 +__ulonglong ~0x7fff ~ -0x8000 +int !0x7fff ! 0x0 +__uint !0x7fff ! 0x0 +char !-0x1 ! 0x0 +__uchar !0xff ! 0x0 +__longlong !0x7fff ! 0x0 +__ulonglong !0x7fff ! 0x0 +int -0x7fff - -0x7fff +__uint -0x7fff - -0x7fff +char --0x1 - 0x1 +__uchar -0xff - 0x1 +__longlong -0x7fff - -0x7fff +__ulonglong -0x7fff - -0x7fff +int --0x8000 - -0x8000 +xchar int -0x0 - 0x0 +int ~-0x8000 ~ 0x7fff +__uint ~-0x8000 ~ 0x7fff +char ~0x0 ~ -0x1 +__uchar ~0x0 ~ 0xff +__longlong ~-0x8000 ~ 0x7fff +__ulonglong ~-0x8000 ~ 0x7fff +int !-0x8000 ! 0x0 +__uint !-0x8000 ! 0x0 +char !0x0 ! 0x1 +__uchar !0x0 ! 0x1 +__longlong !-0x8000 ! 0x0 +__ulonglong !-0x8000 ! 0x0 +int --0x8000 - -0x8000 +__uint --0x8000 - -0x8000 +char -0x0 - 0x0 +__uchar -0x0 - 0x0 +__longlong --0x8000 - -0x8000 +__ulonglong --0x8000 - -0x8000 +int --0x3e8 - 0x3e8 +xchar int -0x18 - -0x18 +int ~-0x3e8 ~ 0x3e7 +__uint ~-0x3e8 ~ 0x3e7 +char ~0x18 ~ -0x19 +__uchar ~0x18 ~ 0xe7 +__longlong ~-0x3e8 ~ 0x3e7 +__ulonglong ~-0x3e8 ~ 0x3e7 +int !-0x3e8 ! 0x0 +__uint !-0x3e8 ! 0x0 +char !0x18 ! 0x0 +__uchar !0x18 ! 0x0 +__longlong !-0x3e8 ! 0x0 +__ulonglong !-0x3e8 ! 0x0 +int --0x3e8 - 0x3e8 +__uint --0x3e8 - 0x3e8 +char -0x18 - -0x18 +__uchar -0x18 - 0xe8 +__longlong --0x3e8 - 0x3e8 +__ulonglong --0x3e8 - 0x3e8 +int --0x2710 - 0x2710 +xchar int --0x10 - 0x10 +int ~-0x2710 ~ 0x270f +__uint ~-0x2710 ~ 0x270f +char ~-0x10 ~ 0xf +__uchar ~0xf0 ~ 0xf +__longlong ~-0x2710 ~ 0x270f +__ulonglong ~-0x2710 ~ 0x270f +int !-0x2710 ! 0x0 +__uint !-0x2710 ! 0x0 +char !-0x10 ! 0x0 +__uchar !0xf0 ! 0x0 +__longlong !-0x2710 ! 0x0 +__ulonglong !-0x2710 ! 0x0 +int --0x2710 - 0x2710 +__uint --0x2710 - 0x2710 +char --0x10 - 0x10 +__uchar -0xf0 - 0x10 +__longlong --0x2710 - 0x2710 +__ulonglong --0x2710 - 0x2710 +0x0,0x5,0x4,0x3,0x2, +int 0x0 || 0x0 == 0x0 (0x0) +__uint 0x0 || 0x0 == 0x0 (0x0) +char 0x0 || 0x0 == 0x0 (0x0) +__uchar 0x0 || 0x0 == 0x0 (0x0) +__longlong 0x0 || 0x0 == 0x0 (0x0) +__ulonglong 0x0 || 0x0 == 0x0 (0x0) +int 0x0 && 0x0 == 0x0 (0x0) +__uint 0x0 && 0x0 == 0x0 (0x0) +char 0x0 && 0x0 == 0x0 (0x0) +__uchar 0x0 && 0x0 == 0x0 (0x0) +__longlong 0x0 && 0x0 == 0x0 (0x0) +__ulonglong 0x0 && 0x0 == 0x0 (0x0) +int 0x0 || 0x1 == 0x1 (0x1) +__uint 0x0 || 0x1 == 0x1 (0x1) +char 0x0 || 0x1 == 0x1 (0x1) +__uchar 0x0 || 0x1 == 0x1 (0x1) +__longlong 0x0 || 0x1 == 0x1 (0x1) +__ulonglong 0x0 || 0x1 == 0x1 (0x1) +int 0x0 && 0x1 == 0x0 (0x0) +__uint 0x0 && 0x1 == 0x0 (0x0) +char 0x0 && 0x1 == 0x0 (0x0) +__uchar 0x0 && 0x1 == 0x0 (0x0) +__longlong 0x0 && 0x1 == 0x0 (0x0) +__ulonglong 0x0 && 0x1 == 0x0 (0x0) +int 0x0 || 0xffff == 0x1 (0x1) +__uint 0x0 || 0xffff == 0x1 (0x1) +char 0x0 || 0xffff == 0x1 (0x1) +__uchar 0x0 || 0xff == 0x1 (0x1) +__longlong 0x0 || 0xffff == 0x1 (0x1) +__ulonglong 0x0 || 0xffff == 0x1 (0x1) +int 0x0 && 0xffff == 0x0 (0x0) +__uint 0x0 && 0xffff == 0x0 (0x0) +char 0x0 && 0xffff == 0x0 (0x0) +__uchar 0x0 && 0xff == 0x0 (0x0) +__longlong 0x0 && 0xffff == 0x0 (0x0) +__ulonglong 0x0 && 0xffff == 0x0 (0x0) +int 0x0 || 0x2a == 0x1 (0x1) +__uint 0x0 || 0x2a == 0x1 (0x1) +char 0x0 || 0x2a == 0x1 (0x1) +__uchar 0x0 || 0x2a == 0x1 (0x1) +__longlong 0x0 || 0x2a == 0x1 (0x1) +__ulonglong 0x0 || 0x2a == 0x1 (0x1) +int 0x0 && 0x2a == 0x0 (0x0) +__uint 0x0 && 0x2a == 0x0 (0x0) +char 0x0 && 0x2a == 0x0 (0x0) +__uchar 0x0 && 0x2a == 0x0 (0x0) +__longlong 0x0 && 0x2a == 0x0 (0x0) +__ulonglong 0x0 && 0x2a == 0x0 (0x0) +int 0x0 || 0x17 == 0x1 (0x1) +__uint 0x0 || 0x17 == 0x1 (0x1) +char 0x0 || 0x17 == 0x1 (0x1) +__uchar 0x0 || 0x17 == 0x1 (0x1) +__longlong 0x0 || 0x17 == 0x1 (0x1) +__ulonglong 0x0 || 0x17 == 0x1 (0x1) +int 0x0 && 0x17 == 0x0 (0x0) +__uint 0x0 && 0x17 == 0x0 (0x0) +char 0x0 && 0x17 == 0x0 (0x0) +__uchar 0x0 && 0x17 == 0x0 (0x0) +__longlong 0x0 && 0x17 == 0x0 (0x0) +__ulonglong 0x0 && 0x17 == 0x0 (0x0) +int 0x0 || 0x7fff == 0x1 (0x1) +__uint 0x0 || 0x7fff == 0x1 (0x1) +char 0x0 || 0xffff == 0x1 (0x1) +__uchar 0x0 || 0xff == 0x1 (0x1) +__longlong 0x0 || 0x7fff == 0x1 (0x1) +__ulonglong 0x0 || 0x7fff == 0x1 (0x1) +int 0x0 && 0x7fff == 0x0 (0x0) +__uint 0x0 && 0x7fff == 0x0 (0x0) +char 0x0 && 0xffff == 0x0 (0x0) +__uchar 0x0 && 0xff == 0x0 (0x0) +__longlong 0x0 && 0x7fff == 0x0 (0x0) +__ulonglong 0x0 && 0x7fff == 0x0 (0x0) +int 0x0 || 0x8000 == 0x1 (0x1) +__uint 0x0 || 0x8000 == 0x1 (0x1) +char 0x0 || 0x0 == 0x0 (0x0) +__uchar 0x0 || 0x0 == 0x0 (0x0) +__longlong 0x0 || 0x8000 == 0x1 (0x1) +__ulonglong 0x0 || 0x8000 == 0x1 (0x1) +int 0x0 && 0x8000 == 0x0 (0x0) +__uint 0x0 && 0x8000 == 0x0 (0x0) +char 0x0 && 0x0 == 0x0 (0x0) +__uchar 0x0 && 0x0 == 0x0 (0x0) +__longlong 0x0 && 0x8000 == 0x0 (0x0) +__ulonglong 0x0 && 0x8000 == 0x0 (0x0) +int 0x1 || 0x0 == 0x1 (0x1) +__uint 0x1 || 0x0 == 0x1 (0x1) +char 0x1 || 0x0 == 0x1 (0x1) +__uchar 0x1 || 0x0 == 0x1 (0x1) +__longlong 0x1 || 0x0 == 0x1 (0x1) +__ulonglong 0x1 || 0x0 == 0x1 (0x1) +int 0x1 && 0x0 == 0x0 (0x0) +__uint 0x1 && 0x0 == 0x0 (0x0) +char 0x1 && 0x0 == 0x0 (0x0) +__uchar 0x1 && 0x0 == 0x0 (0x0) +__longlong 0x1 && 0x0 == 0x0 (0x0) +__ulonglong 0x1 && 0x0 == 0x0 (0x0) +int 0x1 || 0x1 == 0x1 (0x1) +__uint 0x1 || 0x1 == 0x1 (0x1) +char 0x1 || 0x1 == 0x1 (0x1) +__uchar 0x1 || 0x1 == 0x1 (0x1) +__longlong 0x1 || 0x1 == 0x1 (0x1) +__ulonglong 0x1 || 0x1 == 0x1 (0x1) +int 0x1 && 0x1 == 0x1 (0x1) +__uint 0x1 && 0x1 == 0x1 (0x1) +char 0x1 && 0x1 == 0x1 (0x1) +__uchar 0x1 && 0x1 == 0x1 (0x1) +__longlong 0x1 && 0x1 == 0x1 (0x1) +__ulonglong 0x1 && 0x1 == 0x1 (0x1) +int 0x1 || 0xffff == 0x1 (0x1) +__uint 0x1 || 0xffff == 0x1 (0x1) +char 0x1 || 0xffff == 0x1 (0x1) +__uchar 0x1 || 0xff == 0x1 (0x1) +__longlong 0x1 || 0xffff == 0x1 (0x1) +__ulonglong 0x1 || 0xffff == 0x1 (0x1) +int 0x1 && 0xffff == 0x1 (0x1) +__uint 0x1 && 0xffff == 0x1 (0x1) +char 0x1 && 0xffff == 0x1 (0x1) +__uchar 0x1 && 0xff == 0x1 (0x1) +__longlong 0x1 && 0xffff == 0x1 (0x1) +__ulonglong 0x1 && 0xffff == 0x1 (0x1) +int 0x1 || 0x2a == 0x1 (0x1) +__uint 0x1 || 0x2a == 0x1 (0x1) +char 0x1 || 0x2a == 0x1 (0x1) +__uchar 0x1 || 0x2a == 0x1 (0x1) +__longlong 0x1 || 0x2a == 0x1 (0x1) +__ulonglong 0x1 || 0x2a == 0x1 (0x1) +int 0x1 && 0x2a == 0x1 (0x1) +__uint 0x1 && 0x2a == 0x1 (0x1) +char 0x1 && 0x2a == 0x1 (0x1) +__uchar 0x1 && 0x2a == 0x1 (0x1) +__longlong 0x1 && 0x2a == 0x1 (0x1) +__ulonglong 0x1 && 0x2a == 0x1 (0x1) +int 0x1 || 0x17 == 0x1 (0x1) +__uint 0x1 || 0x17 == 0x1 (0x1) +char 0x1 || 0x17 == 0x1 (0x1) +__uchar 0x1 || 0x17 == 0x1 (0x1) +__longlong 0x1 || 0x17 == 0x1 (0x1) +__ulonglong 0x1 || 0x17 == 0x1 (0x1) +int 0x1 && 0x17 == 0x1 (0x1) +__uint 0x1 && 0x17 == 0x1 (0x1) +char 0x1 && 0x17 == 0x1 (0x1) +__uchar 0x1 && 0x17 == 0x1 (0x1) +__longlong 0x1 && 0x17 == 0x1 (0x1) +__ulonglong 0x1 && 0x17 == 0x1 (0x1) +int 0x1 || 0x7fff == 0x1 (0x1) +__uint 0x1 || 0x7fff == 0x1 (0x1) +char 0x1 || 0xffff == 0x1 (0x1) +__uchar 0x1 || 0xff == 0x1 (0x1) +__longlong 0x1 || 0x7fff == 0x1 (0x1) +__ulonglong 0x1 || 0x7fff == 0x1 (0x1) +int 0x1 && 0x7fff == 0x1 (0x1) +__uint 0x1 && 0x7fff == 0x1 (0x1) +char 0x1 && 0xffff == 0x1 (0x1) +__uchar 0x1 && 0xff == 0x1 (0x1) +__longlong 0x1 && 0x7fff == 0x1 (0x1) +__ulonglong 0x1 && 0x7fff == 0x1 (0x1) +int 0x1 || 0x8000 == 0x1 (0x1) +__uint 0x1 || 0x8000 == 0x1 (0x1) +char 0x1 || 0x0 == 0x1 (0x1) +__uchar 0x1 || 0x0 == 0x1 (0x1) +__longlong 0x1 || 0x8000 == 0x1 (0x1) +__ulonglong 0x1 || 0x8000 == 0x1 (0x1) +int 0x1 && 0x8000 == 0x1 (0x1) +__uint 0x1 && 0x8000 == 0x1 (0x1) +char 0x1 && 0x0 == 0x0 (0x0) +__uchar 0x1 && 0x0 == 0x0 (0x0) +__longlong 0x1 && 0x8000 == 0x1 (0x1) +__ulonglong 0x1 && 0x8000 == 0x1 (0x1) +int 0xffff || 0x0 == 0x1 (0x1) +__uint 0xffff || 0x0 == 0x1 (0x1) +char 0xffff || 0x0 == 0x1 (0x1) +__uchar 0xff || 0x0 == 0x1 (0x1) +__longlong 0xffff || 0x0 == 0x1 (0x1) +__ulonglong 0xffff || 0x0 == 0x1 (0x1) +int 0xffff && 0x0 == 0x0 (0x0) +__uint 0xffff && 0x0 == 0x0 (0x0) +char 0xffff && 0x0 == 0x0 (0x0) +__uchar 0xff && 0x0 == 0x0 (0x0) +__longlong 0xffff && 0x0 == 0x0 (0x0) +__ulonglong 0xffff && 0x0 == 0x0 (0x0) +int 0xffff || 0x1 == 0x1 (0x1) +__uint 0xffff || 0x1 == 0x1 (0x1) +char 0xffff || 0x1 == 0x1 (0x1) +__uchar 0xff || 0x1 == 0x1 (0x1) +__longlong 0xffff || 0x1 == 0x1 (0x1) +__ulonglong 0xffff || 0x1 == 0x1 (0x1) +int 0xffff && 0x1 == 0x1 (0x1) +__uint 0xffff && 0x1 == 0x1 (0x1) +char 0xffff && 0x1 == 0x1 (0x1) +__uchar 0xff && 0x1 == 0x1 (0x1) +__longlong 0xffff && 0x1 == 0x1 (0x1) +__ulonglong 0xffff && 0x1 == 0x1 (0x1) +int 0xffff || 0xffff == 0x1 (0x1) +__uint 0xffff || 0xffff == 0x1 (0x1) +char 0xffff || 0xffff == 0x1 (0x1) +__uchar 0xff || 0xff == 0x1 (0x1) +__longlong 0xffff || 0xffff == 0x1 (0x1) +__ulonglong 0xffff || 0xffff == 0x1 (0x1) +int 0xffff && 0xffff == 0x1 (0x1) +__uint 0xffff && 0xffff == 0x1 (0x1) +char 0xffff && 0xffff == 0x1 (0x1) +__uchar 0xff && 0xff == 0x1 (0x1) +__longlong 0xffff && 0xffff == 0x1 (0x1) +__ulonglong 0xffff && 0xffff == 0x1 (0x1) +int 0xffff || 0x2a == 0x1 (0x1) +__uint 0xffff || 0x2a == 0x1 (0x1) +char 0xffff || 0x2a == 0x1 (0x1) +__uchar 0xff || 0x2a == 0x1 (0x1) +__longlong 0xffff || 0x2a == 0x1 (0x1) +__ulonglong 0xffff || 0x2a == 0x1 (0x1) +int 0xffff && 0x2a == 0x1 (0x1) +__uint 0xffff && 0x2a == 0x1 (0x1) +char 0xffff && 0x2a == 0x1 (0x1) +__uchar 0xff && 0x2a == 0x1 (0x1) +__longlong 0xffff && 0x2a == 0x1 (0x1) +__ulonglong 0xffff && 0x2a == 0x1 (0x1) +int 0xffff || 0x17 == 0x1 (0x1) +__uint 0xffff || 0x17 == 0x1 (0x1) +char 0xffff || 0x17 == 0x1 (0x1) +__uchar 0xff || 0x17 == 0x1 (0x1) +__longlong 0xffff || 0x17 == 0x1 (0x1) +__ulonglong 0xffff || 0x17 == 0x1 (0x1) +int 0xffff && 0x17 == 0x1 (0x1) +__uint 0xffff && 0x17 == 0x1 (0x1) +char 0xffff && 0x17 == 0x1 (0x1) +__uchar 0xff && 0x17 == 0x1 (0x1) +__longlong 0xffff && 0x17 == 0x1 (0x1) +__ulonglong 0xffff && 0x17 == 0x1 (0x1) +int 0xffff || 0x7fff == 0x1 (0x1) +__uint 0xffff || 0x7fff == 0x1 (0x1) +char 0xffff || 0xffff == 0x1 (0x1) +__uchar 0xff || 0xff == 0x1 (0x1) +__longlong 0xffff || 0x7fff == 0x1 (0x1) +__ulonglong 0xffff || 0x7fff == 0x1 (0x1) +int 0xffff && 0x7fff == 0x1 (0x1) +__uint 0xffff && 0x7fff == 0x1 (0x1) +char 0xffff && 0xffff == 0x1 (0x1) +__uchar 0xff && 0xff == 0x1 (0x1) +__longlong 0xffff && 0x7fff == 0x1 (0x1) +__ulonglong 0xffff && 0x7fff == 0x1 (0x1) +int 0xffff || 0x8000 == 0x1 (0x1) +__uint 0xffff || 0x8000 == 0x1 (0x1) +char 0xffff || 0x0 == 0x1 (0x1) +__uchar 0xff || 0x0 == 0x1 (0x1) +__longlong 0xffff || 0x8000 == 0x1 (0x1) +__ulonglong 0xffff || 0x8000 == 0x1 (0x1) +int 0xffff && 0x8000 == 0x1 (0x1) +__uint 0xffff && 0x8000 == 0x1 (0x1) +char 0xffff && 0x0 == 0x0 (0x0) +__uchar 0xff && 0x0 == 0x0 (0x0) +__longlong 0xffff && 0x8000 == 0x1 (0x1) +__ulonglong 0xffff && 0x8000 == 0x1 (0x1) +int 0x2a || 0x0 == 0x1 (0x1) +__uint 0x2a || 0x0 == 0x1 (0x1) +char 0x2a || 0x0 == 0x1 (0x1) +__uchar 0x2a || 0x0 == 0x1 (0x1) +__longlong 0x2a || 0x0 == 0x1 (0x1) +__ulonglong 0x2a || 0x0 == 0x1 (0x1) +int 0x2a && 0x0 == 0x0 (0x0) +__uint 0x2a && 0x0 == 0x0 (0x0) +char 0x2a && 0x0 == 0x0 (0x0) +__uchar 0x2a && 0x0 == 0x0 (0x0) +__longlong 0x2a && 0x0 == 0x0 (0x0) +__ulonglong 0x2a && 0x0 == 0x0 (0x0) +int 0x2a || 0x1 == 0x1 (0x1) +__uint 0x2a || 0x1 == 0x1 (0x1) +char 0x2a || 0x1 == 0x1 (0x1) +__uchar 0x2a || 0x1 == 0x1 (0x1) +__longlong 0x2a || 0x1 == 0x1 (0x1) +__ulonglong 0x2a || 0x1 == 0x1 (0x1) +int 0x2a && 0x1 == 0x1 (0x1) +__uint 0x2a && 0x1 == 0x1 (0x1) +char 0x2a && 0x1 == 0x1 (0x1) +__uchar 0x2a && 0x1 == 0x1 (0x1) +__longlong 0x2a && 0x1 == 0x1 (0x1) +__ulonglong 0x2a && 0x1 == 0x1 (0x1) +int 0x2a || 0xffff == 0x1 (0x1) +__uint 0x2a || 0xffff == 0x1 (0x1) +char 0x2a || 0xffff == 0x1 (0x1) +__uchar 0x2a || 0xff == 0x1 (0x1) +__longlong 0x2a || 0xffff == 0x1 (0x1) +__ulonglong 0x2a || 0xffff == 0x1 (0x1) +int 0x2a && 0xffff == 0x1 (0x1) +__uint 0x2a && 0xffff == 0x1 (0x1) +char 0x2a && 0xffff == 0x1 (0x1) +__uchar 0x2a && 0xff == 0x1 (0x1) +__longlong 0x2a && 0xffff == 0x1 (0x1) +__ulonglong 0x2a && 0xffff == 0x1 (0x1) +int 0x2a || 0x2a == 0x1 (0x1) +__uint 0x2a || 0x2a == 0x1 (0x1) +char 0x2a || 0x2a == 0x1 (0x1) +__uchar 0x2a || 0x2a == 0x1 (0x1) +__longlong 0x2a || 0x2a == 0x1 (0x1) +__ulonglong 0x2a || 0x2a == 0x1 (0x1) +int 0x2a && 0x2a == 0x1 (0x1) +__uint 0x2a && 0x2a == 0x1 (0x1) +char 0x2a && 0x2a == 0x1 (0x1) +__uchar 0x2a && 0x2a == 0x1 (0x1) +__longlong 0x2a && 0x2a == 0x1 (0x1) +__ulonglong 0x2a && 0x2a == 0x1 (0x1) +int 0x2a || 0x17 == 0x1 (0x1) +__uint 0x2a || 0x17 == 0x1 (0x1) +char 0x2a || 0x17 == 0x1 (0x1) +__uchar 0x2a || 0x17 == 0x1 (0x1) +__longlong 0x2a || 0x17 == 0x1 (0x1) +__ulonglong 0x2a || 0x17 == 0x1 (0x1) +int 0x2a && 0x17 == 0x1 (0x1) +__uint 0x2a && 0x17 == 0x1 (0x1) +char 0x2a && 0x17 == 0x1 (0x1) +__uchar 0x2a && 0x17 == 0x1 (0x1) +__longlong 0x2a && 0x17 == 0x1 (0x1) +__ulonglong 0x2a && 0x17 == 0x1 (0x1) +int 0x2a || 0x7fff == 0x1 (0x1) +__uint 0x2a || 0x7fff == 0x1 (0x1) +char 0x2a || 0xffff == 0x1 (0x1) +__uchar 0x2a || 0xff == 0x1 (0x1) +__longlong 0x2a || 0x7fff == 0x1 (0x1) +__ulonglong 0x2a || 0x7fff == 0x1 (0x1) +int 0x2a && 0x7fff == 0x1 (0x1) +__uint 0x2a && 0x7fff == 0x1 (0x1) +char 0x2a && 0xffff == 0x1 (0x1) +__uchar 0x2a && 0xff == 0x1 (0x1) +__longlong 0x2a && 0x7fff == 0x1 (0x1) +__ulonglong 0x2a && 0x7fff == 0x1 (0x1) +int 0x2a || 0x8000 == 0x1 (0x1) +__uint 0x2a || 0x8000 == 0x1 (0x1) +char 0x2a || 0x0 == 0x1 (0x1) +__uchar 0x2a || 0x0 == 0x1 (0x1) +__longlong 0x2a || 0x8000 == 0x1 (0x1) +__ulonglong 0x2a || 0x8000 == 0x1 (0x1) +int 0x2a && 0x8000 == 0x1 (0x1) +__uint 0x2a && 0x8000 == 0x1 (0x1) +char 0x2a && 0x0 == 0x0 (0x0) +__uchar 0x2a && 0x0 == 0x0 (0x0) +__longlong 0x2a && 0x8000 == 0x1 (0x1) +__ulonglong 0x2a && 0x8000 == 0x1 (0x1) +int 0x17 || 0x0 == 0x1 (0x1) +__uint 0x17 || 0x0 == 0x1 (0x1) +char 0x17 || 0x0 == 0x1 (0x1) +__uchar 0x17 || 0x0 == 0x1 (0x1) +__longlong 0x17 || 0x0 == 0x1 (0x1) +__ulonglong 0x17 || 0x0 == 0x1 (0x1) +int 0x17 && 0x0 == 0x0 (0x0) +__uint 0x17 && 0x0 == 0x0 (0x0) +char 0x17 && 0x0 == 0x0 (0x0) +__uchar 0x17 && 0x0 == 0x0 (0x0) +__longlong 0x17 && 0x0 == 0x0 (0x0) +__ulonglong 0x17 && 0x0 == 0x0 (0x0) +int 0x17 || 0x1 == 0x1 (0x1) +__uint 0x17 || 0x1 == 0x1 (0x1) +char 0x17 || 0x1 == 0x1 (0x1) +__uchar 0x17 || 0x1 == 0x1 (0x1) +__longlong 0x17 || 0x1 == 0x1 (0x1) +__ulonglong 0x17 || 0x1 == 0x1 (0x1) +int 0x17 && 0x1 == 0x1 (0x1) +__uint 0x17 && 0x1 == 0x1 (0x1) +char 0x17 && 0x1 == 0x1 (0x1) +__uchar 0x17 && 0x1 == 0x1 (0x1) +__longlong 0x17 && 0x1 == 0x1 (0x1) +__ulonglong 0x17 && 0x1 == 0x1 (0x1) +int 0x17 || 0xffff == 0x1 (0x1) +__uint 0x17 || 0xffff == 0x1 (0x1) +char 0x17 || 0xffff == 0x1 (0x1) +__uchar 0x17 || 0xff == 0x1 (0x1) +__longlong 0x17 || 0xffff == 0x1 (0x1) +__ulonglong 0x17 || 0xffff == 0x1 (0x1) +int 0x17 && 0xffff == 0x1 (0x1) +__uint 0x17 && 0xffff == 0x1 (0x1) +char 0x17 && 0xffff == 0x1 (0x1) +__uchar 0x17 && 0xff == 0x1 (0x1) +__longlong 0x17 && 0xffff == 0x1 (0x1) +__ulonglong 0x17 && 0xffff == 0x1 (0x1) +int 0x17 || 0x2a == 0x1 (0x1) +__uint 0x17 || 0x2a == 0x1 (0x1) +char 0x17 || 0x2a == 0x1 (0x1) +__uchar 0x17 || 0x2a == 0x1 (0x1) +__longlong 0x17 || 0x2a == 0x1 (0x1) +__ulonglong 0x17 || 0x2a == 0x1 (0x1) +int 0x17 && 0x2a == 0x1 (0x1) +__uint 0x17 && 0x2a == 0x1 (0x1) +char 0x17 && 0x2a == 0x1 (0x1) +__uchar 0x17 && 0x2a == 0x1 (0x1) +__longlong 0x17 && 0x2a == 0x1 (0x1) +__ulonglong 0x17 && 0x2a == 0x1 (0x1) +int 0x17 || 0x17 == 0x1 (0x1) +__uint 0x17 || 0x17 == 0x1 (0x1) +char 0x17 || 0x17 == 0x1 (0x1) +__uchar 0x17 || 0x17 == 0x1 (0x1) +__longlong 0x17 || 0x17 == 0x1 (0x1) +__ulonglong 0x17 || 0x17 == 0x1 (0x1) +int 0x17 && 0x17 == 0x1 (0x1) +__uint 0x17 && 0x17 == 0x1 (0x1) +char 0x17 && 0x17 == 0x1 (0x1) +__uchar 0x17 && 0x17 == 0x1 (0x1) +__longlong 0x17 && 0x17 == 0x1 (0x1) +__ulonglong 0x17 && 0x17 == 0x1 (0x1) +int 0x17 || 0x7fff == 0x1 (0x1) +__uint 0x17 || 0x7fff == 0x1 (0x1) +char 0x17 || 0xffff == 0x1 (0x1) +__uchar 0x17 || 0xff == 0x1 (0x1) +__longlong 0x17 || 0x7fff == 0x1 (0x1) +__ulonglong 0x17 || 0x7fff == 0x1 (0x1) +int 0x17 && 0x7fff == 0x1 (0x1) +__uint 0x17 && 0x7fff == 0x1 (0x1) +char 0x17 && 0xffff == 0x1 (0x1) +__uchar 0x17 && 0xff == 0x1 (0x1) +__longlong 0x17 && 0x7fff == 0x1 (0x1) +__ulonglong 0x17 && 0x7fff == 0x1 (0x1) +int 0x17 || 0x8000 == 0x1 (0x1) +__uint 0x17 || 0x8000 == 0x1 (0x1) +char 0x17 || 0x0 == 0x1 (0x1) +__uchar 0x17 || 0x0 == 0x1 (0x1) +__longlong 0x17 || 0x8000 == 0x1 (0x1) +__ulonglong 0x17 || 0x8000 == 0x1 (0x1) +int 0x17 && 0x8000 == 0x1 (0x1) +__uint 0x17 && 0x8000 == 0x1 (0x1) +char 0x17 && 0x0 == 0x0 (0x0) +__uchar 0x17 && 0x0 == 0x0 (0x0) +__longlong 0x17 && 0x8000 == 0x1 (0x1) +__ulonglong 0x17 && 0x8000 == 0x1 (0x1) +int 0x7fff || 0x0 == 0x1 (0x1) +__uint 0x7fff || 0x0 == 0x1 (0x1) +char 0xffff || 0x0 == 0x1 (0x1) +__uchar 0xff || 0x0 == 0x1 (0x1) +__longlong 0x7fff || 0x0 == 0x1 (0x1) +__ulonglong 0x7fff || 0x0 == 0x1 (0x1) +int 0x7fff && 0x0 == 0x0 (0x0) +__uint 0x7fff && 0x0 == 0x0 (0x0) +char 0xffff && 0x0 == 0x0 (0x0) +__uchar 0xff && 0x0 == 0x0 (0x0) +__longlong 0x7fff && 0x0 == 0x0 (0x0) +__ulonglong 0x7fff && 0x0 == 0x0 (0x0) +int 0x7fff || 0x1 == 0x1 (0x1) +__uint 0x7fff || 0x1 == 0x1 (0x1) +char 0xffff || 0x1 == 0x1 (0x1) +__uchar 0xff || 0x1 == 0x1 (0x1) +__longlong 0x7fff || 0x1 == 0x1 (0x1) +__ulonglong 0x7fff || 0x1 == 0x1 (0x1) +int 0x7fff && 0x1 == 0x1 (0x1) +__uint 0x7fff && 0x1 == 0x1 (0x1) +char 0xffff && 0x1 == 0x1 (0x1) +__uchar 0xff && 0x1 == 0x1 (0x1) +__longlong 0x7fff && 0x1 == 0x1 (0x1) +__ulonglong 0x7fff && 0x1 == 0x1 (0x1) +int 0x7fff || 0xffff == 0x1 (0x1) +__uint 0x7fff || 0xffff == 0x1 (0x1) +char 0xffff || 0xffff == 0x1 (0x1) +__uchar 0xff || 0xff == 0x1 (0x1) +__longlong 0x7fff || 0xffff == 0x1 (0x1) +__ulonglong 0x7fff || 0xffff == 0x1 (0x1) +int 0x7fff && 0xffff == 0x1 (0x1) +__uint 0x7fff && 0xffff == 0x1 (0x1) +char 0xffff && 0xffff == 0x1 (0x1) +__uchar 0xff && 0xff == 0x1 (0x1) +__longlong 0x7fff && 0xffff == 0x1 (0x1) +__ulonglong 0x7fff && 0xffff == 0x1 (0x1) +int 0x7fff || 0x2a == 0x1 (0x1) +__uint 0x7fff || 0x2a == 0x1 (0x1) +char 0xffff || 0x2a == 0x1 (0x1) +__uchar 0xff || 0x2a == 0x1 (0x1) +__longlong 0x7fff || 0x2a == 0x1 (0x1) +__ulonglong 0x7fff || 0x2a == 0x1 (0x1) +int 0x7fff && 0x2a == 0x1 (0x1) +__uint 0x7fff && 0x2a == 0x1 (0x1) +char 0xffff && 0x2a == 0x1 (0x1) +__uchar 0xff && 0x2a == 0x1 (0x1) +__longlong 0x7fff && 0x2a == 0x1 (0x1) +__ulonglong 0x7fff && 0x2a == 0x1 (0x1) +int 0x7fff || 0x17 == 0x1 (0x1) +__uint 0x7fff || 0x17 == 0x1 (0x1) +char 0xffff || 0x17 == 0x1 (0x1) +__uchar 0xff || 0x17 == 0x1 (0x1) +__longlong 0x7fff || 0x17 == 0x1 (0x1) +__ulonglong 0x7fff || 0x17 == 0x1 (0x1) +int 0x7fff && 0x17 == 0x1 (0x1) +__uint 0x7fff && 0x17 == 0x1 (0x1) +char 0xffff && 0x17 == 0x1 (0x1) +__uchar 0xff && 0x17 == 0x1 (0x1) +__longlong 0x7fff && 0x17 == 0x1 (0x1) +__ulonglong 0x7fff && 0x17 == 0x1 (0x1) +int 0x7fff || 0x7fff == 0x1 (0x1) +__uint 0x7fff || 0x7fff == 0x1 (0x1) +char 0xffff || 0xffff == 0x1 (0x1) +__uchar 0xff || 0xff == 0x1 (0x1) +__longlong 0x7fff || 0x7fff == 0x1 (0x1) +__ulonglong 0x7fff || 0x7fff == 0x1 (0x1) +int 0x7fff && 0x7fff == 0x1 (0x1) +__uint 0x7fff && 0x7fff == 0x1 (0x1) +char 0xffff && 0xffff == 0x1 (0x1) +__uchar 0xff && 0xff == 0x1 (0x1) +__longlong 0x7fff && 0x7fff == 0x1 (0x1) +__ulonglong 0x7fff && 0x7fff == 0x1 (0x1) +int 0x7fff || 0x8000 == 0x1 (0x1) +__uint 0x7fff || 0x8000 == 0x1 (0x1) +char 0xffff || 0x0 == 0x1 (0x1) +__uchar 0xff || 0x0 == 0x1 (0x1) +__longlong 0x7fff || 0x8000 == 0x1 (0x1) +__ulonglong 0x7fff || 0x8000 == 0x1 (0x1) +int 0x7fff && 0x8000 == 0x1 (0x1) +__uint 0x7fff && 0x8000 == 0x1 (0x1) +char 0xffff && 0x0 == 0x0 (0x0) +__uchar 0xff && 0x0 == 0x0 (0x0) +__longlong 0x7fff && 0x8000 == 0x1 (0x1) +__ulonglong 0x7fff && 0x8000 == 0x1 (0x1) +int 0x8000 || 0x0 == 0x1 (0x1) +__uint 0x8000 || 0x0 == 0x1 (0x1) +char 0x0 || 0x0 == 0x0 (0x0) +__uchar 0x0 || 0x0 == 0x0 (0x0) +__longlong 0x8000 || 0x0 == 0x1 (0x1) +__ulonglong 0x8000 || 0x0 == 0x1 (0x1) +int 0x8000 && 0x0 == 0x0 (0x0) +__uint 0x8000 && 0x0 == 0x0 (0x0) +char 0x0 && 0x0 == 0x0 (0x0) +__uchar 0x0 && 0x0 == 0x0 (0x0) +__longlong 0x8000 && 0x0 == 0x0 (0x0) +__ulonglong 0x8000 && 0x0 == 0x0 (0x0) +int 0x8000 || 0x1 == 0x1 (0x1) +__uint 0x8000 || 0x1 == 0x1 (0x1) +char 0x0 || 0x1 == 0x1 (0x1) +__uchar 0x0 || 0x1 == 0x1 (0x1) +__longlong 0x8000 || 0x1 == 0x1 (0x1) +__ulonglong 0x8000 || 0x1 == 0x1 (0x1) +int 0x8000 && 0x1 == 0x1 (0x1) +__uint 0x8000 && 0x1 == 0x1 (0x1) +char 0x0 && 0x1 == 0x0 (0x0) +__uchar 0x0 && 0x1 == 0x0 (0x0) +__longlong 0x8000 && 0x1 == 0x1 (0x1) +__ulonglong 0x8000 && 0x1 == 0x1 (0x1) +int 0x8000 || 0xffff == 0x1 (0x1) +__uint 0x8000 || 0xffff == 0x1 (0x1) +char 0x0 || 0xffff == 0x1 (0x1) +__uchar 0x0 || 0xff == 0x1 (0x1) +__longlong 0x8000 || 0xffff == 0x1 (0x1) +__ulonglong 0x8000 || 0xffff == 0x1 (0x1) +int 0x8000 && 0xffff == 0x1 (0x1) +__uint 0x8000 && 0xffff == 0x1 (0x1) +char 0x0 && 0xffff == 0x0 (0x0) +__uchar 0x0 && 0xff == 0x0 (0x0) +__longlong 0x8000 && 0xffff == 0x1 (0x1) +__ulonglong 0x8000 && 0xffff == 0x1 (0x1) +int 0x8000 || 0x2a == 0x1 (0x1) +__uint 0x8000 || 0x2a == 0x1 (0x1) +char 0x0 || 0x2a == 0x1 (0x1) +__uchar 0x0 || 0x2a == 0x1 (0x1) +__longlong 0x8000 || 0x2a == 0x1 (0x1) +__ulonglong 0x8000 || 0x2a == 0x1 (0x1) +int 0x8000 && 0x2a == 0x1 (0x1) +__uint 0x8000 && 0x2a == 0x1 (0x1) +char 0x0 && 0x2a == 0x0 (0x0) +__uchar 0x0 && 0x2a == 0x0 (0x0) +__longlong 0x8000 && 0x2a == 0x1 (0x1) +__ulonglong 0x8000 && 0x2a == 0x1 (0x1) +int 0x8000 || 0x17 == 0x1 (0x1) +__uint 0x8000 || 0x17 == 0x1 (0x1) +char 0x0 || 0x17 == 0x1 (0x1) +__uchar 0x0 || 0x17 == 0x1 (0x1) +__longlong 0x8000 || 0x17 == 0x1 (0x1) +__ulonglong 0x8000 || 0x17 == 0x1 (0x1) +int 0x8000 && 0x17 == 0x1 (0x1) +__uint 0x8000 && 0x17 == 0x1 (0x1) +char 0x0 && 0x17 == 0x0 (0x0) +__uchar 0x0 && 0x17 == 0x0 (0x0) +__longlong 0x8000 && 0x17 == 0x1 (0x1) +__ulonglong 0x8000 && 0x17 == 0x1 (0x1) +int 0x8000 || 0x7fff == 0x1 (0x1) +__uint 0x8000 || 0x7fff == 0x1 (0x1) +char 0x0 || 0xffff == 0x1 (0x1) +__uchar 0x0 || 0xff == 0x1 (0x1) +__longlong 0x8000 || 0x7fff == 0x1 (0x1) +__ulonglong 0x8000 || 0x7fff == 0x1 (0x1) +int 0x8000 && 0x7fff == 0x1 (0x1) +__uint 0x8000 && 0x7fff == 0x1 (0x1) +char 0x0 && 0xffff == 0x0 (0x0) +__uchar 0x0 && 0xff == 0x0 (0x0) +__longlong 0x8000 && 0x7fff == 0x1 (0x1) +__ulonglong 0x8000 && 0x7fff == 0x1 (0x1) +int 0x8000 || 0x8000 == 0x1 (0x1) +__uint 0x8000 || 0x8000 == 0x1 (0x1) +char 0x0 || 0x0 == 0x0 (0x0) +__uchar 0x0 || 0x0 == 0x0 (0x0) +__longlong 0x8000 || 0x8000 == 0x1 (0x1) +__ulonglong 0x8000 || 0x8000 == 0x1 (0x1) +int 0x8000 && 0x8000 == 0x1 (0x1) +__uint 0x8000 && 0x8000 == 0x1 (0x1) +char 0x0 && 0x0 == 0x0 (0x0) +__uchar 0x0 && 0x0 == 0x0 (0x0) +__longlong 0x8000 && 0x8000 == 0x1 (0x1) +__ulonglong 0x8000 && 0x8000 == 0x1 (0x1) +0xbef0 +0xbac0 +0x2a +0x2 +0x17 +0x2a +0x3 +0x17 +0x2 +0x8 +0x8007 (0x8007) +0x8002 (0x8002) +0x1000 (0x1000) +0x8000 (0x8000) +0x40x0 +0x40000 (0x40000) +0xfffc0000 (0xfffc0000) +fritzhans 0x6 +hans2int OK +bubu +0xa0x20xafloat 0x2null +<= 10 + +0x0 +0x0 +eins +<= 10 +0x1 +0x10x0 +0x10x0 +zwei +<= 10 +0x20x1 +0x20x10x0 +0x20x10x0 +drei, nicht vier +<= 10 +0x30x20x1 +0x30x20x10x0 +0x30x20x10x0 +vier +<= 10 +0x40x30x20x1 +0x40x30x20x10x0 +0x40x30x20x10x0 +wos moanst? +<= 10 +0x50x40x30x20x1 +0x50x40x30x20x10x0 +0x50x40x30x20x10x0 +wos moanst? +<= 10 +0x60x50x40x30x20x1 +0x60x50x40x30x20x10x0 +0x60x50x40x30x20x10x0 +wos moanst? +<= 10 +0x70x60x50x40x30x20x1 +0x70x60x50x40x30x20x10x0 +0x70x60x50x40x30x20x10x0 +wos moanst? +<= 10 +0x80x70x60x50x40x30x20x1 +0x80x70x60x50x40x30x20x10x0 +0x80x70x60x50x40x30x20x10x0 +wos moanst? +<= 10 +0x90x80x70x60x50x40x30x20x1 +0x90x80x70x60x50x40x30x20x10x0 +0x90x80x70x60x50x40x30x20x10x0 +wos moanst? +<= 10 +0xa0x90x80x70x60x50x40x30x20x1 +0xa0x90x80x70x60x50x40x30x20x10x0 +0xa0x90x80x70x60x50x40x30x20x10x0 +wos moanst? +== 11 +0xb0xa0x90x80x70x60x50x40x30x20x1 +0xb0xa0x90x80x70x60x50x40x30x20x10x0 +0xb0xa0x90x80x70x60x50x40x30x20x10x0 +wos moanst? +> 11 +0xc0xb0xa0x90x80x70x60x50x40x30x20x1 +0xc0xb0xa0x90x80x70x60x50x40x30x20x10x0 +0xc0xb0xa0x90x80x70x60x50x40x30x20x10x0 +wos moanst? +> 11 +0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x1 +0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x10x0 +0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x10x0 +wos moanst? +> 11 +0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x1 +0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x10x0 +0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x10x0 +wos moanst? +> 11 +0xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x1 +0xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x10x0 +0xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x10x0 +wos moanst? +> 11 +0x100xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x1 +0x100xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x10x0 +0x100xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x10x0 +wos moanst? +> 11 +0x110x100xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x1 +0x110x100xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x10x0 +0x110x100xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x10x0 +wos moanst? +> 11 +0x120x110x100xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x1 +0x120x110x100xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x10x0 +0x120x110x100xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x10x0 +wos moanst? +> 11 +0x130x120x110x100xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x1 +0x130x120x110x100xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x10x0 +0x130x120x110x100xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x10x0 +wos moanst? +> 11 +0x140x130x120x110x100xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x1 +0x140x130x120x110x100xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x10x0 +0x140x130x120x110x100xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x10x0 +wos moanst? +> 11 +0x150x140x130x120x110x100xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x1 +0x150x140x130x120x110x100xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x10x0 +0x150x140x130x120x110x100xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x10x0 +wos moanst? +> 11 +0x160x150x140x130x120x110x100xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x1 +0x160x150x140x130x120x110x100xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x10x0 +0x160x150x140x130x120x110x100xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x10x0 +wos moanst? +> 11 +0x170x160x150x140x130x120x110x100xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x1 +0x170x160x150x140x130x120x110x100xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x10x0 +0x170x160x150x140x130x120x110x100xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x10x0 +wos moanst? +> 11 +0x180x170x160x150x140x130x120x110x100xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x1 +0x180x170x160x150x140x130x120x110x100xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x10x0 +0x180x170x160x150x140x130x120x110x100xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x10x0 +-0x8000 +0xffff diff --git a/test/hw/output.gcc.linux64 b/test/hw/output.gcc.linux64 new file mode 100644 index 0000000..0681d95 --- /dev/null +++ b/test/hw/output.gcc.linux64 @@ -0,0 +1,40394 @@ +0x2a +extreme 0x2a +0xffff +extreme 0xffff +0x8000 +extreme 0x8000 +0x11a +0xbef0 +0xbac0 +nok +ok +hello, world! +lo, world! +ello, world! +signed numbers +-0xa-0xa +0x5 +0xa +unsigned numbers +0xfff6 +0x5 +0xa +arith shift right +0xffff >> 0x2 == 0xffff +0xff00 >> 0x4 == 0xfff0 +0xf0 >> 0x2 == 0x3c +0x8000 >> 0x1 == 0xc000 +0x8001 >> 0x1 == 0xc000 +0x7fff >> 0x1 == 0x3fff +0xffff u>> 0x2 == 0x3fff +0xff00 u>> 0x4 == 0xff0 +0xf0 u>> 0x2 == 0x3c +0x8000 u>> 0x1 == 0x4000 +0x8001 u>> 0x1 == 0x4000 +0x7fff u>> 0x1 == 0x3fff +0xa - 0x5 == 0x5 +0xa - 0xa == 0x0 +0x5 - 0xa == -0x5 +0x0 - 0xa == -0xa +0xfff6 - 0x0 == -0xa +0xa - 0x0 == 0xa +0xfff6 - 0xfffb == -0x5 +0xfff6 - 0x5 == -0xf +0xa - 0xfff6 == 0x14 +0x5 + 0xa == 0xf +0xfffb + 0xa == 0x5 +0x0 + 0x5 == 0x5 +0x0 + 0xfffb == -0x5 +0xfffb + 0x0 == -0x5 +0x5 + 0x0 == 0x5 +0x5 + 0xfff6 == -0x5 +0x2 * 0x4 == 0x8 +0xfffe * 0x4 == -0x8 +0x0 * 0x2 == 0x0 +0x0 * 0xfffe == 0x0 +0x2 * 0xfffc == -0x8 +0x2 * 0x0 == 0x0 +0xfffe * 0x0 == 0x0 +0x100 * 0x100 == 0x0 +0x2a u/ 0x5 == 0x8 +0x5 u/ 0x2a == 0x0 +0xffd6 u/ 0x5 == 0x332a +0x2a u/ 0xfffb == 0x0 +0xfffb u/ 0x2a == 0x618 +0x28 u/ 0x8 == 0x5 +0x0 u/ 0x8 == 0x0 +0x2a / 0x5 == 0x8 +0x5 / 0x2a == 0x0 +0xffd6 / 0x5 == -0x8 +0x2a / 0xfffb == -0x8 +0xfffb / 0x2a == 0x0 +0x28 / 0x8 == 0x5 +0x0 / 0x8 == 0x0 +0xffd6 / 0xfffb == 0x8 +sizeof(char) == 0x1 +sizeof(short) == 0x2 +sizeof(int) == 0x2 +sizeof(long) == 0x8 +sizeof(long long) == 0x4 +finished +leer finished +0x0 * 0xffff == 0x0 +0x0 / 0xffff == 0x0 +0x0 % 0xffff == 0x0 +int 0x0 ^ 0xffff == -0x1 (0xffff) +__uint 0x0 ^ 0xffff == -0x1 (0xffff) +char 0x0 ^ 0xffff == -0x1 (0xffff) +__uchar 0x0 ^ 0xff == 0xff (0xff) +__longlong 0x0 ^ 0xffff == -0x1 (0xffff) +__ulonglong 0x0 ^ 0xffff == -0x1 (0xffff) +int 0x0 && 0xffff == 0x0 (0x0) +__uint 0x0 && 0xffff == 0x0 (0x0) +char 0x0 && 0xffff == 0x0 (0x0) +__uchar 0x0 && 0xff == 0x0 (0x0) +__longlong 0x0 && 0xffff == 0x0 (0x0) +__ulonglong 0x0 && 0xffff == 0x0 (0x0) +int 0x0 || 0xffff == 0x1 (0x1) +__uint 0x0 || 0xffff == 0x1 (0x1) +char 0x0 || 0xffff == 0x1 (0x1) +__uchar 0x0 || 0xff == 0x1 (0x1) +__longlong 0x0 || 0xffff == 0x1 (0x1) +__ulonglong 0x0 || 0xffff == 0x1 (0x1) +int 0x0 & 0xffff == 0x0 (0x0) +__uint 0x0 & 0xffff == 0x0 (0x0) +char 0x0 & 0xffff == 0x0 (0x0) +__uchar 0x0 & 0xff == 0x0 (0x0) +__longlong 0x0 & 0xffff == 0x0 (0x0) +__ulonglong 0x0 & 0xffff == 0x0 (0x0) +int 0x0 | 0xffff == -0x1 (0xffff) +__uint 0x0 | 0xffff == -0x1 (0xffff) +char 0x0 | 0xffff == -0x1 (0xffff) +__uchar 0x0 | 0xff == 0xff (0xff) +__longlong 0x0 | 0xffff == -0x1 (0xffff) +__ulonglong 0x0 | 0xffff == -0x1 (0xffff) +int 0x0 << 0x1 == 0x0 (0x0) +__uint 0x0 << 0x1 == 0x0 (0x0) +char 0x0 << 0x1 == 0x0 (0x0) +__uchar 0x0 << 0x1 == 0x0 (0x0) +__longlong 0x0 << 0x1 == 0x0 (0x0) +__ulonglong 0x0 << 0x1 == 0x0 (0x0) +int 0x0 >> 0x1 == 0x0 (0x0) +__uint 0x0 >> 0x1 == 0x0 (0x0) +char 0x0 >> 0x1 == 0x0 (0x0) +__uchar 0x0 >> 0x1 == 0x0 (0x0) +__longlong 0x0 >> 0x1 == 0x0 (0x0) +__ulonglong 0x0 >> 0x1 == 0x0 (0x0) +int 0x0 + 0xffff == -0x1 (0xffff) +__uint 0x0 + 0xffff == -0x1 (0xffff) +char 0x0 + 0xffff == -0x1 (0xffff) +__uchar 0x0 + 0xff == 0xff (0xff) +__longlong 0x0 + 0xffff == -0x1 (0xffff) +__ulonglong 0x0 + 0xffff == -0x1 (0xffff) +float 0x0 + 0xffff == -0x1 (0xffff) +int 0x0 - 0xffff == 0x1 (0x1) +__uint 0x0 - 0xffff == 0x1 (0x1) +char 0x0 - 0xffff == 0x1 (0x1) +__uchar 0x0 - 0xff == 0x1 (0x1) +__longlong 0x0 - 0xffff == 0x1 (0x1) +__ulonglong 0x0 - 0xffff == 0x1 (0x1) +float 0x0 - 0xffff == 0x1 (0x1) +int 0x0 * 0xffff == 0x0 (0x0) +__uint 0x0 * 0xffff == 0x0 (0x0) +char 0x0 * 0xffff == 0x0 (0x0) +__uchar 0x0 * 0xff == 0x0 (0x0) +__longlong 0x0 * 0xffff == 0x0 (0x0) +__ulonglong 0x0 * 0xffff == 0x0 (0x0) +float 0x0 * 0xffff == 0x0 (0x0) +int 0x0 < 0xffff == 0x0 (0x0) +__uint 0x0 < 0xffff == 0x1 (0x1) +char 0x0 < 0xffff == 0x0 (0x0) +__uchar 0x0 < 0xff == 0x1 (0x1) +__longlong 0x0 < 0xffff == 0x0 (0x0) +__ulonglong 0x0 < 0xffff == 0x1 (0x1) +float 0x0 < 0xffff == 0x0 (0x0) +int 0x0 > 0xffff == 0x1 (0x1) +__uint 0x0 > 0xffff == 0x0 (0x0) +char 0x0 > 0xffff == 0x1 (0x1) +__uchar 0x0 > 0xff == 0x0 (0x0) +__longlong 0x0 > 0xffff == 0x1 (0x1) +__ulonglong 0x0 > 0xffff == 0x0 (0x0) +float 0x0 > 0xffff == 0x1 (0x1) +int 0x0 <= 0xffff == 0x0 (0x0) +__uint 0x0 <= 0xffff == 0x1 (0x1) +char 0x0 <= 0xffff == 0x0 (0x0) +__uchar 0x0 <= 0xff == 0x1 (0x1) +__longlong 0x0 <= 0xffff == 0x0 (0x0) +__ulonglong 0x0 <= 0xffff == 0x1 (0x1) +float 0x0 <= 0xffff == 0x0 (0x0) +int 0x0 == 0xffff == 0x0 (0x0) +__uint 0x0 == 0xffff == 0x0 (0x0) +char 0x0 == 0xffff == 0x0 (0x0) +__uchar 0x0 == 0xff == 0x0 (0x0) +__longlong 0x0 == 0xffff == 0x0 (0x0) +__ulonglong 0x0 == 0xffff == 0x0 (0x0) +float 0x0 == 0xffff == 0x0 (0x0) +int 0x0 != 0xffff == 0x1 (0x1) +__uint 0x0 != 0xffff == 0x1 (0x1) +char 0x0 != 0xffff == 0x1 (0x1) +__uchar 0x0 != 0xff == 0x1 (0x1) +__longlong 0x0 != 0xffff == 0x1 (0x1) +__ulonglong 0x0 != 0xffff == 0x1 (0x1) +float 0x0 != 0xffff == 0x1 (0x1) +int 0x0 >= 0xffff == 0x1 (0x1) +__uint 0x0 >= 0xffff == 0x0 (0x0) +char 0x0 >= 0xffff == 0x1 (0x1) +__uchar 0x0 >= 0xff == 0x0 (0x0) +__longlong 0x0 >= 0xffff == 0x1 (0x1) +__ulonglong 0x0 >= 0xffff == 0x0 (0x0) +float 0x0 >= 0xffff == 0x1 (0x1) +int 0x0 / 0xffff == 0x0 (0x0) +__uint 0x0 / 0xffff == 0x0 (0x0) +char 0x0 / 0xffff == 0x0 (0x0) +__uchar 0x0 / 0xff == 0x0 (0x0) +__longlong 0x0 / 0xffff == 0x0 (0x0) +__ulonglong 0x0 / 0xffff == 0x0 (0x0) +float 0x0 / 0xffff == 0x0 (0x0) +int 0x0 % 0xffff == 0x0 (0x0) +__uint 0x0 % 0xffff == 0x0 (0x0) +char 0x0 % 0xffff == 0x0 (0x0) +__uchar 0x0 % 0xff == 0x0 (0x0) +__longlong 0x0 % 0xffff == 0x0 (0x0) +__ulonglong 0x0 % 0xffff == 0x0 (0x0) +0x0 * 0x1 == 0x0 +0x0 / 0x1 == 0x0 +0x0 % 0x1 == 0x0 +int 0x0 ^ 0x1 == 0x1 (0x1) +__uint 0x0 ^ 0x1 == 0x1 (0x1) +char 0x0 ^ 0x1 == 0x1 (0x1) +__uchar 0x0 ^ 0x1 == 0x1 (0x1) +__longlong 0x0 ^ 0x1 == 0x1 (0x1) +__ulonglong 0x0 ^ 0x1 == 0x1 (0x1) +int 0x0 && 0x1 == 0x0 (0x0) +__uint 0x0 && 0x1 == 0x0 (0x0) +char 0x0 && 0x1 == 0x0 (0x0) +__uchar 0x0 && 0x1 == 0x0 (0x0) +__longlong 0x0 && 0x1 == 0x0 (0x0) +__ulonglong 0x0 && 0x1 == 0x0 (0x0) +int 0x0 || 0x1 == 0x1 (0x1) +__uint 0x0 || 0x1 == 0x1 (0x1) +char 0x0 || 0x1 == 0x1 (0x1) +__uchar 0x0 || 0x1 == 0x1 (0x1) +__longlong 0x0 || 0x1 == 0x1 (0x1) +__ulonglong 0x0 || 0x1 == 0x1 (0x1) +int 0x0 & 0x1 == 0x0 (0x0) +__uint 0x0 & 0x1 == 0x0 (0x0) +char 0x0 & 0x1 == 0x0 (0x0) +__uchar 0x0 & 0x1 == 0x0 (0x0) +__longlong 0x0 & 0x1 == 0x0 (0x0) +__ulonglong 0x0 & 0x1 == 0x0 (0x0) +int 0x0 | 0x1 == 0x1 (0x1) +__uint 0x0 | 0x1 == 0x1 (0x1) +char 0x0 | 0x1 == 0x1 (0x1) +__uchar 0x0 | 0x1 == 0x1 (0x1) +__longlong 0x0 | 0x1 == 0x1 (0x1) +__ulonglong 0x0 | 0x1 == 0x1 (0x1) +int 0x0 << 0x2 == 0x0 (0x0) +__uint 0x0 << 0x2 == 0x0 (0x0) +char 0x0 << 0x2 == 0x0 (0x0) +__uchar 0x0 << 0x2 == 0x0 (0x0) +__longlong 0x0 << 0x2 == 0x0 (0x0) +__ulonglong 0x0 << 0x2 == 0x0 (0x0) +int 0x0 >> 0x2 == 0x0 (0x0) +__uint 0x0 >> 0x2 == 0x0 (0x0) +char 0x0 >> 0x2 == 0x0 (0x0) +__uchar 0x0 >> 0x2 == 0x0 (0x0) +__longlong 0x0 >> 0x2 == 0x0 (0x0) +__ulonglong 0x0 >> 0x2 == 0x0 (0x0) +int 0x0 + 0x1 == 0x1 (0x1) +__uint 0x0 + 0x1 == 0x1 (0x1) +char 0x0 + 0x1 == 0x1 (0x1) +__uchar 0x0 + 0x1 == 0x1 (0x1) +__longlong 0x0 + 0x1 == 0x1 (0x1) +__ulonglong 0x0 + 0x1 == 0x1 (0x1) +float 0x0 + 0x1 == 0x1 (0x1) +int 0x0 - 0x1 == -0x1 (0xffff) +__uint 0x0 - 0x1 == -0x1 (0xffff) +char 0x0 - 0x1 == -0x1 (0xffff) +__uchar 0x0 - 0x1 == 0xff (0xff) +__longlong 0x0 - 0x1 == -0x1 (0xffff) +__ulonglong 0x0 - 0x1 == -0x1 (0xffff) +float 0x0 - 0x1 == -0x1 (0xffff) +int 0x0 * 0x1 == 0x0 (0x0) +__uint 0x0 * 0x1 == 0x0 (0x0) +char 0x0 * 0x1 == 0x0 (0x0) +__uchar 0x0 * 0x1 == 0x0 (0x0) +__longlong 0x0 * 0x1 == 0x0 (0x0) +__ulonglong 0x0 * 0x1 == 0x0 (0x0) +float 0x0 * 0x1 == 0x0 (0x0) +int 0x0 < 0x1 == 0x1 (0x1) +__uint 0x0 < 0x1 == 0x1 (0x1) +char 0x0 < 0x1 == 0x1 (0x1) +__uchar 0x0 < 0x1 == 0x1 (0x1) +__longlong 0x0 < 0x1 == 0x1 (0x1) +__ulonglong 0x0 < 0x1 == 0x1 (0x1) +float 0x0 < 0x1 == 0x1 (0x1) +int 0x0 > 0x1 == 0x0 (0x0) +__uint 0x0 > 0x1 == 0x0 (0x0) +char 0x0 > 0x1 == 0x0 (0x0) +__uchar 0x0 > 0x1 == 0x0 (0x0) +__longlong 0x0 > 0x1 == 0x0 (0x0) +__ulonglong 0x0 > 0x1 == 0x0 (0x0) +float 0x0 > 0x1 == 0x0 (0x0) +int 0x0 <= 0x1 == 0x1 (0x1) +__uint 0x0 <= 0x1 == 0x1 (0x1) +char 0x0 <= 0x1 == 0x1 (0x1) +__uchar 0x0 <= 0x1 == 0x1 (0x1) +__longlong 0x0 <= 0x1 == 0x1 (0x1) +__ulonglong 0x0 <= 0x1 == 0x1 (0x1) +float 0x0 <= 0x1 == 0x1 (0x1) +int 0x0 == 0x1 == 0x0 (0x0) +__uint 0x0 == 0x1 == 0x0 (0x0) +char 0x0 == 0x1 == 0x0 (0x0) +__uchar 0x0 == 0x1 == 0x0 (0x0) +__longlong 0x0 == 0x1 == 0x0 (0x0) +__ulonglong 0x0 == 0x1 == 0x0 (0x0) +float 0x0 == 0x1 == 0x0 (0x0) +int 0x0 != 0x1 == 0x1 (0x1) +__uint 0x0 != 0x1 == 0x1 (0x1) +char 0x0 != 0x1 == 0x1 (0x1) +__uchar 0x0 != 0x1 == 0x1 (0x1) +__longlong 0x0 != 0x1 == 0x1 (0x1) +__ulonglong 0x0 != 0x1 == 0x1 (0x1) +float 0x0 != 0x1 == 0x1 (0x1) +int 0x0 >= 0x1 == 0x0 (0x0) +__uint 0x0 >= 0x1 == 0x0 (0x0) +char 0x0 >= 0x1 == 0x0 (0x0) +__uchar 0x0 >= 0x1 == 0x0 (0x0) +__longlong 0x0 >= 0x1 == 0x0 (0x0) +__ulonglong 0x0 >= 0x1 == 0x0 (0x0) +float 0x0 >= 0x1 == 0x0 (0x0) +int 0x0 / 0x1 == 0x0 (0x0) +__uint 0x0 / 0x1 == 0x0 (0x0) +char 0x0 / 0x1 == 0x0 (0x0) +__uchar 0x0 / 0x1 == 0x0 (0x0) +__longlong 0x0 / 0x1 == 0x0 (0x0) +__ulonglong 0x0 / 0x1 == 0x0 (0x0) +float 0x0 / 0x1 == 0x0 (0x0) +int 0x0 % 0x1 == 0x0 (0x0) +__uint 0x0 % 0x1 == 0x0 (0x0) +char 0x0 % 0x1 == 0x0 (0x0) +__uchar 0x0 % 0x1 == 0x0 (0x0) +__longlong 0x0 % 0x1 == 0x0 (0x0) +__ulonglong 0x0 % 0x1 == 0x0 (0x0) +0x0 * 0x2 == 0x0 +0x0 / 0x2 == 0x0 +0x0 % 0x2 == 0x0 +int 0x0 ^ 0x2 == 0x2 (0x2) +__uint 0x0 ^ 0x2 == 0x2 (0x2) +char 0x0 ^ 0x2 == 0x2 (0x2) +__uchar 0x0 ^ 0x2 == 0x2 (0x2) +__longlong 0x0 ^ 0x2 == 0x2 (0x2) +__ulonglong 0x0 ^ 0x2 == 0x2 (0x2) +int 0x0 && 0x2 == 0x0 (0x0) +__uint 0x0 && 0x2 == 0x0 (0x0) +char 0x0 && 0x2 == 0x0 (0x0) +__uchar 0x0 && 0x2 == 0x0 (0x0) +__longlong 0x0 && 0x2 == 0x0 (0x0) +__ulonglong 0x0 && 0x2 == 0x0 (0x0) +int 0x0 || 0x2 == 0x1 (0x1) +__uint 0x0 || 0x2 == 0x1 (0x1) +char 0x0 || 0x2 == 0x1 (0x1) +__uchar 0x0 || 0x2 == 0x1 (0x1) +__longlong 0x0 || 0x2 == 0x1 (0x1) +__ulonglong 0x0 || 0x2 == 0x1 (0x1) +int 0x0 & 0x2 == 0x0 (0x0) +__uint 0x0 & 0x2 == 0x0 (0x0) +char 0x0 & 0x2 == 0x0 (0x0) +__uchar 0x0 & 0x2 == 0x0 (0x0) +__longlong 0x0 & 0x2 == 0x0 (0x0) +__ulonglong 0x0 & 0x2 == 0x0 (0x0) +int 0x0 | 0x2 == 0x2 (0x2) +__uint 0x0 | 0x2 == 0x2 (0x2) +char 0x0 | 0x2 == 0x2 (0x2) +__uchar 0x0 | 0x2 == 0x2 (0x2) +__longlong 0x0 | 0x2 == 0x2 (0x2) +__ulonglong 0x0 | 0x2 == 0x2 (0x2) +int 0x0 << 0x3 == 0x0 (0x0) +__uint 0x0 << 0x3 == 0x0 (0x0) +char 0x0 << 0x3 == 0x0 (0x0) +__uchar 0x0 << 0x3 == 0x0 (0x0) +__longlong 0x0 << 0x3 == 0x0 (0x0) +__ulonglong 0x0 << 0x3 == 0x0 (0x0) +int 0x0 >> 0x3 == 0x0 (0x0) +__uint 0x0 >> 0x3 == 0x0 (0x0) +char 0x0 >> 0x3 == 0x0 (0x0) +__uchar 0x0 >> 0x3 == 0x0 (0x0) +__longlong 0x0 >> 0x3 == 0x0 (0x0) +__ulonglong 0x0 >> 0x3 == 0x0 (0x0) +int 0x0 + 0x2 == 0x2 (0x2) +__uint 0x0 + 0x2 == 0x2 (0x2) +char 0x0 + 0x2 == 0x2 (0x2) +__uchar 0x0 + 0x2 == 0x2 (0x2) +__longlong 0x0 + 0x2 == 0x2 (0x2) +__ulonglong 0x0 + 0x2 == 0x2 (0x2) +float 0x0 + 0x2 == 0x2 (0x2) +int 0x0 - 0x2 == -0x2 (0xfffe) +__uint 0x0 - 0x2 == -0x2 (0xfffe) +char 0x0 - 0x2 == -0x2 (0xfffe) +__uchar 0x0 - 0x2 == 0xfe (0xfe) +__longlong 0x0 - 0x2 == -0x2 (0xfffe) +__ulonglong 0x0 - 0x2 == -0x2 (0xfffe) +float 0x0 - 0x2 == -0x2 (0xfffe) +int 0x0 * 0x2 == 0x0 (0x0) +__uint 0x0 * 0x2 == 0x0 (0x0) +char 0x0 * 0x2 == 0x0 (0x0) +__uchar 0x0 * 0x2 == 0x0 (0x0) +__longlong 0x0 * 0x2 == 0x0 (0x0) +__ulonglong 0x0 * 0x2 == 0x0 (0x0) +float 0x0 * 0x2 == 0x0 (0x0) +int 0x0 < 0x2 == 0x1 (0x1) +__uint 0x0 < 0x2 == 0x1 (0x1) +char 0x0 < 0x2 == 0x1 (0x1) +__uchar 0x0 < 0x2 == 0x1 (0x1) +__longlong 0x0 < 0x2 == 0x1 (0x1) +__ulonglong 0x0 < 0x2 == 0x1 (0x1) +float 0x0 < 0x2 == 0x1 (0x1) +int 0x0 > 0x2 == 0x0 (0x0) +__uint 0x0 > 0x2 == 0x0 (0x0) +char 0x0 > 0x2 == 0x0 (0x0) +__uchar 0x0 > 0x2 == 0x0 (0x0) +__longlong 0x0 > 0x2 == 0x0 (0x0) +__ulonglong 0x0 > 0x2 == 0x0 (0x0) +float 0x0 > 0x2 == 0x0 (0x0) +int 0x0 <= 0x2 == 0x1 (0x1) +__uint 0x0 <= 0x2 == 0x1 (0x1) +char 0x0 <= 0x2 == 0x1 (0x1) +__uchar 0x0 <= 0x2 == 0x1 (0x1) +__longlong 0x0 <= 0x2 == 0x1 (0x1) +__ulonglong 0x0 <= 0x2 == 0x1 (0x1) +float 0x0 <= 0x2 == 0x1 (0x1) +int 0x0 == 0x2 == 0x0 (0x0) +__uint 0x0 == 0x2 == 0x0 (0x0) +char 0x0 == 0x2 == 0x0 (0x0) +__uchar 0x0 == 0x2 == 0x0 (0x0) +__longlong 0x0 == 0x2 == 0x0 (0x0) +__ulonglong 0x0 == 0x2 == 0x0 (0x0) +float 0x0 == 0x2 == 0x0 (0x0) +int 0x0 != 0x2 == 0x1 (0x1) +__uint 0x0 != 0x2 == 0x1 (0x1) +char 0x0 != 0x2 == 0x1 (0x1) +__uchar 0x0 != 0x2 == 0x1 (0x1) +__longlong 0x0 != 0x2 == 0x1 (0x1) +__ulonglong 0x0 != 0x2 == 0x1 (0x1) +float 0x0 != 0x2 == 0x1 (0x1) +int 0x0 >= 0x2 == 0x0 (0x0) +__uint 0x0 >= 0x2 == 0x0 (0x0) +char 0x0 >= 0x2 == 0x0 (0x0) +__uchar 0x0 >= 0x2 == 0x0 (0x0) +__longlong 0x0 >= 0x2 == 0x0 (0x0) +__ulonglong 0x0 >= 0x2 == 0x0 (0x0) +float 0x0 >= 0x2 == 0x0 (0x0) +int 0x0 / 0x2 == 0x0 (0x0) +__uint 0x0 / 0x2 == 0x0 (0x0) +char 0x0 / 0x2 == 0x0 (0x0) +__uchar 0x0 / 0x2 == 0x0 (0x0) +__longlong 0x0 / 0x2 == 0x0 (0x0) +__ulonglong 0x0 / 0x2 == 0x0 (0x0) +float 0x0 / 0x2 == 0x0 (0x0) +int 0x0 % 0x2 == 0x0 (0x0) +__uint 0x0 % 0x2 == 0x0 (0x0) +char 0x0 % 0x2 == 0x0 (0x0) +__uchar 0x0 % 0x2 == 0x0 (0x0) +__longlong 0x0 % 0x2 == 0x0 (0x0) +__ulonglong 0x0 % 0x2 == 0x0 (0x0) +0x0 * 0xfffe == 0x0 +0x0 / 0xfffe == 0x0 +0x0 % 0xfffe == 0x0 +int 0x0 ^ 0xfffe == -0x2 (0xfffe) +__uint 0x0 ^ 0xfffe == -0x2 (0xfffe) +char 0x0 ^ 0xfffe == -0x2 (0xfffe) +__uchar 0x0 ^ 0xfe == 0xfe (0xfe) +__longlong 0x0 ^ 0xfffe == -0x2 (0xfffe) +__ulonglong 0x0 ^ 0xfffe == -0x2 (0xfffe) +int 0x0 && 0xfffe == 0x0 (0x0) +__uint 0x0 && 0xfffe == 0x0 (0x0) +char 0x0 && 0xfffe == 0x0 (0x0) +__uchar 0x0 && 0xfe == 0x0 (0x0) +__longlong 0x0 && 0xfffe == 0x0 (0x0) +__ulonglong 0x0 && 0xfffe == 0x0 (0x0) +int 0x0 || 0xfffe == 0x1 (0x1) +__uint 0x0 || 0xfffe == 0x1 (0x1) +char 0x0 || 0xfffe == 0x1 (0x1) +__uchar 0x0 || 0xfe == 0x1 (0x1) +__longlong 0x0 || 0xfffe == 0x1 (0x1) +__ulonglong 0x0 || 0xfffe == 0x1 (0x1) +int 0x0 & 0xfffe == 0x0 (0x0) +__uint 0x0 & 0xfffe == 0x0 (0x0) +char 0x0 & 0xfffe == 0x0 (0x0) +__uchar 0x0 & 0xfe == 0x0 (0x0) +__longlong 0x0 & 0xfffe == 0x0 (0x0) +__ulonglong 0x0 & 0xfffe == 0x0 (0x0) +int 0x0 | 0xfffe == -0x2 (0xfffe) +__uint 0x0 | 0xfffe == -0x2 (0xfffe) +char 0x0 | 0xfffe == -0x2 (0xfffe) +__uchar 0x0 | 0xfe == 0xfe (0xfe) +__longlong 0x0 | 0xfffe == -0x2 (0xfffe) +__ulonglong 0x0 | 0xfffe == -0x2 (0xfffe) +int 0x0 << 0x4 == 0x0 (0x0) +__uint 0x0 << 0x4 == 0x0 (0x0) +char 0x0 << 0x4 == 0x0 (0x0) +__uchar 0x0 << 0x4 == 0x0 (0x0) +__longlong 0x0 << 0x4 == 0x0 (0x0) +__ulonglong 0x0 << 0x4 == 0x0 (0x0) +int 0x0 >> 0x4 == 0x0 (0x0) +__uint 0x0 >> 0x4 == 0x0 (0x0) +char 0x0 >> 0x4 == 0x0 (0x0) +__uchar 0x0 >> 0x4 == 0x0 (0x0) +__longlong 0x0 >> 0x4 == 0x0 (0x0) +__ulonglong 0x0 >> 0x4 == 0x0 (0x0) +int 0x0 + 0xfffe == -0x2 (0xfffe) +__uint 0x0 + 0xfffe == -0x2 (0xfffe) +char 0x0 + 0xfffe == -0x2 (0xfffe) +__uchar 0x0 + 0xfe == 0xfe (0xfe) +__longlong 0x0 + 0xfffe == -0x2 (0xfffe) +__ulonglong 0x0 + 0xfffe == -0x2 (0xfffe) +float 0x0 + 0xfffe == -0x2 (0xfffe) +int 0x0 - 0xfffe == 0x2 (0x2) +__uint 0x0 - 0xfffe == 0x2 (0x2) +char 0x0 - 0xfffe == 0x2 (0x2) +__uchar 0x0 - 0xfe == 0x2 (0x2) +__longlong 0x0 - 0xfffe == 0x2 (0x2) +__ulonglong 0x0 - 0xfffe == 0x2 (0x2) +float 0x0 - 0xfffe == 0x2 (0x2) +int 0x0 * 0xfffe == 0x0 (0x0) +__uint 0x0 * 0xfffe == 0x0 (0x0) +char 0x0 * 0xfffe == 0x0 (0x0) +__uchar 0x0 * 0xfe == 0x0 (0x0) +__longlong 0x0 * 0xfffe == 0x0 (0x0) +__ulonglong 0x0 * 0xfffe == 0x0 (0x0) +float 0x0 * 0xfffe == 0x0 (0x0) +int 0x0 < 0xfffe == 0x0 (0x0) +__uint 0x0 < 0xfffe == 0x1 (0x1) +char 0x0 < 0xfffe == 0x0 (0x0) +__uchar 0x0 < 0xfe == 0x1 (0x1) +__longlong 0x0 < 0xfffe == 0x0 (0x0) +__ulonglong 0x0 < 0xfffe == 0x1 (0x1) +float 0x0 < 0xfffe == 0x0 (0x0) +int 0x0 > 0xfffe == 0x1 (0x1) +__uint 0x0 > 0xfffe == 0x0 (0x0) +char 0x0 > 0xfffe == 0x1 (0x1) +__uchar 0x0 > 0xfe == 0x0 (0x0) +__longlong 0x0 > 0xfffe == 0x1 (0x1) +__ulonglong 0x0 > 0xfffe == 0x0 (0x0) +float 0x0 > 0xfffe == 0x1 (0x1) +int 0x0 <= 0xfffe == 0x0 (0x0) +__uint 0x0 <= 0xfffe == 0x1 (0x1) +char 0x0 <= 0xfffe == 0x0 (0x0) +__uchar 0x0 <= 0xfe == 0x1 (0x1) +__longlong 0x0 <= 0xfffe == 0x0 (0x0) +__ulonglong 0x0 <= 0xfffe == 0x1 (0x1) +float 0x0 <= 0xfffe == 0x0 (0x0) +int 0x0 == 0xfffe == 0x0 (0x0) +__uint 0x0 == 0xfffe == 0x0 (0x0) +char 0x0 == 0xfffe == 0x0 (0x0) +__uchar 0x0 == 0xfe == 0x0 (0x0) +__longlong 0x0 == 0xfffe == 0x0 (0x0) +__ulonglong 0x0 == 0xfffe == 0x0 (0x0) +float 0x0 == 0xfffe == 0x0 (0x0) +int 0x0 != 0xfffe == 0x1 (0x1) +__uint 0x0 != 0xfffe == 0x1 (0x1) +char 0x0 != 0xfffe == 0x1 (0x1) +__uchar 0x0 != 0xfe == 0x1 (0x1) +__longlong 0x0 != 0xfffe == 0x1 (0x1) +__ulonglong 0x0 != 0xfffe == 0x1 (0x1) +float 0x0 != 0xfffe == 0x1 (0x1) +int 0x0 >= 0xfffe == 0x1 (0x1) +__uint 0x0 >= 0xfffe == 0x0 (0x0) +char 0x0 >= 0xfffe == 0x1 (0x1) +__uchar 0x0 >= 0xfe == 0x0 (0x0) +__longlong 0x0 >= 0xfffe == 0x1 (0x1) +__ulonglong 0x0 >= 0xfffe == 0x0 (0x0) +float 0x0 >= 0xfffe == 0x1 (0x1) +int 0x0 / 0xfffe == 0x0 (0x0) +__uint 0x0 / 0xfffe == 0x0 (0x0) +char 0x0 / 0xfffe == 0x0 (0x0) +__uchar 0x0 / 0xfe == 0x0 (0x0) +__longlong 0x0 / 0xfffe == 0x0 (0x0) +__ulonglong 0x0 / 0xfffe == 0x0 (0x0) +float 0x0 / 0xfffe == 0x0 (0x0) +int 0x0 % 0xfffe == 0x0 (0x0) +__uint 0x0 % 0xfffe == 0x0 (0x0) +char 0x0 % 0xfffe == 0x0 (0x0) +__uchar 0x0 % 0xfe == 0x0 (0x0) +__longlong 0x0 % 0xfffe == 0x0 (0x0) +__ulonglong 0x0 % 0xfffe == 0x0 (0x0) +0x0 * 0x4 == 0x0 +0x0 / 0x4 == 0x0 +0x0 % 0x4 == 0x0 +int 0x0 ^ 0x4 == 0x4 (0x4) +__uint 0x0 ^ 0x4 == 0x4 (0x4) +char 0x0 ^ 0x4 == 0x4 (0x4) +__uchar 0x0 ^ 0x4 == 0x4 (0x4) +__longlong 0x0 ^ 0x4 == 0x4 (0x4) +__ulonglong 0x0 ^ 0x4 == 0x4 (0x4) +int 0x0 && 0x4 == 0x0 (0x0) +__uint 0x0 && 0x4 == 0x0 (0x0) +char 0x0 && 0x4 == 0x0 (0x0) +__uchar 0x0 && 0x4 == 0x0 (0x0) +__longlong 0x0 && 0x4 == 0x0 (0x0) +__ulonglong 0x0 && 0x4 == 0x0 (0x0) +int 0x0 || 0x4 == 0x1 (0x1) +__uint 0x0 || 0x4 == 0x1 (0x1) +char 0x0 || 0x4 == 0x1 (0x1) +__uchar 0x0 || 0x4 == 0x1 (0x1) +__longlong 0x0 || 0x4 == 0x1 (0x1) +__ulonglong 0x0 || 0x4 == 0x1 (0x1) +int 0x0 & 0x4 == 0x0 (0x0) +__uint 0x0 & 0x4 == 0x0 (0x0) +char 0x0 & 0x4 == 0x0 (0x0) +__uchar 0x0 & 0x4 == 0x0 (0x0) +__longlong 0x0 & 0x4 == 0x0 (0x0) +__ulonglong 0x0 & 0x4 == 0x0 (0x0) +int 0x0 | 0x4 == 0x4 (0x4) +__uint 0x0 | 0x4 == 0x4 (0x4) +char 0x0 | 0x4 == 0x4 (0x4) +__uchar 0x0 | 0x4 == 0x4 (0x4) +__longlong 0x0 | 0x4 == 0x4 (0x4) +__ulonglong 0x0 | 0x4 == 0x4 (0x4) +int 0x0 << 0x5 == 0x0 (0x0) +__uint 0x0 << 0x5 == 0x0 (0x0) +char 0x0 << 0x5 == 0x0 (0x0) +__uchar 0x0 << 0x5 == 0x0 (0x0) +__longlong 0x0 << 0x5 == 0x0 (0x0) +__ulonglong 0x0 << 0x5 == 0x0 (0x0) +int 0x0 >> 0x5 == 0x0 (0x0) +__uint 0x0 >> 0x5 == 0x0 (0x0) +char 0x0 >> 0x5 == 0x0 (0x0) +__uchar 0x0 >> 0x5 == 0x0 (0x0) +__longlong 0x0 >> 0x5 == 0x0 (0x0) +__ulonglong 0x0 >> 0x5 == 0x0 (0x0) +int 0x0 + 0x4 == 0x4 (0x4) +__uint 0x0 + 0x4 == 0x4 (0x4) +char 0x0 + 0x4 == 0x4 (0x4) +__uchar 0x0 + 0x4 == 0x4 (0x4) +__longlong 0x0 + 0x4 == 0x4 (0x4) +__ulonglong 0x0 + 0x4 == 0x4 (0x4) +float 0x0 + 0x4 == 0x4 (0x4) +int 0x0 - 0x4 == -0x4 (0xfffc) +__uint 0x0 - 0x4 == -0x4 (0xfffc) +char 0x0 - 0x4 == -0x4 (0xfffc) +__uchar 0x0 - 0x4 == 0xfc (0xfc) +__longlong 0x0 - 0x4 == -0x4 (0xfffc) +__ulonglong 0x0 - 0x4 == -0x4 (0xfffc) +float 0x0 - 0x4 == -0x4 (0xfffc) +int 0x0 * 0x4 == 0x0 (0x0) +__uint 0x0 * 0x4 == 0x0 (0x0) +char 0x0 * 0x4 == 0x0 (0x0) +__uchar 0x0 * 0x4 == 0x0 (0x0) +__longlong 0x0 * 0x4 == 0x0 (0x0) +__ulonglong 0x0 * 0x4 == 0x0 (0x0) +float 0x0 * 0x4 == 0x0 (0x0) +int 0x0 < 0x4 == 0x1 (0x1) +__uint 0x0 < 0x4 == 0x1 (0x1) +char 0x0 < 0x4 == 0x1 (0x1) +__uchar 0x0 < 0x4 == 0x1 (0x1) +__longlong 0x0 < 0x4 == 0x1 (0x1) +__ulonglong 0x0 < 0x4 == 0x1 (0x1) +float 0x0 < 0x4 == 0x1 (0x1) +int 0x0 > 0x4 == 0x0 (0x0) +__uint 0x0 > 0x4 == 0x0 (0x0) +char 0x0 > 0x4 == 0x0 (0x0) +__uchar 0x0 > 0x4 == 0x0 (0x0) +__longlong 0x0 > 0x4 == 0x0 (0x0) +__ulonglong 0x0 > 0x4 == 0x0 (0x0) +float 0x0 > 0x4 == 0x0 (0x0) +int 0x0 <= 0x4 == 0x1 (0x1) +__uint 0x0 <= 0x4 == 0x1 (0x1) +char 0x0 <= 0x4 == 0x1 (0x1) +__uchar 0x0 <= 0x4 == 0x1 (0x1) +__longlong 0x0 <= 0x4 == 0x1 (0x1) +__ulonglong 0x0 <= 0x4 == 0x1 (0x1) +float 0x0 <= 0x4 == 0x1 (0x1) +int 0x0 == 0x4 == 0x0 (0x0) +__uint 0x0 == 0x4 == 0x0 (0x0) +char 0x0 == 0x4 == 0x0 (0x0) +__uchar 0x0 == 0x4 == 0x0 (0x0) +__longlong 0x0 == 0x4 == 0x0 (0x0) +__ulonglong 0x0 == 0x4 == 0x0 (0x0) +float 0x0 == 0x4 == 0x0 (0x0) +int 0x0 != 0x4 == 0x1 (0x1) +__uint 0x0 != 0x4 == 0x1 (0x1) +char 0x0 != 0x4 == 0x1 (0x1) +__uchar 0x0 != 0x4 == 0x1 (0x1) +__longlong 0x0 != 0x4 == 0x1 (0x1) +__ulonglong 0x0 != 0x4 == 0x1 (0x1) +float 0x0 != 0x4 == 0x1 (0x1) +int 0x0 >= 0x4 == 0x0 (0x0) +__uint 0x0 >= 0x4 == 0x0 (0x0) +char 0x0 >= 0x4 == 0x0 (0x0) +__uchar 0x0 >= 0x4 == 0x0 (0x0) +__longlong 0x0 >= 0x4 == 0x0 (0x0) +__ulonglong 0x0 >= 0x4 == 0x0 (0x0) +float 0x0 >= 0x4 == 0x0 (0x0) +int 0x0 / 0x4 == 0x0 (0x0) +__uint 0x0 / 0x4 == 0x0 (0x0) +char 0x0 / 0x4 == 0x0 (0x0) +__uchar 0x0 / 0x4 == 0x0 (0x0) +__longlong 0x0 / 0x4 == 0x0 (0x0) +__ulonglong 0x0 / 0x4 == 0x0 (0x0) +float 0x0 / 0x4 == 0x0 (0x0) +int 0x0 % 0x4 == 0x0 (0x0) +__uint 0x0 % 0x4 == 0x0 (0x0) +char 0x0 % 0x4 == 0x0 (0x0) +__uchar 0x0 % 0x4 == 0x0 (0x0) +__longlong 0x0 % 0x4 == 0x0 (0x0) +__ulonglong 0x0 % 0x4 == 0x0 (0x0) +0x0 * 0xfffc == 0x0 +0x0 / 0xfffc == 0x0 +0x0 % 0xfffc == 0x0 +int 0x0 ^ 0xfffc == -0x4 (0xfffc) +__uint 0x0 ^ 0xfffc == -0x4 (0xfffc) +char 0x0 ^ 0xfffc == -0x4 (0xfffc) +__uchar 0x0 ^ 0xfc == 0xfc (0xfc) +__longlong 0x0 ^ 0xfffc == -0x4 (0xfffc) +__ulonglong 0x0 ^ 0xfffc == -0x4 (0xfffc) +int 0x0 && 0xfffc == 0x0 (0x0) +__uint 0x0 && 0xfffc == 0x0 (0x0) +char 0x0 && 0xfffc == 0x0 (0x0) +__uchar 0x0 && 0xfc == 0x0 (0x0) +__longlong 0x0 && 0xfffc == 0x0 (0x0) +__ulonglong 0x0 && 0xfffc == 0x0 (0x0) +int 0x0 || 0xfffc == 0x1 (0x1) +__uint 0x0 || 0xfffc == 0x1 (0x1) +char 0x0 || 0xfffc == 0x1 (0x1) +__uchar 0x0 || 0xfc == 0x1 (0x1) +__longlong 0x0 || 0xfffc == 0x1 (0x1) +__ulonglong 0x0 || 0xfffc == 0x1 (0x1) +int 0x0 & 0xfffc == 0x0 (0x0) +__uint 0x0 & 0xfffc == 0x0 (0x0) +char 0x0 & 0xfffc == 0x0 (0x0) +__uchar 0x0 & 0xfc == 0x0 (0x0) +__longlong 0x0 & 0xfffc == 0x0 (0x0) +__ulonglong 0x0 & 0xfffc == 0x0 (0x0) +int 0x0 | 0xfffc == -0x4 (0xfffc) +__uint 0x0 | 0xfffc == -0x4 (0xfffc) +char 0x0 | 0xfffc == -0x4 (0xfffc) +__uchar 0x0 | 0xfc == 0xfc (0xfc) +__longlong 0x0 | 0xfffc == -0x4 (0xfffc) +__ulonglong 0x0 | 0xfffc == -0x4 (0xfffc) +int 0x0 << 0x6 == 0x0 (0x0) +__uint 0x0 << 0x6 == 0x0 (0x0) +char 0x0 << 0x6 == 0x0 (0x0) +__uchar 0x0 << 0x6 == 0x0 (0x0) +__longlong 0x0 << 0x6 == 0x0 (0x0) +__ulonglong 0x0 << 0x6 == 0x0 (0x0) +int 0x0 >> 0x6 == 0x0 (0x0) +__uint 0x0 >> 0x6 == 0x0 (0x0) +char 0x0 >> 0x6 == 0x0 (0x0) +__uchar 0x0 >> 0x6 == 0x0 (0x0) +__longlong 0x0 >> 0x6 == 0x0 (0x0) +__ulonglong 0x0 >> 0x6 == 0x0 (0x0) +int 0x0 + 0xfffc == -0x4 (0xfffc) +__uint 0x0 + 0xfffc == -0x4 (0xfffc) +char 0x0 + 0xfffc == -0x4 (0xfffc) +__uchar 0x0 + 0xfc == 0xfc (0xfc) +__longlong 0x0 + 0xfffc == -0x4 (0xfffc) +__ulonglong 0x0 + 0xfffc == -0x4 (0xfffc) +float 0x0 + 0xfffc == -0x4 (0xfffc) +int 0x0 - 0xfffc == 0x4 (0x4) +__uint 0x0 - 0xfffc == 0x4 (0x4) +char 0x0 - 0xfffc == 0x4 (0x4) +__uchar 0x0 - 0xfc == 0x4 (0x4) +__longlong 0x0 - 0xfffc == 0x4 (0x4) +__ulonglong 0x0 - 0xfffc == 0x4 (0x4) +float 0x0 - 0xfffc == 0x4 (0x4) +int 0x0 * 0xfffc == 0x0 (0x0) +__uint 0x0 * 0xfffc == 0x0 (0x0) +char 0x0 * 0xfffc == 0x0 (0x0) +__uchar 0x0 * 0xfc == 0x0 (0x0) +__longlong 0x0 * 0xfffc == 0x0 (0x0) +__ulonglong 0x0 * 0xfffc == 0x0 (0x0) +float 0x0 * 0xfffc == 0x0 (0x0) +int 0x0 < 0xfffc == 0x0 (0x0) +__uint 0x0 < 0xfffc == 0x1 (0x1) +char 0x0 < 0xfffc == 0x0 (0x0) +__uchar 0x0 < 0xfc == 0x1 (0x1) +__longlong 0x0 < 0xfffc == 0x0 (0x0) +__ulonglong 0x0 < 0xfffc == 0x1 (0x1) +float 0x0 < 0xfffc == 0x0 (0x0) +int 0x0 > 0xfffc == 0x1 (0x1) +__uint 0x0 > 0xfffc == 0x0 (0x0) +char 0x0 > 0xfffc == 0x1 (0x1) +__uchar 0x0 > 0xfc == 0x0 (0x0) +__longlong 0x0 > 0xfffc == 0x1 (0x1) +__ulonglong 0x0 > 0xfffc == 0x0 (0x0) +float 0x0 > 0xfffc == 0x1 (0x1) +int 0x0 <= 0xfffc == 0x0 (0x0) +__uint 0x0 <= 0xfffc == 0x1 (0x1) +char 0x0 <= 0xfffc == 0x0 (0x0) +__uchar 0x0 <= 0xfc == 0x1 (0x1) +__longlong 0x0 <= 0xfffc == 0x0 (0x0) +__ulonglong 0x0 <= 0xfffc == 0x1 (0x1) +float 0x0 <= 0xfffc == 0x0 (0x0) +int 0x0 == 0xfffc == 0x0 (0x0) +__uint 0x0 == 0xfffc == 0x0 (0x0) +char 0x0 == 0xfffc == 0x0 (0x0) +__uchar 0x0 == 0xfc == 0x0 (0x0) +__longlong 0x0 == 0xfffc == 0x0 (0x0) +__ulonglong 0x0 == 0xfffc == 0x0 (0x0) +float 0x0 == 0xfffc == 0x0 (0x0) +int 0x0 != 0xfffc == 0x1 (0x1) +__uint 0x0 != 0xfffc == 0x1 (0x1) +char 0x0 != 0xfffc == 0x1 (0x1) +__uchar 0x0 != 0xfc == 0x1 (0x1) +__longlong 0x0 != 0xfffc == 0x1 (0x1) +__ulonglong 0x0 != 0xfffc == 0x1 (0x1) +float 0x0 != 0xfffc == 0x1 (0x1) +int 0x0 >= 0xfffc == 0x1 (0x1) +__uint 0x0 >= 0xfffc == 0x0 (0x0) +char 0x0 >= 0xfffc == 0x1 (0x1) +__uchar 0x0 >= 0xfc == 0x0 (0x0) +__longlong 0x0 >= 0xfffc == 0x1 (0x1) +__ulonglong 0x0 >= 0xfffc == 0x0 (0x0) +float 0x0 >= 0xfffc == 0x1 (0x1) +int 0x0 / 0xfffc == 0x0 (0x0) +__uint 0x0 / 0xfffc == 0x0 (0x0) +char 0x0 / 0xfffc == 0x0 (0x0) +__uchar 0x0 / 0xfc == 0x0 (0x0) +__longlong 0x0 / 0xfffc == 0x0 (0x0) +__ulonglong 0x0 / 0xfffc == 0x0 (0x0) +float 0x0 / 0xfffc == 0x0 (0x0) +int 0x0 % 0xfffc == 0x0 (0x0) +__uint 0x0 % 0xfffc == 0x0 (0x0) +char 0x0 % 0xfffc == 0x0 (0x0) +__uchar 0x0 % 0xfc == 0x0 (0x0) +__longlong 0x0 % 0xfffc == 0x0 (0x0) +__ulonglong 0x0 % 0xfffc == 0x0 (0x0) +0x0 * 0xa == 0x0 +0x0 / 0xa == 0x0 +0x0 % 0xa == 0x0 +int 0x0 ^ 0xa == 0xa (0xa) +__uint 0x0 ^ 0xa == 0xa (0xa) +char 0x0 ^ 0xa == 0xa (0xa) +__uchar 0x0 ^ 0xa == 0xa (0xa) +__longlong 0x0 ^ 0xa == 0xa (0xa) +__ulonglong 0x0 ^ 0xa == 0xa (0xa) +int 0x0 && 0xa == 0x0 (0x0) +__uint 0x0 && 0xa == 0x0 (0x0) +char 0x0 && 0xa == 0x0 (0x0) +__uchar 0x0 && 0xa == 0x0 (0x0) +__longlong 0x0 && 0xa == 0x0 (0x0) +__ulonglong 0x0 && 0xa == 0x0 (0x0) +int 0x0 || 0xa == 0x1 (0x1) +__uint 0x0 || 0xa == 0x1 (0x1) +char 0x0 || 0xa == 0x1 (0x1) +__uchar 0x0 || 0xa == 0x1 (0x1) +__longlong 0x0 || 0xa == 0x1 (0x1) +__ulonglong 0x0 || 0xa == 0x1 (0x1) +int 0x0 & 0xa == 0x0 (0x0) +__uint 0x0 & 0xa == 0x0 (0x0) +char 0x0 & 0xa == 0x0 (0x0) +__uchar 0x0 & 0xa == 0x0 (0x0) +__longlong 0x0 & 0xa == 0x0 (0x0) +__ulonglong 0x0 & 0xa == 0x0 (0x0) +int 0x0 | 0xa == 0xa (0xa) +__uint 0x0 | 0xa == 0xa (0xa) +char 0x0 | 0xa == 0xa (0xa) +__uchar 0x0 | 0xa == 0xa (0xa) +__longlong 0x0 | 0xa == 0xa (0xa) +__ulonglong 0x0 | 0xa == 0xa (0xa) +int 0x0 << 0x7 == 0x0 (0x0) +__uint 0x0 << 0x7 == 0x0 (0x0) +char 0x0 << 0x7 == 0x0 (0x0) +__uchar 0x0 << 0x7 == 0x0 (0x0) +__longlong 0x0 << 0x7 == 0x0 (0x0) +__ulonglong 0x0 << 0x7 == 0x0 (0x0) +int 0x0 >> 0x7 == 0x0 (0x0) +__uint 0x0 >> 0x7 == 0x0 (0x0) +char 0x0 >> 0x7 == 0x0 (0x0) +__uchar 0x0 >> 0x7 == 0x0 (0x0) +__longlong 0x0 >> 0x7 == 0x0 (0x0) +__ulonglong 0x0 >> 0x7 == 0x0 (0x0) +int 0x0 + 0xa == 0xa (0xa) +__uint 0x0 + 0xa == 0xa (0xa) +char 0x0 + 0xa == 0xa (0xa) +__uchar 0x0 + 0xa == 0xa (0xa) +__longlong 0x0 + 0xa == 0xa (0xa) +__ulonglong 0x0 + 0xa == 0xa (0xa) +float 0x0 + 0xa == 0xa (0xa) +int 0x0 - 0xa == -0xa (0xfff6) +__uint 0x0 - 0xa == -0xa (0xfff6) +char 0x0 - 0xa == -0xa (0xfff6) +__uchar 0x0 - 0xa == 0xf6 (0xf6) +__longlong 0x0 - 0xa == -0xa (0xfff6) +__ulonglong 0x0 - 0xa == -0xa (0xfff6) +float 0x0 - 0xa == -0xa (0xfff6) +int 0x0 * 0xa == 0x0 (0x0) +__uint 0x0 * 0xa == 0x0 (0x0) +char 0x0 * 0xa == 0x0 (0x0) +__uchar 0x0 * 0xa == 0x0 (0x0) +__longlong 0x0 * 0xa == 0x0 (0x0) +__ulonglong 0x0 * 0xa == 0x0 (0x0) +float 0x0 * 0xa == 0x0 (0x0) +int 0x0 < 0xa == 0x1 (0x1) +__uint 0x0 < 0xa == 0x1 (0x1) +char 0x0 < 0xa == 0x1 (0x1) +__uchar 0x0 < 0xa == 0x1 (0x1) +__longlong 0x0 < 0xa == 0x1 (0x1) +__ulonglong 0x0 < 0xa == 0x1 (0x1) +float 0x0 < 0xa == 0x1 (0x1) +int 0x0 > 0xa == 0x0 (0x0) +__uint 0x0 > 0xa == 0x0 (0x0) +char 0x0 > 0xa == 0x0 (0x0) +__uchar 0x0 > 0xa == 0x0 (0x0) +__longlong 0x0 > 0xa == 0x0 (0x0) +__ulonglong 0x0 > 0xa == 0x0 (0x0) +float 0x0 > 0xa == 0x0 (0x0) +int 0x0 <= 0xa == 0x1 (0x1) +__uint 0x0 <= 0xa == 0x1 (0x1) +char 0x0 <= 0xa == 0x1 (0x1) +__uchar 0x0 <= 0xa == 0x1 (0x1) +__longlong 0x0 <= 0xa == 0x1 (0x1) +__ulonglong 0x0 <= 0xa == 0x1 (0x1) +float 0x0 <= 0xa == 0x1 (0x1) +int 0x0 == 0xa == 0x0 (0x0) +__uint 0x0 == 0xa == 0x0 (0x0) +char 0x0 == 0xa == 0x0 (0x0) +__uchar 0x0 == 0xa == 0x0 (0x0) +__longlong 0x0 == 0xa == 0x0 (0x0) +__ulonglong 0x0 == 0xa == 0x0 (0x0) +float 0x0 == 0xa == 0x0 (0x0) +int 0x0 != 0xa == 0x1 (0x1) +__uint 0x0 != 0xa == 0x1 (0x1) +char 0x0 != 0xa == 0x1 (0x1) +__uchar 0x0 != 0xa == 0x1 (0x1) +__longlong 0x0 != 0xa == 0x1 (0x1) +__ulonglong 0x0 != 0xa == 0x1 (0x1) +float 0x0 != 0xa == 0x1 (0x1) +int 0x0 >= 0xa == 0x0 (0x0) +__uint 0x0 >= 0xa == 0x0 (0x0) +char 0x0 >= 0xa == 0x0 (0x0) +__uchar 0x0 >= 0xa == 0x0 (0x0) +__longlong 0x0 >= 0xa == 0x0 (0x0) +__ulonglong 0x0 >= 0xa == 0x0 (0x0) +float 0x0 >= 0xa == 0x0 (0x0) +int 0x0 / 0xa == 0x0 (0x0) +__uint 0x0 / 0xa == 0x0 (0x0) +char 0x0 / 0xa == 0x0 (0x0) +__uchar 0x0 / 0xa == 0x0 (0x0) +__longlong 0x0 / 0xa == 0x0 (0x0) +__ulonglong 0x0 / 0xa == 0x0 (0x0) +float 0x0 / 0xa == 0x0 (0x0) +int 0x0 % 0xa == 0x0 (0x0) +__uint 0x0 % 0xa == 0x0 (0x0) +char 0x0 % 0xa == 0x0 (0x0) +__uchar 0x0 % 0xa == 0x0 (0x0) +__longlong 0x0 % 0xa == 0x0 (0x0) +__ulonglong 0x0 % 0xa == 0x0 (0x0) +0x0 * 0xfff6 == 0x0 +0x0 / 0xfff6 == 0x0 +0x0 % 0xfff6 == 0x0 +int 0x0 ^ 0xfff6 == -0xa (0xfff6) +__uint 0x0 ^ 0xfff6 == -0xa (0xfff6) +char 0x0 ^ 0xfff6 == -0xa (0xfff6) +__uchar 0x0 ^ 0xf6 == 0xf6 (0xf6) +__longlong 0x0 ^ 0xfff6 == -0xa (0xfff6) +__ulonglong 0x0 ^ 0xfff6 == -0xa (0xfff6) +int 0x0 && 0xfff6 == 0x0 (0x0) +__uint 0x0 && 0xfff6 == 0x0 (0x0) +char 0x0 && 0xfff6 == 0x0 (0x0) +__uchar 0x0 && 0xf6 == 0x0 (0x0) +__longlong 0x0 && 0xfff6 == 0x0 (0x0) +__ulonglong 0x0 && 0xfff6 == 0x0 (0x0) +int 0x0 || 0xfff6 == 0x1 (0x1) +__uint 0x0 || 0xfff6 == 0x1 (0x1) +char 0x0 || 0xfff6 == 0x1 (0x1) +__uchar 0x0 || 0xf6 == 0x1 (0x1) +__longlong 0x0 || 0xfff6 == 0x1 (0x1) +__ulonglong 0x0 || 0xfff6 == 0x1 (0x1) +int 0x0 & 0xfff6 == 0x0 (0x0) +__uint 0x0 & 0xfff6 == 0x0 (0x0) +char 0x0 & 0xfff6 == 0x0 (0x0) +__uchar 0x0 & 0xf6 == 0x0 (0x0) +__longlong 0x0 & 0xfff6 == 0x0 (0x0) +__ulonglong 0x0 & 0xfff6 == 0x0 (0x0) +int 0x0 | 0xfff6 == -0xa (0xfff6) +__uint 0x0 | 0xfff6 == -0xa (0xfff6) +char 0x0 | 0xfff6 == -0xa (0xfff6) +__uchar 0x0 | 0xf6 == 0xf6 (0xf6) +__longlong 0x0 | 0xfff6 == -0xa (0xfff6) +__ulonglong 0x0 | 0xfff6 == -0xa (0xfff6) +int 0x0 << 0x8 == 0x0 (0x0) +__uint 0x0 << 0x8 == 0x0 (0x0) +char 0x0 << 0x8 == 0x0 (0x0) +__uchar 0x0 << 0x8 == 0x0 (0x0) +__longlong 0x0 << 0x8 == 0x0 (0x0) +__ulonglong 0x0 << 0x8 == 0x0 (0x0) +int 0x0 >> 0x8 == 0x0 (0x0) +__uint 0x0 >> 0x8 == 0x0 (0x0) +char 0x0 >> 0x8 == 0x0 (0x0) +__uchar 0x0 >> 0x8 == 0x0 (0x0) +__longlong 0x0 >> 0x8 == 0x0 (0x0) +__ulonglong 0x0 >> 0x8 == 0x0 (0x0) +int 0x0 + 0xfff6 == -0xa (0xfff6) +__uint 0x0 + 0xfff6 == -0xa (0xfff6) +char 0x0 + 0xfff6 == -0xa (0xfff6) +__uchar 0x0 + 0xf6 == 0xf6 (0xf6) +__longlong 0x0 + 0xfff6 == -0xa (0xfff6) +__ulonglong 0x0 + 0xfff6 == -0xa (0xfff6) +float 0x0 + 0xfff6 == -0xa (0xfff6) +int 0x0 - 0xfff6 == 0xa (0xa) +__uint 0x0 - 0xfff6 == 0xa (0xa) +char 0x0 - 0xfff6 == 0xa (0xa) +__uchar 0x0 - 0xf6 == 0xa (0xa) +__longlong 0x0 - 0xfff6 == 0xa (0xa) +__ulonglong 0x0 - 0xfff6 == 0xa (0xa) +float 0x0 - 0xfff6 == 0xa (0xa) +int 0x0 * 0xfff6 == 0x0 (0x0) +__uint 0x0 * 0xfff6 == 0x0 (0x0) +char 0x0 * 0xfff6 == 0x0 (0x0) +__uchar 0x0 * 0xf6 == 0x0 (0x0) +__longlong 0x0 * 0xfff6 == 0x0 (0x0) +__ulonglong 0x0 * 0xfff6 == 0x0 (0x0) +float 0x0 * 0xfff6 == 0x0 (0x0) +int 0x0 < 0xfff6 == 0x0 (0x0) +__uint 0x0 < 0xfff6 == 0x1 (0x1) +char 0x0 < 0xfff6 == 0x0 (0x0) +__uchar 0x0 < 0xf6 == 0x1 (0x1) +__longlong 0x0 < 0xfff6 == 0x0 (0x0) +__ulonglong 0x0 < 0xfff6 == 0x1 (0x1) +float 0x0 < 0xfff6 == 0x0 (0x0) +int 0x0 > 0xfff6 == 0x1 (0x1) +__uint 0x0 > 0xfff6 == 0x0 (0x0) +char 0x0 > 0xfff6 == 0x1 (0x1) +__uchar 0x0 > 0xf6 == 0x0 (0x0) +__longlong 0x0 > 0xfff6 == 0x1 (0x1) +__ulonglong 0x0 > 0xfff6 == 0x0 (0x0) +float 0x0 > 0xfff6 == 0x1 (0x1) +int 0x0 <= 0xfff6 == 0x0 (0x0) +__uint 0x0 <= 0xfff6 == 0x1 (0x1) +char 0x0 <= 0xfff6 == 0x0 (0x0) +__uchar 0x0 <= 0xf6 == 0x1 (0x1) +__longlong 0x0 <= 0xfff6 == 0x0 (0x0) +__ulonglong 0x0 <= 0xfff6 == 0x1 (0x1) +float 0x0 <= 0xfff6 == 0x0 (0x0) +int 0x0 == 0xfff6 == 0x0 (0x0) +__uint 0x0 == 0xfff6 == 0x0 (0x0) +char 0x0 == 0xfff6 == 0x0 (0x0) +__uchar 0x0 == 0xf6 == 0x0 (0x0) +__longlong 0x0 == 0xfff6 == 0x0 (0x0) +__ulonglong 0x0 == 0xfff6 == 0x0 (0x0) +float 0x0 == 0xfff6 == 0x0 (0x0) +int 0x0 != 0xfff6 == 0x1 (0x1) +__uint 0x0 != 0xfff6 == 0x1 (0x1) +char 0x0 != 0xfff6 == 0x1 (0x1) +__uchar 0x0 != 0xf6 == 0x1 (0x1) +__longlong 0x0 != 0xfff6 == 0x1 (0x1) +__ulonglong 0x0 != 0xfff6 == 0x1 (0x1) +float 0x0 != 0xfff6 == 0x1 (0x1) +int 0x0 >= 0xfff6 == 0x1 (0x1) +__uint 0x0 >= 0xfff6 == 0x0 (0x0) +char 0x0 >= 0xfff6 == 0x1 (0x1) +__uchar 0x0 >= 0xf6 == 0x0 (0x0) +__longlong 0x0 >= 0xfff6 == 0x1 (0x1) +__ulonglong 0x0 >= 0xfff6 == 0x0 (0x0) +float 0x0 >= 0xfff6 == 0x1 (0x1) +int 0x0 / 0xfff6 == 0x0 (0x0) +__uint 0x0 / 0xfff6 == 0x0 (0x0) +char 0x0 / 0xfff6 == 0x0 (0x0) +__uchar 0x0 / 0xf6 == 0x0 (0x0) +__longlong 0x0 / 0xfff6 == 0x0 (0x0) +__ulonglong 0x0 / 0xfff6 == 0x0 (0x0) +float 0x0 / 0xfff6 == 0x0 (0x0) +int 0x0 % 0xfff6 == 0x0 (0x0) +__uint 0x0 % 0xfff6 == 0x0 (0x0) +char 0x0 % 0xfff6 == 0x0 (0x0) +__uchar 0x0 % 0xf6 == 0x0 (0x0) +__longlong 0x0 % 0xfff6 == 0x0 (0x0) +__ulonglong 0x0 % 0xfff6 == 0x0 (0x0) +0x0 * 0x5 == 0x0 +0x0 / 0x5 == 0x0 +0x0 % 0x5 == 0x0 +int 0x0 ^ 0x5 == 0x5 (0x5) +__uint 0x0 ^ 0x5 == 0x5 (0x5) +char 0x0 ^ 0x5 == 0x5 (0x5) +__uchar 0x0 ^ 0x5 == 0x5 (0x5) +__longlong 0x0 ^ 0x5 == 0x5 (0x5) +__ulonglong 0x0 ^ 0x5 == 0x5 (0x5) +int 0x0 && 0x5 == 0x0 (0x0) +__uint 0x0 && 0x5 == 0x0 (0x0) +char 0x0 && 0x5 == 0x0 (0x0) +__uchar 0x0 && 0x5 == 0x0 (0x0) +__longlong 0x0 && 0x5 == 0x0 (0x0) +__ulonglong 0x0 && 0x5 == 0x0 (0x0) +int 0x0 || 0x5 == 0x1 (0x1) +__uint 0x0 || 0x5 == 0x1 (0x1) +char 0x0 || 0x5 == 0x1 (0x1) +__uchar 0x0 || 0x5 == 0x1 (0x1) +__longlong 0x0 || 0x5 == 0x1 (0x1) +__ulonglong 0x0 || 0x5 == 0x1 (0x1) +int 0x0 & 0x5 == 0x0 (0x0) +__uint 0x0 & 0x5 == 0x0 (0x0) +char 0x0 & 0x5 == 0x0 (0x0) +__uchar 0x0 & 0x5 == 0x0 (0x0) +__longlong 0x0 & 0x5 == 0x0 (0x0) +__ulonglong 0x0 & 0x5 == 0x0 (0x0) +int 0x0 | 0x5 == 0x5 (0x5) +__uint 0x0 | 0x5 == 0x5 (0x5) +char 0x0 | 0x5 == 0x5 (0x5) +__uchar 0x0 | 0x5 == 0x5 (0x5) +__longlong 0x0 | 0x5 == 0x5 (0x5) +__ulonglong 0x0 | 0x5 == 0x5 (0x5) +int 0x0 << 0x9 == 0x0 (0x0) +__uint 0x0 << 0x9 == 0x0 (0x0) +char 0x0 << 0x9 == 0x0 (0x0) +__uchar 0x0 << 0x9 == 0x0 (0x0) +__longlong 0x0 << 0x9 == 0x0 (0x0) +__ulonglong 0x0 << 0x9 == 0x0 (0x0) +int 0x0 >> 0x9 == 0x0 (0x0) +__uint 0x0 >> 0x9 == 0x0 (0x0) +char 0x0 >> 0x9 == 0x0 (0x0) +__uchar 0x0 >> 0x9 == 0x0 (0x0) +__longlong 0x0 >> 0x9 == 0x0 (0x0) +__ulonglong 0x0 >> 0x9 == 0x0 (0x0) +int 0x0 + 0x5 == 0x5 (0x5) +__uint 0x0 + 0x5 == 0x5 (0x5) +char 0x0 + 0x5 == 0x5 (0x5) +__uchar 0x0 + 0x5 == 0x5 (0x5) +__longlong 0x0 + 0x5 == 0x5 (0x5) +__ulonglong 0x0 + 0x5 == 0x5 (0x5) +float 0x0 + 0x5 == 0x5 (0x5) +int 0x0 - 0x5 == -0x5 (0xfffb) +__uint 0x0 - 0x5 == -0x5 (0xfffb) +char 0x0 - 0x5 == -0x5 (0xfffb) +__uchar 0x0 - 0x5 == 0xfb (0xfb) +__longlong 0x0 - 0x5 == -0x5 (0xfffb) +__ulonglong 0x0 - 0x5 == -0x5 (0xfffb) +float 0x0 - 0x5 == -0x5 (0xfffb) +int 0x0 * 0x5 == 0x0 (0x0) +__uint 0x0 * 0x5 == 0x0 (0x0) +char 0x0 * 0x5 == 0x0 (0x0) +__uchar 0x0 * 0x5 == 0x0 (0x0) +__longlong 0x0 * 0x5 == 0x0 (0x0) +__ulonglong 0x0 * 0x5 == 0x0 (0x0) +float 0x0 * 0x5 == 0x0 (0x0) +int 0x0 < 0x5 == 0x1 (0x1) +__uint 0x0 < 0x5 == 0x1 (0x1) +char 0x0 < 0x5 == 0x1 (0x1) +__uchar 0x0 < 0x5 == 0x1 (0x1) +__longlong 0x0 < 0x5 == 0x1 (0x1) +__ulonglong 0x0 < 0x5 == 0x1 (0x1) +float 0x0 < 0x5 == 0x1 (0x1) +int 0x0 > 0x5 == 0x0 (0x0) +__uint 0x0 > 0x5 == 0x0 (0x0) +char 0x0 > 0x5 == 0x0 (0x0) +__uchar 0x0 > 0x5 == 0x0 (0x0) +__longlong 0x0 > 0x5 == 0x0 (0x0) +__ulonglong 0x0 > 0x5 == 0x0 (0x0) +float 0x0 > 0x5 == 0x0 (0x0) +int 0x0 <= 0x5 == 0x1 (0x1) +__uint 0x0 <= 0x5 == 0x1 (0x1) +char 0x0 <= 0x5 == 0x1 (0x1) +__uchar 0x0 <= 0x5 == 0x1 (0x1) +__longlong 0x0 <= 0x5 == 0x1 (0x1) +__ulonglong 0x0 <= 0x5 == 0x1 (0x1) +float 0x0 <= 0x5 == 0x1 (0x1) +int 0x0 == 0x5 == 0x0 (0x0) +__uint 0x0 == 0x5 == 0x0 (0x0) +char 0x0 == 0x5 == 0x0 (0x0) +__uchar 0x0 == 0x5 == 0x0 (0x0) +__longlong 0x0 == 0x5 == 0x0 (0x0) +__ulonglong 0x0 == 0x5 == 0x0 (0x0) +float 0x0 == 0x5 == 0x0 (0x0) +int 0x0 != 0x5 == 0x1 (0x1) +__uint 0x0 != 0x5 == 0x1 (0x1) +char 0x0 != 0x5 == 0x1 (0x1) +__uchar 0x0 != 0x5 == 0x1 (0x1) +__longlong 0x0 != 0x5 == 0x1 (0x1) +__ulonglong 0x0 != 0x5 == 0x1 (0x1) +float 0x0 != 0x5 == 0x1 (0x1) +int 0x0 >= 0x5 == 0x0 (0x0) +__uint 0x0 >= 0x5 == 0x0 (0x0) +char 0x0 >= 0x5 == 0x0 (0x0) +__uchar 0x0 >= 0x5 == 0x0 (0x0) +__longlong 0x0 >= 0x5 == 0x0 (0x0) +__ulonglong 0x0 >= 0x5 == 0x0 (0x0) +float 0x0 >= 0x5 == 0x0 (0x0) +int 0x0 / 0x5 == 0x0 (0x0) +__uint 0x0 / 0x5 == 0x0 (0x0) +char 0x0 / 0x5 == 0x0 (0x0) +__uchar 0x0 / 0x5 == 0x0 (0x0) +__longlong 0x0 / 0x5 == 0x0 (0x0) +__ulonglong 0x0 / 0x5 == 0x0 (0x0) +float 0x0 / 0x5 == 0x0 (0x0) +int 0x0 % 0x5 == 0x0 (0x0) +__uint 0x0 % 0x5 == 0x0 (0x0) +char 0x0 % 0x5 == 0x0 (0x0) +__uchar 0x0 % 0x5 == 0x0 (0x0) +__longlong 0x0 % 0x5 == 0x0 (0x0) +__ulonglong 0x0 % 0x5 == 0x0 (0x0) +0x0 * 0x7 == 0x0 +0x0 / 0x7 == 0x0 +0x0 % 0x7 == 0x0 +int 0x0 ^ 0x7 == 0x7 (0x7) +__uint 0x0 ^ 0x7 == 0x7 (0x7) +char 0x0 ^ 0x7 == 0x7 (0x7) +__uchar 0x0 ^ 0x7 == 0x7 (0x7) +__longlong 0x0 ^ 0x7 == 0x7 (0x7) +__ulonglong 0x0 ^ 0x7 == 0x7 (0x7) +int 0x0 && 0x7 == 0x0 (0x0) +__uint 0x0 && 0x7 == 0x0 (0x0) +char 0x0 && 0x7 == 0x0 (0x0) +__uchar 0x0 && 0x7 == 0x0 (0x0) +__longlong 0x0 && 0x7 == 0x0 (0x0) +__ulonglong 0x0 && 0x7 == 0x0 (0x0) +int 0x0 || 0x7 == 0x1 (0x1) +__uint 0x0 || 0x7 == 0x1 (0x1) +char 0x0 || 0x7 == 0x1 (0x1) +__uchar 0x0 || 0x7 == 0x1 (0x1) +__longlong 0x0 || 0x7 == 0x1 (0x1) +__ulonglong 0x0 || 0x7 == 0x1 (0x1) +int 0x0 & 0x7 == 0x0 (0x0) +__uint 0x0 & 0x7 == 0x0 (0x0) +char 0x0 & 0x7 == 0x0 (0x0) +__uchar 0x0 & 0x7 == 0x0 (0x0) +__longlong 0x0 & 0x7 == 0x0 (0x0) +__ulonglong 0x0 & 0x7 == 0x0 (0x0) +int 0x0 | 0x7 == 0x7 (0x7) +__uint 0x0 | 0x7 == 0x7 (0x7) +char 0x0 | 0x7 == 0x7 (0x7) +__uchar 0x0 | 0x7 == 0x7 (0x7) +__longlong 0x0 | 0x7 == 0x7 (0x7) +__ulonglong 0x0 | 0x7 == 0x7 (0x7) +int 0x0 << 0xa == 0x0 (0x0) +__uint 0x0 << 0xa == 0x0 (0x0) +char 0x0 << 0xa == 0x0 (0x0) +__uchar 0x0 << 0xa == 0x0 (0x0) +__longlong 0x0 << 0xa == 0x0 (0x0) +__ulonglong 0x0 << 0xa == 0x0 (0x0) +int 0x0 >> 0xa == 0x0 (0x0) +__uint 0x0 >> 0xa == 0x0 (0x0) +char 0x0 >> 0xa == 0x0 (0x0) +__uchar 0x0 >> 0xa == 0x0 (0x0) +__longlong 0x0 >> 0xa == 0x0 (0x0) +__ulonglong 0x0 >> 0xa == 0x0 (0x0) +int 0x0 + 0x7 == 0x7 (0x7) +__uint 0x0 + 0x7 == 0x7 (0x7) +char 0x0 + 0x7 == 0x7 (0x7) +__uchar 0x0 + 0x7 == 0x7 (0x7) +__longlong 0x0 + 0x7 == 0x7 (0x7) +__ulonglong 0x0 + 0x7 == 0x7 (0x7) +float 0x0 + 0x7 == 0x7 (0x7) +int 0x0 - 0x7 == -0x7 (0xfff9) +__uint 0x0 - 0x7 == -0x7 (0xfff9) +char 0x0 - 0x7 == -0x7 (0xfff9) +__uchar 0x0 - 0x7 == 0xf9 (0xf9) +__longlong 0x0 - 0x7 == -0x7 (0xfff9) +__ulonglong 0x0 - 0x7 == -0x7 (0xfff9) +float 0x0 - 0x7 == -0x7 (0xfff9) +int 0x0 * 0x7 == 0x0 (0x0) +__uint 0x0 * 0x7 == 0x0 (0x0) +char 0x0 * 0x7 == 0x0 (0x0) +__uchar 0x0 * 0x7 == 0x0 (0x0) +__longlong 0x0 * 0x7 == 0x0 (0x0) +__ulonglong 0x0 * 0x7 == 0x0 (0x0) +float 0x0 * 0x7 == 0x0 (0x0) +int 0x0 < 0x7 == 0x1 (0x1) +__uint 0x0 < 0x7 == 0x1 (0x1) +char 0x0 < 0x7 == 0x1 (0x1) +__uchar 0x0 < 0x7 == 0x1 (0x1) +__longlong 0x0 < 0x7 == 0x1 (0x1) +__ulonglong 0x0 < 0x7 == 0x1 (0x1) +float 0x0 < 0x7 == 0x1 (0x1) +int 0x0 > 0x7 == 0x0 (0x0) +__uint 0x0 > 0x7 == 0x0 (0x0) +char 0x0 > 0x7 == 0x0 (0x0) +__uchar 0x0 > 0x7 == 0x0 (0x0) +__longlong 0x0 > 0x7 == 0x0 (0x0) +__ulonglong 0x0 > 0x7 == 0x0 (0x0) +float 0x0 > 0x7 == 0x0 (0x0) +int 0x0 <= 0x7 == 0x1 (0x1) +__uint 0x0 <= 0x7 == 0x1 (0x1) +char 0x0 <= 0x7 == 0x1 (0x1) +__uchar 0x0 <= 0x7 == 0x1 (0x1) +__longlong 0x0 <= 0x7 == 0x1 (0x1) +__ulonglong 0x0 <= 0x7 == 0x1 (0x1) +float 0x0 <= 0x7 == 0x1 (0x1) +int 0x0 == 0x7 == 0x0 (0x0) +__uint 0x0 == 0x7 == 0x0 (0x0) +char 0x0 == 0x7 == 0x0 (0x0) +__uchar 0x0 == 0x7 == 0x0 (0x0) +__longlong 0x0 == 0x7 == 0x0 (0x0) +__ulonglong 0x0 == 0x7 == 0x0 (0x0) +float 0x0 == 0x7 == 0x0 (0x0) +int 0x0 != 0x7 == 0x1 (0x1) +__uint 0x0 != 0x7 == 0x1 (0x1) +char 0x0 != 0x7 == 0x1 (0x1) +__uchar 0x0 != 0x7 == 0x1 (0x1) +__longlong 0x0 != 0x7 == 0x1 (0x1) +__ulonglong 0x0 != 0x7 == 0x1 (0x1) +float 0x0 != 0x7 == 0x1 (0x1) +int 0x0 >= 0x7 == 0x0 (0x0) +__uint 0x0 >= 0x7 == 0x0 (0x0) +char 0x0 >= 0x7 == 0x0 (0x0) +__uchar 0x0 >= 0x7 == 0x0 (0x0) +__longlong 0x0 >= 0x7 == 0x0 (0x0) +__ulonglong 0x0 >= 0x7 == 0x0 (0x0) +float 0x0 >= 0x7 == 0x0 (0x0) +int 0x0 / 0x7 == 0x0 (0x0) +__uint 0x0 / 0x7 == 0x0 (0x0) +char 0x0 / 0x7 == 0x0 (0x0) +__uchar 0x0 / 0x7 == 0x0 (0x0) +__longlong 0x0 / 0x7 == 0x0 (0x0) +__ulonglong 0x0 / 0x7 == 0x0 (0x0) +float 0x0 / 0x7 == 0x0 (0x0) +int 0x0 % 0x7 == 0x0 (0x0) +__uint 0x0 % 0x7 == 0x0 (0x0) +char 0x0 % 0x7 == 0x0 (0x0) +__uchar 0x0 % 0x7 == 0x0 (0x0) +__longlong 0x0 % 0x7 == 0x0 (0x0) +__ulonglong 0x0 % 0x7 == 0x0 (0x0) +0x0 * 0x2a == 0x0 +0x0 / 0x2a == 0x0 +0x0 % 0x2a == 0x0 +int 0x0 ^ 0x2a == 0x2a (0x2a) +__uint 0x0 ^ 0x2a == 0x2a (0x2a) +char 0x0 ^ 0x2a == 0x2a (0x2a) +__uchar 0x0 ^ 0x2a == 0x2a (0x2a) +__longlong 0x0 ^ 0x2a == 0x2a (0x2a) +__ulonglong 0x0 ^ 0x2a == 0x2a (0x2a) +int 0x0 && 0x2a == 0x0 (0x0) +__uint 0x0 && 0x2a == 0x0 (0x0) +char 0x0 && 0x2a == 0x0 (0x0) +__uchar 0x0 && 0x2a == 0x0 (0x0) +__longlong 0x0 && 0x2a == 0x0 (0x0) +__ulonglong 0x0 && 0x2a == 0x0 (0x0) +int 0x0 || 0x2a == 0x1 (0x1) +__uint 0x0 || 0x2a == 0x1 (0x1) +char 0x0 || 0x2a == 0x1 (0x1) +__uchar 0x0 || 0x2a == 0x1 (0x1) +__longlong 0x0 || 0x2a == 0x1 (0x1) +__ulonglong 0x0 || 0x2a == 0x1 (0x1) +int 0x0 & 0x2a == 0x0 (0x0) +__uint 0x0 & 0x2a == 0x0 (0x0) +char 0x0 & 0x2a == 0x0 (0x0) +__uchar 0x0 & 0x2a == 0x0 (0x0) +__longlong 0x0 & 0x2a == 0x0 (0x0) +__ulonglong 0x0 & 0x2a == 0x0 (0x0) +int 0x0 | 0x2a == 0x2a (0x2a) +__uint 0x0 | 0x2a == 0x2a (0x2a) +char 0x0 | 0x2a == 0x2a (0x2a) +__uchar 0x0 | 0x2a == 0x2a (0x2a) +__longlong 0x0 | 0x2a == 0x2a (0x2a) +__ulonglong 0x0 | 0x2a == 0x2a (0x2a) +int 0x0 << 0xc == 0x0 (0x0) +__uint 0x0 << 0xc == 0x0 (0x0) +char 0x0 << 0xc == 0x0 (0x0) +__uchar 0x0 << 0xc == 0x0 (0x0) +__longlong 0x0 << 0xc == 0x0 (0x0) +__ulonglong 0x0 << 0xc == 0x0 (0x0) +int 0x0 >> 0xc == 0x0 (0x0) +__uint 0x0 >> 0xc == 0x0 (0x0) +char 0x0 >> 0xc == 0x0 (0x0) +__uchar 0x0 >> 0xc == 0x0 (0x0) +__longlong 0x0 >> 0xc == 0x0 (0x0) +__ulonglong 0x0 >> 0xc == 0x0 (0x0) +int 0x0 + 0x2a == 0x2a (0x2a) +__uint 0x0 + 0x2a == 0x2a (0x2a) +char 0x0 + 0x2a == 0x2a (0x2a) +__uchar 0x0 + 0x2a == 0x2a (0x2a) +__longlong 0x0 + 0x2a == 0x2a (0x2a) +__ulonglong 0x0 + 0x2a == 0x2a (0x2a) +float 0x0 + 0x2a == 0x2a (0x2a) +int 0x0 - 0x2a == -0x2a (0xffd6) +__uint 0x0 - 0x2a == -0x2a (0xffd6) +char 0x0 - 0x2a == -0x2a (0xffd6) +__uchar 0x0 - 0x2a == 0xd6 (0xd6) +__longlong 0x0 - 0x2a == -0x2a (0xffd6) +__ulonglong 0x0 - 0x2a == -0x2a (0xffd6) +float 0x0 - 0x2a == -0x2a (0xffd6) +int 0x0 * 0x2a == 0x0 (0x0) +__uint 0x0 * 0x2a == 0x0 (0x0) +char 0x0 * 0x2a == 0x0 (0x0) +__uchar 0x0 * 0x2a == 0x0 (0x0) +__longlong 0x0 * 0x2a == 0x0 (0x0) +__ulonglong 0x0 * 0x2a == 0x0 (0x0) +float 0x0 * 0x2a == 0x0 (0x0) +int 0x0 < 0x2a == 0x1 (0x1) +__uint 0x0 < 0x2a == 0x1 (0x1) +char 0x0 < 0x2a == 0x1 (0x1) +__uchar 0x0 < 0x2a == 0x1 (0x1) +__longlong 0x0 < 0x2a == 0x1 (0x1) +__ulonglong 0x0 < 0x2a == 0x1 (0x1) +float 0x0 < 0x2a == 0x1 (0x1) +int 0x0 > 0x2a == 0x0 (0x0) +__uint 0x0 > 0x2a == 0x0 (0x0) +char 0x0 > 0x2a == 0x0 (0x0) +__uchar 0x0 > 0x2a == 0x0 (0x0) +__longlong 0x0 > 0x2a == 0x0 (0x0) +__ulonglong 0x0 > 0x2a == 0x0 (0x0) +float 0x0 > 0x2a == 0x0 (0x0) +int 0x0 <= 0x2a == 0x1 (0x1) +__uint 0x0 <= 0x2a == 0x1 (0x1) +char 0x0 <= 0x2a == 0x1 (0x1) +__uchar 0x0 <= 0x2a == 0x1 (0x1) +__longlong 0x0 <= 0x2a == 0x1 (0x1) +__ulonglong 0x0 <= 0x2a == 0x1 (0x1) +float 0x0 <= 0x2a == 0x1 (0x1) +int 0x0 == 0x2a == 0x0 (0x0) +__uint 0x0 == 0x2a == 0x0 (0x0) +char 0x0 == 0x2a == 0x0 (0x0) +__uchar 0x0 == 0x2a == 0x0 (0x0) +__longlong 0x0 == 0x2a == 0x0 (0x0) +__ulonglong 0x0 == 0x2a == 0x0 (0x0) +float 0x0 == 0x2a == 0x0 (0x0) +int 0x0 != 0x2a == 0x1 (0x1) +__uint 0x0 != 0x2a == 0x1 (0x1) +char 0x0 != 0x2a == 0x1 (0x1) +__uchar 0x0 != 0x2a == 0x1 (0x1) +__longlong 0x0 != 0x2a == 0x1 (0x1) +__ulonglong 0x0 != 0x2a == 0x1 (0x1) +float 0x0 != 0x2a == 0x1 (0x1) +int 0x0 >= 0x2a == 0x0 (0x0) +__uint 0x0 >= 0x2a == 0x0 (0x0) +char 0x0 >= 0x2a == 0x0 (0x0) +__uchar 0x0 >= 0x2a == 0x0 (0x0) +__longlong 0x0 >= 0x2a == 0x0 (0x0) +__ulonglong 0x0 >= 0x2a == 0x0 (0x0) +float 0x0 >= 0x2a == 0x0 (0x0) +int 0x0 / 0x2a == 0x0 (0x0) +__uint 0x0 / 0x2a == 0x0 (0x0) +char 0x0 / 0x2a == 0x0 (0x0) +__uchar 0x0 / 0x2a == 0x0 (0x0) +__longlong 0x0 / 0x2a == 0x0 (0x0) +__ulonglong 0x0 / 0x2a == 0x0 (0x0) +float 0x0 / 0x2a == 0x0 (0x0) +int 0x0 % 0x2a == 0x0 (0x0) +__uint 0x0 % 0x2a == 0x0 (0x0) +char 0x0 % 0x2a == 0x0 (0x0) +__uchar 0x0 % 0x2a == 0x0 (0x0) +__longlong 0x0 % 0x2a == 0x0 (0x0) +__ulonglong 0x0 % 0x2a == 0x0 (0x0) +0x0 * 0x17 == 0x0 +0x0 / 0x17 == 0x0 +0x0 % 0x17 == 0x0 +int 0x0 ^ 0x17 == 0x17 (0x17) +__uint 0x0 ^ 0x17 == 0x17 (0x17) +char 0x0 ^ 0x17 == 0x17 (0x17) +__uchar 0x0 ^ 0x17 == 0x17 (0x17) +__longlong 0x0 ^ 0x17 == 0x17 (0x17) +__ulonglong 0x0 ^ 0x17 == 0x17 (0x17) +int 0x0 && 0x17 == 0x0 (0x0) +__uint 0x0 && 0x17 == 0x0 (0x0) +char 0x0 && 0x17 == 0x0 (0x0) +__uchar 0x0 && 0x17 == 0x0 (0x0) +__longlong 0x0 && 0x17 == 0x0 (0x0) +__ulonglong 0x0 && 0x17 == 0x0 (0x0) +int 0x0 || 0x17 == 0x1 (0x1) +__uint 0x0 || 0x17 == 0x1 (0x1) +char 0x0 || 0x17 == 0x1 (0x1) +__uchar 0x0 || 0x17 == 0x1 (0x1) +__longlong 0x0 || 0x17 == 0x1 (0x1) +__ulonglong 0x0 || 0x17 == 0x1 (0x1) +int 0x0 & 0x17 == 0x0 (0x0) +__uint 0x0 & 0x17 == 0x0 (0x0) +char 0x0 & 0x17 == 0x0 (0x0) +__uchar 0x0 & 0x17 == 0x0 (0x0) +__longlong 0x0 & 0x17 == 0x0 (0x0) +__ulonglong 0x0 & 0x17 == 0x0 (0x0) +int 0x0 | 0x17 == 0x17 (0x17) +__uint 0x0 | 0x17 == 0x17 (0x17) +char 0x0 | 0x17 == 0x17 (0x17) +__uchar 0x0 | 0x17 == 0x17 (0x17) +__longlong 0x0 | 0x17 == 0x17 (0x17) +__ulonglong 0x0 | 0x17 == 0x17 (0x17) +int 0x0 << 0xe == 0x0 (0x0) +__uint 0x0 << 0xe == 0x0 (0x0) +char 0x0 << 0xe == 0x0 (0x0) +__uchar 0x0 << 0xe == 0x0 (0x0) +__longlong 0x0 << 0xe == 0x0 (0x0) +__ulonglong 0x0 << 0xe == 0x0 (0x0) +int 0x0 >> 0xe == 0x0 (0x0) +__uint 0x0 >> 0xe == 0x0 (0x0) +char 0x0 >> 0xe == 0x0 (0x0) +__uchar 0x0 >> 0xe == 0x0 (0x0) +__longlong 0x0 >> 0xe == 0x0 (0x0) +__ulonglong 0x0 >> 0xe == 0x0 (0x0) +int 0x0 + 0x17 == 0x17 (0x17) +__uint 0x0 + 0x17 == 0x17 (0x17) +char 0x0 + 0x17 == 0x17 (0x17) +__uchar 0x0 + 0x17 == 0x17 (0x17) +__longlong 0x0 + 0x17 == 0x17 (0x17) +__ulonglong 0x0 + 0x17 == 0x17 (0x17) +float 0x0 + 0x17 == 0x17 (0x17) +int 0x0 - 0x17 == -0x17 (0xffe9) +__uint 0x0 - 0x17 == -0x17 (0xffe9) +char 0x0 - 0x17 == -0x17 (0xffe9) +__uchar 0x0 - 0x17 == 0xe9 (0xe9) +__longlong 0x0 - 0x17 == -0x17 (0xffe9) +__ulonglong 0x0 - 0x17 == -0x17 (0xffe9) +float 0x0 - 0x17 == -0x17 (0xffe9) +int 0x0 * 0x17 == 0x0 (0x0) +__uint 0x0 * 0x17 == 0x0 (0x0) +char 0x0 * 0x17 == 0x0 (0x0) +__uchar 0x0 * 0x17 == 0x0 (0x0) +__longlong 0x0 * 0x17 == 0x0 (0x0) +__ulonglong 0x0 * 0x17 == 0x0 (0x0) +float 0x0 * 0x17 == 0x0 (0x0) +int 0x0 < 0x17 == 0x1 (0x1) +__uint 0x0 < 0x17 == 0x1 (0x1) +char 0x0 < 0x17 == 0x1 (0x1) +__uchar 0x0 < 0x17 == 0x1 (0x1) +__longlong 0x0 < 0x17 == 0x1 (0x1) +__ulonglong 0x0 < 0x17 == 0x1 (0x1) +float 0x0 < 0x17 == 0x1 (0x1) +int 0x0 > 0x17 == 0x0 (0x0) +__uint 0x0 > 0x17 == 0x0 (0x0) +char 0x0 > 0x17 == 0x0 (0x0) +__uchar 0x0 > 0x17 == 0x0 (0x0) +__longlong 0x0 > 0x17 == 0x0 (0x0) +__ulonglong 0x0 > 0x17 == 0x0 (0x0) +float 0x0 > 0x17 == 0x0 (0x0) +int 0x0 <= 0x17 == 0x1 (0x1) +__uint 0x0 <= 0x17 == 0x1 (0x1) +char 0x0 <= 0x17 == 0x1 (0x1) +__uchar 0x0 <= 0x17 == 0x1 (0x1) +__longlong 0x0 <= 0x17 == 0x1 (0x1) +__ulonglong 0x0 <= 0x17 == 0x1 (0x1) +float 0x0 <= 0x17 == 0x1 (0x1) +int 0x0 == 0x17 == 0x0 (0x0) +__uint 0x0 == 0x17 == 0x0 (0x0) +char 0x0 == 0x17 == 0x0 (0x0) +__uchar 0x0 == 0x17 == 0x0 (0x0) +__longlong 0x0 == 0x17 == 0x0 (0x0) +__ulonglong 0x0 == 0x17 == 0x0 (0x0) +float 0x0 == 0x17 == 0x0 (0x0) +int 0x0 != 0x17 == 0x1 (0x1) +__uint 0x0 != 0x17 == 0x1 (0x1) +char 0x0 != 0x17 == 0x1 (0x1) +__uchar 0x0 != 0x17 == 0x1 (0x1) +__longlong 0x0 != 0x17 == 0x1 (0x1) +__ulonglong 0x0 != 0x17 == 0x1 (0x1) +float 0x0 != 0x17 == 0x1 (0x1) +int 0x0 >= 0x17 == 0x0 (0x0) +__uint 0x0 >= 0x17 == 0x0 (0x0) +char 0x0 >= 0x17 == 0x0 (0x0) +__uchar 0x0 >= 0x17 == 0x0 (0x0) +__longlong 0x0 >= 0x17 == 0x0 (0x0) +__ulonglong 0x0 >= 0x17 == 0x0 (0x0) +float 0x0 >= 0x17 == 0x0 (0x0) +int 0x0 / 0x17 == 0x0 (0x0) +__uint 0x0 / 0x17 == 0x0 (0x0) +char 0x0 / 0x17 == 0x0 (0x0) +__uchar 0x0 / 0x17 == 0x0 (0x0) +__longlong 0x0 / 0x17 == 0x0 (0x0) +__ulonglong 0x0 / 0x17 == 0x0 (0x0) +float 0x0 / 0x17 == 0x0 (0x0) +int 0x0 % 0x17 == 0x0 (0x0) +__uint 0x0 % 0x17 == 0x0 (0x0) +char 0x0 % 0x17 == 0x0 (0x0) +__uchar 0x0 % 0x17 == 0x0 (0x0) +__longlong 0x0 % 0x17 == 0x0 (0x0) +__ulonglong 0x0 % 0x17 == 0x0 (0x0) +0x0 * 0x7fff == 0x0 +0x0 / 0x7fff == 0x0 +0x0 % 0x7fff == 0x0 +int 0x0 ^ 0x7fff == 0x7fff (0x7fff) +__uint 0x0 ^ 0x7fff == 0x7fff (0x7fff) +char 0x0 ^ 0xffff == -0x1 (0xffff) +__uchar 0x0 ^ 0xff == 0xff (0xff) +__longlong 0x0 ^ 0x7fff == 0x7fff (0x7fff) +__ulonglong 0x0 ^ 0x7fff == 0x7fff (0x7fff) +int 0x0 && 0x7fff == 0x0 (0x0) +__uint 0x0 && 0x7fff == 0x0 (0x0) +char 0x0 && 0xffff == 0x0 (0x0) +__uchar 0x0 && 0xff == 0x0 (0x0) +__longlong 0x0 && 0x7fff == 0x0 (0x0) +__ulonglong 0x0 && 0x7fff == 0x0 (0x0) +int 0x0 || 0x7fff == 0x1 (0x1) +__uint 0x0 || 0x7fff == 0x1 (0x1) +char 0x0 || 0xffff == 0x1 (0x1) +__uchar 0x0 || 0xff == 0x1 (0x1) +__longlong 0x0 || 0x7fff == 0x1 (0x1) +__ulonglong 0x0 || 0x7fff == 0x1 (0x1) +int 0x0 & 0x7fff == 0x0 (0x0) +__uint 0x0 & 0x7fff == 0x0 (0x0) +char 0x0 & 0xffff == 0x0 (0x0) +__uchar 0x0 & 0xff == 0x0 (0x0) +__longlong 0x0 & 0x7fff == 0x0 (0x0) +__ulonglong 0x0 & 0x7fff == 0x0 (0x0) +int 0x0 | 0x7fff == 0x7fff (0x7fff) +__uint 0x0 | 0x7fff == 0x7fff (0x7fff) +char 0x0 | 0xffff == -0x1 (0xffff) +__uchar 0x0 | 0xff == 0xff (0xff) +__longlong 0x0 | 0x7fff == 0x7fff (0x7fff) +__ulonglong 0x0 | 0x7fff == 0x7fff (0x7fff) +int 0x0 << 0x10 == 0x0 (0x0) +__uint 0x0 << 0x10 == 0x0 (0x0) +char 0x0 << 0x10 == 0x0 (0x0) +__uchar 0x0 << 0x10 == 0x0 (0x0) +__longlong 0x0 << 0x10 == 0x0 (0x0) +__ulonglong 0x0 << 0x10 == 0x0 (0x0) +int 0x0 >> 0x10 == 0x0 (0x0) +__uint 0x0 >> 0x10 == 0x0 (0x0) +char 0x0 >> 0x10 == 0x0 (0x0) +__uchar 0x0 >> 0x10 == 0x0 (0x0) +__longlong 0x0 >> 0x10 == 0x0 (0x0) +__ulonglong 0x0 >> 0x10 == 0x0 (0x0) +int 0x0 + 0x7fff == 0x7fff (0x7fff) +__uint 0x0 + 0x7fff == 0x7fff (0x7fff) +char 0x0 + 0xffff == -0x1 (0xffff) +__uchar 0x0 + 0xff == 0xff (0xff) +__longlong 0x0 + 0x7fff == 0x7fff (0x7fff) +__ulonglong 0x0 + 0x7fff == 0x7fff (0x7fff) +float 0x0 + 0x7fff == 0x7fff (0x7fff) +int 0x0 - 0x7fff == -0x7fff (0x8001) +__uint 0x0 - 0x7fff == -0x7fff (0x8001) +char 0x0 - 0xffff == 0x1 (0x1) +__uchar 0x0 - 0xff == 0x1 (0x1) +__longlong 0x0 - 0x7fff == -0x7fff (0x8001) +__ulonglong 0x0 - 0x7fff == -0x7fff (0x8001) +float 0x0 - 0x7fff == -0x7fff (0x8001) +int 0x0 * 0x7fff == 0x0 (0x0) +__uint 0x0 * 0x7fff == 0x0 (0x0) +char 0x0 * 0xffff == 0x0 (0x0) +__uchar 0x0 * 0xff == 0x0 (0x0) +__longlong 0x0 * 0x7fff == 0x0 (0x0) +__ulonglong 0x0 * 0x7fff == 0x0 (0x0) +float 0x0 * 0x7fff == 0x0 (0x0) +int 0x0 < 0x7fff == 0x1 (0x1) +__uint 0x0 < 0x7fff == 0x1 (0x1) +char 0x0 < 0xffff == 0x0 (0x0) +__uchar 0x0 < 0xff == 0x1 (0x1) +__longlong 0x0 < 0x7fff == 0x1 (0x1) +__ulonglong 0x0 < 0x7fff == 0x1 (0x1) +float 0x0 < 0x7fff == 0x1 (0x1) +int 0x0 > 0x7fff == 0x0 (0x0) +__uint 0x0 > 0x7fff == 0x0 (0x0) +char 0x0 > 0xffff == 0x1 (0x1) +__uchar 0x0 > 0xff == 0x0 (0x0) +__longlong 0x0 > 0x7fff == 0x0 (0x0) +__ulonglong 0x0 > 0x7fff == 0x0 (0x0) +float 0x0 > 0x7fff == 0x0 (0x0) +int 0x0 <= 0x7fff == 0x1 (0x1) +__uint 0x0 <= 0x7fff == 0x1 (0x1) +char 0x0 <= 0xffff == 0x0 (0x0) +__uchar 0x0 <= 0xff == 0x1 (0x1) +__longlong 0x0 <= 0x7fff == 0x1 (0x1) +__ulonglong 0x0 <= 0x7fff == 0x1 (0x1) +float 0x0 <= 0x7fff == 0x1 (0x1) +int 0x0 == 0x7fff == 0x0 (0x0) +__uint 0x0 == 0x7fff == 0x0 (0x0) +char 0x0 == 0xffff == 0x0 (0x0) +__uchar 0x0 == 0xff == 0x0 (0x0) +__longlong 0x0 == 0x7fff == 0x0 (0x0) +__ulonglong 0x0 == 0x7fff == 0x0 (0x0) +float 0x0 == 0x7fff == 0x0 (0x0) +int 0x0 != 0x7fff == 0x1 (0x1) +__uint 0x0 != 0x7fff == 0x1 (0x1) +char 0x0 != 0xffff == 0x1 (0x1) +__uchar 0x0 != 0xff == 0x1 (0x1) +__longlong 0x0 != 0x7fff == 0x1 (0x1) +__ulonglong 0x0 != 0x7fff == 0x1 (0x1) +float 0x0 != 0x7fff == 0x1 (0x1) +int 0x0 >= 0x7fff == 0x0 (0x0) +__uint 0x0 >= 0x7fff == 0x0 (0x0) +char 0x0 >= 0xffff == 0x1 (0x1) +__uchar 0x0 >= 0xff == 0x0 (0x0) +__longlong 0x0 >= 0x7fff == 0x0 (0x0) +__ulonglong 0x0 >= 0x7fff == 0x0 (0x0) +float 0x0 >= 0x7fff == 0x0 (0x0) +int 0x0 / 0x7fff == 0x0 (0x0) +__uint 0x0 / 0x7fff == 0x0 (0x0) +char 0x0 / 0xffff == 0x0 (0x0) +__uchar 0x0 / 0xff == 0x0 (0x0) +__longlong 0x0 / 0x7fff == 0x0 (0x0) +__ulonglong 0x0 / 0x7fff == 0x0 (0x0) +float 0x0 / 0x7fff == 0x0 (0x0) +int 0x0 % 0x7fff == 0x0 (0x0) +__uint 0x0 % 0x7fff == 0x0 (0x0) +char 0x0 % 0xffff == 0x0 (0x0) +__uchar 0x0 % 0xff == 0x0 (0x0) +__longlong 0x0 % 0x7fff == 0x0 (0x0) +__ulonglong 0x0 % 0x7fff == 0x0 (0x0) +0x0 * 0x8000 == 0x0 +0x0 / 0x8000 == 0x0 +0x0 % 0x8000 == 0x0 +int 0x0 ^ 0x8000 == -0x8000 (0x8000) +__uint 0x0 ^ 0x8000 == -0x8000 (0x8000) +char 0x0 ^ 0x0 == 0x0 (0x0) +__uchar 0x0 ^ 0x0 == 0x0 (0x0) +__longlong 0x0 ^ 0x8000 == -0x8000 (0x8000) +__ulonglong 0x0 ^ 0x8000 == -0x8000 (0x8000) +int 0x0 && 0x8000 == 0x0 (0x0) +__uint 0x0 && 0x8000 == 0x0 (0x0) +char 0x0 && 0x0 == 0x0 (0x0) +__uchar 0x0 && 0x0 == 0x0 (0x0) +__longlong 0x0 && 0x8000 == 0x0 (0x0) +__ulonglong 0x0 && 0x8000 == 0x0 (0x0) +int 0x0 || 0x8000 == 0x1 (0x1) +__uint 0x0 || 0x8000 == 0x1 (0x1) +char 0x0 || 0x0 == 0x0 (0x0) +__uchar 0x0 || 0x0 == 0x0 (0x0) +__longlong 0x0 || 0x8000 == 0x1 (0x1) +__ulonglong 0x0 || 0x8000 == 0x1 (0x1) +int 0x0 & 0x8000 == 0x0 (0x0) +__uint 0x0 & 0x8000 == 0x0 (0x0) +char 0x0 & 0x0 == 0x0 (0x0) +__uchar 0x0 & 0x0 == 0x0 (0x0) +__longlong 0x0 & 0x8000 == 0x0 (0x0) +__ulonglong 0x0 & 0x8000 == 0x0 (0x0) +int 0x0 | 0x8000 == -0x8000 (0x8000) +__uint 0x0 | 0x8000 == -0x8000 (0x8000) +char 0x0 | 0x0 == 0x0 (0x0) +__uchar 0x0 | 0x0 == 0x0 (0x0) +__longlong 0x0 | 0x8000 == -0x8000 (0x8000) +__ulonglong 0x0 | 0x8000 == -0x8000 (0x8000) +int 0x0 << 0x12 == 0x0 (0x0) +__uint 0x0 << 0x12 == 0x0 (0x0) +char 0x0 << 0x12 == 0x0 (0x0) +__uchar 0x0 << 0x12 == 0x0 (0x0) +__longlong 0x0 << 0x12 == 0x0 (0x0) +__ulonglong 0x0 << 0x12 == 0x0 (0x0) +int 0x0 >> 0x12 == 0x0 (0x0) +__uint 0x0 >> 0x12 == 0x0 (0x0) +char 0x0 >> 0x12 == 0x0 (0x0) +__uchar 0x0 >> 0x12 == 0x0 (0x0) +__longlong 0x0 >> 0x12 == 0x0 (0x0) +__ulonglong 0x0 >> 0x12 == 0x0 (0x0) +int 0x0 + 0x8000 == -0x8000 (0x8000) +__uint 0x0 + 0x8000 == -0x8000 (0x8000) +char 0x0 + 0x0 == 0x0 (0x0) +__uchar 0x0 + 0x0 == 0x0 (0x0) +__longlong 0x0 + 0x8000 == -0x8000 (0x8000) +__ulonglong 0x0 + 0x8000 == -0x8000 (0x8000) +float 0x0 + 0x8000 == -0x8000 (0x8000) +int 0x0 - 0x8000 == -0x8000 (0x8000) +__uint 0x0 - 0x8000 == -0x8000 (0x8000) +char 0x0 - 0x0 == 0x0 (0x0) +__uchar 0x0 - 0x0 == 0x0 (0x0) +__longlong 0x0 - 0x8000 == -0x8000 (0x8000) +__ulonglong 0x0 - 0x8000 == -0x8000 (0x8000) +float 0x0 - 0x8000 == -0x8000 (0x8000) +int 0x0 * 0x8000 == 0x0 (0x0) +__uint 0x0 * 0x8000 == 0x0 (0x0) +char 0x0 * 0x0 == 0x0 (0x0) +__uchar 0x0 * 0x0 == 0x0 (0x0) +__longlong 0x0 * 0x8000 == 0x0 (0x0) +__ulonglong 0x0 * 0x8000 == 0x0 (0x0) +float 0x0 * 0x8000 == 0x0 (0x0) +int 0x0 < 0x8000 == 0x0 (0x0) +__uint 0x0 < 0x8000 == 0x1 (0x1) +char 0x0 < 0x0 == 0x0 (0x0) +__uchar 0x0 < 0x0 == 0x0 (0x0) +__longlong 0x0 < 0x8000 == 0x0 (0x0) +__ulonglong 0x0 < 0x8000 == 0x1 (0x1) +float 0x0 < 0x8000 == 0x0 (0x0) +int 0x0 > 0x8000 == 0x1 (0x1) +__uint 0x0 > 0x8000 == 0x0 (0x0) +char 0x0 > 0x0 == 0x0 (0x0) +__uchar 0x0 > 0x0 == 0x0 (0x0) +__longlong 0x0 > 0x8000 == 0x1 (0x1) +__ulonglong 0x0 > 0x8000 == 0x0 (0x0) +float 0x0 > 0x8000 == 0x1 (0x1) +int 0x0 <= 0x8000 == 0x0 (0x0) +__uint 0x0 <= 0x8000 == 0x1 (0x1) +char 0x0 <= 0x0 == 0x1 (0x1) +__uchar 0x0 <= 0x0 == 0x1 (0x1) +__longlong 0x0 <= 0x8000 == 0x0 (0x0) +__ulonglong 0x0 <= 0x8000 == 0x1 (0x1) +float 0x0 <= 0x8000 == 0x0 (0x0) +int 0x0 == 0x8000 == 0x0 (0x0) +__uint 0x0 == 0x8000 == 0x0 (0x0) +char 0x0 == 0x0 == 0x1 (0x1) +__uchar 0x0 == 0x0 == 0x1 (0x1) +__longlong 0x0 == 0x8000 == 0x0 (0x0) +__ulonglong 0x0 == 0x8000 == 0x0 (0x0) +float 0x0 == 0x8000 == 0x0 (0x0) +int 0x0 != 0x8000 == 0x1 (0x1) +__uint 0x0 != 0x8000 == 0x1 (0x1) +char 0x0 != 0x0 == 0x0 (0x0) +__uchar 0x0 != 0x0 == 0x0 (0x0) +__longlong 0x0 != 0x8000 == 0x1 (0x1) +__ulonglong 0x0 != 0x8000 == 0x1 (0x1) +float 0x0 != 0x8000 == 0x1 (0x1) +int 0x0 >= 0x8000 == 0x1 (0x1) +__uint 0x0 >= 0x8000 == 0x0 (0x0) +char 0x0 >= 0x0 == 0x1 (0x1) +__uchar 0x0 >= 0x0 == 0x1 (0x1) +__longlong 0x0 >= 0x8000 == 0x1 (0x1) +__ulonglong 0x0 >= 0x8000 == 0x0 (0x0) +float 0x0 >= 0x8000 == 0x1 (0x1) +int 0x0 / 0x8000 == 0x0 (0x0) +__uint 0x0 / 0x8000 == 0x0 (0x0) +__longlong 0x0 / 0x8000 == 0x0 (0x0) +__ulonglong 0x0 / 0x8000 == 0x0 (0x0) +float 0x0 / 0x8000 == 0x0 (0x0) +int 0x0 % 0x8000 == 0x0 (0x0) +__uint 0x0 % 0x8000 == 0x0 (0x0) +__longlong 0x0 % 0x8000 == 0x0 (0x0) +__ulonglong 0x0 % 0x8000 == 0x0 (0x0) +0x0 * 0x3e8 == 0x0 +0x0 / 0x3e8 == 0x0 +0x0 % 0x3e8 == 0x0 +int 0x0 ^ 0x3e8 == 0x3e8 (0x3e8) +__uint 0x0 ^ 0x3e8 == 0x3e8 (0x3e8) +char 0x0 ^ 0xffe8 == -0x18 (0xffe8) +__uchar 0x0 ^ 0xe8 == 0xe8 (0xe8) +__longlong 0x0 ^ 0x3e8 == 0x3e8 (0x3e8) +__ulonglong 0x0 ^ 0x3e8 == 0x3e8 (0x3e8) +int 0x0 && 0x3e8 == 0x0 (0x0) +__uint 0x0 && 0x3e8 == 0x0 (0x0) +char 0x0 && 0xffe8 == 0x0 (0x0) +__uchar 0x0 && 0xe8 == 0x0 (0x0) +__longlong 0x0 && 0x3e8 == 0x0 (0x0) +__ulonglong 0x0 && 0x3e8 == 0x0 (0x0) +int 0x0 || 0x3e8 == 0x1 (0x1) +__uint 0x0 || 0x3e8 == 0x1 (0x1) +char 0x0 || 0xffe8 == 0x1 (0x1) +__uchar 0x0 || 0xe8 == 0x1 (0x1) +__longlong 0x0 || 0x3e8 == 0x1 (0x1) +__ulonglong 0x0 || 0x3e8 == 0x1 (0x1) +int 0x0 & 0x3e8 == 0x0 (0x0) +__uint 0x0 & 0x3e8 == 0x0 (0x0) +char 0x0 & 0xffe8 == 0x0 (0x0) +__uchar 0x0 & 0xe8 == 0x0 (0x0) +__longlong 0x0 & 0x3e8 == 0x0 (0x0) +__ulonglong 0x0 & 0x3e8 == 0x0 (0x0) +int 0x0 | 0x3e8 == 0x3e8 (0x3e8) +__uint 0x0 | 0x3e8 == 0x3e8 (0x3e8) +char 0x0 | 0xffe8 == -0x18 (0xffe8) +__uchar 0x0 | 0xe8 == 0xe8 (0xe8) +__longlong 0x0 | 0x3e8 == 0x3e8 (0x3e8) +__ulonglong 0x0 | 0x3e8 == 0x3e8 (0x3e8) +int 0x0 << 0x14 == 0x0 (0x0) +__uint 0x0 << 0x14 == 0x0 (0x0) +char 0x0 << 0x14 == 0x0 (0x0) +__uchar 0x0 << 0x14 == 0x0 (0x0) +__longlong 0x0 << 0x14 == 0x0 (0x0) +__ulonglong 0x0 << 0x14 == 0x0 (0x0) +int 0x0 >> 0x14 == 0x0 (0x0) +__uint 0x0 >> 0x14 == 0x0 (0x0) +char 0x0 >> 0x14 == 0x0 (0x0) +__uchar 0x0 >> 0x14 == 0x0 (0x0) +__longlong 0x0 >> 0x14 == 0x0 (0x0) +__ulonglong 0x0 >> 0x14 == 0x0 (0x0) +int 0x0 + 0x3e8 == 0x3e8 (0x3e8) +__uint 0x0 + 0x3e8 == 0x3e8 (0x3e8) +char 0x0 + 0xffe8 == -0x18 (0xffe8) +__uchar 0x0 + 0xe8 == 0xe8 (0xe8) +__longlong 0x0 + 0x3e8 == 0x3e8 (0x3e8) +__ulonglong 0x0 + 0x3e8 == 0x3e8 (0x3e8) +float 0x0 + 0x3e8 == 0x3e8 (0x3e8) +int 0x0 - 0x3e8 == -0x3e8 (0xfc18) +__uint 0x0 - 0x3e8 == -0x3e8 (0xfc18) +char 0x0 - 0xffe8 == 0x18 (0x18) +__uchar 0x0 - 0xe8 == 0x18 (0x18) +__longlong 0x0 - 0x3e8 == -0x3e8 (0xfc18) +__ulonglong 0x0 - 0x3e8 == -0x3e8 (0xfc18) +float 0x0 - 0x3e8 == -0x3e8 (0xfc18) +int 0x0 * 0x3e8 == 0x0 (0x0) +__uint 0x0 * 0x3e8 == 0x0 (0x0) +char 0x0 * 0xffe8 == 0x0 (0x0) +__uchar 0x0 * 0xe8 == 0x0 (0x0) +__longlong 0x0 * 0x3e8 == 0x0 (0x0) +__ulonglong 0x0 * 0x3e8 == 0x0 (0x0) +float 0x0 * 0x3e8 == 0x0 (0x0) +int 0x0 < 0x3e8 == 0x1 (0x1) +__uint 0x0 < 0x3e8 == 0x1 (0x1) +char 0x0 < 0xffe8 == 0x0 (0x0) +__uchar 0x0 < 0xe8 == 0x1 (0x1) +__longlong 0x0 < 0x3e8 == 0x1 (0x1) +__ulonglong 0x0 < 0x3e8 == 0x1 (0x1) +float 0x0 < 0x3e8 == 0x1 (0x1) +int 0x0 > 0x3e8 == 0x0 (0x0) +__uint 0x0 > 0x3e8 == 0x0 (0x0) +char 0x0 > 0xffe8 == 0x1 (0x1) +__uchar 0x0 > 0xe8 == 0x0 (0x0) +__longlong 0x0 > 0x3e8 == 0x0 (0x0) +__ulonglong 0x0 > 0x3e8 == 0x0 (0x0) +float 0x0 > 0x3e8 == 0x0 (0x0) +int 0x0 <= 0x3e8 == 0x1 (0x1) +__uint 0x0 <= 0x3e8 == 0x1 (0x1) +char 0x0 <= 0xffe8 == 0x0 (0x0) +__uchar 0x0 <= 0xe8 == 0x1 (0x1) +__longlong 0x0 <= 0x3e8 == 0x1 (0x1) +__ulonglong 0x0 <= 0x3e8 == 0x1 (0x1) +float 0x0 <= 0x3e8 == 0x1 (0x1) +int 0x0 == 0x3e8 == 0x0 (0x0) +__uint 0x0 == 0x3e8 == 0x0 (0x0) +char 0x0 == 0xffe8 == 0x0 (0x0) +__uchar 0x0 == 0xe8 == 0x0 (0x0) +__longlong 0x0 == 0x3e8 == 0x0 (0x0) +__ulonglong 0x0 == 0x3e8 == 0x0 (0x0) +float 0x0 == 0x3e8 == 0x0 (0x0) +int 0x0 != 0x3e8 == 0x1 (0x1) +__uint 0x0 != 0x3e8 == 0x1 (0x1) +char 0x0 != 0xffe8 == 0x1 (0x1) +__uchar 0x0 != 0xe8 == 0x1 (0x1) +__longlong 0x0 != 0x3e8 == 0x1 (0x1) +__ulonglong 0x0 != 0x3e8 == 0x1 (0x1) +float 0x0 != 0x3e8 == 0x1 (0x1) +int 0x0 >= 0x3e8 == 0x0 (0x0) +__uint 0x0 >= 0x3e8 == 0x0 (0x0) +char 0x0 >= 0xffe8 == 0x1 (0x1) +__uchar 0x0 >= 0xe8 == 0x0 (0x0) +__longlong 0x0 >= 0x3e8 == 0x0 (0x0) +__ulonglong 0x0 >= 0x3e8 == 0x0 (0x0) +float 0x0 >= 0x3e8 == 0x0 (0x0) +int 0x0 / 0x3e8 == 0x0 (0x0) +__uint 0x0 / 0x3e8 == 0x0 (0x0) +char 0x0 / 0xffe8 == 0x0 (0x0) +__uchar 0x0 / 0xe8 == 0x0 (0x0) +__longlong 0x0 / 0x3e8 == 0x0 (0x0) +__ulonglong 0x0 / 0x3e8 == 0x0 (0x0) +float 0x0 / 0x3e8 == 0x0 (0x0) +int 0x0 % 0x3e8 == 0x0 (0x0) +__uint 0x0 % 0x3e8 == 0x0 (0x0) +char 0x0 % 0xffe8 == 0x0 (0x0) +__uchar 0x0 % 0xe8 == 0x0 (0x0) +__longlong 0x0 % 0x3e8 == 0x0 (0x0) +__ulonglong 0x0 % 0x3e8 == 0x0 (0x0) +0x0 * 0x2710 == 0x0 +0x0 / 0x2710 == 0x0 +0x0 % 0x2710 == 0x0 +int 0x0 ^ 0x2710 == 0x2710 (0x2710) +__uint 0x0 ^ 0x2710 == 0x2710 (0x2710) +char 0x0 ^ 0x10 == 0x10 (0x10) +__uchar 0x0 ^ 0x10 == 0x10 (0x10) +__longlong 0x0 ^ 0x2710 == 0x2710 (0x2710) +__ulonglong 0x0 ^ 0x2710 == 0x2710 (0x2710) +int 0x0 && 0x2710 == 0x0 (0x0) +__uint 0x0 && 0x2710 == 0x0 (0x0) +char 0x0 && 0x10 == 0x0 (0x0) +__uchar 0x0 && 0x10 == 0x0 (0x0) +__longlong 0x0 && 0x2710 == 0x0 (0x0) +__ulonglong 0x0 && 0x2710 == 0x0 (0x0) +int 0x0 || 0x2710 == 0x1 (0x1) +__uint 0x0 || 0x2710 == 0x1 (0x1) +char 0x0 || 0x10 == 0x1 (0x1) +__uchar 0x0 || 0x10 == 0x1 (0x1) +__longlong 0x0 || 0x2710 == 0x1 (0x1) +__ulonglong 0x0 || 0x2710 == 0x1 (0x1) +int 0x0 & 0x2710 == 0x0 (0x0) +__uint 0x0 & 0x2710 == 0x0 (0x0) +char 0x0 & 0x10 == 0x0 (0x0) +__uchar 0x0 & 0x10 == 0x0 (0x0) +__longlong 0x0 & 0x2710 == 0x0 (0x0) +__ulonglong 0x0 & 0x2710 == 0x0 (0x0) +int 0x0 | 0x2710 == 0x2710 (0x2710) +__uint 0x0 | 0x2710 == 0x2710 (0x2710) +char 0x0 | 0x10 == 0x10 (0x10) +__uchar 0x0 | 0x10 == 0x10 (0x10) +__longlong 0x0 | 0x2710 == 0x2710 (0x2710) +__ulonglong 0x0 | 0x2710 == 0x2710 (0x2710) +int 0x0 << 0x16 == 0x0 (0x0) +__uint 0x0 << 0x16 == 0x0 (0x0) +char 0x0 << 0x16 == 0x0 (0x0) +__uchar 0x0 << 0x16 == 0x0 (0x0) +__longlong 0x0 << 0x16 == 0x0 (0x0) +__ulonglong 0x0 << 0x16 == 0x0 (0x0) +int 0x0 >> 0x16 == 0x0 (0x0) +__uint 0x0 >> 0x16 == 0x0 (0x0) +char 0x0 >> 0x16 == 0x0 (0x0) +__uchar 0x0 >> 0x16 == 0x0 (0x0) +__longlong 0x0 >> 0x16 == 0x0 (0x0) +__ulonglong 0x0 >> 0x16 == 0x0 (0x0) +int 0x0 + 0x2710 == 0x2710 (0x2710) +__uint 0x0 + 0x2710 == 0x2710 (0x2710) +char 0x0 + 0x10 == 0x10 (0x10) +__uchar 0x0 + 0x10 == 0x10 (0x10) +__longlong 0x0 + 0x2710 == 0x2710 (0x2710) +__ulonglong 0x0 + 0x2710 == 0x2710 (0x2710) +float 0x0 + 0x2710 == 0x2710 (0x2710) +int 0x0 - 0x2710 == -0x2710 (0xd8f0) +__uint 0x0 - 0x2710 == -0x2710 (0xd8f0) +char 0x0 - 0x10 == -0x10 (0xfff0) +__uchar 0x0 - 0x10 == 0xf0 (0xf0) +__longlong 0x0 - 0x2710 == -0x2710 (0xd8f0) +__ulonglong 0x0 - 0x2710 == -0x2710 (0xd8f0) +float 0x0 - 0x2710 == -0x2710 (0xd8f0) +int 0x0 * 0x2710 == 0x0 (0x0) +__uint 0x0 * 0x2710 == 0x0 (0x0) +char 0x0 * 0x10 == 0x0 (0x0) +__uchar 0x0 * 0x10 == 0x0 (0x0) +__longlong 0x0 * 0x2710 == 0x0 (0x0) +__ulonglong 0x0 * 0x2710 == 0x0 (0x0) +float 0x0 * 0x2710 == 0x0 (0x0) +int 0x0 < 0x2710 == 0x1 (0x1) +__uint 0x0 < 0x2710 == 0x1 (0x1) +char 0x0 < 0x10 == 0x1 (0x1) +__uchar 0x0 < 0x10 == 0x1 (0x1) +__longlong 0x0 < 0x2710 == 0x1 (0x1) +__ulonglong 0x0 < 0x2710 == 0x1 (0x1) +float 0x0 < 0x2710 == 0x1 (0x1) +int 0x0 > 0x2710 == 0x0 (0x0) +__uint 0x0 > 0x2710 == 0x0 (0x0) +char 0x0 > 0x10 == 0x0 (0x0) +__uchar 0x0 > 0x10 == 0x0 (0x0) +__longlong 0x0 > 0x2710 == 0x0 (0x0) +__ulonglong 0x0 > 0x2710 == 0x0 (0x0) +float 0x0 > 0x2710 == 0x0 (0x0) +int 0x0 <= 0x2710 == 0x1 (0x1) +__uint 0x0 <= 0x2710 == 0x1 (0x1) +char 0x0 <= 0x10 == 0x1 (0x1) +__uchar 0x0 <= 0x10 == 0x1 (0x1) +__longlong 0x0 <= 0x2710 == 0x1 (0x1) +__ulonglong 0x0 <= 0x2710 == 0x1 (0x1) +float 0x0 <= 0x2710 == 0x1 (0x1) +int 0x0 == 0x2710 == 0x0 (0x0) +__uint 0x0 == 0x2710 == 0x0 (0x0) +char 0x0 == 0x10 == 0x0 (0x0) +__uchar 0x0 == 0x10 == 0x0 (0x0) +__longlong 0x0 == 0x2710 == 0x0 (0x0) +__ulonglong 0x0 == 0x2710 == 0x0 (0x0) +float 0x0 == 0x2710 == 0x0 (0x0) +int 0x0 != 0x2710 == 0x1 (0x1) +__uint 0x0 != 0x2710 == 0x1 (0x1) +char 0x0 != 0x10 == 0x1 (0x1) +__uchar 0x0 != 0x10 == 0x1 (0x1) +__longlong 0x0 != 0x2710 == 0x1 (0x1) +__ulonglong 0x0 != 0x2710 == 0x1 (0x1) +float 0x0 != 0x2710 == 0x1 (0x1) +int 0x0 >= 0x2710 == 0x0 (0x0) +__uint 0x0 >= 0x2710 == 0x0 (0x0) +char 0x0 >= 0x10 == 0x0 (0x0) +__uchar 0x0 >= 0x10 == 0x0 (0x0) +__longlong 0x0 >= 0x2710 == 0x0 (0x0) +__ulonglong 0x0 >= 0x2710 == 0x0 (0x0) +float 0x0 >= 0x2710 == 0x0 (0x0) +int 0x0 / 0x2710 == 0x0 (0x0) +__uint 0x0 / 0x2710 == 0x0 (0x0) +char 0x0 / 0x10 == 0x0 (0x0) +__uchar 0x0 / 0x10 == 0x0 (0x0) +__longlong 0x0 / 0x2710 == 0x0 (0x0) +__ulonglong 0x0 / 0x2710 == 0x0 (0x0) +float 0x0 / 0x2710 == 0x0 (0x0) +int 0x0 % 0x2710 == 0x0 (0x0) +__uint 0x0 % 0x2710 == 0x0 (0x0) +char 0x0 % 0x10 == 0x0 (0x0) +__uchar 0x0 % 0x10 == 0x0 (0x0) +__longlong 0x0 % 0x2710 == 0x0 (0x0) +__ulonglong 0x0 % 0x2710 == 0x0 (0x0) +int xor420x0 xor42 0x2a +__uint xor420x0 xor42 0x2a +char xor420x0 xor42 0x2a +__uchar xor420x0 xor42 0x2a +__longlong xor420x0 xor42 0x2a +__ulonglong xor420x0 xor42 0x2a +int land10x0 land1 0x0 +__uint land10x0 land1 0x0 +char land10x0 land1 0x0 +__uchar land10x0 land1 0x0 +__longlong land10x0 land1 0x0 +__ulonglong land10x0 land1 0x0 +int lor10x0 lor1 0x1 +__uint lor10x0 lor1 0x1 +char lor10x0 lor1 0x1 +__uchar lor10x0 lor1 0x1 +__longlong lor10x0 lor1 0x1 +__ulonglong lor10x0 lor1 0x1 +int and420x0 and42 0x0 +__uint and420x0 and42 0x0 +char and420x0 and42 0x0 +__uchar and420x0 and42 0x0 +__longlong and420x0 and42 0x0 +__ulonglong and420x0 and42 0x0 +int or420x0 or42 0x2a +__uint or420x0 or42 0x2a +char or420x0 or42 0x2a +__uchar or420x0 or42 0x2a +__longlong or420x0 or42 0x2a +__ulonglong or420x0 or42 0x2a +int shl50x0 shl5 0x0 +__uint shl50x0 shl5 0x0 +char shl50x0 shl5 0x0 +__uchar shl50x0 shl5 0x0 +__longlong shl50x0 shl5 0x0 +__ulonglong shl50x0 shl5 0x0 +int shr50x0 shr5 0x0 +__uint shr50x0 shr5 0x0 +char shr50x0 shr5 0x0 +__uchar shr50x0 shr5 0x0 +__longlong shr50x0 shr5 0x0 +__ulonglong shr50x0 shr5 0x0 +int add420x0 add42 0x2a +__uint add420x0 add42 0x2a +char add420x0 add42 0x2a +__uchar add420x0 add42 0x2a +__longlong add420x0 add42 0x2a +__ulonglong add420x0 add42 0x2a +float add420x0 add42 0x2a +int sub420x0 sub42 -0x2a +__uint sub420x0 sub42 -0x2a +char sub420x0 sub42 -0x2a +__uchar sub420x0 sub42 0xd6 +__longlong sub420x0 sub42 -0x2a +__ulonglong sub420x0 sub42 -0x2a +float sub420x0 sub42 -0x2a +int mul420x0 mul42 0x0 +__uint mul420x0 mul42 0x0 +char mul420x0 mul42 0x0 +__uchar mul420x0 mul42 0x0 +__longlong mul420x0 mul42 0x0 +__ulonglong mul420x0 mul42 0x0 +float mul420x0 mul42 0x0 +int lt420x0 lt42 0x1 +__uint lt420x0 lt42 0x1 +char lt420x0 lt42 0x1 +__uchar lt420x0 lt42 0x1 +__longlong lt420x0 lt42 0x1 +__ulonglong lt420x0 lt42 0x1 +float lt420x0 lt42 0x1 +int gt420x0 gt42 0x0 +__uint gt420x0 gt42 0x0 +char gt420x0 gt42 0x0 +__uchar gt420x0 gt42 0x0 +__longlong gt420x0 gt42 0x0 +__ulonglong gt420x0 gt42 0x0 +float gt420x0 gt42 0x0 +int le420x0 le42 0x1 +__uint le420x0 le42 0x1 +char le420x0 le42 0x1 +__uchar le420x0 le42 0x1 +__longlong le420x0 le42 0x1 +__ulonglong le420x0 le42 0x1 +float le420x0 le42 0x1 +int eq420x0 eq42 0x0 +__uint eq420x0 eq42 0x0 +char eq420x0 eq42 0x0 +__uchar eq420x0 eq42 0x0 +__longlong eq420x0 eq42 0x0 +__ulonglong eq420x0 eq42 0x0 +float eq420x0 eq42 0x0 +int ne420x0 ne42 0x1 +__uint ne420x0 ne42 0x1 +char ne420x0 ne42 0x1 +__uchar ne420x0 ne42 0x1 +__longlong ne420x0 ne42 0x1 +__ulonglong ne420x0 ne42 0x1 +float ne420x0 ne42 0x1 +int ge420x0 ge42 0x0 +__uint ge420x0 ge42 0x0 +char ge420x0 ge42 0x0 +__uchar ge420x0 ge42 0x0 +__longlong ge420x0 ge42 0x0 +__ulonglong ge420x0 ge42 0x0 +float ge420x0 ge42 0x0 +int div420x0 div42 0x0 +__uint div420x0 div42 0x0 +char div420x0 div42 0x0 +__uchar div420x0 div42 0x0 +__longlong div420x0 div42 0x0 +__ulonglong div420x0 div42 0x0 +float div420x0 div42 0x0 +int mod230x0 mod23 0x0 +__uint mod230x0 mod23 0x0 +char mod230x0 mod23 0x0 +__uchar mod230x0 mod23 0x0 +__longlong mod230x0 mod23 0x0 +__ulonglong mod230x0 mod23 0x0 +0xffff * 0xffff == 0x1 +0xffff / 0xffff == 0x1 +0xffff % 0xffff == 0x0 +int 0xffff ^ 0xffff == 0x0 (0x0) +__uint 0xffff ^ 0xffff == 0x0 (0x0) +char 0xffff ^ 0xffff == 0x0 (0x0) +__uchar 0xff ^ 0xff == 0x0 (0x0) +__longlong 0xffff ^ 0xffff == 0x0 (0x0) +__ulonglong 0xffff ^ 0xffff == 0x0 (0x0) +int 0xffff && 0xffff == 0x1 (0x1) +__uint 0xffff && 0xffff == 0x1 (0x1) +char 0xffff && 0xffff == 0x1 (0x1) +__uchar 0xff && 0xff == 0x1 (0x1) +__longlong 0xffff && 0xffff == 0x1 (0x1) +__ulonglong 0xffff && 0xffff == 0x1 (0x1) +int 0xffff || 0xffff == 0x1 (0x1) +__uint 0xffff || 0xffff == 0x1 (0x1) +char 0xffff || 0xffff == 0x1 (0x1) +__uchar 0xff || 0xff == 0x1 (0x1) +__longlong 0xffff || 0xffff == 0x1 (0x1) +__ulonglong 0xffff || 0xffff == 0x1 (0x1) +int 0xffff & 0xffff == -0x1 (0xffff) +__uint 0xffff & 0xffff == -0x1 (0xffff) +char 0xffff & 0xffff == -0x1 (0xffff) +__uchar 0xff & 0xff == 0xff (0xff) +__longlong 0xffff & 0xffff == -0x1 (0xffff) +__ulonglong 0xffff & 0xffff == -0x1 (0xffff) +int 0xffff | 0xffff == -0x1 (0xffff) +__uint 0xffff | 0xffff == -0x1 (0xffff) +char 0xffff | 0xffff == -0x1 (0xffff) +__uchar 0xff | 0xff == 0xff (0xff) +__longlong 0xffff | 0xffff == -0x1 (0xffff) +__ulonglong 0xffff | 0xffff == -0x1 (0xffff) +int 0xffff << 0x1 == -0x2 (0xfffe) +__uint 0xffff << 0x1 == -0x2 (0xfffe) +char 0xffff << 0x1 == -0x2 (0xfffe) +__uchar 0xff << 0x1 == 0xfe (0xfe) +__longlong 0xffff << 0x1 == -0x2 (0xfffe) +__ulonglong 0xffff << 0x1 == -0x2 (0xfffe) +int 0xffff >> 0x1 == -0x1 (0xffff) +__uint 0xffff >> 0x1 == 0x7fff (0x7fff) +char 0xffff >> 0x1 == -0x1 (0xffff) +__uchar 0xff >> 0x1 == 0x7f (0x7f) +__longlong 0xffff >> 0x1 == -0x1 (0xffff) +__ulonglong 0xffff >> 0x1 == -0x1 (0xffff) +int 0xffff + 0xffff == -0x2 (0xfffe) +__uint 0xffff + 0xffff == -0x2 (0xfffe) +char 0xffff + 0xffff == -0x2 (0xfffe) +__uchar 0xff + 0xff == 0xfe (0xfe) +__longlong 0xffff + 0xffff == -0x2 (0xfffe) +__ulonglong 0xffff + 0xffff == -0x2 (0xfffe) +float 0xffff + 0xffff == -0x2 (0xfffe) +int 0xffff - 0xffff == 0x0 (0x0) +__uint 0xffff - 0xffff == 0x0 (0x0) +char 0xffff - 0xffff == 0x0 (0x0) +__uchar 0xff - 0xff == 0x0 (0x0) +__longlong 0xffff - 0xffff == 0x0 (0x0) +__ulonglong 0xffff - 0xffff == 0x0 (0x0) +float 0xffff - 0xffff == 0x0 (0x0) +int 0xffff * 0xffff == 0x1 (0x1) +__uint 0xffff * 0xffff == 0x1 (0x1) +char 0xffff * 0xffff == 0x1 (0x1) +__uchar 0xff * 0xff == 0x1 (0x1) +__longlong 0xffff * 0xffff == 0x1 (0x1) +__ulonglong 0xffff * 0xffff == 0x1 (0x1) +float 0xffff * 0xffff == 0x1 (0x1) +int 0xffff < 0xffff == 0x0 (0x0) +__uint 0xffff < 0xffff == 0x0 (0x0) +char 0xffff < 0xffff == 0x0 (0x0) +__uchar 0xff < 0xff == 0x0 (0x0) +__longlong 0xffff < 0xffff == 0x0 (0x0) +__ulonglong 0xffff < 0xffff == 0x0 (0x0) +float 0xffff < 0xffff == 0x0 (0x0) +int 0xffff > 0xffff == 0x0 (0x0) +__uint 0xffff > 0xffff == 0x0 (0x0) +char 0xffff > 0xffff == 0x0 (0x0) +__uchar 0xff > 0xff == 0x0 (0x0) +__longlong 0xffff > 0xffff == 0x0 (0x0) +__ulonglong 0xffff > 0xffff == 0x0 (0x0) +float 0xffff > 0xffff == 0x0 (0x0) +int 0xffff <= 0xffff == 0x1 (0x1) +__uint 0xffff <= 0xffff == 0x1 (0x1) +char 0xffff <= 0xffff == 0x1 (0x1) +__uchar 0xff <= 0xff == 0x1 (0x1) +__longlong 0xffff <= 0xffff == 0x1 (0x1) +__ulonglong 0xffff <= 0xffff == 0x1 (0x1) +float 0xffff <= 0xffff == 0x1 (0x1) +int 0xffff == 0xffff == 0x1 (0x1) +__uint 0xffff == 0xffff == 0x1 (0x1) +char 0xffff == 0xffff == 0x1 (0x1) +__uchar 0xff == 0xff == 0x1 (0x1) +__longlong 0xffff == 0xffff == 0x1 (0x1) +__ulonglong 0xffff == 0xffff == 0x1 (0x1) +float 0xffff == 0xffff == 0x1 (0x1) +int 0xffff != 0xffff == 0x0 (0x0) +__uint 0xffff != 0xffff == 0x0 (0x0) +char 0xffff != 0xffff == 0x0 (0x0) +__uchar 0xff != 0xff == 0x0 (0x0) +__longlong 0xffff != 0xffff == 0x0 (0x0) +__ulonglong 0xffff != 0xffff == 0x0 (0x0) +float 0xffff != 0xffff == 0x0 (0x0) +int 0xffff >= 0xffff == 0x1 (0x1) +__uint 0xffff >= 0xffff == 0x1 (0x1) +char 0xffff >= 0xffff == 0x1 (0x1) +__uchar 0xff >= 0xff == 0x1 (0x1) +__longlong 0xffff >= 0xffff == 0x1 (0x1) +__ulonglong 0xffff >= 0xffff == 0x1 (0x1) +float 0xffff >= 0xffff == 0x1 (0x1) +int 0xffff / 0xffff == 0x1 (0x1) +__uint 0xffff / 0xffff == 0x1 (0x1) +char 0xffff / 0xffff == 0x1 (0x1) +__uchar 0xff / 0xff == 0x1 (0x1) +__longlong 0xffff / 0xffff == 0x1 (0x1) +__ulonglong 0xffff / 0xffff == 0x1 (0x1) +float 0xffff / 0xffff == 0x1 (0x1) +int 0xffff % 0xffff == 0x0 (0x0) +__uint 0xffff % 0xffff == 0x0 (0x0) +char 0xffff % 0xffff == 0x0 (0x0) +__uchar 0xff % 0xff == 0x0 (0x0) +__longlong 0xffff % 0xffff == 0x0 (0x0) +__ulonglong 0xffff % 0xffff == 0x0 (0x0) +0xffff * 0x1 == -0x1 +0xffff / 0x1 == -0x1 +0xffff % 0x1 == 0x0 +int 0xffff ^ 0x1 == -0x2 (0xfffe) +__uint 0xffff ^ 0x1 == -0x2 (0xfffe) +char 0xffff ^ 0x1 == -0x2 (0xfffe) +__uchar 0xff ^ 0x1 == 0xfe (0xfe) +__longlong 0xffff ^ 0x1 == -0x2 (0xfffe) +__ulonglong 0xffff ^ 0x1 == -0x2 (0xfffe) +int 0xffff && 0x1 == 0x1 (0x1) +__uint 0xffff && 0x1 == 0x1 (0x1) +char 0xffff && 0x1 == 0x1 (0x1) +__uchar 0xff && 0x1 == 0x1 (0x1) +__longlong 0xffff && 0x1 == 0x1 (0x1) +__ulonglong 0xffff && 0x1 == 0x1 (0x1) +int 0xffff || 0x1 == 0x1 (0x1) +__uint 0xffff || 0x1 == 0x1 (0x1) +char 0xffff || 0x1 == 0x1 (0x1) +__uchar 0xff || 0x1 == 0x1 (0x1) +__longlong 0xffff || 0x1 == 0x1 (0x1) +__ulonglong 0xffff || 0x1 == 0x1 (0x1) +int 0xffff & 0x1 == 0x1 (0x1) +__uint 0xffff & 0x1 == 0x1 (0x1) +char 0xffff & 0x1 == 0x1 (0x1) +__uchar 0xff & 0x1 == 0x1 (0x1) +__longlong 0xffff & 0x1 == 0x1 (0x1) +__ulonglong 0xffff & 0x1 == 0x1 (0x1) +int 0xffff | 0x1 == -0x1 (0xffff) +__uint 0xffff | 0x1 == -0x1 (0xffff) +char 0xffff | 0x1 == -0x1 (0xffff) +__uchar 0xff | 0x1 == 0xff (0xff) +__longlong 0xffff | 0x1 == -0x1 (0xffff) +__ulonglong 0xffff | 0x1 == -0x1 (0xffff) +int 0xffff << 0x2 == -0x4 (0xfffc) +__uint 0xffff << 0x2 == -0x4 (0xfffc) +char 0xffff << 0x2 == -0x4 (0xfffc) +__uchar 0xff << 0x2 == 0xfc (0xfc) +__longlong 0xffff << 0x2 == -0x4 (0xfffc) +__ulonglong 0xffff << 0x2 == -0x4 (0xfffc) +int 0xffff >> 0x2 == -0x1 (0xffff) +__uint 0xffff >> 0x2 == 0x3fff (0x3fff) +char 0xffff >> 0x2 == -0x1 (0xffff) +__uchar 0xff >> 0x2 == 0x3f (0x3f) +__longlong 0xffff >> 0x2 == -0x1 (0xffff) +__ulonglong 0xffff >> 0x2 == -0x1 (0xffff) +int 0xffff + 0x1 == 0x0 (0x0) +__uint 0xffff + 0x1 == 0x0 (0x0) +char 0xffff + 0x1 == 0x0 (0x0) +__uchar 0xff + 0x1 == 0x0 (0x0) +__longlong 0xffff + 0x1 == 0x0 (0x0) +__ulonglong 0xffff + 0x1 == 0x0 (0x0) +float 0xffff + 0x1 == 0x0 (0x0) +int 0xffff - 0x1 == -0x2 (0xfffe) +__uint 0xffff - 0x1 == -0x2 (0xfffe) +char 0xffff - 0x1 == -0x2 (0xfffe) +__uchar 0xff - 0x1 == 0xfe (0xfe) +__longlong 0xffff - 0x1 == -0x2 (0xfffe) +__ulonglong 0xffff - 0x1 == -0x2 (0xfffe) +float 0xffff - 0x1 == -0x2 (0xfffe) +int 0xffff * 0x1 == -0x1 (0xffff) +__uint 0xffff * 0x1 == -0x1 (0xffff) +char 0xffff * 0x1 == -0x1 (0xffff) +__uchar 0xff * 0x1 == 0xff (0xff) +__longlong 0xffff * 0x1 == -0x1 (0xffff) +__ulonglong 0xffff * 0x1 == -0x1 (0xffff) +float 0xffff * 0x1 == -0x1 (0xffff) +int 0xffff < 0x1 == 0x1 (0x1) +__uint 0xffff < 0x1 == 0x0 (0x0) +char 0xffff < 0x1 == 0x1 (0x1) +__uchar 0xff < 0x1 == 0x0 (0x0) +__longlong 0xffff < 0x1 == 0x1 (0x1) +__ulonglong 0xffff < 0x1 == 0x0 (0x0) +float 0xffff < 0x1 == 0x1 (0x1) +int 0xffff > 0x1 == 0x0 (0x0) +__uint 0xffff > 0x1 == 0x1 (0x1) +char 0xffff > 0x1 == 0x0 (0x0) +__uchar 0xff > 0x1 == 0x1 (0x1) +__longlong 0xffff > 0x1 == 0x0 (0x0) +__ulonglong 0xffff > 0x1 == 0x1 (0x1) +float 0xffff > 0x1 == 0x0 (0x0) +int 0xffff <= 0x1 == 0x1 (0x1) +__uint 0xffff <= 0x1 == 0x0 (0x0) +char 0xffff <= 0x1 == 0x1 (0x1) +__uchar 0xff <= 0x1 == 0x0 (0x0) +__longlong 0xffff <= 0x1 == 0x1 (0x1) +__ulonglong 0xffff <= 0x1 == 0x0 (0x0) +float 0xffff <= 0x1 == 0x1 (0x1) +int 0xffff == 0x1 == 0x0 (0x0) +__uint 0xffff == 0x1 == 0x0 (0x0) +char 0xffff == 0x1 == 0x0 (0x0) +__uchar 0xff == 0x1 == 0x0 (0x0) +__longlong 0xffff == 0x1 == 0x0 (0x0) +__ulonglong 0xffff == 0x1 == 0x0 (0x0) +float 0xffff == 0x1 == 0x0 (0x0) +int 0xffff != 0x1 == 0x1 (0x1) +__uint 0xffff != 0x1 == 0x1 (0x1) +char 0xffff != 0x1 == 0x1 (0x1) +__uchar 0xff != 0x1 == 0x1 (0x1) +__longlong 0xffff != 0x1 == 0x1 (0x1) +__ulonglong 0xffff != 0x1 == 0x1 (0x1) +float 0xffff != 0x1 == 0x1 (0x1) +int 0xffff >= 0x1 == 0x0 (0x0) +__uint 0xffff >= 0x1 == 0x1 (0x1) +char 0xffff >= 0x1 == 0x0 (0x0) +__uchar 0xff >= 0x1 == 0x1 (0x1) +__longlong 0xffff >= 0x1 == 0x0 (0x0) +__ulonglong 0xffff >= 0x1 == 0x1 (0x1) +float 0xffff >= 0x1 == 0x0 (0x0) +int 0xffff / 0x1 == -0x1 (0xffff) +__uint 0xffff / 0x1 == -0x1 (0xffff) +char 0xffff / 0x1 == -0x1 (0xffff) +__uchar 0xff / 0x1 == 0xff (0xff) +__longlong 0xffff / 0x1 == -0x1 (0xffff) +__ulonglong 0xffff / 0x1 == -0x1 (0xffff) +float 0xffff / 0x1 == -0x1 (0xffff) +int 0xffff % 0x1 == 0x0 (0x0) +__uint 0xffff % 0x1 == 0x0 (0x0) +char 0xffff % 0x1 == 0x0 (0x0) +__uchar 0xff % 0x1 == 0x0 (0x0) +__longlong 0xffff % 0x1 == 0x0 (0x0) +__ulonglong 0xffff % 0x1 == 0x0 (0x0) +0xffff * 0x2 == -0x2 +0xffff / 0x2 == 0x0 +0xffff % 0x2 == -0x1 +int 0xffff ^ 0x2 == -0x3 (0xfffd) +__uint 0xffff ^ 0x2 == -0x3 (0xfffd) +char 0xffff ^ 0x2 == -0x3 (0xfffd) +__uchar 0xff ^ 0x2 == 0xfd (0xfd) +__longlong 0xffff ^ 0x2 == -0x3 (0xfffd) +__ulonglong 0xffff ^ 0x2 == -0x3 (0xfffd) +int 0xffff && 0x2 == 0x1 (0x1) +__uint 0xffff && 0x2 == 0x1 (0x1) +char 0xffff && 0x2 == 0x1 (0x1) +__uchar 0xff && 0x2 == 0x1 (0x1) +__longlong 0xffff && 0x2 == 0x1 (0x1) +__ulonglong 0xffff && 0x2 == 0x1 (0x1) +int 0xffff || 0x2 == 0x1 (0x1) +__uint 0xffff || 0x2 == 0x1 (0x1) +char 0xffff || 0x2 == 0x1 (0x1) +__uchar 0xff || 0x2 == 0x1 (0x1) +__longlong 0xffff || 0x2 == 0x1 (0x1) +__ulonglong 0xffff || 0x2 == 0x1 (0x1) +int 0xffff & 0x2 == 0x2 (0x2) +__uint 0xffff & 0x2 == 0x2 (0x2) +char 0xffff & 0x2 == 0x2 (0x2) +__uchar 0xff & 0x2 == 0x2 (0x2) +__longlong 0xffff & 0x2 == 0x2 (0x2) +__ulonglong 0xffff & 0x2 == 0x2 (0x2) +int 0xffff | 0x2 == -0x1 (0xffff) +__uint 0xffff | 0x2 == -0x1 (0xffff) +char 0xffff | 0x2 == -0x1 (0xffff) +__uchar 0xff | 0x2 == 0xff (0xff) +__longlong 0xffff | 0x2 == -0x1 (0xffff) +__ulonglong 0xffff | 0x2 == -0x1 (0xffff) +int 0xffff << 0x3 == -0x8 (0xfff8) +__uint 0xffff << 0x3 == -0x8 (0xfff8) +char 0xffff << 0x3 == -0x8 (0xfff8) +__uchar 0xff << 0x3 == 0xf8 (0xf8) +__longlong 0xffff << 0x3 == -0x8 (0xfff8) +__ulonglong 0xffff << 0x3 == -0x8 (0xfff8) +int 0xffff >> 0x3 == -0x1 (0xffff) +__uint 0xffff >> 0x3 == 0x1fff (0x1fff) +char 0xffff >> 0x3 == -0x1 (0xffff) +__uchar 0xff >> 0x3 == 0x1f (0x1f) +__longlong 0xffff >> 0x3 == -0x1 (0xffff) +__ulonglong 0xffff >> 0x3 == -0x1 (0xffff) +int 0xffff + 0x2 == 0x1 (0x1) +__uint 0xffff + 0x2 == 0x1 (0x1) +char 0xffff + 0x2 == 0x1 (0x1) +__uchar 0xff + 0x2 == 0x1 (0x1) +__longlong 0xffff + 0x2 == 0x1 (0x1) +__ulonglong 0xffff + 0x2 == 0x1 (0x1) +float 0xffff + 0x2 == 0x1 (0x1) +int 0xffff - 0x2 == -0x3 (0xfffd) +__uint 0xffff - 0x2 == -0x3 (0xfffd) +char 0xffff - 0x2 == -0x3 (0xfffd) +__uchar 0xff - 0x2 == 0xfd (0xfd) +__longlong 0xffff - 0x2 == -0x3 (0xfffd) +__ulonglong 0xffff - 0x2 == -0x3 (0xfffd) +float 0xffff - 0x2 == -0x3 (0xfffd) +int 0xffff * 0x2 == -0x2 (0xfffe) +__uint 0xffff * 0x2 == -0x2 (0xfffe) +char 0xffff * 0x2 == -0x2 (0xfffe) +__uchar 0xff * 0x2 == 0xfe (0xfe) +__longlong 0xffff * 0x2 == -0x2 (0xfffe) +__ulonglong 0xffff * 0x2 == -0x2 (0xfffe) +float 0xffff * 0x2 == -0x2 (0xfffe) +int 0xffff < 0x2 == 0x1 (0x1) +__uint 0xffff < 0x2 == 0x0 (0x0) +char 0xffff < 0x2 == 0x1 (0x1) +__uchar 0xff < 0x2 == 0x0 (0x0) +__longlong 0xffff < 0x2 == 0x1 (0x1) +__ulonglong 0xffff < 0x2 == 0x0 (0x0) +float 0xffff < 0x2 == 0x1 (0x1) +int 0xffff > 0x2 == 0x0 (0x0) +__uint 0xffff > 0x2 == 0x1 (0x1) +char 0xffff > 0x2 == 0x0 (0x0) +__uchar 0xff > 0x2 == 0x1 (0x1) +__longlong 0xffff > 0x2 == 0x0 (0x0) +__ulonglong 0xffff > 0x2 == 0x1 (0x1) +float 0xffff > 0x2 == 0x0 (0x0) +int 0xffff <= 0x2 == 0x1 (0x1) +__uint 0xffff <= 0x2 == 0x0 (0x0) +char 0xffff <= 0x2 == 0x1 (0x1) +__uchar 0xff <= 0x2 == 0x0 (0x0) +__longlong 0xffff <= 0x2 == 0x1 (0x1) +__ulonglong 0xffff <= 0x2 == 0x0 (0x0) +float 0xffff <= 0x2 == 0x1 (0x1) +int 0xffff == 0x2 == 0x0 (0x0) +__uint 0xffff == 0x2 == 0x0 (0x0) +char 0xffff == 0x2 == 0x0 (0x0) +__uchar 0xff == 0x2 == 0x0 (0x0) +__longlong 0xffff == 0x2 == 0x0 (0x0) +__ulonglong 0xffff == 0x2 == 0x0 (0x0) +float 0xffff == 0x2 == 0x0 (0x0) +int 0xffff != 0x2 == 0x1 (0x1) +__uint 0xffff != 0x2 == 0x1 (0x1) +char 0xffff != 0x2 == 0x1 (0x1) +__uchar 0xff != 0x2 == 0x1 (0x1) +__longlong 0xffff != 0x2 == 0x1 (0x1) +__ulonglong 0xffff != 0x2 == 0x1 (0x1) +float 0xffff != 0x2 == 0x1 (0x1) +int 0xffff >= 0x2 == 0x0 (0x0) +__uint 0xffff >= 0x2 == 0x1 (0x1) +char 0xffff >= 0x2 == 0x0 (0x0) +__uchar 0xff >= 0x2 == 0x1 (0x1) +__longlong 0xffff >= 0x2 == 0x0 (0x0) +__ulonglong 0xffff >= 0x2 == 0x1 (0x1) +float 0xffff >= 0x2 == 0x0 (0x0) +int 0xffff / 0x2 == 0x0 (0x0) +__uint 0xffff / 0x2 == 0x7fff (0x7fff) +char 0xffff / 0x2 == 0x0 (0x0) +__uchar 0xff / 0x2 == 0x7f (0x7f) +__longlong 0xffff / 0x2 == 0x0 (0x0) +__ulonglong 0xffff / 0x2 == -0x1 (0xffff) +float 0xffff / 0x2 == 0x0 (0x0) +int 0xffff % 0x2 == -0x1 (0xffff) +__uint 0xffff % 0x2 == 0x1 (0x1) +char 0xffff % 0x2 == -0x1 (0xffff) +__uchar 0xff % 0x2 == 0x1 (0x1) +__longlong 0xffff % 0x2 == -0x1 (0xffff) +__ulonglong 0xffff % 0x2 == 0x1 (0x1) +0xffff * 0xfffe == 0x2 +0xffff / 0xfffe == 0x0 +0xffff % 0xfffe == -0x1 +int 0xffff ^ 0xfffe == 0x1 (0x1) +__uint 0xffff ^ 0xfffe == 0x1 (0x1) +char 0xffff ^ 0xfffe == 0x1 (0x1) +__uchar 0xff ^ 0xfe == 0x1 (0x1) +__longlong 0xffff ^ 0xfffe == 0x1 (0x1) +__ulonglong 0xffff ^ 0xfffe == 0x1 (0x1) +int 0xffff && 0xfffe == 0x1 (0x1) +__uint 0xffff && 0xfffe == 0x1 (0x1) +char 0xffff && 0xfffe == 0x1 (0x1) +__uchar 0xff && 0xfe == 0x1 (0x1) +__longlong 0xffff && 0xfffe == 0x1 (0x1) +__ulonglong 0xffff && 0xfffe == 0x1 (0x1) +int 0xffff || 0xfffe == 0x1 (0x1) +__uint 0xffff || 0xfffe == 0x1 (0x1) +char 0xffff || 0xfffe == 0x1 (0x1) +__uchar 0xff || 0xfe == 0x1 (0x1) +__longlong 0xffff || 0xfffe == 0x1 (0x1) +__ulonglong 0xffff || 0xfffe == 0x1 (0x1) +int 0xffff & 0xfffe == -0x2 (0xfffe) +__uint 0xffff & 0xfffe == -0x2 (0xfffe) +char 0xffff & 0xfffe == -0x2 (0xfffe) +__uchar 0xff & 0xfe == 0xfe (0xfe) +__longlong 0xffff & 0xfffe == -0x2 (0xfffe) +__ulonglong 0xffff & 0xfffe == -0x2 (0xfffe) +int 0xffff | 0xfffe == -0x1 (0xffff) +__uint 0xffff | 0xfffe == -0x1 (0xffff) +char 0xffff | 0xfffe == -0x1 (0xffff) +__uchar 0xff | 0xfe == 0xff (0xff) +__longlong 0xffff | 0xfffe == -0x1 (0xffff) +__ulonglong 0xffff | 0xfffe == -0x1 (0xffff) +int 0xffff << 0x4 == -0x10 (0xfff0) +__uint 0xffff << 0x4 == -0x10 (0xfff0) +char 0xffff << 0x4 == -0x10 (0xfff0) +__uchar 0xff << 0x4 == 0xf0 (0xf0) +__longlong 0xffff << 0x4 == -0x10 (0xfff0) +__ulonglong 0xffff << 0x4 == -0x10 (0xfff0) +int 0xffff >> 0x4 == -0x1 (0xffff) +__uint 0xffff >> 0x4 == 0xfff (0xfff) +char 0xffff >> 0x4 == -0x1 (0xffff) +__uchar 0xff >> 0x4 == 0xf (0xf) +__longlong 0xffff >> 0x4 == -0x1 (0xffff) +__ulonglong 0xffff >> 0x4 == -0x1 (0xffff) +int 0xffff + 0xfffe == -0x3 (0xfffd) +__uint 0xffff + 0xfffe == -0x3 (0xfffd) +char 0xffff + 0xfffe == -0x3 (0xfffd) +__uchar 0xff + 0xfe == 0xfd (0xfd) +__longlong 0xffff + 0xfffe == -0x3 (0xfffd) +__ulonglong 0xffff + 0xfffe == -0x3 (0xfffd) +float 0xffff + 0xfffe == -0x3 (0xfffd) +int 0xffff - 0xfffe == 0x1 (0x1) +__uint 0xffff - 0xfffe == 0x1 (0x1) +char 0xffff - 0xfffe == 0x1 (0x1) +__uchar 0xff - 0xfe == 0x1 (0x1) +__longlong 0xffff - 0xfffe == 0x1 (0x1) +__ulonglong 0xffff - 0xfffe == 0x1 (0x1) +float 0xffff - 0xfffe == 0x1 (0x1) +int 0xffff * 0xfffe == 0x2 (0x2) +__uint 0xffff * 0xfffe == 0x2 (0x2) +char 0xffff * 0xfffe == 0x2 (0x2) +__uchar 0xff * 0xfe == 0x2 (0x2) +__longlong 0xffff * 0xfffe == 0x2 (0x2) +__ulonglong 0xffff * 0xfffe == 0x2 (0x2) +float 0xffff * 0xfffe == 0x2 (0x2) +int 0xffff < 0xfffe == 0x0 (0x0) +__uint 0xffff < 0xfffe == 0x0 (0x0) +char 0xffff < 0xfffe == 0x0 (0x0) +__uchar 0xff < 0xfe == 0x0 (0x0) +__longlong 0xffff < 0xfffe == 0x0 (0x0) +__ulonglong 0xffff < 0xfffe == 0x0 (0x0) +float 0xffff < 0xfffe == 0x0 (0x0) +int 0xffff > 0xfffe == 0x1 (0x1) +__uint 0xffff > 0xfffe == 0x1 (0x1) +char 0xffff > 0xfffe == 0x1 (0x1) +__uchar 0xff > 0xfe == 0x1 (0x1) +__longlong 0xffff > 0xfffe == 0x1 (0x1) +__ulonglong 0xffff > 0xfffe == 0x1 (0x1) +float 0xffff > 0xfffe == 0x1 (0x1) +int 0xffff <= 0xfffe == 0x0 (0x0) +__uint 0xffff <= 0xfffe == 0x0 (0x0) +char 0xffff <= 0xfffe == 0x0 (0x0) +__uchar 0xff <= 0xfe == 0x0 (0x0) +__longlong 0xffff <= 0xfffe == 0x0 (0x0) +__ulonglong 0xffff <= 0xfffe == 0x0 (0x0) +float 0xffff <= 0xfffe == 0x0 (0x0) +int 0xffff == 0xfffe == 0x0 (0x0) +__uint 0xffff == 0xfffe == 0x0 (0x0) +char 0xffff == 0xfffe == 0x0 (0x0) +__uchar 0xff == 0xfe == 0x0 (0x0) +__longlong 0xffff == 0xfffe == 0x0 (0x0) +__ulonglong 0xffff == 0xfffe == 0x0 (0x0) +float 0xffff == 0xfffe == 0x0 (0x0) +int 0xffff != 0xfffe == 0x1 (0x1) +__uint 0xffff != 0xfffe == 0x1 (0x1) +char 0xffff != 0xfffe == 0x1 (0x1) +__uchar 0xff != 0xfe == 0x1 (0x1) +__longlong 0xffff != 0xfffe == 0x1 (0x1) +__ulonglong 0xffff != 0xfffe == 0x1 (0x1) +float 0xffff != 0xfffe == 0x1 (0x1) +int 0xffff >= 0xfffe == 0x1 (0x1) +__uint 0xffff >= 0xfffe == 0x1 (0x1) +char 0xffff >= 0xfffe == 0x1 (0x1) +__uchar 0xff >= 0xfe == 0x1 (0x1) +__longlong 0xffff >= 0xfffe == 0x1 (0x1) +__ulonglong 0xffff >= 0xfffe == 0x1 (0x1) +float 0xffff >= 0xfffe == 0x1 (0x1) +int 0xffff / 0xfffe == 0x0 (0x0) +__uint 0xffff / 0xfffe == 0x1 (0x1) +char 0xffff / 0xfffe == 0x0 (0x0) +__uchar 0xff / 0xfe == 0x1 (0x1) +__longlong 0xffff / 0xfffe == 0x0 (0x0) +__ulonglong 0xffff / 0xfffe == 0x1 (0x1) +float 0xffff / 0xfffe == 0x0 (0x0) +int 0xffff % 0xfffe == -0x1 (0xffff) +__uint 0xffff % 0xfffe == 0x1 (0x1) +char 0xffff % 0xfffe == -0x1 (0xffff) +__uchar 0xff % 0xfe == 0x1 (0x1) +__longlong 0xffff % 0xfffe == -0x1 (0xffff) +__ulonglong 0xffff % 0xfffe == 0x1 (0x1) +0xffff * 0x4 == -0x4 +0xffff / 0x4 == 0x0 +0xffff % 0x4 == -0x1 +int 0xffff ^ 0x4 == -0x5 (0xfffb) +__uint 0xffff ^ 0x4 == -0x5 (0xfffb) +char 0xffff ^ 0x4 == -0x5 (0xfffb) +__uchar 0xff ^ 0x4 == 0xfb (0xfb) +__longlong 0xffff ^ 0x4 == -0x5 (0xfffb) +__ulonglong 0xffff ^ 0x4 == -0x5 (0xfffb) +int 0xffff && 0x4 == 0x1 (0x1) +__uint 0xffff && 0x4 == 0x1 (0x1) +char 0xffff && 0x4 == 0x1 (0x1) +__uchar 0xff && 0x4 == 0x1 (0x1) +__longlong 0xffff && 0x4 == 0x1 (0x1) +__ulonglong 0xffff && 0x4 == 0x1 (0x1) +int 0xffff || 0x4 == 0x1 (0x1) +__uint 0xffff || 0x4 == 0x1 (0x1) +char 0xffff || 0x4 == 0x1 (0x1) +__uchar 0xff || 0x4 == 0x1 (0x1) +__longlong 0xffff || 0x4 == 0x1 (0x1) +__ulonglong 0xffff || 0x4 == 0x1 (0x1) +int 0xffff & 0x4 == 0x4 (0x4) +__uint 0xffff & 0x4 == 0x4 (0x4) +char 0xffff & 0x4 == 0x4 (0x4) +__uchar 0xff & 0x4 == 0x4 (0x4) +__longlong 0xffff & 0x4 == 0x4 (0x4) +__ulonglong 0xffff & 0x4 == 0x4 (0x4) +int 0xffff | 0x4 == -0x1 (0xffff) +__uint 0xffff | 0x4 == -0x1 (0xffff) +char 0xffff | 0x4 == -0x1 (0xffff) +__uchar 0xff | 0x4 == 0xff (0xff) +__longlong 0xffff | 0x4 == -0x1 (0xffff) +__ulonglong 0xffff | 0x4 == -0x1 (0xffff) +int 0xffff << 0x5 == -0x20 (0xffe0) +__uint 0xffff << 0x5 == -0x20 (0xffe0) +char 0xffff << 0x5 == -0x20 (0xffe0) +__uchar 0xff << 0x5 == 0xe0 (0xe0) +__longlong 0xffff << 0x5 == -0x20 (0xffe0) +__ulonglong 0xffff << 0x5 == -0x20 (0xffe0) +int 0xffff >> 0x5 == -0x1 (0xffff) +__uint 0xffff >> 0x5 == 0x7ff (0x7ff) +char 0xffff >> 0x5 == -0x1 (0xffff) +__uchar 0xff >> 0x5 == 0x7 (0x7) +__longlong 0xffff >> 0x5 == -0x1 (0xffff) +__ulonglong 0xffff >> 0x5 == -0x1 (0xffff) +int 0xffff + 0x4 == 0x3 (0x3) +__uint 0xffff + 0x4 == 0x3 (0x3) +char 0xffff + 0x4 == 0x3 (0x3) +__uchar 0xff + 0x4 == 0x3 (0x3) +__longlong 0xffff + 0x4 == 0x3 (0x3) +__ulonglong 0xffff + 0x4 == 0x3 (0x3) +float 0xffff + 0x4 == 0x3 (0x3) +int 0xffff - 0x4 == -0x5 (0xfffb) +__uint 0xffff - 0x4 == -0x5 (0xfffb) +char 0xffff - 0x4 == -0x5 (0xfffb) +__uchar 0xff - 0x4 == 0xfb (0xfb) +__longlong 0xffff - 0x4 == -0x5 (0xfffb) +__ulonglong 0xffff - 0x4 == -0x5 (0xfffb) +float 0xffff - 0x4 == -0x5 (0xfffb) +int 0xffff * 0x4 == -0x4 (0xfffc) +__uint 0xffff * 0x4 == -0x4 (0xfffc) +char 0xffff * 0x4 == -0x4 (0xfffc) +__uchar 0xff * 0x4 == 0xfc (0xfc) +__longlong 0xffff * 0x4 == -0x4 (0xfffc) +__ulonglong 0xffff * 0x4 == -0x4 (0xfffc) +float 0xffff * 0x4 == -0x4 (0xfffc) +int 0xffff < 0x4 == 0x1 (0x1) +__uint 0xffff < 0x4 == 0x0 (0x0) +char 0xffff < 0x4 == 0x1 (0x1) +__uchar 0xff < 0x4 == 0x0 (0x0) +__longlong 0xffff < 0x4 == 0x1 (0x1) +__ulonglong 0xffff < 0x4 == 0x0 (0x0) +float 0xffff < 0x4 == 0x1 (0x1) +int 0xffff > 0x4 == 0x0 (0x0) +__uint 0xffff > 0x4 == 0x1 (0x1) +char 0xffff > 0x4 == 0x0 (0x0) +__uchar 0xff > 0x4 == 0x1 (0x1) +__longlong 0xffff > 0x4 == 0x0 (0x0) +__ulonglong 0xffff > 0x4 == 0x1 (0x1) +float 0xffff > 0x4 == 0x0 (0x0) +int 0xffff <= 0x4 == 0x1 (0x1) +__uint 0xffff <= 0x4 == 0x0 (0x0) +char 0xffff <= 0x4 == 0x1 (0x1) +__uchar 0xff <= 0x4 == 0x0 (0x0) +__longlong 0xffff <= 0x4 == 0x1 (0x1) +__ulonglong 0xffff <= 0x4 == 0x0 (0x0) +float 0xffff <= 0x4 == 0x1 (0x1) +int 0xffff == 0x4 == 0x0 (0x0) +__uint 0xffff == 0x4 == 0x0 (0x0) +char 0xffff == 0x4 == 0x0 (0x0) +__uchar 0xff == 0x4 == 0x0 (0x0) +__longlong 0xffff == 0x4 == 0x0 (0x0) +__ulonglong 0xffff == 0x4 == 0x0 (0x0) +float 0xffff == 0x4 == 0x0 (0x0) +int 0xffff != 0x4 == 0x1 (0x1) +__uint 0xffff != 0x4 == 0x1 (0x1) +char 0xffff != 0x4 == 0x1 (0x1) +__uchar 0xff != 0x4 == 0x1 (0x1) +__longlong 0xffff != 0x4 == 0x1 (0x1) +__ulonglong 0xffff != 0x4 == 0x1 (0x1) +float 0xffff != 0x4 == 0x1 (0x1) +int 0xffff >= 0x4 == 0x0 (0x0) +__uint 0xffff >= 0x4 == 0x1 (0x1) +char 0xffff >= 0x4 == 0x0 (0x0) +__uchar 0xff >= 0x4 == 0x1 (0x1) +__longlong 0xffff >= 0x4 == 0x0 (0x0) +__ulonglong 0xffff >= 0x4 == 0x1 (0x1) +float 0xffff >= 0x4 == 0x0 (0x0) +int 0xffff / 0x4 == 0x0 (0x0) +__uint 0xffff / 0x4 == 0x3fff (0x3fff) +char 0xffff / 0x4 == 0x0 (0x0) +__uchar 0xff / 0x4 == 0x3f (0x3f) +__longlong 0xffff / 0x4 == 0x0 (0x0) +__ulonglong 0xffff / 0x4 == -0x1 (0xffff) +float 0xffff / 0x4 == 0x0 (0x0) +int 0xffff % 0x4 == -0x1 (0xffff) +__uint 0xffff % 0x4 == 0x3 (0x3) +char 0xffff % 0x4 == -0x1 (0xffff) +__uchar 0xff % 0x4 == 0x3 (0x3) +__longlong 0xffff % 0x4 == -0x1 (0xffff) +__ulonglong 0xffff % 0x4 == 0x3 (0x3) +0xffff * 0xfffc == 0x4 +0xffff / 0xfffc == 0x0 +0xffff % 0xfffc == -0x1 +int 0xffff ^ 0xfffc == 0x3 (0x3) +__uint 0xffff ^ 0xfffc == 0x3 (0x3) +char 0xffff ^ 0xfffc == 0x3 (0x3) +__uchar 0xff ^ 0xfc == 0x3 (0x3) +__longlong 0xffff ^ 0xfffc == 0x3 (0x3) +__ulonglong 0xffff ^ 0xfffc == 0x3 (0x3) +int 0xffff && 0xfffc == 0x1 (0x1) +__uint 0xffff && 0xfffc == 0x1 (0x1) +char 0xffff && 0xfffc == 0x1 (0x1) +__uchar 0xff && 0xfc == 0x1 (0x1) +__longlong 0xffff && 0xfffc == 0x1 (0x1) +__ulonglong 0xffff && 0xfffc == 0x1 (0x1) +int 0xffff || 0xfffc == 0x1 (0x1) +__uint 0xffff || 0xfffc == 0x1 (0x1) +char 0xffff || 0xfffc == 0x1 (0x1) +__uchar 0xff || 0xfc == 0x1 (0x1) +__longlong 0xffff || 0xfffc == 0x1 (0x1) +__ulonglong 0xffff || 0xfffc == 0x1 (0x1) +int 0xffff & 0xfffc == -0x4 (0xfffc) +__uint 0xffff & 0xfffc == -0x4 (0xfffc) +char 0xffff & 0xfffc == -0x4 (0xfffc) +__uchar 0xff & 0xfc == 0xfc (0xfc) +__longlong 0xffff & 0xfffc == -0x4 (0xfffc) +__ulonglong 0xffff & 0xfffc == -0x4 (0xfffc) +int 0xffff | 0xfffc == -0x1 (0xffff) +__uint 0xffff | 0xfffc == -0x1 (0xffff) +char 0xffff | 0xfffc == -0x1 (0xffff) +__uchar 0xff | 0xfc == 0xff (0xff) +__longlong 0xffff | 0xfffc == -0x1 (0xffff) +__ulonglong 0xffff | 0xfffc == -0x1 (0xffff) +int 0xffff << 0x6 == -0x40 (0xffc0) +__uint 0xffff << 0x6 == -0x40 (0xffc0) +char 0xffff << 0x6 == -0x40 (0xffc0) +__uchar 0xff << 0x6 == 0xc0 (0xc0) +__longlong 0xffff << 0x6 == -0x40 (0xffc0) +__ulonglong 0xffff << 0x6 == -0x40 (0xffc0) +int 0xffff >> 0x6 == -0x1 (0xffff) +__uint 0xffff >> 0x6 == 0x3ff (0x3ff) +char 0xffff >> 0x6 == -0x1 (0xffff) +__uchar 0xff >> 0x6 == 0x3 (0x3) +__longlong 0xffff >> 0x6 == -0x1 (0xffff) +__ulonglong 0xffff >> 0x6 == -0x1 (0xffff) +int 0xffff + 0xfffc == -0x5 (0xfffb) +__uint 0xffff + 0xfffc == -0x5 (0xfffb) +char 0xffff + 0xfffc == -0x5 (0xfffb) +__uchar 0xff + 0xfc == 0xfb (0xfb) +__longlong 0xffff + 0xfffc == -0x5 (0xfffb) +__ulonglong 0xffff + 0xfffc == -0x5 (0xfffb) +float 0xffff + 0xfffc == -0x5 (0xfffb) +int 0xffff - 0xfffc == 0x3 (0x3) +__uint 0xffff - 0xfffc == 0x3 (0x3) +char 0xffff - 0xfffc == 0x3 (0x3) +__uchar 0xff - 0xfc == 0x3 (0x3) +__longlong 0xffff - 0xfffc == 0x3 (0x3) +__ulonglong 0xffff - 0xfffc == 0x3 (0x3) +float 0xffff - 0xfffc == 0x3 (0x3) +int 0xffff * 0xfffc == 0x4 (0x4) +__uint 0xffff * 0xfffc == 0x4 (0x4) +char 0xffff * 0xfffc == 0x4 (0x4) +__uchar 0xff * 0xfc == 0x4 (0x4) +__longlong 0xffff * 0xfffc == 0x4 (0x4) +__ulonglong 0xffff * 0xfffc == 0x4 (0x4) +float 0xffff * 0xfffc == 0x4 (0x4) +int 0xffff < 0xfffc == 0x0 (0x0) +__uint 0xffff < 0xfffc == 0x0 (0x0) +char 0xffff < 0xfffc == 0x0 (0x0) +__uchar 0xff < 0xfc == 0x0 (0x0) +__longlong 0xffff < 0xfffc == 0x0 (0x0) +__ulonglong 0xffff < 0xfffc == 0x0 (0x0) +float 0xffff < 0xfffc == 0x0 (0x0) +int 0xffff > 0xfffc == 0x1 (0x1) +__uint 0xffff > 0xfffc == 0x1 (0x1) +char 0xffff > 0xfffc == 0x1 (0x1) +__uchar 0xff > 0xfc == 0x1 (0x1) +__longlong 0xffff > 0xfffc == 0x1 (0x1) +__ulonglong 0xffff > 0xfffc == 0x1 (0x1) +float 0xffff > 0xfffc == 0x1 (0x1) +int 0xffff <= 0xfffc == 0x0 (0x0) +__uint 0xffff <= 0xfffc == 0x0 (0x0) +char 0xffff <= 0xfffc == 0x0 (0x0) +__uchar 0xff <= 0xfc == 0x0 (0x0) +__longlong 0xffff <= 0xfffc == 0x0 (0x0) +__ulonglong 0xffff <= 0xfffc == 0x0 (0x0) +float 0xffff <= 0xfffc == 0x0 (0x0) +int 0xffff == 0xfffc == 0x0 (0x0) +__uint 0xffff == 0xfffc == 0x0 (0x0) +char 0xffff == 0xfffc == 0x0 (0x0) +__uchar 0xff == 0xfc == 0x0 (0x0) +__longlong 0xffff == 0xfffc == 0x0 (0x0) +__ulonglong 0xffff == 0xfffc == 0x0 (0x0) +float 0xffff == 0xfffc == 0x0 (0x0) +int 0xffff != 0xfffc == 0x1 (0x1) +__uint 0xffff != 0xfffc == 0x1 (0x1) +char 0xffff != 0xfffc == 0x1 (0x1) +__uchar 0xff != 0xfc == 0x1 (0x1) +__longlong 0xffff != 0xfffc == 0x1 (0x1) +__ulonglong 0xffff != 0xfffc == 0x1 (0x1) +float 0xffff != 0xfffc == 0x1 (0x1) +int 0xffff >= 0xfffc == 0x1 (0x1) +__uint 0xffff >= 0xfffc == 0x1 (0x1) +char 0xffff >= 0xfffc == 0x1 (0x1) +__uchar 0xff >= 0xfc == 0x1 (0x1) +__longlong 0xffff >= 0xfffc == 0x1 (0x1) +__ulonglong 0xffff >= 0xfffc == 0x1 (0x1) +float 0xffff >= 0xfffc == 0x1 (0x1) +int 0xffff / 0xfffc == 0x0 (0x0) +__uint 0xffff / 0xfffc == 0x1 (0x1) +char 0xffff / 0xfffc == 0x0 (0x0) +__uchar 0xff / 0xfc == 0x1 (0x1) +__longlong 0xffff / 0xfffc == 0x0 (0x0) +__ulonglong 0xffff / 0xfffc == 0x1 (0x1) +float 0xffff / 0xfffc == 0x0 (0x0) +int 0xffff % 0xfffc == -0x1 (0xffff) +__uint 0xffff % 0xfffc == 0x3 (0x3) +char 0xffff % 0xfffc == -0x1 (0xffff) +__uchar 0xff % 0xfc == 0x3 (0x3) +__longlong 0xffff % 0xfffc == -0x1 (0xffff) +__ulonglong 0xffff % 0xfffc == 0x3 (0x3) +0xffff * 0xa == -0xa +0xffff / 0xa == 0x0 +0xffff % 0xa == -0x1 +int 0xffff ^ 0xa == -0xb (0xfff5) +__uint 0xffff ^ 0xa == -0xb (0xfff5) +char 0xffff ^ 0xa == -0xb (0xfff5) +__uchar 0xff ^ 0xa == 0xf5 (0xf5) +__longlong 0xffff ^ 0xa == -0xb (0xfff5) +__ulonglong 0xffff ^ 0xa == -0xb (0xfff5) +int 0xffff && 0xa == 0x1 (0x1) +__uint 0xffff && 0xa == 0x1 (0x1) +char 0xffff && 0xa == 0x1 (0x1) +__uchar 0xff && 0xa == 0x1 (0x1) +__longlong 0xffff && 0xa == 0x1 (0x1) +__ulonglong 0xffff && 0xa == 0x1 (0x1) +int 0xffff || 0xa == 0x1 (0x1) +__uint 0xffff || 0xa == 0x1 (0x1) +char 0xffff || 0xa == 0x1 (0x1) +__uchar 0xff || 0xa == 0x1 (0x1) +__longlong 0xffff || 0xa == 0x1 (0x1) +__ulonglong 0xffff || 0xa == 0x1 (0x1) +int 0xffff & 0xa == 0xa (0xa) +__uint 0xffff & 0xa == 0xa (0xa) +char 0xffff & 0xa == 0xa (0xa) +__uchar 0xff & 0xa == 0xa (0xa) +__longlong 0xffff & 0xa == 0xa (0xa) +__ulonglong 0xffff & 0xa == 0xa (0xa) +int 0xffff | 0xa == -0x1 (0xffff) +__uint 0xffff | 0xa == -0x1 (0xffff) +char 0xffff | 0xa == -0x1 (0xffff) +__uchar 0xff | 0xa == 0xff (0xff) +__longlong 0xffff | 0xa == -0x1 (0xffff) +__ulonglong 0xffff | 0xa == -0x1 (0xffff) +int 0xffff << 0x7 == -0x80 (0xff80) +__uint 0xffff << 0x7 == -0x80 (0xff80) +char 0xffff << 0x7 == -0x80 (0xff80) +__uchar 0xff << 0x7 == 0x80 (0x80) +__longlong 0xffff << 0x7 == -0x80 (0xff80) +__ulonglong 0xffff << 0x7 == -0x80 (0xff80) +int 0xffff >> 0x7 == -0x1 (0xffff) +__uint 0xffff >> 0x7 == 0x1ff (0x1ff) +char 0xffff >> 0x7 == -0x1 (0xffff) +__uchar 0xff >> 0x7 == 0x1 (0x1) +__longlong 0xffff >> 0x7 == -0x1 (0xffff) +__ulonglong 0xffff >> 0x7 == -0x1 (0xffff) +int 0xffff + 0xa == 0x9 (0x9) +__uint 0xffff + 0xa == 0x9 (0x9) +char 0xffff + 0xa == 0x9 (0x9) +__uchar 0xff + 0xa == 0x9 (0x9) +__longlong 0xffff + 0xa == 0x9 (0x9) +__ulonglong 0xffff + 0xa == 0x9 (0x9) +float 0xffff + 0xa == 0x9 (0x9) +int 0xffff - 0xa == -0xb (0xfff5) +__uint 0xffff - 0xa == -0xb (0xfff5) +char 0xffff - 0xa == -0xb (0xfff5) +__uchar 0xff - 0xa == 0xf5 (0xf5) +__longlong 0xffff - 0xa == -0xb (0xfff5) +__ulonglong 0xffff - 0xa == -0xb (0xfff5) +float 0xffff - 0xa == -0xb (0xfff5) +int 0xffff * 0xa == -0xa (0xfff6) +__uint 0xffff * 0xa == -0xa (0xfff6) +char 0xffff * 0xa == -0xa (0xfff6) +__uchar 0xff * 0xa == 0xf6 (0xf6) +__longlong 0xffff * 0xa == -0xa (0xfff6) +__ulonglong 0xffff * 0xa == -0xa (0xfff6) +float 0xffff * 0xa == -0xa (0xfff6) +int 0xffff < 0xa == 0x1 (0x1) +__uint 0xffff < 0xa == 0x0 (0x0) +char 0xffff < 0xa == 0x1 (0x1) +__uchar 0xff < 0xa == 0x0 (0x0) +__longlong 0xffff < 0xa == 0x1 (0x1) +__ulonglong 0xffff < 0xa == 0x0 (0x0) +float 0xffff < 0xa == 0x1 (0x1) +int 0xffff > 0xa == 0x0 (0x0) +__uint 0xffff > 0xa == 0x1 (0x1) +char 0xffff > 0xa == 0x0 (0x0) +__uchar 0xff > 0xa == 0x1 (0x1) +__longlong 0xffff > 0xa == 0x0 (0x0) +__ulonglong 0xffff > 0xa == 0x1 (0x1) +float 0xffff > 0xa == 0x0 (0x0) +int 0xffff <= 0xa == 0x1 (0x1) +__uint 0xffff <= 0xa == 0x0 (0x0) +char 0xffff <= 0xa == 0x1 (0x1) +__uchar 0xff <= 0xa == 0x0 (0x0) +__longlong 0xffff <= 0xa == 0x1 (0x1) +__ulonglong 0xffff <= 0xa == 0x0 (0x0) +float 0xffff <= 0xa == 0x1 (0x1) +int 0xffff == 0xa == 0x0 (0x0) +__uint 0xffff == 0xa == 0x0 (0x0) +char 0xffff == 0xa == 0x0 (0x0) +__uchar 0xff == 0xa == 0x0 (0x0) +__longlong 0xffff == 0xa == 0x0 (0x0) +__ulonglong 0xffff == 0xa == 0x0 (0x0) +float 0xffff == 0xa == 0x0 (0x0) +int 0xffff != 0xa == 0x1 (0x1) +__uint 0xffff != 0xa == 0x1 (0x1) +char 0xffff != 0xa == 0x1 (0x1) +__uchar 0xff != 0xa == 0x1 (0x1) +__longlong 0xffff != 0xa == 0x1 (0x1) +__ulonglong 0xffff != 0xa == 0x1 (0x1) +float 0xffff != 0xa == 0x1 (0x1) +int 0xffff >= 0xa == 0x0 (0x0) +__uint 0xffff >= 0xa == 0x1 (0x1) +char 0xffff >= 0xa == 0x0 (0x0) +__uchar 0xff >= 0xa == 0x1 (0x1) +__longlong 0xffff >= 0xa == 0x0 (0x0) +__ulonglong 0xffff >= 0xa == 0x1 (0x1) +float 0xffff >= 0xa == 0x0 (0x0) +int 0xffff / 0xa == 0x0 (0x0) +__uint 0xffff / 0xa == 0x1999 (0x1999) +char 0xffff / 0xa == 0x0 (0x0) +__uchar 0xff / 0xa == 0x19 (0x19) +__longlong 0xffff / 0xa == 0x0 (0x0) +__ulonglong 0xffff / 0xa == -0x6667 (0x9999) +float 0xffff / 0xa == 0x0 (0x0) +int 0xffff % 0xa == -0x1 (0xffff) +__uint 0xffff % 0xa == 0x5 (0x5) +char 0xffff % 0xa == -0x1 (0xffff) +__uchar 0xff % 0xa == 0x5 (0x5) +__longlong 0xffff % 0xa == -0x1 (0xffff) +__ulonglong 0xffff % 0xa == 0x5 (0x5) +0xffff * 0xfff6 == 0xa +0xffff / 0xfff6 == 0x0 +0xffff % 0xfff6 == -0x1 +int 0xffff ^ 0xfff6 == 0x9 (0x9) +__uint 0xffff ^ 0xfff6 == 0x9 (0x9) +char 0xffff ^ 0xfff6 == 0x9 (0x9) +__uchar 0xff ^ 0xf6 == 0x9 (0x9) +__longlong 0xffff ^ 0xfff6 == 0x9 (0x9) +__ulonglong 0xffff ^ 0xfff6 == 0x9 (0x9) +int 0xffff && 0xfff6 == 0x1 (0x1) +__uint 0xffff && 0xfff6 == 0x1 (0x1) +char 0xffff && 0xfff6 == 0x1 (0x1) +__uchar 0xff && 0xf6 == 0x1 (0x1) +__longlong 0xffff && 0xfff6 == 0x1 (0x1) +__ulonglong 0xffff && 0xfff6 == 0x1 (0x1) +int 0xffff || 0xfff6 == 0x1 (0x1) +__uint 0xffff || 0xfff6 == 0x1 (0x1) +char 0xffff || 0xfff6 == 0x1 (0x1) +__uchar 0xff || 0xf6 == 0x1 (0x1) +__longlong 0xffff || 0xfff6 == 0x1 (0x1) +__ulonglong 0xffff || 0xfff6 == 0x1 (0x1) +int 0xffff & 0xfff6 == -0xa (0xfff6) +__uint 0xffff & 0xfff6 == -0xa (0xfff6) +char 0xffff & 0xfff6 == -0xa (0xfff6) +__uchar 0xff & 0xf6 == 0xf6 (0xf6) +__longlong 0xffff & 0xfff6 == -0xa (0xfff6) +__ulonglong 0xffff & 0xfff6 == -0xa (0xfff6) +int 0xffff | 0xfff6 == -0x1 (0xffff) +__uint 0xffff | 0xfff6 == -0x1 (0xffff) +char 0xffff | 0xfff6 == -0x1 (0xffff) +__uchar 0xff | 0xf6 == 0xff (0xff) +__longlong 0xffff | 0xfff6 == -0x1 (0xffff) +__ulonglong 0xffff | 0xfff6 == -0x1 (0xffff) +int 0xffff << 0x8 == -0x100 (0xff00) +__uint 0xffff << 0x8 == -0x100 (0xff00) +char 0xffff << 0x8 == 0x0 (0x0) +__uchar 0xff << 0x8 == 0x0 (0x0) +__longlong 0xffff << 0x8 == -0x100 (0xff00) +__ulonglong 0xffff << 0x8 == -0x100 (0xff00) +int 0xffff >> 0x8 == -0x1 (0xffff) +__uint 0xffff >> 0x8 == 0xff (0xff) +char 0xffff >> 0x8 == -0x1 (0xffff) +__uchar 0xff >> 0x8 == 0x0 (0x0) +__longlong 0xffff >> 0x8 == -0x1 (0xffff) +__ulonglong 0xffff >> 0x8 == -0x1 (0xffff) +int 0xffff + 0xfff6 == -0xb (0xfff5) +__uint 0xffff + 0xfff6 == -0xb (0xfff5) +char 0xffff + 0xfff6 == -0xb (0xfff5) +__uchar 0xff + 0xf6 == 0xf5 (0xf5) +__longlong 0xffff + 0xfff6 == -0xb (0xfff5) +__ulonglong 0xffff + 0xfff6 == -0xb (0xfff5) +float 0xffff + 0xfff6 == -0xb (0xfff5) +int 0xffff - 0xfff6 == 0x9 (0x9) +__uint 0xffff - 0xfff6 == 0x9 (0x9) +char 0xffff - 0xfff6 == 0x9 (0x9) +__uchar 0xff - 0xf6 == 0x9 (0x9) +__longlong 0xffff - 0xfff6 == 0x9 (0x9) +__ulonglong 0xffff - 0xfff6 == 0x9 (0x9) +float 0xffff - 0xfff6 == 0x9 (0x9) +int 0xffff * 0xfff6 == 0xa (0xa) +__uint 0xffff * 0xfff6 == 0xa (0xa) +char 0xffff * 0xfff6 == 0xa (0xa) +__uchar 0xff * 0xf6 == 0xa (0xa) +__longlong 0xffff * 0xfff6 == 0xa (0xa) +__ulonglong 0xffff * 0xfff6 == 0xa (0xa) +float 0xffff * 0xfff6 == 0xa (0xa) +int 0xffff < 0xfff6 == 0x0 (0x0) +__uint 0xffff < 0xfff6 == 0x0 (0x0) +char 0xffff < 0xfff6 == 0x0 (0x0) +__uchar 0xff < 0xf6 == 0x0 (0x0) +__longlong 0xffff < 0xfff6 == 0x0 (0x0) +__ulonglong 0xffff < 0xfff6 == 0x0 (0x0) +float 0xffff < 0xfff6 == 0x0 (0x0) +int 0xffff > 0xfff6 == 0x1 (0x1) +__uint 0xffff > 0xfff6 == 0x1 (0x1) +char 0xffff > 0xfff6 == 0x1 (0x1) +__uchar 0xff > 0xf6 == 0x1 (0x1) +__longlong 0xffff > 0xfff6 == 0x1 (0x1) +__ulonglong 0xffff > 0xfff6 == 0x1 (0x1) +float 0xffff > 0xfff6 == 0x1 (0x1) +int 0xffff <= 0xfff6 == 0x0 (0x0) +__uint 0xffff <= 0xfff6 == 0x0 (0x0) +char 0xffff <= 0xfff6 == 0x0 (0x0) +__uchar 0xff <= 0xf6 == 0x0 (0x0) +__longlong 0xffff <= 0xfff6 == 0x0 (0x0) +__ulonglong 0xffff <= 0xfff6 == 0x0 (0x0) +float 0xffff <= 0xfff6 == 0x0 (0x0) +int 0xffff == 0xfff6 == 0x0 (0x0) +__uint 0xffff == 0xfff6 == 0x0 (0x0) +char 0xffff == 0xfff6 == 0x0 (0x0) +__uchar 0xff == 0xf6 == 0x0 (0x0) +__longlong 0xffff == 0xfff6 == 0x0 (0x0) +__ulonglong 0xffff == 0xfff6 == 0x0 (0x0) +float 0xffff == 0xfff6 == 0x0 (0x0) +int 0xffff != 0xfff6 == 0x1 (0x1) +__uint 0xffff != 0xfff6 == 0x1 (0x1) +char 0xffff != 0xfff6 == 0x1 (0x1) +__uchar 0xff != 0xf6 == 0x1 (0x1) +__longlong 0xffff != 0xfff6 == 0x1 (0x1) +__ulonglong 0xffff != 0xfff6 == 0x1 (0x1) +float 0xffff != 0xfff6 == 0x1 (0x1) +int 0xffff >= 0xfff6 == 0x1 (0x1) +__uint 0xffff >= 0xfff6 == 0x1 (0x1) +char 0xffff >= 0xfff6 == 0x1 (0x1) +__uchar 0xff >= 0xf6 == 0x1 (0x1) +__longlong 0xffff >= 0xfff6 == 0x1 (0x1) +__ulonglong 0xffff >= 0xfff6 == 0x1 (0x1) +float 0xffff >= 0xfff6 == 0x1 (0x1) +int 0xffff / 0xfff6 == 0x0 (0x0) +__uint 0xffff / 0xfff6 == 0x1 (0x1) +char 0xffff / 0xfff6 == 0x0 (0x0) +__uchar 0xff / 0xf6 == 0x1 (0x1) +__longlong 0xffff / 0xfff6 == 0x0 (0x0) +__ulonglong 0xffff / 0xfff6 == 0x1 (0x1) +float 0xffff / 0xfff6 == 0x0 (0x0) +int 0xffff % 0xfff6 == -0x1 (0xffff) +__uint 0xffff % 0xfff6 == 0x9 (0x9) +char 0xffff % 0xfff6 == -0x1 (0xffff) +__uchar 0xff % 0xf6 == 0x9 (0x9) +__longlong 0xffff % 0xfff6 == -0x1 (0xffff) +__ulonglong 0xffff % 0xfff6 == 0x9 (0x9) +0xffff * 0x5 == -0x5 +0xffff / 0x5 == 0x0 +0xffff % 0x5 == -0x1 +int 0xffff ^ 0x5 == -0x6 (0xfffa) +__uint 0xffff ^ 0x5 == -0x6 (0xfffa) +char 0xffff ^ 0x5 == -0x6 (0xfffa) +__uchar 0xff ^ 0x5 == 0xfa (0xfa) +__longlong 0xffff ^ 0x5 == -0x6 (0xfffa) +__ulonglong 0xffff ^ 0x5 == -0x6 (0xfffa) +int 0xffff && 0x5 == 0x1 (0x1) +__uint 0xffff && 0x5 == 0x1 (0x1) +char 0xffff && 0x5 == 0x1 (0x1) +__uchar 0xff && 0x5 == 0x1 (0x1) +__longlong 0xffff && 0x5 == 0x1 (0x1) +__ulonglong 0xffff && 0x5 == 0x1 (0x1) +int 0xffff || 0x5 == 0x1 (0x1) +__uint 0xffff || 0x5 == 0x1 (0x1) +char 0xffff || 0x5 == 0x1 (0x1) +__uchar 0xff || 0x5 == 0x1 (0x1) +__longlong 0xffff || 0x5 == 0x1 (0x1) +__ulonglong 0xffff || 0x5 == 0x1 (0x1) +int 0xffff & 0x5 == 0x5 (0x5) +__uint 0xffff & 0x5 == 0x5 (0x5) +char 0xffff & 0x5 == 0x5 (0x5) +__uchar 0xff & 0x5 == 0x5 (0x5) +__longlong 0xffff & 0x5 == 0x5 (0x5) +__ulonglong 0xffff & 0x5 == 0x5 (0x5) +int 0xffff | 0x5 == -0x1 (0xffff) +__uint 0xffff | 0x5 == -0x1 (0xffff) +char 0xffff | 0x5 == -0x1 (0xffff) +__uchar 0xff | 0x5 == 0xff (0xff) +__longlong 0xffff | 0x5 == -0x1 (0xffff) +__ulonglong 0xffff | 0x5 == -0x1 (0xffff) +int 0xffff << 0x9 == -0x200 (0xfe00) +__uint 0xffff << 0x9 == -0x200 (0xfe00) +char 0xffff << 0x9 == 0x0 (0x0) +__uchar 0xff << 0x9 == 0x0 (0x0) +__longlong 0xffff << 0x9 == -0x200 (0xfe00) +__ulonglong 0xffff << 0x9 == -0x200 (0xfe00) +int 0xffff >> 0x9 == -0x1 (0xffff) +__uint 0xffff >> 0x9 == 0x7f (0x7f) +char 0xffff >> 0x9 == -0x1 (0xffff) +__uchar 0xff >> 0x9 == 0x0 (0x0) +__longlong 0xffff >> 0x9 == -0x1 (0xffff) +__ulonglong 0xffff >> 0x9 == -0x1 (0xffff) +int 0xffff + 0x5 == 0x4 (0x4) +__uint 0xffff + 0x5 == 0x4 (0x4) +char 0xffff + 0x5 == 0x4 (0x4) +__uchar 0xff + 0x5 == 0x4 (0x4) +__longlong 0xffff + 0x5 == 0x4 (0x4) +__ulonglong 0xffff + 0x5 == 0x4 (0x4) +float 0xffff + 0x5 == 0x4 (0x4) +int 0xffff - 0x5 == -0x6 (0xfffa) +__uint 0xffff - 0x5 == -0x6 (0xfffa) +char 0xffff - 0x5 == -0x6 (0xfffa) +__uchar 0xff - 0x5 == 0xfa (0xfa) +__longlong 0xffff - 0x5 == -0x6 (0xfffa) +__ulonglong 0xffff - 0x5 == -0x6 (0xfffa) +float 0xffff - 0x5 == -0x6 (0xfffa) +int 0xffff * 0x5 == -0x5 (0xfffb) +__uint 0xffff * 0x5 == -0x5 (0xfffb) +char 0xffff * 0x5 == -0x5 (0xfffb) +__uchar 0xff * 0x5 == 0xfb (0xfb) +__longlong 0xffff * 0x5 == -0x5 (0xfffb) +__ulonglong 0xffff * 0x5 == -0x5 (0xfffb) +float 0xffff * 0x5 == -0x5 (0xfffb) +int 0xffff < 0x5 == 0x1 (0x1) +__uint 0xffff < 0x5 == 0x0 (0x0) +char 0xffff < 0x5 == 0x1 (0x1) +__uchar 0xff < 0x5 == 0x0 (0x0) +__longlong 0xffff < 0x5 == 0x1 (0x1) +__ulonglong 0xffff < 0x5 == 0x0 (0x0) +float 0xffff < 0x5 == 0x1 (0x1) +int 0xffff > 0x5 == 0x0 (0x0) +__uint 0xffff > 0x5 == 0x1 (0x1) +char 0xffff > 0x5 == 0x0 (0x0) +__uchar 0xff > 0x5 == 0x1 (0x1) +__longlong 0xffff > 0x5 == 0x0 (0x0) +__ulonglong 0xffff > 0x5 == 0x1 (0x1) +float 0xffff > 0x5 == 0x0 (0x0) +int 0xffff <= 0x5 == 0x1 (0x1) +__uint 0xffff <= 0x5 == 0x0 (0x0) +char 0xffff <= 0x5 == 0x1 (0x1) +__uchar 0xff <= 0x5 == 0x0 (0x0) +__longlong 0xffff <= 0x5 == 0x1 (0x1) +__ulonglong 0xffff <= 0x5 == 0x0 (0x0) +float 0xffff <= 0x5 == 0x1 (0x1) +int 0xffff == 0x5 == 0x0 (0x0) +__uint 0xffff == 0x5 == 0x0 (0x0) +char 0xffff == 0x5 == 0x0 (0x0) +__uchar 0xff == 0x5 == 0x0 (0x0) +__longlong 0xffff == 0x5 == 0x0 (0x0) +__ulonglong 0xffff == 0x5 == 0x0 (0x0) +float 0xffff == 0x5 == 0x0 (0x0) +int 0xffff != 0x5 == 0x1 (0x1) +__uint 0xffff != 0x5 == 0x1 (0x1) +char 0xffff != 0x5 == 0x1 (0x1) +__uchar 0xff != 0x5 == 0x1 (0x1) +__longlong 0xffff != 0x5 == 0x1 (0x1) +__ulonglong 0xffff != 0x5 == 0x1 (0x1) +float 0xffff != 0x5 == 0x1 (0x1) +int 0xffff >= 0x5 == 0x0 (0x0) +__uint 0xffff >= 0x5 == 0x1 (0x1) +char 0xffff >= 0x5 == 0x0 (0x0) +__uchar 0xff >= 0x5 == 0x1 (0x1) +__longlong 0xffff >= 0x5 == 0x0 (0x0) +__ulonglong 0xffff >= 0x5 == 0x1 (0x1) +float 0xffff >= 0x5 == 0x0 (0x0) +int 0xffff / 0x5 == 0x0 (0x0) +__uint 0xffff / 0x5 == 0x3333 (0x3333) +char 0xffff / 0x5 == 0x0 (0x0) +__uchar 0xff / 0x5 == 0x33 (0x33) +__longlong 0xffff / 0x5 == 0x0 (0x0) +__ulonglong 0xffff / 0x5 == 0x3333 (0x3333) +float 0xffff / 0x5 == 0x0 (0x0) +int 0xffff % 0x5 == -0x1 (0xffff) +__uint 0xffff % 0x5 == 0x0 (0x0) +char 0xffff % 0x5 == -0x1 (0xffff) +__uchar 0xff % 0x5 == 0x0 (0x0) +__longlong 0xffff % 0x5 == -0x1 (0xffff) +__ulonglong 0xffff % 0x5 == 0x0 (0x0) +0xffff * 0x7 == -0x7 +0xffff / 0x7 == 0x0 +0xffff % 0x7 == -0x1 +int 0xffff ^ 0x7 == -0x8 (0xfff8) +__uint 0xffff ^ 0x7 == -0x8 (0xfff8) +char 0xffff ^ 0x7 == -0x8 (0xfff8) +__uchar 0xff ^ 0x7 == 0xf8 (0xf8) +__longlong 0xffff ^ 0x7 == -0x8 (0xfff8) +__ulonglong 0xffff ^ 0x7 == -0x8 (0xfff8) +int 0xffff && 0x7 == 0x1 (0x1) +__uint 0xffff && 0x7 == 0x1 (0x1) +char 0xffff && 0x7 == 0x1 (0x1) +__uchar 0xff && 0x7 == 0x1 (0x1) +__longlong 0xffff && 0x7 == 0x1 (0x1) +__ulonglong 0xffff && 0x7 == 0x1 (0x1) +int 0xffff || 0x7 == 0x1 (0x1) +__uint 0xffff || 0x7 == 0x1 (0x1) +char 0xffff || 0x7 == 0x1 (0x1) +__uchar 0xff || 0x7 == 0x1 (0x1) +__longlong 0xffff || 0x7 == 0x1 (0x1) +__ulonglong 0xffff || 0x7 == 0x1 (0x1) +int 0xffff & 0x7 == 0x7 (0x7) +__uint 0xffff & 0x7 == 0x7 (0x7) +char 0xffff & 0x7 == 0x7 (0x7) +__uchar 0xff & 0x7 == 0x7 (0x7) +__longlong 0xffff & 0x7 == 0x7 (0x7) +__ulonglong 0xffff & 0x7 == 0x7 (0x7) +int 0xffff | 0x7 == -0x1 (0xffff) +__uint 0xffff | 0x7 == -0x1 (0xffff) +char 0xffff | 0x7 == -0x1 (0xffff) +__uchar 0xff | 0x7 == 0xff (0xff) +__longlong 0xffff | 0x7 == -0x1 (0xffff) +__ulonglong 0xffff | 0x7 == -0x1 (0xffff) +int 0xffff << 0xa == -0x400 (0xfc00) +__uint 0xffff << 0xa == -0x400 (0xfc00) +char 0xffff << 0xa == 0x0 (0x0) +__uchar 0xff << 0xa == 0x0 (0x0) +__longlong 0xffff << 0xa == -0x400 (0xfc00) +__ulonglong 0xffff << 0xa == -0x400 (0xfc00) +int 0xffff >> 0xa == -0x1 (0xffff) +__uint 0xffff >> 0xa == 0x3f (0x3f) +char 0xffff >> 0xa == -0x1 (0xffff) +__uchar 0xff >> 0xa == 0x0 (0x0) +__longlong 0xffff >> 0xa == -0x1 (0xffff) +__ulonglong 0xffff >> 0xa == -0x1 (0xffff) +int 0xffff + 0x7 == 0x6 (0x6) +__uint 0xffff + 0x7 == 0x6 (0x6) +char 0xffff + 0x7 == 0x6 (0x6) +__uchar 0xff + 0x7 == 0x6 (0x6) +__longlong 0xffff + 0x7 == 0x6 (0x6) +__ulonglong 0xffff + 0x7 == 0x6 (0x6) +float 0xffff + 0x7 == 0x6 (0x6) +int 0xffff - 0x7 == -0x8 (0xfff8) +__uint 0xffff - 0x7 == -0x8 (0xfff8) +char 0xffff - 0x7 == -0x8 (0xfff8) +__uchar 0xff - 0x7 == 0xf8 (0xf8) +__longlong 0xffff - 0x7 == -0x8 (0xfff8) +__ulonglong 0xffff - 0x7 == -0x8 (0xfff8) +float 0xffff - 0x7 == -0x8 (0xfff8) +int 0xffff * 0x7 == -0x7 (0xfff9) +__uint 0xffff * 0x7 == -0x7 (0xfff9) +char 0xffff * 0x7 == -0x7 (0xfff9) +__uchar 0xff * 0x7 == 0xf9 (0xf9) +__longlong 0xffff * 0x7 == -0x7 (0xfff9) +__ulonglong 0xffff * 0x7 == -0x7 (0xfff9) +float 0xffff * 0x7 == -0x7 (0xfff9) +int 0xffff < 0x7 == 0x1 (0x1) +__uint 0xffff < 0x7 == 0x0 (0x0) +char 0xffff < 0x7 == 0x1 (0x1) +__uchar 0xff < 0x7 == 0x0 (0x0) +__longlong 0xffff < 0x7 == 0x1 (0x1) +__ulonglong 0xffff < 0x7 == 0x0 (0x0) +float 0xffff < 0x7 == 0x1 (0x1) +int 0xffff > 0x7 == 0x0 (0x0) +__uint 0xffff > 0x7 == 0x1 (0x1) +char 0xffff > 0x7 == 0x0 (0x0) +__uchar 0xff > 0x7 == 0x1 (0x1) +__longlong 0xffff > 0x7 == 0x0 (0x0) +__ulonglong 0xffff > 0x7 == 0x1 (0x1) +float 0xffff > 0x7 == 0x0 (0x0) +int 0xffff <= 0x7 == 0x1 (0x1) +__uint 0xffff <= 0x7 == 0x0 (0x0) +char 0xffff <= 0x7 == 0x1 (0x1) +__uchar 0xff <= 0x7 == 0x0 (0x0) +__longlong 0xffff <= 0x7 == 0x1 (0x1) +__ulonglong 0xffff <= 0x7 == 0x0 (0x0) +float 0xffff <= 0x7 == 0x1 (0x1) +int 0xffff == 0x7 == 0x0 (0x0) +__uint 0xffff == 0x7 == 0x0 (0x0) +char 0xffff == 0x7 == 0x0 (0x0) +__uchar 0xff == 0x7 == 0x0 (0x0) +__longlong 0xffff == 0x7 == 0x0 (0x0) +__ulonglong 0xffff == 0x7 == 0x0 (0x0) +float 0xffff == 0x7 == 0x0 (0x0) +int 0xffff != 0x7 == 0x1 (0x1) +__uint 0xffff != 0x7 == 0x1 (0x1) +char 0xffff != 0x7 == 0x1 (0x1) +__uchar 0xff != 0x7 == 0x1 (0x1) +__longlong 0xffff != 0x7 == 0x1 (0x1) +__ulonglong 0xffff != 0x7 == 0x1 (0x1) +float 0xffff != 0x7 == 0x1 (0x1) +int 0xffff >= 0x7 == 0x0 (0x0) +__uint 0xffff >= 0x7 == 0x1 (0x1) +char 0xffff >= 0x7 == 0x0 (0x0) +__uchar 0xff >= 0x7 == 0x1 (0x1) +__longlong 0xffff >= 0x7 == 0x0 (0x0) +__ulonglong 0xffff >= 0x7 == 0x1 (0x1) +float 0xffff >= 0x7 == 0x0 (0x0) +int 0xffff / 0x7 == 0x0 (0x0) +__uint 0xffff / 0x7 == 0x2492 (0x2492) +char 0xffff / 0x7 == 0x0 (0x0) +__uchar 0xff / 0x7 == 0x24 (0x24) +__longlong 0xffff / 0x7 == 0x0 (0x0) +__ulonglong 0xffff / 0x7 == 0x4924 (0x4924) +float 0xffff / 0x7 == 0x0 (0x0) +int 0xffff % 0x7 == -0x1 (0xffff) +__uint 0xffff % 0x7 == 0x1 (0x1) +char 0xffff % 0x7 == -0x1 (0xffff) +__uchar 0xff % 0x7 == 0x3 (0x3) +__longlong 0xffff % 0x7 == -0x1 (0xffff) +__ulonglong 0xffff % 0x7 == 0x3 (0x3) +0xffff * 0x2a == -0x2a +0xffff / 0x2a == 0x0 +0xffff % 0x2a == -0x1 +int 0xffff ^ 0x2a == -0x2b (0xffd5) +__uint 0xffff ^ 0x2a == -0x2b (0xffd5) +char 0xffff ^ 0x2a == -0x2b (0xffd5) +__uchar 0xff ^ 0x2a == 0xd5 (0xd5) +__longlong 0xffff ^ 0x2a == -0x2b (0xffd5) +__ulonglong 0xffff ^ 0x2a == -0x2b (0xffd5) +int 0xffff && 0x2a == 0x1 (0x1) +__uint 0xffff && 0x2a == 0x1 (0x1) +char 0xffff && 0x2a == 0x1 (0x1) +__uchar 0xff && 0x2a == 0x1 (0x1) +__longlong 0xffff && 0x2a == 0x1 (0x1) +__ulonglong 0xffff && 0x2a == 0x1 (0x1) +int 0xffff || 0x2a == 0x1 (0x1) +__uint 0xffff || 0x2a == 0x1 (0x1) +char 0xffff || 0x2a == 0x1 (0x1) +__uchar 0xff || 0x2a == 0x1 (0x1) +__longlong 0xffff || 0x2a == 0x1 (0x1) +__ulonglong 0xffff || 0x2a == 0x1 (0x1) +int 0xffff & 0x2a == 0x2a (0x2a) +__uint 0xffff & 0x2a == 0x2a (0x2a) +char 0xffff & 0x2a == 0x2a (0x2a) +__uchar 0xff & 0x2a == 0x2a (0x2a) +__longlong 0xffff & 0x2a == 0x2a (0x2a) +__ulonglong 0xffff & 0x2a == 0x2a (0x2a) +int 0xffff | 0x2a == -0x1 (0xffff) +__uint 0xffff | 0x2a == -0x1 (0xffff) +char 0xffff | 0x2a == -0x1 (0xffff) +__uchar 0xff | 0x2a == 0xff (0xff) +__longlong 0xffff | 0x2a == -0x1 (0xffff) +__ulonglong 0xffff | 0x2a == -0x1 (0xffff) +int 0xffff << 0xc == -0x1000 (0xf000) +__uint 0xffff << 0xc == -0x1000 (0xf000) +char 0xffff << 0xc == 0x0 (0x0) +__uchar 0xff << 0xc == 0x0 (0x0) +__longlong 0xffff << 0xc == -0x1000 (0xf000) +__ulonglong 0xffff << 0xc == -0x1000 (0xf000) +int 0xffff >> 0xc == -0x1 (0xffff) +__uint 0xffff >> 0xc == 0xf (0xf) +char 0xffff >> 0xc == -0x1 (0xffff) +__uchar 0xff >> 0xc == 0x0 (0x0) +__longlong 0xffff >> 0xc == -0x1 (0xffff) +__ulonglong 0xffff >> 0xc == -0x1 (0xffff) +int 0xffff + 0x2a == 0x29 (0x29) +__uint 0xffff + 0x2a == 0x29 (0x29) +char 0xffff + 0x2a == 0x29 (0x29) +__uchar 0xff + 0x2a == 0x29 (0x29) +__longlong 0xffff + 0x2a == 0x29 (0x29) +__ulonglong 0xffff + 0x2a == 0x29 (0x29) +float 0xffff + 0x2a == 0x29 (0x29) +int 0xffff - 0x2a == -0x2b (0xffd5) +__uint 0xffff - 0x2a == -0x2b (0xffd5) +char 0xffff - 0x2a == -0x2b (0xffd5) +__uchar 0xff - 0x2a == 0xd5 (0xd5) +__longlong 0xffff - 0x2a == -0x2b (0xffd5) +__ulonglong 0xffff - 0x2a == -0x2b (0xffd5) +float 0xffff - 0x2a == -0x2b (0xffd5) +int 0xffff * 0x2a == -0x2a (0xffd6) +__uint 0xffff * 0x2a == -0x2a (0xffd6) +char 0xffff * 0x2a == -0x2a (0xffd6) +__uchar 0xff * 0x2a == 0xd6 (0xd6) +__longlong 0xffff * 0x2a == -0x2a (0xffd6) +__ulonglong 0xffff * 0x2a == -0x2a (0xffd6) +float 0xffff * 0x2a == -0x2a (0xffd6) +int 0xffff < 0x2a == 0x1 (0x1) +__uint 0xffff < 0x2a == 0x0 (0x0) +char 0xffff < 0x2a == 0x1 (0x1) +__uchar 0xff < 0x2a == 0x0 (0x0) +__longlong 0xffff < 0x2a == 0x1 (0x1) +__ulonglong 0xffff < 0x2a == 0x0 (0x0) +float 0xffff < 0x2a == 0x1 (0x1) +int 0xffff > 0x2a == 0x0 (0x0) +__uint 0xffff > 0x2a == 0x1 (0x1) +char 0xffff > 0x2a == 0x0 (0x0) +__uchar 0xff > 0x2a == 0x1 (0x1) +__longlong 0xffff > 0x2a == 0x0 (0x0) +__ulonglong 0xffff > 0x2a == 0x1 (0x1) +float 0xffff > 0x2a == 0x0 (0x0) +int 0xffff <= 0x2a == 0x1 (0x1) +__uint 0xffff <= 0x2a == 0x0 (0x0) +char 0xffff <= 0x2a == 0x1 (0x1) +__uchar 0xff <= 0x2a == 0x0 (0x0) +__longlong 0xffff <= 0x2a == 0x1 (0x1) +__ulonglong 0xffff <= 0x2a == 0x0 (0x0) +float 0xffff <= 0x2a == 0x1 (0x1) +int 0xffff == 0x2a == 0x0 (0x0) +__uint 0xffff == 0x2a == 0x0 (0x0) +char 0xffff == 0x2a == 0x0 (0x0) +__uchar 0xff == 0x2a == 0x0 (0x0) +__longlong 0xffff == 0x2a == 0x0 (0x0) +__ulonglong 0xffff == 0x2a == 0x0 (0x0) +float 0xffff == 0x2a == 0x0 (0x0) +int 0xffff != 0x2a == 0x1 (0x1) +__uint 0xffff != 0x2a == 0x1 (0x1) +char 0xffff != 0x2a == 0x1 (0x1) +__uchar 0xff != 0x2a == 0x1 (0x1) +__longlong 0xffff != 0x2a == 0x1 (0x1) +__ulonglong 0xffff != 0x2a == 0x1 (0x1) +float 0xffff != 0x2a == 0x1 (0x1) +int 0xffff >= 0x2a == 0x0 (0x0) +__uint 0xffff >= 0x2a == 0x1 (0x1) +char 0xffff >= 0x2a == 0x0 (0x0) +__uchar 0xff >= 0x2a == 0x1 (0x1) +__longlong 0xffff >= 0x2a == 0x0 (0x0) +__ulonglong 0xffff >= 0x2a == 0x1 (0x1) +float 0xffff >= 0x2a == 0x0 (0x0) +int 0xffff / 0x2a == 0x0 (0x0) +__uint 0xffff / 0x2a == 0x618 (0x618) +char 0xffff / 0x2a == 0x0 (0x0) +__uchar 0xff / 0x2a == 0x6 (0x6) +__longlong 0xffff / 0x2a == 0x0 (0x0) +__ulonglong 0xffff / 0x2a == 0x6186 (0x6186) +float 0xffff / 0x2a == 0x0 (0x0) +int 0xffff % 0x2a == -0x1 (0xffff) +__uint 0xffff % 0x2a == 0xf (0xf) +char 0xffff % 0x2a == -0x1 (0xffff) +__uchar 0xff % 0x2a == 0x3 (0x3) +__longlong 0xffff % 0x2a == -0x1 (0xffff) +__ulonglong 0xffff % 0x2a == 0x3 (0x3) +0xffff * 0x17 == -0x17 +0xffff / 0x17 == 0x0 +0xffff % 0x17 == -0x1 +int 0xffff ^ 0x17 == -0x18 (0xffe8) +__uint 0xffff ^ 0x17 == -0x18 (0xffe8) +char 0xffff ^ 0x17 == -0x18 (0xffe8) +__uchar 0xff ^ 0x17 == 0xe8 (0xe8) +__longlong 0xffff ^ 0x17 == -0x18 (0xffe8) +__ulonglong 0xffff ^ 0x17 == -0x18 (0xffe8) +int 0xffff && 0x17 == 0x1 (0x1) +__uint 0xffff && 0x17 == 0x1 (0x1) +char 0xffff && 0x17 == 0x1 (0x1) +__uchar 0xff && 0x17 == 0x1 (0x1) +__longlong 0xffff && 0x17 == 0x1 (0x1) +__ulonglong 0xffff && 0x17 == 0x1 (0x1) +int 0xffff || 0x17 == 0x1 (0x1) +__uint 0xffff || 0x17 == 0x1 (0x1) +char 0xffff || 0x17 == 0x1 (0x1) +__uchar 0xff || 0x17 == 0x1 (0x1) +__longlong 0xffff || 0x17 == 0x1 (0x1) +__ulonglong 0xffff || 0x17 == 0x1 (0x1) +int 0xffff & 0x17 == 0x17 (0x17) +__uint 0xffff & 0x17 == 0x17 (0x17) +char 0xffff & 0x17 == 0x17 (0x17) +__uchar 0xff & 0x17 == 0x17 (0x17) +__longlong 0xffff & 0x17 == 0x17 (0x17) +__ulonglong 0xffff & 0x17 == 0x17 (0x17) +int 0xffff | 0x17 == -0x1 (0xffff) +__uint 0xffff | 0x17 == -0x1 (0xffff) +char 0xffff | 0x17 == -0x1 (0xffff) +__uchar 0xff | 0x17 == 0xff (0xff) +__longlong 0xffff | 0x17 == -0x1 (0xffff) +__ulonglong 0xffff | 0x17 == -0x1 (0xffff) +int 0xffff << 0xe == -0x4000 (0xc000) +__uint 0xffff << 0xe == -0x4000 (0xc000) +char 0xffff << 0xe == 0x0 (0x0) +__uchar 0xff << 0xe == 0x0 (0x0) +__longlong 0xffff << 0xe == -0x4000 (0xc000) +__ulonglong 0xffff << 0xe == -0x4000 (0xc000) +int 0xffff >> 0xe == -0x1 (0xffff) +__uint 0xffff >> 0xe == 0x3 (0x3) +char 0xffff >> 0xe == -0x1 (0xffff) +__uchar 0xff >> 0xe == 0x0 (0x0) +__longlong 0xffff >> 0xe == -0x1 (0xffff) +__ulonglong 0xffff >> 0xe == -0x1 (0xffff) +int 0xffff + 0x17 == 0x16 (0x16) +__uint 0xffff + 0x17 == 0x16 (0x16) +char 0xffff + 0x17 == 0x16 (0x16) +__uchar 0xff + 0x17 == 0x16 (0x16) +__longlong 0xffff + 0x17 == 0x16 (0x16) +__ulonglong 0xffff + 0x17 == 0x16 (0x16) +float 0xffff + 0x17 == 0x16 (0x16) +int 0xffff - 0x17 == -0x18 (0xffe8) +__uint 0xffff - 0x17 == -0x18 (0xffe8) +char 0xffff - 0x17 == -0x18 (0xffe8) +__uchar 0xff - 0x17 == 0xe8 (0xe8) +__longlong 0xffff - 0x17 == -0x18 (0xffe8) +__ulonglong 0xffff - 0x17 == -0x18 (0xffe8) +float 0xffff - 0x17 == -0x18 (0xffe8) +int 0xffff * 0x17 == -0x17 (0xffe9) +__uint 0xffff * 0x17 == -0x17 (0xffe9) +char 0xffff * 0x17 == -0x17 (0xffe9) +__uchar 0xff * 0x17 == 0xe9 (0xe9) +__longlong 0xffff * 0x17 == -0x17 (0xffe9) +__ulonglong 0xffff * 0x17 == -0x17 (0xffe9) +float 0xffff * 0x17 == -0x17 (0xffe9) +int 0xffff < 0x17 == 0x1 (0x1) +__uint 0xffff < 0x17 == 0x0 (0x0) +char 0xffff < 0x17 == 0x1 (0x1) +__uchar 0xff < 0x17 == 0x0 (0x0) +__longlong 0xffff < 0x17 == 0x1 (0x1) +__ulonglong 0xffff < 0x17 == 0x0 (0x0) +float 0xffff < 0x17 == 0x1 (0x1) +int 0xffff > 0x17 == 0x0 (0x0) +__uint 0xffff > 0x17 == 0x1 (0x1) +char 0xffff > 0x17 == 0x0 (0x0) +__uchar 0xff > 0x17 == 0x1 (0x1) +__longlong 0xffff > 0x17 == 0x0 (0x0) +__ulonglong 0xffff > 0x17 == 0x1 (0x1) +float 0xffff > 0x17 == 0x0 (0x0) +int 0xffff <= 0x17 == 0x1 (0x1) +__uint 0xffff <= 0x17 == 0x0 (0x0) +char 0xffff <= 0x17 == 0x1 (0x1) +__uchar 0xff <= 0x17 == 0x0 (0x0) +__longlong 0xffff <= 0x17 == 0x1 (0x1) +__ulonglong 0xffff <= 0x17 == 0x0 (0x0) +float 0xffff <= 0x17 == 0x1 (0x1) +int 0xffff == 0x17 == 0x0 (0x0) +__uint 0xffff == 0x17 == 0x0 (0x0) +char 0xffff == 0x17 == 0x0 (0x0) +__uchar 0xff == 0x17 == 0x0 (0x0) +__longlong 0xffff == 0x17 == 0x0 (0x0) +__ulonglong 0xffff == 0x17 == 0x0 (0x0) +float 0xffff == 0x17 == 0x0 (0x0) +int 0xffff != 0x17 == 0x1 (0x1) +__uint 0xffff != 0x17 == 0x1 (0x1) +char 0xffff != 0x17 == 0x1 (0x1) +__uchar 0xff != 0x17 == 0x1 (0x1) +__longlong 0xffff != 0x17 == 0x1 (0x1) +__ulonglong 0xffff != 0x17 == 0x1 (0x1) +float 0xffff != 0x17 == 0x1 (0x1) +int 0xffff >= 0x17 == 0x0 (0x0) +__uint 0xffff >= 0x17 == 0x1 (0x1) +char 0xffff >= 0x17 == 0x0 (0x0) +__uchar 0xff >= 0x17 == 0x1 (0x1) +__longlong 0xffff >= 0x17 == 0x0 (0x0) +__ulonglong 0xffff >= 0x17 == 0x1 (0x1) +float 0xffff >= 0x17 == 0x0 (0x0) +int 0xffff / 0x17 == 0x0 (0x0) +__uint 0xffff / 0x17 == 0xb21 (0xb21) +char 0xffff / 0x17 == 0x0 (0x0) +__uchar 0xff / 0x17 == 0xb (0xb) +__longlong 0xffff / 0x17 == 0x0 (0x0) +__ulonglong 0xffff / 0x17 == 0x642c (0x642c) +float 0xffff / 0x17 == 0x0 (0x0) +int 0xffff % 0x17 == -0x1 (0xffff) +__uint 0xffff % 0x17 == 0x8 (0x8) +char 0xffff % 0x17 == -0x1 (0xffff) +__uchar 0xff % 0x17 == 0x2 (0x2) +__longlong 0xffff % 0x17 == -0x1 (0xffff) +__ulonglong 0xffff % 0x17 == 0xb (0xb) +0xffff * 0x7fff == -0x7fff +0xffff / 0x7fff == 0x0 +0xffff % 0x7fff == -0x1 +int 0xffff ^ 0x7fff == -0x8000 (0x8000) +__uint 0xffff ^ 0x7fff == -0x8000 (0x8000) +char 0xffff ^ 0xffff == 0x0 (0x0) +__uchar 0xff ^ 0xff == 0x0 (0x0) +__longlong 0xffff ^ 0x7fff == -0x8000 (0x8000) +__ulonglong 0xffff ^ 0x7fff == -0x8000 (0x8000) +int 0xffff && 0x7fff == 0x1 (0x1) +__uint 0xffff && 0x7fff == 0x1 (0x1) +char 0xffff && 0xffff == 0x1 (0x1) +__uchar 0xff && 0xff == 0x1 (0x1) +__longlong 0xffff && 0x7fff == 0x1 (0x1) +__ulonglong 0xffff && 0x7fff == 0x1 (0x1) +int 0xffff || 0x7fff == 0x1 (0x1) +__uint 0xffff || 0x7fff == 0x1 (0x1) +char 0xffff || 0xffff == 0x1 (0x1) +__uchar 0xff || 0xff == 0x1 (0x1) +__longlong 0xffff || 0x7fff == 0x1 (0x1) +__ulonglong 0xffff || 0x7fff == 0x1 (0x1) +int 0xffff & 0x7fff == 0x7fff (0x7fff) +__uint 0xffff & 0x7fff == 0x7fff (0x7fff) +char 0xffff & 0xffff == -0x1 (0xffff) +__uchar 0xff & 0xff == 0xff (0xff) +__longlong 0xffff & 0x7fff == 0x7fff (0x7fff) +__ulonglong 0xffff & 0x7fff == 0x7fff (0x7fff) +int 0xffff | 0x7fff == -0x1 (0xffff) +__uint 0xffff | 0x7fff == -0x1 (0xffff) +char 0xffff | 0xffff == -0x1 (0xffff) +__uchar 0xff | 0xff == 0xff (0xff) +__longlong 0xffff | 0x7fff == -0x1 (0xffff) +__ulonglong 0xffff | 0x7fff == -0x1 (0xffff) +int 0xffff << 0x10 == 0x0 (0x0) +__uint 0xffff << 0x10 == 0x0 (0x0) +char 0xffff << 0x10 == 0x0 (0x0) +__uchar 0xff << 0x10 == 0x0 (0x0) +__longlong 0xffff << 0x10 == 0x0 (0x0) +__ulonglong 0xffff << 0x10 == 0x0 (0x0) +int 0xffff >> 0x10 == -0x1 (0xffff) +__uint 0xffff >> 0x10 == 0x0 (0x0) +char 0xffff >> 0x10 == -0x1 (0xffff) +__uchar 0xff >> 0x10 == 0x0 (0x0) +__longlong 0xffff >> 0x10 == -0x1 (0xffff) +__ulonglong 0xffff >> 0x10 == -0x1 (0xffff) +int 0xffff + 0x7fff == 0x7ffe (0x7ffe) +__uint 0xffff + 0x7fff == 0x7ffe (0x7ffe) +char 0xffff + 0xffff == -0x2 (0xfffe) +__uchar 0xff + 0xff == 0xfe (0xfe) +__longlong 0xffff + 0x7fff == 0x7ffe (0x7ffe) +__ulonglong 0xffff + 0x7fff == 0x7ffe (0x7ffe) +float 0xffff + 0x7fff == 0x7ffe (0x7ffe) +int 0xffff - 0x7fff == -0x8000 (0x8000) +__uint 0xffff - 0x7fff == -0x8000 (0x8000) +char 0xffff - 0xffff == 0x0 (0x0) +__uchar 0xff - 0xff == 0x0 (0x0) +__longlong 0xffff - 0x7fff == -0x8000 (0x8000) +__ulonglong 0xffff - 0x7fff == -0x8000 (0x8000) +float 0xffff - 0x7fff == -0x8000 (0x8000) +int 0xffff * 0x7fff == -0x7fff (0x8001) +__uint 0xffff * 0x7fff == -0x7fff (0x8001) +char 0xffff * 0xffff == 0x1 (0x1) +__uchar 0xff * 0xff == 0x1 (0x1) +__longlong 0xffff * 0x7fff == -0x7fff (0x8001) +__ulonglong 0xffff * 0x7fff == -0x7fff (0x8001) +float 0xffff * 0x7fff == -0x7fff (0x8001) +int 0xffff < 0x7fff == 0x1 (0x1) +__uint 0xffff < 0x7fff == 0x0 (0x0) +char 0xffff < 0xffff == 0x0 (0x0) +__uchar 0xff < 0xff == 0x0 (0x0) +__longlong 0xffff < 0x7fff == 0x1 (0x1) +__ulonglong 0xffff < 0x7fff == 0x0 (0x0) +float 0xffff < 0x7fff == 0x1 (0x1) +int 0xffff > 0x7fff == 0x0 (0x0) +__uint 0xffff > 0x7fff == 0x1 (0x1) +char 0xffff > 0xffff == 0x0 (0x0) +__uchar 0xff > 0xff == 0x0 (0x0) +__longlong 0xffff > 0x7fff == 0x0 (0x0) +__ulonglong 0xffff > 0x7fff == 0x1 (0x1) +float 0xffff > 0x7fff == 0x0 (0x0) +int 0xffff <= 0x7fff == 0x1 (0x1) +__uint 0xffff <= 0x7fff == 0x0 (0x0) +char 0xffff <= 0xffff == 0x1 (0x1) +__uchar 0xff <= 0xff == 0x1 (0x1) +__longlong 0xffff <= 0x7fff == 0x1 (0x1) +__ulonglong 0xffff <= 0x7fff == 0x0 (0x0) +float 0xffff <= 0x7fff == 0x1 (0x1) +int 0xffff == 0x7fff == 0x0 (0x0) +__uint 0xffff == 0x7fff == 0x0 (0x0) +char 0xffff == 0xffff == 0x1 (0x1) +__uchar 0xff == 0xff == 0x1 (0x1) +__longlong 0xffff == 0x7fff == 0x0 (0x0) +__ulonglong 0xffff == 0x7fff == 0x0 (0x0) +float 0xffff == 0x7fff == 0x0 (0x0) +int 0xffff != 0x7fff == 0x1 (0x1) +__uint 0xffff != 0x7fff == 0x1 (0x1) +char 0xffff != 0xffff == 0x0 (0x0) +__uchar 0xff != 0xff == 0x0 (0x0) +__longlong 0xffff != 0x7fff == 0x1 (0x1) +__ulonglong 0xffff != 0x7fff == 0x1 (0x1) +float 0xffff != 0x7fff == 0x1 (0x1) +int 0xffff >= 0x7fff == 0x0 (0x0) +__uint 0xffff >= 0x7fff == 0x1 (0x1) +char 0xffff >= 0xffff == 0x1 (0x1) +__uchar 0xff >= 0xff == 0x1 (0x1) +__longlong 0xffff >= 0x7fff == 0x0 (0x0) +__ulonglong 0xffff >= 0x7fff == 0x1 (0x1) +float 0xffff >= 0x7fff == 0x0 (0x0) +int 0xffff / 0x7fff == 0x0 (0x0) +__uint 0xffff / 0x7fff == 0x2 (0x2) +char 0xffff / 0xffff == 0x1 (0x1) +__uchar 0xff / 0xff == 0x1 (0x1) +__longlong 0xffff / 0x7fff == 0x0 (0x0) +__ulonglong 0xffff / 0x7fff == 0x4 (0x4) +float 0xffff / 0x7fff == 0x0 (0x0) +int 0xffff % 0x7fff == -0x1 (0xffff) +__uint 0xffff % 0x7fff == 0x1 (0x1) +char 0xffff % 0xffff == 0x0 (0x0) +__uchar 0xff % 0xff == 0x0 (0x0) +__longlong 0xffff % 0x7fff == -0x1 (0xffff) +__ulonglong 0xffff % 0x7fff == 0x3 (0x3) +0xffff * 0x8000 == -0x8000 +0xffff / 0x8000 == 0x0 +0xffff % 0x8000 == -0x1 +int 0xffff ^ 0x8000 == 0x7fff (0x7fff) +__uint 0xffff ^ 0x8000 == 0x7fff (0x7fff) +char 0xffff ^ 0x0 == -0x1 (0xffff) +__uchar 0xff ^ 0x0 == 0xff (0xff) +__longlong 0xffff ^ 0x8000 == 0x7fff (0x7fff) +__ulonglong 0xffff ^ 0x8000 == 0x7fff (0x7fff) +int 0xffff && 0x8000 == 0x1 (0x1) +__uint 0xffff && 0x8000 == 0x1 (0x1) +char 0xffff && 0x0 == 0x0 (0x0) +__uchar 0xff && 0x0 == 0x0 (0x0) +__longlong 0xffff && 0x8000 == 0x1 (0x1) +__ulonglong 0xffff && 0x8000 == 0x1 (0x1) +int 0xffff || 0x8000 == 0x1 (0x1) +__uint 0xffff || 0x8000 == 0x1 (0x1) +char 0xffff || 0x0 == 0x1 (0x1) +__uchar 0xff || 0x0 == 0x1 (0x1) +__longlong 0xffff || 0x8000 == 0x1 (0x1) +__ulonglong 0xffff || 0x8000 == 0x1 (0x1) +int 0xffff & 0x8000 == -0x8000 (0x8000) +__uint 0xffff & 0x8000 == -0x8000 (0x8000) +char 0xffff & 0x0 == 0x0 (0x0) +__uchar 0xff & 0x0 == 0x0 (0x0) +__longlong 0xffff & 0x8000 == -0x8000 (0x8000) +__ulonglong 0xffff & 0x8000 == -0x8000 (0x8000) +int 0xffff | 0x8000 == -0x1 (0xffff) +__uint 0xffff | 0x8000 == -0x1 (0xffff) +char 0xffff | 0x0 == -0x1 (0xffff) +__uchar 0xff | 0x0 == 0xff (0xff) +__longlong 0xffff | 0x8000 == -0x1 (0xffff) +__ulonglong 0xffff | 0x8000 == -0x1 (0xffff) +int 0xffff << 0x12 == 0x0 (0x0) +__uint 0xffff << 0x12 == 0x0 (0x0) +char 0xffff << 0x12 == 0x0 (0x0) +__uchar 0xff << 0x12 == 0x0 (0x0) +__longlong 0xffff << 0x12 == 0x0 (0x0) +__ulonglong 0xffff << 0x12 == 0x0 (0x0) +int 0xffff >> 0x12 == -0x1 (0xffff) +__uint 0xffff >> 0x12 == 0x0 (0x0) +char 0xffff >> 0x12 == -0x1 (0xffff) +__uchar 0xff >> 0x12 == 0x0 (0x0) +__longlong 0xffff >> 0x12 == -0x1 (0xffff) +__ulonglong 0xffff >> 0x12 == 0x3fff (0x3fff) +int 0xffff + 0x8000 == 0x7fff (0x7fff) +__uint 0xffff + 0x8000 == 0x7fff (0x7fff) +char 0xffff + 0x0 == -0x1 (0xffff) +__uchar 0xff + 0x0 == 0xff (0xff) +__longlong 0xffff + 0x8000 == 0x7fff (0x7fff) +__ulonglong 0xffff + 0x8000 == 0x7fff (0x7fff) +float 0xffff + 0x8000 == 0x7fff (0x7fff) +int 0xffff - 0x8000 == 0x7fff (0x7fff) +__uint 0xffff - 0x8000 == 0x7fff (0x7fff) +char 0xffff - 0x0 == -0x1 (0xffff) +__uchar 0xff - 0x0 == 0xff (0xff) +__longlong 0xffff - 0x8000 == 0x7fff (0x7fff) +__ulonglong 0xffff - 0x8000 == 0x7fff (0x7fff) +float 0xffff - 0x8000 == 0x7fff (0x7fff) +int 0xffff * 0x8000 == -0x8000 (0x8000) +__uint 0xffff * 0x8000 == -0x8000 (0x8000) +char 0xffff * 0x0 == 0x0 (0x0) +__uchar 0xff * 0x0 == 0x0 (0x0) +__longlong 0xffff * 0x8000 == -0x8000 (0x8000) +__ulonglong 0xffff * 0x8000 == -0x8000 (0x8000) +float 0xffff * 0x8000 == -0x8000 (0x8000) +int 0xffff < 0x8000 == 0x0 (0x0) +__uint 0xffff < 0x8000 == 0x0 (0x0) +char 0xffff < 0x0 == 0x1 (0x1) +__uchar 0xff < 0x0 == 0x0 (0x0) +__longlong 0xffff < 0x8000 == 0x0 (0x0) +__ulonglong 0xffff < 0x8000 == 0x0 (0x0) +float 0xffff < 0x8000 == 0x0 (0x0) +int 0xffff > 0x8000 == 0x1 (0x1) +__uint 0xffff > 0x8000 == 0x1 (0x1) +char 0xffff > 0x0 == 0x0 (0x0) +__uchar 0xff > 0x0 == 0x1 (0x1) +__longlong 0xffff > 0x8000 == 0x1 (0x1) +__ulonglong 0xffff > 0x8000 == 0x1 (0x1) +float 0xffff > 0x8000 == 0x1 (0x1) +int 0xffff <= 0x8000 == 0x0 (0x0) +__uint 0xffff <= 0x8000 == 0x0 (0x0) +char 0xffff <= 0x0 == 0x1 (0x1) +__uchar 0xff <= 0x0 == 0x0 (0x0) +__longlong 0xffff <= 0x8000 == 0x0 (0x0) +__ulonglong 0xffff <= 0x8000 == 0x0 (0x0) +float 0xffff <= 0x8000 == 0x0 (0x0) +int 0xffff == 0x8000 == 0x0 (0x0) +__uint 0xffff == 0x8000 == 0x0 (0x0) +char 0xffff == 0x0 == 0x0 (0x0) +__uchar 0xff == 0x0 == 0x0 (0x0) +__longlong 0xffff == 0x8000 == 0x0 (0x0) +__ulonglong 0xffff == 0x8000 == 0x0 (0x0) +float 0xffff == 0x8000 == 0x0 (0x0) +int 0xffff != 0x8000 == 0x1 (0x1) +__uint 0xffff != 0x8000 == 0x1 (0x1) +char 0xffff != 0x0 == 0x1 (0x1) +__uchar 0xff != 0x0 == 0x1 (0x1) +__longlong 0xffff != 0x8000 == 0x1 (0x1) +__ulonglong 0xffff != 0x8000 == 0x1 (0x1) +float 0xffff != 0x8000 == 0x1 (0x1) +int 0xffff >= 0x8000 == 0x1 (0x1) +__uint 0xffff >= 0x8000 == 0x1 (0x1) +char 0xffff >= 0x0 == 0x0 (0x0) +__uchar 0xff >= 0x0 == 0x1 (0x1) +__longlong 0xffff >= 0x8000 == 0x1 (0x1) +__ulonglong 0xffff >= 0x8000 == 0x1 (0x1) +float 0xffff >= 0x8000 == 0x1 (0x1) +int 0xffff / 0x8000 == 0x0 (0x0) +__uint 0xffff / 0x8000 == 0x1 (0x1) +__longlong 0xffff / 0x8000 == 0x0 (0x0) +__ulonglong 0xffff / 0x8000 == 0x1 (0x1) +float 0xffff / 0x8000 == 0x0 (0x0) +int 0xffff % 0x8000 == -0x1 (0xffff) +__uint 0xffff % 0x8000 == 0x7fff (0x7fff) +__longlong 0xffff % 0x8000 == -0x1 (0xffff) +__ulonglong 0xffff % 0x8000 == 0x7fff (0x7fff) +0xffff * 0x3e8 == -0x3e8 +0xffff / 0x3e8 == 0x0 +0xffff % 0x3e8 == -0x1 +int 0xffff ^ 0x3e8 == -0x3e9 (0xfc17) +__uint 0xffff ^ 0x3e8 == -0x3e9 (0xfc17) +char 0xffff ^ 0xffe8 == 0x17 (0x17) +__uchar 0xff ^ 0xe8 == 0x17 (0x17) +__longlong 0xffff ^ 0x3e8 == -0x3e9 (0xfc17) +__ulonglong 0xffff ^ 0x3e8 == -0x3e9 (0xfc17) +int 0xffff && 0x3e8 == 0x1 (0x1) +__uint 0xffff && 0x3e8 == 0x1 (0x1) +char 0xffff && 0xffe8 == 0x1 (0x1) +__uchar 0xff && 0xe8 == 0x1 (0x1) +__longlong 0xffff && 0x3e8 == 0x1 (0x1) +__ulonglong 0xffff && 0x3e8 == 0x1 (0x1) +int 0xffff || 0x3e8 == 0x1 (0x1) +__uint 0xffff || 0x3e8 == 0x1 (0x1) +char 0xffff || 0xffe8 == 0x1 (0x1) +__uchar 0xff || 0xe8 == 0x1 (0x1) +__longlong 0xffff || 0x3e8 == 0x1 (0x1) +__ulonglong 0xffff || 0x3e8 == 0x1 (0x1) +int 0xffff & 0x3e8 == 0x3e8 (0x3e8) +__uint 0xffff & 0x3e8 == 0x3e8 (0x3e8) +char 0xffff & 0xffe8 == -0x18 (0xffe8) +__uchar 0xff & 0xe8 == 0xe8 (0xe8) +__longlong 0xffff & 0x3e8 == 0x3e8 (0x3e8) +__ulonglong 0xffff & 0x3e8 == 0x3e8 (0x3e8) +int 0xffff | 0x3e8 == -0x1 (0xffff) +__uint 0xffff | 0x3e8 == -0x1 (0xffff) +char 0xffff | 0xffe8 == -0x1 (0xffff) +__uchar 0xff | 0xe8 == 0xff (0xff) +__longlong 0xffff | 0x3e8 == -0x1 (0xffff) +__ulonglong 0xffff | 0x3e8 == -0x1 (0xffff) +int 0xffff << 0x14 == 0x0 (0x0) +__uint 0xffff << 0x14 == 0x0 (0x0) +char 0xffff << 0x14 == 0x0 (0x0) +__uchar 0xff << 0x14 == 0x0 (0x0) +__longlong 0xffff << 0x14 == 0x0 (0x0) +__ulonglong 0xffff << 0x14 == 0x0 (0x0) +int 0xffff >> 0x14 == -0x1 (0xffff) +__uint 0xffff >> 0x14 == 0x0 (0x0) +char 0xffff >> 0x14 == -0x1 (0xffff) +__uchar 0xff >> 0x14 == 0x0 (0x0) +__longlong 0xffff >> 0x14 == -0x1 (0xffff) +__ulonglong 0xffff >> 0x14 == 0xfff (0xfff) +int 0xffff + 0x3e8 == 0x3e7 (0x3e7) +__uint 0xffff + 0x3e8 == 0x3e7 (0x3e7) +char 0xffff + 0xffe8 == -0x19 (0xffe7) +__uchar 0xff + 0xe8 == 0xe7 (0xe7) +__longlong 0xffff + 0x3e8 == 0x3e7 (0x3e7) +__ulonglong 0xffff + 0x3e8 == 0x3e7 (0x3e7) +float 0xffff + 0x3e8 == 0x3e7 (0x3e7) +int 0xffff - 0x3e8 == -0x3e9 (0xfc17) +__uint 0xffff - 0x3e8 == -0x3e9 (0xfc17) +char 0xffff - 0xffe8 == 0x17 (0x17) +__uchar 0xff - 0xe8 == 0x17 (0x17) +__longlong 0xffff - 0x3e8 == -0x3e9 (0xfc17) +__ulonglong 0xffff - 0x3e8 == -0x3e9 (0xfc17) +float 0xffff - 0x3e8 == -0x3e9 (0xfc17) +int 0xffff * 0x3e8 == -0x3e8 (0xfc18) +__uint 0xffff * 0x3e8 == -0x3e8 (0xfc18) +char 0xffff * 0xffe8 == 0x18 (0x18) +__uchar 0xff * 0xe8 == 0x18 (0x18) +__longlong 0xffff * 0x3e8 == -0x3e8 (0xfc18) +__ulonglong 0xffff * 0x3e8 == -0x3e8 (0xfc18) +float 0xffff * 0x3e8 == -0x3e8 (0xfc18) +int 0xffff < 0x3e8 == 0x1 (0x1) +__uint 0xffff < 0x3e8 == 0x0 (0x0) +char 0xffff < 0xffe8 == 0x0 (0x0) +__uchar 0xff < 0xe8 == 0x0 (0x0) +__longlong 0xffff < 0x3e8 == 0x1 (0x1) +__ulonglong 0xffff < 0x3e8 == 0x0 (0x0) +float 0xffff < 0x3e8 == 0x1 (0x1) +int 0xffff > 0x3e8 == 0x0 (0x0) +__uint 0xffff > 0x3e8 == 0x1 (0x1) +char 0xffff > 0xffe8 == 0x1 (0x1) +__uchar 0xff > 0xe8 == 0x1 (0x1) +__longlong 0xffff > 0x3e8 == 0x0 (0x0) +__ulonglong 0xffff > 0x3e8 == 0x1 (0x1) +float 0xffff > 0x3e8 == 0x0 (0x0) +int 0xffff <= 0x3e8 == 0x1 (0x1) +__uint 0xffff <= 0x3e8 == 0x0 (0x0) +char 0xffff <= 0xffe8 == 0x0 (0x0) +__uchar 0xff <= 0xe8 == 0x0 (0x0) +__longlong 0xffff <= 0x3e8 == 0x1 (0x1) +__ulonglong 0xffff <= 0x3e8 == 0x0 (0x0) +float 0xffff <= 0x3e8 == 0x1 (0x1) +int 0xffff == 0x3e8 == 0x0 (0x0) +__uint 0xffff == 0x3e8 == 0x0 (0x0) +char 0xffff == 0xffe8 == 0x0 (0x0) +__uchar 0xff == 0xe8 == 0x0 (0x0) +__longlong 0xffff == 0x3e8 == 0x0 (0x0) +__ulonglong 0xffff == 0x3e8 == 0x0 (0x0) +float 0xffff == 0x3e8 == 0x0 (0x0) +int 0xffff != 0x3e8 == 0x1 (0x1) +__uint 0xffff != 0x3e8 == 0x1 (0x1) +char 0xffff != 0xffe8 == 0x1 (0x1) +__uchar 0xff != 0xe8 == 0x1 (0x1) +__longlong 0xffff != 0x3e8 == 0x1 (0x1) +__ulonglong 0xffff != 0x3e8 == 0x1 (0x1) +float 0xffff != 0x3e8 == 0x1 (0x1) +int 0xffff >= 0x3e8 == 0x0 (0x0) +__uint 0xffff >= 0x3e8 == 0x1 (0x1) +char 0xffff >= 0xffe8 == 0x1 (0x1) +__uchar 0xff >= 0xe8 == 0x1 (0x1) +__longlong 0xffff >= 0x3e8 == 0x0 (0x0) +__ulonglong 0xffff >= 0x3e8 == 0x1 (0x1) +float 0xffff >= 0x3e8 == 0x0 (0x0) +int 0xffff / 0x3e8 == 0x0 (0x0) +__uint 0xffff / 0x3e8 == 0x41 (0x41) +char 0xffff / 0xffe8 == 0x0 (0x0) +__uchar 0xff / 0xe8 == 0x1 (0x1) +__longlong 0xffff / 0x3e8 == 0x0 (0x0) +__ulonglong 0xffff / 0x3e8 == -0x76c9 (0x8937) +float 0xffff / 0x3e8 == 0x0 (0x0) +int 0xffff % 0x3e8 == -0x1 (0xffff) +__uint 0xffff % 0x3e8 == 0x217 (0x217) +char 0xffff % 0xffe8 == -0x1 (0xffff) +__uchar 0xff % 0xe8 == 0x17 (0x17) +__longlong 0xffff % 0x3e8 == -0x1 (0xffff) +__ulonglong 0xffff % 0x3e8 == 0x127 (0x127) +0xffff * 0x2710 == -0x2710 +0xffff / 0x2710 == 0x0 +0xffff % 0x2710 == -0x1 +int 0xffff ^ 0x2710 == -0x2711 (0xd8ef) +__uint 0xffff ^ 0x2710 == -0x2711 (0xd8ef) +char 0xffff ^ 0x10 == -0x11 (0xffef) +__uchar 0xff ^ 0x10 == 0xef (0xef) +__longlong 0xffff ^ 0x2710 == -0x2711 (0xd8ef) +__ulonglong 0xffff ^ 0x2710 == -0x2711 (0xd8ef) +int 0xffff && 0x2710 == 0x1 (0x1) +__uint 0xffff && 0x2710 == 0x1 (0x1) +char 0xffff && 0x10 == 0x1 (0x1) +__uchar 0xff && 0x10 == 0x1 (0x1) +__longlong 0xffff && 0x2710 == 0x1 (0x1) +__ulonglong 0xffff && 0x2710 == 0x1 (0x1) +int 0xffff || 0x2710 == 0x1 (0x1) +__uint 0xffff || 0x2710 == 0x1 (0x1) +char 0xffff || 0x10 == 0x1 (0x1) +__uchar 0xff || 0x10 == 0x1 (0x1) +__longlong 0xffff || 0x2710 == 0x1 (0x1) +__ulonglong 0xffff || 0x2710 == 0x1 (0x1) +int 0xffff & 0x2710 == 0x2710 (0x2710) +__uint 0xffff & 0x2710 == 0x2710 (0x2710) +char 0xffff & 0x10 == 0x10 (0x10) +__uchar 0xff & 0x10 == 0x10 (0x10) +__longlong 0xffff & 0x2710 == 0x2710 (0x2710) +__ulonglong 0xffff & 0x2710 == 0x2710 (0x2710) +int 0xffff | 0x2710 == -0x1 (0xffff) +__uint 0xffff | 0x2710 == -0x1 (0xffff) +char 0xffff | 0x10 == -0x1 (0xffff) +__uchar 0xff | 0x10 == 0xff (0xff) +__longlong 0xffff | 0x2710 == -0x1 (0xffff) +__ulonglong 0xffff | 0x2710 == -0x1 (0xffff) +int 0xffff << 0x16 == 0x0 (0x0) +__uint 0xffff << 0x16 == 0x0 (0x0) +char 0xffff << 0x16 == 0x0 (0x0) +__uchar 0xff << 0x16 == 0x0 (0x0) +__longlong 0xffff << 0x16 == 0x0 (0x0) +__ulonglong 0xffff << 0x16 == 0x0 (0x0) +int 0xffff >> 0x16 == -0x1 (0xffff) +__uint 0xffff >> 0x16 == 0x0 (0x0) +char 0xffff >> 0x16 == -0x1 (0xffff) +__uchar 0xff >> 0x16 == 0x0 (0x0) +__longlong 0xffff >> 0x16 == -0x1 (0xffff) +__ulonglong 0xffff >> 0x16 == 0x3ff (0x3ff) +int 0xffff + 0x2710 == 0x270f (0x270f) +__uint 0xffff + 0x2710 == 0x270f (0x270f) +char 0xffff + 0x10 == 0xf (0xf) +__uchar 0xff + 0x10 == 0xf (0xf) +__longlong 0xffff + 0x2710 == 0x270f (0x270f) +__ulonglong 0xffff + 0x2710 == 0x270f (0x270f) +float 0xffff + 0x2710 == 0x270f (0x270f) +int 0xffff - 0x2710 == -0x2711 (0xd8ef) +__uint 0xffff - 0x2710 == -0x2711 (0xd8ef) +char 0xffff - 0x10 == -0x11 (0xffef) +__uchar 0xff - 0x10 == 0xef (0xef) +__longlong 0xffff - 0x2710 == -0x2711 (0xd8ef) +__ulonglong 0xffff - 0x2710 == -0x2711 (0xd8ef) +float 0xffff - 0x2710 == -0x2711 (0xd8ef) +int 0xffff * 0x2710 == -0x2710 (0xd8f0) +__uint 0xffff * 0x2710 == -0x2710 (0xd8f0) +char 0xffff * 0x10 == -0x10 (0xfff0) +__uchar 0xff * 0x10 == 0xf0 (0xf0) +__longlong 0xffff * 0x2710 == -0x2710 (0xd8f0) +__ulonglong 0xffff * 0x2710 == -0x2710 (0xd8f0) +float 0xffff * 0x2710 == -0x2710 (0xd8f0) +int 0xffff < 0x2710 == 0x1 (0x1) +__uint 0xffff < 0x2710 == 0x0 (0x0) +char 0xffff < 0x10 == 0x1 (0x1) +__uchar 0xff < 0x10 == 0x0 (0x0) +__longlong 0xffff < 0x2710 == 0x1 (0x1) +__ulonglong 0xffff < 0x2710 == 0x0 (0x0) +float 0xffff < 0x2710 == 0x1 (0x1) +int 0xffff > 0x2710 == 0x0 (0x0) +__uint 0xffff > 0x2710 == 0x1 (0x1) +char 0xffff > 0x10 == 0x0 (0x0) +__uchar 0xff > 0x10 == 0x1 (0x1) +__longlong 0xffff > 0x2710 == 0x0 (0x0) +__ulonglong 0xffff > 0x2710 == 0x1 (0x1) +float 0xffff > 0x2710 == 0x0 (0x0) +int 0xffff <= 0x2710 == 0x1 (0x1) +__uint 0xffff <= 0x2710 == 0x0 (0x0) +char 0xffff <= 0x10 == 0x1 (0x1) +__uchar 0xff <= 0x10 == 0x0 (0x0) +__longlong 0xffff <= 0x2710 == 0x1 (0x1) +__ulonglong 0xffff <= 0x2710 == 0x0 (0x0) +float 0xffff <= 0x2710 == 0x1 (0x1) +int 0xffff == 0x2710 == 0x0 (0x0) +__uint 0xffff == 0x2710 == 0x0 (0x0) +char 0xffff == 0x10 == 0x0 (0x0) +__uchar 0xff == 0x10 == 0x0 (0x0) +__longlong 0xffff == 0x2710 == 0x0 (0x0) +__ulonglong 0xffff == 0x2710 == 0x0 (0x0) +float 0xffff == 0x2710 == 0x0 (0x0) +int 0xffff != 0x2710 == 0x1 (0x1) +__uint 0xffff != 0x2710 == 0x1 (0x1) +char 0xffff != 0x10 == 0x1 (0x1) +__uchar 0xff != 0x10 == 0x1 (0x1) +__longlong 0xffff != 0x2710 == 0x1 (0x1) +__ulonglong 0xffff != 0x2710 == 0x1 (0x1) +float 0xffff != 0x2710 == 0x1 (0x1) +int 0xffff >= 0x2710 == 0x0 (0x0) +__uint 0xffff >= 0x2710 == 0x1 (0x1) +char 0xffff >= 0x10 == 0x0 (0x0) +__uchar 0xff >= 0x10 == 0x1 (0x1) +__longlong 0xffff >= 0x2710 == 0x0 (0x0) +__ulonglong 0xffff >= 0x2710 == 0x1 (0x1) +float 0xffff >= 0x2710 == 0x0 (0x0) +int 0xffff / 0x2710 == 0x0 (0x0) +__uint 0xffff / 0x2710 == 0x6 (0x6) +char 0xffff / 0x10 == 0x0 (0x0) +__uchar 0xff / 0x10 == 0xf (0xf) +__longlong 0xffff / 0x2710 == 0x0 (0x0) +__ulonglong 0xffff / 0x2710 == -0x7248 (0x8db8) +float 0xffff / 0x2710 == 0x0 (0x0) +int 0xffff % 0x2710 == -0x1 (0xffff) +__uint 0xffff % 0x2710 == 0x159f (0x159f) +char 0xffff % 0x10 == -0x1 (0xffff) +__uchar 0xff % 0x10 == 0xf (0xf) +__longlong 0xffff % 0x2710 == -0x1 (0xffff) +__ulonglong 0xffff % 0x2710 == 0x1c7f (0x1c7f) +int xor42-0x1 xor42 -0x2b +__uint xor42-0x1 xor42 -0x2b +char xor42-0x1 xor42 -0x2b +__uchar xor420xff xor42 0xd5 +__longlong xor42-0x1 xor42 -0x2b +__ulonglong xor42-0x1 xor42 -0x2b +int land1-0x1 land1 0x1 +__uint land1-0x1 land1 0x1 +char land1-0x1 land1 0x1 +__uchar land10xff land1 0x1 +__longlong land1-0x1 land1 0x1 +__ulonglong land1-0x1 land1 0x1 +int lor1-0x1 lor1 0x1 +__uint lor1-0x1 lor1 0x1 +char lor1-0x1 lor1 0x1 +__uchar lor10xff lor1 0x1 +__longlong lor1-0x1 lor1 0x1 +__ulonglong lor1-0x1 lor1 0x1 +int and42-0x1 and42 0x2a +__uint and42-0x1 and42 0x2a +char and42-0x1 and42 0x2a +__uchar and420xff and42 0x2a +__longlong and42-0x1 and42 0x2a +__ulonglong and42-0x1 and42 0x2a +int or42-0x1 or42 -0x1 +__uint or42-0x1 or42 -0x1 +char or42-0x1 or42 -0x1 +__uchar or420xff or42 0xff +__longlong or42-0x1 or42 -0x1 +__ulonglong or42-0x1 or42 -0x1 +int shl5-0x1 shl5 -0x20 +__uint shl5-0x1 shl5 -0x20 +char shl5-0x1 shl5 -0x20 +__uchar shl50xff shl5 0xe0 +__longlong shl5-0x1 shl5 -0x20 +__ulonglong shl5-0x1 shl5 -0x20 +int shr5-0x1 shr5 -0x1 +__uint shr5-0x1 shr5 0x7ff +char shr5-0x1 shr5 -0x1 +__uchar shr50xff shr5 0x7 +__longlong shr5-0x1 shr5 -0x1 +__ulonglong shr5-0x1 shr5 -0x1 +int add42-0x1 add42 0x29 +__uint add42-0x1 add42 0x29 +char add42-0x1 add42 0x29 +__uchar add420xff add42 0x29 +__longlong add42-0x1 add42 0x29 +__ulonglong add42-0x1 add42 0x29 +float add42-0x1 add42 0x29 +int sub42-0x1 sub42 -0x2b +__uint sub42-0x1 sub42 -0x2b +char sub42-0x1 sub42 -0x2b +__uchar sub420xff sub42 0xd5 +__longlong sub42-0x1 sub42 -0x2b +__ulonglong sub42-0x1 sub42 -0x2b +float sub42-0x1 sub42 -0x2b +int mul42-0x1 mul42 -0x2a +__uint mul42-0x1 mul42 -0x2a +char mul42-0x1 mul42 -0x2a +__uchar mul420xff mul42 0xd6 +__longlong mul42-0x1 mul42 -0x2a +__ulonglong mul42-0x1 mul42 -0x2a +float mul42-0x1 mul42 -0x2a +int lt42-0x1 lt42 0x1 +__uint lt42-0x1 lt42 0x0 +char lt42-0x1 lt42 0x1 +__uchar lt420xff lt42 0x0 +__longlong lt42-0x1 lt42 0x1 +__ulonglong lt42-0x1 lt42 0x0 +float lt42-0x1 lt42 0x1 +int gt42-0x1 gt42 0x0 +__uint gt42-0x1 gt42 0x1 +char gt42-0x1 gt42 0x0 +__uchar gt420xff gt42 0x1 +__longlong gt42-0x1 gt42 0x0 +__ulonglong gt42-0x1 gt42 0x1 +float gt42-0x1 gt42 0x0 +int le42-0x1 le42 0x1 +__uint le42-0x1 le42 0x0 +char le42-0x1 le42 0x1 +__uchar le420xff le42 0x0 +__longlong le42-0x1 le42 0x1 +__ulonglong le42-0x1 le42 0x0 +float le42-0x1 le42 0x1 +int eq42-0x1 eq42 0x0 +__uint eq42-0x1 eq42 0x0 +char eq42-0x1 eq42 0x0 +__uchar eq420xff eq42 0x0 +__longlong eq42-0x1 eq42 0x0 +__ulonglong eq42-0x1 eq42 0x0 +float eq42-0x1 eq42 0x0 +int ne42-0x1 ne42 0x1 +__uint ne42-0x1 ne42 0x1 +char ne42-0x1 ne42 0x1 +__uchar ne420xff ne42 0x1 +__longlong ne42-0x1 ne42 0x1 +__ulonglong ne42-0x1 ne42 0x1 +float ne42-0x1 ne42 0x1 +int ge42-0x1 ge42 0x0 +__uint ge42-0x1 ge42 0x1 +char ge42-0x1 ge42 0x0 +__uchar ge420xff ge42 0x1 +__longlong ge42-0x1 ge42 0x0 +__ulonglong ge42-0x1 ge42 0x1 +float ge42-0x1 ge42 0x0 +int div42-0x1 div42 0x0 +__uint div42-0x1 div42 0x618 +char div42-0x1 div42 0x0 +__uchar div420xff div42 0x6 +__longlong div42-0x1 div42 0x0 +__ulonglong div42-0x1 div42 0x6186 +float div42-0x1 div42 0x0 +int mod23-0x1 mod23 -0x1 +__uint mod23-0x1 mod23 0x8 +char mod23-0x1 mod23 -0x1 +__uchar mod230xff mod23 0x2 +__longlong mod23-0x1 mod23 -0x1 +__ulonglong mod23-0x1 mod23 0xb +0x1 * 0xffff == -0x1 +0x1 / 0xffff == -0x1 +0x1 % 0xffff == 0x0 +int 0x1 ^ 0xffff == -0x2 (0xfffe) +__uint 0x1 ^ 0xffff == -0x2 (0xfffe) +char 0x1 ^ 0xffff == -0x2 (0xfffe) +__uchar 0x1 ^ 0xff == 0xfe (0xfe) +__longlong 0x1 ^ 0xffff == -0x2 (0xfffe) +__ulonglong 0x1 ^ 0xffff == -0x2 (0xfffe) +int 0x1 && 0xffff == 0x1 (0x1) +__uint 0x1 && 0xffff == 0x1 (0x1) +char 0x1 && 0xffff == 0x1 (0x1) +__uchar 0x1 && 0xff == 0x1 (0x1) +__longlong 0x1 && 0xffff == 0x1 (0x1) +__ulonglong 0x1 && 0xffff == 0x1 (0x1) +int 0x1 || 0xffff == 0x1 (0x1) +__uint 0x1 || 0xffff == 0x1 (0x1) +char 0x1 || 0xffff == 0x1 (0x1) +__uchar 0x1 || 0xff == 0x1 (0x1) +__longlong 0x1 || 0xffff == 0x1 (0x1) +__ulonglong 0x1 || 0xffff == 0x1 (0x1) +int 0x1 & 0xffff == 0x1 (0x1) +__uint 0x1 & 0xffff == 0x1 (0x1) +char 0x1 & 0xffff == 0x1 (0x1) +__uchar 0x1 & 0xff == 0x1 (0x1) +__longlong 0x1 & 0xffff == 0x1 (0x1) +__ulonglong 0x1 & 0xffff == 0x1 (0x1) +int 0x1 | 0xffff == -0x1 (0xffff) +__uint 0x1 | 0xffff == -0x1 (0xffff) +char 0x1 | 0xffff == -0x1 (0xffff) +__uchar 0x1 | 0xff == 0xff (0xff) +__longlong 0x1 | 0xffff == -0x1 (0xffff) +__ulonglong 0x1 | 0xffff == -0x1 (0xffff) +int 0x1 << 0x1 == 0x2 (0x2) +__uint 0x1 << 0x1 == 0x2 (0x2) +char 0x1 << 0x1 == 0x2 (0x2) +__uchar 0x1 << 0x1 == 0x2 (0x2) +__longlong 0x1 << 0x1 == 0x2 (0x2) +__ulonglong 0x1 << 0x1 == 0x2 (0x2) +int 0x1 >> 0x1 == 0x0 (0x0) +__uint 0x1 >> 0x1 == 0x0 (0x0) +char 0x1 >> 0x1 == 0x0 (0x0) +__uchar 0x1 >> 0x1 == 0x0 (0x0) +__longlong 0x1 >> 0x1 == 0x0 (0x0) +__ulonglong 0x1 >> 0x1 == 0x0 (0x0) +int 0x1 + 0xffff == 0x0 (0x0) +__uint 0x1 + 0xffff == 0x0 (0x0) +char 0x1 + 0xffff == 0x0 (0x0) +__uchar 0x1 + 0xff == 0x0 (0x0) +__longlong 0x1 + 0xffff == 0x0 (0x0) +__ulonglong 0x1 + 0xffff == 0x0 (0x0) +float 0x1 + 0xffff == 0x0 (0x0) +int 0x1 - 0xffff == 0x2 (0x2) +__uint 0x1 - 0xffff == 0x2 (0x2) +char 0x1 - 0xffff == 0x2 (0x2) +__uchar 0x1 - 0xff == 0x2 (0x2) +__longlong 0x1 - 0xffff == 0x2 (0x2) +__ulonglong 0x1 - 0xffff == 0x2 (0x2) +float 0x1 - 0xffff == 0x2 (0x2) +int 0x1 * 0xffff == -0x1 (0xffff) +__uint 0x1 * 0xffff == -0x1 (0xffff) +char 0x1 * 0xffff == -0x1 (0xffff) +__uchar 0x1 * 0xff == 0xff (0xff) +__longlong 0x1 * 0xffff == -0x1 (0xffff) +__ulonglong 0x1 * 0xffff == -0x1 (0xffff) +float 0x1 * 0xffff == -0x1 (0xffff) +int 0x1 < 0xffff == 0x0 (0x0) +__uint 0x1 < 0xffff == 0x1 (0x1) +char 0x1 < 0xffff == 0x0 (0x0) +__uchar 0x1 < 0xff == 0x1 (0x1) +__longlong 0x1 < 0xffff == 0x0 (0x0) +__ulonglong 0x1 < 0xffff == 0x1 (0x1) +float 0x1 < 0xffff == 0x0 (0x0) +int 0x1 > 0xffff == 0x1 (0x1) +__uint 0x1 > 0xffff == 0x0 (0x0) +char 0x1 > 0xffff == 0x1 (0x1) +__uchar 0x1 > 0xff == 0x0 (0x0) +__longlong 0x1 > 0xffff == 0x1 (0x1) +__ulonglong 0x1 > 0xffff == 0x0 (0x0) +float 0x1 > 0xffff == 0x1 (0x1) +int 0x1 <= 0xffff == 0x0 (0x0) +__uint 0x1 <= 0xffff == 0x1 (0x1) +char 0x1 <= 0xffff == 0x0 (0x0) +__uchar 0x1 <= 0xff == 0x1 (0x1) +__longlong 0x1 <= 0xffff == 0x0 (0x0) +__ulonglong 0x1 <= 0xffff == 0x1 (0x1) +float 0x1 <= 0xffff == 0x0 (0x0) +int 0x1 == 0xffff == 0x0 (0x0) +__uint 0x1 == 0xffff == 0x0 (0x0) +char 0x1 == 0xffff == 0x0 (0x0) +__uchar 0x1 == 0xff == 0x0 (0x0) +__longlong 0x1 == 0xffff == 0x0 (0x0) +__ulonglong 0x1 == 0xffff == 0x0 (0x0) +float 0x1 == 0xffff == 0x0 (0x0) +int 0x1 != 0xffff == 0x1 (0x1) +__uint 0x1 != 0xffff == 0x1 (0x1) +char 0x1 != 0xffff == 0x1 (0x1) +__uchar 0x1 != 0xff == 0x1 (0x1) +__longlong 0x1 != 0xffff == 0x1 (0x1) +__ulonglong 0x1 != 0xffff == 0x1 (0x1) +float 0x1 != 0xffff == 0x1 (0x1) +int 0x1 >= 0xffff == 0x1 (0x1) +__uint 0x1 >= 0xffff == 0x0 (0x0) +char 0x1 >= 0xffff == 0x1 (0x1) +__uchar 0x1 >= 0xff == 0x0 (0x0) +__longlong 0x1 >= 0xffff == 0x1 (0x1) +__ulonglong 0x1 >= 0xffff == 0x0 (0x0) +float 0x1 >= 0xffff == 0x1 (0x1) +int 0x1 / 0xffff == -0x1 (0xffff) +__uint 0x1 / 0xffff == 0x0 (0x0) +char 0x1 / 0xffff == -0x1 (0xffff) +__uchar 0x1 / 0xff == 0x0 (0x0) +__longlong 0x1 / 0xffff == -0x1 (0xffff) +__ulonglong 0x1 / 0xffff == 0x0 (0x0) +float 0x1 / 0xffff == -0x1 (0xffff) +int 0x1 % 0xffff == 0x0 (0x0) +__uint 0x1 % 0xffff == 0x1 (0x1) +char 0x1 % 0xffff == 0x0 (0x0) +__uchar 0x1 % 0xff == 0x1 (0x1) +__longlong 0x1 % 0xffff == 0x0 (0x0) +__ulonglong 0x1 % 0xffff == 0x1 (0x1) +0x1 * 0x1 == 0x1 +0x1 / 0x1 == 0x1 +0x1 % 0x1 == 0x0 +int 0x1 ^ 0x1 == 0x0 (0x0) +__uint 0x1 ^ 0x1 == 0x0 (0x0) +char 0x1 ^ 0x1 == 0x0 (0x0) +__uchar 0x1 ^ 0x1 == 0x0 (0x0) +__longlong 0x1 ^ 0x1 == 0x0 (0x0) +__ulonglong 0x1 ^ 0x1 == 0x0 (0x0) +int 0x1 && 0x1 == 0x1 (0x1) +__uint 0x1 && 0x1 == 0x1 (0x1) +char 0x1 && 0x1 == 0x1 (0x1) +__uchar 0x1 && 0x1 == 0x1 (0x1) +__longlong 0x1 && 0x1 == 0x1 (0x1) +__ulonglong 0x1 && 0x1 == 0x1 (0x1) +int 0x1 || 0x1 == 0x1 (0x1) +__uint 0x1 || 0x1 == 0x1 (0x1) +char 0x1 || 0x1 == 0x1 (0x1) +__uchar 0x1 || 0x1 == 0x1 (0x1) +__longlong 0x1 || 0x1 == 0x1 (0x1) +__ulonglong 0x1 || 0x1 == 0x1 (0x1) +int 0x1 & 0x1 == 0x1 (0x1) +__uint 0x1 & 0x1 == 0x1 (0x1) +char 0x1 & 0x1 == 0x1 (0x1) +__uchar 0x1 & 0x1 == 0x1 (0x1) +__longlong 0x1 & 0x1 == 0x1 (0x1) +__ulonglong 0x1 & 0x1 == 0x1 (0x1) +int 0x1 | 0x1 == 0x1 (0x1) +__uint 0x1 | 0x1 == 0x1 (0x1) +char 0x1 | 0x1 == 0x1 (0x1) +__uchar 0x1 | 0x1 == 0x1 (0x1) +__longlong 0x1 | 0x1 == 0x1 (0x1) +__ulonglong 0x1 | 0x1 == 0x1 (0x1) +int 0x1 << 0x2 == 0x4 (0x4) +__uint 0x1 << 0x2 == 0x4 (0x4) +char 0x1 << 0x2 == 0x4 (0x4) +__uchar 0x1 << 0x2 == 0x4 (0x4) +__longlong 0x1 << 0x2 == 0x4 (0x4) +__ulonglong 0x1 << 0x2 == 0x4 (0x4) +int 0x1 >> 0x2 == 0x0 (0x0) +__uint 0x1 >> 0x2 == 0x0 (0x0) +char 0x1 >> 0x2 == 0x0 (0x0) +__uchar 0x1 >> 0x2 == 0x0 (0x0) +__longlong 0x1 >> 0x2 == 0x0 (0x0) +__ulonglong 0x1 >> 0x2 == 0x0 (0x0) +int 0x1 + 0x1 == 0x2 (0x2) +__uint 0x1 + 0x1 == 0x2 (0x2) +char 0x1 + 0x1 == 0x2 (0x2) +__uchar 0x1 + 0x1 == 0x2 (0x2) +__longlong 0x1 + 0x1 == 0x2 (0x2) +__ulonglong 0x1 + 0x1 == 0x2 (0x2) +float 0x1 + 0x1 == 0x2 (0x2) +int 0x1 - 0x1 == 0x0 (0x0) +__uint 0x1 - 0x1 == 0x0 (0x0) +char 0x1 - 0x1 == 0x0 (0x0) +__uchar 0x1 - 0x1 == 0x0 (0x0) +__longlong 0x1 - 0x1 == 0x0 (0x0) +__ulonglong 0x1 - 0x1 == 0x0 (0x0) +float 0x1 - 0x1 == 0x0 (0x0) +int 0x1 * 0x1 == 0x1 (0x1) +__uint 0x1 * 0x1 == 0x1 (0x1) +char 0x1 * 0x1 == 0x1 (0x1) +__uchar 0x1 * 0x1 == 0x1 (0x1) +__longlong 0x1 * 0x1 == 0x1 (0x1) +__ulonglong 0x1 * 0x1 == 0x1 (0x1) +float 0x1 * 0x1 == 0x1 (0x1) +int 0x1 < 0x1 == 0x0 (0x0) +__uint 0x1 < 0x1 == 0x0 (0x0) +char 0x1 < 0x1 == 0x0 (0x0) +__uchar 0x1 < 0x1 == 0x0 (0x0) +__longlong 0x1 < 0x1 == 0x0 (0x0) +__ulonglong 0x1 < 0x1 == 0x0 (0x0) +float 0x1 < 0x1 == 0x0 (0x0) +int 0x1 > 0x1 == 0x0 (0x0) +__uint 0x1 > 0x1 == 0x0 (0x0) +char 0x1 > 0x1 == 0x0 (0x0) +__uchar 0x1 > 0x1 == 0x0 (0x0) +__longlong 0x1 > 0x1 == 0x0 (0x0) +__ulonglong 0x1 > 0x1 == 0x0 (0x0) +float 0x1 > 0x1 == 0x0 (0x0) +int 0x1 <= 0x1 == 0x1 (0x1) +__uint 0x1 <= 0x1 == 0x1 (0x1) +char 0x1 <= 0x1 == 0x1 (0x1) +__uchar 0x1 <= 0x1 == 0x1 (0x1) +__longlong 0x1 <= 0x1 == 0x1 (0x1) +__ulonglong 0x1 <= 0x1 == 0x1 (0x1) +float 0x1 <= 0x1 == 0x1 (0x1) +int 0x1 == 0x1 == 0x1 (0x1) +__uint 0x1 == 0x1 == 0x1 (0x1) +char 0x1 == 0x1 == 0x1 (0x1) +__uchar 0x1 == 0x1 == 0x1 (0x1) +__longlong 0x1 == 0x1 == 0x1 (0x1) +__ulonglong 0x1 == 0x1 == 0x1 (0x1) +float 0x1 == 0x1 == 0x1 (0x1) +int 0x1 != 0x1 == 0x0 (0x0) +__uint 0x1 != 0x1 == 0x0 (0x0) +char 0x1 != 0x1 == 0x0 (0x0) +__uchar 0x1 != 0x1 == 0x0 (0x0) +__longlong 0x1 != 0x1 == 0x0 (0x0) +__ulonglong 0x1 != 0x1 == 0x0 (0x0) +float 0x1 != 0x1 == 0x0 (0x0) +int 0x1 >= 0x1 == 0x1 (0x1) +__uint 0x1 >= 0x1 == 0x1 (0x1) +char 0x1 >= 0x1 == 0x1 (0x1) +__uchar 0x1 >= 0x1 == 0x1 (0x1) +__longlong 0x1 >= 0x1 == 0x1 (0x1) +__ulonglong 0x1 >= 0x1 == 0x1 (0x1) +float 0x1 >= 0x1 == 0x1 (0x1) +int 0x1 / 0x1 == 0x1 (0x1) +__uint 0x1 / 0x1 == 0x1 (0x1) +char 0x1 / 0x1 == 0x1 (0x1) +__uchar 0x1 / 0x1 == 0x1 (0x1) +__longlong 0x1 / 0x1 == 0x1 (0x1) +__ulonglong 0x1 / 0x1 == 0x1 (0x1) +float 0x1 / 0x1 == 0x1 (0x1) +int 0x1 % 0x1 == 0x0 (0x0) +__uint 0x1 % 0x1 == 0x0 (0x0) +char 0x1 % 0x1 == 0x0 (0x0) +__uchar 0x1 % 0x1 == 0x0 (0x0) +__longlong 0x1 % 0x1 == 0x0 (0x0) +__ulonglong 0x1 % 0x1 == 0x0 (0x0) +0x1 * 0x2 == 0x2 +0x1 / 0x2 == 0x0 +0x1 % 0x2 == 0x1 +int 0x1 ^ 0x2 == 0x3 (0x3) +__uint 0x1 ^ 0x2 == 0x3 (0x3) +char 0x1 ^ 0x2 == 0x3 (0x3) +__uchar 0x1 ^ 0x2 == 0x3 (0x3) +__longlong 0x1 ^ 0x2 == 0x3 (0x3) +__ulonglong 0x1 ^ 0x2 == 0x3 (0x3) +int 0x1 && 0x2 == 0x1 (0x1) +__uint 0x1 && 0x2 == 0x1 (0x1) +char 0x1 && 0x2 == 0x1 (0x1) +__uchar 0x1 && 0x2 == 0x1 (0x1) +__longlong 0x1 && 0x2 == 0x1 (0x1) +__ulonglong 0x1 && 0x2 == 0x1 (0x1) +int 0x1 || 0x2 == 0x1 (0x1) +__uint 0x1 || 0x2 == 0x1 (0x1) +char 0x1 || 0x2 == 0x1 (0x1) +__uchar 0x1 || 0x2 == 0x1 (0x1) +__longlong 0x1 || 0x2 == 0x1 (0x1) +__ulonglong 0x1 || 0x2 == 0x1 (0x1) +int 0x1 & 0x2 == 0x0 (0x0) +__uint 0x1 & 0x2 == 0x0 (0x0) +char 0x1 & 0x2 == 0x0 (0x0) +__uchar 0x1 & 0x2 == 0x0 (0x0) +__longlong 0x1 & 0x2 == 0x0 (0x0) +__ulonglong 0x1 & 0x2 == 0x0 (0x0) +int 0x1 | 0x2 == 0x3 (0x3) +__uint 0x1 | 0x2 == 0x3 (0x3) +char 0x1 | 0x2 == 0x3 (0x3) +__uchar 0x1 | 0x2 == 0x3 (0x3) +__longlong 0x1 | 0x2 == 0x3 (0x3) +__ulonglong 0x1 | 0x2 == 0x3 (0x3) +int 0x1 << 0x3 == 0x8 (0x8) +__uint 0x1 << 0x3 == 0x8 (0x8) +char 0x1 << 0x3 == 0x8 (0x8) +__uchar 0x1 << 0x3 == 0x8 (0x8) +__longlong 0x1 << 0x3 == 0x8 (0x8) +__ulonglong 0x1 << 0x3 == 0x8 (0x8) +int 0x1 >> 0x3 == 0x0 (0x0) +__uint 0x1 >> 0x3 == 0x0 (0x0) +char 0x1 >> 0x3 == 0x0 (0x0) +__uchar 0x1 >> 0x3 == 0x0 (0x0) +__longlong 0x1 >> 0x3 == 0x0 (0x0) +__ulonglong 0x1 >> 0x3 == 0x0 (0x0) +int 0x1 + 0x2 == 0x3 (0x3) +__uint 0x1 + 0x2 == 0x3 (0x3) +char 0x1 + 0x2 == 0x3 (0x3) +__uchar 0x1 + 0x2 == 0x3 (0x3) +__longlong 0x1 + 0x2 == 0x3 (0x3) +__ulonglong 0x1 + 0x2 == 0x3 (0x3) +float 0x1 + 0x2 == 0x3 (0x3) +int 0x1 - 0x2 == -0x1 (0xffff) +__uint 0x1 - 0x2 == -0x1 (0xffff) +char 0x1 - 0x2 == -0x1 (0xffff) +__uchar 0x1 - 0x2 == 0xff (0xff) +__longlong 0x1 - 0x2 == -0x1 (0xffff) +__ulonglong 0x1 - 0x2 == -0x1 (0xffff) +float 0x1 - 0x2 == -0x1 (0xffff) +int 0x1 * 0x2 == 0x2 (0x2) +__uint 0x1 * 0x2 == 0x2 (0x2) +char 0x1 * 0x2 == 0x2 (0x2) +__uchar 0x1 * 0x2 == 0x2 (0x2) +__longlong 0x1 * 0x2 == 0x2 (0x2) +__ulonglong 0x1 * 0x2 == 0x2 (0x2) +float 0x1 * 0x2 == 0x2 (0x2) +int 0x1 < 0x2 == 0x1 (0x1) +__uint 0x1 < 0x2 == 0x1 (0x1) +char 0x1 < 0x2 == 0x1 (0x1) +__uchar 0x1 < 0x2 == 0x1 (0x1) +__longlong 0x1 < 0x2 == 0x1 (0x1) +__ulonglong 0x1 < 0x2 == 0x1 (0x1) +float 0x1 < 0x2 == 0x1 (0x1) +int 0x1 > 0x2 == 0x0 (0x0) +__uint 0x1 > 0x2 == 0x0 (0x0) +char 0x1 > 0x2 == 0x0 (0x0) +__uchar 0x1 > 0x2 == 0x0 (0x0) +__longlong 0x1 > 0x2 == 0x0 (0x0) +__ulonglong 0x1 > 0x2 == 0x0 (0x0) +float 0x1 > 0x2 == 0x0 (0x0) +int 0x1 <= 0x2 == 0x1 (0x1) +__uint 0x1 <= 0x2 == 0x1 (0x1) +char 0x1 <= 0x2 == 0x1 (0x1) +__uchar 0x1 <= 0x2 == 0x1 (0x1) +__longlong 0x1 <= 0x2 == 0x1 (0x1) +__ulonglong 0x1 <= 0x2 == 0x1 (0x1) +float 0x1 <= 0x2 == 0x1 (0x1) +int 0x1 == 0x2 == 0x0 (0x0) +__uint 0x1 == 0x2 == 0x0 (0x0) +char 0x1 == 0x2 == 0x0 (0x0) +__uchar 0x1 == 0x2 == 0x0 (0x0) +__longlong 0x1 == 0x2 == 0x0 (0x0) +__ulonglong 0x1 == 0x2 == 0x0 (0x0) +float 0x1 == 0x2 == 0x0 (0x0) +int 0x1 != 0x2 == 0x1 (0x1) +__uint 0x1 != 0x2 == 0x1 (0x1) +char 0x1 != 0x2 == 0x1 (0x1) +__uchar 0x1 != 0x2 == 0x1 (0x1) +__longlong 0x1 != 0x2 == 0x1 (0x1) +__ulonglong 0x1 != 0x2 == 0x1 (0x1) +float 0x1 != 0x2 == 0x1 (0x1) +int 0x1 >= 0x2 == 0x0 (0x0) +__uint 0x1 >= 0x2 == 0x0 (0x0) +char 0x1 >= 0x2 == 0x0 (0x0) +__uchar 0x1 >= 0x2 == 0x0 (0x0) +__longlong 0x1 >= 0x2 == 0x0 (0x0) +__ulonglong 0x1 >= 0x2 == 0x0 (0x0) +float 0x1 >= 0x2 == 0x0 (0x0) +int 0x1 / 0x2 == 0x0 (0x0) +__uint 0x1 / 0x2 == 0x0 (0x0) +char 0x1 / 0x2 == 0x0 (0x0) +__uchar 0x1 / 0x2 == 0x0 (0x0) +__longlong 0x1 / 0x2 == 0x0 (0x0) +__ulonglong 0x1 / 0x2 == 0x0 (0x0) +float 0x1 / 0x2 == 0x0 (0x0) +int 0x1 % 0x2 == 0x1 (0x1) +__uint 0x1 % 0x2 == 0x1 (0x1) +char 0x1 % 0x2 == 0x1 (0x1) +__uchar 0x1 % 0x2 == 0x1 (0x1) +__longlong 0x1 % 0x2 == 0x1 (0x1) +__ulonglong 0x1 % 0x2 == 0x1 (0x1) +0x1 * 0xfffe == -0x2 +0x1 / 0xfffe == 0x0 +0x1 % 0xfffe == 0x1 +int 0x1 ^ 0xfffe == -0x1 (0xffff) +__uint 0x1 ^ 0xfffe == -0x1 (0xffff) +char 0x1 ^ 0xfffe == -0x1 (0xffff) +__uchar 0x1 ^ 0xfe == 0xff (0xff) +__longlong 0x1 ^ 0xfffe == -0x1 (0xffff) +__ulonglong 0x1 ^ 0xfffe == -0x1 (0xffff) +int 0x1 && 0xfffe == 0x1 (0x1) +__uint 0x1 && 0xfffe == 0x1 (0x1) +char 0x1 && 0xfffe == 0x1 (0x1) +__uchar 0x1 && 0xfe == 0x1 (0x1) +__longlong 0x1 && 0xfffe == 0x1 (0x1) +__ulonglong 0x1 && 0xfffe == 0x1 (0x1) +int 0x1 || 0xfffe == 0x1 (0x1) +__uint 0x1 || 0xfffe == 0x1 (0x1) +char 0x1 || 0xfffe == 0x1 (0x1) +__uchar 0x1 || 0xfe == 0x1 (0x1) +__longlong 0x1 || 0xfffe == 0x1 (0x1) +__ulonglong 0x1 || 0xfffe == 0x1 (0x1) +int 0x1 & 0xfffe == 0x0 (0x0) +__uint 0x1 & 0xfffe == 0x0 (0x0) +char 0x1 & 0xfffe == 0x0 (0x0) +__uchar 0x1 & 0xfe == 0x0 (0x0) +__longlong 0x1 & 0xfffe == 0x0 (0x0) +__ulonglong 0x1 & 0xfffe == 0x0 (0x0) +int 0x1 | 0xfffe == -0x1 (0xffff) +__uint 0x1 | 0xfffe == -0x1 (0xffff) +char 0x1 | 0xfffe == -0x1 (0xffff) +__uchar 0x1 | 0xfe == 0xff (0xff) +__longlong 0x1 | 0xfffe == -0x1 (0xffff) +__ulonglong 0x1 | 0xfffe == -0x1 (0xffff) +int 0x1 << 0x4 == 0x10 (0x10) +__uint 0x1 << 0x4 == 0x10 (0x10) +char 0x1 << 0x4 == 0x10 (0x10) +__uchar 0x1 << 0x4 == 0x10 (0x10) +__longlong 0x1 << 0x4 == 0x10 (0x10) +__ulonglong 0x1 << 0x4 == 0x10 (0x10) +int 0x1 >> 0x4 == 0x0 (0x0) +__uint 0x1 >> 0x4 == 0x0 (0x0) +char 0x1 >> 0x4 == 0x0 (0x0) +__uchar 0x1 >> 0x4 == 0x0 (0x0) +__longlong 0x1 >> 0x4 == 0x0 (0x0) +__ulonglong 0x1 >> 0x4 == 0x0 (0x0) +int 0x1 + 0xfffe == -0x1 (0xffff) +__uint 0x1 + 0xfffe == -0x1 (0xffff) +char 0x1 + 0xfffe == -0x1 (0xffff) +__uchar 0x1 + 0xfe == 0xff (0xff) +__longlong 0x1 + 0xfffe == -0x1 (0xffff) +__ulonglong 0x1 + 0xfffe == -0x1 (0xffff) +float 0x1 + 0xfffe == -0x1 (0xffff) +int 0x1 - 0xfffe == 0x3 (0x3) +__uint 0x1 - 0xfffe == 0x3 (0x3) +char 0x1 - 0xfffe == 0x3 (0x3) +__uchar 0x1 - 0xfe == 0x3 (0x3) +__longlong 0x1 - 0xfffe == 0x3 (0x3) +__ulonglong 0x1 - 0xfffe == 0x3 (0x3) +float 0x1 - 0xfffe == 0x3 (0x3) +int 0x1 * 0xfffe == -0x2 (0xfffe) +__uint 0x1 * 0xfffe == -0x2 (0xfffe) +char 0x1 * 0xfffe == -0x2 (0xfffe) +__uchar 0x1 * 0xfe == 0xfe (0xfe) +__longlong 0x1 * 0xfffe == -0x2 (0xfffe) +__ulonglong 0x1 * 0xfffe == -0x2 (0xfffe) +float 0x1 * 0xfffe == -0x2 (0xfffe) +int 0x1 < 0xfffe == 0x0 (0x0) +__uint 0x1 < 0xfffe == 0x1 (0x1) +char 0x1 < 0xfffe == 0x0 (0x0) +__uchar 0x1 < 0xfe == 0x1 (0x1) +__longlong 0x1 < 0xfffe == 0x0 (0x0) +__ulonglong 0x1 < 0xfffe == 0x1 (0x1) +float 0x1 < 0xfffe == 0x0 (0x0) +int 0x1 > 0xfffe == 0x1 (0x1) +__uint 0x1 > 0xfffe == 0x0 (0x0) +char 0x1 > 0xfffe == 0x1 (0x1) +__uchar 0x1 > 0xfe == 0x0 (0x0) +__longlong 0x1 > 0xfffe == 0x1 (0x1) +__ulonglong 0x1 > 0xfffe == 0x0 (0x0) +float 0x1 > 0xfffe == 0x1 (0x1) +int 0x1 <= 0xfffe == 0x0 (0x0) +__uint 0x1 <= 0xfffe == 0x1 (0x1) +char 0x1 <= 0xfffe == 0x0 (0x0) +__uchar 0x1 <= 0xfe == 0x1 (0x1) +__longlong 0x1 <= 0xfffe == 0x0 (0x0) +__ulonglong 0x1 <= 0xfffe == 0x1 (0x1) +float 0x1 <= 0xfffe == 0x0 (0x0) +int 0x1 == 0xfffe == 0x0 (0x0) +__uint 0x1 == 0xfffe == 0x0 (0x0) +char 0x1 == 0xfffe == 0x0 (0x0) +__uchar 0x1 == 0xfe == 0x0 (0x0) +__longlong 0x1 == 0xfffe == 0x0 (0x0) +__ulonglong 0x1 == 0xfffe == 0x0 (0x0) +float 0x1 == 0xfffe == 0x0 (0x0) +int 0x1 != 0xfffe == 0x1 (0x1) +__uint 0x1 != 0xfffe == 0x1 (0x1) +char 0x1 != 0xfffe == 0x1 (0x1) +__uchar 0x1 != 0xfe == 0x1 (0x1) +__longlong 0x1 != 0xfffe == 0x1 (0x1) +__ulonglong 0x1 != 0xfffe == 0x1 (0x1) +float 0x1 != 0xfffe == 0x1 (0x1) +int 0x1 >= 0xfffe == 0x1 (0x1) +__uint 0x1 >= 0xfffe == 0x0 (0x0) +char 0x1 >= 0xfffe == 0x1 (0x1) +__uchar 0x1 >= 0xfe == 0x0 (0x0) +__longlong 0x1 >= 0xfffe == 0x1 (0x1) +__ulonglong 0x1 >= 0xfffe == 0x0 (0x0) +float 0x1 >= 0xfffe == 0x1 (0x1) +int 0x1 / 0xfffe == 0x0 (0x0) +__uint 0x1 / 0xfffe == 0x0 (0x0) +char 0x1 / 0xfffe == 0x0 (0x0) +__uchar 0x1 / 0xfe == 0x0 (0x0) +__longlong 0x1 / 0xfffe == 0x0 (0x0) +__ulonglong 0x1 / 0xfffe == 0x0 (0x0) +float 0x1 / 0xfffe == 0x0 (0x0) +int 0x1 % 0xfffe == 0x1 (0x1) +__uint 0x1 % 0xfffe == 0x1 (0x1) +char 0x1 % 0xfffe == 0x1 (0x1) +__uchar 0x1 % 0xfe == 0x1 (0x1) +__longlong 0x1 % 0xfffe == 0x1 (0x1) +__ulonglong 0x1 % 0xfffe == 0x1 (0x1) +0x1 * 0x4 == 0x4 +0x1 / 0x4 == 0x0 +0x1 % 0x4 == 0x1 +int 0x1 ^ 0x4 == 0x5 (0x5) +__uint 0x1 ^ 0x4 == 0x5 (0x5) +char 0x1 ^ 0x4 == 0x5 (0x5) +__uchar 0x1 ^ 0x4 == 0x5 (0x5) +__longlong 0x1 ^ 0x4 == 0x5 (0x5) +__ulonglong 0x1 ^ 0x4 == 0x5 (0x5) +int 0x1 && 0x4 == 0x1 (0x1) +__uint 0x1 && 0x4 == 0x1 (0x1) +char 0x1 && 0x4 == 0x1 (0x1) +__uchar 0x1 && 0x4 == 0x1 (0x1) +__longlong 0x1 && 0x4 == 0x1 (0x1) +__ulonglong 0x1 && 0x4 == 0x1 (0x1) +int 0x1 || 0x4 == 0x1 (0x1) +__uint 0x1 || 0x4 == 0x1 (0x1) +char 0x1 || 0x4 == 0x1 (0x1) +__uchar 0x1 || 0x4 == 0x1 (0x1) +__longlong 0x1 || 0x4 == 0x1 (0x1) +__ulonglong 0x1 || 0x4 == 0x1 (0x1) +int 0x1 & 0x4 == 0x0 (0x0) +__uint 0x1 & 0x4 == 0x0 (0x0) +char 0x1 & 0x4 == 0x0 (0x0) +__uchar 0x1 & 0x4 == 0x0 (0x0) +__longlong 0x1 & 0x4 == 0x0 (0x0) +__ulonglong 0x1 & 0x4 == 0x0 (0x0) +int 0x1 | 0x4 == 0x5 (0x5) +__uint 0x1 | 0x4 == 0x5 (0x5) +char 0x1 | 0x4 == 0x5 (0x5) +__uchar 0x1 | 0x4 == 0x5 (0x5) +__longlong 0x1 | 0x4 == 0x5 (0x5) +__ulonglong 0x1 | 0x4 == 0x5 (0x5) +int 0x1 << 0x5 == 0x20 (0x20) +__uint 0x1 << 0x5 == 0x20 (0x20) +char 0x1 << 0x5 == 0x20 (0x20) +__uchar 0x1 << 0x5 == 0x20 (0x20) +__longlong 0x1 << 0x5 == 0x20 (0x20) +__ulonglong 0x1 << 0x5 == 0x20 (0x20) +int 0x1 >> 0x5 == 0x0 (0x0) +__uint 0x1 >> 0x5 == 0x0 (0x0) +char 0x1 >> 0x5 == 0x0 (0x0) +__uchar 0x1 >> 0x5 == 0x0 (0x0) +__longlong 0x1 >> 0x5 == 0x0 (0x0) +__ulonglong 0x1 >> 0x5 == 0x0 (0x0) +int 0x1 + 0x4 == 0x5 (0x5) +__uint 0x1 + 0x4 == 0x5 (0x5) +char 0x1 + 0x4 == 0x5 (0x5) +__uchar 0x1 + 0x4 == 0x5 (0x5) +__longlong 0x1 + 0x4 == 0x5 (0x5) +__ulonglong 0x1 + 0x4 == 0x5 (0x5) +float 0x1 + 0x4 == 0x5 (0x5) +int 0x1 - 0x4 == -0x3 (0xfffd) +__uint 0x1 - 0x4 == -0x3 (0xfffd) +char 0x1 - 0x4 == -0x3 (0xfffd) +__uchar 0x1 - 0x4 == 0xfd (0xfd) +__longlong 0x1 - 0x4 == -0x3 (0xfffd) +__ulonglong 0x1 - 0x4 == -0x3 (0xfffd) +float 0x1 - 0x4 == -0x3 (0xfffd) +int 0x1 * 0x4 == 0x4 (0x4) +__uint 0x1 * 0x4 == 0x4 (0x4) +char 0x1 * 0x4 == 0x4 (0x4) +__uchar 0x1 * 0x4 == 0x4 (0x4) +__longlong 0x1 * 0x4 == 0x4 (0x4) +__ulonglong 0x1 * 0x4 == 0x4 (0x4) +float 0x1 * 0x4 == 0x4 (0x4) +int 0x1 < 0x4 == 0x1 (0x1) +__uint 0x1 < 0x4 == 0x1 (0x1) +char 0x1 < 0x4 == 0x1 (0x1) +__uchar 0x1 < 0x4 == 0x1 (0x1) +__longlong 0x1 < 0x4 == 0x1 (0x1) +__ulonglong 0x1 < 0x4 == 0x1 (0x1) +float 0x1 < 0x4 == 0x1 (0x1) +int 0x1 > 0x4 == 0x0 (0x0) +__uint 0x1 > 0x4 == 0x0 (0x0) +char 0x1 > 0x4 == 0x0 (0x0) +__uchar 0x1 > 0x4 == 0x0 (0x0) +__longlong 0x1 > 0x4 == 0x0 (0x0) +__ulonglong 0x1 > 0x4 == 0x0 (0x0) +float 0x1 > 0x4 == 0x0 (0x0) +int 0x1 <= 0x4 == 0x1 (0x1) +__uint 0x1 <= 0x4 == 0x1 (0x1) +char 0x1 <= 0x4 == 0x1 (0x1) +__uchar 0x1 <= 0x4 == 0x1 (0x1) +__longlong 0x1 <= 0x4 == 0x1 (0x1) +__ulonglong 0x1 <= 0x4 == 0x1 (0x1) +float 0x1 <= 0x4 == 0x1 (0x1) +int 0x1 == 0x4 == 0x0 (0x0) +__uint 0x1 == 0x4 == 0x0 (0x0) +char 0x1 == 0x4 == 0x0 (0x0) +__uchar 0x1 == 0x4 == 0x0 (0x0) +__longlong 0x1 == 0x4 == 0x0 (0x0) +__ulonglong 0x1 == 0x4 == 0x0 (0x0) +float 0x1 == 0x4 == 0x0 (0x0) +int 0x1 != 0x4 == 0x1 (0x1) +__uint 0x1 != 0x4 == 0x1 (0x1) +char 0x1 != 0x4 == 0x1 (0x1) +__uchar 0x1 != 0x4 == 0x1 (0x1) +__longlong 0x1 != 0x4 == 0x1 (0x1) +__ulonglong 0x1 != 0x4 == 0x1 (0x1) +float 0x1 != 0x4 == 0x1 (0x1) +int 0x1 >= 0x4 == 0x0 (0x0) +__uint 0x1 >= 0x4 == 0x0 (0x0) +char 0x1 >= 0x4 == 0x0 (0x0) +__uchar 0x1 >= 0x4 == 0x0 (0x0) +__longlong 0x1 >= 0x4 == 0x0 (0x0) +__ulonglong 0x1 >= 0x4 == 0x0 (0x0) +float 0x1 >= 0x4 == 0x0 (0x0) +int 0x1 / 0x4 == 0x0 (0x0) +__uint 0x1 / 0x4 == 0x0 (0x0) +char 0x1 / 0x4 == 0x0 (0x0) +__uchar 0x1 / 0x4 == 0x0 (0x0) +__longlong 0x1 / 0x4 == 0x0 (0x0) +__ulonglong 0x1 / 0x4 == 0x0 (0x0) +float 0x1 / 0x4 == 0x0 (0x0) +int 0x1 % 0x4 == 0x1 (0x1) +__uint 0x1 % 0x4 == 0x1 (0x1) +char 0x1 % 0x4 == 0x1 (0x1) +__uchar 0x1 % 0x4 == 0x1 (0x1) +__longlong 0x1 % 0x4 == 0x1 (0x1) +__ulonglong 0x1 % 0x4 == 0x1 (0x1) +0x1 * 0xfffc == -0x4 +0x1 / 0xfffc == 0x0 +0x1 % 0xfffc == 0x1 +int 0x1 ^ 0xfffc == -0x3 (0xfffd) +__uint 0x1 ^ 0xfffc == -0x3 (0xfffd) +char 0x1 ^ 0xfffc == -0x3 (0xfffd) +__uchar 0x1 ^ 0xfc == 0xfd (0xfd) +__longlong 0x1 ^ 0xfffc == -0x3 (0xfffd) +__ulonglong 0x1 ^ 0xfffc == -0x3 (0xfffd) +int 0x1 && 0xfffc == 0x1 (0x1) +__uint 0x1 && 0xfffc == 0x1 (0x1) +char 0x1 && 0xfffc == 0x1 (0x1) +__uchar 0x1 && 0xfc == 0x1 (0x1) +__longlong 0x1 && 0xfffc == 0x1 (0x1) +__ulonglong 0x1 && 0xfffc == 0x1 (0x1) +int 0x1 || 0xfffc == 0x1 (0x1) +__uint 0x1 || 0xfffc == 0x1 (0x1) +char 0x1 || 0xfffc == 0x1 (0x1) +__uchar 0x1 || 0xfc == 0x1 (0x1) +__longlong 0x1 || 0xfffc == 0x1 (0x1) +__ulonglong 0x1 || 0xfffc == 0x1 (0x1) +int 0x1 & 0xfffc == 0x0 (0x0) +__uint 0x1 & 0xfffc == 0x0 (0x0) +char 0x1 & 0xfffc == 0x0 (0x0) +__uchar 0x1 & 0xfc == 0x0 (0x0) +__longlong 0x1 & 0xfffc == 0x0 (0x0) +__ulonglong 0x1 & 0xfffc == 0x0 (0x0) +int 0x1 | 0xfffc == -0x3 (0xfffd) +__uint 0x1 | 0xfffc == -0x3 (0xfffd) +char 0x1 | 0xfffc == -0x3 (0xfffd) +__uchar 0x1 | 0xfc == 0xfd (0xfd) +__longlong 0x1 | 0xfffc == -0x3 (0xfffd) +__ulonglong 0x1 | 0xfffc == -0x3 (0xfffd) +int 0x1 << 0x6 == 0x40 (0x40) +__uint 0x1 << 0x6 == 0x40 (0x40) +char 0x1 << 0x6 == 0x40 (0x40) +__uchar 0x1 << 0x6 == 0x40 (0x40) +__longlong 0x1 << 0x6 == 0x40 (0x40) +__ulonglong 0x1 << 0x6 == 0x40 (0x40) +int 0x1 >> 0x6 == 0x0 (0x0) +__uint 0x1 >> 0x6 == 0x0 (0x0) +char 0x1 >> 0x6 == 0x0 (0x0) +__uchar 0x1 >> 0x6 == 0x0 (0x0) +__longlong 0x1 >> 0x6 == 0x0 (0x0) +__ulonglong 0x1 >> 0x6 == 0x0 (0x0) +int 0x1 + 0xfffc == -0x3 (0xfffd) +__uint 0x1 + 0xfffc == -0x3 (0xfffd) +char 0x1 + 0xfffc == -0x3 (0xfffd) +__uchar 0x1 + 0xfc == 0xfd (0xfd) +__longlong 0x1 + 0xfffc == -0x3 (0xfffd) +__ulonglong 0x1 + 0xfffc == -0x3 (0xfffd) +float 0x1 + 0xfffc == -0x3 (0xfffd) +int 0x1 - 0xfffc == 0x5 (0x5) +__uint 0x1 - 0xfffc == 0x5 (0x5) +char 0x1 - 0xfffc == 0x5 (0x5) +__uchar 0x1 - 0xfc == 0x5 (0x5) +__longlong 0x1 - 0xfffc == 0x5 (0x5) +__ulonglong 0x1 - 0xfffc == 0x5 (0x5) +float 0x1 - 0xfffc == 0x5 (0x5) +int 0x1 * 0xfffc == -0x4 (0xfffc) +__uint 0x1 * 0xfffc == -0x4 (0xfffc) +char 0x1 * 0xfffc == -0x4 (0xfffc) +__uchar 0x1 * 0xfc == 0xfc (0xfc) +__longlong 0x1 * 0xfffc == -0x4 (0xfffc) +__ulonglong 0x1 * 0xfffc == -0x4 (0xfffc) +float 0x1 * 0xfffc == -0x4 (0xfffc) +int 0x1 < 0xfffc == 0x0 (0x0) +__uint 0x1 < 0xfffc == 0x1 (0x1) +char 0x1 < 0xfffc == 0x0 (0x0) +__uchar 0x1 < 0xfc == 0x1 (0x1) +__longlong 0x1 < 0xfffc == 0x0 (0x0) +__ulonglong 0x1 < 0xfffc == 0x1 (0x1) +float 0x1 < 0xfffc == 0x0 (0x0) +int 0x1 > 0xfffc == 0x1 (0x1) +__uint 0x1 > 0xfffc == 0x0 (0x0) +char 0x1 > 0xfffc == 0x1 (0x1) +__uchar 0x1 > 0xfc == 0x0 (0x0) +__longlong 0x1 > 0xfffc == 0x1 (0x1) +__ulonglong 0x1 > 0xfffc == 0x0 (0x0) +float 0x1 > 0xfffc == 0x1 (0x1) +int 0x1 <= 0xfffc == 0x0 (0x0) +__uint 0x1 <= 0xfffc == 0x1 (0x1) +char 0x1 <= 0xfffc == 0x0 (0x0) +__uchar 0x1 <= 0xfc == 0x1 (0x1) +__longlong 0x1 <= 0xfffc == 0x0 (0x0) +__ulonglong 0x1 <= 0xfffc == 0x1 (0x1) +float 0x1 <= 0xfffc == 0x0 (0x0) +int 0x1 == 0xfffc == 0x0 (0x0) +__uint 0x1 == 0xfffc == 0x0 (0x0) +char 0x1 == 0xfffc == 0x0 (0x0) +__uchar 0x1 == 0xfc == 0x0 (0x0) +__longlong 0x1 == 0xfffc == 0x0 (0x0) +__ulonglong 0x1 == 0xfffc == 0x0 (0x0) +float 0x1 == 0xfffc == 0x0 (0x0) +int 0x1 != 0xfffc == 0x1 (0x1) +__uint 0x1 != 0xfffc == 0x1 (0x1) +char 0x1 != 0xfffc == 0x1 (0x1) +__uchar 0x1 != 0xfc == 0x1 (0x1) +__longlong 0x1 != 0xfffc == 0x1 (0x1) +__ulonglong 0x1 != 0xfffc == 0x1 (0x1) +float 0x1 != 0xfffc == 0x1 (0x1) +int 0x1 >= 0xfffc == 0x1 (0x1) +__uint 0x1 >= 0xfffc == 0x0 (0x0) +char 0x1 >= 0xfffc == 0x1 (0x1) +__uchar 0x1 >= 0xfc == 0x0 (0x0) +__longlong 0x1 >= 0xfffc == 0x1 (0x1) +__ulonglong 0x1 >= 0xfffc == 0x0 (0x0) +float 0x1 >= 0xfffc == 0x1 (0x1) +int 0x1 / 0xfffc == 0x0 (0x0) +__uint 0x1 / 0xfffc == 0x0 (0x0) +char 0x1 / 0xfffc == 0x0 (0x0) +__uchar 0x1 / 0xfc == 0x0 (0x0) +__longlong 0x1 / 0xfffc == 0x0 (0x0) +__ulonglong 0x1 / 0xfffc == 0x0 (0x0) +float 0x1 / 0xfffc == 0x0 (0x0) +int 0x1 % 0xfffc == 0x1 (0x1) +__uint 0x1 % 0xfffc == 0x1 (0x1) +char 0x1 % 0xfffc == 0x1 (0x1) +__uchar 0x1 % 0xfc == 0x1 (0x1) +__longlong 0x1 % 0xfffc == 0x1 (0x1) +__ulonglong 0x1 % 0xfffc == 0x1 (0x1) +0x1 * 0xa == 0xa +0x1 / 0xa == 0x0 +0x1 % 0xa == 0x1 +int 0x1 ^ 0xa == 0xb (0xb) +__uint 0x1 ^ 0xa == 0xb (0xb) +char 0x1 ^ 0xa == 0xb (0xb) +__uchar 0x1 ^ 0xa == 0xb (0xb) +__longlong 0x1 ^ 0xa == 0xb (0xb) +__ulonglong 0x1 ^ 0xa == 0xb (0xb) +int 0x1 && 0xa == 0x1 (0x1) +__uint 0x1 && 0xa == 0x1 (0x1) +char 0x1 && 0xa == 0x1 (0x1) +__uchar 0x1 && 0xa == 0x1 (0x1) +__longlong 0x1 && 0xa == 0x1 (0x1) +__ulonglong 0x1 && 0xa == 0x1 (0x1) +int 0x1 || 0xa == 0x1 (0x1) +__uint 0x1 || 0xa == 0x1 (0x1) +char 0x1 || 0xa == 0x1 (0x1) +__uchar 0x1 || 0xa == 0x1 (0x1) +__longlong 0x1 || 0xa == 0x1 (0x1) +__ulonglong 0x1 || 0xa == 0x1 (0x1) +int 0x1 & 0xa == 0x0 (0x0) +__uint 0x1 & 0xa == 0x0 (0x0) +char 0x1 & 0xa == 0x0 (0x0) +__uchar 0x1 & 0xa == 0x0 (0x0) +__longlong 0x1 & 0xa == 0x0 (0x0) +__ulonglong 0x1 & 0xa == 0x0 (0x0) +int 0x1 | 0xa == 0xb (0xb) +__uint 0x1 | 0xa == 0xb (0xb) +char 0x1 | 0xa == 0xb (0xb) +__uchar 0x1 | 0xa == 0xb (0xb) +__longlong 0x1 | 0xa == 0xb (0xb) +__ulonglong 0x1 | 0xa == 0xb (0xb) +int 0x1 << 0x7 == 0x80 (0x80) +__uint 0x1 << 0x7 == 0x80 (0x80) +char 0x1 << 0x7 == -0x80 (0xff80) +__uchar 0x1 << 0x7 == 0x80 (0x80) +__longlong 0x1 << 0x7 == 0x80 (0x80) +__ulonglong 0x1 << 0x7 == 0x80 (0x80) +int 0x1 >> 0x7 == 0x0 (0x0) +__uint 0x1 >> 0x7 == 0x0 (0x0) +char 0x1 >> 0x7 == 0x0 (0x0) +__uchar 0x1 >> 0x7 == 0x0 (0x0) +__longlong 0x1 >> 0x7 == 0x0 (0x0) +__ulonglong 0x1 >> 0x7 == 0x0 (0x0) +int 0x1 + 0xa == 0xb (0xb) +__uint 0x1 + 0xa == 0xb (0xb) +char 0x1 + 0xa == 0xb (0xb) +__uchar 0x1 + 0xa == 0xb (0xb) +__longlong 0x1 + 0xa == 0xb (0xb) +__ulonglong 0x1 + 0xa == 0xb (0xb) +float 0x1 + 0xa == 0xb (0xb) +int 0x1 - 0xa == -0x9 (0xfff7) +__uint 0x1 - 0xa == -0x9 (0xfff7) +char 0x1 - 0xa == -0x9 (0xfff7) +__uchar 0x1 - 0xa == 0xf7 (0xf7) +__longlong 0x1 - 0xa == -0x9 (0xfff7) +__ulonglong 0x1 - 0xa == -0x9 (0xfff7) +float 0x1 - 0xa == -0x9 (0xfff7) +int 0x1 * 0xa == 0xa (0xa) +__uint 0x1 * 0xa == 0xa (0xa) +char 0x1 * 0xa == 0xa (0xa) +__uchar 0x1 * 0xa == 0xa (0xa) +__longlong 0x1 * 0xa == 0xa (0xa) +__ulonglong 0x1 * 0xa == 0xa (0xa) +float 0x1 * 0xa == 0xa (0xa) +int 0x1 < 0xa == 0x1 (0x1) +__uint 0x1 < 0xa == 0x1 (0x1) +char 0x1 < 0xa == 0x1 (0x1) +__uchar 0x1 < 0xa == 0x1 (0x1) +__longlong 0x1 < 0xa == 0x1 (0x1) +__ulonglong 0x1 < 0xa == 0x1 (0x1) +float 0x1 < 0xa == 0x1 (0x1) +int 0x1 > 0xa == 0x0 (0x0) +__uint 0x1 > 0xa == 0x0 (0x0) +char 0x1 > 0xa == 0x0 (0x0) +__uchar 0x1 > 0xa == 0x0 (0x0) +__longlong 0x1 > 0xa == 0x0 (0x0) +__ulonglong 0x1 > 0xa == 0x0 (0x0) +float 0x1 > 0xa == 0x0 (0x0) +int 0x1 <= 0xa == 0x1 (0x1) +__uint 0x1 <= 0xa == 0x1 (0x1) +char 0x1 <= 0xa == 0x1 (0x1) +__uchar 0x1 <= 0xa == 0x1 (0x1) +__longlong 0x1 <= 0xa == 0x1 (0x1) +__ulonglong 0x1 <= 0xa == 0x1 (0x1) +float 0x1 <= 0xa == 0x1 (0x1) +int 0x1 == 0xa == 0x0 (0x0) +__uint 0x1 == 0xa == 0x0 (0x0) +char 0x1 == 0xa == 0x0 (0x0) +__uchar 0x1 == 0xa == 0x0 (0x0) +__longlong 0x1 == 0xa == 0x0 (0x0) +__ulonglong 0x1 == 0xa == 0x0 (0x0) +float 0x1 == 0xa == 0x0 (0x0) +int 0x1 != 0xa == 0x1 (0x1) +__uint 0x1 != 0xa == 0x1 (0x1) +char 0x1 != 0xa == 0x1 (0x1) +__uchar 0x1 != 0xa == 0x1 (0x1) +__longlong 0x1 != 0xa == 0x1 (0x1) +__ulonglong 0x1 != 0xa == 0x1 (0x1) +float 0x1 != 0xa == 0x1 (0x1) +int 0x1 >= 0xa == 0x0 (0x0) +__uint 0x1 >= 0xa == 0x0 (0x0) +char 0x1 >= 0xa == 0x0 (0x0) +__uchar 0x1 >= 0xa == 0x0 (0x0) +__longlong 0x1 >= 0xa == 0x0 (0x0) +__ulonglong 0x1 >= 0xa == 0x0 (0x0) +float 0x1 >= 0xa == 0x0 (0x0) +int 0x1 / 0xa == 0x0 (0x0) +__uint 0x1 / 0xa == 0x0 (0x0) +char 0x1 / 0xa == 0x0 (0x0) +__uchar 0x1 / 0xa == 0x0 (0x0) +__longlong 0x1 / 0xa == 0x0 (0x0) +__ulonglong 0x1 / 0xa == 0x0 (0x0) +float 0x1 / 0xa == 0x0 (0x0) +int 0x1 % 0xa == 0x1 (0x1) +__uint 0x1 % 0xa == 0x1 (0x1) +char 0x1 % 0xa == 0x1 (0x1) +__uchar 0x1 % 0xa == 0x1 (0x1) +__longlong 0x1 % 0xa == 0x1 (0x1) +__ulonglong 0x1 % 0xa == 0x1 (0x1) +0x1 * 0xfff6 == -0xa +0x1 / 0xfff6 == 0x0 +0x1 % 0xfff6 == 0x1 +int 0x1 ^ 0xfff6 == -0x9 (0xfff7) +__uint 0x1 ^ 0xfff6 == -0x9 (0xfff7) +char 0x1 ^ 0xfff6 == -0x9 (0xfff7) +__uchar 0x1 ^ 0xf6 == 0xf7 (0xf7) +__longlong 0x1 ^ 0xfff6 == -0x9 (0xfff7) +__ulonglong 0x1 ^ 0xfff6 == -0x9 (0xfff7) +int 0x1 && 0xfff6 == 0x1 (0x1) +__uint 0x1 && 0xfff6 == 0x1 (0x1) +char 0x1 && 0xfff6 == 0x1 (0x1) +__uchar 0x1 && 0xf6 == 0x1 (0x1) +__longlong 0x1 && 0xfff6 == 0x1 (0x1) +__ulonglong 0x1 && 0xfff6 == 0x1 (0x1) +int 0x1 || 0xfff6 == 0x1 (0x1) +__uint 0x1 || 0xfff6 == 0x1 (0x1) +char 0x1 || 0xfff6 == 0x1 (0x1) +__uchar 0x1 || 0xf6 == 0x1 (0x1) +__longlong 0x1 || 0xfff6 == 0x1 (0x1) +__ulonglong 0x1 || 0xfff6 == 0x1 (0x1) +int 0x1 & 0xfff6 == 0x0 (0x0) +__uint 0x1 & 0xfff6 == 0x0 (0x0) +char 0x1 & 0xfff6 == 0x0 (0x0) +__uchar 0x1 & 0xf6 == 0x0 (0x0) +__longlong 0x1 & 0xfff6 == 0x0 (0x0) +__ulonglong 0x1 & 0xfff6 == 0x0 (0x0) +int 0x1 | 0xfff6 == -0x9 (0xfff7) +__uint 0x1 | 0xfff6 == -0x9 (0xfff7) +char 0x1 | 0xfff6 == -0x9 (0xfff7) +__uchar 0x1 | 0xf6 == 0xf7 (0xf7) +__longlong 0x1 | 0xfff6 == -0x9 (0xfff7) +__ulonglong 0x1 | 0xfff6 == -0x9 (0xfff7) +int 0x1 << 0x8 == 0x100 (0x100) +__uint 0x1 << 0x8 == 0x100 (0x100) +char 0x1 << 0x8 == 0x0 (0x0) +__uchar 0x1 << 0x8 == 0x0 (0x0) +__longlong 0x1 << 0x8 == 0x100 (0x100) +__ulonglong 0x1 << 0x8 == 0x100 (0x100) +int 0x1 >> 0x8 == 0x0 (0x0) +__uint 0x1 >> 0x8 == 0x0 (0x0) +char 0x1 >> 0x8 == 0x0 (0x0) +__uchar 0x1 >> 0x8 == 0x0 (0x0) +__longlong 0x1 >> 0x8 == 0x0 (0x0) +__ulonglong 0x1 >> 0x8 == 0x0 (0x0) +int 0x1 + 0xfff6 == -0x9 (0xfff7) +__uint 0x1 + 0xfff6 == -0x9 (0xfff7) +char 0x1 + 0xfff6 == -0x9 (0xfff7) +__uchar 0x1 + 0xf6 == 0xf7 (0xf7) +__longlong 0x1 + 0xfff6 == -0x9 (0xfff7) +__ulonglong 0x1 + 0xfff6 == -0x9 (0xfff7) +float 0x1 + 0xfff6 == -0x9 (0xfff7) +int 0x1 - 0xfff6 == 0xb (0xb) +__uint 0x1 - 0xfff6 == 0xb (0xb) +char 0x1 - 0xfff6 == 0xb (0xb) +__uchar 0x1 - 0xf6 == 0xb (0xb) +__longlong 0x1 - 0xfff6 == 0xb (0xb) +__ulonglong 0x1 - 0xfff6 == 0xb (0xb) +float 0x1 - 0xfff6 == 0xb (0xb) +int 0x1 * 0xfff6 == -0xa (0xfff6) +__uint 0x1 * 0xfff6 == -0xa (0xfff6) +char 0x1 * 0xfff6 == -0xa (0xfff6) +__uchar 0x1 * 0xf6 == 0xf6 (0xf6) +__longlong 0x1 * 0xfff6 == -0xa (0xfff6) +__ulonglong 0x1 * 0xfff6 == -0xa (0xfff6) +float 0x1 * 0xfff6 == -0xa (0xfff6) +int 0x1 < 0xfff6 == 0x0 (0x0) +__uint 0x1 < 0xfff6 == 0x1 (0x1) +char 0x1 < 0xfff6 == 0x0 (0x0) +__uchar 0x1 < 0xf6 == 0x1 (0x1) +__longlong 0x1 < 0xfff6 == 0x0 (0x0) +__ulonglong 0x1 < 0xfff6 == 0x1 (0x1) +float 0x1 < 0xfff6 == 0x0 (0x0) +int 0x1 > 0xfff6 == 0x1 (0x1) +__uint 0x1 > 0xfff6 == 0x0 (0x0) +char 0x1 > 0xfff6 == 0x1 (0x1) +__uchar 0x1 > 0xf6 == 0x0 (0x0) +__longlong 0x1 > 0xfff6 == 0x1 (0x1) +__ulonglong 0x1 > 0xfff6 == 0x0 (0x0) +float 0x1 > 0xfff6 == 0x1 (0x1) +int 0x1 <= 0xfff6 == 0x0 (0x0) +__uint 0x1 <= 0xfff6 == 0x1 (0x1) +char 0x1 <= 0xfff6 == 0x0 (0x0) +__uchar 0x1 <= 0xf6 == 0x1 (0x1) +__longlong 0x1 <= 0xfff6 == 0x0 (0x0) +__ulonglong 0x1 <= 0xfff6 == 0x1 (0x1) +float 0x1 <= 0xfff6 == 0x0 (0x0) +int 0x1 == 0xfff6 == 0x0 (0x0) +__uint 0x1 == 0xfff6 == 0x0 (0x0) +char 0x1 == 0xfff6 == 0x0 (0x0) +__uchar 0x1 == 0xf6 == 0x0 (0x0) +__longlong 0x1 == 0xfff6 == 0x0 (0x0) +__ulonglong 0x1 == 0xfff6 == 0x0 (0x0) +float 0x1 == 0xfff6 == 0x0 (0x0) +int 0x1 != 0xfff6 == 0x1 (0x1) +__uint 0x1 != 0xfff6 == 0x1 (0x1) +char 0x1 != 0xfff6 == 0x1 (0x1) +__uchar 0x1 != 0xf6 == 0x1 (0x1) +__longlong 0x1 != 0xfff6 == 0x1 (0x1) +__ulonglong 0x1 != 0xfff6 == 0x1 (0x1) +float 0x1 != 0xfff6 == 0x1 (0x1) +int 0x1 >= 0xfff6 == 0x1 (0x1) +__uint 0x1 >= 0xfff6 == 0x0 (0x0) +char 0x1 >= 0xfff6 == 0x1 (0x1) +__uchar 0x1 >= 0xf6 == 0x0 (0x0) +__longlong 0x1 >= 0xfff6 == 0x1 (0x1) +__ulonglong 0x1 >= 0xfff6 == 0x0 (0x0) +float 0x1 >= 0xfff6 == 0x1 (0x1) +int 0x1 / 0xfff6 == 0x0 (0x0) +__uint 0x1 / 0xfff6 == 0x0 (0x0) +char 0x1 / 0xfff6 == 0x0 (0x0) +__uchar 0x1 / 0xf6 == 0x0 (0x0) +__longlong 0x1 / 0xfff6 == 0x0 (0x0) +__ulonglong 0x1 / 0xfff6 == 0x0 (0x0) +float 0x1 / 0xfff6 == 0x0 (0x0) +int 0x1 % 0xfff6 == 0x1 (0x1) +__uint 0x1 % 0xfff6 == 0x1 (0x1) +char 0x1 % 0xfff6 == 0x1 (0x1) +__uchar 0x1 % 0xf6 == 0x1 (0x1) +__longlong 0x1 % 0xfff6 == 0x1 (0x1) +__ulonglong 0x1 % 0xfff6 == 0x1 (0x1) +0x1 * 0x5 == 0x5 +0x1 / 0x5 == 0x0 +0x1 % 0x5 == 0x1 +int 0x1 ^ 0x5 == 0x4 (0x4) +__uint 0x1 ^ 0x5 == 0x4 (0x4) +char 0x1 ^ 0x5 == 0x4 (0x4) +__uchar 0x1 ^ 0x5 == 0x4 (0x4) +__longlong 0x1 ^ 0x5 == 0x4 (0x4) +__ulonglong 0x1 ^ 0x5 == 0x4 (0x4) +int 0x1 && 0x5 == 0x1 (0x1) +__uint 0x1 && 0x5 == 0x1 (0x1) +char 0x1 && 0x5 == 0x1 (0x1) +__uchar 0x1 && 0x5 == 0x1 (0x1) +__longlong 0x1 && 0x5 == 0x1 (0x1) +__ulonglong 0x1 && 0x5 == 0x1 (0x1) +int 0x1 || 0x5 == 0x1 (0x1) +__uint 0x1 || 0x5 == 0x1 (0x1) +char 0x1 || 0x5 == 0x1 (0x1) +__uchar 0x1 || 0x5 == 0x1 (0x1) +__longlong 0x1 || 0x5 == 0x1 (0x1) +__ulonglong 0x1 || 0x5 == 0x1 (0x1) +int 0x1 & 0x5 == 0x1 (0x1) +__uint 0x1 & 0x5 == 0x1 (0x1) +char 0x1 & 0x5 == 0x1 (0x1) +__uchar 0x1 & 0x5 == 0x1 (0x1) +__longlong 0x1 & 0x5 == 0x1 (0x1) +__ulonglong 0x1 & 0x5 == 0x1 (0x1) +int 0x1 | 0x5 == 0x5 (0x5) +__uint 0x1 | 0x5 == 0x5 (0x5) +char 0x1 | 0x5 == 0x5 (0x5) +__uchar 0x1 | 0x5 == 0x5 (0x5) +__longlong 0x1 | 0x5 == 0x5 (0x5) +__ulonglong 0x1 | 0x5 == 0x5 (0x5) +int 0x1 << 0x9 == 0x200 (0x200) +__uint 0x1 << 0x9 == 0x200 (0x200) +char 0x1 << 0x9 == 0x0 (0x0) +__uchar 0x1 << 0x9 == 0x0 (0x0) +__longlong 0x1 << 0x9 == 0x200 (0x200) +__ulonglong 0x1 << 0x9 == 0x200 (0x200) +int 0x1 >> 0x9 == 0x0 (0x0) +__uint 0x1 >> 0x9 == 0x0 (0x0) +char 0x1 >> 0x9 == 0x0 (0x0) +__uchar 0x1 >> 0x9 == 0x0 (0x0) +__longlong 0x1 >> 0x9 == 0x0 (0x0) +__ulonglong 0x1 >> 0x9 == 0x0 (0x0) +int 0x1 + 0x5 == 0x6 (0x6) +__uint 0x1 + 0x5 == 0x6 (0x6) +char 0x1 + 0x5 == 0x6 (0x6) +__uchar 0x1 + 0x5 == 0x6 (0x6) +__longlong 0x1 + 0x5 == 0x6 (0x6) +__ulonglong 0x1 + 0x5 == 0x6 (0x6) +float 0x1 + 0x5 == 0x6 (0x6) +int 0x1 - 0x5 == -0x4 (0xfffc) +__uint 0x1 - 0x5 == -0x4 (0xfffc) +char 0x1 - 0x5 == -0x4 (0xfffc) +__uchar 0x1 - 0x5 == 0xfc (0xfc) +__longlong 0x1 - 0x5 == -0x4 (0xfffc) +__ulonglong 0x1 - 0x5 == -0x4 (0xfffc) +float 0x1 - 0x5 == -0x4 (0xfffc) +int 0x1 * 0x5 == 0x5 (0x5) +__uint 0x1 * 0x5 == 0x5 (0x5) +char 0x1 * 0x5 == 0x5 (0x5) +__uchar 0x1 * 0x5 == 0x5 (0x5) +__longlong 0x1 * 0x5 == 0x5 (0x5) +__ulonglong 0x1 * 0x5 == 0x5 (0x5) +float 0x1 * 0x5 == 0x5 (0x5) +int 0x1 < 0x5 == 0x1 (0x1) +__uint 0x1 < 0x5 == 0x1 (0x1) +char 0x1 < 0x5 == 0x1 (0x1) +__uchar 0x1 < 0x5 == 0x1 (0x1) +__longlong 0x1 < 0x5 == 0x1 (0x1) +__ulonglong 0x1 < 0x5 == 0x1 (0x1) +float 0x1 < 0x5 == 0x1 (0x1) +int 0x1 > 0x5 == 0x0 (0x0) +__uint 0x1 > 0x5 == 0x0 (0x0) +char 0x1 > 0x5 == 0x0 (0x0) +__uchar 0x1 > 0x5 == 0x0 (0x0) +__longlong 0x1 > 0x5 == 0x0 (0x0) +__ulonglong 0x1 > 0x5 == 0x0 (0x0) +float 0x1 > 0x5 == 0x0 (0x0) +int 0x1 <= 0x5 == 0x1 (0x1) +__uint 0x1 <= 0x5 == 0x1 (0x1) +char 0x1 <= 0x5 == 0x1 (0x1) +__uchar 0x1 <= 0x5 == 0x1 (0x1) +__longlong 0x1 <= 0x5 == 0x1 (0x1) +__ulonglong 0x1 <= 0x5 == 0x1 (0x1) +float 0x1 <= 0x5 == 0x1 (0x1) +int 0x1 == 0x5 == 0x0 (0x0) +__uint 0x1 == 0x5 == 0x0 (0x0) +char 0x1 == 0x5 == 0x0 (0x0) +__uchar 0x1 == 0x5 == 0x0 (0x0) +__longlong 0x1 == 0x5 == 0x0 (0x0) +__ulonglong 0x1 == 0x5 == 0x0 (0x0) +float 0x1 == 0x5 == 0x0 (0x0) +int 0x1 != 0x5 == 0x1 (0x1) +__uint 0x1 != 0x5 == 0x1 (0x1) +char 0x1 != 0x5 == 0x1 (0x1) +__uchar 0x1 != 0x5 == 0x1 (0x1) +__longlong 0x1 != 0x5 == 0x1 (0x1) +__ulonglong 0x1 != 0x5 == 0x1 (0x1) +float 0x1 != 0x5 == 0x1 (0x1) +int 0x1 >= 0x5 == 0x0 (0x0) +__uint 0x1 >= 0x5 == 0x0 (0x0) +char 0x1 >= 0x5 == 0x0 (0x0) +__uchar 0x1 >= 0x5 == 0x0 (0x0) +__longlong 0x1 >= 0x5 == 0x0 (0x0) +__ulonglong 0x1 >= 0x5 == 0x0 (0x0) +float 0x1 >= 0x5 == 0x0 (0x0) +int 0x1 / 0x5 == 0x0 (0x0) +__uint 0x1 / 0x5 == 0x0 (0x0) +char 0x1 / 0x5 == 0x0 (0x0) +__uchar 0x1 / 0x5 == 0x0 (0x0) +__longlong 0x1 / 0x5 == 0x0 (0x0) +__ulonglong 0x1 / 0x5 == 0x0 (0x0) +float 0x1 / 0x5 == 0x0 (0x0) +int 0x1 % 0x5 == 0x1 (0x1) +__uint 0x1 % 0x5 == 0x1 (0x1) +char 0x1 % 0x5 == 0x1 (0x1) +__uchar 0x1 % 0x5 == 0x1 (0x1) +__longlong 0x1 % 0x5 == 0x1 (0x1) +__ulonglong 0x1 % 0x5 == 0x1 (0x1) +0x1 * 0x7 == 0x7 +0x1 / 0x7 == 0x0 +0x1 % 0x7 == 0x1 +int 0x1 ^ 0x7 == 0x6 (0x6) +__uint 0x1 ^ 0x7 == 0x6 (0x6) +char 0x1 ^ 0x7 == 0x6 (0x6) +__uchar 0x1 ^ 0x7 == 0x6 (0x6) +__longlong 0x1 ^ 0x7 == 0x6 (0x6) +__ulonglong 0x1 ^ 0x7 == 0x6 (0x6) +int 0x1 && 0x7 == 0x1 (0x1) +__uint 0x1 && 0x7 == 0x1 (0x1) +char 0x1 && 0x7 == 0x1 (0x1) +__uchar 0x1 && 0x7 == 0x1 (0x1) +__longlong 0x1 && 0x7 == 0x1 (0x1) +__ulonglong 0x1 && 0x7 == 0x1 (0x1) +int 0x1 || 0x7 == 0x1 (0x1) +__uint 0x1 || 0x7 == 0x1 (0x1) +char 0x1 || 0x7 == 0x1 (0x1) +__uchar 0x1 || 0x7 == 0x1 (0x1) +__longlong 0x1 || 0x7 == 0x1 (0x1) +__ulonglong 0x1 || 0x7 == 0x1 (0x1) +int 0x1 & 0x7 == 0x1 (0x1) +__uint 0x1 & 0x7 == 0x1 (0x1) +char 0x1 & 0x7 == 0x1 (0x1) +__uchar 0x1 & 0x7 == 0x1 (0x1) +__longlong 0x1 & 0x7 == 0x1 (0x1) +__ulonglong 0x1 & 0x7 == 0x1 (0x1) +int 0x1 | 0x7 == 0x7 (0x7) +__uint 0x1 | 0x7 == 0x7 (0x7) +char 0x1 | 0x7 == 0x7 (0x7) +__uchar 0x1 | 0x7 == 0x7 (0x7) +__longlong 0x1 | 0x7 == 0x7 (0x7) +__ulonglong 0x1 | 0x7 == 0x7 (0x7) +int 0x1 << 0xa == 0x400 (0x400) +__uint 0x1 << 0xa == 0x400 (0x400) +char 0x1 << 0xa == 0x0 (0x0) +__uchar 0x1 << 0xa == 0x0 (0x0) +__longlong 0x1 << 0xa == 0x400 (0x400) +__ulonglong 0x1 << 0xa == 0x400 (0x400) +int 0x1 >> 0xa == 0x0 (0x0) +__uint 0x1 >> 0xa == 0x0 (0x0) +char 0x1 >> 0xa == 0x0 (0x0) +__uchar 0x1 >> 0xa == 0x0 (0x0) +__longlong 0x1 >> 0xa == 0x0 (0x0) +__ulonglong 0x1 >> 0xa == 0x0 (0x0) +int 0x1 + 0x7 == 0x8 (0x8) +__uint 0x1 + 0x7 == 0x8 (0x8) +char 0x1 + 0x7 == 0x8 (0x8) +__uchar 0x1 + 0x7 == 0x8 (0x8) +__longlong 0x1 + 0x7 == 0x8 (0x8) +__ulonglong 0x1 + 0x7 == 0x8 (0x8) +float 0x1 + 0x7 == 0x8 (0x8) +int 0x1 - 0x7 == -0x6 (0xfffa) +__uint 0x1 - 0x7 == -0x6 (0xfffa) +char 0x1 - 0x7 == -0x6 (0xfffa) +__uchar 0x1 - 0x7 == 0xfa (0xfa) +__longlong 0x1 - 0x7 == -0x6 (0xfffa) +__ulonglong 0x1 - 0x7 == -0x6 (0xfffa) +float 0x1 - 0x7 == -0x6 (0xfffa) +int 0x1 * 0x7 == 0x7 (0x7) +__uint 0x1 * 0x7 == 0x7 (0x7) +char 0x1 * 0x7 == 0x7 (0x7) +__uchar 0x1 * 0x7 == 0x7 (0x7) +__longlong 0x1 * 0x7 == 0x7 (0x7) +__ulonglong 0x1 * 0x7 == 0x7 (0x7) +float 0x1 * 0x7 == 0x7 (0x7) +int 0x1 < 0x7 == 0x1 (0x1) +__uint 0x1 < 0x7 == 0x1 (0x1) +char 0x1 < 0x7 == 0x1 (0x1) +__uchar 0x1 < 0x7 == 0x1 (0x1) +__longlong 0x1 < 0x7 == 0x1 (0x1) +__ulonglong 0x1 < 0x7 == 0x1 (0x1) +float 0x1 < 0x7 == 0x1 (0x1) +int 0x1 > 0x7 == 0x0 (0x0) +__uint 0x1 > 0x7 == 0x0 (0x0) +char 0x1 > 0x7 == 0x0 (0x0) +__uchar 0x1 > 0x7 == 0x0 (0x0) +__longlong 0x1 > 0x7 == 0x0 (0x0) +__ulonglong 0x1 > 0x7 == 0x0 (0x0) +float 0x1 > 0x7 == 0x0 (0x0) +int 0x1 <= 0x7 == 0x1 (0x1) +__uint 0x1 <= 0x7 == 0x1 (0x1) +char 0x1 <= 0x7 == 0x1 (0x1) +__uchar 0x1 <= 0x7 == 0x1 (0x1) +__longlong 0x1 <= 0x7 == 0x1 (0x1) +__ulonglong 0x1 <= 0x7 == 0x1 (0x1) +float 0x1 <= 0x7 == 0x1 (0x1) +int 0x1 == 0x7 == 0x0 (0x0) +__uint 0x1 == 0x7 == 0x0 (0x0) +char 0x1 == 0x7 == 0x0 (0x0) +__uchar 0x1 == 0x7 == 0x0 (0x0) +__longlong 0x1 == 0x7 == 0x0 (0x0) +__ulonglong 0x1 == 0x7 == 0x0 (0x0) +float 0x1 == 0x7 == 0x0 (0x0) +int 0x1 != 0x7 == 0x1 (0x1) +__uint 0x1 != 0x7 == 0x1 (0x1) +char 0x1 != 0x7 == 0x1 (0x1) +__uchar 0x1 != 0x7 == 0x1 (0x1) +__longlong 0x1 != 0x7 == 0x1 (0x1) +__ulonglong 0x1 != 0x7 == 0x1 (0x1) +float 0x1 != 0x7 == 0x1 (0x1) +int 0x1 >= 0x7 == 0x0 (0x0) +__uint 0x1 >= 0x7 == 0x0 (0x0) +char 0x1 >= 0x7 == 0x0 (0x0) +__uchar 0x1 >= 0x7 == 0x0 (0x0) +__longlong 0x1 >= 0x7 == 0x0 (0x0) +__ulonglong 0x1 >= 0x7 == 0x0 (0x0) +float 0x1 >= 0x7 == 0x0 (0x0) +int 0x1 / 0x7 == 0x0 (0x0) +__uint 0x1 / 0x7 == 0x0 (0x0) +char 0x1 / 0x7 == 0x0 (0x0) +__uchar 0x1 / 0x7 == 0x0 (0x0) +__longlong 0x1 / 0x7 == 0x0 (0x0) +__ulonglong 0x1 / 0x7 == 0x0 (0x0) +float 0x1 / 0x7 == 0x0 (0x0) +int 0x1 % 0x7 == 0x1 (0x1) +__uint 0x1 % 0x7 == 0x1 (0x1) +char 0x1 % 0x7 == 0x1 (0x1) +__uchar 0x1 % 0x7 == 0x1 (0x1) +__longlong 0x1 % 0x7 == 0x1 (0x1) +__ulonglong 0x1 % 0x7 == 0x1 (0x1) +0x1 * 0x2a == 0x2a +0x1 / 0x2a == 0x0 +0x1 % 0x2a == 0x1 +int 0x1 ^ 0x2a == 0x2b (0x2b) +__uint 0x1 ^ 0x2a == 0x2b (0x2b) +char 0x1 ^ 0x2a == 0x2b (0x2b) +__uchar 0x1 ^ 0x2a == 0x2b (0x2b) +__longlong 0x1 ^ 0x2a == 0x2b (0x2b) +__ulonglong 0x1 ^ 0x2a == 0x2b (0x2b) +int 0x1 && 0x2a == 0x1 (0x1) +__uint 0x1 && 0x2a == 0x1 (0x1) +char 0x1 && 0x2a == 0x1 (0x1) +__uchar 0x1 && 0x2a == 0x1 (0x1) +__longlong 0x1 && 0x2a == 0x1 (0x1) +__ulonglong 0x1 && 0x2a == 0x1 (0x1) +int 0x1 || 0x2a == 0x1 (0x1) +__uint 0x1 || 0x2a == 0x1 (0x1) +char 0x1 || 0x2a == 0x1 (0x1) +__uchar 0x1 || 0x2a == 0x1 (0x1) +__longlong 0x1 || 0x2a == 0x1 (0x1) +__ulonglong 0x1 || 0x2a == 0x1 (0x1) +int 0x1 & 0x2a == 0x0 (0x0) +__uint 0x1 & 0x2a == 0x0 (0x0) +char 0x1 & 0x2a == 0x0 (0x0) +__uchar 0x1 & 0x2a == 0x0 (0x0) +__longlong 0x1 & 0x2a == 0x0 (0x0) +__ulonglong 0x1 & 0x2a == 0x0 (0x0) +int 0x1 | 0x2a == 0x2b (0x2b) +__uint 0x1 | 0x2a == 0x2b (0x2b) +char 0x1 | 0x2a == 0x2b (0x2b) +__uchar 0x1 | 0x2a == 0x2b (0x2b) +__longlong 0x1 | 0x2a == 0x2b (0x2b) +__ulonglong 0x1 | 0x2a == 0x2b (0x2b) +int 0x1 << 0xc == 0x1000 (0x1000) +__uint 0x1 << 0xc == 0x1000 (0x1000) +char 0x1 << 0xc == 0x0 (0x0) +__uchar 0x1 << 0xc == 0x0 (0x0) +__longlong 0x1 << 0xc == 0x1000 (0x1000) +__ulonglong 0x1 << 0xc == 0x1000 (0x1000) +int 0x1 >> 0xc == 0x0 (0x0) +__uint 0x1 >> 0xc == 0x0 (0x0) +char 0x1 >> 0xc == 0x0 (0x0) +__uchar 0x1 >> 0xc == 0x0 (0x0) +__longlong 0x1 >> 0xc == 0x0 (0x0) +__ulonglong 0x1 >> 0xc == 0x0 (0x0) +int 0x1 + 0x2a == 0x2b (0x2b) +__uint 0x1 + 0x2a == 0x2b (0x2b) +char 0x1 + 0x2a == 0x2b (0x2b) +__uchar 0x1 + 0x2a == 0x2b (0x2b) +__longlong 0x1 + 0x2a == 0x2b (0x2b) +__ulonglong 0x1 + 0x2a == 0x2b (0x2b) +float 0x1 + 0x2a == 0x2b (0x2b) +int 0x1 - 0x2a == -0x29 (0xffd7) +__uint 0x1 - 0x2a == -0x29 (0xffd7) +char 0x1 - 0x2a == -0x29 (0xffd7) +__uchar 0x1 - 0x2a == 0xd7 (0xd7) +__longlong 0x1 - 0x2a == -0x29 (0xffd7) +__ulonglong 0x1 - 0x2a == -0x29 (0xffd7) +float 0x1 - 0x2a == -0x29 (0xffd7) +int 0x1 * 0x2a == 0x2a (0x2a) +__uint 0x1 * 0x2a == 0x2a (0x2a) +char 0x1 * 0x2a == 0x2a (0x2a) +__uchar 0x1 * 0x2a == 0x2a (0x2a) +__longlong 0x1 * 0x2a == 0x2a (0x2a) +__ulonglong 0x1 * 0x2a == 0x2a (0x2a) +float 0x1 * 0x2a == 0x2a (0x2a) +int 0x1 < 0x2a == 0x1 (0x1) +__uint 0x1 < 0x2a == 0x1 (0x1) +char 0x1 < 0x2a == 0x1 (0x1) +__uchar 0x1 < 0x2a == 0x1 (0x1) +__longlong 0x1 < 0x2a == 0x1 (0x1) +__ulonglong 0x1 < 0x2a == 0x1 (0x1) +float 0x1 < 0x2a == 0x1 (0x1) +int 0x1 > 0x2a == 0x0 (0x0) +__uint 0x1 > 0x2a == 0x0 (0x0) +char 0x1 > 0x2a == 0x0 (0x0) +__uchar 0x1 > 0x2a == 0x0 (0x0) +__longlong 0x1 > 0x2a == 0x0 (0x0) +__ulonglong 0x1 > 0x2a == 0x0 (0x0) +float 0x1 > 0x2a == 0x0 (0x0) +int 0x1 <= 0x2a == 0x1 (0x1) +__uint 0x1 <= 0x2a == 0x1 (0x1) +char 0x1 <= 0x2a == 0x1 (0x1) +__uchar 0x1 <= 0x2a == 0x1 (0x1) +__longlong 0x1 <= 0x2a == 0x1 (0x1) +__ulonglong 0x1 <= 0x2a == 0x1 (0x1) +float 0x1 <= 0x2a == 0x1 (0x1) +int 0x1 == 0x2a == 0x0 (0x0) +__uint 0x1 == 0x2a == 0x0 (0x0) +char 0x1 == 0x2a == 0x0 (0x0) +__uchar 0x1 == 0x2a == 0x0 (0x0) +__longlong 0x1 == 0x2a == 0x0 (0x0) +__ulonglong 0x1 == 0x2a == 0x0 (0x0) +float 0x1 == 0x2a == 0x0 (0x0) +int 0x1 != 0x2a == 0x1 (0x1) +__uint 0x1 != 0x2a == 0x1 (0x1) +char 0x1 != 0x2a == 0x1 (0x1) +__uchar 0x1 != 0x2a == 0x1 (0x1) +__longlong 0x1 != 0x2a == 0x1 (0x1) +__ulonglong 0x1 != 0x2a == 0x1 (0x1) +float 0x1 != 0x2a == 0x1 (0x1) +int 0x1 >= 0x2a == 0x0 (0x0) +__uint 0x1 >= 0x2a == 0x0 (0x0) +char 0x1 >= 0x2a == 0x0 (0x0) +__uchar 0x1 >= 0x2a == 0x0 (0x0) +__longlong 0x1 >= 0x2a == 0x0 (0x0) +__ulonglong 0x1 >= 0x2a == 0x0 (0x0) +float 0x1 >= 0x2a == 0x0 (0x0) +int 0x1 / 0x2a == 0x0 (0x0) +__uint 0x1 / 0x2a == 0x0 (0x0) +char 0x1 / 0x2a == 0x0 (0x0) +__uchar 0x1 / 0x2a == 0x0 (0x0) +__longlong 0x1 / 0x2a == 0x0 (0x0) +__ulonglong 0x1 / 0x2a == 0x0 (0x0) +float 0x1 / 0x2a == 0x0 (0x0) +int 0x1 % 0x2a == 0x1 (0x1) +__uint 0x1 % 0x2a == 0x1 (0x1) +char 0x1 % 0x2a == 0x1 (0x1) +__uchar 0x1 % 0x2a == 0x1 (0x1) +__longlong 0x1 % 0x2a == 0x1 (0x1) +__ulonglong 0x1 % 0x2a == 0x1 (0x1) +0x1 * 0x17 == 0x17 +0x1 / 0x17 == 0x0 +0x1 % 0x17 == 0x1 +int 0x1 ^ 0x17 == 0x16 (0x16) +__uint 0x1 ^ 0x17 == 0x16 (0x16) +char 0x1 ^ 0x17 == 0x16 (0x16) +__uchar 0x1 ^ 0x17 == 0x16 (0x16) +__longlong 0x1 ^ 0x17 == 0x16 (0x16) +__ulonglong 0x1 ^ 0x17 == 0x16 (0x16) +int 0x1 && 0x17 == 0x1 (0x1) +__uint 0x1 && 0x17 == 0x1 (0x1) +char 0x1 && 0x17 == 0x1 (0x1) +__uchar 0x1 && 0x17 == 0x1 (0x1) +__longlong 0x1 && 0x17 == 0x1 (0x1) +__ulonglong 0x1 && 0x17 == 0x1 (0x1) +int 0x1 || 0x17 == 0x1 (0x1) +__uint 0x1 || 0x17 == 0x1 (0x1) +char 0x1 || 0x17 == 0x1 (0x1) +__uchar 0x1 || 0x17 == 0x1 (0x1) +__longlong 0x1 || 0x17 == 0x1 (0x1) +__ulonglong 0x1 || 0x17 == 0x1 (0x1) +int 0x1 & 0x17 == 0x1 (0x1) +__uint 0x1 & 0x17 == 0x1 (0x1) +char 0x1 & 0x17 == 0x1 (0x1) +__uchar 0x1 & 0x17 == 0x1 (0x1) +__longlong 0x1 & 0x17 == 0x1 (0x1) +__ulonglong 0x1 & 0x17 == 0x1 (0x1) +int 0x1 | 0x17 == 0x17 (0x17) +__uint 0x1 | 0x17 == 0x17 (0x17) +char 0x1 | 0x17 == 0x17 (0x17) +__uchar 0x1 | 0x17 == 0x17 (0x17) +__longlong 0x1 | 0x17 == 0x17 (0x17) +__ulonglong 0x1 | 0x17 == 0x17 (0x17) +int 0x1 << 0xe == 0x4000 (0x4000) +__uint 0x1 << 0xe == 0x4000 (0x4000) +char 0x1 << 0xe == 0x0 (0x0) +__uchar 0x1 << 0xe == 0x0 (0x0) +__longlong 0x1 << 0xe == 0x4000 (0x4000) +__ulonglong 0x1 << 0xe == 0x4000 (0x4000) +int 0x1 >> 0xe == 0x0 (0x0) +__uint 0x1 >> 0xe == 0x0 (0x0) +char 0x1 >> 0xe == 0x0 (0x0) +__uchar 0x1 >> 0xe == 0x0 (0x0) +__longlong 0x1 >> 0xe == 0x0 (0x0) +__ulonglong 0x1 >> 0xe == 0x0 (0x0) +int 0x1 + 0x17 == 0x18 (0x18) +__uint 0x1 + 0x17 == 0x18 (0x18) +char 0x1 + 0x17 == 0x18 (0x18) +__uchar 0x1 + 0x17 == 0x18 (0x18) +__longlong 0x1 + 0x17 == 0x18 (0x18) +__ulonglong 0x1 + 0x17 == 0x18 (0x18) +float 0x1 + 0x17 == 0x18 (0x18) +int 0x1 - 0x17 == -0x16 (0xffea) +__uint 0x1 - 0x17 == -0x16 (0xffea) +char 0x1 - 0x17 == -0x16 (0xffea) +__uchar 0x1 - 0x17 == 0xea (0xea) +__longlong 0x1 - 0x17 == -0x16 (0xffea) +__ulonglong 0x1 - 0x17 == -0x16 (0xffea) +float 0x1 - 0x17 == -0x16 (0xffea) +int 0x1 * 0x17 == 0x17 (0x17) +__uint 0x1 * 0x17 == 0x17 (0x17) +char 0x1 * 0x17 == 0x17 (0x17) +__uchar 0x1 * 0x17 == 0x17 (0x17) +__longlong 0x1 * 0x17 == 0x17 (0x17) +__ulonglong 0x1 * 0x17 == 0x17 (0x17) +float 0x1 * 0x17 == 0x17 (0x17) +int 0x1 < 0x17 == 0x1 (0x1) +__uint 0x1 < 0x17 == 0x1 (0x1) +char 0x1 < 0x17 == 0x1 (0x1) +__uchar 0x1 < 0x17 == 0x1 (0x1) +__longlong 0x1 < 0x17 == 0x1 (0x1) +__ulonglong 0x1 < 0x17 == 0x1 (0x1) +float 0x1 < 0x17 == 0x1 (0x1) +int 0x1 > 0x17 == 0x0 (0x0) +__uint 0x1 > 0x17 == 0x0 (0x0) +char 0x1 > 0x17 == 0x0 (0x0) +__uchar 0x1 > 0x17 == 0x0 (0x0) +__longlong 0x1 > 0x17 == 0x0 (0x0) +__ulonglong 0x1 > 0x17 == 0x0 (0x0) +float 0x1 > 0x17 == 0x0 (0x0) +int 0x1 <= 0x17 == 0x1 (0x1) +__uint 0x1 <= 0x17 == 0x1 (0x1) +char 0x1 <= 0x17 == 0x1 (0x1) +__uchar 0x1 <= 0x17 == 0x1 (0x1) +__longlong 0x1 <= 0x17 == 0x1 (0x1) +__ulonglong 0x1 <= 0x17 == 0x1 (0x1) +float 0x1 <= 0x17 == 0x1 (0x1) +int 0x1 == 0x17 == 0x0 (0x0) +__uint 0x1 == 0x17 == 0x0 (0x0) +char 0x1 == 0x17 == 0x0 (0x0) +__uchar 0x1 == 0x17 == 0x0 (0x0) +__longlong 0x1 == 0x17 == 0x0 (0x0) +__ulonglong 0x1 == 0x17 == 0x0 (0x0) +float 0x1 == 0x17 == 0x0 (0x0) +int 0x1 != 0x17 == 0x1 (0x1) +__uint 0x1 != 0x17 == 0x1 (0x1) +char 0x1 != 0x17 == 0x1 (0x1) +__uchar 0x1 != 0x17 == 0x1 (0x1) +__longlong 0x1 != 0x17 == 0x1 (0x1) +__ulonglong 0x1 != 0x17 == 0x1 (0x1) +float 0x1 != 0x17 == 0x1 (0x1) +int 0x1 >= 0x17 == 0x0 (0x0) +__uint 0x1 >= 0x17 == 0x0 (0x0) +char 0x1 >= 0x17 == 0x0 (0x0) +__uchar 0x1 >= 0x17 == 0x0 (0x0) +__longlong 0x1 >= 0x17 == 0x0 (0x0) +__ulonglong 0x1 >= 0x17 == 0x0 (0x0) +float 0x1 >= 0x17 == 0x0 (0x0) +int 0x1 / 0x17 == 0x0 (0x0) +__uint 0x1 / 0x17 == 0x0 (0x0) +char 0x1 / 0x17 == 0x0 (0x0) +__uchar 0x1 / 0x17 == 0x0 (0x0) +__longlong 0x1 / 0x17 == 0x0 (0x0) +__ulonglong 0x1 / 0x17 == 0x0 (0x0) +float 0x1 / 0x17 == 0x0 (0x0) +int 0x1 % 0x17 == 0x1 (0x1) +__uint 0x1 % 0x17 == 0x1 (0x1) +char 0x1 % 0x17 == 0x1 (0x1) +__uchar 0x1 % 0x17 == 0x1 (0x1) +__longlong 0x1 % 0x17 == 0x1 (0x1) +__ulonglong 0x1 % 0x17 == 0x1 (0x1) +0x1 * 0x7fff == 0x7fff +0x1 / 0x7fff == 0x0 +0x1 % 0x7fff == 0x1 +int 0x1 ^ 0x7fff == 0x7ffe (0x7ffe) +__uint 0x1 ^ 0x7fff == 0x7ffe (0x7ffe) +char 0x1 ^ 0xffff == -0x2 (0xfffe) +__uchar 0x1 ^ 0xff == 0xfe (0xfe) +__longlong 0x1 ^ 0x7fff == 0x7ffe (0x7ffe) +__ulonglong 0x1 ^ 0x7fff == 0x7ffe (0x7ffe) +int 0x1 && 0x7fff == 0x1 (0x1) +__uint 0x1 && 0x7fff == 0x1 (0x1) +char 0x1 && 0xffff == 0x1 (0x1) +__uchar 0x1 && 0xff == 0x1 (0x1) +__longlong 0x1 && 0x7fff == 0x1 (0x1) +__ulonglong 0x1 && 0x7fff == 0x1 (0x1) +int 0x1 || 0x7fff == 0x1 (0x1) +__uint 0x1 || 0x7fff == 0x1 (0x1) +char 0x1 || 0xffff == 0x1 (0x1) +__uchar 0x1 || 0xff == 0x1 (0x1) +__longlong 0x1 || 0x7fff == 0x1 (0x1) +__ulonglong 0x1 || 0x7fff == 0x1 (0x1) +int 0x1 & 0x7fff == 0x1 (0x1) +__uint 0x1 & 0x7fff == 0x1 (0x1) +char 0x1 & 0xffff == 0x1 (0x1) +__uchar 0x1 & 0xff == 0x1 (0x1) +__longlong 0x1 & 0x7fff == 0x1 (0x1) +__ulonglong 0x1 & 0x7fff == 0x1 (0x1) +int 0x1 | 0x7fff == 0x7fff (0x7fff) +__uint 0x1 | 0x7fff == 0x7fff (0x7fff) +char 0x1 | 0xffff == -0x1 (0xffff) +__uchar 0x1 | 0xff == 0xff (0xff) +__longlong 0x1 | 0x7fff == 0x7fff (0x7fff) +__ulonglong 0x1 | 0x7fff == 0x7fff (0x7fff) +int 0x1 << 0x10 == 0x0 (0x0) +__uint 0x1 << 0x10 == 0x0 (0x0) +char 0x1 << 0x10 == 0x0 (0x0) +__uchar 0x1 << 0x10 == 0x0 (0x0) +__longlong 0x1 << 0x10 == 0x0 (0x0) +__ulonglong 0x1 << 0x10 == 0x0 (0x0) +int 0x1 >> 0x10 == 0x0 (0x0) +__uint 0x1 >> 0x10 == 0x0 (0x0) +char 0x1 >> 0x10 == 0x0 (0x0) +__uchar 0x1 >> 0x10 == 0x0 (0x0) +__longlong 0x1 >> 0x10 == 0x0 (0x0) +__ulonglong 0x1 >> 0x10 == 0x0 (0x0) +int 0x1 + 0x7fff == -0x8000 (0x8000) +__uint 0x1 + 0x7fff == -0x8000 (0x8000) +char 0x1 + 0xffff == 0x0 (0x0) +__uchar 0x1 + 0xff == 0x0 (0x0) +__longlong 0x1 + 0x7fff == -0x8000 (0x8000) +__ulonglong 0x1 + 0x7fff == -0x8000 (0x8000) +float 0x1 + 0x7fff == -0x8000 (0x8000) +int 0x1 - 0x7fff == -0x7ffe (0x8002) +__uint 0x1 - 0x7fff == -0x7ffe (0x8002) +char 0x1 - 0xffff == 0x2 (0x2) +__uchar 0x1 - 0xff == 0x2 (0x2) +__longlong 0x1 - 0x7fff == -0x7ffe (0x8002) +__ulonglong 0x1 - 0x7fff == -0x7ffe (0x8002) +float 0x1 - 0x7fff == -0x7ffe (0x8002) +int 0x1 * 0x7fff == 0x7fff (0x7fff) +__uint 0x1 * 0x7fff == 0x7fff (0x7fff) +char 0x1 * 0xffff == -0x1 (0xffff) +__uchar 0x1 * 0xff == 0xff (0xff) +__longlong 0x1 * 0x7fff == 0x7fff (0x7fff) +__ulonglong 0x1 * 0x7fff == 0x7fff (0x7fff) +float 0x1 * 0x7fff == 0x7fff (0x7fff) +int 0x1 < 0x7fff == 0x1 (0x1) +__uint 0x1 < 0x7fff == 0x1 (0x1) +char 0x1 < 0xffff == 0x0 (0x0) +__uchar 0x1 < 0xff == 0x1 (0x1) +__longlong 0x1 < 0x7fff == 0x1 (0x1) +__ulonglong 0x1 < 0x7fff == 0x1 (0x1) +float 0x1 < 0x7fff == 0x1 (0x1) +int 0x1 > 0x7fff == 0x0 (0x0) +__uint 0x1 > 0x7fff == 0x0 (0x0) +char 0x1 > 0xffff == 0x1 (0x1) +__uchar 0x1 > 0xff == 0x0 (0x0) +__longlong 0x1 > 0x7fff == 0x0 (0x0) +__ulonglong 0x1 > 0x7fff == 0x0 (0x0) +float 0x1 > 0x7fff == 0x0 (0x0) +int 0x1 <= 0x7fff == 0x1 (0x1) +__uint 0x1 <= 0x7fff == 0x1 (0x1) +char 0x1 <= 0xffff == 0x0 (0x0) +__uchar 0x1 <= 0xff == 0x1 (0x1) +__longlong 0x1 <= 0x7fff == 0x1 (0x1) +__ulonglong 0x1 <= 0x7fff == 0x1 (0x1) +float 0x1 <= 0x7fff == 0x1 (0x1) +int 0x1 == 0x7fff == 0x0 (0x0) +__uint 0x1 == 0x7fff == 0x0 (0x0) +char 0x1 == 0xffff == 0x0 (0x0) +__uchar 0x1 == 0xff == 0x0 (0x0) +__longlong 0x1 == 0x7fff == 0x0 (0x0) +__ulonglong 0x1 == 0x7fff == 0x0 (0x0) +float 0x1 == 0x7fff == 0x0 (0x0) +int 0x1 != 0x7fff == 0x1 (0x1) +__uint 0x1 != 0x7fff == 0x1 (0x1) +char 0x1 != 0xffff == 0x1 (0x1) +__uchar 0x1 != 0xff == 0x1 (0x1) +__longlong 0x1 != 0x7fff == 0x1 (0x1) +__ulonglong 0x1 != 0x7fff == 0x1 (0x1) +float 0x1 != 0x7fff == 0x1 (0x1) +int 0x1 >= 0x7fff == 0x0 (0x0) +__uint 0x1 >= 0x7fff == 0x0 (0x0) +char 0x1 >= 0xffff == 0x1 (0x1) +__uchar 0x1 >= 0xff == 0x0 (0x0) +__longlong 0x1 >= 0x7fff == 0x0 (0x0) +__ulonglong 0x1 >= 0x7fff == 0x0 (0x0) +float 0x1 >= 0x7fff == 0x0 (0x0) +int 0x1 / 0x7fff == 0x0 (0x0) +__uint 0x1 / 0x7fff == 0x0 (0x0) +char 0x1 / 0xffff == -0x1 (0xffff) +__uchar 0x1 / 0xff == 0x0 (0x0) +__longlong 0x1 / 0x7fff == 0x0 (0x0) +__ulonglong 0x1 / 0x7fff == 0x0 (0x0) +float 0x1 / 0x7fff == 0x0 (0x0) +int 0x1 % 0x7fff == 0x1 (0x1) +__uint 0x1 % 0x7fff == 0x1 (0x1) +char 0x1 % 0xffff == 0x0 (0x0) +__uchar 0x1 % 0xff == 0x1 (0x1) +__longlong 0x1 % 0x7fff == 0x1 (0x1) +__ulonglong 0x1 % 0x7fff == 0x1 (0x1) +0x1 * 0x8000 == -0x8000 +0x1 / 0x8000 == 0x0 +0x1 % 0x8000 == 0x1 +int 0x1 ^ 0x8000 == -0x7fff (0x8001) +__uint 0x1 ^ 0x8000 == -0x7fff (0x8001) +char 0x1 ^ 0x0 == 0x1 (0x1) +__uchar 0x1 ^ 0x0 == 0x1 (0x1) +__longlong 0x1 ^ 0x8000 == -0x7fff (0x8001) +__ulonglong 0x1 ^ 0x8000 == -0x7fff (0x8001) +int 0x1 && 0x8000 == 0x1 (0x1) +__uint 0x1 && 0x8000 == 0x1 (0x1) +char 0x1 && 0x0 == 0x0 (0x0) +__uchar 0x1 && 0x0 == 0x0 (0x0) +__longlong 0x1 && 0x8000 == 0x1 (0x1) +__ulonglong 0x1 && 0x8000 == 0x1 (0x1) +int 0x1 || 0x8000 == 0x1 (0x1) +__uint 0x1 || 0x8000 == 0x1 (0x1) +char 0x1 || 0x0 == 0x1 (0x1) +__uchar 0x1 || 0x0 == 0x1 (0x1) +__longlong 0x1 || 0x8000 == 0x1 (0x1) +__ulonglong 0x1 || 0x8000 == 0x1 (0x1) +int 0x1 & 0x8000 == 0x0 (0x0) +__uint 0x1 & 0x8000 == 0x0 (0x0) +char 0x1 & 0x0 == 0x0 (0x0) +__uchar 0x1 & 0x0 == 0x0 (0x0) +__longlong 0x1 & 0x8000 == 0x0 (0x0) +__ulonglong 0x1 & 0x8000 == 0x0 (0x0) +int 0x1 | 0x8000 == -0x7fff (0x8001) +__uint 0x1 | 0x8000 == -0x7fff (0x8001) +char 0x1 | 0x0 == 0x1 (0x1) +__uchar 0x1 | 0x0 == 0x1 (0x1) +__longlong 0x1 | 0x8000 == -0x7fff (0x8001) +__ulonglong 0x1 | 0x8000 == -0x7fff (0x8001) +int 0x1 << 0x12 == 0x0 (0x0) +__uint 0x1 << 0x12 == 0x0 (0x0) +char 0x1 << 0x12 == 0x0 (0x0) +__uchar 0x1 << 0x12 == 0x0 (0x0) +__longlong 0x1 << 0x12 == 0x0 (0x0) +__ulonglong 0x1 << 0x12 == 0x0 (0x0) +int 0x1 >> 0x12 == 0x0 (0x0) +__uint 0x1 >> 0x12 == 0x0 (0x0) +char 0x1 >> 0x12 == 0x0 (0x0) +__uchar 0x1 >> 0x12 == 0x0 (0x0) +__longlong 0x1 >> 0x12 == 0x0 (0x0) +__ulonglong 0x1 >> 0x12 == 0x0 (0x0) +int 0x1 + 0x8000 == -0x7fff (0x8001) +__uint 0x1 + 0x8000 == -0x7fff (0x8001) +char 0x1 + 0x0 == 0x1 (0x1) +__uchar 0x1 + 0x0 == 0x1 (0x1) +__longlong 0x1 + 0x8000 == -0x7fff (0x8001) +__ulonglong 0x1 + 0x8000 == -0x7fff (0x8001) +float 0x1 + 0x8000 == -0x7fff (0x8001) +int 0x1 - 0x8000 == -0x7fff (0x8001) +__uint 0x1 - 0x8000 == -0x7fff (0x8001) +char 0x1 - 0x0 == 0x1 (0x1) +__uchar 0x1 - 0x0 == 0x1 (0x1) +__longlong 0x1 - 0x8000 == -0x7fff (0x8001) +__ulonglong 0x1 - 0x8000 == -0x7fff (0x8001) +float 0x1 - 0x8000 == -0x7fff (0x8001) +int 0x1 * 0x8000 == -0x8000 (0x8000) +__uint 0x1 * 0x8000 == -0x8000 (0x8000) +char 0x1 * 0x0 == 0x0 (0x0) +__uchar 0x1 * 0x0 == 0x0 (0x0) +__longlong 0x1 * 0x8000 == -0x8000 (0x8000) +__ulonglong 0x1 * 0x8000 == -0x8000 (0x8000) +float 0x1 * 0x8000 == -0x8000 (0x8000) +int 0x1 < 0x8000 == 0x0 (0x0) +__uint 0x1 < 0x8000 == 0x1 (0x1) +char 0x1 < 0x0 == 0x0 (0x0) +__uchar 0x1 < 0x0 == 0x0 (0x0) +__longlong 0x1 < 0x8000 == 0x0 (0x0) +__ulonglong 0x1 < 0x8000 == 0x1 (0x1) +float 0x1 < 0x8000 == 0x0 (0x0) +int 0x1 > 0x8000 == 0x1 (0x1) +__uint 0x1 > 0x8000 == 0x0 (0x0) +char 0x1 > 0x0 == 0x1 (0x1) +__uchar 0x1 > 0x0 == 0x1 (0x1) +__longlong 0x1 > 0x8000 == 0x1 (0x1) +__ulonglong 0x1 > 0x8000 == 0x0 (0x0) +float 0x1 > 0x8000 == 0x1 (0x1) +int 0x1 <= 0x8000 == 0x0 (0x0) +__uint 0x1 <= 0x8000 == 0x1 (0x1) +char 0x1 <= 0x0 == 0x0 (0x0) +__uchar 0x1 <= 0x0 == 0x0 (0x0) +__longlong 0x1 <= 0x8000 == 0x0 (0x0) +__ulonglong 0x1 <= 0x8000 == 0x1 (0x1) +float 0x1 <= 0x8000 == 0x0 (0x0) +int 0x1 == 0x8000 == 0x0 (0x0) +__uint 0x1 == 0x8000 == 0x0 (0x0) +char 0x1 == 0x0 == 0x0 (0x0) +__uchar 0x1 == 0x0 == 0x0 (0x0) +__longlong 0x1 == 0x8000 == 0x0 (0x0) +__ulonglong 0x1 == 0x8000 == 0x0 (0x0) +float 0x1 == 0x8000 == 0x0 (0x0) +int 0x1 != 0x8000 == 0x1 (0x1) +__uint 0x1 != 0x8000 == 0x1 (0x1) +char 0x1 != 0x0 == 0x1 (0x1) +__uchar 0x1 != 0x0 == 0x1 (0x1) +__longlong 0x1 != 0x8000 == 0x1 (0x1) +__ulonglong 0x1 != 0x8000 == 0x1 (0x1) +float 0x1 != 0x8000 == 0x1 (0x1) +int 0x1 >= 0x8000 == 0x1 (0x1) +__uint 0x1 >= 0x8000 == 0x0 (0x0) +char 0x1 >= 0x0 == 0x1 (0x1) +__uchar 0x1 >= 0x0 == 0x1 (0x1) +__longlong 0x1 >= 0x8000 == 0x1 (0x1) +__ulonglong 0x1 >= 0x8000 == 0x0 (0x0) +float 0x1 >= 0x8000 == 0x1 (0x1) +int 0x1 / 0x8000 == 0x0 (0x0) +__uint 0x1 / 0x8000 == 0x0 (0x0) +__longlong 0x1 / 0x8000 == 0x0 (0x0) +__ulonglong 0x1 / 0x8000 == 0x0 (0x0) +float 0x1 / 0x8000 == 0x0 (0x0) +int 0x1 % 0x8000 == 0x1 (0x1) +__uint 0x1 % 0x8000 == 0x1 (0x1) +__longlong 0x1 % 0x8000 == 0x1 (0x1) +__ulonglong 0x1 % 0x8000 == 0x1 (0x1) +0x1 * 0x3e8 == 0x3e8 +0x1 / 0x3e8 == 0x0 +0x1 % 0x3e8 == 0x1 +int 0x1 ^ 0x3e8 == 0x3e9 (0x3e9) +__uint 0x1 ^ 0x3e8 == 0x3e9 (0x3e9) +char 0x1 ^ 0xffe8 == -0x17 (0xffe9) +__uchar 0x1 ^ 0xe8 == 0xe9 (0xe9) +__longlong 0x1 ^ 0x3e8 == 0x3e9 (0x3e9) +__ulonglong 0x1 ^ 0x3e8 == 0x3e9 (0x3e9) +int 0x1 && 0x3e8 == 0x1 (0x1) +__uint 0x1 && 0x3e8 == 0x1 (0x1) +char 0x1 && 0xffe8 == 0x1 (0x1) +__uchar 0x1 && 0xe8 == 0x1 (0x1) +__longlong 0x1 && 0x3e8 == 0x1 (0x1) +__ulonglong 0x1 && 0x3e8 == 0x1 (0x1) +int 0x1 || 0x3e8 == 0x1 (0x1) +__uint 0x1 || 0x3e8 == 0x1 (0x1) +char 0x1 || 0xffe8 == 0x1 (0x1) +__uchar 0x1 || 0xe8 == 0x1 (0x1) +__longlong 0x1 || 0x3e8 == 0x1 (0x1) +__ulonglong 0x1 || 0x3e8 == 0x1 (0x1) +int 0x1 & 0x3e8 == 0x0 (0x0) +__uint 0x1 & 0x3e8 == 0x0 (0x0) +char 0x1 & 0xffe8 == 0x0 (0x0) +__uchar 0x1 & 0xe8 == 0x0 (0x0) +__longlong 0x1 & 0x3e8 == 0x0 (0x0) +__ulonglong 0x1 & 0x3e8 == 0x0 (0x0) +int 0x1 | 0x3e8 == 0x3e9 (0x3e9) +__uint 0x1 | 0x3e8 == 0x3e9 (0x3e9) +char 0x1 | 0xffe8 == -0x17 (0xffe9) +__uchar 0x1 | 0xe8 == 0xe9 (0xe9) +__longlong 0x1 | 0x3e8 == 0x3e9 (0x3e9) +__ulonglong 0x1 | 0x3e8 == 0x3e9 (0x3e9) +int 0x1 << 0x14 == 0x0 (0x0) +__uint 0x1 << 0x14 == 0x0 (0x0) +char 0x1 << 0x14 == 0x0 (0x0) +__uchar 0x1 << 0x14 == 0x0 (0x0) +__longlong 0x1 << 0x14 == 0x0 (0x0) +__ulonglong 0x1 << 0x14 == 0x0 (0x0) +int 0x1 >> 0x14 == 0x0 (0x0) +__uint 0x1 >> 0x14 == 0x0 (0x0) +char 0x1 >> 0x14 == 0x0 (0x0) +__uchar 0x1 >> 0x14 == 0x0 (0x0) +__longlong 0x1 >> 0x14 == 0x0 (0x0) +__ulonglong 0x1 >> 0x14 == 0x0 (0x0) +int 0x1 + 0x3e8 == 0x3e9 (0x3e9) +__uint 0x1 + 0x3e8 == 0x3e9 (0x3e9) +char 0x1 + 0xffe8 == -0x17 (0xffe9) +__uchar 0x1 + 0xe8 == 0xe9 (0xe9) +__longlong 0x1 + 0x3e8 == 0x3e9 (0x3e9) +__ulonglong 0x1 + 0x3e8 == 0x3e9 (0x3e9) +float 0x1 + 0x3e8 == 0x3e9 (0x3e9) +int 0x1 - 0x3e8 == -0x3e7 (0xfc19) +__uint 0x1 - 0x3e8 == -0x3e7 (0xfc19) +char 0x1 - 0xffe8 == 0x19 (0x19) +__uchar 0x1 - 0xe8 == 0x19 (0x19) +__longlong 0x1 - 0x3e8 == -0x3e7 (0xfc19) +__ulonglong 0x1 - 0x3e8 == -0x3e7 (0xfc19) +float 0x1 - 0x3e8 == -0x3e7 (0xfc19) +int 0x1 * 0x3e8 == 0x3e8 (0x3e8) +__uint 0x1 * 0x3e8 == 0x3e8 (0x3e8) +char 0x1 * 0xffe8 == -0x18 (0xffe8) +__uchar 0x1 * 0xe8 == 0xe8 (0xe8) +__longlong 0x1 * 0x3e8 == 0x3e8 (0x3e8) +__ulonglong 0x1 * 0x3e8 == 0x3e8 (0x3e8) +float 0x1 * 0x3e8 == 0x3e8 (0x3e8) +int 0x1 < 0x3e8 == 0x1 (0x1) +__uint 0x1 < 0x3e8 == 0x1 (0x1) +char 0x1 < 0xffe8 == 0x0 (0x0) +__uchar 0x1 < 0xe8 == 0x1 (0x1) +__longlong 0x1 < 0x3e8 == 0x1 (0x1) +__ulonglong 0x1 < 0x3e8 == 0x1 (0x1) +float 0x1 < 0x3e8 == 0x1 (0x1) +int 0x1 > 0x3e8 == 0x0 (0x0) +__uint 0x1 > 0x3e8 == 0x0 (0x0) +char 0x1 > 0xffe8 == 0x1 (0x1) +__uchar 0x1 > 0xe8 == 0x0 (0x0) +__longlong 0x1 > 0x3e8 == 0x0 (0x0) +__ulonglong 0x1 > 0x3e8 == 0x0 (0x0) +float 0x1 > 0x3e8 == 0x0 (0x0) +int 0x1 <= 0x3e8 == 0x1 (0x1) +__uint 0x1 <= 0x3e8 == 0x1 (0x1) +char 0x1 <= 0xffe8 == 0x0 (0x0) +__uchar 0x1 <= 0xe8 == 0x1 (0x1) +__longlong 0x1 <= 0x3e8 == 0x1 (0x1) +__ulonglong 0x1 <= 0x3e8 == 0x1 (0x1) +float 0x1 <= 0x3e8 == 0x1 (0x1) +int 0x1 == 0x3e8 == 0x0 (0x0) +__uint 0x1 == 0x3e8 == 0x0 (0x0) +char 0x1 == 0xffe8 == 0x0 (0x0) +__uchar 0x1 == 0xe8 == 0x0 (0x0) +__longlong 0x1 == 0x3e8 == 0x0 (0x0) +__ulonglong 0x1 == 0x3e8 == 0x0 (0x0) +float 0x1 == 0x3e8 == 0x0 (0x0) +int 0x1 != 0x3e8 == 0x1 (0x1) +__uint 0x1 != 0x3e8 == 0x1 (0x1) +char 0x1 != 0xffe8 == 0x1 (0x1) +__uchar 0x1 != 0xe8 == 0x1 (0x1) +__longlong 0x1 != 0x3e8 == 0x1 (0x1) +__ulonglong 0x1 != 0x3e8 == 0x1 (0x1) +float 0x1 != 0x3e8 == 0x1 (0x1) +int 0x1 >= 0x3e8 == 0x0 (0x0) +__uint 0x1 >= 0x3e8 == 0x0 (0x0) +char 0x1 >= 0xffe8 == 0x1 (0x1) +__uchar 0x1 >= 0xe8 == 0x0 (0x0) +__longlong 0x1 >= 0x3e8 == 0x0 (0x0) +__ulonglong 0x1 >= 0x3e8 == 0x0 (0x0) +float 0x1 >= 0x3e8 == 0x0 (0x0) +int 0x1 / 0x3e8 == 0x0 (0x0) +__uint 0x1 / 0x3e8 == 0x0 (0x0) +char 0x1 / 0xffe8 == 0x0 (0x0) +__uchar 0x1 / 0xe8 == 0x0 (0x0) +__longlong 0x1 / 0x3e8 == 0x0 (0x0) +__ulonglong 0x1 / 0x3e8 == 0x0 (0x0) +float 0x1 / 0x3e8 == 0x0 (0x0) +int 0x1 % 0x3e8 == 0x1 (0x1) +__uint 0x1 % 0x3e8 == 0x1 (0x1) +char 0x1 % 0xffe8 == 0x1 (0x1) +__uchar 0x1 % 0xe8 == 0x1 (0x1) +__longlong 0x1 % 0x3e8 == 0x1 (0x1) +__ulonglong 0x1 % 0x3e8 == 0x1 (0x1) +0x1 * 0x2710 == 0x2710 +0x1 / 0x2710 == 0x0 +0x1 % 0x2710 == 0x1 +int 0x1 ^ 0x2710 == 0x2711 (0x2711) +__uint 0x1 ^ 0x2710 == 0x2711 (0x2711) +char 0x1 ^ 0x10 == 0x11 (0x11) +__uchar 0x1 ^ 0x10 == 0x11 (0x11) +__longlong 0x1 ^ 0x2710 == 0x2711 (0x2711) +__ulonglong 0x1 ^ 0x2710 == 0x2711 (0x2711) +int 0x1 && 0x2710 == 0x1 (0x1) +__uint 0x1 && 0x2710 == 0x1 (0x1) +char 0x1 && 0x10 == 0x1 (0x1) +__uchar 0x1 && 0x10 == 0x1 (0x1) +__longlong 0x1 && 0x2710 == 0x1 (0x1) +__ulonglong 0x1 && 0x2710 == 0x1 (0x1) +int 0x1 || 0x2710 == 0x1 (0x1) +__uint 0x1 || 0x2710 == 0x1 (0x1) +char 0x1 || 0x10 == 0x1 (0x1) +__uchar 0x1 || 0x10 == 0x1 (0x1) +__longlong 0x1 || 0x2710 == 0x1 (0x1) +__ulonglong 0x1 || 0x2710 == 0x1 (0x1) +int 0x1 & 0x2710 == 0x0 (0x0) +__uint 0x1 & 0x2710 == 0x0 (0x0) +char 0x1 & 0x10 == 0x0 (0x0) +__uchar 0x1 & 0x10 == 0x0 (0x0) +__longlong 0x1 & 0x2710 == 0x0 (0x0) +__ulonglong 0x1 & 0x2710 == 0x0 (0x0) +int 0x1 | 0x2710 == 0x2711 (0x2711) +__uint 0x1 | 0x2710 == 0x2711 (0x2711) +char 0x1 | 0x10 == 0x11 (0x11) +__uchar 0x1 | 0x10 == 0x11 (0x11) +__longlong 0x1 | 0x2710 == 0x2711 (0x2711) +__ulonglong 0x1 | 0x2710 == 0x2711 (0x2711) +int 0x1 << 0x16 == 0x0 (0x0) +__uint 0x1 << 0x16 == 0x0 (0x0) +char 0x1 << 0x16 == 0x0 (0x0) +__uchar 0x1 << 0x16 == 0x0 (0x0) +__longlong 0x1 << 0x16 == 0x0 (0x0) +__ulonglong 0x1 << 0x16 == 0x0 (0x0) +int 0x1 >> 0x16 == 0x0 (0x0) +__uint 0x1 >> 0x16 == 0x0 (0x0) +char 0x1 >> 0x16 == 0x0 (0x0) +__uchar 0x1 >> 0x16 == 0x0 (0x0) +__longlong 0x1 >> 0x16 == 0x0 (0x0) +__ulonglong 0x1 >> 0x16 == 0x0 (0x0) +int 0x1 + 0x2710 == 0x2711 (0x2711) +__uint 0x1 + 0x2710 == 0x2711 (0x2711) +char 0x1 + 0x10 == 0x11 (0x11) +__uchar 0x1 + 0x10 == 0x11 (0x11) +__longlong 0x1 + 0x2710 == 0x2711 (0x2711) +__ulonglong 0x1 + 0x2710 == 0x2711 (0x2711) +float 0x1 + 0x2710 == 0x2711 (0x2711) +int 0x1 - 0x2710 == -0x270f (0xd8f1) +__uint 0x1 - 0x2710 == -0x270f (0xd8f1) +char 0x1 - 0x10 == -0xf (0xfff1) +__uchar 0x1 - 0x10 == 0xf1 (0xf1) +__longlong 0x1 - 0x2710 == -0x270f (0xd8f1) +__ulonglong 0x1 - 0x2710 == -0x270f (0xd8f1) +float 0x1 - 0x2710 == -0x270f (0xd8f1) +int 0x1 * 0x2710 == 0x2710 (0x2710) +__uint 0x1 * 0x2710 == 0x2710 (0x2710) +char 0x1 * 0x10 == 0x10 (0x10) +__uchar 0x1 * 0x10 == 0x10 (0x10) +__longlong 0x1 * 0x2710 == 0x2710 (0x2710) +__ulonglong 0x1 * 0x2710 == 0x2710 (0x2710) +float 0x1 * 0x2710 == 0x2710 (0x2710) +int 0x1 < 0x2710 == 0x1 (0x1) +__uint 0x1 < 0x2710 == 0x1 (0x1) +char 0x1 < 0x10 == 0x1 (0x1) +__uchar 0x1 < 0x10 == 0x1 (0x1) +__longlong 0x1 < 0x2710 == 0x1 (0x1) +__ulonglong 0x1 < 0x2710 == 0x1 (0x1) +float 0x1 < 0x2710 == 0x1 (0x1) +int 0x1 > 0x2710 == 0x0 (0x0) +__uint 0x1 > 0x2710 == 0x0 (0x0) +char 0x1 > 0x10 == 0x0 (0x0) +__uchar 0x1 > 0x10 == 0x0 (0x0) +__longlong 0x1 > 0x2710 == 0x0 (0x0) +__ulonglong 0x1 > 0x2710 == 0x0 (0x0) +float 0x1 > 0x2710 == 0x0 (0x0) +int 0x1 <= 0x2710 == 0x1 (0x1) +__uint 0x1 <= 0x2710 == 0x1 (0x1) +char 0x1 <= 0x10 == 0x1 (0x1) +__uchar 0x1 <= 0x10 == 0x1 (0x1) +__longlong 0x1 <= 0x2710 == 0x1 (0x1) +__ulonglong 0x1 <= 0x2710 == 0x1 (0x1) +float 0x1 <= 0x2710 == 0x1 (0x1) +int 0x1 == 0x2710 == 0x0 (0x0) +__uint 0x1 == 0x2710 == 0x0 (0x0) +char 0x1 == 0x10 == 0x0 (0x0) +__uchar 0x1 == 0x10 == 0x0 (0x0) +__longlong 0x1 == 0x2710 == 0x0 (0x0) +__ulonglong 0x1 == 0x2710 == 0x0 (0x0) +float 0x1 == 0x2710 == 0x0 (0x0) +int 0x1 != 0x2710 == 0x1 (0x1) +__uint 0x1 != 0x2710 == 0x1 (0x1) +char 0x1 != 0x10 == 0x1 (0x1) +__uchar 0x1 != 0x10 == 0x1 (0x1) +__longlong 0x1 != 0x2710 == 0x1 (0x1) +__ulonglong 0x1 != 0x2710 == 0x1 (0x1) +float 0x1 != 0x2710 == 0x1 (0x1) +int 0x1 >= 0x2710 == 0x0 (0x0) +__uint 0x1 >= 0x2710 == 0x0 (0x0) +char 0x1 >= 0x10 == 0x0 (0x0) +__uchar 0x1 >= 0x10 == 0x0 (0x0) +__longlong 0x1 >= 0x2710 == 0x0 (0x0) +__ulonglong 0x1 >= 0x2710 == 0x0 (0x0) +float 0x1 >= 0x2710 == 0x0 (0x0) +int 0x1 / 0x2710 == 0x0 (0x0) +__uint 0x1 / 0x2710 == 0x0 (0x0) +char 0x1 / 0x10 == 0x0 (0x0) +__uchar 0x1 / 0x10 == 0x0 (0x0) +__longlong 0x1 / 0x2710 == 0x0 (0x0) +__ulonglong 0x1 / 0x2710 == 0x0 (0x0) +float 0x1 / 0x2710 == 0x0 (0x0) +int 0x1 % 0x2710 == 0x1 (0x1) +__uint 0x1 % 0x2710 == 0x1 (0x1) +char 0x1 % 0x10 == 0x1 (0x1) +__uchar 0x1 % 0x10 == 0x1 (0x1) +__longlong 0x1 % 0x2710 == 0x1 (0x1) +__ulonglong 0x1 % 0x2710 == 0x1 (0x1) +int xor420x1 xor42 0x2b +__uint xor420x1 xor42 0x2b +char xor420x1 xor42 0x2b +__uchar xor420x1 xor42 0x2b +__longlong xor420x1 xor42 0x2b +__ulonglong xor420x1 xor42 0x2b +int land10x1 land1 0x1 +__uint land10x1 land1 0x1 +char land10x1 land1 0x1 +__uchar land10x1 land1 0x1 +__longlong land10x1 land1 0x1 +__ulonglong land10x1 land1 0x1 +int lor10x1 lor1 0x1 +__uint lor10x1 lor1 0x1 +char lor10x1 lor1 0x1 +__uchar lor10x1 lor1 0x1 +__longlong lor10x1 lor1 0x1 +__ulonglong lor10x1 lor1 0x1 +int and420x1 and42 0x0 +__uint and420x1 and42 0x0 +char and420x1 and42 0x0 +__uchar and420x1 and42 0x0 +__longlong and420x1 and42 0x0 +__ulonglong and420x1 and42 0x0 +int or420x1 or42 0x2b +__uint or420x1 or42 0x2b +char or420x1 or42 0x2b +__uchar or420x1 or42 0x2b +__longlong or420x1 or42 0x2b +__ulonglong or420x1 or42 0x2b +int shl50x1 shl5 0x20 +__uint shl50x1 shl5 0x20 +char shl50x1 shl5 0x20 +__uchar shl50x1 shl5 0x20 +__longlong shl50x1 shl5 0x20 +__ulonglong shl50x1 shl5 0x20 +int shr50x1 shr5 0x0 +__uint shr50x1 shr5 0x0 +char shr50x1 shr5 0x0 +__uchar shr50x1 shr5 0x0 +__longlong shr50x1 shr5 0x0 +__ulonglong shr50x1 shr5 0x0 +int add420x1 add42 0x2b +__uint add420x1 add42 0x2b +char add420x1 add42 0x2b +__uchar add420x1 add42 0x2b +__longlong add420x1 add42 0x2b +__ulonglong add420x1 add42 0x2b +float add420x1 add42 0x2b +int sub420x1 sub42 -0x29 +__uint sub420x1 sub42 -0x29 +char sub420x1 sub42 -0x29 +__uchar sub420x1 sub42 0xd7 +__longlong sub420x1 sub42 -0x29 +__ulonglong sub420x1 sub42 -0x29 +float sub420x1 sub42 -0x29 +int mul420x1 mul42 0x2a +__uint mul420x1 mul42 0x2a +char mul420x1 mul42 0x2a +__uchar mul420x1 mul42 0x2a +__longlong mul420x1 mul42 0x2a +__ulonglong mul420x1 mul42 0x2a +float mul420x1 mul42 0x2a +int lt420x1 lt42 0x1 +__uint lt420x1 lt42 0x1 +char lt420x1 lt42 0x1 +__uchar lt420x1 lt42 0x1 +__longlong lt420x1 lt42 0x1 +__ulonglong lt420x1 lt42 0x1 +float lt420x1 lt42 0x1 +int gt420x1 gt42 0x0 +__uint gt420x1 gt42 0x0 +char gt420x1 gt42 0x0 +__uchar gt420x1 gt42 0x0 +__longlong gt420x1 gt42 0x0 +__ulonglong gt420x1 gt42 0x0 +float gt420x1 gt42 0x0 +int le420x1 le42 0x1 +__uint le420x1 le42 0x1 +char le420x1 le42 0x1 +__uchar le420x1 le42 0x1 +__longlong le420x1 le42 0x1 +__ulonglong le420x1 le42 0x1 +float le420x1 le42 0x1 +int eq420x1 eq42 0x0 +__uint eq420x1 eq42 0x0 +char eq420x1 eq42 0x0 +__uchar eq420x1 eq42 0x0 +__longlong eq420x1 eq42 0x0 +__ulonglong eq420x1 eq42 0x0 +float eq420x1 eq42 0x0 +int ne420x1 ne42 0x1 +__uint ne420x1 ne42 0x1 +char ne420x1 ne42 0x1 +__uchar ne420x1 ne42 0x1 +__longlong ne420x1 ne42 0x1 +__ulonglong ne420x1 ne42 0x1 +float ne420x1 ne42 0x1 +int ge420x1 ge42 0x0 +__uint ge420x1 ge42 0x0 +char ge420x1 ge42 0x0 +__uchar ge420x1 ge42 0x0 +__longlong ge420x1 ge42 0x0 +__ulonglong ge420x1 ge42 0x0 +float ge420x1 ge42 0x0 +int div420x1 div42 0x0 +__uint div420x1 div42 0x0 +char div420x1 div42 0x0 +__uchar div420x1 div42 0x0 +__longlong div420x1 div42 0x0 +__ulonglong div420x1 div42 0x0 +float div420x1 div42 0x0 +int mod230x1 mod23 0x1 +__uint mod230x1 mod23 0x1 +char mod230x1 mod23 0x1 +__uchar mod230x1 mod23 0x1 +__longlong mod230x1 mod23 0x1 +__ulonglong mod230x1 mod23 0x1 +0x2 * 0xffff == -0x2 +0x2 / 0xffff == -0x2 +0x2 % 0xffff == 0x0 +int 0x2 ^ 0xffff == -0x3 (0xfffd) +__uint 0x2 ^ 0xffff == -0x3 (0xfffd) +char 0x2 ^ 0xffff == -0x3 (0xfffd) +__uchar 0x2 ^ 0xff == 0xfd (0xfd) +__longlong 0x2 ^ 0xffff == -0x3 (0xfffd) +__ulonglong 0x2 ^ 0xffff == -0x3 (0xfffd) +int 0x2 && 0xffff == 0x1 (0x1) +__uint 0x2 && 0xffff == 0x1 (0x1) +char 0x2 && 0xffff == 0x1 (0x1) +__uchar 0x2 && 0xff == 0x1 (0x1) +__longlong 0x2 && 0xffff == 0x1 (0x1) +__ulonglong 0x2 && 0xffff == 0x1 (0x1) +int 0x2 || 0xffff == 0x1 (0x1) +__uint 0x2 || 0xffff == 0x1 (0x1) +char 0x2 || 0xffff == 0x1 (0x1) +__uchar 0x2 || 0xff == 0x1 (0x1) +__longlong 0x2 || 0xffff == 0x1 (0x1) +__ulonglong 0x2 || 0xffff == 0x1 (0x1) +int 0x2 & 0xffff == 0x2 (0x2) +__uint 0x2 & 0xffff == 0x2 (0x2) +char 0x2 & 0xffff == 0x2 (0x2) +__uchar 0x2 & 0xff == 0x2 (0x2) +__longlong 0x2 & 0xffff == 0x2 (0x2) +__ulonglong 0x2 & 0xffff == 0x2 (0x2) +int 0x2 | 0xffff == -0x1 (0xffff) +__uint 0x2 | 0xffff == -0x1 (0xffff) +char 0x2 | 0xffff == -0x1 (0xffff) +__uchar 0x2 | 0xff == 0xff (0xff) +__longlong 0x2 | 0xffff == -0x1 (0xffff) +__ulonglong 0x2 | 0xffff == -0x1 (0xffff) +int 0x2 << 0x1 == 0x4 (0x4) +__uint 0x2 << 0x1 == 0x4 (0x4) +char 0x2 << 0x1 == 0x4 (0x4) +__uchar 0x2 << 0x1 == 0x4 (0x4) +__longlong 0x2 << 0x1 == 0x4 (0x4) +__ulonglong 0x2 << 0x1 == 0x4 (0x4) +int 0x2 >> 0x1 == 0x1 (0x1) +__uint 0x2 >> 0x1 == 0x1 (0x1) +char 0x2 >> 0x1 == 0x1 (0x1) +__uchar 0x2 >> 0x1 == 0x1 (0x1) +__longlong 0x2 >> 0x1 == 0x1 (0x1) +__ulonglong 0x2 >> 0x1 == 0x1 (0x1) +int 0x2 + 0xffff == 0x1 (0x1) +__uint 0x2 + 0xffff == 0x1 (0x1) +char 0x2 + 0xffff == 0x1 (0x1) +__uchar 0x2 + 0xff == 0x1 (0x1) +__longlong 0x2 + 0xffff == 0x1 (0x1) +__ulonglong 0x2 + 0xffff == 0x1 (0x1) +float 0x2 + 0xffff == 0x1 (0x1) +int 0x2 - 0xffff == 0x3 (0x3) +__uint 0x2 - 0xffff == 0x3 (0x3) +char 0x2 - 0xffff == 0x3 (0x3) +__uchar 0x2 - 0xff == 0x3 (0x3) +__longlong 0x2 - 0xffff == 0x3 (0x3) +__ulonglong 0x2 - 0xffff == 0x3 (0x3) +float 0x2 - 0xffff == 0x3 (0x3) +int 0x2 * 0xffff == -0x2 (0xfffe) +__uint 0x2 * 0xffff == -0x2 (0xfffe) +char 0x2 * 0xffff == -0x2 (0xfffe) +__uchar 0x2 * 0xff == 0xfe (0xfe) +__longlong 0x2 * 0xffff == -0x2 (0xfffe) +__ulonglong 0x2 * 0xffff == -0x2 (0xfffe) +float 0x2 * 0xffff == -0x2 (0xfffe) +int 0x2 < 0xffff == 0x0 (0x0) +__uint 0x2 < 0xffff == 0x1 (0x1) +char 0x2 < 0xffff == 0x0 (0x0) +__uchar 0x2 < 0xff == 0x1 (0x1) +__longlong 0x2 < 0xffff == 0x0 (0x0) +__ulonglong 0x2 < 0xffff == 0x1 (0x1) +float 0x2 < 0xffff == 0x0 (0x0) +int 0x2 > 0xffff == 0x1 (0x1) +__uint 0x2 > 0xffff == 0x0 (0x0) +char 0x2 > 0xffff == 0x1 (0x1) +__uchar 0x2 > 0xff == 0x0 (0x0) +__longlong 0x2 > 0xffff == 0x1 (0x1) +__ulonglong 0x2 > 0xffff == 0x0 (0x0) +float 0x2 > 0xffff == 0x1 (0x1) +int 0x2 <= 0xffff == 0x0 (0x0) +__uint 0x2 <= 0xffff == 0x1 (0x1) +char 0x2 <= 0xffff == 0x0 (0x0) +__uchar 0x2 <= 0xff == 0x1 (0x1) +__longlong 0x2 <= 0xffff == 0x0 (0x0) +__ulonglong 0x2 <= 0xffff == 0x1 (0x1) +float 0x2 <= 0xffff == 0x0 (0x0) +int 0x2 == 0xffff == 0x0 (0x0) +__uint 0x2 == 0xffff == 0x0 (0x0) +char 0x2 == 0xffff == 0x0 (0x0) +__uchar 0x2 == 0xff == 0x0 (0x0) +__longlong 0x2 == 0xffff == 0x0 (0x0) +__ulonglong 0x2 == 0xffff == 0x0 (0x0) +float 0x2 == 0xffff == 0x0 (0x0) +int 0x2 != 0xffff == 0x1 (0x1) +__uint 0x2 != 0xffff == 0x1 (0x1) +char 0x2 != 0xffff == 0x1 (0x1) +__uchar 0x2 != 0xff == 0x1 (0x1) +__longlong 0x2 != 0xffff == 0x1 (0x1) +__ulonglong 0x2 != 0xffff == 0x1 (0x1) +float 0x2 != 0xffff == 0x1 (0x1) +int 0x2 >= 0xffff == 0x1 (0x1) +__uint 0x2 >= 0xffff == 0x0 (0x0) +char 0x2 >= 0xffff == 0x1 (0x1) +__uchar 0x2 >= 0xff == 0x0 (0x0) +__longlong 0x2 >= 0xffff == 0x1 (0x1) +__ulonglong 0x2 >= 0xffff == 0x0 (0x0) +float 0x2 >= 0xffff == 0x1 (0x1) +int 0x2 / 0xffff == -0x2 (0xfffe) +__uint 0x2 / 0xffff == 0x0 (0x0) +char 0x2 / 0xffff == -0x2 (0xfffe) +__uchar 0x2 / 0xff == 0x0 (0x0) +__longlong 0x2 / 0xffff == -0x2 (0xfffe) +__ulonglong 0x2 / 0xffff == 0x0 (0x0) +float 0x2 / 0xffff == -0x2 (0xfffe) +int 0x2 % 0xffff == 0x0 (0x0) +__uint 0x2 % 0xffff == 0x2 (0x2) +char 0x2 % 0xffff == 0x0 (0x0) +__uchar 0x2 % 0xff == 0x2 (0x2) +__longlong 0x2 % 0xffff == 0x0 (0x0) +__ulonglong 0x2 % 0xffff == 0x2 (0x2) +0x2 * 0x1 == 0x2 +0x2 / 0x1 == 0x2 +0x2 % 0x1 == 0x0 +int 0x2 ^ 0x1 == 0x3 (0x3) +__uint 0x2 ^ 0x1 == 0x3 (0x3) +char 0x2 ^ 0x1 == 0x3 (0x3) +__uchar 0x2 ^ 0x1 == 0x3 (0x3) +__longlong 0x2 ^ 0x1 == 0x3 (0x3) +__ulonglong 0x2 ^ 0x1 == 0x3 (0x3) +int 0x2 && 0x1 == 0x1 (0x1) +__uint 0x2 && 0x1 == 0x1 (0x1) +char 0x2 && 0x1 == 0x1 (0x1) +__uchar 0x2 && 0x1 == 0x1 (0x1) +__longlong 0x2 && 0x1 == 0x1 (0x1) +__ulonglong 0x2 && 0x1 == 0x1 (0x1) +int 0x2 || 0x1 == 0x1 (0x1) +__uint 0x2 || 0x1 == 0x1 (0x1) +char 0x2 || 0x1 == 0x1 (0x1) +__uchar 0x2 || 0x1 == 0x1 (0x1) +__longlong 0x2 || 0x1 == 0x1 (0x1) +__ulonglong 0x2 || 0x1 == 0x1 (0x1) +int 0x2 & 0x1 == 0x0 (0x0) +__uint 0x2 & 0x1 == 0x0 (0x0) +char 0x2 & 0x1 == 0x0 (0x0) +__uchar 0x2 & 0x1 == 0x0 (0x0) +__longlong 0x2 & 0x1 == 0x0 (0x0) +__ulonglong 0x2 & 0x1 == 0x0 (0x0) +int 0x2 | 0x1 == 0x3 (0x3) +__uint 0x2 | 0x1 == 0x3 (0x3) +char 0x2 | 0x1 == 0x3 (0x3) +__uchar 0x2 | 0x1 == 0x3 (0x3) +__longlong 0x2 | 0x1 == 0x3 (0x3) +__ulonglong 0x2 | 0x1 == 0x3 (0x3) +int 0x2 << 0x2 == 0x8 (0x8) +__uint 0x2 << 0x2 == 0x8 (0x8) +char 0x2 << 0x2 == 0x8 (0x8) +__uchar 0x2 << 0x2 == 0x8 (0x8) +__longlong 0x2 << 0x2 == 0x8 (0x8) +__ulonglong 0x2 << 0x2 == 0x8 (0x8) +int 0x2 >> 0x2 == 0x0 (0x0) +__uint 0x2 >> 0x2 == 0x0 (0x0) +char 0x2 >> 0x2 == 0x0 (0x0) +__uchar 0x2 >> 0x2 == 0x0 (0x0) +__longlong 0x2 >> 0x2 == 0x0 (0x0) +__ulonglong 0x2 >> 0x2 == 0x0 (0x0) +int 0x2 + 0x1 == 0x3 (0x3) +__uint 0x2 + 0x1 == 0x3 (0x3) +char 0x2 + 0x1 == 0x3 (0x3) +__uchar 0x2 + 0x1 == 0x3 (0x3) +__longlong 0x2 + 0x1 == 0x3 (0x3) +__ulonglong 0x2 + 0x1 == 0x3 (0x3) +float 0x2 + 0x1 == 0x3 (0x3) +int 0x2 - 0x1 == 0x1 (0x1) +__uint 0x2 - 0x1 == 0x1 (0x1) +char 0x2 - 0x1 == 0x1 (0x1) +__uchar 0x2 - 0x1 == 0x1 (0x1) +__longlong 0x2 - 0x1 == 0x1 (0x1) +__ulonglong 0x2 - 0x1 == 0x1 (0x1) +float 0x2 - 0x1 == 0x1 (0x1) +int 0x2 * 0x1 == 0x2 (0x2) +__uint 0x2 * 0x1 == 0x2 (0x2) +char 0x2 * 0x1 == 0x2 (0x2) +__uchar 0x2 * 0x1 == 0x2 (0x2) +__longlong 0x2 * 0x1 == 0x2 (0x2) +__ulonglong 0x2 * 0x1 == 0x2 (0x2) +float 0x2 * 0x1 == 0x2 (0x2) +int 0x2 < 0x1 == 0x0 (0x0) +__uint 0x2 < 0x1 == 0x0 (0x0) +char 0x2 < 0x1 == 0x0 (0x0) +__uchar 0x2 < 0x1 == 0x0 (0x0) +__longlong 0x2 < 0x1 == 0x0 (0x0) +__ulonglong 0x2 < 0x1 == 0x0 (0x0) +float 0x2 < 0x1 == 0x0 (0x0) +int 0x2 > 0x1 == 0x1 (0x1) +__uint 0x2 > 0x1 == 0x1 (0x1) +char 0x2 > 0x1 == 0x1 (0x1) +__uchar 0x2 > 0x1 == 0x1 (0x1) +__longlong 0x2 > 0x1 == 0x1 (0x1) +__ulonglong 0x2 > 0x1 == 0x1 (0x1) +float 0x2 > 0x1 == 0x1 (0x1) +int 0x2 <= 0x1 == 0x0 (0x0) +__uint 0x2 <= 0x1 == 0x0 (0x0) +char 0x2 <= 0x1 == 0x0 (0x0) +__uchar 0x2 <= 0x1 == 0x0 (0x0) +__longlong 0x2 <= 0x1 == 0x0 (0x0) +__ulonglong 0x2 <= 0x1 == 0x0 (0x0) +float 0x2 <= 0x1 == 0x0 (0x0) +int 0x2 == 0x1 == 0x0 (0x0) +__uint 0x2 == 0x1 == 0x0 (0x0) +char 0x2 == 0x1 == 0x0 (0x0) +__uchar 0x2 == 0x1 == 0x0 (0x0) +__longlong 0x2 == 0x1 == 0x0 (0x0) +__ulonglong 0x2 == 0x1 == 0x0 (0x0) +float 0x2 == 0x1 == 0x0 (0x0) +int 0x2 != 0x1 == 0x1 (0x1) +__uint 0x2 != 0x1 == 0x1 (0x1) +char 0x2 != 0x1 == 0x1 (0x1) +__uchar 0x2 != 0x1 == 0x1 (0x1) +__longlong 0x2 != 0x1 == 0x1 (0x1) +__ulonglong 0x2 != 0x1 == 0x1 (0x1) +float 0x2 != 0x1 == 0x1 (0x1) +int 0x2 >= 0x1 == 0x1 (0x1) +__uint 0x2 >= 0x1 == 0x1 (0x1) +char 0x2 >= 0x1 == 0x1 (0x1) +__uchar 0x2 >= 0x1 == 0x1 (0x1) +__longlong 0x2 >= 0x1 == 0x1 (0x1) +__ulonglong 0x2 >= 0x1 == 0x1 (0x1) +float 0x2 >= 0x1 == 0x1 (0x1) +int 0x2 / 0x1 == 0x2 (0x2) +__uint 0x2 / 0x1 == 0x2 (0x2) +char 0x2 / 0x1 == 0x2 (0x2) +__uchar 0x2 / 0x1 == 0x2 (0x2) +__longlong 0x2 / 0x1 == 0x2 (0x2) +__ulonglong 0x2 / 0x1 == 0x2 (0x2) +float 0x2 / 0x1 == 0x2 (0x2) +int 0x2 % 0x1 == 0x0 (0x0) +__uint 0x2 % 0x1 == 0x0 (0x0) +char 0x2 % 0x1 == 0x0 (0x0) +__uchar 0x2 % 0x1 == 0x0 (0x0) +__longlong 0x2 % 0x1 == 0x0 (0x0) +__ulonglong 0x2 % 0x1 == 0x0 (0x0) +0x2 * 0x2 == 0x4 +0x2 / 0x2 == 0x1 +0x2 % 0x2 == 0x0 +int 0x2 ^ 0x2 == 0x0 (0x0) +__uint 0x2 ^ 0x2 == 0x0 (0x0) +char 0x2 ^ 0x2 == 0x0 (0x0) +__uchar 0x2 ^ 0x2 == 0x0 (0x0) +__longlong 0x2 ^ 0x2 == 0x0 (0x0) +__ulonglong 0x2 ^ 0x2 == 0x0 (0x0) +int 0x2 && 0x2 == 0x1 (0x1) +__uint 0x2 && 0x2 == 0x1 (0x1) +char 0x2 && 0x2 == 0x1 (0x1) +__uchar 0x2 && 0x2 == 0x1 (0x1) +__longlong 0x2 && 0x2 == 0x1 (0x1) +__ulonglong 0x2 && 0x2 == 0x1 (0x1) +int 0x2 || 0x2 == 0x1 (0x1) +__uint 0x2 || 0x2 == 0x1 (0x1) +char 0x2 || 0x2 == 0x1 (0x1) +__uchar 0x2 || 0x2 == 0x1 (0x1) +__longlong 0x2 || 0x2 == 0x1 (0x1) +__ulonglong 0x2 || 0x2 == 0x1 (0x1) +int 0x2 & 0x2 == 0x2 (0x2) +__uint 0x2 & 0x2 == 0x2 (0x2) +char 0x2 & 0x2 == 0x2 (0x2) +__uchar 0x2 & 0x2 == 0x2 (0x2) +__longlong 0x2 & 0x2 == 0x2 (0x2) +__ulonglong 0x2 & 0x2 == 0x2 (0x2) +int 0x2 | 0x2 == 0x2 (0x2) +__uint 0x2 | 0x2 == 0x2 (0x2) +char 0x2 | 0x2 == 0x2 (0x2) +__uchar 0x2 | 0x2 == 0x2 (0x2) +__longlong 0x2 | 0x2 == 0x2 (0x2) +__ulonglong 0x2 | 0x2 == 0x2 (0x2) +int 0x2 << 0x3 == 0x10 (0x10) +__uint 0x2 << 0x3 == 0x10 (0x10) +char 0x2 << 0x3 == 0x10 (0x10) +__uchar 0x2 << 0x3 == 0x10 (0x10) +__longlong 0x2 << 0x3 == 0x10 (0x10) +__ulonglong 0x2 << 0x3 == 0x10 (0x10) +int 0x2 >> 0x3 == 0x0 (0x0) +__uint 0x2 >> 0x3 == 0x0 (0x0) +char 0x2 >> 0x3 == 0x0 (0x0) +__uchar 0x2 >> 0x3 == 0x0 (0x0) +__longlong 0x2 >> 0x3 == 0x0 (0x0) +__ulonglong 0x2 >> 0x3 == 0x0 (0x0) +int 0x2 + 0x2 == 0x4 (0x4) +__uint 0x2 + 0x2 == 0x4 (0x4) +char 0x2 + 0x2 == 0x4 (0x4) +__uchar 0x2 + 0x2 == 0x4 (0x4) +__longlong 0x2 + 0x2 == 0x4 (0x4) +__ulonglong 0x2 + 0x2 == 0x4 (0x4) +float 0x2 + 0x2 == 0x4 (0x4) +int 0x2 - 0x2 == 0x0 (0x0) +__uint 0x2 - 0x2 == 0x0 (0x0) +char 0x2 - 0x2 == 0x0 (0x0) +__uchar 0x2 - 0x2 == 0x0 (0x0) +__longlong 0x2 - 0x2 == 0x0 (0x0) +__ulonglong 0x2 - 0x2 == 0x0 (0x0) +float 0x2 - 0x2 == 0x0 (0x0) +int 0x2 * 0x2 == 0x4 (0x4) +__uint 0x2 * 0x2 == 0x4 (0x4) +char 0x2 * 0x2 == 0x4 (0x4) +__uchar 0x2 * 0x2 == 0x4 (0x4) +__longlong 0x2 * 0x2 == 0x4 (0x4) +__ulonglong 0x2 * 0x2 == 0x4 (0x4) +float 0x2 * 0x2 == 0x4 (0x4) +int 0x2 < 0x2 == 0x0 (0x0) +__uint 0x2 < 0x2 == 0x0 (0x0) +char 0x2 < 0x2 == 0x0 (0x0) +__uchar 0x2 < 0x2 == 0x0 (0x0) +__longlong 0x2 < 0x2 == 0x0 (0x0) +__ulonglong 0x2 < 0x2 == 0x0 (0x0) +float 0x2 < 0x2 == 0x0 (0x0) +int 0x2 > 0x2 == 0x0 (0x0) +__uint 0x2 > 0x2 == 0x0 (0x0) +char 0x2 > 0x2 == 0x0 (0x0) +__uchar 0x2 > 0x2 == 0x0 (0x0) +__longlong 0x2 > 0x2 == 0x0 (0x0) +__ulonglong 0x2 > 0x2 == 0x0 (0x0) +float 0x2 > 0x2 == 0x0 (0x0) +int 0x2 <= 0x2 == 0x1 (0x1) +__uint 0x2 <= 0x2 == 0x1 (0x1) +char 0x2 <= 0x2 == 0x1 (0x1) +__uchar 0x2 <= 0x2 == 0x1 (0x1) +__longlong 0x2 <= 0x2 == 0x1 (0x1) +__ulonglong 0x2 <= 0x2 == 0x1 (0x1) +float 0x2 <= 0x2 == 0x1 (0x1) +int 0x2 == 0x2 == 0x1 (0x1) +__uint 0x2 == 0x2 == 0x1 (0x1) +char 0x2 == 0x2 == 0x1 (0x1) +__uchar 0x2 == 0x2 == 0x1 (0x1) +__longlong 0x2 == 0x2 == 0x1 (0x1) +__ulonglong 0x2 == 0x2 == 0x1 (0x1) +float 0x2 == 0x2 == 0x1 (0x1) +int 0x2 != 0x2 == 0x0 (0x0) +__uint 0x2 != 0x2 == 0x0 (0x0) +char 0x2 != 0x2 == 0x0 (0x0) +__uchar 0x2 != 0x2 == 0x0 (0x0) +__longlong 0x2 != 0x2 == 0x0 (0x0) +__ulonglong 0x2 != 0x2 == 0x0 (0x0) +float 0x2 != 0x2 == 0x0 (0x0) +int 0x2 >= 0x2 == 0x1 (0x1) +__uint 0x2 >= 0x2 == 0x1 (0x1) +char 0x2 >= 0x2 == 0x1 (0x1) +__uchar 0x2 >= 0x2 == 0x1 (0x1) +__longlong 0x2 >= 0x2 == 0x1 (0x1) +__ulonglong 0x2 >= 0x2 == 0x1 (0x1) +float 0x2 >= 0x2 == 0x1 (0x1) +int 0x2 / 0x2 == 0x1 (0x1) +__uint 0x2 / 0x2 == 0x1 (0x1) +char 0x2 / 0x2 == 0x1 (0x1) +__uchar 0x2 / 0x2 == 0x1 (0x1) +__longlong 0x2 / 0x2 == 0x1 (0x1) +__ulonglong 0x2 / 0x2 == 0x1 (0x1) +float 0x2 / 0x2 == 0x1 (0x1) +int 0x2 % 0x2 == 0x0 (0x0) +__uint 0x2 % 0x2 == 0x0 (0x0) +char 0x2 % 0x2 == 0x0 (0x0) +__uchar 0x2 % 0x2 == 0x0 (0x0) +__longlong 0x2 % 0x2 == 0x0 (0x0) +__ulonglong 0x2 % 0x2 == 0x0 (0x0) +0x2 * 0xfffe == -0x4 +0x2 / 0xfffe == -0x1 +0x2 % 0xfffe == 0x0 +int 0x2 ^ 0xfffe == -0x4 (0xfffc) +__uint 0x2 ^ 0xfffe == -0x4 (0xfffc) +char 0x2 ^ 0xfffe == -0x4 (0xfffc) +__uchar 0x2 ^ 0xfe == 0xfc (0xfc) +__longlong 0x2 ^ 0xfffe == -0x4 (0xfffc) +__ulonglong 0x2 ^ 0xfffe == -0x4 (0xfffc) +int 0x2 && 0xfffe == 0x1 (0x1) +__uint 0x2 && 0xfffe == 0x1 (0x1) +char 0x2 && 0xfffe == 0x1 (0x1) +__uchar 0x2 && 0xfe == 0x1 (0x1) +__longlong 0x2 && 0xfffe == 0x1 (0x1) +__ulonglong 0x2 && 0xfffe == 0x1 (0x1) +int 0x2 || 0xfffe == 0x1 (0x1) +__uint 0x2 || 0xfffe == 0x1 (0x1) +char 0x2 || 0xfffe == 0x1 (0x1) +__uchar 0x2 || 0xfe == 0x1 (0x1) +__longlong 0x2 || 0xfffe == 0x1 (0x1) +__ulonglong 0x2 || 0xfffe == 0x1 (0x1) +int 0x2 & 0xfffe == 0x2 (0x2) +__uint 0x2 & 0xfffe == 0x2 (0x2) +char 0x2 & 0xfffe == 0x2 (0x2) +__uchar 0x2 & 0xfe == 0x2 (0x2) +__longlong 0x2 & 0xfffe == 0x2 (0x2) +__ulonglong 0x2 & 0xfffe == 0x2 (0x2) +int 0x2 | 0xfffe == -0x2 (0xfffe) +__uint 0x2 | 0xfffe == -0x2 (0xfffe) +char 0x2 | 0xfffe == -0x2 (0xfffe) +__uchar 0x2 | 0xfe == 0xfe (0xfe) +__longlong 0x2 | 0xfffe == -0x2 (0xfffe) +__ulonglong 0x2 | 0xfffe == -0x2 (0xfffe) +int 0x2 << 0x4 == 0x20 (0x20) +__uint 0x2 << 0x4 == 0x20 (0x20) +char 0x2 << 0x4 == 0x20 (0x20) +__uchar 0x2 << 0x4 == 0x20 (0x20) +__longlong 0x2 << 0x4 == 0x20 (0x20) +__ulonglong 0x2 << 0x4 == 0x20 (0x20) +int 0x2 >> 0x4 == 0x0 (0x0) +__uint 0x2 >> 0x4 == 0x0 (0x0) +char 0x2 >> 0x4 == 0x0 (0x0) +__uchar 0x2 >> 0x4 == 0x0 (0x0) +__longlong 0x2 >> 0x4 == 0x0 (0x0) +__ulonglong 0x2 >> 0x4 == 0x0 (0x0) +int 0x2 + 0xfffe == 0x0 (0x0) +__uint 0x2 + 0xfffe == 0x0 (0x0) +char 0x2 + 0xfffe == 0x0 (0x0) +__uchar 0x2 + 0xfe == 0x0 (0x0) +__longlong 0x2 + 0xfffe == 0x0 (0x0) +__ulonglong 0x2 + 0xfffe == 0x0 (0x0) +float 0x2 + 0xfffe == 0x0 (0x0) +int 0x2 - 0xfffe == 0x4 (0x4) +__uint 0x2 - 0xfffe == 0x4 (0x4) +char 0x2 - 0xfffe == 0x4 (0x4) +__uchar 0x2 - 0xfe == 0x4 (0x4) +__longlong 0x2 - 0xfffe == 0x4 (0x4) +__ulonglong 0x2 - 0xfffe == 0x4 (0x4) +float 0x2 - 0xfffe == 0x4 (0x4) +int 0x2 * 0xfffe == -0x4 (0xfffc) +__uint 0x2 * 0xfffe == -0x4 (0xfffc) +char 0x2 * 0xfffe == -0x4 (0xfffc) +__uchar 0x2 * 0xfe == 0xfc (0xfc) +__longlong 0x2 * 0xfffe == -0x4 (0xfffc) +__ulonglong 0x2 * 0xfffe == -0x4 (0xfffc) +float 0x2 * 0xfffe == -0x4 (0xfffc) +int 0x2 < 0xfffe == 0x0 (0x0) +__uint 0x2 < 0xfffe == 0x1 (0x1) +char 0x2 < 0xfffe == 0x0 (0x0) +__uchar 0x2 < 0xfe == 0x1 (0x1) +__longlong 0x2 < 0xfffe == 0x0 (0x0) +__ulonglong 0x2 < 0xfffe == 0x1 (0x1) +float 0x2 < 0xfffe == 0x0 (0x0) +int 0x2 > 0xfffe == 0x1 (0x1) +__uint 0x2 > 0xfffe == 0x0 (0x0) +char 0x2 > 0xfffe == 0x1 (0x1) +__uchar 0x2 > 0xfe == 0x0 (0x0) +__longlong 0x2 > 0xfffe == 0x1 (0x1) +__ulonglong 0x2 > 0xfffe == 0x0 (0x0) +float 0x2 > 0xfffe == 0x1 (0x1) +int 0x2 <= 0xfffe == 0x0 (0x0) +__uint 0x2 <= 0xfffe == 0x1 (0x1) +char 0x2 <= 0xfffe == 0x0 (0x0) +__uchar 0x2 <= 0xfe == 0x1 (0x1) +__longlong 0x2 <= 0xfffe == 0x0 (0x0) +__ulonglong 0x2 <= 0xfffe == 0x1 (0x1) +float 0x2 <= 0xfffe == 0x0 (0x0) +int 0x2 == 0xfffe == 0x0 (0x0) +__uint 0x2 == 0xfffe == 0x0 (0x0) +char 0x2 == 0xfffe == 0x0 (0x0) +__uchar 0x2 == 0xfe == 0x0 (0x0) +__longlong 0x2 == 0xfffe == 0x0 (0x0) +__ulonglong 0x2 == 0xfffe == 0x0 (0x0) +float 0x2 == 0xfffe == 0x0 (0x0) +int 0x2 != 0xfffe == 0x1 (0x1) +__uint 0x2 != 0xfffe == 0x1 (0x1) +char 0x2 != 0xfffe == 0x1 (0x1) +__uchar 0x2 != 0xfe == 0x1 (0x1) +__longlong 0x2 != 0xfffe == 0x1 (0x1) +__ulonglong 0x2 != 0xfffe == 0x1 (0x1) +float 0x2 != 0xfffe == 0x1 (0x1) +int 0x2 >= 0xfffe == 0x1 (0x1) +__uint 0x2 >= 0xfffe == 0x0 (0x0) +char 0x2 >= 0xfffe == 0x1 (0x1) +__uchar 0x2 >= 0xfe == 0x0 (0x0) +__longlong 0x2 >= 0xfffe == 0x1 (0x1) +__ulonglong 0x2 >= 0xfffe == 0x0 (0x0) +float 0x2 >= 0xfffe == 0x1 (0x1) +int 0x2 / 0xfffe == -0x1 (0xffff) +__uint 0x2 / 0xfffe == 0x0 (0x0) +char 0x2 / 0xfffe == -0x1 (0xffff) +__uchar 0x2 / 0xfe == 0x0 (0x0) +__longlong 0x2 / 0xfffe == -0x1 (0xffff) +__ulonglong 0x2 / 0xfffe == 0x0 (0x0) +float 0x2 / 0xfffe == -0x1 (0xffff) +int 0x2 % 0xfffe == 0x0 (0x0) +__uint 0x2 % 0xfffe == 0x2 (0x2) +char 0x2 % 0xfffe == 0x0 (0x0) +__uchar 0x2 % 0xfe == 0x2 (0x2) +__longlong 0x2 % 0xfffe == 0x0 (0x0) +__ulonglong 0x2 % 0xfffe == 0x2 (0x2) +0x2 * 0x4 == 0x8 +0x2 / 0x4 == 0x0 +0x2 % 0x4 == 0x2 +int 0x2 ^ 0x4 == 0x6 (0x6) +__uint 0x2 ^ 0x4 == 0x6 (0x6) +char 0x2 ^ 0x4 == 0x6 (0x6) +__uchar 0x2 ^ 0x4 == 0x6 (0x6) +__longlong 0x2 ^ 0x4 == 0x6 (0x6) +__ulonglong 0x2 ^ 0x4 == 0x6 (0x6) +int 0x2 && 0x4 == 0x1 (0x1) +__uint 0x2 && 0x4 == 0x1 (0x1) +char 0x2 && 0x4 == 0x1 (0x1) +__uchar 0x2 && 0x4 == 0x1 (0x1) +__longlong 0x2 && 0x4 == 0x1 (0x1) +__ulonglong 0x2 && 0x4 == 0x1 (0x1) +int 0x2 || 0x4 == 0x1 (0x1) +__uint 0x2 || 0x4 == 0x1 (0x1) +char 0x2 || 0x4 == 0x1 (0x1) +__uchar 0x2 || 0x4 == 0x1 (0x1) +__longlong 0x2 || 0x4 == 0x1 (0x1) +__ulonglong 0x2 || 0x4 == 0x1 (0x1) +int 0x2 & 0x4 == 0x0 (0x0) +__uint 0x2 & 0x4 == 0x0 (0x0) +char 0x2 & 0x4 == 0x0 (0x0) +__uchar 0x2 & 0x4 == 0x0 (0x0) +__longlong 0x2 & 0x4 == 0x0 (0x0) +__ulonglong 0x2 & 0x4 == 0x0 (0x0) +int 0x2 | 0x4 == 0x6 (0x6) +__uint 0x2 | 0x4 == 0x6 (0x6) +char 0x2 | 0x4 == 0x6 (0x6) +__uchar 0x2 | 0x4 == 0x6 (0x6) +__longlong 0x2 | 0x4 == 0x6 (0x6) +__ulonglong 0x2 | 0x4 == 0x6 (0x6) +int 0x2 << 0x5 == 0x40 (0x40) +__uint 0x2 << 0x5 == 0x40 (0x40) +char 0x2 << 0x5 == 0x40 (0x40) +__uchar 0x2 << 0x5 == 0x40 (0x40) +__longlong 0x2 << 0x5 == 0x40 (0x40) +__ulonglong 0x2 << 0x5 == 0x40 (0x40) +int 0x2 >> 0x5 == 0x0 (0x0) +__uint 0x2 >> 0x5 == 0x0 (0x0) +char 0x2 >> 0x5 == 0x0 (0x0) +__uchar 0x2 >> 0x5 == 0x0 (0x0) +__longlong 0x2 >> 0x5 == 0x0 (0x0) +__ulonglong 0x2 >> 0x5 == 0x0 (0x0) +int 0x2 + 0x4 == 0x6 (0x6) +__uint 0x2 + 0x4 == 0x6 (0x6) +char 0x2 + 0x4 == 0x6 (0x6) +__uchar 0x2 + 0x4 == 0x6 (0x6) +__longlong 0x2 + 0x4 == 0x6 (0x6) +__ulonglong 0x2 + 0x4 == 0x6 (0x6) +float 0x2 + 0x4 == 0x6 (0x6) +int 0x2 - 0x4 == -0x2 (0xfffe) +__uint 0x2 - 0x4 == -0x2 (0xfffe) +char 0x2 - 0x4 == -0x2 (0xfffe) +__uchar 0x2 - 0x4 == 0xfe (0xfe) +__longlong 0x2 - 0x4 == -0x2 (0xfffe) +__ulonglong 0x2 - 0x4 == -0x2 (0xfffe) +float 0x2 - 0x4 == -0x2 (0xfffe) +int 0x2 * 0x4 == 0x8 (0x8) +__uint 0x2 * 0x4 == 0x8 (0x8) +char 0x2 * 0x4 == 0x8 (0x8) +__uchar 0x2 * 0x4 == 0x8 (0x8) +__longlong 0x2 * 0x4 == 0x8 (0x8) +__ulonglong 0x2 * 0x4 == 0x8 (0x8) +float 0x2 * 0x4 == 0x8 (0x8) +int 0x2 < 0x4 == 0x1 (0x1) +__uint 0x2 < 0x4 == 0x1 (0x1) +char 0x2 < 0x4 == 0x1 (0x1) +__uchar 0x2 < 0x4 == 0x1 (0x1) +__longlong 0x2 < 0x4 == 0x1 (0x1) +__ulonglong 0x2 < 0x4 == 0x1 (0x1) +float 0x2 < 0x4 == 0x1 (0x1) +int 0x2 > 0x4 == 0x0 (0x0) +__uint 0x2 > 0x4 == 0x0 (0x0) +char 0x2 > 0x4 == 0x0 (0x0) +__uchar 0x2 > 0x4 == 0x0 (0x0) +__longlong 0x2 > 0x4 == 0x0 (0x0) +__ulonglong 0x2 > 0x4 == 0x0 (0x0) +float 0x2 > 0x4 == 0x0 (0x0) +int 0x2 <= 0x4 == 0x1 (0x1) +__uint 0x2 <= 0x4 == 0x1 (0x1) +char 0x2 <= 0x4 == 0x1 (0x1) +__uchar 0x2 <= 0x4 == 0x1 (0x1) +__longlong 0x2 <= 0x4 == 0x1 (0x1) +__ulonglong 0x2 <= 0x4 == 0x1 (0x1) +float 0x2 <= 0x4 == 0x1 (0x1) +int 0x2 == 0x4 == 0x0 (0x0) +__uint 0x2 == 0x4 == 0x0 (0x0) +char 0x2 == 0x4 == 0x0 (0x0) +__uchar 0x2 == 0x4 == 0x0 (0x0) +__longlong 0x2 == 0x4 == 0x0 (0x0) +__ulonglong 0x2 == 0x4 == 0x0 (0x0) +float 0x2 == 0x4 == 0x0 (0x0) +int 0x2 != 0x4 == 0x1 (0x1) +__uint 0x2 != 0x4 == 0x1 (0x1) +char 0x2 != 0x4 == 0x1 (0x1) +__uchar 0x2 != 0x4 == 0x1 (0x1) +__longlong 0x2 != 0x4 == 0x1 (0x1) +__ulonglong 0x2 != 0x4 == 0x1 (0x1) +float 0x2 != 0x4 == 0x1 (0x1) +int 0x2 >= 0x4 == 0x0 (0x0) +__uint 0x2 >= 0x4 == 0x0 (0x0) +char 0x2 >= 0x4 == 0x0 (0x0) +__uchar 0x2 >= 0x4 == 0x0 (0x0) +__longlong 0x2 >= 0x4 == 0x0 (0x0) +__ulonglong 0x2 >= 0x4 == 0x0 (0x0) +float 0x2 >= 0x4 == 0x0 (0x0) +int 0x2 / 0x4 == 0x0 (0x0) +__uint 0x2 / 0x4 == 0x0 (0x0) +char 0x2 / 0x4 == 0x0 (0x0) +__uchar 0x2 / 0x4 == 0x0 (0x0) +__longlong 0x2 / 0x4 == 0x0 (0x0) +__ulonglong 0x2 / 0x4 == 0x0 (0x0) +float 0x2 / 0x4 == 0x0 (0x0) +int 0x2 % 0x4 == 0x2 (0x2) +__uint 0x2 % 0x4 == 0x2 (0x2) +char 0x2 % 0x4 == 0x2 (0x2) +__uchar 0x2 % 0x4 == 0x2 (0x2) +__longlong 0x2 % 0x4 == 0x2 (0x2) +__ulonglong 0x2 % 0x4 == 0x2 (0x2) +0x2 * 0xfffc == -0x8 +0x2 / 0xfffc == 0x0 +0x2 % 0xfffc == 0x2 +int 0x2 ^ 0xfffc == -0x2 (0xfffe) +__uint 0x2 ^ 0xfffc == -0x2 (0xfffe) +char 0x2 ^ 0xfffc == -0x2 (0xfffe) +__uchar 0x2 ^ 0xfc == 0xfe (0xfe) +__longlong 0x2 ^ 0xfffc == -0x2 (0xfffe) +__ulonglong 0x2 ^ 0xfffc == -0x2 (0xfffe) +int 0x2 && 0xfffc == 0x1 (0x1) +__uint 0x2 && 0xfffc == 0x1 (0x1) +char 0x2 && 0xfffc == 0x1 (0x1) +__uchar 0x2 && 0xfc == 0x1 (0x1) +__longlong 0x2 && 0xfffc == 0x1 (0x1) +__ulonglong 0x2 && 0xfffc == 0x1 (0x1) +int 0x2 || 0xfffc == 0x1 (0x1) +__uint 0x2 || 0xfffc == 0x1 (0x1) +char 0x2 || 0xfffc == 0x1 (0x1) +__uchar 0x2 || 0xfc == 0x1 (0x1) +__longlong 0x2 || 0xfffc == 0x1 (0x1) +__ulonglong 0x2 || 0xfffc == 0x1 (0x1) +int 0x2 & 0xfffc == 0x0 (0x0) +__uint 0x2 & 0xfffc == 0x0 (0x0) +char 0x2 & 0xfffc == 0x0 (0x0) +__uchar 0x2 & 0xfc == 0x0 (0x0) +__longlong 0x2 & 0xfffc == 0x0 (0x0) +__ulonglong 0x2 & 0xfffc == 0x0 (0x0) +int 0x2 | 0xfffc == -0x2 (0xfffe) +__uint 0x2 | 0xfffc == -0x2 (0xfffe) +char 0x2 | 0xfffc == -0x2 (0xfffe) +__uchar 0x2 | 0xfc == 0xfe (0xfe) +__longlong 0x2 | 0xfffc == -0x2 (0xfffe) +__ulonglong 0x2 | 0xfffc == -0x2 (0xfffe) +int 0x2 << 0x6 == 0x80 (0x80) +__uint 0x2 << 0x6 == 0x80 (0x80) +char 0x2 << 0x6 == -0x80 (0xff80) +__uchar 0x2 << 0x6 == 0x80 (0x80) +__longlong 0x2 << 0x6 == 0x80 (0x80) +__ulonglong 0x2 << 0x6 == 0x80 (0x80) +int 0x2 >> 0x6 == 0x0 (0x0) +__uint 0x2 >> 0x6 == 0x0 (0x0) +char 0x2 >> 0x6 == 0x0 (0x0) +__uchar 0x2 >> 0x6 == 0x0 (0x0) +__longlong 0x2 >> 0x6 == 0x0 (0x0) +__ulonglong 0x2 >> 0x6 == 0x0 (0x0) +int 0x2 + 0xfffc == -0x2 (0xfffe) +__uint 0x2 + 0xfffc == -0x2 (0xfffe) +char 0x2 + 0xfffc == -0x2 (0xfffe) +__uchar 0x2 + 0xfc == 0xfe (0xfe) +__longlong 0x2 + 0xfffc == -0x2 (0xfffe) +__ulonglong 0x2 + 0xfffc == -0x2 (0xfffe) +float 0x2 + 0xfffc == -0x2 (0xfffe) +int 0x2 - 0xfffc == 0x6 (0x6) +__uint 0x2 - 0xfffc == 0x6 (0x6) +char 0x2 - 0xfffc == 0x6 (0x6) +__uchar 0x2 - 0xfc == 0x6 (0x6) +__longlong 0x2 - 0xfffc == 0x6 (0x6) +__ulonglong 0x2 - 0xfffc == 0x6 (0x6) +float 0x2 - 0xfffc == 0x6 (0x6) +int 0x2 * 0xfffc == -0x8 (0xfff8) +__uint 0x2 * 0xfffc == -0x8 (0xfff8) +char 0x2 * 0xfffc == -0x8 (0xfff8) +__uchar 0x2 * 0xfc == 0xf8 (0xf8) +__longlong 0x2 * 0xfffc == -0x8 (0xfff8) +__ulonglong 0x2 * 0xfffc == -0x8 (0xfff8) +float 0x2 * 0xfffc == -0x8 (0xfff8) +int 0x2 < 0xfffc == 0x0 (0x0) +__uint 0x2 < 0xfffc == 0x1 (0x1) +char 0x2 < 0xfffc == 0x0 (0x0) +__uchar 0x2 < 0xfc == 0x1 (0x1) +__longlong 0x2 < 0xfffc == 0x0 (0x0) +__ulonglong 0x2 < 0xfffc == 0x1 (0x1) +float 0x2 < 0xfffc == 0x0 (0x0) +int 0x2 > 0xfffc == 0x1 (0x1) +__uint 0x2 > 0xfffc == 0x0 (0x0) +char 0x2 > 0xfffc == 0x1 (0x1) +__uchar 0x2 > 0xfc == 0x0 (0x0) +__longlong 0x2 > 0xfffc == 0x1 (0x1) +__ulonglong 0x2 > 0xfffc == 0x0 (0x0) +float 0x2 > 0xfffc == 0x1 (0x1) +int 0x2 <= 0xfffc == 0x0 (0x0) +__uint 0x2 <= 0xfffc == 0x1 (0x1) +char 0x2 <= 0xfffc == 0x0 (0x0) +__uchar 0x2 <= 0xfc == 0x1 (0x1) +__longlong 0x2 <= 0xfffc == 0x0 (0x0) +__ulonglong 0x2 <= 0xfffc == 0x1 (0x1) +float 0x2 <= 0xfffc == 0x0 (0x0) +int 0x2 == 0xfffc == 0x0 (0x0) +__uint 0x2 == 0xfffc == 0x0 (0x0) +char 0x2 == 0xfffc == 0x0 (0x0) +__uchar 0x2 == 0xfc == 0x0 (0x0) +__longlong 0x2 == 0xfffc == 0x0 (0x0) +__ulonglong 0x2 == 0xfffc == 0x0 (0x0) +float 0x2 == 0xfffc == 0x0 (0x0) +int 0x2 != 0xfffc == 0x1 (0x1) +__uint 0x2 != 0xfffc == 0x1 (0x1) +char 0x2 != 0xfffc == 0x1 (0x1) +__uchar 0x2 != 0xfc == 0x1 (0x1) +__longlong 0x2 != 0xfffc == 0x1 (0x1) +__ulonglong 0x2 != 0xfffc == 0x1 (0x1) +float 0x2 != 0xfffc == 0x1 (0x1) +int 0x2 >= 0xfffc == 0x1 (0x1) +__uint 0x2 >= 0xfffc == 0x0 (0x0) +char 0x2 >= 0xfffc == 0x1 (0x1) +__uchar 0x2 >= 0xfc == 0x0 (0x0) +__longlong 0x2 >= 0xfffc == 0x1 (0x1) +__ulonglong 0x2 >= 0xfffc == 0x0 (0x0) +float 0x2 >= 0xfffc == 0x1 (0x1) +int 0x2 / 0xfffc == 0x0 (0x0) +__uint 0x2 / 0xfffc == 0x0 (0x0) +char 0x2 / 0xfffc == 0x0 (0x0) +__uchar 0x2 / 0xfc == 0x0 (0x0) +__longlong 0x2 / 0xfffc == 0x0 (0x0) +__ulonglong 0x2 / 0xfffc == 0x0 (0x0) +float 0x2 / 0xfffc == 0x0 (0x0) +int 0x2 % 0xfffc == 0x2 (0x2) +__uint 0x2 % 0xfffc == 0x2 (0x2) +char 0x2 % 0xfffc == 0x2 (0x2) +__uchar 0x2 % 0xfc == 0x2 (0x2) +__longlong 0x2 % 0xfffc == 0x2 (0x2) +__ulonglong 0x2 % 0xfffc == 0x2 (0x2) +0x2 * 0xa == 0x14 +0x2 / 0xa == 0x0 +0x2 % 0xa == 0x2 +int 0x2 ^ 0xa == 0x8 (0x8) +__uint 0x2 ^ 0xa == 0x8 (0x8) +char 0x2 ^ 0xa == 0x8 (0x8) +__uchar 0x2 ^ 0xa == 0x8 (0x8) +__longlong 0x2 ^ 0xa == 0x8 (0x8) +__ulonglong 0x2 ^ 0xa == 0x8 (0x8) +int 0x2 && 0xa == 0x1 (0x1) +__uint 0x2 && 0xa == 0x1 (0x1) +char 0x2 && 0xa == 0x1 (0x1) +__uchar 0x2 && 0xa == 0x1 (0x1) +__longlong 0x2 && 0xa == 0x1 (0x1) +__ulonglong 0x2 && 0xa == 0x1 (0x1) +int 0x2 || 0xa == 0x1 (0x1) +__uint 0x2 || 0xa == 0x1 (0x1) +char 0x2 || 0xa == 0x1 (0x1) +__uchar 0x2 || 0xa == 0x1 (0x1) +__longlong 0x2 || 0xa == 0x1 (0x1) +__ulonglong 0x2 || 0xa == 0x1 (0x1) +int 0x2 & 0xa == 0x2 (0x2) +__uint 0x2 & 0xa == 0x2 (0x2) +char 0x2 & 0xa == 0x2 (0x2) +__uchar 0x2 & 0xa == 0x2 (0x2) +__longlong 0x2 & 0xa == 0x2 (0x2) +__ulonglong 0x2 & 0xa == 0x2 (0x2) +int 0x2 | 0xa == 0xa (0xa) +__uint 0x2 | 0xa == 0xa (0xa) +char 0x2 | 0xa == 0xa (0xa) +__uchar 0x2 | 0xa == 0xa (0xa) +__longlong 0x2 | 0xa == 0xa (0xa) +__ulonglong 0x2 | 0xa == 0xa (0xa) +int 0x2 << 0x7 == 0x100 (0x100) +__uint 0x2 << 0x7 == 0x100 (0x100) +char 0x2 << 0x7 == 0x0 (0x0) +__uchar 0x2 << 0x7 == 0x0 (0x0) +__longlong 0x2 << 0x7 == 0x100 (0x100) +__ulonglong 0x2 << 0x7 == 0x100 (0x100) +int 0x2 >> 0x7 == 0x0 (0x0) +__uint 0x2 >> 0x7 == 0x0 (0x0) +char 0x2 >> 0x7 == 0x0 (0x0) +__uchar 0x2 >> 0x7 == 0x0 (0x0) +__longlong 0x2 >> 0x7 == 0x0 (0x0) +__ulonglong 0x2 >> 0x7 == 0x0 (0x0) +int 0x2 + 0xa == 0xc (0xc) +__uint 0x2 + 0xa == 0xc (0xc) +char 0x2 + 0xa == 0xc (0xc) +__uchar 0x2 + 0xa == 0xc (0xc) +__longlong 0x2 + 0xa == 0xc (0xc) +__ulonglong 0x2 + 0xa == 0xc (0xc) +float 0x2 + 0xa == 0xc (0xc) +int 0x2 - 0xa == -0x8 (0xfff8) +__uint 0x2 - 0xa == -0x8 (0xfff8) +char 0x2 - 0xa == -0x8 (0xfff8) +__uchar 0x2 - 0xa == 0xf8 (0xf8) +__longlong 0x2 - 0xa == -0x8 (0xfff8) +__ulonglong 0x2 - 0xa == -0x8 (0xfff8) +float 0x2 - 0xa == -0x8 (0xfff8) +int 0x2 * 0xa == 0x14 (0x14) +__uint 0x2 * 0xa == 0x14 (0x14) +char 0x2 * 0xa == 0x14 (0x14) +__uchar 0x2 * 0xa == 0x14 (0x14) +__longlong 0x2 * 0xa == 0x14 (0x14) +__ulonglong 0x2 * 0xa == 0x14 (0x14) +float 0x2 * 0xa == 0x14 (0x14) +int 0x2 < 0xa == 0x1 (0x1) +__uint 0x2 < 0xa == 0x1 (0x1) +char 0x2 < 0xa == 0x1 (0x1) +__uchar 0x2 < 0xa == 0x1 (0x1) +__longlong 0x2 < 0xa == 0x1 (0x1) +__ulonglong 0x2 < 0xa == 0x1 (0x1) +float 0x2 < 0xa == 0x1 (0x1) +int 0x2 > 0xa == 0x0 (0x0) +__uint 0x2 > 0xa == 0x0 (0x0) +char 0x2 > 0xa == 0x0 (0x0) +__uchar 0x2 > 0xa == 0x0 (0x0) +__longlong 0x2 > 0xa == 0x0 (0x0) +__ulonglong 0x2 > 0xa == 0x0 (0x0) +float 0x2 > 0xa == 0x0 (0x0) +int 0x2 <= 0xa == 0x1 (0x1) +__uint 0x2 <= 0xa == 0x1 (0x1) +char 0x2 <= 0xa == 0x1 (0x1) +__uchar 0x2 <= 0xa == 0x1 (0x1) +__longlong 0x2 <= 0xa == 0x1 (0x1) +__ulonglong 0x2 <= 0xa == 0x1 (0x1) +float 0x2 <= 0xa == 0x1 (0x1) +int 0x2 == 0xa == 0x0 (0x0) +__uint 0x2 == 0xa == 0x0 (0x0) +char 0x2 == 0xa == 0x0 (0x0) +__uchar 0x2 == 0xa == 0x0 (0x0) +__longlong 0x2 == 0xa == 0x0 (0x0) +__ulonglong 0x2 == 0xa == 0x0 (0x0) +float 0x2 == 0xa == 0x0 (0x0) +int 0x2 != 0xa == 0x1 (0x1) +__uint 0x2 != 0xa == 0x1 (0x1) +char 0x2 != 0xa == 0x1 (0x1) +__uchar 0x2 != 0xa == 0x1 (0x1) +__longlong 0x2 != 0xa == 0x1 (0x1) +__ulonglong 0x2 != 0xa == 0x1 (0x1) +float 0x2 != 0xa == 0x1 (0x1) +int 0x2 >= 0xa == 0x0 (0x0) +__uint 0x2 >= 0xa == 0x0 (0x0) +char 0x2 >= 0xa == 0x0 (0x0) +__uchar 0x2 >= 0xa == 0x0 (0x0) +__longlong 0x2 >= 0xa == 0x0 (0x0) +__ulonglong 0x2 >= 0xa == 0x0 (0x0) +float 0x2 >= 0xa == 0x0 (0x0) +int 0x2 / 0xa == 0x0 (0x0) +__uint 0x2 / 0xa == 0x0 (0x0) +char 0x2 / 0xa == 0x0 (0x0) +__uchar 0x2 / 0xa == 0x0 (0x0) +__longlong 0x2 / 0xa == 0x0 (0x0) +__ulonglong 0x2 / 0xa == 0x0 (0x0) +float 0x2 / 0xa == 0x0 (0x0) +int 0x2 % 0xa == 0x2 (0x2) +__uint 0x2 % 0xa == 0x2 (0x2) +char 0x2 % 0xa == 0x2 (0x2) +__uchar 0x2 % 0xa == 0x2 (0x2) +__longlong 0x2 % 0xa == 0x2 (0x2) +__ulonglong 0x2 % 0xa == 0x2 (0x2) +0x2 * 0xfff6 == -0x14 +0x2 / 0xfff6 == 0x0 +0x2 % 0xfff6 == 0x2 +int 0x2 ^ 0xfff6 == -0xc (0xfff4) +__uint 0x2 ^ 0xfff6 == -0xc (0xfff4) +char 0x2 ^ 0xfff6 == -0xc (0xfff4) +__uchar 0x2 ^ 0xf6 == 0xf4 (0xf4) +__longlong 0x2 ^ 0xfff6 == -0xc (0xfff4) +__ulonglong 0x2 ^ 0xfff6 == -0xc (0xfff4) +int 0x2 && 0xfff6 == 0x1 (0x1) +__uint 0x2 && 0xfff6 == 0x1 (0x1) +char 0x2 && 0xfff6 == 0x1 (0x1) +__uchar 0x2 && 0xf6 == 0x1 (0x1) +__longlong 0x2 && 0xfff6 == 0x1 (0x1) +__ulonglong 0x2 && 0xfff6 == 0x1 (0x1) +int 0x2 || 0xfff6 == 0x1 (0x1) +__uint 0x2 || 0xfff6 == 0x1 (0x1) +char 0x2 || 0xfff6 == 0x1 (0x1) +__uchar 0x2 || 0xf6 == 0x1 (0x1) +__longlong 0x2 || 0xfff6 == 0x1 (0x1) +__ulonglong 0x2 || 0xfff6 == 0x1 (0x1) +int 0x2 & 0xfff6 == 0x2 (0x2) +__uint 0x2 & 0xfff6 == 0x2 (0x2) +char 0x2 & 0xfff6 == 0x2 (0x2) +__uchar 0x2 & 0xf6 == 0x2 (0x2) +__longlong 0x2 & 0xfff6 == 0x2 (0x2) +__ulonglong 0x2 & 0xfff6 == 0x2 (0x2) +int 0x2 | 0xfff6 == -0xa (0xfff6) +__uint 0x2 | 0xfff6 == -0xa (0xfff6) +char 0x2 | 0xfff6 == -0xa (0xfff6) +__uchar 0x2 | 0xf6 == 0xf6 (0xf6) +__longlong 0x2 | 0xfff6 == -0xa (0xfff6) +__ulonglong 0x2 | 0xfff6 == -0xa (0xfff6) +int 0x2 << 0x8 == 0x200 (0x200) +__uint 0x2 << 0x8 == 0x200 (0x200) +char 0x2 << 0x8 == 0x0 (0x0) +__uchar 0x2 << 0x8 == 0x0 (0x0) +__longlong 0x2 << 0x8 == 0x200 (0x200) +__ulonglong 0x2 << 0x8 == 0x200 (0x200) +int 0x2 >> 0x8 == 0x0 (0x0) +__uint 0x2 >> 0x8 == 0x0 (0x0) +char 0x2 >> 0x8 == 0x0 (0x0) +__uchar 0x2 >> 0x8 == 0x0 (0x0) +__longlong 0x2 >> 0x8 == 0x0 (0x0) +__ulonglong 0x2 >> 0x8 == 0x0 (0x0) +int 0x2 + 0xfff6 == -0x8 (0xfff8) +__uint 0x2 + 0xfff6 == -0x8 (0xfff8) +char 0x2 + 0xfff6 == -0x8 (0xfff8) +__uchar 0x2 + 0xf6 == 0xf8 (0xf8) +__longlong 0x2 + 0xfff6 == -0x8 (0xfff8) +__ulonglong 0x2 + 0xfff6 == -0x8 (0xfff8) +float 0x2 + 0xfff6 == -0x8 (0xfff8) +int 0x2 - 0xfff6 == 0xc (0xc) +__uint 0x2 - 0xfff6 == 0xc (0xc) +char 0x2 - 0xfff6 == 0xc (0xc) +__uchar 0x2 - 0xf6 == 0xc (0xc) +__longlong 0x2 - 0xfff6 == 0xc (0xc) +__ulonglong 0x2 - 0xfff6 == 0xc (0xc) +float 0x2 - 0xfff6 == 0xc (0xc) +int 0x2 * 0xfff6 == -0x14 (0xffec) +__uint 0x2 * 0xfff6 == -0x14 (0xffec) +char 0x2 * 0xfff6 == -0x14 (0xffec) +__uchar 0x2 * 0xf6 == 0xec (0xec) +__longlong 0x2 * 0xfff6 == -0x14 (0xffec) +__ulonglong 0x2 * 0xfff6 == -0x14 (0xffec) +float 0x2 * 0xfff6 == -0x14 (0xffec) +int 0x2 < 0xfff6 == 0x0 (0x0) +__uint 0x2 < 0xfff6 == 0x1 (0x1) +char 0x2 < 0xfff6 == 0x0 (0x0) +__uchar 0x2 < 0xf6 == 0x1 (0x1) +__longlong 0x2 < 0xfff6 == 0x0 (0x0) +__ulonglong 0x2 < 0xfff6 == 0x1 (0x1) +float 0x2 < 0xfff6 == 0x0 (0x0) +int 0x2 > 0xfff6 == 0x1 (0x1) +__uint 0x2 > 0xfff6 == 0x0 (0x0) +char 0x2 > 0xfff6 == 0x1 (0x1) +__uchar 0x2 > 0xf6 == 0x0 (0x0) +__longlong 0x2 > 0xfff6 == 0x1 (0x1) +__ulonglong 0x2 > 0xfff6 == 0x0 (0x0) +float 0x2 > 0xfff6 == 0x1 (0x1) +int 0x2 <= 0xfff6 == 0x0 (0x0) +__uint 0x2 <= 0xfff6 == 0x1 (0x1) +char 0x2 <= 0xfff6 == 0x0 (0x0) +__uchar 0x2 <= 0xf6 == 0x1 (0x1) +__longlong 0x2 <= 0xfff6 == 0x0 (0x0) +__ulonglong 0x2 <= 0xfff6 == 0x1 (0x1) +float 0x2 <= 0xfff6 == 0x0 (0x0) +int 0x2 == 0xfff6 == 0x0 (0x0) +__uint 0x2 == 0xfff6 == 0x0 (0x0) +char 0x2 == 0xfff6 == 0x0 (0x0) +__uchar 0x2 == 0xf6 == 0x0 (0x0) +__longlong 0x2 == 0xfff6 == 0x0 (0x0) +__ulonglong 0x2 == 0xfff6 == 0x0 (0x0) +float 0x2 == 0xfff6 == 0x0 (0x0) +int 0x2 != 0xfff6 == 0x1 (0x1) +__uint 0x2 != 0xfff6 == 0x1 (0x1) +char 0x2 != 0xfff6 == 0x1 (0x1) +__uchar 0x2 != 0xf6 == 0x1 (0x1) +__longlong 0x2 != 0xfff6 == 0x1 (0x1) +__ulonglong 0x2 != 0xfff6 == 0x1 (0x1) +float 0x2 != 0xfff6 == 0x1 (0x1) +int 0x2 >= 0xfff6 == 0x1 (0x1) +__uint 0x2 >= 0xfff6 == 0x0 (0x0) +char 0x2 >= 0xfff6 == 0x1 (0x1) +__uchar 0x2 >= 0xf6 == 0x0 (0x0) +__longlong 0x2 >= 0xfff6 == 0x1 (0x1) +__ulonglong 0x2 >= 0xfff6 == 0x0 (0x0) +float 0x2 >= 0xfff6 == 0x1 (0x1) +int 0x2 / 0xfff6 == 0x0 (0x0) +__uint 0x2 / 0xfff6 == 0x0 (0x0) +char 0x2 / 0xfff6 == 0x0 (0x0) +__uchar 0x2 / 0xf6 == 0x0 (0x0) +__longlong 0x2 / 0xfff6 == 0x0 (0x0) +__ulonglong 0x2 / 0xfff6 == 0x0 (0x0) +float 0x2 / 0xfff6 == 0x0 (0x0) +int 0x2 % 0xfff6 == 0x2 (0x2) +__uint 0x2 % 0xfff6 == 0x2 (0x2) +char 0x2 % 0xfff6 == 0x2 (0x2) +__uchar 0x2 % 0xf6 == 0x2 (0x2) +__longlong 0x2 % 0xfff6 == 0x2 (0x2) +__ulonglong 0x2 % 0xfff6 == 0x2 (0x2) +0x2 * 0x5 == 0xa +0x2 / 0x5 == 0x0 +0x2 % 0x5 == 0x2 +int 0x2 ^ 0x5 == 0x7 (0x7) +__uint 0x2 ^ 0x5 == 0x7 (0x7) +char 0x2 ^ 0x5 == 0x7 (0x7) +__uchar 0x2 ^ 0x5 == 0x7 (0x7) +__longlong 0x2 ^ 0x5 == 0x7 (0x7) +__ulonglong 0x2 ^ 0x5 == 0x7 (0x7) +int 0x2 && 0x5 == 0x1 (0x1) +__uint 0x2 && 0x5 == 0x1 (0x1) +char 0x2 && 0x5 == 0x1 (0x1) +__uchar 0x2 && 0x5 == 0x1 (0x1) +__longlong 0x2 && 0x5 == 0x1 (0x1) +__ulonglong 0x2 && 0x5 == 0x1 (0x1) +int 0x2 || 0x5 == 0x1 (0x1) +__uint 0x2 || 0x5 == 0x1 (0x1) +char 0x2 || 0x5 == 0x1 (0x1) +__uchar 0x2 || 0x5 == 0x1 (0x1) +__longlong 0x2 || 0x5 == 0x1 (0x1) +__ulonglong 0x2 || 0x5 == 0x1 (0x1) +int 0x2 & 0x5 == 0x0 (0x0) +__uint 0x2 & 0x5 == 0x0 (0x0) +char 0x2 & 0x5 == 0x0 (0x0) +__uchar 0x2 & 0x5 == 0x0 (0x0) +__longlong 0x2 & 0x5 == 0x0 (0x0) +__ulonglong 0x2 & 0x5 == 0x0 (0x0) +int 0x2 | 0x5 == 0x7 (0x7) +__uint 0x2 | 0x5 == 0x7 (0x7) +char 0x2 | 0x5 == 0x7 (0x7) +__uchar 0x2 | 0x5 == 0x7 (0x7) +__longlong 0x2 | 0x5 == 0x7 (0x7) +__ulonglong 0x2 | 0x5 == 0x7 (0x7) +int 0x2 << 0x9 == 0x400 (0x400) +__uint 0x2 << 0x9 == 0x400 (0x400) +char 0x2 << 0x9 == 0x0 (0x0) +__uchar 0x2 << 0x9 == 0x0 (0x0) +__longlong 0x2 << 0x9 == 0x400 (0x400) +__ulonglong 0x2 << 0x9 == 0x400 (0x400) +int 0x2 >> 0x9 == 0x0 (0x0) +__uint 0x2 >> 0x9 == 0x0 (0x0) +char 0x2 >> 0x9 == 0x0 (0x0) +__uchar 0x2 >> 0x9 == 0x0 (0x0) +__longlong 0x2 >> 0x9 == 0x0 (0x0) +__ulonglong 0x2 >> 0x9 == 0x0 (0x0) +int 0x2 + 0x5 == 0x7 (0x7) +__uint 0x2 + 0x5 == 0x7 (0x7) +char 0x2 + 0x5 == 0x7 (0x7) +__uchar 0x2 + 0x5 == 0x7 (0x7) +__longlong 0x2 + 0x5 == 0x7 (0x7) +__ulonglong 0x2 + 0x5 == 0x7 (0x7) +float 0x2 + 0x5 == 0x7 (0x7) +int 0x2 - 0x5 == -0x3 (0xfffd) +__uint 0x2 - 0x5 == -0x3 (0xfffd) +char 0x2 - 0x5 == -0x3 (0xfffd) +__uchar 0x2 - 0x5 == 0xfd (0xfd) +__longlong 0x2 - 0x5 == -0x3 (0xfffd) +__ulonglong 0x2 - 0x5 == -0x3 (0xfffd) +float 0x2 - 0x5 == -0x3 (0xfffd) +int 0x2 * 0x5 == 0xa (0xa) +__uint 0x2 * 0x5 == 0xa (0xa) +char 0x2 * 0x5 == 0xa (0xa) +__uchar 0x2 * 0x5 == 0xa (0xa) +__longlong 0x2 * 0x5 == 0xa (0xa) +__ulonglong 0x2 * 0x5 == 0xa (0xa) +float 0x2 * 0x5 == 0xa (0xa) +int 0x2 < 0x5 == 0x1 (0x1) +__uint 0x2 < 0x5 == 0x1 (0x1) +char 0x2 < 0x5 == 0x1 (0x1) +__uchar 0x2 < 0x5 == 0x1 (0x1) +__longlong 0x2 < 0x5 == 0x1 (0x1) +__ulonglong 0x2 < 0x5 == 0x1 (0x1) +float 0x2 < 0x5 == 0x1 (0x1) +int 0x2 > 0x5 == 0x0 (0x0) +__uint 0x2 > 0x5 == 0x0 (0x0) +char 0x2 > 0x5 == 0x0 (0x0) +__uchar 0x2 > 0x5 == 0x0 (0x0) +__longlong 0x2 > 0x5 == 0x0 (0x0) +__ulonglong 0x2 > 0x5 == 0x0 (0x0) +float 0x2 > 0x5 == 0x0 (0x0) +int 0x2 <= 0x5 == 0x1 (0x1) +__uint 0x2 <= 0x5 == 0x1 (0x1) +char 0x2 <= 0x5 == 0x1 (0x1) +__uchar 0x2 <= 0x5 == 0x1 (0x1) +__longlong 0x2 <= 0x5 == 0x1 (0x1) +__ulonglong 0x2 <= 0x5 == 0x1 (0x1) +float 0x2 <= 0x5 == 0x1 (0x1) +int 0x2 == 0x5 == 0x0 (0x0) +__uint 0x2 == 0x5 == 0x0 (0x0) +char 0x2 == 0x5 == 0x0 (0x0) +__uchar 0x2 == 0x5 == 0x0 (0x0) +__longlong 0x2 == 0x5 == 0x0 (0x0) +__ulonglong 0x2 == 0x5 == 0x0 (0x0) +float 0x2 == 0x5 == 0x0 (0x0) +int 0x2 != 0x5 == 0x1 (0x1) +__uint 0x2 != 0x5 == 0x1 (0x1) +char 0x2 != 0x5 == 0x1 (0x1) +__uchar 0x2 != 0x5 == 0x1 (0x1) +__longlong 0x2 != 0x5 == 0x1 (0x1) +__ulonglong 0x2 != 0x5 == 0x1 (0x1) +float 0x2 != 0x5 == 0x1 (0x1) +int 0x2 >= 0x5 == 0x0 (0x0) +__uint 0x2 >= 0x5 == 0x0 (0x0) +char 0x2 >= 0x5 == 0x0 (0x0) +__uchar 0x2 >= 0x5 == 0x0 (0x0) +__longlong 0x2 >= 0x5 == 0x0 (0x0) +__ulonglong 0x2 >= 0x5 == 0x0 (0x0) +float 0x2 >= 0x5 == 0x0 (0x0) +int 0x2 / 0x5 == 0x0 (0x0) +__uint 0x2 / 0x5 == 0x0 (0x0) +char 0x2 / 0x5 == 0x0 (0x0) +__uchar 0x2 / 0x5 == 0x0 (0x0) +__longlong 0x2 / 0x5 == 0x0 (0x0) +__ulonglong 0x2 / 0x5 == 0x0 (0x0) +float 0x2 / 0x5 == 0x0 (0x0) +int 0x2 % 0x5 == 0x2 (0x2) +__uint 0x2 % 0x5 == 0x2 (0x2) +char 0x2 % 0x5 == 0x2 (0x2) +__uchar 0x2 % 0x5 == 0x2 (0x2) +__longlong 0x2 % 0x5 == 0x2 (0x2) +__ulonglong 0x2 % 0x5 == 0x2 (0x2) +0x2 * 0x7 == 0xe +0x2 / 0x7 == 0x0 +0x2 % 0x7 == 0x2 +int 0x2 ^ 0x7 == 0x5 (0x5) +__uint 0x2 ^ 0x7 == 0x5 (0x5) +char 0x2 ^ 0x7 == 0x5 (0x5) +__uchar 0x2 ^ 0x7 == 0x5 (0x5) +__longlong 0x2 ^ 0x7 == 0x5 (0x5) +__ulonglong 0x2 ^ 0x7 == 0x5 (0x5) +int 0x2 && 0x7 == 0x1 (0x1) +__uint 0x2 && 0x7 == 0x1 (0x1) +char 0x2 && 0x7 == 0x1 (0x1) +__uchar 0x2 && 0x7 == 0x1 (0x1) +__longlong 0x2 && 0x7 == 0x1 (0x1) +__ulonglong 0x2 && 0x7 == 0x1 (0x1) +int 0x2 || 0x7 == 0x1 (0x1) +__uint 0x2 || 0x7 == 0x1 (0x1) +char 0x2 || 0x7 == 0x1 (0x1) +__uchar 0x2 || 0x7 == 0x1 (0x1) +__longlong 0x2 || 0x7 == 0x1 (0x1) +__ulonglong 0x2 || 0x7 == 0x1 (0x1) +int 0x2 & 0x7 == 0x2 (0x2) +__uint 0x2 & 0x7 == 0x2 (0x2) +char 0x2 & 0x7 == 0x2 (0x2) +__uchar 0x2 & 0x7 == 0x2 (0x2) +__longlong 0x2 & 0x7 == 0x2 (0x2) +__ulonglong 0x2 & 0x7 == 0x2 (0x2) +int 0x2 | 0x7 == 0x7 (0x7) +__uint 0x2 | 0x7 == 0x7 (0x7) +char 0x2 | 0x7 == 0x7 (0x7) +__uchar 0x2 | 0x7 == 0x7 (0x7) +__longlong 0x2 | 0x7 == 0x7 (0x7) +__ulonglong 0x2 | 0x7 == 0x7 (0x7) +int 0x2 << 0xa == 0x800 (0x800) +__uint 0x2 << 0xa == 0x800 (0x800) +char 0x2 << 0xa == 0x0 (0x0) +__uchar 0x2 << 0xa == 0x0 (0x0) +__longlong 0x2 << 0xa == 0x800 (0x800) +__ulonglong 0x2 << 0xa == 0x800 (0x800) +int 0x2 >> 0xa == 0x0 (0x0) +__uint 0x2 >> 0xa == 0x0 (0x0) +char 0x2 >> 0xa == 0x0 (0x0) +__uchar 0x2 >> 0xa == 0x0 (0x0) +__longlong 0x2 >> 0xa == 0x0 (0x0) +__ulonglong 0x2 >> 0xa == 0x0 (0x0) +int 0x2 + 0x7 == 0x9 (0x9) +__uint 0x2 + 0x7 == 0x9 (0x9) +char 0x2 + 0x7 == 0x9 (0x9) +__uchar 0x2 + 0x7 == 0x9 (0x9) +__longlong 0x2 + 0x7 == 0x9 (0x9) +__ulonglong 0x2 + 0x7 == 0x9 (0x9) +float 0x2 + 0x7 == 0x9 (0x9) +int 0x2 - 0x7 == -0x5 (0xfffb) +__uint 0x2 - 0x7 == -0x5 (0xfffb) +char 0x2 - 0x7 == -0x5 (0xfffb) +__uchar 0x2 - 0x7 == 0xfb (0xfb) +__longlong 0x2 - 0x7 == -0x5 (0xfffb) +__ulonglong 0x2 - 0x7 == -0x5 (0xfffb) +float 0x2 - 0x7 == -0x5 (0xfffb) +int 0x2 * 0x7 == 0xe (0xe) +__uint 0x2 * 0x7 == 0xe (0xe) +char 0x2 * 0x7 == 0xe (0xe) +__uchar 0x2 * 0x7 == 0xe (0xe) +__longlong 0x2 * 0x7 == 0xe (0xe) +__ulonglong 0x2 * 0x7 == 0xe (0xe) +float 0x2 * 0x7 == 0xe (0xe) +int 0x2 < 0x7 == 0x1 (0x1) +__uint 0x2 < 0x7 == 0x1 (0x1) +char 0x2 < 0x7 == 0x1 (0x1) +__uchar 0x2 < 0x7 == 0x1 (0x1) +__longlong 0x2 < 0x7 == 0x1 (0x1) +__ulonglong 0x2 < 0x7 == 0x1 (0x1) +float 0x2 < 0x7 == 0x1 (0x1) +int 0x2 > 0x7 == 0x0 (0x0) +__uint 0x2 > 0x7 == 0x0 (0x0) +char 0x2 > 0x7 == 0x0 (0x0) +__uchar 0x2 > 0x7 == 0x0 (0x0) +__longlong 0x2 > 0x7 == 0x0 (0x0) +__ulonglong 0x2 > 0x7 == 0x0 (0x0) +float 0x2 > 0x7 == 0x0 (0x0) +int 0x2 <= 0x7 == 0x1 (0x1) +__uint 0x2 <= 0x7 == 0x1 (0x1) +char 0x2 <= 0x7 == 0x1 (0x1) +__uchar 0x2 <= 0x7 == 0x1 (0x1) +__longlong 0x2 <= 0x7 == 0x1 (0x1) +__ulonglong 0x2 <= 0x7 == 0x1 (0x1) +float 0x2 <= 0x7 == 0x1 (0x1) +int 0x2 == 0x7 == 0x0 (0x0) +__uint 0x2 == 0x7 == 0x0 (0x0) +char 0x2 == 0x7 == 0x0 (0x0) +__uchar 0x2 == 0x7 == 0x0 (0x0) +__longlong 0x2 == 0x7 == 0x0 (0x0) +__ulonglong 0x2 == 0x7 == 0x0 (0x0) +float 0x2 == 0x7 == 0x0 (0x0) +int 0x2 != 0x7 == 0x1 (0x1) +__uint 0x2 != 0x7 == 0x1 (0x1) +char 0x2 != 0x7 == 0x1 (0x1) +__uchar 0x2 != 0x7 == 0x1 (0x1) +__longlong 0x2 != 0x7 == 0x1 (0x1) +__ulonglong 0x2 != 0x7 == 0x1 (0x1) +float 0x2 != 0x7 == 0x1 (0x1) +int 0x2 >= 0x7 == 0x0 (0x0) +__uint 0x2 >= 0x7 == 0x0 (0x0) +char 0x2 >= 0x7 == 0x0 (0x0) +__uchar 0x2 >= 0x7 == 0x0 (0x0) +__longlong 0x2 >= 0x7 == 0x0 (0x0) +__ulonglong 0x2 >= 0x7 == 0x0 (0x0) +float 0x2 >= 0x7 == 0x0 (0x0) +int 0x2 / 0x7 == 0x0 (0x0) +__uint 0x2 / 0x7 == 0x0 (0x0) +char 0x2 / 0x7 == 0x0 (0x0) +__uchar 0x2 / 0x7 == 0x0 (0x0) +__longlong 0x2 / 0x7 == 0x0 (0x0) +__ulonglong 0x2 / 0x7 == 0x0 (0x0) +float 0x2 / 0x7 == 0x0 (0x0) +int 0x2 % 0x7 == 0x2 (0x2) +__uint 0x2 % 0x7 == 0x2 (0x2) +char 0x2 % 0x7 == 0x2 (0x2) +__uchar 0x2 % 0x7 == 0x2 (0x2) +__longlong 0x2 % 0x7 == 0x2 (0x2) +__ulonglong 0x2 % 0x7 == 0x2 (0x2) +0x2 * 0x2a == 0x54 +0x2 / 0x2a == 0x0 +0x2 % 0x2a == 0x2 +int 0x2 ^ 0x2a == 0x28 (0x28) +__uint 0x2 ^ 0x2a == 0x28 (0x28) +char 0x2 ^ 0x2a == 0x28 (0x28) +__uchar 0x2 ^ 0x2a == 0x28 (0x28) +__longlong 0x2 ^ 0x2a == 0x28 (0x28) +__ulonglong 0x2 ^ 0x2a == 0x28 (0x28) +int 0x2 && 0x2a == 0x1 (0x1) +__uint 0x2 && 0x2a == 0x1 (0x1) +char 0x2 && 0x2a == 0x1 (0x1) +__uchar 0x2 && 0x2a == 0x1 (0x1) +__longlong 0x2 && 0x2a == 0x1 (0x1) +__ulonglong 0x2 && 0x2a == 0x1 (0x1) +int 0x2 || 0x2a == 0x1 (0x1) +__uint 0x2 || 0x2a == 0x1 (0x1) +char 0x2 || 0x2a == 0x1 (0x1) +__uchar 0x2 || 0x2a == 0x1 (0x1) +__longlong 0x2 || 0x2a == 0x1 (0x1) +__ulonglong 0x2 || 0x2a == 0x1 (0x1) +int 0x2 & 0x2a == 0x2 (0x2) +__uint 0x2 & 0x2a == 0x2 (0x2) +char 0x2 & 0x2a == 0x2 (0x2) +__uchar 0x2 & 0x2a == 0x2 (0x2) +__longlong 0x2 & 0x2a == 0x2 (0x2) +__ulonglong 0x2 & 0x2a == 0x2 (0x2) +int 0x2 | 0x2a == 0x2a (0x2a) +__uint 0x2 | 0x2a == 0x2a (0x2a) +char 0x2 | 0x2a == 0x2a (0x2a) +__uchar 0x2 | 0x2a == 0x2a (0x2a) +__longlong 0x2 | 0x2a == 0x2a (0x2a) +__ulonglong 0x2 | 0x2a == 0x2a (0x2a) +int 0x2 << 0xc == 0x2000 (0x2000) +__uint 0x2 << 0xc == 0x2000 (0x2000) +char 0x2 << 0xc == 0x0 (0x0) +__uchar 0x2 << 0xc == 0x0 (0x0) +__longlong 0x2 << 0xc == 0x2000 (0x2000) +__ulonglong 0x2 << 0xc == 0x2000 (0x2000) +int 0x2 >> 0xc == 0x0 (0x0) +__uint 0x2 >> 0xc == 0x0 (0x0) +char 0x2 >> 0xc == 0x0 (0x0) +__uchar 0x2 >> 0xc == 0x0 (0x0) +__longlong 0x2 >> 0xc == 0x0 (0x0) +__ulonglong 0x2 >> 0xc == 0x0 (0x0) +int 0x2 + 0x2a == 0x2c (0x2c) +__uint 0x2 + 0x2a == 0x2c (0x2c) +char 0x2 + 0x2a == 0x2c (0x2c) +__uchar 0x2 + 0x2a == 0x2c (0x2c) +__longlong 0x2 + 0x2a == 0x2c (0x2c) +__ulonglong 0x2 + 0x2a == 0x2c (0x2c) +float 0x2 + 0x2a == 0x2c (0x2c) +int 0x2 - 0x2a == -0x28 (0xffd8) +__uint 0x2 - 0x2a == -0x28 (0xffd8) +char 0x2 - 0x2a == -0x28 (0xffd8) +__uchar 0x2 - 0x2a == 0xd8 (0xd8) +__longlong 0x2 - 0x2a == -0x28 (0xffd8) +__ulonglong 0x2 - 0x2a == -0x28 (0xffd8) +float 0x2 - 0x2a == -0x28 (0xffd8) +int 0x2 * 0x2a == 0x54 (0x54) +__uint 0x2 * 0x2a == 0x54 (0x54) +char 0x2 * 0x2a == 0x54 (0x54) +__uchar 0x2 * 0x2a == 0x54 (0x54) +__longlong 0x2 * 0x2a == 0x54 (0x54) +__ulonglong 0x2 * 0x2a == 0x54 (0x54) +float 0x2 * 0x2a == 0x54 (0x54) +int 0x2 < 0x2a == 0x1 (0x1) +__uint 0x2 < 0x2a == 0x1 (0x1) +char 0x2 < 0x2a == 0x1 (0x1) +__uchar 0x2 < 0x2a == 0x1 (0x1) +__longlong 0x2 < 0x2a == 0x1 (0x1) +__ulonglong 0x2 < 0x2a == 0x1 (0x1) +float 0x2 < 0x2a == 0x1 (0x1) +int 0x2 > 0x2a == 0x0 (0x0) +__uint 0x2 > 0x2a == 0x0 (0x0) +char 0x2 > 0x2a == 0x0 (0x0) +__uchar 0x2 > 0x2a == 0x0 (0x0) +__longlong 0x2 > 0x2a == 0x0 (0x0) +__ulonglong 0x2 > 0x2a == 0x0 (0x0) +float 0x2 > 0x2a == 0x0 (0x0) +int 0x2 <= 0x2a == 0x1 (0x1) +__uint 0x2 <= 0x2a == 0x1 (0x1) +char 0x2 <= 0x2a == 0x1 (0x1) +__uchar 0x2 <= 0x2a == 0x1 (0x1) +__longlong 0x2 <= 0x2a == 0x1 (0x1) +__ulonglong 0x2 <= 0x2a == 0x1 (0x1) +float 0x2 <= 0x2a == 0x1 (0x1) +int 0x2 == 0x2a == 0x0 (0x0) +__uint 0x2 == 0x2a == 0x0 (0x0) +char 0x2 == 0x2a == 0x0 (0x0) +__uchar 0x2 == 0x2a == 0x0 (0x0) +__longlong 0x2 == 0x2a == 0x0 (0x0) +__ulonglong 0x2 == 0x2a == 0x0 (0x0) +float 0x2 == 0x2a == 0x0 (0x0) +int 0x2 != 0x2a == 0x1 (0x1) +__uint 0x2 != 0x2a == 0x1 (0x1) +char 0x2 != 0x2a == 0x1 (0x1) +__uchar 0x2 != 0x2a == 0x1 (0x1) +__longlong 0x2 != 0x2a == 0x1 (0x1) +__ulonglong 0x2 != 0x2a == 0x1 (0x1) +float 0x2 != 0x2a == 0x1 (0x1) +int 0x2 >= 0x2a == 0x0 (0x0) +__uint 0x2 >= 0x2a == 0x0 (0x0) +char 0x2 >= 0x2a == 0x0 (0x0) +__uchar 0x2 >= 0x2a == 0x0 (0x0) +__longlong 0x2 >= 0x2a == 0x0 (0x0) +__ulonglong 0x2 >= 0x2a == 0x0 (0x0) +float 0x2 >= 0x2a == 0x0 (0x0) +int 0x2 / 0x2a == 0x0 (0x0) +__uint 0x2 / 0x2a == 0x0 (0x0) +char 0x2 / 0x2a == 0x0 (0x0) +__uchar 0x2 / 0x2a == 0x0 (0x0) +__longlong 0x2 / 0x2a == 0x0 (0x0) +__ulonglong 0x2 / 0x2a == 0x0 (0x0) +float 0x2 / 0x2a == 0x0 (0x0) +int 0x2 % 0x2a == 0x2 (0x2) +__uint 0x2 % 0x2a == 0x2 (0x2) +char 0x2 % 0x2a == 0x2 (0x2) +__uchar 0x2 % 0x2a == 0x2 (0x2) +__longlong 0x2 % 0x2a == 0x2 (0x2) +__ulonglong 0x2 % 0x2a == 0x2 (0x2) +0x2 * 0x17 == 0x2e +0x2 / 0x17 == 0x0 +0x2 % 0x17 == 0x2 +int 0x2 ^ 0x17 == 0x15 (0x15) +__uint 0x2 ^ 0x17 == 0x15 (0x15) +char 0x2 ^ 0x17 == 0x15 (0x15) +__uchar 0x2 ^ 0x17 == 0x15 (0x15) +__longlong 0x2 ^ 0x17 == 0x15 (0x15) +__ulonglong 0x2 ^ 0x17 == 0x15 (0x15) +int 0x2 && 0x17 == 0x1 (0x1) +__uint 0x2 && 0x17 == 0x1 (0x1) +char 0x2 && 0x17 == 0x1 (0x1) +__uchar 0x2 && 0x17 == 0x1 (0x1) +__longlong 0x2 && 0x17 == 0x1 (0x1) +__ulonglong 0x2 && 0x17 == 0x1 (0x1) +int 0x2 || 0x17 == 0x1 (0x1) +__uint 0x2 || 0x17 == 0x1 (0x1) +char 0x2 || 0x17 == 0x1 (0x1) +__uchar 0x2 || 0x17 == 0x1 (0x1) +__longlong 0x2 || 0x17 == 0x1 (0x1) +__ulonglong 0x2 || 0x17 == 0x1 (0x1) +int 0x2 & 0x17 == 0x2 (0x2) +__uint 0x2 & 0x17 == 0x2 (0x2) +char 0x2 & 0x17 == 0x2 (0x2) +__uchar 0x2 & 0x17 == 0x2 (0x2) +__longlong 0x2 & 0x17 == 0x2 (0x2) +__ulonglong 0x2 & 0x17 == 0x2 (0x2) +int 0x2 | 0x17 == 0x17 (0x17) +__uint 0x2 | 0x17 == 0x17 (0x17) +char 0x2 | 0x17 == 0x17 (0x17) +__uchar 0x2 | 0x17 == 0x17 (0x17) +__longlong 0x2 | 0x17 == 0x17 (0x17) +__ulonglong 0x2 | 0x17 == 0x17 (0x17) +int 0x2 << 0xe == -0x8000 (0x8000) +__uint 0x2 << 0xe == -0x8000 (0x8000) +char 0x2 << 0xe == 0x0 (0x0) +__uchar 0x2 << 0xe == 0x0 (0x0) +__longlong 0x2 << 0xe == -0x8000 (0x8000) +__ulonglong 0x2 << 0xe == -0x8000 (0x8000) +int 0x2 >> 0xe == 0x0 (0x0) +__uint 0x2 >> 0xe == 0x0 (0x0) +char 0x2 >> 0xe == 0x0 (0x0) +__uchar 0x2 >> 0xe == 0x0 (0x0) +__longlong 0x2 >> 0xe == 0x0 (0x0) +__ulonglong 0x2 >> 0xe == 0x0 (0x0) +int 0x2 + 0x17 == 0x19 (0x19) +__uint 0x2 + 0x17 == 0x19 (0x19) +char 0x2 + 0x17 == 0x19 (0x19) +__uchar 0x2 + 0x17 == 0x19 (0x19) +__longlong 0x2 + 0x17 == 0x19 (0x19) +__ulonglong 0x2 + 0x17 == 0x19 (0x19) +float 0x2 + 0x17 == 0x19 (0x19) +int 0x2 - 0x17 == -0x15 (0xffeb) +__uint 0x2 - 0x17 == -0x15 (0xffeb) +char 0x2 - 0x17 == -0x15 (0xffeb) +__uchar 0x2 - 0x17 == 0xeb (0xeb) +__longlong 0x2 - 0x17 == -0x15 (0xffeb) +__ulonglong 0x2 - 0x17 == -0x15 (0xffeb) +float 0x2 - 0x17 == -0x15 (0xffeb) +int 0x2 * 0x17 == 0x2e (0x2e) +__uint 0x2 * 0x17 == 0x2e (0x2e) +char 0x2 * 0x17 == 0x2e (0x2e) +__uchar 0x2 * 0x17 == 0x2e (0x2e) +__longlong 0x2 * 0x17 == 0x2e (0x2e) +__ulonglong 0x2 * 0x17 == 0x2e (0x2e) +float 0x2 * 0x17 == 0x2e (0x2e) +int 0x2 < 0x17 == 0x1 (0x1) +__uint 0x2 < 0x17 == 0x1 (0x1) +char 0x2 < 0x17 == 0x1 (0x1) +__uchar 0x2 < 0x17 == 0x1 (0x1) +__longlong 0x2 < 0x17 == 0x1 (0x1) +__ulonglong 0x2 < 0x17 == 0x1 (0x1) +float 0x2 < 0x17 == 0x1 (0x1) +int 0x2 > 0x17 == 0x0 (0x0) +__uint 0x2 > 0x17 == 0x0 (0x0) +char 0x2 > 0x17 == 0x0 (0x0) +__uchar 0x2 > 0x17 == 0x0 (0x0) +__longlong 0x2 > 0x17 == 0x0 (0x0) +__ulonglong 0x2 > 0x17 == 0x0 (0x0) +float 0x2 > 0x17 == 0x0 (0x0) +int 0x2 <= 0x17 == 0x1 (0x1) +__uint 0x2 <= 0x17 == 0x1 (0x1) +char 0x2 <= 0x17 == 0x1 (0x1) +__uchar 0x2 <= 0x17 == 0x1 (0x1) +__longlong 0x2 <= 0x17 == 0x1 (0x1) +__ulonglong 0x2 <= 0x17 == 0x1 (0x1) +float 0x2 <= 0x17 == 0x1 (0x1) +int 0x2 == 0x17 == 0x0 (0x0) +__uint 0x2 == 0x17 == 0x0 (0x0) +char 0x2 == 0x17 == 0x0 (0x0) +__uchar 0x2 == 0x17 == 0x0 (0x0) +__longlong 0x2 == 0x17 == 0x0 (0x0) +__ulonglong 0x2 == 0x17 == 0x0 (0x0) +float 0x2 == 0x17 == 0x0 (0x0) +int 0x2 != 0x17 == 0x1 (0x1) +__uint 0x2 != 0x17 == 0x1 (0x1) +char 0x2 != 0x17 == 0x1 (0x1) +__uchar 0x2 != 0x17 == 0x1 (0x1) +__longlong 0x2 != 0x17 == 0x1 (0x1) +__ulonglong 0x2 != 0x17 == 0x1 (0x1) +float 0x2 != 0x17 == 0x1 (0x1) +int 0x2 >= 0x17 == 0x0 (0x0) +__uint 0x2 >= 0x17 == 0x0 (0x0) +char 0x2 >= 0x17 == 0x0 (0x0) +__uchar 0x2 >= 0x17 == 0x0 (0x0) +__longlong 0x2 >= 0x17 == 0x0 (0x0) +__ulonglong 0x2 >= 0x17 == 0x0 (0x0) +float 0x2 >= 0x17 == 0x0 (0x0) +int 0x2 / 0x17 == 0x0 (0x0) +__uint 0x2 / 0x17 == 0x0 (0x0) +char 0x2 / 0x17 == 0x0 (0x0) +__uchar 0x2 / 0x17 == 0x0 (0x0) +__longlong 0x2 / 0x17 == 0x0 (0x0) +__ulonglong 0x2 / 0x17 == 0x0 (0x0) +float 0x2 / 0x17 == 0x0 (0x0) +int 0x2 % 0x17 == 0x2 (0x2) +__uint 0x2 % 0x17 == 0x2 (0x2) +char 0x2 % 0x17 == 0x2 (0x2) +__uchar 0x2 % 0x17 == 0x2 (0x2) +__longlong 0x2 % 0x17 == 0x2 (0x2) +__ulonglong 0x2 % 0x17 == 0x2 (0x2) +0x2 * 0x7fff == -0x2 +0x2 / 0x7fff == 0x0 +0x2 % 0x7fff == 0x2 +int 0x2 ^ 0x7fff == 0x7ffd (0x7ffd) +__uint 0x2 ^ 0x7fff == 0x7ffd (0x7ffd) +char 0x2 ^ 0xffff == -0x3 (0xfffd) +__uchar 0x2 ^ 0xff == 0xfd (0xfd) +__longlong 0x2 ^ 0x7fff == 0x7ffd (0x7ffd) +__ulonglong 0x2 ^ 0x7fff == 0x7ffd (0x7ffd) +int 0x2 && 0x7fff == 0x1 (0x1) +__uint 0x2 && 0x7fff == 0x1 (0x1) +char 0x2 && 0xffff == 0x1 (0x1) +__uchar 0x2 && 0xff == 0x1 (0x1) +__longlong 0x2 && 0x7fff == 0x1 (0x1) +__ulonglong 0x2 && 0x7fff == 0x1 (0x1) +int 0x2 || 0x7fff == 0x1 (0x1) +__uint 0x2 || 0x7fff == 0x1 (0x1) +char 0x2 || 0xffff == 0x1 (0x1) +__uchar 0x2 || 0xff == 0x1 (0x1) +__longlong 0x2 || 0x7fff == 0x1 (0x1) +__ulonglong 0x2 || 0x7fff == 0x1 (0x1) +int 0x2 & 0x7fff == 0x2 (0x2) +__uint 0x2 & 0x7fff == 0x2 (0x2) +char 0x2 & 0xffff == 0x2 (0x2) +__uchar 0x2 & 0xff == 0x2 (0x2) +__longlong 0x2 & 0x7fff == 0x2 (0x2) +__ulonglong 0x2 & 0x7fff == 0x2 (0x2) +int 0x2 | 0x7fff == 0x7fff (0x7fff) +__uint 0x2 | 0x7fff == 0x7fff (0x7fff) +char 0x2 | 0xffff == -0x1 (0xffff) +__uchar 0x2 | 0xff == 0xff (0xff) +__longlong 0x2 | 0x7fff == 0x7fff (0x7fff) +__ulonglong 0x2 | 0x7fff == 0x7fff (0x7fff) +int 0x2 << 0x10 == 0x0 (0x0) +__uint 0x2 << 0x10 == 0x0 (0x0) +char 0x2 << 0x10 == 0x0 (0x0) +__uchar 0x2 << 0x10 == 0x0 (0x0) +__longlong 0x2 << 0x10 == 0x0 (0x0) +__ulonglong 0x2 << 0x10 == 0x0 (0x0) +int 0x2 >> 0x10 == 0x0 (0x0) +__uint 0x2 >> 0x10 == 0x0 (0x0) +char 0x2 >> 0x10 == 0x0 (0x0) +__uchar 0x2 >> 0x10 == 0x0 (0x0) +__longlong 0x2 >> 0x10 == 0x0 (0x0) +__ulonglong 0x2 >> 0x10 == 0x0 (0x0) +int 0x2 + 0x7fff == -0x7fff (0x8001) +__uint 0x2 + 0x7fff == -0x7fff (0x8001) +char 0x2 + 0xffff == 0x1 (0x1) +__uchar 0x2 + 0xff == 0x1 (0x1) +__longlong 0x2 + 0x7fff == -0x7fff (0x8001) +__ulonglong 0x2 + 0x7fff == -0x7fff (0x8001) +float 0x2 + 0x7fff == -0x7fff (0x8001) +int 0x2 - 0x7fff == -0x7ffd (0x8003) +__uint 0x2 - 0x7fff == -0x7ffd (0x8003) +char 0x2 - 0xffff == 0x3 (0x3) +__uchar 0x2 - 0xff == 0x3 (0x3) +__longlong 0x2 - 0x7fff == -0x7ffd (0x8003) +__ulonglong 0x2 - 0x7fff == -0x7ffd (0x8003) +float 0x2 - 0x7fff == -0x7ffd (0x8003) +int 0x2 * 0x7fff == -0x2 (0xfffe) +__uint 0x2 * 0x7fff == -0x2 (0xfffe) +char 0x2 * 0xffff == -0x2 (0xfffe) +__uchar 0x2 * 0xff == 0xfe (0xfe) +__longlong 0x2 * 0x7fff == -0x2 (0xfffe) +__ulonglong 0x2 * 0x7fff == -0x2 (0xfffe) +float 0x2 * 0x7fff == -0x2 (0xfffe) +int 0x2 < 0x7fff == 0x1 (0x1) +__uint 0x2 < 0x7fff == 0x1 (0x1) +char 0x2 < 0xffff == 0x0 (0x0) +__uchar 0x2 < 0xff == 0x1 (0x1) +__longlong 0x2 < 0x7fff == 0x1 (0x1) +__ulonglong 0x2 < 0x7fff == 0x1 (0x1) +float 0x2 < 0x7fff == 0x1 (0x1) +int 0x2 > 0x7fff == 0x0 (0x0) +__uint 0x2 > 0x7fff == 0x0 (0x0) +char 0x2 > 0xffff == 0x1 (0x1) +__uchar 0x2 > 0xff == 0x0 (0x0) +__longlong 0x2 > 0x7fff == 0x0 (0x0) +__ulonglong 0x2 > 0x7fff == 0x0 (0x0) +float 0x2 > 0x7fff == 0x0 (0x0) +int 0x2 <= 0x7fff == 0x1 (0x1) +__uint 0x2 <= 0x7fff == 0x1 (0x1) +char 0x2 <= 0xffff == 0x0 (0x0) +__uchar 0x2 <= 0xff == 0x1 (0x1) +__longlong 0x2 <= 0x7fff == 0x1 (0x1) +__ulonglong 0x2 <= 0x7fff == 0x1 (0x1) +float 0x2 <= 0x7fff == 0x1 (0x1) +int 0x2 == 0x7fff == 0x0 (0x0) +__uint 0x2 == 0x7fff == 0x0 (0x0) +char 0x2 == 0xffff == 0x0 (0x0) +__uchar 0x2 == 0xff == 0x0 (0x0) +__longlong 0x2 == 0x7fff == 0x0 (0x0) +__ulonglong 0x2 == 0x7fff == 0x0 (0x0) +float 0x2 == 0x7fff == 0x0 (0x0) +int 0x2 != 0x7fff == 0x1 (0x1) +__uint 0x2 != 0x7fff == 0x1 (0x1) +char 0x2 != 0xffff == 0x1 (0x1) +__uchar 0x2 != 0xff == 0x1 (0x1) +__longlong 0x2 != 0x7fff == 0x1 (0x1) +__ulonglong 0x2 != 0x7fff == 0x1 (0x1) +float 0x2 != 0x7fff == 0x1 (0x1) +int 0x2 >= 0x7fff == 0x0 (0x0) +__uint 0x2 >= 0x7fff == 0x0 (0x0) +char 0x2 >= 0xffff == 0x1 (0x1) +__uchar 0x2 >= 0xff == 0x0 (0x0) +__longlong 0x2 >= 0x7fff == 0x0 (0x0) +__ulonglong 0x2 >= 0x7fff == 0x0 (0x0) +float 0x2 >= 0x7fff == 0x0 (0x0) +int 0x2 / 0x7fff == 0x0 (0x0) +__uint 0x2 / 0x7fff == 0x0 (0x0) +char 0x2 / 0xffff == -0x2 (0xfffe) +__uchar 0x2 / 0xff == 0x0 (0x0) +__longlong 0x2 / 0x7fff == 0x0 (0x0) +__ulonglong 0x2 / 0x7fff == 0x0 (0x0) +float 0x2 / 0x7fff == 0x0 (0x0) +int 0x2 % 0x7fff == 0x2 (0x2) +__uint 0x2 % 0x7fff == 0x2 (0x2) +char 0x2 % 0xffff == 0x0 (0x0) +__uchar 0x2 % 0xff == 0x2 (0x2) +__longlong 0x2 % 0x7fff == 0x2 (0x2) +__ulonglong 0x2 % 0x7fff == 0x2 (0x2) +0x2 * 0x8000 == 0x0 +0x2 / 0x8000 == 0x0 +0x2 % 0x8000 == 0x2 +int 0x2 ^ 0x8000 == -0x7ffe (0x8002) +__uint 0x2 ^ 0x8000 == -0x7ffe (0x8002) +char 0x2 ^ 0x0 == 0x2 (0x2) +__uchar 0x2 ^ 0x0 == 0x2 (0x2) +__longlong 0x2 ^ 0x8000 == -0x7ffe (0x8002) +__ulonglong 0x2 ^ 0x8000 == -0x7ffe (0x8002) +int 0x2 && 0x8000 == 0x1 (0x1) +__uint 0x2 && 0x8000 == 0x1 (0x1) +char 0x2 && 0x0 == 0x0 (0x0) +__uchar 0x2 && 0x0 == 0x0 (0x0) +__longlong 0x2 && 0x8000 == 0x1 (0x1) +__ulonglong 0x2 && 0x8000 == 0x1 (0x1) +int 0x2 || 0x8000 == 0x1 (0x1) +__uint 0x2 || 0x8000 == 0x1 (0x1) +char 0x2 || 0x0 == 0x1 (0x1) +__uchar 0x2 || 0x0 == 0x1 (0x1) +__longlong 0x2 || 0x8000 == 0x1 (0x1) +__ulonglong 0x2 || 0x8000 == 0x1 (0x1) +int 0x2 & 0x8000 == 0x0 (0x0) +__uint 0x2 & 0x8000 == 0x0 (0x0) +char 0x2 & 0x0 == 0x0 (0x0) +__uchar 0x2 & 0x0 == 0x0 (0x0) +__longlong 0x2 & 0x8000 == 0x0 (0x0) +__ulonglong 0x2 & 0x8000 == 0x0 (0x0) +int 0x2 | 0x8000 == -0x7ffe (0x8002) +__uint 0x2 | 0x8000 == -0x7ffe (0x8002) +char 0x2 | 0x0 == 0x2 (0x2) +__uchar 0x2 | 0x0 == 0x2 (0x2) +__longlong 0x2 | 0x8000 == -0x7ffe (0x8002) +__ulonglong 0x2 | 0x8000 == -0x7ffe (0x8002) +int 0x2 << 0x12 == 0x0 (0x0) +__uint 0x2 << 0x12 == 0x0 (0x0) +char 0x2 << 0x12 == 0x0 (0x0) +__uchar 0x2 << 0x12 == 0x0 (0x0) +__longlong 0x2 << 0x12 == 0x0 (0x0) +__ulonglong 0x2 << 0x12 == 0x0 (0x0) +int 0x2 >> 0x12 == 0x0 (0x0) +__uint 0x2 >> 0x12 == 0x0 (0x0) +char 0x2 >> 0x12 == 0x0 (0x0) +__uchar 0x2 >> 0x12 == 0x0 (0x0) +__longlong 0x2 >> 0x12 == 0x0 (0x0) +__ulonglong 0x2 >> 0x12 == 0x0 (0x0) +int 0x2 + 0x8000 == -0x7ffe (0x8002) +__uint 0x2 + 0x8000 == -0x7ffe (0x8002) +char 0x2 + 0x0 == 0x2 (0x2) +__uchar 0x2 + 0x0 == 0x2 (0x2) +__longlong 0x2 + 0x8000 == -0x7ffe (0x8002) +__ulonglong 0x2 + 0x8000 == -0x7ffe (0x8002) +float 0x2 + 0x8000 == -0x7ffe (0x8002) +int 0x2 - 0x8000 == -0x7ffe (0x8002) +__uint 0x2 - 0x8000 == -0x7ffe (0x8002) +char 0x2 - 0x0 == 0x2 (0x2) +__uchar 0x2 - 0x0 == 0x2 (0x2) +__longlong 0x2 - 0x8000 == -0x7ffe (0x8002) +__ulonglong 0x2 - 0x8000 == -0x7ffe (0x8002) +float 0x2 - 0x8000 == -0x7ffe (0x8002) +int 0x2 * 0x8000 == 0x0 (0x0) +__uint 0x2 * 0x8000 == 0x0 (0x0) +char 0x2 * 0x0 == 0x0 (0x0) +__uchar 0x2 * 0x0 == 0x0 (0x0) +__longlong 0x2 * 0x8000 == 0x0 (0x0) +__ulonglong 0x2 * 0x8000 == 0x0 (0x0) +float 0x2 * 0x8000 == 0x0 (0x0) +int 0x2 < 0x8000 == 0x0 (0x0) +__uint 0x2 < 0x8000 == 0x1 (0x1) +char 0x2 < 0x0 == 0x0 (0x0) +__uchar 0x2 < 0x0 == 0x0 (0x0) +__longlong 0x2 < 0x8000 == 0x0 (0x0) +__ulonglong 0x2 < 0x8000 == 0x1 (0x1) +float 0x2 < 0x8000 == 0x0 (0x0) +int 0x2 > 0x8000 == 0x1 (0x1) +__uint 0x2 > 0x8000 == 0x0 (0x0) +char 0x2 > 0x0 == 0x1 (0x1) +__uchar 0x2 > 0x0 == 0x1 (0x1) +__longlong 0x2 > 0x8000 == 0x1 (0x1) +__ulonglong 0x2 > 0x8000 == 0x0 (0x0) +float 0x2 > 0x8000 == 0x1 (0x1) +int 0x2 <= 0x8000 == 0x0 (0x0) +__uint 0x2 <= 0x8000 == 0x1 (0x1) +char 0x2 <= 0x0 == 0x0 (0x0) +__uchar 0x2 <= 0x0 == 0x0 (0x0) +__longlong 0x2 <= 0x8000 == 0x0 (0x0) +__ulonglong 0x2 <= 0x8000 == 0x1 (0x1) +float 0x2 <= 0x8000 == 0x0 (0x0) +int 0x2 == 0x8000 == 0x0 (0x0) +__uint 0x2 == 0x8000 == 0x0 (0x0) +char 0x2 == 0x0 == 0x0 (0x0) +__uchar 0x2 == 0x0 == 0x0 (0x0) +__longlong 0x2 == 0x8000 == 0x0 (0x0) +__ulonglong 0x2 == 0x8000 == 0x0 (0x0) +float 0x2 == 0x8000 == 0x0 (0x0) +int 0x2 != 0x8000 == 0x1 (0x1) +__uint 0x2 != 0x8000 == 0x1 (0x1) +char 0x2 != 0x0 == 0x1 (0x1) +__uchar 0x2 != 0x0 == 0x1 (0x1) +__longlong 0x2 != 0x8000 == 0x1 (0x1) +__ulonglong 0x2 != 0x8000 == 0x1 (0x1) +float 0x2 != 0x8000 == 0x1 (0x1) +int 0x2 >= 0x8000 == 0x1 (0x1) +__uint 0x2 >= 0x8000 == 0x0 (0x0) +char 0x2 >= 0x0 == 0x1 (0x1) +__uchar 0x2 >= 0x0 == 0x1 (0x1) +__longlong 0x2 >= 0x8000 == 0x1 (0x1) +__ulonglong 0x2 >= 0x8000 == 0x0 (0x0) +float 0x2 >= 0x8000 == 0x1 (0x1) +int 0x2 / 0x8000 == 0x0 (0x0) +__uint 0x2 / 0x8000 == 0x0 (0x0) +__longlong 0x2 / 0x8000 == 0x0 (0x0) +__ulonglong 0x2 / 0x8000 == 0x0 (0x0) +float 0x2 / 0x8000 == 0x0 (0x0) +int 0x2 % 0x8000 == 0x2 (0x2) +__uint 0x2 % 0x8000 == 0x2 (0x2) +__longlong 0x2 % 0x8000 == 0x2 (0x2) +__ulonglong 0x2 % 0x8000 == 0x2 (0x2) +0x2 * 0x3e8 == 0x7d0 +0x2 / 0x3e8 == 0x0 +0x2 % 0x3e8 == 0x2 +int 0x2 ^ 0x3e8 == 0x3ea (0x3ea) +__uint 0x2 ^ 0x3e8 == 0x3ea (0x3ea) +char 0x2 ^ 0xffe8 == -0x16 (0xffea) +__uchar 0x2 ^ 0xe8 == 0xea (0xea) +__longlong 0x2 ^ 0x3e8 == 0x3ea (0x3ea) +__ulonglong 0x2 ^ 0x3e8 == 0x3ea (0x3ea) +int 0x2 && 0x3e8 == 0x1 (0x1) +__uint 0x2 && 0x3e8 == 0x1 (0x1) +char 0x2 && 0xffe8 == 0x1 (0x1) +__uchar 0x2 && 0xe8 == 0x1 (0x1) +__longlong 0x2 && 0x3e8 == 0x1 (0x1) +__ulonglong 0x2 && 0x3e8 == 0x1 (0x1) +int 0x2 || 0x3e8 == 0x1 (0x1) +__uint 0x2 || 0x3e8 == 0x1 (0x1) +char 0x2 || 0xffe8 == 0x1 (0x1) +__uchar 0x2 || 0xe8 == 0x1 (0x1) +__longlong 0x2 || 0x3e8 == 0x1 (0x1) +__ulonglong 0x2 || 0x3e8 == 0x1 (0x1) +int 0x2 & 0x3e8 == 0x0 (0x0) +__uint 0x2 & 0x3e8 == 0x0 (0x0) +char 0x2 & 0xffe8 == 0x0 (0x0) +__uchar 0x2 & 0xe8 == 0x0 (0x0) +__longlong 0x2 & 0x3e8 == 0x0 (0x0) +__ulonglong 0x2 & 0x3e8 == 0x0 (0x0) +int 0x2 | 0x3e8 == 0x3ea (0x3ea) +__uint 0x2 | 0x3e8 == 0x3ea (0x3ea) +char 0x2 | 0xffe8 == -0x16 (0xffea) +__uchar 0x2 | 0xe8 == 0xea (0xea) +__longlong 0x2 | 0x3e8 == 0x3ea (0x3ea) +__ulonglong 0x2 | 0x3e8 == 0x3ea (0x3ea) +int 0x2 << 0x14 == 0x0 (0x0) +__uint 0x2 << 0x14 == 0x0 (0x0) +char 0x2 << 0x14 == 0x0 (0x0) +__uchar 0x2 << 0x14 == 0x0 (0x0) +__longlong 0x2 << 0x14 == 0x0 (0x0) +__ulonglong 0x2 << 0x14 == 0x0 (0x0) +int 0x2 >> 0x14 == 0x0 (0x0) +__uint 0x2 >> 0x14 == 0x0 (0x0) +char 0x2 >> 0x14 == 0x0 (0x0) +__uchar 0x2 >> 0x14 == 0x0 (0x0) +__longlong 0x2 >> 0x14 == 0x0 (0x0) +__ulonglong 0x2 >> 0x14 == 0x0 (0x0) +int 0x2 + 0x3e8 == 0x3ea (0x3ea) +__uint 0x2 + 0x3e8 == 0x3ea (0x3ea) +char 0x2 + 0xffe8 == -0x16 (0xffea) +__uchar 0x2 + 0xe8 == 0xea (0xea) +__longlong 0x2 + 0x3e8 == 0x3ea (0x3ea) +__ulonglong 0x2 + 0x3e8 == 0x3ea (0x3ea) +float 0x2 + 0x3e8 == 0x3ea (0x3ea) +int 0x2 - 0x3e8 == -0x3e6 (0xfc1a) +__uint 0x2 - 0x3e8 == -0x3e6 (0xfc1a) +char 0x2 - 0xffe8 == 0x1a (0x1a) +__uchar 0x2 - 0xe8 == 0x1a (0x1a) +__longlong 0x2 - 0x3e8 == -0x3e6 (0xfc1a) +__ulonglong 0x2 - 0x3e8 == -0x3e6 (0xfc1a) +float 0x2 - 0x3e8 == -0x3e6 (0xfc1a) +int 0x2 * 0x3e8 == 0x7d0 (0x7d0) +__uint 0x2 * 0x3e8 == 0x7d0 (0x7d0) +char 0x2 * 0xffe8 == -0x30 (0xffd0) +__uchar 0x2 * 0xe8 == 0xd0 (0xd0) +__longlong 0x2 * 0x3e8 == 0x7d0 (0x7d0) +__ulonglong 0x2 * 0x3e8 == 0x7d0 (0x7d0) +float 0x2 * 0x3e8 == 0x7d0 (0x7d0) +int 0x2 < 0x3e8 == 0x1 (0x1) +__uint 0x2 < 0x3e8 == 0x1 (0x1) +char 0x2 < 0xffe8 == 0x0 (0x0) +__uchar 0x2 < 0xe8 == 0x1 (0x1) +__longlong 0x2 < 0x3e8 == 0x1 (0x1) +__ulonglong 0x2 < 0x3e8 == 0x1 (0x1) +float 0x2 < 0x3e8 == 0x1 (0x1) +int 0x2 > 0x3e8 == 0x0 (0x0) +__uint 0x2 > 0x3e8 == 0x0 (0x0) +char 0x2 > 0xffe8 == 0x1 (0x1) +__uchar 0x2 > 0xe8 == 0x0 (0x0) +__longlong 0x2 > 0x3e8 == 0x0 (0x0) +__ulonglong 0x2 > 0x3e8 == 0x0 (0x0) +float 0x2 > 0x3e8 == 0x0 (0x0) +int 0x2 <= 0x3e8 == 0x1 (0x1) +__uint 0x2 <= 0x3e8 == 0x1 (0x1) +char 0x2 <= 0xffe8 == 0x0 (0x0) +__uchar 0x2 <= 0xe8 == 0x1 (0x1) +__longlong 0x2 <= 0x3e8 == 0x1 (0x1) +__ulonglong 0x2 <= 0x3e8 == 0x1 (0x1) +float 0x2 <= 0x3e8 == 0x1 (0x1) +int 0x2 == 0x3e8 == 0x0 (0x0) +__uint 0x2 == 0x3e8 == 0x0 (0x0) +char 0x2 == 0xffe8 == 0x0 (0x0) +__uchar 0x2 == 0xe8 == 0x0 (0x0) +__longlong 0x2 == 0x3e8 == 0x0 (0x0) +__ulonglong 0x2 == 0x3e8 == 0x0 (0x0) +float 0x2 == 0x3e8 == 0x0 (0x0) +int 0x2 != 0x3e8 == 0x1 (0x1) +__uint 0x2 != 0x3e8 == 0x1 (0x1) +char 0x2 != 0xffe8 == 0x1 (0x1) +__uchar 0x2 != 0xe8 == 0x1 (0x1) +__longlong 0x2 != 0x3e8 == 0x1 (0x1) +__ulonglong 0x2 != 0x3e8 == 0x1 (0x1) +float 0x2 != 0x3e8 == 0x1 (0x1) +int 0x2 >= 0x3e8 == 0x0 (0x0) +__uint 0x2 >= 0x3e8 == 0x0 (0x0) +char 0x2 >= 0xffe8 == 0x1 (0x1) +__uchar 0x2 >= 0xe8 == 0x0 (0x0) +__longlong 0x2 >= 0x3e8 == 0x0 (0x0) +__ulonglong 0x2 >= 0x3e8 == 0x0 (0x0) +float 0x2 >= 0x3e8 == 0x0 (0x0) +int 0x2 / 0x3e8 == 0x0 (0x0) +__uint 0x2 / 0x3e8 == 0x0 (0x0) +char 0x2 / 0xffe8 == 0x0 (0x0) +__uchar 0x2 / 0xe8 == 0x0 (0x0) +__longlong 0x2 / 0x3e8 == 0x0 (0x0) +__ulonglong 0x2 / 0x3e8 == 0x0 (0x0) +float 0x2 / 0x3e8 == 0x0 (0x0) +int 0x2 % 0x3e8 == 0x2 (0x2) +__uint 0x2 % 0x3e8 == 0x2 (0x2) +char 0x2 % 0xffe8 == 0x2 (0x2) +__uchar 0x2 % 0xe8 == 0x2 (0x2) +__longlong 0x2 % 0x3e8 == 0x2 (0x2) +__ulonglong 0x2 % 0x3e8 == 0x2 (0x2) +0x2 * 0x2710 == 0x4e20 +0x2 / 0x2710 == 0x0 +0x2 % 0x2710 == 0x2 +int 0x2 ^ 0x2710 == 0x2712 (0x2712) +__uint 0x2 ^ 0x2710 == 0x2712 (0x2712) +char 0x2 ^ 0x10 == 0x12 (0x12) +__uchar 0x2 ^ 0x10 == 0x12 (0x12) +__longlong 0x2 ^ 0x2710 == 0x2712 (0x2712) +__ulonglong 0x2 ^ 0x2710 == 0x2712 (0x2712) +int 0x2 && 0x2710 == 0x1 (0x1) +__uint 0x2 && 0x2710 == 0x1 (0x1) +char 0x2 && 0x10 == 0x1 (0x1) +__uchar 0x2 && 0x10 == 0x1 (0x1) +__longlong 0x2 && 0x2710 == 0x1 (0x1) +__ulonglong 0x2 && 0x2710 == 0x1 (0x1) +int 0x2 || 0x2710 == 0x1 (0x1) +__uint 0x2 || 0x2710 == 0x1 (0x1) +char 0x2 || 0x10 == 0x1 (0x1) +__uchar 0x2 || 0x10 == 0x1 (0x1) +__longlong 0x2 || 0x2710 == 0x1 (0x1) +__ulonglong 0x2 || 0x2710 == 0x1 (0x1) +int 0x2 & 0x2710 == 0x0 (0x0) +__uint 0x2 & 0x2710 == 0x0 (0x0) +char 0x2 & 0x10 == 0x0 (0x0) +__uchar 0x2 & 0x10 == 0x0 (0x0) +__longlong 0x2 & 0x2710 == 0x0 (0x0) +__ulonglong 0x2 & 0x2710 == 0x0 (0x0) +int 0x2 | 0x2710 == 0x2712 (0x2712) +__uint 0x2 | 0x2710 == 0x2712 (0x2712) +char 0x2 | 0x10 == 0x12 (0x12) +__uchar 0x2 | 0x10 == 0x12 (0x12) +__longlong 0x2 | 0x2710 == 0x2712 (0x2712) +__ulonglong 0x2 | 0x2710 == 0x2712 (0x2712) +int 0x2 << 0x16 == 0x0 (0x0) +__uint 0x2 << 0x16 == 0x0 (0x0) +char 0x2 << 0x16 == 0x0 (0x0) +__uchar 0x2 << 0x16 == 0x0 (0x0) +__longlong 0x2 << 0x16 == 0x0 (0x0) +__ulonglong 0x2 << 0x16 == 0x0 (0x0) +int 0x2 >> 0x16 == 0x0 (0x0) +__uint 0x2 >> 0x16 == 0x0 (0x0) +char 0x2 >> 0x16 == 0x0 (0x0) +__uchar 0x2 >> 0x16 == 0x0 (0x0) +__longlong 0x2 >> 0x16 == 0x0 (0x0) +__ulonglong 0x2 >> 0x16 == 0x0 (0x0) +int 0x2 + 0x2710 == 0x2712 (0x2712) +__uint 0x2 + 0x2710 == 0x2712 (0x2712) +char 0x2 + 0x10 == 0x12 (0x12) +__uchar 0x2 + 0x10 == 0x12 (0x12) +__longlong 0x2 + 0x2710 == 0x2712 (0x2712) +__ulonglong 0x2 + 0x2710 == 0x2712 (0x2712) +float 0x2 + 0x2710 == 0x2712 (0x2712) +int 0x2 - 0x2710 == -0x270e (0xd8f2) +__uint 0x2 - 0x2710 == -0x270e (0xd8f2) +char 0x2 - 0x10 == -0xe (0xfff2) +__uchar 0x2 - 0x10 == 0xf2 (0xf2) +__longlong 0x2 - 0x2710 == -0x270e (0xd8f2) +__ulonglong 0x2 - 0x2710 == -0x270e (0xd8f2) +float 0x2 - 0x2710 == -0x270e (0xd8f2) +int 0x2 * 0x2710 == 0x4e20 (0x4e20) +__uint 0x2 * 0x2710 == 0x4e20 (0x4e20) +char 0x2 * 0x10 == 0x20 (0x20) +__uchar 0x2 * 0x10 == 0x20 (0x20) +__longlong 0x2 * 0x2710 == 0x4e20 (0x4e20) +__ulonglong 0x2 * 0x2710 == 0x4e20 (0x4e20) +float 0x2 * 0x2710 == 0x4e20 (0x4e20) +int 0x2 < 0x2710 == 0x1 (0x1) +__uint 0x2 < 0x2710 == 0x1 (0x1) +char 0x2 < 0x10 == 0x1 (0x1) +__uchar 0x2 < 0x10 == 0x1 (0x1) +__longlong 0x2 < 0x2710 == 0x1 (0x1) +__ulonglong 0x2 < 0x2710 == 0x1 (0x1) +float 0x2 < 0x2710 == 0x1 (0x1) +int 0x2 > 0x2710 == 0x0 (0x0) +__uint 0x2 > 0x2710 == 0x0 (0x0) +char 0x2 > 0x10 == 0x0 (0x0) +__uchar 0x2 > 0x10 == 0x0 (0x0) +__longlong 0x2 > 0x2710 == 0x0 (0x0) +__ulonglong 0x2 > 0x2710 == 0x0 (0x0) +float 0x2 > 0x2710 == 0x0 (0x0) +int 0x2 <= 0x2710 == 0x1 (0x1) +__uint 0x2 <= 0x2710 == 0x1 (0x1) +char 0x2 <= 0x10 == 0x1 (0x1) +__uchar 0x2 <= 0x10 == 0x1 (0x1) +__longlong 0x2 <= 0x2710 == 0x1 (0x1) +__ulonglong 0x2 <= 0x2710 == 0x1 (0x1) +float 0x2 <= 0x2710 == 0x1 (0x1) +int 0x2 == 0x2710 == 0x0 (0x0) +__uint 0x2 == 0x2710 == 0x0 (0x0) +char 0x2 == 0x10 == 0x0 (0x0) +__uchar 0x2 == 0x10 == 0x0 (0x0) +__longlong 0x2 == 0x2710 == 0x0 (0x0) +__ulonglong 0x2 == 0x2710 == 0x0 (0x0) +float 0x2 == 0x2710 == 0x0 (0x0) +int 0x2 != 0x2710 == 0x1 (0x1) +__uint 0x2 != 0x2710 == 0x1 (0x1) +char 0x2 != 0x10 == 0x1 (0x1) +__uchar 0x2 != 0x10 == 0x1 (0x1) +__longlong 0x2 != 0x2710 == 0x1 (0x1) +__ulonglong 0x2 != 0x2710 == 0x1 (0x1) +float 0x2 != 0x2710 == 0x1 (0x1) +int 0x2 >= 0x2710 == 0x0 (0x0) +__uint 0x2 >= 0x2710 == 0x0 (0x0) +char 0x2 >= 0x10 == 0x0 (0x0) +__uchar 0x2 >= 0x10 == 0x0 (0x0) +__longlong 0x2 >= 0x2710 == 0x0 (0x0) +__ulonglong 0x2 >= 0x2710 == 0x0 (0x0) +float 0x2 >= 0x2710 == 0x0 (0x0) +int 0x2 / 0x2710 == 0x0 (0x0) +__uint 0x2 / 0x2710 == 0x0 (0x0) +char 0x2 / 0x10 == 0x0 (0x0) +__uchar 0x2 / 0x10 == 0x0 (0x0) +__longlong 0x2 / 0x2710 == 0x0 (0x0) +__ulonglong 0x2 / 0x2710 == 0x0 (0x0) +float 0x2 / 0x2710 == 0x0 (0x0) +int 0x2 % 0x2710 == 0x2 (0x2) +__uint 0x2 % 0x2710 == 0x2 (0x2) +char 0x2 % 0x10 == 0x2 (0x2) +__uchar 0x2 % 0x10 == 0x2 (0x2) +__longlong 0x2 % 0x2710 == 0x2 (0x2) +__ulonglong 0x2 % 0x2710 == 0x2 (0x2) +int xor420x2 xor42 0x28 +__uint xor420x2 xor42 0x28 +char xor420x2 xor42 0x28 +__uchar xor420x2 xor42 0x28 +__longlong xor420x2 xor42 0x28 +__ulonglong xor420x2 xor42 0x28 +int land10x2 land1 0x1 +__uint land10x2 land1 0x1 +char land10x2 land1 0x1 +__uchar land10x2 land1 0x1 +__longlong land10x2 land1 0x1 +__ulonglong land10x2 land1 0x1 +int lor10x2 lor1 0x1 +__uint lor10x2 lor1 0x1 +char lor10x2 lor1 0x1 +__uchar lor10x2 lor1 0x1 +__longlong lor10x2 lor1 0x1 +__ulonglong lor10x2 lor1 0x1 +int and420x2 and42 0x2 +__uint and420x2 and42 0x2 +char and420x2 and42 0x2 +__uchar and420x2 and42 0x2 +__longlong and420x2 and42 0x2 +__ulonglong and420x2 and42 0x2 +int or420x2 or42 0x2a +__uint or420x2 or42 0x2a +char or420x2 or42 0x2a +__uchar or420x2 or42 0x2a +__longlong or420x2 or42 0x2a +__ulonglong or420x2 or42 0x2a +int shl50x2 shl5 0x40 +__uint shl50x2 shl5 0x40 +char shl50x2 shl5 0x40 +__uchar shl50x2 shl5 0x40 +__longlong shl50x2 shl5 0x40 +__ulonglong shl50x2 shl5 0x40 +int shr50x2 shr5 0x0 +__uint shr50x2 shr5 0x0 +char shr50x2 shr5 0x0 +__uchar shr50x2 shr5 0x0 +__longlong shr50x2 shr5 0x0 +__ulonglong shr50x2 shr5 0x0 +int add420x2 add42 0x2c +__uint add420x2 add42 0x2c +char add420x2 add42 0x2c +__uchar add420x2 add42 0x2c +__longlong add420x2 add42 0x2c +__ulonglong add420x2 add42 0x2c +float add420x2 add42 0x2c +int sub420x2 sub42 -0x28 +__uint sub420x2 sub42 -0x28 +char sub420x2 sub42 -0x28 +__uchar sub420x2 sub42 0xd8 +__longlong sub420x2 sub42 -0x28 +__ulonglong sub420x2 sub42 -0x28 +float sub420x2 sub42 -0x28 +int mul420x2 mul42 0x54 +__uint mul420x2 mul42 0x54 +char mul420x2 mul42 0x54 +__uchar mul420x2 mul42 0x54 +__longlong mul420x2 mul42 0x54 +__ulonglong mul420x2 mul42 0x54 +float mul420x2 mul42 0x54 +int lt420x2 lt42 0x1 +__uint lt420x2 lt42 0x1 +char lt420x2 lt42 0x1 +__uchar lt420x2 lt42 0x1 +__longlong lt420x2 lt42 0x1 +__ulonglong lt420x2 lt42 0x1 +float lt420x2 lt42 0x1 +int gt420x2 gt42 0x0 +__uint gt420x2 gt42 0x0 +char gt420x2 gt42 0x0 +__uchar gt420x2 gt42 0x0 +__longlong gt420x2 gt42 0x0 +__ulonglong gt420x2 gt42 0x0 +float gt420x2 gt42 0x0 +int le420x2 le42 0x1 +__uint le420x2 le42 0x1 +char le420x2 le42 0x1 +__uchar le420x2 le42 0x1 +__longlong le420x2 le42 0x1 +__ulonglong le420x2 le42 0x1 +float le420x2 le42 0x1 +int eq420x2 eq42 0x0 +__uint eq420x2 eq42 0x0 +char eq420x2 eq42 0x0 +__uchar eq420x2 eq42 0x0 +__longlong eq420x2 eq42 0x0 +__ulonglong eq420x2 eq42 0x0 +float eq420x2 eq42 0x0 +int ne420x2 ne42 0x1 +__uint ne420x2 ne42 0x1 +char ne420x2 ne42 0x1 +__uchar ne420x2 ne42 0x1 +__longlong ne420x2 ne42 0x1 +__ulonglong ne420x2 ne42 0x1 +float ne420x2 ne42 0x1 +int ge420x2 ge42 0x0 +__uint ge420x2 ge42 0x0 +char ge420x2 ge42 0x0 +__uchar ge420x2 ge42 0x0 +__longlong ge420x2 ge42 0x0 +__ulonglong ge420x2 ge42 0x0 +float ge420x2 ge42 0x0 +int div420x2 div42 0x0 +__uint div420x2 div42 0x0 +char div420x2 div42 0x0 +__uchar div420x2 div42 0x0 +__longlong div420x2 div42 0x0 +__ulonglong div420x2 div42 0x0 +float div420x2 div42 0x0 +int mod230x2 mod23 0x2 +__uint mod230x2 mod23 0x2 +char mod230x2 mod23 0x2 +__uchar mod230x2 mod23 0x2 +__longlong mod230x2 mod23 0x2 +__ulonglong mod230x2 mod23 0x2 +0xfffe * 0xffff == 0x2 +0xfffe / 0xffff == 0x2 +0xfffe % 0xffff == 0x0 +int 0xfffe ^ 0xffff == 0x1 (0x1) +__uint 0xfffe ^ 0xffff == 0x1 (0x1) +char 0xfffe ^ 0xffff == 0x1 (0x1) +__uchar 0xfe ^ 0xff == 0x1 (0x1) +__longlong 0xfffe ^ 0xffff == 0x1 (0x1) +__ulonglong 0xfffe ^ 0xffff == 0x1 (0x1) +int 0xfffe && 0xffff == 0x1 (0x1) +__uint 0xfffe && 0xffff == 0x1 (0x1) +char 0xfffe && 0xffff == 0x1 (0x1) +__uchar 0xfe && 0xff == 0x1 (0x1) +__longlong 0xfffe && 0xffff == 0x1 (0x1) +__ulonglong 0xfffe && 0xffff == 0x1 (0x1) +int 0xfffe || 0xffff == 0x1 (0x1) +__uint 0xfffe || 0xffff == 0x1 (0x1) +char 0xfffe || 0xffff == 0x1 (0x1) +__uchar 0xfe || 0xff == 0x1 (0x1) +__longlong 0xfffe || 0xffff == 0x1 (0x1) +__ulonglong 0xfffe || 0xffff == 0x1 (0x1) +int 0xfffe & 0xffff == -0x2 (0xfffe) +__uint 0xfffe & 0xffff == -0x2 (0xfffe) +char 0xfffe & 0xffff == -0x2 (0xfffe) +__uchar 0xfe & 0xff == 0xfe (0xfe) +__longlong 0xfffe & 0xffff == -0x2 (0xfffe) +__ulonglong 0xfffe & 0xffff == -0x2 (0xfffe) +int 0xfffe | 0xffff == -0x1 (0xffff) +__uint 0xfffe | 0xffff == -0x1 (0xffff) +char 0xfffe | 0xffff == -0x1 (0xffff) +__uchar 0xfe | 0xff == 0xff (0xff) +__longlong 0xfffe | 0xffff == -0x1 (0xffff) +__ulonglong 0xfffe | 0xffff == -0x1 (0xffff) +int 0xfffe << 0x1 == -0x4 (0xfffc) +__uint 0xfffe << 0x1 == -0x4 (0xfffc) +char 0xfffe << 0x1 == -0x4 (0xfffc) +__uchar 0xfe << 0x1 == 0xfc (0xfc) +__longlong 0xfffe << 0x1 == -0x4 (0xfffc) +__ulonglong 0xfffe << 0x1 == -0x4 (0xfffc) +int 0xfffe >> 0x1 == -0x1 (0xffff) +__uint 0xfffe >> 0x1 == 0x7fff (0x7fff) +char 0xfffe >> 0x1 == -0x1 (0xffff) +__uchar 0xfe >> 0x1 == 0x7f (0x7f) +__longlong 0xfffe >> 0x1 == -0x1 (0xffff) +__ulonglong 0xfffe >> 0x1 == -0x1 (0xffff) +int 0xfffe + 0xffff == -0x3 (0xfffd) +__uint 0xfffe + 0xffff == -0x3 (0xfffd) +char 0xfffe + 0xffff == -0x3 (0xfffd) +__uchar 0xfe + 0xff == 0xfd (0xfd) +__longlong 0xfffe + 0xffff == -0x3 (0xfffd) +__ulonglong 0xfffe + 0xffff == -0x3 (0xfffd) +float 0xfffe + 0xffff == -0x3 (0xfffd) +int 0xfffe - 0xffff == -0x1 (0xffff) +__uint 0xfffe - 0xffff == -0x1 (0xffff) +char 0xfffe - 0xffff == -0x1 (0xffff) +__uchar 0xfe - 0xff == 0xff (0xff) +__longlong 0xfffe - 0xffff == -0x1 (0xffff) +__ulonglong 0xfffe - 0xffff == -0x1 (0xffff) +float 0xfffe - 0xffff == -0x1 (0xffff) +int 0xfffe * 0xffff == 0x2 (0x2) +__uint 0xfffe * 0xffff == 0x2 (0x2) +char 0xfffe * 0xffff == 0x2 (0x2) +__uchar 0xfe * 0xff == 0x2 (0x2) +__longlong 0xfffe * 0xffff == 0x2 (0x2) +__ulonglong 0xfffe * 0xffff == 0x2 (0x2) +float 0xfffe * 0xffff == 0x2 (0x2) +int 0xfffe < 0xffff == 0x1 (0x1) +__uint 0xfffe < 0xffff == 0x1 (0x1) +char 0xfffe < 0xffff == 0x1 (0x1) +__uchar 0xfe < 0xff == 0x1 (0x1) +__longlong 0xfffe < 0xffff == 0x1 (0x1) +__ulonglong 0xfffe < 0xffff == 0x1 (0x1) +float 0xfffe < 0xffff == 0x1 (0x1) +int 0xfffe > 0xffff == 0x0 (0x0) +__uint 0xfffe > 0xffff == 0x0 (0x0) +char 0xfffe > 0xffff == 0x0 (0x0) +__uchar 0xfe > 0xff == 0x0 (0x0) +__longlong 0xfffe > 0xffff == 0x0 (0x0) +__ulonglong 0xfffe > 0xffff == 0x0 (0x0) +float 0xfffe > 0xffff == 0x0 (0x0) +int 0xfffe <= 0xffff == 0x1 (0x1) +__uint 0xfffe <= 0xffff == 0x1 (0x1) +char 0xfffe <= 0xffff == 0x1 (0x1) +__uchar 0xfe <= 0xff == 0x1 (0x1) +__longlong 0xfffe <= 0xffff == 0x1 (0x1) +__ulonglong 0xfffe <= 0xffff == 0x1 (0x1) +float 0xfffe <= 0xffff == 0x1 (0x1) +int 0xfffe == 0xffff == 0x0 (0x0) +__uint 0xfffe == 0xffff == 0x0 (0x0) +char 0xfffe == 0xffff == 0x0 (0x0) +__uchar 0xfe == 0xff == 0x0 (0x0) +__longlong 0xfffe == 0xffff == 0x0 (0x0) +__ulonglong 0xfffe == 0xffff == 0x0 (0x0) +float 0xfffe == 0xffff == 0x0 (0x0) +int 0xfffe != 0xffff == 0x1 (0x1) +__uint 0xfffe != 0xffff == 0x1 (0x1) +char 0xfffe != 0xffff == 0x1 (0x1) +__uchar 0xfe != 0xff == 0x1 (0x1) +__longlong 0xfffe != 0xffff == 0x1 (0x1) +__ulonglong 0xfffe != 0xffff == 0x1 (0x1) +float 0xfffe != 0xffff == 0x1 (0x1) +int 0xfffe >= 0xffff == 0x0 (0x0) +__uint 0xfffe >= 0xffff == 0x0 (0x0) +char 0xfffe >= 0xffff == 0x0 (0x0) +__uchar 0xfe >= 0xff == 0x0 (0x0) +__longlong 0xfffe >= 0xffff == 0x0 (0x0) +__ulonglong 0xfffe >= 0xffff == 0x0 (0x0) +float 0xfffe >= 0xffff == 0x0 (0x0) +int 0xfffe / 0xffff == 0x2 (0x2) +__uint 0xfffe / 0xffff == 0x0 (0x0) +char 0xfffe / 0xffff == 0x2 (0x2) +__uchar 0xfe / 0xff == 0x0 (0x0) +__longlong 0xfffe / 0xffff == 0x2 (0x2) +__ulonglong 0xfffe / 0xffff == 0x0 (0x0) +float 0xfffe / 0xffff == 0x2 (0x2) +int 0xfffe % 0xffff == 0x0 (0x0) +__uint 0xfffe % 0xffff == -0x2 (0xfffe) +char 0xfffe % 0xffff == 0x0 (0x0) +__uchar 0xfe % 0xff == 0xfe (0xfe) +__longlong 0xfffe % 0xffff == 0x0 (0x0) +__ulonglong 0xfffe % 0xffff == -0x2 (0xfffe) +0xfffe * 0x1 == -0x2 +0xfffe / 0x1 == -0x2 +0xfffe % 0x1 == 0x0 +int 0xfffe ^ 0x1 == -0x1 (0xffff) +__uint 0xfffe ^ 0x1 == -0x1 (0xffff) +char 0xfffe ^ 0x1 == -0x1 (0xffff) +__uchar 0xfe ^ 0x1 == 0xff (0xff) +__longlong 0xfffe ^ 0x1 == -0x1 (0xffff) +__ulonglong 0xfffe ^ 0x1 == -0x1 (0xffff) +int 0xfffe && 0x1 == 0x1 (0x1) +__uint 0xfffe && 0x1 == 0x1 (0x1) +char 0xfffe && 0x1 == 0x1 (0x1) +__uchar 0xfe && 0x1 == 0x1 (0x1) +__longlong 0xfffe && 0x1 == 0x1 (0x1) +__ulonglong 0xfffe && 0x1 == 0x1 (0x1) +int 0xfffe || 0x1 == 0x1 (0x1) +__uint 0xfffe || 0x1 == 0x1 (0x1) +char 0xfffe || 0x1 == 0x1 (0x1) +__uchar 0xfe || 0x1 == 0x1 (0x1) +__longlong 0xfffe || 0x1 == 0x1 (0x1) +__ulonglong 0xfffe || 0x1 == 0x1 (0x1) +int 0xfffe & 0x1 == 0x0 (0x0) +__uint 0xfffe & 0x1 == 0x0 (0x0) +char 0xfffe & 0x1 == 0x0 (0x0) +__uchar 0xfe & 0x1 == 0x0 (0x0) +__longlong 0xfffe & 0x1 == 0x0 (0x0) +__ulonglong 0xfffe & 0x1 == 0x0 (0x0) +int 0xfffe | 0x1 == -0x1 (0xffff) +__uint 0xfffe | 0x1 == -0x1 (0xffff) +char 0xfffe | 0x1 == -0x1 (0xffff) +__uchar 0xfe | 0x1 == 0xff (0xff) +__longlong 0xfffe | 0x1 == -0x1 (0xffff) +__ulonglong 0xfffe | 0x1 == -0x1 (0xffff) +int 0xfffe << 0x2 == -0x8 (0xfff8) +__uint 0xfffe << 0x2 == -0x8 (0xfff8) +char 0xfffe << 0x2 == -0x8 (0xfff8) +__uchar 0xfe << 0x2 == 0xf8 (0xf8) +__longlong 0xfffe << 0x2 == -0x8 (0xfff8) +__ulonglong 0xfffe << 0x2 == -0x8 (0xfff8) +int 0xfffe >> 0x2 == -0x1 (0xffff) +__uint 0xfffe >> 0x2 == 0x3fff (0x3fff) +char 0xfffe >> 0x2 == -0x1 (0xffff) +__uchar 0xfe >> 0x2 == 0x3f (0x3f) +__longlong 0xfffe >> 0x2 == -0x1 (0xffff) +__ulonglong 0xfffe >> 0x2 == -0x1 (0xffff) +int 0xfffe + 0x1 == -0x1 (0xffff) +__uint 0xfffe + 0x1 == -0x1 (0xffff) +char 0xfffe + 0x1 == -0x1 (0xffff) +__uchar 0xfe + 0x1 == 0xff (0xff) +__longlong 0xfffe + 0x1 == -0x1 (0xffff) +__ulonglong 0xfffe + 0x1 == -0x1 (0xffff) +float 0xfffe + 0x1 == -0x1 (0xffff) +int 0xfffe - 0x1 == -0x3 (0xfffd) +__uint 0xfffe - 0x1 == -0x3 (0xfffd) +char 0xfffe - 0x1 == -0x3 (0xfffd) +__uchar 0xfe - 0x1 == 0xfd (0xfd) +__longlong 0xfffe - 0x1 == -0x3 (0xfffd) +__ulonglong 0xfffe - 0x1 == -0x3 (0xfffd) +float 0xfffe - 0x1 == -0x3 (0xfffd) +int 0xfffe * 0x1 == -0x2 (0xfffe) +__uint 0xfffe * 0x1 == -0x2 (0xfffe) +char 0xfffe * 0x1 == -0x2 (0xfffe) +__uchar 0xfe * 0x1 == 0xfe (0xfe) +__longlong 0xfffe * 0x1 == -0x2 (0xfffe) +__ulonglong 0xfffe * 0x1 == -0x2 (0xfffe) +float 0xfffe * 0x1 == -0x2 (0xfffe) +int 0xfffe < 0x1 == 0x1 (0x1) +__uint 0xfffe < 0x1 == 0x0 (0x0) +char 0xfffe < 0x1 == 0x1 (0x1) +__uchar 0xfe < 0x1 == 0x0 (0x0) +__longlong 0xfffe < 0x1 == 0x1 (0x1) +__ulonglong 0xfffe < 0x1 == 0x0 (0x0) +float 0xfffe < 0x1 == 0x1 (0x1) +int 0xfffe > 0x1 == 0x0 (0x0) +__uint 0xfffe > 0x1 == 0x1 (0x1) +char 0xfffe > 0x1 == 0x0 (0x0) +__uchar 0xfe > 0x1 == 0x1 (0x1) +__longlong 0xfffe > 0x1 == 0x0 (0x0) +__ulonglong 0xfffe > 0x1 == 0x1 (0x1) +float 0xfffe > 0x1 == 0x0 (0x0) +int 0xfffe <= 0x1 == 0x1 (0x1) +__uint 0xfffe <= 0x1 == 0x0 (0x0) +char 0xfffe <= 0x1 == 0x1 (0x1) +__uchar 0xfe <= 0x1 == 0x0 (0x0) +__longlong 0xfffe <= 0x1 == 0x1 (0x1) +__ulonglong 0xfffe <= 0x1 == 0x0 (0x0) +float 0xfffe <= 0x1 == 0x1 (0x1) +int 0xfffe == 0x1 == 0x0 (0x0) +__uint 0xfffe == 0x1 == 0x0 (0x0) +char 0xfffe == 0x1 == 0x0 (0x0) +__uchar 0xfe == 0x1 == 0x0 (0x0) +__longlong 0xfffe == 0x1 == 0x0 (0x0) +__ulonglong 0xfffe == 0x1 == 0x0 (0x0) +float 0xfffe == 0x1 == 0x0 (0x0) +int 0xfffe != 0x1 == 0x1 (0x1) +__uint 0xfffe != 0x1 == 0x1 (0x1) +char 0xfffe != 0x1 == 0x1 (0x1) +__uchar 0xfe != 0x1 == 0x1 (0x1) +__longlong 0xfffe != 0x1 == 0x1 (0x1) +__ulonglong 0xfffe != 0x1 == 0x1 (0x1) +float 0xfffe != 0x1 == 0x1 (0x1) +int 0xfffe >= 0x1 == 0x0 (0x0) +__uint 0xfffe >= 0x1 == 0x1 (0x1) +char 0xfffe >= 0x1 == 0x0 (0x0) +__uchar 0xfe >= 0x1 == 0x1 (0x1) +__longlong 0xfffe >= 0x1 == 0x0 (0x0) +__ulonglong 0xfffe >= 0x1 == 0x1 (0x1) +float 0xfffe >= 0x1 == 0x0 (0x0) +int 0xfffe / 0x1 == -0x2 (0xfffe) +__uint 0xfffe / 0x1 == -0x2 (0xfffe) +char 0xfffe / 0x1 == -0x2 (0xfffe) +__uchar 0xfe / 0x1 == 0xfe (0xfe) +__longlong 0xfffe / 0x1 == -0x2 (0xfffe) +__ulonglong 0xfffe / 0x1 == -0x2 (0xfffe) +float 0xfffe / 0x1 == -0x2 (0xfffe) +int 0xfffe % 0x1 == 0x0 (0x0) +__uint 0xfffe % 0x1 == 0x0 (0x0) +char 0xfffe % 0x1 == 0x0 (0x0) +__uchar 0xfe % 0x1 == 0x0 (0x0) +__longlong 0xfffe % 0x1 == 0x0 (0x0) +__ulonglong 0xfffe % 0x1 == 0x0 (0x0) +0xfffe * 0x2 == -0x4 +0xfffe / 0x2 == -0x1 +0xfffe % 0x2 == 0x0 +int 0xfffe ^ 0x2 == -0x4 (0xfffc) +__uint 0xfffe ^ 0x2 == -0x4 (0xfffc) +char 0xfffe ^ 0x2 == -0x4 (0xfffc) +__uchar 0xfe ^ 0x2 == 0xfc (0xfc) +__longlong 0xfffe ^ 0x2 == -0x4 (0xfffc) +__ulonglong 0xfffe ^ 0x2 == -0x4 (0xfffc) +int 0xfffe && 0x2 == 0x1 (0x1) +__uint 0xfffe && 0x2 == 0x1 (0x1) +char 0xfffe && 0x2 == 0x1 (0x1) +__uchar 0xfe && 0x2 == 0x1 (0x1) +__longlong 0xfffe && 0x2 == 0x1 (0x1) +__ulonglong 0xfffe && 0x2 == 0x1 (0x1) +int 0xfffe || 0x2 == 0x1 (0x1) +__uint 0xfffe || 0x2 == 0x1 (0x1) +char 0xfffe || 0x2 == 0x1 (0x1) +__uchar 0xfe || 0x2 == 0x1 (0x1) +__longlong 0xfffe || 0x2 == 0x1 (0x1) +__ulonglong 0xfffe || 0x2 == 0x1 (0x1) +int 0xfffe & 0x2 == 0x2 (0x2) +__uint 0xfffe & 0x2 == 0x2 (0x2) +char 0xfffe & 0x2 == 0x2 (0x2) +__uchar 0xfe & 0x2 == 0x2 (0x2) +__longlong 0xfffe & 0x2 == 0x2 (0x2) +__ulonglong 0xfffe & 0x2 == 0x2 (0x2) +int 0xfffe | 0x2 == -0x2 (0xfffe) +__uint 0xfffe | 0x2 == -0x2 (0xfffe) +char 0xfffe | 0x2 == -0x2 (0xfffe) +__uchar 0xfe | 0x2 == 0xfe (0xfe) +__longlong 0xfffe | 0x2 == -0x2 (0xfffe) +__ulonglong 0xfffe | 0x2 == -0x2 (0xfffe) +int 0xfffe << 0x3 == -0x10 (0xfff0) +__uint 0xfffe << 0x3 == -0x10 (0xfff0) +char 0xfffe << 0x3 == -0x10 (0xfff0) +__uchar 0xfe << 0x3 == 0xf0 (0xf0) +__longlong 0xfffe << 0x3 == -0x10 (0xfff0) +__ulonglong 0xfffe << 0x3 == -0x10 (0xfff0) +int 0xfffe >> 0x3 == -0x1 (0xffff) +__uint 0xfffe >> 0x3 == 0x1fff (0x1fff) +char 0xfffe >> 0x3 == -0x1 (0xffff) +__uchar 0xfe >> 0x3 == 0x1f (0x1f) +__longlong 0xfffe >> 0x3 == -0x1 (0xffff) +__ulonglong 0xfffe >> 0x3 == -0x1 (0xffff) +int 0xfffe + 0x2 == 0x0 (0x0) +__uint 0xfffe + 0x2 == 0x0 (0x0) +char 0xfffe + 0x2 == 0x0 (0x0) +__uchar 0xfe + 0x2 == 0x0 (0x0) +__longlong 0xfffe + 0x2 == 0x0 (0x0) +__ulonglong 0xfffe + 0x2 == 0x0 (0x0) +float 0xfffe + 0x2 == 0x0 (0x0) +int 0xfffe - 0x2 == -0x4 (0xfffc) +__uint 0xfffe - 0x2 == -0x4 (0xfffc) +char 0xfffe - 0x2 == -0x4 (0xfffc) +__uchar 0xfe - 0x2 == 0xfc (0xfc) +__longlong 0xfffe - 0x2 == -0x4 (0xfffc) +__ulonglong 0xfffe - 0x2 == -0x4 (0xfffc) +float 0xfffe - 0x2 == -0x4 (0xfffc) +int 0xfffe * 0x2 == -0x4 (0xfffc) +__uint 0xfffe * 0x2 == -0x4 (0xfffc) +char 0xfffe * 0x2 == -0x4 (0xfffc) +__uchar 0xfe * 0x2 == 0xfc (0xfc) +__longlong 0xfffe * 0x2 == -0x4 (0xfffc) +__ulonglong 0xfffe * 0x2 == -0x4 (0xfffc) +float 0xfffe * 0x2 == -0x4 (0xfffc) +int 0xfffe < 0x2 == 0x1 (0x1) +__uint 0xfffe < 0x2 == 0x0 (0x0) +char 0xfffe < 0x2 == 0x1 (0x1) +__uchar 0xfe < 0x2 == 0x0 (0x0) +__longlong 0xfffe < 0x2 == 0x1 (0x1) +__ulonglong 0xfffe < 0x2 == 0x0 (0x0) +float 0xfffe < 0x2 == 0x1 (0x1) +int 0xfffe > 0x2 == 0x0 (0x0) +__uint 0xfffe > 0x2 == 0x1 (0x1) +char 0xfffe > 0x2 == 0x0 (0x0) +__uchar 0xfe > 0x2 == 0x1 (0x1) +__longlong 0xfffe > 0x2 == 0x0 (0x0) +__ulonglong 0xfffe > 0x2 == 0x1 (0x1) +float 0xfffe > 0x2 == 0x0 (0x0) +int 0xfffe <= 0x2 == 0x1 (0x1) +__uint 0xfffe <= 0x2 == 0x0 (0x0) +char 0xfffe <= 0x2 == 0x1 (0x1) +__uchar 0xfe <= 0x2 == 0x0 (0x0) +__longlong 0xfffe <= 0x2 == 0x1 (0x1) +__ulonglong 0xfffe <= 0x2 == 0x0 (0x0) +float 0xfffe <= 0x2 == 0x1 (0x1) +int 0xfffe == 0x2 == 0x0 (0x0) +__uint 0xfffe == 0x2 == 0x0 (0x0) +char 0xfffe == 0x2 == 0x0 (0x0) +__uchar 0xfe == 0x2 == 0x0 (0x0) +__longlong 0xfffe == 0x2 == 0x0 (0x0) +__ulonglong 0xfffe == 0x2 == 0x0 (0x0) +float 0xfffe == 0x2 == 0x0 (0x0) +int 0xfffe != 0x2 == 0x1 (0x1) +__uint 0xfffe != 0x2 == 0x1 (0x1) +char 0xfffe != 0x2 == 0x1 (0x1) +__uchar 0xfe != 0x2 == 0x1 (0x1) +__longlong 0xfffe != 0x2 == 0x1 (0x1) +__ulonglong 0xfffe != 0x2 == 0x1 (0x1) +float 0xfffe != 0x2 == 0x1 (0x1) +int 0xfffe >= 0x2 == 0x0 (0x0) +__uint 0xfffe >= 0x2 == 0x1 (0x1) +char 0xfffe >= 0x2 == 0x0 (0x0) +__uchar 0xfe >= 0x2 == 0x1 (0x1) +__longlong 0xfffe >= 0x2 == 0x0 (0x0) +__ulonglong 0xfffe >= 0x2 == 0x1 (0x1) +float 0xfffe >= 0x2 == 0x0 (0x0) +int 0xfffe / 0x2 == -0x1 (0xffff) +__uint 0xfffe / 0x2 == 0x7fff (0x7fff) +char 0xfffe / 0x2 == -0x1 (0xffff) +__uchar 0xfe / 0x2 == 0x7f (0x7f) +__longlong 0xfffe / 0x2 == -0x1 (0xffff) +__ulonglong 0xfffe / 0x2 == -0x1 (0xffff) +float 0xfffe / 0x2 == -0x1 (0xffff) +int 0xfffe % 0x2 == 0x0 (0x0) +__uint 0xfffe % 0x2 == 0x0 (0x0) +char 0xfffe % 0x2 == 0x0 (0x0) +__uchar 0xfe % 0x2 == 0x0 (0x0) +__longlong 0xfffe % 0x2 == 0x0 (0x0) +__ulonglong 0xfffe % 0x2 == 0x0 (0x0) +0xfffe * 0xfffe == 0x4 +0xfffe / 0xfffe == 0x1 +0xfffe % 0xfffe == 0x0 +int 0xfffe ^ 0xfffe == 0x0 (0x0) +__uint 0xfffe ^ 0xfffe == 0x0 (0x0) +char 0xfffe ^ 0xfffe == 0x0 (0x0) +__uchar 0xfe ^ 0xfe == 0x0 (0x0) +__longlong 0xfffe ^ 0xfffe == 0x0 (0x0) +__ulonglong 0xfffe ^ 0xfffe == 0x0 (0x0) +int 0xfffe && 0xfffe == 0x1 (0x1) +__uint 0xfffe && 0xfffe == 0x1 (0x1) +char 0xfffe && 0xfffe == 0x1 (0x1) +__uchar 0xfe && 0xfe == 0x1 (0x1) +__longlong 0xfffe && 0xfffe == 0x1 (0x1) +__ulonglong 0xfffe && 0xfffe == 0x1 (0x1) +int 0xfffe || 0xfffe == 0x1 (0x1) +__uint 0xfffe || 0xfffe == 0x1 (0x1) +char 0xfffe || 0xfffe == 0x1 (0x1) +__uchar 0xfe || 0xfe == 0x1 (0x1) +__longlong 0xfffe || 0xfffe == 0x1 (0x1) +__ulonglong 0xfffe || 0xfffe == 0x1 (0x1) +int 0xfffe & 0xfffe == -0x2 (0xfffe) +__uint 0xfffe & 0xfffe == -0x2 (0xfffe) +char 0xfffe & 0xfffe == -0x2 (0xfffe) +__uchar 0xfe & 0xfe == 0xfe (0xfe) +__longlong 0xfffe & 0xfffe == -0x2 (0xfffe) +__ulonglong 0xfffe & 0xfffe == -0x2 (0xfffe) +int 0xfffe | 0xfffe == -0x2 (0xfffe) +__uint 0xfffe | 0xfffe == -0x2 (0xfffe) +char 0xfffe | 0xfffe == -0x2 (0xfffe) +__uchar 0xfe | 0xfe == 0xfe (0xfe) +__longlong 0xfffe | 0xfffe == -0x2 (0xfffe) +__ulonglong 0xfffe | 0xfffe == -0x2 (0xfffe) +int 0xfffe << 0x4 == -0x20 (0xffe0) +__uint 0xfffe << 0x4 == -0x20 (0xffe0) +char 0xfffe << 0x4 == -0x20 (0xffe0) +__uchar 0xfe << 0x4 == 0xe0 (0xe0) +__longlong 0xfffe << 0x4 == -0x20 (0xffe0) +__ulonglong 0xfffe << 0x4 == -0x20 (0xffe0) +int 0xfffe >> 0x4 == -0x1 (0xffff) +__uint 0xfffe >> 0x4 == 0xfff (0xfff) +char 0xfffe >> 0x4 == -0x1 (0xffff) +__uchar 0xfe >> 0x4 == 0xf (0xf) +__longlong 0xfffe >> 0x4 == -0x1 (0xffff) +__ulonglong 0xfffe >> 0x4 == -0x1 (0xffff) +int 0xfffe + 0xfffe == -0x4 (0xfffc) +__uint 0xfffe + 0xfffe == -0x4 (0xfffc) +char 0xfffe + 0xfffe == -0x4 (0xfffc) +__uchar 0xfe + 0xfe == 0xfc (0xfc) +__longlong 0xfffe + 0xfffe == -0x4 (0xfffc) +__ulonglong 0xfffe + 0xfffe == -0x4 (0xfffc) +float 0xfffe + 0xfffe == -0x4 (0xfffc) +int 0xfffe - 0xfffe == 0x0 (0x0) +__uint 0xfffe - 0xfffe == 0x0 (0x0) +char 0xfffe - 0xfffe == 0x0 (0x0) +__uchar 0xfe - 0xfe == 0x0 (0x0) +__longlong 0xfffe - 0xfffe == 0x0 (0x0) +__ulonglong 0xfffe - 0xfffe == 0x0 (0x0) +float 0xfffe - 0xfffe == 0x0 (0x0) +int 0xfffe * 0xfffe == 0x4 (0x4) +__uint 0xfffe * 0xfffe == 0x4 (0x4) +char 0xfffe * 0xfffe == 0x4 (0x4) +__uchar 0xfe * 0xfe == 0x4 (0x4) +__longlong 0xfffe * 0xfffe == 0x4 (0x4) +__ulonglong 0xfffe * 0xfffe == 0x4 (0x4) +float 0xfffe * 0xfffe == 0x4 (0x4) +int 0xfffe < 0xfffe == 0x0 (0x0) +__uint 0xfffe < 0xfffe == 0x0 (0x0) +char 0xfffe < 0xfffe == 0x0 (0x0) +__uchar 0xfe < 0xfe == 0x0 (0x0) +__longlong 0xfffe < 0xfffe == 0x0 (0x0) +__ulonglong 0xfffe < 0xfffe == 0x0 (0x0) +float 0xfffe < 0xfffe == 0x0 (0x0) +int 0xfffe > 0xfffe == 0x0 (0x0) +__uint 0xfffe > 0xfffe == 0x0 (0x0) +char 0xfffe > 0xfffe == 0x0 (0x0) +__uchar 0xfe > 0xfe == 0x0 (0x0) +__longlong 0xfffe > 0xfffe == 0x0 (0x0) +__ulonglong 0xfffe > 0xfffe == 0x0 (0x0) +float 0xfffe > 0xfffe == 0x0 (0x0) +int 0xfffe <= 0xfffe == 0x1 (0x1) +__uint 0xfffe <= 0xfffe == 0x1 (0x1) +char 0xfffe <= 0xfffe == 0x1 (0x1) +__uchar 0xfe <= 0xfe == 0x1 (0x1) +__longlong 0xfffe <= 0xfffe == 0x1 (0x1) +__ulonglong 0xfffe <= 0xfffe == 0x1 (0x1) +float 0xfffe <= 0xfffe == 0x1 (0x1) +int 0xfffe == 0xfffe == 0x1 (0x1) +__uint 0xfffe == 0xfffe == 0x1 (0x1) +char 0xfffe == 0xfffe == 0x1 (0x1) +__uchar 0xfe == 0xfe == 0x1 (0x1) +__longlong 0xfffe == 0xfffe == 0x1 (0x1) +__ulonglong 0xfffe == 0xfffe == 0x1 (0x1) +float 0xfffe == 0xfffe == 0x1 (0x1) +int 0xfffe != 0xfffe == 0x0 (0x0) +__uint 0xfffe != 0xfffe == 0x0 (0x0) +char 0xfffe != 0xfffe == 0x0 (0x0) +__uchar 0xfe != 0xfe == 0x0 (0x0) +__longlong 0xfffe != 0xfffe == 0x0 (0x0) +__ulonglong 0xfffe != 0xfffe == 0x0 (0x0) +float 0xfffe != 0xfffe == 0x0 (0x0) +int 0xfffe >= 0xfffe == 0x1 (0x1) +__uint 0xfffe >= 0xfffe == 0x1 (0x1) +char 0xfffe >= 0xfffe == 0x1 (0x1) +__uchar 0xfe >= 0xfe == 0x1 (0x1) +__longlong 0xfffe >= 0xfffe == 0x1 (0x1) +__ulonglong 0xfffe >= 0xfffe == 0x1 (0x1) +float 0xfffe >= 0xfffe == 0x1 (0x1) +int 0xfffe / 0xfffe == 0x1 (0x1) +__uint 0xfffe / 0xfffe == 0x1 (0x1) +char 0xfffe / 0xfffe == 0x1 (0x1) +__uchar 0xfe / 0xfe == 0x1 (0x1) +__longlong 0xfffe / 0xfffe == 0x1 (0x1) +__ulonglong 0xfffe / 0xfffe == 0x1 (0x1) +float 0xfffe / 0xfffe == 0x1 (0x1) +int 0xfffe % 0xfffe == 0x0 (0x0) +__uint 0xfffe % 0xfffe == 0x0 (0x0) +char 0xfffe % 0xfffe == 0x0 (0x0) +__uchar 0xfe % 0xfe == 0x0 (0x0) +__longlong 0xfffe % 0xfffe == 0x0 (0x0) +__ulonglong 0xfffe % 0xfffe == 0x0 (0x0) +0xfffe * 0x4 == -0x8 +0xfffe / 0x4 == 0x0 +0xfffe % 0x4 == -0x2 +int 0xfffe ^ 0x4 == -0x6 (0xfffa) +__uint 0xfffe ^ 0x4 == -0x6 (0xfffa) +char 0xfffe ^ 0x4 == -0x6 (0xfffa) +__uchar 0xfe ^ 0x4 == 0xfa (0xfa) +__longlong 0xfffe ^ 0x4 == -0x6 (0xfffa) +__ulonglong 0xfffe ^ 0x4 == -0x6 (0xfffa) +int 0xfffe && 0x4 == 0x1 (0x1) +__uint 0xfffe && 0x4 == 0x1 (0x1) +char 0xfffe && 0x4 == 0x1 (0x1) +__uchar 0xfe && 0x4 == 0x1 (0x1) +__longlong 0xfffe && 0x4 == 0x1 (0x1) +__ulonglong 0xfffe && 0x4 == 0x1 (0x1) +int 0xfffe || 0x4 == 0x1 (0x1) +__uint 0xfffe || 0x4 == 0x1 (0x1) +char 0xfffe || 0x4 == 0x1 (0x1) +__uchar 0xfe || 0x4 == 0x1 (0x1) +__longlong 0xfffe || 0x4 == 0x1 (0x1) +__ulonglong 0xfffe || 0x4 == 0x1 (0x1) +int 0xfffe & 0x4 == 0x4 (0x4) +__uint 0xfffe & 0x4 == 0x4 (0x4) +char 0xfffe & 0x4 == 0x4 (0x4) +__uchar 0xfe & 0x4 == 0x4 (0x4) +__longlong 0xfffe & 0x4 == 0x4 (0x4) +__ulonglong 0xfffe & 0x4 == 0x4 (0x4) +int 0xfffe | 0x4 == -0x2 (0xfffe) +__uint 0xfffe | 0x4 == -0x2 (0xfffe) +char 0xfffe | 0x4 == -0x2 (0xfffe) +__uchar 0xfe | 0x4 == 0xfe (0xfe) +__longlong 0xfffe | 0x4 == -0x2 (0xfffe) +__ulonglong 0xfffe | 0x4 == -0x2 (0xfffe) +int 0xfffe << 0x5 == -0x40 (0xffc0) +__uint 0xfffe << 0x5 == -0x40 (0xffc0) +char 0xfffe << 0x5 == -0x40 (0xffc0) +__uchar 0xfe << 0x5 == 0xc0 (0xc0) +__longlong 0xfffe << 0x5 == -0x40 (0xffc0) +__ulonglong 0xfffe << 0x5 == -0x40 (0xffc0) +int 0xfffe >> 0x5 == -0x1 (0xffff) +__uint 0xfffe >> 0x5 == 0x7ff (0x7ff) +char 0xfffe >> 0x5 == -0x1 (0xffff) +__uchar 0xfe >> 0x5 == 0x7 (0x7) +__longlong 0xfffe >> 0x5 == -0x1 (0xffff) +__ulonglong 0xfffe >> 0x5 == -0x1 (0xffff) +int 0xfffe + 0x4 == 0x2 (0x2) +__uint 0xfffe + 0x4 == 0x2 (0x2) +char 0xfffe + 0x4 == 0x2 (0x2) +__uchar 0xfe + 0x4 == 0x2 (0x2) +__longlong 0xfffe + 0x4 == 0x2 (0x2) +__ulonglong 0xfffe + 0x4 == 0x2 (0x2) +float 0xfffe + 0x4 == 0x2 (0x2) +int 0xfffe - 0x4 == -0x6 (0xfffa) +__uint 0xfffe - 0x4 == -0x6 (0xfffa) +char 0xfffe - 0x4 == -0x6 (0xfffa) +__uchar 0xfe - 0x4 == 0xfa (0xfa) +__longlong 0xfffe - 0x4 == -0x6 (0xfffa) +__ulonglong 0xfffe - 0x4 == -0x6 (0xfffa) +float 0xfffe - 0x4 == -0x6 (0xfffa) +int 0xfffe * 0x4 == -0x8 (0xfff8) +__uint 0xfffe * 0x4 == -0x8 (0xfff8) +char 0xfffe * 0x4 == -0x8 (0xfff8) +__uchar 0xfe * 0x4 == 0xf8 (0xf8) +__longlong 0xfffe * 0x4 == -0x8 (0xfff8) +__ulonglong 0xfffe * 0x4 == -0x8 (0xfff8) +float 0xfffe * 0x4 == -0x8 (0xfff8) +int 0xfffe < 0x4 == 0x1 (0x1) +__uint 0xfffe < 0x4 == 0x0 (0x0) +char 0xfffe < 0x4 == 0x1 (0x1) +__uchar 0xfe < 0x4 == 0x0 (0x0) +__longlong 0xfffe < 0x4 == 0x1 (0x1) +__ulonglong 0xfffe < 0x4 == 0x0 (0x0) +float 0xfffe < 0x4 == 0x1 (0x1) +int 0xfffe > 0x4 == 0x0 (0x0) +__uint 0xfffe > 0x4 == 0x1 (0x1) +char 0xfffe > 0x4 == 0x0 (0x0) +__uchar 0xfe > 0x4 == 0x1 (0x1) +__longlong 0xfffe > 0x4 == 0x0 (0x0) +__ulonglong 0xfffe > 0x4 == 0x1 (0x1) +float 0xfffe > 0x4 == 0x0 (0x0) +int 0xfffe <= 0x4 == 0x1 (0x1) +__uint 0xfffe <= 0x4 == 0x0 (0x0) +char 0xfffe <= 0x4 == 0x1 (0x1) +__uchar 0xfe <= 0x4 == 0x0 (0x0) +__longlong 0xfffe <= 0x4 == 0x1 (0x1) +__ulonglong 0xfffe <= 0x4 == 0x0 (0x0) +float 0xfffe <= 0x4 == 0x1 (0x1) +int 0xfffe == 0x4 == 0x0 (0x0) +__uint 0xfffe == 0x4 == 0x0 (0x0) +char 0xfffe == 0x4 == 0x0 (0x0) +__uchar 0xfe == 0x4 == 0x0 (0x0) +__longlong 0xfffe == 0x4 == 0x0 (0x0) +__ulonglong 0xfffe == 0x4 == 0x0 (0x0) +float 0xfffe == 0x4 == 0x0 (0x0) +int 0xfffe != 0x4 == 0x1 (0x1) +__uint 0xfffe != 0x4 == 0x1 (0x1) +char 0xfffe != 0x4 == 0x1 (0x1) +__uchar 0xfe != 0x4 == 0x1 (0x1) +__longlong 0xfffe != 0x4 == 0x1 (0x1) +__ulonglong 0xfffe != 0x4 == 0x1 (0x1) +float 0xfffe != 0x4 == 0x1 (0x1) +int 0xfffe >= 0x4 == 0x0 (0x0) +__uint 0xfffe >= 0x4 == 0x1 (0x1) +char 0xfffe >= 0x4 == 0x0 (0x0) +__uchar 0xfe >= 0x4 == 0x1 (0x1) +__longlong 0xfffe >= 0x4 == 0x0 (0x0) +__ulonglong 0xfffe >= 0x4 == 0x1 (0x1) +float 0xfffe >= 0x4 == 0x0 (0x0) +int 0xfffe / 0x4 == 0x0 (0x0) +__uint 0xfffe / 0x4 == 0x3fff (0x3fff) +char 0xfffe / 0x4 == 0x0 (0x0) +__uchar 0xfe / 0x4 == 0x3f (0x3f) +__longlong 0xfffe / 0x4 == 0x0 (0x0) +__ulonglong 0xfffe / 0x4 == -0x1 (0xffff) +float 0xfffe / 0x4 == 0x0 (0x0) +int 0xfffe % 0x4 == -0x2 (0xfffe) +__uint 0xfffe % 0x4 == 0x2 (0x2) +char 0xfffe % 0x4 == -0x2 (0xfffe) +__uchar 0xfe % 0x4 == 0x2 (0x2) +__longlong 0xfffe % 0x4 == -0x2 (0xfffe) +__ulonglong 0xfffe % 0x4 == 0x2 (0x2) +0xfffe * 0xfffc == 0x8 +0xfffe / 0xfffc == 0x0 +0xfffe % 0xfffc == -0x2 +int 0xfffe ^ 0xfffc == 0x2 (0x2) +__uint 0xfffe ^ 0xfffc == 0x2 (0x2) +char 0xfffe ^ 0xfffc == 0x2 (0x2) +__uchar 0xfe ^ 0xfc == 0x2 (0x2) +__longlong 0xfffe ^ 0xfffc == 0x2 (0x2) +__ulonglong 0xfffe ^ 0xfffc == 0x2 (0x2) +int 0xfffe && 0xfffc == 0x1 (0x1) +__uint 0xfffe && 0xfffc == 0x1 (0x1) +char 0xfffe && 0xfffc == 0x1 (0x1) +__uchar 0xfe && 0xfc == 0x1 (0x1) +__longlong 0xfffe && 0xfffc == 0x1 (0x1) +__ulonglong 0xfffe && 0xfffc == 0x1 (0x1) +int 0xfffe || 0xfffc == 0x1 (0x1) +__uint 0xfffe || 0xfffc == 0x1 (0x1) +char 0xfffe || 0xfffc == 0x1 (0x1) +__uchar 0xfe || 0xfc == 0x1 (0x1) +__longlong 0xfffe || 0xfffc == 0x1 (0x1) +__ulonglong 0xfffe || 0xfffc == 0x1 (0x1) +int 0xfffe & 0xfffc == -0x4 (0xfffc) +__uint 0xfffe & 0xfffc == -0x4 (0xfffc) +char 0xfffe & 0xfffc == -0x4 (0xfffc) +__uchar 0xfe & 0xfc == 0xfc (0xfc) +__longlong 0xfffe & 0xfffc == -0x4 (0xfffc) +__ulonglong 0xfffe & 0xfffc == -0x4 (0xfffc) +int 0xfffe | 0xfffc == -0x2 (0xfffe) +__uint 0xfffe | 0xfffc == -0x2 (0xfffe) +char 0xfffe | 0xfffc == -0x2 (0xfffe) +__uchar 0xfe | 0xfc == 0xfe (0xfe) +__longlong 0xfffe | 0xfffc == -0x2 (0xfffe) +__ulonglong 0xfffe | 0xfffc == -0x2 (0xfffe) +int 0xfffe << 0x6 == -0x80 (0xff80) +__uint 0xfffe << 0x6 == -0x80 (0xff80) +char 0xfffe << 0x6 == -0x80 (0xff80) +__uchar 0xfe << 0x6 == 0x80 (0x80) +__longlong 0xfffe << 0x6 == -0x80 (0xff80) +__ulonglong 0xfffe << 0x6 == -0x80 (0xff80) +int 0xfffe >> 0x6 == -0x1 (0xffff) +__uint 0xfffe >> 0x6 == 0x3ff (0x3ff) +char 0xfffe >> 0x6 == -0x1 (0xffff) +__uchar 0xfe >> 0x6 == 0x3 (0x3) +__longlong 0xfffe >> 0x6 == -0x1 (0xffff) +__ulonglong 0xfffe >> 0x6 == -0x1 (0xffff) +int 0xfffe + 0xfffc == -0x6 (0xfffa) +__uint 0xfffe + 0xfffc == -0x6 (0xfffa) +char 0xfffe + 0xfffc == -0x6 (0xfffa) +__uchar 0xfe + 0xfc == 0xfa (0xfa) +__longlong 0xfffe + 0xfffc == -0x6 (0xfffa) +__ulonglong 0xfffe + 0xfffc == -0x6 (0xfffa) +float 0xfffe + 0xfffc == -0x6 (0xfffa) +int 0xfffe - 0xfffc == 0x2 (0x2) +__uint 0xfffe - 0xfffc == 0x2 (0x2) +char 0xfffe - 0xfffc == 0x2 (0x2) +__uchar 0xfe - 0xfc == 0x2 (0x2) +__longlong 0xfffe - 0xfffc == 0x2 (0x2) +__ulonglong 0xfffe - 0xfffc == 0x2 (0x2) +float 0xfffe - 0xfffc == 0x2 (0x2) +int 0xfffe * 0xfffc == 0x8 (0x8) +__uint 0xfffe * 0xfffc == 0x8 (0x8) +char 0xfffe * 0xfffc == 0x8 (0x8) +__uchar 0xfe * 0xfc == 0x8 (0x8) +__longlong 0xfffe * 0xfffc == 0x8 (0x8) +__ulonglong 0xfffe * 0xfffc == 0x8 (0x8) +float 0xfffe * 0xfffc == 0x8 (0x8) +int 0xfffe < 0xfffc == 0x0 (0x0) +__uint 0xfffe < 0xfffc == 0x0 (0x0) +char 0xfffe < 0xfffc == 0x0 (0x0) +__uchar 0xfe < 0xfc == 0x0 (0x0) +__longlong 0xfffe < 0xfffc == 0x0 (0x0) +__ulonglong 0xfffe < 0xfffc == 0x0 (0x0) +float 0xfffe < 0xfffc == 0x0 (0x0) +int 0xfffe > 0xfffc == 0x1 (0x1) +__uint 0xfffe > 0xfffc == 0x1 (0x1) +char 0xfffe > 0xfffc == 0x1 (0x1) +__uchar 0xfe > 0xfc == 0x1 (0x1) +__longlong 0xfffe > 0xfffc == 0x1 (0x1) +__ulonglong 0xfffe > 0xfffc == 0x1 (0x1) +float 0xfffe > 0xfffc == 0x1 (0x1) +int 0xfffe <= 0xfffc == 0x0 (0x0) +__uint 0xfffe <= 0xfffc == 0x0 (0x0) +char 0xfffe <= 0xfffc == 0x0 (0x0) +__uchar 0xfe <= 0xfc == 0x0 (0x0) +__longlong 0xfffe <= 0xfffc == 0x0 (0x0) +__ulonglong 0xfffe <= 0xfffc == 0x0 (0x0) +float 0xfffe <= 0xfffc == 0x0 (0x0) +int 0xfffe == 0xfffc == 0x0 (0x0) +__uint 0xfffe == 0xfffc == 0x0 (0x0) +char 0xfffe == 0xfffc == 0x0 (0x0) +__uchar 0xfe == 0xfc == 0x0 (0x0) +__longlong 0xfffe == 0xfffc == 0x0 (0x0) +__ulonglong 0xfffe == 0xfffc == 0x0 (0x0) +float 0xfffe == 0xfffc == 0x0 (0x0) +int 0xfffe != 0xfffc == 0x1 (0x1) +__uint 0xfffe != 0xfffc == 0x1 (0x1) +char 0xfffe != 0xfffc == 0x1 (0x1) +__uchar 0xfe != 0xfc == 0x1 (0x1) +__longlong 0xfffe != 0xfffc == 0x1 (0x1) +__ulonglong 0xfffe != 0xfffc == 0x1 (0x1) +float 0xfffe != 0xfffc == 0x1 (0x1) +int 0xfffe >= 0xfffc == 0x1 (0x1) +__uint 0xfffe >= 0xfffc == 0x1 (0x1) +char 0xfffe >= 0xfffc == 0x1 (0x1) +__uchar 0xfe >= 0xfc == 0x1 (0x1) +__longlong 0xfffe >= 0xfffc == 0x1 (0x1) +__ulonglong 0xfffe >= 0xfffc == 0x1 (0x1) +float 0xfffe >= 0xfffc == 0x1 (0x1) +int 0xfffe / 0xfffc == 0x0 (0x0) +__uint 0xfffe / 0xfffc == 0x1 (0x1) +char 0xfffe / 0xfffc == 0x0 (0x0) +__uchar 0xfe / 0xfc == 0x1 (0x1) +__longlong 0xfffe / 0xfffc == 0x0 (0x0) +__ulonglong 0xfffe / 0xfffc == 0x1 (0x1) +float 0xfffe / 0xfffc == 0x0 (0x0) +int 0xfffe % 0xfffc == -0x2 (0xfffe) +__uint 0xfffe % 0xfffc == 0x2 (0x2) +char 0xfffe % 0xfffc == -0x2 (0xfffe) +__uchar 0xfe % 0xfc == 0x2 (0x2) +__longlong 0xfffe % 0xfffc == -0x2 (0xfffe) +__ulonglong 0xfffe % 0xfffc == 0x2 (0x2) +0xfffe * 0xa == -0x14 +0xfffe / 0xa == 0x0 +0xfffe % 0xa == -0x2 +int 0xfffe ^ 0xa == -0xc (0xfff4) +__uint 0xfffe ^ 0xa == -0xc (0xfff4) +char 0xfffe ^ 0xa == -0xc (0xfff4) +__uchar 0xfe ^ 0xa == 0xf4 (0xf4) +__longlong 0xfffe ^ 0xa == -0xc (0xfff4) +__ulonglong 0xfffe ^ 0xa == -0xc (0xfff4) +int 0xfffe && 0xa == 0x1 (0x1) +__uint 0xfffe && 0xa == 0x1 (0x1) +char 0xfffe && 0xa == 0x1 (0x1) +__uchar 0xfe && 0xa == 0x1 (0x1) +__longlong 0xfffe && 0xa == 0x1 (0x1) +__ulonglong 0xfffe && 0xa == 0x1 (0x1) +int 0xfffe || 0xa == 0x1 (0x1) +__uint 0xfffe || 0xa == 0x1 (0x1) +char 0xfffe || 0xa == 0x1 (0x1) +__uchar 0xfe || 0xa == 0x1 (0x1) +__longlong 0xfffe || 0xa == 0x1 (0x1) +__ulonglong 0xfffe || 0xa == 0x1 (0x1) +int 0xfffe & 0xa == 0xa (0xa) +__uint 0xfffe & 0xa == 0xa (0xa) +char 0xfffe & 0xa == 0xa (0xa) +__uchar 0xfe & 0xa == 0xa (0xa) +__longlong 0xfffe & 0xa == 0xa (0xa) +__ulonglong 0xfffe & 0xa == 0xa (0xa) +int 0xfffe | 0xa == -0x2 (0xfffe) +__uint 0xfffe | 0xa == -0x2 (0xfffe) +char 0xfffe | 0xa == -0x2 (0xfffe) +__uchar 0xfe | 0xa == 0xfe (0xfe) +__longlong 0xfffe | 0xa == -0x2 (0xfffe) +__ulonglong 0xfffe | 0xa == -0x2 (0xfffe) +int 0xfffe << 0x7 == -0x100 (0xff00) +__uint 0xfffe << 0x7 == -0x100 (0xff00) +char 0xfffe << 0x7 == 0x0 (0x0) +__uchar 0xfe << 0x7 == 0x0 (0x0) +__longlong 0xfffe << 0x7 == -0x100 (0xff00) +__ulonglong 0xfffe << 0x7 == -0x100 (0xff00) +int 0xfffe >> 0x7 == -0x1 (0xffff) +__uint 0xfffe >> 0x7 == 0x1ff (0x1ff) +char 0xfffe >> 0x7 == -0x1 (0xffff) +__uchar 0xfe >> 0x7 == 0x1 (0x1) +__longlong 0xfffe >> 0x7 == -0x1 (0xffff) +__ulonglong 0xfffe >> 0x7 == -0x1 (0xffff) +int 0xfffe + 0xa == 0x8 (0x8) +__uint 0xfffe + 0xa == 0x8 (0x8) +char 0xfffe + 0xa == 0x8 (0x8) +__uchar 0xfe + 0xa == 0x8 (0x8) +__longlong 0xfffe + 0xa == 0x8 (0x8) +__ulonglong 0xfffe + 0xa == 0x8 (0x8) +float 0xfffe + 0xa == 0x8 (0x8) +int 0xfffe - 0xa == -0xc (0xfff4) +__uint 0xfffe - 0xa == -0xc (0xfff4) +char 0xfffe - 0xa == -0xc (0xfff4) +__uchar 0xfe - 0xa == 0xf4 (0xf4) +__longlong 0xfffe - 0xa == -0xc (0xfff4) +__ulonglong 0xfffe - 0xa == -0xc (0xfff4) +float 0xfffe - 0xa == -0xc (0xfff4) +int 0xfffe * 0xa == -0x14 (0xffec) +__uint 0xfffe * 0xa == -0x14 (0xffec) +char 0xfffe * 0xa == -0x14 (0xffec) +__uchar 0xfe * 0xa == 0xec (0xec) +__longlong 0xfffe * 0xa == -0x14 (0xffec) +__ulonglong 0xfffe * 0xa == -0x14 (0xffec) +float 0xfffe * 0xa == -0x14 (0xffec) +int 0xfffe < 0xa == 0x1 (0x1) +__uint 0xfffe < 0xa == 0x0 (0x0) +char 0xfffe < 0xa == 0x1 (0x1) +__uchar 0xfe < 0xa == 0x0 (0x0) +__longlong 0xfffe < 0xa == 0x1 (0x1) +__ulonglong 0xfffe < 0xa == 0x0 (0x0) +float 0xfffe < 0xa == 0x1 (0x1) +int 0xfffe > 0xa == 0x0 (0x0) +__uint 0xfffe > 0xa == 0x1 (0x1) +char 0xfffe > 0xa == 0x0 (0x0) +__uchar 0xfe > 0xa == 0x1 (0x1) +__longlong 0xfffe > 0xa == 0x0 (0x0) +__ulonglong 0xfffe > 0xa == 0x1 (0x1) +float 0xfffe > 0xa == 0x0 (0x0) +int 0xfffe <= 0xa == 0x1 (0x1) +__uint 0xfffe <= 0xa == 0x0 (0x0) +char 0xfffe <= 0xa == 0x1 (0x1) +__uchar 0xfe <= 0xa == 0x0 (0x0) +__longlong 0xfffe <= 0xa == 0x1 (0x1) +__ulonglong 0xfffe <= 0xa == 0x0 (0x0) +float 0xfffe <= 0xa == 0x1 (0x1) +int 0xfffe == 0xa == 0x0 (0x0) +__uint 0xfffe == 0xa == 0x0 (0x0) +char 0xfffe == 0xa == 0x0 (0x0) +__uchar 0xfe == 0xa == 0x0 (0x0) +__longlong 0xfffe == 0xa == 0x0 (0x0) +__ulonglong 0xfffe == 0xa == 0x0 (0x0) +float 0xfffe == 0xa == 0x0 (0x0) +int 0xfffe != 0xa == 0x1 (0x1) +__uint 0xfffe != 0xa == 0x1 (0x1) +char 0xfffe != 0xa == 0x1 (0x1) +__uchar 0xfe != 0xa == 0x1 (0x1) +__longlong 0xfffe != 0xa == 0x1 (0x1) +__ulonglong 0xfffe != 0xa == 0x1 (0x1) +float 0xfffe != 0xa == 0x1 (0x1) +int 0xfffe >= 0xa == 0x0 (0x0) +__uint 0xfffe >= 0xa == 0x1 (0x1) +char 0xfffe >= 0xa == 0x0 (0x0) +__uchar 0xfe >= 0xa == 0x1 (0x1) +__longlong 0xfffe >= 0xa == 0x0 (0x0) +__ulonglong 0xfffe >= 0xa == 0x1 (0x1) +float 0xfffe >= 0xa == 0x0 (0x0) +int 0xfffe / 0xa == 0x0 (0x0) +__uint 0xfffe / 0xa == 0x1999 (0x1999) +char 0xfffe / 0xa == 0x0 (0x0) +__uchar 0xfe / 0xa == 0x19 (0x19) +__longlong 0xfffe / 0xa == 0x0 (0x0) +__ulonglong 0xfffe / 0xa == -0x6667 (0x9999) +float 0xfffe / 0xa == 0x0 (0x0) +int 0xfffe % 0xa == -0x2 (0xfffe) +__uint 0xfffe % 0xa == 0x4 (0x4) +char 0xfffe % 0xa == -0x2 (0xfffe) +__uchar 0xfe % 0xa == 0x4 (0x4) +__longlong 0xfffe % 0xa == -0x2 (0xfffe) +__ulonglong 0xfffe % 0xa == 0x4 (0x4) +0xfffe * 0xfff6 == 0x14 +0xfffe / 0xfff6 == 0x0 +0xfffe % 0xfff6 == -0x2 +int 0xfffe ^ 0xfff6 == 0x8 (0x8) +__uint 0xfffe ^ 0xfff6 == 0x8 (0x8) +char 0xfffe ^ 0xfff6 == 0x8 (0x8) +__uchar 0xfe ^ 0xf6 == 0x8 (0x8) +__longlong 0xfffe ^ 0xfff6 == 0x8 (0x8) +__ulonglong 0xfffe ^ 0xfff6 == 0x8 (0x8) +int 0xfffe && 0xfff6 == 0x1 (0x1) +__uint 0xfffe && 0xfff6 == 0x1 (0x1) +char 0xfffe && 0xfff6 == 0x1 (0x1) +__uchar 0xfe && 0xf6 == 0x1 (0x1) +__longlong 0xfffe && 0xfff6 == 0x1 (0x1) +__ulonglong 0xfffe && 0xfff6 == 0x1 (0x1) +int 0xfffe || 0xfff6 == 0x1 (0x1) +__uint 0xfffe || 0xfff6 == 0x1 (0x1) +char 0xfffe || 0xfff6 == 0x1 (0x1) +__uchar 0xfe || 0xf6 == 0x1 (0x1) +__longlong 0xfffe || 0xfff6 == 0x1 (0x1) +__ulonglong 0xfffe || 0xfff6 == 0x1 (0x1) +int 0xfffe & 0xfff6 == -0xa (0xfff6) +__uint 0xfffe & 0xfff6 == -0xa (0xfff6) +char 0xfffe & 0xfff6 == -0xa (0xfff6) +__uchar 0xfe & 0xf6 == 0xf6 (0xf6) +__longlong 0xfffe & 0xfff6 == -0xa (0xfff6) +__ulonglong 0xfffe & 0xfff6 == -0xa (0xfff6) +int 0xfffe | 0xfff6 == -0x2 (0xfffe) +__uint 0xfffe | 0xfff6 == -0x2 (0xfffe) +char 0xfffe | 0xfff6 == -0x2 (0xfffe) +__uchar 0xfe | 0xf6 == 0xfe (0xfe) +__longlong 0xfffe | 0xfff6 == -0x2 (0xfffe) +__ulonglong 0xfffe | 0xfff6 == -0x2 (0xfffe) +int 0xfffe << 0x8 == -0x200 (0xfe00) +__uint 0xfffe << 0x8 == -0x200 (0xfe00) +char 0xfffe << 0x8 == 0x0 (0x0) +__uchar 0xfe << 0x8 == 0x0 (0x0) +__longlong 0xfffe << 0x8 == -0x200 (0xfe00) +__ulonglong 0xfffe << 0x8 == -0x200 (0xfe00) +int 0xfffe >> 0x8 == -0x1 (0xffff) +__uint 0xfffe >> 0x8 == 0xff (0xff) +char 0xfffe >> 0x8 == -0x1 (0xffff) +__uchar 0xfe >> 0x8 == 0x0 (0x0) +__longlong 0xfffe >> 0x8 == -0x1 (0xffff) +__ulonglong 0xfffe >> 0x8 == -0x1 (0xffff) +int 0xfffe + 0xfff6 == -0xc (0xfff4) +__uint 0xfffe + 0xfff6 == -0xc (0xfff4) +char 0xfffe + 0xfff6 == -0xc (0xfff4) +__uchar 0xfe + 0xf6 == 0xf4 (0xf4) +__longlong 0xfffe + 0xfff6 == -0xc (0xfff4) +__ulonglong 0xfffe + 0xfff6 == -0xc (0xfff4) +float 0xfffe + 0xfff6 == -0xc (0xfff4) +int 0xfffe - 0xfff6 == 0x8 (0x8) +__uint 0xfffe - 0xfff6 == 0x8 (0x8) +char 0xfffe - 0xfff6 == 0x8 (0x8) +__uchar 0xfe - 0xf6 == 0x8 (0x8) +__longlong 0xfffe - 0xfff6 == 0x8 (0x8) +__ulonglong 0xfffe - 0xfff6 == 0x8 (0x8) +float 0xfffe - 0xfff6 == 0x8 (0x8) +int 0xfffe * 0xfff6 == 0x14 (0x14) +__uint 0xfffe * 0xfff6 == 0x14 (0x14) +char 0xfffe * 0xfff6 == 0x14 (0x14) +__uchar 0xfe * 0xf6 == 0x14 (0x14) +__longlong 0xfffe * 0xfff6 == 0x14 (0x14) +__ulonglong 0xfffe * 0xfff6 == 0x14 (0x14) +float 0xfffe * 0xfff6 == 0x14 (0x14) +int 0xfffe < 0xfff6 == 0x0 (0x0) +__uint 0xfffe < 0xfff6 == 0x0 (0x0) +char 0xfffe < 0xfff6 == 0x0 (0x0) +__uchar 0xfe < 0xf6 == 0x0 (0x0) +__longlong 0xfffe < 0xfff6 == 0x0 (0x0) +__ulonglong 0xfffe < 0xfff6 == 0x0 (0x0) +float 0xfffe < 0xfff6 == 0x0 (0x0) +int 0xfffe > 0xfff6 == 0x1 (0x1) +__uint 0xfffe > 0xfff6 == 0x1 (0x1) +char 0xfffe > 0xfff6 == 0x1 (0x1) +__uchar 0xfe > 0xf6 == 0x1 (0x1) +__longlong 0xfffe > 0xfff6 == 0x1 (0x1) +__ulonglong 0xfffe > 0xfff6 == 0x1 (0x1) +float 0xfffe > 0xfff6 == 0x1 (0x1) +int 0xfffe <= 0xfff6 == 0x0 (0x0) +__uint 0xfffe <= 0xfff6 == 0x0 (0x0) +char 0xfffe <= 0xfff6 == 0x0 (0x0) +__uchar 0xfe <= 0xf6 == 0x0 (0x0) +__longlong 0xfffe <= 0xfff6 == 0x0 (0x0) +__ulonglong 0xfffe <= 0xfff6 == 0x0 (0x0) +float 0xfffe <= 0xfff6 == 0x0 (0x0) +int 0xfffe == 0xfff6 == 0x0 (0x0) +__uint 0xfffe == 0xfff6 == 0x0 (0x0) +char 0xfffe == 0xfff6 == 0x0 (0x0) +__uchar 0xfe == 0xf6 == 0x0 (0x0) +__longlong 0xfffe == 0xfff6 == 0x0 (0x0) +__ulonglong 0xfffe == 0xfff6 == 0x0 (0x0) +float 0xfffe == 0xfff6 == 0x0 (0x0) +int 0xfffe != 0xfff6 == 0x1 (0x1) +__uint 0xfffe != 0xfff6 == 0x1 (0x1) +char 0xfffe != 0xfff6 == 0x1 (0x1) +__uchar 0xfe != 0xf6 == 0x1 (0x1) +__longlong 0xfffe != 0xfff6 == 0x1 (0x1) +__ulonglong 0xfffe != 0xfff6 == 0x1 (0x1) +float 0xfffe != 0xfff6 == 0x1 (0x1) +int 0xfffe >= 0xfff6 == 0x1 (0x1) +__uint 0xfffe >= 0xfff6 == 0x1 (0x1) +char 0xfffe >= 0xfff6 == 0x1 (0x1) +__uchar 0xfe >= 0xf6 == 0x1 (0x1) +__longlong 0xfffe >= 0xfff6 == 0x1 (0x1) +__ulonglong 0xfffe >= 0xfff6 == 0x1 (0x1) +float 0xfffe >= 0xfff6 == 0x1 (0x1) +int 0xfffe / 0xfff6 == 0x0 (0x0) +__uint 0xfffe / 0xfff6 == 0x1 (0x1) +char 0xfffe / 0xfff6 == 0x0 (0x0) +__uchar 0xfe / 0xf6 == 0x1 (0x1) +__longlong 0xfffe / 0xfff6 == 0x0 (0x0) +__ulonglong 0xfffe / 0xfff6 == 0x1 (0x1) +float 0xfffe / 0xfff6 == 0x0 (0x0) +int 0xfffe % 0xfff6 == -0x2 (0xfffe) +__uint 0xfffe % 0xfff6 == 0x8 (0x8) +char 0xfffe % 0xfff6 == -0x2 (0xfffe) +__uchar 0xfe % 0xf6 == 0x8 (0x8) +__longlong 0xfffe % 0xfff6 == -0x2 (0xfffe) +__ulonglong 0xfffe % 0xfff6 == 0x8 (0x8) +0xfffe * 0x5 == -0xa +0xfffe / 0x5 == 0x0 +0xfffe % 0x5 == -0x2 +int 0xfffe ^ 0x5 == -0x5 (0xfffb) +__uint 0xfffe ^ 0x5 == -0x5 (0xfffb) +char 0xfffe ^ 0x5 == -0x5 (0xfffb) +__uchar 0xfe ^ 0x5 == 0xfb (0xfb) +__longlong 0xfffe ^ 0x5 == -0x5 (0xfffb) +__ulonglong 0xfffe ^ 0x5 == -0x5 (0xfffb) +int 0xfffe && 0x5 == 0x1 (0x1) +__uint 0xfffe && 0x5 == 0x1 (0x1) +char 0xfffe && 0x5 == 0x1 (0x1) +__uchar 0xfe && 0x5 == 0x1 (0x1) +__longlong 0xfffe && 0x5 == 0x1 (0x1) +__ulonglong 0xfffe && 0x5 == 0x1 (0x1) +int 0xfffe || 0x5 == 0x1 (0x1) +__uint 0xfffe || 0x5 == 0x1 (0x1) +char 0xfffe || 0x5 == 0x1 (0x1) +__uchar 0xfe || 0x5 == 0x1 (0x1) +__longlong 0xfffe || 0x5 == 0x1 (0x1) +__ulonglong 0xfffe || 0x5 == 0x1 (0x1) +int 0xfffe & 0x5 == 0x4 (0x4) +__uint 0xfffe & 0x5 == 0x4 (0x4) +char 0xfffe & 0x5 == 0x4 (0x4) +__uchar 0xfe & 0x5 == 0x4 (0x4) +__longlong 0xfffe & 0x5 == 0x4 (0x4) +__ulonglong 0xfffe & 0x5 == 0x4 (0x4) +int 0xfffe | 0x5 == -0x1 (0xffff) +__uint 0xfffe | 0x5 == -0x1 (0xffff) +char 0xfffe | 0x5 == -0x1 (0xffff) +__uchar 0xfe | 0x5 == 0xff (0xff) +__longlong 0xfffe | 0x5 == -0x1 (0xffff) +__ulonglong 0xfffe | 0x5 == -0x1 (0xffff) +int 0xfffe << 0x9 == -0x400 (0xfc00) +__uint 0xfffe << 0x9 == -0x400 (0xfc00) +char 0xfffe << 0x9 == 0x0 (0x0) +__uchar 0xfe << 0x9 == 0x0 (0x0) +__longlong 0xfffe << 0x9 == -0x400 (0xfc00) +__ulonglong 0xfffe << 0x9 == -0x400 (0xfc00) +int 0xfffe >> 0x9 == -0x1 (0xffff) +__uint 0xfffe >> 0x9 == 0x7f (0x7f) +char 0xfffe >> 0x9 == -0x1 (0xffff) +__uchar 0xfe >> 0x9 == 0x0 (0x0) +__longlong 0xfffe >> 0x9 == -0x1 (0xffff) +__ulonglong 0xfffe >> 0x9 == -0x1 (0xffff) +int 0xfffe + 0x5 == 0x3 (0x3) +__uint 0xfffe + 0x5 == 0x3 (0x3) +char 0xfffe + 0x5 == 0x3 (0x3) +__uchar 0xfe + 0x5 == 0x3 (0x3) +__longlong 0xfffe + 0x5 == 0x3 (0x3) +__ulonglong 0xfffe + 0x5 == 0x3 (0x3) +float 0xfffe + 0x5 == 0x3 (0x3) +int 0xfffe - 0x5 == -0x7 (0xfff9) +__uint 0xfffe - 0x5 == -0x7 (0xfff9) +char 0xfffe - 0x5 == -0x7 (0xfff9) +__uchar 0xfe - 0x5 == 0xf9 (0xf9) +__longlong 0xfffe - 0x5 == -0x7 (0xfff9) +__ulonglong 0xfffe - 0x5 == -0x7 (0xfff9) +float 0xfffe - 0x5 == -0x7 (0xfff9) +int 0xfffe * 0x5 == -0xa (0xfff6) +__uint 0xfffe * 0x5 == -0xa (0xfff6) +char 0xfffe * 0x5 == -0xa (0xfff6) +__uchar 0xfe * 0x5 == 0xf6 (0xf6) +__longlong 0xfffe * 0x5 == -0xa (0xfff6) +__ulonglong 0xfffe * 0x5 == -0xa (0xfff6) +float 0xfffe * 0x5 == -0xa (0xfff6) +int 0xfffe < 0x5 == 0x1 (0x1) +__uint 0xfffe < 0x5 == 0x0 (0x0) +char 0xfffe < 0x5 == 0x1 (0x1) +__uchar 0xfe < 0x5 == 0x0 (0x0) +__longlong 0xfffe < 0x5 == 0x1 (0x1) +__ulonglong 0xfffe < 0x5 == 0x0 (0x0) +float 0xfffe < 0x5 == 0x1 (0x1) +int 0xfffe > 0x5 == 0x0 (0x0) +__uint 0xfffe > 0x5 == 0x1 (0x1) +char 0xfffe > 0x5 == 0x0 (0x0) +__uchar 0xfe > 0x5 == 0x1 (0x1) +__longlong 0xfffe > 0x5 == 0x0 (0x0) +__ulonglong 0xfffe > 0x5 == 0x1 (0x1) +float 0xfffe > 0x5 == 0x0 (0x0) +int 0xfffe <= 0x5 == 0x1 (0x1) +__uint 0xfffe <= 0x5 == 0x0 (0x0) +char 0xfffe <= 0x5 == 0x1 (0x1) +__uchar 0xfe <= 0x5 == 0x0 (0x0) +__longlong 0xfffe <= 0x5 == 0x1 (0x1) +__ulonglong 0xfffe <= 0x5 == 0x0 (0x0) +float 0xfffe <= 0x5 == 0x1 (0x1) +int 0xfffe == 0x5 == 0x0 (0x0) +__uint 0xfffe == 0x5 == 0x0 (0x0) +char 0xfffe == 0x5 == 0x0 (0x0) +__uchar 0xfe == 0x5 == 0x0 (0x0) +__longlong 0xfffe == 0x5 == 0x0 (0x0) +__ulonglong 0xfffe == 0x5 == 0x0 (0x0) +float 0xfffe == 0x5 == 0x0 (0x0) +int 0xfffe != 0x5 == 0x1 (0x1) +__uint 0xfffe != 0x5 == 0x1 (0x1) +char 0xfffe != 0x5 == 0x1 (0x1) +__uchar 0xfe != 0x5 == 0x1 (0x1) +__longlong 0xfffe != 0x5 == 0x1 (0x1) +__ulonglong 0xfffe != 0x5 == 0x1 (0x1) +float 0xfffe != 0x5 == 0x1 (0x1) +int 0xfffe >= 0x5 == 0x0 (0x0) +__uint 0xfffe >= 0x5 == 0x1 (0x1) +char 0xfffe >= 0x5 == 0x0 (0x0) +__uchar 0xfe >= 0x5 == 0x1 (0x1) +__longlong 0xfffe >= 0x5 == 0x0 (0x0) +__ulonglong 0xfffe >= 0x5 == 0x1 (0x1) +float 0xfffe >= 0x5 == 0x0 (0x0) +int 0xfffe / 0x5 == 0x0 (0x0) +__uint 0xfffe / 0x5 == 0x3332 (0x3332) +char 0xfffe / 0x5 == 0x0 (0x0) +__uchar 0xfe / 0x5 == 0x32 (0x32) +__longlong 0xfffe / 0x5 == 0x0 (0x0) +__ulonglong 0xfffe / 0x5 == 0x3332 (0x3332) +float 0xfffe / 0x5 == 0x0 (0x0) +int 0xfffe % 0x5 == -0x2 (0xfffe) +__uint 0xfffe % 0x5 == 0x4 (0x4) +char 0xfffe % 0x5 == -0x2 (0xfffe) +__uchar 0xfe % 0x5 == 0x4 (0x4) +__longlong 0xfffe % 0x5 == -0x2 (0xfffe) +__ulonglong 0xfffe % 0x5 == 0x4 (0x4) +0xfffe * 0x7 == -0xe +0xfffe / 0x7 == 0x0 +0xfffe % 0x7 == -0x2 +int 0xfffe ^ 0x7 == -0x7 (0xfff9) +__uint 0xfffe ^ 0x7 == -0x7 (0xfff9) +char 0xfffe ^ 0x7 == -0x7 (0xfff9) +__uchar 0xfe ^ 0x7 == 0xf9 (0xf9) +__longlong 0xfffe ^ 0x7 == -0x7 (0xfff9) +__ulonglong 0xfffe ^ 0x7 == -0x7 (0xfff9) +int 0xfffe && 0x7 == 0x1 (0x1) +__uint 0xfffe && 0x7 == 0x1 (0x1) +char 0xfffe && 0x7 == 0x1 (0x1) +__uchar 0xfe && 0x7 == 0x1 (0x1) +__longlong 0xfffe && 0x7 == 0x1 (0x1) +__ulonglong 0xfffe && 0x7 == 0x1 (0x1) +int 0xfffe || 0x7 == 0x1 (0x1) +__uint 0xfffe || 0x7 == 0x1 (0x1) +char 0xfffe || 0x7 == 0x1 (0x1) +__uchar 0xfe || 0x7 == 0x1 (0x1) +__longlong 0xfffe || 0x7 == 0x1 (0x1) +__ulonglong 0xfffe || 0x7 == 0x1 (0x1) +int 0xfffe & 0x7 == 0x6 (0x6) +__uint 0xfffe & 0x7 == 0x6 (0x6) +char 0xfffe & 0x7 == 0x6 (0x6) +__uchar 0xfe & 0x7 == 0x6 (0x6) +__longlong 0xfffe & 0x7 == 0x6 (0x6) +__ulonglong 0xfffe & 0x7 == 0x6 (0x6) +int 0xfffe | 0x7 == -0x1 (0xffff) +__uint 0xfffe | 0x7 == -0x1 (0xffff) +char 0xfffe | 0x7 == -0x1 (0xffff) +__uchar 0xfe | 0x7 == 0xff (0xff) +__longlong 0xfffe | 0x7 == -0x1 (0xffff) +__ulonglong 0xfffe | 0x7 == -0x1 (0xffff) +int 0xfffe << 0xa == -0x800 (0xf800) +__uint 0xfffe << 0xa == -0x800 (0xf800) +char 0xfffe << 0xa == 0x0 (0x0) +__uchar 0xfe << 0xa == 0x0 (0x0) +__longlong 0xfffe << 0xa == -0x800 (0xf800) +__ulonglong 0xfffe << 0xa == -0x800 (0xf800) +int 0xfffe >> 0xa == -0x1 (0xffff) +__uint 0xfffe >> 0xa == 0x3f (0x3f) +char 0xfffe >> 0xa == -0x1 (0xffff) +__uchar 0xfe >> 0xa == 0x0 (0x0) +__longlong 0xfffe >> 0xa == -0x1 (0xffff) +__ulonglong 0xfffe >> 0xa == -0x1 (0xffff) +int 0xfffe + 0x7 == 0x5 (0x5) +__uint 0xfffe + 0x7 == 0x5 (0x5) +char 0xfffe + 0x7 == 0x5 (0x5) +__uchar 0xfe + 0x7 == 0x5 (0x5) +__longlong 0xfffe + 0x7 == 0x5 (0x5) +__ulonglong 0xfffe + 0x7 == 0x5 (0x5) +float 0xfffe + 0x7 == 0x5 (0x5) +int 0xfffe - 0x7 == -0x9 (0xfff7) +__uint 0xfffe - 0x7 == -0x9 (0xfff7) +char 0xfffe - 0x7 == -0x9 (0xfff7) +__uchar 0xfe - 0x7 == 0xf7 (0xf7) +__longlong 0xfffe - 0x7 == -0x9 (0xfff7) +__ulonglong 0xfffe - 0x7 == -0x9 (0xfff7) +float 0xfffe - 0x7 == -0x9 (0xfff7) +int 0xfffe * 0x7 == -0xe (0xfff2) +__uint 0xfffe * 0x7 == -0xe (0xfff2) +char 0xfffe * 0x7 == -0xe (0xfff2) +__uchar 0xfe * 0x7 == 0xf2 (0xf2) +__longlong 0xfffe * 0x7 == -0xe (0xfff2) +__ulonglong 0xfffe * 0x7 == -0xe (0xfff2) +float 0xfffe * 0x7 == -0xe (0xfff2) +int 0xfffe < 0x7 == 0x1 (0x1) +__uint 0xfffe < 0x7 == 0x0 (0x0) +char 0xfffe < 0x7 == 0x1 (0x1) +__uchar 0xfe < 0x7 == 0x0 (0x0) +__longlong 0xfffe < 0x7 == 0x1 (0x1) +__ulonglong 0xfffe < 0x7 == 0x0 (0x0) +float 0xfffe < 0x7 == 0x1 (0x1) +int 0xfffe > 0x7 == 0x0 (0x0) +__uint 0xfffe > 0x7 == 0x1 (0x1) +char 0xfffe > 0x7 == 0x0 (0x0) +__uchar 0xfe > 0x7 == 0x1 (0x1) +__longlong 0xfffe > 0x7 == 0x0 (0x0) +__ulonglong 0xfffe > 0x7 == 0x1 (0x1) +float 0xfffe > 0x7 == 0x0 (0x0) +int 0xfffe <= 0x7 == 0x1 (0x1) +__uint 0xfffe <= 0x7 == 0x0 (0x0) +char 0xfffe <= 0x7 == 0x1 (0x1) +__uchar 0xfe <= 0x7 == 0x0 (0x0) +__longlong 0xfffe <= 0x7 == 0x1 (0x1) +__ulonglong 0xfffe <= 0x7 == 0x0 (0x0) +float 0xfffe <= 0x7 == 0x1 (0x1) +int 0xfffe == 0x7 == 0x0 (0x0) +__uint 0xfffe == 0x7 == 0x0 (0x0) +char 0xfffe == 0x7 == 0x0 (0x0) +__uchar 0xfe == 0x7 == 0x0 (0x0) +__longlong 0xfffe == 0x7 == 0x0 (0x0) +__ulonglong 0xfffe == 0x7 == 0x0 (0x0) +float 0xfffe == 0x7 == 0x0 (0x0) +int 0xfffe != 0x7 == 0x1 (0x1) +__uint 0xfffe != 0x7 == 0x1 (0x1) +char 0xfffe != 0x7 == 0x1 (0x1) +__uchar 0xfe != 0x7 == 0x1 (0x1) +__longlong 0xfffe != 0x7 == 0x1 (0x1) +__ulonglong 0xfffe != 0x7 == 0x1 (0x1) +float 0xfffe != 0x7 == 0x1 (0x1) +int 0xfffe >= 0x7 == 0x0 (0x0) +__uint 0xfffe >= 0x7 == 0x1 (0x1) +char 0xfffe >= 0x7 == 0x0 (0x0) +__uchar 0xfe >= 0x7 == 0x1 (0x1) +__longlong 0xfffe >= 0x7 == 0x0 (0x0) +__ulonglong 0xfffe >= 0x7 == 0x1 (0x1) +float 0xfffe >= 0x7 == 0x0 (0x0) +int 0xfffe / 0x7 == 0x0 (0x0) +__uint 0xfffe / 0x7 == 0x2492 (0x2492) +char 0xfffe / 0x7 == 0x0 (0x0) +__uchar 0xfe / 0x7 == 0x24 (0x24) +__longlong 0xfffe / 0x7 == 0x0 (0x0) +__ulonglong 0xfffe / 0x7 == 0x4924 (0x4924) +float 0xfffe / 0x7 == 0x0 (0x0) +int 0xfffe % 0x7 == -0x2 (0xfffe) +__uint 0xfffe % 0x7 == 0x0 (0x0) +char 0xfffe % 0x7 == -0x2 (0xfffe) +__uchar 0xfe % 0x7 == 0x2 (0x2) +__longlong 0xfffe % 0x7 == -0x2 (0xfffe) +__ulonglong 0xfffe % 0x7 == 0x2 (0x2) +0xfffe * 0x2a == -0x54 +0xfffe / 0x2a == 0x0 +0xfffe % 0x2a == -0x2 +int 0xfffe ^ 0x2a == -0x2c (0xffd4) +__uint 0xfffe ^ 0x2a == -0x2c (0xffd4) +char 0xfffe ^ 0x2a == -0x2c (0xffd4) +__uchar 0xfe ^ 0x2a == 0xd4 (0xd4) +__longlong 0xfffe ^ 0x2a == -0x2c (0xffd4) +__ulonglong 0xfffe ^ 0x2a == -0x2c (0xffd4) +int 0xfffe && 0x2a == 0x1 (0x1) +__uint 0xfffe && 0x2a == 0x1 (0x1) +char 0xfffe && 0x2a == 0x1 (0x1) +__uchar 0xfe && 0x2a == 0x1 (0x1) +__longlong 0xfffe && 0x2a == 0x1 (0x1) +__ulonglong 0xfffe && 0x2a == 0x1 (0x1) +int 0xfffe || 0x2a == 0x1 (0x1) +__uint 0xfffe || 0x2a == 0x1 (0x1) +char 0xfffe || 0x2a == 0x1 (0x1) +__uchar 0xfe || 0x2a == 0x1 (0x1) +__longlong 0xfffe || 0x2a == 0x1 (0x1) +__ulonglong 0xfffe || 0x2a == 0x1 (0x1) +int 0xfffe & 0x2a == 0x2a (0x2a) +__uint 0xfffe & 0x2a == 0x2a (0x2a) +char 0xfffe & 0x2a == 0x2a (0x2a) +__uchar 0xfe & 0x2a == 0x2a (0x2a) +__longlong 0xfffe & 0x2a == 0x2a (0x2a) +__ulonglong 0xfffe & 0x2a == 0x2a (0x2a) +int 0xfffe | 0x2a == -0x2 (0xfffe) +__uint 0xfffe | 0x2a == -0x2 (0xfffe) +char 0xfffe | 0x2a == -0x2 (0xfffe) +__uchar 0xfe | 0x2a == 0xfe (0xfe) +__longlong 0xfffe | 0x2a == -0x2 (0xfffe) +__ulonglong 0xfffe | 0x2a == -0x2 (0xfffe) +int 0xfffe << 0xc == -0x2000 (0xe000) +__uint 0xfffe << 0xc == -0x2000 (0xe000) +char 0xfffe << 0xc == 0x0 (0x0) +__uchar 0xfe << 0xc == 0x0 (0x0) +__longlong 0xfffe << 0xc == -0x2000 (0xe000) +__ulonglong 0xfffe << 0xc == -0x2000 (0xe000) +int 0xfffe >> 0xc == -0x1 (0xffff) +__uint 0xfffe >> 0xc == 0xf (0xf) +char 0xfffe >> 0xc == -0x1 (0xffff) +__uchar 0xfe >> 0xc == 0x0 (0x0) +__longlong 0xfffe >> 0xc == -0x1 (0xffff) +__ulonglong 0xfffe >> 0xc == -0x1 (0xffff) +int 0xfffe + 0x2a == 0x28 (0x28) +__uint 0xfffe + 0x2a == 0x28 (0x28) +char 0xfffe + 0x2a == 0x28 (0x28) +__uchar 0xfe + 0x2a == 0x28 (0x28) +__longlong 0xfffe + 0x2a == 0x28 (0x28) +__ulonglong 0xfffe + 0x2a == 0x28 (0x28) +float 0xfffe + 0x2a == 0x28 (0x28) +int 0xfffe - 0x2a == -0x2c (0xffd4) +__uint 0xfffe - 0x2a == -0x2c (0xffd4) +char 0xfffe - 0x2a == -0x2c (0xffd4) +__uchar 0xfe - 0x2a == 0xd4 (0xd4) +__longlong 0xfffe - 0x2a == -0x2c (0xffd4) +__ulonglong 0xfffe - 0x2a == -0x2c (0xffd4) +float 0xfffe - 0x2a == -0x2c (0xffd4) +int 0xfffe * 0x2a == -0x54 (0xffac) +__uint 0xfffe * 0x2a == -0x54 (0xffac) +char 0xfffe * 0x2a == -0x54 (0xffac) +__uchar 0xfe * 0x2a == 0xac (0xac) +__longlong 0xfffe * 0x2a == -0x54 (0xffac) +__ulonglong 0xfffe * 0x2a == -0x54 (0xffac) +float 0xfffe * 0x2a == -0x54 (0xffac) +int 0xfffe < 0x2a == 0x1 (0x1) +__uint 0xfffe < 0x2a == 0x0 (0x0) +char 0xfffe < 0x2a == 0x1 (0x1) +__uchar 0xfe < 0x2a == 0x0 (0x0) +__longlong 0xfffe < 0x2a == 0x1 (0x1) +__ulonglong 0xfffe < 0x2a == 0x0 (0x0) +float 0xfffe < 0x2a == 0x1 (0x1) +int 0xfffe > 0x2a == 0x0 (0x0) +__uint 0xfffe > 0x2a == 0x1 (0x1) +char 0xfffe > 0x2a == 0x0 (0x0) +__uchar 0xfe > 0x2a == 0x1 (0x1) +__longlong 0xfffe > 0x2a == 0x0 (0x0) +__ulonglong 0xfffe > 0x2a == 0x1 (0x1) +float 0xfffe > 0x2a == 0x0 (0x0) +int 0xfffe <= 0x2a == 0x1 (0x1) +__uint 0xfffe <= 0x2a == 0x0 (0x0) +char 0xfffe <= 0x2a == 0x1 (0x1) +__uchar 0xfe <= 0x2a == 0x0 (0x0) +__longlong 0xfffe <= 0x2a == 0x1 (0x1) +__ulonglong 0xfffe <= 0x2a == 0x0 (0x0) +float 0xfffe <= 0x2a == 0x1 (0x1) +int 0xfffe == 0x2a == 0x0 (0x0) +__uint 0xfffe == 0x2a == 0x0 (0x0) +char 0xfffe == 0x2a == 0x0 (0x0) +__uchar 0xfe == 0x2a == 0x0 (0x0) +__longlong 0xfffe == 0x2a == 0x0 (0x0) +__ulonglong 0xfffe == 0x2a == 0x0 (0x0) +float 0xfffe == 0x2a == 0x0 (0x0) +int 0xfffe != 0x2a == 0x1 (0x1) +__uint 0xfffe != 0x2a == 0x1 (0x1) +char 0xfffe != 0x2a == 0x1 (0x1) +__uchar 0xfe != 0x2a == 0x1 (0x1) +__longlong 0xfffe != 0x2a == 0x1 (0x1) +__ulonglong 0xfffe != 0x2a == 0x1 (0x1) +float 0xfffe != 0x2a == 0x1 (0x1) +int 0xfffe >= 0x2a == 0x0 (0x0) +__uint 0xfffe >= 0x2a == 0x1 (0x1) +char 0xfffe >= 0x2a == 0x0 (0x0) +__uchar 0xfe >= 0x2a == 0x1 (0x1) +__longlong 0xfffe >= 0x2a == 0x0 (0x0) +__ulonglong 0xfffe >= 0x2a == 0x1 (0x1) +float 0xfffe >= 0x2a == 0x0 (0x0) +int 0xfffe / 0x2a == 0x0 (0x0) +__uint 0xfffe / 0x2a == 0x618 (0x618) +char 0xfffe / 0x2a == 0x0 (0x0) +__uchar 0xfe / 0x2a == 0x6 (0x6) +__longlong 0xfffe / 0x2a == 0x0 (0x0) +__ulonglong 0xfffe / 0x2a == 0x6186 (0x6186) +float 0xfffe / 0x2a == 0x0 (0x0) +int 0xfffe % 0x2a == -0x2 (0xfffe) +__uint 0xfffe % 0x2a == 0xe (0xe) +char 0xfffe % 0x2a == -0x2 (0xfffe) +__uchar 0xfe % 0x2a == 0x2 (0x2) +__longlong 0xfffe % 0x2a == -0x2 (0xfffe) +__ulonglong 0xfffe % 0x2a == 0x2 (0x2) +0xfffe * 0x17 == -0x2e +0xfffe / 0x17 == 0x0 +0xfffe % 0x17 == -0x2 +int 0xfffe ^ 0x17 == -0x17 (0xffe9) +__uint 0xfffe ^ 0x17 == -0x17 (0xffe9) +char 0xfffe ^ 0x17 == -0x17 (0xffe9) +__uchar 0xfe ^ 0x17 == 0xe9 (0xe9) +__longlong 0xfffe ^ 0x17 == -0x17 (0xffe9) +__ulonglong 0xfffe ^ 0x17 == -0x17 (0xffe9) +int 0xfffe && 0x17 == 0x1 (0x1) +__uint 0xfffe && 0x17 == 0x1 (0x1) +char 0xfffe && 0x17 == 0x1 (0x1) +__uchar 0xfe && 0x17 == 0x1 (0x1) +__longlong 0xfffe && 0x17 == 0x1 (0x1) +__ulonglong 0xfffe && 0x17 == 0x1 (0x1) +int 0xfffe || 0x17 == 0x1 (0x1) +__uint 0xfffe || 0x17 == 0x1 (0x1) +char 0xfffe || 0x17 == 0x1 (0x1) +__uchar 0xfe || 0x17 == 0x1 (0x1) +__longlong 0xfffe || 0x17 == 0x1 (0x1) +__ulonglong 0xfffe || 0x17 == 0x1 (0x1) +int 0xfffe & 0x17 == 0x16 (0x16) +__uint 0xfffe & 0x17 == 0x16 (0x16) +char 0xfffe & 0x17 == 0x16 (0x16) +__uchar 0xfe & 0x17 == 0x16 (0x16) +__longlong 0xfffe & 0x17 == 0x16 (0x16) +__ulonglong 0xfffe & 0x17 == 0x16 (0x16) +int 0xfffe | 0x17 == -0x1 (0xffff) +__uint 0xfffe | 0x17 == -0x1 (0xffff) +char 0xfffe | 0x17 == -0x1 (0xffff) +__uchar 0xfe | 0x17 == 0xff (0xff) +__longlong 0xfffe | 0x17 == -0x1 (0xffff) +__ulonglong 0xfffe | 0x17 == -0x1 (0xffff) +int 0xfffe << 0xe == -0x8000 (0x8000) +__uint 0xfffe << 0xe == -0x8000 (0x8000) +char 0xfffe << 0xe == 0x0 (0x0) +__uchar 0xfe << 0xe == 0x0 (0x0) +__longlong 0xfffe << 0xe == -0x8000 (0x8000) +__ulonglong 0xfffe << 0xe == -0x8000 (0x8000) +int 0xfffe >> 0xe == -0x1 (0xffff) +__uint 0xfffe >> 0xe == 0x3 (0x3) +char 0xfffe >> 0xe == -0x1 (0xffff) +__uchar 0xfe >> 0xe == 0x0 (0x0) +__longlong 0xfffe >> 0xe == -0x1 (0xffff) +__ulonglong 0xfffe >> 0xe == -0x1 (0xffff) +int 0xfffe + 0x17 == 0x15 (0x15) +__uint 0xfffe + 0x17 == 0x15 (0x15) +char 0xfffe + 0x17 == 0x15 (0x15) +__uchar 0xfe + 0x17 == 0x15 (0x15) +__longlong 0xfffe + 0x17 == 0x15 (0x15) +__ulonglong 0xfffe + 0x17 == 0x15 (0x15) +float 0xfffe + 0x17 == 0x15 (0x15) +int 0xfffe - 0x17 == -0x19 (0xffe7) +__uint 0xfffe - 0x17 == -0x19 (0xffe7) +char 0xfffe - 0x17 == -0x19 (0xffe7) +__uchar 0xfe - 0x17 == 0xe7 (0xe7) +__longlong 0xfffe - 0x17 == -0x19 (0xffe7) +__ulonglong 0xfffe - 0x17 == -0x19 (0xffe7) +float 0xfffe - 0x17 == -0x19 (0xffe7) +int 0xfffe * 0x17 == -0x2e (0xffd2) +__uint 0xfffe * 0x17 == -0x2e (0xffd2) +char 0xfffe * 0x17 == -0x2e (0xffd2) +__uchar 0xfe * 0x17 == 0xd2 (0xd2) +__longlong 0xfffe * 0x17 == -0x2e (0xffd2) +__ulonglong 0xfffe * 0x17 == -0x2e (0xffd2) +float 0xfffe * 0x17 == -0x2e (0xffd2) +int 0xfffe < 0x17 == 0x1 (0x1) +__uint 0xfffe < 0x17 == 0x0 (0x0) +char 0xfffe < 0x17 == 0x1 (0x1) +__uchar 0xfe < 0x17 == 0x0 (0x0) +__longlong 0xfffe < 0x17 == 0x1 (0x1) +__ulonglong 0xfffe < 0x17 == 0x0 (0x0) +float 0xfffe < 0x17 == 0x1 (0x1) +int 0xfffe > 0x17 == 0x0 (0x0) +__uint 0xfffe > 0x17 == 0x1 (0x1) +char 0xfffe > 0x17 == 0x0 (0x0) +__uchar 0xfe > 0x17 == 0x1 (0x1) +__longlong 0xfffe > 0x17 == 0x0 (0x0) +__ulonglong 0xfffe > 0x17 == 0x1 (0x1) +float 0xfffe > 0x17 == 0x0 (0x0) +int 0xfffe <= 0x17 == 0x1 (0x1) +__uint 0xfffe <= 0x17 == 0x0 (0x0) +char 0xfffe <= 0x17 == 0x1 (0x1) +__uchar 0xfe <= 0x17 == 0x0 (0x0) +__longlong 0xfffe <= 0x17 == 0x1 (0x1) +__ulonglong 0xfffe <= 0x17 == 0x0 (0x0) +float 0xfffe <= 0x17 == 0x1 (0x1) +int 0xfffe == 0x17 == 0x0 (0x0) +__uint 0xfffe == 0x17 == 0x0 (0x0) +char 0xfffe == 0x17 == 0x0 (0x0) +__uchar 0xfe == 0x17 == 0x0 (0x0) +__longlong 0xfffe == 0x17 == 0x0 (0x0) +__ulonglong 0xfffe == 0x17 == 0x0 (0x0) +float 0xfffe == 0x17 == 0x0 (0x0) +int 0xfffe != 0x17 == 0x1 (0x1) +__uint 0xfffe != 0x17 == 0x1 (0x1) +char 0xfffe != 0x17 == 0x1 (0x1) +__uchar 0xfe != 0x17 == 0x1 (0x1) +__longlong 0xfffe != 0x17 == 0x1 (0x1) +__ulonglong 0xfffe != 0x17 == 0x1 (0x1) +float 0xfffe != 0x17 == 0x1 (0x1) +int 0xfffe >= 0x17 == 0x0 (0x0) +__uint 0xfffe >= 0x17 == 0x1 (0x1) +char 0xfffe >= 0x17 == 0x0 (0x0) +__uchar 0xfe >= 0x17 == 0x1 (0x1) +__longlong 0xfffe >= 0x17 == 0x0 (0x0) +__ulonglong 0xfffe >= 0x17 == 0x1 (0x1) +float 0xfffe >= 0x17 == 0x0 (0x0) +int 0xfffe / 0x17 == 0x0 (0x0) +__uint 0xfffe / 0x17 == 0xb21 (0xb21) +char 0xfffe / 0x17 == 0x0 (0x0) +__uchar 0xfe / 0x17 == 0xb (0xb) +__longlong 0xfffe / 0x17 == 0x0 (0x0) +__ulonglong 0xfffe / 0x17 == 0x642c (0x642c) +float 0xfffe / 0x17 == 0x0 (0x0) +int 0xfffe % 0x17 == -0x2 (0xfffe) +__uint 0xfffe % 0x17 == 0x7 (0x7) +char 0xfffe % 0x17 == -0x2 (0xfffe) +__uchar 0xfe % 0x17 == 0x1 (0x1) +__longlong 0xfffe % 0x17 == -0x2 (0xfffe) +__ulonglong 0xfffe % 0x17 == 0xa (0xa) +0xfffe * 0x7fff == 0x2 +0xfffe / 0x7fff == 0x0 +0xfffe % 0x7fff == -0x2 +int 0xfffe ^ 0x7fff == -0x7fff (0x8001) +__uint 0xfffe ^ 0x7fff == -0x7fff (0x8001) +char 0xfffe ^ 0xffff == 0x1 (0x1) +__uchar 0xfe ^ 0xff == 0x1 (0x1) +__longlong 0xfffe ^ 0x7fff == -0x7fff (0x8001) +__ulonglong 0xfffe ^ 0x7fff == -0x7fff (0x8001) +int 0xfffe && 0x7fff == 0x1 (0x1) +__uint 0xfffe && 0x7fff == 0x1 (0x1) +char 0xfffe && 0xffff == 0x1 (0x1) +__uchar 0xfe && 0xff == 0x1 (0x1) +__longlong 0xfffe && 0x7fff == 0x1 (0x1) +__ulonglong 0xfffe && 0x7fff == 0x1 (0x1) +int 0xfffe || 0x7fff == 0x1 (0x1) +__uint 0xfffe || 0x7fff == 0x1 (0x1) +char 0xfffe || 0xffff == 0x1 (0x1) +__uchar 0xfe || 0xff == 0x1 (0x1) +__longlong 0xfffe || 0x7fff == 0x1 (0x1) +__ulonglong 0xfffe || 0x7fff == 0x1 (0x1) +int 0xfffe & 0x7fff == 0x7ffe (0x7ffe) +__uint 0xfffe & 0x7fff == 0x7ffe (0x7ffe) +char 0xfffe & 0xffff == -0x2 (0xfffe) +__uchar 0xfe & 0xff == 0xfe (0xfe) +__longlong 0xfffe & 0x7fff == 0x7ffe (0x7ffe) +__ulonglong 0xfffe & 0x7fff == 0x7ffe (0x7ffe) +int 0xfffe | 0x7fff == -0x1 (0xffff) +__uint 0xfffe | 0x7fff == -0x1 (0xffff) +char 0xfffe | 0xffff == -0x1 (0xffff) +__uchar 0xfe | 0xff == 0xff (0xff) +__longlong 0xfffe | 0x7fff == -0x1 (0xffff) +__ulonglong 0xfffe | 0x7fff == -0x1 (0xffff) +int 0xfffe << 0x10 == 0x0 (0x0) +__uint 0xfffe << 0x10 == 0x0 (0x0) +char 0xfffe << 0x10 == 0x0 (0x0) +__uchar 0xfe << 0x10 == 0x0 (0x0) +__longlong 0xfffe << 0x10 == 0x0 (0x0) +__ulonglong 0xfffe << 0x10 == 0x0 (0x0) +int 0xfffe >> 0x10 == -0x1 (0xffff) +__uint 0xfffe >> 0x10 == 0x0 (0x0) +char 0xfffe >> 0x10 == -0x1 (0xffff) +__uchar 0xfe >> 0x10 == 0x0 (0x0) +__longlong 0xfffe >> 0x10 == -0x1 (0xffff) +__ulonglong 0xfffe >> 0x10 == -0x1 (0xffff) +int 0xfffe + 0x7fff == 0x7ffd (0x7ffd) +__uint 0xfffe + 0x7fff == 0x7ffd (0x7ffd) +char 0xfffe + 0xffff == -0x3 (0xfffd) +__uchar 0xfe + 0xff == 0xfd (0xfd) +__longlong 0xfffe + 0x7fff == 0x7ffd (0x7ffd) +__ulonglong 0xfffe + 0x7fff == 0x7ffd (0x7ffd) +float 0xfffe + 0x7fff == 0x7ffd (0x7ffd) +int 0xfffe - 0x7fff == 0x7fff (0x7fff) +__uint 0xfffe - 0x7fff == 0x7fff (0x7fff) +char 0xfffe - 0xffff == -0x1 (0xffff) +__uchar 0xfe - 0xff == 0xff (0xff) +__longlong 0xfffe - 0x7fff == 0x7fff (0x7fff) +__ulonglong 0xfffe - 0x7fff == 0x7fff (0x7fff) +float 0xfffe - 0x7fff == 0x7fff (0x7fff) +int 0xfffe * 0x7fff == 0x2 (0x2) +__uint 0xfffe * 0x7fff == 0x2 (0x2) +char 0xfffe * 0xffff == 0x2 (0x2) +__uchar 0xfe * 0xff == 0x2 (0x2) +__longlong 0xfffe * 0x7fff == 0x2 (0x2) +__ulonglong 0xfffe * 0x7fff == 0x2 (0x2) +float 0xfffe * 0x7fff == 0x2 (0x2) +int 0xfffe < 0x7fff == 0x1 (0x1) +__uint 0xfffe < 0x7fff == 0x0 (0x0) +char 0xfffe < 0xffff == 0x1 (0x1) +__uchar 0xfe < 0xff == 0x1 (0x1) +__longlong 0xfffe < 0x7fff == 0x1 (0x1) +__ulonglong 0xfffe < 0x7fff == 0x0 (0x0) +float 0xfffe < 0x7fff == 0x1 (0x1) +int 0xfffe > 0x7fff == 0x0 (0x0) +__uint 0xfffe > 0x7fff == 0x1 (0x1) +char 0xfffe > 0xffff == 0x0 (0x0) +__uchar 0xfe > 0xff == 0x0 (0x0) +__longlong 0xfffe > 0x7fff == 0x0 (0x0) +__ulonglong 0xfffe > 0x7fff == 0x1 (0x1) +float 0xfffe > 0x7fff == 0x0 (0x0) +int 0xfffe <= 0x7fff == 0x1 (0x1) +__uint 0xfffe <= 0x7fff == 0x0 (0x0) +char 0xfffe <= 0xffff == 0x1 (0x1) +__uchar 0xfe <= 0xff == 0x1 (0x1) +__longlong 0xfffe <= 0x7fff == 0x1 (0x1) +__ulonglong 0xfffe <= 0x7fff == 0x0 (0x0) +float 0xfffe <= 0x7fff == 0x1 (0x1) +int 0xfffe == 0x7fff == 0x0 (0x0) +__uint 0xfffe == 0x7fff == 0x0 (0x0) +char 0xfffe == 0xffff == 0x0 (0x0) +__uchar 0xfe == 0xff == 0x0 (0x0) +__longlong 0xfffe == 0x7fff == 0x0 (0x0) +__ulonglong 0xfffe == 0x7fff == 0x0 (0x0) +float 0xfffe == 0x7fff == 0x0 (0x0) +int 0xfffe != 0x7fff == 0x1 (0x1) +__uint 0xfffe != 0x7fff == 0x1 (0x1) +char 0xfffe != 0xffff == 0x1 (0x1) +__uchar 0xfe != 0xff == 0x1 (0x1) +__longlong 0xfffe != 0x7fff == 0x1 (0x1) +__ulonglong 0xfffe != 0x7fff == 0x1 (0x1) +float 0xfffe != 0x7fff == 0x1 (0x1) +int 0xfffe >= 0x7fff == 0x0 (0x0) +__uint 0xfffe >= 0x7fff == 0x1 (0x1) +char 0xfffe >= 0xffff == 0x0 (0x0) +__uchar 0xfe >= 0xff == 0x0 (0x0) +__longlong 0xfffe >= 0x7fff == 0x0 (0x0) +__ulonglong 0xfffe >= 0x7fff == 0x1 (0x1) +float 0xfffe >= 0x7fff == 0x0 (0x0) +int 0xfffe / 0x7fff == 0x0 (0x0) +__uint 0xfffe / 0x7fff == 0x2 (0x2) +char 0xfffe / 0xffff == 0x2 (0x2) +__uchar 0xfe / 0xff == 0x0 (0x0) +__longlong 0xfffe / 0x7fff == 0x0 (0x0) +__ulonglong 0xfffe / 0x7fff == 0x4 (0x4) +float 0xfffe / 0x7fff == 0x0 (0x0) +int 0xfffe % 0x7fff == -0x2 (0xfffe) +__uint 0xfffe % 0x7fff == 0x0 (0x0) +char 0xfffe % 0xffff == 0x0 (0x0) +__uchar 0xfe % 0xff == 0xfe (0xfe) +__longlong 0xfffe % 0x7fff == -0x2 (0xfffe) +__ulonglong 0xfffe % 0x7fff == 0x2 (0x2) +0xfffe * 0x8000 == 0x0 +0xfffe / 0x8000 == 0x0 +0xfffe % 0x8000 == -0x2 +int 0xfffe ^ 0x8000 == 0x7ffe (0x7ffe) +__uint 0xfffe ^ 0x8000 == 0x7ffe (0x7ffe) +char 0xfffe ^ 0x0 == -0x2 (0xfffe) +__uchar 0xfe ^ 0x0 == 0xfe (0xfe) +__longlong 0xfffe ^ 0x8000 == 0x7ffe (0x7ffe) +__ulonglong 0xfffe ^ 0x8000 == 0x7ffe (0x7ffe) +int 0xfffe && 0x8000 == 0x1 (0x1) +__uint 0xfffe && 0x8000 == 0x1 (0x1) +char 0xfffe && 0x0 == 0x0 (0x0) +__uchar 0xfe && 0x0 == 0x0 (0x0) +__longlong 0xfffe && 0x8000 == 0x1 (0x1) +__ulonglong 0xfffe && 0x8000 == 0x1 (0x1) +int 0xfffe || 0x8000 == 0x1 (0x1) +__uint 0xfffe || 0x8000 == 0x1 (0x1) +char 0xfffe || 0x0 == 0x1 (0x1) +__uchar 0xfe || 0x0 == 0x1 (0x1) +__longlong 0xfffe || 0x8000 == 0x1 (0x1) +__ulonglong 0xfffe || 0x8000 == 0x1 (0x1) +int 0xfffe & 0x8000 == -0x8000 (0x8000) +__uint 0xfffe & 0x8000 == -0x8000 (0x8000) +char 0xfffe & 0x0 == 0x0 (0x0) +__uchar 0xfe & 0x0 == 0x0 (0x0) +__longlong 0xfffe & 0x8000 == -0x8000 (0x8000) +__ulonglong 0xfffe & 0x8000 == -0x8000 (0x8000) +int 0xfffe | 0x8000 == -0x2 (0xfffe) +__uint 0xfffe | 0x8000 == -0x2 (0xfffe) +char 0xfffe | 0x0 == -0x2 (0xfffe) +__uchar 0xfe | 0x0 == 0xfe (0xfe) +__longlong 0xfffe | 0x8000 == -0x2 (0xfffe) +__ulonglong 0xfffe | 0x8000 == -0x2 (0xfffe) +int 0xfffe << 0x12 == 0x0 (0x0) +__uint 0xfffe << 0x12 == 0x0 (0x0) +char 0xfffe << 0x12 == 0x0 (0x0) +__uchar 0xfe << 0x12 == 0x0 (0x0) +__longlong 0xfffe << 0x12 == 0x0 (0x0) +__ulonglong 0xfffe << 0x12 == 0x0 (0x0) +int 0xfffe >> 0x12 == -0x1 (0xffff) +__uint 0xfffe >> 0x12 == 0x0 (0x0) +char 0xfffe >> 0x12 == -0x1 (0xffff) +__uchar 0xfe >> 0x12 == 0x0 (0x0) +__longlong 0xfffe >> 0x12 == -0x1 (0xffff) +__ulonglong 0xfffe >> 0x12 == 0x3fff (0x3fff) +int 0xfffe + 0x8000 == 0x7ffe (0x7ffe) +__uint 0xfffe + 0x8000 == 0x7ffe (0x7ffe) +char 0xfffe + 0x0 == -0x2 (0xfffe) +__uchar 0xfe + 0x0 == 0xfe (0xfe) +__longlong 0xfffe + 0x8000 == 0x7ffe (0x7ffe) +__ulonglong 0xfffe + 0x8000 == 0x7ffe (0x7ffe) +float 0xfffe + 0x8000 == 0x7ffe (0x7ffe) +int 0xfffe - 0x8000 == 0x7ffe (0x7ffe) +__uint 0xfffe - 0x8000 == 0x7ffe (0x7ffe) +char 0xfffe - 0x0 == -0x2 (0xfffe) +__uchar 0xfe - 0x0 == 0xfe (0xfe) +__longlong 0xfffe - 0x8000 == 0x7ffe (0x7ffe) +__ulonglong 0xfffe - 0x8000 == 0x7ffe (0x7ffe) +float 0xfffe - 0x8000 == 0x7ffe (0x7ffe) +int 0xfffe * 0x8000 == 0x0 (0x0) +__uint 0xfffe * 0x8000 == 0x0 (0x0) +char 0xfffe * 0x0 == 0x0 (0x0) +__uchar 0xfe * 0x0 == 0x0 (0x0) +__longlong 0xfffe * 0x8000 == 0x0 (0x0) +__ulonglong 0xfffe * 0x8000 == 0x0 (0x0) +float 0xfffe * 0x8000 == 0x0 (0x0) +int 0xfffe < 0x8000 == 0x0 (0x0) +__uint 0xfffe < 0x8000 == 0x0 (0x0) +char 0xfffe < 0x0 == 0x1 (0x1) +__uchar 0xfe < 0x0 == 0x0 (0x0) +__longlong 0xfffe < 0x8000 == 0x0 (0x0) +__ulonglong 0xfffe < 0x8000 == 0x0 (0x0) +float 0xfffe < 0x8000 == 0x0 (0x0) +int 0xfffe > 0x8000 == 0x1 (0x1) +__uint 0xfffe > 0x8000 == 0x1 (0x1) +char 0xfffe > 0x0 == 0x0 (0x0) +__uchar 0xfe > 0x0 == 0x1 (0x1) +__longlong 0xfffe > 0x8000 == 0x1 (0x1) +__ulonglong 0xfffe > 0x8000 == 0x1 (0x1) +float 0xfffe > 0x8000 == 0x1 (0x1) +int 0xfffe <= 0x8000 == 0x0 (0x0) +__uint 0xfffe <= 0x8000 == 0x0 (0x0) +char 0xfffe <= 0x0 == 0x1 (0x1) +__uchar 0xfe <= 0x0 == 0x0 (0x0) +__longlong 0xfffe <= 0x8000 == 0x0 (0x0) +__ulonglong 0xfffe <= 0x8000 == 0x0 (0x0) +float 0xfffe <= 0x8000 == 0x0 (0x0) +int 0xfffe == 0x8000 == 0x0 (0x0) +__uint 0xfffe == 0x8000 == 0x0 (0x0) +char 0xfffe == 0x0 == 0x0 (0x0) +__uchar 0xfe == 0x0 == 0x0 (0x0) +__longlong 0xfffe == 0x8000 == 0x0 (0x0) +__ulonglong 0xfffe == 0x8000 == 0x0 (0x0) +float 0xfffe == 0x8000 == 0x0 (0x0) +int 0xfffe != 0x8000 == 0x1 (0x1) +__uint 0xfffe != 0x8000 == 0x1 (0x1) +char 0xfffe != 0x0 == 0x1 (0x1) +__uchar 0xfe != 0x0 == 0x1 (0x1) +__longlong 0xfffe != 0x8000 == 0x1 (0x1) +__ulonglong 0xfffe != 0x8000 == 0x1 (0x1) +float 0xfffe != 0x8000 == 0x1 (0x1) +int 0xfffe >= 0x8000 == 0x1 (0x1) +__uint 0xfffe >= 0x8000 == 0x1 (0x1) +char 0xfffe >= 0x0 == 0x0 (0x0) +__uchar 0xfe >= 0x0 == 0x1 (0x1) +__longlong 0xfffe >= 0x8000 == 0x1 (0x1) +__ulonglong 0xfffe >= 0x8000 == 0x1 (0x1) +float 0xfffe >= 0x8000 == 0x1 (0x1) +int 0xfffe / 0x8000 == 0x0 (0x0) +__uint 0xfffe / 0x8000 == 0x1 (0x1) +__longlong 0xfffe / 0x8000 == 0x0 (0x0) +__ulonglong 0xfffe / 0x8000 == 0x1 (0x1) +float 0xfffe / 0x8000 == 0x0 (0x0) +int 0xfffe % 0x8000 == -0x2 (0xfffe) +__uint 0xfffe % 0x8000 == 0x7ffe (0x7ffe) +__longlong 0xfffe % 0x8000 == -0x2 (0xfffe) +__ulonglong 0xfffe % 0x8000 == 0x7ffe (0x7ffe) +0xfffe * 0x3e8 == -0x7d0 +0xfffe / 0x3e8 == 0x0 +0xfffe % 0x3e8 == -0x2 +int 0xfffe ^ 0x3e8 == -0x3ea (0xfc16) +__uint 0xfffe ^ 0x3e8 == -0x3ea (0xfc16) +char 0xfffe ^ 0xffe8 == 0x16 (0x16) +__uchar 0xfe ^ 0xe8 == 0x16 (0x16) +__longlong 0xfffe ^ 0x3e8 == -0x3ea (0xfc16) +__ulonglong 0xfffe ^ 0x3e8 == -0x3ea (0xfc16) +int 0xfffe && 0x3e8 == 0x1 (0x1) +__uint 0xfffe && 0x3e8 == 0x1 (0x1) +char 0xfffe && 0xffe8 == 0x1 (0x1) +__uchar 0xfe && 0xe8 == 0x1 (0x1) +__longlong 0xfffe && 0x3e8 == 0x1 (0x1) +__ulonglong 0xfffe && 0x3e8 == 0x1 (0x1) +int 0xfffe || 0x3e8 == 0x1 (0x1) +__uint 0xfffe || 0x3e8 == 0x1 (0x1) +char 0xfffe || 0xffe8 == 0x1 (0x1) +__uchar 0xfe || 0xe8 == 0x1 (0x1) +__longlong 0xfffe || 0x3e8 == 0x1 (0x1) +__ulonglong 0xfffe || 0x3e8 == 0x1 (0x1) +int 0xfffe & 0x3e8 == 0x3e8 (0x3e8) +__uint 0xfffe & 0x3e8 == 0x3e8 (0x3e8) +char 0xfffe & 0xffe8 == -0x18 (0xffe8) +__uchar 0xfe & 0xe8 == 0xe8 (0xe8) +__longlong 0xfffe & 0x3e8 == 0x3e8 (0x3e8) +__ulonglong 0xfffe & 0x3e8 == 0x3e8 (0x3e8) +int 0xfffe | 0x3e8 == -0x2 (0xfffe) +__uint 0xfffe | 0x3e8 == -0x2 (0xfffe) +char 0xfffe | 0xffe8 == -0x2 (0xfffe) +__uchar 0xfe | 0xe8 == 0xfe (0xfe) +__longlong 0xfffe | 0x3e8 == -0x2 (0xfffe) +__ulonglong 0xfffe | 0x3e8 == -0x2 (0xfffe) +int 0xfffe << 0x14 == 0x0 (0x0) +__uint 0xfffe << 0x14 == 0x0 (0x0) +char 0xfffe << 0x14 == 0x0 (0x0) +__uchar 0xfe << 0x14 == 0x0 (0x0) +__longlong 0xfffe << 0x14 == 0x0 (0x0) +__ulonglong 0xfffe << 0x14 == 0x0 (0x0) +int 0xfffe >> 0x14 == -0x1 (0xffff) +__uint 0xfffe >> 0x14 == 0x0 (0x0) +char 0xfffe >> 0x14 == -0x1 (0xffff) +__uchar 0xfe >> 0x14 == 0x0 (0x0) +__longlong 0xfffe >> 0x14 == -0x1 (0xffff) +__ulonglong 0xfffe >> 0x14 == 0xfff (0xfff) +int 0xfffe + 0x3e8 == 0x3e6 (0x3e6) +__uint 0xfffe + 0x3e8 == 0x3e6 (0x3e6) +char 0xfffe + 0xffe8 == -0x1a (0xffe6) +__uchar 0xfe + 0xe8 == 0xe6 (0xe6) +__longlong 0xfffe + 0x3e8 == 0x3e6 (0x3e6) +__ulonglong 0xfffe + 0x3e8 == 0x3e6 (0x3e6) +float 0xfffe + 0x3e8 == 0x3e6 (0x3e6) +int 0xfffe - 0x3e8 == -0x3ea (0xfc16) +__uint 0xfffe - 0x3e8 == -0x3ea (0xfc16) +char 0xfffe - 0xffe8 == 0x16 (0x16) +__uchar 0xfe - 0xe8 == 0x16 (0x16) +__longlong 0xfffe - 0x3e8 == -0x3ea (0xfc16) +__ulonglong 0xfffe - 0x3e8 == -0x3ea (0xfc16) +float 0xfffe - 0x3e8 == -0x3ea (0xfc16) +int 0xfffe * 0x3e8 == -0x7d0 (0xf830) +__uint 0xfffe * 0x3e8 == -0x7d0 (0xf830) +char 0xfffe * 0xffe8 == 0x30 (0x30) +__uchar 0xfe * 0xe8 == 0x30 (0x30) +__longlong 0xfffe * 0x3e8 == -0x7d0 (0xf830) +__ulonglong 0xfffe * 0x3e8 == -0x7d0 (0xf830) +float 0xfffe * 0x3e8 == -0x7d0 (0xf830) +int 0xfffe < 0x3e8 == 0x1 (0x1) +__uint 0xfffe < 0x3e8 == 0x0 (0x0) +char 0xfffe < 0xffe8 == 0x0 (0x0) +__uchar 0xfe < 0xe8 == 0x0 (0x0) +__longlong 0xfffe < 0x3e8 == 0x1 (0x1) +__ulonglong 0xfffe < 0x3e8 == 0x0 (0x0) +float 0xfffe < 0x3e8 == 0x1 (0x1) +int 0xfffe > 0x3e8 == 0x0 (0x0) +__uint 0xfffe > 0x3e8 == 0x1 (0x1) +char 0xfffe > 0xffe8 == 0x1 (0x1) +__uchar 0xfe > 0xe8 == 0x1 (0x1) +__longlong 0xfffe > 0x3e8 == 0x0 (0x0) +__ulonglong 0xfffe > 0x3e8 == 0x1 (0x1) +float 0xfffe > 0x3e8 == 0x0 (0x0) +int 0xfffe <= 0x3e8 == 0x1 (0x1) +__uint 0xfffe <= 0x3e8 == 0x0 (0x0) +char 0xfffe <= 0xffe8 == 0x0 (0x0) +__uchar 0xfe <= 0xe8 == 0x0 (0x0) +__longlong 0xfffe <= 0x3e8 == 0x1 (0x1) +__ulonglong 0xfffe <= 0x3e8 == 0x0 (0x0) +float 0xfffe <= 0x3e8 == 0x1 (0x1) +int 0xfffe == 0x3e8 == 0x0 (0x0) +__uint 0xfffe == 0x3e8 == 0x0 (0x0) +char 0xfffe == 0xffe8 == 0x0 (0x0) +__uchar 0xfe == 0xe8 == 0x0 (0x0) +__longlong 0xfffe == 0x3e8 == 0x0 (0x0) +__ulonglong 0xfffe == 0x3e8 == 0x0 (0x0) +float 0xfffe == 0x3e8 == 0x0 (0x0) +int 0xfffe != 0x3e8 == 0x1 (0x1) +__uint 0xfffe != 0x3e8 == 0x1 (0x1) +char 0xfffe != 0xffe8 == 0x1 (0x1) +__uchar 0xfe != 0xe8 == 0x1 (0x1) +__longlong 0xfffe != 0x3e8 == 0x1 (0x1) +__ulonglong 0xfffe != 0x3e8 == 0x1 (0x1) +float 0xfffe != 0x3e8 == 0x1 (0x1) +int 0xfffe >= 0x3e8 == 0x0 (0x0) +__uint 0xfffe >= 0x3e8 == 0x1 (0x1) +char 0xfffe >= 0xffe8 == 0x1 (0x1) +__uchar 0xfe >= 0xe8 == 0x1 (0x1) +__longlong 0xfffe >= 0x3e8 == 0x0 (0x0) +__ulonglong 0xfffe >= 0x3e8 == 0x1 (0x1) +float 0xfffe >= 0x3e8 == 0x0 (0x0) +int 0xfffe / 0x3e8 == 0x0 (0x0) +__uint 0xfffe / 0x3e8 == 0x41 (0x41) +char 0xfffe / 0xffe8 == 0x0 (0x0) +__uchar 0xfe / 0xe8 == 0x1 (0x1) +__longlong 0xfffe / 0x3e8 == 0x0 (0x0) +__ulonglong 0xfffe / 0x3e8 == -0x76c9 (0x8937) +float 0xfffe / 0x3e8 == 0x0 (0x0) +int 0xfffe % 0x3e8 == -0x2 (0xfffe) +__uint 0xfffe % 0x3e8 == 0x216 (0x216) +char 0xfffe % 0xffe8 == -0x2 (0xfffe) +__uchar 0xfe % 0xe8 == 0x16 (0x16) +__longlong 0xfffe % 0x3e8 == -0x2 (0xfffe) +__ulonglong 0xfffe % 0x3e8 == 0x126 (0x126) +0xfffe * 0x2710 == -0x4e20 +0xfffe / 0x2710 == 0x0 +0xfffe % 0x2710 == -0x2 +int 0xfffe ^ 0x2710 == -0x2712 (0xd8ee) +__uint 0xfffe ^ 0x2710 == -0x2712 (0xd8ee) +char 0xfffe ^ 0x10 == -0x12 (0xffee) +__uchar 0xfe ^ 0x10 == 0xee (0xee) +__longlong 0xfffe ^ 0x2710 == -0x2712 (0xd8ee) +__ulonglong 0xfffe ^ 0x2710 == -0x2712 (0xd8ee) +int 0xfffe && 0x2710 == 0x1 (0x1) +__uint 0xfffe && 0x2710 == 0x1 (0x1) +char 0xfffe && 0x10 == 0x1 (0x1) +__uchar 0xfe && 0x10 == 0x1 (0x1) +__longlong 0xfffe && 0x2710 == 0x1 (0x1) +__ulonglong 0xfffe && 0x2710 == 0x1 (0x1) +int 0xfffe || 0x2710 == 0x1 (0x1) +__uint 0xfffe || 0x2710 == 0x1 (0x1) +char 0xfffe || 0x10 == 0x1 (0x1) +__uchar 0xfe || 0x10 == 0x1 (0x1) +__longlong 0xfffe || 0x2710 == 0x1 (0x1) +__ulonglong 0xfffe || 0x2710 == 0x1 (0x1) +int 0xfffe & 0x2710 == 0x2710 (0x2710) +__uint 0xfffe & 0x2710 == 0x2710 (0x2710) +char 0xfffe & 0x10 == 0x10 (0x10) +__uchar 0xfe & 0x10 == 0x10 (0x10) +__longlong 0xfffe & 0x2710 == 0x2710 (0x2710) +__ulonglong 0xfffe & 0x2710 == 0x2710 (0x2710) +int 0xfffe | 0x2710 == -0x2 (0xfffe) +__uint 0xfffe | 0x2710 == -0x2 (0xfffe) +char 0xfffe | 0x10 == -0x2 (0xfffe) +__uchar 0xfe | 0x10 == 0xfe (0xfe) +__longlong 0xfffe | 0x2710 == -0x2 (0xfffe) +__ulonglong 0xfffe | 0x2710 == -0x2 (0xfffe) +int 0xfffe << 0x16 == 0x0 (0x0) +__uint 0xfffe << 0x16 == 0x0 (0x0) +char 0xfffe << 0x16 == 0x0 (0x0) +__uchar 0xfe << 0x16 == 0x0 (0x0) +__longlong 0xfffe << 0x16 == 0x0 (0x0) +__ulonglong 0xfffe << 0x16 == 0x0 (0x0) +int 0xfffe >> 0x16 == -0x1 (0xffff) +__uint 0xfffe >> 0x16 == 0x0 (0x0) +char 0xfffe >> 0x16 == -0x1 (0xffff) +__uchar 0xfe >> 0x16 == 0x0 (0x0) +__longlong 0xfffe >> 0x16 == -0x1 (0xffff) +__ulonglong 0xfffe >> 0x16 == 0x3ff (0x3ff) +int 0xfffe + 0x2710 == 0x270e (0x270e) +__uint 0xfffe + 0x2710 == 0x270e (0x270e) +char 0xfffe + 0x10 == 0xe (0xe) +__uchar 0xfe + 0x10 == 0xe (0xe) +__longlong 0xfffe + 0x2710 == 0x270e (0x270e) +__ulonglong 0xfffe + 0x2710 == 0x270e (0x270e) +float 0xfffe + 0x2710 == 0x270e (0x270e) +int 0xfffe - 0x2710 == -0x2712 (0xd8ee) +__uint 0xfffe - 0x2710 == -0x2712 (0xd8ee) +char 0xfffe - 0x10 == -0x12 (0xffee) +__uchar 0xfe - 0x10 == 0xee (0xee) +__longlong 0xfffe - 0x2710 == -0x2712 (0xd8ee) +__ulonglong 0xfffe - 0x2710 == -0x2712 (0xd8ee) +float 0xfffe - 0x2710 == -0x2712 (0xd8ee) +int 0xfffe * 0x2710 == -0x4e20 (0xb1e0) +__uint 0xfffe * 0x2710 == -0x4e20 (0xb1e0) +char 0xfffe * 0x10 == -0x20 (0xffe0) +__uchar 0xfe * 0x10 == 0xe0 (0xe0) +__longlong 0xfffe * 0x2710 == -0x4e20 (0xb1e0) +__ulonglong 0xfffe * 0x2710 == -0x4e20 (0xb1e0) +float 0xfffe * 0x2710 == -0x4e20 (0xb1e0) +int 0xfffe < 0x2710 == 0x1 (0x1) +__uint 0xfffe < 0x2710 == 0x0 (0x0) +char 0xfffe < 0x10 == 0x1 (0x1) +__uchar 0xfe < 0x10 == 0x0 (0x0) +__longlong 0xfffe < 0x2710 == 0x1 (0x1) +__ulonglong 0xfffe < 0x2710 == 0x0 (0x0) +float 0xfffe < 0x2710 == 0x1 (0x1) +int 0xfffe > 0x2710 == 0x0 (0x0) +__uint 0xfffe > 0x2710 == 0x1 (0x1) +char 0xfffe > 0x10 == 0x0 (0x0) +__uchar 0xfe > 0x10 == 0x1 (0x1) +__longlong 0xfffe > 0x2710 == 0x0 (0x0) +__ulonglong 0xfffe > 0x2710 == 0x1 (0x1) +float 0xfffe > 0x2710 == 0x0 (0x0) +int 0xfffe <= 0x2710 == 0x1 (0x1) +__uint 0xfffe <= 0x2710 == 0x0 (0x0) +char 0xfffe <= 0x10 == 0x1 (0x1) +__uchar 0xfe <= 0x10 == 0x0 (0x0) +__longlong 0xfffe <= 0x2710 == 0x1 (0x1) +__ulonglong 0xfffe <= 0x2710 == 0x0 (0x0) +float 0xfffe <= 0x2710 == 0x1 (0x1) +int 0xfffe == 0x2710 == 0x0 (0x0) +__uint 0xfffe == 0x2710 == 0x0 (0x0) +char 0xfffe == 0x10 == 0x0 (0x0) +__uchar 0xfe == 0x10 == 0x0 (0x0) +__longlong 0xfffe == 0x2710 == 0x0 (0x0) +__ulonglong 0xfffe == 0x2710 == 0x0 (0x0) +float 0xfffe == 0x2710 == 0x0 (0x0) +int 0xfffe != 0x2710 == 0x1 (0x1) +__uint 0xfffe != 0x2710 == 0x1 (0x1) +char 0xfffe != 0x10 == 0x1 (0x1) +__uchar 0xfe != 0x10 == 0x1 (0x1) +__longlong 0xfffe != 0x2710 == 0x1 (0x1) +__ulonglong 0xfffe != 0x2710 == 0x1 (0x1) +float 0xfffe != 0x2710 == 0x1 (0x1) +int 0xfffe >= 0x2710 == 0x0 (0x0) +__uint 0xfffe >= 0x2710 == 0x1 (0x1) +char 0xfffe >= 0x10 == 0x0 (0x0) +__uchar 0xfe >= 0x10 == 0x1 (0x1) +__longlong 0xfffe >= 0x2710 == 0x0 (0x0) +__ulonglong 0xfffe >= 0x2710 == 0x1 (0x1) +float 0xfffe >= 0x2710 == 0x0 (0x0) +int 0xfffe / 0x2710 == 0x0 (0x0) +__uint 0xfffe / 0x2710 == 0x6 (0x6) +char 0xfffe / 0x10 == 0x0 (0x0) +__uchar 0xfe / 0x10 == 0xf (0xf) +__longlong 0xfffe / 0x2710 == 0x0 (0x0) +__ulonglong 0xfffe / 0x2710 == -0x7248 (0x8db8) +float 0xfffe / 0x2710 == 0x0 (0x0) +int 0xfffe % 0x2710 == -0x2 (0xfffe) +__uint 0xfffe % 0x2710 == 0x159e (0x159e) +char 0xfffe % 0x10 == -0x2 (0xfffe) +__uchar 0xfe % 0x10 == 0xe (0xe) +__longlong 0xfffe % 0x2710 == -0x2 (0xfffe) +__ulonglong 0xfffe % 0x2710 == 0x1c7e (0x1c7e) +int xor42-0x2 xor42 -0x2c +__uint xor42-0x2 xor42 -0x2c +char xor42-0x2 xor42 -0x2c +__uchar xor420xfe xor42 0xd4 +__longlong xor42-0x2 xor42 -0x2c +__ulonglong xor42-0x2 xor42 -0x2c +int land1-0x2 land1 0x1 +__uint land1-0x2 land1 0x1 +char land1-0x2 land1 0x1 +__uchar land10xfe land1 0x1 +__longlong land1-0x2 land1 0x1 +__ulonglong land1-0x2 land1 0x1 +int lor1-0x2 lor1 0x1 +__uint lor1-0x2 lor1 0x1 +char lor1-0x2 lor1 0x1 +__uchar lor10xfe lor1 0x1 +__longlong lor1-0x2 lor1 0x1 +__ulonglong lor1-0x2 lor1 0x1 +int and42-0x2 and42 0x2a +__uint and42-0x2 and42 0x2a +char and42-0x2 and42 0x2a +__uchar and420xfe and42 0x2a +__longlong and42-0x2 and42 0x2a +__ulonglong and42-0x2 and42 0x2a +int or42-0x2 or42 -0x2 +__uint or42-0x2 or42 -0x2 +char or42-0x2 or42 -0x2 +__uchar or420xfe or42 0xfe +__longlong or42-0x2 or42 -0x2 +__ulonglong or42-0x2 or42 -0x2 +int shl5-0x2 shl5 -0x40 +__uint shl5-0x2 shl5 -0x40 +char shl5-0x2 shl5 -0x40 +__uchar shl50xfe shl5 0xc0 +__longlong shl5-0x2 shl5 -0x40 +__ulonglong shl5-0x2 shl5 -0x40 +int shr5-0x2 shr5 -0x1 +__uint shr5-0x2 shr5 0x7ff +char shr5-0x2 shr5 -0x1 +__uchar shr50xfe shr5 0x7 +__longlong shr5-0x2 shr5 -0x1 +__ulonglong shr5-0x2 shr5 -0x1 +int add42-0x2 add42 0x28 +__uint add42-0x2 add42 0x28 +char add42-0x2 add42 0x28 +__uchar add420xfe add42 0x28 +__longlong add42-0x2 add42 0x28 +__ulonglong add42-0x2 add42 0x28 +float add42-0x2 add42 0x28 +int sub42-0x2 sub42 -0x2c +__uint sub42-0x2 sub42 -0x2c +char sub42-0x2 sub42 -0x2c +__uchar sub420xfe sub42 0xd4 +__longlong sub42-0x2 sub42 -0x2c +__ulonglong sub42-0x2 sub42 -0x2c +float sub42-0x2 sub42 -0x2c +int mul42-0x2 mul42 -0x54 +__uint mul42-0x2 mul42 -0x54 +char mul42-0x2 mul42 -0x54 +__uchar mul420xfe mul42 0xac +__longlong mul42-0x2 mul42 -0x54 +__ulonglong mul42-0x2 mul42 -0x54 +float mul42-0x2 mul42 -0x54 +int lt42-0x2 lt42 0x1 +__uint lt42-0x2 lt42 0x0 +char lt42-0x2 lt42 0x1 +__uchar lt420xfe lt42 0x0 +__longlong lt42-0x2 lt42 0x1 +__ulonglong lt42-0x2 lt42 0x0 +float lt42-0x2 lt42 0x1 +int gt42-0x2 gt42 0x0 +__uint gt42-0x2 gt42 0x1 +char gt42-0x2 gt42 0x0 +__uchar gt420xfe gt42 0x1 +__longlong gt42-0x2 gt42 0x0 +__ulonglong gt42-0x2 gt42 0x1 +float gt42-0x2 gt42 0x0 +int le42-0x2 le42 0x1 +__uint le42-0x2 le42 0x0 +char le42-0x2 le42 0x1 +__uchar le420xfe le42 0x0 +__longlong le42-0x2 le42 0x1 +__ulonglong le42-0x2 le42 0x0 +float le42-0x2 le42 0x1 +int eq42-0x2 eq42 0x0 +__uint eq42-0x2 eq42 0x0 +char eq42-0x2 eq42 0x0 +__uchar eq420xfe eq42 0x0 +__longlong eq42-0x2 eq42 0x0 +__ulonglong eq42-0x2 eq42 0x0 +float eq42-0x2 eq42 0x0 +int ne42-0x2 ne42 0x1 +__uint ne42-0x2 ne42 0x1 +char ne42-0x2 ne42 0x1 +__uchar ne420xfe ne42 0x1 +__longlong ne42-0x2 ne42 0x1 +__ulonglong ne42-0x2 ne42 0x1 +float ne42-0x2 ne42 0x1 +int ge42-0x2 ge42 0x0 +__uint ge42-0x2 ge42 0x1 +char ge42-0x2 ge42 0x0 +__uchar ge420xfe ge42 0x1 +__longlong ge42-0x2 ge42 0x0 +__ulonglong ge42-0x2 ge42 0x1 +float ge42-0x2 ge42 0x0 +int div42-0x2 div42 0x0 +__uint div42-0x2 div42 0x618 +char div42-0x2 div42 0x0 +__uchar div420xfe div42 0x6 +__longlong div42-0x2 div42 0x0 +__ulonglong div42-0x2 div42 0x6186 +float div42-0x2 div42 0x0 +int mod23-0x2 mod23 -0x2 +__uint mod23-0x2 mod23 0x7 +char mod23-0x2 mod23 -0x2 +__uchar mod230xfe mod23 0x1 +__longlong mod23-0x2 mod23 -0x2 +__ulonglong mod23-0x2 mod23 0xa +0x4 * 0xffff == -0x4 +0x4 / 0xffff == -0x4 +0x4 % 0xffff == 0x0 +int 0x4 ^ 0xffff == -0x5 (0xfffb) +__uint 0x4 ^ 0xffff == -0x5 (0xfffb) +char 0x4 ^ 0xffff == -0x5 (0xfffb) +__uchar 0x4 ^ 0xff == 0xfb (0xfb) +__longlong 0x4 ^ 0xffff == -0x5 (0xfffb) +__ulonglong 0x4 ^ 0xffff == -0x5 (0xfffb) +int 0x4 && 0xffff == 0x1 (0x1) +__uint 0x4 && 0xffff == 0x1 (0x1) +char 0x4 && 0xffff == 0x1 (0x1) +__uchar 0x4 && 0xff == 0x1 (0x1) +__longlong 0x4 && 0xffff == 0x1 (0x1) +__ulonglong 0x4 && 0xffff == 0x1 (0x1) +int 0x4 || 0xffff == 0x1 (0x1) +__uint 0x4 || 0xffff == 0x1 (0x1) +char 0x4 || 0xffff == 0x1 (0x1) +__uchar 0x4 || 0xff == 0x1 (0x1) +__longlong 0x4 || 0xffff == 0x1 (0x1) +__ulonglong 0x4 || 0xffff == 0x1 (0x1) +int 0x4 & 0xffff == 0x4 (0x4) +__uint 0x4 & 0xffff == 0x4 (0x4) +char 0x4 & 0xffff == 0x4 (0x4) +__uchar 0x4 & 0xff == 0x4 (0x4) +__longlong 0x4 & 0xffff == 0x4 (0x4) +__ulonglong 0x4 & 0xffff == 0x4 (0x4) +int 0x4 | 0xffff == -0x1 (0xffff) +__uint 0x4 | 0xffff == -0x1 (0xffff) +char 0x4 | 0xffff == -0x1 (0xffff) +__uchar 0x4 | 0xff == 0xff (0xff) +__longlong 0x4 | 0xffff == -0x1 (0xffff) +__ulonglong 0x4 | 0xffff == -0x1 (0xffff) +int 0x4 << 0x1 == 0x8 (0x8) +__uint 0x4 << 0x1 == 0x8 (0x8) +char 0x4 << 0x1 == 0x8 (0x8) +__uchar 0x4 << 0x1 == 0x8 (0x8) +__longlong 0x4 << 0x1 == 0x8 (0x8) +__ulonglong 0x4 << 0x1 == 0x8 (0x8) +int 0x4 >> 0x1 == 0x2 (0x2) +__uint 0x4 >> 0x1 == 0x2 (0x2) +char 0x4 >> 0x1 == 0x2 (0x2) +__uchar 0x4 >> 0x1 == 0x2 (0x2) +__longlong 0x4 >> 0x1 == 0x2 (0x2) +__ulonglong 0x4 >> 0x1 == 0x2 (0x2) +int 0x4 + 0xffff == 0x3 (0x3) +__uint 0x4 + 0xffff == 0x3 (0x3) +char 0x4 + 0xffff == 0x3 (0x3) +__uchar 0x4 + 0xff == 0x3 (0x3) +__longlong 0x4 + 0xffff == 0x3 (0x3) +__ulonglong 0x4 + 0xffff == 0x3 (0x3) +float 0x4 + 0xffff == 0x3 (0x3) +int 0x4 - 0xffff == 0x5 (0x5) +__uint 0x4 - 0xffff == 0x5 (0x5) +char 0x4 - 0xffff == 0x5 (0x5) +__uchar 0x4 - 0xff == 0x5 (0x5) +__longlong 0x4 - 0xffff == 0x5 (0x5) +__ulonglong 0x4 - 0xffff == 0x5 (0x5) +float 0x4 - 0xffff == 0x5 (0x5) +int 0x4 * 0xffff == -0x4 (0xfffc) +__uint 0x4 * 0xffff == -0x4 (0xfffc) +char 0x4 * 0xffff == -0x4 (0xfffc) +__uchar 0x4 * 0xff == 0xfc (0xfc) +__longlong 0x4 * 0xffff == -0x4 (0xfffc) +__ulonglong 0x4 * 0xffff == -0x4 (0xfffc) +float 0x4 * 0xffff == -0x4 (0xfffc) +int 0x4 < 0xffff == 0x0 (0x0) +__uint 0x4 < 0xffff == 0x1 (0x1) +char 0x4 < 0xffff == 0x0 (0x0) +__uchar 0x4 < 0xff == 0x1 (0x1) +__longlong 0x4 < 0xffff == 0x0 (0x0) +__ulonglong 0x4 < 0xffff == 0x1 (0x1) +float 0x4 < 0xffff == 0x0 (0x0) +int 0x4 > 0xffff == 0x1 (0x1) +__uint 0x4 > 0xffff == 0x0 (0x0) +char 0x4 > 0xffff == 0x1 (0x1) +__uchar 0x4 > 0xff == 0x0 (0x0) +__longlong 0x4 > 0xffff == 0x1 (0x1) +__ulonglong 0x4 > 0xffff == 0x0 (0x0) +float 0x4 > 0xffff == 0x1 (0x1) +int 0x4 <= 0xffff == 0x0 (0x0) +__uint 0x4 <= 0xffff == 0x1 (0x1) +char 0x4 <= 0xffff == 0x0 (0x0) +__uchar 0x4 <= 0xff == 0x1 (0x1) +__longlong 0x4 <= 0xffff == 0x0 (0x0) +__ulonglong 0x4 <= 0xffff == 0x1 (0x1) +float 0x4 <= 0xffff == 0x0 (0x0) +int 0x4 == 0xffff == 0x0 (0x0) +__uint 0x4 == 0xffff == 0x0 (0x0) +char 0x4 == 0xffff == 0x0 (0x0) +__uchar 0x4 == 0xff == 0x0 (0x0) +__longlong 0x4 == 0xffff == 0x0 (0x0) +__ulonglong 0x4 == 0xffff == 0x0 (0x0) +float 0x4 == 0xffff == 0x0 (0x0) +int 0x4 != 0xffff == 0x1 (0x1) +__uint 0x4 != 0xffff == 0x1 (0x1) +char 0x4 != 0xffff == 0x1 (0x1) +__uchar 0x4 != 0xff == 0x1 (0x1) +__longlong 0x4 != 0xffff == 0x1 (0x1) +__ulonglong 0x4 != 0xffff == 0x1 (0x1) +float 0x4 != 0xffff == 0x1 (0x1) +int 0x4 >= 0xffff == 0x1 (0x1) +__uint 0x4 >= 0xffff == 0x0 (0x0) +char 0x4 >= 0xffff == 0x1 (0x1) +__uchar 0x4 >= 0xff == 0x0 (0x0) +__longlong 0x4 >= 0xffff == 0x1 (0x1) +__ulonglong 0x4 >= 0xffff == 0x0 (0x0) +float 0x4 >= 0xffff == 0x1 (0x1) +int 0x4 / 0xffff == -0x4 (0xfffc) +__uint 0x4 / 0xffff == 0x0 (0x0) +char 0x4 / 0xffff == -0x4 (0xfffc) +__uchar 0x4 / 0xff == 0x0 (0x0) +__longlong 0x4 / 0xffff == -0x4 (0xfffc) +__ulonglong 0x4 / 0xffff == 0x0 (0x0) +float 0x4 / 0xffff == -0x4 (0xfffc) +int 0x4 % 0xffff == 0x0 (0x0) +__uint 0x4 % 0xffff == 0x4 (0x4) +char 0x4 % 0xffff == 0x0 (0x0) +__uchar 0x4 % 0xff == 0x4 (0x4) +__longlong 0x4 % 0xffff == 0x0 (0x0) +__ulonglong 0x4 % 0xffff == 0x4 (0x4) +0x4 * 0x1 == 0x4 +0x4 / 0x1 == 0x4 +0x4 % 0x1 == 0x0 +int 0x4 ^ 0x1 == 0x5 (0x5) +__uint 0x4 ^ 0x1 == 0x5 (0x5) +char 0x4 ^ 0x1 == 0x5 (0x5) +__uchar 0x4 ^ 0x1 == 0x5 (0x5) +__longlong 0x4 ^ 0x1 == 0x5 (0x5) +__ulonglong 0x4 ^ 0x1 == 0x5 (0x5) +int 0x4 && 0x1 == 0x1 (0x1) +__uint 0x4 && 0x1 == 0x1 (0x1) +char 0x4 && 0x1 == 0x1 (0x1) +__uchar 0x4 && 0x1 == 0x1 (0x1) +__longlong 0x4 && 0x1 == 0x1 (0x1) +__ulonglong 0x4 && 0x1 == 0x1 (0x1) +int 0x4 || 0x1 == 0x1 (0x1) +__uint 0x4 || 0x1 == 0x1 (0x1) +char 0x4 || 0x1 == 0x1 (0x1) +__uchar 0x4 || 0x1 == 0x1 (0x1) +__longlong 0x4 || 0x1 == 0x1 (0x1) +__ulonglong 0x4 || 0x1 == 0x1 (0x1) +int 0x4 & 0x1 == 0x0 (0x0) +__uint 0x4 & 0x1 == 0x0 (0x0) +char 0x4 & 0x1 == 0x0 (0x0) +__uchar 0x4 & 0x1 == 0x0 (0x0) +__longlong 0x4 & 0x1 == 0x0 (0x0) +__ulonglong 0x4 & 0x1 == 0x0 (0x0) +int 0x4 | 0x1 == 0x5 (0x5) +__uint 0x4 | 0x1 == 0x5 (0x5) +char 0x4 | 0x1 == 0x5 (0x5) +__uchar 0x4 | 0x1 == 0x5 (0x5) +__longlong 0x4 | 0x1 == 0x5 (0x5) +__ulonglong 0x4 | 0x1 == 0x5 (0x5) +int 0x4 << 0x2 == 0x10 (0x10) +__uint 0x4 << 0x2 == 0x10 (0x10) +char 0x4 << 0x2 == 0x10 (0x10) +__uchar 0x4 << 0x2 == 0x10 (0x10) +__longlong 0x4 << 0x2 == 0x10 (0x10) +__ulonglong 0x4 << 0x2 == 0x10 (0x10) +int 0x4 >> 0x2 == 0x1 (0x1) +__uint 0x4 >> 0x2 == 0x1 (0x1) +char 0x4 >> 0x2 == 0x1 (0x1) +__uchar 0x4 >> 0x2 == 0x1 (0x1) +__longlong 0x4 >> 0x2 == 0x1 (0x1) +__ulonglong 0x4 >> 0x2 == 0x1 (0x1) +int 0x4 + 0x1 == 0x5 (0x5) +__uint 0x4 + 0x1 == 0x5 (0x5) +char 0x4 + 0x1 == 0x5 (0x5) +__uchar 0x4 + 0x1 == 0x5 (0x5) +__longlong 0x4 + 0x1 == 0x5 (0x5) +__ulonglong 0x4 + 0x1 == 0x5 (0x5) +float 0x4 + 0x1 == 0x5 (0x5) +int 0x4 - 0x1 == 0x3 (0x3) +__uint 0x4 - 0x1 == 0x3 (0x3) +char 0x4 - 0x1 == 0x3 (0x3) +__uchar 0x4 - 0x1 == 0x3 (0x3) +__longlong 0x4 - 0x1 == 0x3 (0x3) +__ulonglong 0x4 - 0x1 == 0x3 (0x3) +float 0x4 - 0x1 == 0x3 (0x3) +int 0x4 * 0x1 == 0x4 (0x4) +__uint 0x4 * 0x1 == 0x4 (0x4) +char 0x4 * 0x1 == 0x4 (0x4) +__uchar 0x4 * 0x1 == 0x4 (0x4) +__longlong 0x4 * 0x1 == 0x4 (0x4) +__ulonglong 0x4 * 0x1 == 0x4 (0x4) +float 0x4 * 0x1 == 0x4 (0x4) +int 0x4 < 0x1 == 0x0 (0x0) +__uint 0x4 < 0x1 == 0x0 (0x0) +char 0x4 < 0x1 == 0x0 (0x0) +__uchar 0x4 < 0x1 == 0x0 (0x0) +__longlong 0x4 < 0x1 == 0x0 (0x0) +__ulonglong 0x4 < 0x1 == 0x0 (0x0) +float 0x4 < 0x1 == 0x0 (0x0) +int 0x4 > 0x1 == 0x1 (0x1) +__uint 0x4 > 0x1 == 0x1 (0x1) +char 0x4 > 0x1 == 0x1 (0x1) +__uchar 0x4 > 0x1 == 0x1 (0x1) +__longlong 0x4 > 0x1 == 0x1 (0x1) +__ulonglong 0x4 > 0x1 == 0x1 (0x1) +float 0x4 > 0x1 == 0x1 (0x1) +int 0x4 <= 0x1 == 0x0 (0x0) +__uint 0x4 <= 0x1 == 0x0 (0x0) +char 0x4 <= 0x1 == 0x0 (0x0) +__uchar 0x4 <= 0x1 == 0x0 (0x0) +__longlong 0x4 <= 0x1 == 0x0 (0x0) +__ulonglong 0x4 <= 0x1 == 0x0 (0x0) +float 0x4 <= 0x1 == 0x0 (0x0) +int 0x4 == 0x1 == 0x0 (0x0) +__uint 0x4 == 0x1 == 0x0 (0x0) +char 0x4 == 0x1 == 0x0 (0x0) +__uchar 0x4 == 0x1 == 0x0 (0x0) +__longlong 0x4 == 0x1 == 0x0 (0x0) +__ulonglong 0x4 == 0x1 == 0x0 (0x0) +float 0x4 == 0x1 == 0x0 (0x0) +int 0x4 != 0x1 == 0x1 (0x1) +__uint 0x4 != 0x1 == 0x1 (0x1) +char 0x4 != 0x1 == 0x1 (0x1) +__uchar 0x4 != 0x1 == 0x1 (0x1) +__longlong 0x4 != 0x1 == 0x1 (0x1) +__ulonglong 0x4 != 0x1 == 0x1 (0x1) +float 0x4 != 0x1 == 0x1 (0x1) +int 0x4 >= 0x1 == 0x1 (0x1) +__uint 0x4 >= 0x1 == 0x1 (0x1) +char 0x4 >= 0x1 == 0x1 (0x1) +__uchar 0x4 >= 0x1 == 0x1 (0x1) +__longlong 0x4 >= 0x1 == 0x1 (0x1) +__ulonglong 0x4 >= 0x1 == 0x1 (0x1) +float 0x4 >= 0x1 == 0x1 (0x1) +int 0x4 / 0x1 == 0x4 (0x4) +__uint 0x4 / 0x1 == 0x4 (0x4) +char 0x4 / 0x1 == 0x4 (0x4) +__uchar 0x4 / 0x1 == 0x4 (0x4) +__longlong 0x4 / 0x1 == 0x4 (0x4) +__ulonglong 0x4 / 0x1 == 0x4 (0x4) +float 0x4 / 0x1 == 0x4 (0x4) +int 0x4 % 0x1 == 0x0 (0x0) +__uint 0x4 % 0x1 == 0x0 (0x0) +char 0x4 % 0x1 == 0x0 (0x0) +__uchar 0x4 % 0x1 == 0x0 (0x0) +__longlong 0x4 % 0x1 == 0x0 (0x0) +__ulonglong 0x4 % 0x1 == 0x0 (0x0) +0x4 * 0x2 == 0x8 +0x4 / 0x2 == 0x2 +0x4 % 0x2 == 0x0 +int 0x4 ^ 0x2 == 0x6 (0x6) +__uint 0x4 ^ 0x2 == 0x6 (0x6) +char 0x4 ^ 0x2 == 0x6 (0x6) +__uchar 0x4 ^ 0x2 == 0x6 (0x6) +__longlong 0x4 ^ 0x2 == 0x6 (0x6) +__ulonglong 0x4 ^ 0x2 == 0x6 (0x6) +int 0x4 && 0x2 == 0x1 (0x1) +__uint 0x4 && 0x2 == 0x1 (0x1) +char 0x4 && 0x2 == 0x1 (0x1) +__uchar 0x4 && 0x2 == 0x1 (0x1) +__longlong 0x4 && 0x2 == 0x1 (0x1) +__ulonglong 0x4 && 0x2 == 0x1 (0x1) +int 0x4 || 0x2 == 0x1 (0x1) +__uint 0x4 || 0x2 == 0x1 (0x1) +char 0x4 || 0x2 == 0x1 (0x1) +__uchar 0x4 || 0x2 == 0x1 (0x1) +__longlong 0x4 || 0x2 == 0x1 (0x1) +__ulonglong 0x4 || 0x2 == 0x1 (0x1) +int 0x4 & 0x2 == 0x0 (0x0) +__uint 0x4 & 0x2 == 0x0 (0x0) +char 0x4 & 0x2 == 0x0 (0x0) +__uchar 0x4 & 0x2 == 0x0 (0x0) +__longlong 0x4 & 0x2 == 0x0 (0x0) +__ulonglong 0x4 & 0x2 == 0x0 (0x0) +int 0x4 | 0x2 == 0x6 (0x6) +__uint 0x4 | 0x2 == 0x6 (0x6) +char 0x4 | 0x2 == 0x6 (0x6) +__uchar 0x4 | 0x2 == 0x6 (0x6) +__longlong 0x4 | 0x2 == 0x6 (0x6) +__ulonglong 0x4 | 0x2 == 0x6 (0x6) +int 0x4 << 0x3 == 0x20 (0x20) +__uint 0x4 << 0x3 == 0x20 (0x20) +char 0x4 << 0x3 == 0x20 (0x20) +__uchar 0x4 << 0x3 == 0x20 (0x20) +__longlong 0x4 << 0x3 == 0x20 (0x20) +__ulonglong 0x4 << 0x3 == 0x20 (0x20) +int 0x4 >> 0x3 == 0x0 (0x0) +__uint 0x4 >> 0x3 == 0x0 (0x0) +char 0x4 >> 0x3 == 0x0 (0x0) +__uchar 0x4 >> 0x3 == 0x0 (0x0) +__longlong 0x4 >> 0x3 == 0x0 (0x0) +__ulonglong 0x4 >> 0x3 == 0x0 (0x0) +int 0x4 + 0x2 == 0x6 (0x6) +__uint 0x4 + 0x2 == 0x6 (0x6) +char 0x4 + 0x2 == 0x6 (0x6) +__uchar 0x4 + 0x2 == 0x6 (0x6) +__longlong 0x4 + 0x2 == 0x6 (0x6) +__ulonglong 0x4 + 0x2 == 0x6 (0x6) +float 0x4 + 0x2 == 0x6 (0x6) +int 0x4 - 0x2 == 0x2 (0x2) +__uint 0x4 - 0x2 == 0x2 (0x2) +char 0x4 - 0x2 == 0x2 (0x2) +__uchar 0x4 - 0x2 == 0x2 (0x2) +__longlong 0x4 - 0x2 == 0x2 (0x2) +__ulonglong 0x4 - 0x2 == 0x2 (0x2) +float 0x4 - 0x2 == 0x2 (0x2) +int 0x4 * 0x2 == 0x8 (0x8) +__uint 0x4 * 0x2 == 0x8 (0x8) +char 0x4 * 0x2 == 0x8 (0x8) +__uchar 0x4 * 0x2 == 0x8 (0x8) +__longlong 0x4 * 0x2 == 0x8 (0x8) +__ulonglong 0x4 * 0x2 == 0x8 (0x8) +float 0x4 * 0x2 == 0x8 (0x8) +int 0x4 < 0x2 == 0x0 (0x0) +__uint 0x4 < 0x2 == 0x0 (0x0) +char 0x4 < 0x2 == 0x0 (0x0) +__uchar 0x4 < 0x2 == 0x0 (0x0) +__longlong 0x4 < 0x2 == 0x0 (0x0) +__ulonglong 0x4 < 0x2 == 0x0 (0x0) +float 0x4 < 0x2 == 0x0 (0x0) +int 0x4 > 0x2 == 0x1 (0x1) +__uint 0x4 > 0x2 == 0x1 (0x1) +char 0x4 > 0x2 == 0x1 (0x1) +__uchar 0x4 > 0x2 == 0x1 (0x1) +__longlong 0x4 > 0x2 == 0x1 (0x1) +__ulonglong 0x4 > 0x2 == 0x1 (0x1) +float 0x4 > 0x2 == 0x1 (0x1) +int 0x4 <= 0x2 == 0x0 (0x0) +__uint 0x4 <= 0x2 == 0x0 (0x0) +char 0x4 <= 0x2 == 0x0 (0x0) +__uchar 0x4 <= 0x2 == 0x0 (0x0) +__longlong 0x4 <= 0x2 == 0x0 (0x0) +__ulonglong 0x4 <= 0x2 == 0x0 (0x0) +float 0x4 <= 0x2 == 0x0 (0x0) +int 0x4 == 0x2 == 0x0 (0x0) +__uint 0x4 == 0x2 == 0x0 (0x0) +char 0x4 == 0x2 == 0x0 (0x0) +__uchar 0x4 == 0x2 == 0x0 (0x0) +__longlong 0x4 == 0x2 == 0x0 (0x0) +__ulonglong 0x4 == 0x2 == 0x0 (0x0) +float 0x4 == 0x2 == 0x0 (0x0) +int 0x4 != 0x2 == 0x1 (0x1) +__uint 0x4 != 0x2 == 0x1 (0x1) +char 0x4 != 0x2 == 0x1 (0x1) +__uchar 0x4 != 0x2 == 0x1 (0x1) +__longlong 0x4 != 0x2 == 0x1 (0x1) +__ulonglong 0x4 != 0x2 == 0x1 (0x1) +float 0x4 != 0x2 == 0x1 (0x1) +int 0x4 >= 0x2 == 0x1 (0x1) +__uint 0x4 >= 0x2 == 0x1 (0x1) +char 0x4 >= 0x2 == 0x1 (0x1) +__uchar 0x4 >= 0x2 == 0x1 (0x1) +__longlong 0x4 >= 0x2 == 0x1 (0x1) +__ulonglong 0x4 >= 0x2 == 0x1 (0x1) +float 0x4 >= 0x2 == 0x1 (0x1) +int 0x4 / 0x2 == 0x2 (0x2) +__uint 0x4 / 0x2 == 0x2 (0x2) +char 0x4 / 0x2 == 0x2 (0x2) +__uchar 0x4 / 0x2 == 0x2 (0x2) +__longlong 0x4 / 0x2 == 0x2 (0x2) +__ulonglong 0x4 / 0x2 == 0x2 (0x2) +float 0x4 / 0x2 == 0x2 (0x2) +int 0x4 % 0x2 == 0x0 (0x0) +__uint 0x4 % 0x2 == 0x0 (0x0) +char 0x4 % 0x2 == 0x0 (0x0) +__uchar 0x4 % 0x2 == 0x0 (0x0) +__longlong 0x4 % 0x2 == 0x0 (0x0) +__ulonglong 0x4 % 0x2 == 0x0 (0x0) +0x4 * 0xfffe == -0x8 +0x4 / 0xfffe == -0x2 +0x4 % 0xfffe == 0x0 +int 0x4 ^ 0xfffe == -0x6 (0xfffa) +__uint 0x4 ^ 0xfffe == -0x6 (0xfffa) +char 0x4 ^ 0xfffe == -0x6 (0xfffa) +__uchar 0x4 ^ 0xfe == 0xfa (0xfa) +__longlong 0x4 ^ 0xfffe == -0x6 (0xfffa) +__ulonglong 0x4 ^ 0xfffe == -0x6 (0xfffa) +int 0x4 && 0xfffe == 0x1 (0x1) +__uint 0x4 && 0xfffe == 0x1 (0x1) +char 0x4 && 0xfffe == 0x1 (0x1) +__uchar 0x4 && 0xfe == 0x1 (0x1) +__longlong 0x4 && 0xfffe == 0x1 (0x1) +__ulonglong 0x4 && 0xfffe == 0x1 (0x1) +int 0x4 || 0xfffe == 0x1 (0x1) +__uint 0x4 || 0xfffe == 0x1 (0x1) +char 0x4 || 0xfffe == 0x1 (0x1) +__uchar 0x4 || 0xfe == 0x1 (0x1) +__longlong 0x4 || 0xfffe == 0x1 (0x1) +__ulonglong 0x4 || 0xfffe == 0x1 (0x1) +int 0x4 & 0xfffe == 0x4 (0x4) +__uint 0x4 & 0xfffe == 0x4 (0x4) +char 0x4 & 0xfffe == 0x4 (0x4) +__uchar 0x4 & 0xfe == 0x4 (0x4) +__longlong 0x4 & 0xfffe == 0x4 (0x4) +__ulonglong 0x4 & 0xfffe == 0x4 (0x4) +int 0x4 | 0xfffe == -0x2 (0xfffe) +__uint 0x4 | 0xfffe == -0x2 (0xfffe) +char 0x4 | 0xfffe == -0x2 (0xfffe) +__uchar 0x4 | 0xfe == 0xfe (0xfe) +__longlong 0x4 | 0xfffe == -0x2 (0xfffe) +__ulonglong 0x4 | 0xfffe == -0x2 (0xfffe) +int 0x4 << 0x4 == 0x40 (0x40) +__uint 0x4 << 0x4 == 0x40 (0x40) +char 0x4 << 0x4 == 0x40 (0x40) +__uchar 0x4 << 0x4 == 0x40 (0x40) +__longlong 0x4 << 0x4 == 0x40 (0x40) +__ulonglong 0x4 << 0x4 == 0x40 (0x40) +int 0x4 >> 0x4 == 0x0 (0x0) +__uint 0x4 >> 0x4 == 0x0 (0x0) +char 0x4 >> 0x4 == 0x0 (0x0) +__uchar 0x4 >> 0x4 == 0x0 (0x0) +__longlong 0x4 >> 0x4 == 0x0 (0x0) +__ulonglong 0x4 >> 0x4 == 0x0 (0x0) +int 0x4 + 0xfffe == 0x2 (0x2) +__uint 0x4 + 0xfffe == 0x2 (0x2) +char 0x4 + 0xfffe == 0x2 (0x2) +__uchar 0x4 + 0xfe == 0x2 (0x2) +__longlong 0x4 + 0xfffe == 0x2 (0x2) +__ulonglong 0x4 + 0xfffe == 0x2 (0x2) +float 0x4 + 0xfffe == 0x2 (0x2) +int 0x4 - 0xfffe == 0x6 (0x6) +__uint 0x4 - 0xfffe == 0x6 (0x6) +char 0x4 - 0xfffe == 0x6 (0x6) +__uchar 0x4 - 0xfe == 0x6 (0x6) +__longlong 0x4 - 0xfffe == 0x6 (0x6) +__ulonglong 0x4 - 0xfffe == 0x6 (0x6) +float 0x4 - 0xfffe == 0x6 (0x6) +int 0x4 * 0xfffe == -0x8 (0xfff8) +__uint 0x4 * 0xfffe == -0x8 (0xfff8) +char 0x4 * 0xfffe == -0x8 (0xfff8) +__uchar 0x4 * 0xfe == 0xf8 (0xf8) +__longlong 0x4 * 0xfffe == -0x8 (0xfff8) +__ulonglong 0x4 * 0xfffe == -0x8 (0xfff8) +float 0x4 * 0xfffe == -0x8 (0xfff8) +int 0x4 < 0xfffe == 0x0 (0x0) +__uint 0x4 < 0xfffe == 0x1 (0x1) +char 0x4 < 0xfffe == 0x0 (0x0) +__uchar 0x4 < 0xfe == 0x1 (0x1) +__longlong 0x4 < 0xfffe == 0x0 (0x0) +__ulonglong 0x4 < 0xfffe == 0x1 (0x1) +float 0x4 < 0xfffe == 0x0 (0x0) +int 0x4 > 0xfffe == 0x1 (0x1) +__uint 0x4 > 0xfffe == 0x0 (0x0) +char 0x4 > 0xfffe == 0x1 (0x1) +__uchar 0x4 > 0xfe == 0x0 (0x0) +__longlong 0x4 > 0xfffe == 0x1 (0x1) +__ulonglong 0x4 > 0xfffe == 0x0 (0x0) +float 0x4 > 0xfffe == 0x1 (0x1) +int 0x4 <= 0xfffe == 0x0 (0x0) +__uint 0x4 <= 0xfffe == 0x1 (0x1) +char 0x4 <= 0xfffe == 0x0 (0x0) +__uchar 0x4 <= 0xfe == 0x1 (0x1) +__longlong 0x4 <= 0xfffe == 0x0 (0x0) +__ulonglong 0x4 <= 0xfffe == 0x1 (0x1) +float 0x4 <= 0xfffe == 0x0 (0x0) +int 0x4 == 0xfffe == 0x0 (0x0) +__uint 0x4 == 0xfffe == 0x0 (0x0) +char 0x4 == 0xfffe == 0x0 (0x0) +__uchar 0x4 == 0xfe == 0x0 (0x0) +__longlong 0x4 == 0xfffe == 0x0 (0x0) +__ulonglong 0x4 == 0xfffe == 0x0 (0x0) +float 0x4 == 0xfffe == 0x0 (0x0) +int 0x4 != 0xfffe == 0x1 (0x1) +__uint 0x4 != 0xfffe == 0x1 (0x1) +char 0x4 != 0xfffe == 0x1 (0x1) +__uchar 0x4 != 0xfe == 0x1 (0x1) +__longlong 0x4 != 0xfffe == 0x1 (0x1) +__ulonglong 0x4 != 0xfffe == 0x1 (0x1) +float 0x4 != 0xfffe == 0x1 (0x1) +int 0x4 >= 0xfffe == 0x1 (0x1) +__uint 0x4 >= 0xfffe == 0x0 (0x0) +char 0x4 >= 0xfffe == 0x1 (0x1) +__uchar 0x4 >= 0xfe == 0x0 (0x0) +__longlong 0x4 >= 0xfffe == 0x1 (0x1) +__ulonglong 0x4 >= 0xfffe == 0x0 (0x0) +float 0x4 >= 0xfffe == 0x1 (0x1) +int 0x4 / 0xfffe == -0x2 (0xfffe) +__uint 0x4 / 0xfffe == 0x0 (0x0) +char 0x4 / 0xfffe == -0x2 (0xfffe) +__uchar 0x4 / 0xfe == 0x0 (0x0) +__longlong 0x4 / 0xfffe == -0x2 (0xfffe) +__ulonglong 0x4 / 0xfffe == 0x0 (0x0) +float 0x4 / 0xfffe == -0x2 (0xfffe) +int 0x4 % 0xfffe == 0x0 (0x0) +__uint 0x4 % 0xfffe == 0x4 (0x4) +char 0x4 % 0xfffe == 0x0 (0x0) +__uchar 0x4 % 0xfe == 0x4 (0x4) +__longlong 0x4 % 0xfffe == 0x0 (0x0) +__ulonglong 0x4 % 0xfffe == 0x4 (0x4) +0x4 * 0x4 == 0x10 +0x4 / 0x4 == 0x1 +0x4 % 0x4 == 0x0 +int 0x4 ^ 0x4 == 0x0 (0x0) +__uint 0x4 ^ 0x4 == 0x0 (0x0) +char 0x4 ^ 0x4 == 0x0 (0x0) +__uchar 0x4 ^ 0x4 == 0x0 (0x0) +__longlong 0x4 ^ 0x4 == 0x0 (0x0) +__ulonglong 0x4 ^ 0x4 == 0x0 (0x0) +int 0x4 && 0x4 == 0x1 (0x1) +__uint 0x4 && 0x4 == 0x1 (0x1) +char 0x4 && 0x4 == 0x1 (0x1) +__uchar 0x4 && 0x4 == 0x1 (0x1) +__longlong 0x4 && 0x4 == 0x1 (0x1) +__ulonglong 0x4 && 0x4 == 0x1 (0x1) +int 0x4 || 0x4 == 0x1 (0x1) +__uint 0x4 || 0x4 == 0x1 (0x1) +char 0x4 || 0x4 == 0x1 (0x1) +__uchar 0x4 || 0x4 == 0x1 (0x1) +__longlong 0x4 || 0x4 == 0x1 (0x1) +__ulonglong 0x4 || 0x4 == 0x1 (0x1) +int 0x4 & 0x4 == 0x4 (0x4) +__uint 0x4 & 0x4 == 0x4 (0x4) +char 0x4 & 0x4 == 0x4 (0x4) +__uchar 0x4 & 0x4 == 0x4 (0x4) +__longlong 0x4 & 0x4 == 0x4 (0x4) +__ulonglong 0x4 & 0x4 == 0x4 (0x4) +int 0x4 | 0x4 == 0x4 (0x4) +__uint 0x4 | 0x4 == 0x4 (0x4) +char 0x4 | 0x4 == 0x4 (0x4) +__uchar 0x4 | 0x4 == 0x4 (0x4) +__longlong 0x4 | 0x4 == 0x4 (0x4) +__ulonglong 0x4 | 0x4 == 0x4 (0x4) +int 0x4 << 0x5 == 0x80 (0x80) +__uint 0x4 << 0x5 == 0x80 (0x80) +char 0x4 << 0x5 == -0x80 (0xff80) +__uchar 0x4 << 0x5 == 0x80 (0x80) +__longlong 0x4 << 0x5 == 0x80 (0x80) +__ulonglong 0x4 << 0x5 == 0x80 (0x80) +int 0x4 >> 0x5 == 0x0 (0x0) +__uint 0x4 >> 0x5 == 0x0 (0x0) +char 0x4 >> 0x5 == 0x0 (0x0) +__uchar 0x4 >> 0x5 == 0x0 (0x0) +__longlong 0x4 >> 0x5 == 0x0 (0x0) +__ulonglong 0x4 >> 0x5 == 0x0 (0x0) +int 0x4 + 0x4 == 0x8 (0x8) +__uint 0x4 + 0x4 == 0x8 (0x8) +char 0x4 + 0x4 == 0x8 (0x8) +__uchar 0x4 + 0x4 == 0x8 (0x8) +__longlong 0x4 + 0x4 == 0x8 (0x8) +__ulonglong 0x4 + 0x4 == 0x8 (0x8) +float 0x4 + 0x4 == 0x8 (0x8) +int 0x4 - 0x4 == 0x0 (0x0) +__uint 0x4 - 0x4 == 0x0 (0x0) +char 0x4 - 0x4 == 0x0 (0x0) +__uchar 0x4 - 0x4 == 0x0 (0x0) +__longlong 0x4 - 0x4 == 0x0 (0x0) +__ulonglong 0x4 - 0x4 == 0x0 (0x0) +float 0x4 - 0x4 == 0x0 (0x0) +int 0x4 * 0x4 == 0x10 (0x10) +__uint 0x4 * 0x4 == 0x10 (0x10) +char 0x4 * 0x4 == 0x10 (0x10) +__uchar 0x4 * 0x4 == 0x10 (0x10) +__longlong 0x4 * 0x4 == 0x10 (0x10) +__ulonglong 0x4 * 0x4 == 0x10 (0x10) +float 0x4 * 0x4 == 0x10 (0x10) +int 0x4 < 0x4 == 0x0 (0x0) +__uint 0x4 < 0x4 == 0x0 (0x0) +char 0x4 < 0x4 == 0x0 (0x0) +__uchar 0x4 < 0x4 == 0x0 (0x0) +__longlong 0x4 < 0x4 == 0x0 (0x0) +__ulonglong 0x4 < 0x4 == 0x0 (0x0) +float 0x4 < 0x4 == 0x0 (0x0) +int 0x4 > 0x4 == 0x0 (0x0) +__uint 0x4 > 0x4 == 0x0 (0x0) +char 0x4 > 0x4 == 0x0 (0x0) +__uchar 0x4 > 0x4 == 0x0 (0x0) +__longlong 0x4 > 0x4 == 0x0 (0x0) +__ulonglong 0x4 > 0x4 == 0x0 (0x0) +float 0x4 > 0x4 == 0x0 (0x0) +int 0x4 <= 0x4 == 0x1 (0x1) +__uint 0x4 <= 0x4 == 0x1 (0x1) +char 0x4 <= 0x4 == 0x1 (0x1) +__uchar 0x4 <= 0x4 == 0x1 (0x1) +__longlong 0x4 <= 0x4 == 0x1 (0x1) +__ulonglong 0x4 <= 0x4 == 0x1 (0x1) +float 0x4 <= 0x4 == 0x1 (0x1) +int 0x4 == 0x4 == 0x1 (0x1) +__uint 0x4 == 0x4 == 0x1 (0x1) +char 0x4 == 0x4 == 0x1 (0x1) +__uchar 0x4 == 0x4 == 0x1 (0x1) +__longlong 0x4 == 0x4 == 0x1 (0x1) +__ulonglong 0x4 == 0x4 == 0x1 (0x1) +float 0x4 == 0x4 == 0x1 (0x1) +int 0x4 != 0x4 == 0x0 (0x0) +__uint 0x4 != 0x4 == 0x0 (0x0) +char 0x4 != 0x4 == 0x0 (0x0) +__uchar 0x4 != 0x4 == 0x0 (0x0) +__longlong 0x4 != 0x4 == 0x0 (0x0) +__ulonglong 0x4 != 0x4 == 0x0 (0x0) +float 0x4 != 0x4 == 0x0 (0x0) +int 0x4 >= 0x4 == 0x1 (0x1) +__uint 0x4 >= 0x4 == 0x1 (0x1) +char 0x4 >= 0x4 == 0x1 (0x1) +__uchar 0x4 >= 0x4 == 0x1 (0x1) +__longlong 0x4 >= 0x4 == 0x1 (0x1) +__ulonglong 0x4 >= 0x4 == 0x1 (0x1) +float 0x4 >= 0x4 == 0x1 (0x1) +int 0x4 / 0x4 == 0x1 (0x1) +__uint 0x4 / 0x4 == 0x1 (0x1) +char 0x4 / 0x4 == 0x1 (0x1) +__uchar 0x4 / 0x4 == 0x1 (0x1) +__longlong 0x4 / 0x4 == 0x1 (0x1) +__ulonglong 0x4 / 0x4 == 0x1 (0x1) +float 0x4 / 0x4 == 0x1 (0x1) +int 0x4 % 0x4 == 0x0 (0x0) +__uint 0x4 % 0x4 == 0x0 (0x0) +char 0x4 % 0x4 == 0x0 (0x0) +__uchar 0x4 % 0x4 == 0x0 (0x0) +__longlong 0x4 % 0x4 == 0x0 (0x0) +__ulonglong 0x4 % 0x4 == 0x0 (0x0) +0x4 * 0xfffc == -0x10 +0x4 / 0xfffc == -0x1 +0x4 % 0xfffc == 0x0 +int 0x4 ^ 0xfffc == -0x8 (0xfff8) +__uint 0x4 ^ 0xfffc == -0x8 (0xfff8) +char 0x4 ^ 0xfffc == -0x8 (0xfff8) +__uchar 0x4 ^ 0xfc == 0xf8 (0xf8) +__longlong 0x4 ^ 0xfffc == -0x8 (0xfff8) +__ulonglong 0x4 ^ 0xfffc == -0x8 (0xfff8) +int 0x4 && 0xfffc == 0x1 (0x1) +__uint 0x4 && 0xfffc == 0x1 (0x1) +char 0x4 && 0xfffc == 0x1 (0x1) +__uchar 0x4 && 0xfc == 0x1 (0x1) +__longlong 0x4 && 0xfffc == 0x1 (0x1) +__ulonglong 0x4 && 0xfffc == 0x1 (0x1) +int 0x4 || 0xfffc == 0x1 (0x1) +__uint 0x4 || 0xfffc == 0x1 (0x1) +char 0x4 || 0xfffc == 0x1 (0x1) +__uchar 0x4 || 0xfc == 0x1 (0x1) +__longlong 0x4 || 0xfffc == 0x1 (0x1) +__ulonglong 0x4 || 0xfffc == 0x1 (0x1) +int 0x4 & 0xfffc == 0x4 (0x4) +__uint 0x4 & 0xfffc == 0x4 (0x4) +char 0x4 & 0xfffc == 0x4 (0x4) +__uchar 0x4 & 0xfc == 0x4 (0x4) +__longlong 0x4 & 0xfffc == 0x4 (0x4) +__ulonglong 0x4 & 0xfffc == 0x4 (0x4) +int 0x4 | 0xfffc == -0x4 (0xfffc) +__uint 0x4 | 0xfffc == -0x4 (0xfffc) +char 0x4 | 0xfffc == -0x4 (0xfffc) +__uchar 0x4 | 0xfc == 0xfc (0xfc) +__longlong 0x4 | 0xfffc == -0x4 (0xfffc) +__ulonglong 0x4 | 0xfffc == -0x4 (0xfffc) +int 0x4 << 0x6 == 0x100 (0x100) +__uint 0x4 << 0x6 == 0x100 (0x100) +char 0x4 << 0x6 == 0x0 (0x0) +__uchar 0x4 << 0x6 == 0x0 (0x0) +__longlong 0x4 << 0x6 == 0x100 (0x100) +__ulonglong 0x4 << 0x6 == 0x100 (0x100) +int 0x4 >> 0x6 == 0x0 (0x0) +__uint 0x4 >> 0x6 == 0x0 (0x0) +char 0x4 >> 0x6 == 0x0 (0x0) +__uchar 0x4 >> 0x6 == 0x0 (0x0) +__longlong 0x4 >> 0x6 == 0x0 (0x0) +__ulonglong 0x4 >> 0x6 == 0x0 (0x0) +int 0x4 + 0xfffc == 0x0 (0x0) +__uint 0x4 + 0xfffc == 0x0 (0x0) +char 0x4 + 0xfffc == 0x0 (0x0) +__uchar 0x4 + 0xfc == 0x0 (0x0) +__longlong 0x4 + 0xfffc == 0x0 (0x0) +__ulonglong 0x4 + 0xfffc == 0x0 (0x0) +float 0x4 + 0xfffc == 0x0 (0x0) +int 0x4 - 0xfffc == 0x8 (0x8) +__uint 0x4 - 0xfffc == 0x8 (0x8) +char 0x4 - 0xfffc == 0x8 (0x8) +__uchar 0x4 - 0xfc == 0x8 (0x8) +__longlong 0x4 - 0xfffc == 0x8 (0x8) +__ulonglong 0x4 - 0xfffc == 0x8 (0x8) +float 0x4 - 0xfffc == 0x8 (0x8) +int 0x4 * 0xfffc == -0x10 (0xfff0) +__uint 0x4 * 0xfffc == -0x10 (0xfff0) +char 0x4 * 0xfffc == -0x10 (0xfff0) +__uchar 0x4 * 0xfc == 0xf0 (0xf0) +__longlong 0x4 * 0xfffc == -0x10 (0xfff0) +__ulonglong 0x4 * 0xfffc == -0x10 (0xfff0) +float 0x4 * 0xfffc == -0x10 (0xfff0) +int 0x4 < 0xfffc == 0x0 (0x0) +__uint 0x4 < 0xfffc == 0x1 (0x1) +char 0x4 < 0xfffc == 0x0 (0x0) +__uchar 0x4 < 0xfc == 0x1 (0x1) +__longlong 0x4 < 0xfffc == 0x0 (0x0) +__ulonglong 0x4 < 0xfffc == 0x1 (0x1) +float 0x4 < 0xfffc == 0x0 (0x0) +int 0x4 > 0xfffc == 0x1 (0x1) +__uint 0x4 > 0xfffc == 0x0 (0x0) +char 0x4 > 0xfffc == 0x1 (0x1) +__uchar 0x4 > 0xfc == 0x0 (0x0) +__longlong 0x4 > 0xfffc == 0x1 (0x1) +__ulonglong 0x4 > 0xfffc == 0x0 (0x0) +float 0x4 > 0xfffc == 0x1 (0x1) +int 0x4 <= 0xfffc == 0x0 (0x0) +__uint 0x4 <= 0xfffc == 0x1 (0x1) +char 0x4 <= 0xfffc == 0x0 (0x0) +__uchar 0x4 <= 0xfc == 0x1 (0x1) +__longlong 0x4 <= 0xfffc == 0x0 (0x0) +__ulonglong 0x4 <= 0xfffc == 0x1 (0x1) +float 0x4 <= 0xfffc == 0x0 (0x0) +int 0x4 == 0xfffc == 0x0 (0x0) +__uint 0x4 == 0xfffc == 0x0 (0x0) +char 0x4 == 0xfffc == 0x0 (0x0) +__uchar 0x4 == 0xfc == 0x0 (0x0) +__longlong 0x4 == 0xfffc == 0x0 (0x0) +__ulonglong 0x4 == 0xfffc == 0x0 (0x0) +float 0x4 == 0xfffc == 0x0 (0x0) +int 0x4 != 0xfffc == 0x1 (0x1) +__uint 0x4 != 0xfffc == 0x1 (0x1) +char 0x4 != 0xfffc == 0x1 (0x1) +__uchar 0x4 != 0xfc == 0x1 (0x1) +__longlong 0x4 != 0xfffc == 0x1 (0x1) +__ulonglong 0x4 != 0xfffc == 0x1 (0x1) +float 0x4 != 0xfffc == 0x1 (0x1) +int 0x4 >= 0xfffc == 0x1 (0x1) +__uint 0x4 >= 0xfffc == 0x0 (0x0) +char 0x4 >= 0xfffc == 0x1 (0x1) +__uchar 0x4 >= 0xfc == 0x0 (0x0) +__longlong 0x4 >= 0xfffc == 0x1 (0x1) +__ulonglong 0x4 >= 0xfffc == 0x0 (0x0) +float 0x4 >= 0xfffc == 0x1 (0x1) +int 0x4 / 0xfffc == -0x1 (0xffff) +__uint 0x4 / 0xfffc == 0x0 (0x0) +char 0x4 / 0xfffc == -0x1 (0xffff) +__uchar 0x4 / 0xfc == 0x0 (0x0) +__longlong 0x4 / 0xfffc == -0x1 (0xffff) +__ulonglong 0x4 / 0xfffc == 0x0 (0x0) +float 0x4 / 0xfffc == -0x1 (0xffff) +int 0x4 % 0xfffc == 0x0 (0x0) +__uint 0x4 % 0xfffc == 0x4 (0x4) +char 0x4 % 0xfffc == 0x0 (0x0) +__uchar 0x4 % 0xfc == 0x4 (0x4) +__longlong 0x4 % 0xfffc == 0x0 (0x0) +__ulonglong 0x4 % 0xfffc == 0x4 (0x4) +0x4 * 0xa == 0x28 +0x4 / 0xa == 0x0 +0x4 % 0xa == 0x4 +int 0x4 ^ 0xa == 0xe (0xe) +__uint 0x4 ^ 0xa == 0xe (0xe) +char 0x4 ^ 0xa == 0xe (0xe) +__uchar 0x4 ^ 0xa == 0xe (0xe) +__longlong 0x4 ^ 0xa == 0xe (0xe) +__ulonglong 0x4 ^ 0xa == 0xe (0xe) +int 0x4 && 0xa == 0x1 (0x1) +__uint 0x4 && 0xa == 0x1 (0x1) +char 0x4 && 0xa == 0x1 (0x1) +__uchar 0x4 && 0xa == 0x1 (0x1) +__longlong 0x4 && 0xa == 0x1 (0x1) +__ulonglong 0x4 && 0xa == 0x1 (0x1) +int 0x4 || 0xa == 0x1 (0x1) +__uint 0x4 || 0xa == 0x1 (0x1) +char 0x4 || 0xa == 0x1 (0x1) +__uchar 0x4 || 0xa == 0x1 (0x1) +__longlong 0x4 || 0xa == 0x1 (0x1) +__ulonglong 0x4 || 0xa == 0x1 (0x1) +int 0x4 & 0xa == 0x0 (0x0) +__uint 0x4 & 0xa == 0x0 (0x0) +char 0x4 & 0xa == 0x0 (0x0) +__uchar 0x4 & 0xa == 0x0 (0x0) +__longlong 0x4 & 0xa == 0x0 (0x0) +__ulonglong 0x4 & 0xa == 0x0 (0x0) +int 0x4 | 0xa == 0xe (0xe) +__uint 0x4 | 0xa == 0xe (0xe) +char 0x4 | 0xa == 0xe (0xe) +__uchar 0x4 | 0xa == 0xe (0xe) +__longlong 0x4 | 0xa == 0xe (0xe) +__ulonglong 0x4 | 0xa == 0xe (0xe) +int 0x4 << 0x7 == 0x200 (0x200) +__uint 0x4 << 0x7 == 0x200 (0x200) +char 0x4 << 0x7 == 0x0 (0x0) +__uchar 0x4 << 0x7 == 0x0 (0x0) +__longlong 0x4 << 0x7 == 0x200 (0x200) +__ulonglong 0x4 << 0x7 == 0x200 (0x200) +int 0x4 >> 0x7 == 0x0 (0x0) +__uint 0x4 >> 0x7 == 0x0 (0x0) +char 0x4 >> 0x7 == 0x0 (0x0) +__uchar 0x4 >> 0x7 == 0x0 (0x0) +__longlong 0x4 >> 0x7 == 0x0 (0x0) +__ulonglong 0x4 >> 0x7 == 0x0 (0x0) +int 0x4 + 0xa == 0xe (0xe) +__uint 0x4 + 0xa == 0xe (0xe) +char 0x4 + 0xa == 0xe (0xe) +__uchar 0x4 + 0xa == 0xe (0xe) +__longlong 0x4 + 0xa == 0xe (0xe) +__ulonglong 0x4 + 0xa == 0xe (0xe) +float 0x4 + 0xa == 0xe (0xe) +int 0x4 - 0xa == -0x6 (0xfffa) +__uint 0x4 - 0xa == -0x6 (0xfffa) +char 0x4 - 0xa == -0x6 (0xfffa) +__uchar 0x4 - 0xa == 0xfa (0xfa) +__longlong 0x4 - 0xa == -0x6 (0xfffa) +__ulonglong 0x4 - 0xa == -0x6 (0xfffa) +float 0x4 - 0xa == -0x6 (0xfffa) +int 0x4 * 0xa == 0x28 (0x28) +__uint 0x4 * 0xa == 0x28 (0x28) +char 0x4 * 0xa == 0x28 (0x28) +__uchar 0x4 * 0xa == 0x28 (0x28) +__longlong 0x4 * 0xa == 0x28 (0x28) +__ulonglong 0x4 * 0xa == 0x28 (0x28) +float 0x4 * 0xa == 0x28 (0x28) +int 0x4 < 0xa == 0x1 (0x1) +__uint 0x4 < 0xa == 0x1 (0x1) +char 0x4 < 0xa == 0x1 (0x1) +__uchar 0x4 < 0xa == 0x1 (0x1) +__longlong 0x4 < 0xa == 0x1 (0x1) +__ulonglong 0x4 < 0xa == 0x1 (0x1) +float 0x4 < 0xa == 0x1 (0x1) +int 0x4 > 0xa == 0x0 (0x0) +__uint 0x4 > 0xa == 0x0 (0x0) +char 0x4 > 0xa == 0x0 (0x0) +__uchar 0x4 > 0xa == 0x0 (0x0) +__longlong 0x4 > 0xa == 0x0 (0x0) +__ulonglong 0x4 > 0xa == 0x0 (0x0) +float 0x4 > 0xa == 0x0 (0x0) +int 0x4 <= 0xa == 0x1 (0x1) +__uint 0x4 <= 0xa == 0x1 (0x1) +char 0x4 <= 0xa == 0x1 (0x1) +__uchar 0x4 <= 0xa == 0x1 (0x1) +__longlong 0x4 <= 0xa == 0x1 (0x1) +__ulonglong 0x4 <= 0xa == 0x1 (0x1) +float 0x4 <= 0xa == 0x1 (0x1) +int 0x4 == 0xa == 0x0 (0x0) +__uint 0x4 == 0xa == 0x0 (0x0) +char 0x4 == 0xa == 0x0 (0x0) +__uchar 0x4 == 0xa == 0x0 (0x0) +__longlong 0x4 == 0xa == 0x0 (0x0) +__ulonglong 0x4 == 0xa == 0x0 (0x0) +float 0x4 == 0xa == 0x0 (0x0) +int 0x4 != 0xa == 0x1 (0x1) +__uint 0x4 != 0xa == 0x1 (0x1) +char 0x4 != 0xa == 0x1 (0x1) +__uchar 0x4 != 0xa == 0x1 (0x1) +__longlong 0x4 != 0xa == 0x1 (0x1) +__ulonglong 0x4 != 0xa == 0x1 (0x1) +float 0x4 != 0xa == 0x1 (0x1) +int 0x4 >= 0xa == 0x0 (0x0) +__uint 0x4 >= 0xa == 0x0 (0x0) +char 0x4 >= 0xa == 0x0 (0x0) +__uchar 0x4 >= 0xa == 0x0 (0x0) +__longlong 0x4 >= 0xa == 0x0 (0x0) +__ulonglong 0x4 >= 0xa == 0x0 (0x0) +float 0x4 >= 0xa == 0x0 (0x0) +int 0x4 / 0xa == 0x0 (0x0) +__uint 0x4 / 0xa == 0x0 (0x0) +char 0x4 / 0xa == 0x0 (0x0) +__uchar 0x4 / 0xa == 0x0 (0x0) +__longlong 0x4 / 0xa == 0x0 (0x0) +__ulonglong 0x4 / 0xa == 0x0 (0x0) +float 0x4 / 0xa == 0x0 (0x0) +int 0x4 % 0xa == 0x4 (0x4) +__uint 0x4 % 0xa == 0x4 (0x4) +char 0x4 % 0xa == 0x4 (0x4) +__uchar 0x4 % 0xa == 0x4 (0x4) +__longlong 0x4 % 0xa == 0x4 (0x4) +__ulonglong 0x4 % 0xa == 0x4 (0x4) +0x4 * 0xfff6 == -0x28 +0x4 / 0xfff6 == 0x0 +0x4 % 0xfff6 == 0x4 +int 0x4 ^ 0xfff6 == -0xe (0xfff2) +__uint 0x4 ^ 0xfff6 == -0xe (0xfff2) +char 0x4 ^ 0xfff6 == -0xe (0xfff2) +__uchar 0x4 ^ 0xf6 == 0xf2 (0xf2) +__longlong 0x4 ^ 0xfff6 == -0xe (0xfff2) +__ulonglong 0x4 ^ 0xfff6 == -0xe (0xfff2) +int 0x4 && 0xfff6 == 0x1 (0x1) +__uint 0x4 && 0xfff6 == 0x1 (0x1) +char 0x4 && 0xfff6 == 0x1 (0x1) +__uchar 0x4 && 0xf6 == 0x1 (0x1) +__longlong 0x4 && 0xfff6 == 0x1 (0x1) +__ulonglong 0x4 && 0xfff6 == 0x1 (0x1) +int 0x4 || 0xfff6 == 0x1 (0x1) +__uint 0x4 || 0xfff6 == 0x1 (0x1) +char 0x4 || 0xfff6 == 0x1 (0x1) +__uchar 0x4 || 0xf6 == 0x1 (0x1) +__longlong 0x4 || 0xfff6 == 0x1 (0x1) +__ulonglong 0x4 || 0xfff6 == 0x1 (0x1) +int 0x4 & 0xfff6 == 0x4 (0x4) +__uint 0x4 & 0xfff6 == 0x4 (0x4) +char 0x4 & 0xfff6 == 0x4 (0x4) +__uchar 0x4 & 0xf6 == 0x4 (0x4) +__longlong 0x4 & 0xfff6 == 0x4 (0x4) +__ulonglong 0x4 & 0xfff6 == 0x4 (0x4) +int 0x4 | 0xfff6 == -0xa (0xfff6) +__uint 0x4 | 0xfff6 == -0xa (0xfff6) +char 0x4 | 0xfff6 == -0xa (0xfff6) +__uchar 0x4 | 0xf6 == 0xf6 (0xf6) +__longlong 0x4 | 0xfff6 == -0xa (0xfff6) +__ulonglong 0x4 | 0xfff6 == -0xa (0xfff6) +int 0x4 << 0x8 == 0x400 (0x400) +__uint 0x4 << 0x8 == 0x400 (0x400) +char 0x4 << 0x8 == 0x0 (0x0) +__uchar 0x4 << 0x8 == 0x0 (0x0) +__longlong 0x4 << 0x8 == 0x400 (0x400) +__ulonglong 0x4 << 0x8 == 0x400 (0x400) +int 0x4 >> 0x8 == 0x0 (0x0) +__uint 0x4 >> 0x8 == 0x0 (0x0) +char 0x4 >> 0x8 == 0x0 (0x0) +__uchar 0x4 >> 0x8 == 0x0 (0x0) +__longlong 0x4 >> 0x8 == 0x0 (0x0) +__ulonglong 0x4 >> 0x8 == 0x0 (0x0) +int 0x4 + 0xfff6 == -0x6 (0xfffa) +__uint 0x4 + 0xfff6 == -0x6 (0xfffa) +char 0x4 + 0xfff6 == -0x6 (0xfffa) +__uchar 0x4 + 0xf6 == 0xfa (0xfa) +__longlong 0x4 + 0xfff6 == -0x6 (0xfffa) +__ulonglong 0x4 + 0xfff6 == -0x6 (0xfffa) +float 0x4 + 0xfff6 == -0x6 (0xfffa) +int 0x4 - 0xfff6 == 0xe (0xe) +__uint 0x4 - 0xfff6 == 0xe (0xe) +char 0x4 - 0xfff6 == 0xe (0xe) +__uchar 0x4 - 0xf6 == 0xe (0xe) +__longlong 0x4 - 0xfff6 == 0xe (0xe) +__ulonglong 0x4 - 0xfff6 == 0xe (0xe) +float 0x4 - 0xfff6 == 0xe (0xe) +int 0x4 * 0xfff6 == -0x28 (0xffd8) +__uint 0x4 * 0xfff6 == -0x28 (0xffd8) +char 0x4 * 0xfff6 == -0x28 (0xffd8) +__uchar 0x4 * 0xf6 == 0xd8 (0xd8) +__longlong 0x4 * 0xfff6 == -0x28 (0xffd8) +__ulonglong 0x4 * 0xfff6 == -0x28 (0xffd8) +float 0x4 * 0xfff6 == -0x28 (0xffd8) +int 0x4 < 0xfff6 == 0x0 (0x0) +__uint 0x4 < 0xfff6 == 0x1 (0x1) +char 0x4 < 0xfff6 == 0x0 (0x0) +__uchar 0x4 < 0xf6 == 0x1 (0x1) +__longlong 0x4 < 0xfff6 == 0x0 (0x0) +__ulonglong 0x4 < 0xfff6 == 0x1 (0x1) +float 0x4 < 0xfff6 == 0x0 (0x0) +int 0x4 > 0xfff6 == 0x1 (0x1) +__uint 0x4 > 0xfff6 == 0x0 (0x0) +char 0x4 > 0xfff6 == 0x1 (0x1) +__uchar 0x4 > 0xf6 == 0x0 (0x0) +__longlong 0x4 > 0xfff6 == 0x1 (0x1) +__ulonglong 0x4 > 0xfff6 == 0x0 (0x0) +float 0x4 > 0xfff6 == 0x1 (0x1) +int 0x4 <= 0xfff6 == 0x0 (0x0) +__uint 0x4 <= 0xfff6 == 0x1 (0x1) +char 0x4 <= 0xfff6 == 0x0 (0x0) +__uchar 0x4 <= 0xf6 == 0x1 (0x1) +__longlong 0x4 <= 0xfff6 == 0x0 (0x0) +__ulonglong 0x4 <= 0xfff6 == 0x1 (0x1) +float 0x4 <= 0xfff6 == 0x0 (0x0) +int 0x4 == 0xfff6 == 0x0 (0x0) +__uint 0x4 == 0xfff6 == 0x0 (0x0) +char 0x4 == 0xfff6 == 0x0 (0x0) +__uchar 0x4 == 0xf6 == 0x0 (0x0) +__longlong 0x4 == 0xfff6 == 0x0 (0x0) +__ulonglong 0x4 == 0xfff6 == 0x0 (0x0) +float 0x4 == 0xfff6 == 0x0 (0x0) +int 0x4 != 0xfff6 == 0x1 (0x1) +__uint 0x4 != 0xfff6 == 0x1 (0x1) +char 0x4 != 0xfff6 == 0x1 (0x1) +__uchar 0x4 != 0xf6 == 0x1 (0x1) +__longlong 0x4 != 0xfff6 == 0x1 (0x1) +__ulonglong 0x4 != 0xfff6 == 0x1 (0x1) +float 0x4 != 0xfff6 == 0x1 (0x1) +int 0x4 >= 0xfff6 == 0x1 (0x1) +__uint 0x4 >= 0xfff6 == 0x0 (0x0) +char 0x4 >= 0xfff6 == 0x1 (0x1) +__uchar 0x4 >= 0xf6 == 0x0 (0x0) +__longlong 0x4 >= 0xfff6 == 0x1 (0x1) +__ulonglong 0x4 >= 0xfff6 == 0x0 (0x0) +float 0x4 >= 0xfff6 == 0x1 (0x1) +int 0x4 / 0xfff6 == 0x0 (0x0) +__uint 0x4 / 0xfff6 == 0x0 (0x0) +char 0x4 / 0xfff6 == 0x0 (0x0) +__uchar 0x4 / 0xf6 == 0x0 (0x0) +__longlong 0x4 / 0xfff6 == 0x0 (0x0) +__ulonglong 0x4 / 0xfff6 == 0x0 (0x0) +float 0x4 / 0xfff6 == 0x0 (0x0) +int 0x4 % 0xfff6 == 0x4 (0x4) +__uint 0x4 % 0xfff6 == 0x4 (0x4) +char 0x4 % 0xfff6 == 0x4 (0x4) +__uchar 0x4 % 0xf6 == 0x4 (0x4) +__longlong 0x4 % 0xfff6 == 0x4 (0x4) +__ulonglong 0x4 % 0xfff6 == 0x4 (0x4) +0x4 * 0x5 == 0x14 +0x4 / 0x5 == 0x0 +0x4 % 0x5 == 0x4 +int 0x4 ^ 0x5 == 0x1 (0x1) +__uint 0x4 ^ 0x5 == 0x1 (0x1) +char 0x4 ^ 0x5 == 0x1 (0x1) +__uchar 0x4 ^ 0x5 == 0x1 (0x1) +__longlong 0x4 ^ 0x5 == 0x1 (0x1) +__ulonglong 0x4 ^ 0x5 == 0x1 (0x1) +int 0x4 && 0x5 == 0x1 (0x1) +__uint 0x4 && 0x5 == 0x1 (0x1) +char 0x4 && 0x5 == 0x1 (0x1) +__uchar 0x4 && 0x5 == 0x1 (0x1) +__longlong 0x4 && 0x5 == 0x1 (0x1) +__ulonglong 0x4 && 0x5 == 0x1 (0x1) +int 0x4 || 0x5 == 0x1 (0x1) +__uint 0x4 || 0x5 == 0x1 (0x1) +char 0x4 || 0x5 == 0x1 (0x1) +__uchar 0x4 || 0x5 == 0x1 (0x1) +__longlong 0x4 || 0x5 == 0x1 (0x1) +__ulonglong 0x4 || 0x5 == 0x1 (0x1) +int 0x4 & 0x5 == 0x4 (0x4) +__uint 0x4 & 0x5 == 0x4 (0x4) +char 0x4 & 0x5 == 0x4 (0x4) +__uchar 0x4 & 0x5 == 0x4 (0x4) +__longlong 0x4 & 0x5 == 0x4 (0x4) +__ulonglong 0x4 & 0x5 == 0x4 (0x4) +int 0x4 | 0x5 == 0x5 (0x5) +__uint 0x4 | 0x5 == 0x5 (0x5) +char 0x4 | 0x5 == 0x5 (0x5) +__uchar 0x4 | 0x5 == 0x5 (0x5) +__longlong 0x4 | 0x5 == 0x5 (0x5) +__ulonglong 0x4 | 0x5 == 0x5 (0x5) +int 0x4 << 0x9 == 0x800 (0x800) +__uint 0x4 << 0x9 == 0x800 (0x800) +char 0x4 << 0x9 == 0x0 (0x0) +__uchar 0x4 << 0x9 == 0x0 (0x0) +__longlong 0x4 << 0x9 == 0x800 (0x800) +__ulonglong 0x4 << 0x9 == 0x800 (0x800) +int 0x4 >> 0x9 == 0x0 (0x0) +__uint 0x4 >> 0x9 == 0x0 (0x0) +char 0x4 >> 0x9 == 0x0 (0x0) +__uchar 0x4 >> 0x9 == 0x0 (0x0) +__longlong 0x4 >> 0x9 == 0x0 (0x0) +__ulonglong 0x4 >> 0x9 == 0x0 (0x0) +int 0x4 + 0x5 == 0x9 (0x9) +__uint 0x4 + 0x5 == 0x9 (0x9) +char 0x4 + 0x5 == 0x9 (0x9) +__uchar 0x4 + 0x5 == 0x9 (0x9) +__longlong 0x4 + 0x5 == 0x9 (0x9) +__ulonglong 0x4 + 0x5 == 0x9 (0x9) +float 0x4 + 0x5 == 0x9 (0x9) +int 0x4 - 0x5 == -0x1 (0xffff) +__uint 0x4 - 0x5 == -0x1 (0xffff) +char 0x4 - 0x5 == -0x1 (0xffff) +__uchar 0x4 - 0x5 == 0xff (0xff) +__longlong 0x4 - 0x5 == -0x1 (0xffff) +__ulonglong 0x4 - 0x5 == -0x1 (0xffff) +float 0x4 - 0x5 == -0x1 (0xffff) +int 0x4 * 0x5 == 0x14 (0x14) +__uint 0x4 * 0x5 == 0x14 (0x14) +char 0x4 * 0x5 == 0x14 (0x14) +__uchar 0x4 * 0x5 == 0x14 (0x14) +__longlong 0x4 * 0x5 == 0x14 (0x14) +__ulonglong 0x4 * 0x5 == 0x14 (0x14) +float 0x4 * 0x5 == 0x14 (0x14) +int 0x4 < 0x5 == 0x1 (0x1) +__uint 0x4 < 0x5 == 0x1 (0x1) +char 0x4 < 0x5 == 0x1 (0x1) +__uchar 0x4 < 0x5 == 0x1 (0x1) +__longlong 0x4 < 0x5 == 0x1 (0x1) +__ulonglong 0x4 < 0x5 == 0x1 (0x1) +float 0x4 < 0x5 == 0x1 (0x1) +int 0x4 > 0x5 == 0x0 (0x0) +__uint 0x4 > 0x5 == 0x0 (0x0) +char 0x4 > 0x5 == 0x0 (0x0) +__uchar 0x4 > 0x5 == 0x0 (0x0) +__longlong 0x4 > 0x5 == 0x0 (0x0) +__ulonglong 0x4 > 0x5 == 0x0 (0x0) +float 0x4 > 0x5 == 0x0 (0x0) +int 0x4 <= 0x5 == 0x1 (0x1) +__uint 0x4 <= 0x5 == 0x1 (0x1) +char 0x4 <= 0x5 == 0x1 (0x1) +__uchar 0x4 <= 0x5 == 0x1 (0x1) +__longlong 0x4 <= 0x5 == 0x1 (0x1) +__ulonglong 0x4 <= 0x5 == 0x1 (0x1) +float 0x4 <= 0x5 == 0x1 (0x1) +int 0x4 == 0x5 == 0x0 (0x0) +__uint 0x4 == 0x5 == 0x0 (0x0) +char 0x4 == 0x5 == 0x0 (0x0) +__uchar 0x4 == 0x5 == 0x0 (0x0) +__longlong 0x4 == 0x5 == 0x0 (0x0) +__ulonglong 0x4 == 0x5 == 0x0 (0x0) +float 0x4 == 0x5 == 0x0 (0x0) +int 0x4 != 0x5 == 0x1 (0x1) +__uint 0x4 != 0x5 == 0x1 (0x1) +char 0x4 != 0x5 == 0x1 (0x1) +__uchar 0x4 != 0x5 == 0x1 (0x1) +__longlong 0x4 != 0x5 == 0x1 (0x1) +__ulonglong 0x4 != 0x5 == 0x1 (0x1) +float 0x4 != 0x5 == 0x1 (0x1) +int 0x4 >= 0x5 == 0x0 (0x0) +__uint 0x4 >= 0x5 == 0x0 (0x0) +char 0x4 >= 0x5 == 0x0 (0x0) +__uchar 0x4 >= 0x5 == 0x0 (0x0) +__longlong 0x4 >= 0x5 == 0x0 (0x0) +__ulonglong 0x4 >= 0x5 == 0x0 (0x0) +float 0x4 >= 0x5 == 0x0 (0x0) +int 0x4 / 0x5 == 0x0 (0x0) +__uint 0x4 / 0x5 == 0x0 (0x0) +char 0x4 / 0x5 == 0x0 (0x0) +__uchar 0x4 / 0x5 == 0x0 (0x0) +__longlong 0x4 / 0x5 == 0x0 (0x0) +__ulonglong 0x4 / 0x5 == 0x0 (0x0) +float 0x4 / 0x5 == 0x0 (0x0) +int 0x4 % 0x5 == 0x4 (0x4) +__uint 0x4 % 0x5 == 0x4 (0x4) +char 0x4 % 0x5 == 0x4 (0x4) +__uchar 0x4 % 0x5 == 0x4 (0x4) +__longlong 0x4 % 0x5 == 0x4 (0x4) +__ulonglong 0x4 % 0x5 == 0x4 (0x4) +0x4 * 0x7 == 0x1c +0x4 / 0x7 == 0x0 +0x4 % 0x7 == 0x4 +int 0x4 ^ 0x7 == 0x3 (0x3) +__uint 0x4 ^ 0x7 == 0x3 (0x3) +char 0x4 ^ 0x7 == 0x3 (0x3) +__uchar 0x4 ^ 0x7 == 0x3 (0x3) +__longlong 0x4 ^ 0x7 == 0x3 (0x3) +__ulonglong 0x4 ^ 0x7 == 0x3 (0x3) +int 0x4 && 0x7 == 0x1 (0x1) +__uint 0x4 && 0x7 == 0x1 (0x1) +char 0x4 && 0x7 == 0x1 (0x1) +__uchar 0x4 && 0x7 == 0x1 (0x1) +__longlong 0x4 && 0x7 == 0x1 (0x1) +__ulonglong 0x4 && 0x7 == 0x1 (0x1) +int 0x4 || 0x7 == 0x1 (0x1) +__uint 0x4 || 0x7 == 0x1 (0x1) +char 0x4 || 0x7 == 0x1 (0x1) +__uchar 0x4 || 0x7 == 0x1 (0x1) +__longlong 0x4 || 0x7 == 0x1 (0x1) +__ulonglong 0x4 || 0x7 == 0x1 (0x1) +int 0x4 & 0x7 == 0x4 (0x4) +__uint 0x4 & 0x7 == 0x4 (0x4) +char 0x4 & 0x7 == 0x4 (0x4) +__uchar 0x4 & 0x7 == 0x4 (0x4) +__longlong 0x4 & 0x7 == 0x4 (0x4) +__ulonglong 0x4 & 0x7 == 0x4 (0x4) +int 0x4 | 0x7 == 0x7 (0x7) +__uint 0x4 | 0x7 == 0x7 (0x7) +char 0x4 | 0x7 == 0x7 (0x7) +__uchar 0x4 | 0x7 == 0x7 (0x7) +__longlong 0x4 | 0x7 == 0x7 (0x7) +__ulonglong 0x4 | 0x7 == 0x7 (0x7) +int 0x4 << 0xa == 0x1000 (0x1000) +__uint 0x4 << 0xa == 0x1000 (0x1000) +char 0x4 << 0xa == 0x0 (0x0) +__uchar 0x4 << 0xa == 0x0 (0x0) +__longlong 0x4 << 0xa == 0x1000 (0x1000) +__ulonglong 0x4 << 0xa == 0x1000 (0x1000) +int 0x4 >> 0xa == 0x0 (0x0) +__uint 0x4 >> 0xa == 0x0 (0x0) +char 0x4 >> 0xa == 0x0 (0x0) +__uchar 0x4 >> 0xa == 0x0 (0x0) +__longlong 0x4 >> 0xa == 0x0 (0x0) +__ulonglong 0x4 >> 0xa == 0x0 (0x0) +int 0x4 + 0x7 == 0xb (0xb) +__uint 0x4 + 0x7 == 0xb (0xb) +char 0x4 + 0x7 == 0xb (0xb) +__uchar 0x4 + 0x7 == 0xb (0xb) +__longlong 0x4 + 0x7 == 0xb (0xb) +__ulonglong 0x4 + 0x7 == 0xb (0xb) +float 0x4 + 0x7 == 0xb (0xb) +int 0x4 - 0x7 == -0x3 (0xfffd) +__uint 0x4 - 0x7 == -0x3 (0xfffd) +char 0x4 - 0x7 == -0x3 (0xfffd) +__uchar 0x4 - 0x7 == 0xfd (0xfd) +__longlong 0x4 - 0x7 == -0x3 (0xfffd) +__ulonglong 0x4 - 0x7 == -0x3 (0xfffd) +float 0x4 - 0x7 == -0x3 (0xfffd) +int 0x4 * 0x7 == 0x1c (0x1c) +__uint 0x4 * 0x7 == 0x1c (0x1c) +char 0x4 * 0x7 == 0x1c (0x1c) +__uchar 0x4 * 0x7 == 0x1c (0x1c) +__longlong 0x4 * 0x7 == 0x1c (0x1c) +__ulonglong 0x4 * 0x7 == 0x1c (0x1c) +float 0x4 * 0x7 == 0x1c (0x1c) +int 0x4 < 0x7 == 0x1 (0x1) +__uint 0x4 < 0x7 == 0x1 (0x1) +char 0x4 < 0x7 == 0x1 (0x1) +__uchar 0x4 < 0x7 == 0x1 (0x1) +__longlong 0x4 < 0x7 == 0x1 (0x1) +__ulonglong 0x4 < 0x7 == 0x1 (0x1) +float 0x4 < 0x7 == 0x1 (0x1) +int 0x4 > 0x7 == 0x0 (0x0) +__uint 0x4 > 0x7 == 0x0 (0x0) +char 0x4 > 0x7 == 0x0 (0x0) +__uchar 0x4 > 0x7 == 0x0 (0x0) +__longlong 0x4 > 0x7 == 0x0 (0x0) +__ulonglong 0x4 > 0x7 == 0x0 (0x0) +float 0x4 > 0x7 == 0x0 (0x0) +int 0x4 <= 0x7 == 0x1 (0x1) +__uint 0x4 <= 0x7 == 0x1 (0x1) +char 0x4 <= 0x7 == 0x1 (0x1) +__uchar 0x4 <= 0x7 == 0x1 (0x1) +__longlong 0x4 <= 0x7 == 0x1 (0x1) +__ulonglong 0x4 <= 0x7 == 0x1 (0x1) +float 0x4 <= 0x7 == 0x1 (0x1) +int 0x4 == 0x7 == 0x0 (0x0) +__uint 0x4 == 0x7 == 0x0 (0x0) +char 0x4 == 0x7 == 0x0 (0x0) +__uchar 0x4 == 0x7 == 0x0 (0x0) +__longlong 0x4 == 0x7 == 0x0 (0x0) +__ulonglong 0x4 == 0x7 == 0x0 (0x0) +float 0x4 == 0x7 == 0x0 (0x0) +int 0x4 != 0x7 == 0x1 (0x1) +__uint 0x4 != 0x7 == 0x1 (0x1) +char 0x4 != 0x7 == 0x1 (0x1) +__uchar 0x4 != 0x7 == 0x1 (0x1) +__longlong 0x4 != 0x7 == 0x1 (0x1) +__ulonglong 0x4 != 0x7 == 0x1 (0x1) +float 0x4 != 0x7 == 0x1 (0x1) +int 0x4 >= 0x7 == 0x0 (0x0) +__uint 0x4 >= 0x7 == 0x0 (0x0) +char 0x4 >= 0x7 == 0x0 (0x0) +__uchar 0x4 >= 0x7 == 0x0 (0x0) +__longlong 0x4 >= 0x7 == 0x0 (0x0) +__ulonglong 0x4 >= 0x7 == 0x0 (0x0) +float 0x4 >= 0x7 == 0x0 (0x0) +int 0x4 / 0x7 == 0x0 (0x0) +__uint 0x4 / 0x7 == 0x0 (0x0) +char 0x4 / 0x7 == 0x0 (0x0) +__uchar 0x4 / 0x7 == 0x0 (0x0) +__longlong 0x4 / 0x7 == 0x0 (0x0) +__ulonglong 0x4 / 0x7 == 0x0 (0x0) +float 0x4 / 0x7 == 0x0 (0x0) +int 0x4 % 0x7 == 0x4 (0x4) +__uint 0x4 % 0x7 == 0x4 (0x4) +char 0x4 % 0x7 == 0x4 (0x4) +__uchar 0x4 % 0x7 == 0x4 (0x4) +__longlong 0x4 % 0x7 == 0x4 (0x4) +__ulonglong 0x4 % 0x7 == 0x4 (0x4) +0x4 * 0x2a == 0xa8 +0x4 / 0x2a == 0x0 +0x4 % 0x2a == 0x4 +int 0x4 ^ 0x2a == 0x2e (0x2e) +__uint 0x4 ^ 0x2a == 0x2e (0x2e) +char 0x4 ^ 0x2a == 0x2e (0x2e) +__uchar 0x4 ^ 0x2a == 0x2e (0x2e) +__longlong 0x4 ^ 0x2a == 0x2e (0x2e) +__ulonglong 0x4 ^ 0x2a == 0x2e (0x2e) +int 0x4 && 0x2a == 0x1 (0x1) +__uint 0x4 && 0x2a == 0x1 (0x1) +char 0x4 && 0x2a == 0x1 (0x1) +__uchar 0x4 && 0x2a == 0x1 (0x1) +__longlong 0x4 && 0x2a == 0x1 (0x1) +__ulonglong 0x4 && 0x2a == 0x1 (0x1) +int 0x4 || 0x2a == 0x1 (0x1) +__uint 0x4 || 0x2a == 0x1 (0x1) +char 0x4 || 0x2a == 0x1 (0x1) +__uchar 0x4 || 0x2a == 0x1 (0x1) +__longlong 0x4 || 0x2a == 0x1 (0x1) +__ulonglong 0x4 || 0x2a == 0x1 (0x1) +int 0x4 & 0x2a == 0x0 (0x0) +__uint 0x4 & 0x2a == 0x0 (0x0) +char 0x4 & 0x2a == 0x0 (0x0) +__uchar 0x4 & 0x2a == 0x0 (0x0) +__longlong 0x4 & 0x2a == 0x0 (0x0) +__ulonglong 0x4 & 0x2a == 0x0 (0x0) +int 0x4 | 0x2a == 0x2e (0x2e) +__uint 0x4 | 0x2a == 0x2e (0x2e) +char 0x4 | 0x2a == 0x2e (0x2e) +__uchar 0x4 | 0x2a == 0x2e (0x2e) +__longlong 0x4 | 0x2a == 0x2e (0x2e) +__ulonglong 0x4 | 0x2a == 0x2e (0x2e) +int 0x4 << 0xc == 0x4000 (0x4000) +__uint 0x4 << 0xc == 0x4000 (0x4000) +char 0x4 << 0xc == 0x0 (0x0) +__uchar 0x4 << 0xc == 0x0 (0x0) +__longlong 0x4 << 0xc == 0x4000 (0x4000) +__ulonglong 0x4 << 0xc == 0x4000 (0x4000) +int 0x4 >> 0xc == 0x0 (0x0) +__uint 0x4 >> 0xc == 0x0 (0x0) +char 0x4 >> 0xc == 0x0 (0x0) +__uchar 0x4 >> 0xc == 0x0 (0x0) +__longlong 0x4 >> 0xc == 0x0 (0x0) +__ulonglong 0x4 >> 0xc == 0x0 (0x0) +int 0x4 + 0x2a == 0x2e (0x2e) +__uint 0x4 + 0x2a == 0x2e (0x2e) +char 0x4 + 0x2a == 0x2e (0x2e) +__uchar 0x4 + 0x2a == 0x2e (0x2e) +__longlong 0x4 + 0x2a == 0x2e (0x2e) +__ulonglong 0x4 + 0x2a == 0x2e (0x2e) +float 0x4 + 0x2a == 0x2e (0x2e) +int 0x4 - 0x2a == -0x26 (0xffda) +__uint 0x4 - 0x2a == -0x26 (0xffda) +char 0x4 - 0x2a == -0x26 (0xffda) +__uchar 0x4 - 0x2a == 0xda (0xda) +__longlong 0x4 - 0x2a == -0x26 (0xffda) +__ulonglong 0x4 - 0x2a == -0x26 (0xffda) +float 0x4 - 0x2a == -0x26 (0xffda) +int 0x4 * 0x2a == 0xa8 (0xa8) +__uint 0x4 * 0x2a == 0xa8 (0xa8) +char 0x4 * 0x2a == -0x58 (0xffa8) +__uchar 0x4 * 0x2a == 0xa8 (0xa8) +__longlong 0x4 * 0x2a == 0xa8 (0xa8) +__ulonglong 0x4 * 0x2a == 0xa8 (0xa8) +float 0x4 * 0x2a == 0xa8 (0xa8) +int 0x4 < 0x2a == 0x1 (0x1) +__uint 0x4 < 0x2a == 0x1 (0x1) +char 0x4 < 0x2a == 0x1 (0x1) +__uchar 0x4 < 0x2a == 0x1 (0x1) +__longlong 0x4 < 0x2a == 0x1 (0x1) +__ulonglong 0x4 < 0x2a == 0x1 (0x1) +float 0x4 < 0x2a == 0x1 (0x1) +int 0x4 > 0x2a == 0x0 (0x0) +__uint 0x4 > 0x2a == 0x0 (0x0) +char 0x4 > 0x2a == 0x0 (0x0) +__uchar 0x4 > 0x2a == 0x0 (0x0) +__longlong 0x4 > 0x2a == 0x0 (0x0) +__ulonglong 0x4 > 0x2a == 0x0 (0x0) +float 0x4 > 0x2a == 0x0 (0x0) +int 0x4 <= 0x2a == 0x1 (0x1) +__uint 0x4 <= 0x2a == 0x1 (0x1) +char 0x4 <= 0x2a == 0x1 (0x1) +__uchar 0x4 <= 0x2a == 0x1 (0x1) +__longlong 0x4 <= 0x2a == 0x1 (0x1) +__ulonglong 0x4 <= 0x2a == 0x1 (0x1) +float 0x4 <= 0x2a == 0x1 (0x1) +int 0x4 == 0x2a == 0x0 (0x0) +__uint 0x4 == 0x2a == 0x0 (0x0) +char 0x4 == 0x2a == 0x0 (0x0) +__uchar 0x4 == 0x2a == 0x0 (0x0) +__longlong 0x4 == 0x2a == 0x0 (0x0) +__ulonglong 0x4 == 0x2a == 0x0 (0x0) +float 0x4 == 0x2a == 0x0 (0x0) +int 0x4 != 0x2a == 0x1 (0x1) +__uint 0x4 != 0x2a == 0x1 (0x1) +char 0x4 != 0x2a == 0x1 (0x1) +__uchar 0x4 != 0x2a == 0x1 (0x1) +__longlong 0x4 != 0x2a == 0x1 (0x1) +__ulonglong 0x4 != 0x2a == 0x1 (0x1) +float 0x4 != 0x2a == 0x1 (0x1) +int 0x4 >= 0x2a == 0x0 (0x0) +__uint 0x4 >= 0x2a == 0x0 (0x0) +char 0x4 >= 0x2a == 0x0 (0x0) +__uchar 0x4 >= 0x2a == 0x0 (0x0) +__longlong 0x4 >= 0x2a == 0x0 (0x0) +__ulonglong 0x4 >= 0x2a == 0x0 (0x0) +float 0x4 >= 0x2a == 0x0 (0x0) +int 0x4 / 0x2a == 0x0 (0x0) +__uint 0x4 / 0x2a == 0x0 (0x0) +char 0x4 / 0x2a == 0x0 (0x0) +__uchar 0x4 / 0x2a == 0x0 (0x0) +__longlong 0x4 / 0x2a == 0x0 (0x0) +__ulonglong 0x4 / 0x2a == 0x0 (0x0) +float 0x4 / 0x2a == 0x0 (0x0) +int 0x4 % 0x2a == 0x4 (0x4) +__uint 0x4 % 0x2a == 0x4 (0x4) +char 0x4 % 0x2a == 0x4 (0x4) +__uchar 0x4 % 0x2a == 0x4 (0x4) +__longlong 0x4 % 0x2a == 0x4 (0x4) +__ulonglong 0x4 % 0x2a == 0x4 (0x4) +0x4 * 0x17 == 0x5c +0x4 / 0x17 == 0x0 +0x4 % 0x17 == 0x4 +int 0x4 ^ 0x17 == 0x13 (0x13) +__uint 0x4 ^ 0x17 == 0x13 (0x13) +char 0x4 ^ 0x17 == 0x13 (0x13) +__uchar 0x4 ^ 0x17 == 0x13 (0x13) +__longlong 0x4 ^ 0x17 == 0x13 (0x13) +__ulonglong 0x4 ^ 0x17 == 0x13 (0x13) +int 0x4 && 0x17 == 0x1 (0x1) +__uint 0x4 && 0x17 == 0x1 (0x1) +char 0x4 && 0x17 == 0x1 (0x1) +__uchar 0x4 && 0x17 == 0x1 (0x1) +__longlong 0x4 && 0x17 == 0x1 (0x1) +__ulonglong 0x4 && 0x17 == 0x1 (0x1) +int 0x4 || 0x17 == 0x1 (0x1) +__uint 0x4 || 0x17 == 0x1 (0x1) +char 0x4 || 0x17 == 0x1 (0x1) +__uchar 0x4 || 0x17 == 0x1 (0x1) +__longlong 0x4 || 0x17 == 0x1 (0x1) +__ulonglong 0x4 || 0x17 == 0x1 (0x1) +int 0x4 & 0x17 == 0x4 (0x4) +__uint 0x4 & 0x17 == 0x4 (0x4) +char 0x4 & 0x17 == 0x4 (0x4) +__uchar 0x4 & 0x17 == 0x4 (0x4) +__longlong 0x4 & 0x17 == 0x4 (0x4) +__ulonglong 0x4 & 0x17 == 0x4 (0x4) +int 0x4 | 0x17 == 0x17 (0x17) +__uint 0x4 | 0x17 == 0x17 (0x17) +char 0x4 | 0x17 == 0x17 (0x17) +__uchar 0x4 | 0x17 == 0x17 (0x17) +__longlong 0x4 | 0x17 == 0x17 (0x17) +__ulonglong 0x4 | 0x17 == 0x17 (0x17) +int 0x4 << 0xe == 0x0 (0x0) +__uint 0x4 << 0xe == 0x0 (0x0) +char 0x4 << 0xe == 0x0 (0x0) +__uchar 0x4 << 0xe == 0x0 (0x0) +__longlong 0x4 << 0xe == 0x0 (0x0) +__ulonglong 0x4 << 0xe == 0x0 (0x0) +int 0x4 >> 0xe == 0x0 (0x0) +__uint 0x4 >> 0xe == 0x0 (0x0) +char 0x4 >> 0xe == 0x0 (0x0) +__uchar 0x4 >> 0xe == 0x0 (0x0) +__longlong 0x4 >> 0xe == 0x0 (0x0) +__ulonglong 0x4 >> 0xe == 0x0 (0x0) +int 0x4 + 0x17 == 0x1b (0x1b) +__uint 0x4 + 0x17 == 0x1b (0x1b) +char 0x4 + 0x17 == 0x1b (0x1b) +__uchar 0x4 + 0x17 == 0x1b (0x1b) +__longlong 0x4 + 0x17 == 0x1b (0x1b) +__ulonglong 0x4 + 0x17 == 0x1b (0x1b) +float 0x4 + 0x17 == 0x1b (0x1b) +int 0x4 - 0x17 == -0x13 (0xffed) +__uint 0x4 - 0x17 == -0x13 (0xffed) +char 0x4 - 0x17 == -0x13 (0xffed) +__uchar 0x4 - 0x17 == 0xed (0xed) +__longlong 0x4 - 0x17 == -0x13 (0xffed) +__ulonglong 0x4 - 0x17 == -0x13 (0xffed) +float 0x4 - 0x17 == -0x13 (0xffed) +int 0x4 * 0x17 == 0x5c (0x5c) +__uint 0x4 * 0x17 == 0x5c (0x5c) +char 0x4 * 0x17 == 0x5c (0x5c) +__uchar 0x4 * 0x17 == 0x5c (0x5c) +__longlong 0x4 * 0x17 == 0x5c (0x5c) +__ulonglong 0x4 * 0x17 == 0x5c (0x5c) +float 0x4 * 0x17 == 0x5c (0x5c) +int 0x4 < 0x17 == 0x1 (0x1) +__uint 0x4 < 0x17 == 0x1 (0x1) +char 0x4 < 0x17 == 0x1 (0x1) +__uchar 0x4 < 0x17 == 0x1 (0x1) +__longlong 0x4 < 0x17 == 0x1 (0x1) +__ulonglong 0x4 < 0x17 == 0x1 (0x1) +float 0x4 < 0x17 == 0x1 (0x1) +int 0x4 > 0x17 == 0x0 (0x0) +__uint 0x4 > 0x17 == 0x0 (0x0) +char 0x4 > 0x17 == 0x0 (0x0) +__uchar 0x4 > 0x17 == 0x0 (0x0) +__longlong 0x4 > 0x17 == 0x0 (0x0) +__ulonglong 0x4 > 0x17 == 0x0 (0x0) +float 0x4 > 0x17 == 0x0 (0x0) +int 0x4 <= 0x17 == 0x1 (0x1) +__uint 0x4 <= 0x17 == 0x1 (0x1) +char 0x4 <= 0x17 == 0x1 (0x1) +__uchar 0x4 <= 0x17 == 0x1 (0x1) +__longlong 0x4 <= 0x17 == 0x1 (0x1) +__ulonglong 0x4 <= 0x17 == 0x1 (0x1) +float 0x4 <= 0x17 == 0x1 (0x1) +int 0x4 == 0x17 == 0x0 (0x0) +__uint 0x4 == 0x17 == 0x0 (0x0) +char 0x4 == 0x17 == 0x0 (0x0) +__uchar 0x4 == 0x17 == 0x0 (0x0) +__longlong 0x4 == 0x17 == 0x0 (0x0) +__ulonglong 0x4 == 0x17 == 0x0 (0x0) +float 0x4 == 0x17 == 0x0 (0x0) +int 0x4 != 0x17 == 0x1 (0x1) +__uint 0x4 != 0x17 == 0x1 (0x1) +char 0x4 != 0x17 == 0x1 (0x1) +__uchar 0x4 != 0x17 == 0x1 (0x1) +__longlong 0x4 != 0x17 == 0x1 (0x1) +__ulonglong 0x4 != 0x17 == 0x1 (0x1) +float 0x4 != 0x17 == 0x1 (0x1) +int 0x4 >= 0x17 == 0x0 (0x0) +__uint 0x4 >= 0x17 == 0x0 (0x0) +char 0x4 >= 0x17 == 0x0 (0x0) +__uchar 0x4 >= 0x17 == 0x0 (0x0) +__longlong 0x4 >= 0x17 == 0x0 (0x0) +__ulonglong 0x4 >= 0x17 == 0x0 (0x0) +float 0x4 >= 0x17 == 0x0 (0x0) +int 0x4 / 0x17 == 0x0 (0x0) +__uint 0x4 / 0x17 == 0x0 (0x0) +char 0x4 / 0x17 == 0x0 (0x0) +__uchar 0x4 / 0x17 == 0x0 (0x0) +__longlong 0x4 / 0x17 == 0x0 (0x0) +__ulonglong 0x4 / 0x17 == 0x0 (0x0) +float 0x4 / 0x17 == 0x0 (0x0) +int 0x4 % 0x17 == 0x4 (0x4) +__uint 0x4 % 0x17 == 0x4 (0x4) +char 0x4 % 0x17 == 0x4 (0x4) +__uchar 0x4 % 0x17 == 0x4 (0x4) +__longlong 0x4 % 0x17 == 0x4 (0x4) +__ulonglong 0x4 % 0x17 == 0x4 (0x4) +0x4 * 0x7fff == -0x4 +0x4 / 0x7fff == 0x0 +0x4 % 0x7fff == 0x4 +int 0x4 ^ 0x7fff == 0x7ffb (0x7ffb) +__uint 0x4 ^ 0x7fff == 0x7ffb (0x7ffb) +char 0x4 ^ 0xffff == -0x5 (0xfffb) +__uchar 0x4 ^ 0xff == 0xfb (0xfb) +__longlong 0x4 ^ 0x7fff == 0x7ffb (0x7ffb) +__ulonglong 0x4 ^ 0x7fff == 0x7ffb (0x7ffb) +int 0x4 && 0x7fff == 0x1 (0x1) +__uint 0x4 && 0x7fff == 0x1 (0x1) +char 0x4 && 0xffff == 0x1 (0x1) +__uchar 0x4 && 0xff == 0x1 (0x1) +__longlong 0x4 && 0x7fff == 0x1 (0x1) +__ulonglong 0x4 && 0x7fff == 0x1 (0x1) +int 0x4 || 0x7fff == 0x1 (0x1) +__uint 0x4 || 0x7fff == 0x1 (0x1) +char 0x4 || 0xffff == 0x1 (0x1) +__uchar 0x4 || 0xff == 0x1 (0x1) +__longlong 0x4 || 0x7fff == 0x1 (0x1) +__ulonglong 0x4 || 0x7fff == 0x1 (0x1) +int 0x4 & 0x7fff == 0x4 (0x4) +__uint 0x4 & 0x7fff == 0x4 (0x4) +char 0x4 & 0xffff == 0x4 (0x4) +__uchar 0x4 & 0xff == 0x4 (0x4) +__longlong 0x4 & 0x7fff == 0x4 (0x4) +__ulonglong 0x4 & 0x7fff == 0x4 (0x4) +int 0x4 | 0x7fff == 0x7fff (0x7fff) +__uint 0x4 | 0x7fff == 0x7fff (0x7fff) +char 0x4 | 0xffff == -0x1 (0xffff) +__uchar 0x4 | 0xff == 0xff (0xff) +__longlong 0x4 | 0x7fff == 0x7fff (0x7fff) +__ulonglong 0x4 | 0x7fff == 0x7fff (0x7fff) +int 0x4 << 0x10 == 0x0 (0x0) +__uint 0x4 << 0x10 == 0x0 (0x0) +char 0x4 << 0x10 == 0x0 (0x0) +__uchar 0x4 << 0x10 == 0x0 (0x0) +__longlong 0x4 << 0x10 == 0x0 (0x0) +__ulonglong 0x4 << 0x10 == 0x0 (0x0) +int 0x4 >> 0x10 == 0x0 (0x0) +__uint 0x4 >> 0x10 == 0x0 (0x0) +char 0x4 >> 0x10 == 0x0 (0x0) +__uchar 0x4 >> 0x10 == 0x0 (0x0) +__longlong 0x4 >> 0x10 == 0x0 (0x0) +__ulonglong 0x4 >> 0x10 == 0x0 (0x0) +int 0x4 + 0x7fff == -0x7ffd (0x8003) +__uint 0x4 + 0x7fff == -0x7ffd (0x8003) +char 0x4 + 0xffff == 0x3 (0x3) +__uchar 0x4 + 0xff == 0x3 (0x3) +__longlong 0x4 + 0x7fff == -0x7ffd (0x8003) +__ulonglong 0x4 + 0x7fff == -0x7ffd (0x8003) +float 0x4 + 0x7fff == -0x7ffd (0x8003) +int 0x4 - 0x7fff == -0x7ffb (0x8005) +__uint 0x4 - 0x7fff == -0x7ffb (0x8005) +char 0x4 - 0xffff == 0x5 (0x5) +__uchar 0x4 - 0xff == 0x5 (0x5) +__longlong 0x4 - 0x7fff == -0x7ffb (0x8005) +__ulonglong 0x4 - 0x7fff == -0x7ffb (0x8005) +float 0x4 - 0x7fff == -0x7ffb (0x8005) +int 0x4 * 0x7fff == -0x4 (0xfffc) +__uint 0x4 * 0x7fff == -0x4 (0xfffc) +char 0x4 * 0xffff == -0x4 (0xfffc) +__uchar 0x4 * 0xff == 0xfc (0xfc) +__longlong 0x4 * 0x7fff == -0x4 (0xfffc) +__ulonglong 0x4 * 0x7fff == -0x4 (0xfffc) +float 0x4 * 0x7fff == -0x4 (0xfffc) +int 0x4 < 0x7fff == 0x1 (0x1) +__uint 0x4 < 0x7fff == 0x1 (0x1) +char 0x4 < 0xffff == 0x0 (0x0) +__uchar 0x4 < 0xff == 0x1 (0x1) +__longlong 0x4 < 0x7fff == 0x1 (0x1) +__ulonglong 0x4 < 0x7fff == 0x1 (0x1) +float 0x4 < 0x7fff == 0x1 (0x1) +int 0x4 > 0x7fff == 0x0 (0x0) +__uint 0x4 > 0x7fff == 0x0 (0x0) +char 0x4 > 0xffff == 0x1 (0x1) +__uchar 0x4 > 0xff == 0x0 (0x0) +__longlong 0x4 > 0x7fff == 0x0 (0x0) +__ulonglong 0x4 > 0x7fff == 0x0 (0x0) +float 0x4 > 0x7fff == 0x0 (0x0) +int 0x4 <= 0x7fff == 0x1 (0x1) +__uint 0x4 <= 0x7fff == 0x1 (0x1) +char 0x4 <= 0xffff == 0x0 (0x0) +__uchar 0x4 <= 0xff == 0x1 (0x1) +__longlong 0x4 <= 0x7fff == 0x1 (0x1) +__ulonglong 0x4 <= 0x7fff == 0x1 (0x1) +float 0x4 <= 0x7fff == 0x1 (0x1) +int 0x4 == 0x7fff == 0x0 (0x0) +__uint 0x4 == 0x7fff == 0x0 (0x0) +char 0x4 == 0xffff == 0x0 (0x0) +__uchar 0x4 == 0xff == 0x0 (0x0) +__longlong 0x4 == 0x7fff == 0x0 (0x0) +__ulonglong 0x4 == 0x7fff == 0x0 (0x0) +float 0x4 == 0x7fff == 0x0 (0x0) +int 0x4 != 0x7fff == 0x1 (0x1) +__uint 0x4 != 0x7fff == 0x1 (0x1) +char 0x4 != 0xffff == 0x1 (0x1) +__uchar 0x4 != 0xff == 0x1 (0x1) +__longlong 0x4 != 0x7fff == 0x1 (0x1) +__ulonglong 0x4 != 0x7fff == 0x1 (0x1) +float 0x4 != 0x7fff == 0x1 (0x1) +int 0x4 >= 0x7fff == 0x0 (0x0) +__uint 0x4 >= 0x7fff == 0x0 (0x0) +char 0x4 >= 0xffff == 0x1 (0x1) +__uchar 0x4 >= 0xff == 0x0 (0x0) +__longlong 0x4 >= 0x7fff == 0x0 (0x0) +__ulonglong 0x4 >= 0x7fff == 0x0 (0x0) +float 0x4 >= 0x7fff == 0x0 (0x0) +int 0x4 / 0x7fff == 0x0 (0x0) +__uint 0x4 / 0x7fff == 0x0 (0x0) +char 0x4 / 0xffff == -0x4 (0xfffc) +__uchar 0x4 / 0xff == 0x0 (0x0) +__longlong 0x4 / 0x7fff == 0x0 (0x0) +__ulonglong 0x4 / 0x7fff == 0x0 (0x0) +float 0x4 / 0x7fff == 0x0 (0x0) +int 0x4 % 0x7fff == 0x4 (0x4) +__uint 0x4 % 0x7fff == 0x4 (0x4) +char 0x4 % 0xffff == 0x0 (0x0) +__uchar 0x4 % 0xff == 0x4 (0x4) +__longlong 0x4 % 0x7fff == 0x4 (0x4) +__ulonglong 0x4 % 0x7fff == 0x4 (0x4) +0x4 * 0x8000 == 0x0 +0x4 / 0x8000 == 0x0 +0x4 % 0x8000 == 0x4 +int 0x4 ^ 0x8000 == -0x7ffc (0x8004) +__uint 0x4 ^ 0x8000 == -0x7ffc (0x8004) +char 0x4 ^ 0x0 == 0x4 (0x4) +__uchar 0x4 ^ 0x0 == 0x4 (0x4) +__longlong 0x4 ^ 0x8000 == -0x7ffc (0x8004) +__ulonglong 0x4 ^ 0x8000 == -0x7ffc (0x8004) +int 0x4 && 0x8000 == 0x1 (0x1) +__uint 0x4 && 0x8000 == 0x1 (0x1) +char 0x4 && 0x0 == 0x0 (0x0) +__uchar 0x4 && 0x0 == 0x0 (0x0) +__longlong 0x4 && 0x8000 == 0x1 (0x1) +__ulonglong 0x4 && 0x8000 == 0x1 (0x1) +int 0x4 || 0x8000 == 0x1 (0x1) +__uint 0x4 || 0x8000 == 0x1 (0x1) +char 0x4 || 0x0 == 0x1 (0x1) +__uchar 0x4 || 0x0 == 0x1 (0x1) +__longlong 0x4 || 0x8000 == 0x1 (0x1) +__ulonglong 0x4 || 0x8000 == 0x1 (0x1) +int 0x4 & 0x8000 == 0x0 (0x0) +__uint 0x4 & 0x8000 == 0x0 (0x0) +char 0x4 & 0x0 == 0x0 (0x0) +__uchar 0x4 & 0x0 == 0x0 (0x0) +__longlong 0x4 & 0x8000 == 0x0 (0x0) +__ulonglong 0x4 & 0x8000 == 0x0 (0x0) +int 0x4 | 0x8000 == -0x7ffc (0x8004) +__uint 0x4 | 0x8000 == -0x7ffc (0x8004) +char 0x4 | 0x0 == 0x4 (0x4) +__uchar 0x4 | 0x0 == 0x4 (0x4) +__longlong 0x4 | 0x8000 == -0x7ffc (0x8004) +__ulonglong 0x4 | 0x8000 == -0x7ffc (0x8004) +int 0x4 << 0x12 == 0x0 (0x0) +__uint 0x4 << 0x12 == 0x0 (0x0) +char 0x4 << 0x12 == 0x0 (0x0) +__uchar 0x4 << 0x12 == 0x0 (0x0) +__longlong 0x4 << 0x12 == 0x0 (0x0) +__ulonglong 0x4 << 0x12 == 0x0 (0x0) +int 0x4 >> 0x12 == 0x0 (0x0) +__uint 0x4 >> 0x12 == 0x0 (0x0) +char 0x4 >> 0x12 == 0x0 (0x0) +__uchar 0x4 >> 0x12 == 0x0 (0x0) +__longlong 0x4 >> 0x12 == 0x0 (0x0) +__ulonglong 0x4 >> 0x12 == 0x0 (0x0) +int 0x4 + 0x8000 == -0x7ffc (0x8004) +__uint 0x4 + 0x8000 == -0x7ffc (0x8004) +char 0x4 + 0x0 == 0x4 (0x4) +__uchar 0x4 + 0x0 == 0x4 (0x4) +__longlong 0x4 + 0x8000 == -0x7ffc (0x8004) +__ulonglong 0x4 + 0x8000 == -0x7ffc (0x8004) +float 0x4 + 0x8000 == -0x7ffc (0x8004) +int 0x4 - 0x8000 == -0x7ffc (0x8004) +__uint 0x4 - 0x8000 == -0x7ffc (0x8004) +char 0x4 - 0x0 == 0x4 (0x4) +__uchar 0x4 - 0x0 == 0x4 (0x4) +__longlong 0x4 - 0x8000 == -0x7ffc (0x8004) +__ulonglong 0x4 - 0x8000 == -0x7ffc (0x8004) +float 0x4 - 0x8000 == -0x7ffc (0x8004) +int 0x4 * 0x8000 == 0x0 (0x0) +__uint 0x4 * 0x8000 == 0x0 (0x0) +char 0x4 * 0x0 == 0x0 (0x0) +__uchar 0x4 * 0x0 == 0x0 (0x0) +__longlong 0x4 * 0x8000 == 0x0 (0x0) +__ulonglong 0x4 * 0x8000 == 0x0 (0x0) +float 0x4 * 0x8000 == 0x0 (0x0) +int 0x4 < 0x8000 == 0x0 (0x0) +__uint 0x4 < 0x8000 == 0x1 (0x1) +char 0x4 < 0x0 == 0x0 (0x0) +__uchar 0x4 < 0x0 == 0x0 (0x0) +__longlong 0x4 < 0x8000 == 0x0 (0x0) +__ulonglong 0x4 < 0x8000 == 0x1 (0x1) +float 0x4 < 0x8000 == 0x0 (0x0) +int 0x4 > 0x8000 == 0x1 (0x1) +__uint 0x4 > 0x8000 == 0x0 (0x0) +char 0x4 > 0x0 == 0x1 (0x1) +__uchar 0x4 > 0x0 == 0x1 (0x1) +__longlong 0x4 > 0x8000 == 0x1 (0x1) +__ulonglong 0x4 > 0x8000 == 0x0 (0x0) +float 0x4 > 0x8000 == 0x1 (0x1) +int 0x4 <= 0x8000 == 0x0 (0x0) +__uint 0x4 <= 0x8000 == 0x1 (0x1) +char 0x4 <= 0x0 == 0x0 (0x0) +__uchar 0x4 <= 0x0 == 0x0 (0x0) +__longlong 0x4 <= 0x8000 == 0x0 (0x0) +__ulonglong 0x4 <= 0x8000 == 0x1 (0x1) +float 0x4 <= 0x8000 == 0x0 (0x0) +int 0x4 == 0x8000 == 0x0 (0x0) +__uint 0x4 == 0x8000 == 0x0 (0x0) +char 0x4 == 0x0 == 0x0 (0x0) +__uchar 0x4 == 0x0 == 0x0 (0x0) +__longlong 0x4 == 0x8000 == 0x0 (0x0) +__ulonglong 0x4 == 0x8000 == 0x0 (0x0) +float 0x4 == 0x8000 == 0x0 (0x0) +int 0x4 != 0x8000 == 0x1 (0x1) +__uint 0x4 != 0x8000 == 0x1 (0x1) +char 0x4 != 0x0 == 0x1 (0x1) +__uchar 0x4 != 0x0 == 0x1 (0x1) +__longlong 0x4 != 0x8000 == 0x1 (0x1) +__ulonglong 0x4 != 0x8000 == 0x1 (0x1) +float 0x4 != 0x8000 == 0x1 (0x1) +int 0x4 >= 0x8000 == 0x1 (0x1) +__uint 0x4 >= 0x8000 == 0x0 (0x0) +char 0x4 >= 0x0 == 0x1 (0x1) +__uchar 0x4 >= 0x0 == 0x1 (0x1) +__longlong 0x4 >= 0x8000 == 0x1 (0x1) +__ulonglong 0x4 >= 0x8000 == 0x0 (0x0) +float 0x4 >= 0x8000 == 0x1 (0x1) +int 0x4 / 0x8000 == 0x0 (0x0) +__uint 0x4 / 0x8000 == 0x0 (0x0) +__longlong 0x4 / 0x8000 == 0x0 (0x0) +__ulonglong 0x4 / 0x8000 == 0x0 (0x0) +float 0x4 / 0x8000 == 0x0 (0x0) +int 0x4 % 0x8000 == 0x4 (0x4) +__uint 0x4 % 0x8000 == 0x4 (0x4) +__longlong 0x4 % 0x8000 == 0x4 (0x4) +__ulonglong 0x4 % 0x8000 == 0x4 (0x4) +0x4 * 0x3e8 == 0xfa0 +0x4 / 0x3e8 == 0x0 +0x4 % 0x3e8 == 0x4 +int 0x4 ^ 0x3e8 == 0x3ec (0x3ec) +__uint 0x4 ^ 0x3e8 == 0x3ec (0x3ec) +char 0x4 ^ 0xffe8 == -0x14 (0xffec) +__uchar 0x4 ^ 0xe8 == 0xec (0xec) +__longlong 0x4 ^ 0x3e8 == 0x3ec (0x3ec) +__ulonglong 0x4 ^ 0x3e8 == 0x3ec (0x3ec) +int 0x4 && 0x3e8 == 0x1 (0x1) +__uint 0x4 && 0x3e8 == 0x1 (0x1) +char 0x4 && 0xffe8 == 0x1 (0x1) +__uchar 0x4 && 0xe8 == 0x1 (0x1) +__longlong 0x4 && 0x3e8 == 0x1 (0x1) +__ulonglong 0x4 && 0x3e8 == 0x1 (0x1) +int 0x4 || 0x3e8 == 0x1 (0x1) +__uint 0x4 || 0x3e8 == 0x1 (0x1) +char 0x4 || 0xffe8 == 0x1 (0x1) +__uchar 0x4 || 0xe8 == 0x1 (0x1) +__longlong 0x4 || 0x3e8 == 0x1 (0x1) +__ulonglong 0x4 || 0x3e8 == 0x1 (0x1) +int 0x4 & 0x3e8 == 0x0 (0x0) +__uint 0x4 & 0x3e8 == 0x0 (0x0) +char 0x4 & 0xffe8 == 0x0 (0x0) +__uchar 0x4 & 0xe8 == 0x0 (0x0) +__longlong 0x4 & 0x3e8 == 0x0 (0x0) +__ulonglong 0x4 & 0x3e8 == 0x0 (0x0) +int 0x4 | 0x3e8 == 0x3ec (0x3ec) +__uint 0x4 | 0x3e8 == 0x3ec (0x3ec) +char 0x4 | 0xffe8 == -0x14 (0xffec) +__uchar 0x4 | 0xe8 == 0xec (0xec) +__longlong 0x4 | 0x3e8 == 0x3ec (0x3ec) +__ulonglong 0x4 | 0x3e8 == 0x3ec (0x3ec) +int 0x4 << 0x14 == 0x0 (0x0) +__uint 0x4 << 0x14 == 0x0 (0x0) +char 0x4 << 0x14 == 0x0 (0x0) +__uchar 0x4 << 0x14 == 0x0 (0x0) +__longlong 0x4 << 0x14 == 0x0 (0x0) +__ulonglong 0x4 << 0x14 == 0x0 (0x0) +int 0x4 >> 0x14 == 0x0 (0x0) +__uint 0x4 >> 0x14 == 0x0 (0x0) +char 0x4 >> 0x14 == 0x0 (0x0) +__uchar 0x4 >> 0x14 == 0x0 (0x0) +__longlong 0x4 >> 0x14 == 0x0 (0x0) +__ulonglong 0x4 >> 0x14 == 0x0 (0x0) +int 0x4 + 0x3e8 == 0x3ec (0x3ec) +__uint 0x4 + 0x3e8 == 0x3ec (0x3ec) +char 0x4 + 0xffe8 == -0x14 (0xffec) +__uchar 0x4 + 0xe8 == 0xec (0xec) +__longlong 0x4 + 0x3e8 == 0x3ec (0x3ec) +__ulonglong 0x4 + 0x3e8 == 0x3ec (0x3ec) +float 0x4 + 0x3e8 == 0x3ec (0x3ec) +int 0x4 - 0x3e8 == -0x3e4 (0xfc1c) +__uint 0x4 - 0x3e8 == -0x3e4 (0xfc1c) +char 0x4 - 0xffe8 == 0x1c (0x1c) +__uchar 0x4 - 0xe8 == 0x1c (0x1c) +__longlong 0x4 - 0x3e8 == -0x3e4 (0xfc1c) +__ulonglong 0x4 - 0x3e8 == -0x3e4 (0xfc1c) +float 0x4 - 0x3e8 == -0x3e4 (0xfc1c) +int 0x4 * 0x3e8 == 0xfa0 (0xfa0) +__uint 0x4 * 0x3e8 == 0xfa0 (0xfa0) +char 0x4 * 0xffe8 == -0x60 (0xffa0) +__uchar 0x4 * 0xe8 == 0xa0 (0xa0) +__longlong 0x4 * 0x3e8 == 0xfa0 (0xfa0) +__ulonglong 0x4 * 0x3e8 == 0xfa0 (0xfa0) +float 0x4 * 0x3e8 == 0xfa0 (0xfa0) +int 0x4 < 0x3e8 == 0x1 (0x1) +__uint 0x4 < 0x3e8 == 0x1 (0x1) +char 0x4 < 0xffe8 == 0x0 (0x0) +__uchar 0x4 < 0xe8 == 0x1 (0x1) +__longlong 0x4 < 0x3e8 == 0x1 (0x1) +__ulonglong 0x4 < 0x3e8 == 0x1 (0x1) +float 0x4 < 0x3e8 == 0x1 (0x1) +int 0x4 > 0x3e8 == 0x0 (0x0) +__uint 0x4 > 0x3e8 == 0x0 (0x0) +char 0x4 > 0xffe8 == 0x1 (0x1) +__uchar 0x4 > 0xe8 == 0x0 (0x0) +__longlong 0x4 > 0x3e8 == 0x0 (0x0) +__ulonglong 0x4 > 0x3e8 == 0x0 (0x0) +float 0x4 > 0x3e8 == 0x0 (0x0) +int 0x4 <= 0x3e8 == 0x1 (0x1) +__uint 0x4 <= 0x3e8 == 0x1 (0x1) +char 0x4 <= 0xffe8 == 0x0 (0x0) +__uchar 0x4 <= 0xe8 == 0x1 (0x1) +__longlong 0x4 <= 0x3e8 == 0x1 (0x1) +__ulonglong 0x4 <= 0x3e8 == 0x1 (0x1) +float 0x4 <= 0x3e8 == 0x1 (0x1) +int 0x4 == 0x3e8 == 0x0 (0x0) +__uint 0x4 == 0x3e8 == 0x0 (0x0) +char 0x4 == 0xffe8 == 0x0 (0x0) +__uchar 0x4 == 0xe8 == 0x0 (0x0) +__longlong 0x4 == 0x3e8 == 0x0 (0x0) +__ulonglong 0x4 == 0x3e8 == 0x0 (0x0) +float 0x4 == 0x3e8 == 0x0 (0x0) +int 0x4 != 0x3e8 == 0x1 (0x1) +__uint 0x4 != 0x3e8 == 0x1 (0x1) +char 0x4 != 0xffe8 == 0x1 (0x1) +__uchar 0x4 != 0xe8 == 0x1 (0x1) +__longlong 0x4 != 0x3e8 == 0x1 (0x1) +__ulonglong 0x4 != 0x3e8 == 0x1 (0x1) +float 0x4 != 0x3e8 == 0x1 (0x1) +int 0x4 >= 0x3e8 == 0x0 (0x0) +__uint 0x4 >= 0x3e8 == 0x0 (0x0) +char 0x4 >= 0xffe8 == 0x1 (0x1) +__uchar 0x4 >= 0xe8 == 0x0 (0x0) +__longlong 0x4 >= 0x3e8 == 0x0 (0x0) +__ulonglong 0x4 >= 0x3e8 == 0x0 (0x0) +float 0x4 >= 0x3e8 == 0x0 (0x0) +int 0x4 / 0x3e8 == 0x0 (0x0) +__uint 0x4 / 0x3e8 == 0x0 (0x0) +char 0x4 / 0xffe8 == 0x0 (0x0) +__uchar 0x4 / 0xe8 == 0x0 (0x0) +__longlong 0x4 / 0x3e8 == 0x0 (0x0) +__ulonglong 0x4 / 0x3e8 == 0x0 (0x0) +float 0x4 / 0x3e8 == 0x0 (0x0) +int 0x4 % 0x3e8 == 0x4 (0x4) +__uint 0x4 % 0x3e8 == 0x4 (0x4) +char 0x4 % 0xffe8 == 0x4 (0x4) +__uchar 0x4 % 0xe8 == 0x4 (0x4) +__longlong 0x4 % 0x3e8 == 0x4 (0x4) +__ulonglong 0x4 % 0x3e8 == 0x4 (0x4) +0x4 * 0x2710 == -0x63c0 +0x4 / 0x2710 == 0x0 +0x4 % 0x2710 == 0x4 +int 0x4 ^ 0x2710 == 0x2714 (0x2714) +__uint 0x4 ^ 0x2710 == 0x2714 (0x2714) +char 0x4 ^ 0x10 == 0x14 (0x14) +__uchar 0x4 ^ 0x10 == 0x14 (0x14) +__longlong 0x4 ^ 0x2710 == 0x2714 (0x2714) +__ulonglong 0x4 ^ 0x2710 == 0x2714 (0x2714) +int 0x4 && 0x2710 == 0x1 (0x1) +__uint 0x4 && 0x2710 == 0x1 (0x1) +char 0x4 && 0x10 == 0x1 (0x1) +__uchar 0x4 && 0x10 == 0x1 (0x1) +__longlong 0x4 && 0x2710 == 0x1 (0x1) +__ulonglong 0x4 && 0x2710 == 0x1 (0x1) +int 0x4 || 0x2710 == 0x1 (0x1) +__uint 0x4 || 0x2710 == 0x1 (0x1) +char 0x4 || 0x10 == 0x1 (0x1) +__uchar 0x4 || 0x10 == 0x1 (0x1) +__longlong 0x4 || 0x2710 == 0x1 (0x1) +__ulonglong 0x4 || 0x2710 == 0x1 (0x1) +int 0x4 & 0x2710 == 0x0 (0x0) +__uint 0x4 & 0x2710 == 0x0 (0x0) +char 0x4 & 0x10 == 0x0 (0x0) +__uchar 0x4 & 0x10 == 0x0 (0x0) +__longlong 0x4 & 0x2710 == 0x0 (0x0) +__ulonglong 0x4 & 0x2710 == 0x0 (0x0) +int 0x4 | 0x2710 == 0x2714 (0x2714) +__uint 0x4 | 0x2710 == 0x2714 (0x2714) +char 0x4 | 0x10 == 0x14 (0x14) +__uchar 0x4 | 0x10 == 0x14 (0x14) +__longlong 0x4 | 0x2710 == 0x2714 (0x2714) +__ulonglong 0x4 | 0x2710 == 0x2714 (0x2714) +int 0x4 << 0x16 == 0x0 (0x0) +__uint 0x4 << 0x16 == 0x0 (0x0) +char 0x4 << 0x16 == 0x0 (0x0) +__uchar 0x4 << 0x16 == 0x0 (0x0) +__longlong 0x4 << 0x16 == 0x0 (0x0) +__ulonglong 0x4 << 0x16 == 0x0 (0x0) +int 0x4 >> 0x16 == 0x0 (0x0) +__uint 0x4 >> 0x16 == 0x0 (0x0) +char 0x4 >> 0x16 == 0x0 (0x0) +__uchar 0x4 >> 0x16 == 0x0 (0x0) +__longlong 0x4 >> 0x16 == 0x0 (0x0) +__ulonglong 0x4 >> 0x16 == 0x0 (0x0) +int 0x4 + 0x2710 == 0x2714 (0x2714) +__uint 0x4 + 0x2710 == 0x2714 (0x2714) +char 0x4 + 0x10 == 0x14 (0x14) +__uchar 0x4 + 0x10 == 0x14 (0x14) +__longlong 0x4 + 0x2710 == 0x2714 (0x2714) +__ulonglong 0x4 + 0x2710 == 0x2714 (0x2714) +float 0x4 + 0x2710 == 0x2714 (0x2714) +int 0x4 - 0x2710 == -0x270c (0xd8f4) +__uint 0x4 - 0x2710 == -0x270c (0xd8f4) +char 0x4 - 0x10 == -0xc (0xfff4) +__uchar 0x4 - 0x10 == 0xf4 (0xf4) +__longlong 0x4 - 0x2710 == -0x270c (0xd8f4) +__ulonglong 0x4 - 0x2710 == -0x270c (0xd8f4) +float 0x4 - 0x2710 == -0x270c (0xd8f4) +int 0x4 * 0x2710 == -0x63c0 (0x9c40) +__uint 0x4 * 0x2710 == -0x63c0 (0x9c40) +char 0x4 * 0x10 == 0x40 (0x40) +__uchar 0x4 * 0x10 == 0x40 (0x40) +__longlong 0x4 * 0x2710 == -0x63c0 (0x9c40) +__ulonglong 0x4 * 0x2710 == -0x63c0 (0x9c40) +float 0x4 * 0x2710 == -0x63c0 (0x9c40) +int 0x4 < 0x2710 == 0x1 (0x1) +__uint 0x4 < 0x2710 == 0x1 (0x1) +char 0x4 < 0x10 == 0x1 (0x1) +__uchar 0x4 < 0x10 == 0x1 (0x1) +__longlong 0x4 < 0x2710 == 0x1 (0x1) +__ulonglong 0x4 < 0x2710 == 0x1 (0x1) +float 0x4 < 0x2710 == 0x1 (0x1) +int 0x4 > 0x2710 == 0x0 (0x0) +__uint 0x4 > 0x2710 == 0x0 (0x0) +char 0x4 > 0x10 == 0x0 (0x0) +__uchar 0x4 > 0x10 == 0x0 (0x0) +__longlong 0x4 > 0x2710 == 0x0 (0x0) +__ulonglong 0x4 > 0x2710 == 0x0 (0x0) +float 0x4 > 0x2710 == 0x0 (0x0) +int 0x4 <= 0x2710 == 0x1 (0x1) +__uint 0x4 <= 0x2710 == 0x1 (0x1) +char 0x4 <= 0x10 == 0x1 (0x1) +__uchar 0x4 <= 0x10 == 0x1 (0x1) +__longlong 0x4 <= 0x2710 == 0x1 (0x1) +__ulonglong 0x4 <= 0x2710 == 0x1 (0x1) +float 0x4 <= 0x2710 == 0x1 (0x1) +int 0x4 == 0x2710 == 0x0 (0x0) +__uint 0x4 == 0x2710 == 0x0 (0x0) +char 0x4 == 0x10 == 0x0 (0x0) +__uchar 0x4 == 0x10 == 0x0 (0x0) +__longlong 0x4 == 0x2710 == 0x0 (0x0) +__ulonglong 0x4 == 0x2710 == 0x0 (0x0) +float 0x4 == 0x2710 == 0x0 (0x0) +int 0x4 != 0x2710 == 0x1 (0x1) +__uint 0x4 != 0x2710 == 0x1 (0x1) +char 0x4 != 0x10 == 0x1 (0x1) +__uchar 0x4 != 0x10 == 0x1 (0x1) +__longlong 0x4 != 0x2710 == 0x1 (0x1) +__ulonglong 0x4 != 0x2710 == 0x1 (0x1) +float 0x4 != 0x2710 == 0x1 (0x1) +int 0x4 >= 0x2710 == 0x0 (0x0) +__uint 0x4 >= 0x2710 == 0x0 (0x0) +char 0x4 >= 0x10 == 0x0 (0x0) +__uchar 0x4 >= 0x10 == 0x0 (0x0) +__longlong 0x4 >= 0x2710 == 0x0 (0x0) +__ulonglong 0x4 >= 0x2710 == 0x0 (0x0) +float 0x4 >= 0x2710 == 0x0 (0x0) +int 0x4 / 0x2710 == 0x0 (0x0) +__uint 0x4 / 0x2710 == 0x0 (0x0) +char 0x4 / 0x10 == 0x0 (0x0) +__uchar 0x4 / 0x10 == 0x0 (0x0) +__longlong 0x4 / 0x2710 == 0x0 (0x0) +__ulonglong 0x4 / 0x2710 == 0x0 (0x0) +float 0x4 / 0x2710 == 0x0 (0x0) +int 0x4 % 0x2710 == 0x4 (0x4) +__uint 0x4 % 0x2710 == 0x4 (0x4) +char 0x4 % 0x10 == 0x4 (0x4) +__uchar 0x4 % 0x10 == 0x4 (0x4) +__longlong 0x4 % 0x2710 == 0x4 (0x4) +__ulonglong 0x4 % 0x2710 == 0x4 (0x4) +int xor420x4 xor42 0x2e +__uint xor420x4 xor42 0x2e +char xor420x4 xor42 0x2e +__uchar xor420x4 xor42 0x2e +__longlong xor420x4 xor42 0x2e +__ulonglong xor420x4 xor42 0x2e +int land10x4 land1 0x1 +__uint land10x4 land1 0x1 +char land10x4 land1 0x1 +__uchar land10x4 land1 0x1 +__longlong land10x4 land1 0x1 +__ulonglong land10x4 land1 0x1 +int lor10x4 lor1 0x1 +__uint lor10x4 lor1 0x1 +char lor10x4 lor1 0x1 +__uchar lor10x4 lor1 0x1 +__longlong lor10x4 lor1 0x1 +__ulonglong lor10x4 lor1 0x1 +int and420x4 and42 0x0 +__uint and420x4 and42 0x0 +char and420x4 and42 0x0 +__uchar and420x4 and42 0x0 +__longlong and420x4 and42 0x0 +__ulonglong and420x4 and42 0x0 +int or420x4 or42 0x2e +__uint or420x4 or42 0x2e +char or420x4 or42 0x2e +__uchar or420x4 or42 0x2e +__longlong or420x4 or42 0x2e +__ulonglong or420x4 or42 0x2e +int shl50x4 shl5 0x80 +__uint shl50x4 shl5 0x80 +char shl50x4 shl5 -0x80 +__uchar shl50x4 shl5 0x80 +__longlong shl50x4 shl5 0x80 +__ulonglong shl50x4 shl5 0x80 +int shr50x4 shr5 0x0 +__uint shr50x4 shr5 0x0 +char shr50x4 shr5 0x0 +__uchar shr50x4 shr5 0x0 +__longlong shr50x4 shr5 0x0 +__ulonglong shr50x4 shr5 0x0 +int add420x4 add42 0x2e +__uint add420x4 add42 0x2e +char add420x4 add42 0x2e +__uchar add420x4 add42 0x2e +__longlong add420x4 add42 0x2e +__ulonglong add420x4 add42 0x2e +float add420x4 add42 0x2e +int sub420x4 sub42 -0x26 +__uint sub420x4 sub42 -0x26 +char sub420x4 sub42 -0x26 +__uchar sub420x4 sub42 0xda +__longlong sub420x4 sub42 -0x26 +__ulonglong sub420x4 sub42 -0x26 +float sub420x4 sub42 -0x26 +int mul420x4 mul42 0xa8 +__uint mul420x4 mul42 0xa8 +char mul420x4 mul42 -0x58 +__uchar mul420x4 mul42 0xa8 +__longlong mul420x4 mul42 0xa8 +__ulonglong mul420x4 mul42 0xa8 +float mul420x4 mul42 0xa8 +int lt420x4 lt42 0x1 +__uint lt420x4 lt42 0x1 +char lt420x4 lt42 0x1 +__uchar lt420x4 lt42 0x1 +__longlong lt420x4 lt42 0x1 +__ulonglong lt420x4 lt42 0x1 +float lt420x4 lt42 0x1 +int gt420x4 gt42 0x0 +__uint gt420x4 gt42 0x0 +char gt420x4 gt42 0x0 +__uchar gt420x4 gt42 0x0 +__longlong gt420x4 gt42 0x0 +__ulonglong gt420x4 gt42 0x0 +float gt420x4 gt42 0x0 +int le420x4 le42 0x1 +__uint le420x4 le42 0x1 +char le420x4 le42 0x1 +__uchar le420x4 le42 0x1 +__longlong le420x4 le42 0x1 +__ulonglong le420x4 le42 0x1 +float le420x4 le42 0x1 +int eq420x4 eq42 0x0 +__uint eq420x4 eq42 0x0 +char eq420x4 eq42 0x0 +__uchar eq420x4 eq42 0x0 +__longlong eq420x4 eq42 0x0 +__ulonglong eq420x4 eq42 0x0 +float eq420x4 eq42 0x0 +int ne420x4 ne42 0x1 +__uint ne420x4 ne42 0x1 +char ne420x4 ne42 0x1 +__uchar ne420x4 ne42 0x1 +__longlong ne420x4 ne42 0x1 +__ulonglong ne420x4 ne42 0x1 +float ne420x4 ne42 0x1 +int ge420x4 ge42 0x0 +__uint ge420x4 ge42 0x0 +char ge420x4 ge42 0x0 +__uchar ge420x4 ge42 0x0 +__longlong ge420x4 ge42 0x0 +__ulonglong ge420x4 ge42 0x0 +float ge420x4 ge42 0x0 +int div420x4 div42 0x0 +__uint div420x4 div42 0x0 +char div420x4 div42 0x0 +__uchar div420x4 div42 0x0 +__longlong div420x4 div42 0x0 +__ulonglong div420x4 div42 0x0 +float div420x4 div42 0x0 +int mod230x4 mod23 0x4 +__uint mod230x4 mod23 0x4 +char mod230x4 mod23 0x4 +__uchar mod230x4 mod23 0x4 +__longlong mod230x4 mod23 0x4 +__ulonglong mod230x4 mod23 0x4 +0xfffc * 0xffff == 0x4 +0xfffc / 0xffff == 0x4 +0xfffc % 0xffff == 0x0 +int 0xfffc ^ 0xffff == 0x3 (0x3) +__uint 0xfffc ^ 0xffff == 0x3 (0x3) +char 0xfffc ^ 0xffff == 0x3 (0x3) +__uchar 0xfc ^ 0xff == 0x3 (0x3) +__longlong 0xfffc ^ 0xffff == 0x3 (0x3) +__ulonglong 0xfffc ^ 0xffff == 0x3 (0x3) +int 0xfffc && 0xffff == 0x1 (0x1) +__uint 0xfffc && 0xffff == 0x1 (0x1) +char 0xfffc && 0xffff == 0x1 (0x1) +__uchar 0xfc && 0xff == 0x1 (0x1) +__longlong 0xfffc && 0xffff == 0x1 (0x1) +__ulonglong 0xfffc && 0xffff == 0x1 (0x1) +int 0xfffc || 0xffff == 0x1 (0x1) +__uint 0xfffc || 0xffff == 0x1 (0x1) +char 0xfffc || 0xffff == 0x1 (0x1) +__uchar 0xfc || 0xff == 0x1 (0x1) +__longlong 0xfffc || 0xffff == 0x1 (0x1) +__ulonglong 0xfffc || 0xffff == 0x1 (0x1) +int 0xfffc & 0xffff == -0x4 (0xfffc) +__uint 0xfffc & 0xffff == -0x4 (0xfffc) +char 0xfffc & 0xffff == -0x4 (0xfffc) +__uchar 0xfc & 0xff == 0xfc (0xfc) +__longlong 0xfffc & 0xffff == -0x4 (0xfffc) +__ulonglong 0xfffc & 0xffff == -0x4 (0xfffc) +int 0xfffc | 0xffff == -0x1 (0xffff) +__uint 0xfffc | 0xffff == -0x1 (0xffff) +char 0xfffc | 0xffff == -0x1 (0xffff) +__uchar 0xfc | 0xff == 0xff (0xff) +__longlong 0xfffc | 0xffff == -0x1 (0xffff) +__ulonglong 0xfffc | 0xffff == -0x1 (0xffff) +int 0xfffc << 0x1 == -0x8 (0xfff8) +__uint 0xfffc << 0x1 == -0x8 (0xfff8) +char 0xfffc << 0x1 == -0x8 (0xfff8) +__uchar 0xfc << 0x1 == 0xf8 (0xf8) +__longlong 0xfffc << 0x1 == -0x8 (0xfff8) +__ulonglong 0xfffc << 0x1 == -0x8 (0xfff8) +int 0xfffc >> 0x1 == -0x2 (0xfffe) +__uint 0xfffc >> 0x1 == 0x7ffe (0x7ffe) +char 0xfffc >> 0x1 == -0x2 (0xfffe) +__uchar 0xfc >> 0x1 == 0x7e (0x7e) +__longlong 0xfffc >> 0x1 == -0x2 (0xfffe) +__ulonglong 0xfffc >> 0x1 == -0x2 (0xfffe) +int 0xfffc + 0xffff == -0x5 (0xfffb) +__uint 0xfffc + 0xffff == -0x5 (0xfffb) +char 0xfffc + 0xffff == -0x5 (0xfffb) +__uchar 0xfc + 0xff == 0xfb (0xfb) +__longlong 0xfffc + 0xffff == -0x5 (0xfffb) +__ulonglong 0xfffc + 0xffff == -0x5 (0xfffb) +float 0xfffc + 0xffff == -0x5 (0xfffb) +int 0xfffc - 0xffff == -0x3 (0xfffd) +__uint 0xfffc - 0xffff == -0x3 (0xfffd) +char 0xfffc - 0xffff == -0x3 (0xfffd) +__uchar 0xfc - 0xff == 0xfd (0xfd) +__longlong 0xfffc - 0xffff == -0x3 (0xfffd) +__ulonglong 0xfffc - 0xffff == -0x3 (0xfffd) +float 0xfffc - 0xffff == -0x3 (0xfffd) +int 0xfffc * 0xffff == 0x4 (0x4) +__uint 0xfffc * 0xffff == 0x4 (0x4) +char 0xfffc * 0xffff == 0x4 (0x4) +__uchar 0xfc * 0xff == 0x4 (0x4) +__longlong 0xfffc * 0xffff == 0x4 (0x4) +__ulonglong 0xfffc * 0xffff == 0x4 (0x4) +float 0xfffc * 0xffff == 0x4 (0x4) +int 0xfffc < 0xffff == 0x1 (0x1) +__uint 0xfffc < 0xffff == 0x1 (0x1) +char 0xfffc < 0xffff == 0x1 (0x1) +__uchar 0xfc < 0xff == 0x1 (0x1) +__longlong 0xfffc < 0xffff == 0x1 (0x1) +__ulonglong 0xfffc < 0xffff == 0x1 (0x1) +float 0xfffc < 0xffff == 0x1 (0x1) +int 0xfffc > 0xffff == 0x0 (0x0) +__uint 0xfffc > 0xffff == 0x0 (0x0) +char 0xfffc > 0xffff == 0x0 (0x0) +__uchar 0xfc > 0xff == 0x0 (0x0) +__longlong 0xfffc > 0xffff == 0x0 (0x0) +__ulonglong 0xfffc > 0xffff == 0x0 (0x0) +float 0xfffc > 0xffff == 0x0 (0x0) +int 0xfffc <= 0xffff == 0x1 (0x1) +__uint 0xfffc <= 0xffff == 0x1 (0x1) +char 0xfffc <= 0xffff == 0x1 (0x1) +__uchar 0xfc <= 0xff == 0x1 (0x1) +__longlong 0xfffc <= 0xffff == 0x1 (0x1) +__ulonglong 0xfffc <= 0xffff == 0x1 (0x1) +float 0xfffc <= 0xffff == 0x1 (0x1) +int 0xfffc == 0xffff == 0x0 (0x0) +__uint 0xfffc == 0xffff == 0x0 (0x0) +char 0xfffc == 0xffff == 0x0 (0x0) +__uchar 0xfc == 0xff == 0x0 (0x0) +__longlong 0xfffc == 0xffff == 0x0 (0x0) +__ulonglong 0xfffc == 0xffff == 0x0 (0x0) +float 0xfffc == 0xffff == 0x0 (0x0) +int 0xfffc != 0xffff == 0x1 (0x1) +__uint 0xfffc != 0xffff == 0x1 (0x1) +char 0xfffc != 0xffff == 0x1 (0x1) +__uchar 0xfc != 0xff == 0x1 (0x1) +__longlong 0xfffc != 0xffff == 0x1 (0x1) +__ulonglong 0xfffc != 0xffff == 0x1 (0x1) +float 0xfffc != 0xffff == 0x1 (0x1) +int 0xfffc >= 0xffff == 0x0 (0x0) +__uint 0xfffc >= 0xffff == 0x0 (0x0) +char 0xfffc >= 0xffff == 0x0 (0x0) +__uchar 0xfc >= 0xff == 0x0 (0x0) +__longlong 0xfffc >= 0xffff == 0x0 (0x0) +__ulonglong 0xfffc >= 0xffff == 0x0 (0x0) +float 0xfffc >= 0xffff == 0x0 (0x0) +int 0xfffc / 0xffff == 0x4 (0x4) +__uint 0xfffc / 0xffff == 0x0 (0x0) +char 0xfffc / 0xffff == 0x4 (0x4) +__uchar 0xfc / 0xff == 0x0 (0x0) +__longlong 0xfffc / 0xffff == 0x4 (0x4) +__ulonglong 0xfffc / 0xffff == 0x0 (0x0) +float 0xfffc / 0xffff == 0x4 (0x4) +int 0xfffc % 0xffff == 0x0 (0x0) +__uint 0xfffc % 0xffff == -0x4 (0xfffc) +char 0xfffc % 0xffff == 0x0 (0x0) +__uchar 0xfc % 0xff == 0xfc (0xfc) +__longlong 0xfffc % 0xffff == 0x0 (0x0) +__ulonglong 0xfffc % 0xffff == -0x4 (0xfffc) +0xfffc * 0x1 == -0x4 +0xfffc / 0x1 == -0x4 +0xfffc % 0x1 == 0x0 +int 0xfffc ^ 0x1 == -0x3 (0xfffd) +__uint 0xfffc ^ 0x1 == -0x3 (0xfffd) +char 0xfffc ^ 0x1 == -0x3 (0xfffd) +__uchar 0xfc ^ 0x1 == 0xfd (0xfd) +__longlong 0xfffc ^ 0x1 == -0x3 (0xfffd) +__ulonglong 0xfffc ^ 0x1 == -0x3 (0xfffd) +int 0xfffc && 0x1 == 0x1 (0x1) +__uint 0xfffc && 0x1 == 0x1 (0x1) +char 0xfffc && 0x1 == 0x1 (0x1) +__uchar 0xfc && 0x1 == 0x1 (0x1) +__longlong 0xfffc && 0x1 == 0x1 (0x1) +__ulonglong 0xfffc && 0x1 == 0x1 (0x1) +int 0xfffc || 0x1 == 0x1 (0x1) +__uint 0xfffc || 0x1 == 0x1 (0x1) +char 0xfffc || 0x1 == 0x1 (0x1) +__uchar 0xfc || 0x1 == 0x1 (0x1) +__longlong 0xfffc || 0x1 == 0x1 (0x1) +__ulonglong 0xfffc || 0x1 == 0x1 (0x1) +int 0xfffc & 0x1 == 0x0 (0x0) +__uint 0xfffc & 0x1 == 0x0 (0x0) +char 0xfffc & 0x1 == 0x0 (0x0) +__uchar 0xfc & 0x1 == 0x0 (0x0) +__longlong 0xfffc & 0x1 == 0x0 (0x0) +__ulonglong 0xfffc & 0x1 == 0x0 (0x0) +int 0xfffc | 0x1 == -0x3 (0xfffd) +__uint 0xfffc | 0x1 == -0x3 (0xfffd) +char 0xfffc | 0x1 == -0x3 (0xfffd) +__uchar 0xfc | 0x1 == 0xfd (0xfd) +__longlong 0xfffc | 0x1 == -0x3 (0xfffd) +__ulonglong 0xfffc | 0x1 == -0x3 (0xfffd) +int 0xfffc << 0x2 == -0x10 (0xfff0) +__uint 0xfffc << 0x2 == -0x10 (0xfff0) +char 0xfffc << 0x2 == -0x10 (0xfff0) +__uchar 0xfc << 0x2 == 0xf0 (0xf0) +__longlong 0xfffc << 0x2 == -0x10 (0xfff0) +__ulonglong 0xfffc << 0x2 == -0x10 (0xfff0) +int 0xfffc >> 0x2 == -0x1 (0xffff) +__uint 0xfffc >> 0x2 == 0x3fff (0x3fff) +char 0xfffc >> 0x2 == -0x1 (0xffff) +__uchar 0xfc >> 0x2 == 0x3f (0x3f) +__longlong 0xfffc >> 0x2 == -0x1 (0xffff) +__ulonglong 0xfffc >> 0x2 == -0x1 (0xffff) +int 0xfffc + 0x1 == -0x3 (0xfffd) +__uint 0xfffc + 0x1 == -0x3 (0xfffd) +char 0xfffc + 0x1 == -0x3 (0xfffd) +__uchar 0xfc + 0x1 == 0xfd (0xfd) +__longlong 0xfffc + 0x1 == -0x3 (0xfffd) +__ulonglong 0xfffc + 0x1 == -0x3 (0xfffd) +float 0xfffc + 0x1 == -0x3 (0xfffd) +int 0xfffc - 0x1 == -0x5 (0xfffb) +__uint 0xfffc - 0x1 == -0x5 (0xfffb) +char 0xfffc - 0x1 == -0x5 (0xfffb) +__uchar 0xfc - 0x1 == 0xfb (0xfb) +__longlong 0xfffc - 0x1 == -0x5 (0xfffb) +__ulonglong 0xfffc - 0x1 == -0x5 (0xfffb) +float 0xfffc - 0x1 == -0x5 (0xfffb) +int 0xfffc * 0x1 == -0x4 (0xfffc) +__uint 0xfffc * 0x1 == -0x4 (0xfffc) +char 0xfffc * 0x1 == -0x4 (0xfffc) +__uchar 0xfc * 0x1 == 0xfc (0xfc) +__longlong 0xfffc * 0x1 == -0x4 (0xfffc) +__ulonglong 0xfffc * 0x1 == -0x4 (0xfffc) +float 0xfffc * 0x1 == -0x4 (0xfffc) +int 0xfffc < 0x1 == 0x1 (0x1) +__uint 0xfffc < 0x1 == 0x0 (0x0) +char 0xfffc < 0x1 == 0x1 (0x1) +__uchar 0xfc < 0x1 == 0x0 (0x0) +__longlong 0xfffc < 0x1 == 0x1 (0x1) +__ulonglong 0xfffc < 0x1 == 0x0 (0x0) +float 0xfffc < 0x1 == 0x1 (0x1) +int 0xfffc > 0x1 == 0x0 (0x0) +__uint 0xfffc > 0x1 == 0x1 (0x1) +char 0xfffc > 0x1 == 0x0 (0x0) +__uchar 0xfc > 0x1 == 0x1 (0x1) +__longlong 0xfffc > 0x1 == 0x0 (0x0) +__ulonglong 0xfffc > 0x1 == 0x1 (0x1) +float 0xfffc > 0x1 == 0x0 (0x0) +int 0xfffc <= 0x1 == 0x1 (0x1) +__uint 0xfffc <= 0x1 == 0x0 (0x0) +char 0xfffc <= 0x1 == 0x1 (0x1) +__uchar 0xfc <= 0x1 == 0x0 (0x0) +__longlong 0xfffc <= 0x1 == 0x1 (0x1) +__ulonglong 0xfffc <= 0x1 == 0x0 (0x0) +float 0xfffc <= 0x1 == 0x1 (0x1) +int 0xfffc == 0x1 == 0x0 (0x0) +__uint 0xfffc == 0x1 == 0x0 (0x0) +char 0xfffc == 0x1 == 0x0 (0x0) +__uchar 0xfc == 0x1 == 0x0 (0x0) +__longlong 0xfffc == 0x1 == 0x0 (0x0) +__ulonglong 0xfffc == 0x1 == 0x0 (0x0) +float 0xfffc == 0x1 == 0x0 (0x0) +int 0xfffc != 0x1 == 0x1 (0x1) +__uint 0xfffc != 0x1 == 0x1 (0x1) +char 0xfffc != 0x1 == 0x1 (0x1) +__uchar 0xfc != 0x1 == 0x1 (0x1) +__longlong 0xfffc != 0x1 == 0x1 (0x1) +__ulonglong 0xfffc != 0x1 == 0x1 (0x1) +float 0xfffc != 0x1 == 0x1 (0x1) +int 0xfffc >= 0x1 == 0x0 (0x0) +__uint 0xfffc >= 0x1 == 0x1 (0x1) +char 0xfffc >= 0x1 == 0x0 (0x0) +__uchar 0xfc >= 0x1 == 0x1 (0x1) +__longlong 0xfffc >= 0x1 == 0x0 (0x0) +__ulonglong 0xfffc >= 0x1 == 0x1 (0x1) +float 0xfffc >= 0x1 == 0x0 (0x0) +int 0xfffc / 0x1 == -0x4 (0xfffc) +__uint 0xfffc / 0x1 == -0x4 (0xfffc) +char 0xfffc / 0x1 == -0x4 (0xfffc) +__uchar 0xfc / 0x1 == 0xfc (0xfc) +__longlong 0xfffc / 0x1 == -0x4 (0xfffc) +__ulonglong 0xfffc / 0x1 == -0x4 (0xfffc) +float 0xfffc / 0x1 == -0x4 (0xfffc) +int 0xfffc % 0x1 == 0x0 (0x0) +__uint 0xfffc % 0x1 == 0x0 (0x0) +char 0xfffc % 0x1 == 0x0 (0x0) +__uchar 0xfc % 0x1 == 0x0 (0x0) +__longlong 0xfffc % 0x1 == 0x0 (0x0) +__ulonglong 0xfffc % 0x1 == 0x0 (0x0) +0xfffc * 0x2 == -0x8 +0xfffc / 0x2 == -0x2 +0xfffc % 0x2 == 0x0 +int 0xfffc ^ 0x2 == -0x2 (0xfffe) +__uint 0xfffc ^ 0x2 == -0x2 (0xfffe) +char 0xfffc ^ 0x2 == -0x2 (0xfffe) +__uchar 0xfc ^ 0x2 == 0xfe (0xfe) +__longlong 0xfffc ^ 0x2 == -0x2 (0xfffe) +__ulonglong 0xfffc ^ 0x2 == -0x2 (0xfffe) +int 0xfffc && 0x2 == 0x1 (0x1) +__uint 0xfffc && 0x2 == 0x1 (0x1) +char 0xfffc && 0x2 == 0x1 (0x1) +__uchar 0xfc && 0x2 == 0x1 (0x1) +__longlong 0xfffc && 0x2 == 0x1 (0x1) +__ulonglong 0xfffc && 0x2 == 0x1 (0x1) +int 0xfffc || 0x2 == 0x1 (0x1) +__uint 0xfffc || 0x2 == 0x1 (0x1) +char 0xfffc || 0x2 == 0x1 (0x1) +__uchar 0xfc || 0x2 == 0x1 (0x1) +__longlong 0xfffc || 0x2 == 0x1 (0x1) +__ulonglong 0xfffc || 0x2 == 0x1 (0x1) +int 0xfffc & 0x2 == 0x0 (0x0) +__uint 0xfffc & 0x2 == 0x0 (0x0) +char 0xfffc & 0x2 == 0x0 (0x0) +__uchar 0xfc & 0x2 == 0x0 (0x0) +__longlong 0xfffc & 0x2 == 0x0 (0x0) +__ulonglong 0xfffc & 0x2 == 0x0 (0x0) +int 0xfffc | 0x2 == -0x2 (0xfffe) +__uint 0xfffc | 0x2 == -0x2 (0xfffe) +char 0xfffc | 0x2 == -0x2 (0xfffe) +__uchar 0xfc | 0x2 == 0xfe (0xfe) +__longlong 0xfffc | 0x2 == -0x2 (0xfffe) +__ulonglong 0xfffc | 0x2 == -0x2 (0xfffe) +int 0xfffc << 0x3 == -0x20 (0xffe0) +__uint 0xfffc << 0x3 == -0x20 (0xffe0) +char 0xfffc << 0x3 == -0x20 (0xffe0) +__uchar 0xfc << 0x3 == 0xe0 (0xe0) +__longlong 0xfffc << 0x3 == -0x20 (0xffe0) +__ulonglong 0xfffc << 0x3 == -0x20 (0xffe0) +int 0xfffc >> 0x3 == -0x1 (0xffff) +__uint 0xfffc >> 0x3 == 0x1fff (0x1fff) +char 0xfffc >> 0x3 == -0x1 (0xffff) +__uchar 0xfc >> 0x3 == 0x1f (0x1f) +__longlong 0xfffc >> 0x3 == -0x1 (0xffff) +__ulonglong 0xfffc >> 0x3 == -0x1 (0xffff) +int 0xfffc + 0x2 == -0x2 (0xfffe) +__uint 0xfffc + 0x2 == -0x2 (0xfffe) +char 0xfffc + 0x2 == -0x2 (0xfffe) +__uchar 0xfc + 0x2 == 0xfe (0xfe) +__longlong 0xfffc + 0x2 == -0x2 (0xfffe) +__ulonglong 0xfffc + 0x2 == -0x2 (0xfffe) +float 0xfffc + 0x2 == -0x2 (0xfffe) +int 0xfffc - 0x2 == -0x6 (0xfffa) +__uint 0xfffc - 0x2 == -0x6 (0xfffa) +char 0xfffc - 0x2 == -0x6 (0xfffa) +__uchar 0xfc - 0x2 == 0xfa (0xfa) +__longlong 0xfffc - 0x2 == -0x6 (0xfffa) +__ulonglong 0xfffc - 0x2 == -0x6 (0xfffa) +float 0xfffc - 0x2 == -0x6 (0xfffa) +int 0xfffc * 0x2 == -0x8 (0xfff8) +__uint 0xfffc * 0x2 == -0x8 (0xfff8) +char 0xfffc * 0x2 == -0x8 (0xfff8) +__uchar 0xfc * 0x2 == 0xf8 (0xf8) +__longlong 0xfffc * 0x2 == -0x8 (0xfff8) +__ulonglong 0xfffc * 0x2 == -0x8 (0xfff8) +float 0xfffc * 0x2 == -0x8 (0xfff8) +int 0xfffc < 0x2 == 0x1 (0x1) +__uint 0xfffc < 0x2 == 0x0 (0x0) +char 0xfffc < 0x2 == 0x1 (0x1) +__uchar 0xfc < 0x2 == 0x0 (0x0) +__longlong 0xfffc < 0x2 == 0x1 (0x1) +__ulonglong 0xfffc < 0x2 == 0x0 (0x0) +float 0xfffc < 0x2 == 0x1 (0x1) +int 0xfffc > 0x2 == 0x0 (0x0) +__uint 0xfffc > 0x2 == 0x1 (0x1) +char 0xfffc > 0x2 == 0x0 (0x0) +__uchar 0xfc > 0x2 == 0x1 (0x1) +__longlong 0xfffc > 0x2 == 0x0 (0x0) +__ulonglong 0xfffc > 0x2 == 0x1 (0x1) +float 0xfffc > 0x2 == 0x0 (0x0) +int 0xfffc <= 0x2 == 0x1 (0x1) +__uint 0xfffc <= 0x2 == 0x0 (0x0) +char 0xfffc <= 0x2 == 0x1 (0x1) +__uchar 0xfc <= 0x2 == 0x0 (0x0) +__longlong 0xfffc <= 0x2 == 0x1 (0x1) +__ulonglong 0xfffc <= 0x2 == 0x0 (0x0) +float 0xfffc <= 0x2 == 0x1 (0x1) +int 0xfffc == 0x2 == 0x0 (0x0) +__uint 0xfffc == 0x2 == 0x0 (0x0) +char 0xfffc == 0x2 == 0x0 (0x0) +__uchar 0xfc == 0x2 == 0x0 (0x0) +__longlong 0xfffc == 0x2 == 0x0 (0x0) +__ulonglong 0xfffc == 0x2 == 0x0 (0x0) +float 0xfffc == 0x2 == 0x0 (0x0) +int 0xfffc != 0x2 == 0x1 (0x1) +__uint 0xfffc != 0x2 == 0x1 (0x1) +char 0xfffc != 0x2 == 0x1 (0x1) +__uchar 0xfc != 0x2 == 0x1 (0x1) +__longlong 0xfffc != 0x2 == 0x1 (0x1) +__ulonglong 0xfffc != 0x2 == 0x1 (0x1) +float 0xfffc != 0x2 == 0x1 (0x1) +int 0xfffc >= 0x2 == 0x0 (0x0) +__uint 0xfffc >= 0x2 == 0x1 (0x1) +char 0xfffc >= 0x2 == 0x0 (0x0) +__uchar 0xfc >= 0x2 == 0x1 (0x1) +__longlong 0xfffc >= 0x2 == 0x0 (0x0) +__ulonglong 0xfffc >= 0x2 == 0x1 (0x1) +float 0xfffc >= 0x2 == 0x0 (0x0) +int 0xfffc / 0x2 == -0x2 (0xfffe) +__uint 0xfffc / 0x2 == 0x7ffe (0x7ffe) +char 0xfffc / 0x2 == -0x2 (0xfffe) +__uchar 0xfc / 0x2 == 0x7e (0x7e) +__longlong 0xfffc / 0x2 == -0x2 (0xfffe) +__ulonglong 0xfffc / 0x2 == -0x2 (0xfffe) +float 0xfffc / 0x2 == -0x2 (0xfffe) +int 0xfffc % 0x2 == 0x0 (0x0) +__uint 0xfffc % 0x2 == 0x0 (0x0) +char 0xfffc % 0x2 == 0x0 (0x0) +__uchar 0xfc % 0x2 == 0x0 (0x0) +__longlong 0xfffc % 0x2 == 0x0 (0x0) +__ulonglong 0xfffc % 0x2 == 0x0 (0x0) +0xfffc * 0xfffe == 0x8 +0xfffc / 0xfffe == 0x2 +0xfffc % 0xfffe == 0x0 +int 0xfffc ^ 0xfffe == 0x2 (0x2) +__uint 0xfffc ^ 0xfffe == 0x2 (0x2) +char 0xfffc ^ 0xfffe == 0x2 (0x2) +__uchar 0xfc ^ 0xfe == 0x2 (0x2) +__longlong 0xfffc ^ 0xfffe == 0x2 (0x2) +__ulonglong 0xfffc ^ 0xfffe == 0x2 (0x2) +int 0xfffc && 0xfffe == 0x1 (0x1) +__uint 0xfffc && 0xfffe == 0x1 (0x1) +char 0xfffc && 0xfffe == 0x1 (0x1) +__uchar 0xfc && 0xfe == 0x1 (0x1) +__longlong 0xfffc && 0xfffe == 0x1 (0x1) +__ulonglong 0xfffc && 0xfffe == 0x1 (0x1) +int 0xfffc || 0xfffe == 0x1 (0x1) +__uint 0xfffc || 0xfffe == 0x1 (0x1) +char 0xfffc || 0xfffe == 0x1 (0x1) +__uchar 0xfc || 0xfe == 0x1 (0x1) +__longlong 0xfffc || 0xfffe == 0x1 (0x1) +__ulonglong 0xfffc || 0xfffe == 0x1 (0x1) +int 0xfffc & 0xfffe == -0x4 (0xfffc) +__uint 0xfffc & 0xfffe == -0x4 (0xfffc) +char 0xfffc & 0xfffe == -0x4 (0xfffc) +__uchar 0xfc & 0xfe == 0xfc (0xfc) +__longlong 0xfffc & 0xfffe == -0x4 (0xfffc) +__ulonglong 0xfffc & 0xfffe == -0x4 (0xfffc) +int 0xfffc | 0xfffe == -0x2 (0xfffe) +__uint 0xfffc | 0xfffe == -0x2 (0xfffe) +char 0xfffc | 0xfffe == -0x2 (0xfffe) +__uchar 0xfc | 0xfe == 0xfe (0xfe) +__longlong 0xfffc | 0xfffe == -0x2 (0xfffe) +__ulonglong 0xfffc | 0xfffe == -0x2 (0xfffe) +int 0xfffc << 0x4 == -0x40 (0xffc0) +__uint 0xfffc << 0x4 == -0x40 (0xffc0) +char 0xfffc << 0x4 == -0x40 (0xffc0) +__uchar 0xfc << 0x4 == 0xc0 (0xc0) +__longlong 0xfffc << 0x4 == -0x40 (0xffc0) +__ulonglong 0xfffc << 0x4 == -0x40 (0xffc0) +int 0xfffc >> 0x4 == -0x1 (0xffff) +__uint 0xfffc >> 0x4 == 0xfff (0xfff) +char 0xfffc >> 0x4 == -0x1 (0xffff) +__uchar 0xfc >> 0x4 == 0xf (0xf) +__longlong 0xfffc >> 0x4 == -0x1 (0xffff) +__ulonglong 0xfffc >> 0x4 == -0x1 (0xffff) +int 0xfffc + 0xfffe == -0x6 (0xfffa) +__uint 0xfffc + 0xfffe == -0x6 (0xfffa) +char 0xfffc + 0xfffe == -0x6 (0xfffa) +__uchar 0xfc + 0xfe == 0xfa (0xfa) +__longlong 0xfffc + 0xfffe == -0x6 (0xfffa) +__ulonglong 0xfffc + 0xfffe == -0x6 (0xfffa) +float 0xfffc + 0xfffe == -0x6 (0xfffa) +int 0xfffc - 0xfffe == -0x2 (0xfffe) +__uint 0xfffc - 0xfffe == -0x2 (0xfffe) +char 0xfffc - 0xfffe == -0x2 (0xfffe) +__uchar 0xfc - 0xfe == 0xfe (0xfe) +__longlong 0xfffc - 0xfffe == -0x2 (0xfffe) +__ulonglong 0xfffc - 0xfffe == -0x2 (0xfffe) +float 0xfffc - 0xfffe == -0x2 (0xfffe) +int 0xfffc * 0xfffe == 0x8 (0x8) +__uint 0xfffc * 0xfffe == 0x8 (0x8) +char 0xfffc * 0xfffe == 0x8 (0x8) +__uchar 0xfc * 0xfe == 0x8 (0x8) +__longlong 0xfffc * 0xfffe == 0x8 (0x8) +__ulonglong 0xfffc * 0xfffe == 0x8 (0x8) +float 0xfffc * 0xfffe == 0x8 (0x8) +int 0xfffc < 0xfffe == 0x1 (0x1) +__uint 0xfffc < 0xfffe == 0x1 (0x1) +char 0xfffc < 0xfffe == 0x1 (0x1) +__uchar 0xfc < 0xfe == 0x1 (0x1) +__longlong 0xfffc < 0xfffe == 0x1 (0x1) +__ulonglong 0xfffc < 0xfffe == 0x1 (0x1) +float 0xfffc < 0xfffe == 0x1 (0x1) +int 0xfffc > 0xfffe == 0x0 (0x0) +__uint 0xfffc > 0xfffe == 0x0 (0x0) +char 0xfffc > 0xfffe == 0x0 (0x0) +__uchar 0xfc > 0xfe == 0x0 (0x0) +__longlong 0xfffc > 0xfffe == 0x0 (0x0) +__ulonglong 0xfffc > 0xfffe == 0x0 (0x0) +float 0xfffc > 0xfffe == 0x0 (0x0) +int 0xfffc <= 0xfffe == 0x1 (0x1) +__uint 0xfffc <= 0xfffe == 0x1 (0x1) +char 0xfffc <= 0xfffe == 0x1 (0x1) +__uchar 0xfc <= 0xfe == 0x1 (0x1) +__longlong 0xfffc <= 0xfffe == 0x1 (0x1) +__ulonglong 0xfffc <= 0xfffe == 0x1 (0x1) +float 0xfffc <= 0xfffe == 0x1 (0x1) +int 0xfffc == 0xfffe == 0x0 (0x0) +__uint 0xfffc == 0xfffe == 0x0 (0x0) +char 0xfffc == 0xfffe == 0x0 (0x0) +__uchar 0xfc == 0xfe == 0x0 (0x0) +__longlong 0xfffc == 0xfffe == 0x0 (0x0) +__ulonglong 0xfffc == 0xfffe == 0x0 (0x0) +float 0xfffc == 0xfffe == 0x0 (0x0) +int 0xfffc != 0xfffe == 0x1 (0x1) +__uint 0xfffc != 0xfffe == 0x1 (0x1) +char 0xfffc != 0xfffe == 0x1 (0x1) +__uchar 0xfc != 0xfe == 0x1 (0x1) +__longlong 0xfffc != 0xfffe == 0x1 (0x1) +__ulonglong 0xfffc != 0xfffe == 0x1 (0x1) +float 0xfffc != 0xfffe == 0x1 (0x1) +int 0xfffc >= 0xfffe == 0x0 (0x0) +__uint 0xfffc >= 0xfffe == 0x0 (0x0) +char 0xfffc >= 0xfffe == 0x0 (0x0) +__uchar 0xfc >= 0xfe == 0x0 (0x0) +__longlong 0xfffc >= 0xfffe == 0x0 (0x0) +__ulonglong 0xfffc >= 0xfffe == 0x0 (0x0) +float 0xfffc >= 0xfffe == 0x0 (0x0) +int 0xfffc / 0xfffe == 0x2 (0x2) +__uint 0xfffc / 0xfffe == 0x0 (0x0) +char 0xfffc / 0xfffe == 0x2 (0x2) +__uchar 0xfc / 0xfe == 0x0 (0x0) +__longlong 0xfffc / 0xfffe == 0x2 (0x2) +__ulonglong 0xfffc / 0xfffe == 0x0 (0x0) +float 0xfffc / 0xfffe == 0x2 (0x2) +int 0xfffc % 0xfffe == 0x0 (0x0) +__uint 0xfffc % 0xfffe == -0x4 (0xfffc) +char 0xfffc % 0xfffe == 0x0 (0x0) +__uchar 0xfc % 0xfe == 0xfc (0xfc) +__longlong 0xfffc % 0xfffe == 0x0 (0x0) +__ulonglong 0xfffc % 0xfffe == -0x4 (0xfffc) +0xfffc * 0x4 == -0x10 +0xfffc / 0x4 == -0x1 +0xfffc % 0x4 == 0x0 +int 0xfffc ^ 0x4 == -0x8 (0xfff8) +__uint 0xfffc ^ 0x4 == -0x8 (0xfff8) +char 0xfffc ^ 0x4 == -0x8 (0xfff8) +__uchar 0xfc ^ 0x4 == 0xf8 (0xf8) +__longlong 0xfffc ^ 0x4 == -0x8 (0xfff8) +__ulonglong 0xfffc ^ 0x4 == -0x8 (0xfff8) +int 0xfffc && 0x4 == 0x1 (0x1) +__uint 0xfffc && 0x4 == 0x1 (0x1) +char 0xfffc && 0x4 == 0x1 (0x1) +__uchar 0xfc && 0x4 == 0x1 (0x1) +__longlong 0xfffc && 0x4 == 0x1 (0x1) +__ulonglong 0xfffc && 0x4 == 0x1 (0x1) +int 0xfffc || 0x4 == 0x1 (0x1) +__uint 0xfffc || 0x4 == 0x1 (0x1) +char 0xfffc || 0x4 == 0x1 (0x1) +__uchar 0xfc || 0x4 == 0x1 (0x1) +__longlong 0xfffc || 0x4 == 0x1 (0x1) +__ulonglong 0xfffc || 0x4 == 0x1 (0x1) +int 0xfffc & 0x4 == 0x4 (0x4) +__uint 0xfffc & 0x4 == 0x4 (0x4) +char 0xfffc & 0x4 == 0x4 (0x4) +__uchar 0xfc & 0x4 == 0x4 (0x4) +__longlong 0xfffc & 0x4 == 0x4 (0x4) +__ulonglong 0xfffc & 0x4 == 0x4 (0x4) +int 0xfffc | 0x4 == -0x4 (0xfffc) +__uint 0xfffc | 0x4 == -0x4 (0xfffc) +char 0xfffc | 0x4 == -0x4 (0xfffc) +__uchar 0xfc | 0x4 == 0xfc (0xfc) +__longlong 0xfffc | 0x4 == -0x4 (0xfffc) +__ulonglong 0xfffc | 0x4 == -0x4 (0xfffc) +int 0xfffc << 0x5 == -0x80 (0xff80) +__uint 0xfffc << 0x5 == -0x80 (0xff80) +char 0xfffc << 0x5 == -0x80 (0xff80) +__uchar 0xfc << 0x5 == 0x80 (0x80) +__longlong 0xfffc << 0x5 == -0x80 (0xff80) +__ulonglong 0xfffc << 0x5 == -0x80 (0xff80) +int 0xfffc >> 0x5 == -0x1 (0xffff) +__uint 0xfffc >> 0x5 == 0x7ff (0x7ff) +char 0xfffc >> 0x5 == -0x1 (0xffff) +__uchar 0xfc >> 0x5 == 0x7 (0x7) +__longlong 0xfffc >> 0x5 == -0x1 (0xffff) +__ulonglong 0xfffc >> 0x5 == -0x1 (0xffff) +int 0xfffc + 0x4 == 0x0 (0x0) +__uint 0xfffc + 0x4 == 0x0 (0x0) +char 0xfffc + 0x4 == 0x0 (0x0) +__uchar 0xfc + 0x4 == 0x0 (0x0) +__longlong 0xfffc + 0x4 == 0x0 (0x0) +__ulonglong 0xfffc + 0x4 == 0x0 (0x0) +float 0xfffc + 0x4 == 0x0 (0x0) +int 0xfffc - 0x4 == -0x8 (0xfff8) +__uint 0xfffc - 0x4 == -0x8 (0xfff8) +char 0xfffc - 0x4 == -0x8 (0xfff8) +__uchar 0xfc - 0x4 == 0xf8 (0xf8) +__longlong 0xfffc - 0x4 == -0x8 (0xfff8) +__ulonglong 0xfffc - 0x4 == -0x8 (0xfff8) +float 0xfffc - 0x4 == -0x8 (0xfff8) +int 0xfffc * 0x4 == -0x10 (0xfff0) +__uint 0xfffc * 0x4 == -0x10 (0xfff0) +char 0xfffc * 0x4 == -0x10 (0xfff0) +__uchar 0xfc * 0x4 == 0xf0 (0xf0) +__longlong 0xfffc * 0x4 == -0x10 (0xfff0) +__ulonglong 0xfffc * 0x4 == -0x10 (0xfff0) +float 0xfffc * 0x4 == -0x10 (0xfff0) +int 0xfffc < 0x4 == 0x1 (0x1) +__uint 0xfffc < 0x4 == 0x0 (0x0) +char 0xfffc < 0x4 == 0x1 (0x1) +__uchar 0xfc < 0x4 == 0x0 (0x0) +__longlong 0xfffc < 0x4 == 0x1 (0x1) +__ulonglong 0xfffc < 0x4 == 0x0 (0x0) +float 0xfffc < 0x4 == 0x1 (0x1) +int 0xfffc > 0x4 == 0x0 (0x0) +__uint 0xfffc > 0x4 == 0x1 (0x1) +char 0xfffc > 0x4 == 0x0 (0x0) +__uchar 0xfc > 0x4 == 0x1 (0x1) +__longlong 0xfffc > 0x4 == 0x0 (0x0) +__ulonglong 0xfffc > 0x4 == 0x1 (0x1) +float 0xfffc > 0x4 == 0x0 (0x0) +int 0xfffc <= 0x4 == 0x1 (0x1) +__uint 0xfffc <= 0x4 == 0x0 (0x0) +char 0xfffc <= 0x4 == 0x1 (0x1) +__uchar 0xfc <= 0x4 == 0x0 (0x0) +__longlong 0xfffc <= 0x4 == 0x1 (0x1) +__ulonglong 0xfffc <= 0x4 == 0x0 (0x0) +float 0xfffc <= 0x4 == 0x1 (0x1) +int 0xfffc == 0x4 == 0x0 (0x0) +__uint 0xfffc == 0x4 == 0x0 (0x0) +char 0xfffc == 0x4 == 0x0 (0x0) +__uchar 0xfc == 0x4 == 0x0 (0x0) +__longlong 0xfffc == 0x4 == 0x0 (0x0) +__ulonglong 0xfffc == 0x4 == 0x0 (0x0) +float 0xfffc == 0x4 == 0x0 (0x0) +int 0xfffc != 0x4 == 0x1 (0x1) +__uint 0xfffc != 0x4 == 0x1 (0x1) +char 0xfffc != 0x4 == 0x1 (0x1) +__uchar 0xfc != 0x4 == 0x1 (0x1) +__longlong 0xfffc != 0x4 == 0x1 (0x1) +__ulonglong 0xfffc != 0x4 == 0x1 (0x1) +float 0xfffc != 0x4 == 0x1 (0x1) +int 0xfffc >= 0x4 == 0x0 (0x0) +__uint 0xfffc >= 0x4 == 0x1 (0x1) +char 0xfffc >= 0x4 == 0x0 (0x0) +__uchar 0xfc >= 0x4 == 0x1 (0x1) +__longlong 0xfffc >= 0x4 == 0x0 (0x0) +__ulonglong 0xfffc >= 0x4 == 0x1 (0x1) +float 0xfffc >= 0x4 == 0x0 (0x0) +int 0xfffc / 0x4 == -0x1 (0xffff) +__uint 0xfffc / 0x4 == 0x3fff (0x3fff) +char 0xfffc / 0x4 == -0x1 (0xffff) +__uchar 0xfc / 0x4 == 0x3f (0x3f) +__longlong 0xfffc / 0x4 == -0x1 (0xffff) +__ulonglong 0xfffc / 0x4 == -0x1 (0xffff) +float 0xfffc / 0x4 == -0x1 (0xffff) +int 0xfffc % 0x4 == 0x0 (0x0) +__uint 0xfffc % 0x4 == 0x0 (0x0) +char 0xfffc % 0x4 == 0x0 (0x0) +__uchar 0xfc % 0x4 == 0x0 (0x0) +__longlong 0xfffc % 0x4 == 0x0 (0x0) +__ulonglong 0xfffc % 0x4 == 0x0 (0x0) +0xfffc * 0xfffc == 0x10 +0xfffc / 0xfffc == 0x1 +0xfffc % 0xfffc == 0x0 +int 0xfffc ^ 0xfffc == 0x0 (0x0) +__uint 0xfffc ^ 0xfffc == 0x0 (0x0) +char 0xfffc ^ 0xfffc == 0x0 (0x0) +__uchar 0xfc ^ 0xfc == 0x0 (0x0) +__longlong 0xfffc ^ 0xfffc == 0x0 (0x0) +__ulonglong 0xfffc ^ 0xfffc == 0x0 (0x0) +int 0xfffc && 0xfffc == 0x1 (0x1) +__uint 0xfffc && 0xfffc == 0x1 (0x1) +char 0xfffc && 0xfffc == 0x1 (0x1) +__uchar 0xfc && 0xfc == 0x1 (0x1) +__longlong 0xfffc && 0xfffc == 0x1 (0x1) +__ulonglong 0xfffc && 0xfffc == 0x1 (0x1) +int 0xfffc || 0xfffc == 0x1 (0x1) +__uint 0xfffc || 0xfffc == 0x1 (0x1) +char 0xfffc || 0xfffc == 0x1 (0x1) +__uchar 0xfc || 0xfc == 0x1 (0x1) +__longlong 0xfffc || 0xfffc == 0x1 (0x1) +__ulonglong 0xfffc || 0xfffc == 0x1 (0x1) +int 0xfffc & 0xfffc == -0x4 (0xfffc) +__uint 0xfffc & 0xfffc == -0x4 (0xfffc) +char 0xfffc & 0xfffc == -0x4 (0xfffc) +__uchar 0xfc & 0xfc == 0xfc (0xfc) +__longlong 0xfffc & 0xfffc == -0x4 (0xfffc) +__ulonglong 0xfffc & 0xfffc == -0x4 (0xfffc) +int 0xfffc | 0xfffc == -0x4 (0xfffc) +__uint 0xfffc | 0xfffc == -0x4 (0xfffc) +char 0xfffc | 0xfffc == -0x4 (0xfffc) +__uchar 0xfc | 0xfc == 0xfc (0xfc) +__longlong 0xfffc | 0xfffc == -0x4 (0xfffc) +__ulonglong 0xfffc | 0xfffc == -0x4 (0xfffc) +int 0xfffc << 0x6 == -0x100 (0xff00) +__uint 0xfffc << 0x6 == -0x100 (0xff00) +char 0xfffc << 0x6 == 0x0 (0x0) +__uchar 0xfc << 0x6 == 0x0 (0x0) +__longlong 0xfffc << 0x6 == -0x100 (0xff00) +__ulonglong 0xfffc << 0x6 == -0x100 (0xff00) +int 0xfffc >> 0x6 == -0x1 (0xffff) +__uint 0xfffc >> 0x6 == 0x3ff (0x3ff) +char 0xfffc >> 0x6 == -0x1 (0xffff) +__uchar 0xfc >> 0x6 == 0x3 (0x3) +__longlong 0xfffc >> 0x6 == -0x1 (0xffff) +__ulonglong 0xfffc >> 0x6 == -0x1 (0xffff) +int 0xfffc + 0xfffc == -0x8 (0xfff8) +__uint 0xfffc + 0xfffc == -0x8 (0xfff8) +char 0xfffc + 0xfffc == -0x8 (0xfff8) +__uchar 0xfc + 0xfc == 0xf8 (0xf8) +__longlong 0xfffc + 0xfffc == -0x8 (0xfff8) +__ulonglong 0xfffc + 0xfffc == -0x8 (0xfff8) +float 0xfffc + 0xfffc == -0x8 (0xfff8) +int 0xfffc - 0xfffc == 0x0 (0x0) +__uint 0xfffc - 0xfffc == 0x0 (0x0) +char 0xfffc - 0xfffc == 0x0 (0x0) +__uchar 0xfc - 0xfc == 0x0 (0x0) +__longlong 0xfffc - 0xfffc == 0x0 (0x0) +__ulonglong 0xfffc - 0xfffc == 0x0 (0x0) +float 0xfffc - 0xfffc == 0x0 (0x0) +int 0xfffc * 0xfffc == 0x10 (0x10) +__uint 0xfffc * 0xfffc == 0x10 (0x10) +char 0xfffc * 0xfffc == 0x10 (0x10) +__uchar 0xfc * 0xfc == 0x10 (0x10) +__longlong 0xfffc * 0xfffc == 0x10 (0x10) +__ulonglong 0xfffc * 0xfffc == 0x10 (0x10) +float 0xfffc * 0xfffc == 0x10 (0x10) +int 0xfffc < 0xfffc == 0x0 (0x0) +__uint 0xfffc < 0xfffc == 0x0 (0x0) +char 0xfffc < 0xfffc == 0x0 (0x0) +__uchar 0xfc < 0xfc == 0x0 (0x0) +__longlong 0xfffc < 0xfffc == 0x0 (0x0) +__ulonglong 0xfffc < 0xfffc == 0x0 (0x0) +float 0xfffc < 0xfffc == 0x0 (0x0) +int 0xfffc > 0xfffc == 0x0 (0x0) +__uint 0xfffc > 0xfffc == 0x0 (0x0) +char 0xfffc > 0xfffc == 0x0 (0x0) +__uchar 0xfc > 0xfc == 0x0 (0x0) +__longlong 0xfffc > 0xfffc == 0x0 (0x0) +__ulonglong 0xfffc > 0xfffc == 0x0 (0x0) +float 0xfffc > 0xfffc == 0x0 (0x0) +int 0xfffc <= 0xfffc == 0x1 (0x1) +__uint 0xfffc <= 0xfffc == 0x1 (0x1) +char 0xfffc <= 0xfffc == 0x1 (0x1) +__uchar 0xfc <= 0xfc == 0x1 (0x1) +__longlong 0xfffc <= 0xfffc == 0x1 (0x1) +__ulonglong 0xfffc <= 0xfffc == 0x1 (0x1) +float 0xfffc <= 0xfffc == 0x1 (0x1) +int 0xfffc == 0xfffc == 0x1 (0x1) +__uint 0xfffc == 0xfffc == 0x1 (0x1) +char 0xfffc == 0xfffc == 0x1 (0x1) +__uchar 0xfc == 0xfc == 0x1 (0x1) +__longlong 0xfffc == 0xfffc == 0x1 (0x1) +__ulonglong 0xfffc == 0xfffc == 0x1 (0x1) +float 0xfffc == 0xfffc == 0x1 (0x1) +int 0xfffc != 0xfffc == 0x0 (0x0) +__uint 0xfffc != 0xfffc == 0x0 (0x0) +char 0xfffc != 0xfffc == 0x0 (0x0) +__uchar 0xfc != 0xfc == 0x0 (0x0) +__longlong 0xfffc != 0xfffc == 0x0 (0x0) +__ulonglong 0xfffc != 0xfffc == 0x0 (0x0) +float 0xfffc != 0xfffc == 0x0 (0x0) +int 0xfffc >= 0xfffc == 0x1 (0x1) +__uint 0xfffc >= 0xfffc == 0x1 (0x1) +char 0xfffc >= 0xfffc == 0x1 (0x1) +__uchar 0xfc >= 0xfc == 0x1 (0x1) +__longlong 0xfffc >= 0xfffc == 0x1 (0x1) +__ulonglong 0xfffc >= 0xfffc == 0x1 (0x1) +float 0xfffc >= 0xfffc == 0x1 (0x1) +int 0xfffc / 0xfffc == 0x1 (0x1) +__uint 0xfffc / 0xfffc == 0x1 (0x1) +char 0xfffc / 0xfffc == 0x1 (0x1) +__uchar 0xfc / 0xfc == 0x1 (0x1) +__longlong 0xfffc / 0xfffc == 0x1 (0x1) +__ulonglong 0xfffc / 0xfffc == 0x1 (0x1) +float 0xfffc / 0xfffc == 0x1 (0x1) +int 0xfffc % 0xfffc == 0x0 (0x0) +__uint 0xfffc % 0xfffc == 0x0 (0x0) +char 0xfffc % 0xfffc == 0x0 (0x0) +__uchar 0xfc % 0xfc == 0x0 (0x0) +__longlong 0xfffc % 0xfffc == 0x0 (0x0) +__ulonglong 0xfffc % 0xfffc == 0x0 (0x0) +0xfffc * 0xa == -0x28 +0xfffc / 0xa == 0x0 +0xfffc % 0xa == -0x4 +int 0xfffc ^ 0xa == -0xa (0xfff6) +__uint 0xfffc ^ 0xa == -0xa (0xfff6) +char 0xfffc ^ 0xa == -0xa (0xfff6) +__uchar 0xfc ^ 0xa == 0xf6 (0xf6) +__longlong 0xfffc ^ 0xa == -0xa (0xfff6) +__ulonglong 0xfffc ^ 0xa == -0xa (0xfff6) +int 0xfffc && 0xa == 0x1 (0x1) +__uint 0xfffc && 0xa == 0x1 (0x1) +char 0xfffc && 0xa == 0x1 (0x1) +__uchar 0xfc && 0xa == 0x1 (0x1) +__longlong 0xfffc && 0xa == 0x1 (0x1) +__ulonglong 0xfffc && 0xa == 0x1 (0x1) +int 0xfffc || 0xa == 0x1 (0x1) +__uint 0xfffc || 0xa == 0x1 (0x1) +char 0xfffc || 0xa == 0x1 (0x1) +__uchar 0xfc || 0xa == 0x1 (0x1) +__longlong 0xfffc || 0xa == 0x1 (0x1) +__ulonglong 0xfffc || 0xa == 0x1 (0x1) +int 0xfffc & 0xa == 0x8 (0x8) +__uint 0xfffc & 0xa == 0x8 (0x8) +char 0xfffc & 0xa == 0x8 (0x8) +__uchar 0xfc & 0xa == 0x8 (0x8) +__longlong 0xfffc & 0xa == 0x8 (0x8) +__ulonglong 0xfffc & 0xa == 0x8 (0x8) +int 0xfffc | 0xa == -0x2 (0xfffe) +__uint 0xfffc | 0xa == -0x2 (0xfffe) +char 0xfffc | 0xa == -0x2 (0xfffe) +__uchar 0xfc | 0xa == 0xfe (0xfe) +__longlong 0xfffc | 0xa == -0x2 (0xfffe) +__ulonglong 0xfffc | 0xa == -0x2 (0xfffe) +int 0xfffc << 0x7 == -0x200 (0xfe00) +__uint 0xfffc << 0x7 == -0x200 (0xfe00) +char 0xfffc << 0x7 == 0x0 (0x0) +__uchar 0xfc << 0x7 == 0x0 (0x0) +__longlong 0xfffc << 0x7 == -0x200 (0xfe00) +__ulonglong 0xfffc << 0x7 == -0x200 (0xfe00) +int 0xfffc >> 0x7 == -0x1 (0xffff) +__uint 0xfffc >> 0x7 == 0x1ff (0x1ff) +char 0xfffc >> 0x7 == -0x1 (0xffff) +__uchar 0xfc >> 0x7 == 0x1 (0x1) +__longlong 0xfffc >> 0x7 == -0x1 (0xffff) +__ulonglong 0xfffc >> 0x7 == -0x1 (0xffff) +int 0xfffc + 0xa == 0x6 (0x6) +__uint 0xfffc + 0xa == 0x6 (0x6) +char 0xfffc + 0xa == 0x6 (0x6) +__uchar 0xfc + 0xa == 0x6 (0x6) +__longlong 0xfffc + 0xa == 0x6 (0x6) +__ulonglong 0xfffc + 0xa == 0x6 (0x6) +float 0xfffc + 0xa == 0x6 (0x6) +int 0xfffc - 0xa == -0xe (0xfff2) +__uint 0xfffc - 0xa == -0xe (0xfff2) +char 0xfffc - 0xa == -0xe (0xfff2) +__uchar 0xfc - 0xa == 0xf2 (0xf2) +__longlong 0xfffc - 0xa == -0xe (0xfff2) +__ulonglong 0xfffc - 0xa == -0xe (0xfff2) +float 0xfffc - 0xa == -0xe (0xfff2) +int 0xfffc * 0xa == -0x28 (0xffd8) +__uint 0xfffc * 0xa == -0x28 (0xffd8) +char 0xfffc * 0xa == -0x28 (0xffd8) +__uchar 0xfc * 0xa == 0xd8 (0xd8) +__longlong 0xfffc * 0xa == -0x28 (0xffd8) +__ulonglong 0xfffc * 0xa == -0x28 (0xffd8) +float 0xfffc * 0xa == -0x28 (0xffd8) +int 0xfffc < 0xa == 0x1 (0x1) +__uint 0xfffc < 0xa == 0x0 (0x0) +char 0xfffc < 0xa == 0x1 (0x1) +__uchar 0xfc < 0xa == 0x0 (0x0) +__longlong 0xfffc < 0xa == 0x1 (0x1) +__ulonglong 0xfffc < 0xa == 0x0 (0x0) +float 0xfffc < 0xa == 0x1 (0x1) +int 0xfffc > 0xa == 0x0 (0x0) +__uint 0xfffc > 0xa == 0x1 (0x1) +char 0xfffc > 0xa == 0x0 (0x0) +__uchar 0xfc > 0xa == 0x1 (0x1) +__longlong 0xfffc > 0xa == 0x0 (0x0) +__ulonglong 0xfffc > 0xa == 0x1 (0x1) +float 0xfffc > 0xa == 0x0 (0x0) +int 0xfffc <= 0xa == 0x1 (0x1) +__uint 0xfffc <= 0xa == 0x0 (0x0) +char 0xfffc <= 0xa == 0x1 (0x1) +__uchar 0xfc <= 0xa == 0x0 (0x0) +__longlong 0xfffc <= 0xa == 0x1 (0x1) +__ulonglong 0xfffc <= 0xa == 0x0 (0x0) +float 0xfffc <= 0xa == 0x1 (0x1) +int 0xfffc == 0xa == 0x0 (0x0) +__uint 0xfffc == 0xa == 0x0 (0x0) +char 0xfffc == 0xa == 0x0 (0x0) +__uchar 0xfc == 0xa == 0x0 (0x0) +__longlong 0xfffc == 0xa == 0x0 (0x0) +__ulonglong 0xfffc == 0xa == 0x0 (0x0) +float 0xfffc == 0xa == 0x0 (0x0) +int 0xfffc != 0xa == 0x1 (0x1) +__uint 0xfffc != 0xa == 0x1 (0x1) +char 0xfffc != 0xa == 0x1 (0x1) +__uchar 0xfc != 0xa == 0x1 (0x1) +__longlong 0xfffc != 0xa == 0x1 (0x1) +__ulonglong 0xfffc != 0xa == 0x1 (0x1) +float 0xfffc != 0xa == 0x1 (0x1) +int 0xfffc >= 0xa == 0x0 (0x0) +__uint 0xfffc >= 0xa == 0x1 (0x1) +char 0xfffc >= 0xa == 0x0 (0x0) +__uchar 0xfc >= 0xa == 0x1 (0x1) +__longlong 0xfffc >= 0xa == 0x0 (0x0) +__ulonglong 0xfffc >= 0xa == 0x1 (0x1) +float 0xfffc >= 0xa == 0x0 (0x0) +int 0xfffc / 0xa == 0x0 (0x0) +__uint 0xfffc / 0xa == 0x1999 (0x1999) +char 0xfffc / 0xa == 0x0 (0x0) +__uchar 0xfc / 0xa == 0x19 (0x19) +__longlong 0xfffc / 0xa == 0x0 (0x0) +__ulonglong 0xfffc / 0xa == -0x6667 (0x9999) +float 0xfffc / 0xa == 0x0 (0x0) +int 0xfffc % 0xa == -0x4 (0xfffc) +__uint 0xfffc % 0xa == 0x2 (0x2) +char 0xfffc % 0xa == -0x4 (0xfffc) +__uchar 0xfc % 0xa == 0x2 (0x2) +__longlong 0xfffc % 0xa == -0x4 (0xfffc) +__ulonglong 0xfffc % 0xa == 0x2 (0x2) +0xfffc * 0xfff6 == 0x28 +0xfffc / 0xfff6 == 0x0 +0xfffc % 0xfff6 == -0x4 +int 0xfffc ^ 0xfff6 == 0xa (0xa) +__uint 0xfffc ^ 0xfff6 == 0xa (0xa) +char 0xfffc ^ 0xfff6 == 0xa (0xa) +__uchar 0xfc ^ 0xf6 == 0xa (0xa) +__longlong 0xfffc ^ 0xfff6 == 0xa (0xa) +__ulonglong 0xfffc ^ 0xfff6 == 0xa (0xa) +int 0xfffc && 0xfff6 == 0x1 (0x1) +__uint 0xfffc && 0xfff6 == 0x1 (0x1) +char 0xfffc && 0xfff6 == 0x1 (0x1) +__uchar 0xfc && 0xf6 == 0x1 (0x1) +__longlong 0xfffc && 0xfff6 == 0x1 (0x1) +__ulonglong 0xfffc && 0xfff6 == 0x1 (0x1) +int 0xfffc || 0xfff6 == 0x1 (0x1) +__uint 0xfffc || 0xfff6 == 0x1 (0x1) +char 0xfffc || 0xfff6 == 0x1 (0x1) +__uchar 0xfc || 0xf6 == 0x1 (0x1) +__longlong 0xfffc || 0xfff6 == 0x1 (0x1) +__ulonglong 0xfffc || 0xfff6 == 0x1 (0x1) +int 0xfffc & 0xfff6 == -0xc (0xfff4) +__uint 0xfffc & 0xfff6 == -0xc (0xfff4) +char 0xfffc & 0xfff6 == -0xc (0xfff4) +__uchar 0xfc & 0xf6 == 0xf4 (0xf4) +__longlong 0xfffc & 0xfff6 == -0xc (0xfff4) +__ulonglong 0xfffc & 0xfff6 == -0xc (0xfff4) +int 0xfffc | 0xfff6 == -0x2 (0xfffe) +__uint 0xfffc | 0xfff6 == -0x2 (0xfffe) +char 0xfffc | 0xfff6 == -0x2 (0xfffe) +__uchar 0xfc | 0xf6 == 0xfe (0xfe) +__longlong 0xfffc | 0xfff6 == -0x2 (0xfffe) +__ulonglong 0xfffc | 0xfff6 == -0x2 (0xfffe) +int 0xfffc << 0x8 == -0x400 (0xfc00) +__uint 0xfffc << 0x8 == -0x400 (0xfc00) +char 0xfffc << 0x8 == 0x0 (0x0) +__uchar 0xfc << 0x8 == 0x0 (0x0) +__longlong 0xfffc << 0x8 == -0x400 (0xfc00) +__ulonglong 0xfffc << 0x8 == -0x400 (0xfc00) +int 0xfffc >> 0x8 == -0x1 (0xffff) +__uint 0xfffc >> 0x8 == 0xff (0xff) +char 0xfffc >> 0x8 == -0x1 (0xffff) +__uchar 0xfc >> 0x8 == 0x0 (0x0) +__longlong 0xfffc >> 0x8 == -0x1 (0xffff) +__ulonglong 0xfffc >> 0x8 == -0x1 (0xffff) +int 0xfffc + 0xfff6 == -0xe (0xfff2) +__uint 0xfffc + 0xfff6 == -0xe (0xfff2) +char 0xfffc + 0xfff6 == -0xe (0xfff2) +__uchar 0xfc + 0xf6 == 0xf2 (0xf2) +__longlong 0xfffc + 0xfff6 == -0xe (0xfff2) +__ulonglong 0xfffc + 0xfff6 == -0xe (0xfff2) +float 0xfffc + 0xfff6 == -0xe (0xfff2) +int 0xfffc - 0xfff6 == 0x6 (0x6) +__uint 0xfffc - 0xfff6 == 0x6 (0x6) +char 0xfffc - 0xfff6 == 0x6 (0x6) +__uchar 0xfc - 0xf6 == 0x6 (0x6) +__longlong 0xfffc - 0xfff6 == 0x6 (0x6) +__ulonglong 0xfffc - 0xfff6 == 0x6 (0x6) +float 0xfffc - 0xfff6 == 0x6 (0x6) +int 0xfffc * 0xfff6 == 0x28 (0x28) +__uint 0xfffc * 0xfff6 == 0x28 (0x28) +char 0xfffc * 0xfff6 == 0x28 (0x28) +__uchar 0xfc * 0xf6 == 0x28 (0x28) +__longlong 0xfffc * 0xfff6 == 0x28 (0x28) +__ulonglong 0xfffc * 0xfff6 == 0x28 (0x28) +float 0xfffc * 0xfff6 == 0x28 (0x28) +int 0xfffc < 0xfff6 == 0x0 (0x0) +__uint 0xfffc < 0xfff6 == 0x0 (0x0) +char 0xfffc < 0xfff6 == 0x0 (0x0) +__uchar 0xfc < 0xf6 == 0x0 (0x0) +__longlong 0xfffc < 0xfff6 == 0x0 (0x0) +__ulonglong 0xfffc < 0xfff6 == 0x0 (0x0) +float 0xfffc < 0xfff6 == 0x0 (0x0) +int 0xfffc > 0xfff6 == 0x1 (0x1) +__uint 0xfffc > 0xfff6 == 0x1 (0x1) +char 0xfffc > 0xfff6 == 0x1 (0x1) +__uchar 0xfc > 0xf6 == 0x1 (0x1) +__longlong 0xfffc > 0xfff6 == 0x1 (0x1) +__ulonglong 0xfffc > 0xfff6 == 0x1 (0x1) +float 0xfffc > 0xfff6 == 0x1 (0x1) +int 0xfffc <= 0xfff6 == 0x0 (0x0) +__uint 0xfffc <= 0xfff6 == 0x0 (0x0) +char 0xfffc <= 0xfff6 == 0x0 (0x0) +__uchar 0xfc <= 0xf6 == 0x0 (0x0) +__longlong 0xfffc <= 0xfff6 == 0x0 (0x0) +__ulonglong 0xfffc <= 0xfff6 == 0x0 (0x0) +float 0xfffc <= 0xfff6 == 0x0 (0x0) +int 0xfffc == 0xfff6 == 0x0 (0x0) +__uint 0xfffc == 0xfff6 == 0x0 (0x0) +char 0xfffc == 0xfff6 == 0x0 (0x0) +__uchar 0xfc == 0xf6 == 0x0 (0x0) +__longlong 0xfffc == 0xfff6 == 0x0 (0x0) +__ulonglong 0xfffc == 0xfff6 == 0x0 (0x0) +float 0xfffc == 0xfff6 == 0x0 (0x0) +int 0xfffc != 0xfff6 == 0x1 (0x1) +__uint 0xfffc != 0xfff6 == 0x1 (0x1) +char 0xfffc != 0xfff6 == 0x1 (0x1) +__uchar 0xfc != 0xf6 == 0x1 (0x1) +__longlong 0xfffc != 0xfff6 == 0x1 (0x1) +__ulonglong 0xfffc != 0xfff6 == 0x1 (0x1) +float 0xfffc != 0xfff6 == 0x1 (0x1) +int 0xfffc >= 0xfff6 == 0x1 (0x1) +__uint 0xfffc >= 0xfff6 == 0x1 (0x1) +char 0xfffc >= 0xfff6 == 0x1 (0x1) +__uchar 0xfc >= 0xf6 == 0x1 (0x1) +__longlong 0xfffc >= 0xfff6 == 0x1 (0x1) +__ulonglong 0xfffc >= 0xfff6 == 0x1 (0x1) +float 0xfffc >= 0xfff6 == 0x1 (0x1) +int 0xfffc / 0xfff6 == 0x0 (0x0) +__uint 0xfffc / 0xfff6 == 0x1 (0x1) +char 0xfffc / 0xfff6 == 0x0 (0x0) +__uchar 0xfc / 0xf6 == 0x1 (0x1) +__longlong 0xfffc / 0xfff6 == 0x0 (0x0) +__ulonglong 0xfffc / 0xfff6 == 0x1 (0x1) +float 0xfffc / 0xfff6 == 0x0 (0x0) +int 0xfffc % 0xfff6 == -0x4 (0xfffc) +__uint 0xfffc % 0xfff6 == 0x6 (0x6) +char 0xfffc % 0xfff6 == -0x4 (0xfffc) +__uchar 0xfc % 0xf6 == 0x6 (0x6) +__longlong 0xfffc % 0xfff6 == -0x4 (0xfffc) +__ulonglong 0xfffc % 0xfff6 == 0x6 (0x6) +0xfffc * 0x5 == -0x14 +0xfffc / 0x5 == 0x0 +0xfffc % 0x5 == -0x4 +int 0xfffc ^ 0x5 == -0x7 (0xfff9) +__uint 0xfffc ^ 0x5 == -0x7 (0xfff9) +char 0xfffc ^ 0x5 == -0x7 (0xfff9) +__uchar 0xfc ^ 0x5 == 0xf9 (0xf9) +__longlong 0xfffc ^ 0x5 == -0x7 (0xfff9) +__ulonglong 0xfffc ^ 0x5 == -0x7 (0xfff9) +int 0xfffc && 0x5 == 0x1 (0x1) +__uint 0xfffc && 0x5 == 0x1 (0x1) +char 0xfffc && 0x5 == 0x1 (0x1) +__uchar 0xfc && 0x5 == 0x1 (0x1) +__longlong 0xfffc && 0x5 == 0x1 (0x1) +__ulonglong 0xfffc && 0x5 == 0x1 (0x1) +int 0xfffc || 0x5 == 0x1 (0x1) +__uint 0xfffc || 0x5 == 0x1 (0x1) +char 0xfffc || 0x5 == 0x1 (0x1) +__uchar 0xfc || 0x5 == 0x1 (0x1) +__longlong 0xfffc || 0x5 == 0x1 (0x1) +__ulonglong 0xfffc || 0x5 == 0x1 (0x1) +int 0xfffc & 0x5 == 0x4 (0x4) +__uint 0xfffc & 0x5 == 0x4 (0x4) +char 0xfffc & 0x5 == 0x4 (0x4) +__uchar 0xfc & 0x5 == 0x4 (0x4) +__longlong 0xfffc & 0x5 == 0x4 (0x4) +__ulonglong 0xfffc & 0x5 == 0x4 (0x4) +int 0xfffc | 0x5 == -0x3 (0xfffd) +__uint 0xfffc | 0x5 == -0x3 (0xfffd) +char 0xfffc | 0x5 == -0x3 (0xfffd) +__uchar 0xfc | 0x5 == 0xfd (0xfd) +__longlong 0xfffc | 0x5 == -0x3 (0xfffd) +__ulonglong 0xfffc | 0x5 == -0x3 (0xfffd) +int 0xfffc << 0x9 == -0x800 (0xf800) +__uint 0xfffc << 0x9 == -0x800 (0xf800) +char 0xfffc << 0x9 == 0x0 (0x0) +__uchar 0xfc << 0x9 == 0x0 (0x0) +__longlong 0xfffc << 0x9 == -0x800 (0xf800) +__ulonglong 0xfffc << 0x9 == -0x800 (0xf800) +int 0xfffc >> 0x9 == -0x1 (0xffff) +__uint 0xfffc >> 0x9 == 0x7f (0x7f) +char 0xfffc >> 0x9 == -0x1 (0xffff) +__uchar 0xfc >> 0x9 == 0x0 (0x0) +__longlong 0xfffc >> 0x9 == -0x1 (0xffff) +__ulonglong 0xfffc >> 0x9 == -0x1 (0xffff) +int 0xfffc + 0x5 == 0x1 (0x1) +__uint 0xfffc + 0x5 == 0x1 (0x1) +char 0xfffc + 0x5 == 0x1 (0x1) +__uchar 0xfc + 0x5 == 0x1 (0x1) +__longlong 0xfffc + 0x5 == 0x1 (0x1) +__ulonglong 0xfffc + 0x5 == 0x1 (0x1) +float 0xfffc + 0x5 == 0x1 (0x1) +int 0xfffc - 0x5 == -0x9 (0xfff7) +__uint 0xfffc - 0x5 == -0x9 (0xfff7) +char 0xfffc - 0x5 == -0x9 (0xfff7) +__uchar 0xfc - 0x5 == 0xf7 (0xf7) +__longlong 0xfffc - 0x5 == -0x9 (0xfff7) +__ulonglong 0xfffc - 0x5 == -0x9 (0xfff7) +float 0xfffc - 0x5 == -0x9 (0xfff7) +int 0xfffc * 0x5 == -0x14 (0xffec) +__uint 0xfffc * 0x5 == -0x14 (0xffec) +char 0xfffc * 0x5 == -0x14 (0xffec) +__uchar 0xfc * 0x5 == 0xec (0xec) +__longlong 0xfffc * 0x5 == -0x14 (0xffec) +__ulonglong 0xfffc * 0x5 == -0x14 (0xffec) +float 0xfffc * 0x5 == -0x14 (0xffec) +int 0xfffc < 0x5 == 0x1 (0x1) +__uint 0xfffc < 0x5 == 0x0 (0x0) +char 0xfffc < 0x5 == 0x1 (0x1) +__uchar 0xfc < 0x5 == 0x0 (0x0) +__longlong 0xfffc < 0x5 == 0x1 (0x1) +__ulonglong 0xfffc < 0x5 == 0x0 (0x0) +float 0xfffc < 0x5 == 0x1 (0x1) +int 0xfffc > 0x5 == 0x0 (0x0) +__uint 0xfffc > 0x5 == 0x1 (0x1) +char 0xfffc > 0x5 == 0x0 (0x0) +__uchar 0xfc > 0x5 == 0x1 (0x1) +__longlong 0xfffc > 0x5 == 0x0 (0x0) +__ulonglong 0xfffc > 0x5 == 0x1 (0x1) +float 0xfffc > 0x5 == 0x0 (0x0) +int 0xfffc <= 0x5 == 0x1 (0x1) +__uint 0xfffc <= 0x5 == 0x0 (0x0) +char 0xfffc <= 0x5 == 0x1 (0x1) +__uchar 0xfc <= 0x5 == 0x0 (0x0) +__longlong 0xfffc <= 0x5 == 0x1 (0x1) +__ulonglong 0xfffc <= 0x5 == 0x0 (0x0) +float 0xfffc <= 0x5 == 0x1 (0x1) +int 0xfffc == 0x5 == 0x0 (0x0) +__uint 0xfffc == 0x5 == 0x0 (0x0) +char 0xfffc == 0x5 == 0x0 (0x0) +__uchar 0xfc == 0x5 == 0x0 (0x0) +__longlong 0xfffc == 0x5 == 0x0 (0x0) +__ulonglong 0xfffc == 0x5 == 0x0 (0x0) +float 0xfffc == 0x5 == 0x0 (0x0) +int 0xfffc != 0x5 == 0x1 (0x1) +__uint 0xfffc != 0x5 == 0x1 (0x1) +char 0xfffc != 0x5 == 0x1 (0x1) +__uchar 0xfc != 0x5 == 0x1 (0x1) +__longlong 0xfffc != 0x5 == 0x1 (0x1) +__ulonglong 0xfffc != 0x5 == 0x1 (0x1) +float 0xfffc != 0x5 == 0x1 (0x1) +int 0xfffc >= 0x5 == 0x0 (0x0) +__uint 0xfffc >= 0x5 == 0x1 (0x1) +char 0xfffc >= 0x5 == 0x0 (0x0) +__uchar 0xfc >= 0x5 == 0x1 (0x1) +__longlong 0xfffc >= 0x5 == 0x0 (0x0) +__ulonglong 0xfffc >= 0x5 == 0x1 (0x1) +float 0xfffc >= 0x5 == 0x0 (0x0) +int 0xfffc / 0x5 == 0x0 (0x0) +__uint 0xfffc / 0x5 == 0x3332 (0x3332) +char 0xfffc / 0x5 == 0x0 (0x0) +__uchar 0xfc / 0x5 == 0x32 (0x32) +__longlong 0xfffc / 0x5 == 0x0 (0x0) +__ulonglong 0xfffc / 0x5 == 0x3332 (0x3332) +float 0xfffc / 0x5 == 0x0 (0x0) +int 0xfffc % 0x5 == -0x4 (0xfffc) +__uint 0xfffc % 0x5 == 0x2 (0x2) +char 0xfffc % 0x5 == -0x4 (0xfffc) +__uchar 0xfc % 0x5 == 0x2 (0x2) +__longlong 0xfffc % 0x5 == -0x4 (0xfffc) +__ulonglong 0xfffc % 0x5 == 0x2 (0x2) +0xfffc * 0x7 == -0x1c +0xfffc / 0x7 == 0x0 +0xfffc % 0x7 == -0x4 +int 0xfffc ^ 0x7 == -0x5 (0xfffb) +__uint 0xfffc ^ 0x7 == -0x5 (0xfffb) +char 0xfffc ^ 0x7 == -0x5 (0xfffb) +__uchar 0xfc ^ 0x7 == 0xfb (0xfb) +__longlong 0xfffc ^ 0x7 == -0x5 (0xfffb) +__ulonglong 0xfffc ^ 0x7 == -0x5 (0xfffb) +int 0xfffc && 0x7 == 0x1 (0x1) +__uint 0xfffc && 0x7 == 0x1 (0x1) +char 0xfffc && 0x7 == 0x1 (0x1) +__uchar 0xfc && 0x7 == 0x1 (0x1) +__longlong 0xfffc && 0x7 == 0x1 (0x1) +__ulonglong 0xfffc && 0x7 == 0x1 (0x1) +int 0xfffc || 0x7 == 0x1 (0x1) +__uint 0xfffc || 0x7 == 0x1 (0x1) +char 0xfffc || 0x7 == 0x1 (0x1) +__uchar 0xfc || 0x7 == 0x1 (0x1) +__longlong 0xfffc || 0x7 == 0x1 (0x1) +__ulonglong 0xfffc || 0x7 == 0x1 (0x1) +int 0xfffc & 0x7 == 0x4 (0x4) +__uint 0xfffc & 0x7 == 0x4 (0x4) +char 0xfffc & 0x7 == 0x4 (0x4) +__uchar 0xfc & 0x7 == 0x4 (0x4) +__longlong 0xfffc & 0x7 == 0x4 (0x4) +__ulonglong 0xfffc & 0x7 == 0x4 (0x4) +int 0xfffc | 0x7 == -0x1 (0xffff) +__uint 0xfffc | 0x7 == -0x1 (0xffff) +char 0xfffc | 0x7 == -0x1 (0xffff) +__uchar 0xfc | 0x7 == 0xff (0xff) +__longlong 0xfffc | 0x7 == -0x1 (0xffff) +__ulonglong 0xfffc | 0x7 == -0x1 (0xffff) +int 0xfffc << 0xa == -0x1000 (0xf000) +__uint 0xfffc << 0xa == -0x1000 (0xf000) +char 0xfffc << 0xa == 0x0 (0x0) +__uchar 0xfc << 0xa == 0x0 (0x0) +__longlong 0xfffc << 0xa == -0x1000 (0xf000) +__ulonglong 0xfffc << 0xa == -0x1000 (0xf000) +int 0xfffc >> 0xa == -0x1 (0xffff) +__uint 0xfffc >> 0xa == 0x3f (0x3f) +char 0xfffc >> 0xa == -0x1 (0xffff) +__uchar 0xfc >> 0xa == 0x0 (0x0) +__longlong 0xfffc >> 0xa == -0x1 (0xffff) +__ulonglong 0xfffc >> 0xa == -0x1 (0xffff) +int 0xfffc + 0x7 == 0x3 (0x3) +__uint 0xfffc + 0x7 == 0x3 (0x3) +char 0xfffc + 0x7 == 0x3 (0x3) +__uchar 0xfc + 0x7 == 0x3 (0x3) +__longlong 0xfffc + 0x7 == 0x3 (0x3) +__ulonglong 0xfffc + 0x7 == 0x3 (0x3) +float 0xfffc + 0x7 == 0x3 (0x3) +int 0xfffc - 0x7 == -0xb (0xfff5) +__uint 0xfffc - 0x7 == -0xb (0xfff5) +char 0xfffc - 0x7 == -0xb (0xfff5) +__uchar 0xfc - 0x7 == 0xf5 (0xf5) +__longlong 0xfffc - 0x7 == -0xb (0xfff5) +__ulonglong 0xfffc - 0x7 == -0xb (0xfff5) +float 0xfffc - 0x7 == -0xb (0xfff5) +int 0xfffc * 0x7 == -0x1c (0xffe4) +__uint 0xfffc * 0x7 == -0x1c (0xffe4) +char 0xfffc * 0x7 == -0x1c (0xffe4) +__uchar 0xfc * 0x7 == 0xe4 (0xe4) +__longlong 0xfffc * 0x7 == -0x1c (0xffe4) +__ulonglong 0xfffc * 0x7 == -0x1c (0xffe4) +float 0xfffc * 0x7 == -0x1c (0xffe4) +int 0xfffc < 0x7 == 0x1 (0x1) +__uint 0xfffc < 0x7 == 0x0 (0x0) +char 0xfffc < 0x7 == 0x1 (0x1) +__uchar 0xfc < 0x7 == 0x0 (0x0) +__longlong 0xfffc < 0x7 == 0x1 (0x1) +__ulonglong 0xfffc < 0x7 == 0x0 (0x0) +float 0xfffc < 0x7 == 0x1 (0x1) +int 0xfffc > 0x7 == 0x0 (0x0) +__uint 0xfffc > 0x7 == 0x1 (0x1) +char 0xfffc > 0x7 == 0x0 (0x0) +__uchar 0xfc > 0x7 == 0x1 (0x1) +__longlong 0xfffc > 0x7 == 0x0 (0x0) +__ulonglong 0xfffc > 0x7 == 0x1 (0x1) +float 0xfffc > 0x7 == 0x0 (0x0) +int 0xfffc <= 0x7 == 0x1 (0x1) +__uint 0xfffc <= 0x7 == 0x0 (0x0) +char 0xfffc <= 0x7 == 0x1 (0x1) +__uchar 0xfc <= 0x7 == 0x0 (0x0) +__longlong 0xfffc <= 0x7 == 0x1 (0x1) +__ulonglong 0xfffc <= 0x7 == 0x0 (0x0) +float 0xfffc <= 0x7 == 0x1 (0x1) +int 0xfffc == 0x7 == 0x0 (0x0) +__uint 0xfffc == 0x7 == 0x0 (0x0) +char 0xfffc == 0x7 == 0x0 (0x0) +__uchar 0xfc == 0x7 == 0x0 (0x0) +__longlong 0xfffc == 0x7 == 0x0 (0x0) +__ulonglong 0xfffc == 0x7 == 0x0 (0x0) +float 0xfffc == 0x7 == 0x0 (0x0) +int 0xfffc != 0x7 == 0x1 (0x1) +__uint 0xfffc != 0x7 == 0x1 (0x1) +char 0xfffc != 0x7 == 0x1 (0x1) +__uchar 0xfc != 0x7 == 0x1 (0x1) +__longlong 0xfffc != 0x7 == 0x1 (0x1) +__ulonglong 0xfffc != 0x7 == 0x1 (0x1) +float 0xfffc != 0x7 == 0x1 (0x1) +int 0xfffc >= 0x7 == 0x0 (0x0) +__uint 0xfffc >= 0x7 == 0x1 (0x1) +char 0xfffc >= 0x7 == 0x0 (0x0) +__uchar 0xfc >= 0x7 == 0x1 (0x1) +__longlong 0xfffc >= 0x7 == 0x0 (0x0) +__ulonglong 0xfffc >= 0x7 == 0x1 (0x1) +float 0xfffc >= 0x7 == 0x0 (0x0) +int 0xfffc / 0x7 == 0x0 (0x0) +__uint 0xfffc / 0x7 == 0x2491 (0x2491) +char 0xfffc / 0x7 == 0x0 (0x0) +__uchar 0xfc / 0x7 == 0x24 (0x24) +__longlong 0xfffc / 0x7 == 0x0 (0x0) +__ulonglong 0xfffc / 0x7 == 0x4924 (0x4924) +float 0xfffc / 0x7 == 0x0 (0x0) +int 0xfffc % 0x7 == -0x4 (0xfffc) +__uint 0xfffc % 0x7 == 0x5 (0x5) +char 0xfffc % 0x7 == -0x4 (0xfffc) +__uchar 0xfc % 0x7 == 0x0 (0x0) +__longlong 0xfffc % 0x7 == -0x4 (0xfffc) +__ulonglong 0xfffc % 0x7 == 0x0 (0x0) +0xfffc * 0x2a == -0xa8 +0xfffc / 0x2a == 0x0 +0xfffc % 0x2a == -0x4 +int 0xfffc ^ 0x2a == -0x2a (0xffd6) +__uint 0xfffc ^ 0x2a == -0x2a (0xffd6) +char 0xfffc ^ 0x2a == -0x2a (0xffd6) +__uchar 0xfc ^ 0x2a == 0xd6 (0xd6) +__longlong 0xfffc ^ 0x2a == -0x2a (0xffd6) +__ulonglong 0xfffc ^ 0x2a == -0x2a (0xffd6) +int 0xfffc && 0x2a == 0x1 (0x1) +__uint 0xfffc && 0x2a == 0x1 (0x1) +char 0xfffc && 0x2a == 0x1 (0x1) +__uchar 0xfc && 0x2a == 0x1 (0x1) +__longlong 0xfffc && 0x2a == 0x1 (0x1) +__ulonglong 0xfffc && 0x2a == 0x1 (0x1) +int 0xfffc || 0x2a == 0x1 (0x1) +__uint 0xfffc || 0x2a == 0x1 (0x1) +char 0xfffc || 0x2a == 0x1 (0x1) +__uchar 0xfc || 0x2a == 0x1 (0x1) +__longlong 0xfffc || 0x2a == 0x1 (0x1) +__ulonglong 0xfffc || 0x2a == 0x1 (0x1) +int 0xfffc & 0x2a == 0x28 (0x28) +__uint 0xfffc & 0x2a == 0x28 (0x28) +char 0xfffc & 0x2a == 0x28 (0x28) +__uchar 0xfc & 0x2a == 0x28 (0x28) +__longlong 0xfffc & 0x2a == 0x28 (0x28) +__ulonglong 0xfffc & 0x2a == 0x28 (0x28) +int 0xfffc | 0x2a == -0x2 (0xfffe) +__uint 0xfffc | 0x2a == -0x2 (0xfffe) +char 0xfffc | 0x2a == -0x2 (0xfffe) +__uchar 0xfc | 0x2a == 0xfe (0xfe) +__longlong 0xfffc | 0x2a == -0x2 (0xfffe) +__ulonglong 0xfffc | 0x2a == -0x2 (0xfffe) +int 0xfffc << 0xc == -0x4000 (0xc000) +__uint 0xfffc << 0xc == -0x4000 (0xc000) +char 0xfffc << 0xc == 0x0 (0x0) +__uchar 0xfc << 0xc == 0x0 (0x0) +__longlong 0xfffc << 0xc == -0x4000 (0xc000) +__ulonglong 0xfffc << 0xc == -0x4000 (0xc000) +int 0xfffc >> 0xc == -0x1 (0xffff) +__uint 0xfffc >> 0xc == 0xf (0xf) +char 0xfffc >> 0xc == -0x1 (0xffff) +__uchar 0xfc >> 0xc == 0x0 (0x0) +__longlong 0xfffc >> 0xc == -0x1 (0xffff) +__ulonglong 0xfffc >> 0xc == -0x1 (0xffff) +int 0xfffc + 0x2a == 0x26 (0x26) +__uint 0xfffc + 0x2a == 0x26 (0x26) +char 0xfffc + 0x2a == 0x26 (0x26) +__uchar 0xfc + 0x2a == 0x26 (0x26) +__longlong 0xfffc + 0x2a == 0x26 (0x26) +__ulonglong 0xfffc + 0x2a == 0x26 (0x26) +float 0xfffc + 0x2a == 0x26 (0x26) +int 0xfffc - 0x2a == -0x2e (0xffd2) +__uint 0xfffc - 0x2a == -0x2e (0xffd2) +char 0xfffc - 0x2a == -0x2e (0xffd2) +__uchar 0xfc - 0x2a == 0xd2 (0xd2) +__longlong 0xfffc - 0x2a == -0x2e (0xffd2) +__ulonglong 0xfffc - 0x2a == -0x2e (0xffd2) +float 0xfffc - 0x2a == -0x2e (0xffd2) +int 0xfffc * 0x2a == -0xa8 (0xff58) +__uint 0xfffc * 0x2a == -0xa8 (0xff58) +char 0xfffc * 0x2a == 0x58 (0x58) +__uchar 0xfc * 0x2a == 0x58 (0x58) +__longlong 0xfffc * 0x2a == -0xa8 (0xff58) +__ulonglong 0xfffc * 0x2a == -0xa8 (0xff58) +float 0xfffc * 0x2a == -0xa8 (0xff58) +int 0xfffc < 0x2a == 0x1 (0x1) +__uint 0xfffc < 0x2a == 0x0 (0x0) +char 0xfffc < 0x2a == 0x1 (0x1) +__uchar 0xfc < 0x2a == 0x0 (0x0) +__longlong 0xfffc < 0x2a == 0x1 (0x1) +__ulonglong 0xfffc < 0x2a == 0x0 (0x0) +float 0xfffc < 0x2a == 0x1 (0x1) +int 0xfffc > 0x2a == 0x0 (0x0) +__uint 0xfffc > 0x2a == 0x1 (0x1) +char 0xfffc > 0x2a == 0x0 (0x0) +__uchar 0xfc > 0x2a == 0x1 (0x1) +__longlong 0xfffc > 0x2a == 0x0 (0x0) +__ulonglong 0xfffc > 0x2a == 0x1 (0x1) +float 0xfffc > 0x2a == 0x0 (0x0) +int 0xfffc <= 0x2a == 0x1 (0x1) +__uint 0xfffc <= 0x2a == 0x0 (0x0) +char 0xfffc <= 0x2a == 0x1 (0x1) +__uchar 0xfc <= 0x2a == 0x0 (0x0) +__longlong 0xfffc <= 0x2a == 0x1 (0x1) +__ulonglong 0xfffc <= 0x2a == 0x0 (0x0) +float 0xfffc <= 0x2a == 0x1 (0x1) +int 0xfffc == 0x2a == 0x0 (0x0) +__uint 0xfffc == 0x2a == 0x0 (0x0) +char 0xfffc == 0x2a == 0x0 (0x0) +__uchar 0xfc == 0x2a == 0x0 (0x0) +__longlong 0xfffc == 0x2a == 0x0 (0x0) +__ulonglong 0xfffc == 0x2a == 0x0 (0x0) +float 0xfffc == 0x2a == 0x0 (0x0) +int 0xfffc != 0x2a == 0x1 (0x1) +__uint 0xfffc != 0x2a == 0x1 (0x1) +char 0xfffc != 0x2a == 0x1 (0x1) +__uchar 0xfc != 0x2a == 0x1 (0x1) +__longlong 0xfffc != 0x2a == 0x1 (0x1) +__ulonglong 0xfffc != 0x2a == 0x1 (0x1) +float 0xfffc != 0x2a == 0x1 (0x1) +int 0xfffc >= 0x2a == 0x0 (0x0) +__uint 0xfffc >= 0x2a == 0x1 (0x1) +char 0xfffc >= 0x2a == 0x0 (0x0) +__uchar 0xfc >= 0x2a == 0x1 (0x1) +__longlong 0xfffc >= 0x2a == 0x0 (0x0) +__ulonglong 0xfffc >= 0x2a == 0x1 (0x1) +float 0xfffc >= 0x2a == 0x0 (0x0) +int 0xfffc / 0x2a == 0x0 (0x0) +__uint 0xfffc / 0x2a == 0x618 (0x618) +char 0xfffc / 0x2a == 0x0 (0x0) +__uchar 0xfc / 0x2a == 0x6 (0x6) +__longlong 0xfffc / 0x2a == 0x0 (0x0) +__ulonglong 0xfffc / 0x2a == 0x6186 (0x6186) +float 0xfffc / 0x2a == 0x0 (0x0) +int 0xfffc % 0x2a == -0x4 (0xfffc) +__uint 0xfffc % 0x2a == 0xc (0xc) +char 0xfffc % 0x2a == -0x4 (0xfffc) +__uchar 0xfc % 0x2a == 0x0 (0x0) +__longlong 0xfffc % 0x2a == -0x4 (0xfffc) +__ulonglong 0xfffc % 0x2a == 0x0 (0x0) +0xfffc * 0x17 == -0x5c +0xfffc / 0x17 == 0x0 +0xfffc % 0x17 == -0x4 +int 0xfffc ^ 0x17 == -0x15 (0xffeb) +__uint 0xfffc ^ 0x17 == -0x15 (0xffeb) +char 0xfffc ^ 0x17 == -0x15 (0xffeb) +__uchar 0xfc ^ 0x17 == 0xeb (0xeb) +__longlong 0xfffc ^ 0x17 == -0x15 (0xffeb) +__ulonglong 0xfffc ^ 0x17 == -0x15 (0xffeb) +int 0xfffc && 0x17 == 0x1 (0x1) +__uint 0xfffc && 0x17 == 0x1 (0x1) +char 0xfffc && 0x17 == 0x1 (0x1) +__uchar 0xfc && 0x17 == 0x1 (0x1) +__longlong 0xfffc && 0x17 == 0x1 (0x1) +__ulonglong 0xfffc && 0x17 == 0x1 (0x1) +int 0xfffc || 0x17 == 0x1 (0x1) +__uint 0xfffc || 0x17 == 0x1 (0x1) +char 0xfffc || 0x17 == 0x1 (0x1) +__uchar 0xfc || 0x17 == 0x1 (0x1) +__longlong 0xfffc || 0x17 == 0x1 (0x1) +__ulonglong 0xfffc || 0x17 == 0x1 (0x1) +int 0xfffc & 0x17 == 0x14 (0x14) +__uint 0xfffc & 0x17 == 0x14 (0x14) +char 0xfffc & 0x17 == 0x14 (0x14) +__uchar 0xfc & 0x17 == 0x14 (0x14) +__longlong 0xfffc & 0x17 == 0x14 (0x14) +__ulonglong 0xfffc & 0x17 == 0x14 (0x14) +int 0xfffc | 0x17 == -0x1 (0xffff) +__uint 0xfffc | 0x17 == -0x1 (0xffff) +char 0xfffc | 0x17 == -0x1 (0xffff) +__uchar 0xfc | 0x17 == 0xff (0xff) +__longlong 0xfffc | 0x17 == -0x1 (0xffff) +__ulonglong 0xfffc | 0x17 == -0x1 (0xffff) +int 0xfffc << 0xe == 0x0 (0x0) +__uint 0xfffc << 0xe == 0x0 (0x0) +char 0xfffc << 0xe == 0x0 (0x0) +__uchar 0xfc << 0xe == 0x0 (0x0) +__longlong 0xfffc << 0xe == 0x0 (0x0) +__ulonglong 0xfffc << 0xe == 0x0 (0x0) +int 0xfffc >> 0xe == -0x1 (0xffff) +__uint 0xfffc >> 0xe == 0x3 (0x3) +char 0xfffc >> 0xe == -0x1 (0xffff) +__uchar 0xfc >> 0xe == 0x0 (0x0) +__longlong 0xfffc >> 0xe == -0x1 (0xffff) +__ulonglong 0xfffc >> 0xe == -0x1 (0xffff) +int 0xfffc + 0x17 == 0x13 (0x13) +__uint 0xfffc + 0x17 == 0x13 (0x13) +char 0xfffc + 0x17 == 0x13 (0x13) +__uchar 0xfc + 0x17 == 0x13 (0x13) +__longlong 0xfffc + 0x17 == 0x13 (0x13) +__ulonglong 0xfffc + 0x17 == 0x13 (0x13) +float 0xfffc + 0x17 == 0x13 (0x13) +int 0xfffc - 0x17 == -0x1b (0xffe5) +__uint 0xfffc - 0x17 == -0x1b (0xffe5) +char 0xfffc - 0x17 == -0x1b (0xffe5) +__uchar 0xfc - 0x17 == 0xe5 (0xe5) +__longlong 0xfffc - 0x17 == -0x1b (0xffe5) +__ulonglong 0xfffc - 0x17 == -0x1b (0xffe5) +float 0xfffc - 0x17 == -0x1b (0xffe5) +int 0xfffc * 0x17 == -0x5c (0xffa4) +__uint 0xfffc * 0x17 == -0x5c (0xffa4) +char 0xfffc * 0x17 == -0x5c (0xffa4) +__uchar 0xfc * 0x17 == 0xa4 (0xa4) +__longlong 0xfffc * 0x17 == -0x5c (0xffa4) +__ulonglong 0xfffc * 0x17 == -0x5c (0xffa4) +float 0xfffc * 0x17 == -0x5c (0xffa4) +int 0xfffc < 0x17 == 0x1 (0x1) +__uint 0xfffc < 0x17 == 0x0 (0x0) +char 0xfffc < 0x17 == 0x1 (0x1) +__uchar 0xfc < 0x17 == 0x0 (0x0) +__longlong 0xfffc < 0x17 == 0x1 (0x1) +__ulonglong 0xfffc < 0x17 == 0x0 (0x0) +float 0xfffc < 0x17 == 0x1 (0x1) +int 0xfffc > 0x17 == 0x0 (0x0) +__uint 0xfffc > 0x17 == 0x1 (0x1) +char 0xfffc > 0x17 == 0x0 (0x0) +__uchar 0xfc > 0x17 == 0x1 (0x1) +__longlong 0xfffc > 0x17 == 0x0 (0x0) +__ulonglong 0xfffc > 0x17 == 0x1 (0x1) +float 0xfffc > 0x17 == 0x0 (0x0) +int 0xfffc <= 0x17 == 0x1 (0x1) +__uint 0xfffc <= 0x17 == 0x0 (0x0) +char 0xfffc <= 0x17 == 0x1 (0x1) +__uchar 0xfc <= 0x17 == 0x0 (0x0) +__longlong 0xfffc <= 0x17 == 0x1 (0x1) +__ulonglong 0xfffc <= 0x17 == 0x0 (0x0) +float 0xfffc <= 0x17 == 0x1 (0x1) +int 0xfffc == 0x17 == 0x0 (0x0) +__uint 0xfffc == 0x17 == 0x0 (0x0) +char 0xfffc == 0x17 == 0x0 (0x0) +__uchar 0xfc == 0x17 == 0x0 (0x0) +__longlong 0xfffc == 0x17 == 0x0 (0x0) +__ulonglong 0xfffc == 0x17 == 0x0 (0x0) +float 0xfffc == 0x17 == 0x0 (0x0) +int 0xfffc != 0x17 == 0x1 (0x1) +__uint 0xfffc != 0x17 == 0x1 (0x1) +char 0xfffc != 0x17 == 0x1 (0x1) +__uchar 0xfc != 0x17 == 0x1 (0x1) +__longlong 0xfffc != 0x17 == 0x1 (0x1) +__ulonglong 0xfffc != 0x17 == 0x1 (0x1) +float 0xfffc != 0x17 == 0x1 (0x1) +int 0xfffc >= 0x17 == 0x0 (0x0) +__uint 0xfffc >= 0x17 == 0x1 (0x1) +char 0xfffc >= 0x17 == 0x0 (0x0) +__uchar 0xfc >= 0x17 == 0x1 (0x1) +__longlong 0xfffc >= 0x17 == 0x0 (0x0) +__ulonglong 0xfffc >= 0x17 == 0x1 (0x1) +float 0xfffc >= 0x17 == 0x0 (0x0) +int 0xfffc / 0x17 == 0x0 (0x0) +__uint 0xfffc / 0x17 == 0xb21 (0xb21) +char 0xfffc / 0x17 == 0x0 (0x0) +__uchar 0xfc / 0x17 == 0xa (0xa) +__longlong 0xfffc / 0x17 == 0x0 (0x0) +__ulonglong 0xfffc / 0x17 == 0x642c (0x642c) +float 0xfffc / 0x17 == 0x0 (0x0) +int 0xfffc % 0x17 == -0x4 (0xfffc) +__uint 0xfffc % 0x17 == 0x5 (0x5) +char 0xfffc % 0x17 == -0x4 (0xfffc) +__uchar 0xfc % 0x17 == 0x16 (0x16) +__longlong 0xfffc % 0x17 == -0x4 (0xfffc) +__ulonglong 0xfffc % 0x17 == 0x8 (0x8) +0xfffc * 0x7fff == 0x4 +0xfffc / 0x7fff == 0x0 +0xfffc % 0x7fff == -0x4 +int 0xfffc ^ 0x7fff == -0x7ffd (0x8003) +__uint 0xfffc ^ 0x7fff == -0x7ffd (0x8003) +char 0xfffc ^ 0xffff == 0x3 (0x3) +__uchar 0xfc ^ 0xff == 0x3 (0x3) +__longlong 0xfffc ^ 0x7fff == -0x7ffd (0x8003) +__ulonglong 0xfffc ^ 0x7fff == -0x7ffd (0x8003) +int 0xfffc && 0x7fff == 0x1 (0x1) +__uint 0xfffc && 0x7fff == 0x1 (0x1) +char 0xfffc && 0xffff == 0x1 (0x1) +__uchar 0xfc && 0xff == 0x1 (0x1) +__longlong 0xfffc && 0x7fff == 0x1 (0x1) +__ulonglong 0xfffc && 0x7fff == 0x1 (0x1) +int 0xfffc || 0x7fff == 0x1 (0x1) +__uint 0xfffc || 0x7fff == 0x1 (0x1) +char 0xfffc || 0xffff == 0x1 (0x1) +__uchar 0xfc || 0xff == 0x1 (0x1) +__longlong 0xfffc || 0x7fff == 0x1 (0x1) +__ulonglong 0xfffc || 0x7fff == 0x1 (0x1) +int 0xfffc & 0x7fff == 0x7ffc (0x7ffc) +__uint 0xfffc & 0x7fff == 0x7ffc (0x7ffc) +char 0xfffc & 0xffff == -0x4 (0xfffc) +__uchar 0xfc & 0xff == 0xfc (0xfc) +__longlong 0xfffc & 0x7fff == 0x7ffc (0x7ffc) +__ulonglong 0xfffc & 0x7fff == 0x7ffc (0x7ffc) +int 0xfffc | 0x7fff == -0x1 (0xffff) +__uint 0xfffc | 0x7fff == -0x1 (0xffff) +char 0xfffc | 0xffff == -0x1 (0xffff) +__uchar 0xfc | 0xff == 0xff (0xff) +__longlong 0xfffc | 0x7fff == -0x1 (0xffff) +__ulonglong 0xfffc | 0x7fff == -0x1 (0xffff) +int 0xfffc << 0x10 == 0x0 (0x0) +__uint 0xfffc << 0x10 == 0x0 (0x0) +char 0xfffc << 0x10 == 0x0 (0x0) +__uchar 0xfc << 0x10 == 0x0 (0x0) +__longlong 0xfffc << 0x10 == 0x0 (0x0) +__ulonglong 0xfffc << 0x10 == 0x0 (0x0) +int 0xfffc >> 0x10 == -0x1 (0xffff) +__uint 0xfffc >> 0x10 == 0x0 (0x0) +char 0xfffc >> 0x10 == -0x1 (0xffff) +__uchar 0xfc >> 0x10 == 0x0 (0x0) +__longlong 0xfffc >> 0x10 == -0x1 (0xffff) +__ulonglong 0xfffc >> 0x10 == -0x1 (0xffff) +int 0xfffc + 0x7fff == 0x7ffb (0x7ffb) +__uint 0xfffc + 0x7fff == 0x7ffb (0x7ffb) +char 0xfffc + 0xffff == -0x5 (0xfffb) +__uchar 0xfc + 0xff == 0xfb (0xfb) +__longlong 0xfffc + 0x7fff == 0x7ffb (0x7ffb) +__ulonglong 0xfffc + 0x7fff == 0x7ffb (0x7ffb) +float 0xfffc + 0x7fff == 0x7ffb (0x7ffb) +int 0xfffc - 0x7fff == 0x7ffd (0x7ffd) +__uint 0xfffc - 0x7fff == 0x7ffd (0x7ffd) +char 0xfffc - 0xffff == -0x3 (0xfffd) +__uchar 0xfc - 0xff == 0xfd (0xfd) +__longlong 0xfffc - 0x7fff == 0x7ffd (0x7ffd) +__ulonglong 0xfffc - 0x7fff == 0x7ffd (0x7ffd) +float 0xfffc - 0x7fff == 0x7ffd (0x7ffd) +int 0xfffc * 0x7fff == 0x4 (0x4) +__uint 0xfffc * 0x7fff == 0x4 (0x4) +char 0xfffc * 0xffff == 0x4 (0x4) +__uchar 0xfc * 0xff == 0x4 (0x4) +__longlong 0xfffc * 0x7fff == 0x4 (0x4) +__ulonglong 0xfffc * 0x7fff == 0x4 (0x4) +float 0xfffc * 0x7fff == 0x4 (0x4) +int 0xfffc < 0x7fff == 0x1 (0x1) +__uint 0xfffc < 0x7fff == 0x0 (0x0) +char 0xfffc < 0xffff == 0x1 (0x1) +__uchar 0xfc < 0xff == 0x1 (0x1) +__longlong 0xfffc < 0x7fff == 0x1 (0x1) +__ulonglong 0xfffc < 0x7fff == 0x0 (0x0) +float 0xfffc < 0x7fff == 0x1 (0x1) +int 0xfffc > 0x7fff == 0x0 (0x0) +__uint 0xfffc > 0x7fff == 0x1 (0x1) +char 0xfffc > 0xffff == 0x0 (0x0) +__uchar 0xfc > 0xff == 0x0 (0x0) +__longlong 0xfffc > 0x7fff == 0x0 (0x0) +__ulonglong 0xfffc > 0x7fff == 0x1 (0x1) +float 0xfffc > 0x7fff == 0x0 (0x0) +int 0xfffc <= 0x7fff == 0x1 (0x1) +__uint 0xfffc <= 0x7fff == 0x0 (0x0) +char 0xfffc <= 0xffff == 0x1 (0x1) +__uchar 0xfc <= 0xff == 0x1 (0x1) +__longlong 0xfffc <= 0x7fff == 0x1 (0x1) +__ulonglong 0xfffc <= 0x7fff == 0x0 (0x0) +float 0xfffc <= 0x7fff == 0x1 (0x1) +int 0xfffc == 0x7fff == 0x0 (0x0) +__uint 0xfffc == 0x7fff == 0x0 (0x0) +char 0xfffc == 0xffff == 0x0 (0x0) +__uchar 0xfc == 0xff == 0x0 (0x0) +__longlong 0xfffc == 0x7fff == 0x0 (0x0) +__ulonglong 0xfffc == 0x7fff == 0x0 (0x0) +float 0xfffc == 0x7fff == 0x0 (0x0) +int 0xfffc != 0x7fff == 0x1 (0x1) +__uint 0xfffc != 0x7fff == 0x1 (0x1) +char 0xfffc != 0xffff == 0x1 (0x1) +__uchar 0xfc != 0xff == 0x1 (0x1) +__longlong 0xfffc != 0x7fff == 0x1 (0x1) +__ulonglong 0xfffc != 0x7fff == 0x1 (0x1) +float 0xfffc != 0x7fff == 0x1 (0x1) +int 0xfffc >= 0x7fff == 0x0 (0x0) +__uint 0xfffc >= 0x7fff == 0x1 (0x1) +char 0xfffc >= 0xffff == 0x0 (0x0) +__uchar 0xfc >= 0xff == 0x0 (0x0) +__longlong 0xfffc >= 0x7fff == 0x0 (0x0) +__ulonglong 0xfffc >= 0x7fff == 0x1 (0x1) +float 0xfffc >= 0x7fff == 0x0 (0x0) +int 0xfffc / 0x7fff == 0x0 (0x0) +__uint 0xfffc / 0x7fff == 0x1 (0x1) +char 0xfffc / 0xffff == 0x4 (0x4) +__uchar 0xfc / 0xff == 0x0 (0x0) +__longlong 0xfffc / 0x7fff == 0x0 (0x0) +__ulonglong 0xfffc / 0x7fff == 0x4 (0x4) +float 0xfffc / 0x7fff == 0x0 (0x0) +int 0xfffc % 0x7fff == -0x4 (0xfffc) +__uint 0xfffc % 0x7fff == 0x7ffd (0x7ffd) +char 0xfffc % 0xffff == 0x0 (0x0) +__uchar 0xfc % 0xff == 0xfc (0xfc) +__longlong 0xfffc % 0x7fff == -0x4 (0xfffc) +__ulonglong 0xfffc % 0x7fff == 0x0 (0x0) +0xfffc * 0x8000 == 0x0 +0xfffc / 0x8000 == 0x0 +0xfffc % 0x8000 == -0x4 +int 0xfffc ^ 0x8000 == 0x7ffc (0x7ffc) +__uint 0xfffc ^ 0x8000 == 0x7ffc (0x7ffc) +char 0xfffc ^ 0x0 == -0x4 (0xfffc) +__uchar 0xfc ^ 0x0 == 0xfc (0xfc) +__longlong 0xfffc ^ 0x8000 == 0x7ffc (0x7ffc) +__ulonglong 0xfffc ^ 0x8000 == 0x7ffc (0x7ffc) +int 0xfffc && 0x8000 == 0x1 (0x1) +__uint 0xfffc && 0x8000 == 0x1 (0x1) +char 0xfffc && 0x0 == 0x0 (0x0) +__uchar 0xfc && 0x0 == 0x0 (0x0) +__longlong 0xfffc && 0x8000 == 0x1 (0x1) +__ulonglong 0xfffc && 0x8000 == 0x1 (0x1) +int 0xfffc || 0x8000 == 0x1 (0x1) +__uint 0xfffc || 0x8000 == 0x1 (0x1) +char 0xfffc || 0x0 == 0x1 (0x1) +__uchar 0xfc || 0x0 == 0x1 (0x1) +__longlong 0xfffc || 0x8000 == 0x1 (0x1) +__ulonglong 0xfffc || 0x8000 == 0x1 (0x1) +int 0xfffc & 0x8000 == -0x8000 (0x8000) +__uint 0xfffc & 0x8000 == -0x8000 (0x8000) +char 0xfffc & 0x0 == 0x0 (0x0) +__uchar 0xfc & 0x0 == 0x0 (0x0) +__longlong 0xfffc & 0x8000 == -0x8000 (0x8000) +__ulonglong 0xfffc & 0x8000 == -0x8000 (0x8000) +int 0xfffc | 0x8000 == -0x4 (0xfffc) +__uint 0xfffc | 0x8000 == -0x4 (0xfffc) +char 0xfffc | 0x0 == -0x4 (0xfffc) +__uchar 0xfc | 0x0 == 0xfc (0xfc) +__longlong 0xfffc | 0x8000 == -0x4 (0xfffc) +__ulonglong 0xfffc | 0x8000 == -0x4 (0xfffc) +int 0xfffc << 0x12 == 0x0 (0x0) +__uint 0xfffc << 0x12 == 0x0 (0x0) +char 0xfffc << 0x12 == 0x0 (0x0) +__uchar 0xfc << 0x12 == 0x0 (0x0) +__longlong 0xfffc << 0x12 == 0x0 (0x0) +__ulonglong 0xfffc << 0x12 == 0x0 (0x0) +int 0xfffc >> 0x12 == -0x1 (0xffff) +__uint 0xfffc >> 0x12 == 0x0 (0x0) +char 0xfffc >> 0x12 == -0x1 (0xffff) +__uchar 0xfc >> 0x12 == 0x0 (0x0) +__longlong 0xfffc >> 0x12 == -0x1 (0xffff) +__ulonglong 0xfffc >> 0x12 == 0x3fff (0x3fff) +int 0xfffc + 0x8000 == 0x7ffc (0x7ffc) +__uint 0xfffc + 0x8000 == 0x7ffc (0x7ffc) +char 0xfffc + 0x0 == -0x4 (0xfffc) +__uchar 0xfc + 0x0 == 0xfc (0xfc) +__longlong 0xfffc + 0x8000 == 0x7ffc (0x7ffc) +__ulonglong 0xfffc + 0x8000 == 0x7ffc (0x7ffc) +float 0xfffc + 0x8000 == 0x7ffc (0x7ffc) +int 0xfffc - 0x8000 == 0x7ffc (0x7ffc) +__uint 0xfffc - 0x8000 == 0x7ffc (0x7ffc) +char 0xfffc - 0x0 == -0x4 (0xfffc) +__uchar 0xfc - 0x0 == 0xfc (0xfc) +__longlong 0xfffc - 0x8000 == 0x7ffc (0x7ffc) +__ulonglong 0xfffc - 0x8000 == 0x7ffc (0x7ffc) +float 0xfffc - 0x8000 == 0x7ffc (0x7ffc) +int 0xfffc * 0x8000 == 0x0 (0x0) +__uint 0xfffc * 0x8000 == 0x0 (0x0) +char 0xfffc * 0x0 == 0x0 (0x0) +__uchar 0xfc * 0x0 == 0x0 (0x0) +__longlong 0xfffc * 0x8000 == 0x0 (0x0) +__ulonglong 0xfffc * 0x8000 == 0x0 (0x0) +float 0xfffc * 0x8000 == 0x0 (0x0) +int 0xfffc < 0x8000 == 0x0 (0x0) +__uint 0xfffc < 0x8000 == 0x0 (0x0) +char 0xfffc < 0x0 == 0x1 (0x1) +__uchar 0xfc < 0x0 == 0x0 (0x0) +__longlong 0xfffc < 0x8000 == 0x0 (0x0) +__ulonglong 0xfffc < 0x8000 == 0x0 (0x0) +float 0xfffc < 0x8000 == 0x0 (0x0) +int 0xfffc > 0x8000 == 0x1 (0x1) +__uint 0xfffc > 0x8000 == 0x1 (0x1) +char 0xfffc > 0x0 == 0x0 (0x0) +__uchar 0xfc > 0x0 == 0x1 (0x1) +__longlong 0xfffc > 0x8000 == 0x1 (0x1) +__ulonglong 0xfffc > 0x8000 == 0x1 (0x1) +float 0xfffc > 0x8000 == 0x1 (0x1) +int 0xfffc <= 0x8000 == 0x0 (0x0) +__uint 0xfffc <= 0x8000 == 0x0 (0x0) +char 0xfffc <= 0x0 == 0x1 (0x1) +__uchar 0xfc <= 0x0 == 0x0 (0x0) +__longlong 0xfffc <= 0x8000 == 0x0 (0x0) +__ulonglong 0xfffc <= 0x8000 == 0x0 (0x0) +float 0xfffc <= 0x8000 == 0x0 (0x0) +int 0xfffc == 0x8000 == 0x0 (0x0) +__uint 0xfffc == 0x8000 == 0x0 (0x0) +char 0xfffc == 0x0 == 0x0 (0x0) +__uchar 0xfc == 0x0 == 0x0 (0x0) +__longlong 0xfffc == 0x8000 == 0x0 (0x0) +__ulonglong 0xfffc == 0x8000 == 0x0 (0x0) +float 0xfffc == 0x8000 == 0x0 (0x0) +int 0xfffc != 0x8000 == 0x1 (0x1) +__uint 0xfffc != 0x8000 == 0x1 (0x1) +char 0xfffc != 0x0 == 0x1 (0x1) +__uchar 0xfc != 0x0 == 0x1 (0x1) +__longlong 0xfffc != 0x8000 == 0x1 (0x1) +__ulonglong 0xfffc != 0x8000 == 0x1 (0x1) +float 0xfffc != 0x8000 == 0x1 (0x1) +int 0xfffc >= 0x8000 == 0x1 (0x1) +__uint 0xfffc >= 0x8000 == 0x1 (0x1) +char 0xfffc >= 0x0 == 0x0 (0x0) +__uchar 0xfc >= 0x0 == 0x1 (0x1) +__longlong 0xfffc >= 0x8000 == 0x1 (0x1) +__ulonglong 0xfffc >= 0x8000 == 0x1 (0x1) +float 0xfffc >= 0x8000 == 0x1 (0x1) +int 0xfffc / 0x8000 == 0x0 (0x0) +__uint 0xfffc / 0x8000 == 0x1 (0x1) +__longlong 0xfffc / 0x8000 == 0x0 (0x0) +__ulonglong 0xfffc / 0x8000 == 0x1 (0x1) +float 0xfffc / 0x8000 == 0x0 (0x0) +int 0xfffc % 0x8000 == -0x4 (0xfffc) +__uint 0xfffc % 0x8000 == 0x7ffc (0x7ffc) +__longlong 0xfffc % 0x8000 == -0x4 (0xfffc) +__ulonglong 0xfffc % 0x8000 == 0x7ffc (0x7ffc) +0xfffc * 0x3e8 == -0xfa0 +0xfffc / 0x3e8 == 0x0 +0xfffc % 0x3e8 == -0x4 +int 0xfffc ^ 0x3e8 == -0x3ec (0xfc14) +__uint 0xfffc ^ 0x3e8 == -0x3ec (0xfc14) +char 0xfffc ^ 0xffe8 == 0x14 (0x14) +__uchar 0xfc ^ 0xe8 == 0x14 (0x14) +__longlong 0xfffc ^ 0x3e8 == -0x3ec (0xfc14) +__ulonglong 0xfffc ^ 0x3e8 == -0x3ec (0xfc14) +int 0xfffc && 0x3e8 == 0x1 (0x1) +__uint 0xfffc && 0x3e8 == 0x1 (0x1) +char 0xfffc && 0xffe8 == 0x1 (0x1) +__uchar 0xfc && 0xe8 == 0x1 (0x1) +__longlong 0xfffc && 0x3e8 == 0x1 (0x1) +__ulonglong 0xfffc && 0x3e8 == 0x1 (0x1) +int 0xfffc || 0x3e8 == 0x1 (0x1) +__uint 0xfffc || 0x3e8 == 0x1 (0x1) +char 0xfffc || 0xffe8 == 0x1 (0x1) +__uchar 0xfc || 0xe8 == 0x1 (0x1) +__longlong 0xfffc || 0x3e8 == 0x1 (0x1) +__ulonglong 0xfffc || 0x3e8 == 0x1 (0x1) +int 0xfffc & 0x3e8 == 0x3e8 (0x3e8) +__uint 0xfffc & 0x3e8 == 0x3e8 (0x3e8) +char 0xfffc & 0xffe8 == -0x18 (0xffe8) +__uchar 0xfc & 0xe8 == 0xe8 (0xe8) +__longlong 0xfffc & 0x3e8 == 0x3e8 (0x3e8) +__ulonglong 0xfffc & 0x3e8 == 0x3e8 (0x3e8) +int 0xfffc | 0x3e8 == -0x4 (0xfffc) +__uint 0xfffc | 0x3e8 == -0x4 (0xfffc) +char 0xfffc | 0xffe8 == -0x4 (0xfffc) +__uchar 0xfc | 0xe8 == 0xfc (0xfc) +__longlong 0xfffc | 0x3e8 == -0x4 (0xfffc) +__ulonglong 0xfffc | 0x3e8 == -0x4 (0xfffc) +int 0xfffc << 0x14 == 0x0 (0x0) +__uint 0xfffc << 0x14 == 0x0 (0x0) +char 0xfffc << 0x14 == 0x0 (0x0) +__uchar 0xfc << 0x14 == 0x0 (0x0) +__longlong 0xfffc << 0x14 == 0x0 (0x0) +__ulonglong 0xfffc << 0x14 == 0x0 (0x0) +int 0xfffc >> 0x14 == -0x1 (0xffff) +__uint 0xfffc >> 0x14 == 0x0 (0x0) +char 0xfffc >> 0x14 == -0x1 (0xffff) +__uchar 0xfc >> 0x14 == 0x0 (0x0) +__longlong 0xfffc >> 0x14 == -0x1 (0xffff) +__ulonglong 0xfffc >> 0x14 == 0xfff (0xfff) +int 0xfffc + 0x3e8 == 0x3e4 (0x3e4) +__uint 0xfffc + 0x3e8 == 0x3e4 (0x3e4) +char 0xfffc + 0xffe8 == -0x1c (0xffe4) +__uchar 0xfc + 0xe8 == 0xe4 (0xe4) +__longlong 0xfffc + 0x3e8 == 0x3e4 (0x3e4) +__ulonglong 0xfffc + 0x3e8 == 0x3e4 (0x3e4) +float 0xfffc + 0x3e8 == 0x3e4 (0x3e4) +int 0xfffc - 0x3e8 == -0x3ec (0xfc14) +__uint 0xfffc - 0x3e8 == -0x3ec (0xfc14) +char 0xfffc - 0xffe8 == 0x14 (0x14) +__uchar 0xfc - 0xe8 == 0x14 (0x14) +__longlong 0xfffc - 0x3e8 == -0x3ec (0xfc14) +__ulonglong 0xfffc - 0x3e8 == -0x3ec (0xfc14) +float 0xfffc - 0x3e8 == -0x3ec (0xfc14) +int 0xfffc * 0x3e8 == -0xfa0 (0xf060) +__uint 0xfffc * 0x3e8 == -0xfa0 (0xf060) +char 0xfffc * 0xffe8 == 0x60 (0x60) +__uchar 0xfc * 0xe8 == 0x60 (0x60) +__longlong 0xfffc * 0x3e8 == -0xfa0 (0xf060) +__ulonglong 0xfffc * 0x3e8 == -0xfa0 (0xf060) +float 0xfffc * 0x3e8 == -0xfa0 (0xf060) +int 0xfffc < 0x3e8 == 0x1 (0x1) +__uint 0xfffc < 0x3e8 == 0x0 (0x0) +char 0xfffc < 0xffe8 == 0x0 (0x0) +__uchar 0xfc < 0xe8 == 0x0 (0x0) +__longlong 0xfffc < 0x3e8 == 0x1 (0x1) +__ulonglong 0xfffc < 0x3e8 == 0x0 (0x0) +float 0xfffc < 0x3e8 == 0x1 (0x1) +int 0xfffc > 0x3e8 == 0x0 (0x0) +__uint 0xfffc > 0x3e8 == 0x1 (0x1) +char 0xfffc > 0xffe8 == 0x1 (0x1) +__uchar 0xfc > 0xe8 == 0x1 (0x1) +__longlong 0xfffc > 0x3e8 == 0x0 (0x0) +__ulonglong 0xfffc > 0x3e8 == 0x1 (0x1) +float 0xfffc > 0x3e8 == 0x0 (0x0) +int 0xfffc <= 0x3e8 == 0x1 (0x1) +__uint 0xfffc <= 0x3e8 == 0x0 (0x0) +char 0xfffc <= 0xffe8 == 0x0 (0x0) +__uchar 0xfc <= 0xe8 == 0x0 (0x0) +__longlong 0xfffc <= 0x3e8 == 0x1 (0x1) +__ulonglong 0xfffc <= 0x3e8 == 0x0 (0x0) +float 0xfffc <= 0x3e8 == 0x1 (0x1) +int 0xfffc == 0x3e8 == 0x0 (0x0) +__uint 0xfffc == 0x3e8 == 0x0 (0x0) +char 0xfffc == 0xffe8 == 0x0 (0x0) +__uchar 0xfc == 0xe8 == 0x0 (0x0) +__longlong 0xfffc == 0x3e8 == 0x0 (0x0) +__ulonglong 0xfffc == 0x3e8 == 0x0 (0x0) +float 0xfffc == 0x3e8 == 0x0 (0x0) +int 0xfffc != 0x3e8 == 0x1 (0x1) +__uint 0xfffc != 0x3e8 == 0x1 (0x1) +char 0xfffc != 0xffe8 == 0x1 (0x1) +__uchar 0xfc != 0xe8 == 0x1 (0x1) +__longlong 0xfffc != 0x3e8 == 0x1 (0x1) +__ulonglong 0xfffc != 0x3e8 == 0x1 (0x1) +float 0xfffc != 0x3e8 == 0x1 (0x1) +int 0xfffc >= 0x3e8 == 0x0 (0x0) +__uint 0xfffc >= 0x3e8 == 0x1 (0x1) +char 0xfffc >= 0xffe8 == 0x1 (0x1) +__uchar 0xfc >= 0xe8 == 0x1 (0x1) +__longlong 0xfffc >= 0x3e8 == 0x0 (0x0) +__ulonglong 0xfffc >= 0x3e8 == 0x1 (0x1) +float 0xfffc >= 0x3e8 == 0x0 (0x0) +int 0xfffc / 0x3e8 == 0x0 (0x0) +__uint 0xfffc / 0x3e8 == 0x41 (0x41) +char 0xfffc / 0xffe8 == 0x0 (0x0) +__uchar 0xfc / 0xe8 == 0x1 (0x1) +__longlong 0xfffc / 0x3e8 == 0x0 (0x0) +__ulonglong 0xfffc / 0x3e8 == -0x76c9 (0x8937) +float 0xfffc / 0x3e8 == 0x0 (0x0) +int 0xfffc % 0x3e8 == -0x4 (0xfffc) +__uint 0xfffc % 0x3e8 == 0x214 (0x214) +char 0xfffc % 0xffe8 == -0x4 (0xfffc) +__uchar 0xfc % 0xe8 == 0x14 (0x14) +__longlong 0xfffc % 0x3e8 == -0x4 (0xfffc) +__ulonglong 0xfffc % 0x3e8 == 0x124 (0x124) +0xfffc * 0x2710 == 0x63c0 +0xfffc / 0x2710 == 0x0 +0xfffc % 0x2710 == -0x4 +int 0xfffc ^ 0x2710 == -0x2714 (0xd8ec) +__uint 0xfffc ^ 0x2710 == -0x2714 (0xd8ec) +char 0xfffc ^ 0x10 == -0x14 (0xffec) +__uchar 0xfc ^ 0x10 == 0xec (0xec) +__longlong 0xfffc ^ 0x2710 == -0x2714 (0xd8ec) +__ulonglong 0xfffc ^ 0x2710 == -0x2714 (0xd8ec) +int 0xfffc && 0x2710 == 0x1 (0x1) +__uint 0xfffc && 0x2710 == 0x1 (0x1) +char 0xfffc && 0x10 == 0x1 (0x1) +__uchar 0xfc && 0x10 == 0x1 (0x1) +__longlong 0xfffc && 0x2710 == 0x1 (0x1) +__ulonglong 0xfffc && 0x2710 == 0x1 (0x1) +int 0xfffc || 0x2710 == 0x1 (0x1) +__uint 0xfffc || 0x2710 == 0x1 (0x1) +char 0xfffc || 0x10 == 0x1 (0x1) +__uchar 0xfc || 0x10 == 0x1 (0x1) +__longlong 0xfffc || 0x2710 == 0x1 (0x1) +__ulonglong 0xfffc || 0x2710 == 0x1 (0x1) +int 0xfffc & 0x2710 == 0x2710 (0x2710) +__uint 0xfffc & 0x2710 == 0x2710 (0x2710) +char 0xfffc & 0x10 == 0x10 (0x10) +__uchar 0xfc & 0x10 == 0x10 (0x10) +__longlong 0xfffc & 0x2710 == 0x2710 (0x2710) +__ulonglong 0xfffc & 0x2710 == 0x2710 (0x2710) +int 0xfffc | 0x2710 == -0x4 (0xfffc) +__uint 0xfffc | 0x2710 == -0x4 (0xfffc) +char 0xfffc | 0x10 == -0x4 (0xfffc) +__uchar 0xfc | 0x10 == 0xfc (0xfc) +__longlong 0xfffc | 0x2710 == -0x4 (0xfffc) +__ulonglong 0xfffc | 0x2710 == -0x4 (0xfffc) +int 0xfffc << 0x16 == 0x0 (0x0) +__uint 0xfffc << 0x16 == 0x0 (0x0) +char 0xfffc << 0x16 == 0x0 (0x0) +__uchar 0xfc << 0x16 == 0x0 (0x0) +__longlong 0xfffc << 0x16 == 0x0 (0x0) +__ulonglong 0xfffc << 0x16 == 0x0 (0x0) +int 0xfffc >> 0x16 == -0x1 (0xffff) +__uint 0xfffc >> 0x16 == 0x0 (0x0) +char 0xfffc >> 0x16 == -0x1 (0xffff) +__uchar 0xfc >> 0x16 == 0x0 (0x0) +__longlong 0xfffc >> 0x16 == -0x1 (0xffff) +__ulonglong 0xfffc >> 0x16 == 0x3ff (0x3ff) +int 0xfffc + 0x2710 == 0x270c (0x270c) +__uint 0xfffc + 0x2710 == 0x270c (0x270c) +char 0xfffc + 0x10 == 0xc (0xc) +__uchar 0xfc + 0x10 == 0xc (0xc) +__longlong 0xfffc + 0x2710 == 0x270c (0x270c) +__ulonglong 0xfffc + 0x2710 == 0x270c (0x270c) +float 0xfffc + 0x2710 == 0x270c (0x270c) +int 0xfffc - 0x2710 == -0x2714 (0xd8ec) +__uint 0xfffc - 0x2710 == -0x2714 (0xd8ec) +char 0xfffc - 0x10 == -0x14 (0xffec) +__uchar 0xfc - 0x10 == 0xec (0xec) +__longlong 0xfffc - 0x2710 == -0x2714 (0xd8ec) +__ulonglong 0xfffc - 0x2710 == -0x2714 (0xd8ec) +float 0xfffc - 0x2710 == -0x2714 (0xd8ec) +int 0xfffc * 0x2710 == 0x63c0 (0x63c0) +__uint 0xfffc * 0x2710 == 0x63c0 (0x63c0) +char 0xfffc * 0x10 == -0x40 (0xffc0) +__uchar 0xfc * 0x10 == 0xc0 (0xc0) +__longlong 0xfffc * 0x2710 == 0x63c0 (0x63c0) +__ulonglong 0xfffc * 0x2710 == 0x63c0 (0x63c0) +float 0xfffc * 0x2710 == 0x63c0 (0x63c0) +int 0xfffc < 0x2710 == 0x1 (0x1) +__uint 0xfffc < 0x2710 == 0x0 (0x0) +char 0xfffc < 0x10 == 0x1 (0x1) +__uchar 0xfc < 0x10 == 0x0 (0x0) +__longlong 0xfffc < 0x2710 == 0x1 (0x1) +__ulonglong 0xfffc < 0x2710 == 0x0 (0x0) +float 0xfffc < 0x2710 == 0x1 (0x1) +int 0xfffc > 0x2710 == 0x0 (0x0) +__uint 0xfffc > 0x2710 == 0x1 (0x1) +char 0xfffc > 0x10 == 0x0 (0x0) +__uchar 0xfc > 0x10 == 0x1 (0x1) +__longlong 0xfffc > 0x2710 == 0x0 (0x0) +__ulonglong 0xfffc > 0x2710 == 0x1 (0x1) +float 0xfffc > 0x2710 == 0x0 (0x0) +int 0xfffc <= 0x2710 == 0x1 (0x1) +__uint 0xfffc <= 0x2710 == 0x0 (0x0) +char 0xfffc <= 0x10 == 0x1 (0x1) +__uchar 0xfc <= 0x10 == 0x0 (0x0) +__longlong 0xfffc <= 0x2710 == 0x1 (0x1) +__ulonglong 0xfffc <= 0x2710 == 0x0 (0x0) +float 0xfffc <= 0x2710 == 0x1 (0x1) +int 0xfffc == 0x2710 == 0x0 (0x0) +__uint 0xfffc == 0x2710 == 0x0 (0x0) +char 0xfffc == 0x10 == 0x0 (0x0) +__uchar 0xfc == 0x10 == 0x0 (0x0) +__longlong 0xfffc == 0x2710 == 0x0 (0x0) +__ulonglong 0xfffc == 0x2710 == 0x0 (0x0) +float 0xfffc == 0x2710 == 0x0 (0x0) +int 0xfffc != 0x2710 == 0x1 (0x1) +__uint 0xfffc != 0x2710 == 0x1 (0x1) +char 0xfffc != 0x10 == 0x1 (0x1) +__uchar 0xfc != 0x10 == 0x1 (0x1) +__longlong 0xfffc != 0x2710 == 0x1 (0x1) +__ulonglong 0xfffc != 0x2710 == 0x1 (0x1) +float 0xfffc != 0x2710 == 0x1 (0x1) +int 0xfffc >= 0x2710 == 0x0 (0x0) +__uint 0xfffc >= 0x2710 == 0x1 (0x1) +char 0xfffc >= 0x10 == 0x0 (0x0) +__uchar 0xfc >= 0x10 == 0x1 (0x1) +__longlong 0xfffc >= 0x2710 == 0x0 (0x0) +__ulonglong 0xfffc >= 0x2710 == 0x1 (0x1) +float 0xfffc >= 0x2710 == 0x0 (0x0) +int 0xfffc / 0x2710 == 0x0 (0x0) +__uint 0xfffc / 0x2710 == 0x6 (0x6) +char 0xfffc / 0x10 == 0x0 (0x0) +__uchar 0xfc / 0x10 == 0xf (0xf) +__longlong 0xfffc / 0x2710 == 0x0 (0x0) +__ulonglong 0xfffc / 0x2710 == -0x7248 (0x8db8) +float 0xfffc / 0x2710 == 0x0 (0x0) +int 0xfffc % 0x2710 == -0x4 (0xfffc) +__uint 0xfffc % 0x2710 == 0x159c (0x159c) +char 0xfffc % 0x10 == -0x4 (0xfffc) +__uchar 0xfc % 0x10 == 0xc (0xc) +__longlong 0xfffc % 0x2710 == -0x4 (0xfffc) +__ulonglong 0xfffc % 0x2710 == 0x1c7c (0x1c7c) +int xor42-0x4 xor42 -0x2a +__uint xor42-0x4 xor42 -0x2a +char xor42-0x4 xor42 -0x2a +__uchar xor420xfc xor42 0xd6 +__longlong xor42-0x4 xor42 -0x2a +__ulonglong xor42-0x4 xor42 -0x2a +int land1-0x4 land1 0x1 +__uint land1-0x4 land1 0x1 +char land1-0x4 land1 0x1 +__uchar land10xfc land1 0x1 +__longlong land1-0x4 land1 0x1 +__ulonglong land1-0x4 land1 0x1 +int lor1-0x4 lor1 0x1 +__uint lor1-0x4 lor1 0x1 +char lor1-0x4 lor1 0x1 +__uchar lor10xfc lor1 0x1 +__longlong lor1-0x4 lor1 0x1 +__ulonglong lor1-0x4 lor1 0x1 +int and42-0x4 and42 0x28 +__uint and42-0x4 and42 0x28 +char and42-0x4 and42 0x28 +__uchar and420xfc and42 0x28 +__longlong and42-0x4 and42 0x28 +__ulonglong and42-0x4 and42 0x28 +int or42-0x4 or42 -0x2 +__uint or42-0x4 or42 -0x2 +char or42-0x4 or42 -0x2 +__uchar or420xfc or42 0xfe +__longlong or42-0x4 or42 -0x2 +__ulonglong or42-0x4 or42 -0x2 +int shl5-0x4 shl5 -0x80 +__uint shl5-0x4 shl5 -0x80 +char shl5-0x4 shl5 -0x80 +__uchar shl50xfc shl5 0x80 +__longlong shl5-0x4 shl5 -0x80 +__ulonglong shl5-0x4 shl5 -0x80 +int shr5-0x4 shr5 -0x1 +__uint shr5-0x4 shr5 0x7ff +char shr5-0x4 shr5 -0x1 +__uchar shr50xfc shr5 0x7 +__longlong shr5-0x4 shr5 -0x1 +__ulonglong shr5-0x4 shr5 -0x1 +int add42-0x4 add42 0x26 +__uint add42-0x4 add42 0x26 +char add42-0x4 add42 0x26 +__uchar add420xfc add42 0x26 +__longlong add42-0x4 add42 0x26 +__ulonglong add42-0x4 add42 0x26 +float add42-0x4 add42 0x26 +int sub42-0x4 sub42 -0x2e +__uint sub42-0x4 sub42 -0x2e +char sub42-0x4 sub42 -0x2e +__uchar sub420xfc sub42 0xd2 +__longlong sub42-0x4 sub42 -0x2e +__ulonglong sub42-0x4 sub42 -0x2e +float sub42-0x4 sub42 -0x2e +int mul42-0x4 mul42 -0xa8 +__uint mul42-0x4 mul42 -0xa8 +char mul42-0x4 mul42 0x58 +__uchar mul420xfc mul42 0x58 +__longlong mul42-0x4 mul42 -0xa8 +__ulonglong mul42-0x4 mul42 -0xa8 +float mul42-0x4 mul42 -0xa8 +int lt42-0x4 lt42 0x1 +__uint lt42-0x4 lt42 0x0 +char lt42-0x4 lt42 0x1 +__uchar lt420xfc lt42 0x0 +__longlong lt42-0x4 lt42 0x1 +__ulonglong lt42-0x4 lt42 0x0 +float lt42-0x4 lt42 0x1 +int gt42-0x4 gt42 0x0 +__uint gt42-0x4 gt42 0x1 +char gt42-0x4 gt42 0x0 +__uchar gt420xfc gt42 0x1 +__longlong gt42-0x4 gt42 0x0 +__ulonglong gt42-0x4 gt42 0x1 +float gt42-0x4 gt42 0x0 +int le42-0x4 le42 0x1 +__uint le42-0x4 le42 0x0 +char le42-0x4 le42 0x1 +__uchar le420xfc le42 0x0 +__longlong le42-0x4 le42 0x1 +__ulonglong le42-0x4 le42 0x0 +float le42-0x4 le42 0x1 +int eq42-0x4 eq42 0x0 +__uint eq42-0x4 eq42 0x0 +char eq42-0x4 eq42 0x0 +__uchar eq420xfc eq42 0x0 +__longlong eq42-0x4 eq42 0x0 +__ulonglong eq42-0x4 eq42 0x0 +float eq42-0x4 eq42 0x0 +int ne42-0x4 ne42 0x1 +__uint ne42-0x4 ne42 0x1 +char ne42-0x4 ne42 0x1 +__uchar ne420xfc ne42 0x1 +__longlong ne42-0x4 ne42 0x1 +__ulonglong ne42-0x4 ne42 0x1 +float ne42-0x4 ne42 0x1 +int ge42-0x4 ge42 0x0 +__uint ge42-0x4 ge42 0x1 +char ge42-0x4 ge42 0x0 +__uchar ge420xfc ge42 0x1 +__longlong ge42-0x4 ge42 0x0 +__ulonglong ge42-0x4 ge42 0x1 +float ge42-0x4 ge42 0x0 +int div42-0x4 div42 0x0 +__uint div42-0x4 div42 0x618 +char div42-0x4 div42 0x0 +__uchar div420xfc div42 0x6 +__longlong div42-0x4 div42 0x0 +__ulonglong div42-0x4 div42 0x6186 +float div42-0x4 div42 0x0 +int mod23-0x4 mod23 -0x4 +__uint mod23-0x4 mod23 0x5 +char mod23-0x4 mod23 -0x4 +__uchar mod230xfc mod23 0x16 +__longlong mod23-0x4 mod23 -0x4 +__ulonglong mod23-0x4 mod23 0x8 +0xa * 0xffff == -0xa +0xa / 0xffff == -0xa +0xa % 0xffff == 0x0 +int 0xa ^ 0xffff == -0xb (0xfff5) +__uint 0xa ^ 0xffff == -0xb (0xfff5) +char 0xa ^ 0xffff == -0xb (0xfff5) +__uchar 0xa ^ 0xff == 0xf5 (0xf5) +__longlong 0xa ^ 0xffff == -0xb (0xfff5) +__ulonglong 0xa ^ 0xffff == -0xb (0xfff5) +int 0xa && 0xffff == 0x1 (0x1) +__uint 0xa && 0xffff == 0x1 (0x1) +char 0xa && 0xffff == 0x1 (0x1) +__uchar 0xa && 0xff == 0x1 (0x1) +__longlong 0xa && 0xffff == 0x1 (0x1) +__ulonglong 0xa && 0xffff == 0x1 (0x1) +int 0xa || 0xffff == 0x1 (0x1) +__uint 0xa || 0xffff == 0x1 (0x1) +char 0xa || 0xffff == 0x1 (0x1) +__uchar 0xa || 0xff == 0x1 (0x1) +__longlong 0xa || 0xffff == 0x1 (0x1) +__ulonglong 0xa || 0xffff == 0x1 (0x1) +int 0xa & 0xffff == 0xa (0xa) +__uint 0xa & 0xffff == 0xa (0xa) +char 0xa & 0xffff == 0xa (0xa) +__uchar 0xa & 0xff == 0xa (0xa) +__longlong 0xa & 0xffff == 0xa (0xa) +__ulonglong 0xa & 0xffff == 0xa (0xa) +int 0xa | 0xffff == -0x1 (0xffff) +__uint 0xa | 0xffff == -0x1 (0xffff) +char 0xa | 0xffff == -0x1 (0xffff) +__uchar 0xa | 0xff == 0xff (0xff) +__longlong 0xa | 0xffff == -0x1 (0xffff) +__ulonglong 0xa | 0xffff == -0x1 (0xffff) +int 0xa << 0x1 == 0x14 (0x14) +__uint 0xa << 0x1 == 0x14 (0x14) +char 0xa << 0x1 == 0x14 (0x14) +__uchar 0xa << 0x1 == 0x14 (0x14) +__longlong 0xa << 0x1 == 0x14 (0x14) +__ulonglong 0xa << 0x1 == 0x14 (0x14) +int 0xa >> 0x1 == 0x5 (0x5) +__uint 0xa >> 0x1 == 0x5 (0x5) +char 0xa >> 0x1 == 0x5 (0x5) +__uchar 0xa >> 0x1 == 0x5 (0x5) +__longlong 0xa >> 0x1 == 0x5 (0x5) +__ulonglong 0xa >> 0x1 == 0x5 (0x5) +int 0xa + 0xffff == 0x9 (0x9) +__uint 0xa + 0xffff == 0x9 (0x9) +char 0xa + 0xffff == 0x9 (0x9) +__uchar 0xa + 0xff == 0x9 (0x9) +__longlong 0xa + 0xffff == 0x9 (0x9) +__ulonglong 0xa + 0xffff == 0x9 (0x9) +float 0xa + 0xffff == 0x9 (0x9) +int 0xa - 0xffff == 0xb (0xb) +__uint 0xa - 0xffff == 0xb (0xb) +char 0xa - 0xffff == 0xb (0xb) +__uchar 0xa - 0xff == 0xb (0xb) +__longlong 0xa - 0xffff == 0xb (0xb) +__ulonglong 0xa - 0xffff == 0xb (0xb) +float 0xa - 0xffff == 0xb (0xb) +int 0xa * 0xffff == -0xa (0xfff6) +__uint 0xa * 0xffff == -0xa (0xfff6) +char 0xa * 0xffff == -0xa (0xfff6) +__uchar 0xa * 0xff == 0xf6 (0xf6) +__longlong 0xa * 0xffff == -0xa (0xfff6) +__ulonglong 0xa * 0xffff == -0xa (0xfff6) +float 0xa * 0xffff == -0xa (0xfff6) +int 0xa < 0xffff == 0x0 (0x0) +__uint 0xa < 0xffff == 0x1 (0x1) +char 0xa < 0xffff == 0x0 (0x0) +__uchar 0xa < 0xff == 0x1 (0x1) +__longlong 0xa < 0xffff == 0x0 (0x0) +__ulonglong 0xa < 0xffff == 0x1 (0x1) +float 0xa < 0xffff == 0x0 (0x0) +int 0xa > 0xffff == 0x1 (0x1) +__uint 0xa > 0xffff == 0x0 (0x0) +char 0xa > 0xffff == 0x1 (0x1) +__uchar 0xa > 0xff == 0x0 (0x0) +__longlong 0xa > 0xffff == 0x1 (0x1) +__ulonglong 0xa > 0xffff == 0x0 (0x0) +float 0xa > 0xffff == 0x1 (0x1) +int 0xa <= 0xffff == 0x0 (0x0) +__uint 0xa <= 0xffff == 0x1 (0x1) +char 0xa <= 0xffff == 0x0 (0x0) +__uchar 0xa <= 0xff == 0x1 (0x1) +__longlong 0xa <= 0xffff == 0x0 (0x0) +__ulonglong 0xa <= 0xffff == 0x1 (0x1) +float 0xa <= 0xffff == 0x0 (0x0) +int 0xa == 0xffff == 0x0 (0x0) +__uint 0xa == 0xffff == 0x0 (0x0) +char 0xa == 0xffff == 0x0 (0x0) +__uchar 0xa == 0xff == 0x0 (0x0) +__longlong 0xa == 0xffff == 0x0 (0x0) +__ulonglong 0xa == 0xffff == 0x0 (0x0) +float 0xa == 0xffff == 0x0 (0x0) +int 0xa != 0xffff == 0x1 (0x1) +__uint 0xa != 0xffff == 0x1 (0x1) +char 0xa != 0xffff == 0x1 (0x1) +__uchar 0xa != 0xff == 0x1 (0x1) +__longlong 0xa != 0xffff == 0x1 (0x1) +__ulonglong 0xa != 0xffff == 0x1 (0x1) +float 0xa != 0xffff == 0x1 (0x1) +int 0xa >= 0xffff == 0x1 (0x1) +__uint 0xa >= 0xffff == 0x0 (0x0) +char 0xa >= 0xffff == 0x1 (0x1) +__uchar 0xa >= 0xff == 0x0 (0x0) +__longlong 0xa >= 0xffff == 0x1 (0x1) +__ulonglong 0xa >= 0xffff == 0x0 (0x0) +float 0xa >= 0xffff == 0x1 (0x1) +int 0xa / 0xffff == -0xa (0xfff6) +__uint 0xa / 0xffff == 0x0 (0x0) +char 0xa / 0xffff == -0xa (0xfff6) +__uchar 0xa / 0xff == 0x0 (0x0) +__longlong 0xa / 0xffff == -0xa (0xfff6) +__ulonglong 0xa / 0xffff == 0x0 (0x0) +float 0xa / 0xffff == -0xa (0xfff6) +int 0xa % 0xffff == 0x0 (0x0) +__uint 0xa % 0xffff == 0xa (0xa) +char 0xa % 0xffff == 0x0 (0x0) +__uchar 0xa % 0xff == 0xa (0xa) +__longlong 0xa % 0xffff == 0x0 (0x0) +__ulonglong 0xa % 0xffff == 0xa (0xa) +0xa * 0x1 == 0xa +0xa / 0x1 == 0xa +0xa % 0x1 == 0x0 +int 0xa ^ 0x1 == 0xb (0xb) +__uint 0xa ^ 0x1 == 0xb (0xb) +char 0xa ^ 0x1 == 0xb (0xb) +__uchar 0xa ^ 0x1 == 0xb (0xb) +__longlong 0xa ^ 0x1 == 0xb (0xb) +__ulonglong 0xa ^ 0x1 == 0xb (0xb) +int 0xa && 0x1 == 0x1 (0x1) +__uint 0xa && 0x1 == 0x1 (0x1) +char 0xa && 0x1 == 0x1 (0x1) +__uchar 0xa && 0x1 == 0x1 (0x1) +__longlong 0xa && 0x1 == 0x1 (0x1) +__ulonglong 0xa && 0x1 == 0x1 (0x1) +int 0xa || 0x1 == 0x1 (0x1) +__uint 0xa || 0x1 == 0x1 (0x1) +char 0xa || 0x1 == 0x1 (0x1) +__uchar 0xa || 0x1 == 0x1 (0x1) +__longlong 0xa || 0x1 == 0x1 (0x1) +__ulonglong 0xa || 0x1 == 0x1 (0x1) +int 0xa & 0x1 == 0x0 (0x0) +__uint 0xa & 0x1 == 0x0 (0x0) +char 0xa & 0x1 == 0x0 (0x0) +__uchar 0xa & 0x1 == 0x0 (0x0) +__longlong 0xa & 0x1 == 0x0 (0x0) +__ulonglong 0xa & 0x1 == 0x0 (0x0) +int 0xa | 0x1 == 0xb (0xb) +__uint 0xa | 0x1 == 0xb (0xb) +char 0xa | 0x1 == 0xb (0xb) +__uchar 0xa | 0x1 == 0xb (0xb) +__longlong 0xa | 0x1 == 0xb (0xb) +__ulonglong 0xa | 0x1 == 0xb (0xb) +int 0xa << 0x2 == 0x28 (0x28) +__uint 0xa << 0x2 == 0x28 (0x28) +char 0xa << 0x2 == 0x28 (0x28) +__uchar 0xa << 0x2 == 0x28 (0x28) +__longlong 0xa << 0x2 == 0x28 (0x28) +__ulonglong 0xa << 0x2 == 0x28 (0x28) +int 0xa >> 0x2 == 0x2 (0x2) +__uint 0xa >> 0x2 == 0x2 (0x2) +char 0xa >> 0x2 == 0x2 (0x2) +__uchar 0xa >> 0x2 == 0x2 (0x2) +__longlong 0xa >> 0x2 == 0x2 (0x2) +__ulonglong 0xa >> 0x2 == 0x2 (0x2) +int 0xa + 0x1 == 0xb (0xb) +__uint 0xa + 0x1 == 0xb (0xb) +char 0xa + 0x1 == 0xb (0xb) +__uchar 0xa + 0x1 == 0xb (0xb) +__longlong 0xa + 0x1 == 0xb (0xb) +__ulonglong 0xa + 0x1 == 0xb (0xb) +float 0xa + 0x1 == 0xb (0xb) +int 0xa - 0x1 == 0x9 (0x9) +__uint 0xa - 0x1 == 0x9 (0x9) +char 0xa - 0x1 == 0x9 (0x9) +__uchar 0xa - 0x1 == 0x9 (0x9) +__longlong 0xa - 0x1 == 0x9 (0x9) +__ulonglong 0xa - 0x1 == 0x9 (0x9) +float 0xa - 0x1 == 0x9 (0x9) +int 0xa * 0x1 == 0xa (0xa) +__uint 0xa * 0x1 == 0xa (0xa) +char 0xa * 0x1 == 0xa (0xa) +__uchar 0xa * 0x1 == 0xa (0xa) +__longlong 0xa * 0x1 == 0xa (0xa) +__ulonglong 0xa * 0x1 == 0xa (0xa) +float 0xa * 0x1 == 0xa (0xa) +int 0xa < 0x1 == 0x0 (0x0) +__uint 0xa < 0x1 == 0x0 (0x0) +char 0xa < 0x1 == 0x0 (0x0) +__uchar 0xa < 0x1 == 0x0 (0x0) +__longlong 0xa < 0x1 == 0x0 (0x0) +__ulonglong 0xa < 0x1 == 0x0 (0x0) +float 0xa < 0x1 == 0x0 (0x0) +int 0xa > 0x1 == 0x1 (0x1) +__uint 0xa > 0x1 == 0x1 (0x1) +char 0xa > 0x1 == 0x1 (0x1) +__uchar 0xa > 0x1 == 0x1 (0x1) +__longlong 0xa > 0x1 == 0x1 (0x1) +__ulonglong 0xa > 0x1 == 0x1 (0x1) +float 0xa > 0x1 == 0x1 (0x1) +int 0xa <= 0x1 == 0x0 (0x0) +__uint 0xa <= 0x1 == 0x0 (0x0) +char 0xa <= 0x1 == 0x0 (0x0) +__uchar 0xa <= 0x1 == 0x0 (0x0) +__longlong 0xa <= 0x1 == 0x0 (0x0) +__ulonglong 0xa <= 0x1 == 0x0 (0x0) +float 0xa <= 0x1 == 0x0 (0x0) +int 0xa == 0x1 == 0x0 (0x0) +__uint 0xa == 0x1 == 0x0 (0x0) +char 0xa == 0x1 == 0x0 (0x0) +__uchar 0xa == 0x1 == 0x0 (0x0) +__longlong 0xa == 0x1 == 0x0 (0x0) +__ulonglong 0xa == 0x1 == 0x0 (0x0) +float 0xa == 0x1 == 0x0 (0x0) +int 0xa != 0x1 == 0x1 (0x1) +__uint 0xa != 0x1 == 0x1 (0x1) +char 0xa != 0x1 == 0x1 (0x1) +__uchar 0xa != 0x1 == 0x1 (0x1) +__longlong 0xa != 0x1 == 0x1 (0x1) +__ulonglong 0xa != 0x1 == 0x1 (0x1) +float 0xa != 0x1 == 0x1 (0x1) +int 0xa >= 0x1 == 0x1 (0x1) +__uint 0xa >= 0x1 == 0x1 (0x1) +char 0xa >= 0x1 == 0x1 (0x1) +__uchar 0xa >= 0x1 == 0x1 (0x1) +__longlong 0xa >= 0x1 == 0x1 (0x1) +__ulonglong 0xa >= 0x1 == 0x1 (0x1) +float 0xa >= 0x1 == 0x1 (0x1) +int 0xa / 0x1 == 0xa (0xa) +__uint 0xa / 0x1 == 0xa (0xa) +char 0xa / 0x1 == 0xa (0xa) +__uchar 0xa / 0x1 == 0xa (0xa) +__longlong 0xa / 0x1 == 0xa (0xa) +__ulonglong 0xa / 0x1 == 0xa (0xa) +float 0xa / 0x1 == 0xa (0xa) +int 0xa % 0x1 == 0x0 (0x0) +__uint 0xa % 0x1 == 0x0 (0x0) +char 0xa % 0x1 == 0x0 (0x0) +__uchar 0xa % 0x1 == 0x0 (0x0) +__longlong 0xa % 0x1 == 0x0 (0x0) +__ulonglong 0xa % 0x1 == 0x0 (0x0) +0xa * 0x2 == 0x14 +0xa / 0x2 == 0x5 +0xa % 0x2 == 0x0 +int 0xa ^ 0x2 == 0x8 (0x8) +__uint 0xa ^ 0x2 == 0x8 (0x8) +char 0xa ^ 0x2 == 0x8 (0x8) +__uchar 0xa ^ 0x2 == 0x8 (0x8) +__longlong 0xa ^ 0x2 == 0x8 (0x8) +__ulonglong 0xa ^ 0x2 == 0x8 (0x8) +int 0xa && 0x2 == 0x1 (0x1) +__uint 0xa && 0x2 == 0x1 (0x1) +char 0xa && 0x2 == 0x1 (0x1) +__uchar 0xa && 0x2 == 0x1 (0x1) +__longlong 0xa && 0x2 == 0x1 (0x1) +__ulonglong 0xa && 0x2 == 0x1 (0x1) +int 0xa || 0x2 == 0x1 (0x1) +__uint 0xa || 0x2 == 0x1 (0x1) +char 0xa || 0x2 == 0x1 (0x1) +__uchar 0xa || 0x2 == 0x1 (0x1) +__longlong 0xa || 0x2 == 0x1 (0x1) +__ulonglong 0xa || 0x2 == 0x1 (0x1) +int 0xa & 0x2 == 0x2 (0x2) +__uint 0xa & 0x2 == 0x2 (0x2) +char 0xa & 0x2 == 0x2 (0x2) +__uchar 0xa & 0x2 == 0x2 (0x2) +__longlong 0xa & 0x2 == 0x2 (0x2) +__ulonglong 0xa & 0x2 == 0x2 (0x2) +int 0xa | 0x2 == 0xa (0xa) +__uint 0xa | 0x2 == 0xa (0xa) +char 0xa | 0x2 == 0xa (0xa) +__uchar 0xa | 0x2 == 0xa (0xa) +__longlong 0xa | 0x2 == 0xa (0xa) +__ulonglong 0xa | 0x2 == 0xa (0xa) +int 0xa << 0x3 == 0x50 (0x50) +__uint 0xa << 0x3 == 0x50 (0x50) +char 0xa << 0x3 == 0x50 (0x50) +__uchar 0xa << 0x3 == 0x50 (0x50) +__longlong 0xa << 0x3 == 0x50 (0x50) +__ulonglong 0xa << 0x3 == 0x50 (0x50) +int 0xa >> 0x3 == 0x1 (0x1) +__uint 0xa >> 0x3 == 0x1 (0x1) +char 0xa >> 0x3 == 0x1 (0x1) +__uchar 0xa >> 0x3 == 0x1 (0x1) +__longlong 0xa >> 0x3 == 0x1 (0x1) +__ulonglong 0xa >> 0x3 == 0x1 (0x1) +int 0xa + 0x2 == 0xc (0xc) +__uint 0xa + 0x2 == 0xc (0xc) +char 0xa + 0x2 == 0xc (0xc) +__uchar 0xa + 0x2 == 0xc (0xc) +__longlong 0xa + 0x2 == 0xc (0xc) +__ulonglong 0xa + 0x2 == 0xc (0xc) +float 0xa + 0x2 == 0xc (0xc) +int 0xa - 0x2 == 0x8 (0x8) +__uint 0xa - 0x2 == 0x8 (0x8) +char 0xa - 0x2 == 0x8 (0x8) +__uchar 0xa - 0x2 == 0x8 (0x8) +__longlong 0xa - 0x2 == 0x8 (0x8) +__ulonglong 0xa - 0x2 == 0x8 (0x8) +float 0xa - 0x2 == 0x8 (0x8) +int 0xa * 0x2 == 0x14 (0x14) +__uint 0xa * 0x2 == 0x14 (0x14) +char 0xa * 0x2 == 0x14 (0x14) +__uchar 0xa * 0x2 == 0x14 (0x14) +__longlong 0xa * 0x2 == 0x14 (0x14) +__ulonglong 0xa * 0x2 == 0x14 (0x14) +float 0xa * 0x2 == 0x14 (0x14) +int 0xa < 0x2 == 0x0 (0x0) +__uint 0xa < 0x2 == 0x0 (0x0) +char 0xa < 0x2 == 0x0 (0x0) +__uchar 0xa < 0x2 == 0x0 (0x0) +__longlong 0xa < 0x2 == 0x0 (0x0) +__ulonglong 0xa < 0x2 == 0x0 (0x0) +float 0xa < 0x2 == 0x0 (0x0) +int 0xa > 0x2 == 0x1 (0x1) +__uint 0xa > 0x2 == 0x1 (0x1) +char 0xa > 0x2 == 0x1 (0x1) +__uchar 0xa > 0x2 == 0x1 (0x1) +__longlong 0xa > 0x2 == 0x1 (0x1) +__ulonglong 0xa > 0x2 == 0x1 (0x1) +float 0xa > 0x2 == 0x1 (0x1) +int 0xa <= 0x2 == 0x0 (0x0) +__uint 0xa <= 0x2 == 0x0 (0x0) +char 0xa <= 0x2 == 0x0 (0x0) +__uchar 0xa <= 0x2 == 0x0 (0x0) +__longlong 0xa <= 0x2 == 0x0 (0x0) +__ulonglong 0xa <= 0x2 == 0x0 (0x0) +float 0xa <= 0x2 == 0x0 (0x0) +int 0xa == 0x2 == 0x0 (0x0) +__uint 0xa == 0x2 == 0x0 (0x0) +char 0xa == 0x2 == 0x0 (0x0) +__uchar 0xa == 0x2 == 0x0 (0x0) +__longlong 0xa == 0x2 == 0x0 (0x0) +__ulonglong 0xa == 0x2 == 0x0 (0x0) +float 0xa == 0x2 == 0x0 (0x0) +int 0xa != 0x2 == 0x1 (0x1) +__uint 0xa != 0x2 == 0x1 (0x1) +char 0xa != 0x2 == 0x1 (0x1) +__uchar 0xa != 0x2 == 0x1 (0x1) +__longlong 0xa != 0x2 == 0x1 (0x1) +__ulonglong 0xa != 0x2 == 0x1 (0x1) +float 0xa != 0x2 == 0x1 (0x1) +int 0xa >= 0x2 == 0x1 (0x1) +__uint 0xa >= 0x2 == 0x1 (0x1) +char 0xa >= 0x2 == 0x1 (0x1) +__uchar 0xa >= 0x2 == 0x1 (0x1) +__longlong 0xa >= 0x2 == 0x1 (0x1) +__ulonglong 0xa >= 0x2 == 0x1 (0x1) +float 0xa >= 0x2 == 0x1 (0x1) +int 0xa / 0x2 == 0x5 (0x5) +__uint 0xa / 0x2 == 0x5 (0x5) +char 0xa / 0x2 == 0x5 (0x5) +__uchar 0xa / 0x2 == 0x5 (0x5) +__longlong 0xa / 0x2 == 0x5 (0x5) +__ulonglong 0xa / 0x2 == 0x5 (0x5) +float 0xa / 0x2 == 0x5 (0x5) +int 0xa % 0x2 == 0x0 (0x0) +__uint 0xa % 0x2 == 0x0 (0x0) +char 0xa % 0x2 == 0x0 (0x0) +__uchar 0xa % 0x2 == 0x0 (0x0) +__longlong 0xa % 0x2 == 0x0 (0x0) +__ulonglong 0xa % 0x2 == 0x0 (0x0) +0xa * 0xfffe == -0x14 +0xa / 0xfffe == -0x5 +0xa % 0xfffe == 0x0 +int 0xa ^ 0xfffe == -0xc (0xfff4) +__uint 0xa ^ 0xfffe == -0xc (0xfff4) +char 0xa ^ 0xfffe == -0xc (0xfff4) +__uchar 0xa ^ 0xfe == 0xf4 (0xf4) +__longlong 0xa ^ 0xfffe == -0xc (0xfff4) +__ulonglong 0xa ^ 0xfffe == -0xc (0xfff4) +int 0xa && 0xfffe == 0x1 (0x1) +__uint 0xa && 0xfffe == 0x1 (0x1) +char 0xa && 0xfffe == 0x1 (0x1) +__uchar 0xa && 0xfe == 0x1 (0x1) +__longlong 0xa && 0xfffe == 0x1 (0x1) +__ulonglong 0xa && 0xfffe == 0x1 (0x1) +int 0xa || 0xfffe == 0x1 (0x1) +__uint 0xa || 0xfffe == 0x1 (0x1) +char 0xa || 0xfffe == 0x1 (0x1) +__uchar 0xa || 0xfe == 0x1 (0x1) +__longlong 0xa || 0xfffe == 0x1 (0x1) +__ulonglong 0xa || 0xfffe == 0x1 (0x1) +int 0xa & 0xfffe == 0xa (0xa) +__uint 0xa & 0xfffe == 0xa (0xa) +char 0xa & 0xfffe == 0xa (0xa) +__uchar 0xa & 0xfe == 0xa (0xa) +__longlong 0xa & 0xfffe == 0xa (0xa) +__ulonglong 0xa & 0xfffe == 0xa (0xa) +int 0xa | 0xfffe == -0x2 (0xfffe) +__uint 0xa | 0xfffe == -0x2 (0xfffe) +char 0xa | 0xfffe == -0x2 (0xfffe) +__uchar 0xa | 0xfe == 0xfe (0xfe) +__longlong 0xa | 0xfffe == -0x2 (0xfffe) +__ulonglong 0xa | 0xfffe == -0x2 (0xfffe) +int 0xa << 0x4 == 0xa0 (0xa0) +__uint 0xa << 0x4 == 0xa0 (0xa0) +char 0xa << 0x4 == -0x60 (0xffa0) +__uchar 0xa << 0x4 == 0xa0 (0xa0) +__longlong 0xa << 0x4 == 0xa0 (0xa0) +__ulonglong 0xa << 0x4 == 0xa0 (0xa0) +int 0xa >> 0x4 == 0x0 (0x0) +__uint 0xa >> 0x4 == 0x0 (0x0) +char 0xa >> 0x4 == 0x0 (0x0) +__uchar 0xa >> 0x4 == 0x0 (0x0) +__longlong 0xa >> 0x4 == 0x0 (0x0) +__ulonglong 0xa >> 0x4 == 0x0 (0x0) +int 0xa + 0xfffe == 0x8 (0x8) +__uint 0xa + 0xfffe == 0x8 (0x8) +char 0xa + 0xfffe == 0x8 (0x8) +__uchar 0xa + 0xfe == 0x8 (0x8) +__longlong 0xa + 0xfffe == 0x8 (0x8) +__ulonglong 0xa + 0xfffe == 0x8 (0x8) +float 0xa + 0xfffe == 0x8 (0x8) +int 0xa - 0xfffe == 0xc (0xc) +__uint 0xa - 0xfffe == 0xc (0xc) +char 0xa - 0xfffe == 0xc (0xc) +__uchar 0xa - 0xfe == 0xc (0xc) +__longlong 0xa - 0xfffe == 0xc (0xc) +__ulonglong 0xa - 0xfffe == 0xc (0xc) +float 0xa - 0xfffe == 0xc (0xc) +int 0xa * 0xfffe == -0x14 (0xffec) +__uint 0xa * 0xfffe == -0x14 (0xffec) +char 0xa * 0xfffe == -0x14 (0xffec) +__uchar 0xa * 0xfe == 0xec (0xec) +__longlong 0xa * 0xfffe == -0x14 (0xffec) +__ulonglong 0xa * 0xfffe == -0x14 (0xffec) +float 0xa * 0xfffe == -0x14 (0xffec) +int 0xa < 0xfffe == 0x0 (0x0) +__uint 0xa < 0xfffe == 0x1 (0x1) +char 0xa < 0xfffe == 0x0 (0x0) +__uchar 0xa < 0xfe == 0x1 (0x1) +__longlong 0xa < 0xfffe == 0x0 (0x0) +__ulonglong 0xa < 0xfffe == 0x1 (0x1) +float 0xa < 0xfffe == 0x0 (0x0) +int 0xa > 0xfffe == 0x1 (0x1) +__uint 0xa > 0xfffe == 0x0 (0x0) +char 0xa > 0xfffe == 0x1 (0x1) +__uchar 0xa > 0xfe == 0x0 (0x0) +__longlong 0xa > 0xfffe == 0x1 (0x1) +__ulonglong 0xa > 0xfffe == 0x0 (0x0) +float 0xa > 0xfffe == 0x1 (0x1) +int 0xa <= 0xfffe == 0x0 (0x0) +__uint 0xa <= 0xfffe == 0x1 (0x1) +char 0xa <= 0xfffe == 0x0 (0x0) +__uchar 0xa <= 0xfe == 0x1 (0x1) +__longlong 0xa <= 0xfffe == 0x0 (0x0) +__ulonglong 0xa <= 0xfffe == 0x1 (0x1) +float 0xa <= 0xfffe == 0x0 (0x0) +int 0xa == 0xfffe == 0x0 (0x0) +__uint 0xa == 0xfffe == 0x0 (0x0) +char 0xa == 0xfffe == 0x0 (0x0) +__uchar 0xa == 0xfe == 0x0 (0x0) +__longlong 0xa == 0xfffe == 0x0 (0x0) +__ulonglong 0xa == 0xfffe == 0x0 (0x0) +float 0xa == 0xfffe == 0x0 (0x0) +int 0xa != 0xfffe == 0x1 (0x1) +__uint 0xa != 0xfffe == 0x1 (0x1) +char 0xa != 0xfffe == 0x1 (0x1) +__uchar 0xa != 0xfe == 0x1 (0x1) +__longlong 0xa != 0xfffe == 0x1 (0x1) +__ulonglong 0xa != 0xfffe == 0x1 (0x1) +float 0xa != 0xfffe == 0x1 (0x1) +int 0xa >= 0xfffe == 0x1 (0x1) +__uint 0xa >= 0xfffe == 0x0 (0x0) +char 0xa >= 0xfffe == 0x1 (0x1) +__uchar 0xa >= 0xfe == 0x0 (0x0) +__longlong 0xa >= 0xfffe == 0x1 (0x1) +__ulonglong 0xa >= 0xfffe == 0x0 (0x0) +float 0xa >= 0xfffe == 0x1 (0x1) +int 0xa / 0xfffe == -0x5 (0xfffb) +__uint 0xa / 0xfffe == 0x0 (0x0) +char 0xa / 0xfffe == -0x5 (0xfffb) +__uchar 0xa / 0xfe == 0x0 (0x0) +__longlong 0xa / 0xfffe == -0x5 (0xfffb) +__ulonglong 0xa / 0xfffe == 0x0 (0x0) +float 0xa / 0xfffe == -0x5 (0xfffb) +int 0xa % 0xfffe == 0x0 (0x0) +__uint 0xa % 0xfffe == 0xa (0xa) +char 0xa % 0xfffe == 0x0 (0x0) +__uchar 0xa % 0xfe == 0xa (0xa) +__longlong 0xa % 0xfffe == 0x0 (0x0) +__ulonglong 0xa % 0xfffe == 0xa (0xa) +0xa * 0x4 == 0x28 +0xa / 0x4 == 0x2 +0xa % 0x4 == 0x2 +int 0xa ^ 0x4 == 0xe (0xe) +__uint 0xa ^ 0x4 == 0xe (0xe) +char 0xa ^ 0x4 == 0xe (0xe) +__uchar 0xa ^ 0x4 == 0xe (0xe) +__longlong 0xa ^ 0x4 == 0xe (0xe) +__ulonglong 0xa ^ 0x4 == 0xe (0xe) +int 0xa && 0x4 == 0x1 (0x1) +__uint 0xa && 0x4 == 0x1 (0x1) +char 0xa && 0x4 == 0x1 (0x1) +__uchar 0xa && 0x4 == 0x1 (0x1) +__longlong 0xa && 0x4 == 0x1 (0x1) +__ulonglong 0xa && 0x4 == 0x1 (0x1) +int 0xa || 0x4 == 0x1 (0x1) +__uint 0xa || 0x4 == 0x1 (0x1) +char 0xa || 0x4 == 0x1 (0x1) +__uchar 0xa || 0x4 == 0x1 (0x1) +__longlong 0xa || 0x4 == 0x1 (0x1) +__ulonglong 0xa || 0x4 == 0x1 (0x1) +int 0xa & 0x4 == 0x0 (0x0) +__uint 0xa & 0x4 == 0x0 (0x0) +char 0xa & 0x4 == 0x0 (0x0) +__uchar 0xa & 0x4 == 0x0 (0x0) +__longlong 0xa & 0x4 == 0x0 (0x0) +__ulonglong 0xa & 0x4 == 0x0 (0x0) +int 0xa | 0x4 == 0xe (0xe) +__uint 0xa | 0x4 == 0xe (0xe) +char 0xa | 0x4 == 0xe (0xe) +__uchar 0xa | 0x4 == 0xe (0xe) +__longlong 0xa | 0x4 == 0xe (0xe) +__ulonglong 0xa | 0x4 == 0xe (0xe) +int 0xa << 0x5 == 0x140 (0x140) +__uint 0xa << 0x5 == 0x140 (0x140) +char 0xa << 0x5 == 0x40 (0x40) +__uchar 0xa << 0x5 == 0x40 (0x40) +__longlong 0xa << 0x5 == 0x140 (0x140) +__ulonglong 0xa << 0x5 == 0x140 (0x140) +int 0xa >> 0x5 == 0x0 (0x0) +__uint 0xa >> 0x5 == 0x0 (0x0) +char 0xa >> 0x5 == 0x0 (0x0) +__uchar 0xa >> 0x5 == 0x0 (0x0) +__longlong 0xa >> 0x5 == 0x0 (0x0) +__ulonglong 0xa >> 0x5 == 0x0 (0x0) +int 0xa + 0x4 == 0xe (0xe) +__uint 0xa + 0x4 == 0xe (0xe) +char 0xa + 0x4 == 0xe (0xe) +__uchar 0xa + 0x4 == 0xe (0xe) +__longlong 0xa + 0x4 == 0xe (0xe) +__ulonglong 0xa + 0x4 == 0xe (0xe) +float 0xa + 0x4 == 0xe (0xe) +int 0xa - 0x4 == 0x6 (0x6) +__uint 0xa - 0x4 == 0x6 (0x6) +char 0xa - 0x4 == 0x6 (0x6) +__uchar 0xa - 0x4 == 0x6 (0x6) +__longlong 0xa - 0x4 == 0x6 (0x6) +__ulonglong 0xa - 0x4 == 0x6 (0x6) +float 0xa - 0x4 == 0x6 (0x6) +int 0xa * 0x4 == 0x28 (0x28) +__uint 0xa * 0x4 == 0x28 (0x28) +char 0xa * 0x4 == 0x28 (0x28) +__uchar 0xa * 0x4 == 0x28 (0x28) +__longlong 0xa * 0x4 == 0x28 (0x28) +__ulonglong 0xa * 0x4 == 0x28 (0x28) +float 0xa * 0x4 == 0x28 (0x28) +int 0xa < 0x4 == 0x0 (0x0) +__uint 0xa < 0x4 == 0x0 (0x0) +char 0xa < 0x4 == 0x0 (0x0) +__uchar 0xa < 0x4 == 0x0 (0x0) +__longlong 0xa < 0x4 == 0x0 (0x0) +__ulonglong 0xa < 0x4 == 0x0 (0x0) +float 0xa < 0x4 == 0x0 (0x0) +int 0xa > 0x4 == 0x1 (0x1) +__uint 0xa > 0x4 == 0x1 (0x1) +char 0xa > 0x4 == 0x1 (0x1) +__uchar 0xa > 0x4 == 0x1 (0x1) +__longlong 0xa > 0x4 == 0x1 (0x1) +__ulonglong 0xa > 0x4 == 0x1 (0x1) +float 0xa > 0x4 == 0x1 (0x1) +int 0xa <= 0x4 == 0x0 (0x0) +__uint 0xa <= 0x4 == 0x0 (0x0) +char 0xa <= 0x4 == 0x0 (0x0) +__uchar 0xa <= 0x4 == 0x0 (0x0) +__longlong 0xa <= 0x4 == 0x0 (0x0) +__ulonglong 0xa <= 0x4 == 0x0 (0x0) +float 0xa <= 0x4 == 0x0 (0x0) +int 0xa == 0x4 == 0x0 (0x0) +__uint 0xa == 0x4 == 0x0 (0x0) +char 0xa == 0x4 == 0x0 (0x0) +__uchar 0xa == 0x4 == 0x0 (0x0) +__longlong 0xa == 0x4 == 0x0 (0x0) +__ulonglong 0xa == 0x4 == 0x0 (0x0) +float 0xa == 0x4 == 0x0 (0x0) +int 0xa != 0x4 == 0x1 (0x1) +__uint 0xa != 0x4 == 0x1 (0x1) +char 0xa != 0x4 == 0x1 (0x1) +__uchar 0xa != 0x4 == 0x1 (0x1) +__longlong 0xa != 0x4 == 0x1 (0x1) +__ulonglong 0xa != 0x4 == 0x1 (0x1) +float 0xa != 0x4 == 0x1 (0x1) +int 0xa >= 0x4 == 0x1 (0x1) +__uint 0xa >= 0x4 == 0x1 (0x1) +char 0xa >= 0x4 == 0x1 (0x1) +__uchar 0xa >= 0x4 == 0x1 (0x1) +__longlong 0xa >= 0x4 == 0x1 (0x1) +__ulonglong 0xa >= 0x4 == 0x1 (0x1) +float 0xa >= 0x4 == 0x1 (0x1) +int 0xa / 0x4 == 0x2 (0x2) +__uint 0xa / 0x4 == 0x2 (0x2) +char 0xa / 0x4 == 0x2 (0x2) +__uchar 0xa / 0x4 == 0x2 (0x2) +__longlong 0xa / 0x4 == 0x2 (0x2) +__ulonglong 0xa / 0x4 == 0x2 (0x2) +float 0xa / 0x4 == 0x2 (0x2) +int 0xa % 0x4 == 0x2 (0x2) +__uint 0xa % 0x4 == 0x2 (0x2) +char 0xa % 0x4 == 0x2 (0x2) +__uchar 0xa % 0x4 == 0x2 (0x2) +__longlong 0xa % 0x4 == 0x2 (0x2) +__ulonglong 0xa % 0x4 == 0x2 (0x2) +0xa * 0xfffc == -0x28 +0xa / 0xfffc == -0x2 +0xa % 0xfffc == 0x2 +int 0xa ^ 0xfffc == -0xa (0xfff6) +__uint 0xa ^ 0xfffc == -0xa (0xfff6) +char 0xa ^ 0xfffc == -0xa (0xfff6) +__uchar 0xa ^ 0xfc == 0xf6 (0xf6) +__longlong 0xa ^ 0xfffc == -0xa (0xfff6) +__ulonglong 0xa ^ 0xfffc == -0xa (0xfff6) +int 0xa && 0xfffc == 0x1 (0x1) +__uint 0xa && 0xfffc == 0x1 (0x1) +char 0xa && 0xfffc == 0x1 (0x1) +__uchar 0xa && 0xfc == 0x1 (0x1) +__longlong 0xa && 0xfffc == 0x1 (0x1) +__ulonglong 0xa && 0xfffc == 0x1 (0x1) +int 0xa || 0xfffc == 0x1 (0x1) +__uint 0xa || 0xfffc == 0x1 (0x1) +char 0xa || 0xfffc == 0x1 (0x1) +__uchar 0xa || 0xfc == 0x1 (0x1) +__longlong 0xa || 0xfffc == 0x1 (0x1) +__ulonglong 0xa || 0xfffc == 0x1 (0x1) +int 0xa & 0xfffc == 0x8 (0x8) +__uint 0xa & 0xfffc == 0x8 (0x8) +char 0xa & 0xfffc == 0x8 (0x8) +__uchar 0xa & 0xfc == 0x8 (0x8) +__longlong 0xa & 0xfffc == 0x8 (0x8) +__ulonglong 0xa & 0xfffc == 0x8 (0x8) +int 0xa | 0xfffc == -0x2 (0xfffe) +__uint 0xa | 0xfffc == -0x2 (0xfffe) +char 0xa | 0xfffc == -0x2 (0xfffe) +__uchar 0xa | 0xfc == 0xfe (0xfe) +__longlong 0xa | 0xfffc == -0x2 (0xfffe) +__ulonglong 0xa | 0xfffc == -0x2 (0xfffe) +int 0xa << 0x6 == 0x280 (0x280) +__uint 0xa << 0x6 == 0x280 (0x280) +char 0xa << 0x6 == -0x80 (0xff80) +__uchar 0xa << 0x6 == 0x80 (0x80) +__longlong 0xa << 0x6 == 0x280 (0x280) +__ulonglong 0xa << 0x6 == 0x280 (0x280) +int 0xa >> 0x6 == 0x0 (0x0) +__uint 0xa >> 0x6 == 0x0 (0x0) +char 0xa >> 0x6 == 0x0 (0x0) +__uchar 0xa >> 0x6 == 0x0 (0x0) +__longlong 0xa >> 0x6 == 0x0 (0x0) +__ulonglong 0xa >> 0x6 == 0x0 (0x0) +int 0xa + 0xfffc == 0x6 (0x6) +__uint 0xa + 0xfffc == 0x6 (0x6) +char 0xa + 0xfffc == 0x6 (0x6) +__uchar 0xa + 0xfc == 0x6 (0x6) +__longlong 0xa + 0xfffc == 0x6 (0x6) +__ulonglong 0xa + 0xfffc == 0x6 (0x6) +float 0xa + 0xfffc == 0x6 (0x6) +int 0xa - 0xfffc == 0xe (0xe) +__uint 0xa - 0xfffc == 0xe (0xe) +char 0xa - 0xfffc == 0xe (0xe) +__uchar 0xa - 0xfc == 0xe (0xe) +__longlong 0xa - 0xfffc == 0xe (0xe) +__ulonglong 0xa - 0xfffc == 0xe (0xe) +float 0xa - 0xfffc == 0xe (0xe) +int 0xa * 0xfffc == -0x28 (0xffd8) +__uint 0xa * 0xfffc == -0x28 (0xffd8) +char 0xa * 0xfffc == -0x28 (0xffd8) +__uchar 0xa * 0xfc == 0xd8 (0xd8) +__longlong 0xa * 0xfffc == -0x28 (0xffd8) +__ulonglong 0xa * 0xfffc == -0x28 (0xffd8) +float 0xa * 0xfffc == -0x28 (0xffd8) +int 0xa < 0xfffc == 0x0 (0x0) +__uint 0xa < 0xfffc == 0x1 (0x1) +char 0xa < 0xfffc == 0x0 (0x0) +__uchar 0xa < 0xfc == 0x1 (0x1) +__longlong 0xa < 0xfffc == 0x0 (0x0) +__ulonglong 0xa < 0xfffc == 0x1 (0x1) +float 0xa < 0xfffc == 0x0 (0x0) +int 0xa > 0xfffc == 0x1 (0x1) +__uint 0xa > 0xfffc == 0x0 (0x0) +char 0xa > 0xfffc == 0x1 (0x1) +__uchar 0xa > 0xfc == 0x0 (0x0) +__longlong 0xa > 0xfffc == 0x1 (0x1) +__ulonglong 0xa > 0xfffc == 0x0 (0x0) +float 0xa > 0xfffc == 0x1 (0x1) +int 0xa <= 0xfffc == 0x0 (0x0) +__uint 0xa <= 0xfffc == 0x1 (0x1) +char 0xa <= 0xfffc == 0x0 (0x0) +__uchar 0xa <= 0xfc == 0x1 (0x1) +__longlong 0xa <= 0xfffc == 0x0 (0x0) +__ulonglong 0xa <= 0xfffc == 0x1 (0x1) +float 0xa <= 0xfffc == 0x0 (0x0) +int 0xa == 0xfffc == 0x0 (0x0) +__uint 0xa == 0xfffc == 0x0 (0x0) +char 0xa == 0xfffc == 0x0 (0x0) +__uchar 0xa == 0xfc == 0x0 (0x0) +__longlong 0xa == 0xfffc == 0x0 (0x0) +__ulonglong 0xa == 0xfffc == 0x0 (0x0) +float 0xa == 0xfffc == 0x0 (0x0) +int 0xa != 0xfffc == 0x1 (0x1) +__uint 0xa != 0xfffc == 0x1 (0x1) +char 0xa != 0xfffc == 0x1 (0x1) +__uchar 0xa != 0xfc == 0x1 (0x1) +__longlong 0xa != 0xfffc == 0x1 (0x1) +__ulonglong 0xa != 0xfffc == 0x1 (0x1) +float 0xa != 0xfffc == 0x1 (0x1) +int 0xa >= 0xfffc == 0x1 (0x1) +__uint 0xa >= 0xfffc == 0x0 (0x0) +char 0xa >= 0xfffc == 0x1 (0x1) +__uchar 0xa >= 0xfc == 0x0 (0x0) +__longlong 0xa >= 0xfffc == 0x1 (0x1) +__ulonglong 0xa >= 0xfffc == 0x0 (0x0) +float 0xa >= 0xfffc == 0x1 (0x1) +int 0xa / 0xfffc == -0x2 (0xfffe) +__uint 0xa / 0xfffc == 0x0 (0x0) +char 0xa / 0xfffc == -0x2 (0xfffe) +__uchar 0xa / 0xfc == 0x0 (0x0) +__longlong 0xa / 0xfffc == -0x2 (0xfffe) +__ulonglong 0xa / 0xfffc == 0x0 (0x0) +float 0xa / 0xfffc == -0x2 (0xfffe) +int 0xa % 0xfffc == 0x2 (0x2) +__uint 0xa % 0xfffc == 0xa (0xa) +char 0xa % 0xfffc == 0x2 (0x2) +__uchar 0xa % 0xfc == 0xa (0xa) +__longlong 0xa % 0xfffc == 0x2 (0x2) +__ulonglong 0xa % 0xfffc == 0xa (0xa) +0xa * 0xa == 0x64 +0xa / 0xa == 0x1 +0xa % 0xa == 0x0 +int 0xa ^ 0xa == 0x0 (0x0) +__uint 0xa ^ 0xa == 0x0 (0x0) +char 0xa ^ 0xa == 0x0 (0x0) +__uchar 0xa ^ 0xa == 0x0 (0x0) +__longlong 0xa ^ 0xa == 0x0 (0x0) +__ulonglong 0xa ^ 0xa == 0x0 (0x0) +int 0xa && 0xa == 0x1 (0x1) +__uint 0xa && 0xa == 0x1 (0x1) +char 0xa && 0xa == 0x1 (0x1) +__uchar 0xa && 0xa == 0x1 (0x1) +__longlong 0xa && 0xa == 0x1 (0x1) +__ulonglong 0xa && 0xa == 0x1 (0x1) +int 0xa || 0xa == 0x1 (0x1) +__uint 0xa || 0xa == 0x1 (0x1) +char 0xa || 0xa == 0x1 (0x1) +__uchar 0xa || 0xa == 0x1 (0x1) +__longlong 0xa || 0xa == 0x1 (0x1) +__ulonglong 0xa || 0xa == 0x1 (0x1) +int 0xa & 0xa == 0xa (0xa) +__uint 0xa & 0xa == 0xa (0xa) +char 0xa & 0xa == 0xa (0xa) +__uchar 0xa & 0xa == 0xa (0xa) +__longlong 0xa & 0xa == 0xa (0xa) +__ulonglong 0xa & 0xa == 0xa (0xa) +int 0xa | 0xa == 0xa (0xa) +__uint 0xa | 0xa == 0xa (0xa) +char 0xa | 0xa == 0xa (0xa) +__uchar 0xa | 0xa == 0xa (0xa) +__longlong 0xa | 0xa == 0xa (0xa) +__ulonglong 0xa | 0xa == 0xa (0xa) +int 0xa << 0x7 == 0x500 (0x500) +__uint 0xa << 0x7 == 0x500 (0x500) +char 0xa << 0x7 == 0x0 (0x0) +__uchar 0xa << 0x7 == 0x0 (0x0) +__longlong 0xa << 0x7 == 0x500 (0x500) +__ulonglong 0xa << 0x7 == 0x500 (0x500) +int 0xa >> 0x7 == 0x0 (0x0) +__uint 0xa >> 0x7 == 0x0 (0x0) +char 0xa >> 0x7 == 0x0 (0x0) +__uchar 0xa >> 0x7 == 0x0 (0x0) +__longlong 0xa >> 0x7 == 0x0 (0x0) +__ulonglong 0xa >> 0x7 == 0x0 (0x0) +int 0xa + 0xa == 0x14 (0x14) +__uint 0xa + 0xa == 0x14 (0x14) +char 0xa + 0xa == 0x14 (0x14) +__uchar 0xa + 0xa == 0x14 (0x14) +__longlong 0xa + 0xa == 0x14 (0x14) +__ulonglong 0xa + 0xa == 0x14 (0x14) +float 0xa + 0xa == 0x14 (0x14) +int 0xa - 0xa == 0x0 (0x0) +__uint 0xa - 0xa == 0x0 (0x0) +char 0xa - 0xa == 0x0 (0x0) +__uchar 0xa - 0xa == 0x0 (0x0) +__longlong 0xa - 0xa == 0x0 (0x0) +__ulonglong 0xa - 0xa == 0x0 (0x0) +float 0xa - 0xa == 0x0 (0x0) +int 0xa * 0xa == 0x64 (0x64) +__uint 0xa * 0xa == 0x64 (0x64) +char 0xa * 0xa == 0x64 (0x64) +__uchar 0xa * 0xa == 0x64 (0x64) +__longlong 0xa * 0xa == 0x64 (0x64) +__ulonglong 0xa * 0xa == 0x64 (0x64) +float 0xa * 0xa == 0x64 (0x64) +int 0xa < 0xa == 0x0 (0x0) +__uint 0xa < 0xa == 0x0 (0x0) +char 0xa < 0xa == 0x0 (0x0) +__uchar 0xa < 0xa == 0x0 (0x0) +__longlong 0xa < 0xa == 0x0 (0x0) +__ulonglong 0xa < 0xa == 0x0 (0x0) +float 0xa < 0xa == 0x0 (0x0) +int 0xa > 0xa == 0x0 (0x0) +__uint 0xa > 0xa == 0x0 (0x0) +char 0xa > 0xa == 0x0 (0x0) +__uchar 0xa > 0xa == 0x0 (0x0) +__longlong 0xa > 0xa == 0x0 (0x0) +__ulonglong 0xa > 0xa == 0x0 (0x0) +float 0xa > 0xa == 0x0 (0x0) +int 0xa <= 0xa == 0x1 (0x1) +__uint 0xa <= 0xa == 0x1 (0x1) +char 0xa <= 0xa == 0x1 (0x1) +__uchar 0xa <= 0xa == 0x1 (0x1) +__longlong 0xa <= 0xa == 0x1 (0x1) +__ulonglong 0xa <= 0xa == 0x1 (0x1) +float 0xa <= 0xa == 0x1 (0x1) +int 0xa == 0xa == 0x1 (0x1) +__uint 0xa == 0xa == 0x1 (0x1) +char 0xa == 0xa == 0x1 (0x1) +__uchar 0xa == 0xa == 0x1 (0x1) +__longlong 0xa == 0xa == 0x1 (0x1) +__ulonglong 0xa == 0xa == 0x1 (0x1) +float 0xa == 0xa == 0x1 (0x1) +int 0xa != 0xa == 0x0 (0x0) +__uint 0xa != 0xa == 0x0 (0x0) +char 0xa != 0xa == 0x0 (0x0) +__uchar 0xa != 0xa == 0x0 (0x0) +__longlong 0xa != 0xa == 0x0 (0x0) +__ulonglong 0xa != 0xa == 0x0 (0x0) +float 0xa != 0xa == 0x0 (0x0) +int 0xa >= 0xa == 0x1 (0x1) +__uint 0xa >= 0xa == 0x1 (0x1) +char 0xa >= 0xa == 0x1 (0x1) +__uchar 0xa >= 0xa == 0x1 (0x1) +__longlong 0xa >= 0xa == 0x1 (0x1) +__ulonglong 0xa >= 0xa == 0x1 (0x1) +float 0xa >= 0xa == 0x1 (0x1) +int 0xa / 0xa == 0x1 (0x1) +__uint 0xa / 0xa == 0x1 (0x1) +char 0xa / 0xa == 0x1 (0x1) +__uchar 0xa / 0xa == 0x1 (0x1) +__longlong 0xa / 0xa == 0x1 (0x1) +__ulonglong 0xa / 0xa == 0x1 (0x1) +float 0xa / 0xa == 0x1 (0x1) +int 0xa % 0xa == 0x0 (0x0) +__uint 0xa % 0xa == 0x0 (0x0) +char 0xa % 0xa == 0x0 (0x0) +__uchar 0xa % 0xa == 0x0 (0x0) +__longlong 0xa % 0xa == 0x0 (0x0) +__ulonglong 0xa % 0xa == 0x0 (0x0) +0xa * 0xfff6 == -0x64 +0xa / 0xfff6 == -0x1 +0xa % 0xfff6 == 0x0 +int 0xa ^ 0xfff6 == -0x4 (0xfffc) +__uint 0xa ^ 0xfff6 == -0x4 (0xfffc) +char 0xa ^ 0xfff6 == -0x4 (0xfffc) +__uchar 0xa ^ 0xf6 == 0xfc (0xfc) +__longlong 0xa ^ 0xfff6 == -0x4 (0xfffc) +__ulonglong 0xa ^ 0xfff6 == -0x4 (0xfffc) +int 0xa && 0xfff6 == 0x1 (0x1) +__uint 0xa && 0xfff6 == 0x1 (0x1) +char 0xa && 0xfff6 == 0x1 (0x1) +__uchar 0xa && 0xf6 == 0x1 (0x1) +__longlong 0xa && 0xfff6 == 0x1 (0x1) +__ulonglong 0xa && 0xfff6 == 0x1 (0x1) +int 0xa || 0xfff6 == 0x1 (0x1) +__uint 0xa || 0xfff6 == 0x1 (0x1) +char 0xa || 0xfff6 == 0x1 (0x1) +__uchar 0xa || 0xf6 == 0x1 (0x1) +__longlong 0xa || 0xfff6 == 0x1 (0x1) +__ulonglong 0xa || 0xfff6 == 0x1 (0x1) +int 0xa & 0xfff6 == 0x2 (0x2) +__uint 0xa & 0xfff6 == 0x2 (0x2) +char 0xa & 0xfff6 == 0x2 (0x2) +__uchar 0xa & 0xf6 == 0x2 (0x2) +__longlong 0xa & 0xfff6 == 0x2 (0x2) +__ulonglong 0xa & 0xfff6 == 0x2 (0x2) +int 0xa | 0xfff6 == -0x2 (0xfffe) +__uint 0xa | 0xfff6 == -0x2 (0xfffe) +char 0xa | 0xfff6 == -0x2 (0xfffe) +__uchar 0xa | 0xf6 == 0xfe (0xfe) +__longlong 0xa | 0xfff6 == -0x2 (0xfffe) +__ulonglong 0xa | 0xfff6 == -0x2 (0xfffe) +int 0xa << 0x8 == 0xa00 (0xa00) +__uint 0xa << 0x8 == 0xa00 (0xa00) +char 0xa << 0x8 == 0x0 (0x0) +__uchar 0xa << 0x8 == 0x0 (0x0) +__longlong 0xa << 0x8 == 0xa00 (0xa00) +__ulonglong 0xa << 0x8 == 0xa00 (0xa00) +int 0xa >> 0x8 == 0x0 (0x0) +__uint 0xa >> 0x8 == 0x0 (0x0) +char 0xa >> 0x8 == 0x0 (0x0) +__uchar 0xa >> 0x8 == 0x0 (0x0) +__longlong 0xa >> 0x8 == 0x0 (0x0) +__ulonglong 0xa >> 0x8 == 0x0 (0x0) +int 0xa + 0xfff6 == 0x0 (0x0) +__uint 0xa + 0xfff6 == 0x0 (0x0) +char 0xa + 0xfff6 == 0x0 (0x0) +__uchar 0xa + 0xf6 == 0x0 (0x0) +__longlong 0xa + 0xfff6 == 0x0 (0x0) +__ulonglong 0xa + 0xfff6 == 0x0 (0x0) +float 0xa + 0xfff6 == 0x0 (0x0) +int 0xa - 0xfff6 == 0x14 (0x14) +__uint 0xa - 0xfff6 == 0x14 (0x14) +char 0xa - 0xfff6 == 0x14 (0x14) +__uchar 0xa - 0xf6 == 0x14 (0x14) +__longlong 0xa - 0xfff6 == 0x14 (0x14) +__ulonglong 0xa - 0xfff6 == 0x14 (0x14) +float 0xa - 0xfff6 == 0x14 (0x14) +int 0xa * 0xfff6 == -0x64 (0xff9c) +__uint 0xa * 0xfff6 == -0x64 (0xff9c) +char 0xa * 0xfff6 == -0x64 (0xff9c) +__uchar 0xa * 0xf6 == 0x9c (0x9c) +__longlong 0xa * 0xfff6 == -0x64 (0xff9c) +__ulonglong 0xa * 0xfff6 == -0x64 (0xff9c) +float 0xa * 0xfff6 == -0x64 (0xff9c) +int 0xa < 0xfff6 == 0x0 (0x0) +__uint 0xa < 0xfff6 == 0x1 (0x1) +char 0xa < 0xfff6 == 0x0 (0x0) +__uchar 0xa < 0xf6 == 0x1 (0x1) +__longlong 0xa < 0xfff6 == 0x0 (0x0) +__ulonglong 0xa < 0xfff6 == 0x1 (0x1) +float 0xa < 0xfff6 == 0x0 (0x0) +int 0xa > 0xfff6 == 0x1 (0x1) +__uint 0xa > 0xfff6 == 0x0 (0x0) +char 0xa > 0xfff6 == 0x1 (0x1) +__uchar 0xa > 0xf6 == 0x0 (0x0) +__longlong 0xa > 0xfff6 == 0x1 (0x1) +__ulonglong 0xa > 0xfff6 == 0x0 (0x0) +float 0xa > 0xfff6 == 0x1 (0x1) +int 0xa <= 0xfff6 == 0x0 (0x0) +__uint 0xa <= 0xfff6 == 0x1 (0x1) +char 0xa <= 0xfff6 == 0x0 (0x0) +__uchar 0xa <= 0xf6 == 0x1 (0x1) +__longlong 0xa <= 0xfff6 == 0x0 (0x0) +__ulonglong 0xa <= 0xfff6 == 0x1 (0x1) +float 0xa <= 0xfff6 == 0x0 (0x0) +int 0xa == 0xfff6 == 0x0 (0x0) +__uint 0xa == 0xfff6 == 0x0 (0x0) +char 0xa == 0xfff6 == 0x0 (0x0) +__uchar 0xa == 0xf6 == 0x0 (0x0) +__longlong 0xa == 0xfff6 == 0x0 (0x0) +__ulonglong 0xa == 0xfff6 == 0x0 (0x0) +float 0xa == 0xfff6 == 0x0 (0x0) +int 0xa != 0xfff6 == 0x1 (0x1) +__uint 0xa != 0xfff6 == 0x1 (0x1) +char 0xa != 0xfff6 == 0x1 (0x1) +__uchar 0xa != 0xf6 == 0x1 (0x1) +__longlong 0xa != 0xfff6 == 0x1 (0x1) +__ulonglong 0xa != 0xfff6 == 0x1 (0x1) +float 0xa != 0xfff6 == 0x1 (0x1) +int 0xa >= 0xfff6 == 0x1 (0x1) +__uint 0xa >= 0xfff6 == 0x0 (0x0) +char 0xa >= 0xfff6 == 0x1 (0x1) +__uchar 0xa >= 0xf6 == 0x0 (0x0) +__longlong 0xa >= 0xfff6 == 0x1 (0x1) +__ulonglong 0xa >= 0xfff6 == 0x0 (0x0) +float 0xa >= 0xfff6 == 0x1 (0x1) +int 0xa / 0xfff6 == -0x1 (0xffff) +__uint 0xa / 0xfff6 == 0x0 (0x0) +char 0xa / 0xfff6 == -0x1 (0xffff) +__uchar 0xa / 0xf6 == 0x0 (0x0) +__longlong 0xa / 0xfff6 == -0x1 (0xffff) +__ulonglong 0xa / 0xfff6 == 0x0 (0x0) +float 0xa / 0xfff6 == -0x1 (0xffff) +int 0xa % 0xfff6 == 0x0 (0x0) +__uint 0xa % 0xfff6 == 0xa (0xa) +char 0xa % 0xfff6 == 0x0 (0x0) +__uchar 0xa % 0xf6 == 0xa (0xa) +__longlong 0xa % 0xfff6 == 0x0 (0x0) +__ulonglong 0xa % 0xfff6 == 0xa (0xa) +0xa * 0x5 == 0x32 +0xa / 0x5 == 0x2 +0xa % 0x5 == 0x0 +int 0xa ^ 0x5 == 0xf (0xf) +__uint 0xa ^ 0x5 == 0xf (0xf) +char 0xa ^ 0x5 == 0xf (0xf) +__uchar 0xa ^ 0x5 == 0xf (0xf) +__longlong 0xa ^ 0x5 == 0xf (0xf) +__ulonglong 0xa ^ 0x5 == 0xf (0xf) +int 0xa && 0x5 == 0x1 (0x1) +__uint 0xa && 0x5 == 0x1 (0x1) +char 0xa && 0x5 == 0x1 (0x1) +__uchar 0xa && 0x5 == 0x1 (0x1) +__longlong 0xa && 0x5 == 0x1 (0x1) +__ulonglong 0xa && 0x5 == 0x1 (0x1) +int 0xa || 0x5 == 0x1 (0x1) +__uint 0xa || 0x5 == 0x1 (0x1) +char 0xa || 0x5 == 0x1 (0x1) +__uchar 0xa || 0x5 == 0x1 (0x1) +__longlong 0xa || 0x5 == 0x1 (0x1) +__ulonglong 0xa || 0x5 == 0x1 (0x1) +int 0xa & 0x5 == 0x0 (0x0) +__uint 0xa & 0x5 == 0x0 (0x0) +char 0xa & 0x5 == 0x0 (0x0) +__uchar 0xa & 0x5 == 0x0 (0x0) +__longlong 0xa & 0x5 == 0x0 (0x0) +__ulonglong 0xa & 0x5 == 0x0 (0x0) +int 0xa | 0x5 == 0xf (0xf) +__uint 0xa | 0x5 == 0xf (0xf) +char 0xa | 0x5 == 0xf (0xf) +__uchar 0xa | 0x5 == 0xf (0xf) +__longlong 0xa | 0x5 == 0xf (0xf) +__ulonglong 0xa | 0x5 == 0xf (0xf) +int 0xa << 0x9 == 0x1400 (0x1400) +__uint 0xa << 0x9 == 0x1400 (0x1400) +char 0xa << 0x9 == 0x0 (0x0) +__uchar 0xa << 0x9 == 0x0 (0x0) +__longlong 0xa << 0x9 == 0x1400 (0x1400) +__ulonglong 0xa << 0x9 == 0x1400 (0x1400) +int 0xa >> 0x9 == 0x0 (0x0) +__uint 0xa >> 0x9 == 0x0 (0x0) +char 0xa >> 0x9 == 0x0 (0x0) +__uchar 0xa >> 0x9 == 0x0 (0x0) +__longlong 0xa >> 0x9 == 0x0 (0x0) +__ulonglong 0xa >> 0x9 == 0x0 (0x0) +int 0xa + 0x5 == 0xf (0xf) +__uint 0xa + 0x5 == 0xf (0xf) +char 0xa + 0x5 == 0xf (0xf) +__uchar 0xa + 0x5 == 0xf (0xf) +__longlong 0xa + 0x5 == 0xf (0xf) +__ulonglong 0xa + 0x5 == 0xf (0xf) +float 0xa + 0x5 == 0xf (0xf) +int 0xa - 0x5 == 0x5 (0x5) +__uint 0xa - 0x5 == 0x5 (0x5) +char 0xa - 0x5 == 0x5 (0x5) +__uchar 0xa - 0x5 == 0x5 (0x5) +__longlong 0xa - 0x5 == 0x5 (0x5) +__ulonglong 0xa - 0x5 == 0x5 (0x5) +float 0xa - 0x5 == 0x5 (0x5) +int 0xa * 0x5 == 0x32 (0x32) +__uint 0xa * 0x5 == 0x32 (0x32) +char 0xa * 0x5 == 0x32 (0x32) +__uchar 0xa * 0x5 == 0x32 (0x32) +__longlong 0xa * 0x5 == 0x32 (0x32) +__ulonglong 0xa * 0x5 == 0x32 (0x32) +float 0xa * 0x5 == 0x32 (0x32) +int 0xa < 0x5 == 0x0 (0x0) +__uint 0xa < 0x5 == 0x0 (0x0) +char 0xa < 0x5 == 0x0 (0x0) +__uchar 0xa < 0x5 == 0x0 (0x0) +__longlong 0xa < 0x5 == 0x0 (0x0) +__ulonglong 0xa < 0x5 == 0x0 (0x0) +float 0xa < 0x5 == 0x0 (0x0) +int 0xa > 0x5 == 0x1 (0x1) +__uint 0xa > 0x5 == 0x1 (0x1) +char 0xa > 0x5 == 0x1 (0x1) +__uchar 0xa > 0x5 == 0x1 (0x1) +__longlong 0xa > 0x5 == 0x1 (0x1) +__ulonglong 0xa > 0x5 == 0x1 (0x1) +float 0xa > 0x5 == 0x1 (0x1) +int 0xa <= 0x5 == 0x0 (0x0) +__uint 0xa <= 0x5 == 0x0 (0x0) +char 0xa <= 0x5 == 0x0 (0x0) +__uchar 0xa <= 0x5 == 0x0 (0x0) +__longlong 0xa <= 0x5 == 0x0 (0x0) +__ulonglong 0xa <= 0x5 == 0x0 (0x0) +float 0xa <= 0x5 == 0x0 (0x0) +int 0xa == 0x5 == 0x0 (0x0) +__uint 0xa == 0x5 == 0x0 (0x0) +char 0xa == 0x5 == 0x0 (0x0) +__uchar 0xa == 0x5 == 0x0 (0x0) +__longlong 0xa == 0x5 == 0x0 (0x0) +__ulonglong 0xa == 0x5 == 0x0 (0x0) +float 0xa == 0x5 == 0x0 (0x0) +int 0xa != 0x5 == 0x1 (0x1) +__uint 0xa != 0x5 == 0x1 (0x1) +char 0xa != 0x5 == 0x1 (0x1) +__uchar 0xa != 0x5 == 0x1 (0x1) +__longlong 0xa != 0x5 == 0x1 (0x1) +__ulonglong 0xa != 0x5 == 0x1 (0x1) +float 0xa != 0x5 == 0x1 (0x1) +int 0xa >= 0x5 == 0x1 (0x1) +__uint 0xa >= 0x5 == 0x1 (0x1) +char 0xa >= 0x5 == 0x1 (0x1) +__uchar 0xa >= 0x5 == 0x1 (0x1) +__longlong 0xa >= 0x5 == 0x1 (0x1) +__ulonglong 0xa >= 0x5 == 0x1 (0x1) +float 0xa >= 0x5 == 0x1 (0x1) +int 0xa / 0x5 == 0x2 (0x2) +__uint 0xa / 0x5 == 0x2 (0x2) +char 0xa / 0x5 == 0x2 (0x2) +__uchar 0xa / 0x5 == 0x2 (0x2) +__longlong 0xa / 0x5 == 0x2 (0x2) +__ulonglong 0xa / 0x5 == 0x2 (0x2) +float 0xa / 0x5 == 0x2 (0x2) +int 0xa % 0x5 == 0x0 (0x0) +__uint 0xa % 0x5 == 0x0 (0x0) +char 0xa % 0x5 == 0x0 (0x0) +__uchar 0xa % 0x5 == 0x0 (0x0) +__longlong 0xa % 0x5 == 0x0 (0x0) +__ulonglong 0xa % 0x5 == 0x0 (0x0) +0xa * 0x7 == 0x46 +0xa / 0x7 == 0x1 +0xa % 0x7 == 0x3 +int 0xa ^ 0x7 == 0xd (0xd) +__uint 0xa ^ 0x7 == 0xd (0xd) +char 0xa ^ 0x7 == 0xd (0xd) +__uchar 0xa ^ 0x7 == 0xd (0xd) +__longlong 0xa ^ 0x7 == 0xd (0xd) +__ulonglong 0xa ^ 0x7 == 0xd (0xd) +int 0xa && 0x7 == 0x1 (0x1) +__uint 0xa && 0x7 == 0x1 (0x1) +char 0xa && 0x7 == 0x1 (0x1) +__uchar 0xa && 0x7 == 0x1 (0x1) +__longlong 0xa && 0x7 == 0x1 (0x1) +__ulonglong 0xa && 0x7 == 0x1 (0x1) +int 0xa || 0x7 == 0x1 (0x1) +__uint 0xa || 0x7 == 0x1 (0x1) +char 0xa || 0x7 == 0x1 (0x1) +__uchar 0xa || 0x7 == 0x1 (0x1) +__longlong 0xa || 0x7 == 0x1 (0x1) +__ulonglong 0xa || 0x7 == 0x1 (0x1) +int 0xa & 0x7 == 0x2 (0x2) +__uint 0xa & 0x7 == 0x2 (0x2) +char 0xa & 0x7 == 0x2 (0x2) +__uchar 0xa & 0x7 == 0x2 (0x2) +__longlong 0xa & 0x7 == 0x2 (0x2) +__ulonglong 0xa & 0x7 == 0x2 (0x2) +int 0xa | 0x7 == 0xf (0xf) +__uint 0xa | 0x7 == 0xf (0xf) +char 0xa | 0x7 == 0xf (0xf) +__uchar 0xa | 0x7 == 0xf (0xf) +__longlong 0xa | 0x7 == 0xf (0xf) +__ulonglong 0xa | 0x7 == 0xf (0xf) +int 0xa << 0xa == 0x2800 (0x2800) +__uint 0xa << 0xa == 0x2800 (0x2800) +char 0xa << 0xa == 0x0 (0x0) +__uchar 0xa << 0xa == 0x0 (0x0) +__longlong 0xa << 0xa == 0x2800 (0x2800) +__ulonglong 0xa << 0xa == 0x2800 (0x2800) +int 0xa >> 0xa == 0x0 (0x0) +__uint 0xa >> 0xa == 0x0 (0x0) +char 0xa >> 0xa == 0x0 (0x0) +__uchar 0xa >> 0xa == 0x0 (0x0) +__longlong 0xa >> 0xa == 0x0 (0x0) +__ulonglong 0xa >> 0xa == 0x0 (0x0) +int 0xa + 0x7 == 0x11 (0x11) +__uint 0xa + 0x7 == 0x11 (0x11) +char 0xa + 0x7 == 0x11 (0x11) +__uchar 0xa + 0x7 == 0x11 (0x11) +__longlong 0xa + 0x7 == 0x11 (0x11) +__ulonglong 0xa + 0x7 == 0x11 (0x11) +float 0xa + 0x7 == 0x11 (0x11) +int 0xa - 0x7 == 0x3 (0x3) +__uint 0xa - 0x7 == 0x3 (0x3) +char 0xa - 0x7 == 0x3 (0x3) +__uchar 0xa - 0x7 == 0x3 (0x3) +__longlong 0xa - 0x7 == 0x3 (0x3) +__ulonglong 0xa - 0x7 == 0x3 (0x3) +float 0xa - 0x7 == 0x3 (0x3) +int 0xa * 0x7 == 0x46 (0x46) +__uint 0xa * 0x7 == 0x46 (0x46) +char 0xa * 0x7 == 0x46 (0x46) +__uchar 0xa * 0x7 == 0x46 (0x46) +__longlong 0xa * 0x7 == 0x46 (0x46) +__ulonglong 0xa * 0x7 == 0x46 (0x46) +float 0xa * 0x7 == 0x46 (0x46) +int 0xa < 0x7 == 0x0 (0x0) +__uint 0xa < 0x7 == 0x0 (0x0) +char 0xa < 0x7 == 0x0 (0x0) +__uchar 0xa < 0x7 == 0x0 (0x0) +__longlong 0xa < 0x7 == 0x0 (0x0) +__ulonglong 0xa < 0x7 == 0x0 (0x0) +float 0xa < 0x7 == 0x0 (0x0) +int 0xa > 0x7 == 0x1 (0x1) +__uint 0xa > 0x7 == 0x1 (0x1) +char 0xa > 0x7 == 0x1 (0x1) +__uchar 0xa > 0x7 == 0x1 (0x1) +__longlong 0xa > 0x7 == 0x1 (0x1) +__ulonglong 0xa > 0x7 == 0x1 (0x1) +float 0xa > 0x7 == 0x1 (0x1) +int 0xa <= 0x7 == 0x0 (0x0) +__uint 0xa <= 0x7 == 0x0 (0x0) +char 0xa <= 0x7 == 0x0 (0x0) +__uchar 0xa <= 0x7 == 0x0 (0x0) +__longlong 0xa <= 0x7 == 0x0 (0x0) +__ulonglong 0xa <= 0x7 == 0x0 (0x0) +float 0xa <= 0x7 == 0x0 (0x0) +int 0xa == 0x7 == 0x0 (0x0) +__uint 0xa == 0x7 == 0x0 (0x0) +char 0xa == 0x7 == 0x0 (0x0) +__uchar 0xa == 0x7 == 0x0 (0x0) +__longlong 0xa == 0x7 == 0x0 (0x0) +__ulonglong 0xa == 0x7 == 0x0 (0x0) +float 0xa == 0x7 == 0x0 (0x0) +int 0xa != 0x7 == 0x1 (0x1) +__uint 0xa != 0x7 == 0x1 (0x1) +char 0xa != 0x7 == 0x1 (0x1) +__uchar 0xa != 0x7 == 0x1 (0x1) +__longlong 0xa != 0x7 == 0x1 (0x1) +__ulonglong 0xa != 0x7 == 0x1 (0x1) +float 0xa != 0x7 == 0x1 (0x1) +int 0xa >= 0x7 == 0x1 (0x1) +__uint 0xa >= 0x7 == 0x1 (0x1) +char 0xa >= 0x7 == 0x1 (0x1) +__uchar 0xa >= 0x7 == 0x1 (0x1) +__longlong 0xa >= 0x7 == 0x1 (0x1) +__ulonglong 0xa >= 0x7 == 0x1 (0x1) +float 0xa >= 0x7 == 0x1 (0x1) +int 0xa / 0x7 == 0x1 (0x1) +__uint 0xa / 0x7 == 0x1 (0x1) +char 0xa / 0x7 == 0x1 (0x1) +__uchar 0xa / 0x7 == 0x1 (0x1) +__longlong 0xa / 0x7 == 0x1 (0x1) +__ulonglong 0xa / 0x7 == 0x1 (0x1) +float 0xa / 0x7 == 0x1 (0x1) +int 0xa % 0x7 == 0x3 (0x3) +__uint 0xa % 0x7 == 0x3 (0x3) +char 0xa % 0x7 == 0x3 (0x3) +__uchar 0xa % 0x7 == 0x3 (0x3) +__longlong 0xa % 0x7 == 0x3 (0x3) +__ulonglong 0xa % 0x7 == 0x3 (0x3) +0xa * 0x2a == 0x1a4 +0xa / 0x2a == 0x0 +0xa % 0x2a == 0xa +int 0xa ^ 0x2a == 0x20 (0x20) +__uint 0xa ^ 0x2a == 0x20 (0x20) +char 0xa ^ 0x2a == 0x20 (0x20) +__uchar 0xa ^ 0x2a == 0x20 (0x20) +__longlong 0xa ^ 0x2a == 0x20 (0x20) +__ulonglong 0xa ^ 0x2a == 0x20 (0x20) +int 0xa && 0x2a == 0x1 (0x1) +__uint 0xa && 0x2a == 0x1 (0x1) +char 0xa && 0x2a == 0x1 (0x1) +__uchar 0xa && 0x2a == 0x1 (0x1) +__longlong 0xa && 0x2a == 0x1 (0x1) +__ulonglong 0xa && 0x2a == 0x1 (0x1) +int 0xa || 0x2a == 0x1 (0x1) +__uint 0xa || 0x2a == 0x1 (0x1) +char 0xa || 0x2a == 0x1 (0x1) +__uchar 0xa || 0x2a == 0x1 (0x1) +__longlong 0xa || 0x2a == 0x1 (0x1) +__ulonglong 0xa || 0x2a == 0x1 (0x1) +int 0xa & 0x2a == 0xa (0xa) +__uint 0xa & 0x2a == 0xa (0xa) +char 0xa & 0x2a == 0xa (0xa) +__uchar 0xa & 0x2a == 0xa (0xa) +__longlong 0xa & 0x2a == 0xa (0xa) +__ulonglong 0xa & 0x2a == 0xa (0xa) +int 0xa | 0x2a == 0x2a (0x2a) +__uint 0xa | 0x2a == 0x2a (0x2a) +char 0xa | 0x2a == 0x2a (0x2a) +__uchar 0xa | 0x2a == 0x2a (0x2a) +__longlong 0xa | 0x2a == 0x2a (0x2a) +__ulonglong 0xa | 0x2a == 0x2a (0x2a) +int 0xa << 0xc == -0x6000 (0xa000) +__uint 0xa << 0xc == -0x6000 (0xa000) +char 0xa << 0xc == 0x0 (0x0) +__uchar 0xa << 0xc == 0x0 (0x0) +__longlong 0xa << 0xc == -0x6000 (0xa000) +__ulonglong 0xa << 0xc == -0x6000 (0xa000) +int 0xa >> 0xc == 0x0 (0x0) +__uint 0xa >> 0xc == 0x0 (0x0) +char 0xa >> 0xc == 0x0 (0x0) +__uchar 0xa >> 0xc == 0x0 (0x0) +__longlong 0xa >> 0xc == 0x0 (0x0) +__ulonglong 0xa >> 0xc == 0x0 (0x0) +int 0xa + 0x2a == 0x34 (0x34) +__uint 0xa + 0x2a == 0x34 (0x34) +char 0xa + 0x2a == 0x34 (0x34) +__uchar 0xa + 0x2a == 0x34 (0x34) +__longlong 0xa + 0x2a == 0x34 (0x34) +__ulonglong 0xa + 0x2a == 0x34 (0x34) +float 0xa + 0x2a == 0x34 (0x34) +int 0xa - 0x2a == -0x20 (0xffe0) +__uint 0xa - 0x2a == -0x20 (0xffe0) +char 0xa - 0x2a == -0x20 (0xffe0) +__uchar 0xa - 0x2a == 0xe0 (0xe0) +__longlong 0xa - 0x2a == -0x20 (0xffe0) +__ulonglong 0xa - 0x2a == -0x20 (0xffe0) +float 0xa - 0x2a == -0x20 (0xffe0) +int 0xa * 0x2a == 0x1a4 (0x1a4) +__uint 0xa * 0x2a == 0x1a4 (0x1a4) +char 0xa * 0x2a == -0x5c (0xffa4) +__uchar 0xa * 0x2a == 0xa4 (0xa4) +__longlong 0xa * 0x2a == 0x1a4 (0x1a4) +__ulonglong 0xa * 0x2a == 0x1a4 (0x1a4) +float 0xa * 0x2a == 0x1a4 (0x1a4) +int 0xa < 0x2a == 0x1 (0x1) +__uint 0xa < 0x2a == 0x1 (0x1) +char 0xa < 0x2a == 0x1 (0x1) +__uchar 0xa < 0x2a == 0x1 (0x1) +__longlong 0xa < 0x2a == 0x1 (0x1) +__ulonglong 0xa < 0x2a == 0x1 (0x1) +float 0xa < 0x2a == 0x1 (0x1) +int 0xa > 0x2a == 0x0 (0x0) +__uint 0xa > 0x2a == 0x0 (0x0) +char 0xa > 0x2a == 0x0 (0x0) +__uchar 0xa > 0x2a == 0x0 (0x0) +__longlong 0xa > 0x2a == 0x0 (0x0) +__ulonglong 0xa > 0x2a == 0x0 (0x0) +float 0xa > 0x2a == 0x0 (0x0) +int 0xa <= 0x2a == 0x1 (0x1) +__uint 0xa <= 0x2a == 0x1 (0x1) +char 0xa <= 0x2a == 0x1 (0x1) +__uchar 0xa <= 0x2a == 0x1 (0x1) +__longlong 0xa <= 0x2a == 0x1 (0x1) +__ulonglong 0xa <= 0x2a == 0x1 (0x1) +float 0xa <= 0x2a == 0x1 (0x1) +int 0xa == 0x2a == 0x0 (0x0) +__uint 0xa == 0x2a == 0x0 (0x0) +char 0xa == 0x2a == 0x0 (0x0) +__uchar 0xa == 0x2a == 0x0 (0x0) +__longlong 0xa == 0x2a == 0x0 (0x0) +__ulonglong 0xa == 0x2a == 0x0 (0x0) +float 0xa == 0x2a == 0x0 (0x0) +int 0xa != 0x2a == 0x1 (0x1) +__uint 0xa != 0x2a == 0x1 (0x1) +char 0xa != 0x2a == 0x1 (0x1) +__uchar 0xa != 0x2a == 0x1 (0x1) +__longlong 0xa != 0x2a == 0x1 (0x1) +__ulonglong 0xa != 0x2a == 0x1 (0x1) +float 0xa != 0x2a == 0x1 (0x1) +int 0xa >= 0x2a == 0x0 (0x0) +__uint 0xa >= 0x2a == 0x0 (0x0) +char 0xa >= 0x2a == 0x0 (0x0) +__uchar 0xa >= 0x2a == 0x0 (0x0) +__longlong 0xa >= 0x2a == 0x0 (0x0) +__ulonglong 0xa >= 0x2a == 0x0 (0x0) +float 0xa >= 0x2a == 0x0 (0x0) +int 0xa / 0x2a == 0x0 (0x0) +__uint 0xa / 0x2a == 0x0 (0x0) +char 0xa / 0x2a == 0x0 (0x0) +__uchar 0xa / 0x2a == 0x0 (0x0) +__longlong 0xa / 0x2a == 0x0 (0x0) +__ulonglong 0xa / 0x2a == 0x0 (0x0) +float 0xa / 0x2a == 0x0 (0x0) +int 0xa % 0x2a == 0xa (0xa) +__uint 0xa % 0x2a == 0xa (0xa) +char 0xa % 0x2a == 0xa (0xa) +__uchar 0xa % 0x2a == 0xa (0xa) +__longlong 0xa % 0x2a == 0xa (0xa) +__ulonglong 0xa % 0x2a == 0xa (0xa) +0xa * 0x17 == 0xe6 +0xa / 0x17 == 0x0 +0xa % 0x17 == 0xa +int 0xa ^ 0x17 == 0x1d (0x1d) +__uint 0xa ^ 0x17 == 0x1d (0x1d) +char 0xa ^ 0x17 == 0x1d (0x1d) +__uchar 0xa ^ 0x17 == 0x1d (0x1d) +__longlong 0xa ^ 0x17 == 0x1d (0x1d) +__ulonglong 0xa ^ 0x17 == 0x1d (0x1d) +int 0xa && 0x17 == 0x1 (0x1) +__uint 0xa && 0x17 == 0x1 (0x1) +char 0xa && 0x17 == 0x1 (0x1) +__uchar 0xa && 0x17 == 0x1 (0x1) +__longlong 0xa && 0x17 == 0x1 (0x1) +__ulonglong 0xa && 0x17 == 0x1 (0x1) +int 0xa || 0x17 == 0x1 (0x1) +__uint 0xa || 0x17 == 0x1 (0x1) +char 0xa || 0x17 == 0x1 (0x1) +__uchar 0xa || 0x17 == 0x1 (0x1) +__longlong 0xa || 0x17 == 0x1 (0x1) +__ulonglong 0xa || 0x17 == 0x1 (0x1) +int 0xa & 0x17 == 0x2 (0x2) +__uint 0xa & 0x17 == 0x2 (0x2) +char 0xa & 0x17 == 0x2 (0x2) +__uchar 0xa & 0x17 == 0x2 (0x2) +__longlong 0xa & 0x17 == 0x2 (0x2) +__ulonglong 0xa & 0x17 == 0x2 (0x2) +int 0xa | 0x17 == 0x1f (0x1f) +__uint 0xa | 0x17 == 0x1f (0x1f) +char 0xa | 0x17 == 0x1f (0x1f) +__uchar 0xa | 0x17 == 0x1f (0x1f) +__longlong 0xa | 0x17 == 0x1f (0x1f) +__ulonglong 0xa | 0x17 == 0x1f (0x1f) +int 0xa << 0xe == -0x8000 (0x8000) +__uint 0xa << 0xe == -0x8000 (0x8000) +char 0xa << 0xe == 0x0 (0x0) +__uchar 0xa << 0xe == 0x0 (0x0) +__longlong 0xa << 0xe == -0x8000 (0x8000) +__ulonglong 0xa << 0xe == -0x8000 (0x8000) +int 0xa >> 0xe == 0x0 (0x0) +__uint 0xa >> 0xe == 0x0 (0x0) +char 0xa >> 0xe == 0x0 (0x0) +__uchar 0xa >> 0xe == 0x0 (0x0) +__longlong 0xa >> 0xe == 0x0 (0x0) +__ulonglong 0xa >> 0xe == 0x0 (0x0) +int 0xa + 0x17 == 0x21 (0x21) +__uint 0xa + 0x17 == 0x21 (0x21) +char 0xa + 0x17 == 0x21 (0x21) +__uchar 0xa + 0x17 == 0x21 (0x21) +__longlong 0xa + 0x17 == 0x21 (0x21) +__ulonglong 0xa + 0x17 == 0x21 (0x21) +float 0xa + 0x17 == 0x21 (0x21) +int 0xa - 0x17 == -0xd (0xfff3) +__uint 0xa - 0x17 == -0xd (0xfff3) +char 0xa - 0x17 == -0xd (0xfff3) +__uchar 0xa - 0x17 == 0xf3 (0xf3) +__longlong 0xa - 0x17 == -0xd (0xfff3) +__ulonglong 0xa - 0x17 == -0xd (0xfff3) +float 0xa - 0x17 == -0xd (0xfff3) +int 0xa * 0x17 == 0xe6 (0xe6) +__uint 0xa * 0x17 == 0xe6 (0xe6) +char 0xa * 0x17 == -0x1a (0xffe6) +__uchar 0xa * 0x17 == 0xe6 (0xe6) +__longlong 0xa * 0x17 == 0xe6 (0xe6) +__ulonglong 0xa * 0x17 == 0xe6 (0xe6) +float 0xa * 0x17 == 0xe6 (0xe6) +int 0xa < 0x17 == 0x1 (0x1) +__uint 0xa < 0x17 == 0x1 (0x1) +char 0xa < 0x17 == 0x1 (0x1) +__uchar 0xa < 0x17 == 0x1 (0x1) +__longlong 0xa < 0x17 == 0x1 (0x1) +__ulonglong 0xa < 0x17 == 0x1 (0x1) +float 0xa < 0x17 == 0x1 (0x1) +int 0xa > 0x17 == 0x0 (0x0) +__uint 0xa > 0x17 == 0x0 (0x0) +char 0xa > 0x17 == 0x0 (0x0) +__uchar 0xa > 0x17 == 0x0 (0x0) +__longlong 0xa > 0x17 == 0x0 (0x0) +__ulonglong 0xa > 0x17 == 0x0 (0x0) +float 0xa > 0x17 == 0x0 (0x0) +int 0xa <= 0x17 == 0x1 (0x1) +__uint 0xa <= 0x17 == 0x1 (0x1) +char 0xa <= 0x17 == 0x1 (0x1) +__uchar 0xa <= 0x17 == 0x1 (0x1) +__longlong 0xa <= 0x17 == 0x1 (0x1) +__ulonglong 0xa <= 0x17 == 0x1 (0x1) +float 0xa <= 0x17 == 0x1 (0x1) +int 0xa == 0x17 == 0x0 (0x0) +__uint 0xa == 0x17 == 0x0 (0x0) +char 0xa == 0x17 == 0x0 (0x0) +__uchar 0xa == 0x17 == 0x0 (0x0) +__longlong 0xa == 0x17 == 0x0 (0x0) +__ulonglong 0xa == 0x17 == 0x0 (0x0) +float 0xa == 0x17 == 0x0 (0x0) +int 0xa != 0x17 == 0x1 (0x1) +__uint 0xa != 0x17 == 0x1 (0x1) +char 0xa != 0x17 == 0x1 (0x1) +__uchar 0xa != 0x17 == 0x1 (0x1) +__longlong 0xa != 0x17 == 0x1 (0x1) +__ulonglong 0xa != 0x17 == 0x1 (0x1) +float 0xa != 0x17 == 0x1 (0x1) +int 0xa >= 0x17 == 0x0 (0x0) +__uint 0xa >= 0x17 == 0x0 (0x0) +char 0xa >= 0x17 == 0x0 (0x0) +__uchar 0xa >= 0x17 == 0x0 (0x0) +__longlong 0xa >= 0x17 == 0x0 (0x0) +__ulonglong 0xa >= 0x17 == 0x0 (0x0) +float 0xa >= 0x17 == 0x0 (0x0) +int 0xa / 0x17 == 0x0 (0x0) +__uint 0xa / 0x17 == 0x0 (0x0) +char 0xa / 0x17 == 0x0 (0x0) +__uchar 0xa / 0x17 == 0x0 (0x0) +__longlong 0xa / 0x17 == 0x0 (0x0) +__ulonglong 0xa / 0x17 == 0x0 (0x0) +float 0xa / 0x17 == 0x0 (0x0) +int 0xa % 0x17 == 0xa (0xa) +__uint 0xa % 0x17 == 0xa (0xa) +char 0xa % 0x17 == 0xa (0xa) +__uchar 0xa % 0x17 == 0xa (0xa) +__longlong 0xa % 0x17 == 0xa (0xa) +__ulonglong 0xa % 0x17 == 0xa (0xa) +0xa * 0x7fff == -0xa +0xa / 0x7fff == 0x0 +0xa % 0x7fff == 0xa +int 0xa ^ 0x7fff == 0x7ff5 (0x7ff5) +__uint 0xa ^ 0x7fff == 0x7ff5 (0x7ff5) +char 0xa ^ 0xffff == -0xb (0xfff5) +__uchar 0xa ^ 0xff == 0xf5 (0xf5) +__longlong 0xa ^ 0x7fff == 0x7ff5 (0x7ff5) +__ulonglong 0xa ^ 0x7fff == 0x7ff5 (0x7ff5) +int 0xa && 0x7fff == 0x1 (0x1) +__uint 0xa && 0x7fff == 0x1 (0x1) +char 0xa && 0xffff == 0x1 (0x1) +__uchar 0xa && 0xff == 0x1 (0x1) +__longlong 0xa && 0x7fff == 0x1 (0x1) +__ulonglong 0xa && 0x7fff == 0x1 (0x1) +int 0xa || 0x7fff == 0x1 (0x1) +__uint 0xa || 0x7fff == 0x1 (0x1) +char 0xa || 0xffff == 0x1 (0x1) +__uchar 0xa || 0xff == 0x1 (0x1) +__longlong 0xa || 0x7fff == 0x1 (0x1) +__ulonglong 0xa || 0x7fff == 0x1 (0x1) +int 0xa & 0x7fff == 0xa (0xa) +__uint 0xa & 0x7fff == 0xa (0xa) +char 0xa & 0xffff == 0xa (0xa) +__uchar 0xa & 0xff == 0xa (0xa) +__longlong 0xa & 0x7fff == 0xa (0xa) +__ulonglong 0xa & 0x7fff == 0xa (0xa) +int 0xa | 0x7fff == 0x7fff (0x7fff) +__uint 0xa | 0x7fff == 0x7fff (0x7fff) +char 0xa | 0xffff == -0x1 (0xffff) +__uchar 0xa | 0xff == 0xff (0xff) +__longlong 0xa | 0x7fff == 0x7fff (0x7fff) +__ulonglong 0xa | 0x7fff == 0x7fff (0x7fff) +int 0xa << 0x10 == 0x0 (0x0) +__uint 0xa << 0x10 == 0x0 (0x0) +char 0xa << 0x10 == 0x0 (0x0) +__uchar 0xa << 0x10 == 0x0 (0x0) +__longlong 0xa << 0x10 == 0x0 (0x0) +__ulonglong 0xa << 0x10 == 0x0 (0x0) +int 0xa >> 0x10 == 0x0 (0x0) +__uint 0xa >> 0x10 == 0x0 (0x0) +char 0xa >> 0x10 == 0x0 (0x0) +__uchar 0xa >> 0x10 == 0x0 (0x0) +__longlong 0xa >> 0x10 == 0x0 (0x0) +__ulonglong 0xa >> 0x10 == 0x0 (0x0) +int 0xa + 0x7fff == -0x7ff7 (0x8009) +__uint 0xa + 0x7fff == -0x7ff7 (0x8009) +char 0xa + 0xffff == 0x9 (0x9) +__uchar 0xa + 0xff == 0x9 (0x9) +__longlong 0xa + 0x7fff == -0x7ff7 (0x8009) +__ulonglong 0xa + 0x7fff == -0x7ff7 (0x8009) +float 0xa + 0x7fff == -0x7ff7 (0x8009) +int 0xa - 0x7fff == -0x7ff5 (0x800b) +__uint 0xa - 0x7fff == -0x7ff5 (0x800b) +char 0xa - 0xffff == 0xb (0xb) +__uchar 0xa - 0xff == 0xb (0xb) +__longlong 0xa - 0x7fff == -0x7ff5 (0x800b) +__ulonglong 0xa - 0x7fff == -0x7ff5 (0x800b) +float 0xa - 0x7fff == -0x7ff5 (0x800b) +int 0xa * 0x7fff == -0xa (0xfff6) +__uint 0xa * 0x7fff == -0xa (0xfff6) +char 0xa * 0xffff == -0xa (0xfff6) +__uchar 0xa * 0xff == 0xf6 (0xf6) +__longlong 0xa * 0x7fff == -0xa (0xfff6) +__ulonglong 0xa * 0x7fff == -0xa (0xfff6) +float 0xa * 0x7fff == -0xa (0xfff6) +int 0xa < 0x7fff == 0x1 (0x1) +__uint 0xa < 0x7fff == 0x1 (0x1) +char 0xa < 0xffff == 0x0 (0x0) +__uchar 0xa < 0xff == 0x1 (0x1) +__longlong 0xa < 0x7fff == 0x1 (0x1) +__ulonglong 0xa < 0x7fff == 0x1 (0x1) +float 0xa < 0x7fff == 0x1 (0x1) +int 0xa > 0x7fff == 0x0 (0x0) +__uint 0xa > 0x7fff == 0x0 (0x0) +char 0xa > 0xffff == 0x1 (0x1) +__uchar 0xa > 0xff == 0x0 (0x0) +__longlong 0xa > 0x7fff == 0x0 (0x0) +__ulonglong 0xa > 0x7fff == 0x0 (0x0) +float 0xa > 0x7fff == 0x0 (0x0) +int 0xa <= 0x7fff == 0x1 (0x1) +__uint 0xa <= 0x7fff == 0x1 (0x1) +char 0xa <= 0xffff == 0x0 (0x0) +__uchar 0xa <= 0xff == 0x1 (0x1) +__longlong 0xa <= 0x7fff == 0x1 (0x1) +__ulonglong 0xa <= 0x7fff == 0x1 (0x1) +float 0xa <= 0x7fff == 0x1 (0x1) +int 0xa == 0x7fff == 0x0 (0x0) +__uint 0xa == 0x7fff == 0x0 (0x0) +char 0xa == 0xffff == 0x0 (0x0) +__uchar 0xa == 0xff == 0x0 (0x0) +__longlong 0xa == 0x7fff == 0x0 (0x0) +__ulonglong 0xa == 0x7fff == 0x0 (0x0) +float 0xa == 0x7fff == 0x0 (0x0) +int 0xa != 0x7fff == 0x1 (0x1) +__uint 0xa != 0x7fff == 0x1 (0x1) +char 0xa != 0xffff == 0x1 (0x1) +__uchar 0xa != 0xff == 0x1 (0x1) +__longlong 0xa != 0x7fff == 0x1 (0x1) +__ulonglong 0xa != 0x7fff == 0x1 (0x1) +float 0xa != 0x7fff == 0x1 (0x1) +int 0xa >= 0x7fff == 0x0 (0x0) +__uint 0xa >= 0x7fff == 0x0 (0x0) +char 0xa >= 0xffff == 0x1 (0x1) +__uchar 0xa >= 0xff == 0x0 (0x0) +__longlong 0xa >= 0x7fff == 0x0 (0x0) +__ulonglong 0xa >= 0x7fff == 0x0 (0x0) +float 0xa >= 0x7fff == 0x0 (0x0) +int 0xa / 0x7fff == 0x0 (0x0) +__uint 0xa / 0x7fff == 0x0 (0x0) +char 0xa / 0xffff == -0xa (0xfff6) +__uchar 0xa / 0xff == 0x0 (0x0) +__longlong 0xa / 0x7fff == 0x0 (0x0) +__ulonglong 0xa / 0x7fff == 0x0 (0x0) +float 0xa / 0x7fff == 0x0 (0x0) +int 0xa % 0x7fff == 0xa (0xa) +__uint 0xa % 0x7fff == 0xa (0xa) +char 0xa % 0xffff == 0x0 (0x0) +__uchar 0xa % 0xff == 0xa (0xa) +__longlong 0xa % 0x7fff == 0xa (0xa) +__ulonglong 0xa % 0x7fff == 0xa (0xa) +0xa * 0x8000 == 0x0 +0xa / 0x8000 == 0x0 +0xa % 0x8000 == 0xa +int 0xa ^ 0x8000 == -0x7ff6 (0x800a) +__uint 0xa ^ 0x8000 == -0x7ff6 (0x800a) +char 0xa ^ 0x0 == 0xa (0xa) +__uchar 0xa ^ 0x0 == 0xa (0xa) +__longlong 0xa ^ 0x8000 == -0x7ff6 (0x800a) +__ulonglong 0xa ^ 0x8000 == -0x7ff6 (0x800a) +int 0xa && 0x8000 == 0x1 (0x1) +__uint 0xa && 0x8000 == 0x1 (0x1) +char 0xa && 0x0 == 0x0 (0x0) +__uchar 0xa && 0x0 == 0x0 (0x0) +__longlong 0xa && 0x8000 == 0x1 (0x1) +__ulonglong 0xa && 0x8000 == 0x1 (0x1) +int 0xa || 0x8000 == 0x1 (0x1) +__uint 0xa || 0x8000 == 0x1 (0x1) +char 0xa || 0x0 == 0x1 (0x1) +__uchar 0xa || 0x0 == 0x1 (0x1) +__longlong 0xa || 0x8000 == 0x1 (0x1) +__ulonglong 0xa || 0x8000 == 0x1 (0x1) +int 0xa & 0x8000 == 0x0 (0x0) +__uint 0xa & 0x8000 == 0x0 (0x0) +char 0xa & 0x0 == 0x0 (0x0) +__uchar 0xa & 0x0 == 0x0 (0x0) +__longlong 0xa & 0x8000 == 0x0 (0x0) +__ulonglong 0xa & 0x8000 == 0x0 (0x0) +int 0xa | 0x8000 == -0x7ff6 (0x800a) +__uint 0xa | 0x8000 == -0x7ff6 (0x800a) +char 0xa | 0x0 == 0xa (0xa) +__uchar 0xa | 0x0 == 0xa (0xa) +__longlong 0xa | 0x8000 == -0x7ff6 (0x800a) +__ulonglong 0xa | 0x8000 == -0x7ff6 (0x800a) +int 0xa << 0x12 == 0x0 (0x0) +__uint 0xa << 0x12 == 0x0 (0x0) +char 0xa << 0x12 == 0x0 (0x0) +__uchar 0xa << 0x12 == 0x0 (0x0) +__longlong 0xa << 0x12 == 0x0 (0x0) +__ulonglong 0xa << 0x12 == 0x0 (0x0) +int 0xa >> 0x12 == 0x0 (0x0) +__uint 0xa >> 0x12 == 0x0 (0x0) +char 0xa >> 0x12 == 0x0 (0x0) +__uchar 0xa >> 0x12 == 0x0 (0x0) +__longlong 0xa >> 0x12 == 0x0 (0x0) +__ulonglong 0xa >> 0x12 == 0x0 (0x0) +int 0xa + 0x8000 == -0x7ff6 (0x800a) +__uint 0xa + 0x8000 == -0x7ff6 (0x800a) +char 0xa + 0x0 == 0xa (0xa) +__uchar 0xa + 0x0 == 0xa (0xa) +__longlong 0xa + 0x8000 == -0x7ff6 (0x800a) +__ulonglong 0xa + 0x8000 == -0x7ff6 (0x800a) +float 0xa + 0x8000 == -0x7ff6 (0x800a) +int 0xa - 0x8000 == -0x7ff6 (0x800a) +__uint 0xa - 0x8000 == -0x7ff6 (0x800a) +char 0xa - 0x0 == 0xa (0xa) +__uchar 0xa - 0x0 == 0xa (0xa) +__longlong 0xa - 0x8000 == -0x7ff6 (0x800a) +__ulonglong 0xa - 0x8000 == -0x7ff6 (0x800a) +float 0xa - 0x8000 == -0x7ff6 (0x800a) +int 0xa * 0x8000 == 0x0 (0x0) +__uint 0xa * 0x8000 == 0x0 (0x0) +char 0xa * 0x0 == 0x0 (0x0) +__uchar 0xa * 0x0 == 0x0 (0x0) +__longlong 0xa * 0x8000 == 0x0 (0x0) +__ulonglong 0xa * 0x8000 == 0x0 (0x0) +float 0xa * 0x8000 == 0x0 (0x0) +int 0xa < 0x8000 == 0x0 (0x0) +__uint 0xa < 0x8000 == 0x1 (0x1) +char 0xa < 0x0 == 0x0 (0x0) +__uchar 0xa < 0x0 == 0x0 (0x0) +__longlong 0xa < 0x8000 == 0x0 (0x0) +__ulonglong 0xa < 0x8000 == 0x1 (0x1) +float 0xa < 0x8000 == 0x0 (0x0) +int 0xa > 0x8000 == 0x1 (0x1) +__uint 0xa > 0x8000 == 0x0 (0x0) +char 0xa > 0x0 == 0x1 (0x1) +__uchar 0xa > 0x0 == 0x1 (0x1) +__longlong 0xa > 0x8000 == 0x1 (0x1) +__ulonglong 0xa > 0x8000 == 0x0 (0x0) +float 0xa > 0x8000 == 0x1 (0x1) +int 0xa <= 0x8000 == 0x0 (0x0) +__uint 0xa <= 0x8000 == 0x1 (0x1) +char 0xa <= 0x0 == 0x0 (0x0) +__uchar 0xa <= 0x0 == 0x0 (0x0) +__longlong 0xa <= 0x8000 == 0x0 (0x0) +__ulonglong 0xa <= 0x8000 == 0x1 (0x1) +float 0xa <= 0x8000 == 0x0 (0x0) +int 0xa == 0x8000 == 0x0 (0x0) +__uint 0xa == 0x8000 == 0x0 (0x0) +char 0xa == 0x0 == 0x0 (0x0) +__uchar 0xa == 0x0 == 0x0 (0x0) +__longlong 0xa == 0x8000 == 0x0 (0x0) +__ulonglong 0xa == 0x8000 == 0x0 (0x0) +float 0xa == 0x8000 == 0x0 (0x0) +int 0xa != 0x8000 == 0x1 (0x1) +__uint 0xa != 0x8000 == 0x1 (0x1) +char 0xa != 0x0 == 0x1 (0x1) +__uchar 0xa != 0x0 == 0x1 (0x1) +__longlong 0xa != 0x8000 == 0x1 (0x1) +__ulonglong 0xa != 0x8000 == 0x1 (0x1) +float 0xa != 0x8000 == 0x1 (0x1) +int 0xa >= 0x8000 == 0x1 (0x1) +__uint 0xa >= 0x8000 == 0x0 (0x0) +char 0xa >= 0x0 == 0x1 (0x1) +__uchar 0xa >= 0x0 == 0x1 (0x1) +__longlong 0xa >= 0x8000 == 0x1 (0x1) +__ulonglong 0xa >= 0x8000 == 0x0 (0x0) +float 0xa >= 0x8000 == 0x1 (0x1) +int 0xa / 0x8000 == 0x0 (0x0) +__uint 0xa / 0x8000 == 0x0 (0x0) +__longlong 0xa / 0x8000 == 0x0 (0x0) +__ulonglong 0xa / 0x8000 == 0x0 (0x0) +float 0xa / 0x8000 == 0x0 (0x0) +int 0xa % 0x8000 == 0xa (0xa) +__uint 0xa % 0x8000 == 0xa (0xa) +__longlong 0xa % 0x8000 == 0xa (0xa) +__ulonglong 0xa % 0x8000 == 0xa (0xa) +0xa * 0x3e8 == 0x2710 +0xa / 0x3e8 == 0x0 +0xa % 0x3e8 == 0xa +int 0xa ^ 0x3e8 == 0x3e2 (0x3e2) +__uint 0xa ^ 0x3e8 == 0x3e2 (0x3e2) +char 0xa ^ 0xffe8 == -0x1e (0xffe2) +__uchar 0xa ^ 0xe8 == 0xe2 (0xe2) +__longlong 0xa ^ 0x3e8 == 0x3e2 (0x3e2) +__ulonglong 0xa ^ 0x3e8 == 0x3e2 (0x3e2) +int 0xa && 0x3e8 == 0x1 (0x1) +__uint 0xa && 0x3e8 == 0x1 (0x1) +char 0xa && 0xffe8 == 0x1 (0x1) +__uchar 0xa && 0xe8 == 0x1 (0x1) +__longlong 0xa && 0x3e8 == 0x1 (0x1) +__ulonglong 0xa && 0x3e8 == 0x1 (0x1) +int 0xa || 0x3e8 == 0x1 (0x1) +__uint 0xa || 0x3e8 == 0x1 (0x1) +char 0xa || 0xffe8 == 0x1 (0x1) +__uchar 0xa || 0xe8 == 0x1 (0x1) +__longlong 0xa || 0x3e8 == 0x1 (0x1) +__ulonglong 0xa || 0x3e8 == 0x1 (0x1) +int 0xa & 0x3e8 == 0x8 (0x8) +__uint 0xa & 0x3e8 == 0x8 (0x8) +char 0xa & 0xffe8 == 0x8 (0x8) +__uchar 0xa & 0xe8 == 0x8 (0x8) +__longlong 0xa & 0x3e8 == 0x8 (0x8) +__ulonglong 0xa & 0x3e8 == 0x8 (0x8) +int 0xa | 0x3e8 == 0x3ea (0x3ea) +__uint 0xa | 0x3e8 == 0x3ea (0x3ea) +char 0xa | 0xffe8 == -0x16 (0xffea) +__uchar 0xa | 0xe8 == 0xea (0xea) +__longlong 0xa | 0x3e8 == 0x3ea (0x3ea) +__ulonglong 0xa | 0x3e8 == 0x3ea (0x3ea) +int 0xa << 0x14 == 0x0 (0x0) +__uint 0xa << 0x14 == 0x0 (0x0) +char 0xa << 0x14 == 0x0 (0x0) +__uchar 0xa << 0x14 == 0x0 (0x0) +__longlong 0xa << 0x14 == 0x0 (0x0) +__ulonglong 0xa << 0x14 == 0x0 (0x0) +int 0xa >> 0x14 == 0x0 (0x0) +__uint 0xa >> 0x14 == 0x0 (0x0) +char 0xa >> 0x14 == 0x0 (0x0) +__uchar 0xa >> 0x14 == 0x0 (0x0) +__longlong 0xa >> 0x14 == 0x0 (0x0) +__ulonglong 0xa >> 0x14 == 0x0 (0x0) +int 0xa + 0x3e8 == 0x3f2 (0x3f2) +__uint 0xa + 0x3e8 == 0x3f2 (0x3f2) +char 0xa + 0xffe8 == -0xe (0xfff2) +__uchar 0xa + 0xe8 == 0xf2 (0xf2) +__longlong 0xa + 0x3e8 == 0x3f2 (0x3f2) +__ulonglong 0xa + 0x3e8 == 0x3f2 (0x3f2) +float 0xa + 0x3e8 == 0x3f2 (0x3f2) +int 0xa - 0x3e8 == -0x3de (0xfc22) +__uint 0xa - 0x3e8 == -0x3de (0xfc22) +char 0xa - 0xffe8 == 0x22 (0x22) +__uchar 0xa - 0xe8 == 0x22 (0x22) +__longlong 0xa - 0x3e8 == -0x3de (0xfc22) +__ulonglong 0xa - 0x3e8 == -0x3de (0xfc22) +float 0xa - 0x3e8 == -0x3de (0xfc22) +int 0xa * 0x3e8 == 0x2710 (0x2710) +__uint 0xa * 0x3e8 == 0x2710 (0x2710) +char 0xa * 0xffe8 == 0x10 (0x10) +__uchar 0xa * 0xe8 == 0x10 (0x10) +__longlong 0xa * 0x3e8 == 0x2710 (0x2710) +__ulonglong 0xa * 0x3e8 == 0x2710 (0x2710) +float 0xa * 0x3e8 == 0x2710 (0x2710) +int 0xa < 0x3e8 == 0x1 (0x1) +__uint 0xa < 0x3e8 == 0x1 (0x1) +char 0xa < 0xffe8 == 0x0 (0x0) +__uchar 0xa < 0xe8 == 0x1 (0x1) +__longlong 0xa < 0x3e8 == 0x1 (0x1) +__ulonglong 0xa < 0x3e8 == 0x1 (0x1) +float 0xa < 0x3e8 == 0x1 (0x1) +int 0xa > 0x3e8 == 0x0 (0x0) +__uint 0xa > 0x3e8 == 0x0 (0x0) +char 0xa > 0xffe8 == 0x1 (0x1) +__uchar 0xa > 0xe8 == 0x0 (0x0) +__longlong 0xa > 0x3e8 == 0x0 (0x0) +__ulonglong 0xa > 0x3e8 == 0x0 (0x0) +float 0xa > 0x3e8 == 0x0 (0x0) +int 0xa <= 0x3e8 == 0x1 (0x1) +__uint 0xa <= 0x3e8 == 0x1 (0x1) +char 0xa <= 0xffe8 == 0x0 (0x0) +__uchar 0xa <= 0xe8 == 0x1 (0x1) +__longlong 0xa <= 0x3e8 == 0x1 (0x1) +__ulonglong 0xa <= 0x3e8 == 0x1 (0x1) +float 0xa <= 0x3e8 == 0x1 (0x1) +int 0xa == 0x3e8 == 0x0 (0x0) +__uint 0xa == 0x3e8 == 0x0 (0x0) +char 0xa == 0xffe8 == 0x0 (0x0) +__uchar 0xa == 0xe8 == 0x0 (0x0) +__longlong 0xa == 0x3e8 == 0x0 (0x0) +__ulonglong 0xa == 0x3e8 == 0x0 (0x0) +float 0xa == 0x3e8 == 0x0 (0x0) +int 0xa != 0x3e8 == 0x1 (0x1) +__uint 0xa != 0x3e8 == 0x1 (0x1) +char 0xa != 0xffe8 == 0x1 (0x1) +__uchar 0xa != 0xe8 == 0x1 (0x1) +__longlong 0xa != 0x3e8 == 0x1 (0x1) +__ulonglong 0xa != 0x3e8 == 0x1 (0x1) +float 0xa != 0x3e8 == 0x1 (0x1) +int 0xa >= 0x3e8 == 0x0 (0x0) +__uint 0xa >= 0x3e8 == 0x0 (0x0) +char 0xa >= 0xffe8 == 0x1 (0x1) +__uchar 0xa >= 0xe8 == 0x0 (0x0) +__longlong 0xa >= 0x3e8 == 0x0 (0x0) +__ulonglong 0xa >= 0x3e8 == 0x0 (0x0) +float 0xa >= 0x3e8 == 0x0 (0x0) +int 0xa / 0x3e8 == 0x0 (0x0) +__uint 0xa / 0x3e8 == 0x0 (0x0) +char 0xa / 0xffe8 == 0x0 (0x0) +__uchar 0xa / 0xe8 == 0x0 (0x0) +__longlong 0xa / 0x3e8 == 0x0 (0x0) +__ulonglong 0xa / 0x3e8 == 0x0 (0x0) +float 0xa / 0x3e8 == 0x0 (0x0) +int 0xa % 0x3e8 == 0xa (0xa) +__uint 0xa % 0x3e8 == 0xa (0xa) +char 0xa % 0xffe8 == 0xa (0xa) +__uchar 0xa % 0xe8 == 0xa (0xa) +__longlong 0xa % 0x3e8 == 0xa (0xa) +__ulonglong 0xa % 0x3e8 == 0xa (0xa) +0xa * 0x2710 == -0x7960 +0xa / 0x2710 == 0x0 +0xa % 0x2710 == 0xa +int 0xa ^ 0x2710 == 0x271a (0x271a) +__uint 0xa ^ 0x2710 == 0x271a (0x271a) +char 0xa ^ 0x10 == 0x1a (0x1a) +__uchar 0xa ^ 0x10 == 0x1a (0x1a) +__longlong 0xa ^ 0x2710 == 0x271a (0x271a) +__ulonglong 0xa ^ 0x2710 == 0x271a (0x271a) +int 0xa && 0x2710 == 0x1 (0x1) +__uint 0xa && 0x2710 == 0x1 (0x1) +char 0xa && 0x10 == 0x1 (0x1) +__uchar 0xa && 0x10 == 0x1 (0x1) +__longlong 0xa && 0x2710 == 0x1 (0x1) +__ulonglong 0xa && 0x2710 == 0x1 (0x1) +int 0xa || 0x2710 == 0x1 (0x1) +__uint 0xa || 0x2710 == 0x1 (0x1) +char 0xa || 0x10 == 0x1 (0x1) +__uchar 0xa || 0x10 == 0x1 (0x1) +__longlong 0xa || 0x2710 == 0x1 (0x1) +__ulonglong 0xa || 0x2710 == 0x1 (0x1) +int 0xa & 0x2710 == 0x0 (0x0) +__uint 0xa & 0x2710 == 0x0 (0x0) +char 0xa & 0x10 == 0x0 (0x0) +__uchar 0xa & 0x10 == 0x0 (0x0) +__longlong 0xa & 0x2710 == 0x0 (0x0) +__ulonglong 0xa & 0x2710 == 0x0 (0x0) +int 0xa | 0x2710 == 0x271a (0x271a) +__uint 0xa | 0x2710 == 0x271a (0x271a) +char 0xa | 0x10 == 0x1a (0x1a) +__uchar 0xa | 0x10 == 0x1a (0x1a) +__longlong 0xa | 0x2710 == 0x271a (0x271a) +__ulonglong 0xa | 0x2710 == 0x271a (0x271a) +int 0xa << 0x16 == 0x0 (0x0) +__uint 0xa << 0x16 == 0x0 (0x0) +char 0xa << 0x16 == 0x0 (0x0) +__uchar 0xa << 0x16 == 0x0 (0x0) +__longlong 0xa << 0x16 == 0x0 (0x0) +__ulonglong 0xa << 0x16 == 0x0 (0x0) +int 0xa >> 0x16 == 0x0 (0x0) +__uint 0xa >> 0x16 == 0x0 (0x0) +char 0xa >> 0x16 == 0x0 (0x0) +__uchar 0xa >> 0x16 == 0x0 (0x0) +__longlong 0xa >> 0x16 == 0x0 (0x0) +__ulonglong 0xa >> 0x16 == 0x0 (0x0) +int 0xa + 0x2710 == 0x271a (0x271a) +__uint 0xa + 0x2710 == 0x271a (0x271a) +char 0xa + 0x10 == 0x1a (0x1a) +__uchar 0xa + 0x10 == 0x1a (0x1a) +__longlong 0xa + 0x2710 == 0x271a (0x271a) +__ulonglong 0xa + 0x2710 == 0x271a (0x271a) +float 0xa + 0x2710 == 0x271a (0x271a) +int 0xa - 0x2710 == -0x2706 (0xd8fa) +__uint 0xa - 0x2710 == -0x2706 (0xd8fa) +char 0xa - 0x10 == -0x6 (0xfffa) +__uchar 0xa - 0x10 == 0xfa (0xfa) +__longlong 0xa - 0x2710 == -0x2706 (0xd8fa) +__ulonglong 0xa - 0x2710 == -0x2706 (0xd8fa) +float 0xa - 0x2710 == -0x2706 (0xd8fa) +int 0xa * 0x2710 == -0x7960 (0x86a0) +__uint 0xa * 0x2710 == -0x7960 (0x86a0) +char 0xa * 0x10 == -0x60 (0xffa0) +__uchar 0xa * 0x10 == 0xa0 (0xa0) +__longlong 0xa * 0x2710 == -0x7960 (0x86a0) +__ulonglong 0xa * 0x2710 == -0x7960 (0x86a0) +float 0xa * 0x2710 == -0x7960 (0x86a0) +int 0xa < 0x2710 == 0x1 (0x1) +__uint 0xa < 0x2710 == 0x1 (0x1) +char 0xa < 0x10 == 0x1 (0x1) +__uchar 0xa < 0x10 == 0x1 (0x1) +__longlong 0xa < 0x2710 == 0x1 (0x1) +__ulonglong 0xa < 0x2710 == 0x1 (0x1) +float 0xa < 0x2710 == 0x1 (0x1) +int 0xa > 0x2710 == 0x0 (0x0) +__uint 0xa > 0x2710 == 0x0 (0x0) +char 0xa > 0x10 == 0x0 (0x0) +__uchar 0xa > 0x10 == 0x0 (0x0) +__longlong 0xa > 0x2710 == 0x0 (0x0) +__ulonglong 0xa > 0x2710 == 0x0 (0x0) +float 0xa > 0x2710 == 0x0 (0x0) +int 0xa <= 0x2710 == 0x1 (0x1) +__uint 0xa <= 0x2710 == 0x1 (0x1) +char 0xa <= 0x10 == 0x1 (0x1) +__uchar 0xa <= 0x10 == 0x1 (0x1) +__longlong 0xa <= 0x2710 == 0x1 (0x1) +__ulonglong 0xa <= 0x2710 == 0x1 (0x1) +float 0xa <= 0x2710 == 0x1 (0x1) +int 0xa == 0x2710 == 0x0 (0x0) +__uint 0xa == 0x2710 == 0x0 (0x0) +char 0xa == 0x10 == 0x0 (0x0) +__uchar 0xa == 0x10 == 0x0 (0x0) +__longlong 0xa == 0x2710 == 0x0 (0x0) +__ulonglong 0xa == 0x2710 == 0x0 (0x0) +float 0xa == 0x2710 == 0x0 (0x0) +int 0xa != 0x2710 == 0x1 (0x1) +__uint 0xa != 0x2710 == 0x1 (0x1) +char 0xa != 0x10 == 0x1 (0x1) +__uchar 0xa != 0x10 == 0x1 (0x1) +__longlong 0xa != 0x2710 == 0x1 (0x1) +__ulonglong 0xa != 0x2710 == 0x1 (0x1) +float 0xa != 0x2710 == 0x1 (0x1) +int 0xa >= 0x2710 == 0x0 (0x0) +__uint 0xa >= 0x2710 == 0x0 (0x0) +char 0xa >= 0x10 == 0x0 (0x0) +__uchar 0xa >= 0x10 == 0x0 (0x0) +__longlong 0xa >= 0x2710 == 0x0 (0x0) +__ulonglong 0xa >= 0x2710 == 0x0 (0x0) +float 0xa >= 0x2710 == 0x0 (0x0) +int 0xa / 0x2710 == 0x0 (0x0) +__uint 0xa / 0x2710 == 0x0 (0x0) +char 0xa / 0x10 == 0x0 (0x0) +__uchar 0xa / 0x10 == 0x0 (0x0) +__longlong 0xa / 0x2710 == 0x0 (0x0) +__ulonglong 0xa / 0x2710 == 0x0 (0x0) +float 0xa / 0x2710 == 0x0 (0x0) +int 0xa % 0x2710 == 0xa (0xa) +__uint 0xa % 0x2710 == 0xa (0xa) +char 0xa % 0x10 == 0xa (0xa) +__uchar 0xa % 0x10 == 0xa (0xa) +__longlong 0xa % 0x2710 == 0xa (0xa) +__ulonglong 0xa % 0x2710 == 0xa (0xa) +int xor420xa xor42 0x20 +__uint xor420xa xor42 0x20 +char xor420xa xor42 0x20 +__uchar xor420xa xor42 0x20 +__longlong xor420xa xor42 0x20 +__ulonglong xor420xa xor42 0x20 +int land10xa land1 0x1 +__uint land10xa land1 0x1 +char land10xa land1 0x1 +__uchar land10xa land1 0x1 +__longlong land10xa land1 0x1 +__ulonglong land10xa land1 0x1 +int lor10xa lor1 0x1 +__uint lor10xa lor1 0x1 +char lor10xa lor1 0x1 +__uchar lor10xa lor1 0x1 +__longlong lor10xa lor1 0x1 +__ulonglong lor10xa lor1 0x1 +int and420xa and42 0xa +__uint and420xa and42 0xa +char and420xa and42 0xa +__uchar and420xa and42 0xa +__longlong and420xa and42 0xa +__ulonglong and420xa and42 0xa +int or420xa or42 0x2a +__uint or420xa or42 0x2a +char or420xa or42 0x2a +__uchar or420xa or42 0x2a +__longlong or420xa or42 0x2a +__ulonglong or420xa or42 0x2a +int shl50xa shl5 0x140 +__uint shl50xa shl5 0x140 +char shl50xa shl5 0x40 +__uchar shl50xa shl5 0x40 +__longlong shl50xa shl5 0x140 +__ulonglong shl50xa shl5 0x140 +int shr50xa shr5 0x0 +__uint shr50xa shr5 0x0 +char shr50xa shr5 0x0 +__uchar shr50xa shr5 0x0 +__longlong shr50xa shr5 0x0 +__ulonglong shr50xa shr5 0x0 +int add420xa add42 0x34 +__uint add420xa add42 0x34 +char add420xa add42 0x34 +__uchar add420xa add42 0x34 +__longlong add420xa add42 0x34 +__ulonglong add420xa add42 0x34 +float add420xa add42 0x34 +int sub420xa sub42 -0x20 +__uint sub420xa sub42 -0x20 +char sub420xa sub42 -0x20 +__uchar sub420xa sub42 0xe0 +__longlong sub420xa sub42 -0x20 +__ulonglong sub420xa sub42 -0x20 +float sub420xa sub42 -0x20 +int mul420xa mul42 0x1a4 +__uint mul420xa mul42 0x1a4 +char mul420xa mul42 -0x5c +__uchar mul420xa mul42 0xa4 +__longlong mul420xa mul42 0x1a4 +__ulonglong mul420xa mul42 0x1a4 +float mul420xa mul42 0x1a4 +int lt420xa lt42 0x1 +__uint lt420xa lt42 0x1 +char lt420xa lt42 0x1 +__uchar lt420xa lt42 0x1 +__longlong lt420xa lt42 0x1 +__ulonglong lt420xa lt42 0x1 +float lt420xa lt42 0x1 +int gt420xa gt42 0x0 +__uint gt420xa gt42 0x0 +char gt420xa gt42 0x0 +__uchar gt420xa gt42 0x0 +__longlong gt420xa gt42 0x0 +__ulonglong gt420xa gt42 0x0 +float gt420xa gt42 0x0 +int le420xa le42 0x1 +__uint le420xa le42 0x1 +char le420xa le42 0x1 +__uchar le420xa le42 0x1 +__longlong le420xa le42 0x1 +__ulonglong le420xa le42 0x1 +float le420xa le42 0x1 +int eq420xa eq42 0x0 +__uint eq420xa eq42 0x0 +char eq420xa eq42 0x0 +__uchar eq420xa eq42 0x0 +__longlong eq420xa eq42 0x0 +__ulonglong eq420xa eq42 0x0 +float eq420xa eq42 0x0 +int ne420xa ne42 0x1 +__uint ne420xa ne42 0x1 +char ne420xa ne42 0x1 +__uchar ne420xa ne42 0x1 +__longlong ne420xa ne42 0x1 +__ulonglong ne420xa ne42 0x1 +float ne420xa ne42 0x1 +int ge420xa ge42 0x0 +__uint ge420xa ge42 0x0 +char ge420xa ge42 0x0 +__uchar ge420xa ge42 0x0 +__longlong ge420xa ge42 0x0 +__ulonglong ge420xa ge42 0x0 +float ge420xa ge42 0x0 +int div420xa div42 0x0 +__uint div420xa div42 0x0 +char div420xa div42 0x0 +__uchar div420xa div42 0x0 +__longlong div420xa div42 0x0 +__ulonglong div420xa div42 0x0 +float div420xa div42 0x0 +int mod230xa mod23 0xa +__uint mod230xa mod23 0xa +char mod230xa mod23 0xa +__uchar mod230xa mod23 0xa +__longlong mod230xa mod23 0xa +__ulonglong mod230xa mod23 0xa +0xfff6 * 0xffff == 0xa +0xfff6 / 0xffff == 0xa +0xfff6 % 0xffff == 0x0 +int 0xfff6 ^ 0xffff == 0x9 (0x9) +__uint 0xfff6 ^ 0xffff == 0x9 (0x9) +char 0xfff6 ^ 0xffff == 0x9 (0x9) +__uchar 0xf6 ^ 0xff == 0x9 (0x9) +__longlong 0xfff6 ^ 0xffff == 0x9 (0x9) +__ulonglong 0xfff6 ^ 0xffff == 0x9 (0x9) +int 0xfff6 && 0xffff == 0x1 (0x1) +__uint 0xfff6 && 0xffff == 0x1 (0x1) +char 0xfff6 && 0xffff == 0x1 (0x1) +__uchar 0xf6 && 0xff == 0x1 (0x1) +__longlong 0xfff6 && 0xffff == 0x1 (0x1) +__ulonglong 0xfff6 && 0xffff == 0x1 (0x1) +int 0xfff6 || 0xffff == 0x1 (0x1) +__uint 0xfff6 || 0xffff == 0x1 (0x1) +char 0xfff6 || 0xffff == 0x1 (0x1) +__uchar 0xf6 || 0xff == 0x1 (0x1) +__longlong 0xfff6 || 0xffff == 0x1 (0x1) +__ulonglong 0xfff6 || 0xffff == 0x1 (0x1) +int 0xfff6 & 0xffff == -0xa (0xfff6) +__uint 0xfff6 & 0xffff == -0xa (0xfff6) +char 0xfff6 & 0xffff == -0xa (0xfff6) +__uchar 0xf6 & 0xff == 0xf6 (0xf6) +__longlong 0xfff6 & 0xffff == -0xa (0xfff6) +__ulonglong 0xfff6 & 0xffff == -0xa (0xfff6) +int 0xfff6 | 0xffff == -0x1 (0xffff) +__uint 0xfff6 | 0xffff == -0x1 (0xffff) +char 0xfff6 | 0xffff == -0x1 (0xffff) +__uchar 0xf6 | 0xff == 0xff (0xff) +__longlong 0xfff6 | 0xffff == -0x1 (0xffff) +__ulonglong 0xfff6 | 0xffff == -0x1 (0xffff) +int 0xfff6 << 0x1 == -0x14 (0xffec) +__uint 0xfff6 << 0x1 == -0x14 (0xffec) +char 0xfff6 << 0x1 == -0x14 (0xffec) +__uchar 0xf6 << 0x1 == 0xec (0xec) +__longlong 0xfff6 << 0x1 == -0x14 (0xffec) +__ulonglong 0xfff6 << 0x1 == -0x14 (0xffec) +int 0xfff6 >> 0x1 == -0x5 (0xfffb) +__uint 0xfff6 >> 0x1 == 0x7ffb (0x7ffb) +char 0xfff6 >> 0x1 == -0x5 (0xfffb) +__uchar 0xf6 >> 0x1 == 0x7b (0x7b) +__longlong 0xfff6 >> 0x1 == -0x5 (0xfffb) +__ulonglong 0xfff6 >> 0x1 == -0x5 (0xfffb) +int 0xfff6 + 0xffff == -0xb (0xfff5) +__uint 0xfff6 + 0xffff == -0xb (0xfff5) +char 0xfff6 + 0xffff == -0xb (0xfff5) +__uchar 0xf6 + 0xff == 0xf5 (0xf5) +__longlong 0xfff6 + 0xffff == -0xb (0xfff5) +__ulonglong 0xfff6 + 0xffff == -0xb (0xfff5) +float 0xfff6 + 0xffff == -0xb (0xfff5) +int 0xfff6 - 0xffff == -0x9 (0xfff7) +__uint 0xfff6 - 0xffff == -0x9 (0xfff7) +char 0xfff6 - 0xffff == -0x9 (0xfff7) +__uchar 0xf6 - 0xff == 0xf7 (0xf7) +__longlong 0xfff6 - 0xffff == -0x9 (0xfff7) +__ulonglong 0xfff6 - 0xffff == -0x9 (0xfff7) +float 0xfff6 - 0xffff == -0x9 (0xfff7) +int 0xfff6 * 0xffff == 0xa (0xa) +__uint 0xfff6 * 0xffff == 0xa (0xa) +char 0xfff6 * 0xffff == 0xa (0xa) +__uchar 0xf6 * 0xff == 0xa (0xa) +__longlong 0xfff6 * 0xffff == 0xa (0xa) +__ulonglong 0xfff6 * 0xffff == 0xa (0xa) +float 0xfff6 * 0xffff == 0xa (0xa) +int 0xfff6 < 0xffff == 0x1 (0x1) +__uint 0xfff6 < 0xffff == 0x1 (0x1) +char 0xfff6 < 0xffff == 0x1 (0x1) +__uchar 0xf6 < 0xff == 0x1 (0x1) +__longlong 0xfff6 < 0xffff == 0x1 (0x1) +__ulonglong 0xfff6 < 0xffff == 0x1 (0x1) +float 0xfff6 < 0xffff == 0x1 (0x1) +int 0xfff6 > 0xffff == 0x0 (0x0) +__uint 0xfff6 > 0xffff == 0x0 (0x0) +char 0xfff6 > 0xffff == 0x0 (0x0) +__uchar 0xf6 > 0xff == 0x0 (0x0) +__longlong 0xfff6 > 0xffff == 0x0 (0x0) +__ulonglong 0xfff6 > 0xffff == 0x0 (0x0) +float 0xfff6 > 0xffff == 0x0 (0x0) +int 0xfff6 <= 0xffff == 0x1 (0x1) +__uint 0xfff6 <= 0xffff == 0x1 (0x1) +char 0xfff6 <= 0xffff == 0x1 (0x1) +__uchar 0xf6 <= 0xff == 0x1 (0x1) +__longlong 0xfff6 <= 0xffff == 0x1 (0x1) +__ulonglong 0xfff6 <= 0xffff == 0x1 (0x1) +float 0xfff6 <= 0xffff == 0x1 (0x1) +int 0xfff6 == 0xffff == 0x0 (0x0) +__uint 0xfff6 == 0xffff == 0x0 (0x0) +char 0xfff6 == 0xffff == 0x0 (0x0) +__uchar 0xf6 == 0xff == 0x0 (0x0) +__longlong 0xfff6 == 0xffff == 0x0 (0x0) +__ulonglong 0xfff6 == 0xffff == 0x0 (0x0) +float 0xfff6 == 0xffff == 0x0 (0x0) +int 0xfff6 != 0xffff == 0x1 (0x1) +__uint 0xfff6 != 0xffff == 0x1 (0x1) +char 0xfff6 != 0xffff == 0x1 (0x1) +__uchar 0xf6 != 0xff == 0x1 (0x1) +__longlong 0xfff6 != 0xffff == 0x1 (0x1) +__ulonglong 0xfff6 != 0xffff == 0x1 (0x1) +float 0xfff6 != 0xffff == 0x1 (0x1) +int 0xfff6 >= 0xffff == 0x0 (0x0) +__uint 0xfff6 >= 0xffff == 0x0 (0x0) +char 0xfff6 >= 0xffff == 0x0 (0x0) +__uchar 0xf6 >= 0xff == 0x0 (0x0) +__longlong 0xfff6 >= 0xffff == 0x0 (0x0) +__ulonglong 0xfff6 >= 0xffff == 0x0 (0x0) +float 0xfff6 >= 0xffff == 0x0 (0x0) +int 0xfff6 / 0xffff == 0xa (0xa) +__uint 0xfff6 / 0xffff == 0x0 (0x0) +char 0xfff6 / 0xffff == 0xa (0xa) +__uchar 0xf6 / 0xff == 0x0 (0x0) +__longlong 0xfff6 / 0xffff == 0xa (0xa) +__ulonglong 0xfff6 / 0xffff == 0x0 (0x0) +float 0xfff6 / 0xffff == 0xa (0xa) +int 0xfff6 % 0xffff == 0x0 (0x0) +__uint 0xfff6 % 0xffff == -0xa (0xfff6) +char 0xfff6 % 0xffff == 0x0 (0x0) +__uchar 0xf6 % 0xff == 0xf6 (0xf6) +__longlong 0xfff6 % 0xffff == 0x0 (0x0) +__ulonglong 0xfff6 % 0xffff == -0xa (0xfff6) +0xfff6 * 0x1 == -0xa +0xfff6 / 0x1 == -0xa +0xfff6 % 0x1 == 0x0 +int 0xfff6 ^ 0x1 == -0x9 (0xfff7) +__uint 0xfff6 ^ 0x1 == -0x9 (0xfff7) +char 0xfff6 ^ 0x1 == -0x9 (0xfff7) +__uchar 0xf6 ^ 0x1 == 0xf7 (0xf7) +__longlong 0xfff6 ^ 0x1 == -0x9 (0xfff7) +__ulonglong 0xfff6 ^ 0x1 == -0x9 (0xfff7) +int 0xfff6 && 0x1 == 0x1 (0x1) +__uint 0xfff6 && 0x1 == 0x1 (0x1) +char 0xfff6 && 0x1 == 0x1 (0x1) +__uchar 0xf6 && 0x1 == 0x1 (0x1) +__longlong 0xfff6 && 0x1 == 0x1 (0x1) +__ulonglong 0xfff6 && 0x1 == 0x1 (0x1) +int 0xfff6 || 0x1 == 0x1 (0x1) +__uint 0xfff6 || 0x1 == 0x1 (0x1) +char 0xfff6 || 0x1 == 0x1 (0x1) +__uchar 0xf6 || 0x1 == 0x1 (0x1) +__longlong 0xfff6 || 0x1 == 0x1 (0x1) +__ulonglong 0xfff6 || 0x1 == 0x1 (0x1) +int 0xfff6 & 0x1 == 0x0 (0x0) +__uint 0xfff6 & 0x1 == 0x0 (0x0) +char 0xfff6 & 0x1 == 0x0 (0x0) +__uchar 0xf6 & 0x1 == 0x0 (0x0) +__longlong 0xfff6 & 0x1 == 0x0 (0x0) +__ulonglong 0xfff6 & 0x1 == 0x0 (0x0) +int 0xfff6 | 0x1 == -0x9 (0xfff7) +__uint 0xfff6 | 0x1 == -0x9 (0xfff7) +char 0xfff6 | 0x1 == -0x9 (0xfff7) +__uchar 0xf6 | 0x1 == 0xf7 (0xf7) +__longlong 0xfff6 | 0x1 == -0x9 (0xfff7) +__ulonglong 0xfff6 | 0x1 == -0x9 (0xfff7) +int 0xfff6 << 0x2 == -0x28 (0xffd8) +__uint 0xfff6 << 0x2 == -0x28 (0xffd8) +char 0xfff6 << 0x2 == -0x28 (0xffd8) +__uchar 0xf6 << 0x2 == 0xd8 (0xd8) +__longlong 0xfff6 << 0x2 == -0x28 (0xffd8) +__ulonglong 0xfff6 << 0x2 == -0x28 (0xffd8) +int 0xfff6 >> 0x2 == -0x3 (0xfffd) +__uint 0xfff6 >> 0x2 == 0x3ffd (0x3ffd) +char 0xfff6 >> 0x2 == -0x3 (0xfffd) +__uchar 0xf6 >> 0x2 == 0x3d (0x3d) +__longlong 0xfff6 >> 0x2 == -0x3 (0xfffd) +__ulonglong 0xfff6 >> 0x2 == -0x3 (0xfffd) +int 0xfff6 + 0x1 == -0x9 (0xfff7) +__uint 0xfff6 + 0x1 == -0x9 (0xfff7) +char 0xfff6 + 0x1 == -0x9 (0xfff7) +__uchar 0xf6 + 0x1 == 0xf7 (0xf7) +__longlong 0xfff6 + 0x1 == -0x9 (0xfff7) +__ulonglong 0xfff6 + 0x1 == -0x9 (0xfff7) +float 0xfff6 + 0x1 == -0x9 (0xfff7) +int 0xfff6 - 0x1 == -0xb (0xfff5) +__uint 0xfff6 - 0x1 == -0xb (0xfff5) +char 0xfff6 - 0x1 == -0xb (0xfff5) +__uchar 0xf6 - 0x1 == 0xf5 (0xf5) +__longlong 0xfff6 - 0x1 == -0xb (0xfff5) +__ulonglong 0xfff6 - 0x1 == -0xb (0xfff5) +float 0xfff6 - 0x1 == -0xb (0xfff5) +int 0xfff6 * 0x1 == -0xa (0xfff6) +__uint 0xfff6 * 0x1 == -0xa (0xfff6) +char 0xfff6 * 0x1 == -0xa (0xfff6) +__uchar 0xf6 * 0x1 == 0xf6 (0xf6) +__longlong 0xfff6 * 0x1 == -0xa (0xfff6) +__ulonglong 0xfff6 * 0x1 == -0xa (0xfff6) +float 0xfff6 * 0x1 == -0xa (0xfff6) +int 0xfff6 < 0x1 == 0x1 (0x1) +__uint 0xfff6 < 0x1 == 0x0 (0x0) +char 0xfff6 < 0x1 == 0x1 (0x1) +__uchar 0xf6 < 0x1 == 0x0 (0x0) +__longlong 0xfff6 < 0x1 == 0x1 (0x1) +__ulonglong 0xfff6 < 0x1 == 0x0 (0x0) +float 0xfff6 < 0x1 == 0x1 (0x1) +int 0xfff6 > 0x1 == 0x0 (0x0) +__uint 0xfff6 > 0x1 == 0x1 (0x1) +char 0xfff6 > 0x1 == 0x0 (0x0) +__uchar 0xf6 > 0x1 == 0x1 (0x1) +__longlong 0xfff6 > 0x1 == 0x0 (0x0) +__ulonglong 0xfff6 > 0x1 == 0x1 (0x1) +float 0xfff6 > 0x1 == 0x0 (0x0) +int 0xfff6 <= 0x1 == 0x1 (0x1) +__uint 0xfff6 <= 0x1 == 0x0 (0x0) +char 0xfff6 <= 0x1 == 0x1 (0x1) +__uchar 0xf6 <= 0x1 == 0x0 (0x0) +__longlong 0xfff6 <= 0x1 == 0x1 (0x1) +__ulonglong 0xfff6 <= 0x1 == 0x0 (0x0) +float 0xfff6 <= 0x1 == 0x1 (0x1) +int 0xfff6 == 0x1 == 0x0 (0x0) +__uint 0xfff6 == 0x1 == 0x0 (0x0) +char 0xfff6 == 0x1 == 0x0 (0x0) +__uchar 0xf6 == 0x1 == 0x0 (0x0) +__longlong 0xfff6 == 0x1 == 0x0 (0x0) +__ulonglong 0xfff6 == 0x1 == 0x0 (0x0) +float 0xfff6 == 0x1 == 0x0 (0x0) +int 0xfff6 != 0x1 == 0x1 (0x1) +__uint 0xfff6 != 0x1 == 0x1 (0x1) +char 0xfff6 != 0x1 == 0x1 (0x1) +__uchar 0xf6 != 0x1 == 0x1 (0x1) +__longlong 0xfff6 != 0x1 == 0x1 (0x1) +__ulonglong 0xfff6 != 0x1 == 0x1 (0x1) +float 0xfff6 != 0x1 == 0x1 (0x1) +int 0xfff6 >= 0x1 == 0x0 (0x0) +__uint 0xfff6 >= 0x1 == 0x1 (0x1) +char 0xfff6 >= 0x1 == 0x0 (0x0) +__uchar 0xf6 >= 0x1 == 0x1 (0x1) +__longlong 0xfff6 >= 0x1 == 0x0 (0x0) +__ulonglong 0xfff6 >= 0x1 == 0x1 (0x1) +float 0xfff6 >= 0x1 == 0x0 (0x0) +int 0xfff6 / 0x1 == -0xa (0xfff6) +__uint 0xfff6 / 0x1 == -0xa (0xfff6) +char 0xfff6 / 0x1 == -0xa (0xfff6) +__uchar 0xf6 / 0x1 == 0xf6 (0xf6) +__longlong 0xfff6 / 0x1 == -0xa (0xfff6) +__ulonglong 0xfff6 / 0x1 == -0xa (0xfff6) +float 0xfff6 / 0x1 == -0xa (0xfff6) +int 0xfff6 % 0x1 == 0x0 (0x0) +__uint 0xfff6 % 0x1 == 0x0 (0x0) +char 0xfff6 % 0x1 == 0x0 (0x0) +__uchar 0xf6 % 0x1 == 0x0 (0x0) +__longlong 0xfff6 % 0x1 == 0x0 (0x0) +__ulonglong 0xfff6 % 0x1 == 0x0 (0x0) +0xfff6 * 0x2 == -0x14 +0xfff6 / 0x2 == -0x5 +0xfff6 % 0x2 == 0x0 +int 0xfff6 ^ 0x2 == -0xc (0xfff4) +__uint 0xfff6 ^ 0x2 == -0xc (0xfff4) +char 0xfff6 ^ 0x2 == -0xc (0xfff4) +__uchar 0xf6 ^ 0x2 == 0xf4 (0xf4) +__longlong 0xfff6 ^ 0x2 == -0xc (0xfff4) +__ulonglong 0xfff6 ^ 0x2 == -0xc (0xfff4) +int 0xfff6 && 0x2 == 0x1 (0x1) +__uint 0xfff6 && 0x2 == 0x1 (0x1) +char 0xfff6 && 0x2 == 0x1 (0x1) +__uchar 0xf6 && 0x2 == 0x1 (0x1) +__longlong 0xfff6 && 0x2 == 0x1 (0x1) +__ulonglong 0xfff6 && 0x2 == 0x1 (0x1) +int 0xfff6 || 0x2 == 0x1 (0x1) +__uint 0xfff6 || 0x2 == 0x1 (0x1) +char 0xfff6 || 0x2 == 0x1 (0x1) +__uchar 0xf6 || 0x2 == 0x1 (0x1) +__longlong 0xfff6 || 0x2 == 0x1 (0x1) +__ulonglong 0xfff6 || 0x2 == 0x1 (0x1) +int 0xfff6 & 0x2 == 0x2 (0x2) +__uint 0xfff6 & 0x2 == 0x2 (0x2) +char 0xfff6 & 0x2 == 0x2 (0x2) +__uchar 0xf6 & 0x2 == 0x2 (0x2) +__longlong 0xfff6 & 0x2 == 0x2 (0x2) +__ulonglong 0xfff6 & 0x2 == 0x2 (0x2) +int 0xfff6 | 0x2 == -0xa (0xfff6) +__uint 0xfff6 | 0x2 == -0xa (0xfff6) +char 0xfff6 | 0x2 == -0xa (0xfff6) +__uchar 0xf6 | 0x2 == 0xf6 (0xf6) +__longlong 0xfff6 | 0x2 == -0xa (0xfff6) +__ulonglong 0xfff6 | 0x2 == -0xa (0xfff6) +int 0xfff6 << 0x3 == -0x50 (0xffb0) +__uint 0xfff6 << 0x3 == -0x50 (0xffb0) +char 0xfff6 << 0x3 == -0x50 (0xffb0) +__uchar 0xf6 << 0x3 == 0xb0 (0xb0) +__longlong 0xfff6 << 0x3 == -0x50 (0xffb0) +__ulonglong 0xfff6 << 0x3 == -0x50 (0xffb0) +int 0xfff6 >> 0x3 == -0x2 (0xfffe) +__uint 0xfff6 >> 0x3 == 0x1ffe (0x1ffe) +char 0xfff6 >> 0x3 == -0x2 (0xfffe) +__uchar 0xf6 >> 0x3 == 0x1e (0x1e) +__longlong 0xfff6 >> 0x3 == -0x2 (0xfffe) +__ulonglong 0xfff6 >> 0x3 == -0x2 (0xfffe) +int 0xfff6 + 0x2 == -0x8 (0xfff8) +__uint 0xfff6 + 0x2 == -0x8 (0xfff8) +char 0xfff6 + 0x2 == -0x8 (0xfff8) +__uchar 0xf6 + 0x2 == 0xf8 (0xf8) +__longlong 0xfff6 + 0x2 == -0x8 (0xfff8) +__ulonglong 0xfff6 + 0x2 == -0x8 (0xfff8) +float 0xfff6 + 0x2 == -0x8 (0xfff8) +int 0xfff6 - 0x2 == -0xc (0xfff4) +__uint 0xfff6 - 0x2 == -0xc (0xfff4) +char 0xfff6 - 0x2 == -0xc (0xfff4) +__uchar 0xf6 - 0x2 == 0xf4 (0xf4) +__longlong 0xfff6 - 0x2 == -0xc (0xfff4) +__ulonglong 0xfff6 - 0x2 == -0xc (0xfff4) +float 0xfff6 - 0x2 == -0xc (0xfff4) +int 0xfff6 * 0x2 == -0x14 (0xffec) +__uint 0xfff6 * 0x2 == -0x14 (0xffec) +char 0xfff6 * 0x2 == -0x14 (0xffec) +__uchar 0xf6 * 0x2 == 0xec (0xec) +__longlong 0xfff6 * 0x2 == -0x14 (0xffec) +__ulonglong 0xfff6 * 0x2 == -0x14 (0xffec) +float 0xfff6 * 0x2 == -0x14 (0xffec) +int 0xfff6 < 0x2 == 0x1 (0x1) +__uint 0xfff6 < 0x2 == 0x0 (0x0) +char 0xfff6 < 0x2 == 0x1 (0x1) +__uchar 0xf6 < 0x2 == 0x0 (0x0) +__longlong 0xfff6 < 0x2 == 0x1 (0x1) +__ulonglong 0xfff6 < 0x2 == 0x0 (0x0) +float 0xfff6 < 0x2 == 0x1 (0x1) +int 0xfff6 > 0x2 == 0x0 (0x0) +__uint 0xfff6 > 0x2 == 0x1 (0x1) +char 0xfff6 > 0x2 == 0x0 (0x0) +__uchar 0xf6 > 0x2 == 0x1 (0x1) +__longlong 0xfff6 > 0x2 == 0x0 (0x0) +__ulonglong 0xfff6 > 0x2 == 0x1 (0x1) +float 0xfff6 > 0x2 == 0x0 (0x0) +int 0xfff6 <= 0x2 == 0x1 (0x1) +__uint 0xfff6 <= 0x2 == 0x0 (0x0) +char 0xfff6 <= 0x2 == 0x1 (0x1) +__uchar 0xf6 <= 0x2 == 0x0 (0x0) +__longlong 0xfff6 <= 0x2 == 0x1 (0x1) +__ulonglong 0xfff6 <= 0x2 == 0x0 (0x0) +float 0xfff6 <= 0x2 == 0x1 (0x1) +int 0xfff6 == 0x2 == 0x0 (0x0) +__uint 0xfff6 == 0x2 == 0x0 (0x0) +char 0xfff6 == 0x2 == 0x0 (0x0) +__uchar 0xf6 == 0x2 == 0x0 (0x0) +__longlong 0xfff6 == 0x2 == 0x0 (0x0) +__ulonglong 0xfff6 == 0x2 == 0x0 (0x0) +float 0xfff6 == 0x2 == 0x0 (0x0) +int 0xfff6 != 0x2 == 0x1 (0x1) +__uint 0xfff6 != 0x2 == 0x1 (0x1) +char 0xfff6 != 0x2 == 0x1 (0x1) +__uchar 0xf6 != 0x2 == 0x1 (0x1) +__longlong 0xfff6 != 0x2 == 0x1 (0x1) +__ulonglong 0xfff6 != 0x2 == 0x1 (0x1) +float 0xfff6 != 0x2 == 0x1 (0x1) +int 0xfff6 >= 0x2 == 0x0 (0x0) +__uint 0xfff6 >= 0x2 == 0x1 (0x1) +char 0xfff6 >= 0x2 == 0x0 (0x0) +__uchar 0xf6 >= 0x2 == 0x1 (0x1) +__longlong 0xfff6 >= 0x2 == 0x0 (0x0) +__ulonglong 0xfff6 >= 0x2 == 0x1 (0x1) +float 0xfff6 >= 0x2 == 0x0 (0x0) +int 0xfff6 / 0x2 == -0x5 (0xfffb) +__uint 0xfff6 / 0x2 == 0x7ffb (0x7ffb) +char 0xfff6 / 0x2 == -0x5 (0xfffb) +__uchar 0xf6 / 0x2 == 0x7b (0x7b) +__longlong 0xfff6 / 0x2 == -0x5 (0xfffb) +__ulonglong 0xfff6 / 0x2 == -0x5 (0xfffb) +float 0xfff6 / 0x2 == -0x5 (0xfffb) +int 0xfff6 % 0x2 == 0x0 (0x0) +__uint 0xfff6 % 0x2 == 0x0 (0x0) +char 0xfff6 % 0x2 == 0x0 (0x0) +__uchar 0xf6 % 0x2 == 0x0 (0x0) +__longlong 0xfff6 % 0x2 == 0x0 (0x0) +__ulonglong 0xfff6 % 0x2 == 0x0 (0x0) +0xfff6 * 0xfffe == 0x14 +0xfff6 / 0xfffe == 0x5 +0xfff6 % 0xfffe == 0x0 +int 0xfff6 ^ 0xfffe == 0x8 (0x8) +__uint 0xfff6 ^ 0xfffe == 0x8 (0x8) +char 0xfff6 ^ 0xfffe == 0x8 (0x8) +__uchar 0xf6 ^ 0xfe == 0x8 (0x8) +__longlong 0xfff6 ^ 0xfffe == 0x8 (0x8) +__ulonglong 0xfff6 ^ 0xfffe == 0x8 (0x8) +int 0xfff6 && 0xfffe == 0x1 (0x1) +__uint 0xfff6 && 0xfffe == 0x1 (0x1) +char 0xfff6 && 0xfffe == 0x1 (0x1) +__uchar 0xf6 && 0xfe == 0x1 (0x1) +__longlong 0xfff6 && 0xfffe == 0x1 (0x1) +__ulonglong 0xfff6 && 0xfffe == 0x1 (0x1) +int 0xfff6 || 0xfffe == 0x1 (0x1) +__uint 0xfff6 || 0xfffe == 0x1 (0x1) +char 0xfff6 || 0xfffe == 0x1 (0x1) +__uchar 0xf6 || 0xfe == 0x1 (0x1) +__longlong 0xfff6 || 0xfffe == 0x1 (0x1) +__ulonglong 0xfff6 || 0xfffe == 0x1 (0x1) +int 0xfff6 & 0xfffe == -0xa (0xfff6) +__uint 0xfff6 & 0xfffe == -0xa (0xfff6) +char 0xfff6 & 0xfffe == -0xa (0xfff6) +__uchar 0xf6 & 0xfe == 0xf6 (0xf6) +__longlong 0xfff6 & 0xfffe == -0xa (0xfff6) +__ulonglong 0xfff6 & 0xfffe == -0xa (0xfff6) +int 0xfff6 | 0xfffe == -0x2 (0xfffe) +__uint 0xfff6 | 0xfffe == -0x2 (0xfffe) +char 0xfff6 | 0xfffe == -0x2 (0xfffe) +__uchar 0xf6 | 0xfe == 0xfe (0xfe) +__longlong 0xfff6 | 0xfffe == -0x2 (0xfffe) +__ulonglong 0xfff6 | 0xfffe == -0x2 (0xfffe) +int 0xfff6 << 0x4 == -0xa0 (0xff60) +__uint 0xfff6 << 0x4 == -0xa0 (0xff60) +char 0xfff6 << 0x4 == 0x60 (0x60) +__uchar 0xf6 << 0x4 == 0x60 (0x60) +__longlong 0xfff6 << 0x4 == -0xa0 (0xff60) +__ulonglong 0xfff6 << 0x4 == -0xa0 (0xff60) +int 0xfff6 >> 0x4 == -0x1 (0xffff) +__uint 0xfff6 >> 0x4 == 0xfff (0xfff) +char 0xfff6 >> 0x4 == -0x1 (0xffff) +__uchar 0xf6 >> 0x4 == 0xf (0xf) +__longlong 0xfff6 >> 0x4 == -0x1 (0xffff) +__ulonglong 0xfff6 >> 0x4 == -0x1 (0xffff) +int 0xfff6 + 0xfffe == -0xc (0xfff4) +__uint 0xfff6 + 0xfffe == -0xc (0xfff4) +char 0xfff6 + 0xfffe == -0xc (0xfff4) +__uchar 0xf6 + 0xfe == 0xf4 (0xf4) +__longlong 0xfff6 + 0xfffe == -0xc (0xfff4) +__ulonglong 0xfff6 + 0xfffe == -0xc (0xfff4) +float 0xfff6 + 0xfffe == -0xc (0xfff4) +int 0xfff6 - 0xfffe == -0x8 (0xfff8) +__uint 0xfff6 - 0xfffe == -0x8 (0xfff8) +char 0xfff6 - 0xfffe == -0x8 (0xfff8) +__uchar 0xf6 - 0xfe == 0xf8 (0xf8) +__longlong 0xfff6 - 0xfffe == -0x8 (0xfff8) +__ulonglong 0xfff6 - 0xfffe == -0x8 (0xfff8) +float 0xfff6 - 0xfffe == -0x8 (0xfff8) +int 0xfff6 * 0xfffe == 0x14 (0x14) +__uint 0xfff6 * 0xfffe == 0x14 (0x14) +char 0xfff6 * 0xfffe == 0x14 (0x14) +__uchar 0xf6 * 0xfe == 0x14 (0x14) +__longlong 0xfff6 * 0xfffe == 0x14 (0x14) +__ulonglong 0xfff6 * 0xfffe == 0x14 (0x14) +float 0xfff6 * 0xfffe == 0x14 (0x14) +int 0xfff6 < 0xfffe == 0x1 (0x1) +__uint 0xfff6 < 0xfffe == 0x1 (0x1) +char 0xfff6 < 0xfffe == 0x1 (0x1) +__uchar 0xf6 < 0xfe == 0x1 (0x1) +__longlong 0xfff6 < 0xfffe == 0x1 (0x1) +__ulonglong 0xfff6 < 0xfffe == 0x1 (0x1) +float 0xfff6 < 0xfffe == 0x1 (0x1) +int 0xfff6 > 0xfffe == 0x0 (0x0) +__uint 0xfff6 > 0xfffe == 0x0 (0x0) +char 0xfff6 > 0xfffe == 0x0 (0x0) +__uchar 0xf6 > 0xfe == 0x0 (0x0) +__longlong 0xfff6 > 0xfffe == 0x0 (0x0) +__ulonglong 0xfff6 > 0xfffe == 0x0 (0x0) +float 0xfff6 > 0xfffe == 0x0 (0x0) +int 0xfff6 <= 0xfffe == 0x1 (0x1) +__uint 0xfff6 <= 0xfffe == 0x1 (0x1) +char 0xfff6 <= 0xfffe == 0x1 (0x1) +__uchar 0xf6 <= 0xfe == 0x1 (0x1) +__longlong 0xfff6 <= 0xfffe == 0x1 (0x1) +__ulonglong 0xfff6 <= 0xfffe == 0x1 (0x1) +float 0xfff6 <= 0xfffe == 0x1 (0x1) +int 0xfff6 == 0xfffe == 0x0 (0x0) +__uint 0xfff6 == 0xfffe == 0x0 (0x0) +char 0xfff6 == 0xfffe == 0x0 (0x0) +__uchar 0xf6 == 0xfe == 0x0 (0x0) +__longlong 0xfff6 == 0xfffe == 0x0 (0x0) +__ulonglong 0xfff6 == 0xfffe == 0x0 (0x0) +float 0xfff6 == 0xfffe == 0x0 (0x0) +int 0xfff6 != 0xfffe == 0x1 (0x1) +__uint 0xfff6 != 0xfffe == 0x1 (0x1) +char 0xfff6 != 0xfffe == 0x1 (0x1) +__uchar 0xf6 != 0xfe == 0x1 (0x1) +__longlong 0xfff6 != 0xfffe == 0x1 (0x1) +__ulonglong 0xfff6 != 0xfffe == 0x1 (0x1) +float 0xfff6 != 0xfffe == 0x1 (0x1) +int 0xfff6 >= 0xfffe == 0x0 (0x0) +__uint 0xfff6 >= 0xfffe == 0x0 (0x0) +char 0xfff6 >= 0xfffe == 0x0 (0x0) +__uchar 0xf6 >= 0xfe == 0x0 (0x0) +__longlong 0xfff6 >= 0xfffe == 0x0 (0x0) +__ulonglong 0xfff6 >= 0xfffe == 0x0 (0x0) +float 0xfff6 >= 0xfffe == 0x0 (0x0) +int 0xfff6 / 0xfffe == 0x5 (0x5) +__uint 0xfff6 / 0xfffe == 0x0 (0x0) +char 0xfff6 / 0xfffe == 0x5 (0x5) +__uchar 0xf6 / 0xfe == 0x0 (0x0) +__longlong 0xfff6 / 0xfffe == 0x5 (0x5) +__ulonglong 0xfff6 / 0xfffe == 0x0 (0x0) +float 0xfff6 / 0xfffe == 0x5 (0x5) +int 0xfff6 % 0xfffe == 0x0 (0x0) +__uint 0xfff6 % 0xfffe == -0xa (0xfff6) +char 0xfff6 % 0xfffe == 0x0 (0x0) +__uchar 0xf6 % 0xfe == 0xf6 (0xf6) +__longlong 0xfff6 % 0xfffe == 0x0 (0x0) +__ulonglong 0xfff6 % 0xfffe == -0xa (0xfff6) +0xfff6 * 0x4 == -0x28 +0xfff6 / 0x4 == -0x2 +0xfff6 % 0x4 == -0x2 +int 0xfff6 ^ 0x4 == -0xe (0xfff2) +__uint 0xfff6 ^ 0x4 == -0xe (0xfff2) +char 0xfff6 ^ 0x4 == -0xe (0xfff2) +__uchar 0xf6 ^ 0x4 == 0xf2 (0xf2) +__longlong 0xfff6 ^ 0x4 == -0xe (0xfff2) +__ulonglong 0xfff6 ^ 0x4 == -0xe (0xfff2) +int 0xfff6 && 0x4 == 0x1 (0x1) +__uint 0xfff6 && 0x4 == 0x1 (0x1) +char 0xfff6 && 0x4 == 0x1 (0x1) +__uchar 0xf6 && 0x4 == 0x1 (0x1) +__longlong 0xfff6 && 0x4 == 0x1 (0x1) +__ulonglong 0xfff6 && 0x4 == 0x1 (0x1) +int 0xfff6 || 0x4 == 0x1 (0x1) +__uint 0xfff6 || 0x4 == 0x1 (0x1) +char 0xfff6 || 0x4 == 0x1 (0x1) +__uchar 0xf6 || 0x4 == 0x1 (0x1) +__longlong 0xfff6 || 0x4 == 0x1 (0x1) +__ulonglong 0xfff6 || 0x4 == 0x1 (0x1) +int 0xfff6 & 0x4 == 0x4 (0x4) +__uint 0xfff6 & 0x4 == 0x4 (0x4) +char 0xfff6 & 0x4 == 0x4 (0x4) +__uchar 0xf6 & 0x4 == 0x4 (0x4) +__longlong 0xfff6 & 0x4 == 0x4 (0x4) +__ulonglong 0xfff6 & 0x4 == 0x4 (0x4) +int 0xfff6 | 0x4 == -0xa (0xfff6) +__uint 0xfff6 | 0x4 == -0xa (0xfff6) +char 0xfff6 | 0x4 == -0xa (0xfff6) +__uchar 0xf6 | 0x4 == 0xf6 (0xf6) +__longlong 0xfff6 | 0x4 == -0xa (0xfff6) +__ulonglong 0xfff6 | 0x4 == -0xa (0xfff6) +int 0xfff6 << 0x5 == -0x140 (0xfec0) +__uint 0xfff6 << 0x5 == -0x140 (0xfec0) +char 0xfff6 << 0x5 == -0x40 (0xffc0) +__uchar 0xf6 << 0x5 == 0xc0 (0xc0) +__longlong 0xfff6 << 0x5 == -0x140 (0xfec0) +__ulonglong 0xfff6 << 0x5 == -0x140 (0xfec0) +int 0xfff6 >> 0x5 == -0x1 (0xffff) +__uint 0xfff6 >> 0x5 == 0x7ff (0x7ff) +char 0xfff6 >> 0x5 == -0x1 (0xffff) +__uchar 0xf6 >> 0x5 == 0x7 (0x7) +__longlong 0xfff6 >> 0x5 == -0x1 (0xffff) +__ulonglong 0xfff6 >> 0x5 == -0x1 (0xffff) +int 0xfff6 + 0x4 == -0x6 (0xfffa) +__uint 0xfff6 + 0x4 == -0x6 (0xfffa) +char 0xfff6 + 0x4 == -0x6 (0xfffa) +__uchar 0xf6 + 0x4 == 0xfa (0xfa) +__longlong 0xfff6 + 0x4 == -0x6 (0xfffa) +__ulonglong 0xfff6 + 0x4 == -0x6 (0xfffa) +float 0xfff6 + 0x4 == -0x6 (0xfffa) +int 0xfff6 - 0x4 == -0xe (0xfff2) +__uint 0xfff6 - 0x4 == -0xe (0xfff2) +char 0xfff6 - 0x4 == -0xe (0xfff2) +__uchar 0xf6 - 0x4 == 0xf2 (0xf2) +__longlong 0xfff6 - 0x4 == -0xe (0xfff2) +__ulonglong 0xfff6 - 0x4 == -0xe (0xfff2) +float 0xfff6 - 0x4 == -0xe (0xfff2) +int 0xfff6 * 0x4 == -0x28 (0xffd8) +__uint 0xfff6 * 0x4 == -0x28 (0xffd8) +char 0xfff6 * 0x4 == -0x28 (0xffd8) +__uchar 0xf6 * 0x4 == 0xd8 (0xd8) +__longlong 0xfff6 * 0x4 == -0x28 (0xffd8) +__ulonglong 0xfff6 * 0x4 == -0x28 (0xffd8) +float 0xfff6 * 0x4 == -0x28 (0xffd8) +int 0xfff6 < 0x4 == 0x1 (0x1) +__uint 0xfff6 < 0x4 == 0x0 (0x0) +char 0xfff6 < 0x4 == 0x1 (0x1) +__uchar 0xf6 < 0x4 == 0x0 (0x0) +__longlong 0xfff6 < 0x4 == 0x1 (0x1) +__ulonglong 0xfff6 < 0x4 == 0x0 (0x0) +float 0xfff6 < 0x4 == 0x1 (0x1) +int 0xfff6 > 0x4 == 0x0 (0x0) +__uint 0xfff6 > 0x4 == 0x1 (0x1) +char 0xfff6 > 0x4 == 0x0 (0x0) +__uchar 0xf6 > 0x4 == 0x1 (0x1) +__longlong 0xfff6 > 0x4 == 0x0 (0x0) +__ulonglong 0xfff6 > 0x4 == 0x1 (0x1) +float 0xfff6 > 0x4 == 0x0 (0x0) +int 0xfff6 <= 0x4 == 0x1 (0x1) +__uint 0xfff6 <= 0x4 == 0x0 (0x0) +char 0xfff6 <= 0x4 == 0x1 (0x1) +__uchar 0xf6 <= 0x4 == 0x0 (0x0) +__longlong 0xfff6 <= 0x4 == 0x1 (0x1) +__ulonglong 0xfff6 <= 0x4 == 0x0 (0x0) +float 0xfff6 <= 0x4 == 0x1 (0x1) +int 0xfff6 == 0x4 == 0x0 (0x0) +__uint 0xfff6 == 0x4 == 0x0 (0x0) +char 0xfff6 == 0x4 == 0x0 (0x0) +__uchar 0xf6 == 0x4 == 0x0 (0x0) +__longlong 0xfff6 == 0x4 == 0x0 (0x0) +__ulonglong 0xfff6 == 0x4 == 0x0 (0x0) +float 0xfff6 == 0x4 == 0x0 (0x0) +int 0xfff6 != 0x4 == 0x1 (0x1) +__uint 0xfff6 != 0x4 == 0x1 (0x1) +char 0xfff6 != 0x4 == 0x1 (0x1) +__uchar 0xf6 != 0x4 == 0x1 (0x1) +__longlong 0xfff6 != 0x4 == 0x1 (0x1) +__ulonglong 0xfff6 != 0x4 == 0x1 (0x1) +float 0xfff6 != 0x4 == 0x1 (0x1) +int 0xfff6 >= 0x4 == 0x0 (0x0) +__uint 0xfff6 >= 0x4 == 0x1 (0x1) +char 0xfff6 >= 0x4 == 0x0 (0x0) +__uchar 0xf6 >= 0x4 == 0x1 (0x1) +__longlong 0xfff6 >= 0x4 == 0x0 (0x0) +__ulonglong 0xfff6 >= 0x4 == 0x1 (0x1) +float 0xfff6 >= 0x4 == 0x0 (0x0) +int 0xfff6 / 0x4 == -0x2 (0xfffe) +__uint 0xfff6 / 0x4 == 0x3ffd (0x3ffd) +char 0xfff6 / 0x4 == -0x2 (0xfffe) +__uchar 0xf6 / 0x4 == 0x3d (0x3d) +__longlong 0xfff6 / 0x4 == -0x2 (0xfffe) +__ulonglong 0xfff6 / 0x4 == -0x3 (0xfffd) +float 0xfff6 / 0x4 == -0x2 (0xfffe) +int 0xfff6 % 0x4 == -0x2 (0xfffe) +__uint 0xfff6 % 0x4 == 0x2 (0x2) +char 0xfff6 % 0x4 == -0x2 (0xfffe) +__uchar 0xf6 % 0x4 == 0x2 (0x2) +__longlong 0xfff6 % 0x4 == -0x2 (0xfffe) +__ulonglong 0xfff6 % 0x4 == 0x2 (0x2) +0xfff6 * 0xfffc == 0x28 +0xfff6 / 0xfffc == 0x2 +0xfff6 % 0xfffc == -0x2 +int 0xfff6 ^ 0xfffc == 0xa (0xa) +__uint 0xfff6 ^ 0xfffc == 0xa (0xa) +char 0xfff6 ^ 0xfffc == 0xa (0xa) +__uchar 0xf6 ^ 0xfc == 0xa (0xa) +__longlong 0xfff6 ^ 0xfffc == 0xa (0xa) +__ulonglong 0xfff6 ^ 0xfffc == 0xa (0xa) +int 0xfff6 && 0xfffc == 0x1 (0x1) +__uint 0xfff6 && 0xfffc == 0x1 (0x1) +char 0xfff6 && 0xfffc == 0x1 (0x1) +__uchar 0xf6 && 0xfc == 0x1 (0x1) +__longlong 0xfff6 && 0xfffc == 0x1 (0x1) +__ulonglong 0xfff6 && 0xfffc == 0x1 (0x1) +int 0xfff6 || 0xfffc == 0x1 (0x1) +__uint 0xfff6 || 0xfffc == 0x1 (0x1) +char 0xfff6 || 0xfffc == 0x1 (0x1) +__uchar 0xf6 || 0xfc == 0x1 (0x1) +__longlong 0xfff6 || 0xfffc == 0x1 (0x1) +__ulonglong 0xfff6 || 0xfffc == 0x1 (0x1) +int 0xfff6 & 0xfffc == -0xc (0xfff4) +__uint 0xfff6 & 0xfffc == -0xc (0xfff4) +char 0xfff6 & 0xfffc == -0xc (0xfff4) +__uchar 0xf6 & 0xfc == 0xf4 (0xf4) +__longlong 0xfff6 & 0xfffc == -0xc (0xfff4) +__ulonglong 0xfff6 & 0xfffc == -0xc (0xfff4) +int 0xfff6 | 0xfffc == -0x2 (0xfffe) +__uint 0xfff6 | 0xfffc == -0x2 (0xfffe) +char 0xfff6 | 0xfffc == -0x2 (0xfffe) +__uchar 0xf6 | 0xfc == 0xfe (0xfe) +__longlong 0xfff6 | 0xfffc == -0x2 (0xfffe) +__ulonglong 0xfff6 | 0xfffc == -0x2 (0xfffe) +int 0xfff6 << 0x6 == -0x280 (0xfd80) +__uint 0xfff6 << 0x6 == -0x280 (0xfd80) +char 0xfff6 << 0x6 == -0x80 (0xff80) +__uchar 0xf6 << 0x6 == 0x80 (0x80) +__longlong 0xfff6 << 0x6 == -0x280 (0xfd80) +__ulonglong 0xfff6 << 0x6 == -0x280 (0xfd80) +int 0xfff6 >> 0x6 == -0x1 (0xffff) +__uint 0xfff6 >> 0x6 == 0x3ff (0x3ff) +char 0xfff6 >> 0x6 == -0x1 (0xffff) +__uchar 0xf6 >> 0x6 == 0x3 (0x3) +__longlong 0xfff6 >> 0x6 == -0x1 (0xffff) +__ulonglong 0xfff6 >> 0x6 == -0x1 (0xffff) +int 0xfff6 + 0xfffc == -0xe (0xfff2) +__uint 0xfff6 + 0xfffc == -0xe (0xfff2) +char 0xfff6 + 0xfffc == -0xe (0xfff2) +__uchar 0xf6 + 0xfc == 0xf2 (0xf2) +__longlong 0xfff6 + 0xfffc == -0xe (0xfff2) +__ulonglong 0xfff6 + 0xfffc == -0xe (0xfff2) +float 0xfff6 + 0xfffc == -0xe (0xfff2) +int 0xfff6 - 0xfffc == -0x6 (0xfffa) +__uint 0xfff6 - 0xfffc == -0x6 (0xfffa) +char 0xfff6 - 0xfffc == -0x6 (0xfffa) +__uchar 0xf6 - 0xfc == 0xfa (0xfa) +__longlong 0xfff6 - 0xfffc == -0x6 (0xfffa) +__ulonglong 0xfff6 - 0xfffc == -0x6 (0xfffa) +float 0xfff6 - 0xfffc == -0x6 (0xfffa) +int 0xfff6 * 0xfffc == 0x28 (0x28) +__uint 0xfff6 * 0xfffc == 0x28 (0x28) +char 0xfff6 * 0xfffc == 0x28 (0x28) +__uchar 0xf6 * 0xfc == 0x28 (0x28) +__longlong 0xfff6 * 0xfffc == 0x28 (0x28) +__ulonglong 0xfff6 * 0xfffc == 0x28 (0x28) +float 0xfff6 * 0xfffc == 0x28 (0x28) +int 0xfff6 < 0xfffc == 0x1 (0x1) +__uint 0xfff6 < 0xfffc == 0x1 (0x1) +char 0xfff6 < 0xfffc == 0x1 (0x1) +__uchar 0xf6 < 0xfc == 0x1 (0x1) +__longlong 0xfff6 < 0xfffc == 0x1 (0x1) +__ulonglong 0xfff6 < 0xfffc == 0x1 (0x1) +float 0xfff6 < 0xfffc == 0x1 (0x1) +int 0xfff6 > 0xfffc == 0x0 (0x0) +__uint 0xfff6 > 0xfffc == 0x0 (0x0) +char 0xfff6 > 0xfffc == 0x0 (0x0) +__uchar 0xf6 > 0xfc == 0x0 (0x0) +__longlong 0xfff6 > 0xfffc == 0x0 (0x0) +__ulonglong 0xfff6 > 0xfffc == 0x0 (0x0) +float 0xfff6 > 0xfffc == 0x0 (0x0) +int 0xfff6 <= 0xfffc == 0x1 (0x1) +__uint 0xfff6 <= 0xfffc == 0x1 (0x1) +char 0xfff6 <= 0xfffc == 0x1 (0x1) +__uchar 0xf6 <= 0xfc == 0x1 (0x1) +__longlong 0xfff6 <= 0xfffc == 0x1 (0x1) +__ulonglong 0xfff6 <= 0xfffc == 0x1 (0x1) +float 0xfff6 <= 0xfffc == 0x1 (0x1) +int 0xfff6 == 0xfffc == 0x0 (0x0) +__uint 0xfff6 == 0xfffc == 0x0 (0x0) +char 0xfff6 == 0xfffc == 0x0 (0x0) +__uchar 0xf6 == 0xfc == 0x0 (0x0) +__longlong 0xfff6 == 0xfffc == 0x0 (0x0) +__ulonglong 0xfff6 == 0xfffc == 0x0 (0x0) +float 0xfff6 == 0xfffc == 0x0 (0x0) +int 0xfff6 != 0xfffc == 0x1 (0x1) +__uint 0xfff6 != 0xfffc == 0x1 (0x1) +char 0xfff6 != 0xfffc == 0x1 (0x1) +__uchar 0xf6 != 0xfc == 0x1 (0x1) +__longlong 0xfff6 != 0xfffc == 0x1 (0x1) +__ulonglong 0xfff6 != 0xfffc == 0x1 (0x1) +float 0xfff6 != 0xfffc == 0x1 (0x1) +int 0xfff6 >= 0xfffc == 0x0 (0x0) +__uint 0xfff6 >= 0xfffc == 0x0 (0x0) +char 0xfff6 >= 0xfffc == 0x0 (0x0) +__uchar 0xf6 >= 0xfc == 0x0 (0x0) +__longlong 0xfff6 >= 0xfffc == 0x0 (0x0) +__ulonglong 0xfff6 >= 0xfffc == 0x0 (0x0) +float 0xfff6 >= 0xfffc == 0x0 (0x0) +int 0xfff6 / 0xfffc == 0x2 (0x2) +__uint 0xfff6 / 0xfffc == 0x0 (0x0) +char 0xfff6 / 0xfffc == 0x2 (0x2) +__uchar 0xf6 / 0xfc == 0x0 (0x0) +__longlong 0xfff6 / 0xfffc == 0x2 (0x2) +__ulonglong 0xfff6 / 0xfffc == 0x0 (0x0) +float 0xfff6 / 0xfffc == 0x2 (0x2) +int 0xfff6 % 0xfffc == -0x2 (0xfffe) +__uint 0xfff6 % 0xfffc == -0xa (0xfff6) +char 0xfff6 % 0xfffc == -0x2 (0xfffe) +__uchar 0xf6 % 0xfc == 0xf6 (0xf6) +__longlong 0xfff6 % 0xfffc == -0x2 (0xfffe) +__ulonglong 0xfff6 % 0xfffc == -0xa (0xfff6) +0xfff6 * 0xa == -0x64 +0xfff6 / 0xa == -0x1 +0xfff6 % 0xa == 0x0 +int 0xfff6 ^ 0xa == -0x4 (0xfffc) +__uint 0xfff6 ^ 0xa == -0x4 (0xfffc) +char 0xfff6 ^ 0xa == -0x4 (0xfffc) +__uchar 0xf6 ^ 0xa == 0xfc (0xfc) +__longlong 0xfff6 ^ 0xa == -0x4 (0xfffc) +__ulonglong 0xfff6 ^ 0xa == -0x4 (0xfffc) +int 0xfff6 && 0xa == 0x1 (0x1) +__uint 0xfff6 && 0xa == 0x1 (0x1) +char 0xfff6 && 0xa == 0x1 (0x1) +__uchar 0xf6 && 0xa == 0x1 (0x1) +__longlong 0xfff6 && 0xa == 0x1 (0x1) +__ulonglong 0xfff6 && 0xa == 0x1 (0x1) +int 0xfff6 || 0xa == 0x1 (0x1) +__uint 0xfff6 || 0xa == 0x1 (0x1) +char 0xfff6 || 0xa == 0x1 (0x1) +__uchar 0xf6 || 0xa == 0x1 (0x1) +__longlong 0xfff6 || 0xa == 0x1 (0x1) +__ulonglong 0xfff6 || 0xa == 0x1 (0x1) +int 0xfff6 & 0xa == 0x2 (0x2) +__uint 0xfff6 & 0xa == 0x2 (0x2) +char 0xfff6 & 0xa == 0x2 (0x2) +__uchar 0xf6 & 0xa == 0x2 (0x2) +__longlong 0xfff6 & 0xa == 0x2 (0x2) +__ulonglong 0xfff6 & 0xa == 0x2 (0x2) +int 0xfff6 | 0xa == -0x2 (0xfffe) +__uint 0xfff6 | 0xa == -0x2 (0xfffe) +char 0xfff6 | 0xa == -0x2 (0xfffe) +__uchar 0xf6 | 0xa == 0xfe (0xfe) +__longlong 0xfff6 | 0xa == -0x2 (0xfffe) +__ulonglong 0xfff6 | 0xa == -0x2 (0xfffe) +int 0xfff6 << 0x7 == -0x500 (0xfb00) +__uint 0xfff6 << 0x7 == -0x500 (0xfb00) +char 0xfff6 << 0x7 == 0x0 (0x0) +__uchar 0xf6 << 0x7 == 0x0 (0x0) +__longlong 0xfff6 << 0x7 == -0x500 (0xfb00) +__ulonglong 0xfff6 << 0x7 == -0x500 (0xfb00) +int 0xfff6 >> 0x7 == -0x1 (0xffff) +__uint 0xfff6 >> 0x7 == 0x1ff (0x1ff) +char 0xfff6 >> 0x7 == -0x1 (0xffff) +__uchar 0xf6 >> 0x7 == 0x1 (0x1) +__longlong 0xfff6 >> 0x7 == -0x1 (0xffff) +__ulonglong 0xfff6 >> 0x7 == -0x1 (0xffff) +int 0xfff6 + 0xa == 0x0 (0x0) +__uint 0xfff6 + 0xa == 0x0 (0x0) +char 0xfff6 + 0xa == 0x0 (0x0) +__uchar 0xf6 + 0xa == 0x0 (0x0) +__longlong 0xfff6 + 0xa == 0x0 (0x0) +__ulonglong 0xfff6 + 0xa == 0x0 (0x0) +float 0xfff6 + 0xa == 0x0 (0x0) +int 0xfff6 - 0xa == -0x14 (0xffec) +__uint 0xfff6 - 0xa == -0x14 (0xffec) +char 0xfff6 - 0xa == -0x14 (0xffec) +__uchar 0xf6 - 0xa == 0xec (0xec) +__longlong 0xfff6 - 0xa == -0x14 (0xffec) +__ulonglong 0xfff6 - 0xa == -0x14 (0xffec) +float 0xfff6 - 0xa == -0x14 (0xffec) +int 0xfff6 * 0xa == -0x64 (0xff9c) +__uint 0xfff6 * 0xa == -0x64 (0xff9c) +char 0xfff6 * 0xa == -0x64 (0xff9c) +__uchar 0xf6 * 0xa == 0x9c (0x9c) +__longlong 0xfff6 * 0xa == -0x64 (0xff9c) +__ulonglong 0xfff6 * 0xa == -0x64 (0xff9c) +float 0xfff6 * 0xa == -0x64 (0xff9c) +int 0xfff6 < 0xa == 0x1 (0x1) +__uint 0xfff6 < 0xa == 0x0 (0x0) +char 0xfff6 < 0xa == 0x1 (0x1) +__uchar 0xf6 < 0xa == 0x0 (0x0) +__longlong 0xfff6 < 0xa == 0x1 (0x1) +__ulonglong 0xfff6 < 0xa == 0x0 (0x0) +float 0xfff6 < 0xa == 0x1 (0x1) +int 0xfff6 > 0xa == 0x0 (0x0) +__uint 0xfff6 > 0xa == 0x1 (0x1) +char 0xfff6 > 0xa == 0x0 (0x0) +__uchar 0xf6 > 0xa == 0x1 (0x1) +__longlong 0xfff6 > 0xa == 0x0 (0x0) +__ulonglong 0xfff6 > 0xa == 0x1 (0x1) +float 0xfff6 > 0xa == 0x0 (0x0) +int 0xfff6 <= 0xa == 0x1 (0x1) +__uint 0xfff6 <= 0xa == 0x0 (0x0) +char 0xfff6 <= 0xa == 0x1 (0x1) +__uchar 0xf6 <= 0xa == 0x0 (0x0) +__longlong 0xfff6 <= 0xa == 0x1 (0x1) +__ulonglong 0xfff6 <= 0xa == 0x0 (0x0) +float 0xfff6 <= 0xa == 0x1 (0x1) +int 0xfff6 == 0xa == 0x0 (0x0) +__uint 0xfff6 == 0xa == 0x0 (0x0) +char 0xfff6 == 0xa == 0x0 (0x0) +__uchar 0xf6 == 0xa == 0x0 (0x0) +__longlong 0xfff6 == 0xa == 0x0 (0x0) +__ulonglong 0xfff6 == 0xa == 0x0 (0x0) +float 0xfff6 == 0xa == 0x0 (0x0) +int 0xfff6 != 0xa == 0x1 (0x1) +__uint 0xfff6 != 0xa == 0x1 (0x1) +char 0xfff6 != 0xa == 0x1 (0x1) +__uchar 0xf6 != 0xa == 0x1 (0x1) +__longlong 0xfff6 != 0xa == 0x1 (0x1) +__ulonglong 0xfff6 != 0xa == 0x1 (0x1) +float 0xfff6 != 0xa == 0x1 (0x1) +int 0xfff6 >= 0xa == 0x0 (0x0) +__uint 0xfff6 >= 0xa == 0x1 (0x1) +char 0xfff6 >= 0xa == 0x0 (0x0) +__uchar 0xf6 >= 0xa == 0x1 (0x1) +__longlong 0xfff6 >= 0xa == 0x0 (0x0) +__ulonglong 0xfff6 >= 0xa == 0x1 (0x1) +float 0xfff6 >= 0xa == 0x0 (0x0) +int 0xfff6 / 0xa == -0x1 (0xffff) +__uint 0xfff6 / 0xa == 0x1998 (0x1998) +char 0xfff6 / 0xa == -0x1 (0xffff) +__uchar 0xf6 / 0xa == 0x18 (0x18) +__longlong 0xfff6 / 0xa == -0x1 (0xffff) +__ulonglong 0xfff6 / 0xa == -0x6668 (0x9998) +float 0xfff6 / 0xa == -0x1 (0xffff) +int 0xfff6 % 0xa == 0x0 (0x0) +__uint 0xfff6 % 0xa == 0x6 (0x6) +char 0xfff6 % 0xa == 0x0 (0x0) +__uchar 0xf6 % 0xa == 0x6 (0x6) +__longlong 0xfff6 % 0xa == 0x0 (0x0) +__ulonglong 0xfff6 % 0xa == 0x6 (0x6) +0xfff6 * 0xfff6 == 0x64 +0xfff6 / 0xfff6 == 0x1 +0xfff6 % 0xfff6 == 0x0 +int 0xfff6 ^ 0xfff6 == 0x0 (0x0) +__uint 0xfff6 ^ 0xfff6 == 0x0 (0x0) +char 0xfff6 ^ 0xfff6 == 0x0 (0x0) +__uchar 0xf6 ^ 0xf6 == 0x0 (0x0) +__longlong 0xfff6 ^ 0xfff6 == 0x0 (0x0) +__ulonglong 0xfff6 ^ 0xfff6 == 0x0 (0x0) +int 0xfff6 && 0xfff6 == 0x1 (0x1) +__uint 0xfff6 && 0xfff6 == 0x1 (0x1) +char 0xfff6 && 0xfff6 == 0x1 (0x1) +__uchar 0xf6 && 0xf6 == 0x1 (0x1) +__longlong 0xfff6 && 0xfff6 == 0x1 (0x1) +__ulonglong 0xfff6 && 0xfff6 == 0x1 (0x1) +int 0xfff6 || 0xfff6 == 0x1 (0x1) +__uint 0xfff6 || 0xfff6 == 0x1 (0x1) +char 0xfff6 || 0xfff6 == 0x1 (0x1) +__uchar 0xf6 || 0xf6 == 0x1 (0x1) +__longlong 0xfff6 || 0xfff6 == 0x1 (0x1) +__ulonglong 0xfff6 || 0xfff6 == 0x1 (0x1) +int 0xfff6 & 0xfff6 == -0xa (0xfff6) +__uint 0xfff6 & 0xfff6 == -0xa (0xfff6) +char 0xfff6 & 0xfff6 == -0xa (0xfff6) +__uchar 0xf6 & 0xf6 == 0xf6 (0xf6) +__longlong 0xfff6 & 0xfff6 == -0xa (0xfff6) +__ulonglong 0xfff6 & 0xfff6 == -0xa (0xfff6) +int 0xfff6 | 0xfff6 == -0xa (0xfff6) +__uint 0xfff6 | 0xfff6 == -0xa (0xfff6) +char 0xfff6 | 0xfff6 == -0xa (0xfff6) +__uchar 0xf6 | 0xf6 == 0xf6 (0xf6) +__longlong 0xfff6 | 0xfff6 == -0xa (0xfff6) +__ulonglong 0xfff6 | 0xfff6 == -0xa (0xfff6) +int 0xfff6 << 0x8 == -0xa00 (0xf600) +__uint 0xfff6 << 0x8 == -0xa00 (0xf600) +char 0xfff6 << 0x8 == 0x0 (0x0) +__uchar 0xf6 << 0x8 == 0x0 (0x0) +__longlong 0xfff6 << 0x8 == -0xa00 (0xf600) +__ulonglong 0xfff6 << 0x8 == -0xa00 (0xf600) +int 0xfff6 >> 0x8 == -0x1 (0xffff) +__uint 0xfff6 >> 0x8 == 0xff (0xff) +char 0xfff6 >> 0x8 == -0x1 (0xffff) +__uchar 0xf6 >> 0x8 == 0x0 (0x0) +__longlong 0xfff6 >> 0x8 == -0x1 (0xffff) +__ulonglong 0xfff6 >> 0x8 == -0x1 (0xffff) +int 0xfff6 + 0xfff6 == -0x14 (0xffec) +__uint 0xfff6 + 0xfff6 == -0x14 (0xffec) +char 0xfff6 + 0xfff6 == -0x14 (0xffec) +__uchar 0xf6 + 0xf6 == 0xec (0xec) +__longlong 0xfff6 + 0xfff6 == -0x14 (0xffec) +__ulonglong 0xfff6 + 0xfff6 == -0x14 (0xffec) +float 0xfff6 + 0xfff6 == -0x14 (0xffec) +int 0xfff6 - 0xfff6 == 0x0 (0x0) +__uint 0xfff6 - 0xfff6 == 0x0 (0x0) +char 0xfff6 - 0xfff6 == 0x0 (0x0) +__uchar 0xf6 - 0xf6 == 0x0 (0x0) +__longlong 0xfff6 - 0xfff6 == 0x0 (0x0) +__ulonglong 0xfff6 - 0xfff6 == 0x0 (0x0) +float 0xfff6 - 0xfff6 == 0x0 (0x0) +int 0xfff6 * 0xfff6 == 0x64 (0x64) +__uint 0xfff6 * 0xfff6 == 0x64 (0x64) +char 0xfff6 * 0xfff6 == 0x64 (0x64) +__uchar 0xf6 * 0xf6 == 0x64 (0x64) +__longlong 0xfff6 * 0xfff6 == 0x64 (0x64) +__ulonglong 0xfff6 * 0xfff6 == 0x64 (0x64) +float 0xfff6 * 0xfff6 == 0x64 (0x64) +int 0xfff6 < 0xfff6 == 0x0 (0x0) +__uint 0xfff6 < 0xfff6 == 0x0 (0x0) +char 0xfff6 < 0xfff6 == 0x0 (0x0) +__uchar 0xf6 < 0xf6 == 0x0 (0x0) +__longlong 0xfff6 < 0xfff6 == 0x0 (0x0) +__ulonglong 0xfff6 < 0xfff6 == 0x0 (0x0) +float 0xfff6 < 0xfff6 == 0x0 (0x0) +int 0xfff6 > 0xfff6 == 0x0 (0x0) +__uint 0xfff6 > 0xfff6 == 0x0 (0x0) +char 0xfff6 > 0xfff6 == 0x0 (0x0) +__uchar 0xf6 > 0xf6 == 0x0 (0x0) +__longlong 0xfff6 > 0xfff6 == 0x0 (0x0) +__ulonglong 0xfff6 > 0xfff6 == 0x0 (0x0) +float 0xfff6 > 0xfff6 == 0x0 (0x0) +int 0xfff6 <= 0xfff6 == 0x1 (0x1) +__uint 0xfff6 <= 0xfff6 == 0x1 (0x1) +char 0xfff6 <= 0xfff6 == 0x1 (0x1) +__uchar 0xf6 <= 0xf6 == 0x1 (0x1) +__longlong 0xfff6 <= 0xfff6 == 0x1 (0x1) +__ulonglong 0xfff6 <= 0xfff6 == 0x1 (0x1) +float 0xfff6 <= 0xfff6 == 0x1 (0x1) +int 0xfff6 == 0xfff6 == 0x1 (0x1) +__uint 0xfff6 == 0xfff6 == 0x1 (0x1) +char 0xfff6 == 0xfff6 == 0x1 (0x1) +__uchar 0xf6 == 0xf6 == 0x1 (0x1) +__longlong 0xfff6 == 0xfff6 == 0x1 (0x1) +__ulonglong 0xfff6 == 0xfff6 == 0x1 (0x1) +float 0xfff6 == 0xfff6 == 0x1 (0x1) +int 0xfff6 != 0xfff6 == 0x0 (0x0) +__uint 0xfff6 != 0xfff6 == 0x0 (0x0) +char 0xfff6 != 0xfff6 == 0x0 (0x0) +__uchar 0xf6 != 0xf6 == 0x0 (0x0) +__longlong 0xfff6 != 0xfff6 == 0x0 (0x0) +__ulonglong 0xfff6 != 0xfff6 == 0x0 (0x0) +float 0xfff6 != 0xfff6 == 0x0 (0x0) +int 0xfff6 >= 0xfff6 == 0x1 (0x1) +__uint 0xfff6 >= 0xfff6 == 0x1 (0x1) +char 0xfff6 >= 0xfff6 == 0x1 (0x1) +__uchar 0xf6 >= 0xf6 == 0x1 (0x1) +__longlong 0xfff6 >= 0xfff6 == 0x1 (0x1) +__ulonglong 0xfff6 >= 0xfff6 == 0x1 (0x1) +float 0xfff6 >= 0xfff6 == 0x1 (0x1) +int 0xfff6 / 0xfff6 == 0x1 (0x1) +__uint 0xfff6 / 0xfff6 == 0x1 (0x1) +char 0xfff6 / 0xfff6 == 0x1 (0x1) +__uchar 0xf6 / 0xf6 == 0x1 (0x1) +__longlong 0xfff6 / 0xfff6 == 0x1 (0x1) +__ulonglong 0xfff6 / 0xfff6 == 0x1 (0x1) +float 0xfff6 / 0xfff6 == 0x1 (0x1) +int 0xfff6 % 0xfff6 == 0x0 (0x0) +__uint 0xfff6 % 0xfff6 == 0x0 (0x0) +char 0xfff6 % 0xfff6 == 0x0 (0x0) +__uchar 0xf6 % 0xf6 == 0x0 (0x0) +__longlong 0xfff6 % 0xfff6 == 0x0 (0x0) +__ulonglong 0xfff6 % 0xfff6 == 0x0 (0x0) +0xfff6 * 0x5 == -0x32 +0xfff6 / 0x5 == -0x2 +0xfff6 % 0x5 == 0x0 +int 0xfff6 ^ 0x5 == -0xd (0xfff3) +__uint 0xfff6 ^ 0x5 == -0xd (0xfff3) +char 0xfff6 ^ 0x5 == -0xd (0xfff3) +__uchar 0xf6 ^ 0x5 == 0xf3 (0xf3) +__longlong 0xfff6 ^ 0x5 == -0xd (0xfff3) +__ulonglong 0xfff6 ^ 0x5 == -0xd (0xfff3) +int 0xfff6 && 0x5 == 0x1 (0x1) +__uint 0xfff6 && 0x5 == 0x1 (0x1) +char 0xfff6 && 0x5 == 0x1 (0x1) +__uchar 0xf6 && 0x5 == 0x1 (0x1) +__longlong 0xfff6 && 0x5 == 0x1 (0x1) +__ulonglong 0xfff6 && 0x5 == 0x1 (0x1) +int 0xfff6 || 0x5 == 0x1 (0x1) +__uint 0xfff6 || 0x5 == 0x1 (0x1) +char 0xfff6 || 0x5 == 0x1 (0x1) +__uchar 0xf6 || 0x5 == 0x1 (0x1) +__longlong 0xfff6 || 0x5 == 0x1 (0x1) +__ulonglong 0xfff6 || 0x5 == 0x1 (0x1) +int 0xfff6 & 0x5 == 0x4 (0x4) +__uint 0xfff6 & 0x5 == 0x4 (0x4) +char 0xfff6 & 0x5 == 0x4 (0x4) +__uchar 0xf6 & 0x5 == 0x4 (0x4) +__longlong 0xfff6 & 0x5 == 0x4 (0x4) +__ulonglong 0xfff6 & 0x5 == 0x4 (0x4) +int 0xfff6 | 0x5 == -0x9 (0xfff7) +__uint 0xfff6 | 0x5 == -0x9 (0xfff7) +char 0xfff6 | 0x5 == -0x9 (0xfff7) +__uchar 0xf6 | 0x5 == 0xf7 (0xf7) +__longlong 0xfff6 | 0x5 == -0x9 (0xfff7) +__ulonglong 0xfff6 | 0x5 == -0x9 (0xfff7) +int 0xfff6 << 0x9 == -0x1400 (0xec00) +__uint 0xfff6 << 0x9 == -0x1400 (0xec00) +char 0xfff6 << 0x9 == 0x0 (0x0) +__uchar 0xf6 << 0x9 == 0x0 (0x0) +__longlong 0xfff6 << 0x9 == -0x1400 (0xec00) +__ulonglong 0xfff6 << 0x9 == -0x1400 (0xec00) +int 0xfff6 >> 0x9 == -0x1 (0xffff) +__uint 0xfff6 >> 0x9 == 0x7f (0x7f) +char 0xfff6 >> 0x9 == -0x1 (0xffff) +__uchar 0xf6 >> 0x9 == 0x0 (0x0) +__longlong 0xfff6 >> 0x9 == -0x1 (0xffff) +__ulonglong 0xfff6 >> 0x9 == -0x1 (0xffff) +int 0xfff6 + 0x5 == -0x5 (0xfffb) +__uint 0xfff6 + 0x5 == -0x5 (0xfffb) +char 0xfff6 + 0x5 == -0x5 (0xfffb) +__uchar 0xf6 + 0x5 == 0xfb (0xfb) +__longlong 0xfff6 + 0x5 == -0x5 (0xfffb) +__ulonglong 0xfff6 + 0x5 == -0x5 (0xfffb) +float 0xfff6 + 0x5 == -0x5 (0xfffb) +int 0xfff6 - 0x5 == -0xf (0xfff1) +__uint 0xfff6 - 0x5 == -0xf (0xfff1) +char 0xfff6 - 0x5 == -0xf (0xfff1) +__uchar 0xf6 - 0x5 == 0xf1 (0xf1) +__longlong 0xfff6 - 0x5 == -0xf (0xfff1) +__ulonglong 0xfff6 - 0x5 == -0xf (0xfff1) +float 0xfff6 - 0x5 == -0xf (0xfff1) +int 0xfff6 * 0x5 == -0x32 (0xffce) +__uint 0xfff6 * 0x5 == -0x32 (0xffce) +char 0xfff6 * 0x5 == -0x32 (0xffce) +__uchar 0xf6 * 0x5 == 0xce (0xce) +__longlong 0xfff6 * 0x5 == -0x32 (0xffce) +__ulonglong 0xfff6 * 0x5 == -0x32 (0xffce) +float 0xfff6 * 0x5 == -0x32 (0xffce) +int 0xfff6 < 0x5 == 0x1 (0x1) +__uint 0xfff6 < 0x5 == 0x0 (0x0) +char 0xfff6 < 0x5 == 0x1 (0x1) +__uchar 0xf6 < 0x5 == 0x0 (0x0) +__longlong 0xfff6 < 0x5 == 0x1 (0x1) +__ulonglong 0xfff6 < 0x5 == 0x0 (0x0) +float 0xfff6 < 0x5 == 0x1 (0x1) +int 0xfff6 > 0x5 == 0x0 (0x0) +__uint 0xfff6 > 0x5 == 0x1 (0x1) +char 0xfff6 > 0x5 == 0x0 (0x0) +__uchar 0xf6 > 0x5 == 0x1 (0x1) +__longlong 0xfff6 > 0x5 == 0x0 (0x0) +__ulonglong 0xfff6 > 0x5 == 0x1 (0x1) +float 0xfff6 > 0x5 == 0x0 (0x0) +int 0xfff6 <= 0x5 == 0x1 (0x1) +__uint 0xfff6 <= 0x5 == 0x0 (0x0) +char 0xfff6 <= 0x5 == 0x1 (0x1) +__uchar 0xf6 <= 0x5 == 0x0 (0x0) +__longlong 0xfff6 <= 0x5 == 0x1 (0x1) +__ulonglong 0xfff6 <= 0x5 == 0x0 (0x0) +float 0xfff6 <= 0x5 == 0x1 (0x1) +int 0xfff6 == 0x5 == 0x0 (0x0) +__uint 0xfff6 == 0x5 == 0x0 (0x0) +char 0xfff6 == 0x5 == 0x0 (0x0) +__uchar 0xf6 == 0x5 == 0x0 (0x0) +__longlong 0xfff6 == 0x5 == 0x0 (0x0) +__ulonglong 0xfff6 == 0x5 == 0x0 (0x0) +float 0xfff6 == 0x5 == 0x0 (0x0) +int 0xfff6 != 0x5 == 0x1 (0x1) +__uint 0xfff6 != 0x5 == 0x1 (0x1) +char 0xfff6 != 0x5 == 0x1 (0x1) +__uchar 0xf6 != 0x5 == 0x1 (0x1) +__longlong 0xfff6 != 0x5 == 0x1 (0x1) +__ulonglong 0xfff6 != 0x5 == 0x1 (0x1) +float 0xfff6 != 0x5 == 0x1 (0x1) +int 0xfff6 >= 0x5 == 0x0 (0x0) +__uint 0xfff6 >= 0x5 == 0x1 (0x1) +char 0xfff6 >= 0x5 == 0x0 (0x0) +__uchar 0xf6 >= 0x5 == 0x1 (0x1) +__longlong 0xfff6 >= 0x5 == 0x0 (0x0) +__ulonglong 0xfff6 >= 0x5 == 0x1 (0x1) +float 0xfff6 >= 0x5 == 0x0 (0x0) +int 0xfff6 / 0x5 == -0x2 (0xfffe) +__uint 0xfff6 / 0x5 == 0x3331 (0x3331) +char 0xfff6 / 0x5 == -0x2 (0xfffe) +__uchar 0xf6 / 0x5 == 0x31 (0x31) +__longlong 0xfff6 / 0x5 == -0x2 (0xfffe) +__ulonglong 0xfff6 / 0x5 == 0x3331 (0x3331) +float 0xfff6 / 0x5 == -0x2 (0xfffe) +int 0xfff6 % 0x5 == 0x0 (0x0) +__uint 0xfff6 % 0x5 == 0x1 (0x1) +char 0xfff6 % 0x5 == 0x0 (0x0) +__uchar 0xf6 % 0x5 == 0x1 (0x1) +__longlong 0xfff6 % 0x5 == 0x0 (0x0) +__ulonglong 0xfff6 % 0x5 == 0x1 (0x1) +0xfff6 * 0x7 == -0x46 +0xfff6 / 0x7 == -0x1 +0xfff6 % 0x7 == -0x3 +int 0xfff6 ^ 0x7 == -0xf (0xfff1) +__uint 0xfff6 ^ 0x7 == -0xf (0xfff1) +char 0xfff6 ^ 0x7 == -0xf (0xfff1) +__uchar 0xf6 ^ 0x7 == 0xf1 (0xf1) +__longlong 0xfff6 ^ 0x7 == -0xf (0xfff1) +__ulonglong 0xfff6 ^ 0x7 == -0xf (0xfff1) +int 0xfff6 && 0x7 == 0x1 (0x1) +__uint 0xfff6 && 0x7 == 0x1 (0x1) +char 0xfff6 && 0x7 == 0x1 (0x1) +__uchar 0xf6 && 0x7 == 0x1 (0x1) +__longlong 0xfff6 && 0x7 == 0x1 (0x1) +__ulonglong 0xfff6 && 0x7 == 0x1 (0x1) +int 0xfff6 || 0x7 == 0x1 (0x1) +__uint 0xfff6 || 0x7 == 0x1 (0x1) +char 0xfff6 || 0x7 == 0x1 (0x1) +__uchar 0xf6 || 0x7 == 0x1 (0x1) +__longlong 0xfff6 || 0x7 == 0x1 (0x1) +__ulonglong 0xfff6 || 0x7 == 0x1 (0x1) +int 0xfff6 & 0x7 == 0x6 (0x6) +__uint 0xfff6 & 0x7 == 0x6 (0x6) +char 0xfff6 & 0x7 == 0x6 (0x6) +__uchar 0xf6 & 0x7 == 0x6 (0x6) +__longlong 0xfff6 & 0x7 == 0x6 (0x6) +__ulonglong 0xfff6 & 0x7 == 0x6 (0x6) +int 0xfff6 | 0x7 == -0x9 (0xfff7) +__uint 0xfff6 | 0x7 == -0x9 (0xfff7) +char 0xfff6 | 0x7 == -0x9 (0xfff7) +__uchar 0xf6 | 0x7 == 0xf7 (0xf7) +__longlong 0xfff6 | 0x7 == -0x9 (0xfff7) +__ulonglong 0xfff6 | 0x7 == -0x9 (0xfff7) +int 0xfff6 << 0xa == -0x2800 (0xd800) +__uint 0xfff6 << 0xa == -0x2800 (0xd800) +char 0xfff6 << 0xa == 0x0 (0x0) +__uchar 0xf6 << 0xa == 0x0 (0x0) +__longlong 0xfff6 << 0xa == -0x2800 (0xd800) +__ulonglong 0xfff6 << 0xa == -0x2800 (0xd800) +int 0xfff6 >> 0xa == -0x1 (0xffff) +__uint 0xfff6 >> 0xa == 0x3f (0x3f) +char 0xfff6 >> 0xa == -0x1 (0xffff) +__uchar 0xf6 >> 0xa == 0x0 (0x0) +__longlong 0xfff6 >> 0xa == -0x1 (0xffff) +__ulonglong 0xfff6 >> 0xa == -0x1 (0xffff) +int 0xfff6 + 0x7 == -0x3 (0xfffd) +__uint 0xfff6 + 0x7 == -0x3 (0xfffd) +char 0xfff6 + 0x7 == -0x3 (0xfffd) +__uchar 0xf6 + 0x7 == 0xfd (0xfd) +__longlong 0xfff6 + 0x7 == -0x3 (0xfffd) +__ulonglong 0xfff6 + 0x7 == -0x3 (0xfffd) +float 0xfff6 + 0x7 == -0x3 (0xfffd) +int 0xfff6 - 0x7 == -0x11 (0xffef) +__uint 0xfff6 - 0x7 == -0x11 (0xffef) +char 0xfff6 - 0x7 == -0x11 (0xffef) +__uchar 0xf6 - 0x7 == 0xef (0xef) +__longlong 0xfff6 - 0x7 == -0x11 (0xffef) +__ulonglong 0xfff6 - 0x7 == -0x11 (0xffef) +float 0xfff6 - 0x7 == -0x11 (0xffef) +int 0xfff6 * 0x7 == -0x46 (0xffba) +__uint 0xfff6 * 0x7 == -0x46 (0xffba) +char 0xfff6 * 0x7 == -0x46 (0xffba) +__uchar 0xf6 * 0x7 == 0xba (0xba) +__longlong 0xfff6 * 0x7 == -0x46 (0xffba) +__ulonglong 0xfff6 * 0x7 == -0x46 (0xffba) +float 0xfff6 * 0x7 == -0x46 (0xffba) +int 0xfff6 < 0x7 == 0x1 (0x1) +__uint 0xfff6 < 0x7 == 0x0 (0x0) +char 0xfff6 < 0x7 == 0x1 (0x1) +__uchar 0xf6 < 0x7 == 0x0 (0x0) +__longlong 0xfff6 < 0x7 == 0x1 (0x1) +__ulonglong 0xfff6 < 0x7 == 0x0 (0x0) +float 0xfff6 < 0x7 == 0x1 (0x1) +int 0xfff6 > 0x7 == 0x0 (0x0) +__uint 0xfff6 > 0x7 == 0x1 (0x1) +char 0xfff6 > 0x7 == 0x0 (0x0) +__uchar 0xf6 > 0x7 == 0x1 (0x1) +__longlong 0xfff6 > 0x7 == 0x0 (0x0) +__ulonglong 0xfff6 > 0x7 == 0x1 (0x1) +float 0xfff6 > 0x7 == 0x0 (0x0) +int 0xfff6 <= 0x7 == 0x1 (0x1) +__uint 0xfff6 <= 0x7 == 0x0 (0x0) +char 0xfff6 <= 0x7 == 0x1 (0x1) +__uchar 0xf6 <= 0x7 == 0x0 (0x0) +__longlong 0xfff6 <= 0x7 == 0x1 (0x1) +__ulonglong 0xfff6 <= 0x7 == 0x0 (0x0) +float 0xfff6 <= 0x7 == 0x1 (0x1) +int 0xfff6 == 0x7 == 0x0 (0x0) +__uint 0xfff6 == 0x7 == 0x0 (0x0) +char 0xfff6 == 0x7 == 0x0 (0x0) +__uchar 0xf6 == 0x7 == 0x0 (0x0) +__longlong 0xfff6 == 0x7 == 0x0 (0x0) +__ulonglong 0xfff6 == 0x7 == 0x0 (0x0) +float 0xfff6 == 0x7 == 0x0 (0x0) +int 0xfff6 != 0x7 == 0x1 (0x1) +__uint 0xfff6 != 0x7 == 0x1 (0x1) +char 0xfff6 != 0x7 == 0x1 (0x1) +__uchar 0xf6 != 0x7 == 0x1 (0x1) +__longlong 0xfff6 != 0x7 == 0x1 (0x1) +__ulonglong 0xfff6 != 0x7 == 0x1 (0x1) +float 0xfff6 != 0x7 == 0x1 (0x1) +int 0xfff6 >= 0x7 == 0x0 (0x0) +__uint 0xfff6 >= 0x7 == 0x1 (0x1) +char 0xfff6 >= 0x7 == 0x0 (0x0) +__uchar 0xf6 >= 0x7 == 0x1 (0x1) +__longlong 0xfff6 >= 0x7 == 0x0 (0x0) +__ulonglong 0xfff6 >= 0x7 == 0x1 (0x1) +float 0xfff6 >= 0x7 == 0x0 (0x0) +int 0xfff6 / 0x7 == -0x1 (0xffff) +__uint 0xfff6 / 0x7 == 0x2490 (0x2490) +char 0xfff6 / 0x7 == -0x1 (0xffff) +__uchar 0xf6 / 0x7 == 0x23 (0x23) +__longlong 0xfff6 / 0x7 == -0x1 (0xffff) +__ulonglong 0xfff6 / 0x7 == 0x4923 (0x4923) +float 0xfff6 / 0x7 == -0x1 (0xffff) +int 0xfff6 % 0x7 == -0x3 (0xfffd) +__uint 0xfff6 % 0x7 == 0x6 (0x6) +char 0xfff6 % 0x7 == -0x3 (0xfffd) +__uchar 0xf6 % 0x7 == 0x1 (0x1) +__longlong 0xfff6 % 0x7 == -0x3 (0xfffd) +__ulonglong 0xfff6 % 0x7 == 0x1 (0x1) +0xfff6 * 0x2a == -0x1a4 +0xfff6 / 0x2a == 0x0 +0xfff6 % 0x2a == -0xa +int 0xfff6 ^ 0x2a == -0x24 (0xffdc) +__uint 0xfff6 ^ 0x2a == -0x24 (0xffdc) +char 0xfff6 ^ 0x2a == -0x24 (0xffdc) +__uchar 0xf6 ^ 0x2a == 0xdc (0xdc) +__longlong 0xfff6 ^ 0x2a == -0x24 (0xffdc) +__ulonglong 0xfff6 ^ 0x2a == -0x24 (0xffdc) +int 0xfff6 && 0x2a == 0x1 (0x1) +__uint 0xfff6 && 0x2a == 0x1 (0x1) +char 0xfff6 && 0x2a == 0x1 (0x1) +__uchar 0xf6 && 0x2a == 0x1 (0x1) +__longlong 0xfff6 && 0x2a == 0x1 (0x1) +__ulonglong 0xfff6 && 0x2a == 0x1 (0x1) +int 0xfff6 || 0x2a == 0x1 (0x1) +__uint 0xfff6 || 0x2a == 0x1 (0x1) +char 0xfff6 || 0x2a == 0x1 (0x1) +__uchar 0xf6 || 0x2a == 0x1 (0x1) +__longlong 0xfff6 || 0x2a == 0x1 (0x1) +__ulonglong 0xfff6 || 0x2a == 0x1 (0x1) +int 0xfff6 & 0x2a == 0x22 (0x22) +__uint 0xfff6 & 0x2a == 0x22 (0x22) +char 0xfff6 & 0x2a == 0x22 (0x22) +__uchar 0xf6 & 0x2a == 0x22 (0x22) +__longlong 0xfff6 & 0x2a == 0x22 (0x22) +__ulonglong 0xfff6 & 0x2a == 0x22 (0x22) +int 0xfff6 | 0x2a == -0x2 (0xfffe) +__uint 0xfff6 | 0x2a == -0x2 (0xfffe) +char 0xfff6 | 0x2a == -0x2 (0xfffe) +__uchar 0xf6 | 0x2a == 0xfe (0xfe) +__longlong 0xfff6 | 0x2a == -0x2 (0xfffe) +__ulonglong 0xfff6 | 0x2a == -0x2 (0xfffe) +int 0xfff6 << 0xc == 0x6000 (0x6000) +__uint 0xfff6 << 0xc == 0x6000 (0x6000) +char 0xfff6 << 0xc == 0x0 (0x0) +__uchar 0xf6 << 0xc == 0x0 (0x0) +__longlong 0xfff6 << 0xc == 0x6000 (0x6000) +__ulonglong 0xfff6 << 0xc == 0x6000 (0x6000) +int 0xfff6 >> 0xc == -0x1 (0xffff) +__uint 0xfff6 >> 0xc == 0xf (0xf) +char 0xfff6 >> 0xc == -0x1 (0xffff) +__uchar 0xf6 >> 0xc == 0x0 (0x0) +__longlong 0xfff6 >> 0xc == -0x1 (0xffff) +__ulonglong 0xfff6 >> 0xc == -0x1 (0xffff) +int 0xfff6 + 0x2a == 0x20 (0x20) +__uint 0xfff6 + 0x2a == 0x20 (0x20) +char 0xfff6 + 0x2a == 0x20 (0x20) +__uchar 0xf6 + 0x2a == 0x20 (0x20) +__longlong 0xfff6 + 0x2a == 0x20 (0x20) +__ulonglong 0xfff6 + 0x2a == 0x20 (0x20) +float 0xfff6 + 0x2a == 0x20 (0x20) +int 0xfff6 - 0x2a == -0x34 (0xffcc) +__uint 0xfff6 - 0x2a == -0x34 (0xffcc) +char 0xfff6 - 0x2a == -0x34 (0xffcc) +__uchar 0xf6 - 0x2a == 0xcc (0xcc) +__longlong 0xfff6 - 0x2a == -0x34 (0xffcc) +__ulonglong 0xfff6 - 0x2a == -0x34 (0xffcc) +float 0xfff6 - 0x2a == -0x34 (0xffcc) +int 0xfff6 * 0x2a == -0x1a4 (0xfe5c) +__uint 0xfff6 * 0x2a == -0x1a4 (0xfe5c) +char 0xfff6 * 0x2a == 0x5c (0x5c) +__uchar 0xf6 * 0x2a == 0x5c (0x5c) +__longlong 0xfff6 * 0x2a == -0x1a4 (0xfe5c) +__ulonglong 0xfff6 * 0x2a == -0x1a4 (0xfe5c) +float 0xfff6 * 0x2a == -0x1a4 (0xfe5c) +int 0xfff6 < 0x2a == 0x1 (0x1) +__uint 0xfff6 < 0x2a == 0x0 (0x0) +char 0xfff6 < 0x2a == 0x1 (0x1) +__uchar 0xf6 < 0x2a == 0x0 (0x0) +__longlong 0xfff6 < 0x2a == 0x1 (0x1) +__ulonglong 0xfff6 < 0x2a == 0x0 (0x0) +float 0xfff6 < 0x2a == 0x1 (0x1) +int 0xfff6 > 0x2a == 0x0 (0x0) +__uint 0xfff6 > 0x2a == 0x1 (0x1) +char 0xfff6 > 0x2a == 0x0 (0x0) +__uchar 0xf6 > 0x2a == 0x1 (0x1) +__longlong 0xfff6 > 0x2a == 0x0 (0x0) +__ulonglong 0xfff6 > 0x2a == 0x1 (0x1) +float 0xfff6 > 0x2a == 0x0 (0x0) +int 0xfff6 <= 0x2a == 0x1 (0x1) +__uint 0xfff6 <= 0x2a == 0x0 (0x0) +char 0xfff6 <= 0x2a == 0x1 (0x1) +__uchar 0xf6 <= 0x2a == 0x0 (0x0) +__longlong 0xfff6 <= 0x2a == 0x1 (0x1) +__ulonglong 0xfff6 <= 0x2a == 0x0 (0x0) +float 0xfff6 <= 0x2a == 0x1 (0x1) +int 0xfff6 == 0x2a == 0x0 (0x0) +__uint 0xfff6 == 0x2a == 0x0 (0x0) +char 0xfff6 == 0x2a == 0x0 (0x0) +__uchar 0xf6 == 0x2a == 0x0 (0x0) +__longlong 0xfff6 == 0x2a == 0x0 (0x0) +__ulonglong 0xfff6 == 0x2a == 0x0 (0x0) +float 0xfff6 == 0x2a == 0x0 (0x0) +int 0xfff6 != 0x2a == 0x1 (0x1) +__uint 0xfff6 != 0x2a == 0x1 (0x1) +char 0xfff6 != 0x2a == 0x1 (0x1) +__uchar 0xf6 != 0x2a == 0x1 (0x1) +__longlong 0xfff6 != 0x2a == 0x1 (0x1) +__ulonglong 0xfff6 != 0x2a == 0x1 (0x1) +float 0xfff6 != 0x2a == 0x1 (0x1) +int 0xfff6 >= 0x2a == 0x0 (0x0) +__uint 0xfff6 >= 0x2a == 0x1 (0x1) +char 0xfff6 >= 0x2a == 0x0 (0x0) +__uchar 0xf6 >= 0x2a == 0x1 (0x1) +__longlong 0xfff6 >= 0x2a == 0x0 (0x0) +__ulonglong 0xfff6 >= 0x2a == 0x1 (0x1) +float 0xfff6 >= 0x2a == 0x0 (0x0) +int 0xfff6 / 0x2a == 0x0 (0x0) +__uint 0xfff6 / 0x2a == 0x618 (0x618) +char 0xfff6 / 0x2a == 0x0 (0x0) +__uchar 0xf6 / 0x2a == 0x5 (0x5) +__longlong 0xfff6 / 0x2a == 0x0 (0x0) +__ulonglong 0xfff6 / 0x2a == 0x6185 (0x6185) +float 0xfff6 / 0x2a == 0x0 (0x0) +int 0xfff6 % 0x2a == -0xa (0xfff6) +__uint 0xfff6 % 0x2a == 0x6 (0x6) +char 0xfff6 % 0x2a == -0xa (0xfff6) +__uchar 0xf6 % 0x2a == 0x24 (0x24) +__longlong 0xfff6 % 0x2a == -0xa (0xfff6) +__ulonglong 0xfff6 % 0x2a == 0x24 (0x24) +0xfff6 * 0x17 == -0xe6 +0xfff6 / 0x17 == 0x0 +0xfff6 % 0x17 == -0xa +int 0xfff6 ^ 0x17 == -0x1f (0xffe1) +__uint 0xfff6 ^ 0x17 == -0x1f (0xffe1) +char 0xfff6 ^ 0x17 == -0x1f (0xffe1) +__uchar 0xf6 ^ 0x17 == 0xe1 (0xe1) +__longlong 0xfff6 ^ 0x17 == -0x1f (0xffe1) +__ulonglong 0xfff6 ^ 0x17 == -0x1f (0xffe1) +int 0xfff6 && 0x17 == 0x1 (0x1) +__uint 0xfff6 && 0x17 == 0x1 (0x1) +char 0xfff6 && 0x17 == 0x1 (0x1) +__uchar 0xf6 && 0x17 == 0x1 (0x1) +__longlong 0xfff6 && 0x17 == 0x1 (0x1) +__ulonglong 0xfff6 && 0x17 == 0x1 (0x1) +int 0xfff6 || 0x17 == 0x1 (0x1) +__uint 0xfff6 || 0x17 == 0x1 (0x1) +char 0xfff6 || 0x17 == 0x1 (0x1) +__uchar 0xf6 || 0x17 == 0x1 (0x1) +__longlong 0xfff6 || 0x17 == 0x1 (0x1) +__ulonglong 0xfff6 || 0x17 == 0x1 (0x1) +int 0xfff6 & 0x17 == 0x16 (0x16) +__uint 0xfff6 & 0x17 == 0x16 (0x16) +char 0xfff6 & 0x17 == 0x16 (0x16) +__uchar 0xf6 & 0x17 == 0x16 (0x16) +__longlong 0xfff6 & 0x17 == 0x16 (0x16) +__ulonglong 0xfff6 & 0x17 == 0x16 (0x16) +int 0xfff6 | 0x17 == -0x9 (0xfff7) +__uint 0xfff6 | 0x17 == -0x9 (0xfff7) +char 0xfff6 | 0x17 == -0x9 (0xfff7) +__uchar 0xf6 | 0x17 == 0xf7 (0xf7) +__longlong 0xfff6 | 0x17 == -0x9 (0xfff7) +__ulonglong 0xfff6 | 0x17 == -0x9 (0xfff7) +int 0xfff6 << 0xe == -0x8000 (0x8000) +__uint 0xfff6 << 0xe == -0x8000 (0x8000) +char 0xfff6 << 0xe == 0x0 (0x0) +__uchar 0xf6 << 0xe == 0x0 (0x0) +__longlong 0xfff6 << 0xe == -0x8000 (0x8000) +__ulonglong 0xfff6 << 0xe == -0x8000 (0x8000) +int 0xfff6 >> 0xe == -0x1 (0xffff) +__uint 0xfff6 >> 0xe == 0x3 (0x3) +char 0xfff6 >> 0xe == -0x1 (0xffff) +__uchar 0xf6 >> 0xe == 0x0 (0x0) +__longlong 0xfff6 >> 0xe == -0x1 (0xffff) +__ulonglong 0xfff6 >> 0xe == -0x1 (0xffff) +int 0xfff6 + 0x17 == 0xd (0xd) +__uint 0xfff6 + 0x17 == 0xd (0xd) +char 0xfff6 + 0x17 == 0xd (0xd) +__uchar 0xf6 + 0x17 == 0xd (0xd) +__longlong 0xfff6 + 0x17 == 0xd (0xd) +__ulonglong 0xfff6 + 0x17 == 0xd (0xd) +float 0xfff6 + 0x17 == 0xd (0xd) +int 0xfff6 - 0x17 == -0x21 (0xffdf) +__uint 0xfff6 - 0x17 == -0x21 (0xffdf) +char 0xfff6 - 0x17 == -0x21 (0xffdf) +__uchar 0xf6 - 0x17 == 0xdf (0xdf) +__longlong 0xfff6 - 0x17 == -0x21 (0xffdf) +__ulonglong 0xfff6 - 0x17 == -0x21 (0xffdf) +float 0xfff6 - 0x17 == -0x21 (0xffdf) +int 0xfff6 * 0x17 == -0xe6 (0xff1a) +__uint 0xfff6 * 0x17 == -0xe6 (0xff1a) +char 0xfff6 * 0x17 == 0x1a (0x1a) +__uchar 0xf6 * 0x17 == 0x1a (0x1a) +__longlong 0xfff6 * 0x17 == -0xe6 (0xff1a) +__ulonglong 0xfff6 * 0x17 == -0xe6 (0xff1a) +float 0xfff6 * 0x17 == -0xe6 (0xff1a) +int 0xfff6 < 0x17 == 0x1 (0x1) +__uint 0xfff6 < 0x17 == 0x0 (0x0) +char 0xfff6 < 0x17 == 0x1 (0x1) +__uchar 0xf6 < 0x17 == 0x0 (0x0) +__longlong 0xfff6 < 0x17 == 0x1 (0x1) +__ulonglong 0xfff6 < 0x17 == 0x0 (0x0) +float 0xfff6 < 0x17 == 0x1 (0x1) +int 0xfff6 > 0x17 == 0x0 (0x0) +__uint 0xfff6 > 0x17 == 0x1 (0x1) +char 0xfff6 > 0x17 == 0x0 (0x0) +__uchar 0xf6 > 0x17 == 0x1 (0x1) +__longlong 0xfff6 > 0x17 == 0x0 (0x0) +__ulonglong 0xfff6 > 0x17 == 0x1 (0x1) +float 0xfff6 > 0x17 == 0x0 (0x0) +int 0xfff6 <= 0x17 == 0x1 (0x1) +__uint 0xfff6 <= 0x17 == 0x0 (0x0) +char 0xfff6 <= 0x17 == 0x1 (0x1) +__uchar 0xf6 <= 0x17 == 0x0 (0x0) +__longlong 0xfff6 <= 0x17 == 0x1 (0x1) +__ulonglong 0xfff6 <= 0x17 == 0x0 (0x0) +float 0xfff6 <= 0x17 == 0x1 (0x1) +int 0xfff6 == 0x17 == 0x0 (0x0) +__uint 0xfff6 == 0x17 == 0x0 (0x0) +char 0xfff6 == 0x17 == 0x0 (0x0) +__uchar 0xf6 == 0x17 == 0x0 (0x0) +__longlong 0xfff6 == 0x17 == 0x0 (0x0) +__ulonglong 0xfff6 == 0x17 == 0x0 (0x0) +float 0xfff6 == 0x17 == 0x0 (0x0) +int 0xfff6 != 0x17 == 0x1 (0x1) +__uint 0xfff6 != 0x17 == 0x1 (0x1) +char 0xfff6 != 0x17 == 0x1 (0x1) +__uchar 0xf6 != 0x17 == 0x1 (0x1) +__longlong 0xfff6 != 0x17 == 0x1 (0x1) +__ulonglong 0xfff6 != 0x17 == 0x1 (0x1) +float 0xfff6 != 0x17 == 0x1 (0x1) +int 0xfff6 >= 0x17 == 0x0 (0x0) +__uint 0xfff6 >= 0x17 == 0x1 (0x1) +char 0xfff6 >= 0x17 == 0x0 (0x0) +__uchar 0xf6 >= 0x17 == 0x1 (0x1) +__longlong 0xfff6 >= 0x17 == 0x0 (0x0) +__ulonglong 0xfff6 >= 0x17 == 0x1 (0x1) +float 0xfff6 >= 0x17 == 0x0 (0x0) +int 0xfff6 / 0x17 == 0x0 (0x0) +__uint 0xfff6 / 0x17 == 0xb20 (0xb20) +char 0xfff6 / 0x17 == 0x0 (0x0) +__uchar 0xf6 / 0x17 == 0xa (0xa) +__longlong 0xfff6 / 0x17 == 0x0 (0x0) +__ulonglong 0xfff6 / 0x17 == 0x642c (0x642c) +float 0xfff6 / 0x17 == 0x0 (0x0) +int 0xfff6 % 0x17 == -0xa (0xfff6) +__uint 0xfff6 % 0x17 == 0x16 (0x16) +char 0xfff6 % 0x17 == -0xa (0xfff6) +__uchar 0xf6 % 0x17 == 0x10 (0x10) +__longlong 0xfff6 % 0x17 == -0xa (0xfff6) +__ulonglong 0xfff6 % 0x17 == 0x2 (0x2) +0xfff6 * 0x7fff == 0xa +0xfff6 / 0x7fff == 0x0 +0xfff6 % 0x7fff == -0xa +int 0xfff6 ^ 0x7fff == -0x7ff7 (0x8009) +__uint 0xfff6 ^ 0x7fff == -0x7ff7 (0x8009) +char 0xfff6 ^ 0xffff == 0x9 (0x9) +__uchar 0xf6 ^ 0xff == 0x9 (0x9) +__longlong 0xfff6 ^ 0x7fff == -0x7ff7 (0x8009) +__ulonglong 0xfff6 ^ 0x7fff == -0x7ff7 (0x8009) +int 0xfff6 && 0x7fff == 0x1 (0x1) +__uint 0xfff6 && 0x7fff == 0x1 (0x1) +char 0xfff6 && 0xffff == 0x1 (0x1) +__uchar 0xf6 && 0xff == 0x1 (0x1) +__longlong 0xfff6 && 0x7fff == 0x1 (0x1) +__ulonglong 0xfff6 && 0x7fff == 0x1 (0x1) +int 0xfff6 || 0x7fff == 0x1 (0x1) +__uint 0xfff6 || 0x7fff == 0x1 (0x1) +char 0xfff6 || 0xffff == 0x1 (0x1) +__uchar 0xf6 || 0xff == 0x1 (0x1) +__longlong 0xfff6 || 0x7fff == 0x1 (0x1) +__ulonglong 0xfff6 || 0x7fff == 0x1 (0x1) +int 0xfff6 & 0x7fff == 0x7ff6 (0x7ff6) +__uint 0xfff6 & 0x7fff == 0x7ff6 (0x7ff6) +char 0xfff6 & 0xffff == -0xa (0xfff6) +__uchar 0xf6 & 0xff == 0xf6 (0xf6) +__longlong 0xfff6 & 0x7fff == 0x7ff6 (0x7ff6) +__ulonglong 0xfff6 & 0x7fff == 0x7ff6 (0x7ff6) +int 0xfff6 | 0x7fff == -0x1 (0xffff) +__uint 0xfff6 | 0x7fff == -0x1 (0xffff) +char 0xfff6 | 0xffff == -0x1 (0xffff) +__uchar 0xf6 | 0xff == 0xff (0xff) +__longlong 0xfff6 | 0x7fff == -0x1 (0xffff) +__ulonglong 0xfff6 | 0x7fff == -0x1 (0xffff) +int 0xfff6 << 0x10 == 0x0 (0x0) +__uint 0xfff6 << 0x10 == 0x0 (0x0) +char 0xfff6 << 0x10 == 0x0 (0x0) +__uchar 0xf6 << 0x10 == 0x0 (0x0) +__longlong 0xfff6 << 0x10 == 0x0 (0x0) +__ulonglong 0xfff6 << 0x10 == 0x0 (0x0) +int 0xfff6 >> 0x10 == -0x1 (0xffff) +__uint 0xfff6 >> 0x10 == 0x0 (0x0) +char 0xfff6 >> 0x10 == -0x1 (0xffff) +__uchar 0xf6 >> 0x10 == 0x0 (0x0) +__longlong 0xfff6 >> 0x10 == -0x1 (0xffff) +__ulonglong 0xfff6 >> 0x10 == -0x1 (0xffff) +int 0xfff6 + 0x7fff == 0x7ff5 (0x7ff5) +__uint 0xfff6 + 0x7fff == 0x7ff5 (0x7ff5) +char 0xfff6 + 0xffff == -0xb (0xfff5) +__uchar 0xf6 + 0xff == 0xf5 (0xf5) +__longlong 0xfff6 + 0x7fff == 0x7ff5 (0x7ff5) +__ulonglong 0xfff6 + 0x7fff == 0x7ff5 (0x7ff5) +float 0xfff6 + 0x7fff == 0x7ff5 (0x7ff5) +int 0xfff6 - 0x7fff == 0x7ff7 (0x7ff7) +__uint 0xfff6 - 0x7fff == 0x7ff7 (0x7ff7) +char 0xfff6 - 0xffff == -0x9 (0xfff7) +__uchar 0xf6 - 0xff == 0xf7 (0xf7) +__longlong 0xfff6 - 0x7fff == 0x7ff7 (0x7ff7) +__ulonglong 0xfff6 - 0x7fff == 0x7ff7 (0x7ff7) +float 0xfff6 - 0x7fff == 0x7ff7 (0x7ff7) +int 0xfff6 * 0x7fff == 0xa (0xa) +__uint 0xfff6 * 0x7fff == 0xa (0xa) +char 0xfff6 * 0xffff == 0xa (0xa) +__uchar 0xf6 * 0xff == 0xa (0xa) +__longlong 0xfff6 * 0x7fff == 0xa (0xa) +__ulonglong 0xfff6 * 0x7fff == 0xa (0xa) +float 0xfff6 * 0x7fff == 0xa (0xa) +int 0xfff6 < 0x7fff == 0x1 (0x1) +__uint 0xfff6 < 0x7fff == 0x0 (0x0) +char 0xfff6 < 0xffff == 0x1 (0x1) +__uchar 0xf6 < 0xff == 0x1 (0x1) +__longlong 0xfff6 < 0x7fff == 0x1 (0x1) +__ulonglong 0xfff6 < 0x7fff == 0x0 (0x0) +float 0xfff6 < 0x7fff == 0x1 (0x1) +int 0xfff6 > 0x7fff == 0x0 (0x0) +__uint 0xfff6 > 0x7fff == 0x1 (0x1) +char 0xfff6 > 0xffff == 0x0 (0x0) +__uchar 0xf6 > 0xff == 0x0 (0x0) +__longlong 0xfff6 > 0x7fff == 0x0 (0x0) +__ulonglong 0xfff6 > 0x7fff == 0x1 (0x1) +float 0xfff6 > 0x7fff == 0x0 (0x0) +int 0xfff6 <= 0x7fff == 0x1 (0x1) +__uint 0xfff6 <= 0x7fff == 0x0 (0x0) +char 0xfff6 <= 0xffff == 0x1 (0x1) +__uchar 0xf6 <= 0xff == 0x1 (0x1) +__longlong 0xfff6 <= 0x7fff == 0x1 (0x1) +__ulonglong 0xfff6 <= 0x7fff == 0x0 (0x0) +float 0xfff6 <= 0x7fff == 0x1 (0x1) +int 0xfff6 == 0x7fff == 0x0 (0x0) +__uint 0xfff6 == 0x7fff == 0x0 (0x0) +char 0xfff6 == 0xffff == 0x0 (0x0) +__uchar 0xf6 == 0xff == 0x0 (0x0) +__longlong 0xfff6 == 0x7fff == 0x0 (0x0) +__ulonglong 0xfff6 == 0x7fff == 0x0 (0x0) +float 0xfff6 == 0x7fff == 0x0 (0x0) +int 0xfff6 != 0x7fff == 0x1 (0x1) +__uint 0xfff6 != 0x7fff == 0x1 (0x1) +char 0xfff6 != 0xffff == 0x1 (0x1) +__uchar 0xf6 != 0xff == 0x1 (0x1) +__longlong 0xfff6 != 0x7fff == 0x1 (0x1) +__ulonglong 0xfff6 != 0x7fff == 0x1 (0x1) +float 0xfff6 != 0x7fff == 0x1 (0x1) +int 0xfff6 >= 0x7fff == 0x0 (0x0) +__uint 0xfff6 >= 0x7fff == 0x1 (0x1) +char 0xfff6 >= 0xffff == 0x0 (0x0) +__uchar 0xf6 >= 0xff == 0x0 (0x0) +__longlong 0xfff6 >= 0x7fff == 0x0 (0x0) +__ulonglong 0xfff6 >= 0x7fff == 0x1 (0x1) +float 0xfff6 >= 0x7fff == 0x0 (0x0) +int 0xfff6 / 0x7fff == 0x0 (0x0) +__uint 0xfff6 / 0x7fff == 0x1 (0x1) +char 0xfff6 / 0xffff == 0xa (0xa) +__uchar 0xf6 / 0xff == 0x0 (0x0) +__longlong 0xfff6 / 0x7fff == 0x0 (0x0) +__ulonglong 0xfff6 / 0x7fff == 0x3 (0x3) +float 0xfff6 / 0x7fff == 0x0 (0x0) +int 0xfff6 % 0x7fff == -0xa (0xfff6) +__uint 0xfff6 % 0x7fff == 0x7ff7 (0x7ff7) +char 0xfff6 % 0xffff == 0x0 (0x0) +__uchar 0xf6 % 0xff == 0xf6 (0xf6) +__longlong 0xfff6 % 0x7fff == -0xa (0xfff6) +__ulonglong 0xfff6 % 0x7fff == 0x7ff9 (0x7ff9) +0xfff6 * 0x8000 == 0x0 +0xfff6 / 0x8000 == 0x0 +0xfff6 % 0x8000 == -0xa +int 0xfff6 ^ 0x8000 == 0x7ff6 (0x7ff6) +__uint 0xfff6 ^ 0x8000 == 0x7ff6 (0x7ff6) +char 0xfff6 ^ 0x0 == -0xa (0xfff6) +__uchar 0xf6 ^ 0x0 == 0xf6 (0xf6) +__longlong 0xfff6 ^ 0x8000 == 0x7ff6 (0x7ff6) +__ulonglong 0xfff6 ^ 0x8000 == 0x7ff6 (0x7ff6) +int 0xfff6 && 0x8000 == 0x1 (0x1) +__uint 0xfff6 && 0x8000 == 0x1 (0x1) +char 0xfff6 && 0x0 == 0x0 (0x0) +__uchar 0xf6 && 0x0 == 0x0 (0x0) +__longlong 0xfff6 && 0x8000 == 0x1 (0x1) +__ulonglong 0xfff6 && 0x8000 == 0x1 (0x1) +int 0xfff6 || 0x8000 == 0x1 (0x1) +__uint 0xfff6 || 0x8000 == 0x1 (0x1) +char 0xfff6 || 0x0 == 0x1 (0x1) +__uchar 0xf6 || 0x0 == 0x1 (0x1) +__longlong 0xfff6 || 0x8000 == 0x1 (0x1) +__ulonglong 0xfff6 || 0x8000 == 0x1 (0x1) +int 0xfff6 & 0x8000 == -0x8000 (0x8000) +__uint 0xfff6 & 0x8000 == -0x8000 (0x8000) +char 0xfff6 & 0x0 == 0x0 (0x0) +__uchar 0xf6 & 0x0 == 0x0 (0x0) +__longlong 0xfff6 & 0x8000 == -0x8000 (0x8000) +__ulonglong 0xfff6 & 0x8000 == -0x8000 (0x8000) +int 0xfff6 | 0x8000 == -0xa (0xfff6) +__uint 0xfff6 | 0x8000 == -0xa (0xfff6) +char 0xfff6 | 0x0 == -0xa (0xfff6) +__uchar 0xf6 | 0x0 == 0xf6 (0xf6) +__longlong 0xfff6 | 0x8000 == -0xa (0xfff6) +__ulonglong 0xfff6 | 0x8000 == -0xa (0xfff6) +int 0xfff6 << 0x12 == 0x0 (0x0) +__uint 0xfff6 << 0x12 == 0x0 (0x0) +char 0xfff6 << 0x12 == 0x0 (0x0) +__uchar 0xf6 << 0x12 == 0x0 (0x0) +__longlong 0xfff6 << 0x12 == 0x0 (0x0) +__ulonglong 0xfff6 << 0x12 == 0x0 (0x0) +int 0xfff6 >> 0x12 == -0x1 (0xffff) +__uint 0xfff6 >> 0x12 == 0x0 (0x0) +char 0xfff6 >> 0x12 == -0x1 (0xffff) +__uchar 0xf6 >> 0x12 == 0x0 (0x0) +__longlong 0xfff6 >> 0x12 == -0x1 (0xffff) +__ulonglong 0xfff6 >> 0x12 == 0x3fff (0x3fff) +int 0xfff6 + 0x8000 == 0x7ff6 (0x7ff6) +__uint 0xfff6 + 0x8000 == 0x7ff6 (0x7ff6) +char 0xfff6 + 0x0 == -0xa (0xfff6) +__uchar 0xf6 + 0x0 == 0xf6 (0xf6) +__longlong 0xfff6 + 0x8000 == 0x7ff6 (0x7ff6) +__ulonglong 0xfff6 + 0x8000 == 0x7ff6 (0x7ff6) +float 0xfff6 + 0x8000 == 0x7ff6 (0x7ff6) +int 0xfff6 - 0x8000 == 0x7ff6 (0x7ff6) +__uint 0xfff6 - 0x8000 == 0x7ff6 (0x7ff6) +char 0xfff6 - 0x0 == -0xa (0xfff6) +__uchar 0xf6 - 0x0 == 0xf6 (0xf6) +__longlong 0xfff6 - 0x8000 == 0x7ff6 (0x7ff6) +__ulonglong 0xfff6 - 0x8000 == 0x7ff6 (0x7ff6) +float 0xfff6 - 0x8000 == 0x7ff6 (0x7ff6) +int 0xfff6 * 0x8000 == 0x0 (0x0) +__uint 0xfff6 * 0x8000 == 0x0 (0x0) +char 0xfff6 * 0x0 == 0x0 (0x0) +__uchar 0xf6 * 0x0 == 0x0 (0x0) +__longlong 0xfff6 * 0x8000 == 0x0 (0x0) +__ulonglong 0xfff6 * 0x8000 == 0x0 (0x0) +float 0xfff6 * 0x8000 == 0x0 (0x0) +int 0xfff6 < 0x8000 == 0x0 (0x0) +__uint 0xfff6 < 0x8000 == 0x0 (0x0) +char 0xfff6 < 0x0 == 0x1 (0x1) +__uchar 0xf6 < 0x0 == 0x0 (0x0) +__longlong 0xfff6 < 0x8000 == 0x0 (0x0) +__ulonglong 0xfff6 < 0x8000 == 0x0 (0x0) +float 0xfff6 < 0x8000 == 0x0 (0x0) +int 0xfff6 > 0x8000 == 0x1 (0x1) +__uint 0xfff6 > 0x8000 == 0x1 (0x1) +char 0xfff6 > 0x0 == 0x0 (0x0) +__uchar 0xf6 > 0x0 == 0x1 (0x1) +__longlong 0xfff6 > 0x8000 == 0x1 (0x1) +__ulonglong 0xfff6 > 0x8000 == 0x1 (0x1) +float 0xfff6 > 0x8000 == 0x1 (0x1) +int 0xfff6 <= 0x8000 == 0x0 (0x0) +__uint 0xfff6 <= 0x8000 == 0x0 (0x0) +char 0xfff6 <= 0x0 == 0x1 (0x1) +__uchar 0xf6 <= 0x0 == 0x0 (0x0) +__longlong 0xfff6 <= 0x8000 == 0x0 (0x0) +__ulonglong 0xfff6 <= 0x8000 == 0x0 (0x0) +float 0xfff6 <= 0x8000 == 0x0 (0x0) +int 0xfff6 == 0x8000 == 0x0 (0x0) +__uint 0xfff6 == 0x8000 == 0x0 (0x0) +char 0xfff6 == 0x0 == 0x0 (0x0) +__uchar 0xf6 == 0x0 == 0x0 (0x0) +__longlong 0xfff6 == 0x8000 == 0x0 (0x0) +__ulonglong 0xfff6 == 0x8000 == 0x0 (0x0) +float 0xfff6 == 0x8000 == 0x0 (0x0) +int 0xfff6 != 0x8000 == 0x1 (0x1) +__uint 0xfff6 != 0x8000 == 0x1 (0x1) +char 0xfff6 != 0x0 == 0x1 (0x1) +__uchar 0xf6 != 0x0 == 0x1 (0x1) +__longlong 0xfff6 != 0x8000 == 0x1 (0x1) +__ulonglong 0xfff6 != 0x8000 == 0x1 (0x1) +float 0xfff6 != 0x8000 == 0x1 (0x1) +int 0xfff6 >= 0x8000 == 0x1 (0x1) +__uint 0xfff6 >= 0x8000 == 0x1 (0x1) +char 0xfff6 >= 0x0 == 0x0 (0x0) +__uchar 0xf6 >= 0x0 == 0x1 (0x1) +__longlong 0xfff6 >= 0x8000 == 0x1 (0x1) +__ulonglong 0xfff6 >= 0x8000 == 0x1 (0x1) +float 0xfff6 >= 0x8000 == 0x1 (0x1) +int 0xfff6 / 0x8000 == 0x0 (0x0) +__uint 0xfff6 / 0x8000 == 0x1 (0x1) +__longlong 0xfff6 / 0x8000 == 0x0 (0x0) +__ulonglong 0xfff6 / 0x8000 == 0x1 (0x1) +float 0xfff6 / 0x8000 == 0x0 (0x0) +int 0xfff6 % 0x8000 == -0xa (0xfff6) +__uint 0xfff6 % 0x8000 == 0x7ff6 (0x7ff6) +__longlong 0xfff6 % 0x8000 == -0xa (0xfff6) +__ulonglong 0xfff6 % 0x8000 == 0x7ff6 (0x7ff6) +0xfff6 * 0x3e8 == -0x2710 +0xfff6 / 0x3e8 == 0x0 +0xfff6 % 0x3e8 == -0xa +int 0xfff6 ^ 0x3e8 == -0x3e2 (0xfc1e) +__uint 0xfff6 ^ 0x3e8 == -0x3e2 (0xfc1e) +char 0xfff6 ^ 0xffe8 == 0x1e (0x1e) +__uchar 0xf6 ^ 0xe8 == 0x1e (0x1e) +__longlong 0xfff6 ^ 0x3e8 == -0x3e2 (0xfc1e) +__ulonglong 0xfff6 ^ 0x3e8 == -0x3e2 (0xfc1e) +int 0xfff6 && 0x3e8 == 0x1 (0x1) +__uint 0xfff6 && 0x3e8 == 0x1 (0x1) +char 0xfff6 && 0xffe8 == 0x1 (0x1) +__uchar 0xf6 && 0xe8 == 0x1 (0x1) +__longlong 0xfff6 && 0x3e8 == 0x1 (0x1) +__ulonglong 0xfff6 && 0x3e8 == 0x1 (0x1) +int 0xfff6 || 0x3e8 == 0x1 (0x1) +__uint 0xfff6 || 0x3e8 == 0x1 (0x1) +char 0xfff6 || 0xffe8 == 0x1 (0x1) +__uchar 0xf6 || 0xe8 == 0x1 (0x1) +__longlong 0xfff6 || 0x3e8 == 0x1 (0x1) +__ulonglong 0xfff6 || 0x3e8 == 0x1 (0x1) +int 0xfff6 & 0x3e8 == 0x3e0 (0x3e0) +__uint 0xfff6 & 0x3e8 == 0x3e0 (0x3e0) +char 0xfff6 & 0xffe8 == -0x20 (0xffe0) +__uchar 0xf6 & 0xe8 == 0xe0 (0xe0) +__longlong 0xfff6 & 0x3e8 == 0x3e0 (0x3e0) +__ulonglong 0xfff6 & 0x3e8 == 0x3e0 (0x3e0) +int 0xfff6 | 0x3e8 == -0x2 (0xfffe) +__uint 0xfff6 | 0x3e8 == -0x2 (0xfffe) +char 0xfff6 | 0xffe8 == -0x2 (0xfffe) +__uchar 0xf6 | 0xe8 == 0xfe (0xfe) +__longlong 0xfff6 | 0x3e8 == -0x2 (0xfffe) +__ulonglong 0xfff6 | 0x3e8 == -0x2 (0xfffe) +int 0xfff6 << 0x14 == 0x0 (0x0) +__uint 0xfff6 << 0x14 == 0x0 (0x0) +char 0xfff6 << 0x14 == 0x0 (0x0) +__uchar 0xf6 << 0x14 == 0x0 (0x0) +__longlong 0xfff6 << 0x14 == 0x0 (0x0) +__ulonglong 0xfff6 << 0x14 == 0x0 (0x0) +int 0xfff6 >> 0x14 == -0x1 (0xffff) +__uint 0xfff6 >> 0x14 == 0x0 (0x0) +char 0xfff6 >> 0x14 == -0x1 (0xffff) +__uchar 0xf6 >> 0x14 == 0x0 (0x0) +__longlong 0xfff6 >> 0x14 == -0x1 (0xffff) +__ulonglong 0xfff6 >> 0x14 == 0xfff (0xfff) +int 0xfff6 + 0x3e8 == 0x3de (0x3de) +__uint 0xfff6 + 0x3e8 == 0x3de (0x3de) +char 0xfff6 + 0xffe8 == -0x22 (0xffde) +__uchar 0xf6 + 0xe8 == 0xde (0xde) +__longlong 0xfff6 + 0x3e8 == 0x3de (0x3de) +__ulonglong 0xfff6 + 0x3e8 == 0x3de (0x3de) +float 0xfff6 + 0x3e8 == 0x3de (0x3de) +int 0xfff6 - 0x3e8 == -0x3f2 (0xfc0e) +__uint 0xfff6 - 0x3e8 == -0x3f2 (0xfc0e) +char 0xfff6 - 0xffe8 == 0xe (0xe) +__uchar 0xf6 - 0xe8 == 0xe (0xe) +__longlong 0xfff6 - 0x3e8 == -0x3f2 (0xfc0e) +__ulonglong 0xfff6 - 0x3e8 == -0x3f2 (0xfc0e) +float 0xfff6 - 0x3e8 == -0x3f2 (0xfc0e) +int 0xfff6 * 0x3e8 == -0x2710 (0xd8f0) +__uint 0xfff6 * 0x3e8 == -0x2710 (0xd8f0) +char 0xfff6 * 0xffe8 == -0x10 (0xfff0) +__uchar 0xf6 * 0xe8 == 0xf0 (0xf0) +__longlong 0xfff6 * 0x3e8 == -0x2710 (0xd8f0) +__ulonglong 0xfff6 * 0x3e8 == -0x2710 (0xd8f0) +float 0xfff6 * 0x3e8 == -0x2710 (0xd8f0) +int 0xfff6 < 0x3e8 == 0x1 (0x1) +__uint 0xfff6 < 0x3e8 == 0x0 (0x0) +char 0xfff6 < 0xffe8 == 0x0 (0x0) +__uchar 0xf6 < 0xe8 == 0x0 (0x0) +__longlong 0xfff6 < 0x3e8 == 0x1 (0x1) +__ulonglong 0xfff6 < 0x3e8 == 0x0 (0x0) +float 0xfff6 < 0x3e8 == 0x1 (0x1) +int 0xfff6 > 0x3e8 == 0x0 (0x0) +__uint 0xfff6 > 0x3e8 == 0x1 (0x1) +char 0xfff6 > 0xffe8 == 0x1 (0x1) +__uchar 0xf6 > 0xe8 == 0x1 (0x1) +__longlong 0xfff6 > 0x3e8 == 0x0 (0x0) +__ulonglong 0xfff6 > 0x3e8 == 0x1 (0x1) +float 0xfff6 > 0x3e8 == 0x0 (0x0) +int 0xfff6 <= 0x3e8 == 0x1 (0x1) +__uint 0xfff6 <= 0x3e8 == 0x0 (0x0) +char 0xfff6 <= 0xffe8 == 0x0 (0x0) +__uchar 0xf6 <= 0xe8 == 0x0 (0x0) +__longlong 0xfff6 <= 0x3e8 == 0x1 (0x1) +__ulonglong 0xfff6 <= 0x3e8 == 0x0 (0x0) +float 0xfff6 <= 0x3e8 == 0x1 (0x1) +int 0xfff6 == 0x3e8 == 0x0 (0x0) +__uint 0xfff6 == 0x3e8 == 0x0 (0x0) +char 0xfff6 == 0xffe8 == 0x0 (0x0) +__uchar 0xf6 == 0xe8 == 0x0 (0x0) +__longlong 0xfff6 == 0x3e8 == 0x0 (0x0) +__ulonglong 0xfff6 == 0x3e8 == 0x0 (0x0) +float 0xfff6 == 0x3e8 == 0x0 (0x0) +int 0xfff6 != 0x3e8 == 0x1 (0x1) +__uint 0xfff6 != 0x3e8 == 0x1 (0x1) +char 0xfff6 != 0xffe8 == 0x1 (0x1) +__uchar 0xf6 != 0xe8 == 0x1 (0x1) +__longlong 0xfff6 != 0x3e8 == 0x1 (0x1) +__ulonglong 0xfff6 != 0x3e8 == 0x1 (0x1) +float 0xfff6 != 0x3e8 == 0x1 (0x1) +int 0xfff6 >= 0x3e8 == 0x0 (0x0) +__uint 0xfff6 >= 0x3e8 == 0x1 (0x1) +char 0xfff6 >= 0xffe8 == 0x1 (0x1) +__uchar 0xf6 >= 0xe8 == 0x1 (0x1) +__longlong 0xfff6 >= 0x3e8 == 0x0 (0x0) +__ulonglong 0xfff6 >= 0x3e8 == 0x1 (0x1) +float 0xfff6 >= 0x3e8 == 0x0 (0x0) +int 0xfff6 / 0x3e8 == 0x0 (0x0) +__uint 0xfff6 / 0x3e8 == 0x41 (0x41) +char 0xfff6 / 0xffe8 == 0x0 (0x0) +__uchar 0xf6 / 0xe8 == 0x1 (0x1) +__longlong 0xfff6 / 0x3e8 == 0x0 (0x0) +__ulonglong 0xfff6 / 0x3e8 == -0x76c9 (0x8937) +float 0xfff6 / 0x3e8 == 0x0 (0x0) +int 0xfff6 % 0x3e8 == -0xa (0xfff6) +__uint 0xfff6 % 0x3e8 == 0x20e (0x20e) +char 0xfff6 % 0xffe8 == -0xa (0xfff6) +__uchar 0xf6 % 0xe8 == 0xe (0xe) +__longlong 0xfff6 % 0x3e8 == -0xa (0xfff6) +__ulonglong 0xfff6 % 0x3e8 == 0x11e (0x11e) +0xfff6 * 0x2710 == 0x7960 +0xfff6 / 0x2710 == 0x0 +0xfff6 % 0x2710 == -0xa +int 0xfff6 ^ 0x2710 == -0x271a (0xd8e6) +__uint 0xfff6 ^ 0x2710 == -0x271a (0xd8e6) +char 0xfff6 ^ 0x10 == -0x1a (0xffe6) +__uchar 0xf6 ^ 0x10 == 0xe6 (0xe6) +__longlong 0xfff6 ^ 0x2710 == -0x271a (0xd8e6) +__ulonglong 0xfff6 ^ 0x2710 == -0x271a (0xd8e6) +int 0xfff6 && 0x2710 == 0x1 (0x1) +__uint 0xfff6 && 0x2710 == 0x1 (0x1) +char 0xfff6 && 0x10 == 0x1 (0x1) +__uchar 0xf6 && 0x10 == 0x1 (0x1) +__longlong 0xfff6 && 0x2710 == 0x1 (0x1) +__ulonglong 0xfff6 && 0x2710 == 0x1 (0x1) +int 0xfff6 || 0x2710 == 0x1 (0x1) +__uint 0xfff6 || 0x2710 == 0x1 (0x1) +char 0xfff6 || 0x10 == 0x1 (0x1) +__uchar 0xf6 || 0x10 == 0x1 (0x1) +__longlong 0xfff6 || 0x2710 == 0x1 (0x1) +__ulonglong 0xfff6 || 0x2710 == 0x1 (0x1) +int 0xfff6 & 0x2710 == 0x2710 (0x2710) +__uint 0xfff6 & 0x2710 == 0x2710 (0x2710) +char 0xfff6 & 0x10 == 0x10 (0x10) +__uchar 0xf6 & 0x10 == 0x10 (0x10) +__longlong 0xfff6 & 0x2710 == 0x2710 (0x2710) +__ulonglong 0xfff6 & 0x2710 == 0x2710 (0x2710) +int 0xfff6 | 0x2710 == -0xa (0xfff6) +__uint 0xfff6 | 0x2710 == -0xa (0xfff6) +char 0xfff6 | 0x10 == -0xa (0xfff6) +__uchar 0xf6 | 0x10 == 0xf6 (0xf6) +__longlong 0xfff6 | 0x2710 == -0xa (0xfff6) +__ulonglong 0xfff6 | 0x2710 == -0xa (0xfff6) +int 0xfff6 << 0x16 == 0x0 (0x0) +__uint 0xfff6 << 0x16 == 0x0 (0x0) +char 0xfff6 << 0x16 == 0x0 (0x0) +__uchar 0xf6 << 0x16 == 0x0 (0x0) +__longlong 0xfff6 << 0x16 == 0x0 (0x0) +__ulonglong 0xfff6 << 0x16 == 0x0 (0x0) +int 0xfff6 >> 0x16 == -0x1 (0xffff) +__uint 0xfff6 >> 0x16 == 0x0 (0x0) +char 0xfff6 >> 0x16 == -0x1 (0xffff) +__uchar 0xf6 >> 0x16 == 0x0 (0x0) +__longlong 0xfff6 >> 0x16 == -0x1 (0xffff) +__ulonglong 0xfff6 >> 0x16 == 0x3ff (0x3ff) +int 0xfff6 + 0x2710 == 0x2706 (0x2706) +__uint 0xfff6 + 0x2710 == 0x2706 (0x2706) +char 0xfff6 + 0x10 == 0x6 (0x6) +__uchar 0xf6 + 0x10 == 0x6 (0x6) +__longlong 0xfff6 + 0x2710 == 0x2706 (0x2706) +__ulonglong 0xfff6 + 0x2710 == 0x2706 (0x2706) +float 0xfff6 + 0x2710 == 0x2706 (0x2706) +int 0xfff6 - 0x2710 == -0x271a (0xd8e6) +__uint 0xfff6 - 0x2710 == -0x271a (0xd8e6) +char 0xfff6 - 0x10 == -0x1a (0xffe6) +__uchar 0xf6 - 0x10 == 0xe6 (0xe6) +__longlong 0xfff6 - 0x2710 == -0x271a (0xd8e6) +__ulonglong 0xfff6 - 0x2710 == -0x271a (0xd8e6) +float 0xfff6 - 0x2710 == -0x271a (0xd8e6) +int 0xfff6 * 0x2710 == 0x7960 (0x7960) +__uint 0xfff6 * 0x2710 == 0x7960 (0x7960) +char 0xfff6 * 0x10 == 0x60 (0x60) +__uchar 0xf6 * 0x10 == 0x60 (0x60) +__longlong 0xfff6 * 0x2710 == 0x7960 (0x7960) +__ulonglong 0xfff6 * 0x2710 == 0x7960 (0x7960) +float 0xfff6 * 0x2710 == 0x7960 (0x7960) +int 0xfff6 < 0x2710 == 0x1 (0x1) +__uint 0xfff6 < 0x2710 == 0x0 (0x0) +char 0xfff6 < 0x10 == 0x1 (0x1) +__uchar 0xf6 < 0x10 == 0x0 (0x0) +__longlong 0xfff6 < 0x2710 == 0x1 (0x1) +__ulonglong 0xfff6 < 0x2710 == 0x0 (0x0) +float 0xfff6 < 0x2710 == 0x1 (0x1) +int 0xfff6 > 0x2710 == 0x0 (0x0) +__uint 0xfff6 > 0x2710 == 0x1 (0x1) +char 0xfff6 > 0x10 == 0x0 (0x0) +__uchar 0xf6 > 0x10 == 0x1 (0x1) +__longlong 0xfff6 > 0x2710 == 0x0 (0x0) +__ulonglong 0xfff6 > 0x2710 == 0x1 (0x1) +float 0xfff6 > 0x2710 == 0x0 (0x0) +int 0xfff6 <= 0x2710 == 0x1 (0x1) +__uint 0xfff6 <= 0x2710 == 0x0 (0x0) +char 0xfff6 <= 0x10 == 0x1 (0x1) +__uchar 0xf6 <= 0x10 == 0x0 (0x0) +__longlong 0xfff6 <= 0x2710 == 0x1 (0x1) +__ulonglong 0xfff6 <= 0x2710 == 0x0 (0x0) +float 0xfff6 <= 0x2710 == 0x1 (0x1) +int 0xfff6 == 0x2710 == 0x0 (0x0) +__uint 0xfff6 == 0x2710 == 0x0 (0x0) +char 0xfff6 == 0x10 == 0x0 (0x0) +__uchar 0xf6 == 0x10 == 0x0 (0x0) +__longlong 0xfff6 == 0x2710 == 0x0 (0x0) +__ulonglong 0xfff6 == 0x2710 == 0x0 (0x0) +float 0xfff6 == 0x2710 == 0x0 (0x0) +int 0xfff6 != 0x2710 == 0x1 (0x1) +__uint 0xfff6 != 0x2710 == 0x1 (0x1) +char 0xfff6 != 0x10 == 0x1 (0x1) +__uchar 0xf6 != 0x10 == 0x1 (0x1) +__longlong 0xfff6 != 0x2710 == 0x1 (0x1) +__ulonglong 0xfff6 != 0x2710 == 0x1 (0x1) +float 0xfff6 != 0x2710 == 0x1 (0x1) +int 0xfff6 >= 0x2710 == 0x0 (0x0) +__uint 0xfff6 >= 0x2710 == 0x1 (0x1) +char 0xfff6 >= 0x10 == 0x0 (0x0) +__uchar 0xf6 >= 0x10 == 0x1 (0x1) +__longlong 0xfff6 >= 0x2710 == 0x0 (0x0) +__ulonglong 0xfff6 >= 0x2710 == 0x1 (0x1) +float 0xfff6 >= 0x2710 == 0x0 (0x0) +int 0xfff6 / 0x2710 == 0x0 (0x0) +__uint 0xfff6 / 0x2710 == 0x6 (0x6) +char 0xfff6 / 0x10 == 0x0 (0x0) +__uchar 0xf6 / 0x10 == 0xf (0xf) +__longlong 0xfff6 / 0x2710 == 0x0 (0x0) +__ulonglong 0xfff6 / 0x2710 == -0x7248 (0x8db8) +float 0xfff6 / 0x2710 == 0x0 (0x0) +int 0xfff6 % 0x2710 == -0xa (0xfff6) +__uint 0xfff6 % 0x2710 == 0x1596 (0x1596) +char 0xfff6 % 0x10 == -0xa (0xfff6) +__uchar 0xf6 % 0x10 == 0x6 (0x6) +__longlong 0xfff6 % 0x2710 == -0xa (0xfff6) +__ulonglong 0xfff6 % 0x2710 == 0x1c76 (0x1c76) +int xor42-0xa xor42 -0x24 +__uint xor42-0xa xor42 -0x24 +char xor42-0xa xor42 -0x24 +__uchar xor420xf6 xor42 0xdc +__longlong xor42-0xa xor42 -0x24 +__ulonglong xor42-0xa xor42 -0x24 +int land1-0xa land1 0x1 +__uint land1-0xa land1 0x1 +char land1-0xa land1 0x1 +__uchar land10xf6 land1 0x1 +__longlong land1-0xa land1 0x1 +__ulonglong land1-0xa land1 0x1 +int lor1-0xa lor1 0x1 +__uint lor1-0xa lor1 0x1 +char lor1-0xa lor1 0x1 +__uchar lor10xf6 lor1 0x1 +__longlong lor1-0xa lor1 0x1 +__ulonglong lor1-0xa lor1 0x1 +int and42-0xa and42 0x22 +__uint and42-0xa and42 0x22 +char and42-0xa and42 0x22 +__uchar and420xf6 and42 0x22 +__longlong and42-0xa and42 0x22 +__ulonglong and42-0xa and42 0x22 +int or42-0xa or42 -0x2 +__uint or42-0xa or42 -0x2 +char or42-0xa or42 -0x2 +__uchar or420xf6 or42 0xfe +__longlong or42-0xa or42 -0x2 +__ulonglong or42-0xa or42 -0x2 +int shl5-0xa shl5 -0x140 +__uint shl5-0xa shl5 -0x140 +char shl5-0xa shl5 -0x40 +__uchar shl50xf6 shl5 0xc0 +__longlong shl5-0xa shl5 -0x140 +__ulonglong shl5-0xa shl5 -0x140 +int shr5-0xa shr5 -0x1 +__uint shr5-0xa shr5 0x7ff +char shr5-0xa shr5 -0x1 +__uchar shr50xf6 shr5 0x7 +__longlong shr5-0xa shr5 -0x1 +__ulonglong shr5-0xa shr5 -0x1 +int add42-0xa add42 0x20 +__uint add42-0xa add42 0x20 +char add42-0xa add42 0x20 +__uchar add420xf6 add42 0x20 +__longlong add42-0xa add42 0x20 +__ulonglong add42-0xa add42 0x20 +float add42-0xa add42 0x20 +int sub42-0xa sub42 -0x34 +__uint sub42-0xa sub42 -0x34 +char sub42-0xa sub42 -0x34 +__uchar sub420xf6 sub42 0xcc +__longlong sub42-0xa sub42 -0x34 +__ulonglong sub42-0xa sub42 -0x34 +float sub42-0xa sub42 -0x34 +int mul42-0xa mul42 -0x1a4 +__uint mul42-0xa mul42 -0x1a4 +char mul42-0xa mul42 0x5c +__uchar mul420xf6 mul42 0x5c +__longlong mul42-0xa mul42 -0x1a4 +__ulonglong mul42-0xa mul42 -0x1a4 +float mul42-0xa mul42 -0x1a4 +int lt42-0xa lt42 0x1 +__uint lt42-0xa lt42 0x0 +char lt42-0xa lt42 0x1 +__uchar lt420xf6 lt42 0x0 +__longlong lt42-0xa lt42 0x1 +__ulonglong lt42-0xa lt42 0x0 +float lt42-0xa lt42 0x1 +int gt42-0xa gt42 0x0 +__uint gt42-0xa gt42 0x1 +char gt42-0xa gt42 0x0 +__uchar gt420xf6 gt42 0x1 +__longlong gt42-0xa gt42 0x0 +__ulonglong gt42-0xa gt42 0x1 +float gt42-0xa gt42 0x0 +int le42-0xa le42 0x1 +__uint le42-0xa le42 0x0 +char le42-0xa le42 0x1 +__uchar le420xf6 le42 0x0 +__longlong le42-0xa le42 0x1 +__ulonglong le42-0xa le42 0x0 +float le42-0xa le42 0x1 +int eq42-0xa eq42 0x0 +__uint eq42-0xa eq42 0x0 +char eq42-0xa eq42 0x0 +__uchar eq420xf6 eq42 0x0 +__longlong eq42-0xa eq42 0x0 +__ulonglong eq42-0xa eq42 0x0 +float eq42-0xa eq42 0x0 +int ne42-0xa ne42 0x1 +__uint ne42-0xa ne42 0x1 +char ne42-0xa ne42 0x1 +__uchar ne420xf6 ne42 0x1 +__longlong ne42-0xa ne42 0x1 +__ulonglong ne42-0xa ne42 0x1 +float ne42-0xa ne42 0x1 +int ge42-0xa ge42 0x0 +__uint ge42-0xa ge42 0x1 +char ge42-0xa ge42 0x0 +__uchar ge420xf6 ge42 0x1 +__longlong ge42-0xa ge42 0x0 +__ulonglong ge42-0xa ge42 0x1 +float ge42-0xa ge42 0x0 +int div42-0xa div42 0x0 +__uint div42-0xa div42 0x618 +char div42-0xa div42 0x0 +__uchar div420xf6 div42 0x5 +__longlong div42-0xa div42 0x0 +__ulonglong div42-0xa div42 0x6185 +float div42-0xa div42 0x0 +int mod23-0xa mod23 -0xa +__uint mod23-0xa mod23 0x16 +char mod23-0xa mod23 -0xa +__uchar mod230xf6 mod23 0x10 +__longlong mod23-0xa mod23 -0xa +__ulonglong mod23-0xa mod23 0x2 +0x5 * 0xffff == -0x5 +0x5 / 0xffff == -0x5 +0x5 % 0xffff == 0x0 +int 0x5 ^ 0xffff == -0x6 (0xfffa) +__uint 0x5 ^ 0xffff == -0x6 (0xfffa) +char 0x5 ^ 0xffff == -0x6 (0xfffa) +__uchar 0x5 ^ 0xff == 0xfa (0xfa) +__longlong 0x5 ^ 0xffff == -0x6 (0xfffa) +__ulonglong 0x5 ^ 0xffff == -0x6 (0xfffa) +int 0x5 && 0xffff == 0x1 (0x1) +__uint 0x5 && 0xffff == 0x1 (0x1) +char 0x5 && 0xffff == 0x1 (0x1) +__uchar 0x5 && 0xff == 0x1 (0x1) +__longlong 0x5 && 0xffff == 0x1 (0x1) +__ulonglong 0x5 && 0xffff == 0x1 (0x1) +int 0x5 || 0xffff == 0x1 (0x1) +__uint 0x5 || 0xffff == 0x1 (0x1) +char 0x5 || 0xffff == 0x1 (0x1) +__uchar 0x5 || 0xff == 0x1 (0x1) +__longlong 0x5 || 0xffff == 0x1 (0x1) +__ulonglong 0x5 || 0xffff == 0x1 (0x1) +int 0x5 & 0xffff == 0x5 (0x5) +__uint 0x5 & 0xffff == 0x5 (0x5) +char 0x5 & 0xffff == 0x5 (0x5) +__uchar 0x5 & 0xff == 0x5 (0x5) +__longlong 0x5 & 0xffff == 0x5 (0x5) +__ulonglong 0x5 & 0xffff == 0x5 (0x5) +int 0x5 | 0xffff == -0x1 (0xffff) +__uint 0x5 | 0xffff == -0x1 (0xffff) +char 0x5 | 0xffff == -0x1 (0xffff) +__uchar 0x5 | 0xff == 0xff (0xff) +__longlong 0x5 | 0xffff == -0x1 (0xffff) +__ulonglong 0x5 | 0xffff == -0x1 (0xffff) +int 0x5 << 0x1 == 0xa (0xa) +__uint 0x5 << 0x1 == 0xa (0xa) +char 0x5 << 0x1 == 0xa (0xa) +__uchar 0x5 << 0x1 == 0xa (0xa) +__longlong 0x5 << 0x1 == 0xa (0xa) +__ulonglong 0x5 << 0x1 == 0xa (0xa) +int 0x5 >> 0x1 == 0x2 (0x2) +__uint 0x5 >> 0x1 == 0x2 (0x2) +char 0x5 >> 0x1 == 0x2 (0x2) +__uchar 0x5 >> 0x1 == 0x2 (0x2) +__longlong 0x5 >> 0x1 == 0x2 (0x2) +__ulonglong 0x5 >> 0x1 == 0x2 (0x2) +int 0x5 + 0xffff == 0x4 (0x4) +__uint 0x5 + 0xffff == 0x4 (0x4) +char 0x5 + 0xffff == 0x4 (0x4) +__uchar 0x5 + 0xff == 0x4 (0x4) +__longlong 0x5 + 0xffff == 0x4 (0x4) +__ulonglong 0x5 + 0xffff == 0x4 (0x4) +float 0x5 + 0xffff == 0x4 (0x4) +int 0x5 - 0xffff == 0x6 (0x6) +__uint 0x5 - 0xffff == 0x6 (0x6) +char 0x5 - 0xffff == 0x6 (0x6) +__uchar 0x5 - 0xff == 0x6 (0x6) +__longlong 0x5 - 0xffff == 0x6 (0x6) +__ulonglong 0x5 - 0xffff == 0x6 (0x6) +float 0x5 - 0xffff == 0x6 (0x6) +int 0x5 * 0xffff == -0x5 (0xfffb) +__uint 0x5 * 0xffff == -0x5 (0xfffb) +char 0x5 * 0xffff == -0x5 (0xfffb) +__uchar 0x5 * 0xff == 0xfb (0xfb) +__longlong 0x5 * 0xffff == -0x5 (0xfffb) +__ulonglong 0x5 * 0xffff == -0x5 (0xfffb) +float 0x5 * 0xffff == -0x5 (0xfffb) +int 0x5 < 0xffff == 0x0 (0x0) +__uint 0x5 < 0xffff == 0x1 (0x1) +char 0x5 < 0xffff == 0x0 (0x0) +__uchar 0x5 < 0xff == 0x1 (0x1) +__longlong 0x5 < 0xffff == 0x0 (0x0) +__ulonglong 0x5 < 0xffff == 0x1 (0x1) +float 0x5 < 0xffff == 0x0 (0x0) +int 0x5 > 0xffff == 0x1 (0x1) +__uint 0x5 > 0xffff == 0x0 (0x0) +char 0x5 > 0xffff == 0x1 (0x1) +__uchar 0x5 > 0xff == 0x0 (0x0) +__longlong 0x5 > 0xffff == 0x1 (0x1) +__ulonglong 0x5 > 0xffff == 0x0 (0x0) +float 0x5 > 0xffff == 0x1 (0x1) +int 0x5 <= 0xffff == 0x0 (0x0) +__uint 0x5 <= 0xffff == 0x1 (0x1) +char 0x5 <= 0xffff == 0x0 (0x0) +__uchar 0x5 <= 0xff == 0x1 (0x1) +__longlong 0x5 <= 0xffff == 0x0 (0x0) +__ulonglong 0x5 <= 0xffff == 0x1 (0x1) +float 0x5 <= 0xffff == 0x0 (0x0) +int 0x5 == 0xffff == 0x0 (0x0) +__uint 0x5 == 0xffff == 0x0 (0x0) +char 0x5 == 0xffff == 0x0 (0x0) +__uchar 0x5 == 0xff == 0x0 (0x0) +__longlong 0x5 == 0xffff == 0x0 (0x0) +__ulonglong 0x5 == 0xffff == 0x0 (0x0) +float 0x5 == 0xffff == 0x0 (0x0) +int 0x5 != 0xffff == 0x1 (0x1) +__uint 0x5 != 0xffff == 0x1 (0x1) +char 0x5 != 0xffff == 0x1 (0x1) +__uchar 0x5 != 0xff == 0x1 (0x1) +__longlong 0x5 != 0xffff == 0x1 (0x1) +__ulonglong 0x5 != 0xffff == 0x1 (0x1) +float 0x5 != 0xffff == 0x1 (0x1) +int 0x5 >= 0xffff == 0x1 (0x1) +__uint 0x5 >= 0xffff == 0x0 (0x0) +char 0x5 >= 0xffff == 0x1 (0x1) +__uchar 0x5 >= 0xff == 0x0 (0x0) +__longlong 0x5 >= 0xffff == 0x1 (0x1) +__ulonglong 0x5 >= 0xffff == 0x0 (0x0) +float 0x5 >= 0xffff == 0x1 (0x1) +int 0x5 / 0xffff == -0x5 (0xfffb) +__uint 0x5 / 0xffff == 0x0 (0x0) +char 0x5 / 0xffff == -0x5 (0xfffb) +__uchar 0x5 / 0xff == 0x0 (0x0) +__longlong 0x5 / 0xffff == -0x5 (0xfffb) +__ulonglong 0x5 / 0xffff == 0x0 (0x0) +float 0x5 / 0xffff == -0x5 (0xfffb) +int 0x5 % 0xffff == 0x0 (0x0) +__uint 0x5 % 0xffff == 0x5 (0x5) +char 0x5 % 0xffff == 0x0 (0x0) +__uchar 0x5 % 0xff == 0x5 (0x5) +__longlong 0x5 % 0xffff == 0x0 (0x0) +__ulonglong 0x5 % 0xffff == 0x5 (0x5) +0x5 * 0x1 == 0x5 +0x5 / 0x1 == 0x5 +0x5 % 0x1 == 0x0 +int 0x5 ^ 0x1 == 0x4 (0x4) +__uint 0x5 ^ 0x1 == 0x4 (0x4) +char 0x5 ^ 0x1 == 0x4 (0x4) +__uchar 0x5 ^ 0x1 == 0x4 (0x4) +__longlong 0x5 ^ 0x1 == 0x4 (0x4) +__ulonglong 0x5 ^ 0x1 == 0x4 (0x4) +int 0x5 && 0x1 == 0x1 (0x1) +__uint 0x5 && 0x1 == 0x1 (0x1) +char 0x5 && 0x1 == 0x1 (0x1) +__uchar 0x5 && 0x1 == 0x1 (0x1) +__longlong 0x5 && 0x1 == 0x1 (0x1) +__ulonglong 0x5 && 0x1 == 0x1 (0x1) +int 0x5 || 0x1 == 0x1 (0x1) +__uint 0x5 || 0x1 == 0x1 (0x1) +char 0x5 || 0x1 == 0x1 (0x1) +__uchar 0x5 || 0x1 == 0x1 (0x1) +__longlong 0x5 || 0x1 == 0x1 (0x1) +__ulonglong 0x5 || 0x1 == 0x1 (0x1) +int 0x5 & 0x1 == 0x1 (0x1) +__uint 0x5 & 0x1 == 0x1 (0x1) +char 0x5 & 0x1 == 0x1 (0x1) +__uchar 0x5 & 0x1 == 0x1 (0x1) +__longlong 0x5 & 0x1 == 0x1 (0x1) +__ulonglong 0x5 & 0x1 == 0x1 (0x1) +int 0x5 | 0x1 == 0x5 (0x5) +__uint 0x5 | 0x1 == 0x5 (0x5) +char 0x5 | 0x1 == 0x5 (0x5) +__uchar 0x5 | 0x1 == 0x5 (0x5) +__longlong 0x5 | 0x1 == 0x5 (0x5) +__ulonglong 0x5 | 0x1 == 0x5 (0x5) +int 0x5 << 0x2 == 0x14 (0x14) +__uint 0x5 << 0x2 == 0x14 (0x14) +char 0x5 << 0x2 == 0x14 (0x14) +__uchar 0x5 << 0x2 == 0x14 (0x14) +__longlong 0x5 << 0x2 == 0x14 (0x14) +__ulonglong 0x5 << 0x2 == 0x14 (0x14) +int 0x5 >> 0x2 == 0x1 (0x1) +__uint 0x5 >> 0x2 == 0x1 (0x1) +char 0x5 >> 0x2 == 0x1 (0x1) +__uchar 0x5 >> 0x2 == 0x1 (0x1) +__longlong 0x5 >> 0x2 == 0x1 (0x1) +__ulonglong 0x5 >> 0x2 == 0x1 (0x1) +int 0x5 + 0x1 == 0x6 (0x6) +__uint 0x5 + 0x1 == 0x6 (0x6) +char 0x5 + 0x1 == 0x6 (0x6) +__uchar 0x5 + 0x1 == 0x6 (0x6) +__longlong 0x5 + 0x1 == 0x6 (0x6) +__ulonglong 0x5 + 0x1 == 0x6 (0x6) +float 0x5 + 0x1 == 0x6 (0x6) +int 0x5 - 0x1 == 0x4 (0x4) +__uint 0x5 - 0x1 == 0x4 (0x4) +char 0x5 - 0x1 == 0x4 (0x4) +__uchar 0x5 - 0x1 == 0x4 (0x4) +__longlong 0x5 - 0x1 == 0x4 (0x4) +__ulonglong 0x5 - 0x1 == 0x4 (0x4) +float 0x5 - 0x1 == 0x4 (0x4) +int 0x5 * 0x1 == 0x5 (0x5) +__uint 0x5 * 0x1 == 0x5 (0x5) +char 0x5 * 0x1 == 0x5 (0x5) +__uchar 0x5 * 0x1 == 0x5 (0x5) +__longlong 0x5 * 0x1 == 0x5 (0x5) +__ulonglong 0x5 * 0x1 == 0x5 (0x5) +float 0x5 * 0x1 == 0x5 (0x5) +int 0x5 < 0x1 == 0x0 (0x0) +__uint 0x5 < 0x1 == 0x0 (0x0) +char 0x5 < 0x1 == 0x0 (0x0) +__uchar 0x5 < 0x1 == 0x0 (0x0) +__longlong 0x5 < 0x1 == 0x0 (0x0) +__ulonglong 0x5 < 0x1 == 0x0 (0x0) +float 0x5 < 0x1 == 0x0 (0x0) +int 0x5 > 0x1 == 0x1 (0x1) +__uint 0x5 > 0x1 == 0x1 (0x1) +char 0x5 > 0x1 == 0x1 (0x1) +__uchar 0x5 > 0x1 == 0x1 (0x1) +__longlong 0x5 > 0x1 == 0x1 (0x1) +__ulonglong 0x5 > 0x1 == 0x1 (0x1) +float 0x5 > 0x1 == 0x1 (0x1) +int 0x5 <= 0x1 == 0x0 (0x0) +__uint 0x5 <= 0x1 == 0x0 (0x0) +char 0x5 <= 0x1 == 0x0 (0x0) +__uchar 0x5 <= 0x1 == 0x0 (0x0) +__longlong 0x5 <= 0x1 == 0x0 (0x0) +__ulonglong 0x5 <= 0x1 == 0x0 (0x0) +float 0x5 <= 0x1 == 0x0 (0x0) +int 0x5 == 0x1 == 0x0 (0x0) +__uint 0x5 == 0x1 == 0x0 (0x0) +char 0x5 == 0x1 == 0x0 (0x0) +__uchar 0x5 == 0x1 == 0x0 (0x0) +__longlong 0x5 == 0x1 == 0x0 (0x0) +__ulonglong 0x5 == 0x1 == 0x0 (0x0) +float 0x5 == 0x1 == 0x0 (0x0) +int 0x5 != 0x1 == 0x1 (0x1) +__uint 0x5 != 0x1 == 0x1 (0x1) +char 0x5 != 0x1 == 0x1 (0x1) +__uchar 0x5 != 0x1 == 0x1 (0x1) +__longlong 0x5 != 0x1 == 0x1 (0x1) +__ulonglong 0x5 != 0x1 == 0x1 (0x1) +float 0x5 != 0x1 == 0x1 (0x1) +int 0x5 >= 0x1 == 0x1 (0x1) +__uint 0x5 >= 0x1 == 0x1 (0x1) +char 0x5 >= 0x1 == 0x1 (0x1) +__uchar 0x5 >= 0x1 == 0x1 (0x1) +__longlong 0x5 >= 0x1 == 0x1 (0x1) +__ulonglong 0x5 >= 0x1 == 0x1 (0x1) +float 0x5 >= 0x1 == 0x1 (0x1) +int 0x5 / 0x1 == 0x5 (0x5) +__uint 0x5 / 0x1 == 0x5 (0x5) +char 0x5 / 0x1 == 0x5 (0x5) +__uchar 0x5 / 0x1 == 0x5 (0x5) +__longlong 0x5 / 0x1 == 0x5 (0x5) +__ulonglong 0x5 / 0x1 == 0x5 (0x5) +float 0x5 / 0x1 == 0x5 (0x5) +int 0x5 % 0x1 == 0x0 (0x0) +__uint 0x5 % 0x1 == 0x0 (0x0) +char 0x5 % 0x1 == 0x0 (0x0) +__uchar 0x5 % 0x1 == 0x0 (0x0) +__longlong 0x5 % 0x1 == 0x0 (0x0) +__ulonglong 0x5 % 0x1 == 0x0 (0x0) +0x5 * 0x2 == 0xa +0x5 / 0x2 == 0x2 +0x5 % 0x2 == 0x1 +int 0x5 ^ 0x2 == 0x7 (0x7) +__uint 0x5 ^ 0x2 == 0x7 (0x7) +char 0x5 ^ 0x2 == 0x7 (0x7) +__uchar 0x5 ^ 0x2 == 0x7 (0x7) +__longlong 0x5 ^ 0x2 == 0x7 (0x7) +__ulonglong 0x5 ^ 0x2 == 0x7 (0x7) +int 0x5 && 0x2 == 0x1 (0x1) +__uint 0x5 && 0x2 == 0x1 (0x1) +char 0x5 && 0x2 == 0x1 (0x1) +__uchar 0x5 && 0x2 == 0x1 (0x1) +__longlong 0x5 && 0x2 == 0x1 (0x1) +__ulonglong 0x5 && 0x2 == 0x1 (0x1) +int 0x5 || 0x2 == 0x1 (0x1) +__uint 0x5 || 0x2 == 0x1 (0x1) +char 0x5 || 0x2 == 0x1 (0x1) +__uchar 0x5 || 0x2 == 0x1 (0x1) +__longlong 0x5 || 0x2 == 0x1 (0x1) +__ulonglong 0x5 || 0x2 == 0x1 (0x1) +int 0x5 & 0x2 == 0x0 (0x0) +__uint 0x5 & 0x2 == 0x0 (0x0) +char 0x5 & 0x2 == 0x0 (0x0) +__uchar 0x5 & 0x2 == 0x0 (0x0) +__longlong 0x5 & 0x2 == 0x0 (0x0) +__ulonglong 0x5 & 0x2 == 0x0 (0x0) +int 0x5 | 0x2 == 0x7 (0x7) +__uint 0x5 | 0x2 == 0x7 (0x7) +char 0x5 | 0x2 == 0x7 (0x7) +__uchar 0x5 | 0x2 == 0x7 (0x7) +__longlong 0x5 | 0x2 == 0x7 (0x7) +__ulonglong 0x5 | 0x2 == 0x7 (0x7) +int 0x5 << 0x3 == 0x28 (0x28) +__uint 0x5 << 0x3 == 0x28 (0x28) +char 0x5 << 0x3 == 0x28 (0x28) +__uchar 0x5 << 0x3 == 0x28 (0x28) +__longlong 0x5 << 0x3 == 0x28 (0x28) +__ulonglong 0x5 << 0x3 == 0x28 (0x28) +int 0x5 >> 0x3 == 0x0 (0x0) +__uint 0x5 >> 0x3 == 0x0 (0x0) +char 0x5 >> 0x3 == 0x0 (0x0) +__uchar 0x5 >> 0x3 == 0x0 (0x0) +__longlong 0x5 >> 0x3 == 0x0 (0x0) +__ulonglong 0x5 >> 0x3 == 0x0 (0x0) +int 0x5 + 0x2 == 0x7 (0x7) +__uint 0x5 + 0x2 == 0x7 (0x7) +char 0x5 + 0x2 == 0x7 (0x7) +__uchar 0x5 + 0x2 == 0x7 (0x7) +__longlong 0x5 + 0x2 == 0x7 (0x7) +__ulonglong 0x5 + 0x2 == 0x7 (0x7) +float 0x5 + 0x2 == 0x7 (0x7) +int 0x5 - 0x2 == 0x3 (0x3) +__uint 0x5 - 0x2 == 0x3 (0x3) +char 0x5 - 0x2 == 0x3 (0x3) +__uchar 0x5 - 0x2 == 0x3 (0x3) +__longlong 0x5 - 0x2 == 0x3 (0x3) +__ulonglong 0x5 - 0x2 == 0x3 (0x3) +float 0x5 - 0x2 == 0x3 (0x3) +int 0x5 * 0x2 == 0xa (0xa) +__uint 0x5 * 0x2 == 0xa (0xa) +char 0x5 * 0x2 == 0xa (0xa) +__uchar 0x5 * 0x2 == 0xa (0xa) +__longlong 0x5 * 0x2 == 0xa (0xa) +__ulonglong 0x5 * 0x2 == 0xa (0xa) +float 0x5 * 0x2 == 0xa (0xa) +int 0x5 < 0x2 == 0x0 (0x0) +__uint 0x5 < 0x2 == 0x0 (0x0) +char 0x5 < 0x2 == 0x0 (0x0) +__uchar 0x5 < 0x2 == 0x0 (0x0) +__longlong 0x5 < 0x2 == 0x0 (0x0) +__ulonglong 0x5 < 0x2 == 0x0 (0x0) +float 0x5 < 0x2 == 0x0 (0x0) +int 0x5 > 0x2 == 0x1 (0x1) +__uint 0x5 > 0x2 == 0x1 (0x1) +char 0x5 > 0x2 == 0x1 (0x1) +__uchar 0x5 > 0x2 == 0x1 (0x1) +__longlong 0x5 > 0x2 == 0x1 (0x1) +__ulonglong 0x5 > 0x2 == 0x1 (0x1) +float 0x5 > 0x2 == 0x1 (0x1) +int 0x5 <= 0x2 == 0x0 (0x0) +__uint 0x5 <= 0x2 == 0x0 (0x0) +char 0x5 <= 0x2 == 0x0 (0x0) +__uchar 0x5 <= 0x2 == 0x0 (0x0) +__longlong 0x5 <= 0x2 == 0x0 (0x0) +__ulonglong 0x5 <= 0x2 == 0x0 (0x0) +float 0x5 <= 0x2 == 0x0 (0x0) +int 0x5 == 0x2 == 0x0 (0x0) +__uint 0x5 == 0x2 == 0x0 (0x0) +char 0x5 == 0x2 == 0x0 (0x0) +__uchar 0x5 == 0x2 == 0x0 (0x0) +__longlong 0x5 == 0x2 == 0x0 (0x0) +__ulonglong 0x5 == 0x2 == 0x0 (0x0) +float 0x5 == 0x2 == 0x0 (0x0) +int 0x5 != 0x2 == 0x1 (0x1) +__uint 0x5 != 0x2 == 0x1 (0x1) +char 0x5 != 0x2 == 0x1 (0x1) +__uchar 0x5 != 0x2 == 0x1 (0x1) +__longlong 0x5 != 0x2 == 0x1 (0x1) +__ulonglong 0x5 != 0x2 == 0x1 (0x1) +float 0x5 != 0x2 == 0x1 (0x1) +int 0x5 >= 0x2 == 0x1 (0x1) +__uint 0x5 >= 0x2 == 0x1 (0x1) +char 0x5 >= 0x2 == 0x1 (0x1) +__uchar 0x5 >= 0x2 == 0x1 (0x1) +__longlong 0x5 >= 0x2 == 0x1 (0x1) +__ulonglong 0x5 >= 0x2 == 0x1 (0x1) +float 0x5 >= 0x2 == 0x1 (0x1) +int 0x5 / 0x2 == 0x2 (0x2) +__uint 0x5 / 0x2 == 0x2 (0x2) +char 0x5 / 0x2 == 0x2 (0x2) +__uchar 0x5 / 0x2 == 0x2 (0x2) +__longlong 0x5 / 0x2 == 0x2 (0x2) +__ulonglong 0x5 / 0x2 == 0x2 (0x2) +float 0x5 / 0x2 == 0x2 (0x2) +int 0x5 % 0x2 == 0x1 (0x1) +__uint 0x5 % 0x2 == 0x1 (0x1) +char 0x5 % 0x2 == 0x1 (0x1) +__uchar 0x5 % 0x2 == 0x1 (0x1) +__longlong 0x5 % 0x2 == 0x1 (0x1) +__ulonglong 0x5 % 0x2 == 0x1 (0x1) +0x5 * 0xfffe == -0xa +0x5 / 0xfffe == -0x2 +0x5 % 0xfffe == 0x1 +int 0x5 ^ 0xfffe == -0x5 (0xfffb) +__uint 0x5 ^ 0xfffe == -0x5 (0xfffb) +char 0x5 ^ 0xfffe == -0x5 (0xfffb) +__uchar 0x5 ^ 0xfe == 0xfb (0xfb) +__longlong 0x5 ^ 0xfffe == -0x5 (0xfffb) +__ulonglong 0x5 ^ 0xfffe == -0x5 (0xfffb) +int 0x5 && 0xfffe == 0x1 (0x1) +__uint 0x5 && 0xfffe == 0x1 (0x1) +char 0x5 && 0xfffe == 0x1 (0x1) +__uchar 0x5 && 0xfe == 0x1 (0x1) +__longlong 0x5 && 0xfffe == 0x1 (0x1) +__ulonglong 0x5 && 0xfffe == 0x1 (0x1) +int 0x5 || 0xfffe == 0x1 (0x1) +__uint 0x5 || 0xfffe == 0x1 (0x1) +char 0x5 || 0xfffe == 0x1 (0x1) +__uchar 0x5 || 0xfe == 0x1 (0x1) +__longlong 0x5 || 0xfffe == 0x1 (0x1) +__ulonglong 0x5 || 0xfffe == 0x1 (0x1) +int 0x5 & 0xfffe == 0x4 (0x4) +__uint 0x5 & 0xfffe == 0x4 (0x4) +char 0x5 & 0xfffe == 0x4 (0x4) +__uchar 0x5 & 0xfe == 0x4 (0x4) +__longlong 0x5 & 0xfffe == 0x4 (0x4) +__ulonglong 0x5 & 0xfffe == 0x4 (0x4) +int 0x5 | 0xfffe == -0x1 (0xffff) +__uint 0x5 | 0xfffe == -0x1 (0xffff) +char 0x5 | 0xfffe == -0x1 (0xffff) +__uchar 0x5 | 0xfe == 0xff (0xff) +__longlong 0x5 | 0xfffe == -0x1 (0xffff) +__ulonglong 0x5 | 0xfffe == -0x1 (0xffff) +int 0x5 << 0x4 == 0x50 (0x50) +__uint 0x5 << 0x4 == 0x50 (0x50) +char 0x5 << 0x4 == 0x50 (0x50) +__uchar 0x5 << 0x4 == 0x50 (0x50) +__longlong 0x5 << 0x4 == 0x50 (0x50) +__ulonglong 0x5 << 0x4 == 0x50 (0x50) +int 0x5 >> 0x4 == 0x0 (0x0) +__uint 0x5 >> 0x4 == 0x0 (0x0) +char 0x5 >> 0x4 == 0x0 (0x0) +__uchar 0x5 >> 0x4 == 0x0 (0x0) +__longlong 0x5 >> 0x4 == 0x0 (0x0) +__ulonglong 0x5 >> 0x4 == 0x0 (0x0) +int 0x5 + 0xfffe == 0x3 (0x3) +__uint 0x5 + 0xfffe == 0x3 (0x3) +char 0x5 + 0xfffe == 0x3 (0x3) +__uchar 0x5 + 0xfe == 0x3 (0x3) +__longlong 0x5 + 0xfffe == 0x3 (0x3) +__ulonglong 0x5 + 0xfffe == 0x3 (0x3) +float 0x5 + 0xfffe == 0x3 (0x3) +int 0x5 - 0xfffe == 0x7 (0x7) +__uint 0x5 - 0xfffe == 0x7 (0x7) +char 0x5 - 0xfffe == 0x7 (0x7) +__uchar 0x5 - 0xfe == 0x7 (0x7) +__longlong 0x5 - 0xfffe == 0x7 (0x7) +__ulonglong 0x5 - 0xfffe == 0x7 (0x7) +float 0x5 - 0xfffe == 0x7 (0x7) +int 0x5 * 0xfffe == -0xa (0xfff6) +__uint 0x5 * 0xfffe == -0xa (0xfff6) +char 0x5 * 0xfffe == -0xa (0xfff6) +__uchar 0x5 * 0xfe == 0xf6 (0xf6) +__longlong 0x5 * 0xfffe == -0xa (0xfff6) +__ulonglong 0x5 * 0xfffe == -0xa (0xfff6) +float 0x5 * 0xfffe == -0xa (0xfff6) +int 0x5 < 0xfffe == 0x0 (0x0) +__uint 0x5 < 0xfffe == 0x1 (0x1) +char 0x5 < 0xfffe == 0x0 (0x0) +__uchar 0x5 < 0xfe == 0x1 (0x1) +__longlong 0x5 < 0xfffe == 0x0 (0x0) +__ulonglong 0x5 < 0xfffe == 0x1 (0x1) +float 0x5 < 0xfffe == 0x0 (0x0) +int 0x5 > 0xfffe == 0x1 (0x1) +__uint 0x5 > 0xfffe == 0x0 (0x0) +char 0x5 > 0xfffe == 0x1 (0x1) +__uchar 0x5 > 0xfe == 0x0 (0x0) +__longlong 0x5 > 0xfffe == 0x1 (0x1) +__ulonglong 0x5 > 0xfffe == 0x0 (0x0) +float 0x5 > 0xfffe == 0x1 (0x1) +int 0x5 <= 0xfffe == 0x0 (0x0) +__uint 0x5 <= 0xfffe == 0x1 (0x1) +char 0x5 <= 0xfffe == 0x0 (0x0) +__uchar 0x5 <= 0xfe == 0x1 (0x1) +__longlong 0x5 <= 0xfffe == 0x0 (0x0) +__ulonglong 0x5 <= 0xfffe == 0x1 (0x1) +float 0x5 <= 0xfffe == 0x0 (0x0) +int 0x5 == 0xfffe == 0x0 (0x0) +__uint 0x5 == 0xfffe == 0x0 (0x0) +char 0x5 == 0xfffe == 0x0 (0x0) +__uchar 0x5 == 0xfe == 0x0 (0x0) +__longlong 0x5 == 0xfffe == 0x0 (0x0) +__ulonglong 0x5 == 0xfffe == 0x0 (0x0) +float 0x5 == 0xfffe == 0x0 (0x0) +int 0x5 != 0xfffe == 0x1 (0x1) +__uint 0x5 != 0xfffe == 0x1 (0x1) +char 0x5 != 0xfffe == 0x1 (0x1) +__uchar 0x5 != 0xfe == 0x1 (0x1) +__longlong 0x5 != 0xfffe == 0x1 (0x1) +__ulonglong 0x5 != 0xfffe == 0x1 (0x1) +float 0x5 != 0xfffe == 0x1 (0x1) +int 0x5 >= 0xfffe == 0x1 (0x1) +__uint 0x5 >= 0xfffe == 0x0 (0x0) +char 0x5 >= 0xfffe == 0x1 (0x1) +__uchar 0x5 >= 0xfe == 0x0 (0x0) +__longlong 0x5 >= 0xfffe == 0x1 (0x1) +__ulonglong 0x5 >= 0xfffe == 0x0 (0x0) +float 0x5 >= 0xfffe == 0x1 (0x1) +int 0x5 / 0xfffe == -0x2 (0xfffe) +__uint 0x5 / 0xfffe == 0x0 (0x0) +char 0x5 / 0xfffe == -0x2 (0xfffe) +__uchar 0x5 / 0xfe == 0x0 (0x0) +__longlong 0x5 / 0xfffe == -0x2 (0xfffe) +__ulonglong 0x5 / 0xfffe == 0x0 (0x0) +float 0x5 / 0xfffe == -0x2 (0xfffe) +int 0x5 % 0xfffe == 0x1 (0x1) +__uint 0x5 % 0xfffe == 0x5 (0x5) +char 0x5 % 0xfffe == 0x1 (0x1) +__uchar 0x5 % 0xfe == 0x5 (0x5) +__longlong 0x5 % 0xfffe == 0x1 (0x1) +__ulonglong 0x5 % 0xfffe == 0x5 (0x5) +0x5 * 0x4 == 0x14 +0x5 / 0x4 == 0x1 +0x5 % 0x4 == 0x1 +int 0x5 ^ 0x4 == 0x1 (0x1) +__uint 0x5 ^ 0x4 == 0x1 (0x1) +char 0x5 ^ 0x4 == 0x1 (0x1) +__uchar 0x5 ^ 0x4 == 0x1 (0x1) +__longlong 0x5 ^ 0x4 == 0x1 (0x1) +__ulonglong 0x5 ^ 0x4 == 0x1 (0x1) +int 0x5 && 0x4 == 0x1 (0x1) +__uint 0x5 && 0x4 == 0x1 (0x1) +char 0x5 && 0x4 == 0x1 (0x1) +__uchar 0x5 && 0x4 == 0x1 (0x1) +__longlong 0x5 && 0x4 == 0x1 (0x1) +__ulonglong 0x5 && 0x4 == 0x1 (0x1) +int 0x5 || 0x4 == 0x1 (0x1) +__uint 0x5 || 0x4 == 0x1 (0x1) +char 0x5 || 0x4 == 0x1 (0x1) +__uchar 0x5 || 0x4 == 0x1 (0x1) +__longlong 0x5 || 0x4 == 0x1 (0x1) +__ulonglong 0x5 || 0x4 == 0x1 (0x1) +int 0x5 & 0x4 == 0x4 (0x4) +__uint 0x5 & 0x4 == 0x4 (0x4) +char 0x5 & 0x4 == 0x4 (0x4) +__uchar 0x5 & 0x4 == 0x4 (0x4) +__longlong 0x5 & 0x4 == 0x4 (0x4) +__ulonglong 0x5 & 0x4 == 0x4 (0x4) +int 0x5 | 0x4 == 0x5 (0x5) +__uint 0x5 | 0x4 == 0x5 (0x5) +char 0x5 | 0x4 == 0x5 (0x5) +__uchar 0x5 | 0x4 == 0x5 (0x5) +__longlong 0x5 | 0x4 == 0x5 (0x5) +__ulonglong 0x5 | 0x4 == 0x5 (0x5) +int 0x5 << 0x5 == 0xa0 (0xa0) +__uint 0x5 << 0x5 == 0xa0 (0xa0) +char 0x5 << 0x5 == -0x60 (0xffa0) +__uchar 0x5 << 0x5 == 0xa0 (0xa0) +__longlong 0x5 << 0x5 == 0xa0 (0xa0) +__ulonglong 0x5 << 0x5 == 0xa0 (0xa0) +int 0x5 >> 0x5 == 0x0 (0x0) +__uint 0x5 >> 0x5 == 0x0 (0x0) +char 0x5 >> 0x5 == 0x0 (0x0) +__uchar 0x5 >> 0x5 == 0x0 (0x0) +__longlong 0x5 >> 0x5 == 0x0 (0x0) +__ulonglong 0x5 >> 0x5 == 0x0 (0x0) +int 0x5 + 0x4 == 0x9 (0x9) +__uint 0x5 + 0x4 == 0x9 (0x9) +char 0x5 + 0x4 == 0x9 (0x9) +__uchar 0x5 + 0x4 == 0x9 (0x9) +__longlong 0x5 + 0x4 == 0x9 (0x9) +__ulonglong 0x5 + 0x4 == 0x9 (0x9) +float 0x5 + 0x4 == 0x9 (0x9) +int 0x5 - 0x4 == 0x1 (0x1) +__uint 0x5 - 0x4 == 0x1 (0x1) +char 0x5 - 0x4 == 0x1 (0x1) +__uchar 0x5 - 0x4 == 0x1 (0x1) +__longlong 0x5 - 0x4 == 0x1 (0x1) +__ulonglong 0x5 - 0x4 == 0x1 (0x1) +float 0x5 - 0x4 == 0x1 (0x1) +int 0x5 * 0x4 == 0x14 (0x14) +__uint 0x5 * 0x4 == 0x14 (0x14) +char 0x5 * 0x4 == 0x14 (0x14) +__uchar 0x5 * 0x4 == 0x14 (0x14) +__longlong 0x5 * 0x4 == 0x14 (0x14) +__ulonglong 0x5 * 0x4 == 0x14 (0x14) +float 0x5 * 0x4 == 0x14 (0x14) +int 0x5 < 0x4 == 0x0 (0x0) +__uint 0x5 < 0x4 == 0x0 (0x0) +char 0x5 < 0x4 == 0x0 (0x0) +__uchar 0x5 < 0x4 == 0x0 (0x0) +__longlong 0x5 < 0x4 == 0x0 (0x0) +__ulonglong 0x5 < 0x4 == 0x0 (0x0) +float 0x5 < 0x4 == 0x0 (0x0) +int 0x5 > 0x4 == 0x1 (0x1) +__uint 0x5 > 0x4 == 0x1 (0x1) +char 0x5 > 0x4 == 0x1 (0x1) +__uchar 0x5 > 0x4 == 0x1 (0x1) +__longlong 0x5 > 0x4 == 0x1 (0x1) +__ulonglong 0x5 > 0x4 == 0x1 (0x1) +float 0x5 > 0x4 == 0x1 (0x1) +int 0x5 <= 0x4 == 0x0 (0x0) +__uint 0x5 <= 0x4 == 0x0 (0x0) +char 0x5 <= 0x4 == 0x0 (0x0) +__uchar 0x5 <= 0x4 == 0x0 (0x0) +__longlong 0x5 <= 0x4 == 0x0 (0x0) +__ulonglong 0x5 <= 0x4 == 0x0 (0x0) +float 0x5 <= 0x4 == 0x0 (0x0) +int 0x5 == 0x4 == 0x0 (0x0) +__uint 0x5 == 0x4 == 0x0 (0x0) +char 0x5 == 0x4 == 0x0 (0x0) +__uchar 0x5 == 0x4 == 0x0 (0x0) +__longlong 0x5 == 0x4 == 0x0 (0x0) +__ulonglong 0x5 == 0x4 == 0x0 (0x0) +float 0x5 == 0x4 == 0x0 (0x0) +int 0x5 != 0x4 == 0x1 (0x1) +__uint 0x5 != 0x4 == 0x1 (0x1) +char 0x5 != 0x4 == 0x1 (0x1) +__uchar 0x5 != 0x4 == 0x1 (0x1) +__longlong 0x5 != 0x4 == 0x1 (0x1) +__ulonglong 0x5 != 0x4 == 0x1 (0x1) +float 0x5 != 0x4 == 0x1 (0x1) +int 0x5 >= 0x4 == 0x1 (0x1) +__uint 0x5 >= 0x4 == 0x1 (0x1) +char 0x5 >= 0x4 == 0x1 (0x1) +__uchar 0x5 >= 0x4 == 0x1 (0x1) +__longlong 0x5 >= 0x4 == 0x1 (0x1) +__ulonglong 0x5 >= 0x4 == 0x1 (0x1) +float 0x5 >= 0x4 == 0x1 (0x1) +int 0x5 / 0x4 == 0x1 (0x1) +__uint 0x5 / 0x4 == 0x1 (0x1) +char 0x5 / 0x4 == 0x1 (0x1) +__uchar 0x5 / 0x4 == 0x1 (0x1) +__longlong 0x5 / 0x4 == 0x1 (0x1) +__ulonglong 0x5 / 0x4 == 0x1 (0x1) +float 0x5 / 0x4 == 0x1 (0x1) +int 0x5 % 0x4 == 0x1 (0x1) +__uint 0x5 % 0x4 == 0x1 (0x1) +char 0x5 % 0x4 == 0x1 (0x1) +__uchar 0x5 % 0x4 == 0x1 (0x1) +__longlong 0x5 % 0x4 == 0x1 (0x1) +__ulonglong 0x5 % 0x4 == 0x1 (0x1) +0x5 * 0xfffc == -0x14 +0x5 / 0xfffc == -0x1 +0x5 % 0xfffc == 0x1 +int 0x5 ^ 0xfffc == -0x7 (0xfff9) +__uint 0x5 ^ 0xfffc == -0x7 (0xfff9) +char 0x5 ^ 0xfffc == -0x7 (0xfff9) +__uchar 0x5 ^ 0xfc == 0xf9 (0xf9) +__longlong 0x5 ^ 0xfffc == -0x7 (0xfff9) +__ulonglong 0x5 ^ 0xfffc == -0x7 (0xfff9) +int 0x5 && 0xfffc == 0x1 (0x1) +__uint 0x5 && 0xfffc == 0x1 (0x1) +char 0x5 && 0xfffc == 0x1 (0x1) +__uchar 0x5 && 0xfc == 0x1 (0x1) +__longlong 0x5 && 0xfffc == 0x1 (0x1) +__ulonglong 0x5 && 0xfffc == 0x1 (0x1) +int 0x5 || 0xfffc == 0x1 (0x1) +__uint 0x5 || 0xfffc == 0x1 (0x1) +char 0x5 || 0xfffc == 0x1 (0x1) +__uchar 0x5 || 0xfc == 0x1 (0x1) +__longlong 0x5 || 0xfffc == 0x1 (0x1) +__ulonglong 0x5 || 0xfffc == 0x1 (0x1) +int 0x5 & 0xfffc == 0x4 (0x4) +__uint 0x5 & 0xfffc == 0x4 (0x4) +char 0x5 & 0xfffc == 0x4 (0x4) +__uchar 0x5 & 0xfc == 0x4 (0x4) +__longlong 0x5 & 0xfffc == 0x4 (0x4) +__ulonglong 0x5 & 0xfffc == 0x4 (0x4) +int 0x5 | 0xfffc == -0x3 (0xfffd) +__uint 0x5 | 0xfffc == -0x3 (0xfffd) +char 0x5 | 0xfffc == -0x3 (0xfffd) +__uchar 0x5 | 0xfc == 0xfd (0xfd) +__longlong 0x5 | 0xfffc == -0x3 (0xfffd) +__ulonglong 0x5 | 0xfffc == -0x3 (0xfffd) +int 0x5 << 0x6 == 0x140 (0x140) +__uint 0x5 << 0x6 == 0x140 (0x140) +char 0x5 << 0x6 == 0x40 (0x40) +__uchar 0x5 << 0x6 == 0x40 (0x40) +__longlong 0x5 << 0x6 == 0x140 (0x140) +__ulonglong 0x5 << 0x6 == 0x140 (0x140) +int 0x5 >> 0x6 == 0x0 (0x0) +__uint 0x5 >> 0x6 == 0x0 (0x0) +char 0x5 >> 0x6 == 0x0 (0x0) +__uchar 0x5 >> 0x6 == 0x0 (0x0) +__longlong 0x5 >> 0x6 == 0x0 (0x0) +__ulonglong 0x5 >> 0x6 == 0x0 (0x0) +int 0x5 + 0xfffc == 0x1 (0x1) +__uint 0x5 + 0xfffc == 0x1 (0x1) +char 0x5 + 0xfffc == 0x1 (0x1) +__uchar 0x5 + 0xfc == 0x1 (0x1) +__longlong 0x5 + 0xfffc == 0x1 (0x1) +__ulonglong 0x5 + 0xfffc == 0x1 (0x1) +float 0x5 + 0xfffc == 0x1 (0x1) +int 0x5 - 0xfffc == 0x9 (0x9) +__uint 0x5 - 0xfffc == 0x9 (0x9) +char 0x5 - 0xfffc == 0x9 (0x9) +__uchar 0x5 - 0xfc == 0x9 (0x9) +__longlong 0x5 - 0xfffc == 0x9 (0x9) +__ulonglong 0x5 - 0xfffc == 0x9 (0x9) +float 0x5 - 0xfffc == 0x9 (0x9) +int 0x5 * 0xfffc == -0x14 (0xffec) +__uint 0x5 * 0xfffc == -0x14 (0xffec) +char 0x5 * 0xfffc == -0x14 (0xffec) +__uchar 0x5 * 0xfc == 0xec (0xec) +__longlong 0x5 * 0xfffc == -0x14 (0xffec) +__ulonglong 0x5 * 0xfffc == -0x14 (0xffec) +float 0x5 * 0xfffc == -0x14 (0xffec) +int 0x5 < 0xfffc == 0x0 (0x0) +__uint 0x5 < 0xfffc == 0x1 (0x1) +char 0x5 < 0xfffc == 0x0 (0x0) +__uchar 0x5 < 0xfc == 0x1 (0x1) +__longlong 0x5 < 0xfffc == 0x0 (0x0) +__ulonglong 0x5 < 0xfffc == 0x1 (0x1) +float 0x5 < 0xfffc == 0x0 (0x0) +int 0x5 > 0xfffc == 0x1 (0x1) +__uint 0x5 > 0xfffc == 0x0 (0x0) +char 0x5 > 0xfffc == 0x1 (0x1) +__uchar 0x5 > 0xfc == 0x0 (0x0) +__longlong 0x5 > 0xfffc == 0x1 (0x1) +__ulonglong 0x5 > 0xfffc == 0x0 (0x0) +float 0x5 > 0xfffc == 0x1 (0x1) +int 0x5 <= 0xfffc == 0x0 (0x0) +__uint 0x5 <= 0xfffc == 0x1 (0x1) +char 0x5 <= 0xfffc == 0x0 (0x0) +__uchar 0x5 <= 0xfc == 0x1 (0x1) +__longlong 0x5 <= 0xfffc == 0x0 (0x0) +__ulonglong 0x5 <= 0xfffc == 0x1 (0x1) +float 0x5 <= 0xfffc == 0x0 (0x0) +int 0x5 == 0xfffc == 0x0 (0x0) +__uint 0x5 == 0xfffc == 0x0 (0x0) +char 0x5 == 0xfffc == 0x0 (0x0) +__uchar 0x5 == 0xfc == 0x0 (0x0) +__longlong 0x5 == 0xfffc == 0x0 (0x0) +__ulonglong 0x5 == 0xfffc == 0x0 (0x0) +float 0x5 == 0xfffc == 0x0 (0x0) +int 0x5 != 0xfffc == 0x1 (0x1) +__uint 0x5 != 0xfffc == 0x1 (0x1) +char 0x5 != 0xfffc == 0x1 (0x1) +__uchar 0x5 != 0xfc == 0x1 (0x1) +__longlong 0x5 != 0xfffc == 0x1 (0x1) +__ulonglong 0x5 != 0xfffc == 0x1 (0x1) +float 0x5 != 0xfffc == 0x1 (0x1) +int 0x5 >= 0xfffc == 0x1 (0x1) +__uint 0x5 >= 0xfffc == 0x0 (0x0) +char 0x5 >= 0xfffc == 0x1 (0x1) +__uchar 0x5 >= 0xfc == 0x0 (0x0) +__longlong 0x5 >= 0xfffc == 0x1 (0x1) +__ulonglong 0x5 >= 0xfffc == 0x0 (0x0) +float 0x5 >= 0xfffc == 0x1 (0x1) +int 0x5 / 0xfffc == -0x1 (0xffff) +__uint 0x5 / 0xfffc == 0x0 (0x0) +char 0x5 / 0xfffc == -0x1 (0xffff) +__uchar 0x5 / 0xfc == 0x0 (0x0) +__longlong 0x5 / 0xfffc == -0x1 (0xffff) +__ulonglong 0x5 / 0xfffc == 0x0 (0x0) +float 0x5 / 0xfffc == -0x1 (0xffff) +int 0x5 % 0xfffc == 0x1 (0x1) +__uint 0x5 % 0xfffc == 0x5 (0x5) +char 0x5 % 0xfffc == 0x1 (0x1) +__uchar 0x5 % 0xfc == 0x5 (0x5) +__longlong 0x5 % 0xfffc == 0x1 (0x1) +__ulonglong 0x5 % 0xfffc == 0x5 (0x5) +0x5 * 0xa == 0x32 +0x5 / 0xa == 0x0 +0x5 % 0xa == 0x5 +int 0x5 ^ 0xa == 0xf (0xf) +__uint 0x5 ^ 0xa == 0xf (0xf) +char 0x5 ^ 0xa == 0xf (0xf) +__uchar 0x5 ^ 0xa == 0xf (0xf) +__longlong 0x5 ^ 0xa == 0xf (0xf) +__ulonglong 0x5 ^ 0xa == 0xf (0xf) +int 0x5 && 0xa == 0x1 (0x1) +__uint 0x5 && 0xa == 0x1 (0x1) +char 0x5 && 0xa == 0x1 (0x1) +__uchar 0x5 && 0xa == 0x1 (0x1) +__longlong 0x5 && 0xa == 0x1 (0x1) +__ulonglong 0x5 && 0xa == 0x1 (0x1) +int 0x5 || 0xa == 0x1 (0x1) +__uint 0x5 || 0xa == 0x1 (0x1) +char 0x5 || 0xa == 0x1 (0x1) +__uchar 0x5 || 0xa == 0x1 (0x1) +__longlong 0x5 || 0xa == 0x1 (0x1) +__ulonglong 0x5 || 0xa == 0x1 (0x1) +int 0x5 & 0xa == 0x0 (0x0) +__uint 0x5 & 0xa == 0x0 (0x0) +char 0x5 & 0xa == 0x0 (0x0) +__uchar 0x5 & 0xa == 0x0 (0x0) +__longlong 0x5 & 0xa == 0x0 (0x0) +__ulonglong 0x5 & 0xa == 0x0 (0x0) +int 0x5 | 0xa == 0xf (0xf) +__uint 0x5 | 0xa == 0xf (0xf) +char 0x5 | 0xa == 0xf (0xf) +__uchar 0x5 | 0xa == 0xf (0xf) +__longlong 0x5 | 0xa == 0xf (0xf) +__ulonglong 0x5 | 0xa == 0xf (0xf) +int 0x5 << 0x7 == 0x280 (0x280) +__uint 0x5 << 0x7 == 0x280 (0x280) +char 0x5 << 0x7 == -0x80 (0xff80) +__uchar 0x5 << 0x7 == 0x80 (0x80) +__longlong 0x5 << 0x7 == 0x280 (0x280) +__ulonglong 0x5 << 0x7 == 0x280 (0x280) +int 0x5 >> 0x7 == 0x0 (0x0) +__uint 0x5 >> 0x7 == 0x0 (0x0) +char 0x5 >> 0x7 == 0x0 (0x0) +__uchar 0x5 >> 0x7 == 0x0 (0x0) +__longlong 0x5 >> 0x7 == 0x0 (0x0) +__ulonglong 0x5 >> 0x7 == 0x0 (0x0) +int 0x5 + 0xa == 0xf (0xf) +__uint 0x5 + 0xa == 0xf (0xf) +char 0x5 + 0xa == 0xf (0xf) +__uchar 0x5 + 0xa == 0xf (0xf) +__longlong 0x5 + 0xa == 0xf (0xf) +__ulonglong 0x5 + 0xa == 0xf (0xf) +float 0x5 + 0xa == 0xf (0xf) +int 0x5 - 0xa == -0x5 (0xfffb) +__uint 0x5 - 0xa == -0x5 (0xfffb) +char 0x5 - 0xa == -0x5 (0xfffb) +__uchar 0x5 - 0xa == 0xfb (0xfb) +__longlong 0x5 - 0xa == -0x5 (0xfffb) +__ulonglong 0x5 - 0xa == -0x5 (0xfffb) +float 0x5 - 0xa == -0x5 (0xfffb) +int 0x5 * 0xa == 0x32 (0x32) +__uint 0x5 * 0xa == 0x32 (0x32) +char 0x5 * 0xa == 0x32 (0x32) +__uchar 0x5 * 0xa == 0x32 (0x32) +__longlong 0x5 * 0xa == 0x32 (0x32) +__ulonglong 0x5 * 0xa == 0x32 (0x32) +float 0x5 * 0xa == 0x32 (0x32) +int 0x5 < 0xa == 0x1 (0x1) +__uint 0x5 < 0xa == 0x1 (0x1) +char 0x5 < 0xa == 0x1 (0x1) +__uchar 0x5 < 0xa == 0x1 (0x1) +__longlong 0x5 < 0xa == 0x1 (0x1) +__ulonglong 0x5 < 0xa == 0x1 (0x1) +float 0x5 < 0xa == 0x1 (0x1) +int 0x5 > 0xa == 0x0 (0x0) +__uint 0x5 > 0xa == 0x0 (0x0) +char 0x5 > 0xa == 0x0 (0x0) +__uchar 0x5 > 0xa == 0x0 (0x0) +__longlong 0x5 > 0xa == 0x0 (0x0) +__ulonglong 0x5 > 0xa == 0x0 (0x0) +float 0x5 > 0xa == 0x0 (0x0) +int 0x5 <= 0xa == 0x1 (0x1) +__uint 0x5 <= 0xa == 0x1 (0x1) +char 0x5 <= 0xa == 0x1 (0x1) +__uchar 0x5 <= 0xa == 0x1 (0x1) +__longlong 0x5 <= 0xa == 0x1 (0x1) +__ulonglong 0x5 <= 0xa == 0x1 (0x1) +float 0x5 <= 0xa == 0x1 (0x1) +int 0x5 == 0xa == 0x0 (0x0) +__uint 0x5 == 0xa == 0x0 (0x0) +char 0x5 == 0xa == 0x0 (0x0) +__uchar 0x5 == 0xa == 0x0 (0x0) +__longlong 0x5 == 0xa == 0x0 (0x0) +__ulonglong 0x5 == 0xa == 0x0 (0x0) +float 0x5 == 0xa == 0x0 (0x0) +int 0x5 != 0xa == 0x1 (0x1) +__uint 0x5 != 0xa == 0x1 (0x1) +char 0x5 != 0xa == 0x1 (0x1) +__uchar 0x5 != 0xa == 0x1 (0x1) +__longlong 0x5 != 0xa == 0x1 (0x1) +__ulonglong 0x5 != 0xa == 0x1 (0x1) +float 0x5 != 0xa == 0x1 (0x1) +int 0x5 >= 0xa == 0x0 (0x0) +__uint 0x5 >= 0xa == 0x0 (0x0) +char 0x5 >= 0xa == 0x0 (0x0) +__uchar 0x5 >= 0xa == 0x0 (0x0) +__longlong 0x5 >= 0xa == 0x0 (0x0) +__ulonglong 0x5 >= 0xa == 0x0 (0x0) +float 0x5 >= 0xa == 0x0 (0x0) +int 0x5 / 0xa == 0x0 (0x0) +__uint 0x5 / 0xa == 0x0 (0x0) +char 0x5 / 0xa == 0x0 (0x0) +__uchar 0x5 / 0xa == 0x0 (0x0) +__longlong 0x5 / 0xa == 0x0 (0x0) +__ulonglong 0x5 / 0xa == 0x0 (0x0) +float 0x5 / 0xa == 0x0 (0x0) +int 0x5 % 0xa == 0x5 (0x5) +__uint 0x5 % 0xa == 0x5 (0x5) +char 0x5 % 0xa == 0x5 (0x5) +__uchar 0x5 % 0xa == 0x5 (0x5) +__longlong 0x5 % 0xa == 0x5 (0x5) +__ulonglong 0x5 % 0xa == 0x5 (0x5) +0x5 * 0xfff6 == -0x32 +0x5 / 0xfff6 == 0x0 +0x5 % 0xfff6 == 0x5 +int 0x5 ^ 0xfff6 == -0xd (0xfff3) +__uint 0x5 ^ 0xfff6 == -0xd (0xfff3) +char 0x5 ^ 0xfff6 == -0xd (0xfff3) +__uchar 0x5 ^ 0xf6 == 0xf3 (0xf3) +__longlong 0x5 ^ 0xfff6 == -0xd (0xfff3) +__ulonglong 0x5 ^ 0xfff6 == -0xd (0xfff3) +int 0x5 && 0xfff6 == 0x1 (0x1) +__uint 0x5 && 0xfff6 == 0x1 (0x1) +char 0x5 && 0xfff6 == 0x1 (0x1) +__uchar 0x5 && 0xf6 == 0x1 (0x1) +__longlong 0x5 && 0xfff6 == 0x1 (0x1) +__ulonglong 0x5 && 0xfff6 == 0x1 (0x1) +int 0x5 || 0xfff6 == 0x1 (0x1) +__uint 0x5 || 0xfff6 == 0x1 (0x1) +char 0x5 || 0xfff6 == 0x1 (0x1) +__uchar 0x5 || 0xf6 == 0x1 (0x1) +__longlong 0x5 || 0xfff6 == 0x1 (0x1) +__ulonglong 0x5 || 0xfff6 == 0x1 (0x1) +int 0x5 & 0xfff6 == 0x4 (0x4) +__uint 0x5 & 0xfff6 == 0x4 (0x4) +char 0x5 & 0xfff6 == 0x4 (0x4) +__uchar 0x5 & 0xf6 == 0x4 (0x4) +__longlong 0x5 & 0xfff6 == 0x4 (0x4) +__ulonglong 0x5 & 0xfff6 == 0x4 (0x4) +int 0x5 | 0xfff6 == -0x9 (0xfff7) +__uint 0x5 | 0xfff6 == -0x9 (0xfff7) +char 0x5 | 0xfff6 == -0x9 (0xfff7) +__uchar 0x5 | 0xf6 == 0xf7 (0xf7) +__longlong 0x5 | 0xfff6 == -0x9 (0xfff7) +__ulonglong 0x5 | 0xfff6 == -0x9 (0xfff7) +int 0x5 << 0x8 == 0x500 (0x500) +__uint 0x5 << 0x8 == 0x500 (0x500) +char 0x5 << 0x8 == 0x0 (0x0) +__uchar 0x5 << 0x8 == 0x0 (0x0) +__longlong 0x5 << 0x8 == 0x500 (0x500) +__ulonglong 0x5 << 0x8 == 0x500 (0x500) +int 0x5 >> 0x8 == 0x0 (0x0) +__uint 0x5 >> 0x8 == 0x0 (0x0) +char 0x5 >> 0x8 == 0x0 (0x0) +__uchar 0x5 >> 0x8 == 0x0 (0x0) +__longlong 0x5 >> 0x8 == 0x0 (0x0) +__ulonglong 0x5 >> 0x8 == 0x0 (0x0) +int 0x5 + 0xfff6 == -0x5 (0xfffb) +__uint 0x5 + 0xfff6 == -0x5 (0xfffb) +char 0x5 + 0xfff6 == -0x5 (0xfffb) +__uchar 0x5 + 0xf6 == 0xfb (0xfb) +__longlong 0x5 + 0xfff6 == -0x5 (0xfffb) +__ulonglong 0x5 + 0xfff6 == -0x5 (0xfffb) +float 0x5 + 0xfff6 == -0x5 (0xfffb) +int 0x5 - 0xfff6 == 0xf (0xf) +__uint 0x5 - 0xfff6 == 0xf (0xf) +char 0x5 - 0xfff6 == 0xf (0xf) +__uchar 0x5 - 0xf6 == 0xf (0xf) +__longlong 0x5 - 0xfff6 == 0xf (0xf) +__ulonglong 0x5 - 0xfff6 == 0xf (0xf) +float 0x5 - 0xfff6 == 0xf (0xf) +int 0x5 * 0xfff6 == -0x32 (0xffce) +__uint 0x5 * 0xfff6 == -0x32 (0xffce) +char 0x5 * 0xfff6 == -0x32 (0xffce) +__uchar 0x5 * 0xf6 == 0xce (0xce) +__longlong 0x5 * 0xfff6 == -0x32 (0xffce) +__ulonglong 0x5 * 0xfff6 == -0x32 (0xffce) +float 0x5 * 0xfff6 == -0x32 (0xffce) +int 0x5 < 0xfff6 == 0x0 (0x0) +__uint 0x5 < 0xfff6 == 0x1 (0x1) +char 0x5 < 0xfff6 == 0x0 (0x0) +__uchar 0x5 < 0xf6 == 0x1 (0x1) +__longlong 0x5 < 0xfff6 == 0x0 (0x0) +__ulonglong 0x5 < 0xfff6 == 0x1 (0x1) +float 0x5 < 0xfff6 == 0x0 (0x0) +int 0x5 > 0xfff6 == 0x1 (0x1) +__uint 0x5 > 0xfff6 == 0x0 (0x0) +char 0x5 > 0xfff6 == 0x1 (0x1) +__uchar 0x5 > 0xf6 == 0x0 (0x0) +__longlong 0x5 > 0xfff6 == 0x1 (0x1) +__ulonglong 0x5 > 0xfff6 == 0x0 (0x0) +float 0x5 > 0xfff6 == 0x1 (0x1) +int 0x5 <= 0xfff6 == 0x0 (0x0) +__uint 0x5 <= 0xfff6 == 0x1 (0x1) +char 0x5 <= 0xfff6 == 0x0 (0x0) +__uchar 0x5 <= 0xf6 == 0x1 (0x1) +__longlong 0x5 <= 0xfff6 == 0x0 (0x0) +__ulonglong 0x5 <= 0xfff6 == 0x1 (0x1) +float 0x5 <= 0xfff6 == 0x0 (0x0) +int 0x5 == 0xfff6 == 0x0 (0x0) +__uint 0x5 == 0xfff6 == 0x0 (0x0) +char 0x5 == 0xfff6 == 0x0 (0x0) +__uchar 0x5 == 0xf6 == 0x0 (0x0) +__longlong 0x5 == 0xfff6 == 0x0 (0x0) +__ulonglong 0x5 == 0xfff6 == 0x0 (0x0) +float 0x5 == 0xfff6 == 0x0 (0x0) +int 0x5 != 0xfff6 == 0x1 (0x1) +__uint 0x5 != 0xfff6 == 0x1 (0x1) +char 0x5 != 0xfff6 == 0x1 (0x1) +__uchar 0x5 != 0xf6 == 0x1 (0x1) +__longlong 0x5 != 0xfff6 == 0x1 (0x1) +__ulonglong 0x5 != 0xfff6 == 0x1 (0x1) +float 0x5 != 0xfff6 == 0x1 (0x1) +int 0x5 >= 0xfff6 == 0x1 (0x1) +__uint 0x5 >= 0xfff6 == 0x0 (0x0) +char 0x5 >= 0xfff6 == 0x1 (0x1) +__uchar 0x5 >= 0xf6 == 0x0 (0x0) +__longlong 0x5 >= 0xfff6 == 0x1 (0x1) +__ulonglong 0x5 >= 0xfff6 == 0x0 (0x0) +float 0x5 >= 0xfff6 == 0x1 (0x1) +int 0x5 / 0xfff6 == 0x0 (0x0) +__uint 0x5 / 0xfff6 == 0x0 (0x0) +char 0x5 / 0xfff6 == 0x0 (0x0) +__uchar 0x5 / 0xf6 == 0x0 (0x0) +__longlong 0x5 / 0xfff6 == 0x0 (0x0) +__ulonglong 0x5 / 0xfff6 == 0x0 (0x0) +float 0x5 / 0xfff6 == 0x0 (0x0) +int 0x5 % 0xfff6 == 0x5 (0x5) +__uint 0x5 % 0xfff6 == 0x5 (0x5) +char 0x5 % 0xfff6 == 0x5 (0x5) +__uchar 0x5 % 0xf6 == 0x5 (0x5) +__longlong 0x5 % 0xfff6 == 0x5 (0x5) +__ulonglong 0x5 % 0xfff6 == 0x5 (0x5) +0x5 * 0x5 == 0x19 +0x5 / 0x5 == 0x1 +0x5 % 0x5 == 0x0 +int 0x5 ^ 0x5 == 0x0 (0x0) +__uint 0x5 ^ 0x5 == 0x0 (0x0) +char 0x5 ^ 0x5 == 0x0 (0x0) +__uchar 0x5 ^ 0x5 == 0x0 (0x0) +__longlong 0x5 ^ 0x5 == 0x0 (0x0) +__ulonglong 0x5 ^ 0x5 == 0x0 (0x0) +int 0x5 && 0x5 == 0x1 (0x1) +__uint 0x5 && 0x5 == 0x1 (0x1) +char 0x5 && 0x5 == 0x1 (0x1) +__uchar 0x5 && 0x5 == 0x1 (0x1) +__longlong 0x5 && 0x5 == 0x1 (0x1) +__ulonglong 0x5 && 0x5 == 0x1 (0x1) +int 0x5 || 0x5 == 0x1 (0x1) +__uint 0x5 || 0x5 == 0x1 (0x1) +char 0x5 || 0x5 == 0x1 (0x1) +__uchar 0x5 || 0x5 == 0x1 (0x1) +__longlong 0x5 || 0x5 == 0x1 (0x1) +__ulonglong 0x5 || 0x5 == 0x1 (0x1) +int 0x5 & 0x5 == 0x5 (0x5) +__uint 0x5 & 0x5 == 0x5 (0x5) +char 0x5 & 0x5 == 0x5 (0x5) +__uchar 0x5 & 0x5 == 0x5 (0x5) +__longlong 0x5 & 0x5 == 0x5 (0x5) +__ulonglong 0x5 & 0x5 == 0x5 (0x5) +int 0x5 | 0x5 == 0x5 (0x5) +__uint 0x5 | 0x5 == 0x5 (0x5) +char 0x5 | 0x5 == 0x5 (0x5) +__uchar 0x5 | 0x5 == 0x5 (0x5) +__longlong 0x5 | 0x5 == 0x5 (0x5) +__ulonglong 0x5 | 0x5 == 0x5 (0x5) +int 0x5 << 0x9 == 0xa00 (0xa00) +__uint 0x5 << 0x9 == 0xa00 (0xa00) +char 0x5 << 0x9 == 0x0 (0x0) +__uchar 0x5 << 0x9 == 0x0 (0x0) +__longlong 0x5 << 0x9 == 0xa00 (0xa00) +__ulonglong 0x5 << 0x9 == 0xa00 (0xa00) +int 0x5 >> 0x9 == 0x0 (0x0) +__uint 0x5 >> 0x9 == 0x0 (0x0) +char 0x5 >> 0x9 == 0x0 (0x0) +__uchar 0x5 >> 0x9 == 0x0 (0x0) +__longlong 0x5 >> 0x9 == 0x0 (0x0) +__ulonglong 0x5 >> 0x9 == 0x0 (0x0) +int 0x5 + 0x5 == 0xa (0xa) +__uint 0x5 + 0x5 == 0xa (0xa) +char 0x5 + 0x5 == 0xa (0xa) +__uchar 0x5 + 0x5 == 0xa (0xa) +__longlong 0x5 + 0x5 == 0xa (0xa) +__ulonglong 0x5 + 0x5 == 0xa (0xa) +float 0x5 + 0x5 == 0xa (0xa) +int 0x5 - 0x5 == 0x0 (0x0) +__uint 0x5 - 0x5 == 0x0 (0x0) +char 0x5 - 0x5 == 0x0 (0x0) +__uchar 0x5 - 0x5 == 0x0 (0x0) +__longlong 0x5 - 0x5 == 0x0 (0x0) +__ulonglong 0x5 - 0x5 == 0x0 (0x0) +float 0x5 - 0x5 == 0x0 (0x0) +int 0x5 * 0x5 == 0x19 (0x19) +__uint 0x5 * 0x5 == 0x19 (0x19) +char 0x5 * 0x5 == 0x19 (0x19) +__uchar 0x5 * 0x5 == 0x19 (0x19) +__longlong 0x5 * 0x5 == 0x19 (0x19) +__ulonglong 0x5 * 0x5 == 0x19 (0x19) +float 0x5 * 0x5 == 0x19 (0x19) +int 0x5 < 0x5 == 0x0 (0x0) +__uint 0x5 < 0x5 == 0x0 (0x0) +char 0x5 < 0x5 == 0x0 (0x0) +__uchar 0x5 < 0x5 == 0x0 (0x0) +__longlong 0x5 < 0x5 == 0x0 (0x0) +__ulonglong 0x5 < 0x5 == 0x0 (0x0) +float 0x5 < 0x5 == 0x0 (0x0) +int 0x5 > 0x5 == 0x0 (0x0) +__uint 0x5 > 0x5 == 0x0 (0x0) +char 0x5 > 0x5 == 0x0 (0x0) +__uchar 0x5 > 0x5 == 0x0 (0x0) +__longlong 0x5 > 0x5 == 0x0 (0x0) +__ulonglong 0x5 > 0x5 == 0x0 (0x0) +float 0x5 > 0x5 == 0x0 (0x0) +int 0x5 <= 0x5 == 0x1 (0x1) +__uint 0x5 <= 0x5 == 0x1 (0x1) +char 0x5 <= 0x5 == 0x1 (0x1) +__uchar 0x5 <= 0x5 == 0x1 (0x1) +__longlong 0x5 <= 0x5 == 0x1 (0x1) +__ulonglong 0x5 <= 0x5 == 0x1 (0x1) +float 0x5 <= 0x5 == 0x1 (0x1) +int 0x5 == 0x5 == 0x1 (0x1) +__uint 0x5 == 0x5 == 0x1 (0x1) +char 0x5 == 0x5 == 0x1 (0x1) +__uchar 0x5 == 0x5 == 0x1 (0x1) +__longlong 0x5 == 0x5 == 0x1 (0x1) +__ulonglong 0x5 == 0x5 == 0x1 (0x1) +float 0x5 == 0x5 == 0x1 (0x1) +int 0x5 != 0x5 == 0x0 (0x0) +__uint 0x5 != 0x5 == 0x0 (0x0) +char 0x5 != 0x5 == 0x0 (0x0) +__uchar 0x5 != 0x5 == 0x0 (0x0) +__longlong 0x5 != 0x5 == 0x0 (0x0) +__ulonglong 0x5 != 0x5 == 0x0 (0x0) +float 0x5 != 0x5 == 0x0 (0x0) +int 0x5 >= 0x5 == 0x1 (0x1) +__uint 0x5 >= 0x5 == 0x1 (0x1) +char 0x5 >= 0x5 == 0x1 (0x1) +__uchar 0x5 >= 0x5 == 0x1 (0x1) +__longlong 0x5 >= 0x5 == 0x1 (0x1) +__ulonglong 0x5 >= 0x5 == 0x1 (0x1) +float 0x5 >= 0x5 == 0x1 (0x1) +int 0x5 / 0x5 == 0x1 (0x1) +__uint 0x5 / 0x5 == 0x1 (0x1) +char 0x5 / 0x5 == 0x1 (0x1) +__uchar 0x5 / 0x5 == 0x1 (0x1) +__longlong 0x5 / 0x5 == 0x1 (0x1) +__ulonglong 0x5 / 0x5 == 0x1 (0x1) +float 0x5 / 0x5 == 0x1 (0x1) +int 0x5 % 0x5 == 0x0 (0x0) +__uint 0x5 % 0x5 == 0x0 (0x0) +char 0x5 % 0x5 == 0x0 (0x0) +__uchar 0x5 % 0x5 == 0x0 (0x0) +__longlong 0x5 % 0x5 == 0x0 (0x0) +__ulonglong 0x5 % 0x5 == 0x0 (0x0) +0x5 * 0x7 == 0x23 +0x5 / 0x7 == 0x0 +0x5 % 0x7 == 0x5 +int 0x5 ^ 0x7 == 0x2 (0x2) +__uint 0x5 ^ 0x7 == 0x2 (0x2) +char 0x5 ^ 0x7 == 0x2 (0x2) +__uchar 0x5 ^ 0x7 == 0x2 (0x2) +__longlong 0x5 ^ 0x7 == 0x2 (0x2) +__ulonglong 0x5 ^ 0x7 == 0x2 (0x2) +int 0x5 && 0x7 == 0x1 (0x1) +__uint 0x5 && 0x7 == 0x1 (0x1) +char 0x5 && 0x7 == 0x1 (0x1) +__uchar 0x5 && 0x7 == 0x1 (0x1) +__longlong 0x5 && 0x7 == 0x1 (0x1) +__ulonglong 0x5 && 0x7 == 0x1 (0x1) +int 0x5 || 0x7 == 0x1 (0x1) +__uint 0x5 || 0x7 == 0x1 (0x1) +char 0x5 || 0x7 == 0x1 (0x1) +__uchar 0x5 || 0x7 == 0x1 (0x1) +__longlong 0x5 || 0x7 == 0x1 (0x1) +__ulonglong 0x5 || 0x7 == 0x1 (0x1) +int 0x5 & 0x7 == 0x5 (0x5) +__uint 0x5 & 0x7 == 0x5 (0x5) +char 0x5 & 0x7 == 0x5 (0x5) +__uchar 0x5 & 0x7 == 0x5 (0x5) +__longlong 0x5 & 0x7 == 0x5 (0x5) +__ulonglong 0x5 & 0x7 == 0x5 (0x5) +int 0x5 | 0x7 == 0x7 (0x7) +__uint 0x5 | 0x7 == 0x7 (0x7) +char 0x5 | 0x7 == 0x7 (0x7) +__uchar 0x5 | 0x7 == 0x7 (0x7) +__longlong 0x5 | 0x7 == 0x7 (0x7) +__ulonglong 0x5 | 0x7 == 0x7 (0x7) +int 0x5 << 0xa == 0x1400 (0x1400) +__uint 0x5 << 0xa == 0x1400 (0x1400) +char 0x5 << 0xa == 0x0 (0x0) +__uchar 0x5 << 0xa == 0x0 (0x0) +__longlong 0x5 << 0xa == 0x1400 (0x1400) +__ulonglong 0x5 << 0xa == 0x1400 (0x1400) +int 0x5 >> 0xa == 0x0 (0x0) +__uint 0x5 >> 0xa == 0x0 (0x0) +char 0x5 >> 0xa == 0x0 (0x0) +__uchar 0x5 >> 0xa == 0x0 (0x0) +__longlong 0x5 >> 0xa == 0x0 (0x0) +__ulonglong 0x5 >> 0xa == 0x0 (0x0) +int 0x5 + 0x7 == 0xc (0xc) +__uint 0x5 + 0x7 == 0xc (0xc) +char 0x5 + 0x7 == 0xc (0xc) +__uchar 0x5 + 0x7 == 0xc (0xc) +__longlong 0x5 + 0x7 == 0xc (0xc) +__ulonglong 0x5 + 0x7 == 0xc (0xc) +float 0x5 + 0x7 == 0xc (0xc) +int 0x5 - 0x7 == -0x2 (0xfffe) +__uint 0x5 - 0x7 == -0x2 (0xfffe) +char 0x5 - 0x7 == -0x2 (0xfffe) +__uchar 0x5 - 0x7 == 0xfe (0xfe) +__longlong 0x5 - 0x7 == -0x2 (0xfffe) +__ulonglong 0x5 - 0x7 == -0x2 (0xfffe) +float 0x5 - 0x7 == -0x2 (0xfffe) +int 0x5 * 0x7 == 0x23 (0x23) +__uint 0x5 * 0x7 == 0x23 (0x23) +char 0x5 * 0x7 == 0x23 (0x23) +__uchar 0x5 * 0x7 == 0x23 (0x23) +__longlong 0x5 * 0x7 == 0x23 (0x23) +__ulonglong 0x5 * 0x7 == 0x23 (0x23) +float 0x5 * 0x7 == 0x23 (0x23) +int 0x5 < 0x7 == 0x1 (0x1) +__uint 0x5 < 0x7 == 0x1 (0x1) +char 0x5 < 0x7 == 0x1 (0x1) +__uchar 0x5 < 0x7 == 0x1 (0x1) +__longlong 0x5 < 0x7 == 0x1 (0x1) +__ulonglong 0x5 < 0x7 == 0x1 (0x1) +float 0x5 < 0x7 == 0x1 (0x1) +int 0x5 > 0x7 == 0x0 (0x0) +__uint 0x5 > 0x7 == 0x0 (0x0) +char 0x5 > 0x7 == 0x0 (0x0) +__uchar 0x5 > 0x7 == 0x0 (0x0) +__longlong 0x5 > 0x7 == 0x0 (0x0) +__ulonglong 0x5 > 0x7 == 0x0 (0x0) +float 0x5 > 0x7 == 0x0 (0x0) +int 0x5 <= 0x7 == 0x1 (0x1) +__uint 0x5 <= 0x7 == 0x1 (0x1) +char 0x5 <= 0x7 == 0x1 (0x1) +__uchar 0x5 <= 0x7 == 0x1 (0x1) +__longlong 0x5 <= 0x7 == 0x1 (0x1) +__ulonglong 0x5 <= 0x7 == 0x1 (0x1) +float 0x5 <= 0x7 == 0x1 (0x1) +int 0x5 == 0x7 == 0x0 (0x0) +__uint 0x5 == 0x7 == 0x0 (0x0) +char 0x5 == 0x7 == 0x0 (0x0) +__uchar 0x5 == 0x7 == 0x0 (0x0) +__longlong 0x5 == 0x7 == 0x0 (0x0) +__ulonglong 0x5 == 0x7 == 0x0 (0x0) +float 0x5 == 0x7 == 0x0 (0x0) +int 0x5 != 0x7 == 0x1 (0x1) +__uint 0x5 != 0x7 == 0x1 (0x1) +char 0x5 != 0x7 == 0x1 (0x1) +__uchar 0x5 != 0x7 == 0x1 (0x1) +__longlong 0x5 != 0x7 == 0x1 (0x1) +__ulonglong 0x5 != 0x7 == 0x1 (0x1) +float 0x5 != 0x7 == 0x1 (0x1) +int 0x5 >= 0x7 == 0x0 (0x0) +__uint 0x5 >= 0x7 == 0x0 (0x0) +char 0x5 >= 0x7 == 0x0 (0x0) +__uchar 0x5 >= 0x7 == 0x0 (0x0) +__longlong 0x5 >= 0x7 == 0x0 (0x0) +__ulonglong 0x5 >= 0x7 == 0x0 (0x0) +float 0x5 >= 0x7 == 0x0 (0x0) +int 0x5 / 0x7 == 0x0 (0x0) +__uint 0x5 / 0x7 == 0x0 (0x0) +char 0x5 / 0x7 == 0x0 (0x0) +__uchar 0x5 / 0x7 == 0x0 (0x0) +__longlong 0x5 / 0x7 == 0x0 (0x0) +__ulonglong 0x5 / 0x7 == 0x0 (0x0) +float 0x5 / 0x7 == 0x0 (0x0) +int 0x5 % 0x7 == 0x5 (0x5) +__uint 0x5 % 0x7 == 0x5 (0x5) +char 0x5 % 0x7 == 0x5 (0x5) +__uchar 0x5 % 0x7 == 0x5 (0x5) +__longlong 0x5 % 0x7 == 0x5 (0x5) +__ulonglong 0x5 % 0x7 == 0x5 (0x5) +0x5 * 0x2a == 0xd2 +0x5 / 0x2a == 0x0 +0x5 % 0x2a == 0x5 +int 0x5 ^ 0x2a == 0x2f (0x2f) +__uint 0x5 ^ 0x2a == 0x2f (0x2f) +char 0x5 ^ 0x2a == 0x2f (0x2f) +__uchar 0x5 ^ 0x2a == 0x2f (0x2f) +__longlong 0x5 ^ 0x2a == 0x2f (0x2f) +__ulonglong 0x5 ^ 0x2a == 0x2f (0x2f) +int 0x5 && 0x2a == 0x1 (0x1) +__uint 0x5 && 0x2a == 0x1 (0x1) +char 0x5 && 0x2a == 0x1 (0x1) +__uchar 0x5 && 0x2a == 0x1 (0x1) +__longlong 0x5 && 0x2a == 0x1 (0x1) +__ulonglong 0x5 && 0x2a == 0x1 (0x1) +int 0x5 || 0x2a == 0x1 (0x1) +__uint 0x5 || 0x2a == 0x1 (0x1) +char 0x5 || 0x2a == 0x1 (0x1) +__uchar 0x5 || 0x2a == 0x1 (0x1) +__longlong 0x5 || 0x2a == 0x1 (0x1) +__ulonglong 0x5 || 0x2a == 0x1 (0x1) +int 0x5 & 0x2a == 0x0 (0x0) +__uint 0x5 & 0x2a == 0x0 (0x0) +char 0x5 & 0x2a == 0x0 (0x0) +__uchar 0x5 & 0x2a == 0x0 (0x0) +__longlong 0x5 & 0x2a == 0x0 (0x0) +__ulonglong 0x5 & 0x2a == 0x0 (0x0) +int 0x5 | 0x2a == 0x2f (0x2f) +__uint 0x5 | 0x2a == 0x2f (0x2f) +char 0x5 | 0x2a == 0x2f (0x2f) +__uchar 0x5 | 0x2a == 0x2f (0x2f) +__longlong 0x5 | 0x2a == 0x2f (0x2f) +__ulonglong 0x5 | 0x2a == 0x2f (0x2f) +int 0x5 << 0xc == 0x5000 (0x5000) +__uint 0x5 << 0xc == 0x5000 (0x5000) +char 0x5 << 0xc == 0x0 (0x0) +__uchar 0x5 << 0xc == 0x0 (0x0) +__longlong 0x5 << 0xc == 0x5000 (0x5000) +__ulonglong 0x5 << 0xc == 0x5000 (0x5000) +int 0x5 >> 0xc == 0x0 (0x0) +__uint 0x5 >> 0xc == 0x0 (0x0) +char 0x5 >> 0xc == 0x0 (0x0) +__uchar 0x5 >> 0xc == 0x0 (0x0) +__longlong 0x5 >> 0xc == 0x0 (0x0) +__ulonglong 0x5 >> 0xc == 0x0 (0x0) +int 0x5 + 0x2a == 0x2f (0x2f) +__uint 0x5 + 0x2a == 0x2f (0x2f) +char 0x5 + 0x2a == 0x2f (0x2f) +__uchar 0x5 + 0x2a == 0x2f (0x2f) +__longlong 0x5 + 0x2a == 0x2f (0x2f) +__ulonglong 0x5 + 0x2a == 0x2f (0x2f) +float 0x5 + 0x2a == 0x2f (0x2f) +int 0x5 - 0x2a == -0x25 (0xffdb) +__uint 0x5 - 0x2a == -0x25 (0xffdb) +char 0x5 - 0x2a == -0x25 (0xffdb) +__uchar 0x5 - 0x2a == 0xdb (0xdb) +__longlong 0x5 - 0x2a == -0x25 (0xffdb) +__ulonglong 0x5 - 0x2a == -0x25 (0xffdb) +float 0x5 - 0x2a == -0x25 (0xffdb) +int 0x5 * 0x2a == 0xd2 (0xd2) +__uint 0x5 * 0x2a == 0xd2 (0xd2) +char 0x5 * 0x2a == -0x2e (0xffd2) +__uchar 0x5 * 0x2a == 0xd2 (0xd2) +__longlong 0x5 * 0x2a == 0xd2 (0xd2) +__ulonglong 0x5 * 0x2a == 0xd2 (0xd2) +float 0x5 * 0x2a == 0xd2 (0xd2) +int 0x5 < 0x2a == 0x1 (0x1) +__uint 0x5 < 0x2a == 0x1 (0x1) +char 0x5 < 0x2a == 0x1 (0x1) +__uchar 0x5 < 0x2a == 0x1 (0x1) +__longlong 0x5 < 0x2a == 0x1 (0x1) +__ulonglong 0x5 < 0x2a == 0x1 (0x1) +float 0x5 < 0x2a == 0x1 (0x1) +int 0x5 > 0x2a == 0x0 (0x0) +__uint 0x5 > 0x2a == 0x0 (0x0) +char 0x5 > 0x2a == 0x0 (0x0) +__uchar 0x5 > 0x2a == 0x0 (0x0) +__longlong 0x5 > 0x2a == 0x0 (0x0) +__ulonglong 0x5 > 0x2a == 0x0 (0x0) +float 0x5 > 0x2a == 0x0 (0x0) +int 0x5 <= 0x2a == 0x1 (0x1) +__uint 0x5 <= 0x2a == 0x1 (0x1) +char 0x5 <= 0x2a == 0x1 (0x1) +__uchar 0x5 <= 0x2a == 0x1 (0x1) +__longlong 0x5 <= 0x2a == 0x1 (0x1) +__ulonglong 0x5 <= 0x2a == 0x1 (0x1) +float 0x5 <= 0x2a == 0x1 (0x1) +int 0x5 == 0x2a == 0x0 (0x0) +__uint 0x5 == 0x2a == 0x0 (0x0) +char 0x5 == 0x2a == 0x0 (0x0) +__uchar 0x5 == 0x2a == 0x0 (0x0) +__longlong 0x5 == 0x2a == 0x0 (0x0) +__ulonglong 0x5 == 0x2a == 0x0 (0x0) +float 0x5 == 0x2a == 0x0 (0x0) +int 0x5 != 0x2a == 0x1 (0x1) +__uint 0x5 != 0x2a == 0x1 (0x1) +char 0x5 != 0x2a == 0x1 (0x1) +__uchar 0x5 != 0x2a == 0x1 (0x1) +__longlong 0x5 != 0x2a == 0x1 (0x1) +__ulonglong 0x5 != 0x2a == 0x1 (0x1) +float 0x5 != 0x2a == 0x1 (0x1) +int 0x5 >= 0x2a == 0x0 (0x0) +__uint 0x5 >= 0x2a == 0x0 (0x0) +char 0x5 >= 0x2a == 0x0 (0x0) +__uchar 0x5 >= 0x2a == 0x0 (0x0) +__longlong 0x5 >= 0x2a == 0x0 (0x0) +__ulonglong 0x5 >= 0x2a == 0x0 (0x0) +float 0x5 >= 0x2a == 0x0 (0x0) +int 0x5 / 0x2a == 0x0 (0x0) +__uint 0x5 / 0x2a == 0x0 (0x0) +char 0x5 / 0x2a == 0x0 (0x0) +__uchar 0x5 / 0x2a == 0x0 (0x0) +__longlong 0x5 / 0x2a == 0x0 (0x0) +__ulonglong 0x5 / 0x2a == 0x0 (0x0) +float 0x5 / 0x2a == 0x0 (0x0) +int 0x5 % 0x2a == 0x5 (0x5) +__uint 0x5 % 0x2a == 0x5 (0x5) +char 0x5 % 0x2a == 0x5 (0x5) +__uchar 0x5 % 0x2a == 0x5 (0x5) +__longlong 0x5 % 0x2a == 0x5 (0x5) +__ulonglong 0x5 % 0x2a == 0x5 (0x5) +0x5 * 0x17 == 0x73 +0x5 / 0x17 == 0x0 +0x5 % 0x17 == 0x5 +int 0x5 ^ 0x17 == 0x12 (0x12) +__uint 0x5 ^ 0x17 == 0x12 (0x12) +char 0x5 ^ 0x17 == 0x12 (0x12) +__uchar 0x5 ^ 0x17 == 0x12 (0x12) +__longlong 0x5 ^ 0x17 == 0x12 (0x12) +__ulonglong 0x5 ^ 0x17 == 0x12 (0x12) +int 0x5 && 0x17 == 0x1 (0x1) +__uint 0x5 && 0x17 == 0x1 (0x1) +char 0x5 && 0x17 == 0x1 (0x1) +__uchar 0x5 && 0x17 == 0x1 (0x1) +__longlong 0x5 && 0x17 == 0x1 (0x1) +__ulonglong 0x5 && 0x17 == 0x1 (0x1) +int 0x5 || 0x17 == 0x1 (0x1) +__uint 0x5 || 0x17 == 0x1 (0x1) +char 0x5 || 0x17 == 0x1 (0x1) +__uchar 0x5 || 0x17 == 0x1 (0x1) +__longlong 0x5 || 0x17 == 0x1 (0x1) +__ulonglong 0x5 || 0x17 == 0x1 (0x1) +int 0x5 & 0x17 == 0x5 (0x5) +__uint 0x5 & 0x17 == 0x5 (0x5) +char 0x5 & 0x17 == 0x5 (0x5) +__uchar 0x5 & 0x17 == 0x5 (0x5) +__longlong 0x5 & 0x17 == 0x5 (0x5) +__ulonglong 0x5 & 0x17 == 0x5 (0x5) +int 0x5 | 0x17 == 0x17 (0x17) +__uint 0x5 | 0x17 == 0x17 (0x17) +char 0x5 | 0x17 == 0x17 (0x17) +__uchar 0x5 | 0x17 == 0x17 (0x17) +__longlong 0x5 | 0x17 == 0x17 (0x17) +__ulonglong 0x5 | 0x17 == 0x17 (0x17) +int 0x5 << 0xe == 0x4000 (0x4000) +__uint 0x5 << 0xe == 0x4000 (0x4000) +char 0x5 << 0xe == 0x0 (0x0) +__uchar 0x5 << 0xe == 0x0 (0x0) +__longlong 0x5 << 0xe == 0x4000 (0x4000) +__ulonglong 0x5 << 0xe == 0x4000 (0x4000) +int 0x5 >> 0xe == 0x0 (0x0) +__uint 0x5 >> 0xe == 0x0 (0x0) +char 0x5 >> 0xe == 0x0 (0x0) +__uchar 0x5 >> 0xe == 0x0 (0x0) +__longlong 0x5 >> 0xe == 0x0 (0x0) +__ulonglong 0x5 >> 0xe == 0x0 (0x0) +int 0x5 + 0x17 == 0x1c (0x1c) +__uint 0x5 + 0x17 == 0x1c (0x1c) +char 0x5 + 0x17 == 0x1c (0x1c) +__uchar 0x5 + 0x17 == 0x1c (0x1c) +__longlong 0x5 + 0x17 == 0x1c (0x1c) +__ulonglong 0x5 + 0x17 == 0x1c (0x1c) +float 0x5 + 0x17 == 0x1c (0x1c) +int 0x5 - 0x17 == -0x12 (0xffee) +__uint 0x5 - 0x17 == -0x12 (0xffee) +char 0x5 - 0x17 == -0x12 (0xffee) +__uchar 0x5 - 0x17 == 0xee (0xee) +__longlong 0x5 - 0x17 == -0x12 (0xffee) +__ulonglong 0x5 - 0x17 == -0x12 (0xffee) +float 0x5 - 0x17 == -0x12 (0xffee) +int 0x5 * 0x17 == 0x73 (0x73) +__uint 0x5 * 0x17 == 0x73 (0x73) +char 0x5 * 0x17 == 0x73 (0x73) +__uchar 0x5 * 0x17 == 0x73 (0x73) +__longlong 0x5 * 0x17 == 0x73 (0x73) +__ulonglong 0x5 * 0x17 == 0x73 (0x73) +float 0x5 * 0x17 == 0x73 (0x73) +int 0x5 < 0x17 == 0x1 (0x1) +__uint 0x5 < 0x17 == 0x1 (0x1) +char 0x5 < 0x17 == 0x1 (0x1) +__uchar 0x5 < 0x17 == 0x1 (0x1) +__longlong 0x5 < 0x17 == 0x1 (0x1) +__ulonglong 0x5 < 0x17 == 0x1 (0x1) +float 0x5 < 0x17 == 0x1 (0x1) +int 0x5 > 0x17 == 0x0 (0x0) +__uint 0x5 > 0x17 == 0x0 (0x0) +char 0x5 > 0x17 == 0x0 (0x0) +__uchar 0x5 > 0x17 == 0x0 (0x0) +__longlong 0x5 > 0x17 == 0x0 (0x0) +__ulonglong 0x5 > 0x17 == 0x0 (0x0) +float 0x5 > 0x17 == 0x0 (0x0) +int 0x5 <= 0x17 == 0x1 (0x1) +__uint 0x5 <= 0x17 == 0x1 (0x1) +char 0x5 <= 0x17 == 0x1 (0x1) +__uchar 0x5 <= 0x17 == 0x1 (0x1) +__longlong 0x5 <= 0x17 == 0x1 (0x1) +__ulonglong 0x5 <= 0x17 == 0x1 (0x1) +float 0x5 <= 0x17 == 0x1 (0x1) +int 0x5 == 0x17 == 0x0 (0x0) +__uint 0x5 == 0x17 == 0x0 (0x0) +char 0x5 == 0x17 == 0x0 (0x0) +__uchar 0x5 == 0x17 == 0x0 (0x0) +__longlong 0x5 == 0x17 == 0x0 (0x0) +__ulonglong 0x5 == 0x17 == 0x0 (0x0) +float 0x5 == 0x17 == 0x0 (0x0) +int 0x5 != 0x17 == 0x1 (0x1) +__uint 0x5 != 0x17 == 0x1 (0x1) +char 0x5 != 0x17 == 0x1 (0x1) +__uchar 0x5 != 0x17 == 0x1 (0x1) +__longlong 0x5 != 0x17 == 0x1 (0x1) +__ulonglong 0x5 != 0x17 == 0x1 (0x1) +float 0x5 != 0x17 == 0x1 (0x1) +int 0x5 >= 0x17 == 0x0 (0x0) +__uint 0x5 >= 0x17 == 0x0 (0x0) +char 0x5 >= 0x17 == 0x0 (0x0) +__uchar 0x5 >= 0x17 == 0x0 (0x0) +__longlong 0x5 >= 0x17 == 0x0 (0x0) +__ulonglong 0x5 >= 0x17 == 0x0 (0x0) +float 0x5 >= 0x17 == 0x0 (0x0) +int 0x5 / 0x17 == 0x0 (0x0) +__uint 0x5 / 0x17 == 0x0 (0x0) +char 0x5 / 0x17 == 0x0 (0x0) +__uchar 0x5 / 0x17 == 0x0 (0x0) +__longlong 0x5 / 0x17 == 0x0 (0x0) +__ulonglong 0x5 / 0x17 == 0x0 (0x0) +float 0x5 / 0x17 == 0x0 (0x0) +int 0x5 % 0x17 == 0x5 (0x5) +__uint 0x5 % 0x17 == 0x5 (0x5) +char 0x5 % 0x17 == 0x5 (0x5) +__uchar 0x5 % 0x17 == 0x5 (0x5) +__longlong 0x5 % 0x17 == 0x5 (0x5) +__ulonglong 0x5 % 0x17 == 0x5 (0x5) +0x5 * 0x7fff == 0x7ffb +0x5 / 0x7fff == 0x0 +0x5 % 0x7fff == 0x5 +int 0x5 ^ 0x7fff == 0x7ffa (0x7ffa) +__uint 0x5 ^ 0x7fff == 0x7ffa (0x7ffa) +char 0x5 ^ 0xffff == -0x6 (0xfffa) +__uchar 0x5 ^ 0xff == 0xfa (0xfa) +__longlong 0x5 ^ 0x7fff == 0x7ffa (0x7ffa) +__ulonglong 0x5 ^ 0x7fff == 0x7ffa (0x7ffa) +int 0x5 && 0x7fff == 0x1 (0x1) +__uint 0x5 && 0x7fff == 0x1 (0x1) +char 0x5 && 0xffff == 0x1 (0x1) +__uchar 0x5 && 0xff == 0x1 (0x1) +__longlong 0x5 && 0x7fff == 0x1 (0x1) +__ulonglong 0x5 && 0x7fff == 0x1 (0x1) +int 0x5 || 0x7fff == 0x1 (0x1) +__uint 0x5 || 0x7fff == 0x1 (0x1) +char 0x5 || 0xffff == 0x1 (0x1) +__uchar 0x5 || 0xff == 0x1 (0x1) +__longlong 0x5 || 0x7fff == 0x1 (0x1) +__ulonglong 0x5 || 0x7fff == 0x1 (0x1) +int 0x5 & 0x7fff == 0x5 (0x5) +__uint 0x5 & 0x7fff == 0x5 (0x5) +char 0x5 & 0xffff == 0x5 (0x5) +__uchar 0x5 & 0xff == 0x5 (0x5) +__longlong 0x5 & 0x7fff == 0x5 (0x5) +__ulonglong 0x5 & 0x7fff == 0x5 (0x5) +int 0x5 | 0x7fff == 0x7fff (0x7fff) +__uint 0x5 | 0x7fff == 0x7fff (0x7fff) +char 0x5 | 0xffff == -0x1 (0xffff) +__uchar 0x5 | 0xff == 0xff (0xff) +__longlong 0x5 | 0x7fff == 0x7fff (0x7fff) +__ulonglong 0x5 | 0x7fff == 0x7fff (0x7fff) +int 0x5 << 0x10 == 0x0 (0x0) +__uint 0x5 << 0x10 == 0x0 (0x0) +char 0x5 << 0x10 == 0x0 (0x0) +__uchar 0x5 << 0x10 == 0x0 (0x0) +__longlong 0x5 << 0x10 == 0x0 (0x0) +__ulonglong 0x5 << 0x10 == 0x0 (0x0) +int 0x5 >> 0x10 == 0x0 (0x0) +__uint 0x5 >> 0x10 == 0x0 (0x0) +char 0x5 >> 0x10 == 0x0 (0x0) +__uchar 0x5 >> 0x10 == 0x0 (0x0) +__longlong 0x5 >> 0x10 == 0x0 (0x0) +__ulonglong 0x5 >> 0x10 == 0x0 (0x0) +int 0x5 + 0x7fff == -0x7ffc (0x8004) +__uint 0x5 + 0x7fff == -0x7ffc (0x8004) +char 0x5 + 0xffff == 0x4 (0x4) +__uchar 0x5 + 0xff == 0x4 (0x4) +__longlong 0x5 + 0x7fff == -0x7ffc (0x8004) +__ulonglong 0x5 + 0x7fff == -0x7ffc (0x8004) +float 0x5 + 0x7fff == -0x7ffc (0x8004) +int 0x5 - 0x7fff == -0x7ffa (0x8006) +__uint 0x5 - 0x7fff == -0x7ffa (0x8006) +char 0x5 - 0xffff == 0x6 (0x6) +__uchar 0x5 - 0xff == 0x6 (0x6) +__longlong 0x5 - 0x7fff == -0x7ffa (0x8006) +__ulonglong 0x5 - 0x7fff == -0x7ffa (0x8006) +float 0x5 - 0x7fff == -0x7ffa (0x8006) +int 0x5 * 0x7fff == 0x7ffb (0x7ffb) +__uint 0x5 * 0x7fff == 0x7ffb (0x7ffb) +char 0x5 * 0xffff == -0x5 (0xfffb) +__uchar 0x5 * 0xff == 0xfb (0xfb) +__longlong 0x5 * 0x7fff == 0x7ffb (0x7ffb) +__ulonglong 0x5 * 0x7fff == 0x7ffb (0x7ffb) +float 0x5 * 0x7fff == 0x7ffb (0x7ffb) +int 0x5 < 0x7fff == 0x1 (0x1) +__uint 0x5 < 0x7fff == 0x1 (0x1) +char 0x5 < 0xffff == 0x0 (0x0) +__uchar 0x5 < 0xff == 0x1 (0x1) +__longlong 0x5 < 0x7fff == 0x1 (0x1) +__ulonglong 0x5 < 0x7fff == 0x1 (0x1) +float 0x5 < 0x7fff == 0x1 (0x1) +int 0x5 > 0x7fff == 0x0 (0x0) +__uint 0x5 > 0x7fff == 0x0 (0x0) +char 0x5 > 0xffff == 0x1 (0x1) +__uchar 0x5 > 0xff == 0x0 (0x0) +__longlong 0x5 > 0x7fff == 0x0 (0x0) +__ulonglong 0x5 > 0x7fff == 0x0 (0x0) +float 0x5 > 0x7fff == 0x0 (0x0) +int 0x5 <= 0x7fff == 0x1 (0x1) +__uint 0x5 <= 0x7fff == 0x1 (0x1) +char 0x5 <= 0xffff == 0x0 (0x0) +__uchar 0x5 <= 0xff == 0x1 (0x1) +__longlong 0x5 <= 0x7fff == 0x1 (0x1) +__ulonglong 0x5 <= 0x7fff == 0x1 (0x1) +float 0x5 <= 0x7fff == 0x1 (0x1) +int 0x5 == 0x7fff == 0x0 (0x0) +__uint 0x5 == 0x7fff == 0x0 (0x0) +char 0x5 == 0xffff == 0x0 (0x0) +__uchar 0x5 == 0xff == 0x0 (0x0) +__longlong 0x5 == 0x7fff == 0x0 (0x0) +__ulonglong 0x5 == 0x7fff == 0x0 (0x0) +float 0x5 == 0x7fff == 0x0 (0x0) +int 0x5 != 0x7fff == 0x1 (0x1) +__uint 0x5 != 0x7fff == 0x1 (0x1) +char 0x5 != 0xffff == 0x1 (0x1) +__uchar 0x5 != 0xff == 0x1 (0x1) +__longlong 0x5 != 0x7fff == 0x1 (0x1) +__ulonglong 0x5 != 0x7fff == 0x1 (0x1) +float 0x5 != 0x7fff == 0x1 (0x1) +int 0x5 >= 0x7fff == 0x0 (0x0) +__uint 0x5 >= 0x7fff == 0x0 (0x0) +char 0x5 >= 0xffff == 0x1 (0x1) +__uchar 0x5 >= 0xff == 0x0 (0x0) +__longlong 0x5 >= 0x7fff == 0x0 (0x0) +__ulonglong 0x5 >= 0x7fff == 0x0 (0x0) +float 0x5 >= 0x7fff == 0x0 (0x0) +int 0x5 / 0x7fff == 0x0 (0x0) +__uint 0x5 / 0x7fff == 0x0 (0x0) +char 0x5 / 0xffff == -0x5 (0xfffb) +__uchar 0x5 / 0xff == 0x0 (0x0) +__longlong 0x5 / 0x7fff == 0x0 (0x0) +__ulonglong 0x5 / 0x7fff == 0x0 (0x0) +float 0x5 / 0x7fff == 0x0 (0x0) +int 0x5 % 0x7fff == 0x5 (0x5) +__uint 0x5 % 0x7fff == 0x5 (0x5) +char 0x5 % 0xffff == 0x0 (0x0) +__uchar 0x5 % 0xff == 0x5 (0x5) +__longlong 0x5 % 0x7fff == 0x5 (0x5) +__ulonglong 0x5 % 0x7fff == 0x5 (0x5) +0x5 * 0x8000 == -0x8000 +0x5 / 0x8000 == 0x0 +0x5 % 0x8000 == 0x5 +int 0x5 ^ 0x8000 == -0x7ffb (0x8005) +__uint 0x5 ^ 0x8000 == -0x7ffb (0x8005) +char 0x5 ^ 0x0 == 0x5 (0x5) +__uchar 0x5 ^ 0x0 == 0x5 (0x5) +__longlong 0x5 ^ 0x8000 == -0x7ffb (0x8005) +__ulonglong 0x5 ^ 0x8000 == -0x7ffb (0x8005) +int 0x5 && 0x8000 == 0x1 (0x1) +__uint 0x5 && 0x8000 == 0x1 (0x1) +char 0x5 && 0x0 == 0x0 (0x0) +__uchar 0x5 && 0x0 == 0x0 (0x0) +__longlong 0x5 && 0x8000 == 0x1 (0x1) +__ulonglong 0x5 && 0x8000 == 0x1 (0x1) +int 0x5 || 0x8000 == 0x1 (0x1) +__uint 0x5 || 0x8000 == 0x1 (0x1) +char 0x5 || 0x0 == 0x1 (0x1) +__uchar 0x5 || 0x0 == 0x1 (0x1) +__longlong 0x5 || 0x8000 == 0x1 (0x1) +__ulonglong 0x5 || 0x8000 == 0x1 (0x1) +int 0x5 & 0x8000 == 0x0 (0x0) +__uint 0x5 & 0x8000 == 0x0 (0x0) +char 0x5 & 0x0 == 0x0 (0x0) +__uchar 0x5 & 0x0 == 0x0 (0x0) +__longlong 0x5 & 0x8000 == 0x0 (0x0) +__ulonglong 0x5 & 0x8000 == 0x0 (0x0) +int 0x5 | 0x8000 == -0x7ffb (0x8005) +__uint 0x5 | 0x8000 == -0x7ffb (0x8005) +char 0x5 | 0x0 == 0x5 (0x5) +__uchar 0x5 | 0x0 == 0x5 (0x5) +__longlong 0x5 | 0x8000 == -0x7ffb (0x8005) +__ulonglong 0x5 | 0x8000 == -0x7ffb (0x8005) +int 0x5 << 0x12 == 0x0 (0x0) +__uint 0x5 << 0x12 == 0x0 (0x0) +char 0x5 << 0x12 == 0x0 (0x0) +__uchar 0x5 << 0x12 == 0x0 (0x0) +__longlong 0x5 << 0x12 == 0x0 (0x0) +__ulonglong 0x5 << 0x12 == 0x0 (0x0) +int 0x5 >> 0x12 == 0x0 (0x0) +__uint 0x5 >> 0x12 == 0x0 (0x0) +char 0x5 >> 0x12 == 0x0 (0x0) +__uchar 0x5 >> 0x12 == 0x0 (0x0) +__longlong 0x5 >> 0x12 == 0x0 (0x0) +__ulonglong 0x5 >> 0x12 == 0x0 (0x0) +int 0x5 + 0x8000 == -0x7ffb (0x8005) +__uint 0x5 + 0x8000 == -0x7ffb (0x8005) +char 0x5 + 0x0 == 0x5 (0x5) +__uchar 0x5 + 0x0 == 0x5 (0x5) +__longlong 0x5 + 0x8000 == -0x7ffb (0x8005) +__ulonglong 0x5 + 0x8000 == -0x7ffb (0x8005) +float 0x5 + 0x8000 == -0x7ffb (0x8005) +int 0x5 - 0x8000 == -0x7ffb (0x8005) +__uint 0x5 - 0x8000 == -0x7ffb (0x8005) +char 0x5 - 0x0 == 0x5 (0x5) +__uchar 0x5 - 0x0 == 0x5 (0x5) +__longlong 0x5 - 0x8000 == -0x7ffb (0x8005) +__ulonglong 0x5 - 0x8000 == -0x7ffb (0x8005) +float 0x5 - 0x8000 == -0x7ffb (0x8005) +int 0x5 * 0x8000 == -0x8000 (0x8000) +__uint 0x5 * 0x8000 == -0x8000 (0x8000) +char 0x5 * 0x0 == 0x0 (0x0) +__uchar 0x5 * 0x0 == 0x0 (0x0) +__longlong 0x5 * 0x8000 == -0x8000 (0x8000) +__ulonglong 0x5 * 0x8000 == -0x8000 (0x8000) +float 0x5 * 0x8000 == -0x8000 (0x8000) +int 0x5 < 0x8000 == 0x0 (0x0) +__uint 0x5 < 0x8000 == 0x1 (0x1) +char 0x5 < 0x0 == 0x0 (0x0) +__uchar 0x5 < 0x0 == 0x0 (0x0) +__longlong 0x5 < 0x8000 == 0x0 (0x0) +__ulonglong 0x5 < 0x8000 == 0x1 (0x1) +float 0x5 < 0x8000 == 0x0 (0x0) +int 0x5 > 0x8000 == 0x1 (0x1) +__uint 0x5 > 0x8000 == 0x0 (0x0) +char 0x5 > 0x0 == 0x1 (0x1) +__uchar 0x5 > 0x0 == 0x1 (0x1) +__longlong 0x5 > 0x8000 == 0x1 (0x1) +__ulonglong 0x5 > 0x8000 == 0x0 (0x0) +float 0x5 > 0x8000 == 0x1 (0x1) +int 0x5 <= 0x8000 == 0x0 (0x0) +__uint 0x5 <= 0x8000 == 0x1 (0x1) +char 0x5 <= 0x0 == 0x0 (0x0) +__uchar 0x5 <= 0x0 == 0x0 (0x0) +__longlong 0x5 <= 0x8000 == 0x0 (0x0) +__ulonglong 0x5 <= 0x8000 == 0x1 (0x1) +float 0x5 <= 0x8000 == 0x0 (0x0) +int 0x5 == 0x8000 == 0x0 (0x0) +__uint 0x5 == 0x8000 == 0x0 (0x0) +char 0x5 == 0x0 == 0x0 (0x0) +__uchar 0x5 == 0x0 == 0x0 (0x0) +__longlong 0x5 == 0x8000 == 0x0 (0x0) +__ulonglong 0x5 == 0x8000 == 0x0 (0x0) +float 0x5 == 0x8000 == 0x0 (0x0) +int 0x5 != 0x8000 == 0x1 (0x1) +__uint 0x5 != 0x8000 == 0x1 (0x1) +char 0x5 != 0x0 == 0x1 (0x1) +__uchar 0x5 != 0x0 == 0x1 (0x1) +__longlong 0x5 != 0x8000 == 0x1 (0x1) +__ulonglong 0x5 != 0x8000 == 0x1 (0x1) +float 0x5 != 0x8000 == 0x1 (0x1) +int 0x5 >= 0x8000 == 0x1 (0x1) +__uint 0x5 >= 0x8000 == 0x0 (0x0) +char 0x5 >= 0x0 == 0x1 (0x1) +__uchar 0x5 >= 0x0 == 0x1 (0x1) +__longlong 0x5 >= 0x8000 == 0x1 (0x1) +__ulonglong 0x5 >= 0x8000 == 0x0 (0x0) +float 0x5 >= 0x8000 == 0x1 (0x1) +int 0x5 / 0x8000 == 0x0 (0x0) +__uint 0x5 / 0x8000 == 0x0 (0x0) +__longlong 0x5 / 0x8000 == 0x0 (0x0) +__ulonglong 0x5 / 0x8000 == 0x0 (0x0) +float 0x5 / 0x8000 == 0x0 (0x0) +int 0x5 % 0x8000 == 0x5 (0x5) +__uint 0x5 % 0x8000 == 0x5 (0x5) +__longlong 0x5 % 0x8000 == 0x5 (0x5) +__ulonglong 0x5 % 0x8000 == 0x5 (0x5) +0x5 * 0x3e8 == 0x1388 +0x5 / 0x3e8 == 0x0 +0x5 % 0x3e8 == 0x5 +int 0x5 ^ 0x3e8 == 0x3ed (0x3ed) +__uint 0x5 ^ 0x3e8 == 0x3ed (0x3ed) +char 0x5 ^ 0xffe8 == -0x13 (0xffed) +__uchar 0x5 ^ 0xe8 == 0xed (0xed) +__longlong 0x5 ^ 0x3e8 == 0x3ed (0x3ed) +__ulonglong 0x5 ^ 0x3e8 == 0x3ed (0x3ed) +int 0x5 && 0x3e8 == 0x1 (0x1) +__uint 0x5 && 0x3e8 == 0x1 (0x1) +char 0x5 && 0xffe8 == 0x1 (0x1) +__uchar 0x5 && 0xe8 == 0x1 (0x1) +__longlong 0x5 && 0x3e8 == 0x1 (0x1) +__ulonglong 0x5 && 0x3e8 == 0x1 (0x1) +int 0x5 || 0x3e8 == 0x1 (0x1) +__uint 0x5 || 0x3e8 == 0x1 (0x1) +char 0x5 || 0xffe8 == 0x1 (0x1) +__uchar 0x5 || 0xe8 == 0x1 (0x1) +__longlong 0x5 || 0x3e8 == 0x1 (0x1) +__ulonglong 0x5 || 0x3e8 == 0x1 (0x1) +int 0x5 & 0x3e8 == 0x0 (0x0) +__uint 0x5 & 0x3e8 == 0x0 (0x0) +char 0x5 & 0xffe8 == 0x0 (0x0) +__uchar 0x5 & 0xe8 == 0x0 (0x0) +__longlong 0x5 & 0x3e8 == 0x0 (0x0) +__ulonglong 0x5 & 0x3e8 == 0x0 (0x0) +int 0x5 | 0x3e8 == 0x3ed (0x3ed) +__uint 0x5 | 0x3e8 == 0x3ed (0x3ed) +char 0x5 | 0xffe8 == -0x13 (0xffed) +__uchar 0x5 | 0xe8 == 0xed (0xed) +__longlong 0x5 | 0x3e8 == 0x3ed (0x3ed) +__ulonglong 0x5 | 0x3e8 == 0x3ed (0x3ed) +int 0x5 << 0x14 == 0x0 (0x0) +__uint 0x5 << 0x14 == 0x0 (0x0) +char 0x5 << 0x14 == 0x0 (0x0) +__uchar 0x5 << 0x14 == 0x0 (0x0) +__longlong 0x5 << 0x14 == 0x0 (0x0) +__ulonglong 0x5 << 0x14 == 0x0 (0x0) +int 0x5 >> 0x14 == 0x0 (0x0) +__uint 0x5 >> 0x14 == 0x0 (0x0) +char 0x5 >> 0x14 == 0x0 (0x0) +__uchar 0x5 >> 0x14 == 0x0 (0x0) +__longlong 0x5 >> 0x14 == 0x0 (0x0) +__ulonglong 0x5 >> 0x14 == 0x0 (0x0) +int 0x5 + 0x3e8 == 0x3ed (0x3ed) +__uint 0x5 + 0x3e8 == 0x3ed (0x3ed) +char 0x5 + 0xffe8 == -0x13 (0xffed) +__uchar 0x5 + 0xe8 == 0xed (0xed) +__longlong 0x5 + 0x3e8 == 0x3ed (0x3ed) +__ulonglong 0x5 + 0x3e8 == 0x3ed (0x3ed) +float 0x5 + 0x3e8 == 0x3ed (0x3ed) +int 0x5 - 0x3e8 == -0x3e3 (0xfc1d) +__uint 0x5 - 0x3e8 == -0x3e3 (0xfc1d) +char 0x5 - 0xffe8 == 0x1d (0x1d) +__uchar 0x5 - 0xe8 == 0x1d (0x1d) +__longlong 0x5 - 0x3e8 == -0x3e3 (0xfc1d) +__ulonglong 0x5 - 0x3e8 == -0x3e3 (0xfc1d) +float 0x5 - 0x3e8 == -0x3e3 (0xfc1d) +int 0x5 * 0x3e8 == 0x1388 (0x1388) +__uint 0x5 * 0x3e8 == 0x1388 (0x1388) +char 0x5 * 0xffe8 == -0x78 (0xff88) +__uchar 0x5 * 0xe8 == 0x88 (0x88) +__longlong 0x5 * 0x3e8 == 0x1388 (0x1388) +__ulonglong 0x5 * 0x3e8 == 0x1388 (0x1388) +float 0x5 * 0x3e8 == 0x1388 (0x1388) +int 0x5 < 0x3e8 == 0x1 (0x1) +__uint 0x5 < 0x3e8 == 0x1 (0x1) +char 0x5 < 0xffe8 == 0x0 (0x0) +__uchar 0x5 < 0xe8 == 0x1 (0x1) +__longlong 0x5 < 0x3e8 == 0x1 (0x1) +__ulonglong 0x5 < 0x3e8 == 0x1 (0x1) +float 0x5 < 0x3e8 == 0x1 (0x1) +int 0x5 > 0x3e8 == 0x0 (0x0) +__uint 0x5 > 0x3e8 == 0x0 (0x0) +char 0x5 > 0xffe8 == 0x1 (0x1) +__uchar 0x5 > 0xe8 == 0x0 (0x0) +__longlong 0x5 > 0x3e8 == 0x0 (0x0) +__ulonglong 0x5 > 0x3e8 == 0x0 (0x0) +float 0x5 > 0x3e8 == 0x0 (0x0) +int 0x5 <= 0x3e8 == 0x1 (0x1) +__uint 0x5 <= 0x3e8 == 0x1 (0x1) +char 0x5 <= 0xffe8 == 0x0 (0x0) +__uchar 0x5 <= 0xe8 == 0x1 (0x1) +__longlong 0x5 <= 0x3e8 == 0x1 (0x1) +__ulonglong 0x5 <= 0x3e8 == 0x1 (0x1) +float 0x5 <= 0x3e8 == 0x1 (0x1) +int 0x5 == 0x3e8 == 0x0 (0x0) +__uint 0x5 == 0x3e8 == 0x0 (0x0) +char 0x5 == 0xffe8 == 0x0 (0x0) +__uchar 0x5 == 0xe8 == 0x0 (0x0) +__longlong 0x5 == 0x3e8 == 0x0 (0x0) +__ulonglong 0x5 == 0x3e8 == 0x0 (0x0) +float 0x5 == 0x3e8 == 0x0 (0x0) +int 0x5 != 0x3e8 == 0x1 (0x1) +__uint 0x5 != 0x3e8 == 0x1 (0x1) +char 0x5 != 0xffe8 == 0x1 (0x1) +__uchar 0x5 != 0xe8 == 0x1 (0x1) +__longlong 0x5 != 0x3e8 == 0x1 (0x1) +__ulonglong 0x5 != 0x3e8 == 0x1 (0x1) +float 0x5 != 0x3e8 == 0x1 (0x1) +int 0x5 >= 0x3e8 == 0x0 (0x0) +__uint 0x5 >= 0x3e8 == 0x0 (0x0) +char 0x5 >= 0xffe8 == 0x1 (0x1) +__uchar 0x5 >= 0xe8 == 0x0 (0x0) +__longlong 0x5 >= 0x3e8 == 0x0 (0x0) +__ulonglong 0x5 >= 0x3e8 == 0x0 (0x0) +float 0x5 >= 0x3e8 == 0x0 (0x0) +int 0x5 / 0x3e8 == 0x0 (0x0) +__uint 0x5 / 0x3e8 == 0x0 (0x0) +char 0x5 / 0xffe8 == 0x0 (0x0) +__uchar 0x5 / 0xe8 == 0x0 (0x0) +__longlong 0x5 / 0x3e8 == 0x0 (0x0) +__ulonglong 0x5 / 0x3e8 == 0x0 (0x0) +float 0x5 / 0x3e8 == 0x0 (0x0) +int 0x5 % 0x3e8 == 0x5 (0x5) +__uint 0x5 % 0x3e8 == 0x5 (0x5) +char 0x5 % 0xffe8 == 0x5 (0x5) +__uchar 0x5 % 0xe8 == 0x5 (0x5) +__longlong 0x5 % 0x3e8 == 0x5 (0x5) +__ulonglong 0x5 % 0x3e8 == 0x5 (0x5) +0x5 * 0x2710 == -0x3cb0 +0x5 / 0x2710 == 0x0 +0x5 % 0x2710 == 0x5 +int 0x5 ^ 0x2710 == 0x2715 (0x2715) +__uint 0x5 ^ 0x2710 == 0x2715 (0x2715) +char 0x5 ^ 0x10 == 0x15 (0x15) +__uchar 0x5 ^ 0x10 == 0x15 (0x15) +__longlong 0x5 ^ 0x2710 == 0x2715 (0x2715) +__ulonglong 0x5 ^ 0x2710 == 0x2715 (0x2715) +int 0x5 && 0x2710 == 0x1 (0x1) +__uint 0x5 && 0x2710 == 0x1 (0x1) +char 0x5 && 0x10 == 0x1 (0x1) +__uchar 0x5 && 0x10 == 0x1 (0x1) +__longlong 0x5 && 0x2710 == 0x1 (0x1) +__ulonglong 0x5 && 0x2710 == 0x1 (0x1) +int 0x5 || 0x2710 == 0x1 (0x1) +__uint 0x5 || 0x2710 == 0x1 (0x1) +char 0x5 || 0x10 == 0x1 (0x1) +__uchar 0x5 || 0x10 == 0x1 (0x1) +__longlong 0x5 || 0x2710 == 0x1 (0x1) +__ulonglong 0x5 || 0x2710 == 0x1 (0x1) +int 0x5 & 0x2710 == 0x0 (0x0) +__uint 0x5 & 0x2710 == 0x0 (0x0) +char 0x5 & 0x10 == 0x0 (0x0) +__uchar 0x5 & 0x10 == 0x0 (0x0) +__longlong 0x5 & 0x2710 == 0x0 (0x0) +__ulonglong 0x5 & 0x2710 == 0x0 (0x0) +int 0x5 | 0x2710 == 0x2715 (0x2715) +__uint 0x5 | 0x2710 == 0x2715 (0x2715) +char 0x5 | 0x10 == 0x15 (0x15) +__uchar 0x5 | 0x10 == 0x15 (0x15) +__longlong 0x5 | 0x2710 == 0x2715 (0x2715) +__ulonglong 0x5 | 0x2710 == 0x2715 (0x2715) +int 0x5 << 0x16 == 0x0 (0x0) +__uint 0x5 << 0x16 == 0x0 (0x0) +char 0x5 << 0x16 == 0x0 (0x0) +__uchar 0x5 << 0x16 == 0x0 (0x0) +__longlong 0x5 << 0x16 == 0x0 (0x0) +__ulonglong 0x5 << 0x16 == 0x0 (0x0) +int 0x5 >> 0x16 == 0x0 (0x0) +__uint 0x5 >> 0x16 == 0x0 (0x0) +char 0x5 >> 0x16 == 0x0 (0x0) +__uchar 0x5 >> 0x16 == 0x0 (0x0) +__longlong 0x5 >> 0x16 == 0x0 (0x0) +__ulonglong 0x5 >> 0x16 == 0x0 (0x0) +int 0x5 + 0x2710 == 0x2715 (0x2715) +__uint 0x5 + 0x2710 == 0x2715 (0x2715) +char 0x5 + 0x10 == 0x15 (0x15) +__uchar 0x5 + 0x10 == 0x15 (0x15) +__longlong 0x5 + 0x2710 == 0x2715 (0x2715) +__ulonglong 0x5 + 0x2710 == 0x2715 (0x2715) +float 0x5 + 0x2710 == 0x2715 (0x2715) +int 0x5 - 0x2710 == -0x270b (0xd8f5) +__uint 0x5 - 0x2710 == -0x270b (0xd8f5) +char 0x5 - 0x10 == -0xb (0xfff5) +__uchar 0x5 - 0x10 == 0xf5 (0xf5) +__longlong 0x5 - 0x2710 == -0x270b (0xd8f5) +__ulonglong 0x5 - 0x2710 == -0x270b (0xd8f5) +float 0x5 - 0x2710 == -0x270b (0xd8f5) +int 0x5 * 0x2710 == -0x3cb0 (0xc350) +__uint 0x5 * 0x2710 == -0x3cb0 (0xc350) +char 0x5 * 0x10 == 0x50 (0x50) +__uchar 0x5 * 0x10 == 0x50 (0x50) +__longlong 0x5 * 0x2710 == -0x3cb0 (0xc350) +__ulonglong 0x5 * 0x2710 == -0x3cb0 (0xc350) +float 0x5 * 0x2710 == -0x3cb0 (0xc350) +int 0x5 < 0x2710 == 0x1 (0x1) +__uint 0x5 < 0x2710 == 0x1 (0x1) +char 0x5 < 0x10 == 0x1 (0x1) +__uchar 0x5 < 0x10 == 0x1 (0x1) +__longlong 0x5 < 0x2710 == 0x1 (0x1) +__ulonglong 0x5 < 0x2710 == 0x1 (0x1) +float 0x5 < 0x2710 == 0x1 (0x1) +int 0x5 > 0x2710 == 0x0 (0x0) +__uint 0x5 > 0x2710 == 0x0 (0x0) +char 0x5 > 0x10 == 0x0 (0x0) +__uchar 0x5 > 0x10 == 0x0 (0x0) +__longlong 0x5 > 0x2710 == 0x0 (0x0) +__ulonglong 0x5 > 0x2710 == 0x0 (0x0) +float 0x5 > 0x2710 == 0x0 (0x0) +int 0x5 <= 0x2710 == 0x1 (0x1) +__uint 0x5 <= 0x2710 == 0x1 (0x1) +char 0x5 <= 0x10 == 0x1 (0x1) +__uchar 0x5 <= 0x10 == 0x1 (0x1) +__longlong 0x5 <= 0x2710 == 0x1 (0x1) +__ulonglong 0x5 <= 0x2710 == 0x1 (0x1) +float 0x5 <= 0x2710 == 0x1 (0x1) +int 0x5 == 0x2710 == 0x0 (0x0) +__uint 0x5 == 0x2710 == 0x0 (0x0) +char 0x5 == 0x10 == 0x0 (0x0) +__uchar 0x5 == 0x10 == 0x0 (0x0) +__longlong 0x5 == 0x2710 == 0x0 (0x0) +__ulonglong 0x5 == 0x2710 == 0x0 (0x0) +float 0x5 == 0x2710 == 0x0 (0x0) +int 0x5 != 0x2710 == 0x1 (0x1) +__uint 0x5 != 0x2710 == 0x1 (0x1) +char 0x5 != 0x10 == 0x1 (0x1) +__uchar 0x5 != 0x10 == 0x1 (0x1) +__longlong 0x5 != 0x2710 == 0x1 (0x1) +__ulonglong 0x5 != 0x2710 == 0x1 (0x1) +float 0x5 != 0x2710 == 0x1 (0x1) +int 0x5 >= 0x2710 == 0x0 (0x0) +__uint 0x5 >= 0x2710 == 0x0 (0x0) +char 0x5 >= 0x10 == 0x0 (0x0) +__uchar 0x5 >= 0x10 == 0x0 (0x0) +__longlong 0x5 >= 0x2710 == 0x0 (0x0) +__ulonglong 0x5 >= 0x2710 == 0x0 (0x0) +float 0x5 >= 0x2710 == 0x0 (0x0) +int 0x5 / 0x2710 == 0x0 (0x0) +__uint 0x5 / 0x2710 == 0x0 (0x0) +char 0x5 / 0x10 == 0x0 (0x0) +__uchar 0x5 / 0x10 == 0x0 (0x0) +__longlong 0x5 / 0x2710 == 0x0 (0x0) +__ulonglong 0x5 / 0x2710 == 0x0 (0x0) +float 0x5 / 0x2710 == 0x0 (0x0) +int 0x5 % 0x2710 == 0x5 (0x5) +__uint 0x5 % 0x2710 == 0x5 (0x5) +char 0x5 % 0x10 == 0x5 (0x5) +__uchar 0x5 % 0x10 == 0x5 (0x5) +__longlong 0x5 % 0x2710 == 0x5 (0x5) +__ulonglong 0x5 % 0x2710 == 0x5 (0x5) +int xor420x5 xor42 0x2f +__uint xor420x5 xor42 0x2f +char xor420x5 xor42 0x2f +__uchar xor420x5 xor42 0x2f +__longlong xor420x5 xor42 0x2f +__ulonglong xor420x5 xor42 0x2f +int land10x5 land1 0x1 +__uint land10x5 land1 0x1 +char land10x5 land1 0x1 +__uchar land10x5 land1 0x1 +__longlong land10x5 land1 0x1 +__ulonglong land10x5 land1 0x1 +int lor10x5 lor1 0x1 +__uint lor10x5 lor1 0x1 +char lor10x5 lor1 0x1 +__uchar lor10x5 lor1 0x1 +__longlong lor10x5 lor1 0x1 +__ulonglong lor10x5 lor1 0x1 +int and420x5 and42 0x0 +__uint and420x5 and42 0x0 +char and420x5 and42 0x0 +__uchar and420x5 and42 0x0 +__longlong and420x5 and42 0x0 +__ulonglong and420x5 and42 0x0 +int or420x5 or42 0x2f +__uint or420x5 or42 0x2f +char or420x5 or42 0x2f +__uchar or420x5 or42 0x2f +__longlong or420x5 or42 0x2f +__ulonglong or420x5 or42 0x2f +int shl50x5 shl5 0xa0 +__uint shl50x5 shl5 0xa0 +char shl50x5 shl5 -0x60 +__uchar shl50x5 shl5 0xa0 +__longlong shl50x5 shl5 0xa0 +__ulonglong shl50x5 shl5 0xa0 +int shr50x5 shr5 0x0 +__uint shr50x5 shr5 0x0 +char shr50x5 shr5 0x0 +__uchar shr50x5 shr5 0x0 +__longlong shr50x5 shr5 0x0 +__ulonglong shr50x5 shr5 0x0 +int add420x5 add42 0x2f +__uint add420x5 add42 0x2f +char add420x5 add42 0x2f +__uchar add420x5 add42 0x2f +__longlong add420x5 add42 0x2f +__ulonglong add420x5 add42 0x2f +float add420x5 add42 0x2f +int sub420x5 sub42 -0x25 +__uint sub420x5 sub42 -0x25 +char sub420x5 sub42 -0x25 +__uchar sub420x5 sub42 0xdb +__longlong sub420x5 sub42 -0x25 +__ulonglong sub420x5 sub42 -0x25 +float sub420x5 sub42 -0x25 +int mul420x5 mul42 0xd2 +__uint mul420x5 mul42 0xd2 +char mul420x5 mul42 -0x2e +__uchar mul420x5 mul42 0xd2 +__longlong mul420x5 mul42 0xd2 +__ulonglong mul420x5 mul42 0xd2 +float mul420x5 mul42 0xd2 +int lt420x5 lt42 0x1 +__uint lt420x5 lt42 0x1 +char lt420x5 lt42 0x1 +__uchar lt420x5 lt42 0x1 +__longlong lt420x5 lt42 0x1 +__ulonglong lt420x5 lt42 0x1 +float lt420x5 lt42 0x1 +int gt420x5 gt42 0x0 +__uint gt420x5 gt42 0x0 +char gt420x5 gt42 0x0 +__uchar gt420x5 gt42 0x0 +__longlong gt420x5 gt42 0x0 +__ulonglong gt420x5 gt42 0x0 +float gt420x5 gt42 0x0 +int le420x5 le42 0x1 +__uint le420x5 le42 0x1 +char le420x5 le42 0x1 +__uchar le420x5 le42 0x1 +__longlong le420x5 le42 0x1 +__ulonglong le420x5 le42 0x1 +float le420x5 le42 0x1 +int eq420x5 eq42 0x0 +__uint eq420x5 eq42 0x0 +char eq420x5 eq42 0x0 +__uchar eq420x5 eq42 0x0 +__longlong eq420x5 eq42 0x0 +__ulonglong eq420x5 eq42 0x0 +float eq420x5 eq42 0x0 +int ne420x5 ne42 0x1 +__uint ne420x5 ne42 0x1 +char ne420x5 ne42 0x1 +__uchar ne420x5 ne42 0x1 +__longlong ne420x5 ne42 0x1 +__ulonglong ne420x5 ne42 0x1 +float ne420x5 ne42 0x1 +int ge420x5 ge42 0x0 +__uint ge420x5 ge42 0x0 +char ge420x5 ge42 0x0 +__uchar ge420x5 ge42 0x0 +__longlong ge420x5 ge42 0x0 +__ulonglong ge420x5 ge42 0x0 +float ge420x5 ge42 0x0 +int div420x5 div42 0x0 +__uint div420x5 div42 0x0 +char div420x5 div42 0x0 +__uchar div420x5 div42 0x0 +__longlong div420x5 div42 0x0 +__ulonglong div420x5 div42 0x0 +float div420x5 div42 0x0 +int mod230x5 mod23 0x5 +__uint mod230x5 mod23 0x5 +char mod230x5 mod23 0x5 +__uchar mod230x5 mod23 0x5 +__longlong mod230x5 mod23 0x5 +__ulonglong mod230x5 mod23 0x5 +0x7 * 0xffff == -0x7 +0x7 / 0xffff == -0x7 +0x7 % 0xffff == 0x0 +int 0x7 ^ 0xffff == -0x8 (0xfff8) +__uint 0x7 ^ 0xffff == -0x8 (0xfff8) +char 0x7 ^ 0xffff == -0x8 (0xfff8) +__uchar 0x7 ^ 0xff == 0xf8 (0xf8) +__longlong 0x7 ^ 0xffff == -0x8 (0xfff8) +__ulonglong 0x7 ^ 0xffff == -0x8 (0xfff8) +int 0x7 && 0xffff == 0x1 (0x1) +__uint 0x7 && 0xffff == 0x1 (0x1) +char 0x7 && 0xffff == 0x1 (0x1) +__uchar 0x7 && 0xff == 0x1 (0x1) +__longlong 0x7 && 0xffff == 0x1 (0x1) +__ulonglong 0x7 && 0xffff == 0x1 (0x1) +int 0x7 || 0xffff == 0x1 (0x1) +__uint 0x7 || 0xffff == 0x1 (0x1) +char 0x7 || 0xffff == 0x1 (0x1) +__uchar 0x7 || 0xff == 0x1 (0x1) +__longlong 0x7 || 0xffff == 0x1 (0x1) +__ulonglong 0x7 || 0xffff == 0x1 (0x1) +int 0x7 & 0xffff == 0x7 (0x7) +__uint 0x7 & 0xffff == 0x7 (0x7) +char 0x7 & 0xffff == 0x7 (0x7) +__uchar 0x7 & 0xff == 0x7 (0x7) +__longlong 0x7 & 0xffff == 0x7 (0x7) +__ulonglong 0x7 & 0xffff == 0x7 (0x7) +int 0x7 | 0xffff == -0x1 (0xffff) +__uint 0x7 | 0xffff == -0x1 (0xffff) +char 0x7 | 0xffff == -0x1 (0xffff) +__uchar 0x7 | 0xff == 0xff (0xff) +__longlong 0x7 | 0xffff == -0x1 (0xffff) +__ulonglong 0x7 | 0xffff == -0x1 (0xffff) +int 0x7 << 0x1 == 0xe (0xe) +__uint 0x7 << 0x1 == 0xe (0xe) +char 0x7 << 0x1 == 0xe (0xe) +__uchar 0x7 << 0x1 == 0xe (0xe) +__longlong 0x7 << 0x1 == 0xe (0xe) +__ulonglong 0x7 << 0x1 == 0xe (0xe) +int 0x7 >> 0x1 == 0x3 (0x3) +__uint 0x7 >> 0x1 == 0x3 (0x3) +char 0x7 >> 0x1 == 0x3 (0x3) +__uchar 0x7 >> 0x1 == 0x3 (0x3) +__longlong 0x7 >> 0x1 == 0x3 (0x3) +__ulonglong 0x7 >> 0x1 == 0x3 (0x3) +int 0x7 + 0xffff == 0x6 (0x6) +__uint 0x7 + 0xffff == 0x6 (0x6) +char 0x7 + 0xffff == 0x6 (0x6) +__uchar 0x7 + 0xff == 0x6 (0x6) +__longlong 0x7 + 0xffff == 0x6 (0x6) +__ulonglong 0x7 + 0xffff == 0x6 (0x6) +float 0x7 + 0xffff == 0x6 (0x6) +int 0x7 - 0xffff == 0x8 (0x8) +__uint 0x7 - 0xffff == 0x8 (0x8) +char 0x7 - 0xffff == 0x8 (0x8) +__uchar 0x7 - 0xff == 0x8 (0x8) +__longlong 0x7 - 0xffff == 0x8 (0x8) +__ulonglong 0x7 - 0xffff == 0x8 (0x8) +float 0x7 - 0xffff == 0x8 (0x8) +int 0x7 * 0xffff == -0x7 (0xfff9) +__uint 0x7 * 0xffff == -0x7 (0xfff9) +char 0x7 * 0xffff == -0x7 (0xfff9) +__uchar 0x7 * 0xff == 0xf9 (0xf9) +__longlong 0x7 * 0xffff == -0x7 (0xfff9) +__ulonglong 0x7 * 0xffff == -0x7 (0xfff9) +float 0x7 * 0xffff == -0x7 (0xfff9) +int 0x7 < 0xffff == 0x0 (0x0) +__uint 0x7 < 0xffff == 0x1 (0x1) +char 0x7 < 0xffff == 0x0 (0x0) +__uchar 0x7 < 0xff == 0x1 (0x1) +__longlong 0x7 < 0xffff == 0x0 (0x0) +__ulonglong 0x7 < 0xffff == 0x1 (0x1) +float 0x7 < 0xffff == 0x0 (0x0) +int 0x7 > 0xffff == 0x1 (0x1) +__uint 0x7 > 0xffff == 0x0 (0x0) +char 0x7 > 0xffff == 0x1 (0x1) +__uchar 0x7 > 0xff == 0x0 (0x0) +__longlong 0x7 > 0xffff == 0x1 (0x1) +__ulonglong 0x7 > 0xffff == 0x0 (0x0) +float 0x7 > 0xffff == 0x1 (0x1) +int 0x7 <= 0xffff == 0x0 (0x0) +__uint 0x7 <= 0xffff == 0x1 (0x1) +char 0x7 <= 0xffff == 0x0 (0x0) +__uchar 0x7 <= 0xff == 0x1 (0x1) +__longlong 0x7 <= 0xffff == 0x0 (0x0) +__ulonglong 0x7 <= 0xffff == 0x1 (0x1) +float 0x7 <= 0xffff == 0x0 (0x0) +int 0x7 == 0xffff == 0x0 (0x0) +__uint 0x7 == 0xffff == 0x0 (0x0) +char 0x7 == 0xffff == 0x0 (0x0) +__uchar 0x7 == 0xff == 0x0 (0x0) +__longlong 0x7 == 0xffff == 0x0 (0x0) +__ulonglong 0x7 == 0xffff == 0x0 (0x0) +float 0x7 == 0xffff == 0x0 (0x0) +int 0x7 != 0xffff == 0x1 (0x1) +__uint 0x7 != 0xffff == 0x1 (0x1) +char 0x7 != 0xffff == 0x1 (0x1) +__uchar 0x7 != 0xff == 0x1 (0x1) +__longlong 0x7 != 0xffff == 0x1 (0x1) +__ulonglong 0x7 != 0xffff == 0x1 (0x1) +float 0x7 != 0xffff == 0x1 (0x1) +int 0x7 >= 0xffff == 0x1 (0x1) +__uint 0x7 >= 0xffff == 0x0 (0x0) +char 0x7 >= 0xffff == 0x1 (0x1) +__uchar 0x7 >= 0xff == 0x0 (0x0) +__longlong 0x7 >= 0xffff == 0x1 (0x1) +__ulonglong 0x7 >= 0xffff == 0x0 (0x0) +float 0x7 >= 0xffff == 0x1 (0x1) +int 0x7 / 0xffff == -0x7 (0xfff9) +__uint 0x7 / 0xffff == 0x0 (0x0) +char 0x7 / 0xffff == -0x7 (0xfff9) +__uchar 0x7 / 0xff == 0x0 (0x0) +__longlong 0x7 / 0xffff == -0x7 (0xfff9) +__ulonglong 0x7 / 0xffff == 0x0 (0x0) +float 0x7 / 0xffff == -0x7 (0xfff9) +int 0x7 % 0xffff == 0x0 (0x0) +__uint 0x7 % 0xffff == 0x7 (0x7) +char 0x7 % 0xffff == 0x0 (0x0) +__uchar 0x7 % 0xff == 0x7 (0x7) +__longlong 0x7 % 0xffff == 0x0 (0x0) +__ulonglong 0x7 % 0xffff == 0x7 (0x7) +0x7 * 0x1 == 0x7 +0x7 / 0x1 == 0x7 +0x7 % 0x1 == 0x0 +int 0x7 ^ 0x1 == 0x6 (0x6) +__uint 0x7 ^ 0x1 == 0x6 (0x6) +char 0x7 ^ 0x1 == 0x6 (0x6) +__uchar 0x7 ^ 0x1 == 0x6 (0x6) +__longlong 0x7 ^ 0x1 == 0x6 (0x6) +__ulonglong 0x7 ^ 0x1 == 0x6 (0x6) +int 0x7 && 0x1 == 0x1 (0x1) +__uint 0x7 && 0x1 == 0x1 (0x1) +char 0x7 && 0x1 == 0x1 (0x1) +__uchar 0x7 && 0x1 == 0x1 (0x1) +__longlong 0x7 && 0x1 == 0x1 (0x1) +__ulonglong 0x7 && 0x1 == 0x1 (0x1) +int 0x7 || 0x1 == 0x1 (0x1) +__uint 0x7 || 0x1 == 0x1 (0x1) +char 0x7 || 0x1 == 0x1 (0x1) +__uchar 0x7 || 0x1 == 0x1 (0x1) +__longlong 0x7 || 0x1 == 0x1 (0x1) +__ulonglong 0x7 || 0x1 == 0x1 (0x1) +int 0x7 & 0x1 == 0x1 (0x1) +__uint 0x7 & 0x1 == 0x1 (0x1) +char 0x7 & 0x1 == 0x1 (0x1) +__uchar 0x7 & 0x1 == 0x1 (0x1) +__longlong 0x7 & 0x1 == 0x1 (0x1) +__ulonglong 0x7 & 0x1 == 0x1 (0x1) +int 0x7 | 0x1 == 0x7 (0x7) +__uint 0x7 | 0x1 == 0x7 (0x7) +char 0x7 | 0x1 == 0x7 (0x7) +__uchar 0x7 | 0x1 == 0x7 (0x7) +__longlong 0x7 | 0x1 == 0x7 (0x7) +__ulonglong 0x7 | 0x1 == 0x7 (0x7) +int 0x7 << 0x2 == 0x1c (0x1c) +__uint 0x7 << 0x2 == 0x1c (0x1c) +char 0x7 << 0x2 == 0x1c (0x1c) +__uchar 0x7 << 0x2 == 0x1c (0x1c) +__longlong 0x7 << 0x2 == 0x1c (0x1c) +__ulonglong 0x7 << 0x2 == 0x1c (0x1c) +int 0x7 >> 0x2 == 0x1 (0x1) +__uint 0x7 >> 0x2 == 0x1 (0x1) +char 0x7 >> 0x2 == 0x1 (0x1) +__uchar 0x7 >> 0x2 == 0x1 (0x1) +__longlong 0x7 >> 0x2 == 0x1 (0x1) +__ulonglong 0x7 >> 0x2 == 0x1 (0x1) +int 0x7 + 0x1 == 0x8 (0x8) +__uint 0x7 + 0x1 == 0x8 (0x8) +char 0x7 + 0x1 == 0x8 (0x8) +__uchar 0x7 + 0x1 == 0x8 (0x8) +__longlong 0x7 + 0x1 == 0x8 (0x8) +__ulonglong 0x7 + 0x1 == 0x8 (0x8) +float 0x7 + 0x1 == 0x8 (0x8) +int 0x7 - 0x1 == 0x6 (0x6) +__uint 0x7 - 0x1 == 0x6 (0x6) +char 0x7 - 0x1 == 0x6 (0x6) +__uchar 0x7 - 0x1 == 0x6 (0x6) +__longlong 0x7 - 0x1 == 0x6 (0x6) +__ulonglong 0x7 - 0x1 == 0x6 (0x6) +float 0x7 - 0x1 == 0x6 (0x6) +int 0x7 * 0x1 == 0x7 (0x7) +__uint 0x7 * 0x1 == 0x7 (0x7) +char 0x7 * 0x1 == 0x7 (0x7) +__uchar 0x7 * 0x1 == 0x7 (0x7) +__longlong 0x7 * 0x1 == 0x7 (0x7) +__ulonglong 0x7 * 0x1 == 0x7 (0x7) +float 0x7 * 0x1 == 0x7 (0x7) +int 0x7 < 0x1 == 0x0 (0x0) +__uint 0x7 < 0x1 == 0x0 (0x0) +char 0x7 < 0x1 == 0x0 (0x0) +__uchar 0x7 < 0x1 == 0x0 (0x0) +__longlong 0x7 < 0x1 == 0x0 (0x0) +__ulonglong 0x7 < 0x1 == 0x0 (0x0) +float 0x7 < 0x1 == 0x0 (0x0) +int 0x7 > 0x1 == 0x1 (0x1) +__uint 0x7 > 0x1 == 0x1 (0x1) +char 0x7 > 0x1 == 0x1 (0x1) +__uchar 0x7 > 0x1 == 0x1 (0x1) +__longlong 0x7 > 0x1 == 0x1 (0x1) +__ulonglong 0x7 > 0x1 == 0x1 (0x1) +float 0x7 > 0x1 == 0x1 (0x1) +int 0x7 <= 0x1 == 0x0 (0x0) +__uint 0x7 <= 0x1 == 0x0 (0x0) +char 0x7 <= 0x1 == 0x0 (0x0) +__uchar 0x7 <= 0x1 == 0x0 (0x0) +__longlong 0x7 <= 0x1 == 0x0 (0x0) +__ulonglong 0x7 <= 0x1 == 0x0 (0x0) +float 0x7 <= 0x1 == 0x0 (0x0) +int 0x7 == 0x1 == 0x0 (0x0) +__uint 0x7 == 0x1 == 0x0 (0x0) +char 0x7 == 0x1 == 0x0 (0x0) +__uchar 0x7 == 0x1 == 0x0 (0x0) +__longlong 0x7 == 0x1 == 0x0 (0x0) +__ulonglong 0x7 == 0x1 == 0x0 (0x0) +float 0x7 == 0x1 == 0x0 (0x0) +int 0x7 != 0x1 == 0x1 (0x1) +__uint 0x7 != 0x1 == 0x1 (0x1) +char 0x7 != 0x1 == 0x1 (0x1) +__uchar 0x7 != 0x1 == 0x1 (0x1) +__longlong 0x7 != 0x1 == 0x1 (0x1) +__ulonglong 0x7 != 0x1 == 0x1 (0x1) +float 0x7 != 0x1 == 0x1 (0x1) +int 0x7 >= 0x1 == 0x1 (0x1) +__uint 0x7 >= 0x1 == 0x1 (0x1) +char 0x7 >= 0x1 == 0x1 (0x1) +__uchar 0x7 >= 0x1 == 0x1 (0x1) +__longlong 0x7 >= 0x1 == 0x1 (0x1) +__ulonglong 0x7 >= 0x1 == 0x1 (0x1) +float 0x7 >= 0x1 == 0x1 (0x1) +int 0x7 / 0x1 == 0x7 (0x7) +__uint 0x7 / 0x1 == 0x7 (0x7) +char 0x7 / 0x1 == 0x7 (0x7) +__uchar 0x7 / 0x1 == 0x7 (0x7) +__longlong 0x7 / 0x1 == 0x7 (0x7) +__ulonglong 0x7 / 0x1 == 0x7 (0x7) +float 0x7 / 0x1 == 0x7 (0x7) +int 0x7 % 0x1 == 0x0 (0x0) +__uint 0x7 % 0x1 == 0x0 (0x0) +char 0x7 % 0x1 == 0x0 (0x0) +__uchar 0x7 % 0x1 == 0x0 (0x0) +__longlong 0x7 % 0x1 == 0x0 (0x0) +__ulonglong 0x7 % 0x1 == 0x0 (0x0) +0x7 * 0x2 == 0xe +0x7 / 0x2 == 0x3 +0x7 % 0x2 == 0x1 +int 0x7 ^ 0x2 == 0x5 (0x5) +__uint 0x7 ^ 0x2 == 0x5 (0x5) +char 0x7 ^ 0x2 == 0x5 (0x5) +__uchar 0x7 ^ 0x2 == 0x5 (0x5) +__longlong 0x7 ^ 0x2 == 0x5 (0x5) +__ulonglong 0x7 ^ 0x2 == 0x5 (0x5) +int 0x7 && 0x2 == 0x1 (0x1) +__uint 0x7 && 0x2 == 0x1 (0x1) +char 0x7 && 0x2 == 0x1 (0x1) +__uchar 0x7 && 0x2 == 0x1 (0x1) +__longlong 0x7 && 0x2 == 0x1 (0x1) +__ulonglong 0x7 && 0x2 == 0x1 (0x1) +int 0x7 || 0x2 == 0x1 (0x1) +__uint 0x7 || 0x2 == 0x1 (0x1) +char 0x7 || 0x2 == 0x1 (0x1) +__uchar 0x7 || 0x2 == 0x1 (0x1) +__longlong 0x7 || 0x2 == 0x1 (0x1) +__ulonglong 0x7 || 0x2 == 0x1 (0x1) +int 0x7 & 0x2 == 0x2 (0x2) +__uint 0x7 & 0x2 == 0x2 (0x2) +char 0x7 & 0x2 == 0x2 (0x2) +__uchar 0x7 & 0x2 == 0x2 (0x2) +__longlong 0x7 & 0x2 == 0x2 (0x2) +__ulonglong 0x7 & 0x2 == 0x2 (0x2) +int 0x7 | 0x2 == 0x7 (0x7) +__uint 0x7 | 0x2 == 0x7 (0x7) +char 0x7 | 0x2 == 0x7 (0x7) +__uchar 0x7 | 0x2 == 0x7 (0x7) +__longlong 0x7 | 0x2 == 0x7 (0x7) +__ulonglong 0x7 | 0x2 == 0x7 (0x7) +int 0x7 << 0x3 == 0x38 (0x38) +__uint 0x7 << 0x3 == 0x38 (0x38) +char 0x7 << 0x3 == 0x38 (0x38) +__uchar 0x7 << 0x3 == 0x38 (0x38) +__longlong 0x7 << 0x3 == 0x38 (0x38) +__ulonglong 0x7 << 0x3 == 0x38 (0x38) +int 0x7 >> 0x3 == 0x0 (0x0) +__uint 0x7 >> 0x3 == 0x0 (0x0) +char 0x7 >> 0x3 == 0x0 (0x0) +__uchar 0x7 >> 0x3 == 0x0 (0x0) +__longlong 0x7 >> 0x3 == 0x0 (0x0) +__ulonglong 0x7 >> 0x3 == 0x0 (0x0) +int 0x7 + 0x2 == 0x9 (0x9) +__uint 0x7 + 0x2 == 0x9 (0x9) +char 0x7 + 0x2 == 0x9 (0x9) +__uchar 0x7 + 0x2 == 0x9 (0x9) +__longlong 0x7 + 0x2 == 0x9 (0x9) +__ulonglong 0x7 + 0x2 == 0x9 (0x9) +float 0x7 + 0x2 == 0x9 (0x9) +int 0x7 - 0x2 == 0x5 (0x5) +__uint 0x7 - 0x2 == 0x5 (0x5) +char 0x7 - 0x2 == 0x5 (0x5) +__uchar 0x7 - 0x2 == 0x5 (0x5) +__longlong 0x7 - 0x2 == 0x5 (0x5) +__ulonglong 0x7 - 0x2 == 0x5 (0x5) +float 0x7 - 0x2 == 0x5 (0x5) +int 0x7 * 0x2 == 0xe (0xe) +__uint 0x7 * 0x2 == 0xe (0xe) +char 0x7 * 0x2 == 0xe (0xe) +__uchar 0x7 * 0x2 == 0xe (0xe) +__longlong 0x7 * 0x2 == 0xe (0xe) +__ulonglong 0x7 * 0x2 == 0xe (0xe) +float 0x7 * 0x2 == 0xe (0xe) +int 0x7 < 0x2 == 0x0 (0x0) +__uint 0x7 < 0x2 == 0x0 (0x0) +char 0x7 < 0x2 == 0x0 (0x0) +__uchar 0x7 < 0x2 == 0x0 (0x0) +__longlong 0x7 < 0x2 == 0x0 (0x0) +__ulonglong 0x7 < 0x2 == 0x0 (0x0) +float 0x7 < 0x2 == 0x0 (0x0) +int 0x7 > 0x2 == 0x1 (0x1) +__uint 0x7 > 0x2 == 0x1 (0x1) +char 0x7 > 0x2 == 0x1 (0x1) +__uchar 0x7 > 0x2 == 0x1 (0x1) +__longlong 0x7 > 0x2 == 0x1 (0x1) +__ulonglong 0x7 > 0x2 == 0x1 (0x1) +float 0x7 > 0x2 == 0x1 (0x1) +int 0x7 <= 0x2 == 0x0 (0x0) +__uint 0x7 <= 0x2 == 0x0 (0x0) +char 0x7 <= 0x2 == 0x0 (0x0) +__uchar 0x7 <= 0x2 == 0x0 (0x0) +__longlong 0x7 <= 0x2 == 0x0 (0x0) +__ulonglong 0x7 <= 0x2 == 0x0 (0x0) +float 0x7 <= 0x2 == 0x0 (0x0) +int 0x7 == 0x2 == 0x0 (0x0) +__uint 0x7 == 0x2 == 0x0 (0x0) +char 0x7 == 0x2 == 0x0 (0x0) +__uchar 0x7 == 0x2 == 0x0 (0x0) +__longlong 0x7 == 0x2 == 0x0 (0x0) +__ulonglong 0x7 == 0x2 == 0x0 (0x0) +float 0x7 == 0x2 == 0x0 (0x0) +int 0x7 != 0x2 == 0x1 (0x1) +__uint 0x7 != 0x2 == 0x1 (0x1) +char 0x7 != 0x2 == 0x1 (0x1) +__uchar 0x7 != 0x2 == 0x1 (0x1) +__longlong 0x7 != 0x2 == 0x1 (0x1) +__ulonglong 0x7 != 0x2 == 0x1 (0x1) +float 0x7 != 0x2 == 0x1 (0x1) +int 0x7 >= 0x2 == 0x1 (0x1) +__uint 0x7 >= 0x2 == 0x1 (0x1) +char 0x7 >= 0x2 == 0x1 (0x1) +__uchar 0x7 >= 0x2 == 0x1 (0x1) +__longlong 0x7 >= 0x2 == 0x1 (0x1) +__ulonglong 0x7 >= 0x2 == 0x1 (0x1) +float 0x7 >= 0x2 == 0x1 (0x1) +int 0x7 / 0x2 == 0x3 (0x3) +__uint 0x7 / 0x2 == 0x3 (0x3) +char 0x7 / 0x2 == 0x3 (0x3) +__uchar 0x7 / 0x2 == 0x3 (0x3) +__longlong 0x7 / 0x2 == 0x3 (0x3) +__ulonglong 0x7 / 0x2 == 0x3 (0x3) +float 0x7 / 0x2 == 0x3 (0x3) +int 0x7 % 0x2 == 0x1 (0x1) +__uint 0x7 % 0x2 == 0x1 (0x1) +char 0x7 % 0x2 == 0x1 (0x1) +__uchar 0x7 % 0x2 == 0x1 (0x1) +__longlong 0x7 % 0x2 == 0x1 (0x1) +__ulonglong 0x7 % 0x2 == 0x1 (0x1) +0x7 * 0xfffe == -0xe +0x7 / 0xfffe == -0x3 +0x7 % 0xfffe == 0x1 +int 0x7 ^ 0xfffe == -0x7 (0xfff9) +__uint 0x7 ^ 0xfffe == -0x7 (0xfff9) +char 0x7 ^ 0xfffe == -0x7 (0xfff9) +__uchar 0x7 ^ 0xfe == 0xf9 (0xf9) +__longlong 0x7 ^ 0xfffe == -0x7 (0xfff9) +__ulonglong 0x7 ^ 0xfffe == -0x7 (0xfff9) +int 0x7 && 0xfffe == 0x1 (0x1) +__uint 0x7 && 0xfffe == 0x1 (0x1) +char 0x7 && 0xfffe == 0x1 (0x1) +__uchar 0x7 && 0xfe == 0x1 (0x1) +__longlong 0x7 && 0xfffe == 0x1 (0x1) +__ulonglong 0x7 && 0xfffe == 0x1 (0x1) +int 0x7 || 0xfffe == 0x1 (0x1) +__uint 0x7 || 0xfffe == 0x1 (0x1) +char 0x7 || 0xfffe == 0x1 (0x1) +__uchar 0x7 || 0xfe == 0x1 (0x1) +__longlong 0x7 || 0xfffe == 0x1 (0x1) +__ulonglong 0x7 || 0xfffe == 0x1 (0x1) +int 0x7 & 0xfffe == 0x6 (0x6) +__uint 0x7 & 0xfffe == 0x6 (0x6) +char 0x7 & 0xfffe == 0x6 (0x6) +__uchar 0x7 & 0xfe == 0x6 (0x6) +__longlong 0x7 & 0xfffe == 0x6 (0x6) +__ulonglong 0x7 & 0xfffe == 0x6 (0x6) +int 0x7 | 0xfffe == -0x1 (0xffff) +__uint 0x7 | 0xfffe == -0x1 (0xffff) +char 0x7 | 0xfffe == -0x1 (0xffff) +__uchar 0x7 | 0xfe == 0xff (0xff) +__longlong 0x7 | 0xfffe == -0x1 (0xffff) +__ulonglong 0x7 | 0xfffe == -0x1 (0xffff) +int 0x7 << 0x4 == 0x70 (0x70) +__uint 0x7 << 0x4 == 0x70 (0x70) +char 0x7 << 0x4 == 0x70 (0x70) +__uchar 0x7 << 0x4 == 0x70 (0x70) +__longlong 0x7 << 0x4 == 0x70 (0x70) +__ulonglong 0x7 << 0x4 == 0x70 (0x70) +int 0x7 >> 0x4 == 0x0 (0x0) +__uint 0x7 >> 0x4 == 0x0 (0x0) +char 0x7 >> 0x4 == 0x0 (0x0) +__uchar 0x7 >> 0x4 == 0x0 (0x0) +__longlong 0x7 >> 0x4 == 0x0 (0x0) +__ulonglong 0x7 >> 0x4 == 0x0 (0x0) +int 0x7 + 0xfffe == 0x5 (0x5) +__uint 0x7 + 0xfffe == 0x5 (0x5) +char 0x7 + 0xfffe == 0x5 (0x5) +__uchar 0x7 + 0xfe == 0x5 (0x5) +__longlong 0x7 + 0xfffe == 0x5 (0x5) +__ulonglong 0x7 + 0xfffe == 0x5 (0x5) +float 0x7 + 0xfffe == 0x5 (0x5) +int 0x7 - 0xfffe == 0x9 (0x9) +__uint 0x7 - 0xfffe == 0x9 (0x9) +char 0x7 - 0xfffe == 0x9 (0x9) +__uchar 0x7 - 0xfe == 0x9 (0x9) +__longlong 0x7 - 0xfffe == 0x9 (0x9) +__ulonglong 0x7 - 0xfffe == 0x9 (0x9) +float 0x7 - 0xfffe == 0x9 (0x9) +int 0x7 * 0xfffe == -0xe (0xfff2) +__uint 0x7 * 0xfffe == -0xe (0xfff2) +char 0x7 * 0xfffe == -0xe (0xfff2) +__uchar 0x7 * 0xfe == 0xf2 (0xf2) +__longlong 0x7 * 0xfffe == -0xe (0xfff2) +__ulonglong 0x7 * 0xfffe == -0xe (0xfff2) +float 0x7 * 0xfffe == -0xe (0xfff2) +int 0x7 < 0xfffe == 0x0 (0x0) +__uint 0x7 < 0xfffe == 0x1 (0x1) +char 0x7 < 0xfffe == 0x0 (0x0) +__uchar 0x7 < 0xfe == 0x1 (0x1) +__longlong 0x7 < 0xfffe == 0x0 (0x0) +__ulonglong 0x7 < 0xfffe == 0x1 (0x1) +float 0x7 < 0xfffe == 0x0 (0x0) +int 0x7 > 0xfffe == 0x1 (0x1) +__uint 0x7 > 0xfffe == 0x0 (0x0) +char 0x7 > 0xfffe == 0x1 (0x1) +__uchar 0x7 > 0xfe == 0x0 (0x0) +__longlong 0x7 > 0xfffe == 0x1 (0x1) +__ulonglong 0x7 > 0xfffe == 0x0 (0x0) +float 0x7 > 0xfffe == 0x1 (0x1) +int 0x7 <= 0xfffe == 0x0 (0x0) +__uint 0x7 <= 0xfffe == 0x1 (0x1) +char 0x7 <= 0xfffe == 0x0 (0x0) +__uchar 0x7 <= 0xfe == 0x1 (0x1) +__longlong 0x7 <= 0xfffe == 0x0 (0x0) +__ulonglong 0x7 <= 0xfffe == 0x1 (0x1) +float 0x7 <= 0xfffe == 0x0 (0x0) +int 0x7 == 0xfffe == 0x0 (0x0) +__uint 0x7 == 0xfffe == 0x0 (0x0) +char 0x7 == 0xfffe == 0x0 (0x0) +__uchar 0x7 == 0xfe == 0x0 (0x0) +__longlong 0x7 == 0xfffe == 0x0 (0x0) +__ulonglong 0x7 == 0xfffe == 0x0 (0x0) +float 0x7 == 0xfffe == 0x0 (0x0) +int 0x7 != 0xfffe == 0x1 (0x1) +__uint 0x7 != 0xfffe == 0x1 (0x1) +char 0x7 != 0xfffe == 0x1 (0x1) +__uchar 0x7 != 0xfe == 0x1 (0x1) +__longlong 0x7 != 0xfffe == 0x1 (0x1) +__ulonglong 0x7 != 0xfffe == 0x1 (0x1) +float 0x7 != 0xfffe == 0x1 (0x1) +int 0x7 >= 0xfffe == 0x1 (0x1) +__uint 0x7 >= 0xfffe == 0x0 (0x0) +char 0x7 >= 0xfffe == 0x1 (0x1) +__uchar 0x7 >= 0xfe == 0x0 (0x0) +__longlong 0x7 >= 0xfffe == 0x1 (0x1) +__ulonglong 0x7 >= 0xfffe == 0x0 (0x0) +float 0x7 >= 0xfffe == 0x1 (0x1) +int 0x7 / 0xfffe == -0x3 (0xfffd) +__uint 0x7 / 0xfffe == 0x0 (0x0) +char 0x7 / 0xfffe == -0x3 (0xfffd) +__uchar 0x7 / 0xfe == 0x0 (0x0) +__longlong 0x7 / 0xfffe == -0x3 (0xfffd) +__ulonglong 0x7 / 0xfffe == 0x0 (0x0) +float 0x7 / 0xfffe == -0x3 (0xfffd) +int 0x7 % 0xfffe == 0x1 (0x1) +__uint 0x7 % 0xfffe == 0x7 (0x7) +char 0x7 % 0xfffe == 0x1 (0x1) +__uchar 0x7 % 0xfe == 0x7 (0x7) +__longlong 0x7 % 0xfffe == 0x1 (0x1) +__ulonglong 0x7 % 0xfffe == 0x7 (0x7) +0x7 * 0x4 == 0x1c +0x7 / 0x4 == 0x1 +0x7 % 0x4 == 0x3 +int 0x7 ^ 0x4 == 0x3 (0x3) +__uint 0x7 ^ 0x4 == 0x3 (0x3) +char 0x7 ^ 0x4 == 0x3 (0x3) +__uchar 0x7 ^ 0x4 == 0x3 (0x3) +__longlong 0x7 ^ 0x4 == 0x3 (0x3) +__ulonglong 0x7 ^ 0x4 == 0x3 (0x3) +int 0x7 && 0x4 == 0x1 (0x1) +__uint 0x7 && 0x4 == 0x1 (0x1) +char 0x7 && 0x4 == 0x1 (0x1) +__uchar 0x7 && 0x4 == 0x1 (0x1) +__longlong 0x7 && 0x4 == 0x1 (0x1) +__ulonglong 0x7 && 0x4 == 0x1 (0x1) +int 0x7 || 0x4 == 0x1 (0x1) +__uint 0x7 || 0x4 == 0x1 (0x1) +char 0x7 || 0x4 == 0x1 (0x1) +__uchar 0x7 || 0x4 == 0x1 (0x1) +__longlong 0x7 || 0x4 == 0x1 (0x1) +__ulonglong 0x7 || 0x4 == 0x1 (0x1) +int 0x7 & 0x4 == 0x4 (0x4) +__uint 0x7 & 0x4 == 0x4 (0x4) +char 0x7 & 0x4 == 0x4 (0x4) +__uchar 0x7 & 0x4 == 0x4 (0x4) +__longlong 0x7 & 0x4 == 0x4 (0x4) +__ulonglong 0x7 & 0x4 == 0x4 (0x4) +int 0x7 | 0x4 == 0x7 (0x7) +__uint 0x7 | 0x4 == 0x7 (0x7) +char 0x7 | 0x4 == 0x7 (0x7) +__uchar 0x7 | 0x4 == 0x7 (0x7) +__longlong 0x7 | 0x4 == 0x7 (0x7) +__ulonglong 0x7 | 0x4 == 0x7 (0x7) +int 0x7 << 0x5 == 0xe0 (0xe0) +__uint 0x7 << 0x5 == 0xe0 (0xe0) +char 0x7 << 0x5 == -0x20 (0xffe0) +__uchar 0x7 << 0x5 == 0xe0 (0xe0) +__longlong 0x7 << 0x5 == 0xe0 (0xe0) +__ulonglong 0x7 << 0x5 == 0xe0 (0xe0) +int 0x7 >> 0x5 == 0x0 (0x0) +__uint 0x7 >> 0x5 == 0x0 (0x0) +char 0x7 >> 0x5 == 0x0 (0x0) +__uchar 0x7 >> 0x5 == 0x0 (0x0) +__longlong 0x7 >> 0x5 == 0x0 (0x0) +__ulonglong 0x7 >> 0x5 == 0x0 (0x0) +int 0x7 + 0x4 == 0xb (0xb) +__uint 0x7 + 0x4 == 0xb (0xb) +char 0x7 + 0x4 == 0xb (0xb) +__uchar 0x7 + 0x4 == 0xb (0xb) +__longlong 0x7 + 0x4 == 0xb (0xb) +__ulonglong 0x7 + 0x4 == 0xb (0xb) +float 0x7 + 0x4 == 0xb (0xb) +int 0x7 - 0x4 == 0x3 (0x3) +__uint 0x7 - 0x4 == 0x3 (0x3) +char 0x7 - 0x4 == 0x3 (0x3) +__uchar 0x7 - 0x4 == 0x3 (0x3) +__longlong 0x7 - 0x4 == 0x3 (0x3) +__ulonglong 0x7 - 0x4 == 0x3 (0x3) +float 0x7 - 0x4 == 0x3 (0x3) +int 0x7 * 0x4 == 0x1c (0x1c) +__uint 0x7 * 0x4 == 0x1c (0x1c) +char 0x7 * 0x4 == 0x1c (0x1c) +__uchar 0x7 * 0x4 == 0x1c (0x1c) +__longlong 0x7 * 0x4 == 0x1c (0x1c) +__ulonglong 0x7 * 0x4 == 0x1c (0x1c) +float 0x7 * 0x4 == 0x1c (0x1c) +int 0x7 < 0x4 == 0x0 (0x0) +__uint 0x7 < 0x4 == 0x0 (0x0) +char 0x7 < 0x4 == 0x0 (0x0) +__uchar 0x7 < 0x4 == 0x0 (0x0) +__longlong 0x7 < 0x4 == 0x0 (0x0) +__ulonglong 0x7 < 0x4 == 0x0 (0x0) +float 0x7 < 0x4 == 0x0 (0x0) +int 0x7 > 0x4 == 0x1 (0x1) +__uint 0x7 > 0x4 == 0x1 (0x1) +char 0x7 > 0x4 == 0x1 (0x1) +__uchar 0x7 > 0x4 == 0x1 (0x1) +__longlong 0x7 > 0x4 == 0x1 (0x1) +__ulonglong 0x7 > 0x4 == 0x1 (0x1) +float 0x7 > 0x4 == 0x1 (0x1) +int 0x7 <= 0x4 == 0x0 (0x0) +__uint 0x7 <= 0x4 == 0x0 (0x0) +char 0x7 <= 0x4 == 0x0 (0x0) +__uchar 0x7 <= 0x4 == 0x0 (0x0) +__longlong 0x7 <= 0x4 == 0x0 (0x0) +__ulonglong 0x7 <= 0x4 == 0x0 (0x0) +float 0x7 <= 0x4 == 0x0 (0x0) +int 0x7 == 0x4 == 0x0 (0x0) +__uint 0x7 == 0x4 == 0x0 (0x0) +char 0x7 == 0x4 == 0x0 (0x0) +__uchar 0x7 == 0x4 == 0x0 (0x0) +__longlong 0x7 == 0x4 == 0x0 (0x0) +__ulonglong 0x7 == 0x4 == 0x0 (0x0) +float 0x7 == 0x4 == 0x0 (0x0) +int 0x7 != 0x4 == 0x1 (0x1) +__uint 0x7 != 0x4 == 0x1 (0x1) +char 0x7 != 0x4 == 0x1 (0x1) +__uchar 0x7 != 0x4 == 0x1 (0x1) +__longlong 0x7 != 0x4 == 0x1 (0x1) +__ulonglong 0x7 != 0x4 == 0x1 (0x1) +float 0x7 != 0x4 == 0x1 (0x1) +int 0x7 >= 0x4 == 0x1 (0x1) +__uint 0x7 >= 0x4 == 0x1 (0x1) +char 0x7 >= 0x4 == 0x1 (0x1) +__uchar 0x7 >= 0x4 == 0x1 (0x1) +__longlong 0x7 >= 0x4 == 0x1 (0x1) +__ulonglong 0x7 >= 0x4 == 0x1 (0x1) +float 0x7 >= 0x4 == 0x1 (0x1) +int 0x7 / 0x4 == 0x1 (0x1) +__uint 0x7 / 0x4 == 0x1 (0x1) +char 0x7 / 0x4 == 0x1 (0x1) +__uchar 0x7 / 0x4 == 0x1 (0x1) +__longlong 0x7 / 0x4 == 0x1 (0x1) +__ulonglong 0x7 / 0x4 == 0x1 (0x1) +float 0x7 / 0x4 == 0x1 (0x1) +int 0x7 % 0x4 == 0x3 (0x3) +__uint 0x7 % 0x4 == 0x3 (0x3) +char 0x7 % 0x4 == 0x3 (0x3) +__uchar 0x7 % 0x4 == 0x3 (0x3) +__longlong 0x7 % 0x4 == 0x3 (0x3) +__ulonglong 0x7 % 0x4 == 0x3 (0x3) +0x7 * 0xfffc == -0x1c +0x7 / 0xfffc == -0x1 +0x7 % 0xfffc == 0x3 +int 0x7 ^ 0xfffc == -0x5 (0xfffb) +__uint 0x7 ^ 0xfffc == -0x5 (0xfffb) +char 0x7 ^ 0xfffc == -0x5 (0xfffb) +__uchar 0x7 ^ 0xfc == 0xfb (0xfb) +__longlong 0x7 ^ 0xfffc == -0x5 (0xfffb) +__ulonglong 0x7 ^ 0xfffc == -0x5 (0xfffb) +int 0x7 && 0xfffc == 0x1 (0x1) +__uint 0x7 && 0xfffc == 0x1 (0x1) +char 0x7 && 0xfffc == 0x1 (0x1) +__uchar 0x7 && 0xfc == 0x1 (0x1) +__longlong 0x7 && 0xfffc == 0x1 (0x1) +__ulonglong 0x7 && 0xfffc == 0x1 (0x1) +int 0x7 || 0xfffc == 0x1 (0x1) +__uint 0x7 || 0xfffc == 0x1 (0x1) +char 0x7 || 0xfffc == 0x1 (0x1) +__uchar 0x7 || 0xfc == 0x1 (0x1) +__longlong 0x7 || 0xfffc == 0x1 (0x1) +__ulonglong 0x7 || 0xfffc == 0x1 (0x1) +int 0x7 & 0xfffc == 0x4 (0x4) +__uint 0x7 & 0xfffc == 0x4 (0x4) +char 0x7 & 0xfffc == 0x4 (0x4) +__uchar 0x7 & 0xfc == 0x4 (0x4) +__longlong 0x7 & 0xfffc == 0x4 (0x4) +__ulonglong 0x7 & 0xfffc == 0x4 (0x4) +int 0x7 | 0xfffc == -0x1 (0xffff) +__uint 0x7 | 0xfffc == -0x1 (0xffff) +char 0x7 | 0xfffc == -0x1 (0xffff) +__uchar 0x7 | 0xfc == 0xff (0xff) +__longlong 0x7 | 0xfffc == -0x1 (0xffff) +__ulonglong 0x7 | 0xfffc == -0x1 (0xffff) +int 0x7 << 0x6 == 0x1c0 (0x1c0) +__uint 0x7 << 0x6 == 0x1c0 (0x1c0) +char 0x7 << 0x6 == -0x40 (0xffc0) +__uchar 0x7 << 0x6 == 0xc0 (0xc0) +__longlong 0x7 << 0x6 == 0x1c0 (0x1c0) +__ulonglong 0x7 << 0x6 == 0x1c0 (0x1c0) +int 0x7 >> 0x6 == 0x0 (0x0) +__uint 0x7 >> 0x6 == 0x0 (0x0) +char 0x7 >> 0x6 == 0x0 (0x0) +__uchar 0x7 >> 0x6 == 0x0 (0x0) +__longlong 0x7 >> 0x6 == 0x0 (0x0) +__ulonglong 0x7 >> 0x6 == 0x0 (0x0) +int 0x7 + 0xfffc == 0x3 (0x3) +__uint 0x7 + 0xfffc == 0x3 (0x3) +char 0x7 + 0xfffc == 0x3 (0x3) +__uchar 0x7 + 0xfc == 0x3 (0x3) +__longlong 0x7 + 0xfffc == 0x3 (0x3) +__ulonglong 0x7 + 0xfffc == 0x3 (0x3) +float 0x7 + 0xfffc == 0x3 (0x3) +int 0x7 - 0xfffc == 0xb (0xb) +__uint 0x7 - 0xfffc == 0xb (0xb) +char 0x7 - 0xfffc == 0xb (0xb) +__uchar 0x7 - 0xfc == 0xb (0xb) +__longlong 0x7 - 0xfffc == 0xb (0xb) +__ulonglong 0x7 - 0xfffc == 0xb (0xb) +float 0x7 - 0xfffc == 0xb (0xb) +int 0x7 * 0xfffc == -0x1c (0xffe4) +__uint 0x7 * 0xfffc == -0x1c (0xffe4) +char 0x7 * 0xfffc == -0x1c (0xffe4) +__uchar 0x7 * 0xfc == 0xe4 (0xe4) +__longlong 0x7 * 0xfffc == -0x1c (0xffe4) +__ulonglong 0x7 * 0xfffc == -0x1c (0xffe4) +float 0x7 * 0xfffc == -0x1c (0xffe4) +int 0x7 < 0xfffc == 0x0 (0x0) +__uint 0x7 < 0xfffc == 0x1 (0x1) +char 0x7 < 0xfffc == 0x0 (0x0) +__uchar 0x7 < 0xfc == 0x1 (0x1) +__longlong 0x7 < 0xfffc == 0x0 (0x0) +__ulonglong 0x7 < 0xfffc == 0x1 (0x1) +float 0x7 < 0xfffc == 0x0 (0x0) +int 0x7 > 0xfffc == 0x1 (0x1) +__uint 0x7 > 0xfffc == 0x0 (0x0) +char 0x7 > 0xfffc == 0x1 (0x1) +__uchar 0x7 > 0xfc == 0x0 (0x0) +__longlong 0x7 > 0xfffc == 0x1 (0x1) +__ulonglong 0x7 > 0xfffc == 0x0 (0x0) +float 0x7 > 0xfffc == 0x1 (0x1) +int 0x7 <= 0xfffc == 0x0 (0x0) +__uint 0x7 <= 0xfffc == 0x1 (0x1) +char 0x7 <= 0xfffc == 0x0 (0x0) +__uchar 0x7 <= 0xfc == 0x1 (0x1) +__longlong 0x7 <= 0xfffc == 0x0 (0x0) +__ulonglong 0x7 <= 0xfffc == 0x1 (0x1) +float 0x7 <= 0xfffc == 0x0 (0x0) +int 0x7 == 0xfffc == 0x0 (0x0) +__uint 0x7 == 0xfffc == 0x0 (0x0) +char 0x7 == 0xfffc == 0x0 (0x0) +__uchar 0x7 == 0xfc == 0x0 (0x0) +__longlong 0x7 == 0xfffc == 0x0 (0x0) +__ulonglong 0x7 == 0xfffc == 0x0 (0x0) +float 0x7 == 0xfffc == 0x0 (0x0) +int 0x7 != 0xfffc == 0x1 (0x1) +__uint 0x7 != 0xfffc == 0x1 (0x1) +char 0x7 != 0xfffc == 0x1 (0x1) +__uchar 0x7 != 0xfc == 0x1 (0x1) +__longlong 0x7 != 0xfffc == 0x1 (0x1) +__ulonglong 0x7 != 0xfffc == 0x1 (0x1) +float 0x7 != 0xfffc == 0x1 (0x1) +int 0x7 >= 0xfffc == 0x1 (0x1) +__uint 0x7 >= 0xfffc == 0x0 (0x0) +char 0x7 >= 0xfffc == 0x1 (0x1) +__uchar 0x7 >= 0xfc == 0x0 (0x0) +__longlong 0x7 >= 0xfffc == 0x1 (0x1) +__ulonglong 0x7 >= 0xfffc == 0x0 (0x0) +float 0x7 >= 0xfffc == 0x1 (0x1) +int 0x7 / 0xfffc == -0x1 (0xffff) +__uint 0x7 / 0xfffc == 0x0 (0x0) +char 0x7 / 0xfffc == -0x1 (0xffff) +__uchar 0x7 / 0xfc == 0x0 (0x0) +__longlong 0x7 / 0xfffc == -0x1 (0xffff) +__ulonglong 0x7 / 0xfffc == 0x0 (0x0) +float 0x7 / 0xfffc == -0x1 (0xffff) +int 0x7 % 0xfffc == 0x3 (0x3) +__uint 0x7 % 0xfffc == 0x7 (0x7) +char 0x7 % 0xfffc == 0x3 (0x3) +__uchar 0x7 % 0xfc == 0x7 (0x7) +__longlong 0x7 % 0xfffc == 0x3 (0x3) +__ulonglong 0x7 % 0xfffc == 0x7 (0x7) +0x7 * 0xa == 0x46 +0x7 / 0xa == 0x0 +0x7 % 0xa == 0x7 +int 0x7 ^ 0xa == 0xd (0xd) +__uint 0x7 ^ 0xa == 0xd (0xd) +char 0x7 ^ 0xa == 0xd (0xd) +__uchar 0x7 ^ 0xa == 0xd (0xd) +__longlong 0x7 ^ 0xa == 0xd (0xd) +__ulonglong 0x7 ^ 0xa == 0xd (0xd) +int 0x7 && 0xa == 0x1 (0x1) +__uint 0x7 && 0xa == 0x1 (0x1) +char 0x7 && 0xa == 0x1 (0x1) +__uchar 0x7 && 0xa == 0x1 (0x1) +__longlong 0x7 && 0xa == 0x1 (0x1) +__ulonglong 0x7 && 0xa == 0x1 (0x1) +int 0x7 || 0xa == 0x1 (0x1) +__uint 0x7 || 0xa == 0x1 (0x1) +char 0x7 || 0xa == 0x1 (0x1) +__uchar 0x7 || 0xa == 0x1 (0x1) +__longlong 0x7 || 0xa == 0x1 (0x1) +__ulonglong 0x7 || 0xa == 0x1 (0x1) +int 0x7 & 0xa == 0x2 (0x2) +__uint 0x7 & 0xa == 0x2 (0x2) +char 0x7 & 0xa == 0x2 (0x2) +__uchar 0x7 & 0xa == 0x2 (0x2) +__longlong 0x7 & 0xa == 0x2 (0x2) +__ulonglong 0x7 & 0xa == 0x2 (0x2) +int 0x7 | 0xa == 0xf (0xf) +__uint 0x7 | 0xa == 0xf (0xf) +char 0x7 | 0xa == 0xf (0xf) +__uchar 0x7 | 0xa == 0xf (0xf) +__longlong 0x7 | 0xa == 0xf (0xf) +__ulonglong 0x7 | 0xa == 0xf (0xf) +int 0x7 << 0x7 == 0x380 (0x380) +__uint 0x7 << 0x7 == 0x380 (0x380) +char 0x7 << 0x7 == -0x80 (0xff80) +__uchar 0x7 << 0x7 == 0x80 (0x80) +__longlong 0x7 << 0x7 == 0x380 (0x380) +__ulonglong 0x7 << 0x7 == 0x380 (0x380) +int 0x7 >> 0x7 == 0x0 (0x0) +__uint 0x7 >> 0x7 == 0x0 (0x0) +char 0x7 >> 0x7 == 0x0 (0x0) +__uchar 0x7 >> 0x7 == 0x0 (0x0) +__longlong 0x7 >> 0x7 == 0x0 (0x0) +__ulonglong 0x7 >> 0x7 == 0x0 (0x0) +int 0x7 + 0xa == 0x11 (0x11) +__uint 0x7 + 0xa == 0x11 (0x11) +char 0x7 + 0xa == 0x11 (0x11) +__uchar 0x7 + 0xa == 0x11 (0x11) +__longlong 0x7 + 0xa == 0x11 (0x11) +__ulonglong 0x7 + 0xa == 0x11 (0x11) +float 0x7 + 0xa == 0x11 (0x11) +int 0x7 - 0xa == -0x3 (0xfffd) +__uint 0x7 - 0xa == -0x3 (0xfffd) +char 0x7 - 0xa == -0x3 (0xfffd) +__uchar 0x7 - 0xa == 0xfd (0xfd) +__longlong 0x7 - 0xa == -0x3 (0xfffd) +__ulonglong 0x7 - 0xa == -0x3 (0xfffd) +float 0x7 - 0xa == -0x3 (0xfffd) +int 0x7 * 0xa == 0x46 (0x46) +__uint 0x7 * 0xa == 0x46 (0x46) +char 0x7 * 0xa == 0x46 (0x46) +__uchar 0x7 * 0xa == 0x46 (0x46) +__longlong 0x7 * 0xa == 0x46 (0x46) +__ulonglong 0x7 * 0xa == 0x46 (0x46) +float 0x7 * 0xa == 0x46 (0x46) +int 0x7 < 0xa == 0x1 (0x1) +__uint 0x7 < 0xa == 0x1 (0x1) +char 0x7 < 0xa == 0x1 (0x1) +__uchar 0x7 < 0xa == 0x1 (0x1) +__longlong 0x7 < 0xa == 0x1 (0x1) +__ulonglong 0x7 < 0xa == 0x1 (0x1) +float 0x7 < 0xa == 0x1 (0x1) +int 0x7 > 0xa == 0x0 (0x0) +__uint 0x7 > 0xa == 0x0 (0x0) +char 0x7 > 0xa == 0x0 (0x0) +__uchar 0x7 > 0xa == 0x0 (0x0) +__longlong 0x7 > 0xa == 0x0 (0x0) +__ulonglong 0x7 > 0xa == 0x0 (0x0) +float 0x7 > 0xa == 0x0 (0x0) +int 0x7 <= 0xa == 0x1 (0x1) +__uint 0x7 <= 0xa == 0x1 (0x1) +char 0x7 <= 0xa == 0x1 (0x1) +__uchar 0x7 <= 0xa == 0x1 (0x1) +__longlong 0x7 <= 0xa == 0x1 (0x1) +__ulonglong 0x7 <= 0xa == 0x1 (0x1) +float 0x7 <= 0xa == 0x1 (0x1) +int 0x7 == 0xa == 0x0 (0x0) +__uint 0x7 == 0xa == 0x0 (0x0) +char 0x7 == 0xa == 0x0 (0x0) +__uchar 0x7 == 0xa == 0x0 (0x0) +__longlong 0x7 == 0xa == 0x0 (0x0) +__ulonglong 0x7 == 0xa == 0x0 (0x0) +float 0x7 == 0xa == 0x0 (0x0) +int 0x7 != 0xa == 0x1 (0x1) +__uint 0x7 != 0xa == 0x1 (0x1) +char 0x7 != 0xa == 0x1 (0x1) +__uchar 0x7 != 0xa == 0x1 (0x1) +__longlong 0x7 != 0xa == 0x1 (0x1) +__ulonglong 0x7 != 0xa == 0x1 (0x1) +float 0x7 != 0xa == 0x1 (0x1) +int 0x7 >= 0xa == 0x0 (0x0) +__uint 0x7 >= 0xa == 0x0 (0x0) +char 0x7 >= 0xa == 0x0 (0x0) +__uchar 0x7 >= 0xa == 0x0 (0x0) +__longlong 0x7 >= 0xa == 0x0 (0x0) +__ulonglong 0x7 >= 0xa == 0x0 (0x0) +float 0x7 >= 0xa == 0x0 (0x0) +int 0x7 / 0xa == 0x0 (0x0) +__uint 0x7 / 0xa == 0x0 (0x0) +char 0x7 / 0xa == 0x0 (0x0) +__uchar 0x7 / 0xa == 0x0 (0x0) +__longlong 0x7 / 0xa == 0x0 (0x0) +__ulonglong 0x7 / 0xa == 0x0 (0x0) +float 0x7 / 0xa == 0x0 (0x0) +int 0x7 % 0xa == 0x7 (0x7) +__uint 0x7 % 0xa == 0x7 (0x7) +char 0x7 % 0xa == 0x7 (0x7) +__uchar 0x7 % 0xa == 0x7 (0x7) +__longlong 0x7 % 0xa == 0x7 (0x7) +__ulonglong 0x7 % 0xa == 0x7 (0x7) +0x7 * 0xfff6 == -0x46 +0x7 / 0xfff6 == 0x0 +0x7 % 0xfff6 == 0x7 +int 0x7 ^ 0xfff6 == -0xf (0xfff1) +__uint 0x7 ^ 0xfff6 == -0xf (0xfff1) +char 0x7 ^ 0xfff6 == -0xf (0xfff1) +__uchar 0x7 ^ 0xf6 == 0xf1 (0xf1) +__longlong 0x7 ^ 0xfff6 == -0xf (0xfff1) +__ulonglong 0x7 ^ 0xfff6 == -0xf (0xfff1) +int 0x7 && 0xfff6 == 0x1 (0x1) +__uint 0x7 && 0xfff6 == 0x1 (0x1) +char 0x7 && 0xfff6 == 0x1 (0x1) +__uchar 0x7 && 0xf6 == 0x1 (0x1) +__longlong 0x7 && 0xfff6 == 0x1 (0x1) +__ulonglong 0x7 && 0xfff6 == 0x1 (0x1) +int 0x7 || 0xfff6 == 0x1 (0x1) +__uint 0x7 || 0xfff6 == 0x1 (0x1) +char 0x7 || 0xfff6 == 0x1 (0x1) +__uchar 0x7 || 0xf6 == 0x1 (0x1) +__longlong 0x7 || 0xfff6 == 0x1 (0x1) +__ulonglong 0x7 || 0xfff6 == 0x1 (0x1) +int 0x7 & 0xfff6 == 0x6 (0x6) +__uint 0x7 & 0xfff6 == 0x6 (0x6) +char 0x7 & 0xfff6 == 0x6 (0x6) +__uchar 0x7 & 0xf6 == 0x6 (0x6) +__longlong 0x7 & 0xfff6 == 0x6 (0x6) +__ulonglong 0x7 & 0xfff6 == 0x6 (0x6) +int 0x7 | 0xfff6 == -0x9 (0xfff7) +__uint 0x7 | 0xfff6 == -0x9 (0xfff7) +char 0x7 | 0xfff6 == -0x9 (0xfff7) +__uchar 0x7 | 0xf6 == 0xf7 (0xf7) +__longlong 0x7 | 0xfff6 == -0x9 (0xfff7) +__ulonglong 0x7 | 0xfff6 == -0x9 (0xfff7) +int 0x7 << 0x8 == 0x700 (0x700) +__uint 0x7 << 0x8 == 0x700 (0x700) +char 0x7 << 0x8 == 0x0 (0x0) +__uchar 0x7 << 0x8 == 0x0 (0x0) +__longlong 0x7 << 0x8 == 0x700 (0x700) +__ulonglong 0x7 << 0x8 == 0x700 (0x700) +int 0x7 >> 0x8 == 0x0 (0x0) +__uint 0x7 >> 0x8 == 0x0 (0x0) +char 0x7 >> 0x8 == 0x0 (0x0) +__uchar 0x7 >> 0x8 == 0x0 (0x0) +__longlong 0x7 >> 0x8 == 0x0 (0x0) +__ulonglong 0x7 >> 0x8 == 0x0 (0x0) +int 0x7 + 0xfff6 == -0x3 (0xfffd) +__uint 0x7 + 0xfff6 == -0x3 (0xfffd) +char 0x7 + 0xfff6 == -0x3 (0xfffd) +__uchar 0x7 + 0xf6 == 0xfd (0xfd) +__longlong 0x7 + 0xfff6 == -0x3 (0xfffd) +__ulonglong 0x7 + 0xfff6 == -0x3 (0xfffd) +float 0x7 + 0xfff6 == -0x3 (0xfffd) +int 0x7 - 0xfff6 == 0x11 (0x11) +__uint 0x7 - 0xfff6 == 0x11 (0x11) +char 0x7 - 0xfff6 == 0x11 (0x11) +__uchar 0x7 - 0xf6 == 0x11 (0x11) +__longlong 0x7 - 0xfff6 == 0x11 (0x11) +__ulonglong 0x7 - 0xfff6 == 0x11 (0x11) +float 0x7 - 0xfff6 == 0x11 (0x11) +int 0x7 * 0xfff6 == -0x46 (0xffba) +__uint 0x7 * 0xfff6 == -0x46 (0xffba) +char 0x7 * 0xfff6 == -0x46 (0xffba) +__uchar 0x7 * 0xf6 == 0xba (0xba) +__longlong 0x7 * 0xfff6 == -0x46 (0xffba) +__ulonglong 0x7 * 0xfff6 == -0x46 (0xffba) +float 0x7 * 0xfff6 == -0x46 (0xffba) +int 0x7 < 0xfff6 == 0x0 (0x0) +__uint 0x7 < 0xfff6 == 0x1 (0x1) +char 0x7 < 0xfff6 == 0x0 (0x0) +__uchar 0x7 < 0xf6 == 0x1 (0x1) +__longlong 0x7 < 0xfff6 == 0x0 (0x0) +__ulonglong 0x7 < 0xfff6 == 0x1 (0x1) +float 0x7 < 0xfff6 == 0x0 (0x0) +int 0x7 > 0xfff6 == 0x1 (0x1) +__uint 0x7 > 0xfff6 == 0x0 (0x0) +char 0x7 > 0xfff6 == 0x1 (0x1) +__uchar 0x7 > 0xf6 == 0x0 (0x0) +__longlong 0x7 > 0xfff6 == 0x1 (0x1) +__ulonglong 0x7 > 0xfff6 == 0x0 (0x0) +float 0x7 > 0xfff6 == 0x1 (0x1) +int 0x7 <= 0xfff6 == 0x0 (0x0) +__uint 0x7 <= 0xfff6 == 0x1 (0x1) +char 0x7 <= 0xfff6 == 0x0 (0x0) +__uchar 0x7 <= 0xf6 == 0x1 (0x1) +__longlong 0x7 <= 0xfff6 == 0x0 (0x0) +__ulonglong 0x7 <= 0xfff6 == 0x1 (0x1) +float 0x7 <= 0xfff6 == 0x0 (0x0) +int 0x7 == 0xfff6 == 0x0 (0x0) +__uint 0x7 == 0xfff6 == 0x0 (0x0) +char 0x7 == 0xfff6 == 0x0 (0x0) +__uchar 0x7 == 0xf6 == 0x0 (0x0) +__longlong 0x7 == 0xfff6 == 0x0 (0x0) +__ulonglong 0x7 == 0xfff6 == 0x0 (0x0) +float 0x7 == 0xfff6 == 0x0 (0x0) +int 0x7 != 0xfff6 == 0x1 (0x1) +__uint 0x7 != 0xfff6 == 0x1 (0x1) +char 0x7 != 0xfff6 == 0x1 (0x1) +__uchar 0x7 != 0xf6 == 0x1 (0x1) +__longlong 0x7 != 0xfff6 == 0x1 (0x1) +__ulonglong 0x7 != 0xfff6 == 0x1 (0x1) +float 0x7 != 0xfff6 == 0x1 (0x1) +int 0x7 >= 0xfff6 == 0x1 (0x1) +__uint 0x7 >= 0xfff6 == 0x0 (0x0) +char 0x7 >= 0xfff6 == 0x1 (0x1) +__uchar 0x7 >= 0xf6 == 0x0 (0x0) +__longlong 0x7 >= 0xfff6 == 0x1 (0x1) +__ulonglong 0x7 >= 0xfff6 == 0x0 (0x0) +float 0x7 >= 0xfff6 == 0x1 (0x1) +int 0x7 / 0xfff6 == 0x0 (0x0) +__uint 0x7 / 0xfff6 == 0x0 (0x0) +char 0x7 / 0xfff6 == 0x0 (0x0) +__uchar 0x7 / 0xf6 == 0x0 (0x0) +__longlong 0x7 / 0xfff6 == 0x0 (0x0) +__ulonglong 0x7 / 0xfff6 == 0x0 (0x0) +float 0x7 / 0xfff6 == 0x0 (0x0) +int 0x7 % 0xfff6 == 0x7 (0x7) +__uint 0x7 % 0xfff6 == 0x7 (0x7) +char 0x7 % 0xfff6 == 0x7 (0x7) +__uchar 0x7 % 0xf6 == 0x7 (0x7) +__longlong 0x7 % 0xfff6 == 0x7 (0x7) +__ulonglong 0x7 % 0xfff6 == 0x7 (0x7) +0x7 * 0x5 == 0x23 +0x7 / 0x5 == 0x1 +0x7 % 0x5 == 0x2 +int 0x7 ^ 0x5 == 0x2 (0x2) +__uint 0x7 ^ 0x5 == 0x2 (0x2) +char 0x7 ^ 0x5 == 0x2 (0x2) +__uchar 0x7 ^ 0x5 == 0x2 (0x2) +__longlong 0x7 ^ 0x5 == 0x2 (0x2) +__ulonglong 0x7 ^ 0x5 == 0x2 (0x2) +int 0x7 && 0x5 == 0x1 (0x1) +__uint 0x7 && 0x5 == 0x1 (0x1) +char 0x7 && 0x5 == 0x1 (0x1) +__uchar 0x7 && 0x5 == 0x1 (0x1) +__longlong 0x7 && 0x5 == 0x1 (0x1) +__ulonglong 0x7 && 0x5 == 0x1 (0x1) +int 0x7 || 0x5 == 0x1 (0x1) +__uint 0x7 || 0x5 == 0x1 (0x1) +char 0x7 || 0x5 == 0x1 (0x1) +__uchar 0x7 || 0x5 == 0x1 (0x1) +__longlong 0x7 || 0x5 == 0x1 (0x1) +__ulonglong 0x7 || 0x5 == 0x1 (0x1) +int 0x7 & 0x5 == 0x5 (0x5) +__uint 0x7 & 0x5 == 0x5 (0x5) +char 0x7 & 0x5 == 0x5 (0x5) +__uchar 0x7 & 0x5 == 0x5 (0x5) +__longlong 0x7 & 0x5 == 0x5 (0x5) +__ulonglong 0x7 & 0x5 == 0x5 (0x5) +int 0x7 | 0x5 == 0x7 (0x7) +__uint 0x7 | 0x5 == 0x7 (0x7) +char 0x7 | 0x5 == 0x7 (0x7) +__uchar 0x7 | 0x5 == 0x7 (0x7) +__longlong 0x7 | 0x5 == 0x7 (0x7) +__ulonglong 0x7 | 0x5 == 0x7 (0x7) +int 0x7 << 0x9 == 0xe00 (0xe00) +__uint 0x7 << 0x9 == 0xe00 (0xe00) +char 0x7 << 0x9 == 0x0 (0x0) +__uchar 0x7 << 0x9 == 0x0 (0x0) +__longlong 0x7 << 0x9 == 0xe00 (0xe00) +__ulonglong 0x7 << 0x9 == 0xe00 (0xe00) +int 0x7 >> 0x9 == 0x0 (0x0) +__uint 0x7 >> 0x9 == 0x0 (0x0) +char 0x7 >> 0x9 == 0x0 (0x0) +__uchar 0x7 >> 0x9 == 0x0 (0x0) +__longlong 0x7 >> 0x9 == 0x0 (0x0) +__ulonglong 0x7 >> 0x9 == 0x0 (0x0) +int 0x7 + 0x5 == 0xc (0xc) +__uint 0x7 + 0x5 == 0xc (0xc) +char 0x7 + 0x5 == 0xc (0xc) +__uchar 0x7 + 0x5 == 0xc (0xc) +__longlong 0x7 + 0x5 == 0xc (0xc) +__ulonglong 0x7 + 0x5 == 0xc (0xc) +float 0x7 + 0x5 == 0xc (0xc) +int 0x7 - 0x5 == 0x2 (0x2) +__uint 0x7 - 0x5 == 0x2 (0x2) +char 0x7 - 0x5 == 0x2 (0x2) +__uchar 0x7 - 0x5 == 0x2 (0x2) +__longlong 0x7 - 0x5 == 0x2 (0x2) +__ulonglong 0x7 - 0x5 == 0x2 (0x2) +float 0x7 - 0x5 == 0x2 (0x2) +int 0x7 * 0x5 == 0x23 (0x23) +__uint 0x7 * 0x5 == 0x23 (0x23) +char 0x7 * 0x5 == 0x23 (0x23) +__uchar 0x7 * 0x5 == 0x23 (0x23) +__longlong 0x7 * 0x5 == 0x23 (0x23) +__ulonglong 0x7 * 0x5 == 0x23 (0x23) +float 0x7 * 0x5 == 0x23 (0x23) +int 0x7 < 0x5 == 0x0 (0x0) +__uint 0x7 < 0x5 == 0x0 (0x0) +char 0x7 < 0x5 == 0x0 (0x0) +__uchar 0x7 < 0x5 == 0x0 (0x0) +__longlong 0x7 < 0x5 == 0x0 (0x0) +__ulonglong 0x7 < 0x5 == 0x0 (0x0) +float 0x7 < 0x5 == 0x0 (0x0) +int 0x7 > 0x5 == 0x1 (0x1) +__uint 0x7 > 0x5 == 0x1 (0x1) +char 0x7 > 0x5 == 0x1 (0x1) +__uchar 0x7 > 0x5 == 0x1 (0x1) +__longlong 0x7 > 0x5 == 0x1 (0x1) +__ulonglong 0x7 > 0x5 == 0x1 (0x1) +float 0x7 > 0x5 == 0x1 (0x1) +int 0x7 <= 0x5 == 0x0 (0x0) +__uint 0x7 <= 0x5 == 0x0 (0x0) +char 0x7 <= 0x5 == 0x0 (0x0) +__uchar 0x7 <= 0x5 == 0x0 (0x0) +__longlong 0x7 <= 0x5 == 0x0 (0x0) +__ulonglong 0x7 <= 0x5 == 0x0 (0x0) +float 0x7 <= 0x5 == 0x0 (0x0) +int 0x7 == 0x5 == 0x0 (0x0) +__uint 0x7 == 0x5 == 0x0 (0x0) +char 0x7 == 0x5 == 0x0 (0x0) +__uchar 0x7 == 0x5 == 0x0 (0x0) +__longlong 0x7 == 0x5 == 0x0 (0x0) +__ulonglong 0x7 == 0x5 == 0x0 (0x0) +float 0x7 == 0x5 == 0x0 (0x0) +int 0x7 != 0x5 == 0x1 (0x1) +__uint 0x7 != 0x5 == 0x1 (0x1) +char 0x7 != 0x5 == 0x1 (0x1) +__uchar 0x7 != 0x5 == 0x1 (0x1) +__longlong 0x7 != 0x5 == 0x1 (0x1) +__ulonglong 0x7 != 0x5 == 0x1 (0x1) +float 0x7 != 0x5 == 0x1 (0x1) +int 0x7 >= 0x5 == 0x1 (0x1) +__uint 0x7 >= 0x5 == 0x1 (0x1) +char 0x7 >= 0x5 == 0x1 (0x1) +__uchar 0x7 >= 0x5 == 0x1 (0x1) +__longlong 0x7 >= 0x5 == 0x1 (0x1) +__ulonglong 0x7 >= 0x5 == 0x1 (0x1) +float 0x7 >= 0x5 == 0x1 (0x1) +int 0x7 / 0x5 == 0x1 (0x1) +__uint 0x7 / 0x5 == 0x1 (0x1) +char 0x7 / 0x5 == 0x1 (0x1) +__uchar 0x7 / 0x5 == 0x1 (0x1) +__longlong 0x7 / 0x5 == 0x1 (0x1) +__ulonglong 0x7 / 0x5 == 0x1 (0x1) +float 0x7 / 0x5 == 0x1 (0x1) +int 0x7 % 0x5 == 0x2 (0x2) +__uint 0x7 % 0x5 == 0x2 (0x2) +char 0x7 % 0x5 == 0x2 (0x2) +__uchar 0x7 % 0x5 == 0x2 (0x2) +__longlong 0x7 % 0x5 == 0x2 (0x2) +__ulonglong 0x7 % 0x5 == 0x2 (0x2) +0x7 * 0x7 == 0x31 +0x7 / 0x7 == 0x1 +0x7 % 0x7 == 0x0 +int 0x7 ^ 0x7 == 0x0 (0x0) +__uint 0x7 ^ 0x7 == 0x0 (0x0) +char 0x7 ^ 0x7 == 0x0 (0x0) +__uchar 0x7 ^ 0x7 == 0x0 (0x0) +__longlong 0x7 ^ 0x7 == 0x0 (0x0) +__ulonglong 0x7 ^ 0x7 == 0x0 (0x0) +int 0x7 && 0x7 == 0x1 (0x1) +__uint 0x7 && 0x7 == 0x1 (0x1) +char 0x7 && 0x7 == 0x1 (0x1) +__uchar 0x7 && 0x7 == 0x1 (0x1) +__longlong 0x7 && 0x7 == 0x1 (0x1) +__ulonglong 0x7 && 0x7 == 0x1 (0x1) +int 0x7 || 0x7 == 0x1 (0x1) +__uint 0x7 || 0x7 == 0x1 (0x1) +char 0x7 || 0x7 == 0x1 (0x1) +__uchar 0x7 || 0x7 == 0x1 (0x1) +__longlong 0x7 || 0x7 == 0x1 (0x1) +__ulonglong 0x7 || 0x7 == 0x1 (0x1) +int 0x7 & 0x7 == 0x7 (0x7) +__uint 0x7 & 0x7 == 0x7 (0x7) +char 0x7 & 0x7 == 0x7 (0x7) +__uchar 0x7 & 0x7 == 0x7 (0x7) +__longlong 0x7 & 0x7 == 0x7 (0x7) +__ulonglong 0x7 & 0x7 == 0x7 (0x7) +int 0x7 | 0x7 == 0x7 (0x7) +__uint 0x7 | 0x7 == 0x7 (0x7) +char 0x7 | 0x7 == 0x7 (0x7) +__uchar 0x7 | 0x7 == 0x7 (0x7) +__longlong 0x7 | 0x7 == 0x7 (0x7) +__ulonglong 0x7 | 0x7 == 0x7 (0x7) +int 0x7 << 0xa == 0x1c00 (0x1c00) +__uint 0x7 << 0xa == 0x1c00 (0x1c00) +char 0x7 << 0xa == 0x0 (0x0) +__uchar 0x7 << 0xa == 0x0 (0x0) +__longlong 0x7 << 0xa == 0x1c00 (0x1c00) +__ulonglong 0x7 << 0xa == 0x1c00 (0x1c00) +int 0x7 >> 0xa == 0x0 (0x0) +__uint 0x7 >> 0xa == 0x0 (0x0) +char 0x7 >> 0xa == 0x0 (0x0) +__uchar 0x7 >> 0xa == 0x0 (0x0) +__longlong 0x7 >> 0xa == 0x0 (0x0) +__ulonglong 0x7 >> 0xa == 0x0 (0x0) +int 0x7 + 0x7 == 0xe (0xe) +__uint 0x7 + 0x7 == 0xe (0xe) +char 0x7 + 0x7 == 0xe (0xe) +__uchar 0x7 + 0x7 == 0xe (0xe) +__longlong 0x7 + 0x7 == 0xe (0xe) +__ulonglong 0x7 + 0x7 == 0xe (0xe) +float 0x7 + 0x7 == 0xe (0xe) +int 0x7 - 0x7 == 0x0 (0x0) +__uint 0x7 - 0x7 == 0x0 (0x0) +char 0x7 - 0x7 == 0x0 (0x0) +__uchar 0x7 - 0x7 == 0x0 (0x0) +__longlong 0x7 - 0x7 == 0x0 (0x0) +__ulonglong 0x7 - 0x7 == 0x0 (0x0) +float 0x7 - 0x7 == 0x0 (0x0) +int 0x7 * 0x7 == 0x31 (0x31) +__uint 0x7 * 0x7 == 0x31 (0x31) +char 0x7 * 0x7 == 0x31 (0x31) +__uchar 0x7 * 0x7 == 0x31 (0x31) +__longlong 0x7 * 0x7 == 0x31 (0x31) +__ulonglong 0x7 * 0x7 == 0x31 (0x31) +float 0x7 * 0x7 == 0x31 (0x31) +int 0x7 < 0x7 == 0x0 (0x0) +__uint 0x7 < 0x7 == 0x0 (0x0) +char 0x7 < 0x7 == 0x0 (0x0) +__uchar 0x7 < 0x7 == 0x0 (0x0) +__longlong 0x7 < 0x7 == 0x0 (0x0) +__ulonglong 0x7 < 0x7 == 0x0 (0x0) +float 0x7 < 0x7 == 0x0 (0x0) +int 0x7 > 0x7 == 0x0 (0x0) +__uint 0x7 > 0x7 == 0x0 (0x0) +char 0x7 > 0x7 == 0x0 (0x0) +__uchar 0x7 > 0x7 == 0x0 (0x0) +__longlong 0x7 > 0x7 == 0x0 (0x0) +__ulonglong 0x7 > 0x7 == 0x0 (0x0) +float 0x7 > 0x7 == 0x0 (0x0) +int 0x7 <= 0x7 == 0x1 (0x1) +__uint 0x7 <= 0x7 == 0x1 (0x1) +char 0x7 <= 0x7 == 0x1 (0x1) +__uchar 0x7 <= 0x7 == 0x1 (0x1) +__longlong 0x7 <= 0x7 == 0x1 (0x1) +__ulonglong 0x7 <= 0x7 == 0x1 (0x1) +float 0x7 <= 0x7 == 0x1 (0x1) +int 0x7 == 0x7 == 0x1 (0x1) +__uint 0x7 == 0x7 == 0x1 (0x1) +char 0x7 == 0x7 == 0x1 (0x1) +__uchar 0x7 == 0x7 == 0x1 (0x1) +__longlong 0x7 == 0x7 == 0x1 (0x1) +__ulonglong 0x7 == 0x7 == 0x1 (0x1) +float 0x7 == 0x7 == 0x1 (0x1) +int 0x7 != 0x7 == 0x0 (0x0) +__uint 0x7 != 0x7 == 0x0 (0x0) +char 0x7 != 0x7 == 0x0 (0x0) +__uchar 0x7 != 0x7 == 0x0 (0x0) +__longlong 0x7 != 0x7 == 0x0 (0x0) +__ulonglong 0x7 != 0x7 == 0x0 (0x0) +float 0x7 != 0x7 == 0x0 (0x0) +int 0x7 >= 0x7 == 0x1 (0x1) +__uint 0x7 >= 0x7 == 0x1 (0x1) +char 0x7 >= 0x7 == 0x1 (0x1) +__uchar 0x7 >= 0x7 == 0x1 (0x1) +__longlong 0x7 >= 0x7 == 0x1 (0x1) +__ulonglong 0x7 >= 0x7 == 0x1 (0x1) +float 0x7 >= 0x7 == 0x1 (0x1) +int 0x7 / 0x7 == 0x1 (0x1) +__uint 0x7 / 0x7 == 0x1 (0x1) +char 0x7 / 0x7 == 0x1 (0x1) +__uchar 0x7 / 0x7 == 0x1 (0x1) +__longlong 0x7 / 0x7 == 0x1 (0x1) +__ulonglong 0x7 / 0x7 == 0x1 (0x1) +float 0x7 / 0x7 == 0x1 (0x1) +int 0x7 % 0x7 == 0x0 (0x0) +__uint 0x7 % 0x7 == 0x0 (0x0) +char 0x7 % 0x7 == 0x0 (0x0) +__uchar 0x7 % 0x7 == 0x0 (0x0) +__longlong 0x7 % 0x7 == 0x0 (0x0) +__ulonglong 0x7 % 0x7 == 0x0 (0x0) +0x7 * 0x2a == 0x126 +0x7 / 0x2a == 0x0 +0x7 % 0x2a == 0x7 +int 0x7 ^ 0x2a == 0x2d (0x2d) +__uint 0x7 ^ 0x2a == 0x2d (0x2d) +char 0x7 ^ 0x2a == 0x2d (0x2d) +__uchar 0x7 ^ 0x2a == 0x2d (0x2d) +__longlong 0x7 ^ 0x2a == 0x2d (0x2d) +__ulonglong 0x7 ^ 0x2a == 0x2d (0x2d) +int 0x7 && 0x2a == 0x1 (0x1) +__uint 0x7 && 0x2a == 0x1 (0x1) +char 0x7 && 0x2a == 0x1 (0x1) +__uchar 0x7 && 0x2a == 0x1 (0x1) +__longlong 0x7 && 0x2a == 0x1 (0x1) +__ulonglong 0x7 && 0x2a == 0x1 (0x1) +int 0x7 || 0x2a == 0x1 (0x1) +__uint 0x7 || 0x2a == 0x1 (0x1) +char 0x7 || 0x2a == 0x1 (0x1) +__uchar 0x7 || 0x2a == 0x1 (0x1) +__longlong 0x7 || 0x2a == 0x1 (0x1) +__ulonglong 0x7 || 0x2a == 0x1 (0x1) +int 0x7 & 0x2a == 0x2 (0x2) +__uint 0x7 & 0x2a == 0x2 (0x2) +char 0x7 & 0x2a == 0x2 (0x2) +__uchar 0x7 & 0x2a == 0x2 (0x2) +__longlong 0x7 & 0x2a == 0x2 (0x2) +__ulonglong 0x7 & 0x2a == 0x2 (0x2) +int 0x7 | 0x2a == 0x2f (0x2f) +__uint 0x7 | 0x2a == 0x2f (0x2f) +char 0x7 | 0x2a == 0x2f (0x2f) +__uchar 0x7 | 0x2a == 0x2f (0x2f) +__longlong 0x7 | 0x2a == 0x2f (0x2f) +__ulonglong 0x7 | 0x2a == 0x2f (0x2f) +int 0x7 << 0xc == 0x7000 (0x7000) +__uint 0x7 << 0xc == 0x7000 (0x7000) +char 0x7 << 0xc == 0x0 (0x0) +__uchar 0x7 << 0xc == 0x0 (0x0) +__longlong 0x7 << 0xc == 0x7000 (0x7000) +__ulonglong 0x7 << 0xc == 0x7000 (0x7000) +int 0x7 >> 0xc == 0x0 (0x0) +__uint 0x7 >> 0xc == 0x0 (0x0) +char 0x7 >> 0xc == 0x0 (0x0) +__uchar 0x7 >> 0xc == 0x0 (0x0) +__longlong 0x7 >> 0xc == 0x0 (0x0) +__ulonglong 0x7 >> 0xc == 0x0 (0x0) +int 0x7 + 0x2a == 0x31 (0x31) +__uint 0x7 + 0x2a == 0x31 (0x31) +char 0x7 + 0x2a == 0x31 (0x31) +__uchar 0x7 + 0x2a == 0x31 (0x31) +__longlong 0x7 + 0x2a == 0x31 (0x31) +__ulonglong 0x7 + 0x2a == 0x31 (0x31) +float 0x7 + 0x2a == 0x31 (0x31) +int 0x7 - 0x2a == -0x23 (0xffdd) +__uint 0x7 - 0x2a == -0x23 (0xffdd) +char 0x7 - 0x2a == -0x23 (0xffdd) +__uchar 0x7 - 0x2a == 0xdd (0xdd) +__longlong 0x7 - 0x2a == -0x23 (0xffdd) +__ulonglong 0x7 - 0x2a == -0x23 (0xffdd) +float 0x7 - 0x2a == -0x23 (0xffdd) +int 0x7 * 0x2a == 0x126 (0x126) +__uint 0x7 * 0x2a == 0x126 (0x126) +char 0x7 * 0x2a == 0x26 (0x26) +__uchar 0x7 * 0x2a == 0x26 (0x26) +__longlong 0x7 * 0x2a == 0x126 (0x126) +__ulonglong 0x7 * 0x2a == 0x126 (0x126) +float 0x7 * 0x2a == 0x126 (0x126) +int 0x7 < 0x2a == 0x1 (0x1) +__uint 0x7 < 0x2a == 0x1 (0x1) +char 0x7 < 0x2a == 0x1 (0x1) +__uchar 0x7 < 0x2a == 0x1 (0x1) +__longlong 0x7 < 0x2a == 0x1 (0x1) +__ulonglong 0x7 < 0x2a == 0x1 (0x1) +float 0x7 < 0x2a == 0x1 (0x1) +int 0x7 > 0x2a == 0x0 (0x0) +__uint 0x7 > 0x2a == 0x0 (0x0) +char 0x7 > 0x2a == 0x0 (0x0) +__uchar 0x7 > 0x2a == 0x0 (0x0) +__longlong 0x7 > 0x2a == 0x0 (0x0) +__ulonglong 0x7 > 0x2a == 0x0 (0x0) +float 0x7 > 0x2a == 0x0 (0x0) +int 0x7 <= 0x2a == 0x1 (0x1) +__uint 0x7 <= 0x2a == 0x1 (0x1) +char 0x7 <= 0x2a == 0x1 (0x1) +__uchar 0x7 <= 0x2a == 0x1 (0x1) +__longlong 0x7 <= 0x2a == 0x1 (0x1) +__ulonglong 0x7 <= 0x2a == 0x1 (0x1) +float 0x7 <= 0x2a == 0x1 (0x1) +int 0x7 == 0x2a == 0x0 (0x0) +__uint 0x7 == 0x2a == 0x0 (0x0) +char 0x7 == 0x2a == 0x0 (0x0) +__uchar 0x7 == 0x2a == 0x0 (0x0) +__longlong 0x7 == 0x2a == 0x0 (0x0) +__ulonglong 0x7 == 0x2a == 0x0 (0x0) +float 0x7 == 0x2a == 0x0 (0x0) +int 0x7 != 0x2a == 0x1 (0x1) +__uint 0x7 != 0x2a == 0x1 (0x1) +char 0x7 != 0x2a == 0x1 (0x1) +__uchar 0x7 != 0x2a == 0x1 (0x1) +__longlong 0x7 != 0x2a == 0x1 (0x1) +__ulonglong 0x7 != 0x2a == 0x1 (0x1) +float 0x7 != 0x2a == 0x1 (0x1) +int 0x7 >= 0x2a == 0x0 (0x0) +__uint 0x7 >= 0x2a == 0x0 (0x0) +char 0x7 >= 0x2a == 0x0 (0x0) +__uchar 0x7 >= 0x2a == 0x0 (0x0) +__longlong 0x7 >= 0x2a == 0x0 (0x0) +__ulonglong 0x7 >= 0x2a == 0x0 (0x0) +float 0x7 >= 0x2a == 0x0 (0x0) +int 0x7 / 0x2a == 0x0 (0x0) +__uint 0x7 / 0x2a == 0x0 (0x0) +char 0x7 / 0x2a == 0x0 (0x0) +__uchar 0x7 / 0x2a == 0x0 (0x0) +__longlong 0x7 / 0x2a == 0x0 (0x0) +__ulonglong 0x7 / 0x2a == 0x0 (0x0) +float 0x7 / 0x2a == 0x0 (0x0) +int 0x7 % 0x2a == 0x7 (0x7) +__uint 0x7 % 0x2a == 0x7 (0x7) +char 0x7 % 0x2a == 0x7 (0x7) +__uchar 0x7 % 0x2a == 0x7 (0x7) +__longlong 0x7 % 0x2a == 0x7 (0x7) +__ulonglong 0x7 % 0x2a == 0x7 (0x7) +0x7 * 0x17 == 0xa1 +0x7 / 0x17 == 0x0 +0x7 % 0x17 == 0x7 +int 0x7 ^ 0x17 == 0x10 (0x10) +__uint 0x7 ^ 0x17 == 0x10 (0x10) +char 0x7 ^ 0x17 == 0x10 (0x10) +__uchar 0x7 ^ 0x17 == 0x10 (0x10) +__longlong 0x7 ^ 0x17 == 0x10 (0x10) +__ulonglong 0x7 ^ 0x17 == 0x10 (0x10) +int 0x7 && 0x17 == 0x1 (0x1) +__uint 0x7 && 0x17 == 0x1 (0x1) +char 0x7 && 0x17 == 0x1 (0x1) +__uchar 0x7 && 0x17 == 0x1 (0x1) +__longlong 0x7 && 0x17 == 0x1 (0x1) +__ulonglong 0x7 && 0x17 == 0x1 (0x1) +int 0x7 || 0x17 == 0x1 (0x1) +__uint 0x7 || 0x17 == 0x1 (0x1) +char 0x7 || 0x17 == 0x1 (0x1) +__uchar 0x7 || 0x17 == 0x1 (0x1) +__longlong 0x7 || 0x17 == 0x1 (0x1) +__ulonglong 0x7 || 0x17 == 0x1 (0x1) +int 0x7 & 0x17 == 0x7 (0x7) +__uint 0x7 & 0x17 == 0x7 (0x7) +char 0x7 & 0x17 == 0x7 (0x7) +__uchar 0x7 & 0x17 == 0x7 (0x7) +__longlong 0x7 & 0x17 == 0x7 (0x7) +__ulonglong 0x7 & 0x17 == 0x7 (0x7) +int 0x7 | 0x17 == 0x17 (0x17) +__uint 0x7 | 0x17 == 0x17 (0x17) +char 0x7 | 0x17 == 0x17 (0x17) +__uchar 0x7 | 0x17 == 0x17 (0x17) +__longlong 0x7 | 0x17 == 0x17 (0x17) +__ulonglong 0x7 | 0x17 == 0x17 (0x17) +int 0x7 << 0xe == -0x4000 (0xc000) +__uint 0x7 << 0xe == -0x4000 (0xc000) +char 0x7 << 0xe == 0x0 (0x0) +__uchar 0x7 << 0xe == 0x0 (0x0) +__longlong 0x7 << 0xe == -0x4000 (0xc000) +__ulonglong 0x7 << 0xe == -0x4000 (0xc000) +int 0x7 >> 0xe == 0x0 (0x0) +__uint 0x7 >> 0xe == 0x0 (0x0) +char 0x7 >> 0xe == 0x0 (0x0) +__uchar 0x7 >> 0xe == 0x0 (0x0) +__longlong 0x7 >> 0xe == 0x0 (0x0) +__ulonglong 0x7 >> 0xe == 0x0 (0x0) +int 0x7 + 0x17 == 0x1e (0x1e) +__uint 0x7 + 0x17 == 0x1e (0x1e) +char 0x7 + 0x17 == 0x1e (0x1e) +__uchar 0x7 + 0x17 == 0x1e (0x1e) +__longlong 0x7 + 0x17 == 0x1e (0x1e) +__ulonglong 0x7 + 0x17 == 0x1e (0x1e) +float 0x7 + 0x17 == 0x1e (0x1e) +int 0x7 - 0x17 == -0x10 (0xfff0) +__uint 0x7 - 0x17 == -0x10 (0xfff0) +char 0x7 - 0x17 == -0x10 (0xfff0) +__uchar 0x7 - 0x17 == 0xf0 (0xf0) +__longlong 0x7 - 0x17 == -0x10 (0xfff0) +__ulonglong 0x7 - 0x17 == -0x10 (0xfff0) +float 0x7 - 0x17 == -0x10 (0xfff0) +int 0x7 * 0x17 == 0xa1 (0xa1) +__uint 0x7 * 0x17 == 0xa1 (0xa1) +char 0x7 * 0x17 == -0x5f (0xffa1) +__uchar 0x7 * 0x17 == 0xa1 (0xa1) +__longlong 0x7 * 0x17 == 0xa1 (0xa1) +__ulonglong 0x7 * 0x17 == 0xa1 (0xa1) +float 0x7 * 0x17 == 0xa1 (0xa1) +int 0x7 < 0x17 == 0x1 (0x1) +__uint 0x7 < 0x17 == 0x1 (0x1) +char 0x7 < 0x17 == 0x1 (0x1) +__uchar 0x7 < 0x17 == 0x1 (0x1) +__longlong 0x7 < 0x17 == 0x1 (0x1) +__ulonglong 0x7 < 0x17 == 0x1 (0x1) +float 0x7 < 0x17 == 0x1 (0x1) +int 0x7 > 0x17 == 0x0 (0x0) +__uint 0x7 > 0x17 == 0x0 (0x0) +char 0x7 > 0x17 == 0x0 (0x0) +__uchar 0x7 > 0x17 == 0x0 (0x0) +__longlong 0x7 > 0x17 == 0x0 (0x0) +__ulonglong 0x7 > 0x17 == 0x0 (0x0) +float 0x7 > 0x17 == 0x0 (0x0) +int 0x7 <= 0x17 == 0x1 (0x1) +__uint 0x7 <= 0x17 == 0x1 (0x1) +char 0x7 <= 0x17 == 0x1 (0x1) +__uchar 0x7 <= 0x17 == 0x1 (0x1) +__longlong 0x7 <= 0x17 == 0x1 (0x1) +__ulonglong 0x7 <= 0x17 == 0x1 (0x1) +float 0x7 <= 0x17 == 0x1 (0x1) +int 0x7 == 0x17 == 0x0 (0x0) +__uint 0x7 == 0x17 == 0x0 (0x0) +char 0x7 == 0x17 == 0x0 (0x0) +__uchar 0x7 == 0x17 == 0x0 (0x0) +__longlong 0x7 == 0x17 == 0x0 (0x0) +__ulonglong 0x7 == 0x17 == 0x0 (0x0) +float 0x7 == 0x17 == 0x0 (0x0) +int 0x7 != 0x17 == 0x1 (0x1) +__uint 0x7 != 0x17 == 0x1 (0x1) +char 0x7 != 0x17 == 0x1 (0x1) +__uchar 0x7 != 0x17 == 0x1 (0x1) +__longlong 0x7 != 0x17 == 0x1 (0x1) +__ulonglong 0x7 != 0x17 == 0x1 (0x1) +float 0x7 != 0x17 == 0x1 (0x1) +int 0x7 >= 0x17 == 0x0 (0x0) +__uint 0x7 >= 0x17 == 0x0 (0x0) +char 0x7 >= 0x17 == 0x0 (0x0) +__uchar 0x7 >= 0x17 == 0x0 (0x0) +__longlong 0x7 >= 0x17 == 0x0 (0x0) +__ulonglong 0x7 >= 0x17 == 0x0 (0x0) +float 0x7 >= 0x17 == 0x0 (0x0) +int 0x7 / 0x17 == 0x0 (0x0) +__uint 0x7 / 0x17 == 0x0 (0x0) +char 0x7 / 0x17 == 0x0 (0x0) +__uchar 0x7 / 0x17 == 0x0 (0x0) +__longlong 0x7 / 0x17 == 0x0 (0x0) +__ulonglong 0x7 / 0x17 == 0x0 (0x0) +float 0x7 / 0x17 == 0x0 (0x0) +int 0x7 % 0x17 == 0x7 (0x7) +__uint 0x7 % 0x17 == 0x7 (0x7) +char 0x7 % 0x17 == 0x7 (0x7) +__uchar 0x7 % 0x17 == 0x7 (0x7) +__longlong 0x7 % 0x17 == 0x7 (0x7) +__ulonglong 0x7 % 0x17 == 0x7 (0x7) +0x7 * 0x7fff == 0x7ff9 +0x7 / 0x7fff == 0x0 +0x7 % 0x7fff == 0x7 +int 0x7 ^ 0x7fff == 0x7ff8 (0x7ff8) +__uint 0x7 ^ 0x7fff == 0x7ff8 (0x7ff8) +char 0x7 ^ 0xffff == -0x8 (0xfff8) +__uchar 0x7 ^ 0xff == 0xf8 (0xf8) +__longlong 0x7 ^ 0x7fff == 0x7ff8 (0x7ff8) +__ulonglong 0x7 ^ 0x7fff == 0x7ff8 (0x7ff8) +int 0x7 && 0x7fff == 0x1 (0x1) +__uint 0x7 && 0x7fff == 0x1 (0x1) +char 0x7 && 0xffff == 0x1 (0x1) +__uchar 0x7 && 0xff == 0x1 (0x1) +__longlong 0x7 && 0x7fff == 0x1 (0x1) +__ulonglong 0x7 && 0x7fff == 0x1 (0x1) +int 0x7 || 0x7fff == 0x1 (0x1) +__uint 0x7 || 0x7fff == 0x1 (0x1) +char 0x7 || 0xffff == 0x1 (0x1) +__uchar 0x7 || 0xff == 0x1 (0x1) +__longlong 0x7 || 0x7fff == 0x1 (0x1) +__ulonglong 0x7 || 0x7fff == 0x1 (0x1) +int 0x7 & 0x7fff == 0x7 (0x7) +__uint 0x7 & 0x7fff == 0x7 (0x7) +char 0x7 & 0xffff == 0x7 (0x7) +__uchar 0x7 & 0xff == 0x7 (0x7) +__longlong 0x7 & 0x7fff == 0x7 (0x7) +__ulonglong 0x7 & 0x7fff == 0x7 (0x7) +int 0x7 | 0x7fff == 0x7fff (0x7fff) +__uint 0x7 | 0x7fff == 0x7fff (0x7fff) +char 0x7 | 0xffff == -0x1 (0xffff) +__uchar 0x7 | 0xff == 0xff (0xff) +__longlong 0x7 | 0x7fff == 0x7fff (0x7fff) +__ulonglong 0x7 | 0x7fff == 0x7fff (0x7fff) +int 0x7 << 0x10 == 0x0 (0x0) +__uint 0x7 << 0x10 == 0x0 (0x0) +char 0x7 << 0x10 == 0x0 (0x0) +__uchar 0x7 << 0x10 == 0x0 (0x0) +__longlong 0x7 << 0x10 == 0x0 (0x0) +__ulonglong 0x7 << 0x10 == 0x0 (0x0) +int 0x7 >> 0x10 == 0x0 (0x0) +__uint 0x7 >> 0x10 == 0x0 (0x0) +char 0x7 >> 0x10 == 0x0 (0x0) +__uchar 0x7 >> 0x10 == 0x0 (0x0) +__longlong 0x7 >> 0x10 == 0x0 (0x0) +__ulonglong 0x7 >> 0x10 == 0x0 (0x0) +int 0x7 + 0x7fff == -0x7ffa (0x8006) +__uint 0x7 + 0x7fff == -0x7ffa (0x8006) +char 0x7 + 0xffff == 0x6 (0x6) +__uchar 0x7 + 0xff == 0x6 (0x6) +__longlong 0x7 + 0x7fff == -0x7ffa (0x8006) +__ulonglong 0x7 + 0x7fff == -0x7ffa (0x8006) +float 0x7 + 0x7fff == -0x7ffa (0x8006) +int 0x7 - 0x7fff == -0x7ff8 (0x8008) +__uint 0x7 - 0x7fff == -0x7ff8 (0x8008) +char 0x7 - 0xffff == 0x8 (0x8) +__uchar 0x7 - 0xff == 0x8 (0x8) +__longlong 0x7 - 0x7fff == -0x7ff8 (0x8008) +__ulonglong 0x7 - 0x7fff == -0x7ff8 (0x8008) +float 0x7 - 0x7fff == -0x7ff8 (0x8008) +int 0x7 * 0x7fff == 0x7ff9 (0x7ff9) +__uint 0x7 * 0x7fff == 0x7ff9 (0x7ff9) +char 0x7 * 0xffff == -0x7 (0xfff9) +__uchar 0x7 * 0xff == 0xf9 (0xf9) +__longlong 0x7 * 0x7fff == 0x7ff9 (0x7ff9) +__ulonglong 0x7 * 0x7fff == 0x7ff9 (0x7ff9) +float 0x7 * 0x7fff == 0x7ff9 (0x7ff9) +int 0x7 < 0x7fff == 0x1 (0x1) +__uint 0x7 < 0x7fff == 0x1 (0x1) +char 0x7 < 0xffff == 0x0 (0x0) +__uchar 0x7 < 0xff == 0x1 (0x1) +__longlong 0x7 < 0x7fff == 0x1 (0x1) +__ulonglong 0x7 < 0x7fff == 0x1 (0x1) +float 0x7 < 0x7fff == 0x1 (0x1) +int 0x7 > 0x7fff == 0x0 (0x0) +__uint 0x7 > 0x7fff == 0x0 (0x0) +char 0x7 > 0xffff == 0x1 (0x1) +__uchar 0x7 > 0xff == 0x0 (0x0) +__longlong 0x7 > 0x7fff == 0x0 (0x0) +__ulonglong 0x7 > 0x7fff == 0x0 (0x0) +float 0x7 > 0x7fff == 0x0 (0x0) +int 0x7 <= 0x7fff == 0x1 (0x1) +__uint 0x7 <= 0x7fff == 0x1 (0x1) +char 0x7 <= 0xffff == 0x0 (0x0) +__uchar 0x7 <= 0xff == 0x1 (0x1) +__longlong 0x7 <= 0x7fff == 0x1 (0x1) +__ulonglong 0x7 <= 0x7fff == 0x1 (0x1) +float 0x7 <= 0x7fff == 0x1 (0x1) +int 0x7 == 0x7fff == 0x0 (0x0) +__uint 0x7 == 0x7fff == 0x0 (0x0) +char 0x7 == 0xffff == 0x0 (0x0) +__uchar 0x7 == 0xff == 0x0 (0x0) +__longlong 0x7 == 0x7fff == 0x0 (0x0) +__ulonglong 0x7 == 0x7fff == 0x0 (0x0) +float 0x7 == 0x7fff == 0x0 (0x0) +int 0x7 != 0x7fff == 0x1 (0x1) +__uint 0x7 != 0x7fff == 0x1 (0x1) +char 0x7 != 0xffff == 0x1 (0x1) +__uchar 0x7 != 0xff == 0x1 (0x1) +__longlong 0x7 != 0x7fff == 0x1 (0x1) +__ulonglong 0x7 != 0x7fff == 0x1 (0x1) +float 0x7 != 0x7fff == 0x1 (0x1) +int 0x7 >= 0x7fff == 0x0 (0x0) +__uint 0x7 >= 0x7fff == 0x0 (0x0) +char 0x7 >= 0xffff == 0x1 (0x1) +__uchar 0x7 >= 0xff == 0x0 (0x0) +__longlong 0x7 >= 0x7fff == 0x0 (0x0) +__ulonglong 0x7 >= 0x7fff == 0x0 (0x0) +float 0x7 >= 0x7fff == 0x0 (0x0) +int 0x7 / 0x7fff == 0x0 (0x0) +__uint 0x7 / 0x7fff == 0x0 (0x0) +char 0x7 / 0xffff == -0x7 (0xfff9) +__uchar 0x7 / 0xff == 0x0 (0x0) +__longlong 0x7 / 0x7fff == 0x0 (0x0) +__ulonglong 0x7 / 0x7fff == 0x0 (0x0) +float 0x7 / 0x7fff == 0x0 (0x0) +int 0x7 % 0x7fff == 0x7 (0x7) +__uint 0x7 % 0x7fff == 0x7 (0x7) +char 0x7 % 0xffff == 0x0 (0x0) +__uchar 0x7 % 0xff == 0x7 (0x7) +__longlong 0x7 % 0x7fff == 0x7 (0x7) +__ulonglong 0x7 % 0x7fff == 0x7 (0x7) +0x7 * 0x8000 == -0x8000 +0x7 / 0x8000 == 0x0 +0x7 % 0x8000 == 0x7 +int 0x7 ^ 0x8000 == -0x7ff9 (0x8007) +__uint 0x7 ^ 0x8000 == -0x7ff9 (0x8007) +char 0x7 ^ 0x0 == 0x7 (0x7) +__uchar 0x7 ^ 0x0 == 0x7 (0x7) +__longlong 0x7 ^ 0x8000 == -0x7ff9 (0x8007) +__ulonglong 0x7 ^ 0x8000 == -0x7ff9 (0x8007) +int 0x7 && 0x8000 == 0x1 (0x1) +__uint 0x7 && 0x8000 == 0x1 (0x1) +char 0x7 && 0x0 == 0x0 (0x0) +__uchar 0x7 && 0x0 == 0x0 (0x0) +__longlong 0x7 && 0x8000 == 0x1 (0x1) +__ulonglong 0x7 && 0x8000 == 0x1 (0x1) +int 0x7 || 0x8000 == 0x1 (0x1) +__uint 0x7 || 0x8000 == 0x1 (0x1) +char 0x7 || 0x0 == 0x1 (0x1) +__uchar 0x7 || 0x0 == 0x1 (0x1) +__longlong 0x7 || 0x8000 == 0x1 (0x1) +__ulonglong 0x7 || 0x8000 == 0x1 (0x1) +int 0x7 & 0x8000 == 0x0 (0x0) +__uint 0x7 & 0x8000 == 0x0 (0x0) +char 0x7 & 0x0 == 0x0 (0x0) +__uchar 0x7 & 0x0 == 0x0 (0x0) +__longlong 0x7 & 0x8000 == 0x0 (0x0) +__ulonglong 0x7 & 0x8000 == 0x0 (0x0) +int 0x7 | 0x8000 == -0x7ff9 (0x8007) +__uint 0x7 | 0x8000 == -0x7ff9 (0x8007) +char 0x7 | 0x0 == 0x7 (0x7) +__uchar 0x7 | 0x0 == 0x7 (0x7) +__longlong 0x7 | 0x8000 == -0x7ff9 (0x8007) +__ulonglong 0x7 | 0x8000 == -0x7ff9 (0x8007) +int 0x7 << 0x12 == 0x0 (0x0) +__uint 0x7 << 0x12 == 0x0 (0x0) +char 0x7 << 0x12 == 0x0 (0x0) +__uchar 0x7 << 0x12 == 0x0 (0x0) +__longlong 0x7 << 0x12 == 0x0 (0x0) +__ulonglong 0x7 << 0x12 == 0x0 (0x0) +int 0x7 >> 0x12 == 0x0 (0x0) +__uint 0x7 >> 0x12 == 0x0 (0x0) +char 0x7 >> 0x12 == 0x0 (0x0) +__uchar 0x7 >> 0x12 == 0x0 (0x0) +__longlong 0x7 >> 0x12 == 0x0 (0x0) +__ulonglong 0x7 >> 0x12 == 0x0 (0x0) +int 0x7 + 0x8000 == -0x7ff9 (0x8007) +__uint 0x7 + 0x8000 == -0x7ff9 (0x8007) +char 0x7 + 0x0 == 0x7 (0x7) +__uchar 0x7 + 0x0 == 0x7 (0x7) +__longlong 0x7 + 0x8000 == -0x7ff9 (0x8007) +__ulonglong 0x7 + 0x8000 == -0x7ff9 (0x8007) +float 0x7 + 0x8000 == -0x7ff9 (0x8007) +int 0x7 - 0x8000 == -0x7ff9 (0x8007) +__uint 0x7 - 0x8000 == -0x7ff9 (0x8007) +char 0x7 - 0x0 == 0x7 (0x7) +__uchar 0x7 - 0x0 == 0x7 (0x7) +__longlong 0x7 - 0x8000 == -0x7ff9 (0x8007) +__ulonglong 0x7 - 0x8000 == -0x7ff9 (0x8007) +float 0x7 - 0x8000 == -0x7ff9 (0x8007) +int 0x7 * 0x8000 == -0x8000 (0x8000) +__uint 0x7 * 0x8000 == -0x8000 (0x8000) +char 0x7 * 0x0 == 0x0 (0x0) +__uchar 0x7 * 0x0 == 0x0 (0x0) +__longlong 0x7 * 0x8000 == -0x8000 (0x8000) +__ulonglong 0x7 * 0x8000 == -0x8000 (0x8000) +float 0x7 * 0x8000 == -0x8000 (0x8000) +int 0x7 < 0x8000 == 0x0 (0x0) +__uint 0x7 < 0x8000 == 0x1 (0x1) +char 0x7 < 0x0 == 0x0 (0x0) +__uchar 0x7 < 0x0 == 0x0 (0x0) +__longlong 0x7 < 0x8000 == 0x0 (0x0) +__ulonglong 0x7 < 0x8000 == 0x1 (0x1) +float 0x7 < 0x8000 == 0x0 (0x0) +int 0x7 > 0x8000 == 0x1 (0x1) +__uint 0x7 > 0x8000 == 0x0 (0x0) +char 0x7 > 0x0 == 0x1 (0x1) +__uchar 0x7 > 0x0 == 0x1 (0x1) +__longlong 0x7 > 0x8000 == 0x1 (0x1) +__ulonglong 0x7 > 0x8000 == 0x0 (0x0) +float 0x7 > 0x8000 == 0x1 (0x1) +int 0x7 <= 0x8000 == 0x0 (0x0) +__uint 0x7 <= 0x8000 == 0x1 (0x1) +char 0x7 <= 0x0 == 0x0 (0x0) +__uchar 0x7 <= 0x0 == 0x0 (0x0) +__longlong 0x7 <= 0x8000 == 0x0 (0x0) +__ulonglong 0x7 <= 0x8000 == 0x1 (0x1) +float 0x7 <= 0x8000 == 0x0 (0x0) +int 0x7 == 0x8000 == 0x0 (0x0) +__uint 0x7 == 0x8000 == 0x0 (0x0) +char 0x7 == 0x0 == 0x0 (0x0) +__uchar 0x7 == 0x0 == 0x0 (0x0) +__longlong 0x7 == 0x8000 == 0x0 (0x0) +__ulonglong 0x7 == 0x8000 == 0x0 (0x0) +float 0x7 == 0x8000 == 0x0 (0x0) +int 0x7 != 0x8000 == 0x1 (0x1) +__uint 0x7 != 0x8000 == 0x1 (0x1) +char 0x7 != 0x0 == 0x1 (0x1) +__uchar 0x7 != 0x0 == 0x1 (0x1) +__longlong 0x7 != 0x8000 == 0x1 (0x1) +__ulonglong 0x7 != 0x8000 == 0x1 (0x1) +float 0x7 != 0x8000 == 0x1 (0x1) +int 0x7 >= 0x8000 == 0x1 (0x1) +__uint 0x7 >= 0x8000 == 0x0 (0x0) +char 0x7 >= 0x0 == 0x1 (0x1) +__uchar 0x7 >= 0x0 == 0x1 (0x1) +__longlong 0x7 >= 0x8000 == 0x1 (0x1) +__ulonglong 0x7 >= 0x8000 == 0x0 (0x0) +float 0x7 >= 0x8000 == 0x1 (0x1) +int 0x7 / 0x8000 == 0x0 (0x0) +__uint 0x7 / 0x8000 == 0x0 (0x0) +__longlong 0x7 / 0x8000 == 0x0 (0x0) +__ulonglong 0x7 / 0x8000 == 0x0 (0x0) +float 0x7 / 0x8000 == 0x0 (0x0) +int 0x7 % 0x8000 == 0x7 (0x7) +__uint 0x7 % 0x8000 == 0x7 (0x7) +__longlong 0x7 % 0x8000 == 0x7 (0x7) +__ulonglong 0x7 % 0x8000 == 0x7 (0x7) +0x7 * 0x3e8 == 0x1b58 +0x7 / 0x3e8 == 0x0 +0x7 % 0x3e8 == 0x7 +int 0x7 ^ 0x3e8 == 0x3ef (0x3ef) +__uint 0x7 ^ 0x3e8 == 0x3ef (0x3ef) +char 0x7 ^ 0xffe8 == -0x11 (0xffef) +__uchar 0x7 ^ 0xe8 == 0xef (0xef) +__longlong 0x7 ^ 0x3e8 == 0x3ef (0x3ef) +__ulonglong 0x7 ^ 0x3e8 == 0x3ef (0x3ef) +int 0x7 && 0x3e8 == 0x1 (0x1) +__uint 0x7 && 0x3e8 == 0x1 (0x1) +char 0x7 && 0xffe8 == 0x1 (0x1) +__uchar 0x7 && 0xe8 == 0x1 (0x1) +__longlong 0x7 && 0x3e8 == 0x1 (0x1) +__ulonglong 0x7 && 0x3e8 == 0x1 (0x1) +int 0x7 || 0x3e8 == 0x1 (0x1) +__uint 0x7 || 0x3e8 == 0x1 (0x1) +char 0x7 || 0xffe8 == 0x1 (0x1) +__uchar 0x7 || 0xe8 == 0x1 (0x1) +__longlong 0x7 || 0x3e8 == 0x1 (0x1) +__ulonglong 0x7 || 0x3e8 == 0x1 (0x1) +int 0x7 & 0x3e8 == 0x0 (0x0) +__uint 0x7 & 0x3e8 == 0x0 (0x0) +char 0x7 & 0xffe8 == 0x0 (0x0) +__uchar 0x7 & 0xe8 == 0x0 (0x0) +__longlong 0x7 & 0x3e8 == 0x0 (0x0) +__ulonglong 0x7 & 0x3e8 == 0x0 (0x0) +int 0x7 | 0x3e8 == 0x3ef (0x3ef) +__uint 0x7 | 0x3e8 == 0x3ef (0x3ef) +char 0x7 | 0xffe8 == -0x11 (0xffef) +__uchar 0x7 | 0xe8 == 0xef (0xef) +__longlong 0x7 | 0x3e8 == 0x3ef (0x3ef) +__ulonglong 0x7 | 0x3e8 == 0x3ef (0x3ef) +int 0x7 << 0x14 == 0x0 (0x0) +__uint 0x7 << 0x14 == 0x0 (0x0) +char 0x7 << 0x14 == 0x0 (0x0) +__uchar 0x7 << 0x14 == 0x0 (0x0) +__longlong 0x7 << 0x14 == 0x0 (0x0) +__ulonglong 0x7 << 0x14 == 0x0 (0x0) +int 0x7 >> 0x14 == 0x0 (0x0) +__uint 0x7 >> 0x14 == 0x0 (0x0) +char 0x7 >> 0x14 == 0x0 (0x0) +__uchar 0x7 >> 0x14 == 0x0 (0x0) +__longlong 0x7 >> 0x14 == 0x0 (0x0) +__ulonglong 0x7 >> 0x14 == 0x0 (0x0) +int 0x7 + 0x3e8 == 0x3ef (0x3ef) +__uint 0x7 + 0x3e8 == 0x3ef (0x3ef) +char 0x7 + 0xffe8 == -0x11 (0xffef) +__uchar 0x7 + 0xe8 == 0xef (0xef) +__longlong 0x7 + 0x3e8 == 0x3ef (0x3ef) +__ulonglong 0x7 + 0x3e8 == 0x3ef (0x3ef) +float 0x7 + 0x3e8 == 0x3ef (0x3ef) +int 0x7 - 0x3e8 == -0x3e1 (0xfc1f) +__uint 0x7 - 0x3e8 == -0x3e1 (0xfc1f) +char 0x7 - 0xffe8 == 0x1f (0x1f) +__uchar 0x7 - 0xe8 == 0x1f (0x1f) +__longlong 0x7 - 0x3e8 == -0x3e1 (0xfc1f) +__ulonglong 0x7 - 0x3e8 == -0x3e1 (0xfc1f) +float 0x7 - 0x3e8 == -0x3e1 (0xfc1f) +int 0x7 * 0x3e8 == 0x1b58 (0x1b58) +__uint 0x7 * 0x3e8 == 0x1b58 (0x1b58) +char 0x7 * 0xffe8 == 0x58 (0x58) +__uchar 0x7 * 0xe8 == 0x58 (0x58) +__longlong 0x7 * 0x3e8 == 0x1b58 (0x1b58) +__ulonglong 0x7 * 0x3e8 == 0x1b58 (0x1b58) +float 0x7 * 0x3e8 == 0x1b58 (0x1b58) +int 0x7 < 0x3e8 == 0x1 (0x1) +__uint 0x7 < 0x3e8 == 0x1 (0x1) +char 0x7 < 0xffe8 == 0x0 (0x0) +__uchar 0x7 < 0xe8 == 0x1 (0x1) +__longlong 0x7 < 0x3e8 == 0x1 (0x1) +__ulonglong 0x7 < 0x3e8 == 0x1 (0x1) +float 0x7 < 0x3e8 == 0x1 (0x1) +int 0x7 > 0x3e8 == 0x0 (0x0) +__uint 0x7 > 0x3e8 == 0x0 (0x0) +char 0x7 > 0xffe8 == 0x1 (0x1) +__uchar 0x7 > 0xe8 == 0x0 (0x0) +__longlong 0x7 > 0x3e8 == 0x0 (0x0) +__ulonglong 0x7 > 0x3e8 == 0x0 (0x0) +float 0x7 > 0x3e8 == 0x0 (0x0) +int 0x7 <= 0x3e8 == 0x1 (0x1) +__uint 0x7 <= 0x3e8 == 0x1 (0x1) +char 0x7 <= 0xffe8 == 0x0 (0x0) +__uchar 0x7 <= 0xe8 == 0x1 (0x1) +__longlong 0x7 <= 0x3e8 == 0x1 (0x1) +__ulonglong 0x7 <= 0x3e8 == 0x1 (0x1) +float 0x7 <= 0x3e8 == 0x1 (0x1) +int 0x7 == 0x3e8 == 0x0 (0x0) +__uint 0x7 == 0x3e8 == 0x0 (0x0) +char 0x7 == 0xffe8 == 0x0 (0x0) +__uchar 0x7 == 0xe8 == 0x0 (0x0) +__longlong 0x7 == 0x3e8 == 0x0 (0x0) +__ulonglong 0x7 == 0x3e8 == 0x0 (0x0) +float 0x7 == 0x3e8 == 0x0 (0x0) +int 0x7 != 0x3e8 == 0x1 (0x1) +__uint 0x7 != 0x3e8 == 0x1 (0x1) +char 0x7 != 0xffe8 == 0x1 (0x1) +__uchar 0x7 != 0xe8 == 0x1 (0x1) +__longlong 0x7 != 0x3e8 == 0x1 (0x1) +__ulonglong 0x7 != 0x3e8 == 0x1 (0x1) +float 0x7 != 0x3e8 == 0x1 (0x1) +int 0x7 >= 0x3e8 == 0x0 (0x0) +__uint 0x7 >= 0x3e8 == 0x0 (0x0) +char 0x7 >= 0xffe8 == 0x1 (0x1) +__uchar 0x7 >= 0xe8 == 0x0 (0x0) +__longlong 0x7 >= 0x3e8 == 0x0 (0x0) +__ulonglong 0x7 >= 0x3e8 == 0x0 (0x0) +float 0x7 >= 0x3e8 == 0x0 (0x0) +int 0x7 / 0x3e8 == 0x0 (0x0) +__uint 0x7 / 0x3e8 == 0x0 (0x0) +char 0x7 / 0xffe8 == 0x0 (0x0) +__uchar 0x7 / 0xe8 == 0x0 (0x0) +__longlong 0x7 / 0x3e8 == 0x0 (0x0) +__ulonglong 0x7 / 0x3e8 == 0x0 (0x0) +float 0x7 / 0x3e8 == 0x0 (0x0) +int 0x7 % 0x3e8 == 0x7 (0x7) +__uint 0x7 % 0x3e8 == 0x7 (0x7) +char 0x7 % 0xffe8 == 0x7 (0x7) +__uchar 0x7 % 0xe8 == 0x7 (0x7) +__longlong 0x7 % 0x3e8 == 0x7 (0x7) +__ulonglong 0x7 % 0x3e8 == 0x7 (0x7) +0x7 * 0x2710 == 0x1170 +0x7 / 0x2710 == 0x0 +0x7 % 0x2710 == 0x7 +int 0x7 ^ 0x2710 == 0x2717 (0x2717) +__uint 0x7 ^ 0x2710 == 0x2717 (0x2717) +char 0x7 ^ 0x10 == 0x17 (0x17) +__uchar 0x7 ^ 0x10 == 0x17 (0x17) +__longlong 0x7 ^ 0x2710 == 0x2717 (0x2717) +__ulonglong 0x7 ^ 0x2710 == 0x2717 (0x2717) +int 0x7 && 0x2710 == 0x1 (0x1) +__uint 0x7 && 0x2710 == 0x1 (0x1) +char 0x7 && 0x10 == 0x1 (0x1) +__uchar 0x7 && 0x10 == 0x1 (0x1) +__longlong 0x7 && 0x2710 == 0x1 (0x1) +__ulonglong 0x7 && 0x2710 == 0x1 (0x1) +int 0x7 || 0x2710 == 0x1 (0x1) +__uint 0x7 || 0x2710 == 0x1 (0x1) +char 0x7 || 0x10 == 0x1 (0x1) +__uchar 0x7 || 0x10 == 0x1 (0x1) +__longlong 0x7 || 0x2710 == 0x1 (0x1) +__ulonglong 0x7 || 0x2710 == 0x1 (0x1) +int 0x7 & 0x2710 == 0x0 (0x0) +__uint 0x7 & 0x2710 == 0x0 (0x0) +char 0x7 & 0x10 == 0x0 (0x0) +__uchar 0x7 & 0x10 == 0x0 (0x0) +__longlong 0x7 & 0x2710 == 0x0 (0x0) +__ulonglong 0x7 & 0x2710 == 0x0 (0x0) +int 0x7 | 0x2710 == 0x2717 (0x2717) +__uint 0x7 | 0x2710 == 0x2717 (0x2717) +char 0x7 | 0x10 == 0x17 (0x17) +__uchar 0x7 | 0x10 == 0x17 (0x17) +__longlong 0x7 | 0x2710 == 0x2717 (0x2717) +__ulonglong 0x7 | 0x2710 == 0x2717 (0x2717) +int 0x7 << 0x16 == 0x0 (0x0) +__uint 0x7 << 0x16 == 0x0 (0x0) +char 0x7 << 0x16 == 0x0 (0x0) +__uchar 0x7 << 0x16 == 0x0 (0x0) +__longlong 0x7 << 0x16 == 0x0 (0x0) +__ulonglong 0x7 << 0x16 == 0x0 (0x0) +int 0x7 >> 0x16 == 0x0 (0x0) +__uint 0x7 >> 0x16 == 0x0 (0x0) +char 0x7 >> 0x16 == 0x0 (0x0) +__uchar 0x7 >> 0x16 == 0x0 (0x0) +__longlong 0x7 >> 0x16 == 0x0 (0x0) +__ulonglong 0x7 >> 0x16 == 0x0 (0x0) +int 0x7 + 0x2710 == 0x2717 (0x2717) +__uint 0x7 + 0x2710 == 0x2717 (0x2717) +char 0x7 + 0x10 == 0x17 (0x17) +__uchar 0x7 + 0x10 == 0x17 (0x17) +__longlong 0x7 + 0x2710 == 0x2717 (0x2717) +__ulonglong 0x7 + 0x2710 == 0x2717 (0x2717) +float 0x7 + 0x2710 == 0x2717 (0x2717) +int 0x7 - 0x2710 == -0x2709 (0xd8f7) +__uint 0x7 - 0x2710 == -0x2709 (0xd8f7) +char 0x7 - 0x10 == -0x9 (0xfff7) +__uchar 0x7 - 0x10 == 0xf7 (0xf7) +__longlong 0x7 - 0x2710 == -0x2709 (0xd8f7) +__ulonglong 0x7 - 0x2710 == -0x2709 (0xd8f7) +float 0x7 - 0x2710 == -0x2709 (0xd8f7) +int 0x7 * 0x2710 == 0x1170 (0x1170) +__uint 0x7 * 0x2710 == 0x1170 (0x1170) +char 0x7 * 0x10 == 0x70 (0x70) +__uchar 0x7 * 0x10 == 0x70 (0x70) +__longlong 0x7 * 0x2710 == 0x1170 (0x1170) +__ulonglong 0x7 * 0x2710 == 0x1170 (0x1170) +float 0x7 * 0x2710 == 0x1170 (0x1170) +int 0x7 < 0x2710 == 0x1 (0x1) +__uint 0x7 < 0x2710 == 0x1 (0x1) +char 0x7 < 0x10 == 0x1 (0x1) +__uchar 0x7 < 0x10 == 0x1 (0x1) +__longlong 0x7 < 0x2710 == 0x1 (0x1) +__ulonglong 0x7 < 0x2710 == 0x1 (0x1) +float 0x7 < 0x2710 == 0x1 (0x1) +int 0x7 > 0x2710 == 0x0 (0x0) +__uint 0x7 > 0x2710 == 0x0 (0x0) +char 0x7 > 0x10 == 0x0 (0x0) +__uchar 0x7 > 0x10 == 0x0 (0x0) +__longlong 0x7 > 0x2710 == 0x0 (0x0) +__ulonglong 0x7 > 0x2710 == 0x0 (0x0) +float 0x7 > 0x2710 == 0x0 (0x0) +int 0x7 <= 0x2710 == 0x1 (0x1) +__uint 0x7 <= 0x2710 == 0x1 (0x1) +char 0x7 <= 0x10 == 0x1 (0x1) +__uchar 0x7 <= 0x10 == 0x1 (0x1) +__longlong 0x7 <= 0x2710 == 0x1 (0x1) +__ulonglong 0x7 <= 0x2710 == 0x1 (0x1) +float 0x7 <= 0x2710 == 0x1 (0x1) +int 0x7 == 0x2710 == 0x0 (0x0) +__uint 0x7 == 0x2710 == 0x0 (0x0) +char 0x7 == 0x10 == 0x0 (0x0) +__uchar 0x7 == 0x10 == 0x0 (0x0) +__longlong 0x7 == 0x2710 == 0x0 (0x0) +__ulonglong 0x7 == 0x2710 == 0x0 (0x0) +float 0x7 == 0x2710 == 0x0 (0x0) +int 0x7 != 0x2710 == 0x1 (0x1) +__uint 0x7 != 0x2710 == 0x1 (0x1) +char 0x7 != 0x10 == 0x1 (0x1) +__uchar 0x7 != 0x10 == 0x1 (0x1) +__longlong 0x7 != 0x2710 == 0x1 (0x1) +__ulonglong 0x7 != 0x2710 == 0x1 (0x1) +float 0x7 != 0x2710 == 0x1 (0x1) +int 0x7 >= 0x2710 == 0x0 (0x0) +__uint 0x7 >= 0x2710 == 0x0 (0x0) +char 0x7 >= 0x10 == 0x0 (0x0) +__uchar 0x7 >= 0x10 == 0x0 (0x0) +__longlong 0x7 >= 0x2710 == 0x0 (0x0) +__ulonglong 0x7 >= 0x2710 == 0x0 (0x0) +float 0x7 >= 0x2710 == 0x0 (0x0) +int 0x7 / 0x2710 == 0x0 (0x0) +__uint 0x7 / 0x2710 == 0x0 (0x0) +char 0x7 / 0x10 == 0x0 (0x0) +__uchar 0x7 / 0x10 == 0x0 (0x0) +__longlong 0x7 / 0x2710 == 0x0 (0x0) +__ulonglong 0x7 / 0x2710 == 0x0 (0x0) +float 0x7 / 0x2710 == 0x0 (0x0) +int 0x7 % 0x2710 == 0x7 (0x7) +__uint 0x7 % 0x2710 == 0x7 (0x7) +char 0x7 % 0x10 == 0x7 (0x7) +__uchar 0x7 % 0x10 == 0x7 (0x7) +__longlong 0x7 % 0x2710 == 0x7 (0x7) +__ulonglong 0x7 % 0x2710 == 0x7 (0x7) +int xor420x7 xor42 0x2d +__uint xor420x7 xor42 0x2d +char xor420x7 xor42 0x2d +__uchar xor420x7 xor42 0x2d +__longlong xor420x7 xor42 0x2d +__ulonglong xor420x7 xor42 0x2d +int land10x7 land1 0x1 +__uint land10x7 land1 0x1 +char land10x7 land1 0x1 +__uchar land10x7 land1 0x1 +__longlong land10x7 land1 0x1 +__ulonglong land10x7 land1 0x1 +int lor10x7 lor1 0x1 +__uint lor10x7 lor1 0x1 +char lor10x7 lor1 0x1 +__uchar lor10x7 lor1 0x1 +__longlong lor10x7 lor1 0x1 +__ulonglong lor10x7 lor1 0x1 +int and420x7 and42 0x2 +__uint and420x7 and42 0x2 +char and420x7 and42 0x2 +__uchar and420x7 and42 0x2 +__longlong and420x7 and42 0x2 +__ulonglong and420x7 and42 0x2 +int or420x7 or42 0x2f +__uint or420x7 or42 0x2f +char or420x7 or42 0x2f +__uchar or420x7 or42 0x2f +__longlong or420x7 or42 0x2f +__ulonglong or420x7 or42 0x2f +int shl50x7 shl5 0xe0 +__uint shl50x7 shl5 0xe0 +char shl50x7 shl5 -0x20 +__uchar shl50x7 shl5 0xe0 +__longlong shl50x7 shl5 0xe0 +__ulonglong shl50x7 shl5 0xe0 +int shr50x7 shr5 0x0 +__uint shr50x7 shr5 0x0 +char shr50x7 shr5 0x0 +__uchar shr50x7 shr5 0x0 +__longlong shr50x7 shr5 0x0 +__ulonglong shr50x7 shr5 0x0 +int add420x7 add42 0x31 +__uint add420x7 add42 0x31 +char add420x7 add42 0x31 +__uchar add420x7 add42 0x31 +__longlong add420x7 add42 0x31 +__ulonglong add420x7 add42 0x31 +float add420x7 add42 0x31 +int sub420x7 sub42 -0x23 +__uint sub420x7 sub42 -0x23 +char sub420x7 sub42 -0x23 +__uchar sub420x7 sub42 0xdd +__longlong sub420x7 sub42 -0x23 +__ulonglong sub420x7 sub42 -0x23 +float sub420x7 sub42 -0x23 +int mul420x7 mul42 0x126 +__uint mul420x7 mul42 0x126 +char mul420x7 mul42 0x26 +__uchar mul420x7 mul42 0x26 +__longlong mul420x7 mul42 0x126 +__ulonglong mul420x7 mul42 0x126 +float mul420x7 mul42 0x126 +int lt420x7 lt42 0x1 +__uint lt420x7 lt42 0x1 +char lt420x7 lt42 0x1 +__uchar lt420x7 lt42 0x1 +__longlong lt420x7 lt42 0x1 +__ulonglong lt420x7 lt42 0x1 +float lt420x7 lt42 0x1 +int gt420x7 gt42 0x0 +__uint gt420x7 gt42 0x0 +char gt420x7 gt42 0x0 +__uchar gt420x7 gt42 0x0 +__longlong gt420x7 gt42 0x0 +__ulonglong gt420x7 gt42 0x0 +float gt420x7 gt42 0x0 +int le420x7 le42 0x1 +__uint le420x7 le42 0x1 +char le420x7 le42 0x1 +__uchar le420x7 le42 0x1 +__longlong le420x7 le42 0x1 +__ulonglong le420x7 le42 0x1 +float le420x7 le42 0x1 +int eq420x7 eq42 0x0 +__uint eq420x7 eq42 0x0 +char eq420x7 eq42 0x0 +__uchar eq420x7 eq42 0x0 +__longlong eq420x7 eq42 0x0 +__ulonglong eq420x7 eq42 0x0 +float eq420x7 eq42 0x0 +int ne420x7 ne42 0x1 +__uint ne420x7 ne42 0x1 +char ne420x7 ne42 0x1 +__uchar ne420x7 ne42 0x1 +__longlong ne420x7 ne42 0x1 +__ulonglong ne420x7 ne42 0x1 +float ne420x7 ne42 0x1 +int ge420x7 ge42 0x0 +__uint ge420x7 ge42 0x0 +char ge420x7 ge42 0x0 +__uchar ge420x7 ge42 0x0 +__longlong ge420x7 ge42 0x0 +__ulonglong ge420x7 ge42 0x0 +float ge420x7 ge42 0x0 +int div420x7 div42 0x0 +__uint div420x7 div42 0x0 +char div420x7 div42 0x0 +__uchar div420x7 div42 0x0 +__longlong div420x7 div42 0x0 +__ulonglong div420x7 div42 0x0 +float div420x7 div42 0x0 +int mod230x7 mod23 0x7 +__uint mod230x7 mod23 0x7 +char mod230x7 mod23 0x7 +__uchar mod230x7 mod23 0x7 +__longlong mod230x7 mod23 0x7 +__ulonglong mod230x7 mod23 0x7 +0x2a * 0xffff == -0x2a +0x2a / 0xffff == -0x2a +0x2a % 0xffff == 0x0 +int 0x2a ^ 0xffff == -0x2b (0xffd5) +__uint 0x2a ^ 0xffff == -0x2b (0xffd5) +char 0x2a ^ 0xffff == -0x2b (0xffd5) +__uchar 0x2a ^ 0xff == 0xd5 (0xd5) +__longlong 0x2a ^ 0xffff == -0x2b (0xffd5) +__ulonglong 0x2a ^ 0xffff == -0x2b (0xffd5) +int 0x2a && 0xffff == 0x1 (0x1) +__uint 0x2a && 0xffff == 0x1 (0x1) +char 0x2a && 0xffff == 0x1 (0x1) +__uchar 0x2a && 0xff == 0x1 (0x1) +__longlong 0x2a && 0xffff == 0x1 (0x1) +__ulonglong 0x2a && 0xffff == 0x1 (0x1) +int 0x2a || 0xffff == 0x1 (0x1) +__uint 0x2a || 0xffff == 0x1 (0x1) +char 0x2a || 0xffff == 0x1 (0x1) +__uchar 0x2a || 0xff == 0x1 (0x1) +__longlong 0x2a || 0xffff == 0x1 (0x1) +__ulonglong 0x2a || 0xffff == 0x1 (0x1) +int 0x2a & 0xffff == 0x2a (0x2a) +__uint 0x2a & 0xffff == 0x2a (0x2a) +char 0x2a & 0xffff == 0x2a (0x2a) +__uchar 0x2a & 0xff == 0x2a (0x2a) +__longlong 0x2a & 0xffff == 0x2a (0x2a) +__ulonglong 0x2a & 0xffff == 0x2a (0x2a) +int 0x2a | 0xffff == -0x1 (0xffff) +__uint 0x2a | 0xffff == -0x1 (0xffff) +char 0x2a | 0xffff == -0x1 (0xffff) +__uchar 0x2a | 0xff == 0xff (0xff) +__longlong 0x2a | 0xffff == -0x1 (0xffff) +__ulonglong 0x2a | 0xffff == -0x1 (0xffff) +int 0x2a << 0x1 == 0x54 (0x54) +__uint 0x2a << 0x1 == 0x54 (0x54) +char 0x2a << 0x1 == 0x54 (0x54) +__uchar 0x2a << 0x1 == 0x54 (0x54) +__longlong 0x2a << 0x1 == 0x54 (0x54) +__ulonglong 0x2a << 0x1 == 0x54 (0x54) +int 0x2a >> 0x1 == 0x15 (0x15) +__uint 0x2a >> 0x1 == 0x15 (0x15) +char 0x2a >> 0x1 == 0x15 (0x15) +__uchar 0x2a >> 0x1 == 0x15 (0x15) +__longlong 0x2a >> 0x1 == 0x15 (0x15) +__ulonglong 0x2a >> 0x1 == 0x15 (0x15) +int 0x2a + 0xffff == 0x29 (0x29) +__uint 0x2a + 0xffff == 0x29 (0x29) +char 0x2a + 0xffff == 0x29 (0x29) +__uchar 0x2a + 0xff == 0x29 (0x29) +__longlong 0x2a + 0xffff == 0x29 (0x29) +__ulonglong 0x2a + 0xffff == 0x29 (0x29) +float 0x2a + 0xffff == 0x29 (0x29) +int 0x2a - 0xffff == 0x2b (0x2b) +__uint 0x2a - 0xffff == 0x2b (0x2b) +char 0x2a - 0xffff == 0x2b (0x2b) +__uchar 0x2a - 0xff == 0x2b (0x2b) +__longlong 0x2a - 0xffff == 0x2b (0x2b) +__ulonglong 0x2a - 0xffff == 0x2b (0x2b) +float 0x2a - 0xffff == 0x2b (0x2b) +int 0x2a * 0xffff == -0x2a (0xffd6) +__uint 0x2a * 0xffff == -0x2a (0xffd6) +char 0x2a * 0xffff == -0x2a (0xffd6) +__uchar 0x2a * 0xff == 0xd6 (0xd6) +__longlong 0x2a * 0xffff == -0x2a (0xffd6) +__ulonglong 0x2a * 0xffff == -0x2a (0xffd6) +float 0x2a * 0xffff == -0x2a (0xffd6) +int 0x2a < 0xffff == 0x0 (0x0) +__uint 0x2a < 0xffff == 0x1 (0x1) +char 0x2a < 0xffff == 0x0 (0x0) +__uchar 0x2a < 0xff == 0x1 (0x1) +__longlong 0x2a < 0xffff == 0x0 (0x0) +__ulonglong 0x2a < 0xffff == 0x1 (0x1) +float 0x2a < 0xffff == 0x0 (0x0) +int 0x2a > 0xffff == 0x1 (0x1) +__uint 0x2a > 0xffff == 0x0 (0x0) +char 0x2a > 0xffff == 0x1 (0x1) +__uchar 0x2a > 0xff == 0x0 (0x0) +__longlong 0x2a > 0xffff == 0x1 (0x1) +__ulonglong 0x2a > 0xffff == 0x0 (0x0) +float 0x2a > 0xffff == 0x1 (0x1) +int 0x2a <= 0xffff == 0x0 (0x0) +__uint 0x2a <= 0xffff == 0x1 (0x1) +char 0x2a <= 0xffff == 0x0 (0x0) +__uchar 0x2a <= 0xff == 0x1 (0x1) +__longlong 0x2a <= 0xffff == 0x0 (0x0) +__ulonglong 0x2a <= 0xffff == 0x1 (0x1) +float 0x2a <= 0xffff == 0x0 (0x0) +int 0x2a == 0xffff == 0x0 (0x0) +__uint 0x2a == 0xffff == 0x0 (0x0) +char 0x2a == 0xffff == 0x0 (0x0) +__uchar 0x2a == 0xff == 0x0 (0x0) +__longlong 0x2a == 0xffff == 0x0 (0x0) +__ulonglong 0x2a == 0xffff == 0x0 (0x0) +float 0x2a == 0xffff == 0x0 (0x0) +int 0x2a != 0xffff == 0x1 (0x1) +__uint 0x2a != 0xffff == 0x1 (0x1) +char 0x2a != 0xffff == 0x1 (0x1) +__uchar 0x2a != 0xff == 0x1 (0x1) +__longlong 0x2a != 0xffff == 0x1 (0x1) +__ulonglong 0x2a != 0xffff == 0x1 (0x1) +float 0x2a != 0xffff == 0x1 (0x1) +int 0x2a >= 0xffff == 0x1 (0x1) +__uint 0x2a >= 0xffff == 0x0 (0x0) +char 0x2a >= 0xffff == 0x1 (0x1) +__uchar 0x2a >= 0xff == 0x0 (0x0) +__longlong 0x2a >= 0xffff == 0x1 (0x1) +__ulonglong 0x2a >= 0xffff == 0x0 (0x0) +float 0x2a >= 0xffff == 0x1 (0x1) +int 0x2a / 0xffff == -0x2a (0xffd6) +__uint 0x2a / 0xffff == 0x0 (0x0) +char 0x2a / 0xffff == -0x2a (0xffd6) +__uchar 0x2a / 0xff == 0x0 (0x0) +__longlong 0x2a / 0xffff == -0x2a (0xffd6) +__ulonglong 0x2a / 0xffff == 0x0 (0x0) +float 0x2a / 0xffff == -0x2a (0xffd6) +int 0x2a % 0xffff == 0x0 (0x0) +__uint 0x2a % 0xffff == 0x2a (0x2a) +char 0x2a % 0xffff == 0x0 (0x0) +__uchar 0x2a % 0xff == 0x2a (0x2a) +__longlong 0x2a % 0xffff == 0x0 (0x0) +__ulonglong 0x2a % 0xffff == 0x2a (0x2a) +0x2a * 0x1 == 0x2a +0x2a / 0x1 == 0x2a +0x2a % 0x1 == 0x0 +int 0x2a ^ 0x1 == 0x2b (0x2b) +__uint 0x2a ^ 0x1 == 0x2b (0x2b) +char 0x2a ^ 0x1 == 0x2b (0x2b) +__uchar 0x2a ^ 0x1 == 0x2b (0x2b) +__longlong 0x2a ^ 0x1 == 0x2b (0x2b) +__ulonglong 0x2a ^ 0x1 == 0x2b (0x2b) +int 0x2a && 0x1 == 0x1 (0x1) +__uint 0x2a && 0x1 == 0x1 (0x1) +char 0x2a && 0x1 == 0x1 (0x1) +__uchar 0x2a && 0x1 == 0x1 (0x1) +__longlong 0x2a && 0x1 == 0x1 (0x1) +__ulonglong 0x2a && 0x1 == 0x1 (0x1) +int 0x2a || 0x1 == 0x1 (0x1) +__uint 0x2a || 0x1 == 0x1 (0x1) +char 0x2a || 0x1 == 0x1 (0x1) +__uchar 0x2a || 0x1 == 0x1 (0x1) +__longlong 0x2a || 0x1 == 0x1 (0x1) +__ulonglong 0x2a || 0x1 == 0x1 (0x1) +int 0x2a & 0x1 == 0x0 (0x0) +__uint 0x2a & 0x1 == 0x0 (0x0) +char 0x2a & 0x1 == 0x0 (0x0) +__uchar 0x2a & 0x1 == 0x0 (0x0) +__longlong 0x2a & 0x1 == 0x0 (0x0) +__ulonglong 0x2a & 0x1 == 0x0 (0x0) +int 0x2a | 0x1 == 0x2b (0x2b) +__uint 0x2a | 0x1 == 0x2b (0x2b) +char 0x2a | 0x1 == 0x2b (0x2b) +__uchar 0x2a | 0x1 == 0x2b (0x2b) +__longlong 0x2a | 0x1 == 0x2b (0x2b) +__ulonglong 0x2a | 0x1 == 0x2b (0x2b) +int 0x2a << 0x2 == 0xa8 (0xa8) +__uint 0x2a << 0x2 == 0xa8 (0xa8) +char 0x2a << 0x2 == -0x58 (0xffa8) +__uchar 0x2a << 0x2 == 0xa8 (0xa8) +__longlong 0x2a << 0x2 == 0xa8 (0xa8) +__ulonglong 0x2a << 0x2 == 0xa8 (0xa8) +int 0x2a >> 0x2 == 0xa (0xa) +__uint 0x2a >> 0x2 == 0xa (0xa) +char 0x2a >> 0x2 == 0xa (0xa) +__uchar 0x2a >> 0x2 == 0xa (0xa) +__longlong 0x2a >> 0x2 == 0xa (0xa) +__ulonglong 0x2a >> 0x2 == 0xa (0xa) +int 0x2a + 0x1 == 0x2b (0x2b) +__uint 0x2a + 0x1 == 0x2b (0x2b) +char 0x2a + 0x1 == 0x2b (0x2b) +__uchar 0x2a + 0x1 == 0x2b (0x2b) +__longlong 0x2a + 0x1 == 0x2b (0x2b) +__ulonglong 0x2a + 0x1 == 0x2b (0x2b) +float 0x2a + 0x1 == 0x2b (0x2b) +int 0x2a - 0x1 == 0x29 (0x29) +__uint 0x2a - 0x1 == 0x29 (0x29) +char 0x2a - 0x1 == 0x29 (0x29) +__uchar 0x2a - 0x1 == 0x29 (0x29) +__longlong 0x2a - 0x1 == 0x29 (0x29) +__ulonglong 0x2a - 0x1 == 0x29 (0x29) +float 0x2a - 0x1 == 0x29 (0x29) +int 0x2a * 0x1 == 0x2a (0x2a) +__uint 0x2a * 0x1 == 0x2a (0x2a) +char 0x2a * 0x1 == 0x2a (0x2a) +__uchar 0x2a * 0x1 == 0x2a (0x2a) +__longlong 0x2a * 0x1 == 0x2a (0x2a) +__ulonglong 0x2a * 0x1 == 0x2a (0x2a) +float 0x2a * 0x1 == 0x2a (0x2a) +int 0x2a < 0x1 == 0x0 (0x0) +__uint 0x2a < 0x1 == 0x0 (0x0) +char 0x2a < 0x1 == 0x0 (0x0) +__uchar 0x2a < 0x1 == 0x0 (0x0) +__longlong 0x2a < 0x1 == 0x0 (0x0) +__ulonglong 0x2a < 0x1 == 0x0 (0x0) +float 0x2a < 0x1 == 0x0 (0x0) +int 0x2a > 0x1 == 0x1 (0x1) +__uint 0x2a > 0x1 == 0x1 (0x1) +char 0x2a > 0x1 == 0x1 (0x1) +__uchar 0x2a > 0x1 == 0x1 (0x1) +__longlong 0x2a > 0x1 == 0x1 (0x1) +__ulonglong 0x2a > 0x1 == 0x1 (0x1) +float 0x2a > 0x1 == 0x1 (0x1) +int 0x2a <= 0x1 == 0x0 (0x0) +__uint 0x2a <= 0x1 == 0x0 (0x0) +char 0x2a <= 0x1 == 0x0 (0x0) +__uchar 0x2a <= 0x1 == 0x0 (0x0) +__longlong 0x2a <= 0x1 == 0x0 (0x0) +__ulonglong 0x2a <= 0x1 == 0x0 (0x0) +float 0x2a <= 0x1 == 0x0 (0x0) +int 0x2a == 0x1 == 0x0 (0x0) +__uint 0x2a == 0x1 == 0x0 (0x0) +char 0x2a == 0x1 == 0x0 (0x0) +__uchar 0x2a == 0x1 == 0x0 (0x0) +__longlong 0x2a == 0x1 == 0x0 (0x0) +__ulonglong 0x2a == 0x1 == 0x0 (0x0) +float 0x2a == 0x1 == 0x0 (0x0) +int 0x2a != 0x1 == 0x1 (0x1) +__uint 0x2a != 0x1 == 0x1 (0x1) +char 0x2a != 0x1 == 0x1 (0x1) +__uchar 0x2a != 0x1 == 0x1 (0x1) +__longlong 0x2a != 0x1 == 0x1 (0x1) +__ulonglong 0x2a != 0x1 == 0x1 (0x1) +float 0x2a != 0x1 == 0x1 (0x1) +int 0x2a >= 0x1 == 0x1 (0x1) +__uint 0x2a >= 0x1 == 0x1 (0x1) +char 0x2a >= 0x1 == 0x1 (0x1) +__uchar 0x2a >= 0x1 == 0x1 (0x1) +__longlong 0x2a >= 0x1 == 0x1 (0x1) +__ulonglong 0x2a >= 0x1 == 0x1 (0x1) +float 0x2a >= 0x1 == 0x1 (0x1) +int 0x2a / 0x1 == 0x2a (0x2a) +__uint 0x2a / 0x1 == 0x2a (0x2a) +char 0x2a / 0x1 == 0x2a (0x2a) +__uchar 0x2a / 0x1 == 0x2a (0x2a) +__longlong 0x2a / 0x1 == 0x2a (0x2a) +__ulonglong 0x2a / 0x1 == 0x2a (0x2a) +float 0x2a / 0x1 == 0x2a (0x2a) +int 0x2a % 0x1 == 0x0 (0x0) +__uint 0x2a % 0x1 == 0x0 (0x0) +char 0x2a % 0x1 == 0x0 (0x0) +__uchar 0x2a % 0x1 == 0x0 (0x0) +__longlong 0x2a % 0x1 == 0x0 (0x0) +__ulonglong 0x2a % 0x1 == 0x0 (0x0) +0x2a * 0x2 == 0x54 +0x2a / 0x2 == 0x15 +0x2a % 0x2 == 0x0 +int 0x2a ^ 0x2 == 0x28 (0x28) +__uint 0x2a ^ 0x2 == 0x28 (0x28) +char 0x2a ^ 0x2 == 0x28 (0x28) +__uchar 0x2a ^ 0x2 == 0x28 (0x28) +__longlong 0x2a ^ 0x2 == 0x28 (0x28) +__ulonglong 0x2a ^ 0x2 == 0x28 (0x28) +int 0x2a && 0x2 == 0x1 (0x1) +__uint 0x2a && 0x2 == 0x1 (0x1) +char 0x2a && 0x2 == 0x1 (0x1) +__uchar 0x2a && 0x2 == 0x1 (0x1) +__longlong 0x2a && 0x2 == 0x1 (0x1) +__ulonglong 0x2a && 0x2 == 0x1 (0x1) +int 0x2a || 0x2 == 0x1 (0x1) +__uint 0x2a || 0x2 == 0x1 (0x1) +char 0x2a || 0x2 == 0x1 (0x1) +__uchar 0x2a || 0x2 == 0x1 (0x1) +__longlong 0x2a || 0x2 == 0x1 (0x1) +__ulonglong 0x2a || 0x2 == 0x1 (0x1) +int 0x2a & 0x2 == 0x2 (0x2) +__uint 0x2a & 0x2 == 0x2 (0x2) +char 0x2a & 0x2 == 0x2 (0x2) +__uchar 0x2a & 0x2 == 0x2 (0x2) +__longlong 0x2a & 0x2 == 0x2 (0x2) +__ulonglong 0x2a & 0x2 == 0x2 (0x2) +int 0x2a | 0x2 == 0x2a (0x2a) +__uint 0x2a | 0x2 == 0x2a (0x2a) +char 0x2a | 0x2 == 0x2a (0x2a) +__uchar 0x2a | 0x2 == 0x2a (0x2a) +__longlong 0x2a | 0x2 == 0x2a (0x2a) +__ulonglong 0x2a | 0x2 == 0x2a (0x2a) +int 0x2a << 0x3 == 0x150 (0x150) +__uint 0x2a << 0x3 == 0x150 (0x150) +char 0x2a << 0x3 == 0x50 (0x50) +__uchar 0x2a << 0x3 == 0x50 (0x50) +__longlong 0x2a << 0x3 == 0x150 (0x150) +__ulonglong 0x2a << 0x3 == 0x150 (0x150) +int 0x2a >> 0x3 == 0x5 (0x5) +__uint 0x2a >> 0x3 == 0x5 (0x5) +char 0x2a >> 0x3 == 0x5 (0x5) +__uchar 0x2a >> 0x3 == 0x5 (0x5) +__longlong 0x2a >> 0x3 == 0x5 (0x5) +__ulonglong 0x2a >> 0x3 == 0x5 (0x5) +int 0x2a + 0x2 == 0x2c (0x2c) +__uint 0x2a + 0x2 == 0x2c (0x2c) +char 0x2a + 0x2 == 0x2c (0x2c) +__uchar 0x2a + 0x2 == 0x2c (0x2c) +__longlong 0x2a + 0x2 == 0x2c (0x2c) +__ulonglong 0x2a + 0x2 == 0x2c (0x2c) +float 0x2a + 0x2 == 0x2c (0x2c) +int 0x2a - 0x2 == 0x28 (0x28) +__uint 0x2a - 0x2 == 0x28 (0x28) +char 0x2a - 0x2 == 0x28 (0x28) +__uchar 0x2a - 0x2 == 0x28 (0x28) +__longlong 0x2a - 0x2 == 0x28 (0x28) +__ulonglong 0x2a - 0x2 == 0x28 (0x28) +float 0x2a - 0x2 == 0x28 (0x28) +int 0x2a * 0x2 == 0x54 (0x54) +__uint 0x2a * 0x2 == 0x54 (0x54) +char 0x2a * 0x2 == 0x54 (0x54) +__uchar 0x2a * 0x2 == 0x54 (0x54) +__longlong 0x2a * 0x2 == 0x54 (0x54) +__ulonglong 0x2a * 0x2 == 0x54 (0x54) +float 0x2a * 0x2 == 0x54 (0x54) +int 0x2a < 0x2 == 0x0 (0x0) +__uint 0x2a < 0x2 == 0x0 (0x0) +char 0x2a < 0x2 == 0x0 (0x0) +__uchar 0x2a < 0x2 == 0x0 (0x0) +__longlong 0x2a < 0x2 == 0x0 (0x0) +__ulonglong 0x2a < 0x2 == 0x0 (0x0) +float 0x2a < 0x2 == 0x0 (0x0) +int 0x2a > 0x2 == 0x1 (0x1) +__uint 0x2a > 0x2 == 0x1 (0x1) +char 0x2a > 0x2 == 0x1 (0x1) +__uchar 0x2a > 0x2 == 0x1 (0x1) +__longlong 0x2a > 0x2 == 0x1 (0x1) +__ulonglong 0x2a > 0x2 == 0x1 (0x1) +float 0x2a > 0x2 == 0x1 (0x1) +int 0x2a <= 0x2 == 0x0 (0x0) +__uint 0x2a <= 0x2 == 0x0 (0x0) +char 0x2a <= 0x2 == 0x0 (0x0) +__uchar 0x2a <= 0x2 == 0x0 (0x0) +__longlong 0x2a <= 0x2 == 0x0 (0x0) +__ulonglong 0x2a <= 0x2 == 0x0 (0x0) +float 0x2a <= 0x2 == 0x0 (0x0) +int 0x2a == 0x2 == 0x0 (0x0) +__uint 0x2a == 0x2 == 0x0 (0x0) +char 0x2a == 0x2 == 0x0 (0x0) +__uchar 0x2a == 0x2 == 0x0 (0x0) +__longlong 0x2a == 0x2 == 0x0 (0x0) +__ulonglong 0x2a == 0x2 == 0x0 (0x0) +float 0x2a == 0x2 == 0x0 (0x0) +int 0x2a != 0x2 == 0x1 (0x1) +__uint 0x2a != 0x2 == 0x1 (0x1) +char 0x2a != 0x2 == 0x1 (0x1) +__uchar 0x2a != 0x2 == 0x1 (0x1) +__longlong 0x2a != 0x2 == 0x1 (0x1) +__ulonglong 0x2a != 0x2 == 0x1 (0x1) +float 0x2a != 0x2 == 0x1 (0x1) +int 0x2a >= 0x2 == 0x1 (0x1) +__uint 0x2a >= 0x2 == 0x1 (0x1) +char 0x2a >= 0x2 == 0x1 (0x1) +__uchar 0x2a >= 0x2 == 0x1 (0x1) +__longlong 0x2a >= 0x2 == 0x1 (0x1) +__ulonglong 0x2a >= 0x2 == 0x1 (0x1) +float 0x2a >= 0x2 == 0x1 (0x1) +int 0x2a / 0x2 == 0x15 (0x15) +__uint 0x2a / 0x2 == 0x15 (0x15) +char 0x2a / 0x2 == 0x15 (0x15) +__uchar 0x2a / 0x2 == 0x15 (0x15) +__longlong 0x2a / 0x2 == 0x15 (0x15) +__ulonglong 0x2a / 0x2 == 0x15 (0x15) +float 0x2a / 0x2 == 0x15 (0x15) +int 0x2a % 0x2 == 0x0 (0x0) +__uint 0x2a % 0x2 == 0x0 (0x0) +char 0x2a % 0x2 == 0x0 (0x0) +__uchar 0x2a % 0x2 == 0x0 (0x0) +__longlong 0x2a % 0x2 == 0x0 (0x0) +__ulonglong 0x2a % 0x2 == 0x0 (0x0) +0x2a * 0xfffe == -0x54 +0x2a / 0xfffe == -0x15 +0x2a % 0xfffe == 0x0 +int 0x2a ^ 0xfffe == -0x2c (0xffd4) +__uint 0x2a ^ 0xfffe == -0x2c (0xffd4) +char 0x2a ^ 0xfffe == -0x2c (0xffd4) +__uchar 0x2a ^ 0xfe == 0xd4 (0xd4) +__longlong 0x2a ^ 0xfffe == -0x2c (0xffd4) +__ulonglong 0x2a ^ 0xfffe == -0x2c (0xffd4) +int 0x2a && 0xfffe == 0x1 (0x1) +__uint 0x2a && 0xfffe == 0x1 (0x1) +char 0x2a && 0xfffe == 0x1 (0x1) +__uchar 0x2a && 0xfe == 0x1 (0x1) +__longlong 0x2a && 0xfffe == 0x1 (0x1) +__ulonglong 0x2a && 0xfffe == 0x1 (0x1) +int 0x2a || 0xfffe == 0x1 (0x1) +__uint 0x2a || 0xfffe == 0x1 (0x1) +char 0x2a || 0xfffe == 0x1 (0x1) +__uchar 0x2a || 0xfe == 0x1 (0x1) +__longlong 0x2a || 0xfffe == 0x1 (0x1) +__ulonglong 0x2a || 0xfffe == 0x1 (0x1) +int 0x2a & 0xfffe == 0x2a (0x2a) +__uint 0x2a & 0xfffe == 0x2a (0x2a) +char 0x2a & 0xfffe == 0x2a (0x2a) +__uchar 0x2a & 0xfe == 0x2a (0x2a) +__longlong 0x2a & 0xfffe == 0x2a (0x2a) +__ulonglong 0x2a & 0xfffe == 0x2a (0x2a) +int 0x2a | 0xfffe == -0x2 (0xfffe) +__uint 0x2a | 0xfffe == -0x2 (0xfffe) +char 0x2a | 0xfffe == -0x2 (0xfffe) +__uchar 0x2a | 0xfe == 0xfe (0xfe) +__longlong 0x2a | 0xfffe == -0x2 (0xfffe) +__ulonglong 0x2a | 0xfffe == -0x2 (0xfffe) +int 0x2a << 0x4 == 0x2a0 (0x2a0) +__uint 0x2a << 0x4 == 0x2a0 (0x2a0) +char 0x2a << 0x4 == -0x60 (0xffa0) +__uchar 0x2a << 0x4 == 0xa0 (0xa0) +__longlong 0x2a << 0x4 == 0x2a0 (0x2a0) +__ulonglong 0x2a << 0x4 == 0x2a0 (0x2a0) +int 0x2a >> 0x4 == 0x2 (0x2) +__uint 0x2a >> 0x4 == 0x2 (0x2) +char 0x2a >> 0x4 == 0x2 (0x2) +__uchar 0x2a >> 0x4 == 0x2 (0x2) +__longlong 0x2a >> 0x4 == 0x2 (0x2) +__ulonglong 0x2a >> 0x4 == 0x2 (0x2) +int 0x2a + 0xfffe == 0x28 (0x28) +__uint 0x2a + 0xfffe == 0x28 (0x28) +char 0x2a + 0xfffe == 0x28 (0x28) +__uchar 0x2a + 0xfe == 0x28 (0x28) +__longlong 0x2a + 0xfffe == 0x28 (0x28) +__ulonglong 0x2a + 0xfffe == 0x28 (0x28) +float 0x2a + 0xfffe == 0x28 (0x28) +int 0x2a - 0xfffe == 0x2c (0x2c) +__uint 0x2a - 0xfffe == 0x2c (0x2c) +char 0x2a - 0xfffe == 0x2c (0x2c) +__uchar 0x2a - 0xfe == 0x2c (0x2c) +__longlong 0x2a - 0xfffe == 0x2c (0x2c) +__ulonglong 0x2a - 0xfffe == 0x2c (0x2c) +float 0x2a - 0xfffe == 0x2c (0x2c) +int 0x2a * 0xfffe == -0x54 (0xffac) +__uint 0x2a * 0xfffe == -0x54 (0xffac) +char 0x2a * 0xfffe == -0x54 (0xffac) +__uchar 0x2a * 0xfe == 0xac (0xac) +__longlong 0x2a * 0xfffe == -0x54 (0xffac) +__ulonglong 0x2a * 0xfffe == -0x54 (0xffac) +float 0x2a * 0xfffe == -0x54 (0xffac) +int 0x2a < 0xfffe == 0x0 (0x0) +__uint 0x2a < 0xfffe == 0x1 (0x1) +char 0x2a < 0xfffe == 0x0 (0x0) +__uchar 0x2a < 0xfe == 0x1 (0x1) +__longlong 0x2a < 0xfffe == 0x0 (0x0) +__ulonglong 0x2a < 0xfffe == 0x1 (0x1) +float 0x2a < 0xfffe == 0x0 (0x0) +int 0x2a > 0xfffe == 0x1 (0x1) +__uint 0x2a > 0xfffe == 0x0 (0x0) +char 0x2a > 0xfffe == 0x1 (0x1) +__uchar 0x2a > 0xfe == 0x0 (0x0) +__longlong 0x2a > 0xfffe == 0x1 (0x1) +__ulonglong 0x2a > 0xfffe == 0x0 (0x0) +float 0x2a > 0xfffe == 0x1 (0x1) +int 0x2a <= 0xfffe == 0x0 (0x0) +__uint 0x2a <= 0xfffe == 0x1 (0x1) +char 0x2a <= 0xfffe == 0x0 (0x0) +__uchar 0x2a <= 0xfe == 0x1 (0x1) +__longlong 0x2a <= 0xfffe == 0x0 (0x0) +__ulonglong 0x2a <= 0xfffe == 0x1 (0x1) +float 0x2a <= 0xfffe == 0x0 (0x0) +int 0x2a == 0xfffe == 0x0 (0x0) +__uint 0x2a == 0xfffe == 0x0 (0x0) +char 0x2a == 0xfffe == 0x0 (0x0) +__uchar 0x2a == 0xfe == 0x0 (0x0) +__longlong 0x2a == 0xfffe == 0x0 (0x0) +__ulonglong 0x2a == 0xfffe == 0x0 (0x0) +float 0x2a == 0xfffe == 0x0 (0x0) +int 0x2a != 0xfffe == 0x1 (0x1) +__uint 0x2a != 0xfffe == 0x1 (0x1) +char 0x2a != 0xfffe == 0x1 (0x1) +__uchar 0x2a != 0xfe == 0x1 (0x1) +__longlong 0x2a != 0xfffe == 0x1 (0x1) +__ulonglong 0x2a != 0xfffe == 0x1 (0x1) +float 0x2a != 0xfffe == 0x1 (0x1) +int 0x2a >= 0xfffe == 0x1 (0x1) +__uint 0x2a >= 0xfffe == 0x0 (0x0) +char 0x2a >= 0xfffe == 0x1 (0x1) +__uchar 0x2a >= 0xfe == 0x0 (0x0) +__longlong 0x2a >= 0xfffe == 0x1 (0x1) +__ulonglong 0x2a >= 0xfffe == 0x0 (0x0) +float 0x2a >= 0xfffe == 0x1 (0x1) +int 0x2a / 0xfffe == -0x15 (0xffeb) +__uint 0x2a / 0xfffe == 0x0 (0x0) +char 0x2a / 0xfffe == -0x15 (0xffeb) +__uchar 0x2a / 0xfe == 0x0 (0x0) +__longlong 0x2a / 0xfffe == -0x15 (0xffeb) +__ulonglong 0x2a / 0xfffe == 0x0 (0x0) +float 0x2a / 0xfffe == -0x15 (0xffeb) +int 0x2a % 0xfffe == 0x0 (0x0) +__uint 0x2a % 0xfffe == 0x2a (0x2a) +char 0x2a % 0xfffe == 0x0 (0x0) +__uchar 0x2a % 0xfe == 0x2a (0x2a) +__longlong 0x2a % 0xfffe == 0x0 (0x0) +__ulonglong 0x2a % 0xfffe == 0x2a (0x2a) +0x2a * 0x4 == 0xa8 +0x2a / 0x4 == 0xa +0x2a % 0x4 == 0x2 +int 0x2a ^ 0x4 == 0x2e (0x2e) +__uint 0x2a ^ 0x4 == 0x2e (0x2e) +char 0x2a ^ 0x4 == 0x2e (0x2e) +__uchar 0x2a ^ 0x4 == 0x2e (0x2e) +__longlong 0x2a ^ 0x4 == 0x2e (0x2e) +__ulonglong 0x2a ^ 0x4 == 0x2e (0x2e) +int 0x2a && 0x4 == 0x1 (0x1) +__uint 0x2a && 0x4 == 0x1 (0x1) +char 0x2a && 0x4 == 0x1 (0x1) +__uchar 0x2a && 0x4 == 0x1 (0x1) +__longlong 0x2a && 0x4 == 0x1 (0x1) +__ulonglong 0x2a && 0x4 == 0x1 (0x1) +int 0x2a || 0x4 == 0x1 (0x1) +__uint 0x2a || 0x4 == 0x1 (0x1) +char 0x2a || 0x4 == 0x1 (0x1) +__uchar 0x2a || 0x4 == 0x1 (0x1) +__longlong 0x2a || 0x4 == 0x1 (0x1) +__ulonglong 0x2a || 0x4 == 0x1 (0x1) +int 0x2a & 0x4 == 0x0 (0x0) +__uint 0x2a & 0x4 == 0x0 (0x0) +char 0x2a & 0x4 == 0x0 (0x0) +__uchar 0x2a & 0x4 == 0x0 (0x0) +__longlong 0x2a & 0x4 == 0x0 (0x0) +__ulonglong 0x2a & 0x4 == 0x0 (0x0) +int 0x2a | 0x4 == 0x2e (0x2e) +__uint 0x2a | 0x4 == 0x2e (0x2e) +char 0x2a | 0x4 == 0x2e (0x2e) +__uchar 0x2a | 0x4 == 0x2e (0x2e) +__longlong 0x2a | 0x4 == 0x2e (0x2e) +__ulonglong 0x2a | 0x4 == 0x2e (0x2e) +int 0x2a << 0x5 == 0x540 (0x540) +__uint 0x2a << 0x5 == 0x540 (0x540) +char 0x2a << 0x5 == 0x40 (0x40) +__uchar 0x2a << 0x5 == 0x40 (0x40) +__longlong 0x2a << 0x5 == 0x540 (0x540) +__ulonglong 0x2a << 0x5 == 0x540 (0x540) +int 0x2a >> 0x5 == 0x1 (0x1) +__uint 0x2a >> 0x5 == 0x1 (0x1) +char 0x2a >> 0x5 == 0x1 (0x1) +__uchar 0x2a >> 0x5 == 0x1 (0x1) +__longlong 0x2a >> 0x5 == 0x1 (0x1) +__ulonglong 0x2a >> 0x5 == 0x1 (0x1) +int 0x2a + 0x4 == 0x2e (0x2e) +__uint 0x2a + 0x4 == 0x2e (0x2e) +char 0x2a + 0x4 == 0x2e (0x2e) +__uchar 0x2a + 0x4 == 0x2e (0x2e) +__longlong 0x2a + 0x4 == 0x2e (0x2e) +__ulonglong 0x2a + 0x4 == 0x2e (0x2e) +float 0x2a + 0x4 == 0x2e (0x2e) +int 0x2a - 0x4 == 0x26 (0x26) +__uint 0x2a - 0x4 == 0x26 (0x26) +char 0x2a - 0x4 == 0x26 (0x26) +__uchar 0x2a - 0x4 == 0x26 (0x26) +__longlong 0x2a - 0x4 == 0x26 (0x26) +__ulonglong 0x2a - 0x4 == 0x26 (0x26) +float 0x2a - 0x4 == 0x26 (0x26) +int 0x2a * 0x4 == 0xa8 (0xa8) +__uint 0x2a * 0x4 == 0xa8 (0xa8) +char 0x2a * 0x4 == -0x58 (0xffa8) +__uchar 0x2a * 0x4 == 0xa8 (0xa8) +__longlong 0x2a * 0x4 == 0xa8 (0xa8) +__ulonglong 0x2a * 0x4 == 0xa8 (0xa8) +float 0x2a * 0x4 == 0xa8 (0xa8) +int 0x2a < 0x4 == 0x0 (0x0) +__uint 0x2a < 0x4 == 0x0 (0x0) +char 0x2a < 0x4 == 0x0 (0x0) +__uchar 0x2a < 0x4 == 0x0 (0x0) +__longlong 0x2a < 0x4 == 0x0 (0x0) +__ulonglong 0x2a < 0x4 == 0x0 (0x0) +float 0x2a < 0x4 == 0x0 (0x0) +int 0x2a > 0x4 == 0x1 (0x1) +__uint 0x2a > 0x4 == 0x1 (0x1) +char 0x2a > 0x4 == 0x1 (0x1) +__uchar 0x2a > 0x4 == 0x1 (0x1) +__longlong 0x2a > 0x4 == 0x1 (0x1) +__ulonglong 0x2a > 0x4 == 0x1 (0x1) +float 0x2a > 0x4 == 0x1 (0x1) +int 0x2a <= 0x4 == 0x0 (0x0) +__uint 0x2a <= 0x4 == 0x0 (0x0) +char 0x2a <= 0x4 == 0x0 (0x0) +__uchar 0x2a <= 0x4 == 0x0 (0x0) +__longlong 0x2a <= 0x4 == 0x0 (0x0) +__ulonglong 0x2a <= 0x4 == 0x0 (0x0) +float 0x2a <= 0x4 == 0x0 (0x0) +int 0x2a == 0x4 == 0x0 (0x0) +__uint 0x2a == 0x4 == 0x0 (0x0) +char 0x2a == 0x4 == 0x0 (0x0) +__uchar 0x2a == 0x4 == 0x0 (0x0) +__longlong 0x2a == 0x4 == 0x0 (0x0) +__ulonglong 0x2a == 0x4 == 0x0 (0x0) +float 0x2a == 0x4 == 0x0 (0x0) +int 0x2a != 0x4 == 0x1 (0x1) +__uint 0x2a != 0x4 == 0x1 (0x1) +char 0x2a != 0x4 == 0x1 (0x1) +__uchar 0x2a != 0x4 == 0x1 (0x1) +__longlong 0x2a != 0x4 == 0x1 (0x1) +__ulonglong 0x2a != 0x4 == 0x1 (0x1) +float 0x2a != 0x4 == 0x1 (0x1) +int 0x2a >= 0x4 == 0x1 (0x1) +__uint 0x2a >= 0x4 == 0x1 (0x1) +char 0x2a >= 0x4 == 0x1 (0x1) +__uchar 0x2a >= 0x4 == 0x1 (0x1) +__longlong 0x2a >= 0x4 == 0x1 (0x1) +__ulonglong 0x2a >= 0x4 == 0x1 (0x1) +float 0x2a >= 0x4 == 0x1 (0x1) +int 0x2a / 0x4 == 0xa (0xa) +__uint 0x2a / 0x4 == 0xa (0xa) +char 0x2a / 0x4 == 0xa (0xa) +__uchar 0x2a / 0x4 == 0xa (0xa) +__longlong 0x2a / 0x4 == 0xa (0xa) +__ulonglong 0x2a / 0x4 == 0xa (0xa) +float 0x2a / 0x4 == 0xa (0xa) +int 0x2a % 0x4 == 0x2 (0x2) +__uint 0x2a % 0x4 == 0x2 (0x2) +char 0x2a % 0x4 == 0x2 (0x2) +__uchar 0x2a % 0x4 == 0x2 (0x2) +__longlong 0x2a % 0x4 == 0x2 (0x2) +__ulonglong 0x2a % 0x4 == 0x2 (0x2) +0x2a * 0xfffc == -0xa8 +0x2a / 0xfffc == -0xa +0x2a % 0xfffc == 0x2 +int 0x2a ^ 0xfffc == -0x2a (0xffd6) +__uint 0x2a ^ 0xfffc == -0x2a (0xffd6) +char 0x2a ^ 0xfffc == -0x2a (0xffd6) +__uchar 0x2a ^ 0xfc == 0xd6 (0xd6) +__longlong 0x2a ^ 0xfffc == -0x2a (0xffd6) +__ulonglong 0x2a ^ 0xfffc == -0x2a (0xffd6) +int 0x2a && 0xfffc == 0x1 (0x1) +__uint 0x2a && 0xfffc == 0x1 (0x1) +char 0x2a && 0xfffc == 0x1 (0x1) +__uchar 0x2a && 0xfc == 0x1 (0x1) +__longlong 0x2a && 0xfffc == 0x1 (0x1) +__ulonglong 0x2a && 0xfffc == 0x1 (0x1) +int 0x2a || 0xfffc == 0x1 (0x1) +__uint 0x2a || 0xfffc == 0x1 (0x1) +char 0x2a || 0xfffc == 0x1 (0x1) +__uchar 0x2a || 0xfc == 0x1 (0x1) +__longlong 0x2a || 0xfffc == 0x1 (0x1) +__ulonglong 0x2a || 0xfffc == 0x1 (0x1) +int 0x2a & 0xfffc == 0x28 (0x28) +__uint 0x2a & 0xfffc == 0x28 (0x28) +char 0x2a & 0xfffc == 0x28 (0x28) +__uchar 0x2a & 0xfc == 0x28 (0x28) +__longlong 0x2a & 0xfffc == 0x28 (0x28) +__ulonglong 0x2a & 0xfffc == 0x28 (0x28) +int 0x2a | 0xfffc == -0x2 (0xfffe) +__uint 0x2a | 0xfffc == -0x2 (0xfffe) +char 0x2a | 0xfffc == -0x2 (0xfffe) +__uchar 0x2a | 0xfc == 0xfe (0xfe) +__longlong 0x2a | 0xfffc == -0x2 (0xfffe) +__ulonglong 0x2a | 0xfffc == -0x2 (0xfffe) +int 0x2a << 0x6 == 0xa80 (0xa80) +__uint 0x2a << 0x6 == 0xa80 (0xa80) +char 0x2a << 0x6 == -0x80 (0xff80) +__uchar 0x2a << 0x6 == 0x80 (0x80) +__longlong 0x2a << 0x6 == 0xa80 (0xa80) +__ulonglong 0x2a << 0x6 == 0xa80 (0xa80) +int 0x2a >> 0x6 == 0x0 (0x0) +__uint 0x2a >> 0x6 == 0x0 (0x0) +char 0x2a >> 0x6 == 0x0 (0x0) +__uchar 0x2a >> 0x6 == 0x0 (0x0) +__longlong 0x2a >> 0x6 == 0x0 (0x0) +__ulonglong 0x2a >> 0x6 == 0x0 (0x0) +int 0x2a + 0xfffc == 0x26 (0x26) +__uint 0x2a + 0xfffc == 0x26 (0x26) +char 0x2a + 0xfffc == 0x26 (0x26) +__uchar 0x2a + 0xfc == 0x26 (0x26) +__longlong 0x2a + 0xfffc == 0x26 (0x26) +__ulonglong 0x2a + 0xfffc == 0x26 (0x26) +float 0x2a + 0xfffc == 0x26 (0x26) +int 0x2a - 0xfffc == 0x2e (0x2e) +__uint 0x2a - 0xfffc == 0x2e (0x2e) +char 0x2a - 0xfffc == 0x2e (0x2e) +__uchar 0x2a - 0xfc == 0x2e (0x2e) +__longlong 0x2a - 0xfffc == 0x2e (0x2e) +__ulonglong 0x2a - 0xfffc == 0x2e (0x2e) +float 0x2a - 0xfffc == 0x2e (0x2e) +int 0x2a * 0xfffc == -0xa8 (0xff58) +__uint 0x2a * 0xfffc == -0xa8 (0xff58) +char 0x2a * 0xfffc == 0x58 (0x58) +__uchar 0x2a * 0xfc == 0x58 (0x58) +__longlong 0x2a * 0xfffc == -0xa8 (0xff58) +__ulonglong 0x2a * 0xfffc == -0xa8 (0xff58) +float 0x2a * 0xfffc == -0xa8 (0xff58) +int 0x2a < 0xfffc == 0x0 (0x0) +__uint 0x2a < 0xfffc == 0x1 (0x1) +char 0x2a < 0xfffc == 0x0 (0x0) +__uchar 0x2a < 0xfc == 0x1 (0x1) +__longlong 0x2a < 0xfffc == 0x0 (0x0) +__ulonglong 0x2a < 0xfffc == 0x1 (0x1) +float 0x2a < 0xfffc == 0x0 (0x0) +int 0x2a > 0xfffc == 0x1 (0x1) +__uint 0x2a > 0xfffc == 0x0 (0x0) +char 0x2a > 0xfffc == 0x1 (0x1) +__uchar 0x2a > 0xfc == 0x0 (0x0) +__longlong 0x2a > 0xfffc == 0x1 (0x1) +__ulonglong 0x2a > 0xfffc == 0x0 (0x0) +float 0x2a > 0xfffc == 0x1 (0x1) +int 0x2a <= 0xfffc == 0x0 (0x0) +__uint 0x2a <= 0xfffc == 0x1 (0x1) +char 0x2a <= 0xfffc == 0x0 (0x0) +__uchar 0x2a <= 0xfc == 0x1 (0x1) +__longlong 0x2a <= 0xfffc == 0x0 (0x0) +__ulonglong 0x2a <= 0xfffc == 0x1 (0x1) +float 0x2a <= 0xfffc == 0x0 (0x0) +int 0x2a == 0xfffc == 0x0 (0x0) +__uint 0x2a == 0xfffc == 0x0 (0x0) +char 0x2a == 0xfffc == 0x0 (0x0) +__uchar 0x2a == 0xfc == 0x0 (0x0) +__longlong 0x2a == 0xfffc == 0x0 (0x0) +__ulonglong 0x2a == 0xfffc == 0x0 (0x0) +float 0x2a == 0xfffc == 0x0 (0x0) +int 0x2a != 0xfffc == 0x1 (0x1) +__uint 0x2a != 0xfffc == 0x1 (0x1) +char 0x2a != 0xfffc == 0x1 (0x1) +__uchar 0x2a != 0xfc == 0x1 (0x1) +__longlong 0x2a != 0xfffc == 0x1 (0x1) +__ulonglong 0x2a != 0xfffc == 0x1 (0x1) +float 0x2a != 0xfffc == 0x1 (0x1) +int 0x2a >= 0xfffc == 0x1 (0x1) +__uint 0x2a >= 0xfffc == 0x0 (0x0) +char 0x2a >= 0xfffc == 0x1 (0x1) +__uchar 0x2a >= 0xfc == 0x0 (0x0) +__longlong 0x2a >= 0xfffc == 0x1 (0x1) +__ulonglong 0x2a >= 0xfffc == 0x0 (0x0) +float 0x2a >= 0xfffc == 0x1 (0x1) +int 0x2a / 0xfffc == -0xa (0xfff6) +__uint 0x2a / 0xfffc == 0x0 (0x0) +char 0x2a / 0xfffc == -0xa (0xfff6) +__uchar 0x2a / 0xfc == 0x0 (0x0) +__longlong 0x2a / 0xfffc == -0xa (0xfff6) +__ulonglong 0x2a / 0xfffc == 0x0 (0x0) +float 0x2a / 0xfffc == -0xa (0xfff6) +int 0x2a % 0xfffc == 0x2 (0x2) +__uint 0x2a % 0xfffc == 0x2a (0x2a) +char 0x2a % 0xfffc == 0x2 (0x2) +__uchar 0x2a % 0xfc == 0x2a (0x2a) +__longlong 0x2a % 0xfffc == 0x2 (0x2) +__ulonglong 0x2a % 0xfffc == 0x2a (0x2a) +0x2a * 0xa == 0x1a4 +0x2a / 0xa == 0x4 +0x2a % 0xa == 0x2 +int 0x2a ^ 0xa == 0x20 (0x20) +__uint 0x2a ^ 0xa == 0x20 (0x20) +char 0x2a ^ 0xa == 0x20 (0x20) +__uchar 0x2a ^ 0xa == 0x20 (0x20) +__longlong 0x2a ^ 0xa == 0x20 (0x20) +__ulonglong 0x2a ^ 0xa == 0x20 (0x20) +int 0x2a && 0xa == 0x1 (0x1) +__uint 0x2a && 0xa == 0x1 (0x1) +char 0x2a && 0xa == 0x1 (0x1) +__uchar 0x2a && 0xa == 0x1 (0x1) +__longlong 0x2a && 0xa == 0x1 (0x1) +__ulonglong 0x2a && 0xa == 0x1 (0x1) +int 0x2a || 0xa == 0x1 (0x1) +__uint 0x2a || 0xa == 0x1 (0x1) +char 0x2a || 0xa == 0x1 (0x1) +__uchar 0x2a || 0xa == 0x1 (0x1) +__longlong 0x2a || 0xa == 0x1 (0x1) +__ulonglong 0x2a || 0xa == 0x1 (0x1) +int 0x2a & 0xa == 0xa (0xa) +__uint 0x2a & 0xa == 0xa (0xa) +char 0x2a & 0xa == 0xa (0xa) +__uchar 0x2a & 0xa == 0xa (0xa) +__longlong 0x2a & 0xa == 0xa (0xa) +__ulonglong 0x2a & 0xa == 0xa (0xa) +int 0x2a | 0xa == 0x2a (0x2a) +__uint 0x2a | 0xa == 0x2a (0x2a) +char 0x2a | 0xa == 0x2a (0x2a) +__uchar 0x2a | 0xa == 0x2a (0x2a) +__longlong 0x2a | 0xa == 0x2a (0x2a) +__ulonglong 0x2a | 0xa == 0x2a (0x2a) +int 0x2a << 0x7 == 0x1500 (0x1500) +__uint 0x2a << 0x7 == 0x1500 (0x1500) +char 0x2a << 0x7 == 0x0 (0x0) +__uchar 0x2a << 0x7 == 0x0 (0x0) +__longlong 0x2a << 0x7 == 0x1500 (0x1500) +__ulonglong 0x2a << 0x7 == 0x1500 (0x1500) +int 0x2a >> 0x7 == 0x0 (0x0) +__uint 0x2a >> 0x7 == 0x0 (0x0) +char 0x2a >> 0x7 == 0x0 (0x0) +__uchar 0x2a >> 0x7 == 0x0 (0x0) +__longlong 0x2a >> 0x7 == 0x0 (0x0) +__ulonglong 0x2a >> 0x7 == 0x0 (0x0) +int 0x2a + 0xa == 0x34 (0x34) +__uint 0x2a + 0xa == 0x34 (0x34) +char 0x2a + 0xa == 0x34 (0x34) +__uchar 0x2a + 0xa == 0x34 (0x34) +__longlong 0x2a + 0xa == 0x34 (0x34) +__ulonglong 0x2a + 0xa == 0x34 (0x34) +float 0x2a + 0xa == 0x34 (0x34) +int 0x2a - 0xa == 0x20 (0x20) +__uint 0x2a - 0xa == 0x20 (0x20) +char 0x2a - 0xa == 0x20 (0x20) +__uchar 0x2a - 0xa == 0x20 (0x20) +__longlong 0x2a - 0xa == 0x20 (0x20) +__ulonglong 0x2a - 0xa == 0x20 (0x20) +float 0x2a - 0xa == 0x20 (0x20) +int 0x2a * 0xa == 0x1a4 (0x1a4) +__uint 0x2a * 0xa == 0x1a4 (0x1a4) +char 0x2a * 0xa == -0x5c (0xffa4) +__uchar 0x2a * 0xa == 0xa4 (0xa4) +__longlong 0x2a * 0xa == 0x1a4 (0x1a4) +__ulonglong 0x2a * 0xa == 0x1a4 (0x1a4) +float 0x2a * 0xa == 0x1a4 (0x1a4) +int 0x2a < 0xa == 0x0 (0x0) +__uint 0x2a < 0xa == 0x0 (0x0) +char 0x2a < 0xa == 0x0 (0x0) +__uchar 0x2a < 0xa == 0x0 (0x0) +__longlong 0x2a < 0xa == 0x0 (0x0) +__ulonglong 0x2a < 0xa == 0x0 (0x0) +float 0x2a < 0xa == 0x0 (0x0) +int 0x2a > 0xa == 0x1 (0x1) +__uint 0x2a > 0xa == 0x1 (0x1) +char 0x2a > 0xa == 0x1 (0x1) +__uchar 0x2a > 0xa == 0x1 (0x1) +__longlong 0x2a > 0xa == 0x1 (0x1) +__ulonglong 0x2a > 0xa == 0x1 (0x1) +float 0x2a > 0xa == 0x1 (0x1) +int 0x2a <= 0xa == 0x0 (0x0) +__uint 0x2a <= 0xa == 0x0 (0x0) +char 0x2a <= 0xa == 0x0 (0x0) +__uchar 0x2a <= 0xa == 0x0 (0x0) +__longlong 0x2a <= 0xa == 0x0 (0x0) +__ulonglong 0x2a <= 0xa == 0x0 (0x0) +float 0x2a <= 0xa == 0x0 (0x0) +int 0x2a == 0xa == 0x0 (0x0) +__uint 0x2a == 0xa == 0x0 (0x0) +char 0x2a == 0xa == 0x0 (0x0) +__uchar 0x2a == 0xa == 0x0 (0x0) +__longlong 0x2a == 0xa == 0x0 (0x0) +__ulonglong 0x2a == 0xa == 0x0 (0x0) +float 0x2a == 0xa == 0x0 (0x0) +int 0x2a != 0xa == 0x1 (0x1) +__uint 0x2a != 0xa == 0x1 (0x1) +char 0x2a != 0xa == 0x1 (0x1) +__uchar 0x2a != 0xa == 0x1 (0x1) +__longlong 0x2a != 0xa == 0x1 (0x1) +__ulonglong 0x2a != 0xa == 0x1 (0x1) +float 0x2a != 0xa == 0x1 (0x1) +int 0x2a >= 0xa == 0x1 (0x1) +__uint 0x2a >= 0xa == 0x1 (0x1) +char 0x2a >= 0xa == 0x1 (0x1) +__uchar 0x2a >= 0xa == 0x1 (0x1) +__longlong 0x2a >= 0xa == 0x1 (0x1) +__ulonglong 0x2a >= 0xa == 0x1 (0x1) +float 0x2a >= 0xa == 0x1 (0x1) +int 0x2a / 0xa == 0x4 (0x4) +__uint 0x2a / 0xa == 0x4 (0x4) +char 0x2a / 0xa == 0x4 (0x4) +__uchar 0x2a / 0xa == 0x4 (0x4) +__longlong 0x2a / 0xa == 0x4 (0x4) +__ulonglong 0x2a / 0xa == 0x4 (0x4) +float 0x2a / 0xa == 0x4 (0x4) +int 0x2a % 0xa == 0x2 (0x2) +__uint 0x2a % 0xa == 0x2 (0x2) +char 0x2a % 0xa == 0x2 (0x2) +__uchar 0x2a % 0xa == 0x2 (0x2) +__longlong 0x2a % 0xa == 0x2 (0x2) +__ulonglong 0x2a % 0xa == 0x2 (0x2) +0x2a * 0xfff6 == -0x1a4 +0x2a / 0xfff6 == -0x4 +0x2a % 0xfff6 == 0x2 +int 0x2a ^ 0xfff6 == -0x24 (0xffdc) +__uint 0x2a ^ 0xfff6 == -0x24 (0xffdc) +char 0x2a ^ 0xfff6 == -0x24 (0xffdc) +__uchar 0x2a ^ 0xf6 == 0xdc (0xdc) +__longlong 0x2a ^ 0xfff6 == -0x24 (0xffdc) +__ulonglong 0x2a ^ 0xfff6 == -0x24 (0xffdc) +int 0x2a && 0xfff6 == 0x1 (0x1) +__uint 0x2a && 0xfff6 == 0x1 (0x1) +char 0x2a && 0xfff6 == 0x1 (0x1) +__uchar 0x2a && 0xf6 == 0x1 (0x1) +__longlong 0x2a && 0xfff6 == 0x1 (0x1) +__ulonglong 0x2a && 0xfff6 == 0x1 (0x1) +int 0x2a || 0xfff6 == 0x1 (0x1) +__uint 0x2a || 0xfff6 == 0x1 (0x1) +char 0x2a || 0xfff6 == 0x1 (0x1) +__uchar 0x2a || 0xf6 == 0x1 (0x1) +__longlong 0x2a || 0xfff6 == 0x1 (0x1) +__ulonglong 0x2a || 0xfff6 == 0x1 (0x1) +int 0x2a & 0xfff6 == 0x22 (0x22) +__uint 0x2a & 0xfff6 == 0x22 (0x22) +char 0x2a & 0xfff6 == 0x22 (0x22) +__uchar 0x2a & 0xf6 == 0x22 (0x22) +__longlong 0x2a & 0xfff6 == 0x22 (0x22) +__ulonglong 0x2a & 0xfff6 == 0x22 (0x22) +int 0x2a | 0xfff6 == -0x2 (0xfffe) +__uint 0x2a | 0xfff6 == -0x2 (0xfffe) +char 0x2a | 0xfff6 == -0x2 (0xfffe) +__uchar 0x2a | 0xf6 == 0xfe (0xfe) +__longlong 0x2a | 0xfff6 == -0x2 (0xfffe) +__ulonglong 0x2a | 0xfff6 == -0x2 (0xfffe) +int 0x2a << 0x8 == 0x2a00 (0x2a00) +__uint 0x2a << 0x8 == 0x2a00 (0x2a00) +char 0x2a << 0x8 == 0x0 (0x0) +__uchar 0x2a << 0x8 == 0x0 (0x0) +__longlong 0x2a << 0x8 == 0x2a00 (0x2a00) +__ulonglong 0x2a << 0x8 == 0x2a00 (0x2a00) +int 0x2a >> 0x8 == 0x0 (0x0) +__uint 0x2a >> 0x8 == 0x0 (0x0) +char 0x2a >> 0x8 == 0x0 (0x0) +__uchar 0x2a >> 0x8 == 0x0 (0x0) +__longlong 0x2a >> 0x8 == 0x0 (0x0) +__ulonglong 0x2a >> 0x8 == 0x0 (0x0) +int 0x2a + 0xfff6 == 0x20 (0x20) +__uint 0x2a + 0xfff6 == 0x20 (0x20) +char 0x2a + 0xfff6 == 0x20 (0x20) +__uchar 0x2a + 0xf6 == 0x20 (0x20) +__longlong 0x2a + 0xfff6 == 0x20 (0x20) +__ulonglong 0x2a + 0xfff6 == 0x20 (0x20) +float 0x2a + 0xfff6 == 0x20 (0x20) +int 0x2a - 0xfff6 == 0x34 (0x34) +__uint 0x2a - 0xfff6 == 0x34 (0x34) +char 0x2a - 0xfff6 == 0x34 (0x34) +__uchar 0x2a - 0xf6 == 0x34 (0x34) +__longlong 0x2a - 0xfff6 == 0x34 (0x34) +__ulonglong 0x2a - 0xfff6 == 0x34 (0x34) +float 0x2a - 0xfff6 == 0x34 (0x34) +int 0x2a * 0xfff6 == -0x1a4 (0xfe5c) +__uint 0x2a * 0xfff6 == -0x1a4 (0xfe5c) +char 0x2a * 0xfff6 == 0x5c (0x5c) +__uchar 0x2a * 0xf6 == 0x5c (0x5c) +__longlong 0x2a * 0xfff6 == -0x1a4 (0xfe5c) +__ulonglong 0x2a * 0xfff6 == -0x1a4 (0xfe5c) +float 0x2a * 0xfff6 == -0x1a4 (0xfe5c) +int 0x2a < 0xfff6 == 0x0 (0x0) +__uint 0x2a < 0xfff6 == 0x1 (0x1) +char 0x2a < 0xfff6 == 0x0 (0x0) +__uchar 0x2a < 0xf6 == 0x1 (0x1) +__longlong 0x2a < 0xfff6 == 0x0 (0x0) +__ulonglong 0x2a < 0xfff6 == 0x1 (0x1) +float 0x2a < 0xfff6 == 0x0 (0x0) +int 0x2a > 0xfff6 == 0x1 (0x1) +__uint 0x2a > 0xfff6 == 0x0 (0x0) +char 0x2a > 0xfff6 == 0x1 (0x1) +__uchar 0x2a > 0xf6 == 0x0 (0x0) +__longlong 0x2a > 0xfff6 == 0x1 (0x1) +__ulonglong 0x2a > 0xfff6 == 0x0 (0x0) +float 0x2a > 0xfff6 == 0x1 (0x1) +int 0x2a <= 0xfff6 == 0x0 (0x0) +__uint 0x2a <= 0xfff6 == 0x1 (0x1) +char 0x2a <= 0xfff6 == 0x0 (0x0) +__uchar 0x2a <= 0xf6 == 0x1 (0x1) +__longlong 0x2a <= 0xfff6 == 0x0 (0x0) +__ulonglong 0x2a <= 0xfff6 == 0x1 (0x1) +float 0x2a <= 0xfff6 == 0x0 (0x0) +int 0x2a == 0xfff6 == 0x0 (0x0) +__uint 0x2a == 0xfff6 == 0x0 (0x0) +char 0x2a == 0xfff6 == 0x0 (0x0) +__uchar 0x2a == 0xf6 == 0x0 (0x0) +__longlong 0x2a == 0xfff6 == 0x0 (0x0) +__ulonglong 0x2a == 0xfff6 == 0x0 (0x0) +float 0x2a == 0xfff6 == 0x0 (0x0) +int 0x2a != 0xfff6 == 0x1 (0x1) +__uint 0x2a != 0xfff6 == 0x1 (0x1) +char 0x2a != 0xfff6 == 0x1 (0x1) +__uchar 0x2a != 0xf6 == 0x1 (0x1) +__longlong 0x2a != 0xfff6 == 0x1 (0x1) +__ulonglong 0x2a != 0xfff6 == 0x1 (0x1) +float 0x2a != 0xfff6 == 0x1 (0x1) +int 0x2a >= 0xfff6 == 0x1 (0x1) +__uint 0x2a >= 0xfff6 == 0x0 (0x0) +char 0x2a >= 0xfff6 == 0x1 (0x1) +__uchar 0x2a >= 0xf6 == 0x0 (0x0) +__longlong 0x2a >= 0xfff6 == 0x1 (0x1) +__ulonglong 0x2a >= 0xfff6 == 0x0 (0x0) +float 0x2a >= 0xfff6 == 0x1 (0x1) +int 0x2a / 0xfff6 == -0x4 (0xfffc) +__uint 0x2a / 0xfff6 == 0x0 (0x0) +char 0x2a / 0xfff6 == -0x4 (0xfffc) +__uchar 0x2a / 0xf6 == 0x0 (0x0) +__longlong 0x2a / 0xfff6 == -0x4 (0xfffc) +__ulonglong 0x2a / 0xfff6 == 0x0 (0x0) +float 0x2a / 0xfff6 == -0x4 (0xfffc) +int 0x2a % 0xfff6 == 0x2 (0x2) +__uint 0x2a % 0xfff6 == 0x2a (0x2a) +char 0x2a % 0xfff6 == 0x2 (0x2) +__uchar 0x2a % 0xf6 == 0x2a (0x2a) +__longlong 0x2a % 0xfff6 == 0x2 (0x2) +__ulonglong 0x2a % 0xfff6 == 0x2a (0x2a) +0x2a * 0x5 == 0xd2 +0x2a / 0x5 == 0x8 +0x2a % 0x5 == 0x2 +int 0x2a ^ 0x5 == 0x2f (0x2f) +__uint 0x2a ^ 0x5 == 0x2f (0x2f) +char 0x2a ^ 0x5 == 0x2f (0x2f) +__uchar 0x2a ^ 0x5 == 0x2f (0x2f) +__longlong 0x2a ^ 0x5 == 0x2f (0x2f) +__ulonglong 0x2a ^ 0x5 == 0x2f (0x2f) +int 0x2a && 0x5 == 0x1 (0x1) +__uint 0x2a && 0x5 == 0x1 (0x1) +char 0x2a && 0x5 == 0x1 (0x1) +__uchar 0x2a && 0x5 == 0x1 (0x1) +__longlong 0x2a && 0x5 == 0x1 (0x1) +__ulonglong 0x2a && 0x5 == 0x1 (0x1) +int 0x2a || 0x5 == 0x1 (0x1) +__uint 0x2a || 0x5 == 0x1 (0x1) +char 0x2a || 0x5 == 0x1 (0x1) +__uchar 0x2a || 0x5 == 0x1 (0x1) +__longlong 0x2a || 0x5 == 0x1 (0x1) +__ulonglong 0x2a || 0x5 == 0x1 (0x1) +int 0x2a & 0x5 == 0x0 (0x0) +__uint 0x2a & 0x5 == 0x0 (0x0) +char 0x2a & 0x5 == 0x0 (0x0) +__uchar 0x2a & 0x5 == 0x0 (0x0) +__longlong 0x2a & 0x5 == 0x0 (0x0) +__ulonglong 0x2a & 0x5 == 0x0 (0x0) +int 0x2a | 0x5 == 0x2f (0x2f) +__uint 0x2a | 0x5 == 0x2f (0x2f) +char 0x2a | 0x5 == 0x2f (0x2f) +__uchar 0x2a | 0x5 == 0x2f (0x2f) +__longlong 0x2a | 0x5 == 0x2f (0x2f) +__ulonglong 0x2a | 0x5 == 0x2f (0x2f) +int 0x2a << 0x9 == 0x5400 (0x5400) +__uint 0x2a << 0x9 == 0x5400 (0x5400) +char 0x2a << 0x9 == 0x0 (0x0) +__uchar 0x2a << 0x9 == 0x0 (0x0) +__longlong 0x2a << 0x9 == 0x5400 (0x5400) +__ulonglong 0x2a << 0x9 == 0x5400 (0x5400) +int 0x2a >> 0x9 == 0x0 (0x0) +__uint 0x2a >> 0x9 == 0x0 (0x0) +char 0x2a >> 0x9 == 0x0 (0x0) +__uchar 0x2a >> 0x9 == 0x0 (0x0) +__longlong 0x2a >> 0x9 == 0x0 (0x0) +__ulonglong 0x2a >> 0x9 == 0x0 (0x0) +int 0x2a + 0x5 == 0x2f (0x2f) +__uint 0x2a + 0x5 == 0x2f (0x2f) +char 0x2a + 0x5 == 0x2f (0x2f) +__uchar 0x2a + 0x5 == 0x2f (0x2f) +__longlong 0x2a + 0x5 == 0x2f (0x2f) +__ulonglong 0x2a + 0x5 == 0x2f (0x2f) +float 0x2a + 0x5 == 0x2f (0x2f) +int 0x2a - 0x5 == 0x25 (0x25) +__uint 0x2a - 0x5 == 0x25 (0x25) +char 0x2a - 0x5 == 0x25 (0x25) +__uchar 0x2a - 0x5 == 0x25 (0x25) +__longlong 0x2a - 0x5 == 0x25 (0x25) +__ulonglong 0x2a - 0x5 == 0x25 (0x25) +float 0x2a - 0x5 == 0x25 (0x25) +int 0x2a * 0x5 == 0xd2 (0xd2) +__uint 0x2a * 0x5 == 0xd2 (0xd2) +char 0x2a * 0x5 == -0x2e (0xffd2) +__uchar 0x2a * 0x5 == 0xd2 (0xd2) +__longlong 0x2a * 0x5 == 0xd2 (0xd2) +__ulonglong 0x2a * 0x5 == 0xd2 (0xd2) +float 0x2a * 0x5 == 0xd2 (0xd2) +int 0x2a < 0x5 == 0x0 (0x0) +__uint 0x2a < 0x5 == 0x0 (0x0) +char 0x2a < 0x5 == 0x0 (0x0) +__uchar 0x2a < 0x5 == 0x0 (0x0) +__longlong 0x2a < 0x5 == 0x0 (0x0) +__ulonglong 0x2a < 0x5 == 0x0 (0x0) +float 0x2a < 0x5 == 0x0 (0x0) +int 0x2a > 0x5 == 0x1 (0x1) +__uint 0x2a > 0x5 == 0x1 (0x1) +char 0x2a > 0x5 == 0x1 (0x1) +__uchar 0x2a > 0x5 == 0x1 (0x1) +__longlong 0x2a > 0x5 == 0x1 (0x1) +__ulonglong 0x2a > 0x5 == 0x1 (0x1) +float 0x2a > 0x5 == 0x1 (0x1) +int 0x2a <= 0x5 == 0x0 (0x0) +__uint 0x2a <= 0x5 == 0x0 (0x0) +char 0x2a <= 0x5 == 0x0 (0x0) +__uchar 0x2a <= 0x5 == 0x0 (0x0) +__longlong 0x2a <= 0x5 == 0x0 (0x0) +__ulonglong 0x2a <= 0x5 == 0x0 (0x0) +float 0x2a <= 0x5 == 0x0 (0x0) +int 0x2a == 0x5 == 0x0 (0x0) +__uint 0x2a == 0x5 == 0x0 (0x0) +char 0x2a == 0x5 == 0x0 (0x0) +__uchar 0x2a == 0x5 == 0x0 (0x0) +__longlong 0x2a == 0x5 == 0x0 (0x0) +__ulonglong 0x2a == 0x5 == 0x0 (0x0) +float 0x2a == 0x5 == 0x0 (0x0) +int 0x2a != 0x5 == 0x1 (0x1) +__uint 0x2a != 0x5 == 0x1 (0x1) +char 0x2a != 0x5 == 0x1 (0x1) +__uchar 0x2a != 0x5 == 0x1 (0x1) +__longlong 0x2a != 0x5 == 0x1 (0x1) +__ulonglong 0x2a != 0x5 == 0x1 (0x1) +float 0x2a != 0x5 == 0x1 (0x1) +int 0x2a >= 0x5 == 0x1 (0x1) +__uint 0x2a >= 0x5 == 0x1 (0x1) +char 0x2a >= 0x5 == 0x1 (0x1) +__uchar 0x2a >= 0x5 == 0x1 (0x1) +__longlong 0x2a >= 0x5 == 0x1 (0x1) +__ulonglong 0x2a >= 0x5 == 0x1 (0x1) +float 0x2a >= 0x5 == 0x1 (0x1) +int 0x2a / 0x5 == 0x8 (0x8) +__uint 0x2a / 0x5 == 0x8 (0x8) +char 0x2a / 0x5 == 0x8 (0x8) +__uchar 0x2a / 0x5 == 0x8 (0x8) +__longlong 0x2a / 0x5 == 0x8 (0x8) +__ulonglong 0x2a / 0x5 == 0x8 (0x8) +float 0x2a / 0x5 == 0x8 (0x8) +int 0x2a % 0x5 == 0x2 (0x2) +__uint 0x2a % 0x5 == 0x2 (0x2) +char 0x2a % 0x5 == 0x2 (0x2) +__uchar 0x2a % 0x5 == 0x2 (0x2) +__longlong 0x2a % 0x5 == 0x2 (0x2) +__ulonglong 0x2a % 0x5 == 0x2 (0x2) +0x2a * 0x7 == 0x126 +0x2a / 0x7 == 0x6 +0x2a % 0x7 == 0x0 +int 0x2a ^ 0x7 == 0x2d (0x2d) +__uint 0x2a ^ 0x7 == 0x2d (0x2d) +char 0x2a ^ 0x7 == 0x2d (0x2d) +__uchar 0x2a ^ 0x7 == 0x2d (0x2d) +__longlong 0x2a ^ 0x7 == 0x2d (0x2d) +__ulonglong 0x2a ^ 0x7 == 0x2d (0x2d) +int 0x2a && 0x7 == 0x1 (0x1) +__uint 0x2a && 0x7 == 0x1 (0x1) +char 0x2a && 0x7 == 0x1 (0x1) +__uchar 0x2a && 0x7 == 0x1 (0x1) +__longlong 0x2a && 0x7 == 0x1 (0x1) +__ulonglong 0x2a && 0x7 == 0x1 (0x1) +int 0x2a || 0x7 == 0x1 (0x1) +__uint 0x2a || 0x7 == 0x1 (0x1) +char 0x2a || 0x7 == 0x1 (0x1) +__uchar 0x2a || 0x7 == 0x1 (0x1) +__longlong 0x2a || 0x7 == 0x1 (0x1) +__ulonglong 0x2a || 0x7 == 0x1 (0x1) +int 0x2a & 0x7 == 0x2 (0x2) +__uint 0x2a & 0x7 == 0x2 (0x2) +char 0x2a & 0x7 == 0x2 (0x2) +__uchar 0x2a & 0x7 == 0x2 (0x2) +__longlong 0x2a & 0x7 == 0x2 (0x2) +__ulonglong 0x2a & 0x7 == 0x2 (0x2) +int 0x2a | 0x7 == 0x2f (0x2f) +__uint 0x2a | 0x7 == 0x2f (0x2f) +char 0x2a | 0x7 == 0x2f (0x2f) +__uchar 0x2a | 0x7 == 0x2f (0x2f) +__longlong 0x2a | 0x7 == 0x2f (0x2f) +__ulonglong 0x2a | 0x7 == 0x2f (0x2f) +int 0x2a << 0xa == -0x5800 (0xa800) +__uint 0x2a << 0xa == -0x5800 (0xa800) +char 0x2a << 0xa == 0x0 (0x0) +__uchar 0x2a << 0xa == 0x0 (0x0) +__longlong 0x2a << 0xa == -0x5800 (0xa800) +__ulonglong 0x2a << 0xa == -0x5800 (0xa800) +int 0x2a >> 0xa == 0x0 (0x0) +__uint 0x2a >> 0xa == 0x0 (0x0) +char 0x2a >> 0xa == 0x0 (0x0) +__uchar 0x2a >> 0xa == 0x0 (0x0) +__longlong 0x2a >> 0xa == 0x0 (0x0) +__ulonglong 0x2a >> 0xa == 0x0 (0x0) +int 0x2a + 0x7 == 0x31 (0x31) +__uint 0x2a + 0x7 == 0x31 (0x31) +char 0x2a + 0x7 == 0x31 (0x31) +__uchar 0x2a + 0x7 == 0x31 (0x31) +__longlong 0x2a + 0x7 == 0x31 (0x31) +__ulonglong 0x2a + 0x7 == 0x31 (0x31) +float 0x2a + 0x7 == 0x31 (0x31) +int 0x2a - 0x7 == 0x23 (0x23) +__uint 0x2a - 0x7 == 0x23 (0x23) +char 0x2a - 0x7 == 0x23 (0x23) +__uchar 0x2a - 0x7 == 0x23 (0x23) +__longlong 0x2a - 0x7 == 0x23 (0x23) +__ulonglong 0x2a - 0x7 == 0x23 (0x23) +float 0x2a - 0x7 == 0x23 (0x23) +int 0x2a * 0x7 == 0x126 (0x126) +__uint 0x2a * 0x7 == 0x126 (0x126) +char 0x2a * 0x7 == 0x26 (0x26) +__uchar 0x2a * 0x7 == 0x26 (0x26) +__longlong 0x2a * 0x7 == 0x126 (0x126) +__ulonglong 0x2a * 0x7 == 0x126 (0x126) +float 0x2a * 0x7 == 0x126 (0x126) +int 0x2a < 0x7 == 0x0 (0x0) +__uint 0x2a < 0x7 == 0x0 (0x0) +char 0x2a < 0x7 == 0x0 (0x0) +__uchar 0x2a < 0x7 == 0x0 (0x0) +__longlong 0x2a < 0x7 == 0x0 (0x0) +__ulonglong 0x2a < 0x7 == 0x0 (0x0) +float 0x2a < 0x7 == 0x0 (0x0) +int 0x2a > 0x7 == 0x1 (0x1) +__uint 0x2a > 0x7 == 0x1 (0x1) +char 0x2a > 0x7 == 0x1 (0x1) +__uchar 0x2a > 0x7 == 0x1 (0x1) +__longlong 0x2a > 0x7 == 0x1 (0x1) +__ulonglong 0x2a > 0x7 == 0x1 (0x1) +float 0x2a > 0x7 == 0x1 (0x1) +int 0x2a <= 0x7 == 0x0 (0x0) +__uint 0x2a <= 0x7 == 0x0 (0x0) +char 0x2a <= 0x7 == 0x0 (0x0) +__uchar 0x2a <= 0x7 == 0x0 (0x0) +__longlong 0x2a <= 0x7 == 0x0 (0x0) +__ulonglong 0x2a <= 0x7 == 0x0 (0x0) +float 0x2a <= 0x7 == 0x0 (0x0) +int 0x2a == 0x7 == 0x0 (0x0) +__uint 0x2a == 0x7 == 0x0 (0x0) +char 0x2a == 0x7 == 0x0 (0x0) +__uchar 0x2a == 0x7 == 0x0 (0x0) +__longlong 0x2a == 0x7 == 0x0 (0x0) +__ulonglong 0x2a == 0x7 == 0x0 (0x0) +float 0x2a == 0x7 == 0x0 (0x0) +int 0x2a != 0x7 == 0x1 (0x1) +__uint 0x2a != 0x7 == 0x1 (0x1) +char 0x2a != 0x7 == 0x1 (0x1) +__uchar 0x2a != 0x7 == 0x1 (0x1) +__longlong 0x2a != 0x7 == 0x1 (0x1) +__ulonglong 0x2a != 0x7 == 0x1 (0x1) +float 0x2a != 0x7 == 0x1 (0x1) +int 0x2a >= 0x7 == 0x1 (0x1) +__uint 0x2a >= 0x7 == 0x1 (0x1) +char 0x2a >= 0x7 == 0x1 (0x1) +__uchar 0x2a >= 0x7 == 0x1 (0x1) +__longlong 0x2a >= 0x7 == 0x1 (0x1) +__ulonglong 0x2a >= 0x7 == 0x1 (0x1) +float 0x2a >= 0x7 == 0x1 (0x1) +int 0x2a / 0x7 == 0x6 (0x6) +__uint 0x2a / 0x7 == 0x6 (0x6) +char 0x2a / 0x7 == 0x6 (0x6) +__uchar 0x2a / 0x7 == 0x6 (0x6) +__longlong 0x2a / 0x7 == 0x6 (0x6) +__ulonglong 0x2a / 0x7 == 0x6 (0x6) +float 0x2a / 0x7 == 0x6 (0x6) +int 0x2a % 0x7 == 0x0 (0x0) +__uint 0x2a % 0x7 == 0x0 (0x0) +char 0x2a % 0x7 == 0x0 (0x0) +__uchar 0x2a % 0x7 == 0x0 (0x0) +__longlong 0x2a % 0x7 == 0x0 (0x0) +__ulonglong 0x2a % 0x7 == 0x0 (0x0) +0x2a * 0x2a == 0x6e4 +0x2a / 0x2a == 0x1 +0x2a % 0x2a == 0x0 +int 0x2a ^ 0x2a == 0x0 (0x0) +__uint 0x2a ^ 0x2a == 0x0 (0x0) +char 0x2a ^ 0x2a == 0x0 (0x0) +__uchar 0x2a ^ 0x2a == 0x0 (0x0) +__longlong 0x2a ^ 0x2a == 0x0 (0x0) +__ulonglong 0x2a ^ 0x2a == 0x0 (0x0) +int 0x2a && 0x2a == 0x1 (0x1) +__uint 0x2a && 0x2a == 0x1 (0x1) +char 0x2a && 0x2a == 0x1 (0x1) +__uchar 0x2a && 0x2a == 0x1 (0x1) +__longlong 0x2a && 0x2a == 0x1 (0x1) +__ulonglong 0x2a && 0x2a == 0x1 (0x1) +int 0x2a || 0x2a == 0x1 (0x1) +__uint 0x2a || 0x2a == 0x1 (0x1) +char 0x2a || 0x2a == 0x1 (0x1) +__uchar 0x2a || 0x2a == 0x1 (0x1) +__longlong 0x2a || 0x2a == 0x1 (0x1) +__ulonglong 0x2a || 0x2a == 0x1 (0x1) +int 0x2a & 0x2a == 0x2a (0x2a) +__uint 0x2a & 0x2a == 0x2a (0x2a) +char 0x2a & 0x2a == 0x2a (0x2a) +__uchar 0x2a & 0x2a == 0x2a (0x2a) +__longlong 0x2a & 0x2a == 0x2a (0x2a) +__ulonglong 0x2a & 0x2a == 0x2a (0x2a) +int 0x2a | 0x2a == 0x2a (0x2a) +__uint 0x2a | 0x2a == 0x2a (0x2a) +char 0x2a | 0x2a == 0x2a (0x2a) +__uchar 0x2a | 0x2a == 0x2a (0x2a) +__longlong 0x2a | 0x2a == 0x2a (0x2a) +__ulonglong 0x2a | 0x2a == 0x2a (0x2a) +int 0x2a << 0xc == -0x6000 (0xa000) +__uint 0x2a << 0xc == -0x6000 (0xa000) +char 0x2a << 0xc == 0x0 (0x0) +__uchar 0x2a << 0xc == 0x0 (0x0) +__longlong 0x2a << 0xc == -0x6000 (0xa000) +__ulonglong 0x2a << 0xc == -0x6000 (0xa000) +int 0x2a >> 0xc == 0x0 (0x0) +__uint 0x2a >> 0xc == 0x0 (0x0) +char 0x2a >> 0xc == 0x0 (0x0) +__uchar 0x2a >> 0xc == 0x0 (0x0) +__longlong 0x2a >> 0xc == 0x0 (0x0) +__ulonglong 0x2a >> 0xc == 0x0 (0x0) +int 0x2a + 0x2a == 0x54 (0x54) +__uint 0x2a + 0x2a == 0x54 (0x54) +char 0x2a + 0x2a == 0x54 (0x54) +__uchar 0x2a + 0x2a == 0x54 (0x54) +__longlong 0x2a + 0x2a == 0x54 (0x54) +__ulonglong 0x2a + 0x2a == 0x54 (0x54) +float 0x2a + 0x2a == 0x54 (0x54) +int 0x2a - 0x2a == 0x0 (0x0) +__uint 0x2a - 0x2a == 0x0 (0x0) +char 0x2a - 0x2a == 0x0 (0x0) +__uchar 0x2a - 0x2a == 0x0 (0x0) +__longlong 0x2a - 0x2a == 0x0 (0x0) +__ulonglong 0x2a - 0x2a == 0x0 (0x0) +float 0x2a - 0x2a == 0x0 (0x0) +int 0x2a * 0x2a == 0x6e4 (0x6e4) +__uint 0x2a * 0x2a == 0x6e4 (0x6e4) +char 0x2a * 0x2a == -0x1c (0xffe4) +__uchar 0x2a * 0x2a == 0xe4 (0xe4) +__longlong 0x2a * 0x2a == 0x6e4 (0x6e4) +__ulonglong 0x2a * 0x2a == 0x6e4 (0x6e4) +float 0x2a * 0x2a == 0x6e4 (0x6e4) +int 0x2a < 0x2a == 0x0 (0x0) +__uint 0x2a < 0x2a == 0x0 (0x0) +char 0x2a < 0x2a == 0x0 (0x0) +__uchar 0x2a < 0x2a == 0x0 (0x0) +__longlong 0x2a < 0x2a == 0x0 (0x0) +__ulonglong 0x2a < 0x2a == 0x0 (0x0) +float 0x2a < 0x2a == 0x0 (0x0) +int 0x2a > 0x2a == 0x0 (0x0) +__uint 0x2a > 0x2a == 0x0 (0x0) +char 0x2a > 0x2a == 0x0 (0x0) +__uchar 0x2a > 0x2a == 0x0 (0x0) +__longlong 0x2a > 0x2a == 0x0 (0x0) +__ulonglong 0x2a > 0x2a == 0x0 (0x0) +float 0x2a > 0x2a == 0x0 (0x0) +int 0x2a <= 0x2a == 0x1 (0x1) +__uint 0x2a <= 0x2a == 0x1 (0x1) +char 0x2a <= 0x2a == 0x1 (0x1) +__uchar 0x2a <= 0x2a == 0x1 (0x1) +__longlong 0x2a <= 0x2a == 0x1 (0x1) +__ulonglong 0x2a <= 0x2a == 0x1 (0x1) +float 0x2a <= 0x2a == 0x1 (0x1) +int 0x2a == 0x2a == 0x1 (0x1) +__uint 0x2a == 0x2a == 0x1 (0x1) +char 0x2a == 0x2a == 0x1 (0x1) +__uchar 0x2a == 0x2a == 0x1 (0x1) +__longlong 0x2a == 0x2a == 0x1 (0x1) +__ulonglong 0x2a == 0x2a == 0x1 (0x1) +float 0x2a == 0x2a == 0x1 (0x1) +int 0x2a != 0x2a == 0x0 (0x0) +__uint 0x2a != 0x2a == 0x0 (0x0) +char 0x2a != 0x2a == 0x0 (0x0) +__uchar 0x2a != 0x2a == 0x0 (0x0) +__longlong 0x2a != 0x2a == 0x0 (0x0) +__ulonglong 0x2a != 0x2a == 0x0 (0x0) +float 0x2a != 0x2a == 0x0 (0x0) +int 0x2a >= 0x2a == 0x1 (0x1) +__uint 0x2a >= 0x2a == 0x1 (0x1) +char 0x2a >= 0x2a == 0x1 (0x1) +__uchar 0x2a >= 0x2a == 0x1 (0x1) +__longlong 0x2a >= 0x2a == 0x1 (0x1) +__ulonglong 0x2a >= 0x2a == 0x1 (0x1) +float 0x2a >= 0x2a == 0x1 (0x1) +int 0x2a / 0x2a == 0x1 (0x1) +__uint 0x2a / 0x2a == 0x1 (0x1) +char 0x2a / 0x2a == 0x1 (0x1) +__uchar 0x2a / 0x2a == 0x1 (0x1) +__longlong 0x2a / 0x2a == 0x1 (0x1) +__ulonglong 0x2a / 0x2a == 0x1 (0x1) +float 0x2a / 0x2a == 0x1 (0x1) +int 0x2a % 0x2a == 0x0 (0x0) +__uint 0x2a % 0x2a == 0x0 (0x0) +char 0x2a % 0x2a == 0x0 (0x0) +__uchar 0x2a % 0x2a == 0x0 (0x0) +__longlong 0x2a % 0x2a == 0x0 (0x0) +__ulonglong 0x2a % 0x2a == 0x0 (0x0) +0x2a * 0x17 == 0x3c6 +0x2a / 0x17 == 0x1 +0x2a % 0x17 == 0x13 +int 0x2a ^ 0x17 == 0x3d (0x3d) +__uint 0x2a ^ 0x17 == 0x3d (0x3d) +char 0x2a ^ 0x17 == 0x3d (0x3d) +__uchar 0x2a ^ 0x17 == 0x3d (0x3d) +__longlong 0x2a ^ 0x17 == 0x3d (0x3d) +__ulonglong 0x2a ^ 0x17 == 0x3d (0x3d) +int 0x2a && 0x17 == 0x1 (0x1) +__uint 0x2a && 0x17 == 0x1 (0x1) +char 0x2a && 0x17 == 0x1 (0x1) +__uchar 0x2a && 0x17 == 0x1 (0x1) +__longlong 0x2a && 0x17 == 0x1 (0x1) +__ulonglong 0x2a && 0x17 == 0x1 (0x1) +int 0x2a || 0x17 == 0x1 (0x1) +__uint 0x2a || 0x17 == 0x1 (0x1) +char 0x2a || 0x17 == 0x1 (0x1) +__uchar 0x2a || 0x17 == 0x1 (0x1) +__longlong 0x2a || 0x17 == 0x1 (0x1) +__ulonglong 0x2a || 0x17 == 0x1 (0x1) +int 0x2a & 0x17 == 0x2 (0x2) +__uint 0x2a & 0x17 == 0x2 (0x2) +char 0x2a & 0x17 == 0x2 (0x2) +__uchar 0x2a & 0x17 == 0x2 (0x2) +__longlong 0x2a & 0x17 == 0x2 (0x2) +__ulonglong 0x2a & 0x17 == 0x2 (0x2) +int 0x2a | 0x17 == 0x3f (0x3f) +__uint 0x2a | 0x17 == 0x3f (0x3f) +char 0x2a | 0x17 == 0x3f (0x3f) +__uchar 0x2a | 0x17 == 0x3f (0x3f) +__longlong 0x2a | 0x17 == 0x3f (0x3f) +__ulonglong 0x2a | 0x17 == 0x3f (0x3f) +int 0x2a << 0xe == -0x8000 (0x8000) +__uint 0x2a << 0xe == -0x8000 (0x8000) +char 0x2a << 0xe == 0x0 (0x0) +__uchar 0x2a << 0xe == 0x0 (0x0) +__longlong 0x2a << 0xe == -0x8000 (0x8000) +__ulonglong 0x2a << 0xe == -0x8000 (0x8000) +int 0x2a >> 0xe == 0x0 (0x0) +__uint 0x2a >> 0xe == 0x0 (0x0) +char 0x2a >> 0xe == 0x0 (0x0) +__uchar 0x2a >> 0xe == 0x0 (0x0) +__longlong 0x2a >> 0xe == 0x0 (0x0) +__ulonglong 0x2a >> 0xe == 0x0 (0x0) +int 0x2a + 0x17 == 0x41 (0x41) +__uint 0x2a + 0x17 == 0x41 (0x41) +char 0x2a + 0x17 == 0x41 (0x41) +__uchar 0x2a + 0x17 == 0x41 (0x41) +__longlong 0x2a + 0x17 == 0x41 (0x41) +__ulonglong 0x2a + 0x17 == 0x41 (0x41) +float 0x2a + 0x17 == 0x41 (0x41) +int 0x2a - 0x17 == 0x13 (0x13) +__uint 0x2a - 0x17 == 0x13 (0x13) +char 0x2a - 0x17 == 0x13 (0x13) +__uchar 0x2a - 0x17 == 0x13 (0x13) +__longlong 0x2a - 0x17 == 0x13 (0x13) +__ulonglong 0x2a - 0x17 == 0x13 (0x13) +float 0x2a - 0x17 == 0x13 (0x13) +int 0x2a * 0x17 == 0x3c6 (0x3c6) +__uint 0x2a * 0x17 == 0x3c6 (0x3c6) +char 0x2a * 0x17 == -0x3a (0xffc6) +__uchar 0x2a * 0x17 == 0xc6 (0xc6) +__longlong 0x2a * 0x17 == 0x3c6 (0x3c6) +__ulonglong 0x2a * 0x17 == 0x3c6 (0x3c6) +float 0x2a * 0x17 == 0x3c6 (0x3c6) +int 0x2a < 0x17 == 0x0 (0x0) +__uint 0x2a < 0x17 == 0x0 (0x0) +char 0x2a < 0x17 == 0x0 (0x0) +__uchar 0x2a < 0x17 == 0x0 (0x0) +__longlong 0x2a < 0x17 == 0x0 (0x0) +__ulonglong 0x2a < 0x17 == 0x0 (0x0) +float 0x2a < 0x17 == 0x0 (0x0) +int 0x2a > 0x17 == 0x1 (0x1) +__uint 0x2a > 0x17 == 0x1 (0x1) +char 0x2a > 0x17 == 0x1 (0x1) +__uchar 0x2a > 0x17 == 0x1 (0x1) +__longlong 0x2a > 0x17 == 0x1 (0x1) +__ulonglong 0x2a > 0x17 == 0x1 (0x1) +float 0x2a > 0x17 == 0x1 (0x1) +int 0x2a <= 0x17 == 0x0 (0x0) +__uint 0x2a <= 0x17 == 0x0 (0x0) +char 0x2a <= 0x17 == 0x0 (0x0) +__uchar 0x2a <= 0x17 == 0x0 (0x0) +__longlong 0x2a <= 0x17 == 0x0 (0x0) +__ulonglong 0x2a <= 0x17 == 0x0 (0x0) +float 0x2a <= 0x17 == 0x0 (0x0) +int 0x2a == 0x17 == 0x0 (0x0) +__uint 0x2a == 0x17 == 0x0 (0x0) +char 0x2a == 0x17 == 0x0 (0x0) +__uchar 0x2a == 0x17 == 0x0 (0x0) +__longlong 0x2a == 0x17 == 0x0 (0x0) +__ulonglong 0x2a == 0x17 == 0x0 (0x0) +float 0x2a == 0x17 == 0x0 (0x0) +int 0x2a != 0x17 == 0x1 (0x1) +__uint 0x2a != 0x17 == 0x1 (0x1) +char 0x2a != 0x17 == 0x1 (0x1) +__uchar 0x2a != 0x17 == 0x1 (0x1) +__longlong 0x2a != 0x17 == 0x1 (0x1) +__ulonglong 0x2a != 0x17 == 0x1 (0x1) +float 0x2a != 0x17 == 0x1 (0x1) +int 0x2a >= 0x17 == 0x1 (0x1) +__uint 0x2a >= 0x17 == 0x1 (0x1) +char 0x2a >= 0x17 == 0x1 (0x1) +__uchar 0x2a >= 0x17 == 0x1 (0x1) +__longlong 0x2a >= 0x17 == 0x1 (0x1) +__ulonglong 0x2a >= 0x17 == 0x1 (0x1) +float 0x2a >= 0x17 == 0x1 (0x1) +int 0x2a / 0x17 == 0x1 (0x1) +__uint 0x2a / 0x17 == 0x1 (0x1) +char 0x2a / 0x17 == 0x1 (0x1) +__uchar 0x2a / 0x17 == 0x1 (0x1) +__longlong 0x2a / 0x17 == 0x1 (0x1) +__ulonglong 0x2a / 0x17 == 0x1 (0x1) +float 0x2a / 0x17 == 0x1 (0x1) +int 0x2a % 0x17 == 0x13 (0x13) +__uint 0x2a % 0x17 == 0x13 (0x13) +char 0x2a % 0x17 == 0x13 (0x13) +__uchar 0x2a % 0x17 == 0x13 (0x13) +__longlong 0x2a % 0x17 == 0x13 (0x13) +__ulonglong 0x2a % 0x17 == 0x13 (0x13) +0x2a * 0x7fff == -0x2a +0x2a / 0x7fff == 0x0 +0x2a % 0x7fff == 0x2a +int 0x2a ^ 0x7fff == 0x7fd5 (0x7fd5) +__uint 0x2a ^ 0x7fff == 0x7fd5 (0x7fd5) +char 0x2a ^ 0xffff == -0x2b (0xffd5) +__uchar 0x2a ^ 0xff == 0xd5 (0xd5) +__longlong 0x2a ^ 0x7fff == 0x7fd5 (0x7fd5) +__ulonglong 0x2a ^ 0x7fff == 0x7fd5 (0x7fd5) +int 0x2a && 0x7fff == 0x1 (0x1) +__uint 0x2a && 0x7fff == 0x1 (0x1) +char 0x2a && 0xffff == 0x1 (0x1) +__uchar 0x2a && 0xff == 0x1 (0x1) +__longlong 0x2a && 0x7fff == 0x1 (0x1) +__ulonglong 0x2a && 0x7fff == 0x1 (0x1) +int 0x2a || 0x7fff == 0x1 (0x1) +__uint 0x2a || 0x7fff == 0x1 (0x1) +char 0x2a || 0xffff == 0x1 (0x1) +__uchar 0x2a || 0xff == 0x1 (0x1) +__longlong 0x2a || 0x7fff == 0x1 (0x1) +__ulonglong 0x2a || 0x7fff == 0x1 (0x1) +int 0x2a & 0x7fff == 0x2a (0x2a) +__uint 0x2a & 0x7fff == 0x2a (0x2a) +char 0x2a & 0xffff == 0x2a (0x2a) +__uchar 0x2a & 0xff == 0x2a (0x2a) +__longlong 0x2a & 0x7fff == 0x2a (0x2a) +__ulonglong 0x2a & 0x7fff == 0x2a (0x2a) +int 0x2a | 0x7fff == 0x7fff (0x7fff) +__uint 0x2a | 0x7fff == 0x7fff (0x7fff) +char 0x2a | 0xffff == -0x1 (0xffff) +__uchar 0x2a | 0xff == 0xff (0xff) +__longlong 0x2a | 0x7fff == 0x7fff (0x7fff) +__ulonglong 0x2a | 0x7fff == 0x7fff (0x7fff) +int 0x2a << 0x10 == 0x0 (0x0) +__uint 0x2a << 0x10 == 0x0 (0x0) +char 0x2a << 0x10 == 0x0 (0x0) +__uchar 0x2a << 0x10 == 0x0 (0x0) +__longlong 0x2a << 0x10 == 0x0 (0x0) +__ulonglong 0x2a << 0x10 == 0x0 (0x0) +int 0x2a >> 0x10 == 0x0 (0x0) +__uint 0x2a >> 0x10 == 0x0 (0x0) +char 0x2a >> 0x10 == 0x0 (0x0) +__uchar 0x2a >> 0x10 == 0x0 (0x0) +__longlong 0x2a >> 0x10 == 0x0 (0x0) +__ulonglong 0x2a >> 0x10 == 0x0 (0x0) +int 0x2a + 0x7fff == -0x7fd7 (0x8029) +__uint 0x2a + 0x7fff == -0x7fd7 (0x8029) +char 0x2a + 0xffff == 0x29 (0x29) +__uchar 0x2a + 0xff == 0x29 (0x29) +__longlong 0x2a + 0x7fff == -0x7fd7 (0x8029) +__ulonglong 0x2a + 0x7fff == -0x7fd7 (0x8029) +float 0x2a + 0x7fff == -0x7fd7 (0x8029) +int 0x2a - 0x7fff == -0x7fd5 (0x802b) +__uint 0x2a - 0x7fff == -0x7fd5 (0x802b) +char 0x2a - 0xffff == 0x2b (0x2b) +__uchar 0x2a - 0xff == 0x2b (0x2b) +__longlong 0x2a - 0x7fff == -0x7fd5 (0x802b) +__ulonglong 0x2a - 0x7fff == -0x7fd5 (0x802b) +float 0x2a - 0x7fff == -0x7fd5 (0x802b) +int 0x2a * 0x7fff == -0x2a (0xffd6) +__uint 0x2a * 0x7fff == -0x2a (0xffd6) +char 0x2a * 0xffff == -0x2a (0xffd6) +__uchar 0x2a * 0xff == 0xd6 (0xd6) +__longlong 0x2a * 0x7fff == -0x2a (0xffd6) +__ulonglong 0x2a * 0x7fff == -0x2a (0xffd6) +float 0x2a * 0x7fff == -0x2a (0xffd6) +int 0x2a < 0x7fff == 0x1 (0x1) +__uint 0x2a < 0x7fff == 0x1 (0x1) +char 0x2a < 0xffff == 0x0 (0x0) +__uchar 0x2a < 0xff == 0x1 (0x1) +__longlong 0x2a < 0x7fff == 0x1 (0x1) +__ulonglong 0x2a < 0x7fff == 0x1 (0x1) +float 0x2a < 0x7fff == 0x1 (0x1) +int 0x2a > 0x7fff == 0x0 (0x0) +__uint 0x2a > 0x7fff == 0x0 (0x0) +char 0x2a > 0xffff == 0x1 (0x1) +__uchar 0x2a > 0xff == 0x0 (0x0) +__longlong 0x2a > 0x7fff == 0x0 (0x0) +__ulonglong 0x2a > 0x7fff == 0x0 (0x0) +float 0x2a > 0x7fff == 0x0 (0x0) +int 0x2a <= 0x7fff == 0x1 (0x1) +__uint 0x2a <= 0x7fff == 0x1 (0x1) +char 0x2a <= 0xffff == 0x0 (0x0) +__uchar 0x2a <= 0xff == 0x1 (0x1) +__longlong 0x2a <= 0x7fff == 0x1 (0x1) +__ulonglong 0x2a <= 0x7fff == 0x1 (0x1) +float 0x2a <= 0x7fff == 0x1 (0x1) +int 0x2a == 0x7fff == 0x0 (0x0) +__uint 0x2a == 0x7fff == 0x0 (0x0) +char 0x2a == 0xffff == 0x0 (0x0) +__uchar 0x2a == 0xff == 0x0 (0x0) +__longlong 0x2a == 0x7fff == 0x0 (0x0) +__ulonglong 0x2a == 0x7fff == 0x0 (0x0) +float 0x2a == 0x7fff == 0x0 (0x0) +int 0x2a != 0x7fff == 0x1 (0x1) +__uint 0x2a != 0x7fff == 0x1 (0x1) +char 0x2a != 0xffff == 0x1 (0x1) +__uchar 0x2a != 0xff == 0x1 (0x1) +__longlong 0x2a != 0x7fff == 0x1 (0x1) +__ulonglong 0x2a != 0x7fff == 0x1 (0x1) +float 0x2a != 0x7fff == 0x1 (0x1) +int 0x2a >= 0x7fff == 0x0 (0x0) +__uint 0x2a >= 0x7fff == 0x0 (0x0) +char 0x2a >= 0xffff == 0x1 (0x1) +__uchar 0x2a >= 0xff == 0x0 (0x0) +__longlong 0x2a >= 0x7fff == 0x0 (0x0) +__ulonglong 0x2a >= 0x7fff == 0x0 (0x0) +float 0x2a >= 0x7fff == 0x0 (0x0) +int 0x2a / 0x7fff == 0x0 (0x0) +__uint 0x2a / 0x7fff == 0x0 (0x0) +char 0x2a / 0xffff == -0x2a (0xffd6) +__uchar 0x2a / 0xff == 0x0 (0x0) +__longlong 0x2a / 0x7fff == 0x0 (0x0) +__ulonglong 0x2a / 0x7fff == 0x0 (0x0) +float 0x2a / 0x7fff == 0x0 (0x0) +int 0x2a % 0x7fff == 0x2a (0x2a) +__uint 0x2a % 0x7fff == 0x2a (0x2a) +char 0x2a % 0xffff == 0x0 (0x0) +__uchar 0x2a % 0xff == 0x2a (0x2a) +__longlong 0x2a % 0x7fff == 0x2a (0x2a) +__ulonglong 0x2a % 0x7fff == 0x2a (0x2a) +0x2a * 0x8000 == 0x0 +0x2a / 0x8000 == 0x0 +0x2a % 0x8000 == 0x2a +int 0x2a ^ 0x8000 == -0x7fd6 (0x802a) +__uint 0x2a ^ 0x8000 == -0x7fd6 (0x802a) +char 0x2a ^ 0x0 == 0x2a (0x2a) +__uchar 0x2a ^ 0x0 == 0x2a (0x2a) +__longlong 0x2a ^ 0x8000 == -0x7fd6 (0x802a) +__ulonglong 0x2a ^ 0x8000 == -0x7fd6 (0x802a) +int 0x2a && 0x8000 == 0x1 (0x1) +__uint 0x2a && 0x8000 == 0x1 (0x1) +char 0x2a && 0x0 == 0x0 (0x0) +__uchar 0x2a && 0x0 == 0x0 (0x0) +__longlong 0x2a && 0x8000 == 0x1 (0x1) +__ulonglong 0x2a && 0x8000 == 0x1 (0x1) +int 0x2a || 0x8000 == 0x1 (0x1) +__uint 0x2a || 0x8000 == 0x1 (0x1) +char 0x2a || 0x0 == 0x1 (0x1) +__uchar 0x2a || 0x0 == 0x1 (0x1) +__longlong 0x2a || 0x8000 == 0x1 (0x1) +__ulonglong 0x2a || 0x8000 == 0x1 (0x1) +int 0x2a & 0x8000 == 0x0 (0x0) +__uint 0x2a & 0x8000 == 0x0 (0x0) +char 0x2a & 0x0 == 0x0 (0x0) +__uchar 0x2a & 0x0 == 0x0 (0x0) +__longlong 0x2a & 0x8000 == 0x0 (0x0) +__ulonglong 0x2a & 0x8000 == 0x0 (0x0) +int 0x2a | 0x8000 == -0x7fd6 (0x802a) +__uint 0x2a | 0x8000 == -0x7fd6 (0x802a) +char 0x2a | 0x0 == 0x2a (0x2a) +__uchar 0x2a | 0x0 == 0x2a (0x2a) +__longlong 0x2a | 0x8000 == -0x7fd6 (0x802a) +__ulonglong 0x2a | 0x8000 == -0x7fd6 (0x802a) +int 0x2a << 0x12 == 0x0 (0x0) +__uint 0x2a << 0x12 == 0x0 (0x0) +char 0x2a << 0x12 == 0x0 (0x0) +__uchar 0x2a << 0x12 == 0x0 (0x0) +__longlong 0x2a << 0x12 == 0x0 (0x0) +__ulonglong 0x2a << 0x12 == 0x0 (0x0) +int 0x2a >> 0x12 == 0x0 (0x0) +__uint 0x2a >> 0x12 == 0x0 (0x0) +char 0x2a >> 0x12 == 0x0 (0x0) +__uchar 0x2a >> 0x12 == 0x0 (0x0) +__longlong 0x2a >> 0x12 == 0x0 (0x0) +__ulonglong 0x2a >> 0x12 == 0x0 (0x0) +int 0x2a + 0x8000 == -0x7fd6 (0x802a) +__uint 0x2a + 0x8000 == -0x7fd6 (0x802a) +char 0x2a + 0x0 == 0x2a (0x2a) +__uchar 0x2a + 0x0 == 0x2a (0x2a) +__longlong 0x2a + 0x8000 == -0x7fd6 (0x802a) +__ulonglong 0x2a + 0x8000 == -0x7fd6 (0x802a) +float 0x2a + 0x8000 == -0x7fd6 (0x802a) +int 0x2a - 0x8000 == -0x7fd6 (0x802a) +__uint 0x2a - 0x8000 == -0x7fd6 (0x802a) +char 0x2a - 0x0 == 0x2a (0x2a) +__uchar 0x2a - 0x0 == 0x2a (0x2a) +__longlong 0x2a - 0x8000 == -0x7fd6 (0x802a) +__ulonglong 0x2a - 0x8000 == -0x7fd6 (0x802a) +float 0x2a - 0x8000 == -0x7fd6 (0x802a) +int 0x2a * 0x8000 == 0x0 (0x0) +__uint 0x2a * 0x8000 == 0x0 (0x0) +char 0x2a * 0x0 == 0x0 (0x0) +__uchar 0x2a * 0x0 == 0x0 (0x0) +__longlong 0x2a * 0x8000 == 0x0 (0x0) +__ulonglong 0x2a * 0x8000 == 0x0 (0x0) +float 0x2a * 0x8000 == 0x0 (0x0) +int 0x2a < 0x8000 == 0x0 (0x0) +__uint 0x2a < 0x8000 == 0x1 (0x1) +char 0x2a < 0x0 == 0x0 (0x0) +__uchar 0x2a < 0x0 == 0x0 (0x0) +__longlong 0x2a < 0x8000 == 0x0 (0x0) +__ulonglong 0x2a < 0x8000 == 0x1 (0x1) +float 0x2a < 0x8000 == 0x0 (0x0) +int 0x2a > 0x8000 == 0x1 (0x1) +__uint 0x2a > 0x8000 == 0x0 (0x0) +char 0x2a > 0x0 == 0x1 (0x1) +__uchar 0x2a > 0x0 == 0x1 (0x1) +__longlong 0x2a > 0x8000 == 0x1 (0x1) +__ulonglong 0x2a > 0x8000 == 0x0 (0x0) +float 0x2a > 0x8000 == 0x1 (0x1) +int 0x2a <= 0x8000 == 0x0 (0x0) +__uint 0x2a <= 0x8000 == 0x1 (0x1) +char 0x2a <= 0x0 == 0x0 (0x0) +__uchar 0x2a <= 0x0 == 0x0 (0x0) +__longlong 0x2a <= 0x8000 == 0x0 (0x0) +__ulonglong 0x2a <= 0x8000 == 0x1 (0x1) +float 0x2a <= 0x8000 == 0x0 (0x0) +int 0x2a == 0x8000 == 0x0 (0x0) +__uint 0x2a == 0x8000 == 0x0 (0x0) +char 0x2a == 0x0 == 0x0 (0x0) +__uchar 0x2a == 0x0 == 0x0 (0x0) +__longlong 0x2a == 0x8000 == 0x0 (0x0) +__ulonglong 0x2a == 0x8000 == 0x0 (0x0) +float 0x2a == 0x8000 == 0x0 (0x0) +int 0x2a != 0x8000 == 0x1 (0x1) +__uint 0x2a != 0x8000 == 0x1 (0x1) +char 0x2a != 0x0 == 0x1 (0x1) +__uchar 0x2a != 0x0 == 0x1 (0x1) +__longlong 0x2a != 0x8000 == 0x1 (0x1) +__ulonglong 0x2a != 0x8000 == 0x1 (0x1) +float 0x2a != 0x8000 == 0x1 (0x1) +int 0x2a >= 0x8000 == 0x1 (0x1) +__uint 0x2a >= 0x8000 == 0x0 (0x0) +char 0x2a >= 0x0 == 0x1 (0x1) +__uchar 0x2a >= 0x0 == 0x1 (0x1) +__longlong 0x2a >= 0x8000 == 0x1 (0x1) +__ulonglong 0x2a >= 0x8000 == 0x0 (0x0) +float 0x2a >= 0x8000 == 0x1 (0x1) +int 0x2a / 0x8000 == 0x0 (0x0) +__uint 0x2a / 0x8000 == 0x0 (0x0) +__longlong 0x2a / 0x8000 == 0x0 (0x0) +__ulonglong 0x2a / 0x8000 == 0x0 (0x0) +float 0x2a / 0x8000 == 0x0 (0x0) +int 0x2a % 0x8000 == 0x2a (0x2a) +__uint 0x2a % 0x8000 == 0x2a (0x2a) +__longlong 0x2a % 0x8000 == 0x2a (0x2a) +__ulonglong 0x2a % 0x8000 == 0x2a (0x2a) +0x2a * 0x3e8 == -0x5bf0 +0x2a / 0x3e8 == 0x0 +0x2a % 0x3e8 == 0x2a +int 0x2a ^ 0x3e8 == 0x3c2 (0x3c2) +__uint 0x2a ^ 0x3e8 == 0x3c2 (0x3c2) +char 0x2a ^ 0xffe8 == -0x3e (0xffc2) +__uchar 0x2a ^ 0xe8 == 0xc2 (0xc2) +__longlong 0x2a ^ 0x3e8 == 0x3c2 (0x3c2) +__ulonglong 0x2a ^ 0x3e8 == 0x3c2 (0x3c2) +int 0x2a && 0x3e8 == 0x1 (0x1) +__uint 0x2a && 0x3e8 == 0x1 (0x1) +char 0x2a && 0xffe8 == 0x1 (0x1) +__uchar 0x2a && 0xe8 == 0x1 (0x1) +__longlong 0x2a && 0x3e8 == 0x1 (0x1) +__ulonglong 0x2a && 0x3e8 == 0x1 (0x1) +int 0x2a || 0x3e8 == 0x1 (0x1) +__uint 0x2a || 0x3e8 == 0x1 (0x1) +char 0x2a || 0xffe8 == 0x1 (0x1) +__uchar 0x2a || 0xe8 == 0x1 (0x1) +__longlong 0x2a || 0x3e8 == 0x1 (0x1) +__ulonglong 0x2a || 0x3e8 == 0x1 (0x1) +int 0x2a & 0x3e8 == 0x28 (0x28) +__uint 0x2a & 0x3e8 == 0x28 (0x28) +char 0x2a & 0xffe8 == 0x28 (0x28) +__uchar 0x2a & 0xe8 == 0x28 (0x28) +__longlong 0x2a & 0x3e8 == 0x28 (0x28) +__ulonglong 0x2a & 0x3e8 == 0x28 (0x28) +int 0x2a | 0x3e8 == 0x3ea (0x3ea) +__uint 0x2a | 0x3e8 == 0x3ea (0x3ea) +char 0x2a | 0xffe8 == -0x16 (0xffea) +__uchar 0x2a | 0xe8 == 0xea (0xea) +__longlong 0x2a | 0x3e8 == 0x3ea (0x3ea) +__ulonglong 0x2a | 0x3e8 == 0x3ea (0x3ea) +int 0x2a << 0x14 == 0x0 (0x0) +__uint 0x2a << 0x14 == 0x0 (0x0) +char 0x2a << 0x14 == 0x0 (0x0) +__uchar 0x2a << 0x14 == 0x0 (0x0) +__longlong 0x2a << 0x14 == 0x0 (0x0) +__ulonglong 0x2a << 0x14 == 0x0 (0x0) +int 0x2a >> 0x14 == 0x0 (0x0) +__uint 0x2a >> 0x14 == 0x0 (0x0) +char 0x2a >> 0x14 == 0x0 (0x0) +__uchar 0x2a >> 0x14 == 0x0 (0x0) +__longlong 0x2a >> 0x14 == 0x0 (0x0) +__ulonglong 0x2a >> 0x14 == 0x0 (0x0) +int 0x2a + 0x3e8 == 0x412 (0x412) +__uint 0x2a + 0x3e8 == 0x412 (0x412) +char 0x2a + 0xffe8 == 0x12 (0x12) +__uchar 0x2a + 0xe8 == 0x12 (0x12) +__longlong 0x2a + 0x3e8 == 0x412 (0x412) +__ulonglong 0x2a + 0x3e8 == 0x412 (0x412) +float 0x2a + 0x3e8 == 0x412 (0x412) +int 0x2a - 0x3e8 == -0x3be (0xfc42) +__uint 0x2a - 0x3e8 == -0x3be (0xfc42) +char 0x2a - 0xffe8 == 0x42 (0x42) +__uchar 0x2a - 0xe8 == 0x42 (0x42) +__longlong 0x2a - 0x3e8 == -0x3be (0xfc42) +__ulonglong 0x2a - 0x3e8 == -0x3be (0xfc42) +float 0x2a - 0x3e8 == -0x3be (0xfc42) +int 0x2a * 0x3e8 == -0x5bf0 (0xa410) +__uint 0x2a * 0x3e8 == -0x5bf0 (0xa410) +char 0x2a * 0xffe8 == 0x10 (0x10) +__uchar 0x2a * 0xe8 == 0x10 (0x10) +__longlong 0x2a * 0x3e8 == -0x5bf0 (0xa410) +__ulonglong 0x2a * 0x3e8 == -0x5bf0 (0xa410) +float 0x2a * 0x3e8 == -0x5bf0 (0xa410) +int 0x2a < 0x3e8 == 0x1 (0x1) +__uint 0x2a < 0x3e8 == 0x1 (0x1) +char 0x2a < 0xffe8 == 0x0 (0x0) +__uchar 0x2a < 0xe8 == 0x1 (0x1) +__longlong 0x2a < 0x3e8 == 0x1 (0x1) +__ulonglong 0x2a < 0x3e8 == 0x1 (0x1) +float 0x2a < 0x3e8 == 0x1 (0x1) +int 0x2a > 0x3e8 == 0x0 (0x0) +__uint 0x2a > 0x3e8 == 0x0 (0x0) +char 0x2a > 0xffe8 == 0x1 (0x1) +__uchar 0x2a > 0xe8 == 0x0 (0x0) +__longlong 0x2a > 0x3e8 == 0x0 (0x0) +__ulonglong 0x2a > 0x3e8 == 0x0 (0x0) +float 0x2a > 0x3e8 == 0x0 (0x0) +int 0x2a <= 0x3e8 == 0x1 (0x1) +__uint 0x2a <= 0x3e8 == 0x1 (0x1) +char 0x2a <= 0xffe8 == 0x0 (0x0) +__uchar 0x2a <= 0xe8 == 0x1 (0x1) +__longlong 0x2a <= 0x3e8 == 0x1 (0x1) +__ulonglong 0x2a <= 0x3e8 == 0x1 (0x1) +float 0x2a <= 0x3e8 == 0x1 (0x1) +int 0x2a == 0x3e8 == 0x0 (0x0) +__uint 0x2a == 0x3e8 == 0x0 (0x0) +char 0x2a == 0xffe8 == 0x0 (0x0) +__uchar 0x2a == 0xe8 == 0x0 (0x0) +__longlong 0x2a == 0x3e8 == 0x0 (0x0) +__ulonglong 0x2a == 0x3e8 == 0x0 (0x0) +float 0x2a == 0x3e8 == 0x0 (0x0) +int 0x2a != 0x3e8 == 0x1 (0x1) +__uint 0x2a != 0x3e8 == 0x1 (0x1) +char 0x2a != 0xffe8 == 0x1 (0x1) +__uchar 0x2a != 0xe8 == 0x1 (0x1) +__longlong 0x2a != 0x3e8 == 0x1 (0x1) +__ulonglong 0x2a != 0x3e8 == 0x1 (0x1) +float 0x2a != 0x3e8 == 0x1 (0x1) +int 0x2a >= 0x3e8 == 0x0 (0x0) +__uint 0x2a >= 0x3e8 == 0x0 (0x0) +char 0x2a >= 0xffe8 == 0x1 (0x1) +__uchar 0x2a >= 0xe8 == 0x0 (0x0) +__longlong 0x2a >= 0x3e8 == 0x0 (0x0) +__ulonglong 0x2a >= 0x3e8 == 0x0 (0x0) +float 0x2a >= 0x3e8 == 0x0 (0x0) +int 0x2a / 0x3e8 == 0x0 (0x0) +__uint 0x2a / 0x3e8 == 0x0 (0x0) +char 0x2a / 0xffe8 == -0x1 (0xffff) +__uchar 0x2a / 0xe8 == 0x0 (0x0) +__longlong 0x2a / 0x3e8 == 0x0 (0x0) +__ulonglong 0x2a / 0x3e8 == 0x0 (0x0) +float 0x2a / 0x3e8 == 0x0 (0x0) +int 0x2a % 0x3e8 == 0x2a (0x2a) +__uint 0x2a % 0x3e8 == 0x2a (0x2a) +char 0x2a % 0xffe8 == 0x12 (0x12) +__uchar 0x2a % 0xe8 == 0x2a (0x2a) +__longlong 0x2a % 0x3e8 == 0x2a (0x2a) +__ulonglong 0x2a % 0x3e8 == 0x2a (0x2a) +0x2a * 0x2710 == 0x68a0 +0x2a / 0x2710 == 0x0 +0x2a % 0x2710 == 0x2a +int 0x2a ^ 0x2710 == 0x273a (0x273a) +__uint 0x2a ^ 0x2710 == 0x273a (0x273a) +char 0x2a ^ 0x10 == 0x3a (0x3a) +__uchar 0x2a ^ 0x10 == 0x3a (0x3a) +__longlong 0x2a ^ 0x2710 == 0x273a (0x273a) +__ulonglong 0x2a ^ 0x2710 == 0x273a (0x273a) +int 0x2a && 0x2710 == 0x1 (0x1) +__uint 0x2a && 0x2710 == 0x1 (0x1) +char 0x2a && 0x10 == 0x1 (0x1) +__uchar 0x2a && 0x10 == 0x1 (0x1) +__longlong 0x2a && 0x2710 == 0x1 (0x1) +__ulonglong 0x2a && 0x2710 == 0x1 (0x1) +int 0x2a || 0x2710 == 0x1 (0x1) +__uint 0x2a || 0x2710 == 0x1 (0x1) +char 0x2a || 0x10 == 0x1 (0x1) +__uchar 0x2a || 0x10 == 0x1 (0x1) +__longlong 0x2a || 0x2710 == 0x1 (0x1) +__ulonglong 0x2a || 0x2710 == 0x1 (0x1) +int 0x2a & 0x2710 == 0x0 (0x0) +__uint 0x2a & 0x2710 == 0x0 (0x0) +char 0x2a & 0x10 == 0x0 (0x0) +__uchar 0x2a & 0x10 == 0x0 (0x0) +__longlong 0x2a & 0x2710 == 0x0 (0x0) +__ulonglong 0x2a & 0x2710 == 0x0 (0x0) +int 0x2a | 0x2710 == 0x273a (0x273a) +__uint 0x2a | 0x2710 == 0x273a (0x273a) +char 0x2a | 0x10 == 0x3a (0x3a) +__uchar 0x2a | 0x10 == 0x3a (0x3a) +__longlong 0x2a | 0x2710 == 0x273a (0x273a) +__ulonglong 0x2a | 0x2710 == 0x273a (0x273a) +int 0x2a << 0x16 == 0x0 (0x0) +__uint 0x2a << 0x16 == 0x0 (0x0) +char 0x2a << 0x16 == 0x0 (0x0) +__uchar 0x2a << 0x16 == 0x0 (0x0) +__longlong 0x2a << 0x16 == 0x0 (0x0) +__ulonglong 0x2a << 0x16 == 0x0 (0x0) +int 0x2a >> 0x16 == 0x0 (0x0) +__uint 0x2a >> 0x16 == 0x0 (0x0) +char 0x2a >> 0x16 == 0x0 (0x0) +__uchar 0x2a >> 0x16 == 0x0 (0x0) +__longlong 0x2a >> 0x16 == 0x0 (0x0) +__ulonglong 0x2a >> 0x16 == 0x0 (0x0) +int 0x2a + 0x2710 == 0x273a (0x273a) +__uint 0x2a + 0x2710 == 0x273a (0x273a) +char 0x2a + 0x10 == 0x3a (0x3a) +__uchar 0x2a + 0x10 == 0x3a (0x3a) +__longlong 0x2a + 0x2710 == 0x273a (0x273a) +__ulonglong 0x2a + 0x2710 == 0x273a (0x273a) +float 0x2a + 0x2710 == 0x273a (0x273a) +int 0x2a - 0x2710 == -0x26e6 (0xd91a) +__uint 0x2a - 0x2710 == -0x26e6 (0xd91a) +char 0x2a - 0x10 == 0x1a (0x1a) +__uchar 0x2a - 0x10 == 0x1a (0x1a) +__longlong 0x2a - 0x2710 == -0x26e6 (0xd91a) +__ulonglong 0x2a - 0x2710 == -0x26e6 (0xd91a) +float 0x2a - 0x2710 == -0x26e6 (0xd91a) +int 0x2a * 0x2710 == 0x68a0 (0x68a0) +__uint 0x2a * 0x2710 == 0x68a0 (0x68a0) +char 0x2a * 0x10 == -0x60 (0xffa0) +__uchar 0x2a * 0x10 == 0xa0 (0xa0) +__longlong 0x2a * 0x2710 == 0x68a0 (0x68a0) +__ulonglong 0x2a * 0x2710 == 0x68a0 (0x68a0) +float 0x2a * 0x2710 == 0x68a0 (0x68a0) +int 0x2a < 0x2710 == 0x1 (0x1) +__uint 0x2a < 0x2710 == 0x1 (0x1) +char 0x2a < 0x10 == 0x0 (0x0) +__uchar 0x2a < 0x10 == 0x0 (0x0) +__longlong 0x2a < 0x2710 == 0x1 (0x1) +__ulonglong 0x2a < 0x2710 == 0x1 (0x1) +float 0x2a < 0x2710 == 0x1 (0x1) +int 0x2a > 0x2710 == 0x0 (0x0) +__uint 0x2a > 0x2710 == 0x0 (0x0) +char 0x2a > 0x10 == 0x1 (0x1) +__uchar 0x2a > 0x10 == 0x1 (0x1) +__longlong 0x2a > 0x2710 == 0x0 (0x0) +__ulonglong 0x2a > 0x2710 == 0x0 (0x0) +float 0x2a > 0x2710 == 0x0 (0x0) +int 0x2a <= 0x2710 == 0x1 (0x1) +__uint 0x2a <= 0x2710 == 0x1 (0x1) +char 0x2a <= 0x10 == 0x0 (0x0) +__uchar 0x2a <= 0x10 == 0x0 (0x0) +__longlong 0x2a <= 0x2710 == 0x1 (0x1) +__ulonglong 0x2a <= 0x2710 == 0x1 (0x1) +float 0x2a <= 0x2710 == 0x1 (0x1) +int 0x2a == 0x2710 == 0x0 (0x0) +__uint 0x2a == 0x2710 == 0x0 (0x0) +char 0x2a == 0x10 == 0x0 (0x0) +__uchar 0x2a == 0x10 == 0x0 (0x0) +__longlong 0x2a == 0x2710 == 0x0 (0x0) +__ulonglong 0x2a == 0x2710 == 0x0 (0x0) +float 0x2a == 0x2710 == 0x0 (0x0) +int 0x2a != 0x2710 == 0x1 (0x1) +__uint 0x2a != 0x2710 == 0x1 (0x1) +char 0x2a != 0x10 == 0x1 (0x1) +__uchar 0x2a != 0x10 == 0x1 (0x1) +__longlong 0x2a != 0x2710 == 0x1 (0x1) +__ulonglong 0x2a != 0x2710 == 0x1 (0x1) +float 0x2a != 0x2710 == 0x1 (0x1) +int 0x2a >= 0x2710 == 0x0 (0x0) +__uint 0x2a >= 0x2710 == 0x0 (0x0) +char 0x2a >= 0x10 == 0x1 (0x1) +__uchar 0x2a >= 0x10 == 0x1 (0x1) +__longlong 0x2a >= 0x2710 == 0x0 (0x0) +__ulonglong 0x2a >= 0x2710 == 0x0 (0x0) +float 0x2a >= 0x2710 == 0x0 (0x0) +int 0x2a / 0x2710 == 0x0 (0x0) +__uint 0x2a / 0x2710 == 0x0 (0x0) +char 0x2a / 0x10 == 0x2 (0x2) +__uchar 0x2a / 0x10 == 0x2 (0x2) +__longlong 0x2a / 0x2710 == 0x0 (0x0) +__ulonglong 0x2a / 0x2710 == 0x0 (0x0) +float 0x2a / 0x2710 == 0x0 (0x0) +int 0x2a % 0x2710 == 0x2a (0x2a) +__uint 0x2a % 0x2710 == 0x2a (0x2a) +char 0x2a % 0x10 == 0xa (0xa) +__uchar 0x2a % 0x10 == 0xa (0xa) +__longlong 0x2a % 0x2710 == 0x2a (0x2a) +__ulonglong 0x2a % 0x2710 == 0x2a (0x2a) +int xor420x2a xor42 0x0 +__uint xor420x2a xor42 0x0 +char xor420x2a xor42 0x0 +__uchar xor420x2a xor42 0x0 +__longlong xor420x2a xor42 0x0 +__ulonglong xor420x2a xor42 0x0 +int land10x2a land1 0x1 +__uint land10x2a land1 0x1 +char land10x2a land1 0x1 +__uchar land10x2a land1 0x1 +__longlong land10x2a land1 0x1 +__ulonglong land10x2a land1 0x1 +int lor10x2a lor1 0x1 +__uint lor10x2a lor1 0x1 +char lor10x2a lor1 0x1 +__uchar lor10x2a lor1 0x1 +__longlong lor10x2a lor1 0x1 +__ulonglong lor10x2a lor1 0x1 +int and420x2a and42 0x2a +__uint and420x2a and42 0x2a +char and420x2a and42 0x2a +__uchar and420x2a and42 0x2a +__longlong and420x2a and42 0x2a +__ulonglong and420x2a and42 0x2a +int or420x2a or42 0x2a +__uint or420x2a or42 0x2a +char or420x2a or42 0x2a +__uchar or420x2a or42 0x2a +__longlong or420x2a or42 0x2a +__ulonglong or420x2a or42 0x2a +int shl50x2a shl5 0x540 +__uint shl50x2a shl5 0x540 +char shl50x2a shl5 0x40 +__uchar shl50x2a shl5 0x40 +__longlong shl50x2a shl5 0x540 +__ulonglong shl50x2a shl5 0x540 +int shr50x2a shr5 0x1 +__uint shr50x2a shr5 0x1 +char shr50x2a shr5 0x1 +__uchar shr50x2a shr5 0x1 +__longlong shr50x2a shr5 0x1 +__ulonglong shr50x2a shr5 0x1 +int add420x2a add42 0x54 +__uint add420x2a add42 0x54 +char add420x2a add42 0x54 +__uchar add420x2a add42 0x54 +__longlong add420x2a add42 0x54 +__ulonglong add420x2a add42 0x54 +float add420x2a add42 0x54 +int sub420x2a sub42 0x0 +__uint sub420x2a sub42 0x0 +char sub420x2a sub42 0x0 +__uchar sub420x2a sub42 0x0 +__longlong sub420x2a sub42 0x0 +__ulonglong sub420x2a sub42 0x0 +float sub420x2a sub42 0x0 +int mul420x2a mul42 0x6e4 +__uint mul420x2a mul42 0x6e4 +char mul420x2a mul42 -0x1c +__uchar mul420x2a mul42 0xe4 +__longlong mul420x2a mul42 0x6e4 +__ulonglong mul420x2a mul42 0x6e4 +float mul420x2a mul42 0x6e4 +int lt420x2a lt42 0x0 +__uint lt420x2a lt42 0x0 +char lt420x2a lt42 0x0 +__uchar lt420x2a lt42 0x0 +__longlong lt420x2a lt42 0x0 +__ulonglong lt420x2a lt42 0x0 +float lt420x2a lt42 0x0 +int gt420x2a gt42 0x0 +__uint gt420x2a gt42 0x0 +char gt420x2a gt42 0x0 +__uchar gt420x2a gt42 0x0 +__longlong gt420x2a gt42 0x0 +__ulonglong gt420x2a gt42 0x0 +float gt420x2a gt42 0x0 +int le420x2a le42 0x1 +__uint le420x2a le42 0x1 +char le420x2a le42 0x1 +__uchar le420x2a le42 0x1 +__longlong le420x2a le42 0x1 +__ulonglong le420x2a le42 0x1 +float le420x2a le42 0x1 +int eq420x2a eq42 0x1 +__uint eq420x2a eq42 0x1 +char eq420x2a eq42 0x1 +__uchar eq420x2a eq42 0x1 +__longlong eq420x2a eq42 0x1 +__ulonglong eq420x2a eq42 0x1 +float eq420x2a eq42 0x1 +int ne420x2a ne42 0x0 +__uint ne420x2a ne42 0x0 +char ne420x2a ne42 0x0 +__uchar ne420x2a ne42 0x0 +__longlong ne420x2a ne42 0x0 +__ulonglong ne420x2a ne42 0x0 +float ne420x2a ne42 0x0 +int ge420x2a ge42 0x1 +__uint ge420x2a ge42 0x1 +char ge420x2a ge42 0x1 +__uchar ge420x2a ge42 0x1 +__longlong ge420x2a ge42 0x1 +__ulonglong ge420x2a ge42 0x1 +float ge420x2a ge42 0x1 +int div420x2a div42 0x1 +__uint div420x2a div42 0x1 +char div420x2a div42 0x1 +__uchar div420x2a div42 0x1 +__longlong div420x2a div42 0x1 +__ulonglong div420x2a div42 0x1 +float div420x2a div42 0x1 +int mod230x2a mod23 0x13 +__uint mod230x2a mod23 0x13 +char mod230x2a mod23 0x13 +__uchar mod230x2a mod23 0x13 +__longlong mod230x2a mod23 0x13 +__ulonglong mod230x2a mod23 0x13 +0x17 * 0xffff == -0x17 +0x17 / 0xffff == -0x17 +0x17 % 0xffff == 0x0 +int 0x17 ^ 0xffff == -0x18 (0xffe8) +__uint 0x17 ^ 0xffff == -0x18 (0xffe8) +char 0x17 ^ 0xffff == -0x18 (0xffe8) +__uchar 0x17 ^ 0xff == 0xe8 (0xe8) +__longlong 0x17 ^ 0xffff == -0x18 (0xffe8) +__ulonglong 0x17 ^ 0xffff == -0x18 (0xffe8) +int 0x17 && 0xffff == 0x1 (0x1) +__uint 0x17 && 0xffff == 0x1 (0x1) +char 0x17 && 0xffff == 0x1 (0x1) +__uchar 0x17 && 0xff == 0x1 (0x1) +__longlong 0x17 && 0xffff == 0x1 (0x1) +__ulonglong 0x17 && 0xffff == 0x1 (0x1) +int 0x17 || 0xffff == 0x1 (0x1) +__uint 0x17 || 0xffff == 0x1 (0x1) +char 0x17 || 0xffff == 0x1 (0x1) +__uchar 0x17 || 0xff == 0x1 (0x1) +__longlong 0x17 || 0xffff == 0x1 (0x1) +__ulonglong 0x17 || 0xffff == 0x1 (0x1) +int 0x17 & 0xffff == 0x17 (0x17) +__uint 0x17 & 0xffff == 0x17 (0x17) +char 0x17 & 0xffff == 0x17 (0x17) +__uchar 0x17 & 0xff == 0x17 (0x17) +__longlong 0x17 & 0xffff == 0x17 (0x17) +__ulonglong 0x17 & 0xffff == 0x17 (0x17) +int 0x17 | 0xffff == -0x1 (0xffff) +__uint 0x17 | 0xffff == -0x1 (0xffff) +char 0x17 | 0xffff == -0x1 (0xffff) +__uchar 0x17 | 0xff == 0xff (0xff) +__longlong 0x17 | 0xffff == -0x1 (0xffff) +__ulonglong 0x17 | 0xffff == -0x1 (0xffff) +int 0x17 << 0x1 == 0x2e (0x2e) +__uint 0x17 << 0x1 == 0x2e (0x2e) +char 0x17 << 0x1 == 0x2e (0x2e) +__uchar 0x17 << 0x1 == 0x2e (0x2e) +__longlong 0x17 << 0x1 == 0x2e (0x2e) +__ulonglong 0x17 << 0x1 == 0x2e (0x2e) +int 0x17 >> 0x1 == 0xb (0xb) +__uint 0x17 >> 0x1 == 0xb (0xb) +char 0x17 >> 0x1 == 0xb (0xb) +__uchar 0x17 >> 0x1 == 0xb (0xb) +__longlong 0x17 >> 0x1 == 0xb (0xb) +__ulonglong 0x17 >> 0x1 == 0xb (0xb) +int 0x17 + 0xffff == 0x16 (0x16) +__uint 0x17 + 0xffff == 0x16 (0x16) +char 0x17 + 0xffff == 0x16 (0x16) +__uchar 0x17 + 0xff == 0x16 (0x16) +__longlong 0x17 + 0xffff == 0x16 (0x16) +__ulonglong 0x17 + 0xffff == 0x16 (0x16) +float 0x17 + 0xffff == 0x16 (0x16) +int 0x17 - 0xffff == 0x18 (0x18) +__uint 0x17 - 0xffff == 0x18 (0x18) +char 0x17 - 0xffff == 0x18 (0x18) +__uchar 0x17 - 0xff == 0x18 (0x18) +__longlong 0x17 - 0xffff == 0x18 (0x18) +__ulonglong 0x17 - 0xffff == 0x18 (0x18) +float 0x17 - 0xffff == 0x18 (0x18) +int 0x17 * 0xffff == -0x17 (0xffe9) +__uint 0x17 * 0xffff == -0x17 (0xffe9) +char 0x17 * 0xffff == -0x17 (0xffe9) +__uchar 0x17 * 0xff == 0xe9 (0xe9) +__longlong 0x17 * 0xffff == -0x17 (0xffe9) +__ulonglong 0x17 * 0xffff == -0x17 (0xffe9) +float 0x17 * 0xffff == -0x17 (0xffe9) +int 0x17 < 0xffff == 0x0 (0x0) +__uint 0x17 < 0xffff == 0x1 (0x1) +char 0x17 < 0xffff == 0x0 (0x0) +__uchar 0x17 < 0xff == 0x1 (0x1) +__longlong 0x17 < 0xffff == 0x0 (0x0) +__ulonglong 0x17 < 0xffff == 0x1 (0x1) +float 0x17 < 0xffff == 0x0 (0x0) +int 0x17 > 0xffff == 0x1 (0x1) +__uint 0x17 > 0xffff == 0x0 (0x0) +char 0x17 > 0xffff == 0x1 (0x1) +__uchar 0x17 > 0xff == 0x0 (0x0) +__longlong 0x17 > 0xffff == 0x1 (0x1) +__ulonglong 0x17 > 0xffff == 0x0 (0x0) +float 0x17 > 0xffff == 0x1 (0x1) +int 0x17 <= 0xffff == 0x0 (0x0) +__uint 0x17 <= 0xffff == 0x1 (0x1) +char 0x17 <= 0xffff == 0x0 (0x0) +__uchar 0x17 <= 0xff == 0x1 (0x1) +__longlong 0x17 <= 0xffff == 0x0 (0x0) +__ulonglong 0x17 <= 0xffff == 0x1 (0x1) +float 0x17 <= 0xffff == 0x0 (0x0) +int 0x17 == 0xffff == 0x0 (0x0) +__uint 0x17 == 0xffff == 0x0 (0x0) +char 0x17 == 0xffff == 0x0 (0x0) +__uchar 0x17 == 0xff == 0x0 (0x0) +__longlong 0x17 == 0xffff == 0x0 (0x0) +__ulonglong 0x17 == 0xffff == 0x0 (0x0) +float 0x17 == 0xffff == 0x0 (0x0) +int 0x17 != 0xffff == 0x1 (0x1) +__uint 0x17 != 0xffff == 0x1 (0x1) +char 0x17 != 0xffff == 0x1 (0x1) +__uchar 0x17 != 0xff == 0x1 (0x1) +__longlong 0x17 != 0xffff == 0x1 (0x1) +__ulonglong 0x17 != 0xffff == 0x1 (0x1) +float 0x17 != 0xffff == 0x1 (0x1) +int 0x17 >= 0xffff == 0x1 (0x1) +__uint 0x17 >= 0xffff == 0x0 (0x0) +char 0x17 >= 0xffff == 0x1 (0x1) +__uchar 0x17 >= 0xff == 0x0 (0x0) +__longlong 0x17 >= 0xffff == 0x1 (0x1) +__ulonglong 0x17 >= 0xffff == 0x0 (0x0) +float 0x17 >= 0xffff == 0x1 (0x1) +int 0x17 / 0xffff == -0x17 (0xffe9) +__uint 0x17 / 0xffff == 0x0 (0x0) +char 0x17 / 0xffff == -0x17 (0xffe9) +__uchar 0x17 / 0xff == 0x0 (0x0) +__longlong 0x17 / 0xffff == -0x17 (0xffe9) +__ulonglong 0x17 / 0xffff == 0x0 (0x0) +float 0x17 / 0xffff == -0x17 (0xffe9) +int 0x17 % 0xffff == 0x0 (0x0) +__uint 0x17 % 0xffff == 0x17 (0x17) +char 0x17 % 0xffff == 0x0 (0x0) +__uchar 0x17 % 0xff == 0x17 (0x17) +__longlong 0x17 % 0xffff == 0x0 (0x0) +__ulonglong 0x17 % 0xffff == 0x17 (0x17) +0x17 * 0x1 == 0x17 +0x17 / 0x1 == 0x17 +0x17 % 0x1 == 0x0 +int 0x17 ^ 0x1 == 0x16 (0x16) +__uint 0x17 ^ 0x1 == 0x16 (0x16) +char 0x17 ^ 0x1 == 0x16 (0x16) +__uchar 0x17 ^ 0x1 == 0x16 (0x16) +__longlong 0x17 ^ 0x1 == 0x16 (0x16) +__ulonglong 0x17 ^ 0x1 == 0x16 (0x16) +int 0x17 && 0x1 == 0x1 (0x1) +__uint 0x17 && 0x1 == 0x1 (0x1) +char 0x17 && 0x1 == 0x1 (0x1) +__uchar 0x17 && 0x1 == 0x1 (0x1) +__longlong 0x17 && 0x1 == 0x1 (0x1) +__ulonglong 0x17 && 0x1 == 0x1 (0x1) +int 0x17 || 0x1 == 0x1 (0x1) +__uint 0x17 || 0x1 == 0x1 (0x1) +char 0x17 || 0x1 == 0x1 (0x1) +__uchar 0x17 || 0x1 == 0x1 (0x1) +__longlong 0x17 || 0x1 == 0x1 (0x1) +__ulonglong 0x17 || 0x1 == 0x1 (0x1) +int 0x17 & 0x1 == 0x1 (0x1) +__uint 0x17 & 0x1 == 0x1 (0x1) +char 0x17 & 0x1 == 0x1 (0x1) +__uchar 0x17 & 0x1 == 0x1 (0x1) +__longlong 0x17 & 0x1 == 0x1 (0x1) +__ulonglong 0x17 & 0x1 == 0x1 (0x1) +int 0x17 | 0x1 == 0x17 (0x17) +__uint 0x17 | 0x1 == 0x17 (0x17) +char 0x17 | 0x1 == 0x17 (0x17) +__uchar 0x17 | 0x1 == 0x17 (0x17) +__longlong 0x17 | 0x1 == 0x17 (0x17) +__ulonglong 0x17 | 0x1 == 0x17 (0x17) +int 0x17 << 0x2 == 0x5c (0x5c) +__uint 0x17 << 0x2 == 0x5c (0x5c) +char 0x17 << 0x2 == 0x5c (0x5c) +__uchar 0x17 << 0x2 == 0x5c (0x5c) +__longlong 0x17 << 0x2 == 0x5c (0x5c) +__ulonglong 0x17 << 0x2 == 0x5c (0x5c) +int 0x17 >> 0x2 == 0x5 (0x5) +__uint 0x17 >> 0x2 == 0x5 (0x5) +char 0x17 >> 0x2 == 0x5 (0x5) +__uchar 0x17 >> 0x2 == 0x5 (0x5) +__longlong 0x17 >> 0x2 == 0x5 (0x5) +__ulonglong 0x17 >> 0x2 == 0x5 (0x5) +int 0x17 + 0x1 == 0x18 (0x18) +__uint 0x17 + 0x1 == 0x18 (0x18) +char 0x17 + 0x1 == 0x18 (0x18) +__uchar 0x17 + 0x1 == 0x18 (0x18) +__longlong 0x17 + 0x1 == 0x18 (0x18) +__ulonglong 0x17 + 0x1 == 0x18 (0x18) +float 0x17 + 0x1 == 0x18 (0x18) +int 0x17 - 0x1 == 0x16 (0x16) +__uint 0x17 - 0x1 == 0x16 (0x16) +char 0x17 - 0x1 == 0x16 (0x16) +__uchar 0x17 - 0x1 == 0x16 (0x16) +__longlong 0x17 - 0x1 == 0x16 (0x16) +__ulonglong 0x17 - 0x1 == 0x16 (0x16) +float 0x17 - 0x1 == 0x16 (0x16) +int 0x17 * 0x1 == 0x17 (0x17) +__uint 0x17 * 0x1 == 0x17 (0x17) +char 0x17 * 0x1 == 0x17 (0x17) +__uchar 0x17 * 0x1 == 0x17 (0x17) +__longlong 0x17 * 0x1 == 0x17 (0x17) +__ulonglong 0x17 * 0x1 == 0x17 (0x17) +float 0x17 * 0x1 == 0x17 (0x17) +int 0x17 < 0x1 == 0x0 (0x0) +__uint 0x17 < 0x1 == 0x0 (0x0) +char 0x17 < 0x1 == 0x0 (0x0) +__uchar 0x17 < 0x1 == 0x0 (0x0) +__longlong 0x17 < 0x1 == 0x0 (0x0) +__ulonglong 0x17 < 0x1 == 0x0 (0x0) +float 0x17 < 0x1 == 0x0 (0x0) +int 0x17 > 0x1 == 0x1 (0x1) +__uint 0x17 > 0x1 == 0x1 (0x1) +char 0x17 > 0x1 == 0x1 (0x1) +__uchar 0x17 > 0x1 == 0x1 (0x1) +__longlong 0x17 > 0x1 == 0x1 (0x1) +__ulonglong 0x17 > 0x1 == 0x1 (0x1) +float 0x17 > 0x1 == 0x1 (0x1) +int 0x17 <= 0x1 == 0x0 (0x0) +__uint 0x17 <= 0x1 == 0x0 (0x0) +char 0x17 <= 0x1 == 0x0 (0x0) +__uchar 0x17 <= 0x1 == 0x0 (0x0) +__longlong 0x17 <= 0x1 == 0x0 (0x0) +__ulonglong 0x17 <= 0x1 == 0x0 (0x0) +float 0x17 <= 0x1 == 0x0 (0x0) +int 0x17 == 0x1 == 0x0 (0x0) +__uint 0x17 == 0x1 == 0x0 (0x0) +char 0x17 == 0x1 == 0x0 (0x0) +__uchar 0x17 == 0x1 == 0x0 (0x0) +__longlong 0x17 == 0x1 == 0x0 (0x0) +__ulonglong 0x17 == 0x1 == 0x0 (0x0) +float 0x17 == 0x1 == 0x0 (0x0) +int 0x17 != 0x1 == 0x1 (0x1) +__uint 0x17 != 0x1 == 0x1 (0x1) +char 0x17 != 0x1 == 0x1 (0x1) +__uchar 0x17 != 0x1 == 0x1 (0x1) +__longlong 0x17 != 0x1 == 0x1 (0x1) +__ulonglong 0x17 != 0x1 == 0x1 (0x1) +float 0x17 != 0x1 == 0x1 (0x1) +int 0x17 >= 0x1 == 0x1 (0x1) +__uint 0x17 >= 0x1 == 0x1 (0x1) +char 0x17 >= 0x1 == 0x1 (0x1) +__uchar 0x17 >= 0x1 == 0x1 (0x1) +__longlong 0x17 >= 0x1 == 0x1 (0x1) +__ulonglong 0x17 >= 0x1 == 0x1 (0x1) +float 0x17 >= 0x1 == 0x1 (0x1) +int 0x17 / 0x1 == 0x17 (0x17) +__uint 0x17 / 0x1 == 0x17 (0x17) +char 0x17 / 0x1 == 0x17 (0x17) +__uchar 0x17 / 0x1 == 0x17 (0x17) +__longlong 0x17 / 0x1 == 0x17 (0x17) +__ulonglong 0x17 / 0x1 == 0x17 (0x17) +float 0x17 / 0x1 == 0x17 (0x17) +int 0x17 % 0x1 == 0x0 (0x0) +__uint 0x17 % 0x1 == 0x0 (0x0) +char 0x17 % 0x1 == 0x0 (0x0) +__uchar 0x17 % 0x1 == 0x0 (0x0) +__longlong 0x17 % 0x1 == 0x0 (0x0) +__ulonglong 0x17 % 0x1 == 0x0 (0x0) +0x17 * 0x2 == 0x2e +0x17 / 0x2 == 0xb +0x17 % 0x2 == 0x1 +int 0x17 ^ 0x2 == 0x15 (0x15) +__uint 0x17 ^ 0x2 == 0x15 (0x15) +char 0x17 ^ 0x2 == 0x15 (0x15) +__uchar 0x17 ^ 0x2 == 0x15 (0x15) +__longlong 0x17 ^ 0x2 == 0x15 (0x15) +__ulonglong 0x17 ^ 0x2 == 0x15 (0x15) +int 0x17 && 0x2 == 0x1 (0x1) +__uint 0x17 && 0x2 == 0x1 (0x1) +char 0x17 && 0x2 == 0x1 (0x1) +__uchar 0x17 && 0x2 == 0x1 (0x1) +__longlong 0x17 && 0x2 == 0x1 (0x1) +__ulonglong 0x17 && 0x2 == 0x1 (0x1) +int 0x17 || 0x2 == 0x1 (0x1) +__uint 0x17 || 0x2 == 0x1 (0x1) +char 0x17 || 0x2 == 0x1 (0x1) +__uchar 0x17 || 0x2 == 0x1 (0x1) +__longlong 0x17 || 0x2 == 0x1 (0x1) +__ulonglong 0x17 || 0x2 == 0x1 (0x1) +int 0x17 & 0x2 == 0x2 (0x2) +__uint 0x17 & 0x2 == 0x2 (0x2) +char 0x17 & 0x2 == 0x2 (0x2) +__uchar 0x17 & 0x2 == 0x2 (0x2) +__longlong 0x17 & 0x2 == 0x2 (0x2) +__ulonglong 0x17 & 0x2 == 0x2 (0x2) +int 0x17 | 0x2 == 0x17 (0x17) +__uint 0x17 | 0x2 == 0x17 (0x17) +char 0x17 | 0x2 == 0x17 (0x17) +__uchar 0x17 | 0x2 == 0x17 (0x17) +__longlong 0x17 | 0x2 == 0x17 (0x17) +__ulonglong 0x17 | 0x2 == 0x17 (0x17) +int 0x17 << 0x3 == 0xb8 (0xb8) +__uint 0x17 << 0x3 == 0xb8 (0xb8) +char 0x17 << 0x3 == -0x48 (0xffb8) +__uchar 0x17 << 0x3 == 0xb8 (0xb8) +__longlong 0x17 << 0x3 == 0xb8 (0xb8) +__ulonglong 0x17 << 0x3 == 0xb8 (0xb8) +int 0x17 >> 0x3 == 0x2 (0x2) +__uint 0x17 >> 0x3 == 0x2 (0x2) +char 0x17 >> 0x3 == 0x2 (0x2) +__uchar 0x17 >> 0x3 == 0x2 (0x2) +__longlong 0x17 >> 0x3 == 0x2 (0x2) +__ulonglong 0x17 >> 0x3 == 0x2 (0x2) +int 0x17 + 0x2 == 0x19 (0x19) +__uint 0x17 + 0x2 == 0x19 (0x19) +char 0x17 + 0x2 == 0x19 (0x19) +__uchar 0x17 + 0x2 == 0x19 (0x19) +__longlong 0x17 + 0x2 == 0x19 (0x19) +__ulonglong 0x17 + 0x2 == 0x19 (0x19) +float 0x17 + 0x2 == 0x19 (0x19) +int 0x17 - 0x2 == 0x15 (0x15) +__uint 0x17 - 0x2 == 0x15 (0x15) +char 0x17 - 0x2 == 0x15 (0x15) +__uchar 0x17 - 0x2 == 0x15 (0x15) +__longlong 0x17 - 0x2 == 0x15 (0x15) +__ulonglong 0x17 - 0x2 == 0x15 (0x15) +float 0x17 - 0x2 == 0x15 (0x15) +int 0x17 * 0x2 == 0x2e (0x2e) +__uint 0x17 * 0x2 == 0x2e (0x2e) +char 0x17 * 0x2 == 0x2e (0x2e) +__uchar 0x17 * 0x2 == 0x2e (0x2e) +__longlong 0x17 * 0x2 == 0x2e (0x2e) +__ulonglong 0x17 * 0x2 == 0x2e (0x2e) +float 0x17 * 0x2 == 0x2e (0x2e) +int 0x17 < 0x2 == 0x0 (0x0) +__uint 0x17 < 0x2 == 0x0 (0x0) +char 0x17 < 0x2 == 0x0 (0x0) +__uchar 0x17 < 0x2 == 0x0 (0x0) +__longlong 0x17 < 0x2 == 0x0 (0x0) +__ulonglong 0x17 < 0x2 == 0x0 (0x0) +float 0x17 < 0x2 == 0x0 (0x0) +int 0x17 > 0x2 == 0x1 (0x1) +__uint 0x17 > 0x2 == 0x1 (0x1) +char 0x17 > 0x2 == 0x1 (0x1) +__uchar 0x17 > 0x2 == 0x1 (0x1) +__longlong 0x17 > 0x2 == 0x1 (0x1) +__ulonglong 0x17 > 0x2 == 0x1 (0x1) +float 0x17 > 0x2 == 0x1 (0x1) +int 0x17 <= 0x2 == 0x0 (0x0) +__uint 0x17 <= 0x2 == 0x0 (0x0) +char 0x17 <= 0x2 == 0x0 (0x0) +__uchar 0x17 <= 0x2 == 0x0 (0x0) +__longlong 0x17 <= 0x2 == 0x0 (0x0) +__ulonglong 0x17 <= 0x2 == 0x0 (0x0) +float 0x17 <= 0x2 == 0x0 (0x0) +int 0x17 == 0x2 == 0x0 (0x0) +__uint 0x17 == 0x2 == 0x0 (0x0) +char 0x17 == 0x2 == 0x0 (0x0) +__uchar 0x17 == 0x2 == 0x0 (0x0) +__longlong 0x17 == 0x2 == 0x0 (0x0) +__ulonglong 0x17 == 0x2 == 0x0 (0x0) +float 0x17 == 0x2 == 0x0 (0x0) +int 0x17 != 0x2 == 0x1 (0x1) +__uint 0x17 != 0x2 == 0x1 (0x1) +char 0x17 != 0x2 == 0x1 (0x1) +__uchar 0x17 != 0x2 == 0x1 (0x1) +__longlong 0x17 != 0x2 == 0x1 (0x1) +__ulonglong 0x17 != 0x2 == 0x1 (0x1) +float 0x17 != 0x2 == 0x1 (0x1) +int 0x17 >= 0x2 == 0x1 (0x1) +__uint 0x17 >= 0x2 == 0x1 (0x1) +char 0x17 >= 0x2 == 0x1 (0x1) +__uchar 0x17 >= 0x2 == 0x1 (0x1) +__longlong 0x17 >= 0x2 == 0x1 (0x1) +__ulonglong 0x17 >= 0x2 == 0x1 (0x1) +float 0x17 >= 0x2 == 0x1 (0x1) +int 0x17 / 0x2 == 0xb (0xb) +__uint 0x17 / 0x2 == 0xb (0xb) +char 0x17 / 0x2 == 0xb (0xb) +__uchar 0x17 / 0x2 == 0xb (0xb) +__longlong 0x17 / 0x2 == 0xb (0xb) +__ulonglong 0x17 / 0x2 == 0xb (0xb) +float 0x17 / 0x2 == 0xb (0xb) +int 0x17 % 0x2 == 0x1 (0x1) +__uint 0x17 % 0x2 == 0x1 (0x1) +char 0x17 % 0x2 == 0x1 (0x1) +__uchar 0x17 % 0x2 == 0x1 (0x1) +__longlong 0x17 % 0x2 == 0x1 (0x1) +__ulonglong 0x17 % 0x2 == 0x1 (0x1) +0x17 * 0xfffe == -0x2e +0x17 / 0xfffe == -0xb +0x17 % 0xfffe == 0x1 +int 0x17 ^ 0xfffe == -0x17 (0xffe9) +__uint 0x17 ^ 0xfffe == -0x17 (0xffe9) +char 0x17 ^ 0xfffe == -0x17 (0xffe9) +__uchar 0x17 ^ 0xfe == 0xe9 (0xe9) +__longlong 0x17 ^ 0xfffe == -0x17 (0xffe9) +__ulonglong 0x17 ^ 0xfffe == -0x17 (0xffe9) +int 0x17 && 0xfffe == 0x1 (0x1) +__uint 0x17 && 0xfffe == 0x1 (0x1) +char 0x17 && 0xfffe == 0x1 (0x1) +__uchar 0x17 && 0xfe == 0x1 (0x1) +__longlong 0x17 && 0xfffe == 0x1 (0x1) +__ulonglong 0x17 && 0xfffe == 0x1 (0x1) +int 0x17 || 0xfffe == 0x1 (0x1) +__uint 0x17 || 0xfffe == 0x1 (0x1) +char 0x17 || 0xfffe == 0x1 (0x1) +__uchar 0x17 || 0xfe == 0x1 (0x1) +__longlong 0x17 || 0xfffe == 0x1 (0x1) +__ulonglong 0x17 || 0xfffe == 0x1 (0x1) +int 0x17 & 0xfffe == 0x16 (0x16) +__uint 0x17 & 0xfffe == 0x16 (0x16) +char 0x17 & 0xfffe == 0x16 (0x16) +__uchar 0x17 & 0xfe == 0x16 (0x16) +__longlong 0x17 & 0xfffe == 0x16 (0x16) +__ulonglong 0x17 & 0xfffe == 0x16 (0x16) +int 0x17 | 0xfffe == -0x1 (0xffff) +__uint 0x17 | 0xfffe == -0x1 (0xffff) +char 0x17 | 0xfffe == -0x1 (0xffff) +__uchar 0x17 | 0xfe == 0xff (0xff) +__longlong 0x17 | 0xfffe == -0x1 (0xffff) +__ulonglong 0x17 | 0xfffe == -0x1 (0xffff) +int 0x17 << 0x4 == 0x170 (0x170) +__uint 0x17 << 0x4 == 0x170 (0x170) +char 0x17 << 0x4 == 0x70 (0x70) +__uchar 0x17 << 0x4 == 0x70 (0x70) +__longlong 0x17 << 0x4 == 0x170 (0x170) +__ulonglong 0x17 << 0x4 == 0x170 (0x170) +int 0x17 >> 0x4 == 0x1 (0x1) +__uint 0x17 >> 0x4 == 0x1 (0x1) +char 0x17 >> 0x4 == 0x1 (0x1) +__uchar 0x17 >> 0x4 == 0x1 (0x1) +__longlong 0x17 >> 0x4 == 0x1 (0x1) +__ulonglong 0x17 >> 0x4 == 0x1 (0x1) +int 0x17 + 0xfffe == 0x15 (0x15) +__uint 0x17 + 0xfffe == 0x15 (0x15) +char 0x17 + 0xfffe == 0x15 (0x15) +__uchar 0x17 + 0xfe == 0x15 (0x15) +__longlong 0x17 + 0xfffe == 0x15 (0x15) +__ulonglong 0x17 + 0xfffe == 0x15 (0x15) +float 0x17 + 0xfffe == 0x15 (0x15) +int 0x17 - 0xfffe == 0x19 (0x19) +__uint 0x17 - 0xfffe == 0x19 (0x19) +char 0x17 - 0xfffe == 0x19 (0x19) +__uchar 0x17 - 0xfe == 0x19 (0x19) +__longlong 0x17 - 0xfffe == 0x19 (0x19) +__ulonglong 0x17 - 0xfffe == 0x19 (0x19) +float 0x17 - 0xfffe == 0x19 (0x19) +int 0x17 * 0xfffe == -0x2e (0xffd2) +__uint 0x17 * 0xfffe == -0x2e (0xffd2) +char 0x17 * 0xfffe == -0x2e (0xffd2) +__uchar 0x17 * 0xfe == 0xd2 (0xd2) +__longlong 0x17 * 0xfffe == -0x2e (0xffd2) +__ulonglong 0x17 * 0xfffe == -0x2e (0xffd2) +float 0x17 * 0xfffe == -0x2e (0xffd2) +int 0x17 < 0xfffe == 0x0 (0x0) +__uint 0x17 < 0xfffe == 0x1 (0x1) +char 0x17 < 0xfffe == 0x0 (0x0) +__uchar 0x17 < 0xfe == 0x1 (0x1) +__longlong 0x17 < 0xfffe == 0x0 (0x0) +__ulonglong 0x17 < 0xfffe == 0x1 (0x1) +float 0x17 < 0xfffe == 0x0 (0x0) +int 0x17 > 0xfffe == 0x1 (0x1) +__uint 0x17 > 0xfffe == 0x0 (0x0) +char 0x17 > 0xfffe == 0x1 (0x1) +__uchar 0x17 > 0xfe == 0x0 (0x0) +__longlong 0x17 > 0xfffe == 0x1 (0x1) +__ulonglong 0x17 > 0xfffe == 0x0 (0x0) +float 0x17 > 0xfffe == 0x1 (0x1) +int 0x17 <= 0xfffe == 0x0 (0x0) +__uint 0x17 <= 0xfffe == 0x1 (0x1) +char 0x17 <= 0xfffe == 0x0 (0x0) +__uchar 0x17 <= 0xfe == 0x1 (0x1) +__longlong 0x17 <= 0xfffe == 0x0 (0x0) +__ulonglong 0x17 <= 0xfffe == 0x1 (0x1) +float 0x17 <= 0xfffe == 0x0 (0x0) +int 0x17 == 0xfffe == 0x0 (0x0) +__uint 0x17 == 0xfffe == 0x0 (0x0) +char 0x17 == 0xfffe == 0x0 (0x0) +__uchar 0x17 == 0xfe == 0x0 (0x0) +__longlong 0x17 == 0xfffe == 0x0 (0x0) +__ulonglong 0x17 == 0xfffe == 0x0 (0x0) +float 0x17 == 0xfffe == 0x0 (0x0) +int 0x17 != 0xfffe == 0x1 (0x1) +__uint 0x17 != 0xfffe == 0x1 (0x1) +char 0x17 != 0xfffe == 0x1 (0x1) +__uchar 0x17 != 0xfe == 0x1 (0x1) +__longlong 0x17 != 0xfffe == 0x1 (0x1) +__ulonglong 0x17 != 0xfffe == 0x1 (0x1) +float 0x17 != 0xfffe == 0x1 (0x1) +int 0x17 >= 0xfffe == 0x1 (0x1) +__uint 0x17 >= 0xfffe == 0x0 (0x0) +char 0x17 >= 0xfffe == 0x1 (0x1) +__uchar 0x17 >= 0xfe == 0x0 (0x0) +__longlong 0x17 >= 0xfffe == 0x1 (0x1) +__ulonglong 0x17 >= 0xfffe == 0x0 (0x0) +float 0x17 >= 0xfffe == 0x1 (0x1) +int 0x17 / 0xfffe == -0xb (0xfff5) +__uint 0x17 / 0xfffe == 0x0 (0x0) +char 0x17 / 0xfffe == -0xb (0xfff5) +__uchar 0x17 / 0xfe == 0x0 (0x0) +__longlong 0x17 / 0xfffe == -0xb (0xfff5) +__ulonglong 0x17 / 0xfffe == 0x0 (0x0) +float 0x17 / 0xfffe == -0xb (0xfff5) +int 0x17 % 0xfffe == 0x1 (0x1) +__uint 0x17 % 0xfffe == 0x17 (0x17) +char 0x17 % 0xfffe == 0x1 (0x1) +__uchar 0x17 % 0xfe == 0x17 (0x17) +__longlong 0x17 % 0xfffe == 0x1 (0x1) +__ulonglong 0x17 % 0xfffe == 0x17 (0x17) +0x17 * 0x4 == 0x5c +0x17 / 0x4 == 0x5 +0x17 % 0x4 == 0x3 +int 0x17 ^ 0x4 == 0x13 (0x13) +__uint 0x17 ^ 0x4 == 0x13 (0x13) +char 0x17 ^ 0x4 == 0x13 (0x13) +__uchar 0x17 ^ 0x4 == 0x13 (0x13) +__longlong 0x17 ^ 0x4 == 0x13 (0x13) +__ulonglong 0x17 ^ 0x4 == 0x13 (0x13) +int 0x17 && 0x4 == 0x1 (0x1) +__uint 0x17 && 0x4 == 0x1 (0x1) +char 0x17 && 0x4 == 0x1 (0x1) +__uchar 0x17 && 0x4 == 0x1 (0x1) +__longlong 0x17 && 0x4 == 0x1 (0x1) +__ulonglong 0x17 && 0x4 == 0x1 (0x1) +int 0x17 || 0x4 == 0x1 (0x1) +__uint 0x17 || 0x4 == 0x1 (0x1) +char 0x17 || 0x4 == 0x1 (0x1) +__uchar 0x17 || 0x4 == 0x1 (0x1) +__longlong 0x17 || 0x4 == 0x1 (0x1) +__ulonglong 0x17 || 0x4 == 0x1 (0x1) +int 0x17 & 0x4 == 0x4 (0x4) +__uint 0x17 & 0x4 == 0x4 (0x4) +char 0x17 & 0x4 == 0x4 (0x4) +__uchar 0x17 & 0x4 == 0x4 (0x4) +__longlong 0x17 & 0x4 == 0x4 (0x4) +__ulonglong 0x17 & 0x4 == 0x4 (0x4) +int 0x17 | 0x4 == 0x17 (0x17) +__uint 0x17 | 0x4 == 0x17 (0x17) +char 0x17 | 0x4 == 0x17 (0x17) +__uchar 0x17 | 0x4 == 0x17 (0x17) +__longlong 0x17 | 0x4 == 0x17 (0x17) +__ulonglong 0x17 | 0x4 == 0x17 (0x17) +int 0x17 << 0x5 == 0x2e0 (0x2e0) +__uint 0x17 << 0x5 == 0x2e0 (0x2e0) +char 0x17 << 0x5 == -0x20 (0xffe0) +__uchar 0x17 << 0x5 == 0xe0 (0xe0) +__longlong 0x17 << 0x5 == 0x2e0 (0x2e0) +__ulonglong 0x17 << 0x5 == 0x2e0 (0x2e0) +int 0x17 >> 0x5 == 0x0 (0x0) +__uint 0x17 >> 0x5 == 0x0 (0x0) +char 0x17 >> 0x5 == 0x0 (0x0) +__uchar 0x17 >> 0x5 == 0x0 (0x0) +__longlong 0x17 >> 0x5 == 0x0 (0x0) +__ulonglong 0x17 >> 0x5 == 0x0 (0x0) +int 0x17 + 0x4 == 0x1b (0x1b) +__uint 0x17 + 0x4 == 0x1b (0x1b) +char 0x17 + 0x4 == 0x1b (0x1b) +__uchar 0x17 + 0x4 == 0x1b (0x1b) +__longlong 0x17 + 0x4 == 0x1b (0x1b) +__ulonglong 0x17 + 0x4 == 0x1b (0x1b) +float 0x17 + 0x4 == 0x1b (0x1b) +int 0x17 - 0x4 == 0x13 (0x13) +__uint 0x17 - 0x4 == 0x13 (0x13) +char 0x17 - 0x4 == 0x13 (0x13) +__uchar 0x17 - 0x4 == 0x13 (0x13) +__longlong 0x17 - 0x4 == 0x13 (0x13) +__ulonglong 0x17 - 0x4 == 0x13 (0x13) +float 0x17 - 0x4 == 0x13 (0x13) +int 0x17 * 0x4 == 0x5c (0x5c) +__uint 0x17 * 0x4 == 0x5c (0x5c) +char 0x17 * 0x4 == 0x5c (0x5c) +__uchar 0x17 * 0x4 == 0x5c (0x5c) +__longlong 0x17 * 0x4 == 0x5c (0x5c) +__ulonglong 0x17 * 0x4 == 0x5c (0x5c) +float 0x17 * 0x4 == 0x5c (0x5c) +int 0x17 < 0x4 == 0x0 (0x0) +__uint 0x17 < 0x4 == 0x0 (0x0) +char 0x17 < 0x4 == 0x0 (0x0) +__uchar 0x17 < 0x4 == 0x0 (0x0) +__longlong 0x17 < 0x4 == 0x0 (0x0) +__ulonglong 0x17 < 0x4 == 0x0 (0x0) +float 0x17 < 0x4 == 0x0 (0x0) +int 0x17 > 0x4 == 0x1 (0x1) +__uint 0x17 > 0x4 == 0x1 (0x1) +char 0x17 > 0x4 == 0x1 (0x1) +__uchar 0x17 > 0x4 == 0x1 (0x1) +__longlong 0x17 > 0x4 == 0x1 (0x1) +__ulonglong 0x17 > 0x4 == 0x1 (0x1) +float 0x17 > 0x4 == 0x1 (0x1) +int 0x17 <= 0x4 == 0x0 (0x0) +__uint 0x17 <= 0x4 == 0x0 (0x0) +char 0x17 <= 0x4 == 0x0 (0x0) +__uchar 0x17 <= 0x4 == 0x0 (0x0) +__longlong 0x17 <= 0x4 == 0x0 (0x0) +__ulonglong 0x17 <= 0x4 == 0x0 (0x0) +float 0x17 <= 0x4 == 0x0 (0x0) +int 0x17 == 0x4 == 0x0 (0x0) +__uint 0x17 == 0x4 == 0x0 (0x0) +char 0x17 == 0x4 == 0x0 (0x0) +__uchar 0x17 == 0x4 == 0x0 (0x0) +__longlong 0x17 == 0x4 == 0x0 (0x0) +__ulonglong 0x17 == 0x4 == 0x0 (0x0) +float 0x17 == 0x4 == 0x0 (0x0) +int 0x17 != 0x4 == 0x1 (0x1) +__uint 0x17 != 0x4 == 0x1 (0x1) +char 0x17 != 0x4 == 0x1 (0x1) +__uchar 0x17 != 0x4 == 0x1 (0x1) +__longlong 0x17 != 0x4 == 0x1 (0x1) +__ulonglong 0x17 != 0x4 == 0x1 (0x1) +float 0x17 != 0x4 == 0x1 (0x1) +int 0x17 >= 0x4 == 0x1 (0x1) +__uint 0x17 >= 0x4 == 0x1 (0x1) +char 0x17 >= 0x4 == 0x1 (0x1) +__uchar 0x17 >= 0x4 == 0x1 (0x1) +__longlong 0x17 >= 0x4 == 0x1 (0x1) +__ulonglong 0x17 >= 0x4 == 0x1 (0x1) +float 0x17 >= 0x4 == 0x1 (0x1) +int 0x17 / 0x4 == 0x5 (0x5) +__uint 0x17 / 0x4 == 0x5 (0x5) +char 0x17 / 0x4 == 0x5 (0x5) +__uchar 0x17 / 0x4 == 0x5 (0x5) +__longlong 0x17 / 0x4 == 0x5 (0x5) +__ulonglong 0x17 / 0x4 == 0x5 (0x5) +float 0x17 / 0x4 == 0x5 (0x5) +int 0x17 % 0x4 == 0x3 (0x3) +__uint 0x17 % 0x4 == 0x3 (0x3) +char 0x17 % 0x4 == 0x3 (0x3) +__uchar 0x17 % 0x4 == 0x3 (0x3) +__longlong 0x17 % 0x4 == 0x3 (0x3) +__ulonglong 0x17 % 0x4 == 0x3 (0x3) +0x17 * 0xfffc == -0x5c +0x17 / 0xfffc == -0x5 +0x17 % 0xfffc == 0x3 +int 0x17 ^ 0xfffc == -0x15 (0xffeb) +__uint 0x17 ^ 0xfffc == -0x15 (0xffeb) +char 0x17 ^ 0xfffc == -0x15 (0xffeb) +__uchar 0x17 ^ 0xfc == 0xeb (0xeb) +__longlong 0x17 ^ 0xfffc == -0x15 (0xffeb) +__ulonglong 0x17 ^ 0xfffc == -0x15 (0xffeb) +int 0x17 && 0xfffc == 0x1 (0x1) +__uint 0x17 && 0xfffc == 0x1 (0x1) +char 0x17 && 0xfffc == 0x1 (0x1) +__uchar 0x17 && 0xfc == 0x1 (0x1) +__longlong 0x17 && 0xfffc == 0x1 (0x1) +__ulonglong 0x17 && 0xfffc == 0x1 (0x1) +int 0x17 || 0xfffc == 0x1 (0x1) +__uint 0x17 || 0xfffc == 0x1 (0x1) +char 0x17 || 0xfffc == 0x1 (0x1) +__uchar 0x17 || 0xfc == 0x1 (0x1) +__longlong 0x17 || 0xfffc == 0x1 (0x1) +__ulonglong 0x17 || 0xfffc == 0x1 (0x1) +int 0x17 & 0xfffc == 0x14 (0x14) +__uint 0x17 & 0xfffc == 0x14 (0x14) +char 0x17 & 0xfffc == 0x14 (0x14) +__uchar 0x17 & 0xfc == 0x14 (0x14) +__longlong 0x17 & 0xfffc == 0x14 (0x14) +__ulonglong 0x17 & 0xfffc == 0x14 (0x14) +int 0x17 | 0xfffc == -0x1 (0xffff) +__uint 0x17 | 0xfffc == -0x1 (0xffff) +char 0x17 | 0xfffc == -0x1 (0xffff) +__uchar 0x17 | 0xfc == 0xff (0xff) +__longlong 0x17 | 0xfffc == -0x1 (0xffff) +__ulonglong 0x17 | 0xfffc == -0x1 (0xffff) +int 0x17 << 0x6 == 0x5c0 (0x5c0) +__uint 0x17 << 0x6 == 0x5c0 (0x5c0) +char 0x17 << 0x6 == -0x40 (0xffc0) +__uchar 0x17 << 0x6 == 0xc0 (0xc0) +__longlong 0x17 << 0x6 == 0x5c0 (0x5c0) +__ulonglong 0x17 << 0x6 == 0x5c0 (0x5c0) +int 0x17 >> 0x6 == 0x0 (0x0) +__uint 0x17 >> 0x6 == 0x0 (0x0) +char 0x17 >> 0x6 == 0x0 (0x0) +__uchar 0x17 >> 0x6 == 0x0 (0x0) +__longlong 0x17 >> 0x6 == 0x0 (0x0) +__ulonglong 0x17 >> 0x6 == 0x0 (0x0) +int 0x17 + 0xfffc == 0x13 (0x13) +__uint 0x17 + 0xfffc == 0x13 (0x13) +char 0x17 + 0xfffc == 0x13 (0x13) +__uchar 0x17 + 0xfc == 0x13 (0x13) +__longlong 0x17 + 0xfffc == 0x13 (0x13) +__ulonglong 0x17 + 0xfffc == 0x13 (0x13) +float 0x17 + 0xfffc == 0x13 (0x13) +int 0x17 - 0xfffc == 0x1b (0x1b) +__uint 0x17 - 0xfffc == 0x1b (0x1b) +char 0x17 - 0xfffc == 0x1b (0x1b) +__uchar 0x17 - 0xfc == 0x1b (0x1b) +__longlong 0x17 - 0xfffc == 0x1b (0x1b) +__ulonglong 0x17 - 0xfffc == 0x1b (0x1b) +float 0x17 - 0xfffc == 0x1b (0x1b) +int 0x17 * 0xfffc == -0x5c (0xffa4) +__uint 0x17 * 0xfffc == -0x5c (0xffa4) +char 0x17 * 0xfffc == -0x5c (0xffa4) +__uchar 0x17 * 0xfc == 0xa4 (0xa4) +__longlong 0x17 * 0xfffc == -0x5c (0xffa4) +__ulonglong 0x17 * 0xfffc == -0x5c (0xffa4) +float 0x17 * 0xfffc == -0x5c (0xffa4) +int 0x17 < 0xfffc == 0x0 (0x0) +__uint 0x17 < 0xfffc == 0x1 (0x1) +char 0x17 < 0xfffc == 0x0 (0x0) +__uchar 0x17 < 0xfc == 0x1 (0x1) +__longlong 0x17 < 0xfffc == 0x0 (0x0) +__ulonglong 0x17 < 0xfffc == 0x1 (0x1) +float 0x17 < 0xfffc == 0x0 (0x0) +int 0x17 > 0xfffc == 0x1 (0x1) +__uint 0x17 > 0xfffc == 0x0 (0x0) +char 0x17 > 0xfffc == 0x1 (0x1) +__uchar 0x17 > 0xfc == 0x0 (0x0) +__longlong 0x17 > 0xfffc == 0x1 (0x1) +__ulonglong 0x17 > 0xfffc == 0x0 (0x0) +float 0x17 > 0xfffc == 0x1 (0x1) +int 0x17 <= 0xfffc == 0x0 (0x0) +__uint 0x17 <= 0xfffc == 0x1 (0x1) +char 0x17 <= 0xfffc == 0x0 (0x0) +__uchar 0x17 <= 0xfc == 0x1 (0x1) +__longlong 0x17 <= 0xfffc == 0x0 (0x0) +__ulonglong 0x17 <= 0xfffc == 0x1 (0x1) +float 0x17 <= 0xfffc == 0x0 (0x0) +int 0x17 == 0xfffc == 0x0 (0x0) +__uint 0x17 == 0xfffc == 0x0 (0x0) +char 0x17 == 0xfffc == 0x0 (0x0) +__uchar 0x17 == 0xfc == 0x0 (0x0) +__longlong 0x17 == 0xfffc == 0x0 (0x0) +__ulonglong 0x17 == 0xfffc == 0x0 (0x0) +float 0x17 == 0xfffc == 0x0 (0x0) +int 0x17 != 0xfffc == 0x1 (0x1) +__uint 0x17 != 0xfffc == 0x1 (0x1) +char 0x17 != 0xfffc == 0x1 (0x1) +__uchar 0x17 != 0xfc == 0x1 (0x1) +__longlong 0x17 != 0xfffc == 0x1 (0x1) +__ulonglong 0x17 != 0xfffc == 0x1 (0x1) +float 0x17 != 0xfffc == 0x1 (0x1) +int 0x17 >= 0xfffc == 0x1 (0x1) +__uint 0x17 >= 0xfffc == 0x0 (0x0) +char 0x17 >= 0xfffc == 0x1 (0x1) +__uchar 0x17 >= 0xfc == 0x0 (0x0) +__longlong 0x17 >= 0xfffc == 0x1 (0x1) +__ulonglong 0x17 >= 0xfffc == 0x0 (0x0) +float 0x17 >= 0xfffc == 0x1 (0x1) +int 0x17 / 0xfffc == -0x5 (0xfffb) +__uint 0x17 / 0xfffc == 0x0 (0x0) +char 0x17 / 0xfffc == -0x5 (0xfffb) +__uchar 0x17 / 0xfc == 0x0 (0x0) +__longlong 0x17 / 0xfffc == -0x5 (0xfffb) +__ulonglong 0x17 / 0xfffc == 0x0 (0x0) +float 0x17 / 0xfffc == -0x5 (0xfffb) +int 0x17 % 0xfffc == 0x3 (0x3) +__uint 0x17 % 0xfffc == 0x17 (0x17) +char 0x17 % 0xfffc == 0x3 (0x3) +__uchar 0x17 % 0xfc == 0x17 (0x17) +__longlong 0x17 % 0xfffc == 0x3 (0x3) +__ulonglong 0x17 % 0xfffc == 0x17 (0x17) +0x17 * 0xa == 0xe6 +0x17 / 0xa == 0x2 +0x17 % 0xa == 0x3 +int 0x17 ^ 0xa == 0x1d (0x1d) +__uint 0x17 ^ 0xa == 0x1d (0x1d) +char 0x17 ^ 0xa == 0x1d (0x1d) +__uchar 0x17 ^ 0xa == 0x1d (0x1d) +__longlong 0x17 ^ 0xa == 0x1d (0x1d) +__ulonglong 0x17 ^ 0xa == 0x1d (0x1d) +int 0x17 && 0xa == 0x1 (0x1) +__uint 0x17 && 0xa == 0x1 (0x1) +char 0x17 && 0xa == 0x1 (0x1) +__uchar 0x17 && 0xa == 0x1 (0x1) +__longlong 0x17 && 0xa == 0x1 (0x1) +__ulonglong 0x17 && 0xa == 0x1 (0x1) +int 0x17 || 0xa == 0x1 (0x1) +__uint 0x17 || 0xa == 0x1 (0x1) +char 0x17 || 0xa == 0x1 (0x1) +__uchar 0x17 || 0xa == 0x1 (0x1) +__longlong 0x17 || 0xa == 0x1 (0x1) +__ulonglong 0x17 || 0xa == 0x1 (0x1) +int 0x17 & 0xa == 0x2 (0x2) +__uint 0x17 & 0xa == 0x2 (0x2) +char 0x17 & 0xa == 0x2 (0x2) +__uchar 0x17 & 0xa == 0x2 (0x2) +__longlong 0x17 & 0xa == 0x2 (0x2) +__ulonglong 0x17 & 0xa == 0x2 (0x2) +int 0x17 | 0xa == 0x1f (0x1f) +__uint 0x17 | 0xa == 0x1f (0x1f) +char 0x17 | 0xa == 0x1f (0x1f) +__uchar 0x17 | 0xa == 0x1f (0x1f) +__longlong 0x17 | 0xa == 0x1f (0x1f) +__ulonglong 0x17 | 0xa == 0x1f (0x1f) +int 0x17 << 0x7 == 0xb80 (0xb80) +__uint 0x17 << 0x7 == 0xb80 (0xb80) +char 0x17 << 0x7 == -0x80 (0xff80) +__uchar 0x17 << 0x7 == 0x80 (0x80) +__longlong 0x17 << 0x7 == 0xb80 (0xb80) +__ulonglong 0x17 << 0x7 == 0xb80 (0xb80) +int 0x17 >> 0x7 == 0x0 (0x0) +__uint 0x17 >> 0x7 == 0x0 (0x0) +char 0x17 >> 0x7 == 0x0 (0x0) +__uchar 0x17 >> 0x7 == 0x0 (0x0) +__longlong 0x17 >> 0x7 == 0x0 (0x0) +__ulonglong 0x17 >> 0x7 == 0x0 (0x0) +int 0x17 + 0xa == 0x21 (0x21) +__uint 0x17 + 0xa == 0x21 (0x21) +char 0x17 + 0xa == 0x21 (0x21) +__uchar 0x17 + 0xa == 0x21 (0x21) +__longlong 0x17 + 0xa == 0x21 (0x21) +__ulonglong 0x17 + 0xa == 0x21 (0x21) +float 0x17 + 0xa == 0x21 (0x21) +int 0x17 - 0xa == 0xd (0xd) +__uint 0x17 - 0xa == 0xd (0xd) +char 0x17 - 0xa == 0xd (0xd) +__uchar 0x17 - 0xa == 0xd (0xd) +__longlong 0x17 - 0xa == 0xd (0xd) +__ulonglong 0x17 - 0xa == 0xd (0xd) +float 0x17 - 0xa == 0xd (0xd) +int 0x17 * 0xa == 0xe6 (0xe6) +__uint 0x17 * 0xa == 0xe6 (0xe6) +char 0x17 * 0xa == -0x1a (0xffe6) +__uchar 0x17 * 0xa == 0xe6 (0xe6) +__longlong 0x17 * 0xa == 0xe6 (0xe6) +__ulonglong 0x17 * 0xa == 0xe6 (0xe6) +float 0x17 * 0xa == 0xe6 (0xe6) +int 0x17 < 0xa == 0x0 (0x0) +__uint 0x17 < 0xa == 0x0 (0x0) +char 0x17 < 0xa == 0x0 (0x0) +__uchar 0x17 < 0xa == 0x0 (0x0) +__longlong 0x17 < 0xa == 0x0 (0x0) +__ulonglong 0x17 < 0xa == 0x0 (0x0) +float 0x17 < 0xa == 0x0 (0x0) +int 0x17 > 0xa == 0x1 (0x1) +__uint 0x17 > 0xa == 0x1 (0x1) +char 0x17 > 0xa == 0x1 (0x1) +__uchar 0x17 > 0xa == 0x1 (0x1) +__longlong 0x17 > 0xa == 0x1 (0x1) +__ulonglong 0x17 > 0xa == 0x1 (0x1) +float 0x17 > 0xa == 0x1 (0x1) +int 0x17 <= 0xa == 0x0 (0x0) +__uint 0x17 <= 0xa == 0x0 (0x0) +char 0x17 <= 0xa == 0x0 (0x0) +__uchar 0x17 <= 0xa == 0x0 (0x0) +__longlong 0x17 <= 0xa == 0x0 (0x0) +__ulonglong 0x17 <= 0xa == 0x0 (0x0) +float 0x17 <= 0xa == 0x0 (0x0) +int 0x17 == 0xa == 0x0 (0x0) +__uint 0x17 == 0xa == 0x0 (0x0) +char 0x17 == 0xa == 0x0 (0x0) +__uchar 0x17 == 0xa == 0x0 (0x0) +__longlong 0x17 == 0xa == 0x0 (0x0) +__ulonglong 0x17 == 0xa == 0x0 (0x0) +float 0x17 == 0xa == 0x0 (0x0) +int 0x17 != 0xa == 0x1 (0x1) +__uint 0x17 != 0xa == 0x1 (0x1) +char 0x17 != 0xa == 0x1 (0x1) +__uchar 0x17 != 0xa == 0x1 (0x1) +__longlong 0x17 != 0xa == 0x1 (0x1) +__ulonglong 0x17 != 0xa == 0x1 (0x1) +float 0x17 != 0xa == 0x1 (0x1) +int 0x17 >= 0xa == 0x1 (0x1) +__uint 0x17 >= 0xa == 0x1 (0x1) +char 0x17 >= 0xa == 0x1 (0x1) +__uchar 0x17 >= 0xa == 0x1 (0x1) +__longlong 0x17 >= 0xa == 0x1 (0x1) +__ulonglong 0x17 >= 0xa == 0x1 (0x1) +float 0x17 >= 0xa == 0x1 (0x1) +int 0x17 / 0xa == 0x2 (0x2) +__uint 0x17 / 0xa == 0x2 (0x2) +char 0x17 / 0xa == 0x2 (0x2) +__uchar 0x17 / 0xa == 0x2 (0x2) +__longlong 0x17 / 0xa == 0x2 (0x2) +__ulonglong 0x17 / 0xa == 0x2 (0x2) +float 0x17 / 0xa == 0x2 (0x2) +int 0x17 % 0xa == 0x3 (0x3) +__uint 0x17 % 0xa == 0x3 (0x3) +char 0x17 % 0xa == 0x3 (0x3) +__uchar 0x17 % 0xa == 0x3 (0x3) +__longlong 0x17 % 0xa == 0x3 (0x3) +__ulonglong 0x17 % 0xa == 0x3 (0x3) +0x17 * 0xfff6 == -0xe6 +0x17 / 0xfff6 == -0x2 +0x17 % 0xfff6 == 0x3 +int 0x17 ^ 0xfff6 == -0x1f (0xffe1) +__uint 0x17 ^ 0xfff6 == -0x1f (0xffe1) +char 0x17 ^ 0xfff6 == -0x1f (0xffe1) +__uchar 0x17 ^ 0xf6 == 0xe1 (0xe1) +__longlong 0x17 ^ 0xfff6 == -0x1f (0xffe1) +__ulonglong 0x17 ^ 0xfff6 == -0x1f (0xffe1) +int 0x17 && 0xfff6 == 0x1 (0x1) +__uint 0x17 && 0xfff6 == 0x1 (0x1) +char 0x17 && 0xfff6 == 0x1 (0x1) +__uchar 0x17 && 0xf6 == 0x1 (0x1) +__longlong 0x17 && 0xfff6 == 0x1 (0x1) +__ulonglong 0x17 && 0xfff6 == 0x1 (0x1) +int 0x17 || 0xfff6 == 0x1 (0x1) +__uint 0x17 || 0xfff6 == 0x1 (0x1) +char 0x17 || 0xfff6 == 0x1 (0x1) +__uchar 0x17 || 0xf6 == 0x1 (0x1) +__longlong 0x17 || 0xfff6 == 0x1 (0x1) +__ulonglong 0x17 || 0xfff6 == 0x1 (0x1) +int 0x17 & 0xfff6 == 0x16 (0x16) +__uint 0x17 & 0xfff6 == 0x16 (0x16) +char 0x17 & 0xfff6 == 0x16 (0x16) +__uchar 0x17 & 0xf6 == 0x16 (0x16) +__longlong 0x17 & 0xfff6 == 0x16 (0x16) +__ulonglong 0x17 & 0xfff6 == 0x16 (0x16) +int 0x17 | 0xfff6 == -0x9 (0xfff7) +__uint 0x17 | 0xfff6 == -0x9 (0xfff7) +char 0x17 | 0xfff6 == -0x9 (0xfff7) +__uchar 0x17 | 0xf6 == 0xf7 (0xf7) +__longlong 0x17 | 0xfff6 == -0x9 (0xfff7) +__ulonglong 0x17 | 0xfff6 == -0x9 (0xfff7) +int 0x17 << 0x8 == 0x1700 (0x1700) +__uint 0x17 << 0x8 == 0x1700 (0x1700) +char 0x17 << 0x8 == 0x0 (0x0) +__uchar 0x17 << 0x8 == 0x0 (0x0) +__longlong 0x17 << 0x8 == 0x1700 (0x1700) +__ulonglong 0x17 << 0x8 == 0x1700 (0x1700) +int 0x17 >> 0x8 == 0x0 (0x0) +__uint 0x17 >> 0x8 == 0x0 (0x0) +char 0x17 >> 0x8 == 0x0 (0x0) +__uchar 0x17 >> 0x8 == 0x0 (0x0) +__longlong 0x17 >> 0x8 == 0x0 (0x0) +__ulonglong 0x17 >> 0x8 == 0x0 (0x0) +int 0x17 + 0xfff6 == 0xd (0xd) +__uint 0x17 + 0xfff6 == 0xd (0xd) +char 0x17 + 0xfff6 == 0xd (0xd) +__uchar 0x17 + 0xf6 == 0xd (0xd) +__longlong 0x17 + 0xfff6 == 0xd (0xd) +__ulonglong 0x17 + 0xfff6 == 0xd (0xd) +float 0x17 + 0xfff6 == 0xd (0xd) +int 0x17 - 0xfff6 == 0x21 (0x21) +__uint 0x17 - 0xfff6 == 0x21 (0x21) +char 0x17 - 0xfff6 == 0x21 (0x21) +__uchar 0x17 - 0xf6 == 0x21 (0x21) +__longlong 0x17 - 0xfff6 == 0x21 (0x21) +__ulonglong 0x17 - 0xfff6 == 0x21 (0x21) +float 0x17 - 0xfff6 == 0x21 (0x21) +int 0x17 * 0xfff6 == -0xe6 (0xff1a) +__uint 0x17 * 0xfff6 == -0xe6 (0xff1a) +char 0x17 * 0xfff6 == 0x1a (0x1a) +__uchar 0x17 * 0xf6 == 0x1a (0x1a) +__longlong 0x17 * 0xfff6 == -0xe6 (0xff1a) +__ulonglong 0x17 * 0xfff6 == -0xe6 (0xff1a) +float 0x17 * 0xfff6 == -0xe6 (0xff1a) +int 0x17 < 0xfff6 == 0x0 (0x0) +__uint 0x17 < 0xfff6 == 0x1 (0x1) +char 0x17 < 0xfff6 == 0x0 (0x0) +__uchar 0x17 < 0xf6 == 0x1 (0x1) +__longlong 0x17 < 0xfff6 == 0x0 (0x0) +__ulonglong 0x17 < 0xfff6 == 0x1 (0x1) +float 0x17 < 0xfff6 == 0x0 (0x0) +int 0x17 > 0xfff6 == 0x1 (0x1) +__uint 0x17 > 0xfff6 == 0x0 (0x0) +char 0x17 > 0xfff6 == 0x1 (0x1) +__uchar 0x17 > 0xf6 == 0x0 (0x0) +__longlong 0x17 > 0xfff6 == 0x1 (0x1) +__ulonglong 0x17 > 0xfff6 == 0x0 (0x0) +float 0x17 > 0xfff6 == 0x1 (0x1) +int 0x17 <= 0xfff6 == 0x0 (0x0) +__uint 0x17 <= 0xfff6 == 0x1 (0x1) +char 0x17 <= 0xfff6 == 0x0 (0x0) +__uchar 0x17 <= 0xf6 == 0x1 (0x1) +__longlong 0x17 <= 0xfff6 == 0x0 (0x0) +__ulonglong 0x17 <= 0xfff6 == 0x1 (0x1) +float 0x17 <= 0xfff6 == 0x0 (0x0) +int 0x17 == 0xfff6 == 0x0 (0x0) +__uint 0x17 == 0xfff6 == 0x0 (0x0) +char 0x17 == 0xfff6 == 0x0 (0x0) +__uchar 0x17 == 0xf6 == 0x0 (0x0) +__longlong 0x17 == 0xfff6 == 0x0 (0x0) +__ulonglong 0x17 == 0xfff6 == 0x0 (0x0) +float 0x17 == 0xfff6 == 0x0 (0x0) +int 0x17 != 0xfff6 == 0x1 (0x1) +__uint 0x17 != 0xfff6 == 0x1 (0x1) +char 0x17 != 0xfff6 == 0x1 (0x1) +__uchar 0x17 != 0xf6 == 0x1 (0x1) +__longlong 0x17 != 0xfff6 == 0x1 (0x1) +__ulonglong 0x17 != 0xfff6 == 0x1 (0x1) +float 0x17 != 0xfff6 == 0x1 (0x1) +int 0x17 >= 0xfff6 == 0x1 (0x1) +__uint 0x17 >= 0xfff6 == 0x0 (0x0) +char 0x17 >= 0xfff6 == 0x1 (0x1) +__uchar 0x17 >= 0xf6 == 0x0 (0x0) +__longlong 0x17 >= 0xfff6 == 0x1 (0x1) +__ulonglong 0x17 >= 0xfff6 == 0x0 (0x0) +float 0x17 >= 0xfff6 == 0x1 (0x1) +int 0x17 / 0xfff6 == -0x2 (0xfffe) +__uint 0x17 / 0xfff6 == 0x0 (0x0) +char 0x17 / 0xfff6 == -0x2 (0xfffe) +__uchar 0x17 / 0xf6 == 0x0 (0x0) +__longlong 0x17 / 0xfff6 == -0x2 (0xfffe) +__ulonglong 0x17 / 0xfff6 == 0x0 (0x0) +float 0x17 / 0xfff6 == -0x2 (0xfffe) +int 0x17 % 0xfff6 == 0x3 (0x3) +__uint 0x17 % 0xfff6 == 0x17 (0x17) +char 0x17 % 0xfff6 == 0x3 (0x3) +__uchar 0x17 % 0xf6 == 0x17 (0x17) +__longlong 0x17 % 0xfff6 == 0x3 (0x3) +__ulonglong 0x17 % 0xfff6 == 0x17 (0x17) +0x17 * 0x5 == 0x73 +0x17 / 0x5 == 0x4 +0x17 % 0x5 == 0x3 +int 0x17 ^ 0x5 == 0x12 (0x12) +__uint 0x17 ^ 0x5 == 0x12 (0x12) +char 0x17 ^ 0x5 == 0x12 (0x12) +__uchar 0x17 ^ 0x5 == 0x12 (0x12) +__longlong 0x17 ^ 0x5 == 0x12 (0x12) +__ulonglong 0x17 ^ 0x5 == 0x12 (0x12) +int 0x17 && 0x5 == 0x1 (0x1) +__uint 0x17 && 0x5 == 0x1 (0x1) +char 0x17 && 0x5 == 0x1 (0x1) +__uchar 0x17 && 0x5 == 0x1 (0x1) +__longlong 0x17 && 0x5 == 0x1 (0x1) +__ulonglong 0x17 && 0x5 == 0x1 (0x1) +int 0x17 || 0x5 == 0x1 (0x1) +__uint 0x17 || 0x5 == 0x1 (0x1) +char 0x17 || 0x5 == 0x1 (0x1) +__uchar 0x17 || 0x5 == 0x1 (0x1) +__longlong 0x17 || 0x5 == 0x1 (0x1) +__ulonglong 0x17 || 0x5 == 0x1 (0x1) +int 0x17 & 0x5 == 0x5 (0x5) +__uint 0x17 & 0x5 == 0x5 (0x5) +char 0x17 & 0x5 == 0x5 (0x5) +__uchar 0x17 & 0x5 == 0x5 (0x5) +__longlong 0x17 & 0x5 == 0x5 (0x5) +__ulonglong 0x17 & 0x5 == 0x5 (0x5) +int 0x17 | 0x5 == 0x17 (0x17) +__uint 0x17 | 0x5 == 0x17 (0x17) +char 0x17 | 0x5 == 0x17 (0x17) +__uchar 0x17 | 0x5 == 0x17 (0x17) +__longlong 0x17 | 0x5 == 0x17 (0x17) +__ulonglong 0x17 | 0x5 == 0x17 (0x17) +int 0x17 << 0x9 == 0x2e00 (0x2e00) +__uint 0x17 << 0x9 == 0x2e00 (0x2e00) +char 0x17 << 0x9 == 0x0 (0x0) +__uchar 0x17 << 0x9 == 0x0 (0x0) +__longlong 0x17 << 0x9 == 0x2e00 (0x2e00) +__ulonglong 0x17 << 0x9 == 0x2e00 (0x2e00) +int 0x17 >> 0x9 == 0x0 (0x0) +__uint 0x17 >> 0x9 == 0x0 (0x0) +char 0x17 >> 0x9 == 0x0 (0x0) +__uchar 0x17 >> 0x9 == 0x0 (0x0) +__longlong 0x17 >> 0x9 == 0x0 (0x0) +__ulonglong 0x17 >> 0x9 == 0x0 (0x0) +int 0x17 + 0x5 == 0x1c (0x1c) +__uint 0x17 + 0x5 == 0x1c (0x1c) +char 0x17 + 0x5 == 0x1c (0x1c) +__uchar 0x17 + 0x5 == 0x1c (0x1c) +__longlong 0x17 + 0x5 == 0x1c (0x1c) +__ulonglong 0x17 + 0x5 == 0x1c (0x1c) +float 0x17 + 0x5 == 0x1c (0x1c) +int 0x17 - 0x5 == 0x12 (0x12) +__uint 0x17 - 0x5 == 0x12 (0x12) +char 0x17 - 0x5 == 0x12 (0x12) +__uchar 0x17 - 0x5 == 0x12 (0x12) +__longlong 0x17 - 0x5 == 0x12 (0x12) +__ulonglong 0x17 - 0x5 == 0x12 (0x12) +float 0x17 - 0x5 == 0x12 (0x12) +int 0x17 * 0x5 == 0x73 (0x73) +__uint 0x17 * 0x5 == 0x73 (0x73) +char 0x17 * 0x5 == 0x73 (0x73) +__uchar 0x17 * 0x5 == 0x73 (0x73) +__longlong 0x17 * 0x5 == 0x73 (0x73) +__ulonglong 0x17 * 0x5 == 0x73 (0x73) +float 0x17 * 0x5 == 0x73 (0x73) +int 0x17 < 0x5 == 0x0 (0x0) +__uint 0x17 < 0x5 == 0x0 (0x0) +char 0x17 < 0x5 == 0x0 (0x0) +__uchar 0x17 < 0x5 == 0x0 (0x0) +__longlong 0x17 < 0x5 == 0x0 (0x0) +__ulonglong 0x17 < 0x5 == 0x0 (0x0) +float 0x17 < 0x5 == 0x0 (0x0) +int 0x17 > 0x5 == 0x1 (0x1) +__uint 0x17 > 0x5 == 0x1 (0x1) +char 0x17 > 0x5 == 0x1 (0x1) +__uchar 0x17 > 0x5 == 0x1 (0x1) +__longlong 0x17 > 0x5 == 0x1 (0x1) +__ulonglong 0x17 > 0x5 == 0x1 (0x1) +float 0x17 > 0x5 == 0x1 (0x1) +int 0x17 <= 0x5 == 0x0 (0x0) +__uint 0x17 <= 0x5 == 0x0 (0x0) +char 0x17 <= 0x5 == 0x0 (0x0) +__uchar 0x17 <= 0x5 == 0x0 (0x0) +__longlong 0x17 <= 0x5 == 0x0 (0x0) +__ulonglong 0x17 <= 0x5 == 0x0 (0x0) +float 0x17 <= 0x5 == 0x0 (0x0) +int 0x17 == 0x5 == 0x0 (0x0) +__uint 0x17 == 0x5 == 0x0 (0x0) +char 0x17 == 0x5 == 0x0 (0x0) +__uchar 0x17 == 0x5 == 0x0 (0x0) +__longlong 0x17 == 0x5 == 0x0 (0x0) +__ulonglong 0x17 == 0x5 == 0x0 (0x0) +float 0x17 == 0x5 == 0x0 (0x0) +int 0x17 != 0x5 == 0x1 (0x1) +__uint 0x17 != 0x5 == 0x1 (0x1) +char 0x17 != 0x5 == 0x1 (0x1) +__uchar 0x17 != 0x5 == 0x1 (0x1) +__longlong 0x17 != 0x5 == 0x1 (0x1) +__ulonglong 0x17 != 0x5 == 0x1 (0x1) +float 0x17 != 0x5 == 0x1 (0x1) +int 0x17 >= 0x5 == 0x1 (0x1) +__uint 0x17 >= 0x5 == 0x1 (0x1) +char 0x17 >= 0x5 == 0x1 (0x1) +__uchar 0x17 >= 0x5 == 0x1 (0x1) +__longlong 0x17 >= 0x5 == 0x1 (0x1) +__ulonglong 0x17 >= 0x5 == 0x1 (0x1) +float 0x17 >= 0x5 == 0x1 (0x1) +int 0x17 / 0x5 == 0x4 (0x4) +__uint 0x17 / 0x5 == 0x4 (0x4) +char 0x17 / 0x5 == 0x4 (0x4) +__uchar 0x17 / 0x5 == 0x4 (0x4) +__longlong 0x17 / 0x5 == 0x4 (0x4) +__ulonglong 0x17 / 0x5 == 0x4 (0x4) +float 0x17 / 0x5 == 0x4 (0x4) +int 0x17 % 0x5 == 0x3 (0x3) +__uint 0x17 % 0x5 == 0x3 (0x3) +char 0x17 % 0x5 == 0x3 (0x3) +__uchar 0x17 % 0x5 == 0x3 (0x3) +__longlong 0x17 % 0x5 == 0x3 (0x3) +__ulonglong 0x17 % 0x5 == 0x3 (0x3) +0x17 * 0x7 == 0xa1 +0x17 / 0x7 == 0x3 +0x17 % 0x7 == 0x2 +int 0x17 ^ 0x7 == 0x10 (0x10) +__uint 0x17 ^ 0x7 == 0x10 (0x10) +char 0x17 ^ 0x7 == 0x10 (0x10) +__uchar 0x17 ^ 0x7 == 0x10 (0x10) +__longlong 0x17 ^ 0x7 == 0x10 (0x10) +__ulonglong 0x17 ^ 0x7 == 0x10 (0x10) +int 0x17 && 0x7 == 0x1 (0x1) +__uint 0x17 && 0x7 == 0x1 (0x1) +char 0x17 && 0x7 == 0x1 (0x1) +__uchar 0x17 && 0x7 == 0x1 (0x1) +__longlong 0x17 && 0x7 == 0x1 (0x1) +__ulonglong 0x17 && 0x7 == 0x1 (0x1) +int 0x17 || 0x7 == 0x1 (0x1) +__uint 0x17 || 0x7 == 0x1 (0x1) +char 0x17 || 0x7 == 0x1 (0x1) +__uchar 0x17 || 0x7 == 0x1 (0x1) +__longlong 0x17 || 0x7 == 0x1 (0x1) +__ulonglong 0x17 || 0x7 == 0x1 (0x1) +int 0x17 & 0x7 == 0x7 (0x7) +__uint 0x17 & 0x7 == 0x7 (0x7) +char 0x17 & 0x7 == 0x7 (0x7) +__uchar 0x17 & 0x7 == 0x7 (0x7) +__longlong 0x17 & 0x7 == 0x7 (0x7) +__ulonglong 0x17 & 0x7 == 0x7 (0x7) +int 0x17 | 0x7 == 0x17 (0x17) +__uint 0x17 | 0x7 == 0x17 (0x17) +char 0x17 | 0x7 == 0x17 (0x17) +__uchar 0x17 | 0x7 == 0x17 (0x17) +__longlong 0x17 | 0x7 == 0x17 (0x17) +__ulonglong 0x17 | 0x7 == 0x17 (0x17) +int 0x17 << 0xa == 0x5c00 (0x5c00) +__uint 0x17 << 0xa == 0x5c00 (0x5c00) +char 0x17 << 0xa == 0x0 (0x0) +__uchar 0x17 << 0xa == 0x0 (0x0) +__longlong 0x17 << 0xa == 0x5c00 (0x5c00) +__ulonglong 0x17 << 0xa == 0x5c00 (0x5c00) +int 0x17 >> 0xa == 0x0 (0x0) +__uint 0x17 >> 0xa == 0x0 (0x0) +char 0x17 >> 0xa == 0x0 (0x0) +__uchar 0x17 >> 0xa == 0x0 (0x0) +__longlong 0x17 >> 0xa == 0x0 (0x0) +__ulonglong 0x17 >> 0xa == 0x0 (0x0) +int 0x17 + 0x7 == 0x1e (0x1e) +__uint 0x17 + 0x7 == 0x1e (0x1e) +char 0x17 + 0x7 == 0x1e (0x1e) +__uchar 0x17 + 0x7 == 0x1e (0x1e) +__longlong 0x17 + 0x7 == 0x1e (0x1e) +__ulonglong 0x17 + 0x7 == 0x1e (0x1e) +float 0x17 + 0x7 == 0x1e (0x1e) +int 0x17 - 0x7 == 0x10 (0x10) +__uint 0x17 - 0x7 == 0x10 (0x10) +char 0x17 - 0x7 == 0x10 (0x10) +__uchar 0x17 - 0x7 == 0x10 (0x10) +__longlong 0x17 - 0x7 == 0x10 (0x10) +__ulonglong 0x17 - 0x7 == 0x10 (0x10) +float 0x17 - 0x7 == 0x10 (0x10) +int 0x17 * 0x7 == 0xa1 (0xa1) +__uint 0x17 * 0x7 == 0xa1 (0xa1) +char 0x17 * 0x7 == -0x5f (0xffa1) +__uchar 0x17 * 0x7 == 0xa1 (0xa1) +__longlong 0x17 * 0x7 == 0xa1 (0xa1) +__ulonglong 0x17 * 0x7 == 0xa1 (0xa1) +float 0x17 * 0x7 == 0xa1 (0xa1) +int 0x17 < 0x7 == 0x0 (0x0) +__uint 0x17 < 0x7 == 0x0 (0x0) +char 0x17 < 0x7 == 0x0 (0x0) +__uchar 0x17 < 0x7 == 0x0 (0x0) +__longlong 0x17 < 0x7 == 0x0 (0x0) +__ulonglong 0x17 < 0x7 == 0x0 (0x0) +float 0x17 < 0x7 == 0x0 (0x0) +int 0x17 > 0x7 == 0x1 (0x1) +__uint 0x17 > 0x7 == 0x1 (0x1) +char 0x17 > 0x7 == 0x1 (0x1) +__uchar 0x17 > 0x7 == 0x1 (0x1) +__longlong 0x17 > 0x7 == 0x1 (0x1) +__ulonglong 0x17 > 0x7 == 0x1 (0x1) +float 0x17 > 0x7 == 0x1 (0x1) +int 0x17 <= 0x7 == 0x0 (0x0) +__uint 0x17 <= 0x7 == 0x0 (0x0) +char 0x17 <= 0x7 == 0x0 (0x0) +__uchar 0x17 <= 0x7 == 0x0 (0x0) +__longlong 0x17 <= 0x7 == 0x0 (0x0) +__ulonglong 0x17 <= 0x7 == 0x0 (0x0) +float 0x17 <= 0x7 == 0x0 (0x0) +int 0x17 == 0x7 == 0x0 (0x0) +__uint 0x17 == 0x7 == 0x0 (0x0) +char 0x17 == 0x7 == 0x0 (0x0) +__uchar 0x17 == 0x7 == 0x0 (0x0) +__longlong 0x17 == 0x7 == 0x0 (0x0) +__ulonglong 0x17 == 0x7 == 0x0 (0x0) +float 0x17 == 0x7 == 0x0 (0x0) +int 0x17 != 0x7 == 0x1 (0x1) +__uint 0x17 != 0x7 == 0x1 (0x1) +char 0x17 != 0x7 == 0x1 (0x1) +__uchar 0x17 != 0x7 == 0x1 (0x1) +__longlong 0x17 != 0x7 == 0x1 (0x1) +__ulonglong 0x17 != 0x7 == 0x1 (0x1) +float 0x17 != 0x7 == 0x1 (0x1) +int 0x17 >= 0x7 == 0x1 (0x1) +__uint 0x17 >= 0x7 == 0x1 (0x1) +char 0x17 >= 0x7 == 0x1 (0x1) +__uchar 0x17 >= 0x7 == 0x1 (0x1) +__longlong 0x17 >= 0x7 == 0x1 (0x1) +__ulonglong 0x17 >= 0x7 == 0x1 (0x1) +float 0x17 >= 0x7 == 0x1 (0x1) +int 0x17 / 0x7 == 0x3 (0x3) +__uint 0x17 / 0x7 == 0x3 (0x3) +char 0x17 / 0x7 == 0x3 (0x3) +__uchar 0x17 / 0x7 == 0x3 (0x3) +__longlong 0x17 / 0x7 == 0x3 (0x3) +__ulonglong 0x17 / 0x7 == 0x3 (0x3) +float 0x17 / 0x7 == 0x3 (0x3) +int 0x17 % 0x7 == 0x2 (0x2) +__uint 0x17 % 0x7 == 0x2 (0x2) +char 0x17 % 0x7 == 0x2 (0x2) +__uchar 0x17 % 0x7 == 0x2 (0x2) +__longlong 0x17 % 0x7 == 0x2 (0x2) +__ulonglong 0x17 % 0x7 == 0x2 (0x2) +0x17 * 0x2a == 0x3c6 +0x17 / 0x2a == 0x0 +0x17 % 0x2a == 0x17 +int 0x17 ^ 0x2a == 0x3d (0x3d) +__uint 0x17 ^ 0x2a == 0x3d (0x3d) +char 0x17 ^ 0x2a == 0x3d (0x3d) +__uchar 0x17 ^ 0x2a == 0x3d (0x3d) +__longlong 0x17 ^ 0x2a == 0x3d (0x3d) +__ulonglong 0x17 ^ 0x2a == 0x3d (0x3d) +int 0x17 && 0x2a == 0x1 (0x1) +__uint 0x17 && 0x2a == 0x1 (0x1) +char 0x17 && 0x2a == 0x1 (0x1) +__uchar 0x17 && 0x2a == 0x1 (0x1) +__longlong 0x17 && 0x2a == 0x1 (0x1) +__ulonglong 0x17 && 0x2a == 0x1 (0x1) +int 0x17 || 0x2a == 0x1 (0x1) +__uint 0x17 || 0x2a == 0x1 (0x1) +char 0x17 || 0x2a == 0x1 (0x1) +__uchar 0x17 || 0x2a == 0x1 (0x1) +__longlong 0x17 || 0x2a == 0x1 (0x1) +__ulonglong 0x17 || 0x2a == 0x1 (0x1) +int 0x17 & 0x2a == 0x2 (0x2) +__uint 0x17 & 0x2a == 0x2 (0x2) +char 0x17 & 0x2a == 0x2 (0x2) +__uchar 0x17 & 0x2a == 0x2 (0x2) +__longlong 0x17 & 0x2a == 0x2 (0x2) +__ulonglong 0x17 & 0x2a == 0x2 (0x2) +int 0x17 | 0x2a == 0x3f (0x3f) +__uint 0x17 | 0x2a == 0x3f (0x3f) +char 0x17 | 0x2a == 0x3f (0x3f) +__uchar 0x17 | 0x2a == 0x3f (0x3f) +__longlong 0x17 | 0x2a == 0x3f (0x3f) +__ulonglong 0x17 | 0x2a == 0x3f (0x3f) +int 0x17 << 0xc == 0x7000 (0x7000) +__uint 0x17 << 0xc == 0x7000 (0x7000) +char 0x17 << 0xc == 0x0 (0x0) +__uchar 0x17 << 0xc == 0x0 (0x0) +__longlong 0x17 << 0xc == 0x7000 (0x7000) +__ulonglong 0x17 << 0xc == 0x7000 (0x7000) +int 0x17 >> 0xc == 0x0 (0x0) +__uint 0x17 >> 0xc == 0x0 (0x0) +char 0x17 >> 0xc == 0x0 (0x0) +__uchar 0x17 >> 0xc == 0x0 (0x0) +__longlong 0x17 >> 0xc == 0x0 (0x0) +__ulonglong 0x17 >> 0xc == 0x0 (0x0) +int 0x17 + 0x2a == 0x41 (0x41) +__uint 0x17 + 0x2a == 0x41 (0x41) +char 0x17 + 0x2a == 0x41 (0x41) +__uchar 0x17 + 0x2a == 0x41 (0x41) +__longlong 0x17 + 0x2a == 0x41 (0x41) +__ulonglong 0x17 + 0x2a == 0x41 (0x41) +float 0x17 + 0x2a == 0x41 (0x41) +int 0x17 - 0x2a == -0x13 (0xffed) +__uint 0x17 - 0x2a == -0x13 (0xffed) +char 0x17 - 0x2a == -0x13 (0xffed) +__uchar 0x17 - 0x2a == 0xed (0xed) +__longlong 0x17 - 0x2a == -0x13 (0xffed) +__ulonglong 0x17 - 0x2a == -0x13 (0xffed) +float 0x17 - 0x2a == -0x13 (0xffed) +int 0x17 * 0x2a == 0x3c6 (0x3c6) +__uint 0x17 * 0x2a == 0x3c6 (0x3c6) +char 0x17 * 0x2a == -0x3a (0xffc6) +__uchar 0x17 * 0x2a == 0xc6 (0xc6) +__longlong 0x17 * 0x2a == 0x3c6 (0x3c6) +__ulonglong 0x17 * 0x2a == 0x3c6 (0x3c6) +float 0x17 * 0x2a == 0x3c6 (0x3c6) +int 0x17 < 0x2a == 0x1 (0x1) +__uint 0x17 < 0x2a == 0x1 (0x1) +char 0x17 < 0x2a == 0x1 (0x1) +__uchar 0x17 < 0x2a == 0x1 (0x1) +__longlong 0x17 < 0x2a == 0x1 (0x1) +__ulonglong 0x17 < 0x2a == 0x1 (0x1) +float 0x17 < 0x2a == 0x1 (0x1) +int 0x17 > 0x2a == 0x0 (0x0) +__uint 0x17 > 0x2a == 0x0 (0x0) +char 0x17 > 0x2a == 0x0 (0x0) +__uchar 0x17 > 0x2a == 0x0 (0x0) +__longlong 0x17 > 0x2a == 0x0 (0x0) +__ulonglong 0x17 > 0x2a == 0x0 (0x0) +float 0x17 > 0x2a == 0x0 (0x0) +int 0x17 <= 0x2a == 0x1 (0x1) +__uint 0x17 <= 0x2a == 0x1 (0x1) +char 0x17 <= 0x2a == 0x1 (0x1) +__uchar 0x17 <= 0x2a == 0x1 (0x1) +__longlong 0x17 <= 0x2a == 0x1 (0x1) +__ulonglong 0x17 <= 0x2a == 0x1 (0x1) +float 0x17 <= 0x2a == 0x1 (0x1) +int 0x17 == 0x2a == 0x0 (0x0) +__uint 0x17 == 0x2a == 0x0 (0x0) +char 0x17 == 0x2a == 0x0 (0x0) +__uchar 0x17 == 0x2a == 0x0 (0x0) +__longlong 0x17 == 0x2a == 0x0 (0x0) +__ulonglong 0x17 == 0x2a == 0x0 (0x0) +float 0x17 == 0x2a == 0x0 (0x0) +int 0x17 != 0x2a == 0x1 (0x1) +__uint 0x17 != 0x2a == 0x1 (0x1) +char 0x17 != 0x2a == 0x1 (0x1) +__uchar 0x17 != 0x2a == 0x1 (0x1) +__longlong 0x17 != 0x2a == 0x1 (0x1) +__ulonglong 0x17 != 0x2a == 0x1 (0x1) +float 0x17 != 0x2a == 0x1 (0x1) +int 0x17 >= 0x2a == 0x0 (0x0) +__uint 0x17 >= 0x2a == 0x0 (0x0) +char 0x17 >= 0x2a == 0x0 (0x0) +__uchar 0x17 >= 0x2a == 0x0 (0x0) +__longlong 0x17 >= 0x2a == 0x0 (0x0) +__ulonglong 0x17 >= 0x2a == 0x0 (0x0) +float 0x17 >= 0x2a == 0x0 (0x0) +int 0x17 / 0x2a == 0x0 (0x0) +__uint 0x17 / 0x2a == 0x0 (0x0) +char 0x17 / 0x2a == 0x0 (0x0) +__uchar 0x17 / 0x2a == 0x0 (0x0) +__longlong 0x17 / 0x2a == 0x0 (0x0) +__ulonglong 0x17 / 0x2a == 0x0 (0x0) +float 0x17 / 0x2a == 0x0 (0x0) +int 0x17 % 0x2a == 0x17 (0x17) +__uint 0x17 % 0x2a == 0x17 (0x17) +char 0x17 % 0x2a == 0x17 (0x17) +__uchar 0x17 % 0x2a == 0x17 (0x17) +__longlong 0x17 % 0x2a == 0x17 (0x17) +__ulonglong 0x17 % 0x2a == 0x17 (0x17) +0x17 * 0x17 == 0x211 +0x17 / 0x17 == 0x1 +0x17 % 0x17 == 0x0 +int 0x17 ^ 0x17 == 0x0 (0x0) +__uint 0x17 ^ 0x17 == 0x0 (0x0) +char 0x17 ^ 0x17 == 0x0 (0x0) +__uchar 0x17 ^ 0x17 == 0x0 (0x0) +__longlong 0x17 ^ 0x17 == 0x0 (0x0) +__ulonglong 0x17 ^ 0x17 == 0x0 (0x0) +int 0x17 && 0x17 == 0x1 (0x1) +__uint 0x17 && 0x17 == 0x1 (0x1) +char 0x17 && 0x17 == 0x1 (0x1) +__uchar 0x17 && 0x17 == 0x1 (0x1) +__longlong 0x17 && 0x17 == 0x1 (0x1) +__ulonglong 0x17 && 0x17 == 0x1 (0x1) +int 0x17 || 0x17 == 0x1 (0x1) +__uint 0x17 || 0x17 == 0x1 (0x1) +char 0x17 || 0x17 == 0x1 (0x1) +__uchar 0x17 || 0x17 == 0x1 (0x1) +__longlong 0x17 || 0x17 == 0x1 (0x1) +__ulonglong 0x17 || 0x17 == 0x1 (0x1) +int 0x17 & 0x17 == 0x17 (0x17) +__uint 0x17 & 0x17 == 0x17 (0x17) +char 0x17 & 0x17 == 0x17 (0x17) +__uchar 0x17 & 0x17 == 0x17 (0x17) +__longlong 0x17 & 0x17 == 0x17 (0x17) +__ulonglong 0x17 & 0x17 == 0x17 (0x17) +int 0x17 | 0x17 == 0x17 (0x17) +__uint 0x17 | 0x17 == 0x17 (0x17) +char 0x17 | 0x17 == 0x17 (0x17) +__uchar 0x17 | 0x17 == 0x17 (0x17) +__longlong 0x17 | 0x17 == 0x17 (0x17) +__ulonglong 0x17 | 0x17 == 0x17 (0x17) +int 0x17 << 0xe == -0x4000 (0xc000) +__uint 0x17 << 0xe == -0x4000 (0xc000) +char 0x17 << 0xe == 0x0 (0x0) +__uchar 0x17 << 0xe == 0x0 (0x0) +__longlong 0x17 << 0xe == -0x4000 (0xc000) +__ulonglong 0x17 << 0xe == -0x4000 (0xc000) +int 0x17 >> 0xe == 0x0 (0x0) +__uint 0x17 >> 0xe == 0x0 (0x0) +char 0x17 >> 0xe == 0x0 (0x0) +__uchar 0x17 >> 0xe == 0x0 (0x0) +__longlong 0x17 >> 0xe == 0x0 (0x0) +__ulonglong 0x17 >> 0xe == 0x0 (0x0) +int 0x17 + 0x17 == 0x2e (0x2e) +__uint 0x17 + 0x17 == 0x2e (0x2e) +char 0x17 + 0x17 == 0x2e (0x2e) +__uchar 0x17 + 0x17 == 0x2e (0x2e) +__longlong 0x17 + 0x17 == 0x2e (0x2e) +__ulonglong 0x17 + 0x17 == 0x2e (0x2e) +float 0x17 + 0x17 == 0x2e (0x2e) +int 0x17 - 0x17 == 0x0 (0x0) +__uint 0x17 - 0x17 == 0x0 (0x0) +char 0x17 - 0x17 == 0x0 (0x0) +__uchar 0x17 - 0x17 == 0x0 (0x0) +__longlong 0x17 - 0x17 == 0x0 (0x0) +__ulonglong 0x17 - 0x17 == 0x0 (0x0) +float 0x17 - 0x17 == 0x0 (0x0) +int 0x17 * 0x17 == 0x211 (0x211) +__uint 0x17 * 0x17 == 0x211 (0x211) +char 0x17 * 0x17 == 0x11 (0x11) +__uchar 0x17 * 0x17 == 0x11 (0x11) +__longlong 0x17 * 0x17 == 0x211 (0x211) +__ulonglong 0x17 * 0x17 == 0x211 (0x211) +float 0x17 * 0x17 == 0x211 (0x211) +int 0x17 < 0x17 == 0x0 (0x0) +__uint 0x17 < 0x17 == 0x0 (0x0) +char 0x17 < 0x17 == 0x0 (0x0) +__uchar 0x17 < 0x17 == 0x0 (0x0) +__longlong 0x17 < 0x17 == 0x0 (0x0) +__ulonglong 0x17 < 0x17 == 0x0 (0x0) +float 0x17 < 0x17 == 0x0 (0x0) +int 0x17 > 0x17 == 0x0 (0x0) +__uint 0x17 > 0x17 == 0x0 (0x0) +char 0x17 > 0x17 == 0x0 (0x0) +__uchar 0x17 > 0x17 == 0x0 (0x0) +__longlong 0x17 > 0x17 == 0x0 (0x0) +__ulonglong 0x17 > 0x17 == 0x0 (0x0) +float 0x17 > 0x17 == 0x0 (0x0) +int 0x17 <= 0x17 == 0x1 (0x1) +__uint 0x17 <= 0x17 == 0x1 (0x1) +char 0x17 <= 0x17 == 0x1 (0x1) +__uchar 0x17 <= 0x17 == 0x1 (0x1) +__longlong 0x17 <= 0x17 == 0x1 (0x1) +__ulonglong 0x17 <= 0x17 == 0x1 (0x1) +float 0x17 <= 0x17 == 0x1 (0x1) +int 0x17 == 0x17 == 0x1 (0x1) +__uint 0x17 == 0x17 == 0x1 (0x1) +char 0x17 == 0x17 == 0x1 (0x1) +__uchar 0x17 == 0x17 == 0x1 (0x1) +__longlong 0x17 == 0x17 == 0x1 (0x1) +__ulonglong 0x17 == 0x17 == 0x1 (0x1) +float 0x17 == 0x17 == 0x1 (0x1) +int 0x17 != 0x17 == 0x0 (0x0) +__uint 0x17 != 0x17 == 0x0 (0x0) +char 0x17 != 0x17 == 0x0 (0x0) +__uchar 0x17 != 0x17 == 0x0 (0x0) +__longlong 0x17 != 0x17 == 0x0 (0x0) +__ulonglong 0x17 != 0x17 == 0x0 (0x0) +float 0x17 != 0x17 == 0x0 (0x0) +int 0x17 >= 0x17 == 0x1 (0x1) +__uint 0x17 >= 0x17 == 0x1 (0x1) +char 0x17 >= 0x17 == 0x1 (0x1) +__uchar 0x17 >= 0x17 == 0x1 (0x1) +__longlong 0x17 >= 0x17 == 0x1 (0x1) +__ulonglong 0x17 >= 0x17 == 0x1 (0x1) +float 0x17 >= 0x17 == 0x1 (0x1) +int 0x17 / 0x17 == 0x1 (0x1) +__uint 0x17 / 0x17 == 0x1 (0x1) +char 0x17 / 0x17 == 0x1 (0x1) +__uchar 0x17 / 0x17 == 0x1 (0x1) +__longlong 0x17 / 0x17 == 0x1 (0x1) +__ulonglong 0x17 / 0x17 == 0x1 (0x1) +float 0x17 / 0x17 == 0x1 (0x1) +int 0x17 % 0x17 == 0x0 (0x0) +__uint 0x17 % 0x17 == 0x0 (0x0) +char 0x17 % 0x17 == 0x0 (0x0) +__uchar 0x17 % 0x17 == 0x0 (0x0) +__longlong 0x17 % 0x17 == 0x0 (0x0) +__ulonglong 0x17 % 0x17 == 0x0 (0x0) +0x17 * 0x7fff == 0x7fe9 +0x17 / 0x7fff == 0x0 +0x17 % 0x7fff == 0x17 +int 0x17 ^ 0x7fff == 0x7fe8 (0x7fe8) +__uint 0x17 ^ 0x7fff == 0x7fe8 (0x7fe8) +char 0x17 ^ 0xffff == -0x18 (0xffe8) +__uchar 0x17 ^ 0xff == 0xe8 (0xe8) +__longlong 0x17 ^ 0x7fff == 0x7fe8 (0x7fe8) +__ulonglong 0x17 ^ 0x7fff == 0x7fe8 (0x7fe8) +int 0x17 && 0x7fff == 0x1 (0x1) +__uint 0x17 && 0x7fff == 0x1 (0x1) +char 0x17 && 0xffff == 0x1 (0x1) +__uchar 0x17 && 0xff == 0x1 (0x1) +__longlong 0x17 && 0x7fff == 0x1 (0x1) +__ulonglong 0x17 && 0x7fff == 0x1 (0x1) +int 0x17 || 0x7fff == 0x1 (0x1) +__uint 0x17 || 0x7fff == 0x1 (0x1) +char 0x17 || 0xffff == 0x1 (0x1) +__uchar 0x17 || 0xff == 0x1 (0x1) +__longlong 0x17 || 0x7fff == 0x1 (0x1) +__ulonglong 0x17 || 0x7fff == 0x1 (0x1) +int 0x17 & 0x7fff == 0x17 (0x17) +__uint 0x17 & 0x7fff == 0x17 (0x17) +char 0x17 & 0xffff == 0x17 (0x17) +__uchar 0x17 & 0xff == 0x17 (0x17) +__longlong 0x17 & 0x7fff == 0x17 (0x17) +__ulonglong 0x17 & 0x7fff == 0x17 (0x17) +int 0x17 | 0x7fff == 0x7fff (0x7fff) +__uint 0x17 | 0x7fff == 0x7fff (0x7fff) +char 0x17 | 0xffff == -0x1 (0xffff) +__uchar 0x17 | 0xff == 0xff (0xff) +__longlong 0x17 | 0x7fff == 0x7fff (0x7fff) +__ulonglong 0x17 | 0x7fff == 0x7fff (0x7fff) +int 0x17 << 0x10 == 0x0 (0x0) +__uint 0x17 << 0x10 == 0x0 (0x0) +char 0x17 << 0x10 == 0x0 (0x0) +__uchar 0x17 << 0x10 == 0x0 (0x0) +__longlong 0x17 << 0x10 == 0x0 (0x0) +__ulonglong 0x17 << 0x10 == 0x0 (0x0) +int 0x17 >> 0x10 == 0x0 (0x0) +__uint 0x17 >> 0x10 == 0x0 (0x0) +char 0x17 >> 0x10 == 0x0 (0x0) +__uchar 0x17 >> 0x10 == 0x0 (0x0) +__longlong 0x17 >> 0x10 == 0x0 (0x0) +__ulonglong 0x17 >> 0x10 == 0x0 (0x0) +int 0x17 + 0x7fff == -0x7fea (0x8016) +__uint 0x17 + 0x7fff == -0x7fea (0x8016) +char 0x17 + 0xffff == 0x16 (0x16) +__uchar 0x17 + 0xff == 0x16 (0x16) +__longlong 0x17 + 0x7fff == -0x7fea (0x8016) +__ulonglong 0x17 + 0x7fff == -0x7fea (0x8016) +float 0x17 + 0x7fff == -0x7fea (0x8016) +int 0x17 - 0x7fff == -0x7fe8 (0x8018) +__uint 0x17 - 0x7fff == -0x7fe8 (0x8018) +char 0x17 - 0xffff == 0x18 (0x18) +__uchar 0x17 - 0xff == 0x18 (0x18) +__longlong 0x17 - 0x7fff == -0x7fe8 (0x8018) +__ulonglong 0x17 - 0x7fff == -0x7fe8 (0x8018) +float 0x17 - 0x7fff == -0x7fe8 (0x8018) +int 0x17 * 0x7fff == 0x7fe9 (0x7fe9) +__uint 0x17 * 0x7fff == 0x7fe9 (0x7fe9) +char 0x17 * 0xffff == -0x17 (0xffe9) +__uchar 0x17 * 0xff == 0xe9 (0xe9) +__longlong 0x17 * 0x7fff == 0x7fe9 (0x7fe9) +__ulonglong 0x17 * 0x7fff == 0x7fe9 (0x7fe9) +float 0x17 * 0x7fff == 0x7fe9 (0x7fe9) +int 0x17 < 0x7fff == 0x1 (0x1) +__uint 0x17 < 0x7fff == 0x1 (0x1) +char 0x17 < 0xffff == 0x0 (0x0) +__uchar 0x17 < 0xff == 0x1 (0x1) +__longlong 0x17 < 0x7fff == 0x1 (0x1) +__ulonglong 0x17 < 0x7fff == 0x1 (0x1) +float 0x17 < 0x7fff == 0x1 (0x1) +int 0x17 > 0x7fff == 0x0 (0x0) +__uint 0x17 > 0x7fff == 0x0 (0x0) +char 0x17 > 0xffff == 0x1 (0x1) +__uchar 0x17 > 0xff == 0x0 (0x0) +__longlong 0x17 > 0x7fff == 0x0 (0x0) +__ulonglong 0x17 > 0x7fff == 0x0 (0x0) +float 0x17 > 0x7fff == 0x0 (0x0) +int 0x17 <= 0x7fff == 0x1 (0x1) +__uint 0x17 <= 0x7fff == 0x1 (0x1) +char 0x17 <= 0xffff == 0x0 (0x0) +__uchar 0x17 <= 0xff == 0x1 (0x1) +__longlong 0x17 <= 0x7fff == 0x1 (0x1) +__ulonglong 0x17 <= 0x7fff == 0x1 (0x1) +float 0x17 <= 0x7fff == 0x1 (0x1) +int 0x17 == 0x7fff == 0x0 (0x0) +__uint 0x17 == 0x7fff == 0x0 (0x0) +char 0x17 == 0xffff == 0x0 (0x0) +__uchar 0x17 == 0xff == 0x0 (0x0) +__longlong 0x17 == 0x7fff == 0x0 (0x0) +__ulonglong 0x17 == 0x7fff == 0x0 (0x0) +float 0x17 == 0x7fff == 0x0 (0x0) +int 0x17 != 0x7fff == 0x1 (0x1) +__uint 0x17 != 0x7fff == 0x1 (0x1) +char 0x17 != 0xffff == 0x1 (0x1) +__uchar 0x17 != 0xff == 0x1 (0x1) +__longlong 0x17 != 0x7fff == 0x1 (0x1) +__ulonglong 0x17 != 0x7fff == 0x1 (0x1) +float 0x17 != 0x7fff == 0x1 (0x1) +int 0x17 >= 0x7fff == 0x0 (0x0) +__uint 0x17 >= 0x7fff == 0x0 (0x0) +char 0x17 >= 0xffff == 0x1 (0x1) +__uchar 0x17 >= 0xff == 0x0 (0x0) +__longlong 0x17 >= 0x7fff == 0x0 (0x0) +__ulonglong 0x17 >= 0x7fff == 0x0 (0x0) +float 0x17 >= 0x7fff == 0x0 (0x0) +int 0x17 / 0x7fff == 0x0 (0x0) +__uint 0x17 / 0x7fff == 0x0 (0x0) +char 0x17 / 0xffff == -0x17 (0xffe9) +__uchar 0x17 / 0xff == 0x0 (0x0) +__longlong 0x17 / 0x7fff == 0x0 (0x0) +__ulonglong 0x17 / 0x7fff == 0x0 (0x0) +float 0x17 / 0x7fff == 0x0 (0x0) +int 0x17 % 0x7fff == 0x17 (0x17) +__uint 0x17 % 0x7fff == 0x17 (0x17) +char 0x17 % 0xffff == 0x0 (0x0) +__uchar 0x17 % 0xff == 0x17 (0x17) +__longlong 0x17 % 0x7fff == 0x17 (0x17) +__ulonglong 0x17 % 0x7fff == 0x17 (0x17) +0x17 * 0x8000 == -0x8000 +0x17 / 0x8000 == 0x0 +0x17 % 0x8000 == 0x17 +int 0x17 ^ 0x8000 == -0x7fe9 (0x8017) +__uint 0x17 ^ 0x8000 == -0x7fe9 (0x8017) +char 0x17 ^ 0x0 == 0x17 (0x17) +__uchar 0x17 ^ 0x0 == 0x17 (0x17) +__longlong 0x17 ^ 0x8000 == -0x7fe9 (0x8017) +__ulonglong 0x17 ^ 0x8000 == -0x7fe9 (0x8017) +int 0x17 && 0x8000 == 0x1 (0x1) +__uint 0x17 && 0x8000 == 0x1 (0x1) +char 0x17 && 0x0 == 0x0 (0x0) +__uchar 0x17 && 0x0 == 0x0 (0x0) +__longlong 0x17 && 0x8000 == 0x1 (0x1) +__ulonglong 0x17 && 0x8000 == 0x1 (0x1) +int 0x17 || 0x8000 == 0x1 (0x1) +__uint 0x17 || 0x8000 == 0x1 (0x1) +char 0x17 || 0x0 == 0x1 (0x1) +__uchar 0x17 || 0x0 == 0x1 (0x1) +__longlong 0x17 || 0x8000 == 0x1 (0x1) +__ulonglong 0x17 || 0x8000 == 0x1 (0x1) +int 0x17 & 0x8000 == 0x0 (0x0) +__uint 0x17 & 0x8000 == 0x0 (0x0) +char 0x17 & 0x0 == 0x0 (0x0) +__uchar 0x17 & 0x0 == 0x0 (0x0) +__longlong 0x17 & 0x8000 == 0x0 (0x0) +__ulonglong 0x17 & 0x8000 == 0x0 (0x0) +int 0x17 | 0x8000 == -0x7fe9 (0x8017) +__uint 0x17 | 0x8000 == -0x7fe9 (0x8017) +char 0x17 | 0x0 == 0x17 (0x17) +__uchar 0x17 | 0x0 == 0x17 (0x17) +__longlong 0x17 | 0x8000 == -0x7fe9 (0x8017) +__ulonglong 0x17 | 0x8000 == -0x7fe9 (0x8017) +int 0x17 << 0x12 == 0x0 (0x0) +__uint 0x17 << 0x12 == 0x0 (0x0) +char 0x17 << 0x12 == 0x0 (0x0) +__uchar 0x17 << 0x12 == 0x0 (0x0) +__longlong 0x17 << 0x12 == 0x0 (0x0) +__ulonglong 0x17 << 0x12 == 0x0 (0x0) +int 0x17 >> 0x12 == 0x0 (0x0) +__uint 0x17 >> 0x12 == 0x0 (0x0) +char 0x17 >> 0x12 == 0x0 (0x0) +__uchar 0x17 >> 0x12 == 0x0 (0x0) +__longlong 0x17 >> 0x12 == 0x0 (0x0) +__ulonglong 0x17 >> 0x12 == 0x0 (0x0) +int 0x17 + 0x8000 == -0x7fe9 (0x8017) +__uint 0x17 + 0x8000 == -0x7fe9 (0x8017) +char 0x17 + 0x0 == 0x17 (0x17) +__uchar 0x17 + 0x0 == 0x17 (0x17) +__longlong 0x17 + 0x8000 == -0x7fe9 (0x8017) +__ulonglong 0x17 + 0x8000 == -0x7fe9 (0x8017) +float 0x17 + 0x8000 == -0x7fe9 (0x8017) +int 0x17 - 0x8000 == -0x7fe9 (0x8017) +__uint 0x17 - 0x8000 == -0x7fe9 (0x8017) +char 0x17 - 0x0 == 0x17 (0x17) +__uchar 0x17 - 0x0 == 0x17 (0x17) +__longlong 0x17 - 0x8000 == -0x7fe9 (0x8017) +__ulonglong 0x17 - 0x8000 == -0x7fe9 (0x8017) +float 0x17 - 0x8000 == -0x7fe9 (0x8017) +int 0x17 * 0x8000 == -0x8000 (0x8000) +__uint 0x17 * 0x8000 == -0x8000 (0x8000) +char 0x17 * 0x0 == 0x0 (0x0) +__uchar 0x17 * 0x0 == 0x0 (0x0) +__longlong 0x17 * 0x8000 == -0x8000 (0x8000) +__ulonglong 0x17 * 0x8000 == -0x8000 (0x8000) +float 0x17 * 0x8000 == -0x8000 (0x8000) +int 0x17 < 0x8000 == 0x0 (0x0) +__uint 0x17 < 0x8000 == 0x1 (0x1) +char 0x17 < 0x0 == 0x0 (0x0) +__uchar 0x17 < 0x0 == 0x0 (0x0) +__longlong 0x17 < 0x8000 == 0x0 (0x0) +__ulonglong 0x17 < 0x8000 == 0x1 (0x1) +float 0x17 < 0x8000 == 0x0 (0x0) +int 0x17 > 0x8000 == 0x1 (0x1) +__uint 0x17 > 0x8000 == 0x0 (0x0) +char 0x17 > 0x0 == 0x1 (0x1) +__uchar 0x17 > 0x0 == 0x1 (0x1) +__longlong 0x17 > 0x8000 == 0x1 (0x1) +__ulonglong 0x17 > 0x8000 == 0x0 (0x0) +float 0x17 > 0x8000 == 0x1 (0x1) +int 0x17 <= 0x8000 == 0x0 (0x0) +__uint 0x17 <= 0x8000 == 0x1 (0x1) +char 0x17 <= 0x0 == 0x0 (0x0) +__uchar 0x17 <= 0x0 == 0x0 (0x0) +__longlong 0x17 <= 0x8000 == 0x0 (0x0) +__ulonglong 0x17 <= 0x8000 == 0x1 (0x1) +float 0x17 <= 0x8000 == 0x0 (0x0) +int 0x17 == 0x8000 == 0x0 (0x0) +__uint 0x17 == 0x8000 == 0x0 (0x0) +char 0x17 == 0x0 == 0x0 (0x0) +__uchar 0x17 == 0x0 == 0x0 (0x0) +__longlong 0x17 == 0x8000 == 0x0 (0x0) +__ulonglong 0x17 == 0x8000 == 0x0 (0x0) +float 0x17 == 0x8000 == 0x0 (0x0) +int 0x17 != 0x8000 == 0x1 (0x1) +__uint 0x17 != 0x8000 == 0x1 (0x1) +char 0x17 != 0x0 == 0x1 (0x1) +__uchar 0x17 != 0x0 == 0x1 (0x1) +__longlong 0x17 != 0x8000 == 0x1 (0x1) +__ulonglong 0x17 != 0x8000 == 0x1 (0x1) +float 0x17 != 0x8000 == 0x1 (0x1) +int 0x17 >= 0x8000 == 0x1 (0x1) +__uint 0x17 >= 0x8000 == 0x0 (0x0) +char 0x17 >= 0x0 == 0x1 (0x1) +__uchar 0x17 >= 0x0 == 0x1 (0x1) +__longlong 0x17 >= 0x8000 == 0x1 (0x1) +__ulonglong 0x17 >= 0x8000 == 0x0 (0x0) +float 0x17 >= 0x8000 == 0x1 (0x1) +int 0x17 / 0x8000 == 0x0 (0x0) +__uint 0x17 / 0x8000 == 0x0 (0x0) +__longlong 0x17 / 0x8000 == 0x0 (0x0) +__ulonglong 0x17 / 0x8000 == 0x0 (0x0) +float 0x17 / 0x8000 == 0x0 (0x0) +int 0x17 % 0x8000 == 0x17 (0x17) +__uint 0x17 % 0x8000 == 0x17 (0x17) +__longlong 0x17 % 0x8000 == 0x17 (0x17) +__ulonglong 0x17 % 0x8000 == 0x17 (0x17) +0x17 * 0x3e8 == 0x59d8 +0x17 / 0x3e8 == 0x0 +0x17 % 0x3e8 == 0x17 +int 0x17 ^ 0x3e8 == 0x3ff (0x3ff) +__uint 0x17 ^ 0x3e8 == 0x3ff (0x3ff) +char 0x17 ^ 0xffe8 == -0x1 (0xffff) +__uchar 0x17 ^ 0xe8 == 0xff (0xff) +__longlong 0x17 ^ 0x3e8 == 0x3ff (0x3ff) +__ulonglong 0x17 ^ 0x3e8 == 0x3ff (0x3ff) +int 0x17 && 0x3e8 == 0x1 (0x1) +__uint 0x17 && 0x3e8 == 0x1 (0x1) +char 0x17 && 0xffe8 == 0x1 (0x1) +__uchar 0x17 && 0xe8 == 0x1 (0x1) +__longlong 0x17 && 0x3e8 == 0x1 (0x1) +__ulonglong 0x17 && 0x3e8 == 0x1 (0x1) +int 0x17 || 0x3e8 == 0x1 (0x1) +__uint 0x17 || 0x3e8 == 0x1 (0x1) +char 0x17 || 0xffe8 == 0x1 (0x1) +__uchar 0x17 || 0xe8 == 0x1 (0x1) +__longlong 0x17 || 0x3e8 == 0x1 (0x1) +__ulonglong 0x17 || 0x3e8 == 0x1 (0x1) +int 0x17 & 0x3e8 == 0x0 (0x0) +__uint 0x17 & 0x3e8 == 0x0 (0x0) +char 0x17 & 0xffe8 == 0x0 (0x0) +__uchar 0x17 & 0xe8 == 0x0 (0x0) +__longlong 0x17 & 0x3e8 == 0x0 (0x0) +__ulonglong 0x17 & 0x3e8 == 0x0 (0x0) +int 0x17 | 0x3e8 == 0x3ff (0x3ff) +__uint 0x17 | 0x3e8 == 0x3ff (0x3ff) +char 0x17 | 0xffe8 == -0x1 (0xffff) +__uchar 0x17 | 0xe8 == 0xff (0xff) +__longlong 0x17 | 0x3e8 == 0x3ff (0x3ff) +__ulonglong 0x17 | 0x3e8 == 0x3ff (0x3ff) +int 0x17 << 0x14 == 0x0 (0x0) +__uint 0x17 << 0x14 == 0x0 (0x0) +char 0x17 << 0x14 == 0x0 (0x0) +__uchar 0x17 << 0x14 == 0x0 (0x0) +__longlong 0x17 << 0x14 == 0x0 (0x0) +__ulonglong 0x17 << 0x14 == 0x0 (0x0) +int 0x17 >> 0x14 == 0x0 (0x0) +__uint 0x17 >> 0x14 == 0x0 (0x0) +char 0x17 >> 0x14 == 0x0 (0x0) +__uchar 0x17 >> 0x14 == 0x0 (0x0) +__longlong 0x17 >> 0x14 == 0x0 (0x0) +__ulonglong 0x17 >> 0x14 == 0x0 (0x0) +int 0x17 + 0x3e8 == 0x3ff (0x3ff) +__uint 0x17 + 0x3e8 == 0x3ff (0x3ff) +char 0x17 + 0xffe8 == -0x1 (0xffff) +__uchar 0x17 + 0xe8 == 0xff (0xff) +__longlong 0x17 + 0x3e8 == 0x3ff (0x3ff) +__ulonglong 0x17 + 0x3e8 == 0x3ff (0x3ff) +float 0x17 + 0x3e8 == 0x3ff (0x3ff) +int 0x17 - 0x3e8 == -0x3d1 (0xfc2f) +__uint 0x17 - 0x3e8 == -0x3d1 (0xfc2f) +char 0x17 - 0xffe8 == 0x2f (0x2f) +__uchar 0x17 - 0xe8 == 0x2f (0x2f) +__longlong 0x17 - 0x3e8 == -0x3d1 (0xfc2f) +__ulonglong 0x17 - 0x3e8 == -0x3d1 (0xfc2f) +float 0x17 - 0x3e8 == -0x3d1 (0xfc2f) +int 0x17 * 0x3e8 == 0x59d8 (0x59d8) +__uint 0x17 * 0x3e8 == 0x59d8 (0x59d8) +char 0x17 * 0xffe8 == -0x28 (0xffd8) +__uchar 0x17 * 0xe8 == 0xd8 (0xd8) +__longlong 0x17 * 0x3e8 == 0x59d8 (0x59d8) +__ulonglong 0x17 * 0x3e8 == 0x59d8 (0x59d8) +float 0x17 * 0x3e8 == 0x59d8 (0x59d8) +int 0x17 < 0x3e8 == 0x1 (0x1) +__uint 0x17 < 0x3e8 == 0x1 (0x1) +char 0x17 < 0xffe8 == 0x0 (0x0) +__uchar 0x17 < 0xe8 == 0x1 (0x1) +__longlong 0x17 < 0x3e8 == 0x1 (0x1) +__ulonglong 0x17 < 0x3e8 == 0x1 (0x1) +float 0x17 < 0x3e8 == 0x1 (0x1) +int 0x17 > 0x3e8 == 0x0 (0x0) +__uint 0x17 > 0x3e8 == 0x0 (0x0) +char 0x17 > 0xffe8 == 0x1 (0x1) +__uchar 0x17 > 0xe8 == 0x0 (0x0) +__longlong 0x17 > 0x3e8 == 0x0 (0x0) +__ulonglong 0x17 > 0x3e8 == 0x0 (0x0) +float 0x17 > 0x3e8 == 0x0 (0x0) +int 0x17 <= 0x3e8 == 0x1 (0x1) +__uint 0x17 <= 0x3e8 == 0x1 (0x1) +char 0x17 <= 0xffe8 == 0x0 (0x0) +__uchar 0x17 <= 0xe8 == 0x1 (0x1) +__longlong 0x17 <= 0x3e8 == 0x1 (0x1) +__ulonglong 0x17 <= 0x3e8 == 0x1 (0x1) +float 0x17 <= 0x3e8 == 0x1 (0x1) +int 0x17 == 0x3e8 == 0x0 (0x0) +__uint 0x17 == 0x3e8 == 0x0 (0x0) +char 0x17 == 0xffe8 == 0x0 (0x0) +__uchar 0x17 == 0xe8 == 0x0 (0x0) +__longlong 0x17 == 0x3e8 == 0x0 (0x0) +__ulonglong 0x17 == 0x3e8 == 0x0 (0x0) +float 0x17 == 0x3e8 == 0x0 (0x0) +int 0x17 != 0x3e8 == 0x1 (0x1) +__uint 0x17 != 0x3e8 == 0x1 (0x1) +char 0x17 != 0xffe8 == 0x1 (0x1) +__uchar 0x17 != 0xe8 == 0x1 (0x1) +__longlong 0x17 != 0x3e8 == 0x1 (0x1) +__ulonglong 0x17 != 0x3e8 == 0x1 (0x1) +float 0x17 != 0x3e8 == 0x1 (0x1) +int 0x17 >= 0x3e8 == 0x0 (0x0) +__uint 0x17 >= 0x3e8 == 0x0 (0x0) +char 0x17 >= 0xffe8 == 0x1 (0x1) +__uchar 0x17 >= 0xe8 == 0x0 (0x0) +__longlong 0x17 >= 0x3e8 == 0x0 (0x0) +__ulonglong 0x17 >= 0x3e8 == 0x0 (0x0) +float 0x17 >= 0x3e8 == 0x0 (0x0) +int 0x17 / 0x3e8 == 0x0 (0x0) +__uint 0x17 / 0x3e8 == 0x0 (0x0) +char 0x17 / 0xffe8 == 0x0 (0x0) +__uchar 0x17 / 0xe8 == 0x0 (0x0) +__longlong 0x17 / 0x3e8 == 0x0 (0x0) +__ulonglong 0x17 / 0x3e8 == 0x0 (0x0) +float 0x17 / 0x3e8 == 0x0 (0x0) +int 0x17 % 0x3e8 == 0x17 (0x17) +__uint 0x17 % 0x3e8 == 0x17 (0x17) +char 0x17 % 0xffe8 == 0x17 (0x17) +__uchar 0x17 % 0xe8 == 0x17 (0x17) +__longlong 0x17 % 0x3e8 == 0x17 (0x17) +__ulonglong 0x17 % 0x3e8 == 0x17 (0x17) +0x17 * 0x2710 == -0x7d90 +0x17 / 0x2710 == 0x0 +0x17 % 0x2710 == 0x17 +int 0x17 ^ 0x2710 == 0x2707 (0x2707) +__uint 0x17 ^ 0x2710 == 0x2707 (0x2707) +char 0x17 ^ 0x10 == 0x7 (0x7) +__uchar 0x17 ^ 0x10 == 0x7 (0x7) +__longlong 0x17 ^ 0x2710 == 0x2707 (0x2707) +__ulonglong 0x17 ^ 0x2710 == 0x2707 (0x2707) +int 0x17 && 0x2710 == 0x1 (0x1) +__uint 0x17 && 0x2710 == 0x1 (0x1) +char 0x17 && 0x10 == 0x1 (0x1) +__uchar 0x17 && 0x10 == 0x1 (0x1) +__longlong 0x17 && 0x2710 == 0x1 (0x1) +__ulonglong 0x17 && 0x2710 == 0x1 (0x1) +int 0x17 || 0x2710 == 0x1 (0x1) +__uint 0x17 || 0x2710 == 0x1 (0x1) +char 0x17 || 0x10 == 0x1 (0x1) +__uchar 0x17 || 0x10 == 0x1 (0x1) +__longlong 0x17 || 0x2710 == 0x1 (0x1) +__ulonglong 0x17 || 0x2710 == 0x1 (0x1) +int 0x17 & 0x2710 == 0x10 (0x10) +__uint 0x17 & 0x2710 == 0x10 (0x10) +char 0x17 & 0x10 == 0x10 (0x10) +__uchar 0x17 & 0x10 == 0x10 (0x10) +__longlong 0x17 & 0x2710 == 0x10 (0x10) +__ulonglong 0x17 & 0x2710 == 0x10 (0x10) +int 0x17 | 0x2710 == 0x2717 (0x2717) +__uint 0x17 | 0x2710 == 0x2717 (0x2717) +char 0x17 | 0x10 == 0x17 (0x17) +__uchar 0x17 | 0x10 == 0x17 (0x17) +__longlong 0x17 | 0x2710 == 0x2717 (0x2717) +__ulonglong 0x17 | 0x2710 == 0x2717 (0x2717) +int 0x17 << 0x16 == 0x0 (0x0) +__uint 0x17 << 0x16 == 0x0 (0x0) +char 0x17 << 0x16 == 0x0 (0x0) +__uchar 0x17 << 0x16 == 0x0 (0x0) +__longlong 0x17 << 0x16 == 0x0 (0x0) +__ulonglong 0x17 << 0x16 == 0x0 (0x0) +int 0x17 >> 0x16 == 0x0 (0x0) +__uint 0x17 >> 0x16 == 0x0 (0x0) +char 0x17 >> 0x16 == 0x0 (0x0) +__uchar 0x17 >> 0x16 == 0x0 (0x0) +__longlong 0x17 >> 0x16 == 0x0 (0x0) +__ulonglong 0x17 >> 0x16 == 0x0 (0x0) +int 0x17 + 0x2710 == 0x2727 (0x2727) +__uint 0x17 + 0x2710 == 0x2727 (0x2727) +char 0x17 + 0x10 == 0x27 (0x27) +__uchar 0x17 + 0x10 == 0x27 (0x27) +__longlong 0x17 + 0x2710 == 0x2727 (0x2727) +__ulonglong 0x17 + 0x2710 == 0x2727 (0x2727) +float 0x17 + 0x2710 == 0x2727 (0x2727) +int 0x17 - 0x2710 == -0x26f9 (0xd907) +__uint 0x17 - 0x2710 == -0x26f9 (0xd907) +char 0x17 - 0x10 == 0x7 (0x7) +__uchar 0x17 - 0x10 == 0x7 (0x7) +__longlong 0x17 - 0x2710 == -0x26f9 (0xd907) +__ulonglong 0x17 - 0x2710 == -0x26f9 (0xd907) +float 0x17 - 0x2710 == -0x26f9 (0xd907) +int 0x17 * 0x2710 == -0x7d90 (0x8270) +__uint 0x17 * 0x2710 == -0x7d90 (0x8270) +char 0x17 * 0x10 == 0x70 (0x70) +__uchar 0x17 * 0x10 == 0x70 (0x70) +__longlong 0x17 * 0x2710 == -0x7d90 (0x8270) +__ulonglong 0x17 * 0x2710 == -0x7d90 (0x8270) +float 0x17 * 0x2710 == -0x7d90 (0x8270) +int 0x17 < 0x2710 == 0x1 (0x1) +__uint 0x17 < 0x2710 == 0x1 (0x1) +char 0x17 < 0x10 == 0x0 (0x0) +__uchar 0x17 < 0x10 == 0x0 (0x0) +__longlong 0x17 < 0x2710 == 0x1 (0x1) +__ulonglong 0x17 < 0x2710 == 0x1 (0x1) +float 0x17 < 0x2710 == 0x1 (0x1) +int 0x17 > 0x2710 == 0x0 (0x0) +__uint 0x17 > 0x2710 == 0x0 (0x0) +char 0x17 > 0x10 == 0x1 (0x1) +__uchar 0x17 > 0x10 == 0x1 (0x1) +__longlong 0x17 > 0x2710 == 0x0 (0x0) +__ulonglong 0x17 > 0x2710 == 0x0 (0x0) +float 0x17 > 0x2710 == 0x0 (0x0) +int 0x17 <= 0x2710 == 0x1 (0x1) +__uint 0x17 <= 0x2710 == 0x1 (0x1) +char 0x17 <= 0x10 == 0x0 (0x0) +__uchar 0x17 <= 0x10 == 0x0 (0x0) +__longlong 0x17 <= 0x2710 == 0x1 (0x1) +__ulonglong 0x17 <= 0x2710 == 0x1 (0x1) +float 0x17 <= 0x2710 == 0x1 (0x1) +int 0x17 == 0x2710 == 0x0 (0x0) +__uint 0x17 == 0x2710 == 0x0 (0x0) +char 0x17 == 0x10 == 0x0 (0x0) +__uchar 0x17 == 0x10 == 0x0 (0x0) +__longlong 0x17 == 0x2710 == 0x0 (0x0) +__ulonglong 0x17 == 0x2710 == 0x0 (0x0) +float 0x17 == 0x2710 == 0x0 (0x0) +int 0x17 != 0x2710 == 0x1 (0x1) +__uint 0x17 != 0x2710 == 0x1 (0x1) +char 0x17 != 0x10 == 0x1 (0x1) +__uchar 0x17 != 0x10 == 0x1 (0x1) +__longlong 0x17 != 0x2710 == 0x1 (0x1) +__ulonglong 0x17 != 0x2710 == 0x1 (0x1) +float 0x17 != 0x2710 == 0x1 (0x1) +int 0x17 >= 0x2710 == 0x0 (0x0) +__uint 0x17 >= 0x2710 == 0x0 (0x0) +char 0x17 >= 0x10 == 0x1 (0x1) +__uchar 0x17 >= 0x10 == 0x1 (0x1) +__longlong 0x17 >= 0x2710 == 0x0 (0x0) +__ulonglong 0x17 >= 0x2710 == 0x0 (0x0) +float 0x17 >= 0x2710 == 0x0 (0x0) +int 0x17 / 0x2710 == 0x0 (0x0) +__uint 0x17 / 0x2710 == 0x0 (0x0) +char 0x17 / 0x10 == 0x1 (0x1) +__uchar 0x17 / 0x10 == 0x1 (0x1) +__longlong 0x17 / 0x2710 == 0x0 (0x0) +__ulonglong 0x17 / 0x2710 == 0x0 (0x0) +float 0x17 / 0x2710 == 0x0 (0x0) +int 0x17 % 0x2710 == 0x17 (0x17) +__uint 0x17 % 0x2710 == 0x17 (0x17) +char 0x17 % 0x10 == 0x7 (0x7) +__uchar 0x17 % 0x10 == 0x7 (0x7) +__longlong 0x17 % 0x2710 == 0x17 (0x17) +__ulonglong 0x17 % 0x2710 == 0x17 (0x17) +int xor420x17 xor42 0x3d +__uint xor420x17 xor42 0x3d +char xor420x17 xor42 0x3d +__uchar xor420x17 xor42 0x3d +__longlong xor420x17 xor42 0x3d +__ulonglong xor420x17 xor42 0x3d +int land10x17 land1 0x1 +__uint land10x17 land1 0x1 +char land10x17 land1 0x1 +__uchar land10x17 land1 0x1 +__longlong land10x17 land1 0x1 +__ulonglong land10x17 land1 0x1 +int lor10x17 lor1 0x1 +__uint lor10x17 lor1 0x1 +char lor10x17 lor1 0x1 +__uchar lor10x17 lor1 0x1 +__longlong lor10x17 lor1 0x1 +__ulonglong lor10x17 lor1 0x1 +int and420x17 and42 0x2 +__uint and420x17 and42 0x2 +char and420x17 and42 0x2 +__uchar and420x17 and42 0x2 +__longlong and420x17 and42 0x2 +__ulonglong and420x17 and42 0x2 +int or420x17 or42 0x3f +__uint or420x17 or42 0x3f +char or420x17 or42 0x3f +__uchar or420x17 or42 0x3f +__longlong or420x17 or42 0x3f +__ulonglong or420x17 or42 0x3f +int shl50x17 shl5 0x2e0 +__uint shl50x17 shl5 0x2e0 +char shl50x17 shl5 -0x20 +__uchar shl50x17 shl5 0xe0 +__longlong shl50x17 shl5 0x2e0 +__ulonglong shl50x17 shl5 0x2e0 +int shr50x17 shr5 0x0 +__uint shr50x17 shr5 0x0 +char shr50x17 shr5 0x0 +__uchar shr50x17 shr5 0x0 +__longlong shr50x17 shr5 0x0 +__ulonglong shr50x17 shr5 0x0 +int add420x17 add42 0x41 +__uint add420x17 add42 0x41 +char add420x17 add42 0x41 +__uchar add420x17 add42 0x41 +__longlong add420x17 add42 0x41 +__ulonglong add420x17 add42 0x41 +float add420x17 add42 0x41 +int sub420x17 sub42 -0x13 +__uint sub420x17 sub42 -0x13 +char sub420x17 sub42 -0x13 +__uchar sub420x17 sub42 0xed +__longlong sub420x17 sub42 -0x13 +__ulonglong sub420x17 sub42 -0x13 +float sub420x17 sub42 -0x13 +int mul420x17 mul42 0x3c6 +__uint mul420x17 mul42 0x3c6 +char mul420x17 mul42 -0x3a +__uchar mul420x17 mul42 0xc6 +__longlong mul420x17 mul42 0x3c6 +__ulonglong mul420x17 mul42 0x3c6 +float mul420x17 mul42 0x3c6 +int lt420x17 lt42 0x1 +__uint lt420x17 lt42 0x1 +char lt420x17 lt42 0x1 +__uchar lt420x17 lt42 0x1 +__longlong lt420x17 lt42 0x1 +__ulonglong lt420x17 lt42 0x1 +float lt420x17 lt42 0x1 +int gt420x17 gt42 0x0 +__uint gt420x17 gt42 0x0 +char gt420x17 gt42 0x0 +__uchar gt420x17 gt42 0x0 +__longlong gt420x17 gt42 0x0 +__ulonglong gt420x17 gt42 0x0 +float gt420x17 gt42 0x0 +int le420x17 le42 0x1 +__uint le420x17 le42 0x1 +char le420x17 le42 0x1 +__uchar le420x17 le42 0x1 +__longlong le420x17 le42 0x1 +__ulonglong le420x17 le42 0x1 +float le420x17 le42 0x1 +int eq420x17 eq42 0x0 +__uint eq420x17 eq42 0x0 +char eq420x17 eq42 0x0 +__uchar eq420x17 eq42 0x0 +__longlong eq420x17 eq42 0x0 +__ulonglong eq420x17 eq42 0x0 +float eq420x17 eq42 0x0 +int ne420x17 ne42 0x1 +__uint ne420x17 ne42 0x1 +char ne420x17 ne42 0x1 +__uchar ne420x17 ne42 0x1 +__longlong ne420x17 ne42 0x1 +__ulonglong ne420x17 ne42 0x1 +float ne420x17 ne42 0x1 +int ge420x17 ge42 0x0 +__uint ge420x17 ge42 0x0 +char ge420x17 ge42 0x0 +__uchar ge420x17 ge42 0x0 +__longlong ge420x17 ge42 0x0 +__ulonglong ge420x17 ge42 0x0 +float ge420x17 ge42 0x0 +int div420x17 div42 0x0 +__uint div420x17 div42 0x0 +char div420x17 div42 0x0 +__uchar div420x17 div42 0x0 +__longlong div420x17 div42 0x0 +__ulonglong div420x17 div42 0x0 +float div420x17 div42 0x0 +int mod230x17 mod23 0x0 +__uint mod230x17 mod23 0x0 +char mod230x17 mod23 0x0 +__uchar mod230x17 mod23 0x0 +__longlong mod230x17 mod23 0x0 +__ulonglong mod230x17 mod23 0x0 +0x7fff * 0xffff == -0x7fff +0x7fff / 0xffff == -0x7fff +0x7fff % 0xffff == 0x0 +int 0x7fff ^ 0xffff == -0x8000 (0x8000) +__uint 0x7fff ^ 0xffff == -0x8000 (0x8000) +char 0xffff ^ 0xffff == 0x0 (0x0) +__uchar 0xff ^ 0xff == 0x0 (0x0) +__longlong 0x7fff ^ 0xffff == -0x8000 (0x8000) +__ulonglong 0x7fff ^ 0xffff == -0x8000 (0x8000) +int 0x7fff && 0xffff == 0x1 (0x1) +__uint 0x7fff && 0xffff == 0x1 (0x1) +char 0xffff && 0xffff == 0x1 (0x1) +__uchar 0xff && 0xff == 0x1 (0x1) +__longlong 0x7fff && 0xffff == 0x1 (0x1) +__ulonglong 0x7fff && 0xffff == 0x1 (0x1) +int 0x7fff || 0xffff == 0x1 (0x1) +__uint 0x7fff || 0xffff == 0x1 (0x1) +char 0xffff || 0xffff == 0x1 (0x1) +__uchar 0xff || 0xff == 0x1 (0x1) +__longlong 0x7fff || 0xffff == 0x1 (0x1) +__ulonglong 0x7fff || 0xffff == 0x1 (0x1) +int 0x7fff & 0xffff == 0x7fff (0x7fff) +__uint 0x7fff & 0xffff == 0x7fff (0x7fff) +char 0xffff & 0xffff == -0x1 (0xffff) +__uchar 0xff & 0xff == 0xff (0xff) +__longlong 0x7fff & 0xffff == 0x7fff (0x7fff) +__ulonglong 0x7fff & 0xffff == 0x7fff (0x7fff) +int 0x7fff | 0xffff == -0x1 (0xffff) +__uint 0x7fff | 0xffff == -0x1 (0xffff) +char 0xffff | 0xffff == -0x1 (0xffff) +__uchar 0xff | 0xff == 0xff (0xff) +__longlong 0x7fff | 0xffff == -0x1 (0xffff) +__ulonglong 0x7fff | 0xffff == -0x1 (0xffff) +int 0x7fff << 0x1 == -0x2 (0xfffe) +__uint 0x7fff << 0x1 == -0x2 (0xfffe) +char 0xffff << 0x1 == -0x2 (0xfffe) +__uchar 0xff << 0x1 == 0xfe (0xfe) +__longlong 0x7fff << 0x1 == -0x2 (0xfffe) +__ulonglong 0x7fff << 0x1 == -0x2 (0xfffe) +int 0x7fff >> 0x1 == 0x3fff (0x3fff) +__uint 0x7fff >> 0x1 == 0x3fff (0x3fff) +char 0xffff >> 0x1 == -0x1 (0xffff) +__uchar 0xff >> 0x1 == 0x7f (0x7f) +__longlong 0x7fff >> 0x1 == 0x3fff (0x3fff) +__ulonglong 0x7fff >> 0x1 == 0x3fff (0x3fff) +int 0x7fff + 0xffff == 0x7ffe (0x7ffe) +__uint 0x7fff + 0xffff == 0x7ffe (0x7ffe) +char 0xffff + 0xffff == -0x2 (0xfffe) +__uchar 0xff + 0xff == 0xfe (0xfe) +__longlong 0x7fff + 0xffff == 0x7ffe (0x7ffe) +__ulonglong 0x7fff + 0xffff == 0x7ffe (0x7ffe) +float 0x7fff + 0xffff == 0x7ffe (0x7ffe) +int 0x7fff - 0xffff == -0x8000 (0x8000) +__uint 0x7fff - 0xffff == -0x8000 (0x8000) +char 0xffff - 0xffff == 0x0 (0x0) +__uchar 0xff - 0xff == 0x0 (0x0) +__longlong 0x7fff - 0xffff == -0x8000 (0x8000) +__ulonglong 0x7fff - 0xffff == -0x8000 (0x8000) +float 0x7fff - 0xffff == -0x8000 (0x8000) +int 0x7fff * 0xffff == -0x7fff (0x8001) +__uint 0x7fff * 0xffff == -0x7fff (0x8001) +char 0xffff * 0xffff == 0x1 (0x1) +__uchar 0xff * 0xff == 0x1 (0x1) +__longlong 0x7fff * 0xffff == -0x7fff (0x8001) +__ulonglong 0x7fff * 0xffff == -0x7fff (0x8001) +float 0x7fff * 0xffff == -0x7fff (0x8001) +int 0x7fff < 0xffff == 0x0 (0x0) +__uint 0x7fff < 0xffff == 0x1 (0x1) +char 0xffff < 0xffff == 0x0 (0x0) +__uchar 0xff < 0xff == 0x0 (0x0) +__longlong 0x7fff < 0xffff == 0x0 (0x0) +__ulonglong 0x7fff < 0xffff == 0x1 (0x1) +float 0x7fff < 0xffff == 0x0 (0x0) +int 0x7fff > 0xffff == 0x1 (0x1) +__uint 0x7fff > 0xffff == 0x0 (0x0) +char 0xffff > 0xffff == 0x0 (0x0) +__uchar 0xff > 0xff == 0x0 (0x0) +__longlong 0x7fff > 0xffff == 0x1 (0x1) +__ulonglong 0x7fff > 0xffff == 0x0 (0x0) +float 0x7fff > 0xffff == 0x1 (0x1) +int 0x7fff <= 0xffff == 0x0 (0x0) +__uint 0x7fff <= 0xffff == 0x1 (0x1) +char 0xffff <= 0xffff == 0x1 (0x1) +__uchar 0xff <= 0xff == 0x1 (0x1) +__longlong 0x7fff <= 0xffff == 0x0 (0x0) +__ulonglong 0x7fff <= 0xffff == 0x1 (0x1) +float 0x7fff <= 0xffff == 0x0 (0x0) +int 0x7fff == 0xffff == 0x0 (0x0) +__uint 0x7fff == 0xffff == 0x0 (0x0) +char 0xffff == 0xffff == 0x1 (0x1) +__uchar 0xff == 0xff == 0x1 (0x1) +__longlong 0x7fff == 0xffff == 0x0 (0x0) +__ulonglong 0x7fff == 0xffff == 0x0 (0x0) +float 0x7fff == 0xffff == 0x0 (0x0) +int 0x7fff != 0xffff == 0x1 (0x1) +__uint 0x7fff != 0xffff == 0x1 (0x1) +char 0xffff != 0xffff == 0x0 (0x0) +__uchar 0xff != 0xff == 0x0 (0x0) +__longlong 0x7fff != 0xffff == 0x1 (0x1) +__ulonglong 0x7fff != 0xffff == 0x1 (0x1) +float 0x7fff != 0xffff == 0x1 (0x1) +int 0x7fff >= 0xffff == 0x1 (0x1) +__uint 0x7fff >= 0xffff == 0x0 (0x0) +char 0xffff >= 0xffff == 0x1 (0x1) +__uchar 0xff >= 0xff == 0x1 (0x1) +__longlong 0x7fff >= 0xffff == 0x1 (0x1) +__ulonglong 0x7fff >= 0xffff == 0x0 (0x0) +float 0x7fff >= 0xffff == 0x1 (0x1) +int 0x7fff / 0xffff == -0x7fff (0x8001) +__uint 0x7fff / 0xffff == 0x0 (0x0) +char 0xffff / 0xffff == 0x1 (0x1) +__uchar 0xff / 0xff == 0x1 (0x1) +__longlong 0x7fff / 0xffff == -0x7fff (0x8001) +__ulonglong 0x7fff / 0xffff == 0x0 (0x0) +float 0x7fff / 0xffff == -0x7fff (0x8001) +int 0x7fff % 0xffff == 0x0 (0x0) +__uint 0x7fff % 0xffff == 0x7fff (0x7fff) +char 0xffff % 0xffff == 0x0 (0x0) +__uchar 0xff % 0xff == 0x0 (0x0) +__longlong 0x7fff % 0xffff == 0x0 (0x0) +__ulonglong 0x7fff % 0xffff == 0x7fff (0x7fff) +0x7fff * 0x1 == 0x7fff +0x7fff / 0x1 == 0x7fff +0x7fff % 0x1 == 0x0 +int 0x7fff ^ 0x1 == 0x7ffe (0x7ffe) +__uint 0x7fff ^ 0x1 == 0x7ffe (0x7ffe) +char 0xffff ^ 0x1 == -0x2 (0xfffe) +__uchar 0xff ^ 0x1 == 0xfe (0xfe) +__longlong 0x7fff ^ 0x1 == 0x7ffe (0x7ffe) +__ulonglong 0x7fff ^ 0x1 == 0x7ffe (0x7ffe) +int 0x7fff && 0x1 == 0x1 (0x1) +__uint 0x7fff && 0x1 == 0x1 (0x1) +char 0xffff && 0x1 == 0x1 (0x1) +__uchar 0xff && 0x1 == 0x1 (0x1) +__longlong 0x7fff && 0x1 == 0x1 (0x1) +__ulonglong 0x7fff && 0x1 == 0x1 (0x1) +int 0x7fff || 0x1 == 0x1 (0x1) +__uint 0x7fff || 0x1 == 0x1 (0x1) +char 0xffff || 0x1 == 0x1 (0x1) +__uchar 0xff || 0x1 == 0x1 (0x1) +__longlong 0x7fff || 0x1 == 0x1 (0x1) +__ulonglong 0x7fff || 0x1 == 0x1 (0x1) +int 0x7fff & 0x1 == 0x1 (0x1) +__uint 0x7fff & 0x1 == 0x1 (0x1) +char 0xffff & 0x1 == 0x1 (0x1) +__uchar 0xff & 0x1 == 0x1 (0x1) +__longlong 0x7fff & 0x1 == 0x1 (0x1) +__ulonglong 0x7fff & 0x1 == 0x1 (0x1) +int 0x7fff | 0x1 == 0x7fff (0x7fff) +__uint 0x7fff | 0x1 == 0x7fff (0x7fff) +char 0xffff | 0x1 == -0x1 (0xffff) +__uchar 0xff | 0x1 == 0xff (0xff) +__longlong 0x7fff | 0x1 == 0x7fff (0x7fff) +__ulonglong 0x7fff | 0x1 == 0x7fff (0x7fff) +int 0x7fff << 0x2 == -0x4 (0xfffc) +__uint 0x7fff << 0x2 == -0x4 (0xfffc) +char 0xffff << 0x2 == -0x4 (0xfffc) +__uchar 0xff << 0x2 == 0xfc (0xfc) +__longlong 0x7fff << 0x2 == -0x4 (0xfffc) +__ulonglong 0x7fff << 0x2 == -0x4 (0xfffc) +int 0x7fff >> 0x2 == 0x1fff (0x1fff) +__uint 0x7fff >> 0x2 == 0x1fff (0x1fff) +char 0xffff >> 0x2 == -0x1 (0xffff) +__uchar 0xff >> 0x2 == 0x3f (0x3f) +__longlong 0x7fff >> 0x2 == 0x1fff (0x1fff) +__ulonglong 0x7fff >> 0x2 == 0x1fff (0x1fff) +int 0x7fff + 0x1 == -0x8000 (0x8000) +__uint 0x7fff + 0x1 == -0x8000 (0x8000) +char 0xffff + 0x1 == 0x0 (0x0) +__uchar 0xff + 0x1 == 0x0 (0x0) +__longlong 0x7fff + 0x1 == -0x8000 (0x8000) +__ulonglong 0x7fff + 0x1 == -0x8000 (0x8000) +float 0x7fff + 0x1 == -0x8000 (0x8000) +int 0x7fff - 0x1 == 0x7ffe (0x7ffe) +__uint 0x7fff - 0x1 == 0x7ffe (0x7ffe) +char 0xffff - 0x1 == -0x2 (0xfffe) +__uchar 0xff - 0x1 == 0xfe (0xfe) +__longlong 0x7fff - 0x1 == 0x7ffe (0x7ffe) +__ulonglong 0x7fff - 0x1 == 0x7ffe (0x7ffe) +float 0x7fff - 0x1 == 0x7ffe (0x7ffe) +int 0x7fff * 0x1 == 0x7fff (0x7fff) +__uint 0x7fff * 0x1 == 0x7fff (0x7fff) +char 0xffff * 0x1 == -0x1 (0xffff) +__uchar 0xff * 0x1 == 0xff (0xff) +__longlong 0x7fff * 0x1 == 0x7fff (0x7fff) +__ulonglong 0x7fff * 0x1 == 0x7fff (0x7fff) +float 0x7fff * 0x1 == 0x7fff (0x7fff) +int 0x7fff < 0x1 == 0x0 (0x0) +__uint 0x7fff < 0x1 == 0x0 (0x0) +char 0xffff < 0x1 == 0x1 (0x1) +__uchar 0xff < 0x1 == 0x0 (0x0) +__longlong 0x7fff < 0x1 == 0x0 (0x0) +__ulonglong 0x7fff < 0x1 == 0x0 (0x0) +float 0x7fff < 0x1 == 0x0 (0x0) +int 0x7fff > 0x1 == 0x1 (0x1) +__uint 0x7fff > 0x1 == 0x1 (0x1) +char 0xffff > 0x1 == 0x0 (0x0) +__uchar 0xff > 0x1 == 0x1 (0x1) +__longlong 0x7fff > 0x1 == 0x1 (0x1) +__ulonglong 0x7fff > 0x1 == 0x1 (0x1) +float 0x7fff > 0x1 == 0x1 (0x1) +int 0x7fff <= 0x1 == 0x0 (0x0) +__uint 0x7fff <= 0x1 == 0x0 (0x0) +char 0xffff <= 0x1 == 0x1 (0x1) +__uchar 0xff <= 0x1 == 0x0 (0x0) +__longlong 0x7fff <= 0x1 == 0x0 (0x0) +__ulonglong 0x7fff <= 0x1 == 0x0 (0x0) +float 0x7fff <= 0x1 == 0x0 (0x0) +int 0x7fff == 0x1 == 0x0 (0x0) +__uint 0x7fff == 0x1 == 0x0 (0x0) +char 0xffff == 0x1 == 0x0 (0x0) +__uchar 0xff == 0x1 == 0x0 (0x0) +__longlong 0x7fff == 0x1 == 0x0 (0x0) +__ulonglong 0x7fff == 0x1 == 0x0 (0x0) +float 0x7fff == 0x1 == 0x0 (0x0) +int 0x7fff != 0x1 == 0x1 (0x1) +__uint 0x7fff != 0x1 == 0x1 (0x1) +char 0xffff != 0x1 == 0x1 (0x1) +__uchar 0xff != 0x1 == 0x1 (0x1) +__longlong 0x7fff != 0x1 == 0x1 (0x1) +__ulonglong 0x7fff != 0x1 == 0x1 (0x1) +float 0x7fff != 0x1 == 0x1 (0x1) +int 0x7fff >= 0x1 == 0x1 (0x1) +__uint 0x7fff >= 0x1 == 0x1 (0x1) +char 0xffff >= 0x1 == 0x0 (0x0) +__uchar 0xff >= 0x1 == 0x1 (0x1) +__longlong 0x7fff >= 0x1 == 0x1 (0x1) +__ulonglong 0x7fff >= 0x1 == 0x1 (0x1) +float 0x7fff >= 0x1 == 0x1 (0x1) +int 0x7fff / 0x1 == 0x7fff (0x7fff) +__uint 0x7fff / 0x1 == 0x7fff (0x7fff) +char 0xffff / 0x1 == -0x1 (0xffff) +__uchar 0xff / 0x1 == 0xff (0xff) +__longlong 0x7fff / 0x1 == 0x7fff (0x7fff) +__ulonglong 0x7fff / 0x1 == 0x7fff (0x7fff) +float 0x7fff / 0x1 == 0x7fff (0x7fff) +int 0x7fff % 0x1 == 0x0 (0x0) +__uint 0x7fff % 0x1 == 0x0 (0x0) +char 0xffff % 0x1 == 0x0 (0x0) +__uchar 0xff % 0x1 == 0x0 (0x0) +__longlong 0x7fff % 0x1 == 0x0 (0x0) +__ulonglong 0x7fff % 0x1 == 0x0 (0x0) +0x7fff * 0x2 == -0x2 +0x7fff / 0x2 == 0x3fff +0x7fff % 0x2 == 0x1 +int 0x7fff ^ 0x2 == 0x7ffd (0x7ffd) +__uint 0x7fff ^ 0x2 == 0x7ffd (0x7ffd) +char 0xffff ^ 0x2 == -0x3 (0xfffd) +__uchar 0xff ^ 0x2 == 0xfd (0xfd) +__longlong 0x7fff ^ 0x2 == 0x7ffd (0x7ffd) +__ulonglong 0x7fff ^ 0x2 == 0x7ffd (0x7ffd) +int 0x7fff && 0x2 == 0x1 (0x1) +__uint 0x7fff && 0x2 == 0x1 (0x1) +char 0xffff && 0x2 == 0x1 (0x1) +__uchar 0xff && 0x2 == 0x1 (0x1) +__longlong 0x7fff && 0x2 == 0x1 (0x1) +__ulonglong 0x7fff && 0x2 == 0x1 (0x1) +int 0x7fff || 0x2 == 0x1 (0x1) +__uint 0x7fff || 0x2 == 0x1 (0x1) +char 0xffff || 0x2 == 0x1 (0x1) +__uchar 0xff || 0x2 == 0x1 (0x1) +__longlong 0x7fff || 0x2 == 0x1 (0x1) +__ulonglong 0x7fff || 0x2 == 0x1 (0x1) +int 0x7fff & 0x2 == 0x2 (0x2) +__uint 0x7fff & 0x2 == 0x2 (0x2) +char 0xffff & 0x2 == 0x2 (0x2) +__uchar 0xff & 0x2 == 0x2 (0x2) +__longlong 0x7fff & 0x2 == 0x2 (0x2) +__ulonglong 0x7fff & 0x2 == 0x2 (0x2) +int 0x7fff | 0x2 == 0x7fff (0x7fff) +__uint 0x7fff | 0x2 == 0x7fff (0x7fff) +char 0xffff | 0x2 == -0x1 (0xffff) +__uchar 0xff | 0x2 == 0xff (0xff) +__longlong 0x7fff | 0x2 == 0x7fff (0x7fff) +__ulonglong 0x7fff | 0x2 == 0x7fff (0x7fff) +int 0x7fff << 0x3 == -0x8 (0xfff8) +__uint 0x7fff << 0x3 == -0x8 (0xfff8) +char 0xffff << 0x3 == -0x8 (0xfff8) +__uchar 0xff << 0x3 == 0xf8 (0xf8) +__longlong 0x7fff << 0x3 == -0x8 (0xfff8) +__ulonglong 0x7fff << 0x3 == -0x8 (0xfff8) +int 0x7fff >> 0x3 == 0xfff (0xfff) +__uint 0x7fff >> 0x3 == 0xfff (0xfff) +char 0xffff >> 0x3 == -0x1 (0xffff) +__uchar 0xff >> 0x3 == 0x1f (0x1f) +__longlong 0x7fff >> 0x3 == 0xfff (0xfff) +__ulonglong 0x7fff >> 0x3 == 0xfff (0xfff) +int 0x7fff + 0x2 == -0x7fff (0x8001) +__uint 0x7fff + 0x2 == -0x7fff (0x8001) +char 0xffff + 0x2 == 0x1 (0x1) +__uchar 0xff + 0x2 == 0x1 (0x1) +__longlong 0x7fff + 0x2 == -0x7fff (0x8001) +__ulonglong 0x7fff + 0x2 == -0x7fff (0x8001) +float 0x7fff + 0x2 == -0x7fff (0x8001) +int 0x7fff - 0x2 == 0x7ffd (0x7ffd) +__uint 0x7fff - 0x2 == 0x7ffd (0x7ffd) +char 0xffff - 0x2 == -0x3 (0xfffd) +__uchar 0xff - 0x2 == 0xfd (0xfd) +__longlong 0x7fff - 0x2 == 0x7ffd (0x7ffd) +__ulonglong 0x7fff - 0x2 == 0x7ffd (0x7ffd) +float 0x7fff - 0x2 == 0x7ffd (0x7ffd) +int 0x7fff * 0x2 == -0x2 (0xfffe) +__uint 0x7fff * 0x2 == -0x2 (0xfffe) +char 0xffff * 0x2 == -0x2 (0xfffe) +__uchar 0xff * 0x2 == 0xfe (0xfe) +__longlong 0x7fff * 0x2 == -0x2 (0xfffe) +__ulonglong 0x7fff * 0x2 == -0x2 (0xfffe) +float 0x7fff * 0x2 == -0x2 (0xfffe) +int 0x7fff < 0x2 == 0x0 (0x0) +__uint 0x7fff < 0x2 == 0x0 (0x0) +char 0xffff < 0x2 == 0x1 (0x1) +__uchar 0xff < 0x2 == 0x0 (0x0) +__longlong 0x7fff < 0x2 == 0x0 (0x0) +__ulonglong 0x7fff < 0x2 == 0x0 (0x0) +float 0x7fff < 0x2 == 0x0 (0x0) +int 0x7fff > 0x2 == 0x1 (0x1) +__uint 0x7fff > 0x2 == 0x1 (0x1) +char 0xffff > 0x2 == 0x0 (0x0) +__uchar 0xff > 0x2 == 0x1 (0x1) +__longlong 0x7fff > 0x2 == 0x1 (0x1) +__ulonglong 0x7fff > 0x2 == 0x1 (0x1) +float 0x7fff > 0x2 == 0x1 (0x1) +int 0x7fff <= 0x2 == 0x0 (0x0) +__uint 0x7fff <= 0x2 == 0x0 (0x0) +char 0xffff <= 0x2 == 0x1 (0x1) +__uchar 0xff <= 0x2 == 0x0 (0x0) +__longlong 0x7fff <= 0x2 == 0x0 (0x0) +__ulonglong 0x7fff <= 0x2 == 0x0 (0x0) +float 0x7fff <= 0x2 == 0x0 (0x0) +int 0x7fff == 0x2 == 0x0 (0x0) +__uint 0x7fff == 0x2 == 0x0 (0x0) +char 0xffff == 0x2 == 0x0 (0x0) +__uchar 0xff == 0x2 == 0x0 (0x0) +__longlong 0x7fff == 0x2 == 0x0 (0x0) +__ulonglong 0x7fff == 0x2 == 0x0 (0x0) +float 0x7fff == 0x2 == 0x0 (0x0) +int 0x7fff != 0x2 == 0x1 (0x1) +__uint 0x7fff != 0x2 == 0x1 (0x1) +char 0xffff != 0x2 == 0x1 (0x1) +__uchar 0xff != 0x2 == 0x1 (0x1) +__longlong 0x7fff != 0x2 == 0x1 (0x1) +__ulonglong 0x7fff != 0x2 == 0x1 (0x1) +float 0x7fff != 0x2 == 0x1 (0x1) +int 0x7fff >= 0x2 == 0x1 (0x1) +__uint 0x7fff >= 0x2 == 0x1 (0x1) +char 0xffff >= 0x2 == 0x0 (0x0) +__uchar 0xff >= 0x2 == 0x1 (0x1) +__longlong 0x7fff >= 0x2 == 0x1 (0x1) +__ulonglong 0x7fff >= 0x2 == 0x1 (0x1) +float 0x7fff >= 0x2 == 0x1 (0x1) +int 0x7fff / 0x2 == 0x3fff (0x3fff) +__uint 0x7fff / 0x2 == 0x3fff (0x3fff) +char 0xffff / 0x2 == 0x0 (0x0) +__uchar 0xff / 0x2 == 0x7f (0x7f) +__longlong 0x7fff / 0x2 == 0x3fff (0x3fff) +__ulonglong 0x7fff / 0x2 == 0x3fff (0x3fff) +float 0x7fff / 0x2 == 0x3fff (0x3fff) +int 0x7fff % 0x2 == 0x1 (0x1) +__uint 0x7fff % 0x2 == 0x1 (0x1) +char 0xffff % 0x2 == -0x1 (0xffff) +__uchar 0xff % 0x2 == 0x1 (0x1) +__longlong 0x7fff % 0x2 == 0x1 (0x1) +__ulonglong 0x7fff % 0x2 == 0x1 (0x1) +0x7fff * 0xfffe == 0x2 +0x7fff / 0xfffe == -0x3fff +0x7fff % 0xfffe == 0x1 +int 0x7fff ^ 0xfffe == -0x7fff (0x8001) +__uint 0x7fff ^ 0xfffe == -0x7fff (0x8001) +char 0xffff ^ 0xfffe == 0x1 (0x1) +__uchar 0xff ^ 0xfe == 0x1 (0x1) +__longlong 0x7fff ^ 0xfffe == -0x7fff (0x8001) +__ulonglong 0x7fff ^ 0xfffe == -0x7fff (0x8001) +int 0x7fff && 0xfffe == 0x1 (0x1) +__uint 0x7fff && 0xfffe == 0x1 (0x1) +char 0xffff && 0xfffe == 0x1 (0x1) +__uchar 0xff && 0xfe == 0x1 (0x1) +__longlong 0x7fff && 0xfffe == 0x1 (0x1) +__ulonglong 0x7fff && 0xfffe == 0x1 (0x1) +int 0x7fff || 0xfffe == 0x1 (0x1) +__uint 0x7fff || 0xfffe == 0x1 (0x1) +char 0xffff || 0xfffe == 0x1 (0x1) +__uchar 0xff || 0xfe == 0x1 (0x1) +__longlong 0x7fff || 0xfffe == 0x1 (0x1) +__ulonglong 0x7fff || 0xfffe == 0x1 (0x1) +int 0x7fff & 0xfffe == 0x7ffe (0x7ffe) +__uint 0x7fff & 0xfffe == 0x7ffe (0x7ffe) +char 0xffff & 0xfffe == -0x2 (0xfffe) +__uchar 0xff & 0xfe == 0xfe (0xfe) +__longlong 0x7fff & 0xfffe == 0x7ffe (0x7ffe) +__ulonglong 0x7fff & 0xfffe == 0x7ffe (0x7ffe) +int 0x7fff | 0xfffe == -0x1 (0xffff) +__uint 0x7fff | 0xfffe == -0x1 (0xffff) +char 0xffff | 0xfffe == -0x1 (0xffff) +__uchar 0xff | 0xfe == 0xff (0xff) +__longlong 0x7fff | 0xfffe == -0x1 (0xffff) +__ulonglong 0x7fff | 0xfffe == -0x1 (0xffff) +int 0x7fff << 0x4 == -0x10 (0xfff0) +__uint 0x7fff << 0x4 == -0x10 (0xfff0) +char 0xffff << 0x4 == -0x10 (0xfff0) +__uchar 0xff << 0x4 == 0xf0 (0xf0) +__longlong 0x7fff << 0x4 == -0x10 (0xfff0) +__ulonglong 0x7fff << 0x4 == -0x10 (0xfff0) +int 0x7fff >> 0x4 == 0x7ff (0x7ff) +__uint 0x7fff >> 0x4 == 0x7ff (0x7ff) +char 0xffff >> 0x4 == -0x1 (0xffff) +__uchar 0xff >> 0x4 == 0xf (0xf) +__longlong 0x7fff >> 0x4 == 0x7ff (0x7ff) +__ulonglong 0x7fff >> 0x4 == 0x7ff (0x7ff) +int 0x7fff + 0xfffe == 0x7ffd (0x7ffd) +__uint 0x7fff + 0xfffe == 0x7ffd (0x7ffd) +char 0xffff + 0xfffe == -0x3 (0xfffd) +__uchar 0xff + 0xfe == 0xfd (0xfd) +__longlong 0x7fff + 0xfffe == 0x7ffd (0x7ffd) +__ulonglong 0x7fff + 0xfffe == 0x7ffd (0x7ffd) +float 0x7fff + 0xfffe == 0x7ffd (0x7ffd) +int 0x7fff - 0xfffe == -0x7fff (0x8001) +__uint 0x7fff - 0xfffe == -0x7fff (0x8001) +char 0xffff - 0xfffe == 0x1 (0x1) +__uchar 0xff - 0xfe == 0x1 (0x1) +__longlong 0x7fff - 0xfffe == -0x7fff (0x8001) +__ulonglong 0x7fff - 0xfffe == -0x7fff (0x8001) +float 0x7fff - 0xfffe == -0x7fff (0x8001) +int 0x7fff * 0xfffe == 0x2 (0x2) +__uint 0x7fff * 0xfffe == 0x2 (0x2) +char 0xffff * 0xfffe == 0x2 (0x2) +__uchar 0xff * 0xfe == 0x2 (0x2) +__longlong 0x7fff * 0xfffe == 0x2 (0x2) +__ulonglong 0x7fff * 0xfffe == 0x2 (0x2) +float 0x7fff * 0xfffe == 0x2 (0x2) +int 0x7fff < 0xfffe == 0x0 (0x0) +__uint 0x7fff < 0xfffe == 0x1 (0x1) +char 0xffff < 0xfffe == 0x0 (0x0) +__uchar 0xff < 0xfe == 0x0 (0x0) +__longlong 0x7fff < 0xfffe == 0x0 (0x0) +__ulonglong 0x7fff < 0xfffe == 0x1 (0x1) +float 0x7fff < 0xfffe == 0x0 (0x0) +int 0x7fff > 0xfffe == 0x1 (0x1) +__uint 0x7fff > 0xfffe == 0x0 (0x0) +char 0xffff > 0xfffe == 0x1 (0x1) +__uchar 0xff > 0xfe == 0x1 (0x1) +__longlong 0x7fff > 0xfffe == 0x1 (0x1) +__ulonglong 0x7fff > 0xfffe == 0x0 (0x0) +float 0x7fff > 0xfffe == 0x1 (0x1) +int 0x7fff <= 0xfffe == 0x0 (0x0) +__uint 0x7fff <= 0xfffe == 0x1 (0x1) +char 0xffff <= 0xfffe == 0x0 (0x0) +__uchar 0xff <= 0xfe == 0x0 (0x0) +__longlong 0x7fff <= 0xfffe == 0x0 (0x0) +__ulonglong 0x7fff <= 0xfffe == 0x1 (0x1) +float 0x7fff <= 0xfffe == 0x0 (0x0) +int 0x7fff == 0xfffe == 0x0 (0x0) +__uint 0x7fff == 0xfffe == 0x0 (0x0) +char 0xffff == 0xfffe == 0x0 (0x0) +__uchar 0xff == 0xfe == 0x0 (0x0) +__longlong 0x7fff == 0xfffe == 0x0 (0x0) +__ulonglong 0x7fff == 0xfffe == 0x0 (0x0) +float 0x7fff == 0xfffe == 0x0 (0x0) +int 0x7fff != 0xfffe == 0x1 (0x1) +__uint 0x7fff != 0xfffe == 0x1 (0x1) +char 0xffff != 0xfffe == 0x1 (0x1) +__uchar 0xff != 0xfe == 0x1 (0x1) +__longlong 0x7fff != 0xfffe == 0x1 (0x1) +__ulonglong 0x7fff != 0xfffe == 0x1 (0x1) +float 0x7fff != 0xfffe == 0x1 (0x1) +int 0x7fff >= 0xfffe == 0x1 (0x1) +__uint 0x7fff >= 0xfffe == 0x0 (0x0) +char 0xffff >= 0xfffe == 0x1 (0x1) +__uchar 0xff >= 0xfe == 0x1 (0x1) +__longlong 0x7fff >= 0xfffe == 0x1 (0x1) +__ulonglong 0x7fff >= 0xfffe == 0x0 (0x0) +float 0x7fff >= 0xfffe == 0x1 (0x1) +int 0x7fff / 0xfffe == -0x3fff (0xc001) +__uint 0x7fff / 0xfffe == 0x0 (0x0) +char 0xffff / 0xfffe == 0x0 (0x0) +__uchar 0xff / 0xfe == 0x1 (0x1) +__longlong 0x7fff / 0xfffe == -0x3fff (0xc001) +__ulonglong 0x7fff / 0xfffe == 0x0 (0x0) +float 0x7fff / 0xfffe == -0x3fff (0xc001) +int 0x7fff % 0xfffe == 0x1 (0x1) +__uint 0x7fff % 0xfffe == 0x7fff (0x7fff) +char 0xffff % 0xfffe == -0x1 (0xffff) +__uchar 0xff % 0xfe == 0x1 (0x1) +__longlong 0x7fff % 0xfffe == 0x1 (0x1) +__ulonglong 0x7fff % 0xfffe == 0x7fff (0x7fff) +0x7fff * 0x4 == -0x4 +0x7fff / 0x4 == 0x1fff +0x7fff % 0x4 == 0x3 +int 0x7fff ^ 0x4 == 0x7ffb (0x7ffb) +__uint 0x7fff ^ 0x4 == 0x7ffb (0x7ffb) +char 0xffff ^ 0x4 == -0x5 (0xfffb) +__uchar 0xff ^ 0x4 == 0xfb (0xfb) +__longlong 0x7fff ^ 0x4 == 0x7ffb (0x7ffb) +__ulonglong 0x7fff ^ 0x4 == 0x7ffb (0x7ffb) +int 0x7fff && 0x4 == 0x1 (0x1) +__uint 0x7fff && 0x4 == 0x1 (0x1) +char 0xffff && 0x4 == 0x1 (0x1) +__uchar 0xff && 0x4 == 0x1 (0x1) +__longlong 0x7fff && 0x4 == 0x1 (0x1) +__ulonglong 0x7fff && 0x4 == 0x1 (0x1) +int 0x7fff || 0x4 == 0x1 (0x1) +__uint 0x7fff || 0x4 == 0x1 (0x1) +char 0xffff || 0x4 == 0x1 (0x1) +__uchar 0xff || 0x4 == 0x1 (0x1) +__longlong 0x7fff || 0x4 == 0x1 (0x1) +__ulonglong 0x7fff || 0x4 == 0x1 (0x1) +int 0x7fff & 0x4 == 0x4 (0x4) +__uint 0x7fff & 0x4 == 0x4 (0x4) +char 0xffff & 0x4 == 0x4 (0x4) +__uchar 0xff & 0x4 == 0x4 (0x4) +__longlong 0x7fff & 0x4 == 0x4 (0x4) +__ulonglong 0x7fff & 0x4 == 0x4 (0x4) +int 0x7fff | 0x4 == 0x7fff (0x7fff) +__uint 0x7fff | 0x4 == 0x7fff (0x7fff) +char 0xffff | 0x4 == -0x1 (0xffff) +__uchar 0xff | 0x4 == 0xff (0xff) +__longlong 0x7fff | 0x4 == 0x7fff (0x7fff) +__ulonglong 0x7fff | 0x4 == 0x7fff (0x7fff) +int 0x7fff << 0x5 == -0x20 (0xffe0) +__uint 0x7fff << 0x5 == -0x20 (0xffe0) +char 0xffff << 0x5 == -0x20 (0xffe0) +__uchar 0xff << 0x5 == 0xe0 (0xe0) +__longlong 0x7fff << 0x5 == -0x20 (0xffe0) +__ulonglong 0x7fff << 0x5 == -0x20 (0xffe0) +int 0x7fff >> 0x5 == 0x3ff (0x3ff) +__uint 0x7fff >> 0x5 == 0x3ff (0x3ff) +char 0xffff >> 0x5 == -0x1 (0xffff) +__uchar 0xff >> 0x5 == 0x7 (0x7) +__longlong 0x7fff >> 0x5 == 0x3ff (0x3ff) +__ulonglong 0x7fff >> 0x5 == 0x3ff (0x3ff) +int 0x7fff + 0x4 == -0x7ffd (0x8003) +__uint 0x7fff + 0x4 == -0x7ffd (0x8003) +char 0xffff + 0x4 == 0x3 (0x3) +__uchar 0xff + 0x4 == 0x3 (0x3) +__longlong 0x7fff + 0x4 == -0x7ffd (0x8003) +__ulonglong 0x7fff + 0x4 == -0x7ffd (0x8003) +float 0x7fff + 0x4 == -0x7ffd (0x8003) +int 0x7fff - 0x4 == 0x7ffb (0x7ffb) +__uint 0x7fff - 0x4 == 0x7ffb (0x7ffb) +char 0xffff - 0x4 == -0x5 (0xfffb) +__uchar 0xff - 0x4 == 0xfb (0xfb) +__longlong 0x7fff - 0x4 == 0x7ffb (0x7ffb) +__ulonglong 0x7fff - 0x4 == 0x7ffb (0x7ffb) +float 0x7fff - 0x4 == 0x7ffb (0x7ffb) +int 0x7fff * 0x4 == -0x4 (0xfffc) +__uint 0x7fff * 0x4 == -0x4 (0xfffc) +char 0xffff * 0x4 == -0x4 (0xfffc) +__uchar 0xff * 0x4 == 0xfc (0xfc) +__longlong 0x7fff * 0x4 == -0x4 (0xfffc) +__ulonglong 0x7fff * 0x4 == -0x4 (0xfffc) +float 0x7fff * 0x4 == -0x4 (0xfffc) +int 0x7fff < 0x4 == 0x0 (0x0) +__uint 0x7fff < 0x4 == 0x0 (0x0) +char 0xffff < 0x4 == 0x1 (0x1) +__uchar 0xff < 0x4 == 0x0 (0x0) +__longlong 0x7fff < 0x4 == 0x0 (0x0) +__ulonglong 0x7fff < 0x4 == 0x0 (0x0) +float 0x7fff < 0x4 == 0x0 (0x0) +int 0x7fff > 0x4 == 0x1 (0x1) +__uint 0x7fff > 0x4 == 0x1 (0x1) +char 0xffff > 0x4 == 0x0 (0x0) +__uchar 0xff > 0x4 == 0x1 (0x1) +__longlong 0x7fff > 0x4 == 0x1 (0x1) +__ulonglong 0x7fff > 0x4 == 0x1 (0x1) +float 0x7fff > 0x4 == 0x1 (0x1) +int 0x7fff <= 0x4 == 0x0 (0x0) +__uint 0x7fff <= 0x4 == 0x0 (0x0) +char 0xffff <= 0x4 == 0x1 (0x1) +__uchar 0xff <= 0x4 == 0x0 (0x0) +__longlong 0x7fff <= 0x4 == 0x0 (0x0) +__ulonglong 0x7fff <= 0x4 == 0x0 (0x0) +float 0x7fff <= 0x4 == 0x0 (0x0) +int 0x7fff == 0x4 == 0x0 (0x0) +__uint 0x7fff == 0x4 == 0x0 (0x0) +char 0xffff == 0x4 == 0x0 (0x0) +__uchar 0xff == 0x4 == 0x0 (0x0) +__longlong 0x7fff == 0x4 == 0x0 (0x0) +__ulonglong 0x7fff == 0x4 == 0x0 (0x0) +float 0x7fff == 0x4 == 0x0 (0x0) +int 0x7fff != 0x4 == 0x1 (0x1) +__uint 0x7fff != 0x4 == 0x1 (0x1) +char 0xffff != 0x4 == 0x1 (0x1) +__uchar 0xff != 0x4 == 0x1 (0x1) +__longlong 0x7fff != 0x4 == 0x1 (0x1) +__ulonglong 0x7fff != 0x4 == 0x1 (0x1) +float 0x7fff != 0x4 == 0x1 (0x1) +int 0x7fff >= 0x4 == 0x1 (0x1) +__uint 0x7fff >= 0x4 == 0x1 (0x1) +char 0xffff >= 0x4 == 0x0 (0x0) +__uchar 0xff >= 0x4 == 0x1 (0x1) +__longlong 0x7fff >= 0x4 == 0x1 (0x1) +__ulonglong 0x7fff >= 0x4 == 0x1 (0x1) +float 0x7fff >= 0x4 == 0x1 (0x1) +int 0x7fff / 0x4 == 0x1fff (0x1fff) +__uint 0x7fff / 0x4 == 0x1fff (0x1fff) +char 0xffff / 0x4 == 0x0 (0x0) +__uchar 0xff / 0x4 == 0x3f (0x3f) +__longlong 0x7fff / 0x4 == 0x1fff (0x1fff) +__ulonglong 0x7fff / 0x4 == 0x1fff (0x1fff) +float 0x7fff / 0x4 == 0x1fff (0x1fff) +int 0x7fff % 0x4 == 0x3 (0x3) +__uint 0x7fff % 0x4 == 0x3 (0x3) +char 0xffff % 0x4 == -0x1 (0xffff) +__uchar 0xff % 0x4 == 0x3 (0x3) +__longlong 0x7fff % 0x4 == 0x3 (0x3) +__ulonglong 0x7fff % 0x4 == 0x3 (0x3) +0x7fff * 0xfffc == 0x4 +0x7fff / 0xfffc == -0x1fff +0x7fff % 0xfffc == 0x3 +int 0x7fff ^ 0xfffc == -0x7ffd (0x8003) +__uint 0x7fff ^ 0xfffc == -0x7ffd (0x8003) +char 0xffff ^ 0xfffc == 0x3 (0x3) +__uchar 0xff ^ 0xfc == 0x3 (0x3) +__longlong 0x7fff ^ 0xfffc == -0x7ffd (0x8003) +__ulonglong 0x7fff ^ 0xfffc == -0x7ffd (0x8003) +int 0x7fff && 0xfffc == 0x1 (0x1) +__uint 0x7fff && 0xfffc == 0x1 (0x1) +char 0xffff && 0xfffc == 0x1 (0x1) +__uchar 0xff && 0xfc == 0x1 (0x1) +__longlong 0x7fff && 0xfffc == 0x1 (0x1) +__ulonglong 0x7fff && 0xfffc == 0x1 (0x1) +int 0x7fff || 0xfffc == 0x1 (0x1) +__uint 0x7fff || 0xfffc == 0x1 (0x1) +char 0xffff || 0xfffc == 0x1 (0x1) +__uchar 0xff || 0xfc == 0x1 (0x1) +__longlong 0x7fff || 0xfffc == 0x1 (0x1) +__ulonglong 0x7fff || 0xfffc == 0x1 (0x1) +int 0x7fff & 0xfffc == 0x7ffc (0x7ffc) +__uint 0x7fff & 0xfffc == 0x7ffc (0x7ffc) +char 0xffff & 0xfffc == -0x4 (0xfffc) +__uchar 0xff & 0xfc == 0xfc (0xfc) +__longlong 0x7fff & 0xfffc == 0x7ffc (0x7ffc) +__ulonglong 0x7fff & 0xfffc == 0x7ffc (0x7ffc) +int 0x7fff | 0xfffc == -0x1 (0xffff) +__uint 0x7fff | 0xfffc == -0x1 (0xffff) +char 0xffff | 0xfffc == -0x1 (0xffff) +__uchar 0xff | 0xfc == 0xff (0xff) +__longlong 0x7fff | 0xfffc == -0x1 (0xffff) +__ulonglong 0x7fff | 0xfffc == -0x1 (0xffff) +int 0x7fff << 0x6 == -0x40 (0xffc0) +__uint 0x7fff << 0x6 == -0x40 (0xffc0) +char 0xffff << 0x6 == -0x40 (0xffc0) +__uchar 0xff << 0x6 == 0xc0 (0xc0) +__longlong 0x7fff << 0x6 == -0x40 (0xffc0) +__ulonglong 0x7fff << 0x6 == -0x40 (0xffc0) +int 0x7fff >> 0x6 == 0x1ff (0x1ff) +__uint 0x7fff >> 0x6 == 0x1ff (0x1ff) +char 0xffff >> 0x6 == -0x1 (0xffff) +__uchar 0xff >> 0x6 == 0x3 (0x3) +__longlong 0x7fff >> 0x6 == 0x1ff (0x1ff) +__ulonglong 0x7fff >> 0x6 == 0x1ff (0x1ff) +int 0x7fff + 0xfffc == 0x7ffb (0x7ffb) +__uint 0x7fff + 0xfffc == 0x7ffb (0x7ffb) +char 0xffff + 0xfffc == -0x5 (0xfffb) +__uchar 0xff + 0xfc == 0xfb (0xfb) +__longlong 0x7fff + 0xfffc == 0x7ffb (0x7ffb) +__ulonglong 0x7fff + 0xfffc == 0x7ffb (0x7ffb) +float 0x7fff + 0xfffc == 0x7ffb (0x7ffb) +int 0x7fff - 0xfffc == -0x7ffd (0x8003) +__uint 0x7fff - 0xfffc == -0x7ffd (0x8003) +char 0xffff - 0xfffc == 0x3 (0x3) +__uchar 0xff - 0xfc == 0x3 (0x3) +__longlong 0x7fff - 0xfffc == -0x7ffd (0x8003) +__ulonglong 0x7fff - 0xfffc == -0x7ffd (0x8003) +float 0x7fff - 0xfffc == -0x7ffd (0x8003) +int 0x7fff * 0xfffc == 0x4 (0x4) +__uint 0x7fff * 0xfffc == 0x4 (0x4) +char 0xffff * 0xfffc == 0x4 (0x4) +__uchar 0xff * 0xfc == 0x4 (0x4) +__longlong 0x7fff * 0xfffc == 0x4 (0x4) +__ulonglong 0x7fff * 0xfffc == 0x4 (0x4) +float 0x7fff * 0xfffc == 0x4 (0x4) +int 0x7fff < 0xfffc == 0x0 (0x0) +__uint 0x7fff < 0xfffc == 0x1 (0x1) +char 0xffff < 0xfffc == 0x0 (0x0) +__uchar 0xff < 0xfc == 0x0 (0x0) +__longlong 0x7fff < 0xfffc == 0x0 (0x0) +__ulonglong 0x7fff < 0xfffc == 0x1 (0x1) +float 0x7fff < 0xfffc == 0x0 (0x0) +int 0x7fff > 0xfffc == 0x1 (0x1) +__uint 0x7fff > 0xfffc == 0x0 (0x0) +char 0xffff > 0xfffc == 0x1 (0x1) +__uchar 0xff > 0xfc == 0x1 (0x1) +__longlong 0x7fff > 0xfffc == 0x1 (0x1) +__ulonglong 0x7fff > 0xfffc == 0x0 (0x0) +float 0x7fff > 0xfffc == 0x1 (0x1) +int 0x7fff <= 0xfffc == 0x0 (0x0) +__uint 0x7fff <= 0xfffc == 0x1 (0x1) +char 0xffff <= 0xfffc == 0x0 (0x0) +__uchar 0xff <= 0xfc == 0x0 (0x0) +__longlong 0x7fff <= 0xfffc == 0x0 (0x0) +__ulonglong 0x7fff <= 0xfffc == 0x1 (0x1) +float 0x7fff <= 0xfffc == 0x0 (0x0) +int 0x7fff == 0xfffc == 0x0 (0x0) +__uint 0x7fff == 0xfffc == 0x0 (0x0) +char 0xffff == 0xfffc == 0x0 (0x0) +__uchar 0xff == 0xfc == 0x0 (0x0) +__longlong 0x7fff == 0xfffc == 0x0 (0x0) +__ulonglong 0x7fff == 0xfffc == 0x0 (0x0) +float 0x7fff == 0xfffc == 0x0 (0x0) +int 0x7fff != 0xfffc == 0x1 (0x1) +__uint 0x7fff != 0xfffc == 0x1 (0x1) +char 0xffff != 0xfffc == 0x1 (0x1) +__uchar 0xff != 0xfc == 0x1 (0x1) +__longlong 0x7fff != 0xfffc == 0x1 (0x1) +__ulonglong 0x7fff != 0xfffc == 0x1 (0x1) +float 0x7fff != 0xfffc == 0x1 (0x1) +int 0x7fff >= 0xfffc == 0x1 (0x1) +__uint 0x7fff >= 0xfffc == 0x0 (0x0) +char 0xffff >= 0xfffc == 0x1 (0x1) +__uchar 0xff >= 0xfc == 0x1 (0x1) +__longlong 0x7fff >= 0xfffc == 0x1 (0x1) +__ulonglong 0x7fff >= 0xfffc == 0x0 (0x0) +float 0x7fff >= 0xfffc == 0x1 (0x1) +int 0x7fff / 0xfffc == -0x1fff (0xe001) +__uint 0x7fff / 0xfffc == 0x0 (0x0) +char 0xffff / 0xfffc == 0x0 (0x0) +__uchar 0xff / 0xfc == 0x1 (0x1) +__longlong 0x7fff / 0xfffc == -0x1fff (0xe001) +__ulonglong 0x7fff / 0xfffc == 0x0 (0x0) +float 0x7fff / 0xfffc == -0x1fff (0xe001) +int 0x7fff % 0xfffc == 0x3 (0x3) +__uint 0x7fff % 0xfffc == 0x7fff (0x7fff) +char 0xffff % 0xfffc == -0x1 (0xffff) +__uchar 0xff % 0xfc == 0x3 (0x3) +__longlong 0x7fff % 0xfffc == 0x3 (0x3) +__ulonglong 0x7fff % 0xfffc == 0x7fff (0x7fff) +0x7fff * 0xa == -0xa +0x7fff / 0xa == 0xccc +0x7fff % 0xa == 0x7 +int 0x7fff ^ 0xa == 0x7ff5 (0x7ff5) +__uint 0x7fff ^ 0xa == 0x7ff5 (0x7ff5) +char 0xffff ^ 0xa == -0xb (0xfff5) +__uchar 0xff ^ 0xa == 0xf5 (0xf5) +__longlong 0x7fff ^ 0xa == 0x7ff5 (0x7ff5) +__ulonglong 0x7fff ^ 0xa == 0x7ff5 (0x7ff5) +int 0x7fff && 0xa == 0x1 (0x1) +__uint 0x7fff && 0xa == 0x1 (0x1) +char 0xffff && 0xa == 0x1 (0x1) +__uchar 0xff && 0xa == 0x1 (0x1) +__longlong 0x7fff && 0xa == 0x1 (0x1) +__ulonglong 0x7fff && 0xa == 0x1 (0x1) +int 0x7fff || 0xa == 0x1 (0x1) +__uint 0x7fff || 0xa == 0x1 (0x1) +char 0xffff || 0xa == 0x1 (0x1) +__uchar 0xff || 0xa == 0x1 (0x1) +__longlong 0x7fff || 0xa == 0x1 (0x1) +__ulonglong 0x7fff || 0xa == 0x1 (0x1) +int 0x7fff & 0xa == 0xa (0xa) +__uint 0x7fff & 0xa == 0xa (0xa) +char 0xffff & 0xa == 0xa (0xa) +__uchar 0xff & 0xa == 0xa (0xa) +__longlong 0x7fff & 0xa == 0xa (0xa) +__ulonglong 0x7fff & 0xa == 0xa (0xa) +int 0x7fff | 0xa == 0x7fff (0x7fff) +__uint 0x7fff | 0xa == 0x7fff (0x7fff) +char 0xffff | 0xa == -0x1 (0xffff) +__uchar 0xff | 0xa == 0xff (0xff) +__longlong 0x7fff | 0xa == 0x7fff (0x7fff) +__ulonglong 0x7fff | 0xa == 0x7fff (0x7fff) +int 0x7fff << 0x7 == -0x80 (0xff80) +__uint 0x7fff << 0x7 == -0x80 (0xff80) +char 0xffff << 0x7 == -0x80 (0xff80) +__uchar 0xff << 0x7 == 0x80 (0x80) +__longlong 0x7fff << 0x7 == -0x80 (0xff80) +__ulonglong 0x7fff << 0x7 == -0x80 (0xff80) +int 0x7fff >> 0x7 == 0xff (0xff) +__uint 0x7fff >> 0x7 == 0xff (0xff) +char 0xffff >> 0x7 == -0x1 (0xffff) +__uchar 0xff >> 0x7 == 0x1 (0x1) +__longlong 0x7fff >> 0x7 == 0xff (0xff) +__ulonglong 0x7fff >> 0x7 == 0xff (0xff) +int 0x7fff + 0xa == -0x7ff7 (0x8009) +__uint 0x7fff + 0xa == -0x7ff7 (0x8009) +char 0xffff + 0xa == 0x9 (0x9) +__uchar 0xff + 0xa == 0x9 (0x9) +__longlong 0x7fff + 0xa == -0x7ff7 (0x8009) +__ulonglong 0x7fff + 0xa == -0x7ff7 (0x8009) +float 0x7fff + 0xa == -0x7ff7 (0x8009) +int 0x7fff - 0xa == 0x7ff5 (0x7ff5) +__uint 0x7fff - 0xa == 0x7ff5 (0x7ff5) +char 0xffff - 0xa == -0xb (0xfff5) +__uchar 0xff - 0xa == 0xf5 (0xf5) +__longlong 0x7fff - 0xa == 0x7ff5 (0x7ff5) +__ulonglong 0x7fff - 0xa == 0x7ff5 (0x7ff5) +float 0x7fff - 0xa == 0x7ff5 (0x7ff5) +int 0x7fff * 0xa == -0xa (0xfff6) +__uint 0x7fff * 0xa == -0xa (0xfff6) +char 0xffff * 0xa == -0xa (0xfff6) +__uchar 0xff * 0xa == 0xf6 (0xf6) +__longlong 0x7fff * 0xa == -0xa (0xfff6) +__ulonglong 0x7fff * 0xa == -0xa (0xfff6) +float 0x7fff * 0xa == -0xa (0xfff6) +int 0x7fff < 0xa == 0x0 (0x0) +__uint 0x7fff < 0xa == 0x0 (0x0) +char 0xffff < 0xa == 0x1 (0x1) +__uchar 0xff < 0xa == 0x0 (0x0) +__longlong 0x7fff < 0xa == 0x0 (0x0) +__ulonglong 0x7fff < 0xa == 0x0 (0x0) +float 0x7fff < 0xa == 0x0 (0x0) +int 0x7fff > 0xa == 0x1 (0x1) +__uint 0x7fff > 0xa == 0x1 (0x1) +char 0xffff > 0xa == 0x0 (0x0) +__uchar 0xff > 0xa == 0x1 (0x1) +__longlong 0x7fff > 0xa == 0x1 (0x1) +__ulonglong 0x7fff > 0xa == 0x1 (0x1) +float 0x7fff > 0xa == 0x1 (0x1) +int 0x7fff <= 0xa == 0x0 (0x0) +__uint 0x7fff <= 0xa == 0x0 (0x0) +char 0xffff <= 0xa == 0x1 (0x1) +__uchar 0xff <= 0xa == 0x0 (0x0) +__longlong 0x7fff <= 0xa == 0x0 (0x0) +__ulonglong 0x7fff <= 0xa == 0x0 (0x0) +float 0x7fff <= 0xa == 0x0 (0x0) +int 0x7fff == 0xa == 0x0 (0x0) +__uint 0x7fff == 0xa == 0x0 (0x0) +char 0xffff == 0xa == 0x0 (0x0) +__uchar 0xff == 0xa == 0x0 (0x0) +__longlong 0x7fff == 0xa == 0x0 (0x0) +__ulonglong 0x7fff == 0xa == 0x0 (0x0) +float 0x7fff == 0xa == 0x0 (0x0) +int 0x7fff != 0xa == 0x1 (0x1) +__uint 0x7fff != 0xa == 0x1 (0x1) +char 0xffff != 0xa == 0x1 (0x1) +__uchar 0xff != 0xa == 0x1 (0x1) +__longlong 0x7fff != 0xa == 0x1 (0x1) +__ulonglong 0x7fff != 0xa == 0x1 (0x1) +float 0x7fff != 0xa == 0x1 (0x1) +int 0x7fff >= 0xa == 0x1 (0x1) +__uint 0x7fff >= 0xa == 0x1 (0x1) +char 0xffff >= 0xa == 0x0 (0x0) +__uchar 0xff >= 0xa == 0x1 (0x1) +__longlong 0x7fff >= 0xa == 0x1 (0x1) +__ulonglong 0x7fff >= 0xa == 0x1 (0x1) +float 0x7fff >= 0xa == 0x1 (0x1) +int 0x7fff / 0xa == 0xccc (0xccc) +__uint 0x7fff / 0xa == 0xccc (0xccc) +char 0xffff / 0xa == 0x0 (0x0) +__uchar 0xff / 0xa == 0x19 (0x19) +__longlong 0x7fff / 0xa == 0xccc (0xccc) +__ulonglong 0x7fff / 0xa == 0xccc (0xccc) +float 0x7fff / 0xa == 0xccc (0xccc) +int 0x7fff % 0xa == 0x7 (0x7) +__uint 0x7fff % 0xa == 0x7 (0x7) +char 0xffff % 0xa == -0x1 (0xffff) +__uchar 0xff % 0xa == 0x5 (0x5) +__longlong 0x7fff % 0xa == 0x7 (0x7) +__ulonglong 0x7fff % 0xa == 0x7 (0x7) +0x7fff * 0xfff6 == 0xa +0x7fff / 0xfff6 == -0xccc +0x7fff % 0xfff6 == 0x7 +int 0x7fff ^ 0xfff6 == -0x7ff7 (0x8009) +__uint 0x7fff ^ 0xfff6 == -0x7ff7 (0x8009) +char 0xffff ^ 0xfff6 == 0x9 (0x9) +__uchar 0xff ^ 0xf6 == 0x9 (0x9) +__longlong 0x7fff ^ 0xfff6 == -0x7ff7 (0x8009) +__ulonglong 0x7fff ^ 0xfff6 == -0x7ff7 (0x8009) +int 0x7fff && 0xfff6 == 0x1 (0x1) +__uint 0x7fff && 0xfff6 == 0x1 (0x1) +char 0xffff && 0xfff6 == 0x1 (0x1) +__uchar 0xff && 0xf6 == 0x1 (0x1) +__longlong 0x7fff && 0xfff6 == 0x1 (0x1) +__ulonglong 0x7fff && 0xfff6 == 0x1 (0x1) +int 0x7fff || 0xfff6 == 0x1 (0x1) +__uint 0x7fff || 0xfff6 == 0x1 (0x1) +char 0xffff || 0xfff6 == 0x1 (0x1) +__uchar 0xff || 0xf6 == 0x1 (0x1) +__longlong 0x7fff || 0xfff6 == 0x1 (0x1) +__ulonglong 0x7fff || 0xfff6 == 0x1 (0x1) +int 0x7fff & 0xfff6 == 0x7ff6 (0x7ff6) +__uint 0x7fff & 0xfff6 == 0x7ff6 (0x7ff6) +char 0xffff & 0xfff6 == -0xa (0xfff6) +__uchar 0xff & 0xf6 == 0xf6 (0xf6) +__longlong 0x7fff & 0xfff6 == 0x7ff6 (0x7ff6) +__ulonglong 0x7fff & 0xfff6 == 0x7ff6 (0x7ff6) +int 0x7fff | 0xfff6 == -0x1 (0xffff) +__uint 0x7fff | 0xfff6 == -0x1 (0xffff) +char 0xffff | 0xfff6 == -0x1 (0xffff) +__uchar 0xff | 0xf6 == 0xff (0xff) +__longlong 0x7fff | 0xfff6 == -0x1 (0xffff) +__ulonglong 0x7fff | 0xfff6 == -0x1 (0xffff) +int 0x7fff << 0x8 == -0x100 (0xff00) +__uint 0x7fff << 0x8 == -0x100 (0xff00) +char 0xffff << 0x8 == 0x0 (0x0) +__uchar 0xff << 0x8 == 0x0 (0x0) +__longlong 0x7fff << 0x8 == -0x100 (0xff00) +__ulonglong 0x7fff << 0x8 == -0x100 (0xff00) +int 0x7fff >> 0x8 == 0x7f (0x7f) +__uint 0x7fff >> 0x8 == 0x7f (0x7f) +char 0xffff >> 0x8 == -0x1 (0xffff) +__uchar 0xff >> 0x8 == 0x0 (0x0) +__longlong 0x7fff >> 0x8 == 0x7f (0x7f) +__ulonglong 0x7fff >> 0x8 == 0x7f (0x7f) +int 0x7fff + 0xfff6 == 0x7ff5 (0x7ff5) +__uint 0x7fff + 0xfff6 == 0x7ff5 (0x7ff5) +char 0xffff + 0xfff6 == -0xb (0xfff5) +__uchar 0xff + 0xf6 == 0xf5 (0xf5) +__longlong 0x7fff + 0xfff6 == 0x7ff5 (0x7ff5) +__ulonglong 0x7fff + 0xfff6 == 0x7ff5 (0x7ff5) +float 0x7fff + 0xfff6 == 0x7ff5 (0x7ff5) +int 0x7fff - 0xfff6 == -0x7ff7 (0x8009) +__uint 0x7fff - 0xfff6 == -0x7ff7 (0x8009) +char 0xffff - 0xfff6 == 0x9 (0x9) +__uchar 0xff - 0xf6 == 0x9 (0x9) +__longlong 0x7fff - 0xfff6 == -0x7ff7 (0x8009) +__ulonglong 0x7fff - 0xfff6 == -0x7ff7 (0x8009) +float 0x7fff - 0xfff6 == -0x7ff7 (0x8009) +int 0x7fff * 0xfff6 == 0xa (0xa) +__uint 0x7fff * 0xfff6 == 0xa (0xa) +char 0xffff * 0xfff6 == 0xa (0xa) +__uchar 0xff * 0xf6 == 0xa (0xa) +__longlong 0x7fff * 0xfff6 == 0xa (0xa) +__ulonglong 0x7fff * 0xfff6 == 0xa (0xa) +float 0x7fff * 0xfff6 == 0xa (0xa) +int 0x7fff < 0xfff6 == 0x0 (0x0) +__uint 0x7fff < 0xfff6 == 0x1 (0x1) +char 0xffff < 0xfff6 == 0x0 (0x0) +__uchar 0xff < 0xf6 == 0x0 (0x0) +__longlong 0x7fff < 0xfff6 == 0x0 (0x0) +__ulonglong 0x7fff < 0xfff6 == 0x1 (0x1) +float 0x7fff < 0xfff6 == 0x0 (0x0) +int 0x7fff > 0xfff6 == 0x1 (0x1) +__uint 0x7fff > 0xfff6 == 0x0 (0x0) +char 0xffff > 0xfff6 == 0x1 (0x1) +__uchar 0xff > 0xf6 == 0x1 (0x1) +__longlong 0x7fff > 0xfff6 == 0x1 (0x1) +__ulonglong 0x7fff > 0xfff6 == 0x0 (0x0) +float 0x7fff > 0xfff6 == 0x1 (0x1) +int 0x7fff <= 0xfff6 == 0x0 (0x0) +__uint 0x7fff <= 0xfff6 == 0x1 (0x1) +char 0xffff <= 0xfff6 == 0x0 (0x0) +__uchar 0xff <= 0xf6 == 0x0 (0x0) +__longlong 0x7fff <= 0xfff6 == 0x0 (0x0) +__ulonglong 0x7fff <= 0xfff6 == 0x1 (0x1) +float 0x7fff <= 0xfff6 == 0x0 (0x0) +int 0x7fff == 0xfff6 == 0x0 (0x0) +__uint 0x7fff == 0xfff6 == 0x0 (0x0) +char 0xffff == 0xfff6 == 0x0 (0x0) +__uchar 0xff == 0xf6 == 0x0 (0x0) +__longlong 0x7fff == 0xfff6 == 0x0 (0x0) +__ulonglong 0x7fff == 0xfff6 == 0x0 (0x0) +float 0x7fff == 0xfff6 == 0x0 (0x0) +int 0x7fff != 0xfff6 == 0x1 (0x1) +__uint 0x7fff != 0xfff6 == 0x1 (0x1) +char 0xffff != 0xfff6 == 0x1 (0x1) +__uchar 0xff != 0xf6 == 0x1 (0x1) +__longlong 0x7fff != 0xfff6 == 0x1 (0x1) +__ulonglong 0x7fff != 0xfff6 == 0x1 (0x1) +float 0x7fff != 0xfff6 == 0x1 (0x1) +int 0x7fff >= 0xfff6 == 0x1 (0x1) +__uint 0x7fff >= 0xfff6 == 0x0 (0x0) +char 0xffff >= 0xfff6 == 0x1 (0x1) +__uchar 0xff >= 0xf6 == 0x1 (0x1) +__longlong 0x7fff >= 0xfff6 == 0x1 (0x1) +__ulonglong 0x7fff >= 0xfff6 == 0x0 (0x0) +float 0x7fff >= 0xfff6 == 0x1 (0x1) +int 0x7fff / 0xfff6 == -0xccc (0xf334) +__uint 0x7fff / 0xfff6 == 0x0 (0x0) +char 0xffff / 0xfff6 == 0x0 (0x0) +__uchar 0xff / 0xf6 == 0x1 (0x1) +__longlong 0x7fff / 0xfff6 == -0xccc (0xf334) +__ulonglong 0x7fff / 0xfff6 == 0x0 (0x0) +float 0x7fff / 0xfff6 == -0xccc (0xf334) +int 0x7fff % 0xfff6 == 0x7 (0x7) +__uint 0x7fff % 0xfff6 == 0x7fff (0x7fff) +char 0xffff % 0xfff6 == -0x1 (0xffff) +__uchar 0xff % 0xf6 == 0x9 (0x9) +__longlong 0x7fff % 0xfff6 == 0x7 (0x7) +__ulonglong 0x7fff % 0xfff6 == 0x7fff (0x7fff) +0x7fff * 0x5 == 0x7ffb +0x7fff / 0x5 == 0x1999 +0x7fff % 0x5 == 0x2 +int 0x7fff ^ 0x5 == 0x7ffa (0x7ffa) +__uint 0x7fff ^ 0x5 == 0x7ffa (0x7ffa) +char 0xffff ^ 0x5 == -0x6 (0xfffa) +__uchar 0xff ^ 0x5 == 0xfa (0xfa) +__longlong 0x7fff ^ 0x5 == 0x7ffa (0x7ffa) +__ulonglong 0x7fff ^ 0x5 == 0x7ffa (0x7ffa) +int 0x7fff && 0x5 == 0x1 (0x1) +__uint 0x7fff && 0x5 == 0x1 (0x1) +char 0xffff && 0x5 == 0x1 (0x1) +__uchar 0xff && 0x5 == 0x1 (0x1) +__longlong 0x7fff && 0x5 == 0x1 (0x1) +__ulonglong 0x7fff && 0x5 == 0x1 (0x1) +int 0x7fff || 0x5 == 0x1 (0x1) +__uint 0x7fff || 0x5 == 0x1 (0x1) +char 0xffff || 0x5 == 0x1 (0x1) +__uchar 0xff || 0x5 == 0x1 (0x1) +__longlong 0x7fff || 0x5 == 0x1 (0x1) +__ulonglong 0x7fff || 0x5 == 0x1 (0x1) +int 0x7fff & 0x5 == 0x5 (0x5) +__uint 0x7fff & 0x5 == 0x5 (0x5) +char 0xffff & 0x5 == 0x5 (0x5) +__uchar 0xff & 0x5 == 0x5 (0x5) +__longlong 0x7fff & 0x5 == 0x5 (0x5) +__ulonglong 0x7fff & 0x5 == 0x5 (0x5) +int 0x7fff | 0x5 == 0x7fff (0x7fff) +__uint 0x7fff | 0x5 == 0x7fff (0x7fff) +char 0xffff | 0x5 == -0x1 (0xffff) +__uchar 0xff | 0x5 == 0xff (0xff) +__longlong 0x7fff | 0x5 == 0x7fff (0x7fff) +__ulonglong 0x7fff | 0x5 == 0x7fff (0x7fff) +int 0x7fff << 0x9 == -0x200 (0xfe00) +__uint 0x7fff << 0x9 == -0x200 (0xfe00) +char 0xffff << 0x9 == 0x0 (0x0) +__uchar 0xff << 0x9 == 0x0 (0x0) +__longlong 0x7fff << 0x9 == -0x200 (0xfe00) +__ulonglong 0x7fff << 0x9 == -0x200 (0xfe00) +int 0x7fff >> 0x9 == 0x3f (0x3f) +__uint 0x7fff >> 0x9 == 0x3f (0x3f) +char 0xffff >> 0x9 == -0x1 (0xffff) +__uchar 0xff >> 0x9 == 0x0 (0x0) +__longlong 0x7fff >> 0x9 == 0x3f (0x3f) +__ulonglong 0x7fff >> 0x9 == 0x3f (0x3f) +int 0x7fff + 0x5 == -0x7ffc (0x8004) +__uint 0x7fff + 0x5 == -0x7ffc (0x8004) +char 0xffff + 0x5 == 0x4 (0x4) +__uchar 0xff + 0x5 == 0x4 (0x4) +__longlong 0x7fff + 0x5 == -0x7ffc (0x8004) +__ulonglong 0x7fff + 0x5 == -0x7ffc (0x8004) +float 0x7fff + 0x5 == -0x7ffc (0x8004) +int 0x7fff - 0x5 == 0x7ffa (0x7ffa) +__uint 0x7fff - 0x5 == 0x7ffa (0x7ffa) +char 0xffff - 0x5 == -0x6 (0xfffa) +__uchar 0xff - 0x5 == 0xfa (0xfa) +__longlong 0x7fff - 0x5 == 0x7ffa (0x7ffa) +__ulonglong 0x7fff - 0x5 == 0x7ffa (0x7ffa) +float 0x7fff - 0x5 == 0x7ffa (0x7ffa) +int 0x7fff * 0x5 == 0x7ffb (0x7ffb) +__uint 0x7fff * 0x5 == 0x7ffb (0x7ffb) +char 0xffff * 0x5 == -0x5 (0xfffb) +__uchar 0xff * 0x5 == 0xfb (0xfb) +__longlong 0x7fff * 0x5 == 0x7ffb (0x7ffb) +__ulonglong 0x7fff * 0x5 == 0x7ffb (0x7ffb) +float 0x7fff * 0x5 == 0x7ffb (0x7ffb) +int 0x7fff < 0x5 == 0x0 (0x0) +__uint 0x7fff < 0x5 == 0x0 (0x0) +char 0xffff < 0x5 == 0x1 (0x1) +__uchar 0xff < 0x5 == 0x0 (0x0) +__longlong 0x7fff < 0x5 == 0x0 (0x0) +__ulonglong 0x7fff < 0x5 == 0x0 (0x0) +float 0x7fff < 0x5 == 0x0 (0x0) +int 0x7fff > 0x5 == 0x1 (0x1) +__uint 0x7fff > 0x5 == 0x1 (0x1) +char 0xffff > 0x5 == 0x0 (0x0) +__uchar 0xff > 0x5 == 0x1 (0x1) +__longlong 0x7fff > 0x5 == 0x1 (0x1) +__ulonglong 0x7fff > 0x5 == 0x1 (0x1) +float 0x7fff > 0x5 == 0x1 (0x1) +int 0x7fff <= 0x5 == 0x0 (0x0) +__uint 0x7fff <= 0x5 == 0x0 (0x0) +char 0xffff <= 0x5 == 0x1 (0x1) +__uchar 0xff <= 0x5 == 0x0 (0x0) +__longlong 0x7fff <= 0x5 == 0x0 (0x0) +__ulonglong 0x7fff <= 0x5 == 0x0 (0x0) +float 0x7fff <= 0x5 == 0x0 (0x0) +int 0x7fff == 0x5 == 0x0 (0x0) +__uint 0x7fff == 0x5 == 0x0 (0x0) +char 0xffff == 0x5 == 0x0 (0x0) +__uchar 0xff == 0x5 == 0x0 (0x0) +__longlong 0x7fff == 0x5 == 0x0 (0x0) +__ulonglong 0x7fff == 0x5 == 0x0 (0x0) +float 0x7fff == 0x5 == 0x0 (0x0) +int 0x7fff != 0x5 == 0x1 (0x1) +__uint 0x7fff != 0x5 == 0x1 (0x1) +char 0xffff != 0x5 == 0x1 (0x1) +__uchar 0xff != 0x5 == 0x1 (0x1) +__longlong 0x7fff != 0x5 == 0x1 (0x1) +__ulonglong 0x7fff != 0x5 == 0x1 (0x1) +float 0x7fff != 0x5 == 0x1 (0x1) +int 0x7fff >= 0x5 == 0x1 (0x1) +__uint 0x7fff >= 0x5 == 0x1 (0x1) +char 0xffff >= 0x5 == 0x0 (0x0) +__uchar 0xff >= 0x5 == 0x1 (0x1) +__longlong 0x7fff >= 0x5 == 0x1 (0x1) +__ulonglong 0x7fff >= 0x5 == 0x1 (0x1) +float 0x7fff >= 0x5 == 0x1 (0x1) +int 0x7fff / 0x5 == 0x1999 (0x1999) +__uint 0x7fff / 0x5 == 0x1999 (0x1999) +char 0xffff / 0x5 == 0x0 (0x0) +__uchar 0xff / 0x5 == 0x33 (0x33) +__longlong 0x7fff / 0x5 == 0x1999 (0x1999) +__ulonglong 0x7fff / 0x5 == 0x1999 (0x1999) +float 0x7fff / 0x5 == 0x1999 (0x1999) +int 0x7fff % 0x5 == 0x2 (0x2) +__uint 0x7fff % 0x5 == 0x2 (0x2) +char 0xffff % 0x5 == -0x1 (0xffff) +__uchar 0xff % 0x5 == 0x0 (0x0) +__longlong 0x7fff % 0x5 == 0x2 (0x2) +__ulonglong 0x7fff % 0x5 == 0x2 (0x2) +0x7fff * 0x7 == 0x7ff9 +0x7fff / 0x7 == 0x1249 +0x7fff % 0x7 == 0x0 +int 0x7fff ^ 0x7 == 0x7ff8 (0x7ff8) +__uint 0x7fff ^ 0x7 == 0x7ff8 (0x7ff8) +char 0xffff ^ 0x7 == -0x8 (0xfff8) +__uchar 0xff ^ 0x7 == 0xf8 (0xf8) +__longlong 0x7fff ^ 0x7 == 0x7ff8 (0x7ff8) +__ulonglong 0x7fff ^ 0x7 == 0x7ff8 (0x7ff8) +int 0x7fff && 0x7 == 0x1 (0x1) +__uint 0x7fff && 0x7 == 0x1 (0x1) +char 0xffff && 0x7 == 0x1 (0x1) +__uchar 0xff && 0x7 == 0x1 (0x1) +__longlong 0x7fff && 0x7 == 0x1 (0x1) +__ulonglong 0x7fff && 0x7 == 0x1 (0x1) +int 0x7fff || 0x7 == 0x1 (0x1) +__uint 0x7fff || 0x7 == 0x1 (0x1) +char 0xffff || 0x7 == 0x1 (0x1) +__uchar 0xff || 0x7 == 0x1 (0x1) +__longlong 0x7fff || 0x7 == 0x1 (0x1) +__ulonglong 0x7fff || 0x7 == 0x1 (0x1) +int 0x7fff & 0x7 == 0x7 (0x7) +__uint 0x7fff & 0x7 == 0x7 (0x7) +char 0xffff & 0x7 == 0x7 (0x7) +__uchar 0xff & 0x7 == 0x7 (0x7) +__longlong 0x7fff & 0x7 == 0x7 (0x7) +__ulonglong 0x7fff & 0x7 == 0x7 (0x7) +int 0x7fff | 0x7 == 0x7fff (0x7fff) +__uint 0x7fff | 0x7 == 0x7fff (0x7fff) +char 0xffff | 0x7 == -0x1 (0xffff) +__uchar 0xff | 0x7 == 0xff (0xff) +__longlong 0x7fff | 0x7 == 0x7fff (0x7fff) +__ulonglong 0x7fff | 0x7 == 0x7fff (0x7fff) +int 0x7fff << 0xa == -0x400 (0xfc00) +__uint 0x7fff << 0xa == -0x400 (0xfc00) +char 0xffff << 0xa == 0x0 (0x0) +__uchar 0xff << 0xa == 0x0 (0x0) +__longlong 0x7fff << 0xa == -0x400 (0xfc00) +__ulonglong 0x7fff << 0xa == -0x400 (0xfc00) +int 0x7fff >> 0xa == 0x1f (0x1f) +__uint 0x7fff >> 0xa == 0x1f (0x1f) +char 0xffff >> 0xa == -0x1 (0xffff) +__uchar 0xff >> 0xa == 0x0 (0x0) +__longlong 0x7fff >> 0xa == 0x1f (0x1f) +__ulonglong 0x7fff >> 0xa == 0x1f (0x1f) +int 0x7fff + 0x7 == -0x7ffa (0x8006) +__uint 0x7fff + 0x7 == -0x7ffa (0x8006) +char 0xffff + 0x7 == 0x6 (0x6) +__uchar 0xff + 0x7 == 0x6 (0x6) +__longlong 0x7fff + 0x7 == -0x7ffa (0x8006) +__ulonglong 0x7fff + 0x7 == -0x7ffa (0x8006) +float 0x7fff + 0x7 == -0x7ffa (0x8006) +int 0x7fff - 0x7 == 0x7ff8 (0x7ff8) +__uint 0x7fff - 0x7 == 0x7ff8 (0x7ff8) +char 0xffff - 0x7 == -0x8 (0xfff8) +__uchar 0xff - 0x7 == 0xf8 (0xf8) +__longlong 0x7fff - 0x7 == 0x7ff8 (0x7ff8) +__ulonglong 0x7fff - 0x7 == 0x7ff8 (0x7ff8) +float 0x7fff - 0x7 == 0x7ff8 (0x7ff8) +int 0x7fff * 0x7 == 0x7ff9 (0x7ff9) +__uint 0x7fff * 0x7 == 0x7ff9 (0x7ff9) +char 0xffff * 0x7 == -0x7 (0xfff9) +__uchar 0xff * 0x7 == 0xf9 (0xf9) +__longlong 0x7fff * 0x7 == 0x7ff9 (0x7ff9) +__ulonglong 0x7fff * 0x7 == 0x7ff9 (0x7ff9) +float 0x7fff * 0x7 == 0x7ff9 (0x7ff9) +int 0x7fff < 0x7 == 0x0 (0x0) +__uint 0x7fff < 0x7 == 0x0 (0x0) +char 0xffff < 0x7 == 0x1 (0x1) +__uchar 0xff < 0x7 == 0x0 (0x0) +__longlong 0x7fff < 0x7 == 0x0 (0x0) +__ulonglong 0x7fff < 0x7 == 0x0 (0x0) +float 0x7fff < 0x7 == 0x0 (0x0) +int 0x7fff > 0x7 == 0x1 (0x1) +__uint 0x7fff > 0x7 == 0x1 (0x1) +char 0xffff > 0x7 == 0x0 (0x0) +__uchar 0xff > 0x7 == 0x1 (0x1) +__longlong 0x7fff > 0x7 == 0x1 (0x1) +__ulonglong 0x7fff > 0x7 == 0x1 (0x1) +float 0x7fff > 0x7 == 0x1 (0x1) +int 0x7fff <= 0x7 == 0x0 (0x0) +__uint 0x7fff <= 0x7 == 0x0 (0x0) +char 0xffff <= 0x7 == 0x1 (0x1) +__uchar 0xff <= 0x7 == 0x0 (0x0) +__longlong 0x7fff <= 0x7 == 0x0 (0x0) +__ulonglong 0x7fff <= 0x7 == 0x0 (0x0) +float 0x7fff <= 0x7 == 0x0 (0x0) +int 0x7fff == 0x7 == 0x0 (0x0) +__uint 0x7fff == 0x7 == 0x0 (0x0) +char 0xffff == 0x7 == 0x0 (0x0) +__uchar 0xff == 0x7 == 0x0 (0x0) +__longlong 0x7fff == 0x7 == 0x0 (0x0) +__ulonglong 0x7fff == 0x7 == 0x0 (0x0) +float 0x7fff == 0x7 == 0x0 (0x0) +int 0x7fff != 0x7 == 0x1 (0x1) +__uint 0x7fff != 0x7 == 0x1 (0x1) +char 0xffff != 0x7 == 0x1 (0x1) +__uchar 0xff != 0x7 == 0x1 (0x1) +__longlong 0x7fff != 0x7 == 0x1 (0x1) +__ulonglong 0x7fff != 0x7 == 0x1 (0x1) +float 0x7fff != 0x7 == 0x1 (0x1) +int 0x7fff >= 0x7 == 0x1 (0x1) +__uint 0x7fff >= 0x7 == 0x1 (0x1) +char 0xffff >= 0x7 == 0x0 (0x0) +__uchar 0xff >= 0x7 == 0x1 (0x1) +__longlong 0x7fff >= 0x7 == 0x1 (0x1) +__ulonglong 0x7fff >= 0x7 == 0x1 (0x1) +float 0x7fff >= 0x7 == 0x1 (0x1) +int 0x7fff / 0x7 == 0x1249 (0x1249) +__uint 0x7fff / 0x7 == 0x1249 (0x1249) +char 0xffff / 0x7 == 0x0 (0x0) +__uchar 0xff / 0x7 == 0x24 (0x24) +__longlong 0x7fff / 0x7 == 0x1249 (0x1249) +__ulonglong 0x7fff / 0x7 == 0x1249 (0x1249) +float 0x7fff / 0x7 == 0x1249 (0x1249) +int 0x7fff % 0x7 == 0x0 (0x0) +__uint 0x7fff % 0x7 == 0x0 (0x0) +char 0xffff % 0x7 == -0x1 (0xffff) +__uchar 0xff % 0x7 == 0x3 (0x3) +__longlong 0x7fff % 0x7 == 0x0 (0x0) +__ulonglong 0x7fff % 0x7 == 0x0 (0x0) +0x7fff * 0x2a == -0x2a +0x7fff / 0x2a == 0x30c +0x7fff % 0x2a == 0x7 +int 0x7fff ^ 0x2a == 0x7fd5 (0x7fd5) +__uint 0x7fff ^ 0x2a == 0x7fd5 (0x7fd5) +char 0xffff ^ 0x2a == -0x2b (0xffd5) +__uchar 0xff ^ 0x2a == 0xd5 (0xd5) +__longlong 0x7fff ^ 0x2a == 0x7fd5 (0x7fd5) +__ulonglong 0x7fff ^ 0x2a == 0x7fd5 (0x7fd5) +int 0x7fff && 0x2a == 0x1 (0x1) +__uint 0x7fff && 0x2a == 0x1 (0x1) +char 0xffff && 0x2a == 0x1 (0x1) +__uchar 0xff && 0x2a == 0x1 (0x1) +__longlong 0x7fff && 0x2a == 0x1 (0x1) +__ulonglong 0x7fff && 0x2a == 0x1 (0x1) +int 0x7fff || 0x2a == 0x1 (0x1) +__uint 0x7fff || 0x2a == 0x1 (0x1) +char 0xffff || 0x2a == 0x1 (0x1) +__uchar 0xff || 0x2a == 0x1 (0x1) +__longlong 0x7fff || 0x2a == 0x1 (0x1) +__ulonglong 0x7fff || 0x2a == 0x1 (0x1) +int 0x7fff & 0x2a == 0x2a (0x2a) +__uint 0x7fff & 0x2a == 0x2a (0x2a) +char 0xffff & 0x2a == 0x2a (0x2a) +__uchar 0xff & 0x2a == 0x2a (0x2a) +__longlong 0x7fff & 0x2a == 0x2a (0x2a) +__ulonglong 0x7fff & 0x2a == 0x2a (0x2a) +int 0x7fff | 0x2a == 0x7fff (0x7fff) +__uint 0x7fff | 0x2a == 0x7fff (0x7fff) +char 0xffff | 0x2a == -0x1 (0xffff) +__uchar 0xff | 0x2a == 0xff (0xff) +__longlong 0x7fff | 0x2a == 0x7fff (0x7fff) +__ulonglong 0x7fff | 0x2a == 0x7fff (0x7fff) +int 0x7fff << 0xc == -0x1000 (0xf000) +__uint 0x7fff << 0xc == -0x1000 (0xf000) +char 0xffff << 0xc == 0x0 (0x0) +__uchar 0xff << 0xc == 0x0 (0x0) +__longlong 0x7fff << 0xc == -0x1000 (0xf000) +__ulonglong 0x7fff << 0xc == -0x1000 (0xf000) +int 0x7fff >> 0xc == 0x7 (0x7) +__uint 0x7fff >> 0xc == 0x7 (0x7) +char 0xffff >> 0xc == -0x1 (0xffff) +__uchar 0xff >> 0xc == 0x0 (0x0) +__longlong 0x7fff >> 0xc == 0x7 (0x7) +__ulonglong 0x7fff >> 0xc == 0x7 (0x7) +int 0x7fff + 0x2a == -0x7fd7 (0x8029) +__uint 0x7fff + 0x2a == -0x7fd7 (0x8029) +char 0xffff + 0x2a == 0x29 (0x29) +__uchar 0xff + 0x2a == 0x29 (0x29) +__longlong 0x7fff + 0x2a == -0x7fd7 (0x8029) +__ulonglong 0x7fff + 0x2a == -0x7fd7 (0x8029) +float 0x7fff + 0x2a == -0x7fd7 (0x8029) +int 0x7fff - 0x2a == 0x7fd5 (0x7fd5) +__uint 0x7fff - 0x2a == 0x7fd5 (0x7fd5) +char 0xffff - 0x2a == -0x2b (0xffd5) +__uchar 0xff - 0x2a == 0xd5 (0xd5) +__longlong 0x7fff - 0x2a == 0x7fd5 (0x7fd5) +__ulonglong 0x7fff - 0x2a == 0x7fd5 (0x7fd5) +float 0x7fff - 0x2a == 0x7fd5 (0x7fd5) +int 0x7fff * 0x2a == -0x2a (0xffd6) +__uint 0x7fff * 0x2a == -0x2a (0xffd6) +char 0xffff * 0x2a == -0x2a (0xffd6) +__uchar 0xff * 0x2a == 0xd6 (0xd6) +__longlong 0x7fff * 0x2a == -0x2a (0xffd6) +__ulonglong 0x7fff * 0x2a == -0x2a (0xffd6) +float 0x7fff * 0x2a == -0x2a (0xffd6) +int 0x7fff < 0x2a == 0x0 (0x0) +__uint 0x7fff < 0x2a == 0x0 (0x0) +char 0xffff < 0x2a == 0x1 (0x1) +__uchar 0xff < 0x2a == 0x0 (0x0) +__longlong 0x7fff < 0x2a == 0x0 (0x0) +__ulonglong 0x7fff < 0x2a == 0x0 (0x0) +float 0x7fff < 0x2a == 0x0 (0x0) +int 0x7fff > 0x2a == 0x1 (0x1) +__uint 0x7fff > 0x2a == 0x1 (0x1) +char 0xffff > 0x2a == 0x0 (0x0) +__uchar 0xff > 0x2a == 0x1 (0x1) +__longlong 0x7fff > 0x2a == 0x1 (0x1) +__ulonglong 0x7fff > 0x2a == 0x1 (0x1) +float 0x7fff > 0x2a == 0x1 (0x1) +int 0x7fff <= 0x2a == 0x0 (0x0) +__uint 0x7fff <= 0x2a == 0x0 (0x0) +char 0xffff <= 0x2a == 0x1 (0x1) +__uchar 0xff <= 0x2a == 0x0 (0x0) +__longlong 0x7fff <= 0x2a == 0x0 (0x0) +__ulonglong 0x7fff <= 0x2a == 0x0 (0x0) +float 0x7fff <= 0x2a == 0x0 (0x0) +int 0x7fff == 0x2a == 0x0 (0x0) +__uint 0x7fff == 0x2a == 0x0 (0x0) +char 0xffff == 0x2a == 0x0 (0x0) +__uchar 0xff == 0x2a == 0x0 (0x0) +__longlong 0x7fff == 0x2a == 0x0 (0x0) +__ulonglong 0x7fff == 0x2a == 0x0 (0x0) +float 0x7fff == 0x2a == 0x0 (0x0) +int 0x7fff != 0x2a == 0x1 (0x1) +__uint 0x7fff != 0x2a == 0x1 (0x1) +char 0xffff != 0x2a == 0x1 (0x1) +__uchar 0xff != 0x2a == 0x1 (0x1) +__longlong 0x7fff != 0x2a == 0x1 (0x1) +__ulonglong 0x7fff != 0x2a == 0x1 (0x1) +float 0x7fff != 0x2a == 0x1 (0x1) +int 0x7fff >= 0x2a == 0x1 (0x1) +__uint 0x7fff >= 0x2a == 0x1 (0x1) +char 0xffff >= 0x2a == 0x0 (0x0) +__uchar 0xff >= 0x2a == 0x1 (0x1) +__longlong 0x7fff >= 0x2a == 0x1 (0x1) +__ulonglong 0x7fff >= 0x2a == 0x1 (0x1) +float 0x7fff >= 0x2a == 0x1 (0x1) +int 0x7fff / 0x2a == 0x30c (0x30c) +__uint 0x7fff / 0x2a == 0x30c (0x30c) +char 0xffff / 0x2a == 0x0 (0x0) +__uchar 0xff / 0x2a == 0x6 (0x6) +__longlong 0x7fff / 0x2a == 0x30c (0x30c) +__ulonglong 0x7fff / 0x2a == 0x30c (0x30c) +float 0x7fff / 0x2a == 0x30c (0x30c) +int 0x7fff % 0x2a == 0x7 (0x7) +__uint 0x7fff % 0x2a == 0x7 (0x7) +char 0xffff % 0x2a == -0x1 (0xffff) +__uchar 0xff % 0x2a == 0x3 (0x3) +__longlong 0x7fff % 0x2a == 0x7 (0x7) +__ulonglong 0x7fff % 0x2a == 0x7 (0x7) +0x7fff * 0x17 == 0x7fe9 +0x7fff / 0x17 == 0x590 +0x7fff % 0x17 == 0xf +int 0x7fff ^ 0x17 == 0x7fe8 (0x7fe8) +__uint 0x7fff ^ 0x17 == 0x7fe8 (0x7fe8) +char 0xffff ^ 0x17 == -0x18 (0xffe8) +__uchar 0xff ^ 0x17 == 0xe8 (0xe8) +__longlong 0x7fff ^ 0x17 == 0x7fe8 (0x7fe8) +__ulonglong 0x7fff ^ 0x17 == 0x7fe8 (0x7fe8) +int 0x7fff && 0x17 == 0x1 (0x1) +__uint 0x7fff && 0x17 == 0x1 (0x1) +char 0xffff && 0x17 == 0x1 (0x1) +__uchar 0xff && 0x17 == 0x1 (0x1) +__longlong 0x7fff && 0x17 == 0x1 (0x1) +__ulonglong 0x7fff && 0x17 == 0x1 (0x1) +int 0x7fff || 0x17 == 0x1 (0x1) +__uint 0x7fff || 0x17 == 0x1 (0x1) +char 0xffff || 0x17 == 0x1 (0x1) +__uchar 0xff || 0x17 == 0x1 (0x1) +__longlong 0x7fff || 0x17 == 0x1 (0x1) +__ulonglong 0x7fff || 0x17 == 0x1 (0x1) +int 0x7fff & 0x17 == 0x17 (0x17) +__uint 0x7fff & 0x17 == 0x17 (0x17) +char 0xffff & 0x17 == 0x17 (0x17) +__uchar 0xff & 0x17 == 0x17 (0x17) +__longlong 0x7fff & 0x17 == 0x17 (0x17) +__ulonglong 0x7fff & 0x17 == 0x17 (0x17) +int 0x7fff | 0x17 == 0x7fff (0x7fff) +__uint 0x7fff | 0x17 == 0x7fff (0x7fff) +char 0xffff | 0x17 == -0x1 (0xffff) +__uchar 0xff | 0x17 == 0xff (0xff) +__longlong 0x7fff | 0x17 == 0x7fff (0x7fff) +__ulonglong 0x7fff | 0x17 == 0x7fff (0x7fff) +int 0x7fff << 0xe == -0x4000 (0xc000) +__uint 0x7fff << 0xe == -0x4000 (0xc000) +char 0xffff << 0xe == 0x0 (0x0) +__uchar 0xff << 0xe == 0x0 (0x0) +__longlong 0x7fff << 0xe == -0x4000 (0xc000) +__ulonglong 0x7fff << 0xe == -0x4000 (0xc000) +int 0x7fff >> 0xe == 0x1 (0x1) +__uint 0x7fff >> 0xe == 0x1 (0x1) +char 0xffff >> 0xe == -0x1 (0xffff) +__uchar 0xff >> 0xe == 0x0 (0x0) +__longlong 0x7fff >> 0xe == 0x1 (0x1) +__ulonglong 0x7fff >> 0xe == 0x1 (0x1) +int 0x7fff + 0x17 == -0x7fea (0x8016) +__uint 0x7fff + 0x17 == -0x7fea (0x8016) +char 0xffff + 0x17 == 0x16 (0x16) +__uchar 0xff + 0x17 == 0x16 (0x16) +__longlong 0x7fff + 0x17 == -0x7fea (0x8016) +__ulonglong 0x7fff + 0x17 == -0x7fea (0x8016) +float 0x7fff + 0x17 == -0x7fea (0x8016) +int 0x7fff - 0x17 == 0x7fe8 (0x7fe8) +__uint 0x7fff - 0x17 == 0x7fe8 (0x7fe8) +char 0xffff - 0x17 == -0x18 (0xffe8) +__uchar 0xff - 0x17 == 0xe8 (0xe8) +__longlong 0x7fff - 0x17 == 0x7fe8 (0x7fe8) +__ulonglong 0x7fff - 0x17 == 0x7fe8 (0x7fe8) +float 0x7fff - 0x17 == 0x7fe8 (0x7fe8) +int 0x7fff * 0x17 == 0x7fe9 (0x7fe9) +__uint 0x7fff * 0x17 == 0x7fe9 (0x7fe9) +char 0xffff * 0x17 == -0x17 (0xffe9) +__uchar 0xff * 0x17 == 0xe9 (0xe9) +__longlong 0x7fff * 0x17 == 0x7fe9 (0x7fe9) +__ulonglong 0x7fff * 0x17 == 0x7fe9 (0x7fe9) +float 0x7fff * 0x17 == 0x7fe9 (0x7fe9) +int 0x7fff < 0x17 == 0x0 (0x0) +__uint 0x7fff < 0x17 == 0x0 (0x0) +char 0xffff < 0x17 == 0x1 (0x1) +__uchar 0xff < 0x17 == 0x0 (0x0) +__longlong 0x7fff < 0x17 == 0x0 (0x0) +__ulonglong 0x7fff < 0x17 == 0x0 (0x0) +float 0x7fff < 0x17 == 0x0 (0x0) +int 0x7fff > 0x17 == 0x1 (0x1) +__uint 0x7fff > 0x17 == 0x1 (0x1) +char 0xffff > 0x17 == 0x0 (0x0) +__uchar 0xff > 0x17 == 0x1 (0x1) +__longlong 0x7fff > 0x17 == 0x1 (0x1) +__ulonglong 0x7fff > 0x17 == 0x1 (0x1) +float 0x7fff > 0x17 == 0x1 (0x1) +int 0x7fff <= 0x17 == 0x0 (0x0) +__uint 0x7fff <= 0x17 == 0x0 (0x0) +char 0xffff <= 0x17 == 0x1 (0x1) +__uchar 0xff <= 0x17 == 0x0 (0x0) +__longlong 0x7fff <= 0x17 == 0x0 (0x0) +__ulonglong 0x7fff <= 0x17 == 0x0 (0x0) +float 0x7fff <= 0x17 == 0x0 (0x0) +int 0x7fff == 0x17 == 0x0 (0x0) +__uint 0x7fff == 0x17 == 0x0 (0x0) +char 0xffff == 0x17 == 0x0 (0x0) +__uchar 0xff == 0x17 == 0x0 (0x0) +__longlong 0x7fff == 0x17 == 0x0 (0x0) +__ulonglong 0x7fff == 0x17 == 0x0 (0x0) +float 0x7fff == 0x17 == 0x0 (0x0) +int 0x7fff != 0x17 == 0x1 (0x1) +__uint 0x7fff != 0x17 == 0x1 (0x1) +char 0xffff != 0x17 == 0x1 (0x1) +__uchar 0xff != 0x17 == 0x1 (0x1) +__longlong 0x7fff != 0x17 == 0x1 (0x1) +__ulonglong 0x7fff != 0x17 == 0x1 (0x1) +float 0x7fff != 0x17 == 0x1 (0x1) +int 0x7fff >= 0x17 == 0x1 (0x1) +__uint 0x7fff >= 0x17 == 0x1 (0x1) +char 0xffff >= 0x17 == 0x0 (0x0) +__uchar 0xff >= 0x17 == 0x1 (0x1) +__longlong 0x7fff >= 0x17 == 0x1 (0x1) +__ulonglong 0x7fff >= 0x17 == 0x1 (0x1) +float 0x7fff >= 0x17 == 0x1 (0x1) +int 0x7fff / 0x17 == 0x590 (0x590) +__uint 0x7fff / 0x17 == 0x590 (0x590) +char 0xffff / 0x17 == 0x0 (0x0) +__uchar 0xff / 0x17 == 0xb (0xb) +__longlong 0x7fff / 0x17 == 0x590 (0x590) +__ulonglong 0x7fff / 0x17 == 0x590 (0x590) +float 0x7fff / 0x17 == 0x590 (0x590) +int 0x7fff % 0x17 == 0xf (0xf) +__uint 0x7fff % 0x17 == 0xf (0xf) +char 0xffff % 0x17 == -0x1 (0xffff) +__uchar 0xff % 0x17 == 0x2 (0x2) +__longlong 0x7fff % 0x17 == 0xf (0xf) +__ulonglong 0x7fff % 0x17 == 0xf (0xf) +0x7fff * 0x7fff == 0x1 +0x7fff / 0x7fff == 0x1 +0x7fff % 0x7fff == 0x0 +int 0x7fff ^ 0x7fff == 0x0 (0x0) +__uint 0x7fff ^ 0x7fff == 0x0 (0x0) +char 0xffff ^ 0xffff == 0x0 (0x0) +__uchar 0xff ^ 0xff == 0x0 (0x0) +__longlong 0x7fff ^ 0x7fff == 0x0 (0x0) +__ulonglong 0x7fff ^ 0x7fff == 0x0 (0x0) +int 0x7fff && 0x7fff == 0x1 (0x1) +__uint 0x7fff && 0x7fff == 0x1 (0x1) +char 0xffff && 0xffff == 0x1 (0x1) +__uchar 0xff && 0xff == 0x1 (0x1) +__longlong 0x7fff && 0x7fff == 0x1 (0x1) +__ulonglong 0x7fff && 0x7fff == 0x1 (0x1) +int 0x7fff || 0x7fff == 0x1 (0x1) +__uint 0x7fff || 0x7fff == 0x1 (0x1) +char 0xffff || 0xffff == 0x1 (0x1) +__uchar 0xff || 0xff == 0x1 (0x1) +__longlong 0x7fff || 0x7fff == 0x1 (0x1) +__ulonglong 0x7fff || 0x7fff == 0x1 (0x1) +int 0x7fff & 0x7fff == 0x7fff (0x7fff) +__uint 0x7fff & 0x7fff == 0x7fff (0x7fff) +char 0xffff & 0xffff == -0x1 (0xffff) +__uchar 0xff & 0xff == 0xff (0xff) +__longlong 0x7fff & 0x7fff == 0x7fff (0x7fff) +__ulonglong 0x7fff & 0x7fff == 0x7fff (0x7fff) +int 0x7fff | 0x7fff == 0x7fff (0x7fff) +__uint 0x7fff | 0x7fff == 0x7fff (0x7fff) +char 0xffff | 0xffff == -0x1 (0xffff) +__uchar 0xff | 0xff == 0xff (0xff) +__longlong 0x7fff | 0x7fff == 0x7fff (0x7fff) +__ulonglong 0x7fff | 0x7fff == 0x7fff (0x7fff) +int 0x7fff << 0x10 == 0x0 (0x0) +__uint 0x7fff << 0x10 == 0x0 (0x0) +char 0xffff << 0x10 == 0x0 (0x0) +__uchar 0xff << 0x10 == 0x0 (0x0) +__longlong 0x7fff << 0x10 == 0x0 (0x0) +__ulonglong 0x7fff << 0x10 == 0x0 (0x0) +int 0x7fff >> 0x10 == 0x0 (0x0) +__uint 0x7fff >> 0x10 == 0x0 (0x0) +char 0xffff >> 0x10 == -0x1 (0xffff) +__uchar 0xff >> 0x10 == 0x0 (0x0) +__longlong 0x7fff >> 0x10 == 0x0 (0x0) +__ulonglong 0x7fff >> 0x10 == 0x0 (0x0) +int 0x7fff + 0x7fff == -0x2 (0xfffe) +__uint 0x7fff + 0x7fff == -0x2 (0xfffe) +char 0xffff + 0xffff == -0x2 (0xfffe) +__uchar 0xff + 0xff == 0xfe (0xfe) +__longlong 0x7fff + 0x7fff == -0x2 (0xfffe) +__ulonglong 0x7fff + 0x7fff == -0x2 (0xfffe) +float 0x7fff + 0x7fff == -0x2 (0xfffe) +int 0x7fff - 0x7fff == 0x0 (0x0) +__uint 0x7fff - 0x7fff == 0x0 (0x0) +char 0xffff - 0xffff == 0x0 (0x0) +__uchar 0xff - 0xff == 0x0 (0x0) +__longlong 0x7fff - 0x7fff == 0x0 (0x0) +__ulonglong 0x7fff - 0x7fff == 0x0 (0x0) +float 0x7fff - 0x7fff == 0x0 (0x0) +int 0x7fff * 0x7fff == 0x1 (0x1) +__uint 0x7fff * 0x7fff == 0x1 (0x1) +char 0xffff * 0xffff == 0x1 (0x1) +__uchar 0xff * 0xff == 0x1 (0x1) +__longlong 0x7fff * 0x7fff == 0x1 (0x1) +__ulonglong 0x7fff * 0x7fff == 0x1 (0x1) +float 0x7fff * 0x7fff == 0x0 (0x0) +int 0x7fff < 0x7fff == 0x0 (0x0) +__uint 0x7fff < 0x7fff == 0x0 (0x0) +char 0xffff < 0xffff == 0x0 (0x0) +__uchar 0xff < 0xff == 0x0 (0x0) +__longlong 0x7fff < 0x7fff == 0x0 (0x0) +__ulonglong 0x7fff < 0x7fff == 0x0 (0x0) +float 0x7fff < 0x7fff == 0x0 (0x0) +int 0x7fff > 0x7fff == 0x0 (0x0) +__uint 0x7fff > 0x7fff == 0x0 (0x0) +char 0xffff > 0xffff == 0x0 (0x0) +__uchar 0xff > 0xff == 0x0 (0x0) +__longlong 0x7fff > 0x7fff == 0x0 (0x0) +__ulonglong 0x7fff > 0x7fff == 0x0 (0x0) +float 0x7fff > 0x7fff == 0x0 (0x0) +int 0x7fff <= 0x7fff == 0x1 (0x1) +__uint 0x7fff <= 0x7fff == 0x1 (0x1) +char 0xffff <= 0xffff == 0x1 (0x1) +__uchar 0xff <= 0xff == 0x1 (0x1) +__longlong 0x7fff <= 0x7fff == 0x1 (0x1) +__ulonglong 0x7fff <= 0x7fff == 0x1 (0x1) +float 0x7fff <= 0x7fff == 0x1 (0x1) +int 0x7fff == 0x7fff == 0x1 (0x1) +__uint 0x7fff == 0x7fff == 0x1 (0x1) +char 0xffff == 0xffff == 0x1 (0x1) +__uchar 0xff == 0xff == 0x1 (0x1) +__longlong 0x7fff == 0x7fff == 0x1 (0x1) +__ulonglong 0x7fff == 0x7fff == 0x1 (0x1) +float 0x7fff == 0x7fff == 0x1 (0x1) +int 0x7fff != 0x7fff == 0x0 (0x0) +__uint 0x7fff != 0x7fff == 0x0 (0x0) +char 0xffff != 0xffff == 0x0 (0x0) +__uchar 0xff != 0xff == 0x0 (0x0) +__longlong 0x7fff != 0x7fff == 0x0 (0x0) +__ulonglong 0x7fff != 0x7fff == 0x0 (0x0) +float 0x7fff != 0x7fff == 0x0 (0x0) +int 0x7fff >= 0x7fff == 0x1 (0x1) +__uint 0x7fff >= 0x7fff == 0x1 (0x1) +char 0xffff >= 0xffff == 0x1 (0x1) +__uchar 0xff >= 0xff == 0x1 (0x1) +__longlong 0x7fff >= 0x7fff == 0x1 (0x1) +__ulonglong 0x7fff >= 0x7fff == 0x1 (0x1) +float 0x7fff >= 0x7fff == 0x1 (0x1) +int 0x7fff / 0x7fff == 0x1 (0x1) +__uint 0x7fff / 0x7fff == 0x1 (0x1) +char 0xffff / 0xffff == 0x1 (0x1) +__uchar 0xff / 0xff == 0x1 (0x1) +__longlong 0x7fff / 0x7fff == 0x1 (0x1) +__ulonglong 0x7fff / 0x7fff == 0x1 (0x1) +float 0x7fff / 0x7fff == 0x1 (0x1) +int 0x7fff % 0x7fff == 0x0 (0x0) +__uint 0x7fff % 0x7fff == 0x0 (0x0) +char 0xffff % 0xffff == 0x0 (0x0) +__uchar 0xff % 0xff == 0x0 (0x0) +__longlong 0x7fff % 0x7fff == 0x0 (0x0) +__ulonglong 0x7fff % 0x7fff == 0x0 (0x0) +0x7fff * 0x8000 == -0x8000 +0x7fff / 0x8000 == 0x0 +0x7fff % 0x8000 == 0x7fff +int 0x7fff ^ 0x8000 == -0x1 (0xffff) +__uint 0x7fff ^ 0x8000 == -0x1 (0xffff) +char 0xffff ^ 0x0 == -0x1 (0xffff) +__uchar 0xff ^ 0x0 == 0xff (0xff) +__longlong 0x7fff ^ 0x8000 == -0x1 (0xffff) +__ulonglong 0x7fff ^ 0x8000 == -0x1 (0xffff) +int 0x7fff && 0x8000 == 0x1 (0x1) +__uint 0x7fff && 0x8000 == 0x1 (0x1) +char 0xffff && 0x0 == 0x0 (0x0) +__uchar 0xff && 0x0 == 0x0 (0x0) +__longlong 0x7fff && 0x8000 == 0x1 (0x1) +__ulonglong 0x7fff && 0x8000 == 0x1 (0x1) +int 0x7fff || 0x8000 == 0x1 (0x1) +__uint 0x7fff || 0x8000 == 0x1 (0x1) +char 0xffff || 0x0 == 0x1 (0x1) +__uchar 0xff || 0x0 == 0x1 (0x1) +__longlong 0x7fff || 0x8000 == 0x1 (0x1) +__ulonglong 0x7fff || 0x8000 == 0x1 (0x1) +int 0x7fff & 0x8000 == 0x0 (0x0) +__uint 0x7fff & 0x8000 == 0x0 (0x0) +char 0xffff & 0x0 == 0x0 (0x0) +__uchar 0xff & 0x0 == 0x0 (0x0) +__longlong 0x7fff & 0x8000 == 0x0 (0x0) +__ulonglong 0x7fff & 0x8000 == 0x0 (0x0) +int 0x7fff | 0x8000 == -0x1 (0xffff) +__uint 0x7fff | 0x8000 == -0x1 (0xffff) +char 0xffff | 0x0 == -0x1 (0xffff) +__uchar 0xff | 0x0 == 0xff (0xff) +__longlong 0x7fff | 0x8000 == -0x1 (0xffff) +__ulonglong 0x7fff | 0x8000 == -0x1 (0xffff) +int 0x7fff << 0x12 == 0x0 (0x0) +__uint 0x7fff << 0x12 == 0x0 (0x0) +char 0xffff << 0x12 == 0x0 (0x0) +__uchar 0xff << 0x12 == 0x0 (0x0) +__longlong 0x7fff << 0x12 == 0x0 (0x0) +__ulonglong 0x7fff << 0x12 == 0x0 (0x0) +int 0x7fff >> 0x12 == 0x0 (0x0) +__uint 0x7fff >> 0x12 == 0x0 (0x0) +char 0xffff >> 0x12 == -0x1 (0xffff) +__uchar 0xff >> 0x12 == 0x0 (0x0) +__longlong 0x7fff >> 0x12 == 0x0 (0x0) +__ulonglong 0x7fff >> 0x12 == 0x0 (0x0) +int 0x7fff + 0x8000 == -0x1 (0xffff) +__uint 0x7fff + 0x8000 == -0x1 (0xffff) +char 0xffff + 0x0 == -0x1 (0xffff) +__uchar 0xff + 0x0 == 0xff (0xff) +__longlong 0x7fff + 0x8000 == -0x1 (0xffff) +__ulonglong 0x7fff + 0x8000 == -0x1 (0xffff) +float 0x7fff + 0x8000 == -0x1 (0xffff) +int 0x7fff - 0x8000 == -0x1 (0xffff) +__uint 0x7fff - 0x8000 == -0x1 (0xffff) +char 0xffff - 0x0 == -0x1 (0xffff) +__uchar 0xff - 0x0 == 0xff (0xff) +__longlong 0x7fff - 0x8000 == -0x1 (0xffff) +__ulonglong 0x7fff - 0x8000 == -0x1 (0xffff) +float 0x7fff - 0x8000 == -0x1 (0xffff) +int 0x7fff * 0x8000 == -0x8000 (0x8000) +__uint 0x7fff * 0x8000 == -0x8000 (0x8000) +char 0xffff * 0x0 == 0x0 (0x0) +__uchar 0xff * 0x0 == 0x0 (0x0) +__longlong 0x7fff * 0x8000 == -0x8000 (0x8000) +__ulonglong 0x7fff * 0x8000 == -0x8000 (0x8000) +float 0x7fff * 0x8000 == -0x8000 (0x8000) +int 0x7fff < 0x8000 == 0x0 (0x0) +__uint 0x7fff < 0x8000 == 0x1 (0x1) +char 0xffff < 0x0 == 0x1 (0x1) +__uchar 0xff < 0x0 == 0x0 (0x0) +__longlong 0x7fff < 0x8000 == 0x0 (0x0) +__ulonglong 0x7fff < 0x8000 == 0x1 (0x1) +float 0x7fff < 0x8000 == 0x0 (0x0) +int 0x7fff > 0x8000 == 0x1 (0x1) +__uint 0x7fff > 0x8000 == 0x0 (0x0) +char 0xffff > 0x0 == 0x0 (0x0) +__uchar 0xff > 0x0 == 0x1 (0x1) +__longlong 0x7fff > 0x8000 == 0x1 (0x1) +__ulonglong 0x7fff > 0x8000 == 0x0 (0x0) +float 0x7fff > 0x8000 == 0x1 (0x1) +int 0x7fff <= 0x8000 == 0x0 (0x0) +__uint 0x7fff <= 0x8000 == 0x1 (0x1) +char 0xffff <= 0x0 == 0x1 (0x1) +__uchar 0xff <= 0x0 == 0x0 (0x0) +__longlong 0x7fff <= 0x8000 == 0x0 (0x0) +__ulonglong 0x7fff <= 0x8000 == 0x1 (0x1) +float 0x7fff <= 0x8000 == 0x0 (0x0) +int 0x7fff == 0x8000 == 0x0 (0x0) +__uint 0x7fff == 0x8000 == 0x0 (0x0) +char 0xffff == 0x0 == 0x0 (0x0) +__uchar 0xff == 0x0 == 0x0 (0x0) +__longlong 0x7fff == 0x8000 == 0x0 (0x0) +__ulonglong 0x7fff == 0x8000 == 0x0 (0x0) +float 0x7fff == 0x8000 == 0x0 (0x0) +int 0x7fff != 0x8000 == 0x1 (0x1) +__uint 0x7fff != 0x8000 == 0x1 (0x1) +char 0xffff != 0x0 == 0x1 (0x1) +__uchar 0xff != 0x0 == 0x1 (0x1) +__longlong 0x7fff != 0x8000 == 0x1 (0x1) +__ulonglong 0x7fff != 0x8000 == 0x1 (0x1) +float 0x7fff != 0x8000 == 0x1 (0x1) +int 0x7fff >= 0x8000 == 0x1 (0x1) +__uint 0x7fff >= 0x8000 == 0x0 (0x0) +char 0xffff >= 0x0 == 0x0 (0x0) +__uchar 0xff >= 0x0 == 0x1 (0x1) +__longlong 0x7fff >= 0x8000 == 0x1 (0x1) +__ulonglong 0x7fff >= 0x8000 == 0x0 (0x0) +float 0x7fff >= 0x8000 == 0x1 (0x1) +int 0x7fff / 0x8000 == 0x0 (0x0) +__uint 0x7fff / 0x8000 == 0x0 (0x0) +__longlong 0x7fff / 0x8000 == 0x0 (0x0) +__ulonglong 0x7fff / 0x8000 == 0x0 (0x0) +float 0x7fff / 0x8000 == 0x0 (0x0) +int 0x7fff % 0x8000 == 0x7fff (0x7fff) +__uint 0x7fff % 0x8000 == 0x7fff (0x7fff) +__longlong 0x7fff % 0x8000 == 0x7fff (0x7fff) +__ulonglong 0x7fff % 0x8000 == 0x7fff (0x7fff) +0x7fff * 0x3e8 == -0x3e8 +0x7fff / 0x3e8 == 0x20 +0x7fff % 0x3e8 == 0x2ff +int 0x7fff ^ 0x3e8 == 0x7c17 (0x7c17) +__uint 0x7fff ^ 0x3e8 == 0x7c17 (0x7c17) +char 0xffff ^ 0xffe8 == 0x17 (0x17) +__uchar 0xff ^ 0xe8 == 0x17 (0x17) +__longlong 0x7fff ^ 0x3e8 == 0x7c17 (0x7c17) +__ulonglong 0x7fff ^ 0x3e8 == 0x7c17 (0x7c17) +int 0x7fff && 0x3e8 == 0x1 (0x1) +__uint 0x7fff && 0x3e8 == 0x1 (0x1) +char 0xffff && 0xffe8 == 0x1 (0x1) +__uchar 0xff && 0xe8 == 0x1 (0x1) +__longlong 0x7fff && 0x3e8 == 0x1 (0x1) +__ulonglong 0x7fff && 0x3e8 == 0x1 (0x1) +int 0x7fff || 0x3e8 == 0x1 (0x1) +__uint 0x7fff || 0x3e8 == 0x1 (0x1) +char 0xffff || 0xffe8 == 0x1 (0x1) +__uchar 0xff || 0xe8 == 0x1 (0x1) +__longlong 0x7fff || 0x3e8 == 0x1 (0x1) +__ulonglong 0x7fff || 0x3e8 == 0x1 (0x1) +int 0x7fff & 0x3e8 == 0x3e8 (0x3e8) +__uint 0x7fff & 0x3e8 == 0x3e8 (0x3e8) +char 0xffff & 0xffe8 == -0x18 (0xffe8) +__uchar 0xff & 0xe8 == 0xe8 (0xe8) +__longlong 0x7fff & 0x3e8 == 0x3e8 (0x3e8) +__ulonglong 0x7fff & 0x3e8 == 0x3e8 (0x3e8) +int 0x7fff | 0x3e8 == 0x7fff (0x7fff) +__uint 0x7fff | 0x3e8 == 0x7fff (0x7fff) +char 0xffff | 0xffe8 == -0x1 (0xffff) +__uchar 0xff | 0xe8 == 0xff (0xff) +__longlong 0x7fff | 0x3e8 == 0x7fff (0x7fff) +__ulonglong 0x7fff | 0x3e8 == 0x7fff (0x7fff) +int 0x7fff << 0x14 == 0x0 (0x0) +__uint 0x7fff << 0x14 == 0x0 (0x0) +char 0xffff << 0x14 == 0x0 (0x0) +__uchar 0xff << 0x14 == 0x0 (0x0) +__longlong 0x7fff << 0x14 == 0x0 (0x0) +__ulonglong 0x7fff << 0x14 == 0x0 (0x0) +int 0x7fff >> 0x14 == 0x0 (0x0) +__uint 0x7fff >> 0x14 == 0x0 (0x0) +char 0xffff >> 0x14 == -0x1 (0xffff) +__uchar 0xff >> 0x14 == 0x0 (0x0) +__longlong 0x7fff >> 0x14 == 0x0 (0x0) +__ulonglong 0x7fff >> 0x14 == 0x0 (0x0) +int 0x7fff + 0x3e8 == -0x7c19 (0x83e7) +__uint 0x7fff + 0x3e8 == -0x7c19 (0x83e7) +char 0xffff + 0xffe8 == -0x19 (0xffe7) +__uchar 0xff + 0xe8 == 0xe7 (0xe7) +__longlong 0x7fff + 0x3e8 == -0x7c19 (0x83e7) +__ulonglong 0x7fff + 0x3e8 == -0x7c19 (0x83e7) +float 0x7fff + 0x3e8 == -0x7c19 (0x83e7) +int 0x7fff - 0x3e8 == 0x7c17 (0x7c17) +__uint 0x7fff - 0x3e8 == 0x7c17 (0x7c17) +char 0xffff - 0xffe8 == 0x17 (0x17) +__uchar 0xff - 0xe8 == 0x17 (0x17) +__longlong 0x7fff - 0x3e8 == 0x7c17 (0x7c17) +__ulonglong 0x7fff - 0x3e8 == 0x7c17 (0x7c17) +float 0x7fff - 0x3e8 == 0x7c17 (0x7c17) +int 0x7fff * 0x3e8 == -0x3e8 (0xfc18) +__uint 0x7fff * 0x3e8 == -0x3e8 (0xfc18) +char 0xffff * 0xffe8 == 0x18 (0x18) +__uchar 0xff * 0xe8 == 0x18 (0x18) +__longlong 0x7fff * 0x3e8 == -0x3e8 (0xfc18) +__ulonglong 0x7fff * 0x3e8 == -0x3e8 (0xfc18) +float 0x7fff * 0x3e8 == -0x3e8 (0xfc18) +int 0x7fff < 0x3e8 == 0x0 (0x0) +__uint 0x7fff < 0x3e8 == 0x0 (0x0) +char 0xffff < 0xffe8 == 0x0 (0x0) +__uchar 0xff < 0xe8 == 0x0 (0x0) +__longlong 0x7fff < 0x3e8 == 0x0 (0x0) +__ulonglong 0x7fff < 0x3e8 == 0x0 (0x0) +float 0x7fff < 0x3e8 == 0x0 (0x0) +int 0x7fff > 0x3e8 == 0x1 (0x1) +__uint 0x7fff > 0x3e8 == 0x1 (0x1) +char 0xffff > 0xffe8 == 0x1 (0x1) +__uchar 0xff > 0xe8 == 0x1 (0x1) +__longlong 0x7fff > 0x3e8 == 0x1 (0x1) +__ulonglong 0x7fff > 0x3e8 == 0x1 (0x1) +float 0x7fff > 0x3e8 == 0x1 (0x1) +int 0x7fff <= 0x3e8 == 0x0 (0x0) +__uint 0x7fff <= 0x3e8 == 0x0 (0x0) +char 0xffff <= 0xffe8 == 0x0 (0x0) +__uchar 0xff <= 0xe8 == 0x0 (0x0) +__longlong 0x7fff <= 0x3e8 == 0x0 (0x0) +__ulonglong 0x7fff <= 0x3e8 == 0x0 (0x0) +float 0x7fff <= 0x3e8 == 0x0 (0x0) +int 0x7fff == 0x3e8 == 0x0 (0x0) +__uint 0x7fff == 0x3e8 == 0x0 (0x0) +char 0xffff == 0xffe8 == 0x0 (0x0) +__uchar 0xff == 0xe8 == 0x0 (0x0) +__longlong 0x7fff == 0x3e8 == 0x0 (0x0) +__ulonglong 0x7fff == 0x3e8 == 0x0 (0x0) +float 0x7fff == 0x3e8 == 0x0 (0x0) +int 0x7fff != 0x3e8 == 0x1 (0x1) +__uint 0x7fff != 0x3e8 == 0x1 (0x1) +char 0xffff != 0xffe8 == 0x1 (0x1) +__uchar 0xff != 0xe8 == 0x1 (0x1) +__longlong 0x7fff != 0x3e8 == 0x1 (0x1) +__ulonglong 0x7fff != 0x3e8 == 0x1 (0x1) +float 0x7fff != 0x3e8 == 0x1 (0x1) +int 0x7fff >= 0x3e8 == 0x1 (0x1) +__uint 0x7fff >= 0x3e8 == 0x1 (0x1) +char 0xffff >= 0xffe8 == 0x1 (0x1) +__uchar 0xff >= 0xe8 == 0x1 (0x1) +__longlong 0x7fff >= 0x3e8 == 0x1 (0x1) +__ulonglong 0x7fff >= 0x3e8 == 0x1 (0x1) +float 0x7fff >= 0x3e8 == 0x1 (0x1) +int 0x7fff / 0x3e8 == 0x20 (0x20) +__uint 0x7fff / 0x3e8 == 0x20 (0x20) +char 0xffff / 0xffe8 == 0x0 (0x0) +__uchar 0xff / 0xe8 == 0x1 (0x1) +__longlong 0x7fff / 0x3e8 == 0x20 (0x20) +__ulonglong 0x7fff / 0x3e8 == 0x20 (0x20) +float 0x7fff / 0x3e8 == 0x20 (0x20) +int 0x7fff % 0x3e8 == 0x2ff (0x2ff) +__uint 0x7fff % 0x3e8 == 0x2ff (0x2ff) +char 0xffff % 0xffe8 == -0x1 (0xffff) +__uchar 0xff % 0xe8 == 0x17 (0x17) +__longlong 0x7fff % 0x3e8 == 0x2ff (0x2ff) +__ulonglong 0x7fff % 0x3e8 == 0x2ff (0x2ff) +0x7fff * 0x2710 == -0x2710 +0x7fff / 0x2710 == 0x3 +0x7fff % 0x2710 == 0xacf +int 0x7fff ^ 0x2710 == 0x58ef (0x58ef) +__uint 0x7fff ^ 0x2710 == 0x58ef (0x58ef) +char 0xffff ^ 0x10 == -0x11 (0xffef) +__uchar 0xff ^ 0x10 == 0xef (0xef) +__longlong 0x7fff ^ 0x2710 == 0x58ef (0x58ef) +__ulonglong 0x7fff ^ 0x2710 == 0x58ef (0x58ef) +int 0x7fff && 0x2710 == 0x1 (0x1) +__uint 0x7fff && 0x2710 == 0x1 (0x1) +char 0xffff && 0x10 == 0x1 (0x1) +__uchar 0xff && 0x10 == 0x1 (0x1) +__longlong 0x7fff && 0x2710 == 0x1 (0x1) +__ulonglong 0x7fff && 0x2710 == 0x1 (0x1) +int 0x7fff || 0x2710 == 0x1 (0x1) +__uint 0x7fff || 0x2710 == 0x1 (0x1) +char 0xffff || 0x10 == 0x1 (0x1) +__uchar 0xff || 0x10 == 0x1 (0x1) +__longlong 0x7fff || 0x2710 == 0x1 (0x1) +__ulonglong 0x7fff || 0x2710 == 0x1 (0x1) +int 0x7fff & 0x2710 == 0x2710 (0x2710) +__uint 0x7fff & 0x2710 == 0x2710 (0x2710) +char 0xffff & 0x10 == 0x10 (0x10) +__uchar 0xff & 0x10 == 0x10 (0x10) +__longlong 0x7fff & 0x2710 == 0x2710 (0x2710) +__ulonglong 0x7fff & 0x2710 == 0x2710 (0x2710) +int 0x7fff | 0x2710 == 0x7fff (0x7fff) +__uint 0x7fff | 0x2710 == 0x7fff (0x7fff) +char 0xffff | 0x10 == -0x1 (0xffff) +__uchar 0xff | 0x10 == 0xff (0xff) +__longlong 0x7fff | 0x2710 == 0x7fff (0x7fff) +__ulonglong 0x7fff | 0x2710 == 0x7fff (0x7fff) +int 0x7fff << 0x16 == 0x0 (0x0) +__uint 0x7fff << 0x16 == 0x0 (0x0) +char 0xffff << 0x16 == 0x0 (0x0) +__uchar 0xff << 0x16 == 0x0 (0x0) +__longlong 0x7fff << 0x16 == 0x0 (0x0) +__ulonglong 0x7fff << 0x16 == 0x0 (0x0) +int 0x7fff >> 0x16 == 0x0 (0x0) +__uint 0x7fff >> 0x16 == 0x0 (0x0) +char 0xffff >> 0x16 == -0x1 (0xffff) +__uchar 0xff >> 0x16 == 0x0 (0x0) +__longlong 0x7fff >> 0x16 == 0x0 (0x0) +__ulonglong 0x7fff >> 0x16 == 0x0 (0x0) +int 0x7fff + 0x2710 == -0x58f1 (0xa70f) +__uint 0x7fff + 0x2710 == -0x58f1 (0xa70f) +char 0xffff + 0x10 == 0xf (0xf) +__uchar 0xff + 0x10 == 0xf (0xf) +__longlong 0x7fff + 0x2710 == -0x58f1 (0xa70f) +__ulonglong 0x7fff + 0x2710 == -0x58f1 (0xa70f) +float 0x7fff + 0x2710 == -0x58f1 (0xa70f) +int 0x7fff - 0x2710 == 0x58ef (0x58ef) +__uint 0x7fff - 0x2710 == 0x58ef (0x58ef) +char 0xffff - 0x10 == -0x11 (0xffef) +__uchar 0xff - 0x10 == 0xef (0xef) +__longlong 0x7fff - 0x2710 == 0x58ef (0x58ef) +__ulonglong 0x7fff - 0x2710 == 0x58ef (0x58ef) +float 0x7fff - 0x2710 == 0x58ef (0x58ef) +int 0x7fff * 0x2710 == -0x2710 (0xd8f0) +__uint 0x7fff * 0x2710 == -0x2710 (0xd8f0) +char 0xffff * 0x10 == -0x10 (0xfff0) +__uchar 0xff * 0x10 == 0xf0 (0xf0) +__longlong 0x7fff * 0x2710 == -0x2710 (0xd8f0) +__ulonglong 0x7fff * 0x2710 == -0x2710 (0xd8f0) +float 0x7fff * 0x2710 == -0x2700 (0xd900) +int 0x7fff < 0x2710 == 0x0 (0x0) +__uint 0x7fff < 0x2710 == 0x0 (0x0) +char 0xffff < 0x10 == 0x1 (0x1) +__uchar 0xff < 0x10 == 0x0 (0x0) +__longlong 0x7fff < 0x2710 == 0x0 (0x0) +__ulonglong 0x7fff < 0x2710 == 0x0 (0x0) +float 0x7fff < 0x2710 == 0x0 (0x0) +int 0x7fff > 0x2710 == 0x1 (0x1) +__uint 0x7fff > 0x2710 == 0x1 (0x1) +char 0xffff > 0x10 == 0x0 (0x0) +__uchar 0xff > 0x10 == 0x1 (0x1) +__longlong 0x7fff > 0x2710 == 0x1 (0x1) +__ulonglong 0x7fff > 0x2710 == 0x1 (0x1) +float 0x7fff > 0x2710 == 0x1 (0x1) +int 0x7fff <= 0x2710 == 0x0 (0x0) +__uint 0x7fff <= 0x2710 == 0x0 (0x0) +char 0xffff <= 0x10 == 0x1 (0x1) +__uchar 0xff <= 0x10 == 0x0 (0x0) +__longlong 0x7fff <= 0x2710 == 0x0 (0x0) +__ulonglong 0x7fff <= 0x2710 == 0x0 (0x0) +float 0x7fff <= 0x2710 == 0x0 (0x0) +int 0x7fff == 0x2710 == 0x0 (0x0) +__uint 0x7fff == 0x2710 == 0x0 (0x0) +char 0xffff == 0x10 == 0x0 (0x0) +__uchar 0xff == 0x10 == 0x0 (0x0) +__longlong 0x7fff == 0x2710 == 0x0 (0x0) +__ulonglong 0x7fff == 0x2710 == 0x0 (0x0) +float 0x7fff == 0x2710 == 0x0 (0x0) +int 0x7fff != 0x2710 == 0x1 (0x1) +__uint 0x7fff != 0x2710 == 0x1 (0x1) +char 0xffff != 0x10 == 0x1 (0x1) +__uchar 0xff != 0x10 == 0x1 (0x1) +__longlong 0x7fff != 0x2710 == 0x1 (0x1) +__ulonglong 0x7fff != 0x2710 == 0x1 (0x1) +float 0x7fff != 0x2710 == 0x1 (0x1) +int 0x7fff >= 0x2710 == 0x1 (0x1) +__uint 0x7fff >= 0x2710 == 0x1 (0x1) +char 0xffff >= 0x10 == 0x0 (0x0) +__uchar 0xff >= 0x10 == 0x1 (0x1) +__longlong 0x7fff >= 0x2710 == 0x1 (0x1) +__ulonglong 0x7fff >= 0x2710 == 0x1 (0x1) +float 0x7fff >= 0x2710 == 0x1 (0x1) +int 0x7fff / 0x2710 == 0x3 (0x3) +__uint 0x7fff / 0x2710 == 0x3 (0x3) +char 0xffff / 0x10 == 0x0 (0x0) +__uchar 0xff / 0x10 == 0xf (0xf) +__longlong 0x7fff / 0x2710 == 0x3 (0x3) +__ulonglong 0x7fff / 0x2710 == 0x3 (0x3) +float 0x7fff / 0x2710 == 0x3 (0x3) +int 0x7fff % 0x2710 == 0xacf (0xacf) +__uint 0x7fff % 0x2710 == 0xacf (0xacf) +char 0xffff % 0x10 == -0x1 (0xffff) +__uchar 0xff % 0x10 == 0xf (0xf) +__longlong 0x7fff % 0x2710 == 0xacf (0xacf) +__ulonglong 0x7fff % 0x2710 == 0xacf (0xacf) +int xor420x7fff xor42 0x7fd5 +__uint xor420x7fff xor42 0x7fd5 +char xor42-0x1 xor42 -0x2b +__uchar xor420xff xor42 0xd5 +__longlong xor420x7fff xor42 0x7fd5 +__ulonglong xor420x7fff xor42 0x7fd5 +int land10x7fff land1 0x1 +__uint land10x7fff land1 0x1 +char land1-0x1 land1 0x1 +__uchar land10xff land1 0x1 +__longlong land10x7fff land1 0x1 +__ulonglong land10x7fff land1 0x1 +int lor10x7fff lor1 0x1 +__uint lor10x7fff lor1 0x1 +char lor1-0x1 lor1 0x1 +__uchar lor10xff lor1 0x1 +__longlong lor10x7fff lor1 0x1 +__ulonglong lor10x7fff lor1 0x1 +int and420x7fff and42 0x2a +__uint and420x7fff and42 0x2a +char and42-0x1 and42 0x2a +__uchar and420xff and42 0x2a +__longlong and420x7fff and42 0x2a +__ulonglong and420x7fff and42 0x2a +int or420x7fff or42 0x7fff +__uint or420x7fff or42 0x7fff +char or42-0x1 or42 -0x1 +__uchar or420xff or42 0xff +__longlong or420x7fff or42 0x7fff +__ulonglong or420x7fff or42 0x7fff +int shl50x7fff shl5 -0x20 +__uint shl50x7fff shl5 -0x20 +char shl5-0x1 shl5 -0x20 +__uchar shl50xff shl5 0xe0 +__longlong shl50x7fff shl5 -0x20 +__ulonglong shl50x7fff shl5 -0x20 +int shr50x7fff shr5 0x3ff +__uint shr50x7fff shr5 0x3ff +char shr5-0x1 shr5 -0x1 +__uchar shr50xff shr5 0x7 +__longlong shr50x7fff shr5 0x3ff +__ulonglong shr50x7fff shr5 0x3ff +int add420x7fff add42 -0x7fd7 +__uint add420x7fff add42 -0x7fd7 +char add42-0x1 add42 0x29 +__uchar add420xff add42 0x29 +__longlong add420x7fff add42 -0x7fd7 +__ulonglong add420x7fff add42 -0x7fd7 +float add420x7fff add42 -0x7fd7 +int sub420x7fff sub42 0x7fd5 +__uint sub420x7fff sub42 0x7fd5 +char sub42-0x1 sub42 -0x2b +__uchar sub420xff sub42 0xd5 +__longlong sub420x7fff sub42 0x7fd5 +__ulonglong sub420x7fff sub42 0x7fd5 +float sub420x7fff sub42 0x7fd5 +int mul420x7fff mul42 -0x2a +__uint mul420x7fff mul42 -0x2a +char mul42-0x1 mul42 -0x2a +__uchar mul420xff mul42 0xd6 +__longlong mul420x7fff mul42 -0x2a +__ulonglong mul420x7fff mul42 -0x2a +float mul420x7fff mul42 -0x2a +int lt420x7fff lt42 0x0 +__uint lt420x7fff lt42 0x0 +char lt42-0x1 lt42 0x1 +__uchar lt420xff lt42 0x0 +__longlong lt420x7fff lt42 0x0 +__ulonglong lt420x7fff lt42 0x0 +float lt420x7fff lt42 0x0 +int gt420x7fff gt42 0x1 +__uint gt420x7fff gt42 0x1 +char gt42-0x1 gt42 0x0 +__uchar gt420xff gt42 0x1 +__longlong gt420x7fff gt42 0x1 +__ulonglong gt420x7fff gt42 0x1 +float gt420x7fff gt42 0x1 +int le420x7fff le42 0x0 +__uint le420x7fff le42 0x0 +char le42-0x1 le42 0x1 +__uchar le420xff le42 0x0 +__longlong le420x7fff le42 0x0 +__ulonglong le420x7fff le42 0x0 +float le420x7fff le42 0x0 +int eq420x7fff eq42 0x0 +__uint eq420x7fff eq42 0x0 +char eq42-0x1 eq42 0x0 +__uchar eq420xff eq42 0x0 +__longlong eq420x7fff eq42 0x0 +__ulonglong eq420x7fff eq42 0x0 +float eq420x7fff eq42 0x0 +int ne420x7fff ne42 0x1 +__uint ne420x7fff ne42 0x1 +char ne42-0x1 ne42 0x1 +__uchar ne420xff ne42 0x1 +__longlong ne420x7fff ne42 0x1 +__ulonglong ne420x7fff ne42 0x1 +float ne420x7fff ne42 0x1 +int ge420x7fff ge42 0x1 +__uint ge420x7fff ge42 0x1 +char ge42-0x1 ge42 0x0 +__uchar ge420xff ge42 0x1 +__longlong ge420x7fff ge42 0x1 +__ulonglong ge420x7fff ge42 0x1 +float ge420x7fff ge42 0x1 +int div420x7fff div42 0x30c +__uint div420x7fff div42 0x30c +char div42-0x1 div42 0x0 +__uchar div420xff div42 0x6 +__longlong div420x7fff div42 0x30c +__ulonglong div420x7fff div42 0x30c +float div420x7fff div42 0x30c +int mod230x7fff mod23 0xf +__uint mod230x7fff mod23 0xf +char mod23-0x1 mod23 -0x1 +__uchar mod230xff mod23 0x2 +__longlong mod230x7fff mod23 0xf +__ulonglong mod230x7fff mod23 0xf +0x8000 * 0xffff == -0x8000 +0x8000 / 0xffff == -0x8000 +0x8000 % 0xffff == 0x0 +int 0x8000 ^ 0xffff == 0x7fff (0x7fff) +__uint 0x8000 ^ 0xffff == 0x7fff (0x7fff) +char 0x0 ^ 0xffff == -0x1 (0xffff) +__uchar 0x0 ^ 0xff == 0xff (0xff) +__longlong 0x8000 ^ 0xffff == 0x7fff (0x7fff) +__ulonglong 0x8000 ^ 0xffff == 0x7fff (0x7fff) +int 0x8000 && 0xffff == 0x1 (0x1) +__uint 0x8000 && 0xffff == 0x1 (0x1) +char 0x0 && 0xffff == 0x0 (0x0) +__uchar 0x0 && 0xff == 0x0 (0x0) +__longlong 0x8000 && 0xffff == 0x1 (0x1) +__ulonglong 0x8000 && 0xffff == 0x1 (0x1) +int 0x8000 || 0xffff == 0x1 (0x1) +__uint 0x8000 || 0xffff == 0x1 (0x1) +char 0x0 || 0xffff == 0x1 (0x1) +__uchar 0x0 || 0xff == 0x1 (0x1) +__longlong 0x8000 || 0xffff == 0x1 (0x1) +__ulonglong 0x8000 || 0xffff == 0x1 (0x1) +int 0x8000 & 0xffff == -0x8000 (0x8000) +__uint 0x8000 & 0xffff == -0x8000 (0x8000) +char 0x0 & 0xffff == 0x0 (0x0) +__uchar 0x0 & 0xff == 0x0 (0x0) +__longlong 0x8000 & 0xffff == -0x8000 (0x8000) +__ulonglong 0x8000 & 0xffff == -0x8000 (0x8000) +int 0x8000 | 0xffff == -0x1 (0xffff) +__uint 0x8000 | 0xffff == -0x1 (0xffff) +char 0x0 | 0xffff == -0x1 (0xffff) +__uchar 0x0 | 0xff == 0xff (0xff) +__longlong 0x8000 | 0xffff == -0x1 (0xffff) +__ulonglong 0x8000 | 0xffff == -0x1 (0xffff) +int 0x8000 << 0x1 == 0x0 (0x0) +__uint 0x8000 << 0x1 == 0x0 (0x0) +char 0x0 << 0x1 == 0x0 (0x0) +__uchar 0x0 << 0x1 == 0x0 (0x0) +__longlong 0x8000 << 0x1 == 0x0 (0x0) +__ulonglong 0x8000 << 0x1 == 0x0 (0x0) +int 0x8000 >> 0x1 == -0x4000 (0xc000) +__uint 0x8000 >> 0x1 == 0x4000 (0x4000) +char 0x0 >> 0x1 == 0x0 (0x0) +__uchar 0x0 >> 0x1 == 0x0 (0x0) +__longlong 0x8000 >> 0x1 == -0x4000 (0xc000) +__ulonglong 0x8000 >> 0x1 == -0x4000 (0xc000) +int 0x8000 + 0xffff == 0x7fff (0x7fff) +__uint 0x8000 + 0xffff == 0x7fff (0x7fff) +char 0x0 + 0xffff == -0x1 (0xffff) +__uchar 0x0 + 0xff == 0xff (0xff) +__longlong 0x8000 + 0xffff == 0x7fff (0x7fff) +__ulonglong 0x8000 + 0xffff == 0x7fff (0x7fff) +float 0x8000 + 0xffff == 0x7fff (0x7fff) +int 0x8000 - 0xffff == -0x7fff (0x8001) +__uint 0x8000 - 0xffff == -0x7fff (0x8001) +char 0x0 - 0xffff == 0x1 (0x1) +__uchar 0x0 - 0xff == 0x1 (0x1) +__longlong 0x8000 - 0xffff == -0x7fff (0x8001) +__ulonglong 0x8000 - 0xffff == -0x7fff (0x8001) +float 0x8000 - 0xffff == -0x7fff (0x8001) +int 0x8000 * 0xffff == -0x8000 (0x8000) +__uint 0x8000 * 0xffff == -0x8000 (0x8000) +char 0x0 * 0xffff == 0x0 (0x0) +__uchar 0x0 * 0xff == 0x0 (0x0) +__longlong 0x8000 * 0xffff == -0x8000 (0x8000) +__ulonglong 0x8000 * 0xffff == -0x8000 (0x8000) +float 0x8000 * 0xffff == -0x8000 (0x8000) +int 0x8000 < 0xffff == 0x1 (0x1) +__uint 0x8000 < 0xffff == 0x1 (0x1) +char 0x0 < 0xffff == 0x0 (0x0) +__uchar 0x0 < 0xff == 0x1 (0x1) +__longlong 0x8000 < 0xffff == 0x1 (0x1) +__ulonglong 0x8000 < 0xffff == 0x1 (0x1) +float 0x8000 < 0xffff == 0x1 (0x1) +int 0x8000 > 0xffff == 0x0 (0x0) +__uint 0x8000 > 0xffff == 0x0 (0x0) +char 0x0 > 0xffff == 0x1 (0x1) +__uchar 0x0 > 0xff == 0x0 (0x0) +__longlong 0x8000 > 0xffff == 0x0 (0x0) +__ulonglong 0x8000 > 0xffff == 0x0 (0x0) +float 0x8000 > 0xffff == 0x0 (0x0) +int 0x8000 <= 0xffff == 0x1 (0x1) +__uint 0x8000 <= 0xffff == 0x1 (0x1) +char 0x0 <= 0xffff == 0x0 (0x0) +__uchar 0x0 <= 0xff == 0x1 (0x1) +__longlong 0x8000 <= 0xffff == 0x1 (0x1) +__ulonglong 0x8000 <= 0xffff == 0x1 (0x1) +float 0x8000 <= 0xffff == 0x1 (0x1) +int 0x8000 == 0xffff == 0x0 (0x0) +__uint 0x8000 == 0xffff == 0x0 (0x0) +char 0x0 == 0xffff == 0x0 (0x0) +__uchar 0x0 == 0xff == 0x0 (0x0) +__longlong 0x8000 == 0xffff == 0x0 (0x0) +__ulonglong 0x8000 == 0xffff == 0x0 (0x0) +float 0x8000 == 0xffff == 0x0 (0x0) +int 0x8000 != 0xffff == 0x1 (0x1) +__uint 0x8000 != 0xffff == 0x1 (0x1) +char 0x0 != 0xffff == 0x1 (0x1) +__uchar 0x0 != 0xff == 0x1 (0x1) +__longlong 0x8000 != 0xffff == 0x1 (0x1) +__ulonglong 0x8000 != 0xffff == 0x1 (0x1) +float 0x8000 != 0xffff == 0x1 (0x1) +int 0x8000 >= 0xffff == 0x0 (0x0) +__uint 0x8000 >= 0xffff == 0x0 (0x0) +char 0x0 >= 0xffff == 0x1 (0x1) +__uchar 0x0 >= 0xff == 0x0 (0x0) +__longlong 0x8000 >= 0xffff == 0x0 (0x0) +__ulonglong 0x8000 >= 0xffff == 0x0 (0x0) +float 0x8000 >= 0xffff == 0x0 (0x0) +int 0x8000 / 0xffff == -0x8000 (0x8000) +__uint 0x8000 / 0xffff == 0x0 (0x0) +char 0x0 / 0xffff == 0x0 (0x0) +__uchar 0x0 / 0xff == 0x0 (0x0) +__longlong 0x8000 / 0xffff == -0x8000 (0x8000) +__ulonglong 0x8000 / 0xffff == 0x0 (0x0) +float 0x8000 / 0xffff == -0x8000 (0x8000) +int 0x8000 % 0xffff == 0x0 (0x0) +__uint 0x8000 % 0xffff == -0x8000 (0x8000) +char 0x0 % 0xffff == 0x0 (0x0) +__uchar 0x0 % 0xff == 0x0 (0x0) +__longlong 0x8000 % 0xffff == 0x0 (0x0) +__ulonglong 0x8000 % 0xffff == -0x8000 (0x8000) +0x8000 * 0x1 == -0x8000 +0x8000 / 0x1 == -0x8000 +0x8000 % 0x1 == 0x0 +int 0x8000 ^ 0x1 == -0x7fff (0x8001) +__uint 0x8000 ^ 0x1 == -0x7fff (0x8001) +char 0x0 ^ 0x1 == 0x1 (0x1) +__uchar 0x0 ^ 0x1 == 0x1 (0x1) +__longlong 0x8000 ^ 0x1 == -0x7fff (0x8001) +__ulonglong 0x8000 ^ 0x1 == -0x7fff (0x8001) +int 0x8000 && 0x1 == 0x1 (0x1) +__uint 0x8000 && 0x1 == 0x1 (0x1) +char 0x0 && 0x1 == 0x0 (0x0) +__uchar 0x0 && 0x1 == 0x0 (0x0) +__longlong 0x8000 && 0x1 == 0x1 (0x1) +__ulonglong 0x8000 && 0x1 == 0x1 (0x1) +int 0x8000 || 0x1 == 0x1 (0x1) +__uint 0x8000 || 0x1 == 0x1 (0x1) +char 0x0 || 0x1 == 0x1 (0x1) +__uchar 0x0 || 0x1 == 0x1 (0x1) +__longlong 0x8000 || 0x1 == 0x1 (0x1) +__ulonglong 0x8000 || 0x1 == 0x1 (0x1) +int 0x8000 & 0x1 == 0x0 (0x0) +__uint 0x8000 & 0x1 == 0x0 (0x0) +char 0x0 & 0x1 == 0x0 (0x0) +__uchar 0x0 & 0x1 == 0x0 (0x0) +__longlong 0x8000 & 0x1 == 0x0 (0x0) +__ulonglong 0x8000 & 0x1 == 0x0 (0x0) +int 0x8000 | 0x1 == -0x7fff (0x8001) +__uint 0x8000 | 0x1 == -0x7fff (0x8001) +char 0x0 | 0x1 == 0x1 (0x1) +__uchar 0x0 | 0x1 == 0x1 (0x1) +__longlong 0x8000 | 0x1 == -0x7fff (0x8001) +__ulonglong 0x8000 | 0x1 == -0x7fff (0x8001) +int 0x8000 << 0x2 == 0x0 (0x0) +__uint 0x8000 << 0x2 == 0x0 (0x0) +char 0x0 << 0x2 == 0x0 (0x0) +__uchar 0x0 << 0x2 == 0x0 (0x0) +__longlong 0x8000 << 0x2 == 0x0 (0x0) +__ulonglong 0x8000 << 0x2 == 0x0 (0x0) +int 0x8000 >> 0x2 == -0x2000 (0xe000) +__uint 0x8000 >> 0x2 == 0x2000 (0x2000) +char 0x0 >> 0x2 == 0x0 (0x0) +__uchar 0x0 >> 0x2 == 0x0 (0x0) +__longlong 0x8000 >> 0x2 == -0x2000 (0xe000) +__ulonglong 0x8000 >> 0x2 == -0x2000 (0xe000) +int 0x8000 + 0x1 == -0x7fff (0x8001) +__uint 0x8000 + 0x1 == -0x7fff (0x8001) +char 0x0 + 0x1 == 0x1 (0x1) +__uchar 0x0 + 0x1 == 0x1 (0x1) +__longlong 0x8000 + 0x1 == -0x7fff (0x8001) +__ulonglong 0x8000 + 0x1 == -0x7fff (0x8001) +float 0x8000 + 0x1 == -0x7fff (0x8001) +int 0x8000 - 0x1 == 0x7fff (0x7fff) +__uint 0x8000 - 0x1 == 0x7fff (0x7fff) +char 0x0 - 0x1 == -0x1 (0xffff) +__uchar 0x0 - 0x1 == 0xff (0xff) +__longlong 0x8000 - 0x1 == 0x7fff (0x7fff) +__ulonglong 0x8000 - 0x1 == 0x7fff (0x7fff) +float 0x8000 - 0x1 == 0x7fff (0x7fff) +int 0x8000 * 0x1 == -0x8000 (0x8000) +__uint 0x8000 * 0x1 == -0x8000 (0x8000) +char 0x0 * 0x1 == 0x0 (0x0) +__uchar 0x0 * 0x1 == 0x0 (0x0) +__longlong 0x8000 * 0x1 == -0x8000 (0x8000) +__ulonglong 0x8000 * 0x1 == -0x8000 (0x8000) +float 0x8000 * 0x1 == -0x8000 (0x8000) +int 0x8000 < 0x1 == 0x1 (0x1) +__uint 0x8000 < 0x1 == 0x0 (0x0) +char 0x0 < 0x1 == 0x1 (0x1) +__uchar 0x0 < 0x1 == 0x1 (0x1) +__longlong 0x8000 < 0x1 == 0x1 (0x1) +__ulonglong 0x8000 < 0x1 == 0x0 (0x0) +float 0x8000 < 0x1 == 0x1 (0x1) +int 0x8000 > 0x1 == 0x0 (0x0) +__uint 0x8000 > 0x1 == 0x1 (0x1) +char 0x0 > 0x1 == 0x0 (0x0) +__uchar 0x0 > 0x1 == 0x0 (0x0) +__longlong 0x8000 > 0x1 == 0x0 (0x0) +__ulonglong 0x8000 > 0x1 == 0x1 (0x1) +float 0x8000 > 0x1 == 0x0 (0x0) +int 0x8000 <= 0x1 == 0x1 (0x1) +__uint 0x8000 <= 0x1 == 0x0 (0x0) +char 0x0 <= 0x1 == 0x1 (0x1) +__uchar 0x0 <= 0x1 == 0x1 (0x1) +__longlong 0x8000 <= 0x1 == 0x1 (0x1) +__ulonglong 0x8000 <= 0x1 == 0x0 (0x0) +float 0x8000 <= 0x1 == 0x1 (0x1) +int 0x8000 == 0x1 == 0x0 (0x0) +__uint 0x8000 == 0x1 == 0x0 (0x0) +char 0x0 == 0x1 == 0x0 (0x0) +__uchar 0x0 == 0x1 == 0x0 (0x0) +__longlong 0x8000 == 0x1 == 0x0 (0x0) +__ulonglong 0x8000 == 0x1 == 0x0 (0x0) +float 0x8000 == 0x1 == 0x0 (0x0) +int 0x8000 != 0x1 == 0x1 (0x1) +__uint 0x8000 != 0x1 == 0x1 (0x1) +char 0x0 != 0x1 == 0x1 (0x1) +__uchar 0x0 != 0x1 == 0x1 (0x1) +__longlong 0x8000 != 0x1 == 0x1 (0x1) +__ulonglong 0x8000 != 0x1 == 0x1 (0x1) +float 0x8000 != 0x1 == 0x1 (0x1) +int 0x8000 >= 0x1 == 0x0 (0x0) +__uint 0x8000 >= 0x1 == 0x1 (0x1) +char 0x0 >= 0x1 == 0x0 (0x0) +__uchar 0x0 >= 0x1 == 0x0 (0x0) +__longlong 0x8000 >= 0x1 == 0x0 (0x0) +__ulonglong 0x8000 >= 0x1 == 0x1 (0x1) +float 0x8000 >= 0x1 == 0x0 (0x0) +int 0x8000 / 0x1 == -0x8000 (0x8000) +__uint 0x8000 / 0x1 == -0x8000 (0x8000) +char 0x0 / 0x1 == 0x0 (0x0) +__uchar 0x0 / 0x1 == 0x0 (0x0) +__longlong 0x8000 / 0x1 == -0x8000 (0x8000) +__ulonglong 0x8000 / 0x1 == -0x8000 (0x8000) +float 0x8000 / 0x1 == -0x8000 (0x8000) +int 0x8000 % 0x1 == 0x0 (0x0) +__uint 0x8000 % 0x1 == 0x0 (0x0) +char 0x0 % 0x1 == 0x0 (0x0) +__uchar 0x0 % 0x1 == 0x0 (0x0) +__longlong 0x8000 % 0x1 == 0x0 (0x0) +__ulonglong 0x8000 % 0x1 == 0x0 (0x0) +0x8000 * 0x2 == 0x0 +0x8000 / 0x2 == -0x4000 +0x8000 % 0x2 == 0x0 +int 0x8000 ^ 0x2 == -0x7ffe (0x8002) +__uint 0x8000 ^ 0x2 == -0x7ffe (0x8002) +char 0x0 ^ 0x2 == 0x2 (0x2) +__uchar 0x0 ^ 0x2 == 0x2 (0x2) +__longlong 0x8000 ^ 0x2 == -0x7ffe (0x8002) +__ulonglong 0x8000 ^ 0x2 == -0x7ffe (0x8002) +int 0x8000 && 0x2 == 0x1 (0x1) +__uint 0x8000 && 0x2 == 0x1 (0x1) +char 0x0 && 0x2 == 0x0 (0x0) +__uchar 0x0 && 0x2 == 0x0 (0x0) +__longlong 0x8000 && 0x2 == 0x1 (0x1) +__ulonglong 0x8000 && 0x2 == 0x1 (0x1) +int 0x8000 || 0x2 == 0x1 (0x1) +__uint 0x8000 || 0x2 == 0x1 (0x1) +char 0x0 || 0x2 == 0x1 (0x1) +__uchar 0x0 || 0x2 == 0x1 (0x1) +__longlong 0x8000 || 0x2 == 0x1 (0x1) +__ulonglong 0x8000 || 0x2 == 0x1 (0x1) +int 0x8000 & 0x2 == 0x0 (0x0) +__uint 0x8000 & 0x2 == 0x0 (0x0) +char 0x0 & 0x2 == 0x0 (0x0) +__uchar 0x0 & 0x2 == 0x0 (0x0) +__longlong 0x8000 & 0x2 == 0x0 (0x0) +__ulonglong 0x8000 & 0x2 == 0x0 (0x0) +int 0x8000 | 0x2 == -0x7ffe (0x8002) +__uint 0x8000 | 0x2 == -0x7ffe (0x8002) +char 0x0 | 0x2 == 0x2 (0x2) +__uchar 0x0 | 0x2 == 0x2 (0x2) +__longlong 0x8000 | 0x2 == -0x7ffe (0x8002) +__ulonglong 0x8000 | 0x2 == -0x7ffe (0x8002) +int 0x8000 << 0x3 == 0x0 (0x0) +__uint 0x8000 << 0x3 == 0x0 (0x0) +char 0x0 << 0x3 == 0x0 (0x0) +__uchar 0x0 << 0x3 == 0x0 (0x0) +__longlong 0x8000 << 0x3 == 0x0 (0x0) +__ulonglong 0x8000 << 0x3 == 0x0 (0x0) +int 0x8000 >> 0x3 == -0x1000 (0xf000) +__uint 0x8000 >> 0x3 == 0x1000 (0x1000) +char 0x0 >> 0x3 == 0x0 (0x0) +__uchar 0x0 >> 0x3 == 0x0 (0x0) +__longlong 0x8000 >> 0x3 == -0x1000 (0xf000) +__ulonglong 0x8000 >> 0x3 == -0x1000 (0xf000) +int 0x8000 + 0x2 == -0x7ffe (0x8002) +__uint 0x8000 + 0x2 == -0x7ffe (0x8002) +char 0x0 + 0x2 == 0x2 (0x2) +__uchar 0x0 + 0x2 == 0x2 (0x2) +__longlong 0x8000 + 0x2 == -0x7ffe (0x8002) +__ulonglong 0x8000 + 0x2 == -0x7ffe (0x8002) +float 0x8000 + 0x2 == -0x7ffe (0x8002) +int 0x8000 - 0x2 == 0x7ffe (0x7ffe) +__uint 0x8000 - 0x2 == 0x7ffe (0x7ffe) +char 0x0 - 0x2 == -0x2 (0xfffe) +__uchar 0x0 - 0x2 == 0xfe (0xfe) +__longlong 0x8000 - 0x2 == 0x7ffe (0x7ffe) +__ulonglong 0x8000 - 0x2 == 0x7ffe (0x7ffe) +float 0x8000 - 0x2 == 0x7ffe (0x7ffe) +int 0x8000 * 0x2 == 0x0 (0x0) +__uint 0x8000 * 0x2 == 0x0 (0x0) +char 0x0 * 0x2 == 0x0 (0x0) +__uchar 0x0 * 0x2 == 0x0 (0x0) +__longlong 0x8000 * 0x2 == 0x0 (0x0) +__ulonglong 0x8000 * 0x2 == 0x0 (0x0) +float 0x8000 * 0x2 == 0x0 (0x0) +int 0x8000 < 0x2 == 0x1 (0x1) +__uint 0x8000 < 0x2 == 0x0 (0x0) +char 0x0 < 0x2 == 0x1 (0x1) +__uchar 0x0 < 0x2 == 0x1 (0x1) +__longlong 0x8000 < 0x2 == 0x1 (0x1) +__ulonglong 0x8000 < 0x2 == 0x0 (0x0) +float 0x8000 < 0x2 == 0x1 (0x1) +int 0x8000 > 0x2 == 0x0 (0x0) +__uint 0x8000 > 0x2 == 0x1 (0x1) +char 0x0 > 0x2 == 0x0 (0x0) +__uchar 0x0 > 0x2 == 0x0 (0x0) +__longlong 0x8000 > 0x2 == 0x0 (0x0) +__ulonglong 0x8000 > 0x2 == 0x1 (0x1) +float 0x8000 > 0x2 == 0x0 (0x0) +int 0x8000 <= 0x2 == 0x1 (0x1) +__uint 0x8000 <= 0x2 == 0x0 (0x0) +char 0x0 <= 0x2 == 0x1 (0x1) +__uchar 0x0 <= 0x2 == 0x1 (0x1) +__longlong 0x8000 <= 0x2 == 0x1 (0x1) +__ulonglong 0x8000 <= 0x2 == 0x0 (0x0) +float 0x8000 <= 0x2 == 0x1 (0x1) +int 0x8000 == 0x2 == 0x0 (0x0) +__uint 0x8000 == 0x2 == 0x0 (0x0) +char 0x0 == 0x2 == 0x0 (0x0) +__uchar 0x0 == 0x2 == 0x0 (0x0) +__longlong 0x8000 == 0x2 == 0x0 (0x0) +__ulonglong 0x8000 == 0x2 == 0x0 (0x0) +float 0x8000 == 0x2 == 0x0 (0x0) +int 0x8000 != 0x2 == 0x1 (0x1) +__uint 0x8000 != 0x2 == 0x1 (0x1) +char 0x0 != 0x2 == 0x1 (0x1) +__uchar 0x0 != 0x2 == 0x1 (0x1) +__longlong 0x8000 != 0x2 == 0x1 (0x1) +__ulonglong 0x8000 != 0x2 == 0x1 (0x1) +float 0x8000 != 0x2 == 0x1 (0x1) +int 0x8000 >= 0x2 == 0x0 (0x0) +__uint 0x8000 >= 0x2 == 0x1 (0x1) +char 0x0 >= 0x2 == 0x0 (0x0) +__uchar 0x0 >= 0x2 == 0x0 (0x0) +__longlong 0x8000 >= 0x2 == 0x0 (0x0) +__ulonglong 0x8000 >= 0x2 == 0x1 (0x1) +float 0x8000 >= 0x2 == 0x0 (0x0) +int 0x8000 / 0x2 == -0x4000 (0xc000) +__uint 0x8000 / 0x2 == 0x4000 (0x4000) +char 0x0 / 0x2 == 0x0 (0x0) +__uchar 0x0 / 0x2 == 0x0 (0x0) +__longlong 0x8000 / 0x2 == -0x4000 (0xc000) +__ulonglong 0x8000 / 0x2 == -0x4000 (0xc000) +float 0x8000 / 0x2 == -0x4000 (0xc000) +int 0x8000 % 0x2 == 0x0 (0x0) +__uint 0x8000 % 0x2 == 0x0 (0x0) +char 0x0 % 0x2 == 0x0 (0x0) +__uchar 0x0 % 0x2 == 0x0 (0x0) +__longlong 0x8000 % 0x2 == 0x0 (0x0) +__ulonglong 0x8000 % 0x2 == 0x0 (0x0) +0x8000 * 0xfffe == 0x0 +0x8000 / 0xfffe == 0x4000 +0x8000 % 0xfffe == 0x0 +int 0x8000 ^ 0xfffe == 0x7ffe (0x7ffe) +__uint 0x8000 ^ 0xfffe == 0x7ffe (0x7ffe) +char 0x0 ^ 0xfffe == -0x2 (0xfffe) +__uchar 0x0 ^ 0xfe == 0xfe (0xfe) +__longlong 0x8000 ^ 0xfffe == 0x7ffe (0x7ffe) +__ulonglong 0x8000 ^ 0xfffe == 0x7ffe (0x7ffe) +int 0x8000 && 0xfffe == 0x1 (0x1) +__uint 0x8000 && 0xfffe == 0x1 (0x1) +char 0x0 && 0xfffe == 0x0 (0x0) +__uchar 0x0 && 0xfe == 0x0 (0x0) +__longlong 0x8000 && 0xfffe == 0x1 (0x1) +__ulonglong 0x8000 && 0xfffe == 0x1 (0x1) +int 0x8000 || 0xfffe == 0x1 (0x1) +__uint 0x8000 || 0xfffe == 0x1 (0x1) +char 0x0 || 0xfffe == 0x1 (0x1) +__uchar 0x0 || 0xfe == 0x1 (0x1) +__longlong 0x8000 || 0xfffe == 0x1 (0x1) +__ulonglong 0x8000 || 0xfffe == 0x1 (0x1) +int 0x8000 & 0xfffe == -0x8000 (0x8000) +__uint 0x8000 & 0xfffe == -0x8000 (0x8000) +char 0x0 & 0xfffe == 0x0 (0x0) +__uchar 0x0 & 0xfe == 0x0 (0x0) +__longlong 0x8000 & 0xfffe == -0x8000 (0x8000) +__ulonglong 0x8000 & 0xfffe == -0x8000 (0x8000) +int 0x8000 | 0xfffe == -0x2 (0xfffe) +__uint 0x8000 | 0xfffe == -0x2 (0xfffe) +char 0x0 | 0xfffe == -0x2 (0xfffe) +__uchar 0x0 | 0xfe == 0xfe (0xfe) +__longlong 0x8000 | 0xfffe == -0x2 (0xfffe) +__ulonglong 0x8000 | 0xfffe == -0x2 (0xfffe) +int 0x8000 << 0x4 == 0x0 (0x0) +__uint 0x8000 << 0x4 == 0x0 (0x0) +char 0x0 << 0x4 == 0x0 (0x0) +__uchar 0x0 << 0x4 == 0x0 (0x0) +__longlong 0x8000 << 0x4 == 0x0 (0x0) +__ulonglong 0x8000 << 0x4 == 0x0 (0x0) +int 0x8000 >> 0x4 == -0x800 (0xf800) +__uint 0x8000 >> 0x4 == 0x800 (0x800) +char 0x0 >> 0x4 == 0x0 (0x0) +__uchar 0x0 >> 0x4 == 0x0 (0x0) +__longlong 0x8000 >> 0x4 == -0x800 (0xf800) +__ulonglong 0x8000 >> 0x4 == -0x800 (0xf800) +int 0x8000 + 0xfffe == 0x7ffe (0x7ffe) +__uint 0x8000 + 0xfffe == 0x7ffe (0x7ffe) +char 0x0 + 0xfffe == -0x2 (0xfffe) +__uchar 0x0 + 0xfe == 0xfe (0xfe) +__longlong 0x8000 + 0xfffe == 0x7ffe (0x7ffe) +__ulonglong 0x8000 + 0xfffe == 0x7ffe (0x7ffe) +float 0x8000 + 0xfffe == 0x7ffe (0x7ffe) +int 0x8000 - 0xfffe == -0x7ffe (0x8002) +__uint 0x8000 - 0xfffe == -0x7ffe (0x8002) +char 0x0 - 0xfffe == 0x2 (0x2) +__uchar 0x0 - 0xfe == 0x2 (0x2) +__longlong 0x8000 - 0xfffe == -0x7ffe (0x8002) +__ulonglong 0x8000 - 0xfffe == -0x7ffe (0x8002) +float 0x8000 - 0xfffe == -0x7ffe (0x8002) +int 0x8000 * 0xfffe == 0x0 (0x0) +__uint 0x8000 * 0xfffe == 0x0 (0x0) +char 0x0 * 0xfffe == 0x0 (0x0) +__uchar 0x0 * 0xfe == 0x0 (0x0) +__longlong 0x8000 * 0xfffe == 0x0 (0x0) +__ulonglong 0x8000 * 0xfffe == 0x0 (0x0) +float 0x8000 * 0xfffe == 0x0 (0x0) +int 0x8000 < 0xfffe == 0x1 (0x1) +__uint 0x8000 < 0xfffe == 0x1 (0x1) +char 0x0 < 0xfffe == 0x0 (0x0) +__uchar 0x0 < 0xfe == 0x1 (0x1) +__longlong 0x8000 < 0xfffe == 0x1 (0x1) +__ulonglong 0x8000 < 0xfffe == 0x1 (0x1) +float 0x8000 < 0xfffe == 0x1 (0x1) +int 0x8000 > 0xfffe == 0x0 (0x0) +__uint 0x8000 > 0xfffe == 0x0 (0x0) +char 0x0 > 0xfffe == 0x1 (0x1) +__uchar 0x0 > 0xfe == 0x0 (0x0) +__longlong 0x8000 > 0xfffe == 0x0 (0x0) +__ulonglong 0x8000 > 0xfffe == 0x0 (0x0) +float 0x8000 > 0xfffe == 0x0 (0x0) +int 0x8000 <= 0xfffe == 0x1 (0x1) +__uint 0x8000 <= 0xfffe == 0x1 (0x1) +char 0x0 <= 0xfffe == 0x0 (0x0) +__uchar 0x0 <= 0xfe == 0x1 (0x1) +__longlong 0x8000 <= 0xfffe == 0x1 (0x1) +__ulonglong 0x8000 <= 0xfffe == 0x1 (0x1) +float 0x8000 <= 0xfffe == 0x1 (0x1) +int 0x8000 == 0xfffe == 0x0 (0x0) +__uint 0x8000 == 0xfffe == 0x0 (0x0) +char 0x0 == 0xfffe == 0x0 (0x0) +__uchar 0x0 == 0xfe == 0x0 (0x0) +__longlong 0x8000 == 0xfffe == 0x0 (0x0) +__ulonglong 0x8000 == 0xfffe == 0x0 (0x0) +float 0x8000 == 0xfffe == 0x0 (0x0) +int 0x8000 != 0xfffe == 0x1 (0x1) +__uint 0x8000 != 0xfffe == 0x1 (0x1) +char 0x0 != 0xfffe == 0x1 (0x1) +__uchar 0x0 != 0xfe == 0x1 (0x1) +__longlong 0x8000 != 0xfffe == 0x1 (0x1) +__ulonglong 0x8000 != 0xfffe == 0x1 (0x1) +float 0x8000 != 0xfffe == 0x1 (0x1) +int 0x8000 >= 0xfffe == 0x0 (0x0) +__uint 0x8000 >= 0xfffe == 0x0 (0x0) +char 0x0 >= 0xfffe == 0x1 (0x1) +__uchar 0x0 >= 0xfe == 0x0 (0x0) +__longlong 0x8000 >= 0xfffe == 0x0 (0x0) +__ulonglong 0x8000 >= 0xfffe == 0x0 (0x0) +float 0x8000 >= 0xfffe == 0x0 (0x0) +int 0x8000 / 0xfffe == 0x4000 (0x4000) +__uint 0x8000 / 0xfffe == 0x0 (0x0) +char 0x0 / 0xfffe == 0x0 (0x0) +__uchar 0x0 / 0xfe == 0x0 (0x0) +__longlong 0x8000 / 0xfffe == 0x4000 (0x4000) +__ulonglong 0x8000 / 0xfffe == 0x0 (0x0) +float 0x8000 / 0xfffe == 0x4000 (0x4000) +int 0x8000 % 0xfffe == 0x0 (0x0) +__uint 0x8000 % 0xfffe == -0x8000 (0x8000) +char 0x0 % 0xfffe == 0x0 (0x0) +__uchar 0x0 % 0xfe == 0x0 (0x0) +__longlong 0x8000 % 0xfffe == 0x0 (0x0) +__ulonglong 0x8000 % 0xfffe == -0x8000 (0x8000) +0x8000 * 0x4 == 0x0 +0x8000 / 0x4 == -0x2000 +0x8000 % 0x4 == 0x0 +int 0x8000 ^ 0x4 == -0x7ffc (0x8004) +__uint 0x8000 ^ 0x4 == -0x7ffc (0x8004) +char 0x0 ^ 0x4 == 0x4 (0x4) +__uchar 0x0 ^ 0x4 == 0x4 (0x4) +__longlong 0x8000 ^ 0x4 == -0x7ffc (0x8004) +__ulonglong 0x8000 ^ 0x4 == -0x7ffc (0x8004) +int 0x8000 && 0x4 == 0x1 (0x1) +__uint 0x8000 && 0x4 == 0x1 (0x1) +char 0x0 && 0x4 == 0x0 (0x0) +__uchar 0x0 && 0x4 == 0x0 (0x0) +__longlong 0x8000 && 0x4 == 0x1 (0x1) +__ulonglong 0x8000 && 0x4 == 0x1 (0x1) +int 0x8000 || 0x4 == 0x1 (0x1) +__uint 0x8000 || 0x4 == 0x1 (0x1) +char 0x0 || 0x4 == 0x1 (0x1) +__uchar 0x0 || 0x4 == 0x1 (0x1) +__longlong 0x8000 || 0x4 == 0x1 (0x1) +__ulonglong 0x8000 || 0x4 == 0x1 (0x1) +int 0x8000 & 0x4 == 0x0 (0x0) +__uint 0x8000 & 0x4 == 0x0 (0x0) +char 0x0 & 0x4 == 0x0 (0x0) +__uchar 0x0 & 0x4 == 0x0 (0x0) +__longlong 0x8000 & 0x4 == 0x0 (0x0) +__ulonglong 0x8000 & 0x4 == 0x0 (0x0) +int 0x8000 | 0x4 == -0x7ffc (0x8004) +__uint 0x8000 | 0x4 == -0x7ffc (0x8004) +char 0x0 | 0x4 == 0x4 (0x4) +__uchar 0x0 | 0x4 == 0x4 (0x4) +__longlong 0x8000 | 0x4 == -0x7ffc (0x8004) +__ulonglong 0x8000 | 0x4 == -0x7ffc (0x8004) +int 0x8000 << 0x5 == 0x0 (0x0) +__uint 0x8000 << 0x5 == 0x0 (0x0) +char 0x0 << 0x5 == 0x0 (0x0) +__uchar 0x0 << 0x5 == 0x0 (0x0) +__longlong 0x8000 << 0x5 == 0x0 (0x0) +__ulonglong 0x8000 << 0x5 == 0x0 (0x0) +int 0x8000 >> 0x5 == -0x400 (0xfc00) +__uint 0x8000 >> 0x5 == 0x400 (0x400) +char 0x0 >> 0x5 == 0x0 (0x0) +__uchar 0x0 >> 0x5 == 0x0 (0x0) +__longlong 0x8000 >> 0x5 == -0x400 (0xfc00) +__ulonglong 0x8000 >> 0x5 == -0x400 (0xfc00) +int 0x8000 + 0x4 == -0x7ffc (0x8004) +__uint 0x8000 + 0x4 == -0x7ffc (0x8004) +char 0x0 + 0x4 == 0x4 (0x4) +__uchar 0x0 + 0x4 == 0x4 (0x4) +__longlong 0x8000 + 0x4 == -0x7ffc (0x8004) +__ulonglong 0x8000 + 0x4 == -0x7ffc (0x8004) +float 0x8000 + 0x4 == -0x7ffc (0x8004) +int 0x8000 - 0x4 == 0x7ffc (0x7ffc) +__uint 0x8000 - 0x4 == 0x7ffc (0x7ffc) +char 0x0 - 0x4 == -0x4 (0xfffc) +__uchar 0x0 - 0x4 == 0xfc (0xfc) +__longlong 0x8000 - 0x4 == 0x7ffc (0x7ffc) +__ulonglong 0x8000 - 0x4 == 0x7ffc (0x7ffc) +float 0x8000 - 0x4 == 0x7ffc (0x7ffc) +int 0x8000 * 0x4 == 0x0 (0x0) +__uint 0x8000 * 0x4 == 0x0 (0x0) +char 0x0 * 0x4 == 0x0 (0x0) +__uchar 0x0 * 0x4 == 0x0 (0x0) +__longlong 0x8000 * 0x4 == 0x0 (0x0) +__ulonglong 0x8000 * 0x4 == 0x0 (0x0) +float 0x8000 * 0x4 == 0x0 (0x0) +int 0x8000 < 0x4 == 0x1 (0x1) +__uint 0x8000 < 0x4 == 0x0 (0x0) +char 0x0 < 0x4 == 0x1 (0x1) +__uchar 0x0 < 0x4 == 0x1 (0x1) +__longlong 0x8000 < 0x4 == 0x1 (0x1) +__ulonglong 0x8000 < 0x4 == 0x0 (0x0) +float 0x8000 < 0x4 == 0x1 (0x1) +int 0x8000 > 0x4 == 0x0 (0x0) +__uint 0x8000 > 0x4 == 0x1 (0x1) +char 0x0 > 0x4 == 0x0 (0x0) +__uchar 0x0 > 0x4 == 0x0 (0x0) +__longlong 0x8000 > 0x4 == 0x0 (0x0) +__ulonglong 0x8000 > 0x4 == 0x1 (0x1) +float 0x8000 > 0x4 == 0x0 (0x0) +int 0x8000 <= 0x4 == 0x1 (0x1) +__uint 0x8000 <= 0x4 == 0x0 (0x0) +char 0x0 <= 0x4 == 0x1 (0x1) +__uchar 0x0 <= 0x4 == 0x1 (0x1) +__longlong 0x8000 <= 0x4 == 0x1 (0x1) +__ulonglong 0x8000 <= 0x4 == 0x0 (0x0) +float 0x8000 <= 0x4 == 0x1 (0x1) +int 0x8000 == 0x4 == 0x0 (0x0) +__uint 0x8000 == 0x4 == 0x0 (0x0) +char 0x0 == 0x4 == 0x0 (0x0) +__uchar 0x0 == 0x4 == 0x0 (0x0) +__longlong 0x8000 == 0x4 == 0x0 (0x0) +__ulonglong 0x8000 == 0x4 == 0x0 (0x0) +float 0x8000 == 0x4 == 0x0 (0x0) +int 0x8000 != 0x4 == 0x1 (0x1) +__uint 0x8000 != 0x4 == 0x1 (0x1) +char 0x0 != 0x4 == 0x1 (0x1) +__uchar 0x0 != 0x4 == 0x1 (0x1) +__longlong 0x8000 != 0x4 == 0x1 (0x1) +__ulonglong 0x8000 != 0x4 == 0x1 (0x1) +float 0x8000 != 0x4 == 0x1 (0x1) +int 0x8000 >= 0x4 == 0x0 (0x0) +__uint 0x8000 >= 0x4 == 0x1 (0x1) +char 0x0 >= 0x4 == 0x0 (0x0) +__uchar 0x0 >= 0x4 == 0x0 (0x0) +__longlong 0x8000 >= 0x4 == 0x0 (0x0) +__ulonglong 0x8000 >= 0x4 == 0x1 (0x1) +float 0x8000 >= 0x4 == 0x0 (0x0) +int 0x8000 / 0x4 == -0x2000 (0xe000) +__uint 0x8000 / 0x4 == 0x2000 (0x2000) +char 0x0 / 0x4 == 0x0 (0x0) +__uchar 0x0 / 0x4 == 0x0 (0x0) +__longlong 0x8000 / 0x4 == -0x2000 (0xe000) +__ulonglong 0x8000 / 0x4 == -0x2000 (0xe000) +float 0x8000 / 0x4 == -0x2000 (0xe000) +int 0x8000 % 0x4 == 0x0 (0x0) +__uint 0x8000 % 0x4 == 0x0 (0x0) +char 0x0 % 0x4 == 0x0 (0x0) +__uchar 0x0 % 0x4 == 0x0 (0x0) +__longlong 0x8000 % 0x4 == 0x0 (0x0) +__ulonglong 0x8000 % 0x4 == 0x0 (0x0) +0x8000 * 0xfffc == 0x0 +0x8000 / 0xfffc == 0x2000 +0x8000 % 0xfffc == 0x0 +int 0x8000 ^ 0xfffc == 0x7ffc (0x7ffc) +__uint 0x8000 ^ 0xfffc == 0x7ffc (0x7ffc) +char 0x0 ^ 0xfffc == -0x4 (0xfffc) +__uchar 0x0 ^ 0xfc == 0xfc (0xfc) +__longlong 0x8000 ^ 0xfffc == 0x7ffc (0x7ffc) +__ulonglong 0x8000 ^ 0xfffc == 0x7ffc (0x7ffc) +int 0x8000 && 0xfffc == 0x1 (0x1) +__uint 0x8000 && 0xfffc == 0x1 (0x1) +char 0x0 && 0xfffc == 0x0 (0x0) +__uchar 0x0 && 0xfc == 0x0 (0x0) +__longlong 0x8000 && 0xfffc == 0x1 (0x1) +__ulonglong 0x8000 && 0xfffc == 0x1 (0x1) +int 0x8000 || 0xfffc == 0x1 (0x1) +__uint 0x8000 || 0xfffc == 0x1 (0x1) +char 0x0 || 0xfffc == 0x1 (0x1) +__uchar 0x0 || 0xfc == 0x1 (0x1) +__longlong 0x8000 || 0xfffc == 0x1 (0x1) +__ulonglong 0x8000 || 0xfffc == 0x1 (0x1) +int 0x8000 & 0xfffc == -0x8000 (0x8000) +__uint 0x8000 & 0xfffc == -0x8000 (0x8000) +char 0x0 & 0xfffc == 0x0 (0x0) +__uchar 0x0 & 0xfc == 0x0 (0x0) +__longlong 0x8000 & 0xfffc == -0x8000 (0x8000) +__ulonglong 0x8000 & 0xfffc == -0x8000 (0x8000) +int 0x8000 | 0xfffc == -0x4 (0xfffc) +__uint 0x8000 | 0xfffc == -0x4 (0xfffc) +char 0x0 | 0xfffc == -0x4 (0xfffc) +__uchar 0x0 | 0xfc == 0xfc (0xfc) +__longlong 0x8000 | 0xfffc == -0x4 (0xfffc) +__ulonglong 0x8000 | 0xfffc == -0x4 (0xfffc) +int 0x8000 << 0x6 == 0x0 (0x0) +__uint 0x8000 << 0x6 == 0x0 (0x0) +char 0x0 << 0x6 == 0x0 (0x0) +__uchar 0x0 << 0x6 == 0x0 (0x0) +__longlong 0x8000 << 0x6 == 0x0 (0x0) +__ulonglong 0x8000 << 0x6 == 0x0 (0x0) +int 0x8000 >> 0x6 == -0x200 (0xfe00) +__uint 0x8000 >> 0x6 == 0x200 (0x200) +char 0x0 >> 0x6 == 0x0 (0x0) +__uchar 0x0 >> 0x6 == 0x0 (0x0) +__longlong 0x8000 >> 0x6 == -0x200 (0xfe00) +__ulonglong 0x8000 >> 0x6 == -0x200 (0xfe00) +int 0x8000 + 0xfffc == 0x7ffc (0x7ffc) +__uint 0x8000 + 0xfffc == 0x7ffc (0x7ffc) +char 0x0 + 0xfffc == -0x4 (0xfffc) +__uchar 0x0 + 0xfc == 0xfc (0xfc) +__longlong 0x8000 + 0xfffc == 0x7ffc (0x7ffc) +__ulonglong 0x8000 + 0xfffc == 0x7ffc (0x7ffc) +float 0x8000 + 0xfffc == 0x7ffc (0x7ffc) +int 0x8000 - 0xfffc == -0x7ffc (0x8004) +__uint 0x8000 - 0xfffc == -0x7ffc (0x8004) +char 0x0 - 0xfffc == 0x4 (0x4) +__uchar 0x0 - 0xfc == 0x4 (0x4) +__longlong 0x8000 - 0xfffc == -0x7ffc (0x8004) +__ulonglong 0x8000 - 0xfffc == -0x7ffc (0x8004) +float 0x8000 - 0xfffc == -0x7ffc (0x8004) +int 0x8000 * 0xfffc == 0x0 (0x0) +__uint 0x8000 * 0xfffc == 0x0 (0x0) +char 0x0 * 0xfffc == 0x0 (0x0) +__uchar 0x0 * 0xfc == 0x0 (0x0) +__longlong 0x8000 * 0xfffc == 0x0 (0x0) +__ulonglong 0x8000 * 0xfffc == 0x0 (0x0) +float 0x8000 * 0xfffc == 0x0 (0x0) +int 0x8000 < 0xfffc == 0x1 (0x1) +__uint 0x8000 < 0xfffc == 0x1 (0x1) +char 0x0 < 0xfffc == 0x0 (0x0) +__uchar 0x0 < 0xfc == 0x1 (0x1) +__longlong 0x8000 < 0xfffc == 0x1 (0x1) +__ulonglong 0x8000 < 0xfffc == 0x1 (0x1) +float 0x8000 < 0xfffc == 0x1 (0x1) +int 0x8000 > 0xfffc == 0x0 (0x0) +__uint 0x8000 > 0xfffc == 0x0 (0x0) +char 0x0 > 0xfffc == 0x1 (0x1) +__uchar 0x0 > 0xfc == 0x0 (0x0) +__longlong 0x8000 > 0xfffc == 0x0 (0x0) +__ulonglong 0x8000 > 0xfffc == 0x0 (0x0) +float 0x8000 > 0xfffc == 0x0 (0x0) +int 0x8000 <= 0xfffc == 0x1 (0x1) +__uint 0x8000 <= 0xfffc == 0x1 (0x1) +char 0x0 <= 0xfffc == 0x0 (0x0) +__uchar 0x0 <= 0xfc == 0x1 (0x1) +__longlong 0x8000 <= 0xfffc == 0x1 (0x1) +__ulonglong 0x8000 <= 0xfffc == 0x1 (0x1) +float 0x8000 <= 0xfffc == 0x1 (0x1) +int 0x8000 == 0xfffc == 0x0 (0x0) +__uint 0x8000 == 0xfffc == 0x0 (0x0) +char 0x0 == 0xfffc == 0x0 (0x0) +__uchar 0x0 == 0xfc == 0x0 (0x0) +__longlong 0x8000 == 0xfffc == 0x0 (0x0) +__ulonglong 0x8000 == 0xfffc == 0x0 (0x0) +float 0x8000 == 0xfffc == 0x0 (0x0) +int 0x8000 != 0xfffc == 0x1 (0x1) +__uint 0x8000 != 0xfffc == 0x1 (0x1) +char 0x0 != 0xfffc == 0x1 (0x1) +__uchar 0x0 != 0xfc == 0x1 (0x1) +__longlong 0x8000 != 0xfffc == 0x1 (0x1) +__ulonglong 0x8000 != 0xfffc == 0x1 (0x1) +float 0x8000 != 0xfffc == 0x1 (0x1) +int 0x8000 >= 0xfffc == 0x0 (0x0) +__uint 0x8000 >= 0xfffc == 0x0 (0x0) +char 0x0 >= 0xfffc == 0x1 (0x1) +__uchar 0x0 >= 0xfc == 0x0 (0x0) +__longlong 0x8000 >= 0xfffc == 0x0 (0x0) +__ulonglong 0x8000 >= 0xfffc == 0x0 (0x0) +float 0x8000 >= 0xfffc == 0x0 (0x0) +int 0x8000 / 0xfffc == 0x2000 (0x2000) +__uint 0x8000 / 0xfffc == 0x0 (0x0) +char 0x0 / 0xfffc == 0x0 (0x0) +__uchar 0x0 / 0xfc == 0x0 (0x0) +__longlong 0x8000 / 0xfffc == 0x2000 (0x2000) +__ulonglong 0x8000 / 0xfffc == 0x0 (0x0) +float 0x8000 / 0xfffc == 0x2000 (0x2000) +int 0x8000 % 0xfffc == 0x0 (0x0) +__uint 0x8000 % 0xfffc == -0x8000 (0x8000) +char 0x0 % 0xfffc == 0x0 (0x0) +__uchar 0x0 % 0xfc == 0x0 (0x0) +__longlong 0x8000 % 0xfffc == 0x0 (0x0) +__ulonglong 0x8000 % 0xfffc == -0x8000 (0x8000) +0x8000 * 0xa == 0x0 +0x8000 / 0xa == -0xccc +0x8000 % 0xa == -0x8 +int 0x8000 ^ 0xa == -0x7ff6 (0x800a) +__uint 0x8000 ^ 0xa == -0x7ff6 (0x800a) +char 0x0 ^ 0xa == 0xa (0xa) +__uchar 0x0 ^ 0xa == 0xa (0xa) +__longlong 0x8000 ^ 0xa == -0x7ff6 (0x800a) +__ulonglong 0x8000 ^ 0xa == -0x7ff6 (0x800a) +int 0x8000 && 0xa == 0x1 (0x1) +__uint 0x8000 && 0xa == 0x1 (0x1) +char 0x0 && 0xa == 0x0 (0x0) +__uchar 0x0 && 0xa == 0x0 (0x0) +__longlong 0x8000 && 0xa == 0x1 (0x1) +__ulonglong 0x8000 && 0xa == 0x1 (0x1) +int 0x8000 || 0xa == 0x1 (0x1) +__uint 0x8000 || 0xa == 0x1 (0x1) +char 0x0 || 0xa == 0x1 (0x1) +__uchar 0x0 || 0xa == 0x1 (0x1) +__longlong 0x8000 || 0xa == 0x1 (0x1) +__ulonglong 0x8000 || 0xa == 0x1 (0x1) +int 0x8000 & 0xa == 0x0 (0x0) +__uint 0x8000 & 0xa == 0x0 (0x0) +char 0x0 & 0xa == 0x0 (0x0) +__uchar 0x0 & 0xa == 0x0 (0x0) +__longlong 0x8000 & 0xa == 0x0 (0x0) +__ulonglong 0x8000 & 0xa == 0x0 (0x0) +int 0x8000 | 0xa == -0x7ff6 (0x800a) +__uint 0x8000 | 0xa == -0x7ff6 (0x800a) +char 0x0 | 0xa == 0xa (0xa) +__uchar 0x0 | 0xa == 0xa (0xa) +__longlong 0x8000 | 0xa == -0x7ff6 (0x800a) +__ulonglong 0x8000 | 0xa == -0x7ff6 (0x800a) +int 0x8000 << 0x7 == 0x0 (0x0) +__uint 0x8000 << 0x7 == 0x0 (0x0) +char 0x0 << 0x7 == 0x0 (0x0) +__uchar 0x0 << 0x7 == 0x0 (0x0) +__longlong 0x8000 << 0x7 == 0x0 (0x0) +__ulonglong 0x8000 << 0x7 == 0x0 (0x0) +int 0x8000 >> 0x7 == -0x100 (0xff00) +__uint 0x8000 >> 0x7 == 0x100 (0x100) +char 0x0 >> 0x7 == 0x0 (0x0) +__uchar 0x0 >> 0x7 == 0x0 (0x0) +__longlong 0x8000 >> 0x7 == -0x100 (0xff00) +__ulonglong 0x8000 >> 0x7 == -0x100 (0xff00) +int 0x8000 + 0xa == -0x7ff6 (0x800a) +__uint 0x8000 + 0xa == -0x7ff6 (0x800a) +char 0x0 + 0xa == 0xa (0xa) +__uchar 0x0 + 0xa == 0xa (0xa) +__longlong 0x8000 + 0xa == -0x7ff6 (0x800a) +__ulonglong 0x8000 + 0xa == -0x7ff6 (0x800a) +float 0x8000 + 0xa == -0x7ff6 (0x800a) +int 0x8000 - 0xa == 0x7ff6 (0x7ff6) +__uint 0x8000 - 0xa == 0x7ff6 (0x7ff6) +char 0x0 - 0xa == -0xa (0xfff6) +__uchar 0x0 - 0xa == 0xf6 (0xf6) +__longlong 0x8000 - 0xa == 0x7ff6 (0x7ff6) +__ulonglong 0x8000 - 0xa == 0x7ff6 (0x7ff6) +float 0x8000 - 0xa == 0x7ff6 (0x7ff6) +int 0x8000 * 0xa == 0x0 (0x0) +__uint 0x8000 * 0xa == 0x0 (0x0) +char 0x0 * 0xa == 0x0 (0x0) +__uchar 0x0 * 0xa == 0x0 (0x0) +__longlong 0x8000 * 0xa == 0x0 (0x0) +__ulonglong 0x8000 * 0xa == 0x0 (0x0) +float 0x8000 * 0xa == 0x0 (0x0) +int 0x8000 < 0xa == 0x1 (0x1) +__uint 0x8000 < 0xa == 0x0 (0x0) +char 0x0 < 0xa == 0x1 (0x1) +__uchar 0x0 < 0xa == 0x1 (0x1) +__longlong 0x8000 < 0xa == 0x1 (0x1) +__ulonglong 0x8000 < 0xa == 0x0 (0x0) +float 0x8000 < 0xa == 0x1 (0x1) +int 0x8000 > 0xa == 0x0 (0x0) +__uint 0x8000 > 0xa == 0x1 (0x1) +char 0x0 > 0xa == 0x0 (0x0) +__uchar 0x0 > 0xa == 0x0 (0x0) +__longlong 0x8000 > 0xa == 0x0 (0x0) +__ulonglong 0x8000 > 0xa == 0x1 (0x1) +float 0x8000 > 0xa == 0x0 (0x0) +int 0x8000 <= 0xa == 0x1 (0x1) +__uint 0x8000 <= 0xa == 0x0 (0x0) +char 0x0 <= 0xa == 0x1 (0x1) +__uchar 0x0 <= 0xa == 0x1 (0x1) +__longlong 0x8000 <= 0xa == 0x1 (0x1) +__ulonglong 0x8000 <= 0xa == 0x0 (0x0) +float 0x8000 <= 0xa == 0x1 (0x1) +int 0x8000 == 0xa == 0x0 (0x0) +__uint 0x8000 == 0xa == 0x0 (0x0) +char 0x0 == 0xa == 0x0 (0x0) +__uchar 0x0 == 0xa == 0x0 (0x0) +__longlong 0x8000 == 0xa == 0x0 (0x0) +__ulonglong 0x8000 == 0xa == 0x0 (0x0) +float 0x8000 == 0xa == 0x0 (0x0) +int 0x8000 != 0xa == 0x1 (0x1) +__uint 0x8000 != 0xa == 0x1 (0x1) +char 0x0 != 0xa == 0x1 (0x1) +__uchar 0x0 != 0xa == 0x1 (0x1) +__longlong 0x8000 != 0xa == 0x1 (0x1) +__ulonglong 0x8000 != 0xa == 0x1 (0x1) +float 0x8000 != 0xa == 0x1 (0x1) +int 0x8000 >= 0xa == 0x0 (0x0) +__uint 0x8000 >= 0xa == 0x1 (0x1) +char 0x0 >= 0xa == 0x0 (0x0) +__uchar 0x0 >= 0xa == 0x0 (0x0) +__longlong 0x8000 >= 0xa == 0x0 (0x0) +__ulonglong 0x8000 >= 0xa == 0x1 (0x1) +float 0x8000 >= 0xa == 0x0 (0x0) +int 0x8000 / 0xa == -0xccc (0xf334) +__uint 0x8000 / 0xa == 0xccc (0xccc) +char 0x0 / 0xa == 0x0 (0x0) +__uchar 0x0 / 0xa == 0x0 (0x0) +__longlong 0x8000 / 0xa == -0xccc (0xf334) +__ulonglong 0x8000 / 0xa == -0x7334 (0x8ccc) +float 0x8000 / 0xa == -0xccc (0xf334) +int 0x8000 % 0xa == -0x8 (0xfff8) +__uint 0x8000 % 0xa == 0x8 (0x8) +char 0x0 % 0xa == 0x0 (0x0) +__uchar 0x0 % 0xa == 0x0 (0x0) +__longlong 0x8000 % 0xa == -0x8 (0xfff8) +__ulonglong 0x8000 % 0xa == 0x8 (0x8) +0x8000 * 0xfff6 == 0x0 +0x8000 / 0xfff6 == 0xccc +0x8000 % 0xfff6 == -0x8 +int 0x8000 ^ 0xfff6 == 0x7ff6 (0x7ff6) +__uint 0x8000 ^ 0xfff6 == 0x7ff6 (0x7ff6) +char 0x0 ^ 0xfff6 == -0xa (0xfff6) +__uchar 0x0 ^ 0xf6 == 0xf6 (0xf6) +__longlong 0x8000 ^ 0xfff6 == 0x7ff6 (0x7ff6) +__ulonglong 0x8000 ^ 0xfff6 == 0x7ff6 (0x7ff6) +int 0x8000 && 0xfff6 == 0x1 (0x1) +__uint 0x8000 && 0xfff6 == 0x1 (0x1) +char 0x0 && 0xfff6 == 0x0 (0x0) +__uchar 0x0 && 0xf6 == 0x0 (0x0) +__longlong 0x8000 && 0xfff6 == 0x1 (0x1) +__ulonglong 0x8000 && 0xfff6 == 0x1 (0x1) +int 0x8000 || 0xfff6 == 0x1 (0x1) +__uint 0x8000 || 0xfff6 == 0x1 (0x1) +char 0x0 || 0xfff6 == 0x1 (0x1) +__uchar 0x0 || 0xf6 == 0x1 (0x1) +__longlong 0x8000 || 0xfff6 == 0x1 (0x1) +__ulonglong 0x8000 || 0xfff6 == 0x1 (0x1) +int 0x8000 & 0xfff6 == -0x8000 (0x8000) +__uint 0x8000 & 0xfff6 == -0x8000 (0x8000) +char 0x0 & 0xfff6 == 0x0 (0x0) +__uchar 0x0 & 0xf6 == 0x0 (0x0) +__longlong 0x8000 & 0xfff6 == -0x8000 (0x8000) +__ulonglong 0x8000 & 0xfff6 == -0x8000 (0x8000) +int 0x8000 | 0xfff6 == -0xa (0xfff6) +__uint 0x8000 | 0xfff6 == -0xa (0xfff6) +char 0x0 | 0xfff6 == -0xa (0xfff6) +__uchar 0x0 | 0xf6 == 0xf6 (0xf6) +__longlong 0x8000 | 0xfff6 == -0xa (0xfff6) +__ulonglong 0x8000 | 0xfff6 == -0xa (0xfff6) +int 0x8000 << 0x8 == 0x0 (0x0) +__uint 0x8000 << 0x8 == 0x0 (0x0) +char 0x0 << 0x8 == 0x0 (0x0) +__uchar 0x0 << 0x8 == 0x0 (0x0) +__longlong 0x8000 << 0x8 == 0x0 (0x0) +__ulonglong 0x8000 << 0x8 == 0x0 (0x0) +int 0x8000 >> 0x8 == -0x80 (0xff80) +__uint 0x8000 >> 0x8 == 0x80 (0x80) +char 0x0 >> 0x8 == 0x0 (0x0) +__uchar 0x0 >> 0x8 == 0x0 (0x0) +__longlong 0x8000 >> 0x8 == -0x80 (0xff80) +__ulonglong 0x8000 >> 0x8 == -0x80 (0xff80) +int 0x8000 + 0xfff6 == 0x7ff6 (0x7ff6) +__uint 0x8000 + 0xfff6 == 0x7ff6 (0x7ff6) +char 0x0 + 0xfff6 == -0xa (0xfff6) +__uchar 0x0 + 0xf6 == 0xf6 (0xf6) +__longlong 0x8000 + 0xfff6 == 0x7ff6 (0x7ff6) +__ulonglong 0x8000 + 0xfff6 == 0x7ff6 (0x7ff6) +float 0x8000 + 0xfff6 == 0x7ff6 (0x7ff6) +int 0x8000 - 0xfff6 == -0x7ff6 (0x800a) +__uint 0x8000 - 0xfff6 == -0x7ff6 (0x800a) +char 0x0 - 0xfff6 == 0xa (0xa) +__uchar 0x0 - 0xf6 == 0xa (0xa) +__longlong 0x8000 - 0xfff6 == -0x7ff6 (0x800a) +__ulonglong 0x8000 - 0xfff6 == -0x7ff6 (0x800a) +float 0x8000 - 0xfff6 == -0x7ff6 (0x800a) +int 0x8000 * 0xfff6 == 0x0 (0x0) +__uint 0x8000 * 0xfff6 == 0x0 (0x0) +char 0x0 * 0xfff6 == 0x0 (0x0) +__uchar 0x0 * 0xf6 == 0x0 (0x0) +__longlong 0x8000 * 0xfff6 == 0x0 (0x0) +__ulonglong 0x8000 * 0xfff6 == 0x0 (0x0) +float 0x8000 * 0xfff6 == 0x0 (0x0) +int 0x8000 < 0xfff6 == 0x1 (0x1) +__uint 0x8000 < 0xfff6 == 0x1 (0x1) +char 0x0 < 0xfff6 == 0x0 (0x0) +__uchar 0x0 < 0xf6 == 0x1 (0x1) +__longlong 0x8000 < 0xfff6 == 0x1 (0x1) +__ulonglong 0x8000 < 0xfff6 == 0x1 (0x1) +float 0x8000 < 0xfff6 == 0x1 (0x1) +int 0x8000 > 0xfff6 == 0x0 (0x0) +__uint 0x8000 > 0xfff6 == 0x0 (0x0) +char 0x0 > 0xfff6 == 0x1 (0x1) +__uchar 0x0 > 0xf6 == 0x0 (0x0) +__longlong 0x8000 > 0xfff6 == 0x0 (0x0) +__ulonglong 0x8000 > 0xfff6 == 0x0 (0x0) +float 0x8000 > 0xfff6 == 0x0 (0x0) +int 0x8000 <= 0xfff6 == 0x1 (0x1) +__uint 0x8000 <= 0xfff6 == 0x1 (0x1) +char 0x0 <= 0xfff6 == 0x0 (0x0) +__uchar 0x0 <= 0xf6 == 0x1 (0x1) +__longlong 0x8000 <= 0xfff6 == 0x1 (0x1) +__ulonglong 0x8000 <= 0xfff6 == 0x1 (0x1) +float 0x8000 <= 0xfff6 == 0x1 (0x1) +int 0x8000 == 0xfff6 == 0x0 (0x0) +__uint 0x8000 == 0xfff6 == 0x0 (0x0) +char 0x0 == 0xfff6 == 0x0 (0x0) +__uchar 0x0 == 0xf6 == 0x0 (0x0) +__longlong 0x8000 == 0xfff6 == 0x0 (0x0) +__ulonglong 0x8000 == 0xfff6 == 0x0 (0x0) +float 0x8000 == 0xfff6 == 0x0 (0x0) +int 0x8000 != 0xfff6 == 0x1 (0x1) +__uint 0x8000 != 0xfff6 == 0x1 (0x1) +char 0x0 != 0xfff6 == 0x1 (0x1) +__uchar 0x0 != 0xf6 == 0x1 (0x1) +__longlong 0x8000 != 0xfff6 == 0x1 (0x1) +__ulonglong 0x8000 != 0xfff6 == 0x1 (0x1) +float 0x8000 != 0xfff6 == 0x1 (0x1) +int 0x8000 >= 0xfff6 == 0x0 (0x0) +__uint 0x8000 >= 0xfff6 == 0x0 (0x0) +char 0x0 >= 0xfff6 == 0x1 (0x1) +__uchar 0x0 >= 0xf6 == 0x0 (0x0) +__longlong 0x8000 >= 0xfff6 == 0x0 (0x0) +__ulonglong 0x8000 >= 0xfff6 == 0x0 (0x0) +float 0x8000 >= 0xfff6 == 0x0 (0x0) +int 0x8000 / 0xfff6 == 0xccc (0xccc) +__uint 0x8000 / 0xfff6 == 0x0 (0x0) +char 0x0 / 0xfff6 == 0x0 (0x0) +__uchar 0x0 / 0xf6 == 0x0 (0x0) +__longlong 0x8000 / 0xfff6 == 0xccc (0xccc) +__ulonglong 0x8000 / 0xfff6 == 0x0 (0x0) +float 0x8000 / 0xfff6 == 0xccc (0xccc) +int 0x8000 % 0xfff6 == -0x8 (0xfff8) +__uint 0x8000 % 0xfff6 == -0x8000 (0x8000) +char 0x0 % 0xfff6 == 0x0 (0x0) +__uchar 0x0 % 0xf6 == 0x0 (0x0) +__longlong 0x8000 % 0xfff6 == -0x8 (0xfff8) +__ulonglong 0x8000 % 0xfff6 == -0x8000 (0x8000) +0x8000 * 0x5 == -0x8000 +0x8000 / 0x5 == -0x1999 +0x8000 % 0x5 == -0x3 +int 0x8000 ^ 0x5 == -0x7ffb (0x8005) +__uint 0x8000 ^ 0x5 == -0x7ffb (0x8005) +char 0x0 ^ 0x5 == 0x5 (0x5) +__uchar 0x0 ^ 0x5 == 0x5 (0x5) +__longlong 0x8000 ^ 0x5 == -0x7ffb (0x8005) +__ulonglong 0x8000 ^ 0x5 == -0x7ffb (0x8005) +int 0x8000 && 0x5 == 0x1 (0x1) +__uint 0x8000 && 0x5 == 0x1 (0x1) +char 0x0 && 0x5 == 0x0 (0x0) +__uchar 0x0 && 0x5 == 0x0 (0x0) +__longlong 0x8000 && 0x5 == 0x1 (0x1) +__ulonglong 0x8000 && 0x5 == 0x1 (0x1) +int 0x8000 || 0x5 == 0x1 (0x1) +__uint 0x8000 || 0x5 == 0x1 (0x1) +char 0x0 || 0x5 == 0x1 (0x1) +__uchar 0x0 || 0x5 == 0x1 (0x1) +__longlong 0x8000 || 0x5 == 0x1 (0x1) +__ulonglong 0x8000 || 0x5 == 0x1 (0x1) +int 0x8000 & 0x5 == 0x0 (0x0) +__uint 0x8000 & 0x5 == 0x0 (0x0) +char 0x0 & 0x5 == 0x0 (0x0) +__uchar 0x0 & 0x5 == 0x0 (0x0) +__longlong 0x8000 & 0x5 == 0x0 (0x0) +__ulonglong 0x8000 & 0x5 == 0x0 (0x0) +int 0x8000 | 0x5 == -0x7ffb (0x8005) +__uint 0x8000 | 0x5 == -0x7ffb (0x8005) +char 0x0 | 0x5 == 0x5 (0x5) +__uchar 0x0 | 0x5 == 0x5 (0x5) +__longlong 0x8000 | 0x5 == -0x7ffb (0x8005) +__ulonglong 0x8000 | 0x5 == -0x7ffb (0x8005) +int 0x8000 << 0x9 == 0x0 (0x0) +__uint 0x8000 << 0x9 == 0x0 (0x0) +char 0x0 << 0x9 == 0x0 (0x0) +__uchar 0x0 << 0x9 == 0x0 (0x0) +__longlong 0x8000 << 0x9 == 0x0 (0x0) +__ulonglong 0x8000 << 0x9 == 0x0 (0x0) +int 0x8000 >> 0x9 == -0x40 (0xffc0) +__uint 0x8000 >> 0x9 == 0x40 (0x40) +char 0x0 >> 0x9 == 0x0 (0x0) +__uchar 0x0 >> 0x9 == 0x0 (0x0) +__longlong 0x8000 >> 0x9 == -0x40 (0xffc0) +__ulonglong 0x8000 >> 0x9 == -0x40 (0xffc0) +int 0x8000 + 0x5 == -0x7ffb (0x8005) +__uint 0x8000 + 0x5 == -0x7ffb (0x8005) +char 0x0 + 0x5 == 0x5 (0x5) +__uchar 0x0 + 0x5 == 0x5 (0x5) +__longlong 0x8000 + 0x5 == -0x7ffb (0x8005) +__ulonglong 0x8000 + 0x5 == -0x7ffb (0x8005) +float 0x8000 + 0x5 == -0x7ffb (0x8005) +int 0x8000 - 0x5 == 0x7ffb (0x7ffb) +__uint 0x8000 - 0x5 == 0x7ffb (0x7ffb) +char 0x0 - 0x5 == -0x5 (0xfffb) +__uchar 0x0 - 0x5 == 0xfb (0xfb) +__longlong 0x8000 - 0x5 == 0x7ffb (0x7ffb) +__ulonglong 0x8000 - 0x5 == 0x7ffb (0x7ffb) +float 0x8000 - 0x5 == 0x7ffb (0x7ffb) +int 0x8000 * 0x5 == -0x8000 (0x8000) +__uint 0x8000 * 0x5 == -0x8000 (0x8000) +char 0x0 * 0x5 == 0x0 (0x0) +__uchar 0x0 * 0x5 == 0x0 (0x0) +__longlong 0x8000 * 0x5 == -0x8000 (0x8000) +__ulonglong 0x8000 * 0x5 == -0x8000 (0x8000) +float 0x8000 * 0x5 == -0x8000 (0x8000) +int 0x8000 < 0x5 == 0x1 (0x1) +__uint 0x8000 < 0x5 == 0x0 (0x0) +char 0x0 < 0x5 == 0x1 (0x1) +__uchar 0x0 < 0x5 == 0x1 (0x1) +__longlong 0x8000 < 0x5 == 0x1 (0x1) +__ulonglong 0x8000 < 0x5 == 0x0 (0x0) +float 0x8000 < 0x5 == 0x1 (0x1) +int 0x8000 > 0x5 == 0x0 (0x0) +__uint 0x8000 > 0x5 == 0x1 (0x1) +char 0x0 > 0x5 == 0x0 (0x0) +__uchar 0x0 > 0x5 == 0x0 (0x0) +__longlong 0x8000 > 0x5 == 0x0 (0x0) +__ulonglong 0x8000 > 0x5 == 0x1 (0x1) +float 0x8000 > 0x5 == 0x0 (0x0) +int 0x8000 <= 0x5 == 0x1 (0x1) +__uint 0x8000 <= 0x5 == 0x0 (0x0) +char 0x0 <= 0x5 == 0x1 (0x1) +__uchar 0x0 <= 0x5 == 0x1 (0x1) +__longlong 0x8000 <= 0x5 == 0x1 (0x1) +__ulonglong 0x8000 <= 0x5 == 0x0 (0x0) +float 0x8000 <= 0x5 == 0x1 (0x1) +int 0x8000 == 0x5 == 0x0 (0x0) +__uint 0x8000 == 0x5 == 0x0 (0x0) +char 0x0 == 0x5 == 0x0 (0x0) +__uchar 0x0 == 0x5 == 0x0 (0x0) +__longlong 0x8000 == 0x5 == 0x0 (0x0) +__ulonglong 0x8000 == 0x5 == 0x0 (0x0) +float 0x8000 == 0x5 == 0x0 (0x0) +int 0x8000 != 0x5 == 0x1 (0x1) +__uint 0x8000 != 0x5 == 0x1 (0x1) +char 0x0 != 0x5 == 0x1 (0x1) +__uchar 0x0 != 0x5 == 0x1 (0x1) +__longlong 0x8000 != 0x5 == 0x1 (0x1) +__ulonglong 0x8000 != 0x5 == 0x1 (0x1) +float 0x8000 != 0x5 == 0x1 (0x1) +int 0x8000 >= 0x5 == 0x0 (0x0) +__uint 0x8000 >= 0x5 == 0x1 (0x1) +char 0x0 >= 0x5 == 0x0 (0x0) +__uchar 0x0 >= 0x5 == 0x0 (0x0) +__longlong 0x8000 >= 0x5 == 0x0 (0x0) +__ulonglong 0x8000 >= 0x5 == 0x1 (0x1) +float 0x8000 >= 0x5 == 0x0 (0x0) +int 0x8000 / 0x5 == -0x1999 (0xe667) +__uint 0x8000 / 0x5 == 0x1999 (0x1999) +char 0x0 / 0x5 == 0x0 (0x0) +__uchar 0x0 / 0x5 == 0x0 (0x0) +__longlong 0x8000 / 0x5 == -0x1999 (0xe667) +__ulonglong 0x8000 / 0x5 == 0x1999 (0x1999) +float 0x8000 / 0x5 == -0x1999 (0xe667) +int 0x8000 % 0x5 == -0x3 (0xfffd) +__uint 0x8000 % 0x5 == 0x3 (0x3) +char 0x0 % 0x5 == 0x0 (0x0) +__uchar 0x0 % 0x5 == 0x0 (0x0) +__longlong 0x8000 % 0x5 == -0x3 (0xfffd) +__ulonglong 0x8000 % 0x5 == 0x3 (0x3) +0x8000 * 0x7 == -0x8000 +0x8000 / 0x7 == -0x1249 +0x8000 % 0x7 == -0x1 +int 0x8000 ^ 0x7 == -0x7ff9 (0x8007) +__uint 0x8000 ^ 0x7 == -0x7ff9 (0x8007) +char 0x0 ^ 0x7 == 0x7 (0x7) +__uchar 0x0 ^ 0x7 == 0x7 (0x7) +__longlong 0x8000 ^ 0x7 == -0x7ff9 (0x8007) +__ulonglong 0x8000 ^ 0x7 == -0x7ff9 (0x8007) +int 0x8000 && 0x7 == 0x1 (0x1) +__uint 0x8000 && 0x7 == 0x1 (0x1) +char 0x0 && 0x7 == 0x0 (0x0) +__uchar 0x0 && 0x7 == 0x0 (0x0) +__longlong 0x8000 && 0x7 == 0x1 (0x1) +__ulonglong 0x8000 && 0x7 == 0x1 (0x1) +int 0x8000 || 0x7 == 0x1 (0x1) +__uint 0x8000 || 0x7 == 0x1 (0x1) +char 0x0 || 0x7 == 0x1 (0x1) +__uchar 0x0 || 0x7 == 0x1 (0x1) +__longlong 0x8000 || 0x7 == 0x1 (0x1) +__ulonglong 0x8000 || 0x7 == 0x1 (0x1) +int 0x8000 & 0x7 == 0x0 (0x0) +__uint 0x8000 & 0x7 == 0x0 (0x0) +char 0x0 & 0x7 == 0x0 (0x0) +__uchar 0x0 & 0x7 == 0x0 (0x0) +__longlong 0x8000 & 0x7 == 0x0 (0x0) +__ulonglong 0x8000 & 0x7 == 0x0 (0x0) +int 0x8000 | 0x7 == -0x7ff9 (0x8007) +__uint 0x8000 | 0x7 == -0x7ff9 (0x8007) +char 0x0 | 0x7 == 0x7 (0x7) +__uchar 0x0 | 0x7 == 0x7 (0x7) +__longlong 0x8000 | 0x7 == -0x7ff9 (0x8007) +__ulonglong 0x8000 | 0x7 == -0x7ff9 (0x8007) +int 0x8000 << 0xa == 0x0 (0x0) +__uint 0x8000 << 0xa == 0x0 (0x0) +char 0x0 << 0xa == 0x0 (0x0) +__uchar 0x0 << 0xa == 0x0 (0x0) +__longlong 0x8000 << 0xa == 0x0 (0x0) +__ulonglong 0x8000 << 0xa == 0x0 (0x0) +int 0x8000 >> 0xa == -0x20 (0xffe0) +__uint 0x8000 >> 0xa == 0x20 (0x20) +char 0x0 >> 0xa == 0x0 (0x0) +__uchar 0x0 >> 0xa == 0x0 (0x0) +__longlong 0x8000 >> 0xa == -0x20 (0xffe0) +__ulonglong 0x8000 >> 0xa == -0x20 (0xffe0) +int 0x8000 + 0x7 == -0x7ff9 (0x8007) +__uint 0x8000 + 0x7 == -0x7ff9 (0x8007) +char 0x0 + 0x7 == 0x7 (0x7) +__uchar 0x0 + 0x7 == 0x7 (0x7) +__longlong 0x8000 + 0x7 == -0x7ff9 (0x8007) +__ulonglong 0x8000 + 0x7 == -0x7ff9 (0x8007) +float 0x8000 + 0x7 == -0x7ff9 (0x8007) +int 0x8000 - 0x7 == 0x7ff9 (0x7ff9) +__uint 0x8000 - 0x7 == 0x7ff9 (0x7ff9) +char 0x0 - 0x7 == -0x7 (0xfff9) +__uchar 0x0 - 0x7 == 0xf9 (0xf9) +__longlong 0x8000 - 0x7 == 0x7ff9 (0x7ff9) +__ulonglong 0x8000 - 0x7 == 0x7ff9 (0x7ff9) +float 0x8000 - 0x7 == 0x7ff9 (0x7ff9) +int 0x8000 * 0x7 == -0x8000 (0x8000) +__uint 0x8000 * 0x7 == -0x8000 (0x8000) +char 0x0 * 0x7 == 0x0 (0x0) +__uchar 0x0 * 0x7 == 0x0 (0x0) +__longlong 0x8000 * 0x7 == -0x8000 (0x8000) +__ulonglong 0x8000 * 0x7 == -0x8000 (0x8000) +float 0x8000 * 0x7 == -0x8000 (0x8000) +int 0x8000 < 0x7 == 0x1 (0x1) +__uint 0x8000 < 0x7 == 0x0 (0x0) +char 0x0 < 0x7 == 0x1 (0x1) +__uchar 0x0 < 0x7 == 0x1 (0x1) +__longlong 0x8000 < 0x7 == 0x1 (0x1) +__ulonglong 0x8000 < 0x7 == 0x0 (0x0) +float 0x8000 < 0x7 == 0x1 (0x1) +int 0x8000 > 0x7 == 0x0 (0x0) +__uint 0x8000 > 0x7 == 0x1 (0x1) +char 0x0 > 0x7 == 0x0 (0x0) +__uchar 0x0 > 0x7 == 0x0 (0x0) +__longlong 0x8000 > 0x7 == 0x0 (0x0) +__ulonglong 0x8000 > 0x7 == 0x1 (0x1) +float 0x8000 > 0x7 == 0x0 (0x0) +int 0x8000 <= 0x7 == 0x1 (0x1) +__uint 0x8000 <= 0x7 == 0x0 (0x0) +char 0x0 <= 0x7 == 0x1 (0x1) +__uchar 0x0 <= 0x7 == 0x1 (0x1) +__longlong 0x8000 <= 0x7 == 0x1 (0x1) +__ulonglong 0x8000 <= 0x7 == 0x0 (0x0) +float 0x8000 <= 0x7 == 0x1 (0x1) +int 0x8000 == 0x7 == 0x0 (0x0) +__uint 0x8000 == 0x7 == 0x0 (0x0) +char 0x0 == 0x7 == 0x0 (0x0) +__uchar 0x0 == 0x7 == 0x0 (0x0) +__longlong 0x8000 == 0x7 == 0x0 (0x0) +__ulonglong 0x8000 == 0x7 == 0x0 (0x0) +float 0x8000 == 0x7 == 0x0 (0x0) +int 0x8000 != 0x7 == 0x1 (0x1) +__uint 0x8000 != 0x7 == 0x1 (0x1) +char 0x0 != 0x7 == 0x1 (0x1) +__uchar 0x0 != 0x7 == 0x1 (0x1) +__longlong 0x8000 != 0x7 == 0x1 (0x1) +__ulonglong 0x8000 != 0x7 == 0x1 (0x1) +float 0x8000 != 0x7 == 0x1 (0x1) +int 0x8000 >= 0x7 == 0x0 (0x0) +__uint 0x8000 >= 0x7 == 0x1 (0x1) +char 0x0 >= 0x7 == 0x0 (0x0) +__uchar 0x0 >= 0x7 == 0x0 (0x0) +__longlong 0x8000 >= 0x7 == 0x0 (0x0) +__ulonglong 0x8000 >= 0x7 == 0x1 (0x1) +float 0x8000 >= 0x7 == 0x0 (0x0) +int 0x8000 / 0x7 == -0x1249 (0xedb7) +__uint 0x8000 / 0x7 == 0x1249 (0x1249) +char 0x0 / 0x7 == 0x0 (0x0) +__uchar 0x0 / 0x7 == 0x0 (0x0) +__longlong 0x8000 / 0x7 == -0x1249 (0xedb7) +__ulonglong 0x8000 / 0x7 == 0x36db (0x36db) +float 0x8000 / 0x7 == -0x1249 (0xedb7) +int 0x8000 % 0x7 == -0x1 (0xffff) +__uint 0x8000 % 0x7 == 0x1 (0x1) +char 0x0 % 0x7 == 0x0 (0x0) +__uchar 0x0 % 0x7 == 0x0 (0x0) +__longlong 0x8000 % 0x7 == -0x1 (0xffff) +__ulonglong 0x8000 % 0x7 == 0x3 (0x3) +0x8000 * 0x2a == 0x0 +0x8000 / 0x2a == -0x30c +0x8000 % 0x2a == -0x8 +int 0x8000 ^ 0x2a == -0x7fd6 (0x802a) +__uint 0x8000 ^ 0x2a == -0x7fd6 (0x802a) +char 0x0 ^ 0x2a == 0x2a (0x2a) +__uchar 0x0 ^ 0x2a == 0x2a (0x2a) +__longlong 0x8000 ^ 0x2a == -0x7fd6 (0x802a) +__ulonglong 0x8000 ^ 0x2a == -0x7fd6 (0x802a) +int 0x8000 && 0x2a == 0x1 (0x1) +__uint 0x8000 && 0x2a == 0x1 (0x1) +char 0x0 && 0x2a == 0x0 (0x0) +__uchar 0x0 && 0x2a == 0x0 (0x0) +__longlong 0x8000 && 0x2a == 0x1 (0x1) +__ulonglong 0x8000 && 0x2a == 0x1 (0x1) +int 0x8000 || 0x2a == 0x1 (0x1) +__uint 0x8000 || 0x2a == 0x1 (0x1) +char 0x0 || 0x2a == 0x1 (0x1) +__uchar 0x0 || 0x2a == 0x1 (0x1) +__longlong 0x8000 || 0x2a == 0x1 (0x1) +__ulonglong 0x8000 || 0x2a == 0x1 (0x1) +int 0x8000 & 0x2a == 0x0 (0x0) +__uint 0x8000 & 0x2a == 0x0 (0x0) +char 0x0 & 0x2a == 0x0 (0x0) +__uchar 0x0 & 0x2a == 0x0 (0x0) +__longlong 0x8000 & 0x2a == 0x0 (0x0) +__ulonglong 0x8000 & 0x2a == 0x0 (0x0) +int 0x8000 | 0x2a == -0x7fd6 (0x802a) +__uint 0x8000 | 0x2a == -0x7fd6 (0x802a) +char 0x0 | 0x2a == 0x2a (0x2a) +__uchar 0x0 | 0x2a == 0x2a (0x2a) +__longlong 0x8000 | 0x2a == -0x7fd6 (0x802a) +__ulonglong 0x8000 | 0x2a == -0x7fd6 (0x802a) +int 0x8000 << 0xc == 0x0 (0x0) +__uint 0x8000 << 0xc == 0x0 (0x0) +char 0x0 << 0xc == 0x0 (0x0) +__uchar 0x0 << 0xc == 0x0 (0x0) +__longlong 0x8000 << 0xc == 0x0 (0x0) +__ulonglong 0x8000 << 0xc == 0x0 (0x0) +int 0x8000 >> 0xc == -0x8 (0xfff8) +__uint 0x8000 >> 0xc == 0x8 (0x8) +char 0x0 >> 0xc == 0x0 (0x0) +__uchar 0x0 >> 0xc == 0x0 (0x0) +__longlong 0x8000 >> 0xc == -0x8 (0xfff8) +__ulonglong 0x8000 >> 0xc == -0x8 (0xfff8) +int 0x8000 + 0x2a == -0x7fd6 (0x802a) +__uint 0x8000 + 0x2a == -0x7fd6 (0x802a) +char 0x0 + 0x2a == 0x2a (0x2a) +__uchar 0x0 + 0x2a == 0x2a (0x2a) +__longlong 0x8000 + 0x2a == -0x7fd6 (0x802a) +__ulonglong 0x8000 + 0x2a == -0x7fd6 (0x802a) +float 0x8000 + 0x2a == -0x7fd6 (0x802a) +int 0x8000 - 0x2a == 0x7fd6 (0x7fd6) +__uint 0x8000 - 0x2a == 0x7fd6 (0x7fd6) +char 0x0 - 0x2a == -0x2a (0xffd6) +__uchar 0x0 - 0x2a == 0xd6 (0xd6) +__longlong 0x8000 - 0x2a == 0x7fd6 (0x7fd6) +__ulonglong 0x8000 - 0x2a == 0x7fd6 (0x7fd6) +float 0x8000 - 0x2a == 0x7fd6 (0x7fd6) +int 0x8000 * 0x2a == 0x0 (0x0) +__uint 0x8000 * 0x2a == 0x0 (0x0) +char 0x0 * 0x2a == 0x0 (0x0) +__uchar 0x0 * 0x2a == 0x0 (0x0) +__longlong 0x8000 * 0x2a == 0x0 (0x0) +__ulonglong 0x8000 * 0x2a == 0x0 (0x0) +float 0x8000 * 0x2a == 0x0 (0x0) +int 0x8000 < 0x2a == 0x1 (0x1) +__uint 0x8000 < 0x2a == 0x0 (0x0) +char 0x0 < 0x2a == 0x1 (0x1) +__uchar 0x0 < 0x2a == 0x1 (0x1) +__longlong 0x8000 < 0x2a == 0x1 (0x1) +__ulonglong 0x8000 < 0x2a == 0x0 (0x0) +float 0x8000 < 0x2a == 0x1 (0x1) +int 0x8000 > 0x2a == 0x0 (0x0) +__uint 0x8000 > 0x2a == 0x1 (0x1) +char 0x0 > 0x2a == 0x0 (0x0) +__uchar 0x0 > 0x2a == 0x0 (0x0) +__longlong 0x8000 > 0x2a == 0x0 (0x0) +__ulonglong 0x8000 > 0x2a == 0x1 (0x1) +float 0x8000 > 0x2a == 0x0 (0x0) +int 0x8000 <= 0x2a == 0x1 (0x1) +__uint 0x8000 <= 0x2a == 0x0 (0x0) +char 0x0 <= 0x2a == 0x1 (0x1) +__uchar 0x0 <= 0x2a == 0x1 (0x1) +__longlong 0x8000 <= 0x2a == 0x1 (0x1) +__ulonglong 0x8000 <= 0x2a == 0x0 (0x0) +float 0x8000 <= 0x2a == 0x1 (0x1) +int 0x8000 == 0x2a == 0x0 (0x0) +__uint 0x8000 == 0x2a == 0x0 (0x0) +char 0x0 == 0x2a == 0x0 (0x0) +__uchar 0x0 == 0x2a == 0x0 (0x0) +__longlong 0x8000 == 0x2a == 0x0 (0x0) +__ulonglong 0x8000 == 0x2a == 0x0 (0x0) +float 0x8000 == 0x2a == 0x0 (0x0) +int 0x8000 != 0x2a == 0x1 (0x1) +__uint 0x8000 != 0x2a == 0x1 (0x1) +char 0x0 != 0x2a == 0x1 (0x1) +__uchar 0x0 != 0x2a == 0x1 (0x1) +__longlong 0x8000 != 0x2a == 0x1 (0x1) +__ulonglong 0x8000 != 0x2a == 0x1 (0x1) +float 0x8000 != 0x2a == 0x1 (0x1) +int 0x8000 >= 0x2a == 0x0 (0x0) +__uint 0x8000 >= 0x2a == 0x1 (0x1) +char 0x0 >= 0x2a == 0x0 (0x0) +__uchar 0x0 >= 0x2a == 0x0 (0x0) +__longlong 0x8000 >= 0x2a == 0x0 (0x0) +__ulonglong 0x8000 >= 0x2a == 0x1 (0x1) +float 0x8000 >= 0x2a == 0x0 (0x0) +int 0x8000 / 0x2a == -0x30c (0xfcf4) +__uint 0x8000 / 0x2a == 0x30c (0x30c) +char 0x0 / 0x2a == 0x0 (0x0) +__uchar 0x0 / 0x2a == 0x0 (0x0) +__longlong 0x8000 / 0x2a == -0x30c (0xfcf4) +__ulonglong 0x8000 / 0x2a == 0x5e79 (0x5e79) +float 0x8000 / 0x2a == -0x30c (0xfcf4) +int 0x8000 % 0x2a == -0x8 (0xfff8) +__uint 0x8000 % 0x2a == 0x8 (0x8) +char 0x0 % 0x2a == 0x0 (0x0) +__uchar 0x0 % 0x2a == 0x0 (0x0) +__longlong 0x8000 % 0x2a == -0x8 (0xfff8) +__ulonglong 0x8000 % 0x2a == 0x26 (0x26) +0x8000 * 0x17 == -0x8000 +0x8000 / 0x17 == -0x590 +0x8000 % 0x17 == -0x10 +int 0x8000 ^ 0x17 == -0x7fe9 (0x8017) +__uint 0x8000 ^ 0x17 == -0x7fe9 (0x8017) +char 0x0 ^ 0x17 == 0x17 (0x17) +__uchar 0x0 ^ 0x17 == 0x17 (0x17) +__longlong 0x8000 ^ 0x17 == -0x7fe9 (0x8017) +__ulonglong 0x8000 ^ 0x17 == -0x7fe9 (0x8017) +int 0x8000 && 0x17 == 0x1 (0x1) +__uint 0x8000 && 0x17 == 0x1 (0x1) +char 0x0 && 0x17 == 0x0 (0x0) +__uchar 0x0 && 0x17 == 0x0 (0x0) +__longlong 0x8000 && 0x17 == 0x1 (0x1) +__ulonglong 0x8000 && 0x17 == 0x1 (0x1) +int 0x8000 || 0x17 == 0x1 (0x1) +__uint 0x8000 || 0x17 == 0x1 (0x1) +char 0x0 || 0x17 == 0x1 (0x1) +__uchar 0x0 || 0x17 == 0x1 (0x1) +__longlong 0x8000 || 0x17 == 0x1 (0x1) +__ulonglong 0x8000 || 0x17 == 0x1 (0x1) +int 0x8000 & 0x17 == 0x0 (0x0) +__uint 0x8000 & 0x17 == 0x0 (0x0) +char 0x0 & 0x17 == 0x0 (0x0) +__uchar 0x0 & 0x17 == 0x0 (0x0) +__longlong 0x8000 & 0x17 == 0x0 (0x0) +__ulonglong 0x8000 & 0x17 == 0x0 (0x0) +int 0x8000 | 0x17 == -0x7fe9 (0x8017) +__uint 0x8000 | 0x17 == -0x7fe9 (0x8017) +char 0x0 | 0x17 == 0x17 (0x17) +__uchar 0x0 | 0x17 == 0x17 (0x17) +__longlong 0x8000 | 0x17 == -0x7fe9 (0x8017) +__ulonglong 0x8000 | 0x17 == -0x7fe9 (0x8017) +int 0x8000 << 0xe == 0x0 (0x0) +__uint 0x8000 << 0xe == 0x0 (0x0) +char 0x0 << 0xe == 0x0 (0x0) +__uchar 0x0 << 0xe == 0x0 (0x0) +__longlong 0x8000 << 0xe == 0x0 (0x0) +__ulonglong 0x8000 << 0xe == 0x0 (0x0) +int 0x8000 >> 0xe == -0x2 (0xfffe) +__uint 0x8000 >> 0xe == 0x2 (0x2) +char 0x0 >> 0xe == 0x0 (0x0) +__uchar 0x0 >> 0xe == 0x0 (0x0) +__longlong 0x8000 >> 0xe == -0x2 (0xfffe) +__ulonglong 0x8000 >> 0xe == -0x2 (0xfffe) +int 0x8000 + 0x17 == -0x7fe9 (0x8017) +__uint 0x8000 + 0x17 == -0x7fe9 (0x8017) +char 0x0 + 0x17 == 0x17 (0x17) +__uchar 0x0 + 0x17 == 0x17 (0x17) +__longlong 0x8000 + 0x17 == -0x7fe9 (0x8017) +__ulonglong 0x8000 + 0x17 == -0x7fe9 (0x8017) +float 0x8000 + 0x17 == -0x7fe9 (0x8017) +int 0x8000 - 0x17 == 0x7fe9 (0x7fe9) +__uint 0x8000 - 0x17 == 0x7fe9 (0x7fe9) +char 0x0 - 0x17 == -0x17 (0xffe9) +__uchar 0x0 - 0x17 == 0xe9 (0xe9) +__longlong 0x8000 - 0x17 == 0x7fe9 (0x7fe9) +__ulonglong 0x8000 - 0x17 == 0x7fe9 (0x7fe9) +float 0x8000 - 0x17 == 0x7fe9 (0x7fe9) +int 0x8000 * 0x17 == -0x8000 (0x8000) +__uint 0x8000 * 0x17 == -0x8000 (0x8000) +char 0x0 * 0x17 == 0x0 (0x0) +__uchar 0x0 * 0x17 == 0x0 (0x0) +__longlong 0x8000 * 0x17 == -0x8000 (0x8000) +__ulonglong 0x8000 * 0x17 == -0x8000 (0x8000) +float 0x8000 * 0x17 == -0x8000 (0x8000) +int 0x8000 < 0x17 == 0x1 (0x1) +__uint 0x8000 < 0x17 == 0x0 (0x0) +char 0x0 < 0x17 == 0x1 (0x1) +__uchar 0x0 < 0x17 == 0x1 (0x1) +__longlong 0x8000 < 0x17 == 0x1 (0x1) +__ulonglong 0x8000 < 0x17 == 0x0 (0x0) +float 0x8000 < 0x17 == 0x1 (0x1) +int 0x8000 > 0x17 == 0x0 (0x0) +__uint 0x8000 > 0x17 == 0x1 (0x1) +char 0x0 > 0x17 == 0x0 (0x0) +__uchar 0x0 > 0x17 == 0x0 (0x0) +__longlong 0x8000 > 0x17 == 0x0 (0x0) +__ulonglong 0x8000 > 0x17 == 0x1 (0x1) +float 0x8000 > 0x17 == 0x0 (0x0) +int 0x8000 <= 0x17 == 0x1 (0x1) +__uint 0x8000 <= 0x17 == 0x0 (0x0) +char 0x0 <= 0x17 == 0x1 (0x1) +__uchar 0x0 <= 0x17 == 0x1 (0x1) +__longlong 0x8000 <= 0x17 == 0x1 (0x1) +__ulonglong 0x8000 <= 0x17 == 0x0 (0x0) +float 0x8000 <= 0x17 == 0x1 (0x1) +int 0x8000 == 0x17 == 0x0 (0x0) +__uint 0x8000 == 0x17 == 0x0 (0x0) +char 0x0 == 0x17 == 0x0 (0x0) +__uchar 0x0 == 0x17 == 0x0 (0x0) +__longlong 0x8000 == 0x17 == 0x0 (0x0) +__ulonglong 0x8000 == 0x17 == 0x0 (0x0) +float 0x8000 == 0x17 == 0x0 (0x0) +int 0x8000 != 0x17 == 0x1 (0x1) +__uint 0x8000 != 0x17 == 0x1 (0x1) +char 0x0 != 0x17 == 0x1 (0x1) +__uchar 0x0 != 0x17 == 0x1 (0x1) +__longlong 0x8000 != 0x17 == 0x1 (0x1) +__ulonglong 0x8000 != 0x17 == 0x1 (0x1) +float 0x8000 != 0x17 == 0x1 (0x1) +int 0x8000 >= 0x17 == 0x0 (0x0) +__uint 0x8000 >= 0x17 == 0x1 (0x1) +char 0x0 >= 0x17 == 0x0 (0x0) +__uchar 0x0 >= 0x17 == 0x0 (0x0) +__longlong 0x8000 >= 0x17 == 0x0 (0x0) +__ulonglong 0x8000 >= 0x17 == 0x1 (0x1) +float 0x8000 >= 0x17 == 0x0 (0x0) +int 0x8000 / 0x17 == -0x590 (0xfa70) +__uint 0x8000 / 0x17 == 0x590 (0x590) +char 0x0 / 0x17 == 0x0 (0x0) +__uchar 0x0 / 0x17 == 0x0 (0x0) +__longlong 0x8000 / 0x17 == -0x590 (0xfa70) +__ulonglong 0x8000 / 0x17 == 0x5e9b (0x5e9b) +float 0x8000 / 0x17 == -0x590 (0xfa70) +int 0x8000 % 0x17 == -0x10 (0xfff0) +__uint 0x8000 % 0x17 == 0x10 (0x10) +char 0x0 % 0x17 == 0x0 (0x0) +__uchar 0x0 % 0x17 == 0x0 (0x0) +__longlong 0x8000 % 0x17 == -0x10 (0xfff0) +__ulonglong 0x8000 % 0x17 == 0x13 (0x13) +0x8000 * 0x7fff == -0x8000 +0x8000 / 0x7fff == -0x1 +0x8000 % 0x7fff == -0x1 +int 0x8000 ^ 0x7fff == -0x1 (0xffff) +__uint 0x8000 ^ 0x7fff == -0x1 (0xffff) +char 0x0 ^ 0xffff == -0x1 (0xffff) +__uchar 0x0 ^ 0xff == 0xff (0xff) +__longlong 0x8000 ^ 0x7fff == -0x1 (0xffff) +__ulonglong 0x8000 ^ 0x7fff == -0x1 (0xffff) +int 0x8000 && 0x7fff == 0x1 (0x1) +__uint 0x8000 && 0x7fff == 0x1 (0x1) +char 0x0 && 0xffff == 0x0 (0x0) +__uchar 0x0 && 0xff == 0x0 (0x0) +__longlong 0x8000 && 0x7fff == 0x1 (0x1) +__ulonglong 0x8000 && 0x7fff == 0x1 (0x1) +int 0x8000 || 0x7fff == 0x1 (0x1) +__uint 0x8000 || 0x7fff == 0x1 (0x1) +char 0x0 || 0xffff == 0x1 (0x1) +__uchar 0x0 || 0xff == 0x1 (0x1) +__longlong 0x8000 || 0x7fff == 0x1 (0x1) +__ulonglong 0x8000 || 0x7fff == 0x1 (0x1) +int 0x8000 & 0x7fff == 0x0 (0x0) +__uint 0x8000 & 0x7fff == 0x0 (0x0) +char 0x0 & 0xffff == 0x0 (0x0) +__uchar 0x0 & 0xff == 0x0 (0x0) +__longlong 0x8000 & 0x7fff == 0x0 (0x0) +__ulonglong 0x8000 & 0x7fff == 0x0 (0x0) +int 0x8000 | 0x7fff == -0x1 (0xffff) +__uint 0x8000 | 0x7fff == -0x1 (0xffff) +char 0x0 | 0xffff == -0x1 (0xffff) +__uchar 0x0 | 0xff == 0xff (0xff) +__longlong 0x8000 | 0x7fff == -0x1 (0xffff) +__ulonglong 0x8000 | 0x7fff == -0x1 (0xffff) +int 0x8000 << 0x10 == 0x0 (0x0) +__uint 0x8000 << 0x10 == 0x0 (0x0) +char 0x0 << 0x10 == 0x0 (0x0) +__uchar 0x0 << 0x10 == 0x0 (0x0) +__longlong 0x8000 << 0x10 == 0x0 (0x0) +__ulonglong 0x8000 << 0x10 == 0x0 (0x0) +int 0x8000 >> 0x10 == -0x1 (0xffff) +__uint 0x8000 >> 0x10 == 0x0 (0x0) +char 0x0 >> 0x10 == 0x0 (0x0) +__uchar 0x0 >> 0x10 == 0x0 (0x0) +__longlong 0x8000 >> 0x10 == -0x1 (0xffff) +__ulonglong 0x8000 >> 0x10 == -0x1 (0xffff) +int 0x8000 + 0x7fff == -0x1 (0xffff) +__uint 0x8000 + 0x7fff == -0x1 (0xffff) +char 0x0 + 0xffff == -0x1 (0xffff) +__uchar 0x0 + 0xff == 0xff (0xff) +__longlong 0x8000 + 0x7fff == -0x1 (0xffff) +__ulonglong 0x8000 + 0x7fff == -0x1 (0xffff) +float 0x8000 + 0x7fff == -0x1 (0xffff) +int 0x8000 - 0x7fff == 0x1 (0x1) +__uint 0x8000 - 0x7fff == 0x1 (0x1) +char 0x0 - 0xffff == 0x1 (0x1) +__uchar 0x0 - 0xff == 0x1 (0x1) +__longlong 0x8000 - 0x7fff == 0x1 (0x1) +__ulonglong 0x8000 - 0x7fff == 0x1 (0x1) +float 0x8000 - 0x7fff == 0x1 (0x1) +int 0x8000 * 0x7fff == -0x8000 (0x8000) +__uint 0x8000 * 0x7fff == -0x8000 (0x8000) +char 0x0 * 0xffff == 0x0 (0x0) +__uchar 0x0 * 0xff == 0x0 (0x0) +__longlong 0x8000 * 0x7fff == -0x8000 (0x8000) +__ulonglong 0x8000 * 0x7fff == -0x8000 (0x8000) +float 0x8000 * 0x7fff == -0x8000 (0x8000) +int 0x8000 < 0x7fff == 0x1 (0x1) +__uint 0x8000 < 0x7fff == 0x0 (0x0) +char 0x0 < 0xffff == 0x0 (0x0) +__uchar 0x0 < 0xff == 0x1 (0x1) +__longlong 0x8000 < 0x7fff == 0x1 (0x1) +__ulonglong 0x8000 < 0x7fff == 0x0 (0x0) +float 0x8000 < 0x7fff == 0x1 (0x1) +int 0x8000 > 0x7fff == 0x0 (0x0) +__uint 0x8000 > 0x7fff == 0x1 (0x1) +char 0x0 > 0xffff == 0x1 (0x1) +__uchar 0x0 > 0xff == 0x0 (0x0) +__longlong 0x8000 > 0x7fff == 0x0 (0x0) +__ulonglong 0x8000 > 0x7fff == 0x1 (0x1) +float 0x8000 > 0x7fff == 0x0 (0x0) +int 0x8000 <= 0x7fff == 0x1 (0x1) +__uint 0x8000 <= 0x7fff == 0x0 (0x0) +char 0x0 <= 0xffff == 0x0 (0x0) +__uchar 0x0 <= 0xff == 0x1 (0x1) +__longlong 0x8000 <= 0x7fff == 0x1 (0x1) +__ulonglong 0x8000 <= 0x7fff == 0x0 (0x0) +float 0x8000 <= 0x7fff == 0x1 (0x1) +int 0x8000 == 0x7fff == 0x0 (0x0) +__uint 0x8000 == 0x7fff == 0x0 (0x0) +char 0x0 == 0xffff == 0x0 (0x0) +__uchar 0x0 == 0xff == 0x0 (0x0) +__longlong 0x8000 == 0x7fff == 0x0 (0x0) +__ulonglong 0x8000 == 0x7fff == 0x0 (0x0) +float 0x8000 == 0x7fff == 0x0 (0x0) +int 0x8000 != 0x7fff == 0x1 (0x1) +__uint 0x8000 != 0x7fff == 0x1 (0x1) +char 0x0 != 0xffff == 0x1 (0x1) +__uchar 0x0 != 0xff == 0x1 (0x1) +__longlong 0x8000 != 0x7fff == 0x1 (0x1) +__ulonglong 0x8000 != 0x7fff == 0x1 (0x1) +float 0x8000 != 0x7fff == 0x1 (0x1) +int 0x8000 >= 0x7fff == 0x0 (0x0) +__uint 0x8000 >= 0x7fff == 0x1 (0x1) +char 0x0 >= 0xffff == 0x1 (0x1) +__uchar 0x0 >= 0xff == 0x0 (0x0) +__longlong 0x8000 >= 0x7fff == 0x0 (0x0) +__ulonglong 0x8000 >= 0x7fff == 0x1 (0x1) +float 0x8000 >= 0x7fff == 0x0 (0x0) +int 0x8000 / 0x7fff == -0x1 (0xffff) +__uint 0x8000 / 0x7fff == 0x1 (0x1) +char 0x0 / 0xffff == 0x0 (0x0) +__uchar 0x0 / 0xff == 0x0 (0x0) +__longlong 0x8000 / 0x7fff == -0x1 (0xffff) +__ulonglong 0x8000 / 0x7fff == 0x3 (0x3) +float 0x8000 / 0x7fff == -0x1 (0xffff) +int 0x8000 % 0x7fff == -0x1 (0xffff) +__uint 0x8000 % 0x7fff == 0x1 (0x1) +char 0x0 % 0xffff == 0x0 (0x0) +__uchar 0x0 % 0xff == 0x0 (0x0) +__longlong 0x8000 % 0x7fff == -0x1 (0xffff) +__ulonglong 0x8000 % 0x7fff == 0x3 (0x3) +0x8000 * 0x8000 == 0x0 +0x8000 / 0x8000 == 0x1 +0x8000 % 0x8000 == 0x0 +int 0x8000 ^ 0x8000 == 0x0 (0x0) +__uint 0x8000 ^ 0x8000 == 0x0 (0x0) +char 0x0 ^ 0x0 == 0x0 (0x0) +__uchar 0x0 ^ 0x0 == 0x0 (0x0) +__longlong 0x8000 ^ 0x8000 == 0x0 (0x0) +__ulonglong 0x8000 ^ 0x8000 == 0x0 (0x0) +int 0x8000 && 0x8000 == 0x1 (0x1) +__uint 0x8000 && 0x8000 == 0x1 (0x1) +char 0x0 && 0x0 == 0x0 (0x0) +__uchar 0x0 && 0x0 == 0x0 (0x0) +__longlong 0x8000 && 0x8000 == 0x1 (0x1) +__ulonglong 0x8000 && 0x8000 == 0x1 (0x1) +int 0x8000 || 0x8000 == 0x1 (0x1) +__uint 0x8000 || 0x8000 == 0x1 (0x1) +char 0x0 || 0x0 == 0x0 (0x0) +__uchar 0x0 || 0x0 == 0x0 (0x0) +__longlong 0x8000 || 0x8000 == 0x1 (0x1) +__ulonglong 0x8000 || 0x8000 == 0x1 (0x1) +int 0x8000 & 0x8000 == -0x8000 (0x8000) +__uint 0x8000 & 0x8000 == -0x8000 (0x8000) +char 0x0 & 0x0 == 0x0 (0x0) +__uchar 0x0 & 0x0 == 0x0 (0x0) +__longlong 0x8000 & 0x8000 == -0x8000 (0x8000) +__ulonglong 0x8000 & 0x8000 == -0x8000 (0x8000) +int 0x8000 | 0x8000 == -0x8000 (0x8000) +__uint 0x8000 | 0x8000 == -0x8000 (0x8000) +char 0x0 | 0x0 == 0x0 (0x0) +__uchar 0x0 | 0x0 == 0x0 (0x0) +__longlong 0x8000 | 0x8000 == -0x8000 (0x8000) +__ulonglong 0x8000 | 0x8000 == -0x8000 (0x8000) +int 0x8000 << 0x12 == 0x0 (0x0) +__uint 0x8000 << 0x12 == 0x0 (0x0) +char 0x0 << 0x12 == 0x0 (0x0) +__uchar 0x0 << 0x12 == 0x0 (0x0) +__longlong 0x8000 << 0x12 == 0x0 (0x0) +__ulonglong 0x8000 << 0x12 == 0x0 (0x0) +int 0x8000 >> 0x12 == -0x1 (0xffff) +__uint 0x8000 >> 0x12 == 0x0 (0x0) +char 0x0 >> 0x12 == 0x0 (0x0) +__uchar 0x0 >> 0x12 == 0x0 (0x0) +__longlong 0x8000 >> 0x12 == -0x1 (0xffff) +__ulonglong 0x8000 >> 0x12 == 0x3fff (0x3fff) +int 0x8000 + 0x8000 == 0x0 (0x0) +__uint 0x8000 + 0x8000 == 0x0 (0x0) +char 0x0 + 0x0 == 0x0 (0x0) +__uchar 0x0 + 0x0 == 0x0 (0x0) +__longlong 0x8000 + 0x8000 == 0x0 (0x0) +__ulonglong 0x8000 + 0x8000 == 0x0 (0x0) +float 0x8000 + 0x8000 == 0x0 (0x0) +int 0x8000 - 0x8000 == 0x0 (0x0) +__uint 0x8000 - 0x8000 == 0x0 (0x0) +char 0x0 - 0x0 == 0x0 (0x0) +__uchar 0x0 - 0x0 == 0x0 (0x0) +__longlong 0x8000 - 0x8000 == 0x0 (0x0) +__ulonglong 0x8000 - 0x8000 == 0x0 (0x0) +float 0x8000 - 0x8000 == 0x0 (0x0) +int 0x8000 * 0x8000 == 0x0 (0x0) +__uint 0x8000 * 0x8000 == 0x0 (0x0) +char 0x0 * 0x0 == 0x0 (0x0) +__uchar 0x0 * 0x0 == 0x0 (0x0) +__longlong 0x8000 * 0x8000 == 0x0 (0x0) +__ulonglong 0x8000 * 0x8000 == 0x0 (0x0) +float 0x8000 * 0x8000 == 0x0 (0x0) +int 0x8000 < 0x8000 == 0x0 (0x0) +__uint 0x8000 < 0x8000 == 0x0 (0x0) +char 0x0 < 0x0 == 0x0 (0x0) +__uchar 0x0 < 0x0 == 0x0 (0x0) +__longlong 0x8000 < 0x8000 == 0x0 (0x0) +__ulonglong 0x8000 < 0x8000 == 0x0 (0x0) +float 0x8000 < 0x8000 == 0x0 (0x0) +int 0x8000 > 0x8000 == 0x0 (0x0) +__uint 0x8000 > 0x8000 == 0x0 (0x0) +char 0x0 > 0x0 == 0x0 (0x0) +__uchar 0x0 > 0x0 == 0x0 (0x0) +__longlong 0x8000 > 0x8000 == 0x0 (0x0) +__ulonglong 0x8000 > 0x8000 == 0x0 (0x0) +float 0x8000 > 0x8000 == 0x0 (0x0) +int 0x8000 <= 0x8000 == 0x1 (0x1) +__uint 0x8000 <= 0x8000 == 0x1 (0x1) +char 0x0 <= 0x0 == 0x1 (0x1) +__uchar 0x0 <= 0x0 == 0x1 (0x1) +__longlong 0x8000 <= 0x8000 == 0x1 (0x1) +__ulonglong 0x8000 <= 0x8000 == 0x1 (0x1) +float 0x8000 <= 0x8000 == 0x1 (0x1) +int 0x8000 == 0x8000 == 0x1 (0x1) +__uint 0x8000 == 0x8000 == 0x1 (0x1) +char 0x0 == 0x0 == 0x1 (0x1) +__uchar 0x0 == 0x0 == 0x1 (0x1) +__longlong 0x8000 == 0x8000 == 0x1 (0x1) +__ulonglong 0x8000 == 0x8000 == 0x1 (0x1) +float 0x8000 == 0x8000 == 0x1 (0x1) +int 0x8000 != 0x8000 == 0x0 (0x0) +__uint 0x8000 != 0x8000 == 0x0 (0x0) +char 0x0 != 0x0 == 0x0 (0x0) +__uchar 0x0 != 0x0 == 0x0 (0x0) +__longlong 0x8000 != 0x8000 == 0x0 (0x0) +__ulonglong 0x8000 != 0x8000 == 0x0 (0x0) +float 0x8000 != 0x8000 == 0x0 (0x0) +int 0x8000 >= 0x8000 == 0x1 (0x1) +__uint 0x8000 >= 0x8000 == 0x1 (0x1) +char 0x0 >= 0x0 == 0x1 (0x1) +__uchar 0x0 >= 0x0 == 0x1 (0x1) +__longlong 0x8000 >= 0x8000 == 0x1 (0x1) +__ulonglong 0x8000 >= 0x8000 == 0x1 (0x1) +float 0x8000 >= 0x8000 == 0x1 (0x1) +int 0x8000 / 0x8000 == 0x1 (0x1) +__uint 0x8000 / 0x8000 == 0x1 (0x1) +__longlong 0x8000 / 0x8000 == 0x1 (0x1) +__ulonglong 0x8000 / 0x8000 == 0x1 (0x1) +float 0x8000 / 0x8000 == 0x1 (0x1) +int 0x8000 % 0x8000 == 0x0 (0x0) +__uint 0x8000 % 0x8000 == 0x0 (0x0) +__longlong 0x8000 % 0x8000 == 0x0 (0x0) +__ulonglong 0x8000 % 0x8000 == 0x0 (0x0) +0x8000 * 0x3e8 == 0x0 +0x8000 / 0x3e8 == -0x20 +0x8000 % 0x3e8 == -0x300 +int 0x8000 ^ 0x3e8 == -0x7c18 (0x83e8) +__uint 0x8000 ^ 0x3e8 == -0x7c18 (0x83e8) +char 0x0 ^ 0xffe8 == -0x18 (0xffe8) +__uchar 0x0 ^ 0xe8 == 0xe8 (0xe8) +__longlong 0x8000 ^ 0x3e8 == -0x7c18 (0x83e8) +__ulonglong 0x8000 ^ 0x3e8 == -0x7c18 (0x83e8) +int 0x8000 && 0x3e8 == 0x1 (0x1) +__uint 0x8000 && 0x3e8 == 0x1 (0x1) +char 0x0 && 0xffe8 == 0x0 (0x0) +__uchar 0x0 && 0xe8 == 0x0 (0x0) +__longlong 0x8000 && 0x3e8 == 0x1 (0x1) +__ulonglong 0x8000 && 0x3e8 == 0x1 (0x1) +int 0x8000 || 0x3e8 == 0x1 (0x1) +__uint 0x8000 || 0x3e8 == 0x1 (0x1) +char 0x0 || 0xffe8 == 0x1 (0x1) +__uchar 0x0 || 0xe8 == 0x1 (0x1) +__longlong 0x8000 || 0x3e8 == 0x1 (0x1) +__ulonglong 0x8000 || 0x3e8 == 0x1 (0x1) +int 0x8000 & 0x3e8 == 0x0 (0x0) +__uint 0x8000 & 0x3e8 == 0x0 (0x0) +char 0x0 & 0xffe8 == 0x0 (0x0) +__uchar 0x0 & 0xe8 == 0x0 (0x0) +__longlong 0x8000 & 0x3e8 == 0x0 (0x0) +__ulonglong 0x8000 & 0x3e8 == 0x0 (0x0) +int 0x8000 | 0x3e8 == -0x7c18 (0x83e8) +__uint 0x8000 | 0x3e8 == -0x7c18 (0x83e8) +char 0x0 | 0xffe8 == -0x18 (0xffe8) +__uchar 0x0 | 0xe8 == 0xe8 (0xe8) +__longlong 0x8000 | 0x3e8 == -0x7c18 (0x83e8) +__ulonglong 0x8000 | 0x3e8 == -0x7c18 (0x83e8) +int 0x8000 << 0x14 == 0x0 (0x0) +__uint 0x8000 << 0x14 == 0x0 (0x0) +char 0x0 << 0x14 == 0x0 (0x0) +__uchar 0x0 << 0x14 == 0x0 (0x0) +__longlong 0x8000 << 0x14 == 0x0 (0x0) +__ulonglong 0x8000 << 0x14 == 0x0 (0x0) +int 0x8000 >> 0x14 == -0x1 (0xffff) +__uint 0x8000 >> 0x14 == 0x0 (0x0) +char 0x0 >> 0x14 == 0x0 (0x0) +__uchar 0x0 >> 0x14 == 0x0 (0x0) +__longlong 0x8000 >> 0x14 == -0x1 (0xffff) +__ulonglong 0x8000 >> 0x14 == 0xfff (0xfff) +int 0x8000 + 0x3e8 == -0x7c18 (0x83e8) +__uint 0x8000 + 0x3e8 == -0x7c18 (0x83e8) +char 0x0 + 0xffe8 == -0x18 (0xffe8) +__uchar 0x0 + 0xe8 == 0xe8 (0xe8) +__longlong 0x8000 + 0x3e8 == -0x7c18 (0x83e8) +__ulonglong 0x8000 + 0x3e8 == -0x7c18 (0x83e8) +float 0x8000 + 0x3e8 == -0x7c18 (0x83e8) +int 0x8000 - 0x3e8 == 0x7c18 (0x7c18) +__uint 0x8000 - 0x3e8 == 0x7c18 (0x7c18) +char 0x0 - 0xffe8 == 0x18 (0x18) +__uchar 0x0 - 0xe8 == 0x18 (0x18) +__longlong 0x8000 - 0x3e8 == 0x7c18 (0x7c18) +__ulonglong 0x8000 - 0x3e8 == 0x7c18 (0x7c18) +float 0x8000 - 0x3e8 == 0x7c18 (0x7c18) +int 0x8000 * 0x3e8 == 0x0 (0x0) +__uint 0x8000 * 0x3e8 == 0x0 (0x0) +char 0x0 * 0xffe8 == 0x0 (0x0) +__uchar 0x0 * 0xe8 == 0x0 (0x0) +__longlong 0x8000 * 0x3e8 == 0x0 (0x0) +__ulonglong 0x8000 * 0x3e8 == 0x0 (0x0) +float 0x8000 * 0x3e8 == 0x0 (0x0) +int 0x8000 < 0x3e8 == 0x1 (0x1) +__uint 0x8000 < 0x3e8 == 0x0 (0x0) +char 0x0 < 0xffe8 == 0x0 (0x0) +__uchar 0x0 < 0xe8 == 0x1 (0x1) +__longlong 0x8000 < 0x3e8 == 0x1 (0x1) +__ulonglong 0x8000 < 0x3e8 == 0x0 (0x0) +float 0x8000 < 0x3e8 == 0x1 (0x1) +int 0x8000 > 0x3e8 == 0x0 (0x0) +__uint 0x8000 > 0x3e8 == 0x1 (0x1) +char 0x0 > 0xffe8 == 0x1 (0x1) +__uchar 0x0 > 0xe8 == 0x0 (0x0) +__longlong 0x8000 > 0x3e8 == 0x0 (0x0) +__ulonglong 0x8000 > 0x3e8 == 0x1 (0x1) +float 0x8000 > 0x3e8 == 0x0 (0x0) +int 0x8000 <= 0x3e8 == 0x1 (0x1) +__uint 0x8000 <= 0x3e8 == 0x0 (0x0) +char 0x0 <= 0xffe8 == 0x0 (0x0) +__uchar 0x0 <= 0xe8 == 0x1 (0x1) +__longlong 0x8000 <= 0x3e8 == 0x1 (0x1) +__ulonglong 0x8000 <= 0x3e8 == 0x0 (0x0) +float 0x8000 <= 0x3e8 == 0x1 (0x1) +int 0x8000 == 0x3e8 == 0x0 (0x0) +__uint 0x8000 == 0x3e8 == 0x0 (0x0) +char 0x0 == 0xffe8 == 0x0 (0x0) +__uchar 0x0 == 0xe8 == 0x0 (0x0) +__longlong 0x8000 == 0x3e8 == 0x0 (0x0) +__ulonglong 0x8000 == 0x3e8 == 0x0 (0x0) +float 0x8000 == 0x3e8 == 0x0 (0x0) +int 0x8000 != 0x3e8 == 0x1 (0x1) +__uint 0x8000 != 0x3e8 == 0x1 (0x1) +char 0x0 != 0xffe8 == 0x1 (0x1) +__uchar 0x0 != 0xe8 == 0x1 (0x1) +__longlong 0x8000 != 0x3e8 == 0x1 (0x1) +__ulonglong 0x8000 != 0x3e8 == 0x1 (0x1) +float 0x8000 != 0x3e8 == 0x1 (0x1) +int 0x8000 >= 0x3e8 == 0x0 (0x0) +__uint 0x8000 >= 0x3e8 == 0x1 (0x1) +char 0x0 >= 0xffe8 == 0x1 (0x1) +__uchar 0x0 >= 0xe8 == 0x0 (0x0) +__longlong 0x8000 >= 0x3e8 == 0x0 (0x0) +__ulonglong 0x8000 >= 0x3e8 == 0x1 (0x1) +float 0x8000 >= 0x3e8 == 0x0 (0x0) +int 0x8000 / 0x3e8 == -0x20 (0xffe0) +__uint 0x8000 / 0x3e8 == 0x20 (0x20) +char 0x0 / 0xffe8 == 0x0 (0x0) +__uchar 0x0 / 0xe8 == 0x0 (0x0) +__longlong 0x8000 / 0x3e8 == -0x20 (0xffe0) +__ulonglong 0x8000 / 0x3e8 == -0x76ea (0x8916) +float 0x8000 / 0x3e8 == -0x20 (0xffe0) +int 0x8000 % 0x3e8 == -0x300 (0xfd00) +__uint 0x8000 % 0x3e8 == 0x300 (0x300) +char 0x0 % 0xffe8 == 0x0 (0x0) +__uchar 0x0 % 0xe8 == 0x0 (0x0) +__longlong 0x8000 % 0x3e8 == -0x300 (0xfd00) +__ulonglong 0x8000 % 0x3e8 == 0x210 (0x210) +0x8000 * 0x2710 == 0x0 +0x8000 / 0x2710 == -0x3 +0x8000 % 0x2710 == -0xad0 +int 0x8000 ^ 0x2710 == -0x58f0 (0xa710) +__uint 0x8000 ^ 0x2710 == -0x58f0 (0xa710) +char 0x0 ^ 0x10 == 0x10 (0x10) +__uchar 0x0 ^ 0x10 == 0x10 (0x10) +__longlong 0x8000 ^ 0x2710 == -0x58f0 (0xa710) +__ulonglong 0x8000 ^ 0x2710 == -0x58f0 (0xa710) +int 0x8000 && 0x2710 == 0x1 (0x1) +__uint 0x8000 && 0x2710 == 0x1 (0x1) +char 0x0 && 0x10 == 0x0 (0x0) +__uchar 0x0 && 0x10 == 0x0 (0x0) +__longlong 0x8000 && 0x2710 == 0x1 (0x1) +__ulonglong 0x8000 && 0x2710 == 0x1 (0x1) +int 0x8000 || 0x2710 == 0x1 (0x1) +__uint 0x8000 || 0x2710 == 0x1 (0x1) +char 0x0 || 0x10 == 0x1 (0x1) +__uchar 0x0 || 0x10 == 0x1 (0x1) +__longlong 0x8000 || 0x2710 == 0x1 (0x1) +__ulonglong 0x8000 || 0x2710 == 0x1 (0x1) +int 0x8000 & 0x2710 == 0x0 (0x0) +__uint 0x8000 & 0x2710 == 0x0 (0x0) +char 0x0 & 0x10 == 0x0 (0x0) +__uchar 0x0 & 0x10 == 0x0 (0x0) +__longlong 0x8000 & 0x2710 == 0x0 (0x0) +__ulonglong 0x8000 & 0x2710 == 0x0 (0x0) +int 0x8000 | 0x2710 == -0x58f0 (0xa710) +__uint 0x8000 | 0x2710 == -0x58f0 (0xa710) +char 0x0 | 0x10 == 0x10 (0x10) +__uchar 0x0 | 0x10 == 0x10 (0x10) +__longlong 0x8000 | 0x2710 == -0x58f0 (0xa710) +__ulonglong 0x8000 | 0x2710 == -0x58f0 (0xa710) +int 0x8000 << 0x16 == 0x0 (0x0) +__uint 0x8000 << 0x16 == 0x0 (0x0) +char 0x0 << 0x16 == 0x0 (0x0) +__uchar 0x0 << 0x16 == 0x0 (0x0) +__longlong 0x8000 << 0x16 == 0x0 (0x0) +__ulonglong 0x8000 << 0x16 == 0x0 (0x0) +int 0x8000 >> 0x16 == -0x1 (0xffff) +__uint 0x8000 >> 0x16 == 0x0 (0x0) +char 0x0 >> 0x16 == 0x0 (0x0) +__uchar 0x0 >> 0x16 == 0x0 (0x0) +__longlong 0x8000 >> 0x16 == -0x1 (0xffff) +__ulonglong 0x8000 >> 0x16 == 0x3ff (0x3ff) +int 0x8000 + 0x2710 == -0x58f0 (0xa710) +__uint 0x8000 + 0x2710 == -0x58f0 (0xa710) +char 0x0 + 0x10 == 0x10 (0x10) +__uchar 0x0 + 0x10 == 0x10 (0x10) +__longlong 0x8000 + 0x2710 == -0x58f0 (0xa710) +__ulonglong 0x8000 + 0x2710 == -0x58f0 (0xa710) +float 0x8000 + 0x2710 == -0x58f0 (0xa710) +int 0x8000 - 0x2710 == 0x58f0 (0x58f0) +__uint 0x8000 - 0x2710 == 0x58f0 (0x58f0) +char 0x0 - 0x10 == -0x10 (0xfff0) +__uchar 0x0 - 0x10 == 0xf0 (0xf0) +__longlong 0x8000 - 0x2710 == 0x58f0 (0x58f0) +__ulonglong 0x8000 - 0x2710 == 0x58f0 (0x58f0) +float 0x8000 - 0x2710 == 0x58f0 (0x58f0) +int 0x8000 * 0x2710 == 0x0 (0x0) +__uint 0x8000 * 0x2710 == 0x0 (0x0) +char 0x0 * 0x10 == 0x0 (0x0) +__uchar 0x0 * 0x10 == 0x0 (0x0) +__longlong 0x8000 * 0x2710 == 0x0 (0x0) +__ulonglong 0x8000 * 0x2710 == 0x0 (0x0) +float 0x8000 * 0x2710 == 0x0 (0x0) +int 0x8000 < 0x2710 == 0x1 (0x1) +__uint 0x8000 < 0x2710 == 0x0 (0x0) +char 0x0 < 0x10 == 0x1 (0x1) +__uchar 0x0 < 0x10 == 0x1 (0x1) +__longlong 0x8000 < 0x2710 == 0x1 (0x1) +__ulonglong 0x8000 < 0x2710 == 0x0 (0x0) +float 0x8000 < 0x2710 == 0x1 (0x1) +int 0x8000 > 0x2710 == 0x0 (0x0) +__uint 0x8000 > 0x2710 == 0x1 (0x1) +char 0x0 > 0x10 == 0x0 (0x0) +__uchar 0x0 > 0x10 == 0x0 (0x0) +__longlong 0x8000 > 0x2710 == 0x0 (0x0) +__ulonglong 0x8000 > 0x2710 == 0x1 (0x1) +float 0x8000 > 0x2710 == 0x0 (0x0) +int 0x8000 <= 0x2710 == 0x1 (0x1) +__uint 0x8000 <= 0x2710 == 0x0 (0x0) +char 0x0 <= 0x10 == 0x1 (0x1) +__uchar 0x0 <= 0x10 == 0x1 (0x1) +__longlong 0x8000 <= 0x2710 == 0x1 (0x1) +__ulonglong 0x8000 <= 0x2710 == 0x0 (0x0) +float 0x8000 <= 0x2710 == 0x1 (0x1) +int 0x8000 == 0x2710 == 0x0 (0x0) +__uint 0x8000 == 0x2710 == 0x0 (0x0) +char 0x0 == 0x10 == 0x0 (0x0) +__uchar 0x0 == 0x10 == 0x0 (0x0) +__longlong 0x8000 == 0x2710 == 0x0 (0x0) +__ulonglong 0x8000 == 0x2710 == 0x0 (0x0) +float 0x8000 == 0x2710 == 0x0 (0x0) +int 0x8000 != 0x2710 == 0x1 (0x1) +__uint 0x8000 != 0x2710 == 0x1 (0x1) +char 0x0 != 0x10 == 0x1 (0x1) +__uchar 0x0 != 0x10 == 0x1 (0x1) +__longlong 0x8000 != 0x2710 == 0x1 (0x1) +__ulonglong 0x8000 != 0x2710 == 0x1 (0x1) +float 0x8000 != 0x2710 == 0x1 (0x1) +int 0x8000 >= 0x2710 == 0x0 (0x0) +__uint 0x8000 >= 0x2710 == 0x1 (0x1) +char 0x0 >= 0x10 == 0x0 (0x0) +__uchar 0x0 >= 0x10 == 0x0 (0x0) +__longlong 0x8000 >= 0x2710 == 0x0 (0x0) +__ulonglong 0x8000 >= 0x2710 == 0x1 (0x1) +float 0x8000 >= 0x2710 == 0x0 (0x0) +int 0x8000 / 0x2710 == -0x3 (0xfffd) +__uint 0x8000 / 0x2710 == 0x3 (0x3) +char 0x0 / 0x10 == 0x0 (0x0) +__uchar 0x0 / 0x10 == 0x0 (0x0) +__longlong 0x8000 / 0x2710 == -0x3 (0xfffd) +__ulonglong 0x8000 / 0x2710 == -0x724b (0x8db5) +float 0x8000 / 0x2710 == -0x3 (0xfffd) +int 0x8000 % 0x2710 == -0xad0 (0xf530) +__uint 0x8000 % 0x2710 == 0xad0 (0xad0) +char 0x0 % 0x10 == 0x0 (0x0) +__uchar 0x0 % 0x10 == 0x0 (0x0) +__longlong 0x8000 % 0x2710 == -0xad0 (0xf530) +__ulonglong 0x8000 % 0x2710 == 0x11b0 (0x11b0) +int xor42-0x8000 xor42 -0x7fd6 +__uint xor42-0x8000 xor42 -0x7fd6 +char xor420x0 xor42 0x2a +__uchar xor420x0 xor42 0x2a +__longlong xor42-0x8000 xor42 -0x7fd6 +__ulonglong xor42-0x8000 xor42 -0x7fd6 +int land1-0x8000 land1 0x1 +__uint land1-0x8000 land1 0x1 +char land10x0 land1 0x0 +__uchar land10x0 land1 0x0 +__longlong land1-0x8000 land1 0x1 +__ulonglong land1-0x8000 land1 0x1 +int lor1-0x8000 lor1 0x1 +__uint lor1-0x8000 lor1 0x1 +char lor10x0 lor1 0x1 +__uchar lor10x0 lor1 0x1 +__longlong lor1-0x8000 lor1 0x1 +__ulonglong lor1-0x8000 lor1 0x1 +int and42-0x8000 and42 0x0 +__uint and42-0x8000 and42 0x0 +char and420x0 and42 0x0 +__uchar and420x0 and42 0x0 +__longlong and42-0x8000 and42 0x0 +__ulonglong and42-0x8000 and42 0x0 +int or42-0x8000 or42 -0x7fd6 +__uint or42-0x8000 or42 -0x7fd6 +char or420x0 or42 0x2a +__uchar or420x0 or42 0x2a +__longlong or42-0x8000 or42 -0x7fd6 +__ulonglong or42-0x8000 or42 -0x7fd6 +int shl5-0x8000 shl5 0x0 +__uint shl5-0x8000 shl5 0x0 +char shl50x0 shl5 0x0 +__uchar shl50x0 shl5 0x0 +__longlong shl5-0x8000 shl5 0x0 +__ulonglong shl5-0x8000 shl5 0x0 +int shr5-0x8000 shr5 -0x400 +__uint shr5-0x8000 shr5 0x400 +char shr50x0 shr5 0x0 +__uchar shr50x0 shr5 0x0 +__longlong shr5-0x8000 shr5 -0x400 +__ulonglong shr5-0x8000 shr5 -0x400 +int add42-0x8000 add42 -0x7fd6 +__uint add42-0x8000 add42 -0x7fd6 +char add420x0 add42 0x2a +__uchar add420x0 add42 0x2a +__longlong add42-0x8000 add42 -0x7fd6 +__ulonglong add42-0x8000 add42 -0x7fd6 +float add42-0x8000 add42 -0x7fd6 +int sub42-0x8000 sub42 0x7fd6 +__uint sub42-0x8000 sub42 0x7fd6 +char sub420x0 sub42 -0x2a +__uchar sub420x0 sub42 0xd6 +__longlong sub42-0x8000 sub42 0x7fd6 +__ulonglong sub42-0x8000 sub42 0x7fd6 +float sub42-0x8000 sub42 0x7fd6 +int mul42-0x8000 mul42 0x0 +__uint mul42-0x8000 mul42 0x0 +char mul420x0 mul42 0x0 +__uchar mul420x0 mul42 0x0 +__longlong mul42-0x8000 mul42 0x0 +__ulonglong mul42-0x8000 mul42 0x0 +float mul42-0x8000 mul42 0x0 +int lt42-0x8000 lt42 0x1 +__uint lt42-0x8000 lt42 0x0 +char lt420x0 lt42 0x1 +__uchar lt420x0 lt42 0x1 +__longlong lt42-0x8000 lt42 0x1 +__ulonglong lt42-0x8000 lt42 0x0 +float lt42-0x8000 lt42 0x1 +int gt42-0x8000 gt42 0x0 +__uint gt42-0x8000 gt42 0x1 +char gt420x0 gt42 0x0 +__uchar gt420x0 gt42 0x0 +__longlong gt42-0x8000 gt42 0x0 +__ulonglong gt42-0x8000 gt42 0x1 +float gt42-0x8000 gt42 0x0 +int le42-0x8000 le42 0x1 +__uint le42-0x8000 le42 0x0 +char le420x0 le42 0x1 +__uchar le420x0 le42 0x1 +__longlong le42-0x8000 le42 0x1 +__ulonglong le42-0x8000 le42 0x0 +float le42-0x8000 le42 0x1 +int eq42-0x8000 eq42 0x0 +__uint eq42-0x8000 eq42 0x0 +char eq420x0 eq42 0x0 +__uchar eq420x0 eq42 0x0 +__longlong eq42-0x8000 eq42 0x0 +__ulonglong eq42-0x8000 eq42 0x0 +float eq42-0x8000 eq42 0x0 +int ne42-0x8000 ne42 0x1 +__uint ne42-0x8000 ne42 0x1 +char ne420x0 ne42 0x1 +__uchar ne420x0 ne42 0x1 +__longlong ne42-0x8000 ne42 0x1 +__ulonglong ne42-0x8000 ne42 0x1 +float ne42-0x8000 ne42 0x1 +int ge42-0x8000 ge42 0x0 +__uint ge42-0x8000 ge42 0x1 +char ge420x0 ge42 0x0 +__uchar ge420x0 ge42 0x0 +__longlong ge42-0x8000 ge42 0x0 +__ulonglong ge42-0x8000 ge42 0x1 +float ge42-0x8000 ge42 0x0 +int div42-0x8000 div42 -0x30c +__uint div42-0x8000 div42 0x30c +char div420x0 div42 0x0 +__uchar div420x0 div42 0x0 +__longlong div42-0x8000 div42 -0x30c +__ulonglong div42-0x8000 div42 0x5e79 +float div42-0x8000 div42 -0x30c +int mod23-0x8000 mod23 -0x10 +__uint mod23-0x8000 mod23 0x10 +char mod230x0 mod23 0x0 +__uchar mod230x0 mod23 0x0 +__longlong mod23-0x8000 mod23 -0x10 +__ulonglong mod23-0x8000 mod23 0x13 +0xfc18 * 0xffff == 0x3e8 +0xfc18 / 0xffff == 0x3e8 +0xfc18 % 0xffff == 0x0 +int 0xfc18 ^ 0xffff == 0x3e7 (0x3e7) +__uint 0xfc18 ^ 0xffff == 0x3e7 (0x3e7) +char 0x18 ^ 0xffff == -0x19 (0xffe7) +__uchar 0x18 ^ 0xff == 0xe7 (0xe7) +__longlong 0xfc18 ^ 0xffff == 0x3e7 (0x3e7) +__ulonglong 0xfc18 ^ 0xffff == 0x3e7 (0x3e7) +int 0xfc18 && 0xffff == 0x1 (0x1) +__uint 0xfc18 && 0xffff == 0x1 (0x1) +char 0x18 && 0xffff == 0x1 (0x1) +__uchar 0x18 && 0xff == 0x1 (0x1) +__longlong 0xfc18 && 0xffff == 0x1 (0x1) +__ulonglong 0xfc18 && 0xffff == 0x1 (0x1) +int 0xfc18 || 0xffff == 0x1 (0x1) +__uint 0xfc18 || 0xffff == 0x1 (0x1) +char 0x18 || 0xffff == 0x1 (0x1) +__uchar 0x18 || 0xff == 0x1 (0x1) +__longlong 0xfc18 || 0xffff == 0x1 (0x1) +__ulonglong 0xfc18 || 0xffff == 0x1 (0x1) +int 0xfc18 & 0xffff == -0x3e8 (0xfc18) +__uint 0xfc18 & 0xffff == -0x3e8 (0xfc18) +char 0x18 & 0xffff == 0x18 (0x18) +__uchar 0x18 & 0xff == 0x18 (0x18) +__longlong 0xfc18 & 0xffff == -0x3e8 (0xfc18) +__ulonglong 0xfc18 & 0xffff == -0x3e8 (0xfc18) +int 0xfc18 | 0xffff == -0x1 (0xffff) +__uint 0xfc18 | 0xffff == -0x1 (0xffff) +char 0x18 | 0xffff == -0x1 (0xffff) +__uchar 0x18 | 0xff == 0xff (0xff) +__longlong 0xfc18 | 0xffff == -0x1 (0xffff) +__ulonglong 0xfc18 | 0xffff == -0x1 (0xffff) +int 0xfc18 << 0x1 == -0x7d0 (0xf830) +__uint 0xfc18 << 0x1 == -0x7d0 (0xf830) +char 0x18 << 0x1 == 0x30 (0x30) +__uchar 0x18 << 0x1 == 0x30 (0x30) +__longlong 0xfc18 << 0x1 == -0x7d0 (0xf830) +__ulonglong 0xfc18 << 0x1 == -0x7d0 (0xf830) +int 0xfc18 >> 0x1 == -0x1f4 (0xfe0c) +__uint 0xfc18 >> 0x1 == 0x7e0c (0x7e0c) +char 0x18 >> 0x1 == 0xc (0xc) +__uchar 0x18 >> 0x1 == 0xc (0xc) +__longlong 0xfc18 >> 0x1 == -0x1f4 (0xfe0c) +__ulonglong 0xfc18 >> 0x1 == -0x1f4 (0xfe0c) +int 0xfc18 + 0xffff == -0x3e9 (0xfc17) +__uint 0xfc18 + 0xffff == -0x3e9 (0xfc17) +char 0x18 + 0xffff == 0x17 (0x17) +__uchar 0x18 + 0xff == 0x17 (0x17) +__longlong 0xfc18 + 0xffff == -0x3e9 (0xfc17) +__ulonglong 0xfc18 + 0xffff == -0x3e9 (0xfc17) +float 0xfc18 + 0xffff == -0x3e9 (0xfc17) +int 0xfc18 - 0xffff == -0x3e7 (0xfc19) +__uint 0xfc18 - 0xffff == -0x3e7 (0xfc19) +char 0x18 - 0xffff == 0x19 (0x19) +__uchar 0x18 - 0xff == 0x19 (0x19) +__longlong 0xfc18 - 0xffff == -0x3e7 (0xfc19) +__ulonglong 0xfc18 - 0xffff == -0x3e7 (0xfc19) +float 0xfc18 - 0xffff == -0x3e7 (0xfc19) +int 0xfc18 * 0xffff == 0x3e8 (0x3e8) +__uint 0xfc18 * 0xffff == 0x3e8 (0x3e8) +char 0x18 * 0xffff == -0x18 (0xffe8) +__uchar 0x18 * 0xff == 0xe8 (0xe8) +__longlong 0xfc18 * 0xffff == 0x3e8 (0x3e8) +__ulonglong 0xfc18 * 0xffff == 0x3e8 (0x3e8) +float 0xfc18 * 0xffff == 0x3e8 (0x3e8) +int 0xfc18 < 0xffff == 0x1 (0x1) +__uint 0xfc18 < 0xffff == 0x1 (0x1) +char 0x18 < 0xffff == 0x0 (0x0) +__uchar 0x18 < 0xff == 0x1 (0x1) +__longlong 0xfc18 < 0xffff == 0x1 (0x1) +__ulonglong 0xfc18 < 0xffff == 0x1 (0x1) +float 0xfc18 < 0xffff == 0x1 (0x1) +int 0xfc18 > 0xffff == 0x0 (0x0) +__uint 0xfc18 > 0xffff == 0x0 (0x0) +char 0x18 > 0xffff == 0x1 (0x1) +__uchar 0x18 > 0xff == 0x0 (0x0) +__longlong 0xfc18 > 0xffff == 0x0 (0x0) +__ulonglong 0xfc18 > 0xffff == 0x0 (0x0) +float 0xfc18 > 0xffff == 0x0 (0x0) +int 0xfc18 <= 0xffff == 0x1 (0x1) +__uint 0xfc18 <= 0xffff == 0x1 (0x1) +char 0x18 <= 0xffff == 0x0 (0x0) +__uchar 0x18 <= 0xff == 0x1 (0x1) +__longlong 0xfc18 <= 0xffff == 0x1 (0x1) +__ulonglong 0xfc18 <= 0xffff == 0x1 (0x1) +float 0xfc18 <= 0xffff == 0x1 (0x1) +int 0xfc18 == 0xffff == 0x0 (0x0) +__uint 0xfc18 == 0xffff == 0x0 (0x0) +char 0x18 == 0xffff == 0x0 (0x0) +__uchar 0x18 == 0xff == 0x0 (0x0) +__longlong 0xfc18 == 0xffff == 0x0 (0x0) +__ulonglong 0xfc18 == 0xffff == 0x0 (0x0) +float 0xfc18 == 0xffff == 0x0 (0x0) +int 0xfc18 != 0xffff == 0x1 (0x1) +__uint 0xfc18 != 0xffff == 0x1 (0x1) +char 0x18 != 0xffff == 0x1 (0x1) +__uchar 0x18 != 0xff == 0x1 (0x1) +__longlong 0xfc18 != 0xffff == 0x1 (0x1) +__ulonglong 0xfc18 != 0xffff == 0x1 (0x1) +float 0xfc18 != 0xffff == 0x1 (0x1) +int 0xfc18 >= 0xffff == 0x0 (0x0) +__uint 0xfc18 >= 0xffff == 0x0 (0x0) +char 0x18 >= 0xffff == 0x1 (0x1) +__uchar 0x18 >= 0xff == 0x0 (0x0) +__longlong 0xfc18 >= 0xffff == 0x0 (0x0) +__ulonglong 0xfc18 >= 0xffff == 0x0 (0x0) +float 0xfc18 >= 0xffff == 0x0 (0x0) +int 0xfc18 / 0xffff == 0x3e8 (0x3e8) +__uint 0xfc18 / 0xffff == 0x0 (0x0) +char 0x18 / 0xffff == -0x18 (0xffe8) +__uchar 0x18 / 0xff == 0x0 (0x0) +__longlong 0xfc18 / 0xffff == 0x3e8 (0x3e8) +__ulonglong 0xfc18 / 0xffff == 0x0 (0x0) +float 0xfc18 / 0xffff == 0x3e8 (0x3e8) +int 0xfc18 % 0xffff == 0x0 (0x0) +__uint 0xfc18 % 0xffff == -0x3e8 (0xfc18) +char 0x18 % 0xffff == 0x0 (0x0) +__uchar 0x18 % 0xff == 0x18 (0x18) +__longlong 0xfc18 % 0xffff == 0x0 (0x0) +__ulonglong 0xfc18 % 0xffff == -0x3e8 (0xfc18) +0xfc18 * 0x1 == -0x3e8 +0xfc18 / 0x1 == -0x3e8 +0xfc18 % 0x1 == 0x0 +int 0xfc18 ^ 0x1 == -0x3e7 (0xfc19) +__uint 0xfc18 ^ 0x1 == -0x3e7 (0xfc19) +char 0x18 ^ 0x1 == 0x19 (0x19) +__uchar 0x18 ^ 0x1 == 0x19 (0x19) +__longlong 0xfc18 ^ 0x1 == -0x3e7 (0xfc19) +__ulonglong 0xfc18 ^ 0x1 == -0x3e7 (0xfc19) +int 0xfc18 && 0x1 == 0x1 (0x1) +__uint 0xfc18 && 0x1 == 0x1 (0x1) +char 0x18 && 0x1 == 0x1 (0x1) +__uchar 0x18 && 0x1 == 0x1 (0x1) +__longlong 0xfc18 && 0x1 == 0x1 (0x1) +__ulonglong 0xfc18 && 0x1 == 0x1 (0x1) +int 0xfc18 || 0x1 == 0x1 (0x1) +__uint 0xfc18 || 0x1 == 0x1 (0x1) +char 0x18 || 0x1 == 0x1 (0x1) +__uchar 0x18 || 0x1 == 0x1 (0x1) +__longlong 0xfc18 || 0x1 == 0x1 (0x1) +__ulonglong 0xfc18 || 0x1 == 0x1 (0x1) +int 0xfc18 & 0x1 == 0x0 (0x0) +__uint 0xfc18 & 0x1 == 0x0 (0x0) +char 0x18 & 0x1 == 0x0 (0x0) +__uchar 0x18 & 0x1 == 0x0 (0x0) +__longlong 0xfc18 & 0x1 == 0x0 (0x0) +__ulonglong 0xfc18 & 0x1 == 0x0 (0x0) +int 0xfc18 | 0x1 == -0x3e7 (0xfc19) +__uint 0xfc18 | 0x1 == -0x3e7 (0xfc19) +char 0x18 | 0x1 == 0x19 (0x19) +__uchar 0x18 | 0x1 == 0x19 (0x19) +__longlong 0xfc18 | 0x1 == -0x3e7 (0xfc19) +__ulonglong 0xfc18 | 0x1 == -0x3e7 (0xfc19) +int 0xfc18 << 0x2 == -0xfa0 (0xf060) +__uint 0xfc18 << 0x2 == -0xfa0 (0xf060) +char 0x18 << 0x2 == 0x60 (0x60) +__uchar 0x18 << 0x2 == 0x60 (0x60) +__longlong 0xfc18 << 0x2 == -0xfa0 (0xf060) +__ulonglong 0xfc18 << 0x2 == -0xfa0 (0xf060) +int 0xfc18 >> 0x2 == -0xfa (0xff06) +__uint 0xfc18 >> 0x2 == 0x3f06 (0x3f06) +char 0x18 >> 0x2 == 0x6 (0x6) +__uchar 0x18 >> 0x2 == 0x6 (0x6) +__longlong 0xfc18 >> 0x2 == -0xfa (0xff06) +__ulonglong 0xfc18 >> 0x2 == -0xfa (0xff06) +int 0xfc18 + 0x1 == -0x3e7 (0xfc19) +__uint 0xfc18 + 0x1 == -0x3e7 (0xfc19) +char 0x18 + 0x1 == 0x19 (0x19) +__uchar 0x18 + 0x1 == 0x19 (0x19) +__longlong 0xfc18 + 0x1 == -0x3e7 (0xfc19) +__ulonglong 0xfc18 + 0x1 == -0x3e7 (0xfc19) +float 0xfc18 + 0x1 == -0x3e7 (0xfc19) +int 0xfc18 - 0x1 == -0x3e9 (0xfc17) +__uint 0xfc18 - 0x1 == -0x3e9 (0xfc17) +char 0x18 - 0x1 == 0x17 (0x17) +__uchar 0x18 - 0x1 == 0x17 (0x17) +__longlong 0xfc18 - 0x1 == -0x3e9 (0xfc17) +__ulonglong 0xfc18 - 0x1 == -0x3e9 (0xfc17) +float 0xfc18 - 0x1 == -0x3e9 (0xfc17) +int 0xfc18 * 0x1 == -0x3e8 (0xfc18) +__uint 0xfc18 * 0x1 == -0x3e8 (0xfc18) +char 0x18 * 0x1 == 0x18 (0x18) +__uchar 0x18 * 0x1 == 0x18 (0x18) +__longlong 0xfc18 * 0x1 == -0x3e8 (0xfc18) +__ulonglong 0xfc18 * 0x1 == -0x3e8 (0xfc18) +float 0xfc18 * 0x1 == -0x3e8 (0xfc18) +int 0xfc18 < 0x1 == 0x1 (0x1) +__uint 0xfc18 < 0x1 == 0x0 (0x0) +char 0x18 < 0x1 == 0x0 (0x0) +__uchar 0x18 < 0x1 == 0x0 (0x0) +__longlong 0xfc18 < 0x1 == 0x1 (0x1) +__ulonglong 0xfc18 < 0x1 == 0x0 (0x0) +float 0xfc18 < 0x1 == 0x1 (0x1) +int 0xfc18 > 0x1 == 0x0 (0x0) +__uint 0xfc18 > 0x1 == 0x1 (0x1) +char 0x18 > 0x1 == 0x1 (0x1) +__uchar 0x18 > 0x1 == 0x1 (0x1) +__longlong 0xfc18 > 0x1 == 0x0 (0x0) +__ulonglong 0xfc18 > 0x1 == 0x1 (0x1) +float 0xfc18 > 0x1 == 0x0 (0x0) +int 0xfc18 <= 0x1 == 0x1 (0x1) +__uint 0xfc18 <= 0x1 == 0x0 (0x0) +char 0x18 <= 0x1 == 0x0 (0x0) +__uchar 0x18 <= 0x1 == 0x0 (0x0) +__longlong 0xfc18 <= 0x1 == 0x1 (0x1) +__ulonglong 0xfc18 <= 0x1 == 0x0 (0x0) +float 0xfc18 <= 0x1 == 0x1 (0x1) +int 0xfc18 == 0x1 == 0x0 (0x0) +__uint 0xfc18 == 0x1 == 0x0 (0x0) +char 0x18 == 0x1 == 0x0 (0x0) +__uchar 0x18 == 0x1 == 0x0 (0x0) +__longlong 0xfc18 == 0x1 == 0x0 (0x0) +__ulonglong 0xfc18 == 0x1 == 0x0 (0x0) +float 0xfc18 == 0x1 == 0x0 (0x0) +int 0xfc18 != 0x1 == 0x1 (0x1) +__uint 0xfc18 != 0x1 == 0x1 (0x1) +char 0x18 != 0x1 == 0x1 (0x1) +__uchar 0x18 != 0x1 == 0x1 (0x1) +__longlong 0xfc18 != 0x1 == 0x1 (0x1) +__ulonglong 0xfc18 != 0x1 == 0x1 (0x1) +float 0xfc18 != 0x1 == 0x1 (0x1) +int 0xfc18 >= 0x1 == 0x0 (0x0) +__uint 0xfc18 >= 0x1 == 0x1 (0x1) +char 0x18 >= 0x1 == 0x1 (0x1) +__uchar 0x18 >= 0x1 == 0x1 (0x1) +__longlong 0xfc18 >= 0x1 == 0x0 (0x0) +__ulonglong 0xfc18 >= 0x1 == 0x1 (0x1) +float 0xfc18 >= 0x1 == 0x0 (0x0) +int 0xfc18 / 0x1 == -0x3e8 (0xfc18) +__uint 0xfc18 / 0x1 == -0x3e8 (0xfc18) +char 0x18 / 0x1 == 0x18 (0x18) +__uchar 0x18 / 0x1 == 0x18 (0x18) +__longlong 0xfc18 / 0x1 == -0x3e8 (0xfc18) +__ulonglong 0xfc18 / 0x1 == -0x3e8 (0xfc18) +float 0xfc18 / 0x1 == -0x3e8 (0xfc18) +int 0xfc18 % 0x1 == 0x0 (0x0) +__uint 0xfc18 % 0x1 == 0x0 (0x0) +char 0x18 % 0x1 == 0x0 (0x0) +__uchar 0x18 % 0x1 == 0x0 (0x0) +__longlong 0xfc18 % 0x1 == 0x0 (0x0) +__ulonglong 0xfc18 % 0x1 == 0x0 (0x0) +0xfc18 * 0x2 == -0x7d0 +0xfc18 / 0x2 == -0x1f4 +0xfc18 % 0x2 == 0x0 +int 0xfc18 ^ 0x2 == -0x3e6 (0xfc1a) +__uint 0xfc18 ^ 0x2 == -0x3e6 (0xfc1a) +char 0x18 ^ 0x2 == 0x1a (0x1a) +__uchar 0x18 ^ 0x2 == 0x1a (0x1a) +__longlong 0xfc18 ^ 0x2 == -0x3e6 (0xfc1a) +__ulonglong 0xfc18 ^ 0x2 == -0x3e6 (0xfc1a) +int 0xfc18 && 0x2 == 0x1 (0x1) +__uint 0xfc18 && 0x2 == 0x1 (0x1) +char 0x18 && 0x2 == 0x1 (0x1) +__uchar 0x18 && 0x2 == 0x1 (0x1) +__longlong 0xfc18 && 0x2 == 0x1 (0x1) +__ulonglong 0xfc18 && 0x2 == 0x1 (0x1) +int 0xfc18 || 0x2 == 0x1 (0x1) +__uint 0xfc18 || 0x2 == 0x1 (0x1) +char 0x18 || 0x2 == 0x1 (0x1) +__uchar 0x18 || 0x2 == 0x1 (0x1) +__longlong 0xfc18 || 0x2 == 0x1 (0x1) +__ulonglong 0xfc18 || 0x2 == 0x1 (0x1) +int 0xfc18 & 0x2 == 0x0 (0x0) +__uint 0xfc18 & 0x2 == 0x0 (0x0) +char 0x18 & 0x2 == 0x0 (0x0) +__uchar 0x18 & 0x2 == 0x0 (0x0) +__longlong 0xfc18 & 0x2 == 0x0 (0x0) +__ulonglong 0xfc18 & 0x2 == 0x0 (0x0) +int 0xfc18 | 0x2 == -0x3e6 (0xfc1a) +__uint 0xfc18 | 0x2 == -0x3e6 (0xfc1a) +char 0x18 | 0x2 == 0x1a (0x1a) +__uchar 0x18 | 0x2 == 0x1a (0x1a) +__longlong 0xfc18 | 0x2 == -0x3e6 (0xfc1a) +__ulonglong 0xfc18 | 0x2 == -0x3e6 (0xfc1a) +int 0xfc18 << 0x3 == -0x1f40 (0xe0c0) +__uint 0xfc18 << 0x3 == -0x1f40 (0xe0c0) +char 0x18 << 0x3 == -0x40 (0xffc0) +__uchar 0x18 << 0x3 == 0xc0 (0xc0) +__longlong 0xfc18 << 0x3 == -0x1f40 (0xe0c0) +__ulonglong 0xfc18 << 0x3 == -0x1f40 (0xe0c0) +int 0xfc18 >> 0x3 == -0x7d (0xff83) +__uint 0xfc18 >> 0x3 == 0x1f83 (0x1f83) +char 0x18 >> 0x3 == 0x3 (0x3) +__uchar 0x18 >> 0x3 == 0x3 (0x3) +__longlong 0xfc18 >> 0x3 == -0x7d (0xff83) +__ulonglong 0xfc18 >> 0x3 == -0x7d (0xff83) +int 0xfc18 + 0x2 == -0x3e6 (0xfc1a) +__uint 0xfc18 + 0x2 == -0x3e6 (0xfc1a) +char 0x18 + 0x2 == 0x1a (0x1a) +__uchar 0x18 + 0x2 == 0x1a (0x1a) +__longlong 0xfc18 + 0x2 == -0x3e6 (0xfc1a) +__ulonglong 0xfc18 + 0x2 == -0x3e6 (0xfc1a) +float 0xfc18 + 0x2 == -0x3e6 (0xfc1a) +int 0xfc18 - 0x2 == -0x3ea (0xfc16) +__uint 0xfc18 - 0x2 == -0x3ea (0xfc16) +char 0x18 - 0x2 == 0x16 (0x16) +__uchar 0x18 - 0x2 == 0x16 (0x16) +__longlong 0xfc18 - 0x2 == -0x3ea (0xfc16) +__ulonglong 0xfc18 - 0x2 == -0x3ea (0xfc16) +float 0xfc18 - 0x2 == -0x3ea (0xfc16) +int 0xfc18 * 0x2 == -0x7d0 (0xf830) +__uint 0xfc18 * 0x2 == -0x7d0 (0xf830) +char 0x18 * 0x2 == 0x30 (0x30) +__uchar 0x18 * 0x2 == 0x30 (0x30) +__longlong 0xfc18 * 0x2 == -0x7d0 (0xf830) +__ulonglong 0xfc18 * 0x2 == -0x7d0 (0xf830) +float 0xfc18 * 0x2 == -0x7d0 (0xf830) +int 0xfc18 < 0x2 == 0x1 (0x1) +__uint 0xfc18 < 0x2 == 0x0 (0x0) +char 0x18 < 0x2 == 0x0 (0x0) +__uchar 0x18 < 0x2 == 0x0 (0x0) +__longlong 0xfc18 < 0x2 == 0x1 (0x1) +__ulonglong 0xfc18 < 0x2 == 0x0 (0x0) +float 0xfc18 < 0x2 == 0x1 (0x1) +int 0xfc18 > 0x2 == 0x0 (0x0) +__uint 0xfc18 > 0x2 == 0x1 (0x1) +char 0x18 > 0x2 == 0x1 (0x1) +__uchar 0x18 > 0x2 == 0x1 (0x1) +__longlong 0xfc18 > 0x2 == 0x0 (0x0) +__ulonglong 0xfc18 > 0x2 == 0x1 (0x1) +float 0xfc18 > 0x2 == 0x0 (0x0) +int 0xfc18 <= 0x2 == 0x1 (0x1) +__uint 0xfc18 <= 0x2 == 0x0 (0x0) +char 0x18 <= 0x2 == 0x0 (0x0) +__uchar 0x18 <= 0x2 == 0x0 (0x0) +__longlong 0xfc18 <= 0x2 == 0x1 (0x1) +__ulonglong 0xfc18 <= 0x2 == 0x0 (0x0) +float 0xfc18 <= 0x2 == 0x1 (0x1) +int 0xfc18 == 0x2 == 0x0 (0x0) +__uint 0xfc18 == 0x2 == 0x0 (0x0) +char 0x18 == 0x2 == 0x0 (0x0) +__uchar 0x18 == 0x2 == 0x0 (0x0) +__longlong 0xfc18 == 0x2 == 0x0 (0x0) +__ulonglong 0xfc18 == 0x2 == 0x0 (0x0) +float 0xfc18 == 0x2 == 0x0 (0x0) +int 0xfc18 != 0x2 == 0x1 (0x1) +__uint 0xfc18 != 0x2 == 0x1 (0x1) +char 0x18 != 0x2 == 0x1 (0x1) +__uchar 0x18 != 0x2 == 0x1 (0x1) +__longlong 0xfc18 != 0x2 == 0x1 (0x1) +__ulonglong 0xfc18 != 0x2 == 0x1 (0x1) +float 0xfc18 != 0x2 == 0x1 (0x1) +int 0xfc18 >= 0x2 == 0x0 (0x0) +__uint 0xfc18 >= 0x2 == 0x1 (0x1) +char 0x18 >= 0x2 == 0x1 (0x1) +__uchar 0x18 >= 0x2 == 0x1 (0x1) +__longlong 0xfc18 >= 0x2 == 0x0 (0x0) +__ulonglong 0xfc18 >= 0x2 == 0x1 (0x1) +float 0xfc18 >= 0x2 == 0x0 (0x0) +int 0xfc18 / 0x2 == -0x1f4 (0xfe0c) +__uint 0xfc18 / 0x2 == 0x7e0c (0x7e0c) +char 0x18 / 0x2 == 0xc (0xc) +__uchar 0x18 / 0x2 == 0xc (0xc) +__longlong 0xfc18 / 0x2 == -0x1f4 (0xfe0c) +__ulonglong 0xfc18 / 0x2 == -0x1f4 (0xfe0c) +float 0xfc18 / 0x2 == -0x1f4 (0xfe0c) +int 0xfc18 % 0x2 == 0x0 (0x0) +__uint 0xfc18 % 0x2 == 0x0 (0x0) +char 0x18 % 0x2 == 0x0 (0x0) +__uchar 0x18 % 0x2 == 0x0 (0x0) +__longlong 0xfc18 % 0x2 == 0x0 (0x0) +__ulonglong 0xfc18 % 0x2 == 0x0 (0x0) +0xfc18 * 0xfffe == 0x7d0 +0xfc18 / 0xfffe == 0x1f4 +0xfc18 % 0xfffe == 0x0 +int 0xfc18 ^ 0xfffe == 0x3e6 (0x3e6) +__uint 0xfc18 ^ 0xfffe == 0x3e6 (0x3e6) +char 0x18 ^ 0xfffe == -0x1a (0xffe6) +__uchar 0x18 ^ 0xfe == 0xe6 (0xe6) +__longlong 0xfc18 ^ 0xfffe == 0x3e6 (0x3e6) +__ulonglong 0xfc18 ^ 0xfffe == 0x3e6 (0x3e6) +int 0xfc18 && 0xfffe == 0x1 (0x1) +__uint 0xfc18 && 0xfffe == 0x1 (0x1) +char 0x18 && 0xfffe == 0x1 (0x1) +__uchar 0x18 && 0xfe == 0x1 (0x1) +__longlong 0xfc18 && 0xfffe == 0x1 (0x1) +__ulonglong 0xfc18 && 0xfffe == 0x1 (0x1) +int 0xfc18 || 0xfffe == 0x1 (0x1) +__uint 0xfc18 || 0xfffe == 0x1 (0x1) +char 0x18 || 0xfffe == 0x1 (0x1) +__uchar 0x18 || 0xfe == 0x1 (0x1) +__longlong 0xfc18 || 0xfffe == 0x1 (0x1) +__ulonglong 0xfc18 || 0xfffe == 0x1 (0x1) +int 0xfc18 & 0xfffe == -0x3e8 (0xfc18) +__uint 0xfc18 & 0xfffe == -0x3e8 (0xfc18) +char 0x18 & 0xfffe == 0x18 (0x18) +__uchar 0x18 & 0xfe == 0x18 (0x18) +__longlong 0xfc18 & 0xfffe == -0x3e8 (0xfc18) +__ulonglong 0xfc18 & 0xfffe == -0x3e8 (0xfc18) +int 0xfc18 | 0xfffe == -0x2 (0xfffe) +__uint 0xfc18 | 0xfffe == -0x2 (0xfffe) +char 0x18 | 0xfffe == -0x2 (0xfffe) +__uchar 0x18 | 0xfe == 0xfe (0xfe) +__longlong 0xfc18 | 0xfffe == -0x2 (0xfffe) +__ulonglong 0xfc18 | 0xfffe == -0x2 (0xfffe) +int 0xfc18 << 0x4 == -0x3e80 (0xc180) +__uint 0xfc18 << 0x4 == -0x3e80 (0xc180) +char 0x18 << 0x4 == -0x80 (0xff80) +__uchar 0x18 << 0x4 == 0x80 (0x80) +__longlong 0xfc18 << 0x4 == -0x3e80 (0xc180) +__ulonglong 0xfc18 << 0x4 == -0x3e80 (0xc180) +int 0xfc18 >> 0x4 == -0x3f (0xffc1) +__uint 0xfc18 >> 0x4 == 0xfc1 (0xfc1) +char 0x18 >> 0x4 == 0x1 (0x1) +__uchar 0x18 >> 0x4 == 0x1 (0x1) +__longlong 0xfc18 >> 0x4 == -0x3f (0xffc1) +__ulonglong 0xfc18 >> 0x4 == -0x3f (0xffc1) +int 0xfc18 + 0xfffe == -0x3ea (0xfc16) +__uint 0xfc18 + 0xfffe == -0x3ea (0xfc16) +char 0x18 + 0xfffe == 0x16 (0x16) +__uchar 0x18 + 0xfe == 0x16 (0x16) +__longlong 0xfc18 + 0xfffe == -0x3ea (0xfc16) +__ulonglong 0xfc18 + 0xfffe == -0x3ea (0xfc16) +float 0xfc18 + 0xfffe == -0x3ea (0xfc16) +int 0xfc18 - 0xfffe == -0x3e6 (0xfc1a) +__uint 0xfc18 - 0xfffe == -0x3e6 (0xfc1a) +char 0x18 - 0xfffe == 0x1a (0x1a) +__uchar 0x18 - 0xfe == 0x1a (0x1a) +__longlong 0xfc18 - 0xfffe == -0x3e6 (0xfc1a) +__ulonglong 0xfc18 - 0xfffe == -0x3e6 (0xfc1a) +float 0xfc18 - 0xfffe == -0x3e6 (0xfc1a) +int 0xfc18 * 0xfffe == 0x7d0 (0x7d0) +__uint 0xfc18 * 0xfffe == 0x7d0 (0x7d0) +char 0x18 * 0xfffe == -0x30 (0xffd0) +__uchar 0x18 * 0xfe == 0xd0 (0xd0) +__longlong 0xfc18 * 0xfffe == 0x7d0 (0x7d0) +__ulonglong 0xfc18 * 0xfffe == 0x7d0 (0x7d0) +float 0xfc18 * 0xfffe == 0x7d0 (0x7d0) +int 0xfc18 < 0xfffe == 0x1 (0x1) +__uint 0xfc18 < 0xfffe == 0x1 (0x1) +char 0x18 < 0xfffe == 0x0 (0x0) +__uchar 0x18 < 0xfe == 0x1 (0x1) +__longlong 0xfc18 < 0xfffe == 0x1 (0x1) +__ulonglong 0xfc18 < 0xfffe == 0x1 (0x1) +float 0xfc18 < 0xfffe == 0x1 (0x1) +int 0xfc18 > 0xfffe == 0x0 (0x0) +__uint 0xfc18 > 0xfffe == 0x0 (0x0) +char 0x18 > 0xfffe == 0x1 (0x1) +__uchar 0x18 > 0xfe == 0x0 (0x0) +__longlong 0xfc18 > 0xfffe == 0x0 (0x0) +__ulonglong 0xfc18 > 0xfffe == 0x0 (0x0) +float 0xfc18 > 0xfffe == 0x0 (0x0) +int 0xfc18 <= 0xfffe == 0x1 (0x1) +__uint 0xfc18 <= 0xfffe == 0x1 (0x1) +char 0x18 <= 0xfffe == 0x0 (0x0) +__uchar 0x18 <= 0xfe == 0x1 (0x1) +__longlong 0xfc18 <= 0xfffe == 0x1 (0x1) +__ulonglong 0xfc18 <= 0xfffe == 0x1 (0x1) +float 0xfc18 <= 0xfffe == 0x1 (0x1) +int 0xfc18 == 0xfffe == 0x0 (0x0) +__uint 0xfc18 == 0xfffe == 0x0 (0x0) +char 0x18 == 0xfffe == 0x0 (0x0) +__uchar 0x18 == 0xfe == 0x0 (0x0) +__longlong 0xfc18 == 0xfffe == 0x0 (0x0) +__ulonglong 0xfc18 == 0xfffe == 0x0 (0x0) +float 0xfc18 == 0xfffe == 0x0 (0x0) +int 0xfc18 != 0xfffe == 0x1 (0x1) +__uint 0xfc18 != 0xfffe == 0x1 (0x1) +char 0x18 != 0xfffe == 0x1 (0x1) +__uchar 0x18 != 0xfe == 0x1 (0x1) +__longlong 0xfc18 != 0xfffe == 0x1 (0x1) +__ulonglong 0xfc18 != 0xfffe == 0x1 (0x1) +float 0xfc18 != 0xfffe == 0x1 (0x1) +int 0xfc18 >= 0xfffe == 0x0 (0x0) +__uint 0xfc18 >= 0xfffe == 0x0 (0x0) +char 0x18 >= 0xfffe == 0x1 (0x1) +__uchar 0x18 >= 0xfe == 0x0 (0x0) +__longlong 0xfc18 >= 0xfffe == 0x0 (0x0) +__ulonglong 0xfc18 >= 0xfffe == 0x0 (0x0) +float 0xfc18 >= 0xfffe == 0x0 (0x0) +int 0xfc18 / 0xfffe == 0x1f4 (0x1f4) +__uint 0xfc18 / 0xfffe == 0x0 (0x0) +char 0x18 / 0xfffe == -0xc (0xfff4) +__uchar 0x18 / 0xfe == 0x0 (0x0) +__longlong 0xfc18 / 0xfffe == 0x1f4 (0x1f4) +__ulonglong 0xfc18 / 0xfffe == 0x0 (0x0) +float 0xfc18 / 0xfffe == 0x1f4 (0x1f4) +int 0xfc18 % 0xfffe == 0x0 (0x0) +__uint 0xfc18 % 0xfffe == -0x3e8 (0xfc18) +char 0x18 % 0xfffe == 0x0 (0x0) +__uchar 0x18 % 0xfe == 0x18 (0x18) +__longlong 0xfc18 % 0xfffe == 0x0 (0x0) +__ulonglong 0xfc18 % 0xfffe == -0x3e8 (0xfc18) +0xfc18 * 0x4 == -0xfa0 +0xfc18 / 0x4 == -0xfa +0xfc18 % 0x4 == 0x0 +int 0xfc18 ^ 0x4 == -0x3e4 (0xfc1c) +__uint 0xfc18 ^ 0x4 == -0x3e4 (0xfc1c) +char 0x18 ^ 0x4 == 0x1c (0x1c) +__uchar 0x18 ^ 0x4 == 0x1c (0x1c) +__longlong 0xfc18 ^ 0x4 == -0x3e4 (0xfc1c) +__ulonglong 0xfc18 ^ 0x4 == -0x3e4 (0xfc1c) +int 0xfc18 && 0x4 == 0x1 (0x1) +__uint 0xfc18 && 0x4 == 0x1 (0x1) +char 0x18 && 0x4 == 0x1 (0x1) +__uchar 0x18 && 0x4 == 0x1 (0x1) +__longlong 0xfc18 && 0x4 == 0x1 (0x1) +__ulonglong 0xfc18 && 0x4 == 0x1 (0x1) +int 0xfc18 || 0x4 == 0x1 (0x1) +__uint 0xfc18 || 0x4 == 0x1 (0x1) +char 0x18 || 0x4 == 0x1 (0x1) +__uchar 0x18 || 0x4 == 0x1 (0x1) +__longlong 0xfc18 || 0x4 == 0x1 (0x1) +__ulonglong 0xfc18 || 0x4 == 0x1 (0x1) +int 0xfc18 & 0x4 == 0x0 (0x0) +__uint 0xfc18 & 0x4 == 0x0 (0x0) +char 0x18 & 0x4 == 0x0 (0x0) +__uchar 0x18 & 0x4 == 0x0 (0x0) +__longlong 0xfc18 & 0x4 == 0x0 (0x0) +__ulonglong 0xfc18 & 0x4 == 0x0 (0x0) +int 0xfc18 | 0x4 == -0x3e4 (0xfc1c) +__uint 0xfc18 | 0x4 == -0x3e4 (0xfc1c) +char 0x18 | 0x4 == 0x1c (0x1c) +__uchar 0x18 | 0x4 == 0x1c (0x1c) +__longlong 0xfc18 | 0x4 == -0x3e4 (0xfc1c) +__ulonglong 0xfc18 | 0x4 == -0x3e4 (0xfc1c) +int 0xfc18 << 0x5 == -0x7d00 (0x8300) +__uint 0xfc18 << 0x5 == -0x7d00 (0x8300) +char 0x18 << 0x5 == 0x0 (0x0) +__uchar 0x18 << 0x5 == 0x0 (0x0) +__longlong 0xfc18 << 0x5 == -0x7d00 (0x8300) +__ulonglong 0xfc18 << 0x5 == -0x7d00 (0x8300) +int 0xfc18 >> 0x5 == -0x20 (0xffe0) +__uint 0xfc18 >> 0x5 == 0x7e0 (0x7e0) +char 0x18 >> 0x5 == 0x0 (0x0) +__uchar 0x18 >> 0x5 == 0x0 (0x0) +__longlong 0xfc18 >> 0x5 == -0x20 (0xffe0) +__ulonglong 0xfc18 >> 0x5 == -0x20 (0xffe0) +int 0xfc18 + 0x4 == -0x3e4 (0xfc1c) +__uint 0xfc18 + 0x4 == -0x3e4 (0xfc1c) +char 0x18 + 0x4 == 0x1c (0x1c) +__uchar 0x18 + 0x4 == 0x1c (0x1c) +__longlong 0xfc18 + 0x4 == -0x3e4 (0xfc1c) +__ulonglong 0xfc18 + 0x4 == -0x3e4 (0xfc1c) +float 0xfc18 + 0x4 == -0x3e4 (0xfc1c) +int 0xfc18 - 0x4 == -0x3ec (0xfc14) +__uint 0xfc18 - 0x4 == -0x3ec (0xfc14) +char 0x18 - 0x4 == 0x14 (0x14) +__uchar 0x18 - 0x4 == 0x14 (0x14) +__longlong 0xfc18 - 0x4 == -0x3ec (0xfc14) +__ulonglong 0xfc18 - 0x4 == -0x3ec (0xfc14) +float 0xfc18 - 0x4 == -0x3ec (0xfc14) +int 0xfc18 * 0x4 == -0xfa0 (0xf060) +__uint 0xfc18 * 0x4 == -0xfa0 (0xf060) +char 0x18 * 0x4 == 0x60 (0x60) +__uchar 0x18 * 0x4 == 0x60 (0x60) +__longlong 0xfc18 * 0x4 == -0xfa0 (0xf060) +__ulonglong 0xfc18 * 0x4 == -0xfa0 (0xf060) +float 0xfc18 * 0x4 == -0xfa0 (0xf060) +int 0xfc18 < 0x4 == 0x1 (0x1) +__uint 0xfc18 < 0x4 == 0x0 (0x0) +char 0x18 < 0x4 == 0x0 (0x0) +__uchar 0x18 < 0x4 == 0x0 (0x0) +__longlong 0xfc18 < 0x4 == 0x1 (0x1) +__ulonglong 0xfc18 < 0x4 == 0x0 (0x0) +float 0xfc18 < 0x4 == 0x1 (0x1) +int 0xfc18 > 0x4 == 0x0 (0x0) +__uint 0xfc18 > 0x4 == 0x1 (0x1) +char 0x18 > 0x4 == 0x1 (0x1) +__uchar 0x18 > 0x4 == 0x1 (0x1) +__longlong 0xfc18 > 0x4 == 0x0 (0x0) +__ulonglong 0xfc18 > 0x4 == 0x1 (0x1) +float 0xfc18 > 0x4 == 0x0 (0x0) +int 0xfc18 <= 0x4 == 0x1 (0x1) +__uint 0xfc18 <= 0x4 == 0x0 (0x0) +char 0x18 <= 0x4 == 0x0 (0x0) +__uchar 0x18 <= 0x4 == 0x0 (0x0) +__longlong 0xfc18 <= 0x4 == 0x1 (0x1) +__ulonglong 0xfc18 <= 0x4 == 0x0 (0x0) +float 0xfc18 <= 0x4 == 0x1 (0x1) +int 0xfc18 == 0x4 == 0x0 (0x0) +__uint 0xfc18 == 0x4 == 0x0 (0x0) +char 0x18 == 0x4 == 0x0 (0x0) +__uchar 0x18 == 0x4 == 0x0 (0x0) +__longlong 0xfc18 == 0x4 == 0x0 (0x0) +__ulonglong 0xfc18 == 0x4 == 0x0 (0x0) +float 0xfc18 == 0x4 == 0x0 (0x0) +int 0xfc18 != 0x4 == 0x1 (0x1) +__uint 0xfc18 != 0x4 == 0x1 (0x1) +char 0x18 != 0x4 == 0x1 (0x1) +__uchar 0x18 != 0x4 == 0x1 (0x1) +__longlong 0xfc18 != 0x4 == 0x1 (0x1) +__ulonglong 0xfc18 != 0x4 == 0x1 (0x1) +float 0xfc18 != 0x4 == 0x1 (0x1) +int 0xfc18 >= 0x4 == 0x0 (0x0) +__uint 0xfc18 >= 0x4 == 0x1 (0x1) +char 0x18 >= 0x4 == 0x1 (0x1) +__uchar 0x18 >= 0x4 == 0x1 (0x1) +__longlong 0xfc18 >= 0x4 == 0x0 (0x0) +__ulonglong 0xfc18 >= 0x4 == 0x1 (0x1) +float 0xfc18 >= 0x4 == 0x0 (0x0) +int 0xfc18 / 0x4 == -0xfa (0xff06) +__uint 0xfc18 / 0x4 == 0x3f06 (0x3f06) +char 0x18 / 0x4 == 0x6 (0x6) +__uchar 0x18 / 0x4 == 0x6 (0x6) +__longlong 0xfc18 / 0x4 == -0xfa (0xff06) +__ulonglong 0xfc18 / 0x4 == -0xfa (0xff06) +float 0xfc18 / 0x4 == -0xfa (0xff06) +int 0xfc18 % 0x4 == 0x0 (0x0) +__uint 0xfc18 % 0x4 == 0x0 (0x0) +char 0x18 % 0x4 == 0x0 (0x0) +__uchar 0x18 % 0x4 == 0x0 (0x0) +__longlong 0xfc18 % 0x4 == 0x0 (0x0) +__ulonglong 0xfc18 % 0x4 == 0x0 (0x0) +0xfc18 * 0xfffc == 0xfa0 +0xfc18 / 0xfffc == 0xfa +0xfc18 % 0xfffc == 0x0 +int 0xfc18 ^ 0xfffc == 0x3e4 (0x3e4) +__uint 0xfc18 ^ 0xfffc == 0x3e4 (0x3e4) +char 0x18 ^ 0xfffc == -0x1c (0xffe4) +__uchar 0x18 ^ 0xfc == 0xe4 (0xe4) +__longlong 0xfc18 ^ 0xfffc == 0x3e4 (0x3e4) +__ulonglong 0xfc18 ^ 0xfffc == 0x3e4 (0x3e4) +int 0xfc18 && 0xfffc == 0x1 (0x1) +__uint 0xfc18 && 0xfffc == 0x1 (0x1) +char 0x18 && 0xfffc == 0x1 (0x1) +__uchar 0x18 && 0xfc == 0x1 (0x1) +__longlong 0xfc18 && 0xfffc == 0x1 (0x1) +__ulonglong 0xfc18 && 0xfffc == 0x1 (0x1) +int 0xfc18 || 0xfffc == 0x1 (0x1) +__uint 0xfc18 || 0xfffc == 0x1 (0x1) +char 0x18 || 0xfffc == 0x1 (0x1) +__uchar 0x18 || 0xfc == 0x1 (0x1) +__longlong 0xfc18 || 0xfffc == 0x1 (0x1) +__ulonglong 0xfc18 || 0xfffc == 0x1 (0x1) +int 0xfc18 & 0xfffc == -0x3e8 (0xfc18) +__uint 0xfc18 & 0xfffc == -0x3e8 (0xfc18) +char 0x18 & 0xfffc == 0x18 (0x18) +__uchar 0x18 & 0xfc == 0x18 (0x18) +__longlong 0xfc18 & 0xfffc == -0x3e8 (0xfc18) +__ulonglong 0xfc18 & 0xfffc == -0x3e8 (0xfc18) +int 0xfc18 | 0xfffc == -0x4 (0xfffc) +__uint 0xfc18 | 0xfffc == -0x4 (0xfffc) +char 0x18 | 0xfffc == -0x4 (0xfffc) +__uchar 0x18 | 0xfc == 0xfc (0xfc) +__longlong 0xfc18 | 0xfffc == -0x4 (0xfffc) +__ulonglong 0xfc18 | 0xfffc == -0x4 (0xfffc) +int 0xfc18 << 0x6 == 0x600 (0x600) +__uint 0xfc18 << 0x6 == 0x600 (0x600) +char 0x18 << 0x6 == 0x0 (0x0) +__uchar 0x18 << 0x6 == 0x0 (0x0) +__longlong 0xfc18 << 0x6 == 0x600 (0x600) +__ulonglong 0xfc18 << 0x6 == 0x600 (0x600) +int 0xfc18 >> 0x6 == -0x10 (0xfff0) +__uint 0xfc18 >> 0x6 == 0x3f0 (0x3f0) +char 0x18 >> 0x6 == 0x0 (0x0) +__uchar 0x18 >> 0x6 == 0x0 (0x0) +__longlong 0xfc18 >> 0x6 == -0x10 (0xfff0) +__ulonglong 0xfc18 >> 0x6 == -0x10 (0xfff0) +int 0xfc18 + 0xfffc == -0x3ec (0xfc14) +__uint 0xfc18 + 0xfffc == -0x3ec (0xfc14) +char 0x18 + 0xfffc == 0x14 (0x14) +__uchar 0x18 + 0xfc == 0x14 (0x14) +__longlong 0xfc18 + 0xfffc == -0x3ec (0xfc14) +__ulonglong 0xfc18 + 0xfffc == -0x3ec (0xfc14) +float 0xfc18 + 0xfffc == -0x3ec (0xfc14) +int 0xfc18 - 0xfffc == -0x3e4 (0xfc1c) +__uint 0xfc18 - 0xfffc == -0x3e4 (0xfc1c) +char 0x18 - 0xfffc == 0x1c (0x1c) +__uchar 0x18 - 0xfc == 0x1c (0x1c) +__longlong 0xfc18 - 0xfffc == -0x3e4 (0xfc1c) +__ulonglong 0xfc18 - 0xfffc == -0x3e4 (0xfc1c) +float 0xfc18 - 0xfffc == -0x3e4 (0xfc1c) +int 0xfc18 * 0xfffc == 0xfa0 (0xfa0) +__uint 0xfc18 * 0xfffc == 0xfa0 (0xfa0) +char 0x18 * 0xfffc == -0x60 (0xffa0) +__uchar 0x18 * 0xfc == 0xa0 (0xa0) +__longlong 0xfc18 * 0xfffc == 0xfa0 (0xfa0) +__ulonglong 0xfc18 * 0xfffc == 0xfa0 (0xfa0) +float 0xfc18 * 0xfffc == 0xfa0 (0xfa0) +int 0xfc18 < 0xfffc == 0x1 (0x1) +__uint 0xfc18 < 0xfffc == 0x1 (0x1) +char 0x18 < 0xfffc == 0x0 (0x0) +__uchar 0x18 < 0xfc == 0x1 (0x1) +__longlong 0xfc18 < 0xfffc == 0x1 (0x1) +__ulonglong 0xfc18 < 0xfffc == 0x1 (0x1) +float 0xfc18 < 0xfffc == 0x1 (0x1) +int 0xfc18 > 0xfffc == 0x0 (0x0) +__uint 0xfc18 > 0xfffc == 0x0 (0x0) +char 0x18 > 0xfffc == 0x1 (0x1) +__uchar 0x18 > 0xfc == 0x0 (0x0) +__longlong 0xfc18 > 0xfffc == 0x0 (0x0) +__ulonglong 0xfc18 > 0xfffc == 0x0 (0x0) +float 0xfc18 > 0xfffc == 0x0 (0x0) +int 0xfc18 <= 0xfffc == 0x1 (0x1) +__uint 0xfc18 <= 0xfffc == 0x1 (0x1) +char 0x18 <= 0xfffc == 0x0 (0x0) +__uchar 0x18 <= 0xfc == 0x1 (0x1) +__longlong 0xfc18 <= 0xfffc == 0x1 (0x1) +__ulonglong 0xfc18 <= 0xfffc == 0x1 (0x1) +float 0xfc18 <= 0xfffc == 0x1 (0x1) +int 0xfc18 == 0xfffc == 0x0 (0x0) +__uint 0xfc18 == 0xfffc == 0x0 (0x0) +char 0x18 == 0xfffc == 0x0 (0x0) +__uchar 0x18 == 0xfc == 0x0 (0x0) +__longlong 0xfc18 == 0xfffc == 0x0 (0x0) +__ulonglong 0xfc18 == 0xfffc == 0x0 (0x0) +float 0xfc18 == 0xfffc == 0x0 (0x0) +int 0xfc18 != 0xfffc == 0x1 (0x1) +__uint 0xfc18 != 0xfffc == 0x1 (0x1) +char 0x18 != 0xfffc == 0x1 (0x1) +__uchar 0x18 != 0xfc == 0x1 (0x1) +__longlong 0xfc18 != 0xfffc == 0x1 (0x1) +__ulonglong 0xfc18 != 0xfffc == 0x1 (0x1) +float 0xfc18 != 0xfffc == 0x1 (0x1) +int 0xfc18 >= 0xfffc == 0x0 (0x0) +__uint 0xfc18 >= 0xfffc == 0x0 (0x0) +char 0x18 >= 0xfffc == 0x1 (0x1) +__uchar 0x18 >= 0xfc == 0x0 (0x0) +__longlong 0xfc18 >= 0xfffc == 0x0 (0x0) +__ulonglong 0xfc18 >= 0xfffc == 0x0 (0x0) +float 0xfc18 >= 0xfffc == 0x0 (0x0) +int 0xfc18 / 0xfffc == 0xfa (0xfa) +__uint 0xfc18 / 0xfffc == 0x0 (0x0) +char 0x18 / 0xfffc == -0x6 (0xfffa) +__uchar 0x18 / 0xfc == 0x0 (0x0) +__longlong 0xfc18 / 0xfffc == 0xfa (0xfa) +__ulonglong 0xfc18 / 0xfffc == 0x0 (0x0) +float 0xfc18 / 0xfffc == 0xfa (0xfa) +int 0xfc18 % 0xfffc == 0x0 (0x0) +__uint 0xfc18 % 0xfffc == -0x3e8 (0xfc18) +char 0x18 % 0xfffc == 0x0 (0x0) +__uchar 0x18 % 0xfc == 0x18 (0x18) +__longlong 0xfc18 % 0xfffc == 0x0 (0x0) +__ulonglong 0xfc18 % 0xfffc == -0x3e8 (0xfc18) +0xfc18 * 0xa == -0x2710 +0xfc18 / 0xa == -0x64 +0xfc18 % 0xa == 0x0 +int 0xfc18 ^ 0xa == -0x3ee (0xfc12) +__uint 0xfc18 ^ 0xa == -0x3ee (0xfc12) +char 0x18 ^ 0xa == 0x12 (0x12) +__uchar 0x18 ^ 0xa == 0x12 (0x12) +__longlong 0xfc18 ^ 0xa == -0x3ee (0xfc12) +__ulonglong 0xfc18 ^ 0xa == -0x3ee (0xfc12) +int 0xfc18 && 0xa == 0x1 (0x1) +__uint 0xfc18 && 0xa == 0x1 (0x1) +char 0x18 && 0xa == 0x1 (0x1) +__uchar 0x18 && 0xa == 0x1 (0x1) +__longlong 0xfc18 && 0xa == 0x1 (0x1) +__ulonglong 0xfc18 && 0xa == 0x1 (0x1) +int 0xfc18 || 0xa == 0x1 (0x1) +__uint 0xfc18 || 0xa == 0x1 (0x1) +char 0x18 || 0xa == 0x1 (0x1) +__uchar 0x18 || 0xa == 0x1 (0x1) +__longlong 0xfc18 || 0xa == 0x1 (0x1) +__ulonglong 0xfc18 || 0xa == 0x1 (0x1) +int 0xfc18 & 0xa == 0x8 (0x8) +__uint 0xfc18 & 0xa == 0x8 (0x8) +char 0x18 & 0xa == 0x8 (0x8) +__uchar 0x18 & 0xa == 0x8 (0x8) +__longlong 0xfc18 & 0xa == 0x8 (0x8) +__ulonglong 0xfc18 & 0xa == 0x8 (0x8) +int 0xfc18 | 0xa == -0x3e6 (0xfc1a) +__uint 0xfc18 | 0xa == -0x3e6 (0xfc1a) +char 0x18 | 0xa == 0x1a (0x1a) +__uchar 0x18 | 0xa == 0x1a (0x1a) +__longlong 0xfc18 | 0xa == -0x3e6 (0xfc1a) +__ulonglong 0xfc18 | 0xa == -0x3e6 (0xfc1a) +int 0xfc18 << 0x7 == 0xc00 (0xc00) +__uint 0xfc18 << 0x7 == 0xc00 (0xc00) +char 0x18 << 0x7 == 0x0 (0x0) +__uchar 0x18 << 0x7 == 0x0 (0x0) +__longlong 0xfc18 << 0x7 == 0xc00 (0xc00) +__ulonglong 0xfc18 << 0x7 == 0xc00 (0xc00) +int 0xfc18 >> 0x7 == -0x8 (0xfff8) +__uint 0xfc18 >> 0x7 == 0x1f8 (0x1f8) +char 0x18 >> 0x7 == 0x0 (0x0) +__uchar 0x18 >> 0x7 == 0x0 (0x0) +__longlong 0xfc18 >> 0x7 == -0x8 (0xfff8) +__ulonglong 0xfc18 >> 0x7 == -0x8 (0xfff8) +int 0xfc18 + 0xa == -0x3de (0xfc22) +__uint 0xfc18 + 0xa == -0x3de (0xfc22) +char 0x18 + 0xa == 0x22 (0x22) +__uchar 0x18 + 0xa == 0x22 (0x22) +__longlong 0xfc18 + 0xa == -0x3de (0xfc22) +__ulonglong 0xfc18 + 0xa == -0x3de (0xfc22) +float 0xfc18 + 0xa == -0x3de (0xfc22) +int 0xfc18 - 0xa == -0x3f2 (0xfc0e) +__uint 0xfc18 - 0xa == -0x3f2 (0xfc0e) +char 0x18 - 0xa == 0xe (0xe) +__uchar 0x18 - 0xa == 0xe (0xe) +__longlong 0xfc18 - 0xa == -0x3f2 (0xfc0e) +__ulonglong 0xfc18 - 0xa == -0x3f2 (0xfc0e) +float 0xfc18 - 0xa == -0x3f2 (0xfc0e) +int 0xfc18 * 0xa == -0x2710 (0xd8f0) +__uint 0xfc18 * 0xa == -0x2710 (0xd8f0) +char 0x18 * 0xa == -0x10 (0xfff0) +__uchar 0x18 * 0xa == 0xf0 (0xf0) +__longlong 0xfc18 * 0xa == -0x2710 (0xd8f0) +__ulonglong 0xfc18 * 0xa == -0x2710 (0xd8f0) +float 0xfc18 * 0xa == -0x2710 (0xd8f0) +int 0xfc18 < 0xa == 0x1 (0x1) +__uint 0xfc18 < 0xa == 0x0 (0x0) +char 0x18 < 0xa == 0x0 (0x0) +__uchar 0x18 < 0xa == 0x0 (0x0) +__longlong 0xfc18 < 0xa == 0x1 (0x1) +__ulonglong 0xfc18 < 0xa == 0x0 (0x0) +float 0xfc18 < 0xa == 0x1 (0x1) +int 0xfc18 > 0xa == 0x0 (0x0) +__uint 0xfc18 > 0xa == 0x1 (0x1) +char 0x18 > 0xa == 0x1 (0x1) +__uchar 0x18 > 0xa == 0x1 (0x1) +__longlong 0xfc18 > 0xa == 0x0 (0x0) +__ulonglong 0xfc18 > 0xa == 0x1 (0x1) +float 0xfc18 > 0xa == 0x0 (0x0) +int 0xfc18 <= 0xa == 0x1 (0x1) +__uint 0xfc18 <= 0xa == 0x0 (0x0) +char 0x18 <= 0xa == 0x0 (0x0) +__uchar 0x18 <= 0xa == 0x0 (0x0) +__longlong 0xfc18 <= 0xa == 0x1 (0x1) +__ulonglong 0xfc18 <= 0xa == 0x0 (0x0) +float 0xfc18 <= 0xa == 0x1 (0x1) +int 0xfc18 == 0xa == 0x0 (0x0) +__uint 0xfc18 == 0xa == 0x0 (0x0) +char 0x18 == 0xa == 0x0 (0x0) +__uchar 0x18 == 0xa == 0x0 (0x0) +__longlong 0xfc18 == 0xa == 0x0 (0x0) +__ulonglong 0xfc18 == 0xa == 0x0 (0x0) +float 0xfc18 == 0xa == 0x0 (0x0) +int 0xfc18 != 0xa == 0x1 (0x1) +__uint 0xfc18 != 0xa == 0x1 (0x1) +char 0x18 != 0xa == 0x1 (0x1) +__uchar 0x18 != 0xa == 0x1 (0x1) +__longlong 0xfc18 != 0xa == 0x1 (0x1) +__ulonglong 0xfc18 != 0xa == 0x1 (0x1) +float 0xfc18 != 0xa == 0x1 (0x1) +int 0xfc18 >= 0xa == 0x0 (0x0) +__uint 0xfc18 >= 0xa == 0x1 (0x1) +char 0x18 >= 0xa == 0x1 (0x1) +__uchar 0x18 >= 0xa == 0x1 (0x1) +__longlong 0xfc18 >= 0xa == 0x0 (0x0) +__ulonglong 0xfc18 >= 0xa == 0x1 (0x1) +float 0xfc18 >= 0xa == 0x0 (0x0) +int 0xfc18 / 0xa == -0x64 (0xff9c) +__uint 0xfc18 / 0xa == 0x1935 (0x1935) +char 0x18 / 0xa == 0x2 (0x2) +__uchar 0x18 / 0xa == 0x2 (0x2) +__longlong 0xfc18 / 0xa == -0x64 (0xff9c) +__ulonglong 0xfc18 / 0xa == -0x66cb (0x9935) +float 0xfc18 / 0xa == -0x64 (0xff9c) +int 0xfc18 % 0xa == 0x0 (0x0) +__uint 0xfc18 % 0xa == 0x6 (0x6) +char 0x18 % 0xa == 0x4 (0x4) +__uchar 0x18 % 0xa == 0x4 (0x4) +__longlong 0xfc18 % 0xa == 0x0 (0x0) +__ulonglong 0xfc18 % 0xa == 0x6 (0x6) +0xfc18 * 0xfff6 == 0x2710 +0xfc18 / 0xfff6 == 0x64 +0xfc18 % 0xfff6 == 0x0 +int 0xfc18 ^ 0xfff6 == 0x3ee (0x3ee) +__uint 0xfc18 ^ 0xfff6 == 0x3ee (0x3ee) +char 0x18 ^ 0xfff6 == -0x12 (0xffee) +__uchar 0x18 ^ 0xf6 == 0xee (0xee) +__longlong 0xfc18 ^ 0xfff6 == 0x3ee (0x3ee) +__ulonglong 0xfc18 ^ 0xfff6 == 0x3ee (0x3ee) +int 0xfc18 && 0xfff6 == 0x1 (0x1) +__uint 0xfc18 && 0xfff6 == 0x1 (0x1) +char 0x18 && 0xfff6 == 0x1 (0x1) +__uchar 0x18 && 0xf6 == 0x1 (0x1) +__longlong 0xfc18 && 0xfff6 == 0x1 (0x1) +__ulonglong 0xfc18 && 0xfff6 == 0x1 (0x1) +int 0xfc18 || 0xfff6 == 0x1 (0x1) +__uint 0xfc18 || 0xfff6 == 0x1 (0x1) +char 0x18 || 0xfff6 == 0x1 (0x1) +__uchar 0x18 || 0xf6 == 0x1 (0x1) +__longlong 0xfc18 || 0xfff6 == 0x1 (0x1) +__ulonglong 0xfc18 || 0xfff6 == 0x1 (0x1) +int 0xfc18 & 0xfff6 == -0x3f0 (0xfc10) +__uint 0xfc18 & 0xfff6 == -0x3f0 (0xfc10) +char 0x18 & 0xfff6 == 0x10 (0x10) +__uchar 0x18 & 0xf6 == 0x10 (0x10) +__longlong 0xfc18 & 0xfff6 == -0x3f0 (0xfc10) +__ulonglong 0xfc18 & 0xfff6 == -0x3f0 (0xfc10) +int 0xfc18 | 0xfff6 == -0x2 (0xfffe) +__uint 0xfc18 | 0xfff6 == -0x2 (0xfffe) +char 0x18 | 0xfff6 == -0x2 (0xfffe) +__uchar 0x18 | 0xf6 == 0xfe (0xfe) +__longlong 0xfc18 | 0xfff6 == -0x2 (0xfffe) +__ulonglong 0xfc18 | 0xfff6 == -0x2 (0xfffe) +int 0xfc18 << 0x8 == 0x1800 (0x1800) +__uint 0xfc18 << 0x8 == 0x1800 (0x1800) +char 0x18 << 0x8 == 0x0 (0x0) +__uchar 0x18 << 0x8 == 0x0 (0x0) +__longlong 0xfc18 << 0x8 == 0x1800 (0x1800) +__ulonglong 0xfc18 << 0x8 == 0x1800 (0x1800) +int 0xfc18 >> 0x8 == -0x4 (0xfffc) +__uint 0xfc18 >> 0x8 == 0xfc (0xfc) +char 0x18 >> 0x8 == 0x0 (0x0) +__uchar 0x18 >> 0x8 == 0x0 (0x0) +__longlong 0xfc18 >> 0x8 == -0x4 (0xfffc) +__ulonglong 0xfc18 >> 0x8 == -0x4 (0xfffc) +int 0xfc18 + 0xfff6 == -0x3f2 (0xfc0e) +__uint 0xfc18 + 0xfff6 == -0x3f2 (0xfc0e) +char 0x18 + 0xfff6 == 0xe (0xe) +__uchar 0x18 + 0xf6 == 0xe (0xe) +__longlong 0xfc18 + 0xfff6 == -0x3f2 (0xfc0e) +__ulonglong 0xfc18 + 0xfff6 == -0x3f2 (0xfc0e) +float 0xfc18 + 0xfff6 == -0x3f2 (0xfc0e) +int 0xfc18 - 0xfff6 == -0x3de (0xfc22) +__uint 0xfc18 - 0xfff6 == -0x3de (0xfc22) +char 0x18 - 0xfff6 == 0x22 (0x22) +__uchar 0x18 - 0xf6 == 0x22 (0x22) +__longlong 0xfc18 - 0xfff6 == -0x3de (0xfc22) +__ulonglong 0xfc18 - 0xfff6 == -0x3de (0xfc22) +float 0xfc18 - 0xfff6 == -0x3de (0xfc22) +int 0xfc18 * 0xfff6 == 0x2710 (0x2710) +__uint 0xfc18 * 0xfff6 == 0x2710 (0x2710) +char 0x18 * 0xfff6 == 0x10 (0x10) +__uchar 0x18 * 0xf6 == 0x10 (0x10) +__longlong 0xfc18 * 0xfff6 == 0x2710 (0x2710) +__ulonglong 0xfc18 * 0xfff6 == 0x2710 (0x2710) +float 0xfc18 * 0xfff6 == 0x2710 (0x2710) +int 0xfc18 < 0xfff6 == 0x1 (0x1) +__uint 0xfc18 < 0xfff6 == 0x1 (0x1) +char 0x18 < 0xfff6 == 0x0 (0x0) +__uchar 0x18 < 0xf6 == 0x1 (0x1) +__longlong 0xfc18 < 0xfff6 == 0x1 (0x1) +__ulonglong 0xfc18 < 0xfff6 == 0x1 (0x1) +float 0xfc18 < 0xfff6 == 0x1 (0x1) +int 0xfc18 > 0xfff6 == 0x0 (0x0) +__uint 0xfc18 > 0xfff6 == 0x0 (0x0) +char 0x18 > 0xfff6 == 0x1 (0x1) +__uchar 0x18 > 0xf6 == 0x0 (0x0) +__longlong 0xfc18 > 0xfff6 == 0x0 (0x0) +__ulonglong 0xfc18 > 0xfff6 == 0x0 (0x0) +float 0xfc18 > 0xfff6 == 0x0 (0x0) +int 0xfc18 <= 0xfff6 == 0x1 (0x1) +__uint 0xfc18 <= 0xfff6 == 0x1 (0x1) +char 0x18 <= 0xfff6 == 0x0 (0x0) +__uchar 0x18 <= 0xf6 == 0x1 (0x1) +__longlong 0xfc18 <= 0xfff6 == 0x1 (0x1) +__ulonglong 0xfc18 <= 0xfff6 == 0x1 (0x1) +float 0xfc18 <= 0xfff6 == 0x1 (0x1) +int 0xfc18 == 0xfff6 == 0x0 (0x0) +__uint 0xfc18 == 0xfff6 == 0x0 (0x0) +char 0x18 == 0xfff6 == 0x0 (0x0) +__uchar 0x18 == 0xf6 == 0x0 (0x0) +__longlong 0xfc18 == 0xfff6 == 0x0 (0x0) +__ulonglong 0xfc18 == 0xfff6 == 0x0 (0x0) +float 0xfc18 == 0xfff6 == 0x0 (0x0) +int 0xfc18 != 0xfff6 == 0x1 (0x1) +__uint 0xfc18 != 0xfff6 == 0x1 (0x1) +char 0x18 != 0xfff6 == 0x1 (0x1) +__uchar 0x18 != 0xf6 == 0x1 (0x1) +__longlong 0xfc18 != 0xfff6 == 0x1 (0x1) +__ulonglong 0xfc18 != 0xfff6 == 0x1 (0x1) +float 0xfc18 != 0xfff6 == 0x1 (0x1) +int 0xfc18 >= 0xfff6 == 0x0 (0x0) +__uint 0xfc18 >= 0xfff6 == 0x0 (0x0) +char 0x18 >= 0xfff6 == 0x1 (0x1) +__uchar 0x18 >= 0xf6 == 0x0 (0x0) +__longlong 0xfc18 >= 0xfff6 == 0x0 (0x0) +__ulonglong 0xfc18 >= 0xfff6 == 0x0 (0x0) +float 0xfc18 >= 0xfff6 == 0x0 (0x0) +int 0xfc18 / 0xfff6 == 0x64 (0x64) +__uint 0xfc18 / 0xfff6 == 0x0 (0x0) +char 0x18 / 0xfff6 == -0x2 (0xfffe) +__uchar 0x18 / 0xf6 == 0x0 (0x0) +__longlong 0xfc18 / 0xfff6 == 0x64 (0x64) +__ulonglong 0xfc18 / 0xfff6 == 0x0 (0x0) +float 0xfc18 / 0xfff6 == 0x64 (0x64) +int 0xfc18 % 0xfff6 == 0x0 (0x0) +__uint 0xfc18 % 0xfff6 == -0x3e8 (0xfc18) +char 0x18 % 0xfff6 == 0x4 (0x4) +__uchar 0x18 % 0xf6 == 0x18 (0x18) +__longlong 0xfc18 % 0xfff6 == 0x0 (0x0) +__ulonglong 0xfc18 % 0xfff6 == -0x3e8 (0xfc18) +0xfc18 * 0x5 == -0x1388 +0xfc18 / 0x5 == -0xc8 +0xfc18 % 0x5 == 0x0 +int 0xfc18 ^ 0x5 == -0x3e3 (0xfc1d) +__uint 0xfc18 ^ 0x5 == -0x3e3 (0xfc1d) +char 0x18 ^ 0x5 == 0x1d (0x1d) +__uchar 0x18 ^ 0x5 == 0x1d (0x1d) +__longlong 0xfc18 ^ 0x5 == -0x3e3 (0xfc1d) +__ulonglong 0xfc18 ^ 0x5 == -0x3e3 (0xfc1d) +int 0xfc18 && 0x5 == 0x1 (0x1) +__uint 0xfc18 && 0x5 == 0x1 (0x1) +char 0x18 && 0x5 == 0x1 (0x1) +__uchar 0x18 && 0x5 == 0x1 (0x1) +__longlong 0xfc18 && 0x5 == 0x1 (0x1) +__ulonglong 0xfc18 && 0x5 == 0x1 (0x1) +int 0xfc18 || 0x5 == 0x1 (0x1) +__uint 0xfc18 || 0x5 == 0x1 (0x1) +char 0x18 || 0x5 == 0x1 (0x1) +__uchar 0x18 || 0x5 == 0x1 (0x1) +__longlong 0xfc18 || 0x5 == 0x1 (0x1) +__ulonglong 0xfc18 || 0x5 == 0x1 (0x1) +int 0xfc18 & 0x5 == 0x0 (0x0) +__uint 0xfc18 & 0x5 == 0x0 (0x0) +char 0x18 & 0x5 == 0x0 (0x0) +__uchar 0x18 & 0x5 == 0x0 (0x0) +__longlong 0xfc18 & 0x5 == 0x0 (0x0) +__ulonglong 0xfc18 & 0x5 == 0x0 (0x0) +int 0xfc18 | 0x5 == -0x3e3 (0xfc1d) +__uint 0xfc18 | 0x5 == -0x3e3 (0xfc1d) +char 0x18 | 0x5 == 0x1d (0x1d) +__uchar 0x18 | 0x5 == 0x1d (0x1d) +__longlong 0xfc18 | 0x5 == -0x3e3 (0xfc1d) +__ulonglong 0xfc18 | 0x5 == -0x3e3 (0xfc1d) +int 0xfc18 << 0x9 == 0x3000 (0x3000) +__uint 0xfc18 << 0x9 == 0x3000 (0x3000) +char 0x18 << 0x9 == 0x0 (0x0) +__uchar 0x18 << 0x9 == 0x0 (0x0) +__longlong 0xfc18 << 0x9 == 0x3000 (0x3000) +__ulonglong 0xfc18 << 0x9 == 0x3000 (0x3000) +int 0xfc18 >> 0x9 == -0x2 (0xfffe) +__uint 0xfc18 >> 0x9 == 0x7e (0x7e) +char 0x18 >> 0x9 == 0x0 (0x0) +__uchar 0x18 >> 0x9 == 0x0 (0x0) +__longlong 0xfc18 >> 0x9 == -0x2 (0xfffe) +__ulonglong 0xfc18 >> 0x9 == -0x2 (0xfffe) +int 0xfc18 + 0x5 == -0x3e3 (0xfc1d) +__uint 0xfc18 + 0x5 == -0x3e3 (0xfc1d) +char 0x18 + 0x5 == 0x1d (0x1d) +__uchar 0x18 + 0x5 == 0x1d (0x1d) +__longlong 0xfc18 + 0x5 == -0x3e3 (0xfc1d) +__ulonglong 0xfc18 + 0x5 == -0x3e3 (0xfc1d) +float 0xfc18 + 0x5 == -0x3e3 (0xfc1d) +int 0xfc18 - 0x5 == -0x3ed (0xfc13) +__uint 0xfc18 - 0x5 == -0x3ed (0xfc13) +char 0x18 - 0x5 == 0x13 (0x13) +__uchar 0x18 - 0x5 == 0x13 (0x13) +__longlong 0xfc18 - 0x5 == -0x3ed (0xfc13) +__ulonglong 0xfc18 - 0x5 == -0x3ed (0xfc13) +float 0xfc18 - 0x5 == -0x3ed (0xfc13) +int 0xfc18 * 0x5 == -0x1388 (0xec78) +__uint 0xfc18 * 0x5 == -0x1388 (0xec78) +char 0x18 * 0x5 == 0x78 (0x78) +__uchar 0x18 * 0x5 == 0x78 (0x78) +__longlong 0xfc18 * 0x5 == -0x1388 (0xec78) +__ulonglong 0xfc18 * 0x5 == -0x1388 (0xec78) +float 0xfc18 * 0x5 == -0x1388 (0xec78) +int 0xfc18 < 0x5 == 0x1 (0x1) +__uint 0xfc18 < 0x5 == 0x0 (0x0) +char 0x18 < 0x5 == 0x0 (0x0) +__uchar 0x18 < 0x5 == 0x0 (0x0) +__longlong 0xfc18 < 0x5 == 0x1 (0x1) +__ulonglong 0xfc18 < 0x5 == 0x0 (0x0) +float 0xfc18 < 0x5 == 0x1 (0x1) +int 0xfc18 > 0x5 == 0x0 (0x0) +__uint 0xfc18 > 0x5 == 0x1 (0x1) +char 0x18 > 0x5 == 0x1 (0x1) +__uchar 0x18 > 0x5 == 0x1 (0x1) +__longlong 0xfc18 > 0x5 == 0x0 (0x0) +__ulonglong 0xfc18 > 0x5 == 0x1 (0x1) +float 0xfc18 > 0x5 == 0x0 (0x0) +int 0xfc18 <= 0x5 == 0x1 (0x1) +__uint 0xfc18 <= 0x5 == 0x0 (0x0) +char 0x18 <= 0x5 == 0x0 (0x0) +__uchar 0x18 <= 0x5 == 0x0 (0x0) +__longlong 0xfc18 <= 0x5 == 0x1 (0x1) +__ulonglong 0xfc18 <= 0x5 == 0x0 (0x0) +float 0xfc18 <= 0x5 == 0x1 (0x1) +int 0xfc18 == 0x5 == 0x0 (0x0) +__uint 0xfc18 == 0x5 == 0x0 (0x0) +char 0x18 == 0x5 == 0x0 (0x0) +__uchar 0x18 == 0x5 == 0x0 (0x0) +__longlong 0xfc18 == 0x5 == 0x0 (0x0) +__ulonglong 0xfc18 == 0x5 == 0x0 (0x0) +float 0xfc18 == 0x5 == 0x0 (0x0) +int 0xfc18 != 0x5 == 0x1 (0x1) +__uint 0xfc18 != 0x5 == 0x1 (0x1) +char 0x18 != 0x5 == 0x1 (0x1) +__uchar 0x18 != 0x5 == 0x1 (0x1) +__longlong 0xfc18 != 0x5 == 0x1 (0x1) +__ulonglong 0xfc18 != 0x5 == 0x1 (0x1) +float 0xfc18 != 0x5 == 0x1 (0x1) +int 0xfc18 >= 0x5 == 0x0 (0x0) +__uint 0xfc18 >= 0x5 == 0x1 (0x1) +char 0x18 >= 0x5 == 0x1 (0x1) +__uchar 0x18 >= 0x5 == 0x1 (0x1) +__longlong 0xfc18 >= 0x5 == 0x0 (0x0) +__ulonglong 0xfc18 >= 0x5 == 0x1 (0x1) +float 0xfc18 >= 0x5 == 0x0 (0x0) +int 0xfc18 / 0x5 == -0xc8 (0xff38) +__uint 0xfc18 / 0x5 == 0x326b (0x326b) +char 0x18 / 0x5 == 0x4 (0x4) +__uchar 0x18 / 0x5 == 0x4 (0x4) +__longlong 0xfc18 / 0x5 == -0xc8 (0xff38) +__ulonglong 0xfc18 / 0x5 == 0x326b (0x326b) +float 0xfc18 / 0x5 == -0xc8 (0xff38) +int 0xfc18 % 0x5 == 0x0 (0x0) +__uint 0xfc18 % 0x5 == 0x1 (0x1) +char 0x18 % 0x5 == 0x4 (0x4) +__uchar 0x18 % 0x5 == 0x4 (0x4) +__longlong 0xfc18 % 0x5 == 0x0 (0x0) +__ulonglong 0xfc18 % 0x5 == 0x1 (0x1) +0xfc18 * 0x7 == -0x1b58 +0xfc18 / 0x7 == -0x8e +0xfc18 % 0x7 == -0x6 +int 0xfc18 ^ 0x7 == -0x3e1 (0xfc1f) +__uint 0xfc18 ^ 0x7 == -0x3e1 (0xfc1f) +char 0x18 ^ 0x7 == 0x1f (0x1f) +__uchar 0x18 ^ 0x7 == 0x1f (0x1f) +__longlong 0xfc18 ^ 0x7 == -0x3e1 (0xfc1f) +__ulonglong 0xfc18 ^ 0x7 == -0x3e1 (0xfc1f) +int 0xfc18 && 0x7 == 0x1 (0x1) +__uint 0xfc18 && 0x7 == 0x1 (0x1) +char 0x18 && 0x7 == 0x1 (0x1) +__uchar 0x18 && 0x7 == 0x1 (0x1) +__longlong 0xfc18 && 0x7 == 0x1 (0x1) +__ulonglong 0xfc18 && 0x7 == 0x1 (0x1) +int 0xfc18 || 0x7 == 0x1 (0x1) +__uint 0xfc18 || 0x7 == 0x1 (0x1) +char 0x18 || 0x7 == 0x1 (0x1) +__uchar 0x18 || 0x7 == 0x1 (0x1) +__longlong 0xfc18 || 0x7 == 0x1 (0x1) +__ulonglong 0xfc18 || 0x7 == 0x1 (0x1) +int 0xfc18 & 0x7 == 0x0 (0x0) +__uint 0xfc18 & 0x7 == 0x0 (0x0) +char 0x18 & 0x7 == 0x0 (0x0) +__uchar 0x18 & 0x7 == 0x0 (0x0) +__longlong 0xfc18 & 0x7 == 0x0 (0x0) +__ulonglong 0xfc18 & 0x7 == 0x0 (0x0) +int 0xfc18 | 0x7 == -0x3e1 (0xfc1f) +__uint 0xfc18 | 0x7 == -0x3e1 (0xfc1f) +char 0x18 | 0x7 == 0x1f (0x1f) +__uchar 0x18 | 0x7 == 0x1f (0x1f) +__longlong 0xfc18 | 0x7 == -0x3e1 (0xfc1f) +__ulonglong 0xfc18 | 0x7 == -0x3e1 (0xfc1f) +int 0xfc18 << 0xa == 0x6000 (0x6000) +__uint 0xfc18 << 0xa == 0x6000 (0x6000) +char 0x18 << 0xa == 0x0 (0x0) +__uchar 0x18 << 0xa == 0x0 (0x0) +__longlong 0xfc18 << 0xa == 0x6000 (0x6000) +__ulonglong 0xfc18 << 0xa == 0x6000 (0x6000) +int 0xfc18 >> 0xa == -0x1 (0xffff) +__uint 0xfc18 >> 0xa == 0x3f (0x3f) +char 0x18 >> 0xa == 0x0 (0x0) +__uchar 0x18 >> 0xa == 0x0 (0x0) +__longlong 0xfc18 >> 0xa == -0x1 (0xffff) +__ulonglong 0xfc18 >> 0xa == -0x1 (0xffff) +int 0xfc18 + 0x7 == -0x3e1 (0xfc1f) +__uint 0xfc18 + 0x7 == -0x3e1 (0xfc1f) +char 0x18 + 0x7 == 0x1f (0x1f) +__uchar 0x18 + 0x7 == 0x1f (0x1f) +__longlong 0xfc18 + 0x7 == -0x3e1 (0xfc1f) +__ulonglong 0xfc18 + 0x7 == -0x3e1 (0xfc1f) +float 0xfc18 + 0x7 == -0x3e1 (0xfc1f) +int 0xfc18 - 0x7 == -0x3ef (0xfc11) +__uint 0xfc18 - 0x7 == -0x3ef (0xfc11) +char 0x18 - 0x7 == 0x11 (0x11) +__uchar 0x18 - 0x7 == 0x11 (0x11) +__longlong 0xfc18 - 0x7 == -0x3ef (0xfc11) +__ulonglong 0xfc18 - 0x7 == -0x3ef (0xfc11) +float 0xfc18 - 0x7 == -0x3ef (0xfc11) +int 0xfc18 * 0x7 == -0x1b58 (0xe4a8) +__uint 0xfc18 * 0x7 == -0x1b58 (0xe4a8) +char 0x18 * 0x7 == -0x58 (0xffa8) +__uchar 0x18 * 0x7 == 0xa8 (0xa8) +__longlong 0xfc18 * 0x7 == -0x1b58 (0xe4a8) +__ulonglong 0xfc18 * 0x7 == -0x1b58 (0xe4a8) +float 0xfc18 * 0x7 == -0x1b58 (0xe4a8) +int 0xfc18 < 0x7 == 0x1 (0x1) +__uint 0xfc18 < 0x7 == 0x0 (0x0) +char 0x18 < 0x7 == 0x0 (0x0) +__uchar 0x18 < 0x7 == 0x0 (0x0) +__longlong 0xfc18 < 0x7 == 0x1 (0x1) +__ulonglong 0xfc18 < 0x7 == 0x0 (0x0) +float 0xfc18 < 0x7 == 0x1 (0x1) +int 0xfc18 > 0x7 == 0x0 (0x0) +__uint 0xfc18 > 0x7 == 0x1 (0x1) +char 0x18 > 0x7 == 0x1 (0x1) +__uchar 0x18 > 0x7 == 0x1 (0x1) +__longlong 0xfc18 > 0x7 == 0x0 (0x0) +__ulonglong 0xfc18 > 0x7 == 0x1 (0x1) +float 0xfc18 > 0x7 == 0x0 (0x0) +int 0xfc18 <= 0x7 == 0x1 (0x1) +__uint 0xfc18 <= 0x7 == 0x0 (0x0) +char 0x18 <= 0x7 == 0x0 (0x0) +__uchar 0x18 <= 0x7 == 0x0 (0x0) +__longlong 0xfc18 <= 0x7 == 0x1 (0x1) +__ulonglong 0xfc18 <= 0x7 == 0x0 (0x0) +float 0xfc18 <= 0x7 == 0x1 (0x1) +int 0xfc18 == 0x7 == 0x0 (0x0) +__uint 0xfc18 == 0x7 == 0x0 (0x0) +char 0x18 == 0x7 == 0x0 (0x0) +__uchar 0x18 == 0x7 == 0x0 (0x0) +__longlong 0xfc18 == 0x7 == 0x0 (0x0) +__ulonglong 0xfc18 == 0x7 == 0x0 (0x0) +float 0xfc18 == 0x7 == 0x0 (0x0) +int 0xfc18 != 0x7 == 0x1 (0x1) +__uint 0xfc18 != 0x7 == 0x1 (0x1) +char 0x18 != 0x7 == 0x1 (0x1) +__uchar 0x18 != 0x7 == 0x1 (0x1) +__longlong 0xfc18 != 0x7 == 0x1 (0x1) +__ulonglong 0xfc18 != 0x7 == 0x1 (0x1) +float 0xfc18 != 0x7 == 0x1 (0x1) +int 0xfc18 >= 0x7 == 0x0 (0x0) +__uint 0xfc18 >= 0x7 == 0x1 (0x1) +char 0x18 >= 0x7 == 0x1 (0x1) +__uchar 0x18 >= 0x7 == 0x1 (0x1) +__longlong 0xfc18 >= 0x7 == 0x0 (0x0) +__ulonglong 0xfc18 >= 0x7 == 0x1 (0x1) +float 0xfc18 >= 0x7 == 0x0 (0x0) +int 0xfc18 / 0x7 == -0x8e (0xff72) +__uint 0xfc18 / 0x7 == 0x2403 (0x2403) +char 0x18 / 0x7 == 0x3 (0x3) +__uchar 0x18 / 0x7 == 0x3 (0x3) +__longlong 0xfc18 / 0x7 == -0x8e (0xff72) +__ulonglong 0xfc18 / 0x7 == 0x4895 (0x4895) +float 0xfc18 / 0x7 == -0x8e (0xff72) +int 0xfc18 % 0x7 == -0x6 (0xfffa) +__uint 0xfc18 % 0x7 == 0x3 (0x3) +char 0x18 % 0x7 == 0x3 (0x3) +__uchar 0x18 % 0x7 == 0x3 (0x3) +__longlong 0xfc18 % 0x7 == -0x6 (0xfffa) +__ulonglong 0xfc18 % 0x7 == 0x5 (0x5) +0xfc18 * 0x2a == 0x5bf0 +0xfc18 / 0x2a == -0x17 +0xfc18 % 0x2a == -0x22 +int 0xfc18 ^ 0x2a == -0x3ce (0xfc32) +__uint 0xfc18 ^ 0x2a == -0x3ce (0xfc32) +char 0x18 ^ 0x2a == 0x32 (0x32) +__uchar 0x18 ^ 0x2a == 0x32 (0x32) +__longlong 0xfc18 ^ 0x2a == -0x3ce (0xfc32) +__ulonglong 0xfc18 ^ 0x2a == -0x3ce (0xfc32) +int 0xfc18 && 0x2a == 0x1 (0x1) +__uint 0xfc18 && 0x2a == 0x1 (0x1) +char 0x18 && 0x2a == 0x1 (0x1) +__uchar 0x18 && 0x2a == 0x1 (0x1) +__longlong 0xfc18 && 0x2a == 0x1 (0x1) +__ulonglong 0xfc18 && 0x2a == 0x1 (0x1) +int 0xfc18 || 0x2a == 0x1 (0x1) +__uint 0xfc18 || 0x2a == 0x1 (0x1) +char 0x18 || 0x2a == 0x1 (0x1) +__uchar 0x18 || 0x2a == 0x1 (0x1) +__longlong 0xfc18 || 0x2a == 0x1 (0x1) +__ulonglong 0xfc18 || 0x2a == 0x1 (0x1) +int 0xfc18 & 0x2a == 0x8 (0x8) +__uint 0xfc18 & 0x2a == 0x8 (0x8) +char 0x18 & 0x2a == 0x8 (0x8) +__uchar 0x18 & 0x2a == 0x8 (0x8) +__longlong 0xfc18 & 0x2a == 0x8 (0x8) +__ulonglong 0xfc18 & 0x2a == 0x8 (0x8) +int 0xfc18 | 0x2a == -0x3c6 (0xfc3a) +__uint 0xfc18 | 0x2a == -0x3c6 (0xfc3a) +char 0x18 | 0x2a == 0x3a (0x3a) +__uchar 0x18 | 0x2a == 0x3a (0x3a) +__longlong 0xfc18 | 0x2a == -0x3c6 (0xfc3a) +__ulonglong 0xfc18 | 0x2a == -0x3c6 (0xfc3a) +int 0xfc18 << 0xc == -0x8000 (0x8000) +__uint 0xfc18 << 0xc == -0x8000 (0x8000) +char 0x18 << 0xc == 0x0 (0x0) +__uchar 0x18 << 0xc == 0x0 (0x0) +__longlong 0xfc18 << 0xc == -0x8000 (0x8000) +__ulonglong 0xfc18 << 0xc == -0x8000 (0x8000) +int 0xfc18 >> 0xc == -0x1 (0xffff) +__uint 0xfc18 >> 0xc == 0xf (0xf) +char 0x18 >> 0xc == 0x0 (0x0) +__uchar 0x18 >> 0xc == 0x0 (0x0) +__longlong 0xfc18 >> 0xc == -0x1 (0xffff) +__ulonglong 0xfc18 >> 0xc == -0x1 (0xffff) +int 0xfc18 + 0x2a == -0x3be (0xfc42) +__uint 0xfc18 + 0x2a == -0x3be (0xfc42) +char 0x18 + 0x2a == 0x42 (0x42) +__uchar 0x18 + 0x2a == 0x42 (0x42) +__longlong 0xfc18 + 0x2a == -0x3be (0xfc42) +__ulonglong 0xfc18 + 0x2a == -0x3be (0xfc42) +float 0xfc18 + 0x2a == -0x3be (0xfc42) +int 0xfc18 - 0x2a == -0x412 (0xfbee) +__uint 0xfc18 - 0x2a == -0x412 (0xfbee) +char 0x18 - 0x2a == -0x12 (0xffee) +__uchar 0x18 - 0x2a == 0xee (0xee) +__longlong 0xfc18 - 0x2a == -0x412 (0xfbee) +__ulonglong 0xfc18 - 0x2a == -0x412 (0xfbee) +float 0xfc18 - 0x2a == -0x412 (0xfbee) +int 0xfc18 * 0x2a == 0x5bf0 (0x5bf0) +__uint 0xfc18 * 0x2a == 0x5bf0 (0x5bf0) +char 0x18 * 0x2a == -0x10 (0xfff0) +__uchar 0x18 * 0x2a == 0xf0 (0xf0) +__longlong 0xfc18 * 0x2a == 0x5bf0 (0x5bf0) +__ulonglong 0xfc18 * 0x2a == 0x5bf0 (0x5bf0) +float 0xfc18 * 0x2a == 0x5bf0 (0x5bf0) +int 0xfc18 < 0x2a == 0x1 (0x1) +__uint 0xfc18 < 0x2a == 0x0 (0x0) +char 0x18 < 0x2a == 0x1 (0x1) +__uchar 0x18 < 0x2a == 0x1 (0x1) +__longlong 0xfc18 < 0x2a == 0x1 (0x1) +__ulonglong 0xfc18 < 0x2a == 0x0 (0x0) +float 0xfc18 < 0x2a == 0x1 (0x1) +int 0xfc18 > 0x2a == 0x0 (0x0) +__uint 0xfc18 > 0x2a == 0x1 (0x1) +char 0x18 > 0x2a == 0x0 (0x0) +__uchar 0x18 > 0x2a == 0x0 (0x0) +__longlong 0xfc18 > 0x2a == 0x0 (0x0) +__ulonglong 0xfc18 > 0x2a == 0x1 (0x1) +float 0xfc18 > 0x2a == 0x0 (0x0) +int 0xfc18 <= 0x2a == 0x1 (0x1) +__uint 0xfc18 <= 0x2a == 0x0 (0x0) +char 0x18 <= 0x2a == 0x1 (0x1) +__uchar 0x18 <= 0x2a == 0x1 (0x1) +__longlong 0xfc18 <= 0x2a == 0x1 (0x1) +__ulonglong 0xfc18 <= 0x2a == 0x0 (0x0) +float 0xfc18 <= 0x2a == 0x1 (0x1) +int 0xfc18 == 0x2a == 0x0 (0x0) +__uint 0xfc18 == 0x2a == 0x0 (0x0) +char 0x18 == 0x2a == 0x0 (0x0) +__uchar 0x18 == 0x2a == 0x0 (0x0) +__longlong 0xfc18 == 0x2a == 0x0 (0x0) +__ulonglong 0xfc18 == 0x2a == 0x0 (0x0) +float 0xfc18 == 0x2a == 0x0 (0x0) +int 0xfc18 != 0x2a == 0x1 (0x1) +__uint 0xfc18 != 0x2a == 0x1 (0x1) +char 0x18 != 0x2a == 0x1 (0x1) +__uchar 0x18 != 0x2a == 0x1 (0x1) +__longlong 0xfc18 != 0x2a == 0x1 (0x1) +__ulonglong 0xfc18 != 0x2a == 0x1 (0x1) +float 0xfc18 != 0x2a == 0x1 (0x1) +int 0xfc18 >= 0x2a == 0x0 (0x0) +__uint 0xfc18 >= 0x2a == 0x1 (0x1) +char 0x18 >= 0x2a == 0x0 (0x0) +__uchar 0x18 >= 0x2a == 0x0 (0x0) +__longlong 0xfc18 >= 0x2a == 0x0 (0x0) +__ulonglong 0xfc18 >= 0x2a == 0x1 (0x1) +float 0xfc18 >= 0x2a == 0x0 (0x0) +int 0xfc18 / 0x2a == -0x17 (0xffe9) +__uint 0xfc18 / 0x2a == 0x600 (0x600) +char 0x18 / 0x2a == 0x0 (0x0) +__uchar 0x18 / 0x2a == 0x0 (0x0) +__longlong 0xfc18 / 0x2a == -0x17 (0xffe9) +__ulonglong 0xfc18 / 0x2a == 0x616e (0x616e) +float 0xfc18 / 0x2a == -0x17 (0xffe9) +int 0xfc18 % 0x2a == -0x22 (0xffde) +__uint 0xfc18 % 0x2a == 0x18 (0x18) +char 0x18 % 0x2a == 0x18 (0x18) +__uchar 0x18 % 0x2a == 0x18 (0x18) +__longlong 0xfc18 % 0x2a == -0x22 (0xffde) +__ulonglong 0xfc18 % 0x2a == 0xc (0xc) +0xfc18 * 0x17 == -0x59d8 +0xfc18 / 0x17 == -0x2b +0xfc18 % 0x17 == -0xb +int 0xfc18 ^ 0x17 == -0x3f1 (0xfc0f) +__uint 0xfc18 ^ 0x17 == -0x3f1 (0xfc0f) +char 0x18 ^ 0x17 == 0xf (0xf) +__uchar 0x18 ^ 0x17 == 0xf (0xf) +__longlong 0xfc18 ^ 0x17 == -0x3f1 (0xfc0f) +__ulonglong 0xfc18 ^ 0x17 == -0x3f1 (0xfc0f) +int 0xfc18 && 0x17 == 0x1 (0x1) +__uint 0xfc18 && 0x17 == 0x1 (0x1) +char 0x18 && 0x17 == 0x1 (0x1) +__uchar 0x18 && 0x17 == 0x1 (0x1) +__longlong 0xfc18 && 0x17 == 0x1 (0x1) +__ulonglong 0xfc18 && 0x17 == 0x1 (0x1) +int 0xfc18 || 0x17 == 0x1 (0x1) +__uint 0xfc18 || 0x17 == 0x1 (0x1) +char 0x18 || 0x17 == 0x1 (0x1) +__uchar 0x18 || 0x17 == 0x1 (0x1) +__longlong 0xfc18 || 0x17 == 0x1 (0x1) +__ulonglong 0xfc18 || 0x17 == 0x1 (0x1) +int 0xfc18 & 0x17 == 0x10 (0x10) +__uint 0xfc18 & 0x17 == 0x10 (0x10) +char 0x18 & 0x17 == 0x10 (0x10) +__uchar 0x18 & 0x17 == 0x10 (0x10) +__longlong 0xfc18 & 0x17 == 0x10 (0x10) +__ulonglong 0xfc18 & 0x17 == 0x10 (0x10) +int 0xfc18 | 0x17 == -0x3e1 (0xfc1f) +__uint 0xfc18 | 0x17 == -0x3e1 (0xfc1f) +char 0x18 | 0x17 == 0x1f (0x1f) +__uchar 0x18 | 0x17 == 0x1f (0x1f) +__longlong 0xfc18 | 0x17 == -0x3e1 (0xfc1f) +__ulonglong 0xfc18 | 0x17 == -0x3e1 (0xfc1f) +int 0xfc18 << 0xe == 0x0 (0x0) +__uint 0xfc18 << 0xe == 0x0 (0x0) +char 0x18 << 0xe == 0x0 (0x0) +__uchar 0x18 << 0xe == 0x0 (0x0) +__longlong 0xfc18 << 0xe == 0x0 (0x0) +__ulonglong 0xfc18 << 0xe == 0x0 (0x0) +int 0xfc18 >> 0xe == -0x1 (0xffff) +__uint 0xfc18 >> 0xe == 0x3 (0x3) +char 0x18 >> 0xe == 0x0 (0x0) +__uchar 0x18 >> 0xe == 0x0 (0x0) +__longlong 0xfc18 >> 0xe == -0x1 (0xffff) +__ulonglong 0xfc18 >> 0xe == -0x1 (0xffff) +int 0xfc18 + 0x17 == -0x3d1 (0xfc2f) +__uint 0xfc18 + 0x17 == -0x3d1 (0xfc2f) +char 0x18 + 0x17 == 0x2f (0x2f) +__uchar 0x18 + 0x17 == 0x2f (0x2f) +__longlong 0xfc18 + 0x17 == -0x3d1 (0xfc2f) +__ulonglong 0xfc18 + 0x17 == -0x3d1 (0xfc2f) +float 0xfc18 + 0x17 == -0x3d1 (0xfc2f) +int 0xfc18 - 0x17 == -0x3ff (0xfc01) +__uint 0xfc18 - 0x17 == -0x3ff (0xfc01) +char 0x18 - 0x17 == 0x1 (0x1) +__uchar 0x18 - 0x17 == 0x1 (0x1) +__longlong 0xfc18 - 0x17 == -0x3ff (0xfc01) +__ulonglong 0xfc18 - 0x17 == -0x3ff (0xfc01) +float 0xfc18 - 0x17 == -0x3ff (0xfc01) +int 0xfc18 * 0x17 == -0x59d8 (0xa628) +__uint 0xfc18 * 0x17 == -0x59d8 (0xa628) +char 0x18 * 0x17 == 0x28 (0x28) +__uchar 0x18 * 0x17 == 0x28 (0x28) +__longlong 0xfc18 * 0x17 == -0x59d8 (0xa628) +__ulonglong 0xfc18 * 0x17 == -0x59d8 (0xa628) +float 0xfc18 * 0x17 == -0x59d8 (0xa628) +int 0xfc18 < 0x17 == 0x1 (0x1) +__uint 0xfc18 < 0x17 == 0x0 (0x0) +char 0x18 < 0x17 == 0x0 (0x0) +__uchar 0x18 < 0x17 == 0x0 (0x0) +__longlong 0xfc18 < 0x17 == 0x1 (0x1) +__ulonglong 0xfc18 < 0x17 == 0x0 (0x0) +float 0xfc18 < 0x17 == 0x1 (0x1) +int 0xfc18 > 0x17 == 0x0 (0x0) +__uint 0xfc18 > 0x17 == 0x1 (0x1) +char 0x18 > 0x17 == 0x1 (0x1) +__uchar 0x18 > 0x17 == 0x1 (0x1) +__longlong 0xfc18 > 0x17 == 0x0 (0x0) +__ulonglong 0xfc18 > 0x17 == 0x1 (0x1) +float 0xfc18 > 0x17 == 0x0 (0x0) +int 0xfc18 <= 0x17 == 0x1 (0x1) +__uint 0xfc18 <= 0x17 == 0x0 (0x0) +char 0x18 <= 0x17 == 0x0 (0x0) +__uchar 0x18 <= 0x17 == 0x0 (0x0) +__longlong 0xfc18 <= 0x17 == 0x1 (0x1) +__ulonglong 0xfc18 <= 0x17 == 0x0 (0x0) +float 0xfc18 <= 0x17 == 0x1 (0x1) +int 0xfc18 == 0x17 == 0x0 (0x0) +__uint 0xfc18 == 0x17 == 0x0 (0x0) +char 0x18 == 0x17 == 0x0 (0x0) +__uchar 0x18 == 0x17 == 0x0 (0x0) +__longlong 0xfc18 == 0x17 == 0x0 (0x0) +__ulonglong 0xfc18 == 0x17 == 0x0 (0x0) +float 0xfc18 == 0x17 == 0x0 (0x0) +int 0xfc18 != 0x17 == 0x1 (0x1) +__uint 0xfc18 != 0x17 == 0x1 (0x1) +char 0x18 != 0x17 == 0x1 (0x1) +__uchar 0x18 != 0x17 == 0x1 (0x1) +__longlong 0xfc18 != 0x17 == 0x1 (0x1) +__ulonglong 0xfc18 != 0x17 == 0x1 (0x1) +float 0xfc18 != 0x17 == 0x1 (0x1) +int 0xfc18 >= 0x17 == 0x0 (0x0) +__uint 0xfc18 >= 0x17 == 0x1 (0x1) +char 0x18 >= 0x17 == 0x1 (0x1) +__uchar 0x18 >= 0x17 == 0x1 (0x1) +__longlong 0xfc18 >= 0x17 == 0x0 (0x0) +__ulonglong 0xfc18 >= 0x17 == 0x1 (0x1) +float 0xfc18 >= 0x17 == 0x0 (0x0) +int 0xfc18 / 0x17 == -0x2b (0xffd5) +__uint 0xfc18 / 0x17 == 0xaf5 (0xaf5) +char 0x18 / 0x17 == 0x1 (0x1) +__uchar 0x18 / 0x17 == 0x1 (0x1) +__longlong 0xfc18 / 0x17 == -0x2b (0xffd5) +__ulonglong 0xfc18 / 0x17 == 0x6401 (0x6401) +float 0xfc18 / 0x17 == -0x2b (0xffd5) +int 0xfc18 % 0x17 == -0xb (0xfff5) +__uint 0xfc18 % 0x17 == 0x15 (0x15) +char 0x18 % 0x17 == 0x1 (0x1) +__uchar 0x18 % 0x17 == 0x1 (0x1) +__longlong 0xfc18 % 0x17 == -0xb (0xfff5) +__ulonglong 0xfc18 % 0x17 == 0x1 (0x1) +0xfc18 * 0x7fff == 0x3e8 +0xfc18 / 0x7fff == 0x0 +0xfc18 % 0x7fff == -0x3e8 +int 0xfc18 ^ 0x7fff == -0x7c19 (0x83e7) +__uint 0xfc18 ^ 0x7fff == -0x7c19 (0x83e7) +char 0x18 ^ 0xffff == -0x19 (0xffe7) +__uchar 0x18 ^ 0xff == 0xe7 (0xe7) +__longlong 0xfc18 ^ 0x7fff == -0x7c19 (0x83e7) +__ulonglong 0xfc18 ^ 0x7fff == -0x7c19 (0x83e7) +int 0xfc18 && 0x7fff == 0x1 (0x1) +__uint 0xfc18 && 0x7fff == 0x1 (0x1) +char 0x18 && 0xffff == 0x1 (0x1) +__uchar 0x18 && 0xff == 0x1 (0x1) +__longlong 0xfc18 && 0x7fff == 0x1 (0x1) +__ulonglong 0xfc18 && 0x7fff == 0x1 (0x1) +int 0xfc18 || 0x7fff == 0x1 (0x1) +__uint 0xfc18 || 0x7fff == 0x1 (0x1) +char 0x18 || 0xffff == 0x1 (0x1) +__uchar 0x18 || 0xff == 0x1 (0x1) +__longlong 0xfc18 || 0x7fff == 0x1 (0x1) +__ulonglong 0xfc18 || 0x7fff == 0x1 (0x1) +int 0xfc18 & 0x7fff == 0x7c18 (0x7c18) +__uint 0xfc18 & 0x7fff == 0x7c18 (0x7c18) +char 0x18 & 0xffff == 0x18 (0x18) +__uchar 0x18 & 0xff == 0x18 (0x18) +__longlong 0xfc18 & 0x7fff == 0x7c18 (0x7c18) +__ulonglong 0xfc18 & 0x7fff == 0x7c18 (0x7c18) +int 0xfc18 | 0x7fff == -0x1 (0xffff) +__uint 0xfc18 | 0x7fff == -0x1 (0xffff) +char 0x18 | 0xffff == -0x1 (0xffff) +__uchar 0x18 | 0xff == 0xff (0xff) +__longlong 0xfc18 | 0x7fff == -0x1 (0xffff) +__ulonglong 0xfc18 | 0x7fff == -0x1 (0xffff) +int 0xfc18 << 0x10 == 0x0 (0x0) +__uint 0xfc18 << 0x10 == 0x0 (0x0) +char 0x18 << 0x10 == 0x0 (0x0) +__uchar 0x18 << 0x10 == 0x0 (0x0) +__longlong 0xfc18 << 0x10 == 0x0 (0x0) +__ulonglong 0xfc18 << 0x10 == 0x0 (0x0) +int 0xfc18 >> 0x10 == -0x1 (0xffff) +__uint 0xfc18 >> 0x10 == 0x0 (0x0) +char 0x18 >> 0x10 == 0x0 (0x0) +__uchar 0x18 >> 0x10 == 0x0 (0x0) +__longlong 0xfc18 >> 0x10 == -0x1 (0xffff) +__ulonglong 0xfc18 >> 0x10 == -0x1 (0xffff) +int 0xfc18 + 0x7fff == 0x7c17 (0x7c17) +__uint 0xfc18 + 0x7fff == 0x7c17 (0x7c17) +char 0x18 + 0xffff == 0x17 (0x17) +__uchar 0x18 + 0xff == 0x17 (0x17) +__longlong 0xfc18 + 0x7fff == 0x7c17 (0x7c17) +__ulonglong 0xfc18 + 0x7fff == 0x7c17 (0x7c17) +float 0xfc18 + 0x7fff == 0x7c17 (0x7c17) +int 0xfc18 - 0x7fff == 0x7c19 (0x7c19) +__uint 0xfc18 - 0x7fff == 0x7c19 (0x7c19) +char 0x18 - 0xffff == 0x19 (0x19) +__uchar 0x18 - 0xff == 0x19 (0x19) +__longlong 0xfc18 - 0x7fff == 0x7c19 (0x7c19) +__ulonglong 0xfc18 - 0x7fff == 0x7c19 (0x7c19) +float 0xfc18 - 0x7fff == 0x7c19 (0x7c19) +int 0xfc18 * 0x7fff == 0x3e8 (0x3e8) +__uint 0xfc18 * 0x7fff == 0x3e8 (0x3e8) +char 0x18 * 0xffff == -0x18 (0xffe8) +__uchar 0x18 * 0xff == 0xe8 (0xe8) +__longlong 0xfc18 * 0x7fff == 0x3e8 (0x3e8) +__ulonglong 0xfc18 * 0x7fff == 0x3e8 (0x3e8) +float 0xfc18 * 0x7fff == 0x3e8 (0x3e8) +int 0xfc18 < 0x7fff == 0x1 (0x1) +__uint 0xfc18 < 0x7fff == 0x0 (0x0) +char 0x18 < 0xffff == 0x0 (0x0) +__uchar 0x18 < 0xff == 0x1 (0x1) +__longlong 0xfc18 < 0x7fff == 0x1 (0x1) +__ulonglong 0xfc18 < 0x7fff == 0x0 (0x0) +float 0xfc18 < 0x7fff == 0x1 (0x1) +int 0xfc18 > 0x7fff == 0x0 (0x0) +__uint 0xfc18 > 0x7fff == 0x1 (0x1) +char 0x18 > 0xffff == 0x1 (0x1) +__uchar 0x18 > 0xff == 0x0 (0x0) +__longlong 0xfc18 > 0x7fff == 0x0 (0x0) +__ulonglong 0xfc18 > 0x7fff == 0x1 (0x1) +float 0xfc18 > 0x7fff == 0x0 (0x0) +int 0xfc18 <= 0x7fff == 0x1 (0x1) +__uint 0xfc18 <= 0x7fff == 0x0 (0x0) +char 0x18 <= 0xffff == 0x0 (0x0) +__uchar 0x18 <= 0xff == 0x1 (0x1) +__longlong 0xfc18 <= 0x7fff == 0x1 (0x1) +__ulonglong 0xfc18 <= 0x7fff == 0x0 (0x0) +float 0xfc18 <= 0x7fff == 0x1 (0x1) +int 0xfc18 == 0x7fff == 0x0 (0x0) +__uint 0xfc18 == 0x7fff == 0x0 (0x0) +char 0x18 == 0xffff == 0x0 (0x0) +__uchar 0x18 == 0xff == 0x0 (0x0) +__longlong 0xfc18 == 0x7fff == 0x0 (0x0) +__ulonglong 0xfc18 == 0x7fff == 0x0 (0x0) +float 0xfc18 == 0x7fff == 0x0 (0x0) +int 0xfc18 != 0x7fff == 0x1 (0x1) +__uint 0xfc18 != 0x7fff == 0x1 (0x1) +char 0x18 != 0xffff == 0x1 (0x1) +__uchar 0x18 != 0xff == 0x1 (0x1) +__longlong 0xfc18 != 0x7fff == 0x1 (0x1) +__ulonglong 0xfc18 != 0x7fff == 0x1 (0x1) +float 0xfc18 != 0x7fff == 0x1 (0x1) +int 0xfc18 >= 0x7fff == 0x0 (0x0) +__uint 0xfc18 >= 0x7fff == 0x1 (0x1) +char 0x18 >= 0xffff == 0x1 (0x1) +__uchar 0x18 >= 0xff == 0x0 (0x0) +__longlong 0xfc18 >= 0x7fff == 0x0 (0x0) +__ulonglong 0xfc18 >= 0x7fff == 0x1 (0x1) +float 0xfc18 >= 0x7fff == 0x0 (0x0) +int 0xfc18 / 0x7fff == 0x0 (0x0) +__uint 0xfc18 / 0x7fff == 0x1 (0x1) +char 0x18 / 0xffff == -0x18 (0xffe8) +__uchar 0x18 / 0xff == 0x0 (0x0) +__longlong 0xfc18 / 0x7fff == 0x0 (0x0) +__ulonglong 0xfc18 / 0x7fff == 0x3 (0x3) +float 0xfc18 / 0x7fff == 0x0 (0x0) +int 0xfc18 % 0x7fff == -0x3e8 (0xfc18) +__uint 0xfc18 % 0x7fff == 0x7c19 (0x7c19) +char 0x18 % 0xffff == 0x0 (0x0) +__uchar 0x18 % 0xff == 0x18 (0x18) +__longlong 0xfc18 % 0x7fff == -0x3e8 (0xfc18) +__ulonglong 0xfc18 % 0x7fff == 0x7c1b (0x7c1b) +0xfc18 * 0x8000 == 0x0 +0xfc18 / 0x8000 == 0x0 +0xfc18 % 0x8000 == -0x3e8 +int 0xfc18 ^ 0x8000 == 0x7c18 (0x7c18) +__uint 0xfc18 ^ 0x8000 == 0x7c18 (0x7c18) +char 0x18 ^ 0x0 == 0x18 (0x18) +__uchar 0x18 ^ 0x0 == 0x18 (0x18) +__longlong 0xfc18 ^ 0x8000 == 0x7c18 (0x7c18) +__ulonglong 0xfc18 ^ 0x8000 == 0x7c18 (0x7c18) +int 0xfc18 && 0x8000 == 0x1 (0x1) +__uint 0xfc18 && 0x8000 == 0x1 (0x1) +char 0x18 && 0x0 == 0x0 (0x0) +__uchar 0x18 && 0x0 == 0x0 (0x0) +__longlong 0xfc18 && 0x8000 == 0x1 (0x1) +__ulonglong 0xfc18 && 0x8000 == 0x1 (0x1) +int 0xfc18 || 0x8000 == 0x1 (0x1) +__uint 0xfc18 || 0x8000 == 0x1 (0x1) +char 0x18 || 0x0 == 0x1 (0x1) +__uchar 0x18 || 0x0 == 0x1 (0x1) +__longlong 0xfc18 || 0x8000 == 0x1 (0x1) +__ulonglong 0xfc18 || 0x8000 == 0x1 (0x1) +int 0xfc18 & 0x8000 == -0x8000 (0x8000) +__uint 0xfc18 & 0x8000 == -0x8000 (0x8000) +char 0x18 & 0x0 == 0x0 (0x0) +__uchar 0x18 & 0x0 == 0x0 (0x0) +__longlong 0xfc18 & 0x8000 == -0x8000 (0x8000) +__ulonglong 0xfc18 & 0x8000 == -0x8000 (0x8000) +int 0xfc18 | 0x8000 == -0x3e8 (0xfc18) +__uint 0xfc18 | 0x8000 == -0x3e8 (0xfc18) +char 0x18 | 0x0 == 0x18 (0x18) +__uchar 0x18 | 0x0 == 0x18 (0x18) +__longlong 0xfc18 | 0x8000 == -0x3e8 (0xfc18) +__ulonglong 0xfc18 | 0x8000 == -0x3e8 (0xfc18) +int 0xfc18 << 0x12 == 0x0 (0x0) +__uint 0xfc18 << 0x12 == 0x0 (0x0) +char 0x18 << 0x12 == 0x0 (0x0) +__uchar 0x18 << 0x12 == 0x0 (0x0) +__longlong 0xfc18 << 0x12 == 0x0 (0x0) +__ulonglong 0xfc18 << 0x12 == 0x0 (0x0) +int 0xfc18 >> 0x12 == -0x1 (0xffff) +__uint 0xfc18 >> 0x12 == 0x0 (0x0) +char 0x18 >> 0x12 == 0x0 (0x0) +__uchar 0x18 >> 0x12 == 0x0 (0x0) +__longlong 0xfc18 >> 0x12 == -0x1 (0xffff) +__ulonglong 0xfc18 >> 0x12 == 0x3fff (0x3fff) +int 0xfc18 + 0x8000 == 0x7c18 (0x7c18) +__uint 0xfc18 + 0x8000 == 0x7c18 (0x7c18) +char 0x18 + 0x0 == 0x18 (0x18) +__uchar 0x18 + 0x0 == 0x18 (0x18) +__longlong 0xfc18 + 0x8000 == 0x7c18 (0x7c18) +__ulonglong 0xfc18 + 0x8000 == 0x7c18 (0x7c18) +float 0xfc18 + 0x8000 == 0x7c18 (0x7c18) +int 0xfc18 - 0x8000 == 0x7c18 (0x7c18) +__uint 0xfc18 - 0x8000 == 0x7c18 (0x7c18) +char 0x18 - 0x0 == 0x18 (0x18) +__uchar 0x18 - 0x0 == 0x18 (0x18) +__longlong 0xfc18 - 0x8000 == 0x7c18 (0x7c18) +__ulonglong 0xfc18 - 0x8000 == 0x7c18 (0x7c18) +float 0xfc18 - 0x8000 == 0x7c18 (0x7c18) +int 0xfc18 * 0x8000 == 0x0 (0x0) +__uint 0xfc18 * 0x8000 == 0x0 (0x0) +char 0x18 * 0x0 == 0x0 (0x0) +__uchar 0x18 * 0x0 == 0x0 (0x0) +__longlong 0xfc18 * 0x8000 == 0x0 (0x0) +__ulonglong 0xfc18 * 0x8000 == 0x0 (0x0) +float 0xfc18 * 0x8000 == 0x0 (0x0) +int 0xfc18 < 0x8000 == 0x0 (0x0) +__uint 0xfc18 < 0x8000 == 0x0 (0x0) +char 0x18 < 0x0 == 0x0 (0x0) +__uchar 0x18 < 0x0 == 0x0 (0x0) +__longlong 0xfc18 < 0x8000 == 0x0 (0x0) +__ulonglong 0xfc18 < 0x8000 == 0x0 (0x0) +float 0xfc18 < 0x8000 == 0x0 (0x0) +int 0xfc18 > 0x8000 == 0x1 (0x1) +__uint 0xfc18 > 0x8000 == 0x1 (0x1) +char 0x18 > 0x0 == 0x1 (0x1) +__uchar 0x18 > 0x0 == 0x1 (0x1) +__longlong 0xfc18 > 0x8000 == 0x1 (0x1) +__ulonglong 0xfc18 > 0x8000 == 0x1 (0x1) +float 0xfc18 > 0x8000 == 0x1 (0x1) +int 0xfc18 <= 0x8000 == 0x0 (0x0) +__uint 0xfc18 <= 0x8000 == 0x0 (0x0) +char 0x18 <= 0x0 == 0x0 (0x0) +__uchar 0x18 <= 0x0 == 0x0 (0x0) +__longlong 0xfc18 <= 0x8000 == 0x0 (0x0) +__ulonglong 0xfc18 <= 0x8000 == 0x0 (0x0) +float 0xfc18 <= 0x8000 == 0x0 (0x0) +int 0xfc18 == 0x8000 == 0x0 (0x0) +__uint 0xfc18 == 0x8000 == 0x0 (0x0) +char 0x18 == 0x0 == 0x0 (0x0) +__uchar 0x18 == 0x0 == 0x0 (0x0) +__longlong 0xfc18 == 0x8000 == 0x0 (0x0) +__ulonglong 0xfc18 == 0x8000 == 0x0 (0x0) +float 0xfc18 == 0x8000 == 0x0 (0x0) +int 0xfc18 != 0x8000 == 0x1 (0x1) +__uint 0xfc18 != 0x8000 == 0x1 (0x1) +char 0x18 != 0x0 == 0x1 (0x1) +__uchar 0x18 != 0x0 == 0x1 (0x1) +__longlong 0xfc18 != 0x8000 == 0x1 (0x1) +__ulonglong 0xfc18 != 0x8000 == 0x1 (0x1) +float 0xfc18 != 0x8000 == 0x1 (0x1) +int 0xfc18 >= 0x8000 == 0x1 (0x1) +__uint 0xfc18 >= 0x8000 == 0x1 (0x1) +char 0x18 >= 0x0 == 0x1 (0x1) +__uchar 0x18 >= 0x0 == 0x1 (0x1) +__longlong 0xfc18 >= 0x8000 == 0x1 (0x1) +__ulonglong 0xfc18 >= 0x8000 == 0x1 (0x1) +float 0xfc18 >= 0x8000 == 0x1 (0x1) +int 0xfc18 / 0x8000 == 0x0 (0x0) +__uint 0xfc18 / 0x8000 == 0x1 (0x1) +__longlong 0xfc18 / 0x8000 == 0x0 (0x0) +__ulonglong 0xfc18 / 0x8000 == 0x1 (0x1) +float 0xfc18 / 0x8000 == 0x0 (0x0) +int 0xfc18 % 0x8000 == -0x3e8 (0xfc18) +__uint 0xfc18 % 0x8000 == 0x7c18 (0x7c18) +__longlong 0xfc18 % 0x8000 == -0x3e8 (0xfc18) +__ulonglong 0xfc18 % 0x8000 == 0x7c18 (0x7c18) +0xfc18 * 0x3e8 == -0x4240 +0xfc18 / 0x3e8 == -0x1 +0xfc18 % 0x3e8 == 0x0 +int 0xfc18 ^ 0x3e8 == -0x10 (0xfff0) +__uint 0xfc18 ^ 0x3e8 == -0x10 (0xfff0) +char 0x18 ^ 0xffe8 == -0x10 (0xfff0) +__uchar 0x18 ^ 0xe8 == 0xf0 (0xf0) +__longlong 0xfc18 ^ 0x3e8 == -0x10 (0xfff0) +__ulonglong 0xfc18 ^ 0x3e8 == -0x10 (0xfff0) +int 0xfc18 && 0x3e8 == 0x1 (0x1) +__uint 0xfc18 && 0x3e8 == 0x1 (0x1) +char 0x18 && 0xffe8 == 0x1 (0x1) +__uchar 0x18 && 0xe8 == 0x1 (0x1) +__longlong 0xfc18 && 0x3e8 == 0x1 (0x1) +__ulonglong 0xfc18 && 0x3e8 == 0x1 (0x1) +int 0xfc18 || 0x3e8 == 0x1 (0x1) +__uint 0xfc18 || 0x3e8 == 0x1 (0x1) +char 0x18 || 0xffe8 == 0x1 (0x1) +__uchar 0x18 || 0xe8 == 0x1 (0x1) +__longlong 0xfc18 || 0x3e8 == 0x1 (0x1) +__ulonglong 0xfc18 || 0x3e8 == 0x1 (0x1) +int 0xfc18 & 0x3e8 == 0x8 (0x8) +__uint 0xfc18 & 0x3e8 == 0x8 (0x8) +char 0x18 & 0xffe8 == 0x8 (0x8) +__uchar 0x18 & 0xe8 == 0x8 (0x8) +__longlong 0xfc18 & 0x3e8 == 0x8 (0x8) +__ulonglong 0xfc18 & 0x3e8 == 0x8 (0x8) +int 0xfc18 | 0x3e8 == -0x8 (0xfff8) +__uint 0xfc18 | 0x3e8 == -0x8 (0xfff8) +char 0x18 | 0xffe8 == -0x8 (0xfff8) +__uchar 0x18 | 0xe8 == 0xf8 (0xf8) +__longlong 0xfc18 | 0x3e8 == -0x8 (0xfff8) +__ulonglong 0xfc18 | 0x3e8 == -0x8 (0xfff8) +int 0xfc18 << 0x14 == 0x0 (0x0) +__uint 0xfc18 << 0x14 == 0x0 (0x0) +char 0x18 << 0x14 == 0x0 (0x0) +__uchar 0x18 << 0x14 == 0x0 (0x0) +__longlong 0xfc18 << 0x14 == 0x0 (0x0) +__ulonglong 0xfc18 << 0x14 == 0x0 (0x0) +int 0xfc18 >> 0x14 == -0x1 (0xffff) +__uint 0xfc18 >> 0x14 == 0x0 (0x0) +char 0x18 >> 0x14 == 0x0 (0x0) +__uchar 0x18 >> 0x14 == 0x0 (0x0) +__longlong 0xfc18 >> 0x14 == -0x1 (0xffff) +__ulonglong 0xfc18 >> 0x14 == 0xfff (0xfff) +int 0xfc18 + 0x3e8 == 0x0 (0x0) +__uint 0xfc18 + 0x3e8 == 0x0 (0x0) +char 0x18 + 0xffe8 == 0x0 (0x0) +__uchar 0x18 + 0xe8 == 0x0 (0x0) +__longlong 0xfc18 + 0x3e8 == 0x0 (0x0) +__ulonglong 0xfc18 + 0x3e8 == 0x0 (0x0) +float 0xfc18 + 0x3e8 == 0x0 (0x0) +int 0xfc18 - 0x3e8 == -0x7d0 (0xf830) +__uint 0xfc18 - 0x3e8 == -0x7d0 (0xf830) +char 0x18 - 0xffe8 == 0x30 (0x30) +__uchar 0x18 - 0xe8 == 0x30 (0x30) +__longlong 0xfc18 - 0x3e8 == -0x7d0 (0xf830) +__ulonglong 0xfc18 - 0x3e8 == -0x7d0 (0xf830) +float 0xfc18 - 0x3e8 == -0x7d0 (0xf830) +int 0xfc18 * 0x3e8 == -0x4240 (0xbdc0) +__uint 0xfc18 * 0x3e8 == -0x4240 (0xbdc0) +char 0x18 * 0xffe8 == -0x40 (0xffc0) +__uchar 0x18 * 0xe8 == 0xc0 (0xc0) +__longlong 0xfc18 * 0x3e8 == -0x4240 (0xbdc0) +__ulonglong 0xfc18 * 0x3e8 == -0x4240 (0xbdc0) +float 0xfc18 * 0x3e8 == -0x4240 (0xbdc0) +int 0xfc18 < 0x3e8 == 0x1 (0x1) +__uint 0xfc18 < 0x3e8 == 0x0 (0x0) +char 0x18 < 0xffe8 == 0x0 (0x0) +__uchar 0x18 < 0xe8 == 0x1 (0x1) +__longlong 0xfc18 < 0x3e8 == 0x1 (0x1) +__ulonglong 0xfc18 < 0x3e8 == 0x0 (0x0) +float 0xfc18 < 0x3e8 == 0x1 (0x1) +int 0xfc18 > 0x3e8 == 0x0 (0x0) +__uint 0xfc18 > 0x3e8 == 0x1 (0x1) +char 0x18 > 0xffe8 == 0x1 (0x1) +__uchar 0x18 > 0xe8 == 0x0 (0x0) +__longlong 0xfc18 > 0x3e8 == 0x0 (0x0) +__ulonglong 0xfc18 > 0x3e8 == 0x1 (0x1) +float 0xfc18 > 0x3e8 == 0x0 (0x0) +int 0xfc18 <= 0x3e8 == 0x1 (0x1) +__uint 0xfc18 <= 0x3e8 == 0x0 (0x0) +char 0x18 <= 0xffe8 == 0x0 (0x0) +__uchar 0x18 <= 0xe8 == 0x1 (0x1) +__longlong 0xfc18 <= 0x3e8 == 0x1 (0x1) +__ulonglong 0xfc18 <= 0x3e8 == 0x0 (0x0) +float 0xfc18 <= 0x3e8 == 0x1 (0x1) +int 0xfc18 == 0x3e8 == 0x0 (0x0) +__uint 0xfc18 == 0x3e8 == 0x0 (0x0) +char 0x18 == 0xffe8 == 0x0 (0x0) +__uchar 0x18 == 0xe8 == 0x0 (0x0) +__longlong 0xfc18 == 0x3e8 == 0x0 (0x0) +__ulonglong 0xfc18 == 0x3e8 == 0x0 (0x0) +float 0xfc18 == 0x3e8 == 0x0 (0x0) +int 0xfc18 != 0x3e8 == 0x1 (0x1) +__uint 0xfc18 != 0x3e8 == 0x1 (0x1) +char 0x18 != 0xffe8 == 0x1 (0x1) +__uchar 0x18 != 0xe8 == 0x1 (0x1) +__longlong 0xfc18 != 0x3e8 == 0x1 (0x1) +__ulonglong 0xfc18 != 0x3e8 == 0x1 (0x1) +float 0xfc18 != 0x3e8 == 0x1 (0x1) +int 0xfc18 >= 0x3e8 == 0x0 (0x0) +__uint 0xfc18 >= 0x3e8 == 0x1 (0x1) +char 0x18 >= 0xffe8 == 0x1 (0x1) +__uchar 0x18 >= 0xe8 == 0x0 (0x0) +__longlong 0xfc18 >= 0x3e8 == 0x0 (0x0) +__ulonglong 0xfc18 >= 0x3e8 == 0x1 (0x1) +float 0xfc18 >= 0x3e8 == 0x0 (0x0) +int 0xfc18 / 0x3e8 == -0x1 (0xffff) +__uint 0xfc18 / 0x3e8 == 0x40 (0x40) +char 0x18 / 0xffe8 == -0x1 (0xffff) +__uchar 0x18 / 0xe8 == 0x0 (0x0) +__longlong 0xfc18 / 0x3e8 == -0x1 (0xffff) +__ulonglong 0xfc18 / 0x3e8 == -0x76ca (0x8936) +float 0xfc18 / 0x3e8 == -0x1 (0xffff) +int 0xfc18 % 0x3e8 == 0x0 (0x0) +__uint 0xfc18 % 0x3e8 == 0x218 (0x218) +char 0x18 % 0xffe8 == 0x0 (0x0) +__uchar 0x18 % 0xe8 == 0x18 (0x18) +__longlong 0xfc18 % 0x3e8 == 0x0 (0x0) +__ulonglong 0xfc18 % 0x3e8 == 0x128 (0x128) +0xfc18 * 0x2710 == 0x6980 +0xfc18 / 0x2710 == 0x0 +0xfc18 % 0x2710 == -0x3e8 +int 0xfc18 ^ 0x2710 == -0x24f8 (0xdb08) +__uint 0xfc18 ^ 0x2710 == -0x24f8 (0xdb08) +char 0x18 ^ 0x10 == 0x8 (0x8) +__uchar 0x18 ^ 0x10 == 0x8 (0x8) +__longlong 0xfc18 ^ 0x2710 == -0x24f8 (0xdb08) +__ulonglong 0xfc18 ^ 0x2710 == -0x24f8 (0xdb08) +int 0xfc18 && 0x2710 == 0x1 (0x1) +__uint 0xfc18 && 0x2710 == 0x1 (0x1) +char 0x18 && 0x10 == 0x1 (0x1) +__uchar 0x18 && 0x10 == 0x1 (0x1) +__longlong 0xfc18 && 0x2710 == 0x1 (0x1) +__ulonglong 0xfc18 && 0x2710 == 0x1 (0x1) +int 0xfc18 || 0x2710 == 0x1 (0x1) +__uint 0xfc18 || 0x2710 == 0x1 (0x1) +char 0x18 || 0x10 == 0x1 (0x1) +__uchar 0x18 || 0x10 == 0x1 (0x1) +__longlong 0xfc18 || 0x2710 == 0x1 (0x1) +__ulonglong 0xfc18 || 0x2710 == 0x1 (0x1) +int 0xfc18 & 0x2710 == 0x2410 (0x2410) +__uint 0xfc18 & 0x2710 == 0x2410 (0x2410) +char 0x18 & 0x10 == 0x10 (0x10) +__uchar 0x18 & 0x10 == 0x10 (0x10) +__longlong 0xfc18 & 0x2710 == 0x2410 (0x2410) +__ulonglong 0xfc18 & 0x2710 == 0x2410 (0x2410) +int 0xfc18 | 0x2710 == -0xe8 (0xff18) +__uint 0xfc18 | 0x2710 == -0xe8 (0xff18) +char 0x18 | 0x10 == 0x18 (0x18) +__uchar 0x18 | 0x10 == 0x18 (0x18) +__longlong 0xfc18 | 0x2710 == -0xe8 (0xff18) +__ulonglong 0xfc18 | 0x2710 == -0xe8 (0xff18) +int 0xfc18 << 0x16 == 0x0 (0x0) +__uint 0xfc18 << 0x16 == 0x0 (0x0) +char 0x18 << 0x16 == 0x0 (0x0) +__uchar 0x18 << 0x16 == 0x0 (0x0) +__longlong 0xfc18 << 0x16 == 0x0 (0x0) +__ulonglong 0xfc18 << 0x16 == 0x0 (0x0) +int 0xfc18 >> 0x16 == -0x1 (0xffff) +__uint 0xfc18 >> 0x16 == 0x0 (0x0) +char 0x18 >> 0x16 == 0x0 (0x0) +__uchar 0x18 >> 0x16 == 0x0 (0x0) +__longlong 0xfc18 >> 0x16 == -0x1 (0xffff) +__ulonglong 0xfc18 >> 0x16 == 0x3ff (0x3ff) +int 0xfc18 + 0x2710 == 0x2328 (0x2328) +__uint 0xfc18 + 0x2710 == 0x2328 (0x2328) +char 0x18 + 0x10 == 0x28 (0x28) +__uchar 0x18 + 0x10 == 0x28 (0x28) +__longlong 0xfc18 + 0x2710 == 0x2328 (0x2328) +__ulonglong 0xfc18 + 0x2710 == 0x2328 (0x2328) +float 0xfc18 + 0x2710 == 0x2328 (0x2328) +int 0xfc18 - 0x2710 == -0x2af8 (0xd508) +__uint 0xfc18 - 0x2710 == -0x2af8 (0xd508) +char 0x18 - 0x10 == 0x8 (0x8) +__uchar 0x18 - 0x10 == 0x8 (0x8) +__longlong 0xfc18 - 0x2710 == -0x2af8 (0xd508) +__ulonglong 0xfc18 - 0x2710 == -0x2af8 (0xd508) +float 0xfc18 - 0x2710 == -0x2af8 (0xd508) +int 0xfc18 * 0x2710 == 0x6980 (0x6980) +__uint 0xfc18 * 0x2710 == 0x6980 (0x6980) +char 0x18 * 0x10 == -0x80 (0xff80) +__uchar 0x18 * 0x10 == 0x80 (0x80) +__longlong 0xfc18 * 0x2710 == 0x6980 (0x6980) +__ulonglong 0xfc18 * 0x2710 == 0x6980 (0x6980) +float 0xfc18 * 0x2710 == 0x6980 (0x6980) +int 0xfc18 < 0x2710 == 0x1 (0x1) +__uint 0xfc18 < 0x2710 == 0x0 (0x0) +char 0x18 < 0x10 == 0x0 (0x0) +__uchar 0x18 < 0x10 == 0x0 (0x0) +__longlong 0xfc18 < 0x2710 == 0x1 (0x1) +__ulonglong 0xfc18 < 0x2710 == 0x0 (0x0) +float 0xfc18 < 0x2710 == 0x1 (0x1) +int 0xfc18 > 0x2710 == 0x0 (0x0) +__uint 0xfc18 > 0x2710 == 0x1 (0x1) +char 0x18 > 0x10 == 0x1 (0x1) +__uchar 0x18 > 0x10 == 0x1 (0x1) +__longlong 0xfc18 > 0x2710 == 0x0 (0x0) +__ulonglong 0xfc18 > 0x2710 == 0x1 (0x1) +float 0xfc18 > 0x2710 == 0x0 (0x0) +int 0xfc18 <= 0x2710 == 0x1 (0x1) +__uint 0xfc18 <= 0x2710 == 0x0 (0x0) +char 0x18 <= 0x10 == 0x0 (0x0) +__uchar 0x18 <= 0x10 == 0x0 (0x0) +__longlong 0xfc18 <= 0x2710 == 0x1 (0x1) +__ulonglong 0xfc18 <= 0x2710 == 0x0 (0x0) +float 0xfc18 <= 0x2710 == 0x1 (0x1) +int 0xfc18 == 0x2710 == 0x0 (0x0) +__uint 0xfc18 == 0x2710 == 0x0 (0x0) +char 0x18 == 0x10 == 0x0 (0x0) +__uchar 0x18 == 0x10 == 0x0 (0x0) +__longlong 0xfc18 == 0x2710 == 0x0 (0x0) +__ulonglong 0xfc18 == 0x2710 == 0x0 (0x0) +float 0xfc18 == 0x2710 == 0x0 (0x0) +int 0xfc18 != 0x2710 == 0x1 (0x1) +__uint 0xfc18 != 0x2710 == 0x1 (0x1) +char 0x18 != 0x10 == 0x1 (0x1) +__uchar 0x18 != 0x10 == 0x1 (0x1) +__longlong 0xfc18 != 0x2710 == 0x1 (0x1) +__ulonglong 0xfc18 != 0x2710 == 0x1 (0x1) +float 0xfc18 != 0x2710 == 0x1 (0x1) +int 0xfc18 >= 0x2710 == 0x0 (0x0) +__uint 0xfc18 >= 0x2710 == 0x1 (0x1) +char 0x18 >= 0x10 == 0x1 (0x1) +__uchar 0x18 >= 0x10 == 0x1 (0x1) +__longlong 0xfc18 >= 0x2710 == 0x0 (0x0) +__ulonglong 0xfc18 >= 0x2710 == 0x1 (0x1) +float 0xfc18 >= 0x2710 == 0x0 (0x0) +int 0xfc18 / 0x2710 == 0x0 (0x0) +__uint 0xfc18 / 0x2710 == 0x6 (0x6) +char 0x18 / 0x10 == 0x1 (0x1) +__uchar 0x18 / 0x10 == 0x1 (0x1) +__longlong 0xfc18 / 0x2710 == 0x0 (0x0) +__ulonglong 0xfc18 / 0x2710 == -0x7248 (0x8db8) +float 0xfc18 / 0x2710 == 0x0 (0x0) +int 0xfc18 % 0x2710 == -0x3e8 (0xfc18) +__uint 0xfc18 % 0x2710 == 0x11b8 (0x11b8) +char 0x18 % 0x10 == 0x8 (0x8) +__uchar 0x18 % 0x10 == 0x8 (0x8) +__longlong 0xfc18 % 0x2710 == -0x3e8 (0xfc18) +__ulonglong 0xfc18 % 0x2710 == 0x1898 (0x1898) +int xor42-0x3e8 xor42 -0x3ce +__uint xor42-0x3e8 xor42 -0x3ce +char xor420x18 xor42 0x32 +__uchar xor420x18 xor42 0x32 +__longlong xor42-0x3e8 xor42 -0x3ce +__ulonglong xor42-0x3e8 xor42 -0x3ce +int land1-0x3e8 land1 0x1 +__uint land1-0x3e8 land1 0x1 +char land10x18 land1 0x1 +__uchar land10x18 land1 0x1 +__longlong land1-0x3e8 land1 0x1 +__ulonglong land1-0x3e8 land1 0x1 +int lor1-0x3e8 lor1 0x1 +__uint lor1-0x3e8 lor1 0x1 +char lor10x18 lor1 0x1 +__uchar lor10x18 lor1 0x1 +__longlong lor1-0x3e8 lor1 0x1 +__ulonglong lor1-0x3e8 lor1 0x1 +int and42-0x3e8 and42 0x8 +__uint and42-0x3e8 and42 0x8 +char and420x18 and42 0x8 +__uchar and420x18 and42 0x8 +__longlong and42-0x3e8 and42 0x8 +__ulonglong and42-0x3e8 and42 0x8 +int or42-0x3e8 or42 -0x3c6 +__uint or42-0x3e8 or42 -0x3c6 +char or420x18 or42 0x3a +__uchar or420x18 or42 0x3a +__longlong or42-0x3e8 or42 -0x3c6 +__ulonglong or42-0x3e8 or42 -0x3c6 +int shl5-0x3e8 shl5 -0x7d00 +__uint shl5-0x3e8 shl5 -0x7d00 +char shl50x18 shl5 0x0 +__uchar shl50x18 shl5 0x0 +__longlong shl5-0x3e8 shl5 -0x7d00 +__ulonglong shl5-0x3e8 shl5 -0x7d00 +int shr5-0x3e8 shr5 -0x20 +__uint shr5-0x3e8 shr5 0x7e0 +char shr50x18 shr5 0x0 +__uchar shr50x18 shr5 0x0 +__longlong shr5-0x3e8 shr5 -0x20 +__ulonglong shr5-0x3e8 shr5 -0x20 +int add42-0x3e8 add42 -0x3be +__uint add42-0x3e8 add42 -0x3be +char add420x18 add42 0x42 +__uchar add420x18 add42 0x42 +__longlong add42-0x3e8 add42 -0x3be +__ulonglong add42-0x3e8 add42 -0x3be +float add42-0x3e8 add42 -0x3be +int sub42-0x3e8 sub42 -0x412 +__uint sub42-0x3e8 sub42 -0x412 +char sub420x18 sub42 -0x12 +__uchar sub420x18 sub42 0xee +__longlong sub42-0x3e8 sub42 -0x412 +__ulonglong sub42-0x3e8 sub42 -0x412 +float sub42-0x3e8 sub42 -0x412 +int mul42-0x3e8 mul42 0x5bf0 +__uint mul42-0x3e8 mul42 0x5bf0 +char mul420x18 mul42 -0x10 +__uchar mul420x18 mul42 0xf0 +__longlong mul42-0x3e8 mul42 0x5bf0 +__ulonglong mul42-0x3e8 mul42 0x5bf0 +float mul42-0x3e8 mul42 0x5bf0 +int lt42-0x3e8 lt42 0x1 +__uint lt42-0x3e8 lt42 0x0 +char lt420x18 lt42 0x1 +__uchar lt420x18 lt42 0x1 +__longlong lt42-0x3e8 lt42 0x1 +__ulonglong lt42-0x3e8 lt42 0x0 +float lt42-0x3e8 lt42 0x1 +int gt42-0x3e8 gt42 0x0 +__uint gt42-0x3e8 gt42 0x1 +char gt420x18 gt42 0x0 +__uchar gt420x18 gt42 0x0 +__longlong gt42-0x3e8 gt42 0x0 +__ulonglong gt42-0x3e8 gt42 0x1 +float gt42-0x3e8 gt42 0x0 +int le42-0x3e8 le42 0x1 +__uint le42-0x3e8 le42 0x0 +char le420x18 le42 0x1 +__uchar le420x18 le42 0x1 +__longlong le42-0x3e8 le42 0x1 +__ulonglong le42-0x3e8 le42 0x0 +float le42-0x3e8 le42 0x1 +int eq42-0x3e8 eq42 0x0 +__uint eq42-0x3e8 eq42 0x0 +char eq420x18 eq42 0x0 +__uchar eq420x18 eq42 0x0 +__longlong eq42-0x3e8 eq42 0x0 +__ulonglong eq42-0x3e8 eq42 0x0 +float eq42-0x3e8 eq42 0x0 +int ne42-0x3e8 ne42 0x1 +__uint ne42-0x3e8 ne42 0x1 +char ne420x18 ne42 0x1 +__uchar ne420x18 ne42 0x1 +__longlong ne42-0x3e8 ne42 0x1 +__ulonglong ne42-0x3e8 ne42 0x1 +float ne42-0x3e8 ne42 0x1 +int ge42-0x3e8 ge42 0x0 +__uint ge42-0x3e8 ge42 0x1 +char ge420x18 ge42 0x0 +__uchar ge420x18 ge42 0x0 +__longlong ge42-0x3e8 ge42 0x0 +__ulonglong ge42-0x3e8 ge42 0x1 +float ge42-0x3e8 ge42 0x0 +int div42-0x3e8 div42 -0x17 +__uint div42-0x3e8 div42 0x600 +char div420x18 div42 0x0 +__uchar div420x18 div42 0x0 +__longlong div42-0x3e8 div42 -0x17 +__ulonglong div42-0x3e8 div42 0x616e +float div42-0x3e8 div42 -0x17 +int mod23-0x3e8 mod23 -0xb +__uint mod23-0x3e8 mod23 0x15 +char mod230x18 mod23 0x1 +__uchar mod230x18 mod23 0x1 +__longlong mod23-0x3e8 mod23 -0xb +__ulonglong mod23-0x3e8 mod23 0x1 +0xd8f0 * 0xffff == 0x2710 +0xd8f0 / 0xffff == 0x2710 +0xd8f0 % 0xffff == 0x0 +int 0xd8f0 ^ 0xffff == 0x270f (0x270f) +__uint 0xd8f0 ^ 0xffff == 0x270f (0x270f) +char 0xfff0 ^ 0xffff == 0xf (0xf) +__uchar 0xf0 ^ 0xff == 0xf (0xf) +__longlong 0xd8f0 ^ 0xffff == 0x270f (0x270f) +__ulonglong 0xd8f0 ^ 0xffff == 0x270f (0x270f) +int 0xd8f0 && 0xffff == 0x1 (0x1) +__uint 0xd8f0 && 0xffff == 0x1 (0x1) +char 0xfff0 && 0xffff == 0x1 (0x1) +__uchar 0xf0 && 0xff == 0x1 (0x1) +__longlong 0xd8f0 && 0xffff == 0x1 (0x1) +__ulonglong 0xd8f0 && 0xffff == 0x1 (0x1) +int 0xd8f0 || 0xffff == 0x1 (0x1) +__uint 0xd8f0 || 0xffff == 0x1 (0x1) +char 0xfff0 || 0xffff == 0x1 (0x1) +__uchar 0xf0 || 0xff == 0x1 (0x1) +__longlong 0xd8f0 || 0xffff == 0x1 (0x1) +__ulonglong 0xd8f0 || 0xffff == 0x1 (0x1) +int 0xd8f0 & 0xffff == -0x2710 (0xd8f0) +__uint 0xd8f0 & 0xffff == -0x2710 (0xd8f0) +char 0xfff0 & 0xffff == -0x10 (0xfff0) +__uchar 0xf0 & 0xff == 0xf0 (0xf0) +__longlong 0xd8f0 & 0xffff == -0x2710 (0xd8f0) +__ulonglong 0xd8f0 & 0xffff == -0x2710 (0xd8f0) +int 0xd8f0 | 0xffff == -0x1 (0xffff) +__uint 0xd8f0 | 0xffff == -0x1 (0xffff) +char 0xfff0 | 0xffff == -0x1 (0xffff) +__uchar 0xf0 | 0xff == 0xff (0xff) +__longlong 0xd8f0 | 0xffff == -0x1 (0xffff) +__ulonglong 0xd8f0 | 0xffff == -0x1 (0xffff) +int 0xd8f0 << 0x1 == -0x4e20 (0xb1e0) +__uint 0xd8f0 << 0x1 == -0x4e20 (0xb1e0) +char 0xfff0 << 0x1 == -0x20 (0xffe0) +__uchar 0xf0 << 0x1 == 0xe0 (0xe0) +__longlong 0xd8f0 << 0x1 == -0x4e20 (0xb1e0) +__ulonglong 0xd8f0 << 0x1 == -0x4e20 (0xb1e0) +int 0xd8f0 >> 0x1 == -0x1388 (0xec78) +__uint 0xd8f0 >> 0x1 == 0x6c78 (0x6c78) +char 0xfff0 >> 0x1 == -0x8 (0xfff8) +__uchar 0xf0 >> 0x1 == 0x78 (0x78) +__longlong 0xd8f0 >> 0x1 == -0x1388 (0xec78) +__ulonglong 0xd8f0 >> 0x1 == -0x1388 (0xec78) +int 0xd8f0 + 0xffff == -0x2711 (0xd8ef) +__uint 0xd8f0 + 0xffff == -0x2711 (0xd8ef) +char 0xfff0 + 0xffff == -0x11 (0xffef) +__uchar 0xf0 + 0xff == 0xef (0xef) +__longlong 0xd8f0 + 0xffff == -0x2711 (0xd8ef) +__ulonglong 0xd8f0 + 0xffff == -0x2711 (0xd8ef) +float 0xd8f0 + 0xffff == -0x2711 (0xd8ef) +int 0xd8f0 - 0xffff == -0x270f (0xd8f1) +__uint 0xd8f0 - 0xffff == -0x270f (0xd8f1) +char 0xfff0 - 0xffff == -0xf (0xfff1) +__uchar 0xf0 - 0xff == 0xf1 (0xf1) +__longlong 0xd8f0 - 0xffff == -0x270f (0xd8f1) +__ulonglong 0xd8f0 - 0xffff == -0x270f (0xd8f1) +float 0xd8f0 - 0xffff == -0x270f (0xd8f1) +int 0xd8f0 * 0xffff == 0x2710 (0x2710) +__uint 0xd8f0 * 0xffff == 0x2710 (0x2710) +char 0xfff0 * 0xffff == 0x10 (0x10) +__uchar 0xf0 * 0xff == 0x10 (0x10) +__longlong 0xd8f0 * 0xffff == 0x2710 (0x2710) +__ulonglong 0xd8f0 * 0xffff == 0x2710 (0x2710) +float 0xd8f0 * 0xffff == 0x2710 (0x2710) +int 0xd8f0 < 0xffff == 0x1 (0x1) +__uint 0xd8f0 < 0xffff == 0x1 (0x1) +char 0xfff0 < 0xffff == 0x1 (0x1) +__uchar 0xf0 < 0xff == 0x1 (0x1) +__longlong 0xd8f0 < 0xffff == 0x1 (0x1) +__ulonglong 0xd8f0 < 0xffff == 0x1 (0x1) +float 0xd8f0 < 0xffff == 0x1 (0x1) +int 0xd8f0 > 0xffff == 0x0 (0x0) +__uint 0xd8f0 > 0xffff == 0x0 (0x0) +char 0xfff0 > 0xffff == 0x0 (0x0) +__uchar 0xf0 > 0xff == 0x0 (0x0) +__longlong 0xd8f0 > 0xffff == 0x0 (0x0) +__ulonglong 0xd8f0 > 0xffff == 0x0 (0x0) +float 0xd8f0 > 0xffff == 0x0 (0x0) +int 0xd8f0 <= 0xffff == 0x1 (0x1) +__uint 0xd8f0 <= 0xffff == 0x1 (0x1) +char 0xfff0 <= 0xffff == 0x1 (0x1) +__uchar 0xf0 <= 0xff == 0x1 (0x1) +__longlong 0xd8f0 <= 0xffff == 0x1 (0x1) +__ulonglong 0xd8f0 <= 0xffff == 0x1 (0x1) +float 0xd8f0 <= 0xffff == 0x1 (0x1) +int 0xd8f0 == 0xffff == 0x0 (0x0) +__uint 0xd8f0 == 0xffff == 0x0 (0x0) +char 0xfff0 == 0xffff == 0x0 (0x0) +__uchar 0xf0 == 0xff == 0x0 (0x0) +__longlong 0xd8f0 == 0xffff == 0x0 (0x0) +__ulonglong 0xd8f0 == 0xffff == 0x0 (0x0) +float 0xd8f0 == 0xffff == 0x0 (0x0) +int 0xd8f0 != 0xffff == 0x1 (0x1) +__uint 0xd8f0 != 0xffff == 0x1 (0x1) +char 0xfff0 != 0xffff == 0x1 (0x1) +__uchar 0xf0 != 0xff == 0x1 (0x1) +__longlong 0xd8f0 != 0xffff == 0x1 (0x1) +__ulonglong 0xd8f0 != 0xffff == 0x1 (0x1) +float 0xd8f0 != 0xffff == 0x1 (0x1) +int 0xd8f0 >= 0xffff == 0x0 (0x0) +__uint 0xd8f0 >= 0xffff == 0x0 (0x0) +char 0xfff0 >= 0xffff == 0x0 (0x0) +__uchar 0xf0 >= 0xff == 0x0 (0x0) +__longlong 0xd8f0 >= 0xffff == 0x0 (0x0) +__ulonglong 0xd8f0 >= 0xffff == 0x0 (0x0) +float 0xd8f0 >= 0xffff == 0x0 (0x0) +int 0xd8f0 / 0xffff == 0x2710 (0x2710) +__uint 0xd8f0 / 0xffff == 0x0 (0x0) +char 0xfff0 / 0xffff == 0x10 (0x10) +__uchar 0xf0 / 0xff == 0x0 (0x0) +__longlong 0xd8f0 / 0xffff == 0x2710 (0x2710) +__ulonglong 0xd8f0 / 0xffff == 0x0 (0x0) +float 0xd8f0 / 0xffff == 0x2710 (0x2710) +int 0xd8f0 % 0xffff == 0x0 (0x0) +__uint 0xd8f0 % 0xffff == -0x2710 (0xd8f0) +char 0xfff0 % 0xffff == 0x0 (0x0) +__uchar 0xf0 % 0xff == 0xf0 (0xf0) +__longlong 0xd8f0 % 0xffff == 0x0 (0x0) +__ulonglong 0xd8f0 % 0xffff == -0x2710 (0xd8f0) +0xd8f0 * 0x1 == -0x2710 +0xd8f0 / 0x1 == -0x2710 +0xd8f0 % 0x1 == 0x0 +int 0xd8f0 ^ 0x1 == -0x270f (0xd8f1) +__uint 0xd8f0 ^ 0x1 == -0x270f (0xd8f1) +char 0xfff0 ^ 0x1 == -0xf (0xfff1) +__uchar 0xf0 ^ 0x1 == 0xf1 (0xf1) +__longlong 0xd8f0 ^ 0x1 == -0x270f (0xd8f1) +__ulonglong 0xd8f0 ^ 0x1 == -0x270f (0xd8f1) +int 0xd8f0 && 0x1 == 0x1 (0x1) +__uint 0xd8f0 && 0x1 == 0x1 (0x1) +char 0xfff0 && 0x1 == 0x1 (0x1) +__uchar 0xf0 && 0x1 == 0x1 (0x1) +__longlong 0xd8f0 && 0x1 == 0x1 (0x1) +__ulonglong 0xd8f0 && 0x1 == 0x1 (0x1) +int 0xd8f0 || 0x1 == 0x1 (0x1) +__uint 0xd8f0 || 0x1 == 0x1 (0x1) +char 0xfff0 || 0x1 == 0x1 (0x1) +__uchar 0xf0 || 0x1 == 0x1 (0x1) +__longlong 0xd8f0 || 0x1 == 0x1 (0x1) +__ulonglong 0xd8f0 || 0x1 == 0x1 (0x1) +int 0xd8f0 & 0x1 == 0x0 (0x0) +__uint 0xd8f0 & 0x1 == 0x0 (0x0) +char 0xfff0 & 0x1 == 0x0 (0x0) +__uchar 0xf0 & 0x1 == 0x0 (0x0) +__longlong 0xd8f0 & 0x1 == 0x0 (0x0) +__ulonglong 0xd8f0 & 0x1 == 0x0 (0x0) +int 0xd8f0 | 0x1 == -0x270f (0xd8f1) +__uint 0xd8f0 | 0x1 == -0x270f (0xd8f1) +char 0xfff0 | 0x1 == -0xf (0xfff1) +__uchar 0xf0 | 0x1 == 0xf1 (0xf1) +__longlong 0xd8f0 | 0x1 == -0x270f (0xd8f1) +__ulonglong 0xd8f0 | 0x1 == -0x270f (0xd8f1) +int 0xd8f0 << 0x2 == 0x63c0 (0x63c0) +__uint 0xd8f0 << 0x2 == 0x63c0 (0x63c0) +char 0xfff0 << 0x2 == -0x40 (0xffc0) +__uchar 0xf0 << 0x2 == 0xc0 (0xc0) +__longlong 0xd8f0 << 0x2 == 0x63c0 (0x63c0) +__ulonglong 0xd8f0 << 0x2 == 0x63c0 (0x63c0) +int 0xd8f0 >> 0x2 == -0x9c4 (0xf63c) +__uint 0xd8f0 >> 0x2 == 0x363c (0x363c) +char 0xfff0 >> 0x2 == -0x4 (0xfffc) +__uchar 0xf0 >> 0x2 == 0x3c (0x3c) +__longlong 0xd8f0 >> 0x2 == -0x9c4 (0xf63c) +__ulonglong 0xd8f0 >> 0x2 == -0x9c4 (0xf63c) +int 0xd8f0 + 0x1 == -0x270f (0xd8f1) +__uint 0xd8f0 + 0x1 == -0x270f (0xd8f1) +char 0xfff0 + 0x1 == -0xf (0xfff1) +__uchar 0xf0 + 0x1 == 0xf1 (0xf1) +__longlong 0xd8f0 + 0x1 == -0x270f (0xd8f1) +__ulonglong 0xd8f0 + 0x1 == -0x270f (0xd8f1) +float 0xd8f0 + 0x1 == -0x270f (0xd8f1) +int 0xd8f0 - 0x1 == -0x2711 (0xd8ef) +__uint 0xd8f0 - 0x1 == -0x2711 (0xd8ef) +char 0xfff0 - 0x1 == -0x11 (0xffef) +__uchar 0xf0 - 0x1 == 0xef (0xef) +__longlong 0xd8f0 - 0x1 == -0x2711 (0xd8ef) +__ulonglong 0xd8f0 - 0x1 == -0x2711 (0xd8ef) +float 0xd8f0 - 0x1 == -0x2711 (0xd8ef) +int 0xd8f0 * 0x1 == -0x2710 (0xd8f0) +__uint 0xd8f0 * 0x1 == -0x2710 (0xd8f0) +char 0xfff0 * 0x1 == -0x10 (0xfff0) +__uchar 0xf0 * 0x1 == 0xf0 (0xf0) +__longlong 0xd8f0 * 0x1 == -0x2710 (0xd8f0) +__ulonglong 0xd8f0 * 0x1 == -0x2710 (0xd8f0) +float 0xd8f0 * 0x1 == -0x2710 (0xd8f0) +int 0xd8f0 < 0x1 == 0x1 (0x1) +__uint 0xd8f0 < 0x1 == 0x0 (0x0) +char 0xfff0 < 0x1 == 0x1 (0x1) +__uchar 0xf0 < 0x1 == 0x0 (0x0) +__longlong 0xd8f0 < 0x1 == 0x1 (0x1) +__ulonglong 0xd8f0 < 0x1 == 0x0 (0x0) +float 0xd8f0 < 0x1 == 0x1 (0x1) +int 0xd8f0 > 0x1 == 0x0 (0x0) +__uint 0xd8f0 > 0x1 == 0x1 (0x1) +char 0xfff0 > 0x1 == 0x0 (0x0) +__uchar 0xf0 > 0x1 == 0x1 (0x1) +__longlong 0xd8f0 > 0x1 == 0x0 (0x0) +__ulonglong 0xd8f0 > 0x1 == 0x1 (0x1) +float 0xd8f0 > 0x1 == 0x0 (0x0) +int 0xd8f0 <= 0x1 == 0x1 (0x1) +__uint 0xd8f0 <= 0x1 == 0x0 (0x0) +char 0xfff0 <= 0x1 == 0x1 (0x1) +__uchar 0xf0 <= 0x1 == 0x0 (0x0) +__longlong 0xd8f0 <= 0x1 == 0x1 (0x1) +__ulonglong 0xd8f0 <= 0x1 == 0x0 (0x0) +float 0xd8f0 <= 0x1 == 0x1 (0x1) +int 0xd8f0 == 0x1 == 0x0 (0x0) +__uint 0xd8f0 == 0x1 == 0x0 (0x0) +char 0xfff0 == 0x1 == 0x0 (0x0) +__uchar 0xf0 == 0x1 == 0x0 (0x0) +__longlong 0xd8f0 == 0x1 == 0x0 (0x0) +__ulonglong 0xd8f0 == 0x1 == 0x0 (0x0) +float 0xd8f0 == 0x1 == 0x0 (0x0) +int 0xd8f0 != 0x1 == 0x1 (0x1) +__uint 0xd8f0 != 0x1 == 0x1 (0x1) +char 0xfff0 != 0x1 == 0x1 (0x1) +__uchar 0xf0 != 0x1 == 0x1 (0x1) +__longlong 0xd8f0 != 0x1 == 0x1 (0x1) +__ulonglong 0xd8f0 != 0x1 == 0x1 (0x1) +float 0xd8f0 != 0x1 == 0x1 (0x1) +int 0xd8f0 >= 0x1 == 0x0 (0x0) +__uint 0xd8f0 >= 0x1 == 0x1 (0x1) +char 0xfff0 >= 0x1 == 0x0 (0x0) +__uchar 0xf0 >= 0x1 == 0x1 (0x1) +__longlong 0xd8f0 >= 0x1 == 0x0 (0x0) +__ulonglong 0xd8f0 >= 0x1 == 0x1 (0x1) +float 0xd8f0 >= 0x1 == 0x0 (0x0) +int 0xd8f0 / 0x1 == -0x2710 (0xd8f0) +__uint 0xd8f0 / 0x1 == -0x2710 (0xd8f0) +char 0xfff0 / 0x1 == -0x10 (0xfff0) +__uchar 0xf0 / 0x1 == 0xf0 (0xf0) +__longlong 0xd8f0 / 0x1 == -0x2710 (0xd8f0) +__ulonglong 0xd8f0 / 0x1 == -0x2710 (0xd8f0) +float 0xd8f0 / 0x1 == -0x2710 (0xd8f0) +int 0xd8f0 % 0x1 == 0x0 (0x0) +__uint 0xd8f0 % 0x1 == 0x0 (0x0) +char 0xfff0 % 0x1 == 0x0 (0x0) +__uchar 0xf0 % 0x1 == 0x0 (0x0) +__longlong 0xd8f0 % 0x1 == 0x0 (0x0) +__ulonglong 0xd8f0 % 0x1 == 0x0 (0x0) +0xd8f0 * 0x2 == -0x4e20 +0xd8f0 / 0x2 == -0x1388 +0xd8f0 % 0x2 == 0x0 +int 0xd8f0 ^ 0x2 == -0x270e (0xd8f2) +__uint 0xd8f0 ^ 0x2 == -0x270e (0xd8f2) +char 0xfff0 ^ 0x2 == -0xe (0xfff2) +__uchar 0xf0 ^ 0x2 == 0xf2 (0xf2) +__longlong 0xd8f0 ^ 0x2 == -0x270e (0xd8f2) +__ulonglong 0xd8f0 ^ 0x2 == -0x270e (0xd8f2) +int 0xd8f0 && 0x2 == 0x1 (0x1) +__uint 0xd8f0 && 0x2 == 0x1 (0x1) +char 0xfff0 && 0x2 == 0x1 (0x1) +__uchar 0xf0 && 0x2 == 0x1 (0x1) +__longlong 0xd8f0 && 0x2 == 0x1 (0x1) +__ulonglong 0xd8f0 && 0x2 == 0x1 (0x1) +int 0xd8f0 || 0x2 == 0x1 (0x1) +__uint 0xd8f0 || 0x2 == 0x1 (0x1) +char 0xfff0 || 0x2 == 0x1 (0x1) +__uchar 0xf0 || 0x2 == 0x1 (0x1) +__longlong 0xd8f0 || 0x2 == 0x1 (0x1) +__ulonglong 0xd8f0 || 0x2 == 0x1 (0x1) +int 0xd8f0 & 0x2 == 0x0 (0x0) +__uint 0xd8f0 & 0x2 == 0x0 (0x0) +char 0xfff0 & 0x2 == 0x0 (0x0) +__uchar 0xf0 & 0x2 == 0x0 (0x0) +__longlong 0xd8f0 & 0x2 == 0x0 (0x0) +__ulonglong 0xd8f0 & 0x2 == 0x0 (0x0) +int 0xd8f0 | 0x2 == -0x270e (0xd8f2) +__uint 0xd8f0 | 0x2 == -0x270e (0xd8f2) +char 0xfff0 | 0x2 == -0xe (0xfff2) +__uchar 0xf0 | 0x2 == 0xf2 (0xf2) +__longlong 0xd8f0 | 0x2 == -0x270e (0xd8f2) +__ulonglong 0xd8f0 | 0x2 == -0x270e (0xd8f2) +int 0xd8f0 << 0x3 == -0x3880 (0xc780) +__uint 0xd8f0 << 0x3 == -0x3880 (0xc780) +char 0xfff0 << 0x3 == -0x80 (0xff80) +__uchar 0xf0 << 0x3 == 0x80 (0x80) +__longlong 0xd8f0 << 0x3 == -0x3880 (0xc780) +__ulonglong 0xd8f0 << 0x3 == -0x3880 (0xc780) +int 0xd8f0 >> 0x3 == -0x4e2 (0xfb1e) +__uint 0xd8f0 >> 0x3 == 0x1b1e (0x1b1e) +char 0xfff0 >> 0x3 == -0x2 (0xfffe) +__uchar 0xf0 >> 0x3 == 0x1e (0x1e) +__longlong 0xd8f0 >> 0x3 == -0x4e2 (0xfb1e) +__ulonglong 0xd8f0 >> 0x3 == -0x4e2 (0xfb1e) +int 0xd8f0 + 0x2 == -0x270e (0xd8f2) +__uint 0xd8f0 + 0x2 == -0x270e (0xd8f2) +char 0xfff0 + 0x2 == -0xe (0xfff2) +__uchar 0xf0 + 0x2 == 0xf2 (0xf2) +__longlong 0xd8f0 + 0x2 == -0x270e (0xd8f2) +__ulonglong 0xd8f0 + 0x2 == -0x270e (0xd8f2) +float 0xd8f0 + 0x2 == -0x270e (0xd8f2) +int 0xd8f0 - 0x2 == -0x2712 (0xd8ee) +__uint 0xd8f0 - 0x2 == -0x2712 (0xd8ee) +char 0xfff0 - 0x2 == -0x12 (0xffee) +__uchar 0xf0 - 0x2 == 0xee (0xee) +__longlong 0xd8f0 - 0x2 == -0x2712 (0xd8ee) +__ulonglong 0xd8f0 - 0x2 == -0x2712 (0xd8ee) +float 0xd8f0 - 0x2 == -0x2712 (0xd8ee) +int 0xd8f0 * 0x2 == -0x4e20 (0xb1e0) +__uint 0xd8f0 * 0x2 == -0x4e20 (0xb1e0) +char 0xfff0 * 0x2 == -0x20 (0xffe0) +__uchar 0xf0 * 0x2 == 0xe0 (0xe0) +__longlong 0xd8f0 * 0x2 == -0x4e20 (0xb1e0) +__ulonglong 0xd8f0 * 0x2 == -0x4e20 (0xb1e0) +float 0xd8f0 * 0x2 == -0x4e20 (0xb1e0) +int 0xd8f0 < 0x2 == 0x1 (0x1) +__uint 0xd8f0 < 0x2 == 0x0 (0x0) +char 0xfff0 < 0x2 == 0x1 (0x1) +__uchar 0xf0 < 0x2 == 0x0 (0x0) +__longlong 0xd8f0 < 0x2 == 0x1 (0x1) +__ulonglong 0xd8f0 < 0x2 == 0x0 (0x0) +float 0xd8f0 < 0x2 == 0x1 (0x1) +int 0xd8f0 > 0x2 == 0x0 (0x0) +__uint 0xd8f0 > 0x2 == 0x1 (0x1) +char 0xfff0 > 0x2 == 0x0 (0x0) +__uchar 0xf0 > 0x2 == 0x1 (0x1) +__longlong 0xd8f0 > 0x2 == 0x0 (0x0) +__ulonglong 0xd8f0 > 0x2 == 0x1 (0x1) +float 0xd8f0 > 0x2 == 0x0 (0x0) +int 0xd8f0 <= 0x2 == 0x1 (0x1) +__uint 0xd8f0 <= 0x2 == 0x0 (0x0) +char 0xfff0 <= 0x2 == 0x1 (0x1) +__uchar 0xf0 <= 0x2 == 0x0 (0x0) +__longlong 0xd8f0 <= 0x2 == 0x1 (0x1) +__ulonglong 0xd8f0 <= 0x2 == 0x0 (0x0) +float 0xd8f0 <= 0x2 == 0x1 (0x1) +int 0xd8f0 == 0x2 == 0x0 (0x0) +__uint 0xd8f0 == 0x2 == 0x0 (0x0) +char 0xfff0 == 0x2 == 0x0 (0x0) +__uchar 0xf0 == 0x2 == 0x0 (0x0) +__longlong 0xd8f0 == 0x2 == 0x0 (0x0) +__ulonglong 0xd8f0 == 0x2 == 0x0 (0x0) +float 0xd8f0 == 0x2 == 0x0 (0x0) +int 0xd8f0 != 0x2 == 0x1 (0x1) +__uint 0xd8f0 != 0x2 == 0x1 (0x1) +char 0xfff0 != 0x2 == 0x1 (0x1) +__uchar 0xf0 != 0x2 == 0x1 (0x1) +__longlong 0xd8f0 != 0x2 == 0x1 (0x1) +__ulonglong 0xd8f0 != 0x2 == 0x1 (0x1) +float 0xd8f0 != 0x2 == 0x1 (0x1) +int 0xd8f0 >= 0x2 == 0x0 (0x0) +__uint 0xd8f0 >= 0x2 == 0x1 (0x1) +char 0xfff0 >= 0x2 == 0x0 (0x0) +__uchar 0xf0 >= 0x2 == 0x1 (0x1) +__longlong 0xd8f0 >= 0x2 == 0x0 (0x0) +__ulonglong 0xd8f0 >= 0x2 == 0x1 (0x1) +float 0xd8f0 >= 0x2 == 0x0 (0x0) +int 0xd8f0 / 0x2 == -0x1388 (0xec78) +__uint 0xd8f0 / 0x2 == 0x6c78 (0x6c78) +char 0xfff0 / 0x2 == -0x8 (0xfff8) +__uchar 0xf0 / 0x2 == 0x78 (0x78) +__longlong 0xd8f0 / 0x2 == -0x1388 (0xec78) +__ulonglong 0xd8f0 / 0x2 == -0x1388 (0xec78) +float 0xd8f0 / 0x2 == -0x1388 (0xec78) +int 0xd8f0 % 0x2 == 0x0 (0x0) +__uint 0xd8f0 % 0x2 == 0x0 (0x0) +char 0xfff0 % 0x2 == 0x0 (0x0) +__uchar 0xf0 % 0x2 == 0x0 (0x0) +__longlong 0xd8f0 % 0x2 == 0x0 (0x0) +__ulonglong 0xd8f0 % 0x2 == 0x0 (0x0) +0xd8f0 * 0xfffe == 0x4e20 +0xd8f0 / 0xfffe == 0x1388 +0xd8f0 % 0xfffe == 0x0 +int 0xd8f0 ^ 0xfffe == 0x270e (0x270e) +__uint 0xd8f0 ^ 0xfffe == 0x270e (0x270e) +char 0xfff0 ^ 0xfffe == 0xe (0xe) +__uchar 0xf0 ^ 0xfe == 0xe (0xe) +__longlong 0xd8f0 ^ 0xfffe == 0x270e (0x270e) +__ulonglong 0xd8f0 ^ 0xfffe == 0x270e (0x270e) +int 0xd8f0 && 0xfffe == 0x1 (0x1) +__uint 0xd8f0 && 0xfffe == 0x1 (0x1) +char 0xfff0 && 0xfffe == 0x1 (0x1) +__uchar 0xf0 && 0xfe == 0x1 (0x1) +__longlong 0xd8f0 && 0xfffe == 0x1 (0x1) +__ulonglong 0xd8f0 && 0xfffe == 0x1 (0x1) +int 0xd8f0 || 0xfffe == 0x1 (0x1) +__uint 0xd8f0 || 0xfffe == 0x1 (0x1) +char 0xfff0 || 0xfffe == 0x1 (0x1) +__uchar 0xf0 || 0xfe == 0x1 (0x1) +__longlong 0xd8f0 || 0xfffe == 0x1 (0x1) +__ulonglong 0xd8f0 || 0xfffe == 0x1 (0x1) +int 0xd8f0 & 0xfffe == -0x2710 (0xd8f0) +__uint 0xd8f0 & 0xfffe == -0x2710 (0xd8f0) +char 0xfff0 & 0xfffe == -0x10 (0xfff0) +__uchar 0xf0 & 0xfe == 0xf0 (0xf0) +__longlong 0xd8f0 & 0xfffe == -0x2710 (0xd8f0) +__ulonglong 0xd8f0 & 0xfffe == -0x2710 (0xd8f0) +int 0xd8f0 | 0xfffe == -0x2 (0xfffe) +__uint 0xd8f0 | 0xfffe == -0x2 (0xfffe) +char 0xfff0 | 0xfffe == -0x2 (0xfffe) +__uchar 0xf0 | 0xfe == 0xfe (0xfe) +__longlong 0xd8f0 | 0xfffe == -0x2 (0xfffe) +__ulonglong 0xd8f0 | 0xfffe == -0x2 (0xfffe) +int 0xd8f0 << 0x4 == -0x7100 (0x8f00) +__uint 0xd8f0 << 0x4 == -0x7100 (0x8f00) +char 0xfff0 << 0x4 == 0x0 (0x0) +__uchar 0xf0 << 0x4 == 0x0 (0x0) +__longlong 0xd8f0 << 0x4 == -0x7100 (0x8f00) +__ulonglong 0xd8f0 << 0x4 == -0x7100 (0x8f00) +int 0xd8f0 >> 0x4 == -0x271 (0xfd8f) +__uint 0xd8f0 >> 0x4 == 0xd8f (0xd8f) +char 0xfff0 >> 0x4 == -0x1 (0xffff) +__uchar 0xf0 >> 0x4 == 0xf (0xf) +__longlong 0xd8f0 >> 0x4 == -0x271 (0xfd8f) +__ulonglong 0xd8f0 >> 0x4 == -0x271 (0xfd8f) +int 0xd8f0 + 0xfffe == -0x2712 (0xd8ee) +__uint 0xd8f0 + 0xfffe == -0x2712 (0xd8ee) +char 0xfff0 + 0xfffe == -0x12 (0xffee) +__uchar 0xf0 + 0xfe == 0xee (0xee) +__longlong 0xd8f0 + 0xfffe == -0x2712 (0xd8ee) +__ulonglong 0xd8f0 + 0xfffe == -0x2712 (0xd8ee) +float 0xd8f0 + 0xfffe == -0x2712 (0xd8ee) +int 0xd8f0 - 0xfffe == -0x270e (0xd8f2) +__uint 0xd8f0 - 0xfffe == -0x270e (0xd8f2) +char 0xfff0 - 0xfffe == -0xe (0xfff2) +__uchar 0xf0 - 0xfe == 0xf2 (0xf2) +__longlong 0xd8f0 - 0xfffe == -0x270e (0xd8f2) +__ulonglong 0xd8f0 - 0xfffe == -0x270e (0xd8f2) +float 0xd8f0 - 0xfffe == -0x270e (0xd8f2) +int 0xd8f0 * 0xfffe == 0x4e20 (0x4e20) +__uint 0xd8f0 * 0xfffe == 0x4e20 (0x4e20) +char 0xfff0 * 0xfffe == 0x20 (0x20) +__uchar 0xf0 * 0xfe == 0x20 (0x20) +__longlong 0xd8f0 * 0xfffe == 0x4e20 (0x4e20) +__ulonglong 0xd8f0 * 0xfffe == 0x4e20 (0x4e20) +float 0xd8f0 * 0xfffe == 0x4e20 (0x4e20) +int 0xd8f0 < 0xfffe == 0x1 (0x1) +__uint 0xd8f0 < 0xfffe == 0x1 (0x1) +char 0xfff0 < 0xfffe == 0x1 (0x1) +__uchar 0xf0 < 0xfe == 0x1 (0x1) +__longlong 0xd8f0 < 0xfffe == 0x1 (0x1) +__ulonglong 0xd8f0 < 0xfffe == 0x1 (0x1) +float 0xd8f0 < 0xfffe == 0x1 (0x1) +int 0xd8f0 > 0xfffe == 0x0 (0x0) +__uint 0xd8f0 > 0xfffe == 0x0 (0x0) +char 0xfff0 > 0xfffe == 0x0 (0x0) +__uchar 0xf0 > 0xfe == 0x0 (0x0) +__longlong 0xd8f0 > 0xfffe == 0x0 (0x0) +__ulonglong 0xd8f0 > 0xfffe == 0x0 (0x0) +float 0xd8f0 > 0xfffe == 0x0 (0x0) +int 0xd8f0 <= 0xfffe == 0x1 (0x1) +__uint 0xd8f0 <= 0xfffe == 0x1 (0x1) +char 0xfff0 <= 0xfffe == 0x1 (0x1) +__uchar 0xf0 <= 0xfe == 0x1 (0x1) +__longlong 0xd8f0 <= 0xfffe == 0x1 (0x1) +__ulonglong 0xd8f0 <= 0xfffe == 0x1 (0x1) +float 0xd8f0 <= 0xfffe == 0x1 (0x1) +int 0xd8f0 == 0xfffe == 0x0 (0x0) +__uint 0xd8f0 == 0xfffe == 0x0 (0x0) +char 0xfff0 == 0xfffe == 0x0 (0x0) +__uchar 0xf0 == 0xfe == 0x0 (0x0) +__longlong 0xd8f0 == 0xfffe == 0x0 (0x0) +__ulonglong 0xd8f0 == 0xfffe == 0x0 (0x0) +float 0xd8f0 == 0xfffe == 0x0 (0x0) +int 0xd8f0 != 0xfffe == 0x1 (0x1) +__uint 0xd8f0 != 0xfffe == 0x1 (0x1) +char 0xfff0 != 0xfffe == 0x1 (0x1) +__uchar 0xf0 != 0xfe == 0x1 (0x1) +__longlong 0xd8f0 != 0xfffe == 0x1 (0x1) +__ulonglong 0xd8f0 != 0xfffe == 0x1 (0x1) +float 0xd8f0 != 0xfffe == 0x1 (0x1) +int 0xd8f0 >= 0xfffe == 0x0 (0x0) +__uint 0xd8f0 >= 0xfffe == 0x0 (0x0) +char 0xfff0 >= 0xfffe == 0x0 (0x0) +__uchar 0xf0 >= 0xfe == 0x0 (0x0) +__longlong 0xd8f0 >= 0xfffe == 0x0 (0x0) +__ulonglong 0xd8f0 >= 0xfffe == 0x0 (0x0) +float 0xd8f0 >= 0xfffe == 0x0 (0x0) +int 0xd8f0 / 0xfffe == 0x1388 (0x1388) +__uint 0xd8f0 / 0xfffe == 0x0 (0x0) +char 0xfff0 / 0xfffe == 0x8 (0x8) +__uchar 0xf0 / 0xfe == 0x0 (0x0) +__longlong 0xd8f0 / 0xfffe == 0x1388 (0x1388) +__ulonglong 0xd8f0 / 0xfffe == 0x0 (0x0) +float 0xd8f0 / 0xfffe == 0x1388 (0x1388) +int 0xd8f0 % 0xfffe == 0x0 (0x0) +__uint 0xd8f0 % 0xfffe == -0x2710 (0xd8f0) +char 0xfff0 % 0xfffe == 0x0 (0x0) +__uchar 0xf0 % 0xfe == 0xf0 (0xf0) +__longlong 0xd8f0 % 0xfffe == 0x0 (0x0) +__ulonglong 0xd8f0 % 0xfffe == -0x2710 (0xd8f0) +0xd8f0 * 0x4 == 0x63c0 +0xd8f0 / 0x4 == -0x9c4 +0xd8f0 % 0x4 == 0x0 +int 0xd8f0 ^ 0x4 == -0x270c (0xd8f4) +__uint 0xd8f0 ^ 0x4 == -0x270c (0xd8f4) +char 0xfff0 ^ 0x4 == -0xc (0xfff4) +__uchar 0xf0 ^ 0x4 == 0xf4 (0xf4) +__longlong 0xd8f0 ^ 0x4 == -0x270c (0xd8f4) +__ulonglong 0xd8f0 ^ 0x4 == -0x270c (0xd8f4) +int 0xd8f0 && 0x4 == 0x1 (0x1) +__uint 0xd8f0 && 0x4 == 0x1 (0x1) +char 0xfff0 && 0x4 == 0x1 (0x1) +__uchar 0xf0 && 0x4 == 0x1 (0x1) +__longlong 0xd8f0 && 0x4 == 0x1 (0x1) +__ulonglong 0xd8f0 && 0x4 == 0x1 (0x1) +int 0xd8f0 || 0x4 == 0x1 (0x1) +__uint 0xd8f0 || 0x4 == 0x1 (0x1) +char 0xfff0 || 0x4 == 0x1 (0x1) +__uchar 0xf0 || 0x4 == 0x1 (0x1) +__longlong 0xd8f0 || 0x4 == 0x1 (0x1) +__ulonglong 0xd8f0 || 0x4 == 0x1 (0x1) +int 0xd8f0 & 0x4 == 0x0 (0x0) +__uint 0xd8f0 & 0x4 == 0x0 (0x0) +char 0xfff0 & 0x4 == 0x0 (0x0) +__uchar 0xf0 & 0x4 == 0x0 (0x0) +__longlong 0xd8f0 & 0x4 == 0x0 (0x0) +__ulonglong 0xd8f0 & 0x4 == 0x0 (0x0) +int 0xd8f0 | 0x4 == -0x270c (0xd8f4) +__uint 0xd8f0 | 0x4 == -0x270c (0xd8f4) +char 0xfff0 | 0x4 == -0xc (0xfff4) +__uchar 0xf0 | 0x4 == 0xf4 (0xf4) +__longlong 0xd8f0 | 0x4 == -0x270c (0xd8f4) +__ulonglong 0xd8f0 | 0x4 == -0x270c (0xd8f4) +int 0xd8f0 << 0x5 == 0x1e00 (0x1e00) +__uint 0xd8f0 << 0x5 == 0x1e00 (0x1e00) +char 0xfff0 << 0x5 == 0x0 (0x0) +__uchar 0xf0 << 0x5 == 0x0 (0x0) +__longlong 0xd8f0 << 0x5 == 0x1e00 (0x1e00) +__ulonglong 0xd8f0 << 0x5 == 0x1e00 (0x1e00) +int 0xd8f0 >> 0x5 == -0x139 (0xfec7) +__uint 0xd8f0 >> 0x5 == 0x6c7 (0x6c7) +char 0xfff0 >> 0x5 == -0x1 (0xffff) +__uchar 0xf0 >> 0x5 == 0x7 (0x7) +__longlong 0xd8f0 >> 0x5 == -0x139 (0xfec7) +__ulonglong 0xd8f0 >> 0x5 == -0x139 (0xfec7) +int 0xd8f0 + 0x4 == -0x270c (0xd8f4) +__uint 0xd8f0 + 0x4 == -0x270c (0xd8f4) +char 0xfff0 + 0x4 == -0xc (0xfff4) +__uchar 0xf0 + 0x4 == 0xf4 (0xf4) +__longlong 0xd8f0 + 0x4 == -0x270c (0xd8f4) +__ulonglong 0xd8f0 + 0x4 == -0x270c (0xd8f4) +float 0xd8f0 + 0x4 == -0x270c (0xd8f4) +int 0xd8f0 - 0x4 == -0x2714 (0xd8ec) +__uint 0xd8f0 - 0x4 == -0x2714 (0xd8ec) +char 0xfff0 - 0x4 == -0x14 (0xffec) +__uchar 0xf0 - 0x4 == 0xec (0xec) +__longlong 0xd8f0 - 0x4 == -0x2714 (0xd8ec) +__ulonglong 0xd8f0 - 0x4 == -0x2714 (0xd8ec) +float 0xd8f0 - 0x4 == -0x2714 (0xd8ec) +int 0xd8f0 * 0x4 == 0x63c0 (0x63c0) +__uint 0xd8f0 * 0x4 == 0x63c0 (0x63c0) +char 0xfff0 * 0x4 == -0x40 (0xffc0) +__uchar 0xf0 * 0x4 == 0xc0 (0xc0) +__longlong 0xd8f0 * 0x4 == 0x63c0 (0x63c0) +__ulonglong 0xd8f0 * 0x4 == 0x63c0 (0x63c0) +float 0xd8f0 * 0x4 == 0x63c0 (0x63c0) +int 0xd8f0 < 0x4 == 0x1 (0x1) +__uint 0xd8f0 < 0x4 == 0x0 (0x0) +char 0xfff0 < 0x4 == 0x1 (0x1) +__uchar 0xf0 < 0x4 == 0x0 (0x0) +__longlong 0xd8f0 < 0x4 == 0x1 (0x1) +__ulonglong 0xd8f0 < 0x4 == 0x0 (0x0) +float 0xd8f0 < 0x4 == 0x1 (0x1) +int 0xd8f0 > 0x4 == 0x0 (0x0) +__uint 0xd8f0 > 0x4 == 0x1 (0x1) +char 0xfff0 > 0x4 == 0x0 (0x0) +__uchar 0xf0 > 0x4 == 0x1 (0x1) +__longlong 0xd8f0 > 0x4 == 0x0 (0x0) +__ulonglong 0xd8f0 > 0x4 == 0x1 (0x1) +float 0xd8f0 > 0x4 == 0x0 (0x0) +int 0xd8f0 <= 0x4 == 0x1 (0x1) +__uint 0xd8f0 <= 0x4 == 0x0 (0x0) +char 0xfff0 <= 0x4 == 0x1 (0x1) +__uchar 0xf0 <= 0x4 == 0x0 (0x0) +__longlong 0xd8f0 <= 0x4 == 0x1 (0x1) +__ulonglong 0xd8f0 <= 0x4 == 0x0 (0x0) +float 0xd8f0 <= 0x4 == 0x1 (0x1) +int 0xd8f0 == 0x4 == 0x0 (0x0) +__uint 0xd8f0 == 0x4 == 0x0 (0x0) +char 0xfff0 == 0x4 == 0x0 (0x0) +__uchar 0xf0 == 0x4 == 0x0 (0x0) +__longlong 0xd8f0 == 0x4 == 0x0 (0x0) +__ulonglong 0xd8f0 == 0x4 == 0x0 (0x0) +float 0xd8f0 == 0x4 == 0x0 (0x0) +int 0xd8f0 != 0x4 == 0x1 (0x1) +__uint 0xd8f0 != 0x4 == 0x1 (0x1) +char 0xfff0 != 0x4 == 0x1 (0x1) +__uchar 0xf0 != 0x4 == 0x1 (0x1) +__longlong 0xd8f0 != 0x4 == 0x1 (0x1) +__ulonglong 0xd8f0 != 0x4 == 0x1 (0x1) +float 0xd8f0 != 0x4 == 0x1 (0x1) +int 0xd8f0 >= 0x4 == 0x0 (0x0) +__uint 0xd8f0 >= 0x4 == 0x1 (0x1) +char 0xfff0 >= 0x4 == 0x0 (0x0) +__uchar 0xf0 >= 0x4 == 0x1 (0x1) +__longlong 0xd8f0 >= 0x4 == 0x0 (0x0) +__ulonglong 0xd8f0 >= 0x4 == 0x1 (0x1) +float 0xd8f0 >= 0x4 == 0x0 (0x0) +int 0xd8f0 / 0x4 == -0x9c4 (0xf63c) +__uint 0xd8f0 / 0x4 == 0x363c (0x363c) +char 0xfff0 / 0x4 == -0x4 (0xfffc) +__uchar 0xf0 / 0x4 == 0x3c (0x3c) +__longlong 0xd8f0 / 0x4 == -0x9c4 (0xf63c) +__ulonglong 0xd8f0 / 0x4 == -0x9c4 (0xf63c) +float 0xd8f0 / 0x4 == -0x9c4 (0xf63c) +int 0xd8f0 % 0x4 == 0x0 (0x0) +__uint 0xd8f0 % 0x4 == 0x0 (0x0) +char 0xfff0 % 0x4 == 0x0 (0x0) +__uchar 0xf0 % 0x4 == 0x0 (0x0) +__longlong 0xd8f0 % 0x4 == 0x0 (0x0) +__ulonglong 0xd8f0 % 0x4 == 0x0 (0x0) +0xd8f0 * 0xfffc == -0x63c0 +0xd8f0 / 0xfffc == 0x9c4 +0xd8f0 % 0xfffc == 0x0 +int 0xd8f0 ^ 0xfffc == 0x270c (0x270c) +__uint 0xd8f0 ^ 0xfffc == 0x270c (0x270c) +char 0xfff0 ^ 0xfffc == 0xc (0xc) +__uchar 0xf0 ^ 0xfc == 0xc (0xc) +__longlong 0xd8f0 ^ 0xfffc == 0x270c (0x270c) +__ulonglong 0xd8f0 ^ 0xfffc == 0x270c (0x270c) +int 0xd8f0 && 0xfffc == 0x1 (0x1) +__uint 0xd8f0 && 0xfffc == 0x1 (0x1) +char 0xfff0 && 0xfffc == 0x1 (0x1) +__uchar 0xf0 && 0xfc == 0x1 (0x1) +__longlong 0xd8f0 && 0xfffc == 0x1 (0x1) +__ulonglong 0xd8f0 && 0xfffc == 0x1 (0x1) +int 0xd8f0 || 0xfffc == 0x1 (0x1) +__uint 0xd8f0 || 0xfffc == 0x1 (0x1) +char 0xfff0 || 0xfffc == 0x1 (0x1) +__uchar 0xf0 || 0xfc == 0x1 (0x1) +__longlong 0xd8f0 || 0xfffc == 0x1 (0x1) +__ulonglong 0xd8f0 || 0xfffc == 0x1 (0x1) +int 0xd8f0 & 0xfffc == -0x2710 (0xd8f0) +__uint 0xd8f0 & 0xfffc == -0x2710 (0xd8f0) +char 0xfff0 & 0xfffc == -0x10 (0xfff0) +__uchar 0xf0 & 0xfc == 0xf0 (0xf0) +__longlong 0xd8f0 & 0xfffc == -0x2710 (0xd8f0) +__ulonglong 0xd8f0 & 0xfffc == -0x2710 (0xd8f0) +int 0xd8f0 | 0xfffc == -0x4 (0xfffc) +__uint 0xd8f0 | 0xfffc == -0x4 (0xfffc) +char 0xfff0 | 0xfffc == -0x4 (0xfffc) +__uchar 0xf0 | 0xfc == 0xfc (0xfc) +__longlong 0xd8f0 | 0xfffc == -0x4 (0xfffc) +__ulonglong 0xd8f0 | 0xfffc == -0x4 (0xfffc) +int 0xd8f0 << 0x6 == 0x3c00 (0x3c00) +__uint 0xd8f0 << 0x6 == 0x3c00 (0x3c00) +char 0xfff0 << 0x6 == 0x0 (0x0) +__uchar 0xf0 << 0x6 == 0x0 (0x0) +__longlong 0xd8f0 << 0x6 == 0x3c00 (0x3c00) +__ulonglong 0xd8f0 << 0x6 == 0x3c00 (0x3c00) +int 0xd8f0 >> 0x6 == -0x9d (0xff63) +__uint 0xd8f0 >> 0x6 == 0x363 (0x363) +char 0xfff0 >> 0x6 == -0x1 (0xffff) +__uchar 0xf0 >> 0x6 == 0x3 (0x3) +__longlong 0xd8f0 >> 0x6 == -0x9d (0xff63) +__ulonglong 0xd8f0 >> 0x6 == -0x9d (0xff63) +int 0xd8f0 + 0xfffc == -0x2714 (0xd8ec) +__uint 0xd8f0 + 0xfffc == -0x2714 (0xd8ec) +char 0xfff0 + 0xfffc == -0x14 (0xffec) +__uchar 0xf0 + 0xfc == 0xec (0xec) +__longlong 0xd8f0 + 0xfffc == -0x2714 (0xd8ec) +__ulonglong 0xd8f0 + 0xfffc == -0x2714 (0xd8ec) +float 0xd8f0 + 0xfffc == -0x2714 (0xd8ec) +int 0xd8f0 - 0xfffc == -0x270c (0xd8f4) +__uint 0xd8f0 - 0xfffc == -0x270c (0xd8f4) +char 0xfff0 - 0xfffc == -0xc (0xfff4) +__uchar 0xf0 - 0xfc == 0xf4 (0xf4) +__longlong 0xd8f0 - 0xfffc == -0x270c (0xd8f4) +__ulonglong 0xd8f0 - 0xfffc == -0x270c (0xd8f4) +float 0xd8f0 - 0xfffc == -0x270c (0xd8f4) +int 0xd8f0 * 0xfffc == -0x63c0 (0x9c40) +__uint 0xd8f0 * 0xfffc == -0x63c0 (0x9c40) +char 0xfff0 * 0xfffc == 0x40 (0x40) +__uchar 0xf0 * 0xfc == 0x40 (0x40) +__longlong 0xd8f0 * 0xfffc == -0x63c0 (0x9c40) +__ulonglong 0xd8f0 * 0xfffc == -0x63c0 (0x9c40) +float 0xd8f0 * 0xfffc == -0x63c0 (0x9c40) +int 0xd8f0 < 0xfffc == 0x1 (0x1) +__uint 0xd8f0 < 0xfffc == 0x1 (0x1) +char 0xfff0 < 0xfffc == 0x1 (0x1) +__uchar 0xf0 < 0xfc == 0x1 (0x1) +__longlong 0xd8f0 < 0xfffc == 0x1 (0x1) +__ulonglong 0xd8f0 < 0xfffc == 0x1 (0x1) +float 0xd8f0 < 0xfffc == 0x1 (0x1) +int 0xd8f0 > 0xfffc == 0x0 (0x0) +__uint 0xd8f0 > 0xfffc == 0x0 (0x0) +char 0xfff0 > 0xfffc == 0x0 (0x0) +__uchar 0xf0 > 0xfc == 0x0 (0x0) +__longlong 0xd8f0 > 0xfffc == 0x0 (0x0) +__ulonglong 0xd8f0 > 0xfffc == 0x0 (0x0) +float 0xd8f0 > 0xfffc == 0x0 (0x0) +int 0xd8f0 <= 0xfffc == 0x1 (0x1) +__uint 0xd8f0 <= 0xfffc == 0x1 (0x1) +char 0xfff0 <= 0xfffc == 0x1 (0x1) +__uchar 0xf0 <= 0xfc == 0x1 (0x1) +__longlong 0xd8f0 <= 0xfffc == 0x1 (0x1) +__ulonglong 0xd8f0 <= 0xfffc == 0x1 (0x1) +float 0xd8f0 <= 0xfffc == 0x1 (0x1) +int 0xd8f0 == 0xfffc == 0x0 (0x0) +__uint 0xd8f0 == 0xfffc == 0x0 (0x0) +char 0xfff0 == 0xfffc == 0x0 (0x0) +__uchar 0xf0 == 0xfc == 0x0 (0x0) +__longlong 0xd8f0 == 0xfffc == 0x0 (0x0) +__ulonglong 0xd8f0 == 0xfffc == 0x0 (0x0) +float 0xd8f0 == 0xfffc == 0x0 (0x0) +int 0xd8f0 != 0xfffc == 0x1 (0x1) +__uint 0xd8f0 != 0xfffc == 0x1 (0x1) +char 0xfff0 != 0xfffc == 0x1 (0x1) +__uchar 0xf0 != 0xfc == 0x1 (0x1) +__longlong 0xd8f0 != 0xfffc == 0x1 (0x1) +__ulonglong 0xd8f0 != 0xfffc == 0x1 (0x1) +float 0xd8f0 != 0xfffc == 0x1 (0x1) +int 0xd8f0 >= 0xfffc == 0x0 (0x0) +__uint 0xd8f0 >= 0xfffc == 0x0 (0x0) +char 0xfff0 >= 0xfffc == 0x0 (0x0) +__uchar 0xf0 >= 0xfc == 0x0 (0x0) +__longlong 0xd8f0 >= 0xfffc == 0x0 (0x0) +__ulonglong 0xd8f0 >= 0xfffc == 0x0 (0x0) +float 0xd8f0 >= 0xfffc == 0x0 (0x0) +int 0xd8f0 / 0xfffc == 0x9c4 (0x9c4) +__uint 0xd8f0 / 0xfffc == 0x0 (0x0) +char 0xfff0 / 0xfffc == 0x4 (0x4) +__uchar 0xf0 / 0xfc == 0x0 (0x0) +__longlong 0xd8f0 / 0xfffc == 0x9c4 (0x9c4) +__ulonglong 0xd8f0 / 0xfffc == 0x0 (0x0) +float 0xd8f0 / 0xfffc == 0x9c4 (0x9c4) +int 0xd8f0 % 0xfffc == 0x0 (0x0) +__uint 0xd8f0 % 0xfffc == -0x2710 (0xd8f0) +char 0xfff0 % 0xfffc == 0x0 (0x0) +__uchar 0xf0 % 0xfc == 0xf0 (0xf0) +__longlong 0xd8f0 % 0xfffc == 0x0 (0x0) +__ulonglong 0xd8f0 % 0xfffc == -0x2710 (0xd8f0) +0xd8f0 * 0xa == 0x7960 +0xd8f0 / 0xa == -0x3e8 +0xd8f0 % 0xa == 0x0 +int 0xd8f0 ^ 0xa == -0x2706 (0xd8fa) +__uint 0xd8f0 ^ 0xa == -0x2706 (0xd8fa) +char 0xfff0 ^ 0xa == -0x6 (0xfffa) +__uchar 0xf0 ^ 0xa == 0xfa (0xfa) +__longlong 0xd8f0 ^ 0xa == -0x2706 (0xd8fa) +__ulonglong 0xd8f0 ^ 0xa == -0x2706 (0xd8fa) +int 0xd8f0 && 0xa == 0x1 (0x1) +__uint 0xd8f0 && 0xa == 0x1 (0x1) +char 0xfff0 && 0xa == 0x1 (0x1) +__uchar 0xf0 && 0xa == 0x1 (0x1) +__longlong 0xd8f0 && 0xa == 0x1 (0x1) +__ulonglong 0xd8f0 && 0xa == 0x1 (0x1) +int 0xd8f0 || 0xa == 0x1 (0x1) +__uint 0xd8f0 || 0xa == 0x1 (0x1) +char 0xfff0 || 0xa == 0x1 (0x1) +__uchar 0xf0 || 0xa == 0x1 (0x1) +__longlong 0xd8f0 || 0xa == 0x1 (0x1) +__ulonglong 0xd8f0 || 0xa == 0x1 (0x1) +int 0xd8f0 & 0xa == 0x0 (0x0) +__uint 0xd8f0 & 0xa == 0x0 (0x0) +char 0xfff0 & 0xa == 0x0 (0x0) +__uchar 0xf0 & 0xa == 0x0 (0x0) +__longlong 0xd8f0 & 0xa == 0x0 (0x0) +__ulonglong 0xd8f0 & 0xa == 0x0 (0x0) +int 0xd8f0 | 0xa == -0x2706 (0xd8fa) +__uint 0xd8f0 | 0xa == -0x2706 (0xd8fa) +char 0xfff0 | 0xa == -0x6 (0xfffa) +__uchar 0xf0 | 0xa == 0xfa (0xfa) +__longlong 0xd8f0 | 0xa == -0x2706 (0xd8fa) +__ulonglong 0xd8f0 | 0xa == -0x2706 (0xd8fa) +int 0xd8f0 << 0x7 == 0x7800 (0x7800) +__uint 0xd8f0 << 0x7 == 0x7800 (0x7800) +char 0xfff0 << 0x7 == 0x0 (0x0) +__uchar 0xf0 << 0x7 == 0x0 (0x0) +__longlong 0xd8f0 << 0x7 == 0x7800 (0x7800) +__ulonglong 0xd8f0 << 0x7 == 0x7800 (0x7800) +int 0xd8f0 >> 0x7 == -0x4f (0xffb1) +__uint 0xd8f0 >> 0x7 == 0x1b1 (0x1b1) +char 0xfff0 >> 0x7 == -0x1 (0xffff) +__uchar 0xf0 >> 0x7 == 0x1 (0x1) +__longlong 0xd8f0 >> 0x7 == -0x4f (0xffb1) +__ulonglong 0xd8f0 >> 0x7 == -0x4f (0xffb1) +int 0xd8f0 + 0xa == -0x2706 (0xd8fa) +__uint 0xd8f0 + 0xa == -0x2706 (0xd8fa) +char 0xfff0 + 0xa == -0x6 (0xfffa) +__uchar 0xf0 + 0xa == 0xfa (0xfa) +__longlong 0xd8f0 + 0xa == -0x2706 (0xd8fa) +__ulonglong 0xd8f0 + 0xa == -0x2706 (0xd8fa) +float 0xd8f0 + 0xa == -0x2706 (0xd8fa) +int 0xd8f0 - 0xa == -0x271a (0xd8e6) +__uint 0xd8f0 - 0xa == -0x271a (0xd8e6) +char 0xfff0 - 0xa == -0x1a (0xffe6) +__uchar 0xf0 - 0xa == 0xe6 (0xe6) +__longlong 0xd8f0 - 0xa == -0x271a (0xd8e6) +__ulonglong 0xd8f0 - 0xa == -0x271a (0xd8e6) +float 0xd8f0 - 0xa == -0x271a (0xd8e6) +int 0xd8f0 * 0xa == 0x7960 (0x7960) +__uint 0xd8f0 * 0xa == 0x7960 (0x7960) +char 0xfff0 * 0xa == 0x60 (0x60) +__uchar 0xf0 * 0xa == 0x60 (0x60) +__longlong 0xd8f0 * 0xa == 0x7960 (0x7960) +__ulonglong 0xd8f0 * 0xa == 0x7960 (0x7960) +float 0xd8f0 * 0xa == 0x7960 (0x7960) +int 0xd8f0 < 0xa == 0x1 (0x1) +__uint 0xd8f0 < 0xa == 0x0 (0x0) +char 0xfff0 < 0xa == 0x1 (0x1) +__uchar 0xf0 < 0xa == 0x0 (0x0) +__longlong 0xd8f0 < 0xa == 0x1 (0x1) +__ulonglong 0xd8f0 < 0xa == 0x0 (0x0) +float 0xd8f0 < 0xa == 0x1 (0x1) +int 0xd8f0 > 0xa == 0x0 (0x0) +__uint 0xd8f0 > 0xa == 0x1 (0x1) +char 0xfff0 > 0xa == 0x0 (0x0) +__uchar 0xf0 > 0xa == 0x1 (0x1) +__longlong 0xd8f0 > 0xa == 0x0 (0x0) +__ulonglong 0xd8f0 > 0xa == 0x1 (0x1) +float 0xd8f0 > 0xa == 0x0 (0x0) +int 0xd8f0 <= 0xa == 0x1 (0x1) +__uint 0xd8f0 <= 0xa == 0x0 (0x0) +char 0xfff0 <= 0xa == 0x1 (0x1) +__uchar 0xf0 <= 0xa == 0x0 (0x0) +__longlong 0xd8f0 <= 0xa == 0x1 (0x1) +__ulonglong 0xd8f0 <= 0xa == 0x0 (0x0) +float 0xd8f0 <= 0xa == 0x1 (0x1) +int 0xd8f0 == 0xa == 0x0 (0x0) +__uint 0xd8f0 == 0xa == 0x0 (0x0) +char 0xfff0 == 0xa == 0x0 (0x0) +__uchar 0xf0 == 0xa == 0x0 (0x0) +__longlong 0xd8f0 == 0xa == 0x0 (0x0) +__ulonglong 0xd8f0 == 0xa == 0x0 (0x0) +float 0xd8f0 == 0xa == 0x0 (0x0) +int 0xd8f0 != 0xa == 0x1 (0x1) +__uint 0xd8f0 != 0xa == 0x1 (0x1) +char 0xfff0 != 0xa == 0x1 (0x1) +__uchar 0xf0 != 0xa == 0x1 (0x1) +__longlong 0xd8f0 != 0xa == 0x1 (0x1) +__ulonglong 0xd8f0 != 0xa == 0x1 (0x1) +float 0xd8f0 != 0xa == 0x1 (0x1) +int 0xd8f0 >= 0xa == 0x0 (0x0) +__uint 0xd8f0 >= 0xa == 0x1 (0x1) +char 0xfff0 >= 0xa == 0x0 (0x0) +__uchar 0xf0 >= 0xa == 0x1 (0x1) +__longlong 0xd8f0 >= 0xa == 0x0 (0x0) +__ulonglong 0xd8f0 >= 0xa == 0x1 (0x1) +float 0xd8f0 >= 0xa == 0x0 (0x0) +int 0xd8f0 / 0xa == -0x3e8 (0xfc18) +__uint 0xd8f0 / 0xa == 0x15b1 (0x15b1) +char 0xfff0 / 0xa == -0x1 (0xffff) +__uchar 0xf0 / 0xa == 0x18 (0x18) +__longlong 0xd8f0 / 0xa == -0x3e8 (0xfc18) +__ulonglong 0xd8f0 / 0xa == -0x6a4f (0x95b1) +float 0xd8f0 / 0xa == -0x3e8 (0xfc18) +int 0xd8f0 % 0xa == 0x0 (0x0) +__uint 0xd8f0 % 0xa == 0x6 (0x6) +char 0xfff0 % 0xa == -0x6 (0xfffa) +__uchar 0xf0 % 0xa == 0x0 (0x0) +__longlong 0xd8f0 % 0xa == 0x0 (0x0) +__ulonglong 0xd8f0 % 0xa == 0x6 (0x6) +0xd8f0 * 0xfff6 == -0x7960 +0xd8f0 / 0xfff6 == 0x3e8 +0xd8f0 % 0xfff6 == 0x0 +int 0xd8f0 ^ 0xfff6 == 0x2706 (0x2706) +__uint 0xd8f0 ^ 0xfff6 == 0x2706 (0x2706) +char 0xfff0 ^ 0xfff6 == 0x6 (0x6) +__uchar 0xf0 ^ 0xf6 == 0x6 (0x6) +__longlong 0xd8f0 ^ 0xfff6 == 0x2706 (0x2706) +__ulonglong 0xd8f0 ^ 0xfff6 == 0x2706 (0x2706) +int 0xd8f0 && 0xfff6 == 0x1 (0x1) +__uint 0xd8f0 && 0xfff6 == 0x1 (0x1) +char 0xfff0 && 0xfff6 == 0x1 (0x1) +__uchar 0xf0 && 0xf6 == 0x1 (0x1) +__longlong 0xd8f0 && 0xfff6 == 0x1 (0x1) +__ulonglong 0xd8f0 && 0xfff6 == 0x1 (0x1) +int 0xd8f0 || 0xfff6 == 0x1 (0x1) +__uint 0xd8f0 || 0xfff6 == 0x1 (0x1) +char 0xfff0 || 0xfff6 == 0x1 (0x1) +__uchar 0xf0 || 0xf6 == 0x1 (0x1) +__longlong 0xd8f0 || 0xfff6 == 0x1 (0x1) +__ulonglong 0xd8f0 || 0xfff6 == 0x1 (0x1) +int 0xd8f0 & 0xfff6 == -0x2710 (0xd8f0) +__uint 0xd8f0 & 0xfff6 == -0x2710 (0xd8f0) +char 0xfff0 & 0xfff6 == -0x10 (0xfff0) +__uchar 0xf0 & 0xf6 == 0xf0 (0xf0) +__longlong 0xd8f0 & 0xfff6 == -0x2710 (0xd8f0) +__ulonglong 0xd8f0 & 0xfff6 == -0x2710 (0xd8f0) +int 0xd8f0 | 0xfff6 == -0xa (0xfff6) +__uint 0xd8f0 | 0xfff6 == -0xa (0xfff6) +char 0xfff0 | 0xfff6 == -0xa (0xfff6) +__uchar 0xf0 | 0xf6 == 0xf6 (0xf6) +__longlong 0xd8f0 | 0xfff6 == -0xa (0xfff6) +__ulonglong 0xd8f0 | 0xfff6 == -0xa (0xfff6) +int 0xd8f0 << 0x8 == -0x1000 (0xf000) +__uint 0xd8f0 << 0x8 == -0x1000 (0xf000) +char 0xfff0 << 0x8 == 0x0 (0x0) +__uchar 0xf0 << 0x8 == 0x0 (0x0) +__longlong 0xd8f0 << 0x8 == -0x1000 (0xf000) +__ulonglong 0xd8f0 << 0x8 == -0x1000 (0xf000) +int 0xd8f0 >> 0x8 == -0x28 (0xffd8) +__uint 0xd8f0 >> 0x8 == 0xd8 (0xd8) +char 0xfff0 >> 0x8 == -0x1 (0xffff) +__uchar 0xf0 >> 0x8 == 0x0 (0x0) +__longlong 0xd8f0 >> 0x8 == -0x28 (0xffd8) +__ulonglong 0xd8f0 >> 0x8 == -0x28 (0xffd8) +int 0xd8f0 + 0xfff6 == -0x271a (0xd8e6) +__uint 0xd8f0 + 0xfff6 == -0x271a (0xd8e6) +char 0xfff0 + 0xfff6 == -0x1a (0xffe6) +__uchar 0xf0 + 0xf6 == 0xe6 (0xe6) +__longlong 0xd8f0 + 0xfff6 == -0x271a (0xd8e6) +__ulonglong 0xd8f0 + 0xfff6 == -0x271a (0xd8e6) +float 0xd8f0 + 0xfff6 == -0x271a (0xd8e6) +int 0xd8f0 - 0xfff6 == -0x2706 (0xd8fa) +__uint 0xd8f0 - 0xfff6 == -0x2706 (0xd8fa) +char 0xfff0 - 0xfff6 == -0x6 (0xfffa) +__uchar 0xf0 - 0xf6 == 0xfa (0xfa) +__longlong 0xd8f0 - 0xfff6 == -0x2706 (0xd8fa) +__ulonglong 0xd8f0 - 0xfff6 == -0x2706 (0xd8fa) +float 0xd8f0 - 0xfff6 == -0x2706 (0xd8fa) +int 0xd8f0 * 0xfff6 == -0x7960 (0x86a0) +__uint 0xd8f0 * 0xfff6 == -0x7960 (0x86a0) +char 0xfff0 * 0xfff6 == -0x60 (0xffa0) +__uchar 0xf0 * 0xf6 == 0xa0 (0xa0) +__longlong 0xd8f0 * 0xfff6 == -0x7960 (0x86a0) +__ulonglong 0xd8f0 * 0xfff6 == -0x7960 (0x86a0) +float 0xd8f0 * 0xfff6 == -0x7960 (0x86a0) +int 0xd8f0 < 0xfff6 == 0x1 (0x1) +__uint 0xd8f0 < 0xfff6 == 0x1 (0x1) +char 0xfff0 < 0xfff6 == 0x1 (0x1) +__uchar 0xf0 < 0xf6 == 0x1 (0x1) +__longlong 0xd8f0 < 0xfff6 == 0x1 (0x1) +__ulonglong 0xd8f0 < 0xfff6 == 0x1 (0x1) +float 0xd8f0 < 0xfff6 == 0x1 (0x1) +int 0xd8f0 > 0xfff6 == 0x0 (0x0) +__uint 0xd8f0 > 0xfff6 == 0x0 (0x0) +char 0xfff0 > 0xfff6 == 0x0 (0x0) +__uchar 0xf0 > 0xf6 == 0x0 (0x0) +__longlong 0xd8f0 > 0xfff6 == 0x0 (0x0) +__ulonglong 0xd8f0 > 0xfff6 == 0x0 (0x0) +float 0xd8f0 > 0xfff6 == 0x0 (0x0) +int 0xd8f0 <= 0xfff6 == 0x1 (0x1) +__uint 0xd8f0 <= 0xfff6 == 0x1 (0x1) +char 0xfff0 <= 0xfff6 == 0x1 (0x1) +__uchar 0xf0 <= 0xf6 == 0x1 (0x1) +__longlong 0xd8f0 <= 0xfff6 == 0x1 (0x1) +__ulonglong 0xd8f0 <= 0xfff6 == 0x1 (0x1) +float 0xd8f0 <= 0xfff6 == 0x1 (0x1) +int 0xd8f0 == 0xfff6 == 0x0 (0x0) +__uint 0xd8f0 == 0xfff6 == 0x0 (0x0) +char 0xfff0 == 0xfff6 == 0x0 (0x0) +__uchar 0xf0 == 0xf6 == 0x0 (0x0) +__longlong 0xd8f0 == 0xfff6 == 0x0 (0x0) +__ulonglong 0xd8f0 == 0xfff6 == 0x0 (0x0) +float 0xd8f0 == 0xfff6 == 0x0 (0x0) +int 0xd8f0 != 0xfff6 == 0x1 (0x1) +__uint 0xd8f0 != 0xfff6 == 0x1 (0x1) +char 0xfff0 != 0xfff6 == 0x1 (0x1) +__uchar 0xf0 != 0xf6 == 0x1 (0x1) +__longlong 0xd8f0 != 0xfff6 == 0x1 (0x1) +__ulonglong 0xd8f0 != 0xfff6 == 0x1 (0x1) +float 0xd8f0 != 0xfff6 == 0x1 (0x1) +int 0xd8f0 >= 0xfff6 == 0x0 (0x0) +__uint 0xd8f0 >= 0xfff6 == 0x0 (0x0) +char 0xfff0 >= 0xfff6 == 0x0 (0x0) +__uchar 0xf0 >= 0xf6 == 0x0 (0x0) +__longlong 0xd8f0 >= 0xfff6 == 0x0 (0x0) +__ulonglong 0xd8f0 >= 0xfff6 == 0x0 (0x0) +float 0xd8f0 >= 0xfff6 == 0x0 (0x0) +int 0xd8f0 / 0xfff6 == 0x3e8 (0x3e8) +__uint 0xd8f0 / 0xfff6 == 0x0 (0x0) +char 0xfff0 / 0xfff6 == 0x1 (0x1) +__uchar 0xf0 / 0xf6 == 0x0 (0x0) +__longlong 0xd8f0 / 0xfff6 == 0x3e8 (0x3e8) +__ulonglong 0xd8f0 / 0xfff6 == 0x0 (0x0) +float 0xd8f0 / 0xfff6 == 0x3e8 (0x3e8) +int 0xd8f0 % 0xfff6 == 0x0 (0x0) +__uint 0xd8f0 % 0xfff6 == -0x2710 (0xd8f0) +char 0xfff0 % 0xfff6 == -0x6 (0xfffa) +__uchar 0xf0 % 0xf6 == 0xf0 (0xf0) +__longlong 0xd8f0 % 0xfff6 == 0x0 (0x0) +__ulonglong 0xd8f0 % 0xfff6 == -0x2710 (0xd8f0) +0xd8f0 * 0x5 == 0x3cb0 +0xd8f0 / 0x5 == -0x7d0 +0xd8f0 % 0x5 == 0x0 +int 0xd8f0 ^ 0x5 == -0x270b (0xd8f5) +__uint 0xd8f0 ^ 0x5 == -0x270b (0xd8f5) +char 0xfff0 ^ 0x5 == -0xb (0xfff5) +__uchar 0xf0 ^ 0x5 == 0xf5 (0xf5) +__longlong 0xd8f0 ^ 0x5 == -0x270b (0xd8f5) +__ulonglong 0xd8f0 ^ 0x5 == -0x270b (0xd8f5) +int 0xd8f0 && 0x5 == 0x1 (0x1) +__uint 0xd8f0 && 0x5 == 0x1 (0x1) +char 0xfff0 && 0x5 == 0x1 (0x1) +__uchar 0xf0 && 0x5 == 0x1 (0x1) +__longlong 0xd8f0 && 0x5 == 0x1 (0x1) +__ulonglong 0xd8f0 && 0x5 == 0x1 (0x1) +int 0xd8f0 || 0x5 == 0x1 (0x1) +__uint 0xd8f0 || 0x5 == 0x1 (0x1) +char 0xfff0 || 0x5 == 0x1 (0x1) +__uchar 0xf0 || 0x5 == 0x1 (0x1) +__longlong 0xd8f0 || 0x5 == 0x1 (0x1) +__ulonglong 0xd8f0 || 0x5 == 0x1 (0x1) +int 0xd8f0 & 0x5 == 0x0 (0x0) +__uint 0xd8f0 & 0x5 == 0x0 (0x0) +char 0xfff0 & 0x5 == 0x0 (0x0) +__uchar 0xf0 & 0x5 == 0x0 (0x0) +__longlong 0xd8f0 & 0x5 == 0x0 (0x0) +__ulonglong 0xd8f0 & 0x5 == 0x0 (0x0) +int 0xd8f0 | 0x5 == -0x270b (0xd8f5) +__uint 0xd8f0 | 0x5 == -0x270b (0xd8f5) +char 0xfff0 | 0x5 == -0xb (0xfff5) +__uchar 0xf0 | 0x5 == 0xf5 (0xf5) +__longlong 0xd8f0 | 0x5 == -0x270b (0xd8f5) +__ulonglong 0xd8f0 | 0x5 == -0x270b (0xd8f5) +int 0xd8f0 << 0x9 == -0x2000 (0xe000) +__uint 0xd8f0 << 0x9 == -0x2000 (0xe000) +char 0xfff0 << 0x9 == 0x0 (0x0) +__uchar 0xf0 << 0x9 == 0x0 (0x0) +__longlong 0xd8f0 << 0x9 == -0x2000 (0xe000) +__ulonglong 0xd8f0 << 0x9 == -0x2000 (0xe000) +int 0xd8f0 >> 0x9 == -0x14 (0xffec) +__uint 0xd8f0 >> 0x9 == 0x6c (0x6c) +char 0xfff0 >> 0x9 == -0x1 (0xffff) +__uchar 0xf0 >> 0x9 == 0x0 (0x0) +__longlong 0xd8f0 >> 0x9 == -0x14 (0xffec) +__ulonglong 0xd8f0 >> 0x9 == -0x14 (0xffec) +int 0xd8f0 + 0x5 == -0x270b (0xd8f5) +__uint 0xd8f0 + 0x5 == -0x270b (0xd8f5) +char 0xfff0 + 0x5 == -0xb (0xfff5) +__uchar 0xf0 + 0x5 == 0xf5 (0xf5) +__longlong 0xd8f0 + 0x5 == -0x270b (0xd8f5) +__ulonglong 0xd8f0 + 0x5 == -0x270b (0xd8f5) +float 0xd8f0 + 0x5 == -0x270b (0xd8f5) +int 0xd8f0 - 0x5 == -0x2715 (0xd8eb) +__uint 0xd8f0 - 0x5 == -0x2715 (0xd8eb) +char 0xfff0 - 0x5 == -0x15 (0xffeb) +__uchar 0xf0 - 0x5 == 0xeb (0xeb) +__longlong 0xd8f0 - 0x5 == -0x2715 (0xd8eb) +__ulonglong 0xd8f0 - 0x5 == -0x2715 (0xd8eb) +float 0xd8f0 - 0x5 == -0x2715 (0xd8eb) +int 0xd8f0 * 0x5 == 0x3cb0 (0x3cb0) +__uint 0xd8f0 * 0x5 == 0x3cb0 (0x3cb0) +char 0xfff0 * 0x5 == -0x50 (0xffb0) +__uchar 0xf0 * 0x5 == 0xb0 (0xb0) +__longlong 0xd8f0 * 0x5 == 0x3cb0 (0x3cb0) +__ulonglong 0xd8f0 * 0x5 == 0x3cb0 (0x3cb0) +float 0xd8f0 * 0x5 == 0x3cb0 (0x3cb0) +int 0xd8f0 < 0x5 == 0x1 (0x1) +__uint 0xd8f0 < 0x5 == 0x0 (0x0) +char 0xfff0 < 0x5 == 0x1 (0x1) +__uchar 0xf0 < 0x5 == 0x0 (0x0) +__longlong 0xd8f0 < 0x5 == 0x1 (0x1) +__ulonglong 0xd8f0 < 0x5 == 0x0 (0x0) +float 0xd8f0 < 0x5 == 0x1 (0x1) +int 0xd8f0 > 0x5 == 0x0 (0x0) +__uint 0xd8f0 > 0x5 == 0x1 (0x1) +char 0xfff0 > 0x5 == 0x0 (0x0) +__uchar 0xf0 > 0x5 == 0x1 (0x1) +__longlong 0xd8f0 > 0x5 == 0x0 (0x0) +__ulonglong 0xd8f0 > 0x5 == 0x1 (0x1) +float 0xd8f0 > 0x5 == 0x0 (0x0) +int 0xd8f0 <= 0x5 == 0x1 (0x1) +__uint 0xd8f0 <= 0x5 == 0x0 (0x0) +char 0xfff0 <= 0x5 == 0x1 (0x1) +__uchar 0xf0 <= 0x5 == 0x0 (0x0) +__longlong 0xd8f0 <= 0x5 == 0x1 (0x1) +__ulonglong 0xd8f0 <= 0x5 == 0x0 (0x0) +float 0xd8f0 <= 0x5 == 0x1 (0x1) +int 0xd8f0 == 0x5 == 0x0 (0x0) +__uint 0xd8f0 == 0x5 == 0x0 (0x0) +char 0xfff0 == 0x5 == 0x0 (0x0) +__uchar 0xf0 == 0x5 == 0x0 (0x0) +__longlong 0xd8f0 == 0x5 == 0x0 (0x0) +__ulonglong 0xd8f0 == 0x5 == 0x0 (0x0) +float 0xd8f0 == 0x5 == 0x0 (0x0) +int 0xd8f0 != 0x5 == 0x1 (0x1) +__uint 0xd8f0 != 0x5 == 0x1 (0x1) +char 0xfff0 != 0x5 == 0x1 (0x1) +__uchar 0xf0 != 0x5 == 0x1 (0x1) +__longlong 0xd8f0 != 0x5 == 0x1 (0x1) +__ulonglong 0xd8f0 != 0x5 == 0x1 (0x1) +float 0xd8f0 != 0x5 == 0x1 (0x1) +int 0xd8f0 >= 0x5 == 0x0 (0x0) +__uint 0xd8f0 >= 0x5 == 0x1 (0x1) +char 0xfff0 >= 0x5 == 0x0 (0x0) +__uchar 0xf0 >= 0x5 == 0x1 (0x1) +__longlong 0xd8f0 >= 0x5 == 0x0 (0x0) +__ulonglong 0xd8f0 >= 0x5 == 0x1 (0x1) +float 0xd8f0 >= 0x5 == 0x0 (0x0) +int 0xd8f0 / 0x5 == -0x7d0 (0xf830) +__uint 0xd8f0 / 0x5 == 0x2b63 (0x2b63) +char 0xfff0 / 0x5 == -0x3 (0xfffd) +__uchar 0xf0 / 0x5 == 0x30 (0x30) +__longlong 0xd8f0 / 0x5 == -0x7d0 (0xf830) +__ulonglong 0xd8f0 / 0x5 == 0x2b63 (0x2b63) +float 0xd8f0 / 0x5 == -0x7d0 (0xf830) +int 0xd8f0 % 0x5 == 0x0 (0x0) +__uint 0xd8f0 % 0x5 == 0x1 (0x1) +char 0xfff0 % 0x5 == -0x1 (0xffff) +__uchar 0xf0 % 0x5 == 0x0 (0x0) +__longlong 0xd8f0 % 0x5 == 0x0 (0x0) +__ulonglong 0xd8f0 % 0x5 == 0x1 (0x1) +0xd8f0 * 0x7 == -0x1170 +0xd8f0 / 0x7 == -0x594 +0xd8f0 % 0x7 == -0x4 +int 0xd8f0 ^ 0x7 == -0x2709 (0xd8f7) +__uint 0xd8f0 ^ 0x7 == -0x2709 (0xd8f7) +char 0xfff0 ^ 0x7 == -0x9 (0xfff7) +__uchar 0xf0 ^ 0x7 == 0xf7 (0xf7) +__longlong 0xd8f0 ^ 0x7 == -0x2709 (0xd8f7) +__ulonglong 0xd8f0 ^ 0x7 == -0x2709 (0xd8f7) +int 0xd8f0 && 0x7 == 0x1 (0x1) +__uint 0xd8f0 && 0x7 == 0x1 (0x1) +char 0xfff0 && 0x7 == 0x1 (0x1) +__uchar 0xf0 && 0x7 == 0x1 (0x1) +__longlong 0xd8f0 && 0x7 == 0x1 (0x1) +__ulonglong 0xd8f0 && 0x7 == 0x1 (0x1) +int 0xd8f0 || 0x7 == 0x1 (0x1) +__uint 0xd8f0 || 0x7 == 0x1 (0x1) +char 0xfff0 || 0x7 == 0x1 (0x1) +__uchar 0xf0 || 0x7 == 0x1 (0x1) +__longlong 0xd8f0 || 0x7 == 0x1 (0x1) +__ulonglong 0xd8f0 || 0x7 == 0x1 (0x1) +int 0xd8f0 & 0x7 == 0x0 (0x0) +__uint 0xd8f0 & 0x7 == 0x0 (0x0) +char 0xfff0 & 0x7 == 0x0 (0x0) +__uchar 0xf0 & 0x7 == 0x0 (0x0) +__longlong 0xd8f0 & 0x7 == 0x0 (0x0) +__ulonglong 0xd8f0 & 0x7 == 0x0 (0x0) +int 0xd8f0 | 0x7 == -0x2709 (0xd8f7) +__uint 0xd8f0 | 0x7 == -0x2709 (0xd8f7) +char 0xfff0 | 0x7 == -0x9 (0xfff7) +__uchar 0xf0 | 0x7 == 0xf7 (0xf7) +__longlong 0xd8f0 | 0x7 == -0x2709 (0xd8f7) +__ulonglong 0xd8f0 | 0x7 == -0x2709 (0xd8f7) +int 0xd8f0 << 0xa == -0x4000 (0xc000) +__uint 0xd8f0 << 0xa == -0x4000 (0xc000) +char 0xfff0 << 0xa == 0x0 (0x0) +__uchar 0xf0 << 0xa == 0x0 (0x0) +__longlong 0xd8f0 << 0xa == -0x4000 (0xc000) +__ulonglong 0xd8f0 << 0xa == -0x4000 (0xc000) +int 0xd8f0 >> 0xa == -0xa (0xfff6) +__uint 0xd8f0 >> 0xa == 0x36 (0x36) +char 0xfff0 >> 0xa == -0x1 (0xffff) +__uchar 0xf0 >> 0xa == 0x0 (0x0) +__longlong 0xd8f0 >> 0xa == -0xa (0xfff6) +__ulonglong 0xd8f0 >> 0xa == -0xa (0xfff6) +int 0xd8f0 + 0x7 == -0x2709 (0xd8f7) +__uint 0xd8f0 + 0x7 == -0x2709 (0xd8f7) +char 0xfff0 + 0x7 == -0x9 (0xfff7) +__uchar 0xf0 + 0x7 == 0xf7 (0xf7) +__longlong 0xd8f0 + 0x7 == -0x2709 (0xd8f7) +__ulonglong 0xd8f0 + 0x7 == -0x2709 (0xd8f7) +float 0xd8f0 + 0x7 == -0x2709 (0xd8f7) +int 0xd8f0 - 0x7 == -0x2717 (0xd8e9) +__uint 0xd8f0 - 0x7 == -0x2717 (0xd8e9) +char 0xfff0 - 0x7 == -0x17 (0xffe9) +__uchar 0xf0 - 0x7 == 0xe9 (0xe9) +__longlong 0xd8f0 - 0x7 == -0x2717 (0xd8e9) +__ulonglong 0xd8f0 - 0x7 == -0x2717 (0xd8e9) +float 0xd8f0 - 0x7 == -0x2717 (0xd8e9) +int 0xd8f0 * 0x7 == -0x1170 (0xee90) +__uint 0xd8f0 * 0x7 == -0x1170 (0xee90) +char 0xfff0 * 0x7 == -0x70 (0xff90) +__uchar 0xf0 * 0x7 == 0x90 (0x90) +__longlong 0xd8f0 * 0x7 == -0x1170 (0xee90) +__ulonglong 0xd8f0 * 0x7 == -0x1170 (0xee90) +float 0xd8f0 * 0x7 == -0x1170 (0xee90) +int 0xd8f0 < 0x7 == 0x1 (0x1) +__uint 0xd8f0 < 0x7 == 0x0 (0x0) +char 0xfff0 < 0x7 == 0x1 (0x1) +__uchar 0xf0 < 0x7 == 0x0 (0x0) +__longlong 0xd8f0 < 0x7 == 0x1 (0x1) +__ulonglong 0xd8f0 < 0x7 == 0x0 (0x0) +float 0xd8f0 < 0x7 == 0x1 (0x1) +int 0xd8f0 > 0x7 == 0x0 (0x0) +__uint 0xd8f0 > 0x7 == 0x1 (0x1) +char 0xfff0 > 0x7 == 0x0 (0x0) +__uchar 0xf0 > 0x7 == 0x1 (0x1) +__longlong 0xd8f0 > 0x7 == 0x0 (0x0) +__ulonglong 0xd8f0 > 0x7 == 0x1 (0x1) +float 0xd8f0 > 0x7 == 0x0 (0x0) +int 0xd8f0 <= 0x7 == 0x1 (0x1) +__uint 0xd8f0 <= 0x7 == 0x0 (0x0) +char 0xfff0 <= 0x7 == 0x1 (0x1) +__uchar 0xf0 <= 0x7 == 0x0 (0x0) +__longlong 0xd8f0 <= 0x7 == 0x1 (0x1) +__ulonglong 0xd8f0 <= 0x7 == 0x0 (0x0) +float 0xd8f0 <= 0x7 == 0x1 (0x1) +int 0xd8f0 == 0x7 == 0x0 (0x0) +__uint 0xd8f0 == 0x7 == 0x0 (0x0) +char 0xfff0 == 0x7 == 0x0 (0x0) +__uchar 0xf0 == 0x7 == 0x0 (0x0) +__longlong 0xd8f0 == 0x7 == 0x0 (0x0) +__ulonglong 0xd8f0 == 0x7 == 0x0 (0x0) +float 0xd8f0 == 0x7 == 0x0 (0x0) +int 0xd8f0 != 0x7 == 0x1 (0x1) +__uint 0xd8f0 != 0x7 == 0x1 (0x1) +char 0xfff0 != 0x7 == 0x1 (0x1) +__uchar 0xf0 != 0x7 == 0x1 (0x1) +__longlong 0xd8f0 != 0x7 == 0x1 (0x1) +__ulonglong 0xd8f0 != 0x7 == 0x1 (0x1) +float 0xd8f0 != 0x7 == 0x1 (0x1) +int 0xd8f0 >= 0x7 == 0x0 (0x0) +__uint 0xd8f0 >= 0x7 == 0x1 (0x1) +char 0xfff0 >= 0x7 == 0x0 (0x0) +__uchar 0xf0 >= 0x7 == 0x1 (0x1) +__longlong 0xd8f0 >= 0x7 == 0x0 (0x0) +__ulonglong 0xd8f0 >= 0x7 == 0x1 (0x1) +float 0xd8f0 >= 0x7 == 0x0 (0x0) +int 0xd8f0 / 0x7 == -0x594 (0xfa6c) +__uint 0xd8f0 / 0x7 == 0x1efd (0x1efd) +char 0xfff0 / 0x7 == -0x2 (0xfffe) +__uchar 0xf0 / 0x7 == 0x22 (0x22) +__longlong 0xd8f0 / 0x7 == -0x594 (0xfa6c) +__ulonglong 0xd8f0 / 0x7 == 0x4390 (0x4390) +float 0xd8f0 / 0x7 == -0x594 (0xfa6c) +int 0xd8f0 % 0x7 == -0x4 (0xfffc) +__uint 0xd8f0 % 0x7 == 0x5 (0x5) +char 0xfff0 % 0x7 == -0x2 (0xfffe) +__uchar 0xf0 % 0x7 == 0x2 (0x2) +__longlong 0xd8f0 % 0x7 == -0x4 (0xfffc) +__ulonglong 0xd8f0 % 0x7 == 0x0 (0x0) +0xd8f0 * 0x2a == -0x68a0 +0xd8f0 / 0x2a == -0xee +0xd8f0 % 0x2a == -0x4 +int 0xd8f0 ^ 0x2a == -0x2726 (0xd8da) +__uint 0xd8f0 ^ 0x2a == -0x2726 (0xd8da) +char 0xfff0 ^ 0x2a == -0x26 (0xffda) +__uchar 0xf0 ^ 0x2a == 0xda (0xda) +__longlong 0xd8f0 ^ 0x2a == -0x2726 (0xd8da) +__ulonglong 0xd8f0 ^ 0x2a == -0x2726 (0xd8da) +int 0xd8f0 && 0x2a == 0x1 (0x1) +__uint 0xd8f0 && 0x2a == 0x1 (0x1) +char 0xfff0 && 0x2a == 0x1 (0x1) +__uchar 0xf0 && 0x2a == 0x1 (0x1) +__longlong 0xd8f0 && 0x2a == 0x1 (0x1) +__ulonglong 0xd8f0 && 0x2a == 0x1 (0x1) +int 0xd8f0 || 0x2a == 0x1 (0x1) +__uint 0xd8f0 || 0x2a == 0x1 (0x1) +char 0xfff0 || 0x2a == 0x1 (0x1) +__uchar 0xf0 || 0x2a == 0x1 (0x1) +__longlong 0xd8f0 || 0x2a == 0x1 (0x1) +__ulonglong 0xd8f0 || 0x2a == 0x1 (0x1) +int 0xd8f0 & 0x2a == 0x20 (0x20) +__uint 0xd8f0 & 0x2a == 0x20 (0x20) +char 0xfff0 & 0x2a == 0x20 (0x20) +__uchar 0xf0 & 0x2a == 0x20 (0x20) +__longlong 0xd8f0 & 0x2a == 0x20 (0x20) +__ulonglong 0xd8f0 & 0x2a == 0x20 (0x20) +int 0xd8f0 | 0x2a == -0x2706 (0xd8fa) +__uint 0xd8f0 | 0x2a == -0x2706 (0xd8fa) +char 0xfff0 | 0x2a == -0x6 (0xfffa) +__uchar 0xf0 | 0x2a == 0xfa (0xfa) +__longlong 0xd8f0 | 0x2a == -0x2706 (0xd8fa) +__ulonglong 0xd8f0 | 0x2a == -0x2706 (0xd8fa) +int 0xd8f0 << 0xc == 0x0 (0x0) +__uint 0xd8f0 << 0xc == 0x0 (0x0) +char 0xfff0 << 0xc == 0x0 (0x0) +__uchar 0xf0 << 0xc == 0x0 (0x0) +__longlong 0xd8f0 << 0xc == 0x0 (0x0) +__ulonglong 0xd8f0 << 0xc == 0x0 (0x0) +int 0xd8f0 >> 0xc == -0x3 (0xfffd) +__uint 0xd8f0 >> 0xc == 0xd (0xd) +char 0xfff0 >> 0xc == -0x1 (0xffff) +__uchar 0xf0 >> 0xc == 0x0 (0x0) +__longlong 0xd8f0 >> 0xc == -0x3 (0xfffd) +__ulonglong 0xd8f0 >> 0xc == -0x3 (0xfffd) +int 0xd8f0 + 0x2a == -0x26e6 (0xd91a) +__uint 0xd8f0 + 0x2a == -0x26e6 (0xd91a) +char 0xfff0 + 0x2a == 0x1a (0x1a) +__uchar 0xf0 + 0x2a == 0x1a (0x1a) +__longlong 0xd8f0 + 0x2a == -0x26e6 (0xd91a) +__ulonglong 0xd8f0 + 0x2a == -0x26e6 (0xd91a) +float 0xd8f0 + 0x2a == -0x26e6 (0xd91a) +int 0xd8f0 - 0x2a == -0x273a (0xd8c6) +__uint 0xd8f0 - 0x2a == -0x273a (0xd8c6) +char 0xfff0 - 0x2a == -0x3a (0xffc6) +__uchar 0xf0 - 0x2a == 0xc6 (0xc6) +__longlong 0xd8f0 - 0x2a == -0x273a (0xd8c6) +__ulonglong 0xd8f0 - 0x2a == -0x273a (0xd8c6) +float 0xd8f0 - 0x2a == -0x273a (0xd8c6) +int 0xd8f0 * 0x2a == -0x68a0 (0x9760) +__uint 0xd8f0 * 0x2a == -0x68a0 (0x9760) +char 0xfff0 * 0x2a == 0x60 (0x60) +__uchar 0xf0 * 0x2a == 0x60 (0x60) +__longlong 0xd8f0 * 0x2a == -0x68a0 (0x9760) +__ulonglong 0xd8f0 * 0x2a == -0x68a0 (0x9760) +float 0xd8f0 * 0x2a == -0x68a0 (0x9760) +int 0xd8f0 < 0x2a == 0x1 (0x1) +__uint 0xd8f0 < 0x2a == 0x0 (0x0) +char 0xfff0 < 0x2a == 0x1 (0x1) +__uchar 0xf0 < 0x2a == 0x0 (0x0) +__longlong 0xd8f0 < 0x2a == 0x1 (0x1) +__ulonglong 0xd8f0 < 0x2a == 0x0 (0x0) +float 0xd8f0 < 0x2a == 0x1 (0x1) +int 0xd8f0 > 0x2a == 0x0 (0x0) +__uint 0xd8f0 > 0x2a == 0x1 (0x1) +char 0xfff0 > 0x2a == 0x0 (0x0) +__uchar 0xf0 > 0x2a == 0x1 (0x1) +__longlong 0xd8f0 > 0x2a == 0x0 (0x0) +__ulonglong 0xd8f0 > 0x2a == 0x1 (0x1) +float 0xd8f0 > 0x2a == 0x0 (0x0) +int 0xd8f0 <= 0x2a == 0x1 (0x1) +__uint 0xd8f0 <= 0x2a == 0x0 (0x0) +char 0xfff0 <= 0x2a == 0x1 (0x1) +__uchar 0xf0 <= 0x2a == 0x0 (0x0) +__longlong 0xd8f0 <= 0x2a == 0x1 (0x1) +__ulonglong 0xd8f0 <= 0x2a == 0x0 (0x0) +float 0xd8f0 <= 0x2a == 0x1 (0x1) +int 0xd8f0 == 0x2a == 0x0 (0x0) +__uint 0xd8f0 == 0x2a == 0x0 (0x0) +char 0xfff0 == 0x2a == 0x0 (0x0) +__uchar 0xf0 == 0x2a == 0x0 (0x0) +__longlong 0xd8f0 == 0x2a == 0x0 (0x0) +__ulonglong 0xd8f0 == 0x2a == 0x0 (0x0) +float 0xd8f0 == 0x2a == 0x0 (0x0) +int 0xd8f0 != 0x2a == 0x1 (0x1) +__uint 0xd8f0 != 0x2a == 0x1 (0x1) +char 0xfff0 != 0x2a == 0x1 (0x1) +__uchar 0xf0 != 0x2a == 0x1 (0x1) +__longlong 0xd8f0 != 0x2a == 0x1 (0x1) +__ulonglong 0xd8f0 != 0x2a == 0x1 (0x1) +float 0xd8f0 != 0x2a == 0x1 (0x1) +int 0xd8f0 >= 0x2a == 0x0 (0x0) +__uint 0xd8f0 >= 0x2a == 0x1 (0x1) +char 0xfff0 >= 0x2a == 0x0 (0x0) +__uchar 0xf0 >= 0x2a == 0x1 (0x1) +__longlong 0xd8f0 >= 0x2a == 0x0 (0x0) +__ulonglong 0xd8f0 >= 0x2a == 0x1 (0x1) +float 0xd8f0 >= 0x2a == 0x0 (0x0) +int 0xd8f0 / 0x2a == -0xee (0xff12) +__uint 0xd8f0 / 0x2a == 0x52a (0x52a) +char 0xfff0 / 0x2a == 0x0 (0x0) +__uchar 0xf0 / 0x2a == 0x5 (0x5) +__longlong 0xd8f0 / 0x2a == -0xee (0xff12) +__ulonglong 0xd8f0 / 0x2a == 0x6098 (0x6098) +float 0xd8f0 / 0x2a == -0xee (0xff12) +int 0xd8f0 % 0x2a == -0x4 (0xfffc) +__uint 0xd8f0 % 0x2a == 0xc (0xc) +char 0xfff0 % 0x2a == -0x10 (0xfff0) +__uchar 0xf0 % 0x2a == 0x1e (0x1e) +__longlong 0xd8f0 % 0x2a == -0x4 (0xfffc) +__ulonglong 0xd8f0 % 0x2a == 0x0 (0x0) +0xd8f0 * 0x17 == 0x7d90 +0xd8f0 / 0x17 == -0x1b2 +0xd8f0 % 0x17 == -0x12 +int 0xd8f0 ^ 0x17 == -0x2719 (0xd8e7) +__uint 0xd8f0 ^ 0x17 == -0x2719 (0xd8e7) +char 0xfff0 ^ 0x17 == -0x19 (0xffe7) +__uchar 0xf0 ^ 0x17 == 0xe7 (0xe7) +__longlong 0xd8f0 ^ 0x17 == -0x2719 (0xd8e7) +__ulonglong 0xd8f0 ^ 0x17 == -0x2719 (0xd8e7) +int 0xd8f0 && 0x17 == 0x1 (0x1) +__uint 0xd8f0 && 0x17 == 0x1 (0x1) +char 0xfff0 && 0x17 == 0x1 (0x1) +__uchar 0xf0 && 0x17 == 0x1 (0x1) +__longlong 0xd8f0 && 0x17 == 0x1 (0x1) +__ulonglong 0xd8f0 && 0x17 == 0x1 (0x1) +int 0xd8f0 || 0x17 == 0x1 (0x1) +__uint 0xd8f0 || 0x17 == 0x1 (0x1) +char 0xfff0 || 0x17 == 0x1 (0x1) +__uchar 0xf0 || 0x17 == 0x1 (0x1) +__longlong 0xd8f0 || 0x17 == 0x1 (0x1) +__ulonglong 0xd8f0 || 0x17 == 0x1 (0x1) +int 0xd8f0 & 0x17 == 0x10 (0x10) +__uint 0xd8f0 & 0x17 == 0x10 (0x10) +char 0xfff0 & 0x17 == 0x10 (0x10) +__uchar 0xf0 & 0x17 == 0x10 (0x10) +__longlong 0xd8f0 & 0x17 == 0x10 (0x10) +__ulonglong 0xd8f0 & 0x17 == 0x10 (0x10) +int 0xd8f0 | 0x17 == -0x2709 (0xd8f7) +__uint 0xd8f0 | 0x17 == -0x2709 (0xd8f7) +char 0xfff0 | 0x17 == -0x9 (0xfff7) +__uchar 0xf0 | 0x17 == 0xf7 (0xf7) +__longlong 0xd8f0 | 0x17 == -0x2709 (0xd8f7) +__ulonglong 0xd8f0 | 0x17 == -0x2709 (0xd8f7) +int 0xd8f0 << 0xe == 0x0 (0x0) +__uint 0xd8f0 << 0xe == 0x0 (0x0) +char 0xfff0 << 0xe == 0x0 (0x0) +__uchar 0xf0 << 0xe == 0x0 (0x0) +__longlong 0xd8f0 << 0xe == 0x0 (0x0) +__ulonglong 0xd8f0 << 0xe == 0x0 (0x0) +int 0xd8f0 >> 0xe == -0x1 (0xffff) +__uint 0xd8f0 >> 0xe == 0x3 (0x3) +char 0xfff0 >> 0xe == -0x1 (0xffff) +__uchar 0xf0 >> 0xe == 0x0 (0x0) +__longlong 0xd8f0 >> 0xe == -0x1 (0xffff) +__ulonglong 0xd8f0 >> 0xe == -0x1 (0xffff) +int 0xd8f0 + 0x17 == -0x26f9 (0xd907) +__uint 0xd8f0 + 0x17 == -0x26f9 (0xd907) +char 0xfff0 + 0x17 == 0x7 (0x7) +__uchar 0xf0 + 0x17 == 0x7 (0x7) +__longlong 0xd8f0 + 0x17 == -0x26f9 (0xd907) +__ulonglong 0xd8f0 + 0x17 == -0x26f9 (0xd907) +float 0xd8f0 + 0x17 == -0x26f9 (0xd907) +int 0xd8f0 - 0x17 == -0x2727 (0xd8d9) +__uint 0xd8f0 - 0x17 == -0x2727 (0xd8d9) +char 0xfff0 - 0x17 == -0x27 (0xffd9) +__uchar 0xf0 - 0x17 == 0xd9 (0xd9) +__longlong 0xd8f0 - 0x17 == -0x2727 (0xd8d9) +__ulonglong 0xd8f0 - 0x17 == -0x2727 (0xd8d9) +float 0xd8f0 - 0x17 == -0x2727 (0xd8d9) +int 0xd8f0 * 0x17 == 0x7d90 (0x7d90) +__uint 0xd8f0 * 0x17 == 0x7d90 (0x7d90) +char 0xfff0 * 0x17 == -0x70 (0xff90) +__uchar 0xf0 * 0x17 == 0x90 (0x90) +__longlong 0xd8f0 * 0x17 == 0x7d90 (0x7d90) +__ulonglong 0xd8f0 * 0x17 == 0x7d90 (0x7d90) +float 0xd8f0 * 0x17 == 0x7d90 (0x7d90) +int 0xd8f0 < 0x17 == 0x1 (0x1) +__uint 0xd8f0 < 0x17 == 0x0 (0x0) +char 0xfff0 < 0x17 == 0x1 (0x1) +__uchar 0xf0 < 0x17 == 0x0 (0x0) +__longlong 0xd8f0 < 0x17 == 0x1 (0x1) +__ulonglong 0xd8f0 < 0x17 == 0x0 (0x0) +float 0xd8f0 < 0x17 == 0x1 (0x1) +int 0xd8f0 > 0x17 == 0x0 (0x0) +__uint 0xd8f0 > 0x17 == 0x1 (0x1) +char 0xfff0 > 0x17 == 0x0 (0x0) +__uchar 0xf0 > 0x17 == 0x1 (0x1) +__longlong 0xd8f0 > 0x17 == 0x0 (0x0) +__ulonglong 0xd8f0 > 0x17 == 0x1 (0x1) +float 0xd8f0 > 0x17 == 0x0 (0x0) +int 0xd8f0 <= 0x17 == 0x1 (0x1) +__uint 0xd8f0 <= 0x17 == 0x0 (0x0) +char 0xfff0 <= 0x17 == 0x1 (0x1) +__uchar 0xf0 <= 0x17 == 0x0 (0x0) +__longlong 0xd8f0 <= 0x17 == 0x1 (0x1) +__ulonglong 0xd8f0 <= 0x17 == 0x0 (0x0) +float 0xd8f0 <= 0x17 == 0x1 (0x1) +int 0xd8f0 == 0x17 == 0x0 (0x0) +__uint 0xd8f0 == 0x17 == 0x0 (0x0) +char 0xfff0 == 0x17 == 0x0 (0x0) +__uchar 0xf0 == 0x17 == 0x0 (0x0) +__longlong 0xd8f0 == 0x17 == 0x0 (0x0) +__ulonglong 0xd8f0 == 0x17 == 0x0 (0x0) +float 0xd8f0 == 0x17 == 0x0 (0x0) +int 0xd8f0 != 0x17 == 0x1 (0x1) +__uint 0xd8f0 != 0x17 == 0x1 (0x1) +char 0xfff0 != 0x17 == 0x1 (0x1) +__uchar 0xf0 != 0x17 == 0x1 (0x1) +__longlong 0xd8f0 != 0x17 == 0x1 (0x1) +__ulonglong 0xd8f0 != 0x17 == 0x1 (0x1) +float 0xd8f0 != 0x17 == 0x1 (0x1) +int 0xd8f0 >= 0x17 == 0x0 (0x0) +__uint 0xd8f0 >= 0x17 == 0x1 (0x1) +char 0xfff0 >= 0x17 == 0x0 (0x0) +__uchar 0xf0 >= 0x17 == 0x1 (0x1) +__longlong 0xd8f0 >= 0x17 == 0x0 (0x0) +__ulonglong 0xd8f0 >= 0x17 == 0x1 (0x1) +float 0xd8f0 >= 0x17 == 0x0 (0x0) +int 0xd8f0 / 0x17 == -0x1b2 (0xfe4e) +__uint 0xd8f0 / 0x17 == 0x96e (0x96e) +char 0xfff0 / 0x17 == 0x0 (0x0) +__uchar 0xf0 / 0x17 == 0xa (0xa) +__longlong 0xd8f0 / 0x17 == -0x1b2 (0xfe4e) +__ulonglong 0xd8f0 / 0x17 == 0x6279 (0x6279) +float 0xd8f0 / 0x17 == -0x1b2 (0xfe4e) +int 0xd8f0 % 0x17 == -0x12 (0xffee) +__uint 0xd8f0 % 0x17 == 0xe (0xe) +char 0xfff0 % 0x17 == -0x10 (0xfff0) +__uchar 0xf0 % 0x17 == 0xa (0xa) +__longlong 0xd8f0 % 0x17 == -0x12 (0xffee) +__ulonglong 0xd8f0 % 0x17 == 0x11 (0x11) +0xd8f0 * 0x7fff == 0x2710 +0xd8f0 / 0x7fff == 0x0 +0xd8f0 % 0x7fff == -0x2710 +int 0xd8f0 ^ 0x7fff == -0x58f1 (0xa70f) +__uint 0xd8f0 ^ 0x7fff == -0x58f1 (0xa70f) +char 0xfff0 ^ 0xffff == 0xf (0xf) +__uchar 0xf0 ^ 0xff == 0xf (0xf) +__longlong 0xd8f0 ^ 0x7fff == -0x58f1 (0xa70f) +__ulonglong 0xd8f0 ^ 0x7fff == -0x58f1 (0xa70f) +int 0xd8f0 && 0x7fff == 0x1 (0x1) +__uint 0xd8f0 && 0x7fff == 0x1 (0x1) +char 0xfff0 && 0xffff == 0x1 (0x1) +__uchar 0xf0 && 0xff == 0x1 (0x1) +__longlong 0xd8f0 && 0x7fff == 0x1 (0x1) +__ulonglong 0xd8f0 && 0x7fff == 0x1 (0x1) +int 0xd8f0 || 0x7fff == 0x1 (0x1) +__uint 0xd8f0 || 0x7fff == 0x1 (0x1) +char 0xfff0 || 0xffff == 0x1 (0x1) +__uchar 0xf0 || 0xff == 0x1 (0x1) +__longlong 0xd8f0 || 0x7fff == 0x1 (0x1) +__ulonglong 0xd8f0 || 0x7fff == 0x1 (0x1) +int 0xd8f0 & 0x7fff == 0x58f0 (0x58f0) +__uint 0xd8f0 & 0x7fff == 0x58f0 (0x58f0) +char 0xfff0 & 0xffff == -0x10 (0xfff0) +__uchar 0xf0 & 0xff == 0xf0 (0xf0) +__longlong 0xd8f0 & 0x7fff == 0x58f0 (0x58f0) +__ulonglong 0xd8f0 & 0x7fff == 0x58f0 (0x58f0) +int 0xd8f0 | 0x7fff == -0x1 (0xffff) +__uint 0xd8f0 | 0x7fff == -0x1 (0xffff) +char 0xfff0 | 0xffff == -0x1 (0xffff) +__uchar 0xf0 | 0xff == 0xff (0xff) +__longlong 0xd8f0 | 0x7fff == -0x1 (0xffff) +__ulonglong 0xd8f0 | 0x7fff == -0x1 (0xffff) +int 0xd8f0 << 0x10 == 0x0 (0x0) +__uint 0xd8f0 << 0x10 == 0x0 (0x0) +char 0xfff0 << 0x10 == 0x0 (0x0) +__uchar 0xf0 << 0x10 == 0x0 (0x0) +__longlong 0xd8f0 << 0x10 == 0x0 (0x0) +__ulonglong 0xd8f0 << 0x10 == 0x0 (0x0) +int 0xd8f0 >> 0x10 == -0x1 (0xffff) +__uint 0xd8f0 >> 0x10 == 0x0 (0x0) +char 0xfff0 >> 0x10 == -0x1 (0xffff) +__uchar 0xf0 >> 0x10 == 0x0 (0x0) +__longlong 0xd8f0 >> 0x10 == -0x1 (0xffff) +__ulonglong 0xd8f0 >> 0x10 == -0x1 (0xffff) +int 0xd8f0 + 0x7fff == 0x58ef (0x58ef) +__uint 0xd8f0 + 0x7fff == 0x58ef (0x58ef) +char 0xfff0 + 0xffff == -0x11 (0xffef) +__uchar 0xf0 + 0xff == 0xef (0xef) +__longlong 0xd8f0 + 0x7fff == 0x58ef (0x58ef) +__ulonglong 0xd8f0 + 0x7fff == 0x58ef (0x58ef) +float 0xd8f0 + 0x7fff == 0x58ef (0x58ef) +int 0xd8f0 - 0x7fff == 0x58f1 (0x58f1) +__uint 0xd8f0 - 0x7fff == 0x58f1 (0x58f1) +char 0xfff0 - 0xffff == -0xf (0xfff1) +__uchar 0xf0 - 0xff == 0xf1 (0xf1) +__longlong 0xd8f0 - 0x7fff == 0x58f1 (0x58f1) +__ulonglong 0xd8f0 - 0x7fff == 0x58f1 (0x58f1) +float 0xd8f0 - 0x7fff == 0x58f1 (0x58f1) +int 0xd8f0 * 0x7fff == 0x2710 (0x2710) +__uint 0xd8f0 * 0x7fff == 0x2710 (0x2710) +char 0xfff0 * 0xffff == 0x10 (0x10) +__uchar 0xf0 * 0xff == 0x10 (0x10) +__longlong 0xd8f0 * 0x7fff == 0x2710 (0x2710) +__ulonglong 0xd8f0 * 0x7fff == 0x2710 (0x2710) +float 0xd8f0 * 0x7fff == 0x2700 (0x2700) +int 0xd8f0 < 0x7fff == 0x1 (0x1) +__uint 0xd8f0 < 0x7fff == 0x0 (0x0) +char 0xfff0 < 0xffff == 0x1 (0x1) +__uchar 0xf0 < 0xff == 0x1 (0x1) +__longlong 0xd8f0 < 0x7fff == 0x1 (0x1) +__ulonglong 0xd8f0 < 0x7fff == 0x0 (0x0) +float 0xd8f0 < 0x7fff == 0x1 (0x1) +int 0xd8f0 > 0x7fff == 0x0 (0x0) +__uint 0xd8f0 > 0x7fff == 0x1 (0x1) +char 0xfff0 > 0xffff == 0x0 (0x0) +__uchar 0xf0 > 0xff == 0x0 (0x0) +__longlong 0xd8f0 > 0x7fff == 0x0 (0x0) +__ulonglong 0xd8f0 > 0x7fff == 0x1 (0x1) +float 0xd8f0 > 0x7fff == 0x0 (0x0) +int 0xd8f0 <= 0x7fff == 0x1 (0x1) +__uint 0xd8f0 <= 0x7fff == 0x0 (0x0) +char 0xfff0 <= 0xffff == 0x1 (0x1) +__uchar 0xf0 <= 0xff == 0x1 (0x1) +__longlong 0xd8f0 <= 0x7fff == 0x1 (0x1) +__ulonglong 0xd8f0 <= 0x7fff == 0x0 (0x0) +float 0xd8f0 <= 0x7fff == 0x1 (0x1) +int 0xd8f0 == 0x7fff == 0x0 (0x0) +__uint 0xd8f0 == 0x7fff == 0x0 (0x0) +char 0xfff0 == 0xffff == 0x0 (0x0) +__uchar 0xf0 == 0xff == 0x0 (0x0) +__longlong 0xd8f0 == 0x7fff == 0x0 (0x0) +__ulonglong 0xd8f0 == 0x7fff == 0x0 (0x0) +float 0xd8f0 == 0x7fff == 0x0 (0x0) +int 0xd8f0 != 0x7fff == 0x1 (0x1) +__uint 0xd8f0 != 0x7fff == 0x1 (0x1) +char 0xfff0 != 0xffff == 0x1 (0x1) +__uchar 0xf0 != 0xff == 0x1 (0x1) +__longlong 0xd8f0 != 0x7fff == 0x1 (0x1) +__ulonglong 0xd8f0 != 0x7fff == 0x1 (0x1) +float 0xd8f0 != 0x7fff == 0x1 (0x1) +int 0xd8f0 >= 0x7fff == 0x0 (0x0) +__uint 0xd8f0 >= 0x7fff == 0x1 (0x1) +char 0xfff0 >= 0xffff == 0x0 (0x0) +__uchar 0xf0 >= 0xff == 0x0 (0x0) +__longlong 0xd8f0 >= 0x7fff == 0x0 (0x0) +__ulonglong 0xd8f0 >= 0x7fff == 0x1 (0x1) +float 0xd8f0 >= 0x7fff == 0x0 (0x0) +int 0xd8f0 / 0x7fff == 0x0 (0x0) +__uint 0xd8f0 / 0x7fff == 0x1 (0x1) +char 0xfff0 / 0xffff == 0x10 (0x10) +__uchar 0xf0 / 0xff == 0x0 (0x0) +__longlong 0xd8f0 / 0x7fff == 0x0 (0x0) +__ulonglong 0xd8f0 / 0x7fff == 0x3 (0x3) +float 0xd8f0 / 0x7fff == 0x0 (0x0) +int 0xd8f0 % 0x7fff == -0x2710 (0xd8f0) +__uint 0xd8f0 % 0x7fff == 0x58f1 (0x58f1) +char 0xfff0 % 0xffff == 0x0 (0x0) +__uchar 0xf0 % 0xff == 0xf0 (0xf0) +__longlong 0xd8f0 % 0x7fff == -0x2710 (0xd8f0) +__ulonglong 0xd8f0 % 0x7fff == 0x58f3 (0x58f3) +0xd8f0 * 0x8000 == 0x0 +0xd8f0 / 0x8000 == 0x0 +0xd8f0 % 0x8000 == -0x2710 +int 0xd8f0 ^ 0x8000 == 0x58f0 (0x58f0) +__uint 0xd8f0 ^ 0x8000 == 0x58f0 (0x58f0) +char 0xfff0 ^ 0x0 == -0x10 (0xfff0) +__uchar 0xf0 ^ 0x0 == 0xf0 (0xf0) +__longlong 0xd8f0 ^ 0x8000 == 0x58f0 (0x58f0) +__ulonglong 0xd8f0 ^ 0x8000 == 0x58f0 (0x58f0) +int 0xd8f0 && 0x8000 == 0x1 (0x1) +__uint 0xd8f0 && 0x8000 == 0x1 (0x1) +char 0xfff0 && 0x0 == 0x0 (0x0) +__uchar 0xf0 && 0x0 == 0x0 (0x0) +__longlong 0xd8f0 && 0x8000 == 0x1 (0x1) +__ulonglong 0xd8f0 && 0x8000 == 0x1 (0x1) +int 0xd8f0 || 0x8000 == 0x1 (0x1) +__uint 0xd8f0 || 0x8000 == 0x1 (0x1) +char 0xfff0 || 0x0 == 0x1 (0x1) +__uchar 0xf0 || 0x0 == 0x1 (0x1) +__longlong 0xd8f0 || 0x8000 == 0x1 (0x1) +__ulonglong 0xd8f0 || 0x8000 == 0x1 (0x1) +int 0xd8f0 & 0x8000 == -0x8000 (0x8000) +__uint 0xd8f0 & 0x8000 == -0x8000 (0x8000) +char 0xfff0 & 0x0 == 0x0 (0x0) +__uchar 0xf0 & 0x0 == 0x0 (0x0) +__longlong 0xd8f0 & 0x8000 == -0x8000 (0x8000) +__ulonglong 0xd8f0 & 0x8000 == -0x8000 (0x8000) +int 0xd8f0 | 0x8000 == -0x2710 (0xd8f0) +__uint 0xd8f0 | 0x8000 == -0x2710 (0xd8f0) +char 0xfff0 | 0x0 == -0x10 (0xfff0) +__uchar 0xf0 | 0x0 == 0xf0 (0xf0) +__longlong 0xd8f0 | 0x8000 == -0x2710 (0xd8f0) +__ulonglong 0xd8f0 | 0x8000 == -0x2710 (0xd8f0) +int 0xd8f0 << 0x12 == 0x0 (0x0) +__uint 0xd8f0 << 0x12 == 0x0 (0x0) +char 0xfff0 << 0x12 == 0x0 (0x0) +__uchar 0xf0 << 0x12 == 0x0 (0x0) +__longlong 0xd8f0 << 0x12 == 0x0 (0x0) +__ulonglong 0xd8f0 << 0x12 == 0x0 (0x0) +int 0xd8f0 >> 0x12 == -0x1 (0xffff) +__uint 0xd8f0 >> 0x12 == 0x0 (0x0) +char 0xfff0 >> 0x12 == -0x1 (0xffff) +__uchar 0xf0 >> 0x12 == 0x0 (0x0) +__longlong 0xd8f0 >> 0x12 == -0x1 (0xffff) +__ulonglong 0xd8f0 >> 0x12 == 0x3fff (0x3fff) +int 0xd8f0 + 0x8000 == 0x58f0 (0x58f0) +__uint 0xd8f0 + 0x8000 == 0x58f0 (0x58f0) +char 0xfff0 + 0x0 == -0x10 (0xfff0) +__uchar 0xf0 + 0x0 == 0xf0 (0xf0) +__longlong 0xd8f0 + 0x8000 == 0x58f0 (0x58f0) +__ulonglong 0xd8f0 + 0x8000 == 0x58f0 (0x58f0) +float 0xd8f0 + 0x8000 == 0x58f0 (0x58f0) +int 0xd8f0 - 0x8000 == 0x58f0 (0x58f0) +__uint 0xd8f0 - 0x8000 == 0x58f0 (0x58f0) +char 0xfff0 - 0x0 == -0x10 (0xfff0) +__uchar 0xf0 - 0x0 == 0xf0 (0xf0) +__longlong 0xd8f0 - 0x8000 == 0x58f0 (0x58f0) +__ulonglong 0xd8f0 - 0x8000 == 0x58f0 (0x58f0) +float 0xd8f0 - 0x8000 == 0x58f0 (0x58f0) +int 0xd8f0 * 0x8000 == 0x0 (0x0) +__uint 0xd8f0 * 0x8000 == 0x0 (0x0) +char 0xfff0 * 0x0 == 0x0 (0x0) +__uchar 0xf0 * 0x0 == 0x0 (0x0) +__longlong 0xd8f0 * 0x8000 == 0x0 (0x0) +__ulonglong 0xd8f0 * 0x8000 == 0x0 (0x0) +float 0xd8f0 * 0x8000 == 0x0 (0x0) +int 0xd8f0 < 0x8000 == 0x0 (0x0) +__uint 0xd8f0 < 0x8000 == 0x0 (0x0) +char 0xfff0 < 0x0 == 0x1 (0x1) +__uchar 0xf0 < 0x0 == 0x0 (0x0) +__longlong 0xd8f0 < 0x8000 == 0x0 (0x0) +__ulonglong 0xd8f0 < 0x8000 == 0x0 (0x0) +float 0xd8f0 < 0x8000 == 0x0 (0x0) +int 0xd8f0 > 0x8000 == 0x1 (0x1) +__uint 0xd8f0 > 0x8000 == 0x1 (0x1) +char 0xfff0 > 0x0 == 0x0 (0x0) +__uchar 0xf0 > 0x0 == 0x1 (0x1) +__longlong 0xd8f0 > 0x8000 == 0x1 (0x1) +__ulonglong 0xd8f0 > 0x8000 == 0x1 (0x1) +float 0xd8f0 > 0x8000 == 0x1 (0x1) +int 0xd8f0 <= 0x8000 == 0x0 (0x0) +__uint 0xd8f0 <= 0x8000 == 0x0 (0x0) +char 0xfff0 <= 0x0 == 0x1 (0x1) +__uchar 0xf0 <= 0x0 == 0x0 (0x0) +__longlong 0xd8f0 <= 0x8000 == 0x0 (0x0) +__ulonglong 0xd8f0 <= 0x8000 == 0x0 (0x0) +float 0xd8f0 <= 0x8000 == 0x0 (0x0) +int 0xd8f0 == 0x8000 == 0x0 (0x0) +__uint 0xd8f0 == 0x8000 == 0x0 (0x0) +char 0xfff0 == 0x0 == 0x0 (0x0) +__uchar 0xf0 == 0x0 == 0x0 (0x0) +__longlong 0xd8f0 == 0x8000 == 0x0 (0x0) +__ulonglong 0xd8f0 == 0x8000 == 0x0 (0x0) +float 0xd8f0 == 0x8000 == 0x0 (0x0) +int 0xd8f0 != 0x8000 == 0x1 (0x1) +__uint 0xd8f0 != 0x8000 == 0x1 (0x1) +char 0xfff0 != 0x0 == 0x1 (0x1) +__uchar 0xf0 != 0x0 == 0x1 (0x1) +__longlong 0xd8f0 != 0x8000 == 0x1 (0x1) +__ulonglong 0xd8f0 != 0x8000 == 0x1 (0x1) +float 0xd8f0 != 0x8000 == 0x1 (0x1) +int 0xd8f0 >= 0x8000 == 0x1 (0x1) +__uint 0xd8f0 >= 0x8000 == 0x1 (0x1) +char 0xfff0 >= 0x0 == 0x0 (0x0) +__uchar 0xf0 >= 0x0 == 0x1 (0x1) +__longlong 0xd8f0 >= 0x8000 == 0x1 (0x1) +__ulonglong 0xd8f0 >= 0x8000 == 0x1 (0x1) +float 0xd8f0 >= 0x8000 == 0x1 (0x1) +int 0xd8f0 / 0x8000 == 0x0 (0x0) +__uint 0xd8f0 / 0x8000 == 0x1 (0x1) +__longlong 0xd8f0 / 0x8000 == 0x0 (0x0) +__ulonglong 0xd8f0 / 0x8000 == 0x1 (0x1) +float 0xd8f0 / 0x8000 == 0x0 (0x0) +int 0xd8f0 % 0x8000 == -0x2710 (0xd8f0) +__uint 0xd8f0 % 0x8000 == 0x58f0 (0x58f0) +__longlong 0xd8f0 % 0x8000 == -0x2710 (0xd8f0) +__ulonglong 0xd8f0 % 0x8000 == 0x58f0 (0x58f0) +0xd8f0 * 0x3e8 == 0x6980 +0xd8f0 / 0x3e8 == -0xa +0xd8f0 % 0x3e8 == 0x0 +int 0xd8f0 ^ 0x3e8 == -0x24e8 (0xdb18) +__uint 0xd8f0 ^ 0x3e8 == -0x24e8 (0xdb18) +char 0xfff0 ^ 0xffe8 == 0x18 (0x18) +__uchar 0xf0 ^ 0xe8 == 0x18 (0x18) +__longlong 0xd8f0 ^ 0x3e8 == -0x24e8 (0xdb18) +__ulonglong 0xd8f0 ^ 0x3e8 == -0x24e8 (0xdb18) +int 0xd8f0 && 0x3e8 == 0x1 (0x1) +__uint 0xd8f0 && 0x3e8 == 0x1 (0x1) +char 0xfff0 && 0xffe8 == 0x1 (0x1) +__uchar 0xf0 && 0xe8 == 0x1 (0x1) +__longlong 0xd8f0 && 0x3e8 == 0x1 (0x1) +__ulonglong 0xd8f0 && 0x3e8 == 0x1 (0x1) +int 0xd8f0 || 0x3e8 == 0x1 (0x1) +__uint 0xd8f0 || 0x3e8 == 0x1 (0x1) +char 0xfff0 || 0xffe8 == 0x1 (0x1) +__uchar 0xf0 || 0xe8 == 0x1 (0x1) +__longlong 0xd8f0 || 0x3e8 == 0x1 (0x1) +__ulonglong 0xd8f0 || 0x3e8 == 0x1 (0x1) +int 0xd8f0 & 0x3e8 == 0xe0 (0xe0) +__uint 0xd8f0 & 0x3e8 == 0xe0 (0xe0) +char 0xfff0 & 0xffe8 == -0x20 (0xffe0) +__uchar 0xf0 & 0xe8 == 0xe0 (0xe0) +__longlong 0xd8f0 & 0x3e8 == 0xe0 (0xe0) +__ulonglong 0xd8f0 & 0x3e8 == 0xe0 (0xe0) +int 0xd8f0 | 0x3e8 == -0x2408 (0xdbf8) +__uint 0xd8f0 | 0x3e8 == -0x2408 (0xdbf8) +char 0xfff0 | 0xffe8 == -0x8 (0xfff8) +__uchar 0xf0 | 0xe8 == 0xf8 (0xf8) +__longlong 0xd8f0 | 0x3e8 == -0x2408 (0xdbf8) +__ulonglong 0xd8f0 | 0x3e8 == -0x2408 (0xdbf8) +int 0xd8f0 << 0x14 == 0x0 (0x0) +__uint 0xd8f0 << 0x14 == 0x0 (0x0) +char 0xfff0 << 0x14 == 0x0 (0x0) +__uchar 0xf0 << 0x14 == 0x0 (0x0) +__longlong 0xd8f0 << 0x14 == 0x0 (0x0) +__ulonglong 0xd8f0 << 0x14 == 0x0 (0x0) +int 0xd8f0 >> 0x14 == -0x1 (0xffff) +__uint 0xd8f0 >> 0x14 == 0x0 (0x0) +char 0xfff0 >> 0x14 == -0x1 (0xffff) +__uchar 0xf0 >> 0x14 == 0x0 (0x0) +__longlong 0xd8f0 >> 0x14 == -0x1 (0xffff) +__ulonglong 0xd8f0 >> 0x14 == 0xfff (0xfff) +int 0xd8f0 + 0x3e8 == -0x2328 (0xdcd8) +__uint 0xd8f0 + 0x3e8 == -0x2328 (0xdcd8) +char 0xfff0 + 0xffe8 == -0x28 (0xffd8) +__uchar 0xf0 + 0xe8 == 0xd8 (0xd8) +__longlong 0xd8f0 + 0x3e8 == -0x2328 (0xdcd8) +__ulonglong 0xd8f0 + 0x3e8 == -0x2328 (0xdcd8) +float 0xd8f0 + 0x3e8 == -0x2328 (0xdcd8) +int 0xd8f0 - 0x3e8 == -0x2af8 (0xd508) +__uint 0xd8f0 - 0x3e8 == -0x2af8 (0xd508) +char 0xfff0 - 0xffe8 == 0x8 (0x8) +__uchar 0xf0 - 0xe8 == 0x8 (0x8) +__longlong 0xd8f0 - 0x3e8 == -0x2af8 (0xd508) +__ulonglong 0xd8f0 - 0x3e8 == -0x2af8 (0xd508) +float 0xd8f0 - 0x3e8 == -0x2af8 (0xd508) +int 0xd8f0 * 0x3e8 == 0x6980 (0x6980) +__uint 0xd8f0 * 0x3e8 == 0x6980 (0x6980) +char 0xfff0 * 0xffe8 == -0x80 (0xff80) +__uchar 0xf0 * 0xe8 == 0x80 (0x80) +__longlong 0xd8f0 * 0x3e8 == 0x6980 (0x6980) +__ulonglong 0xd8f0 * 0x3e8 == 0x6980 (0x6980) +float 0xd8f0 * 0x3e8 == 0x6980 (0x6980) +int 0xd8f0 < 0x3e8 == 0x1 (0x1) +__uint 0xd8f0 < 0x3e8 == 0x0 (0x0) +char 0xfff0 < 0xffe8 == 0x0 (0x0) +__uchar 0xf0 < 0xe8 == 0x0 (0x0) +__longlong 0xd8f0 < 0x3e8 == 0x1 (0x1) +__ulonglong 0xd8f0 < 0x3e8 == 0x0 (0x0) +float 0xd8f0 < 0x3e8 == 0x1 (0x1) +int 0xd8f0 > 0x3e8 == 0x0 (0x0) +__uint 0xd8f0 > 0x3e8 == 0x1 (0x1) +char 0xfff0 > 0xffe8 == 0x1 (0x1) +__uchar 0xf0 > 0xe8 == 0x1 (0x1) +__longlong 0xd8f0 > 0x3e8 == 0x0 (0x0) +__ulonglong 0xd8f0 > 0x3e8 == 0x1 (0x1) +float 0xd8f0 > 0x3e8 == 0x0 (0x0) +int 0xd8f0 <= 0x3e8 == 0x1 (0x1) +__uint 0xd8f0 <= 0x3e8 == 0x0 (0x0) +char 0xfff0 <= 0xffe8 == 0x0 (0x0) +__uchar 0xf0 <= 0xe8 == 0x0 (0x0) +__longlong 0xd8f0 <= 0x3e8 == 0x1 (0x1) +__ulonglong 0xd8f0 <= 0x3e8 == 0x0 (0x0) +float 0xd8f0 <= 0x3e8 == 0x1 (0x1) +int 0xd8f0 == 0x3e8 == 0x0 (0x0) +__uint 0xd8f0 == 0x3e8 == 0x0 (0x0) +char 0xfff0 == 0xffe8 == 0x0 (0x0) +__uchar 0xf0 == 0xe8 == 0x0 (0x0) +__longlong 0xd8f0 == 0x3e8 == 0x0 (0x0) +__ulonglong 0xd8f0 == 0x3e8 == 0x0 (0x0) +float 0xd8f0 == 0x3e8 == 0x0 (0x0) +int 0xd8f0 != 0x3e8 == 0x1 (0x1) +__uint 0xd8f0 != 0x3e8 == 0x1 (0x1) +char 0xfff0 != 0xffe8 == 0x1 (0x1) +__uchar 0xf0 != 0xe8 == 0x1 (0x1) +__longlong 0xd8f0 != 0x3e8 == 0x1 (0x1) +__ulonglong 0xd8f0 != 0x3e8 == 0x1 (0x1) +float 0xd8f0 != 0x3e8 == 0x1 (0x1) +int 0xd8f0 >= 0x3e8 == 0x0 (0x0) +__uint 0xd8f0 >= 0x3e8 == 0x1 (0x1) +char 0xfff0 >= 0xffe8 == 0x1 (0x1) +__uchar 0xf0 >= 0xe8 == 0x1 (0x1) +__longlong 0xd8f0 >= 0x3e8 == 0x0 (0x0) +__ulonglong 0xd8f0 >= 0x3e8 == 0x1 (0x1) +float 0xd8f0 >= 0x3e8 == 0x0 (0x0) +int 0xd8f0 / 0x3e8 == -0xa (0xfff6) +__uint 0xd8f0 / 0x3e8 == 0x37 (0x37) +char 0xfff0 / 0xffe8 == 0x0 (0x0) +__uchar 0xf0 / 0xe8 == 0x1 (0x1) +__longlong 0xd8f0 / 0x3e8 == -0xa (0xfff6) +__ulonglong 0xd8f0 / 0x3e8 == -0x76d3 (0x892d) +float 0xd8f0 / 0x3e8 == -0xa (0xfff6) +int 0xd8f0 % 0x3e8 == 0x0 (0x0) +__uint 0xd8f0 % 0x3e8 == 0x218 (0x218) +char 0xfff0 % 0xffe8 == -0x10 (0xfff0) +__uchar 0xf0 % 0xe8 == 0x8 (0x8) +__longlong 0xd8f0 % 0x3e8 == 0x0 (0x0) +__ulonglong 0xd8f0 % 0x3e8 == 0x128 (0x128) +0xd8f0 * 0x2710 == 0x1f00 +0xd8f0 / 0x2710 == -0x1 +0xd8f0 % 0x2710 == 0x0 +int 0xd8f0 ^ 0x2710 == -0x20 (0xffe0) +__uint 0xd8f0 ^ 0x2710 == -0x20 (0xffe0) +char 0xfff0 ^ 0x10 == -0x20 (0xffe0) +__uchar 0xf0 ^ 0x10 == 0xe0 (0xe0) +__longlong 0xd8f0 ^ 0x2710 == -0x20 (0xffe0) +__ulonglong 0xd8f0 ^ 0x2710 == -0x20 (0xffe0) +int 0xd8f0 && 0x2710 == 0x1 (0x1) +__uint 0xd8f0 && 0x2710 == 0x1 (0x1) +char 0xfff0 && 0x10 == 0x1 (0x1) +__uchar 0xf0 && 0x10 == 0x1 (0x1) +__longlong 0xd8f0 && 0x2710 == 0x1 (0x1) +__ulonglong 0xd8f0 && 0x2710 == 0x1 (0x1) +int 0xd8f0 || 0x2710 == 0x1 (0x1) +__uint 0xd8f0 || 0x2710 == 0x1 (0x1) +char 0xfff0 || 0x10 == 0x1 (0x1) +__uchar 0xf0 || 0x10 == 0x1 (0x1) +__longlong 0xd8f0 || 0x2710 == 0x1 (0x1) +__ulonglong 0xd8f0 || 0x2710 == 0x1 (0x1) +int 0xd8f0 & 0x2710 == 0x10 (0x10) +__uint 0xd8f0 & 0x2710 == 0x10 (0x10) +char 0xfff0 & 0x10 == 0x10 (0x10) +__uchar 0xf0 & 0x10 == 0x10 (0x10) +__longlong 0xd8f0 & 0x2710 == 0x10 (0x10) +__ulonglong 0xd8f0 & 0x2710 == 0x10 (0x10) +int 0xd8f0 | 0x2710 == -0x10 (0xfff0) +__uint 0xd8f0 | 0x2710 == -0x10 (0xfff0) +char 0xfff0 | 0x10 == -0x10 (0xfff0) +__uchar 0xf0 | 0x10 == 0xf0 (0xf0) +__longlong 0xd8f0 | 0x2710 == -0x10 (0xfff0) +__ulonglong 0xd8f0 | 0x2710 == -0x10 (0xfff0) +int 0xd8f0 << 0x16 == 0x0 (0x0) +__uint 0xd8f0 << 0x16 == 0x0 (0x0) +char 0xfff0 << 0x16 == 0x0 (0x0) +__uchar 0xf0 << 0x16 == 0x0 (0x0) +__longlong 0xd8f0 << 0x16 == 0x0 (0x0) +__ulonglong 0xd8f0 << 0x16 == 0x0 (0x0) +int 0xd8f0 >> 0x16 == -0x1 (0xffff) +__uint 0xd8f0 >> 0x16 == 0x0 (0x0) +char 0xfff0 >> 0x16 == -0x1 (0xffff) +__uchar 0xf0 >> 0x16 == 0x0 (0x0) +__longlong 0xd8f0 >> 0x16 == -0x1 (0xffff) +__ulonglong 0xd8f0 >> 0x16 == 0x3ff (0x3ff) +int 0xd8f0 + 0x2710 == 0x0 (0x0) +__uint 0xd8f0 + 0x2710 == 0x0 (0x0) +char 0xfff0 + 0x10 == 0x0 (0x0) +__uchar 0xf0 + 0x10 == 0x0 (0x0) +__longlong 0xd8f0 + 0x2710 == 0x0 (0x0) +__ulonglong 0xd8f0 + 0x2710 == 0x0 (0x0) +float 0xd8f0 + 0x2710 == 0x0 (0x0) +int 0xd8f0 - 0x2710 == -0x4e20 (0xb1e0) +__uint 0xd8f0 - 0x2710 == -0x4e20 (0xb1e0) +char 0xfff0 - 0x10 == -0x20 (0xffe0) +__uchar 0xf0 - 0x10 == 0xe0 (0xe0) +__longlong 0xd8f0 - 0x2710 == -0x4e20 (0xb1e0) +__ulonglong 0xd8f0 - 0x2710 == -0x4e20 (0xb1e0) +float 0xd8f0 - 0x2710 == -0x4e20 (0xb1e0) +int 0xd8f0 * 0x2710 == 0x1f00 (0x1f00) +__uint 0xd8f0 * 0x2710 == 0x1f00 (0x1f00) +char 0xfff0 * 0x10 == 0x0 (0x0) +__uchar 0xf0 * 0x10 == 0x0 (0x0) +__longlong 0xd8f0 * 0x2710 == 0x1f00 (0x1f00) +__ulonglong 0xd8f0 * 0x2710 == 0x1f00 (0x1f00) +float 0xd8f0 * 0x2710 == 0x1f00 (0x1f00) +int 0xd8f0 < 0x2710 == 0x1 (0x1) +__uint 0xd8f0 < 0x2710 == 0x0 (0x0) +char 0xfff0 < 0x10 == 0x1 (0x1) +__uchar 0xf0 < 0x10 == 0x0 (0x0) +__longlong 0xd8f0 < 0x2710 == 0x1 (0x1) +__ulonglong 0xd8f0 < 0x2710 == 0x0 (0x0) +float 0xd8f0 < 0x2710 == 0x1 (0x1) +int 0xd8f0 > 0x2710 == 0x0 (0x0) +__uint 0xd8f0 > 0x2710 == 0x1 (0x1) +char 0xfff0 > 0x10 == 0x0 (0x0) +__uchar 0xf0 > 0x10 == 0x1 (0x1) +__longlong 0xd8f0 > 0x2710 == 0x0 (0x0) +__ulonglong 0xd8f0 > 0x2710 == 0x1 (0x1) +float 0xd8f0 > 0x2710 == 0x0 (0x0) +int 0xd8f0 <= 0x2710 == 0x1 (0x1) +__uint 0xd8f0 <= 0x2710 == 0x0 (0x0) +char 0xfff0 <= 0x10 == 0x1 (0x1) +__uchar 0xf0 <= 0x10 == 0x0 (0x0) +__longlong 0xd8f0 <= 0x2710 == 0x1 (0x1) +__ulonglong 0xd8f0 <= 0x2710 == 0x0 (0x0) +float 0xd8f0 <= 0x2710 == 0x1 (0x1) +int 0xd8f0 == 0x2710 == 0x0 (0x0) +__uint 0xd8f0 == 0x2710 == 0x0 (0x0) +char 0xfff0 == 0x10 == 0x0 (0x0) +__uchar 0xf0 == 0x10 == 0x0 (0x0) +__longlong 0xd8f0 == 0x2710 == 0x0 (0x0) +__ulonglong 0xd8f0 == 0x2710 == 0x0 (0x0) +float 0xd8f0 == 0x2710 == 0x0 (0x0) +int 0xd8f0 != 0x2710 == 0x1 (0x1) +__uint 0xd8f0 != 0x2710 == 0x1 (0x1) +char 0xfff0 != 0x10 == 0x1 (0x1) +__uchar 0xf0 != 0x10 == 0x1 (0x1) +__longlong 0xd8f0 != 0x2710 == 0x1 (0x1) +__ulonglong 0xd8f0 != 0x2710 == 0x1 (0x1) +float 0xd8f0 != 0x2710 == 0x1 (0x1) +int 0xd8f0 >= 0x2710 == 0x0 (0x0) +__uint 0xd8f0 >= 0x2710 == 0x1 (0x1) +char 0xfff0 >= 0x10 == 0x0 (0x0) +__uchar 0xf0 >= 0x10 == 0x1 (0x1) +__longlong 0xd8f0 >= 0x2710 == 0x0 (0x0) +__ulonglong 0xd8f0 >= 0x2710 == 0x1 (0x1) +float 0xd8f0 >= 0x2710 == 0x0 (0x0) +int 0xd8f0 / 0x2710 == -0x1 (0xffff) +__uint 0xd8f0 / 0x2710 == 0x5 (0x5) +char 0xfff0 / 0x10 == -0x1 (0xffff) +__uchar 0xf0 / 0x10 == 0xf (0xf) +__longlong 0xd8f0 / 0x2710 == -0x1 (0xffff) +__ulonglong 0xd8f0 / 0x2710 == -0x7249 (0x8db7) +float 0xd8f0 / 0x2710 == -0x1 (0xffff) +int 0xd8f0 % 0x2710 == 0x0 (0x0) +__uint 0xd8f0 % 0x2710 == 0x15a0 (0x15a0) +char 0xfff0 % 0x10 == 0x0 (0x0) +__uchar 0xf0 % 0x10 == 0x0 (0x0) +__longlong 0xd8f0 % 0x2710 == 0x0 (0x0) +__ulonglong 0xd8f0 % 0x2710 == 0x1c80 (0x1c80) +int xor42-0x2710 xor42 -0x2726 +__uint xor42-0x2710 xor42 -0x2726 +char xor42-0x10 xor42 -0x26 +__uchar xor420xf0 xor42 0xda +__longlong xor42-0x2710 xor42 -0x2726 +__ulonglong xor42-0x2710 xor42 -0x2726 +int land1-0x2710 land1 0x1 +__uint land1-0x2710 land1 0x1 +char land1-0x10 land1 0x1 +__uchar land10xf0 land1 0x1 +__longlong land1-0x2710 land1 0x1 +__ulonglong land1-0x2710 land1 0x1 +int lor1-0x2710 lor1 0x1 +__uint lor1-0x2710 lor1 0x1 +char lor1-0x10 lor1 0x1 +__uchar lor10xf0 lor1 0x1 +__longlong lor1-0x2710 lor1 0x1 +__ulonglong lor1-0x2710 lor1 0x1 +int and42-0x2710 and42 0x20 +__uint and42-0x2710 and42 0x20 +char and42-0x10 and42 0x20 +__uchar and420xf0 and42 0x20 +__longlong and42-0x2710 and42 0x20 +__ulonglong and42-0x2710 and42 0x20 +int or42-0x2710 or42 -0x2706 +__uint or42-0x2710 or42 -0x2706 +char or42-0x10 or42 -0x6 +__uchar or420xf0 or42 0xfa +__longlong or42-0x2710 or42 -0x2706 +__ulonglong or42-0x2710 or42 -0x2706 +int shl5-0x2710 shl5 0x1e00 +__uint shl5-0x2710 shl5 0x1e00 +char shl5-0x10 shl5 0x0 +__uchar shl50xf0 shl5 0x0 +__longlong shl5-0x2710 shl5 0x1e00 +__ulonglong shl5-0x2710 shl5 0x1e00 +int shr5-0x2710 shr5 -0x139 +__uint shr5-0x2710 shr5 0x6c7 +char shr5-0x10 shr5 -0x1 +__uchar shr50xf0 shr5 0x7 +__longlong shr5-0x2710 shr5 -0x139 +__ulonglong shr5-0x2710 shr5 -0x139 +int add42-0x2710 add42 -0x26e6 +__uint add42-0x2710 add42 -0x26e6 +char add42-0x10 add42 0x1a +__uchar add420xf0 add42 0x1a +__longlong add42-0x2710 add42 -0x26e6 +__ulonglong add42-0x2710 add42 -0x26e6 +float add42-0x2710 add42 -0x26e6 +int sub42-0x2710 sub42 -0x273a +__uint sub42-0x2710 sub42 -0x273a +char sub42-0x10 sub42 -0x3a +__uchar sub420xf0 sub42 0xc6 +__longlong sub42-0x2710 sub42 -0x273a +__ulonglong sub42-0x2710 sub42 -0x273a +float sub42-0x2710 sub42 -0x273a +int mul42-0x2710 mul42 -0x68a0 +__uint mul42-0x2710 mul42 -0x68a0 +char mul42-0x10 mul42 0x60 +__uchar mul420xf0 mul42 0x60 +__longlong mul42-0x2710 mul42 -0x68a0 +__ulonglong mul42-0x2710 mul42 -0x68a0 +float mul42-0x2710 mul42 -0x68a0 +int lt42-0x2710 lt42 0x1 +__uint lt42-0x2710 lt42 0x0 +char lt42-0x10 lt42 0x1 +__uchar lt420xf0 lt42 0x0 +__longlong lt42-0x2710 lt42 0x1 +__ulonglong lt42-0x2710 lt42 0x0 +float lt42-0x2710 lt42 0x1 +int gt42-0x2710 gt42 0x0 +__uint gt42-0x2710 gt42 0x1 +char gt42-0x10 gt42 0x0 +__uchar gt420xf0 gt42 0x1 +__longlong gt42-0x2710 gt42 0x0 +__ulonglong gt42-0x2710 gt42 0x1 +float gt42-0x2710 gt42 0x0 +int le42-0x2710 le42 0x1 +__uint le42-0x2710 le42 0x0 +char le42-0x10 le42 0x1 +__uchar le420xf0 le42 0x0 +__longlong le42-0x2710 le42 0x1 +__ulonglong le42-0x2710 le42 0x0 +float le42-0x2710 le42 0x1 +int eq42-0x2710 eq42 0x0 +__uint eq42-0x2710 eq42 0x0 +char eq42-0x10 eq42 0x0 +__uchar eq420xf0 eq42 0x0 +__longlong eq42-0x2710 eq42 0x0 +__ulonglong eq42-0x2710 eq42 0x0 +float eq42-0x2710 eq42 0x0 +int ne42-0x2710 ne42 0x1 +__uint ne42-0x2710 ne42 0x1 +char ne42-0x10 ne42 0x1 +__uchar ne420xf0 ne42 0x1 +__longlong ne42-0x2710 ne42 0x1 +__ulonglong ne42-0x2710 ne42 0x1 +float ne42-0x2710 ne42 0x1 +int ge42-0x2710 ge42 0x0 +__uint ge42-0x2710 ge42 0x1 +char ge42-0x10 ge42 0x0 +__uchar ge420xf0 ge42 0x1 +__longlong ge42-0x2710 ge42 0x0 +__ulonglong ge42-0x2710 ge42 0x1 +float ge42-0x2710 ge42 0x0 +int div42-0x2710 div42 -0xee +__uint div42-0x2710 div42 0x52a +char div42-0x10 div42 0x0 +__uchar div420xf0 div42 0x5 +__longlong div42-0x2710 div42 -0xee +__ulonglong div42-0x2710 div42 0x6098 +float div42-0x2710 div42 -0xee +int mod23-0x2710 mod23 -0x12 +__uint mod23-0x2710 mod23 0xe +char mod23-0x10 mod23 -0x10 +__uchar mod230xf0 mod23 0xa +__longlong mod23-0x2710 mod23 -0x12 +__ulonglong mod23-0x2710 mod23 0x11 +cast from char 0x0 to char 0x0 +cast from char 0x0 to __uchar 0x0 +cast from char 0x0 to __int 0x0 +cast from char 0x0 to __uint 0x0 +cast from char 0x0 to float 0x0 +cast from char 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from char 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __uchar 0x0 to char 0x0 +cast from __uchar 0x0 to __uchar 0x0 +cast from __uchar 0x0 to __int 0x0 +cast from __uchar 0x0 to __uint 0x0 +cast from __uchar 0x0 to float 0x0 +cast from __uchar 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __uchar 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __int 0x0 to char 0x0 +cast from __int 0x0 to __uchar 0x0 +cast from __int 0x0 to __int 0x0 +cast from __int 0x0 to __uint 0x0 +cast from __int 0x0 to float 0x0 +cast from __int 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __int 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __uint 0x0 to char 0x0 +cast from __uint 0x0 to __uchar 0x0 +cast from __uint 0x0 to __int 0x0 +cast from __uint 0x0 to __uint 0x0 +cast from __uint 0x0 to float 0x0 +cast from __uint 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __uint 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from float 0x0 to char 0x0 +cast from float 0x0 to __uchar 0x0 +cast from float 0x0 to __int 0x0 +cast from float 0x0 to __uint 0x0 +cast from float 0x0 to float 0x0 +cast from float 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from float 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __longlong 0x0 to char 0x0 +cast from __longlong 0x0 to __uchar 0x0 +cast from __longlong 0x0 to __int 0x0 +cast from __longlong 0x0 to __uint 0x0 +cast from __longlong 0x0 to float 0x0 +cast from __longlong 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __longlong 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __ulonglong 0x0 to char 0x0 +cast from __ulonglong 0x0 to __uchar 0x0 +cast from __ulonglong 0x0 to __int 0x0 +cast from __ulonglong 0x0 to __uint 0x0 +cast from __ulonglong 0x0 to float 0x0 +cast from __ulonglong 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __ulonglong 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from char -0x1 to char -0x1 +cast from char 0xffff to __uchar 0xff +cast from char -0x1 to __int -0x1 +cast from char 0xffff to __uint 0xffff +cast from char -0x1 to float -0x1 +cast from char 0xffffffff (0xffffffff) + to __longlong 0xffffffff (0xffffffff) + +cast from char 0xffffffff (0xffffffff) + to __ulonglong 0xffffffff (0xffffffff) + +cast from __uchar 0xff to char -0x1 +cast from __uchar 0xff to __uchar 0xff +cast from __uchar 0xff to __int 0xff +cast from __uchar 0xff to __uint 0xff +cast from __uchar 0xff to float 0xff +cast from __uchar 0xff (0xff) + to __longlong 0xff (0xff) + +cast from __uchar 0xff (0xff) + to __ulonglong 0xff (0xff) + +cast from __int -0x1 to char -0x1 +cast from __int 0xffff to __uchar 0xff +cast from __int -0x1 to __int -0x1 +cast from __int 0xffff to __uint 0xffff +cast from __int -0x1 to float -0x1 +cast from __int 0xffffffff (0xffffffff) + to __longlong 0xffffffff (0xffffffff) + +cast from __int 0xffffffff (0xffffffff) + to __ulonglong 0xffffffff (0xffffffff) + +cast from __uint -0x1 to char -0x1 +cast from __uint 0xffff to __uchar 0xff +cast from __uint -0x1 to __int -0x1 +cast from __uint 0xffff to __uint 0xffff +cast from __uint -0x1 to float -0x1 +cast from __uint 0xffff (0xffff) + to __longlong 0xffff (0xffff) + +cast from __uint 0xffff (0xffff) + to __ulonglong 0xffff (0xffff) + +cast from float -0x1 to char -0x1 +cast from float 0xffff to __uchar 0xff +cast from float -0x1 to __int -0x1 +cast from float 0xffff to __uint 0xffff +cast from float -0x1 to float -0x1 +cast from float 0xffffffff (0xffffffff) + to __longlong 0xffffffff (0xffffffff) + +cast from float 0xffffffff (0xffffffff) + to __ulonglong 0xffffffff (0xffffffff) + +cast from __longlong -0x1 to char -0x1 +cast from __longlong 0xffff to __uchar 0xff +cast from __longlong -0x1 to __int -0x1 +cast from __longlong 0xffff to __uint 0xffff +cast from __longlong -0x1 to float -0x1 +cast from __longlong 0xffffffff (0xffffffff) + to __longlong 0xffffffff (0xffffffff) + +cast from __longlong 0xffffffff (0xffffffff) + to __ulonglong 0xffffffff (0xffffffff) + +cast from __ulonglong -0x1 to char -0x1 +cast from __ulonglong 0xffff to __uchar 0xff +cast from __ulonglong -0x1 to __int -0x1 +cast from __ulonglong 0xffff to __uint 0xffff +cast from __ulonglong -0x1 to float 0x0 +cast from __ulonglong 0xffffffff (0xffffffff) + to __longlong 0xffffffff (0xffffffff) + +cast from __ulonglong 0xffffffff (0xffffffff) + to __ulonglong 0xffffffff (0xffffffff) + +cast from char 0x1 to char 0x1 +cast from char 0x1 to __uchar 0x1 +cast from char 0x1 to __int 0x1 +cast from char 0x1 to __uint 0x1 +cast from char 0x1 to float 0x1 +cast from char 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from char 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __uchar 0x1 to char 0x1 +cast from __uchar 0x1 to __uchar 0x1 +cast from __uchar 0x1 to __int 0x1 +cast from __uchar 0x1 to __uint 0x1 +cast from __uchar 0x1 to float 0x1 +cast from __uchar 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __uchar 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __int 0x1 to char 0x1 +cast from __int 0x1 to __uchar 0x1 +cast from __int 0x1 to __int 0x1 +cast from __int 0x1 to __uint 0x1 +cast from __int 0x1 to float 0x1 +cast from __int 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __int 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __uint 0x1 to char 0x1 +cast from __uint 0x1 to __uchar 0x1 +cast from __uint 0x1 to __int 0x1 +cast from __uint 0x1 to __uint 0x1 +cast from __uint 0x1 to float 0x1 +cast from __uint 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __uint 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from float 0x1 to char 0x1 +cast from float 0x1 to __uchar 0x1 +cast from float 0x1 to __int 0x1 +cast from float 0x1 to __uint 0x1 +cast from float 0x1 to float 0x1 +cast from float 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from float 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __longlong 0x1 to char 0x1 +cast from __longlong 0x1 to __uchar 0x1 +cast from __longlong 0x1 to __int 0x1 +cast from __longlong 0x1 to __uint 0x1 +cast from __longlong 0x1 to float 0x1 +cast from __longlong 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __longlong 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __ulonglong 0x1 to char 0x1 +cast from __ulonglong 0x1 to __uchar 0x1 +cast from __ulonglong 0x1 to __int 0x1 +cast from __ulonglong 0x1 to __uint 0x1 +cast from __ulonglong 0x1 to float 0x1 +cast from __ulonglong 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __ulonglong 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from char 0x2 to char 0x2 +cast from char 0x2 to __uchar 0x2 +cast from char 0x2 to __int 0x2 +cast from char 0x2 to __uint 0x2 +cast from char 0x2 to float 0x2 +cast from char 0x2 (0x2) + to __longlong 0x2 (0x2) + +cast from char 0x2 (0x2) + to __ulonglong 0x2 (0x2) + +cast from __uchar 0x2 to char 0x2 +cast from __uchar 0x2 to __uchar 0x2 +cast from __uchar 0x2 to __int 0x2 +cast from __uchar 0x2 to __uint 0x2 +cast from __uchar 0x2 to float 0x2 +cast from __uchar 0x2 (0x2) + to __longlong 0x2 (0x2) + +cast from __uchar 0x2 (0x2) + to __ulonglong 0x2 (0x2) + +cast from __int 0x2 to char 0x2 +cast from __int 0x2 to __uchar 0x2 +cast from __int 0x2 to __int 0x2 +cast from __int 0x2 to __uint 0x2 +cast from __int 0x2 to float 0x2 +cast from __int 0x2 (0x2) + to __longlong 0x2 (0x2) + +cast from __int 0x2 (0x2) + to __ulonglong 0x2 (0x2) + +cast from __uint 0x2 to char 0x2 +cast from __uint 0x2 to __uchar 0x2 +cast from __uint 0x2 to __int 0x2 +cast from __uint 0x2 to __uint 0x2 +cast from __uint 0x2 to float 0x2 +cast from __uint 0x2 (0x2) + to __longlong 0x2 (0x2) + +cast from __uint 0x2 (0x2) + to __ulonglong 0x2 (0x2) + +cast from float 0x2 to char 0x2 +cast from float 0x2 to __uchar 0x2 +cast from float 0x2 to __int 0x2 +cast from float 0x2 to __uint 0x2 +cast from float 0x2 to float 0x2 +cast from float 0x2 (0x2) + to __longlong 0x2 (0x2) + +cast from float 0x2 (0x2) + to __ulonglong 0x2 (0x2) + +cast from __longlong 0x2 to char 0x2 +cast from __longlong 0x2 to __uchar 0x2 +cast from __longlong 0x2 to __int 0x2 +cast from __longlong 0x2 to __uint 0x2 +cast from __longlong 0x2 to float 0x2 +cast from __longlong 0x2 (0x2) + to __longlong 0x2 (0x2) + +cast from __longlong 0x2 (0x2) + to __ulonglong 0x2 (0x2) + +cast from __ulonglong 0x2 to char 0x2 +cast from __ulonglong 0x2 to __uchar 0x2 +cast from __ulonglong 0x2 to __int 0x2 +cast from __ulonglong 0x2 to __uint 0x2 +cast from __ulonglong 0x2 to float 0x2 +cast from __ulonglong 0x2 (0x2) + to __longlong 0x2 (0x2) + +cast from __ulonglong 0x2 (0x2) + to __ulonglong 0x2 (0x2) + +cast from char -0x2 to char -0x2 +cast from char 0xfffe to __uchar 0xfe +cast from char -0x2 to __int -0x2 +cast from char 0xfffe to __uint 0xfffe +cast from char -0x2 to float -0x2 +cast from char 0xfffffffe (0xfffffffe) + to __longlong 0xfffffffe (0xfffffffe) + +cast from char 0xfffffffe (0xfffffffe) + to __ulonglong 0xfffffffe (0xfffffffe) + +cast from __uchar 0xfe to char -0x2 +cast from __uchar 0xfe to __uchar 0xfe +cast from __uchar 0xfe to __int 0xfe +cast from __uchar 0xfe to __uint 0xfe +cast from __uchar 0xfe to float 0xfe +cast from __uchar 0xfe (0xfe) + to __longlong 0xfe (0xfe) + +cast from __uchar 0xfe (0xfe) + to __ulonglong 0xfe (0xfe) + +cast from __int -0x2 to char -0x2 +cast from __int 0xfffe to __uchar 0xfe +cast from __int -0x2 to __int -0x2 +cast from __int 0xfffe to __uint 0xfffe +cast from __int -0x2 to float -0x2 +cast from __int 0xfffffffe (0xfffffffe) + to __longlong 0xfffffffe (0xfffffffe) + +cast from __int 0xfffffffe (0xfffffffe) + to __ulonglong 0xfffffffe (0xfffffffe) + +cast from __uint -0x2 to char -0x2 +cast from __uint 0xfffe to __uchar 0xfe +cast from __uint -0x2 to __int -0x2 +cast from __uint 0xfffe to __uint 0xfffe +cast from __uint -0x2 to float -0x2 +cast from __uint 0xfffe (0xfffe) + to __longlong 0xfffe (0xfffe) + +cast from __uint 0xfffe (0xfffe) + to __ulonglong 0xfffe (0xfffe) + +cast from float -0x2 to char -0x2 +cast from float 0xfffe to __uchar 0xfe +cast from float -0x2 to __int -0x2 +cast from float 0xfffe to __uint 0xfffe +cast from float -0x2 to float -0x2 +cast from float 0xfffffffe (0xfffffffe) + to __longlong 0xfffffffe (0xfffffffe) + +cast from float 0xfffffffe (0xfffffffe) + to __ulonglong 0xfffffffe (0xfffffffe) + +cast from __longlong -0x2 to char -0x2 +cast from __longlong 0xfffe to __uchar 0xfe +cast from __longlong -0x2 to __int -0x2 +cast from __longlong 0xfffe to __uint 0xfffe +cast from __longlong -0x2 to float -0x2 +cast from __longlong 0xfffffffe (0xfffffffe) + to __longlong 0xfffffffe (0xfffffffe) + +cast from __longlong 0xfffffffe (0xfffffffe) + to __ulonglong 0xfffffffe (0xfffffffe) + +cast from __ulonglong -0x2 to char -0x2 +cast from __ulonglong 0xfffe to __uchar 0xfe +cast from __ulonglong -0x2 to __int -0x2 +cast from __ulonglong 0xfffe to __uint 0xfffe +cast from __ulonglong -0x2 to float 0x0 +cast from __ulonglong 0xfffffffe (0xfffffffe) + to __longlong 0xfffffffe (0xfffffffe) + +cast from __ulonglong 0xfffffffe (0xfffffffe) + to __ulonglong 0xfffffffe (0xfffffffe) + +cast from char 0x4 to char 0x4 +cast from char 0x4 to __uchar 0x4 +cast from char 0x4 to __int 0x4 +cast from char 0x4 to __uint 0x4 +cast from char 0x4 to float 0x4 +cast from char 0x4 (0x4) + to __longlong 0x4 (0x4) + +cast from char 0x4 (0x4) + to __ulonglong 0x4 (0x4) + +cast from __uchar 0x4 to char 0x4 +cast from __uchar 0x4 to __uchar 0x4 +cast from __uchar 0x4 to __int 0x4 +cast from __uchar 0x4 to __uint 0x4 +cast from __uchar 0x4 to float 0x4 +cast from __uchar 0x4 (0x4) + to __longlong 0x4 (0x4) + +cast from __uchar 0x4 (0x4) + to __ulonglong 0x4 (0x4) + +cast from __int 0x4 to char 0x4 +cast from __int 0x4 to __uchar 0x4 +cast from __int 0x4 to __int 0x4 +cast from __int 0x4 to __uint 0x4 +cast from __int 0x4 to float 0x4 +cast from __int 0x4 (0x4) + to __longlong 0x4 (0x4) + +cast from __int 0x4 (0x4) + to __ulonglong 0x4 (0x4) + +cast from __uint 0x4 to char 0x4 +cast from __uint 0x4 to __uchar 0x4 +cast from __uint 0x4 to __int 0x4 +cast from __uint 0x4 to __uint 0x4 +cast from __uint 0x4 to float 0x4 +cast from __uint 0x4 (0x4) + to __longlong 0x4 (0x4) + +cast from __uint 0x4 (0x4) + to __ulonglong 0x4 (0x4) + +cast from float 0x4 to char 0x4 +cast from float 0x4 to __uchar 0x4 +cast from float 0x4 to __int 0x4 +cast from float 0x4 to __uint 0x4 +cast from float 0x4 to float 0x4 +cast from float 0x4 (0x4) + to __longlong 0x4 (0x4) + +cast from float 0x4 (0x4) + to __ulonglong 0x4 (0x4) + +cast from __longlong 0x4 to char 0x4 +cast from __longlong 0x4 to __uchar 0x4 +cast from __longlong 0x4 to __int 0x4 +cast from __longlong 0x4 to __uint 0x4 +cast from __longlong 0x4 to float 0x4 +cast from __longlong 0x4 (0x4) + to __longlong 0x4 (0x4) + +cast from __longlong 0x4 (0x4) + to __ulonglong 0x4 (0x4) + +cast from __ulonglong 0x4 to char 0x4 +cast from __ulonglong 0x4 to __uchar 0x4 +cast from __ulonglong 0x4 to __int 0x4 +cast from __ulonglong 0x4 to __uint 0x4 +cast from __ulonglong 0x4 to float 0x4 +cast from __ulonglong 0x4 (0x4) + to __longlong 0x4 (0x4) + +cast from __ulonglong 0x4 (0x4) + to __ulonglong 0x4 (0x4) + +cast from char -0x4 to char -0x4 +cast from char 0xfffc to __uchar 0xfc +cast from char -0x4 to __int -0x4 +cast from char 0xfffc to __uint 0xfffc +cast from char -0x4 to float -0x4 +cast from char 0xfffffffc (0xfffffffc) + to __longlong 0xfffffffc (0xfffffffc) + +cast from char 0xfffffffc (0xfffffffc) + to __ulonglong 0xfffffffc (0xfffffffc) + +cast from __uchar 0xfc to char -0x4 +cast from __uchar 0xfc to __uchar 0xfc +cast from __uchar 0xfc to __int 0xfc +cast from __uchar 0xfc to __uint 0xfc +cast from __uchar 0xfc to float 0xfc +cast from __uchar 0xfc (0xfc) + to __longlong 0xfc (0xfc) + +cast from __uchar 0xfc (0xfc) + to __ulonglong 0xfc (0xfc) + +cast from __int -0x4 to char -0x4 +cast from __int 0xfffc to __uchar 0xfc +cast from __int -0x4 to __int -0x4 +cast from __int 0xfffc to __uint 0xfffc +cast from __int -0x4 to float -0x4 +cast from __int 0xfffffffc (0xfffffffc) + to __longlong 0xfffffffc (0xfffffffc) + +cast from __int 0xfffffffc (0xfffffffc) + to __ulonglong 0xfffffffc (0xfffffffc) + +cast from __uint -0x4 to char -0x4 +cast from __uint 0xfffc to __uchar 0xfc +cast from __uint -0x4 to __int -0x4 +cast from __uint 0xfffc to __uint 0xfffc +cast from __uint -0x4 to float -0x4 +cast from __uint 0xfffc (0xfffc) + to __longlong 0xfffc (0xfffc) + +cast from __uint 0xfffc (0xfffc) + to __ulonglong 0xfffc (0xfffc) + +cast from float -0x4 to char -0x4 +cast from float 0xfffc to __uchar 0xfc +cast from float -0x4 to __int -0x4 +cast from float 0xfffc to __uint 0xfffc +cast from float -0x4 to float -0x4 +cast from float 0xfffffffc (0xfffffffc) + to __longlong 0xfffffffc (0xfffffffc) + +cast from float 0xfffffffc (0xfffffffc) + to __ulonglong 0xfffffffc (0xfffffffc) + +cast from __longlong -0x4 to char -0x4 +cast from __longlong 0xfffc to __uchar 0xfc +cast from __longlong -0x4 to __int -0x4 +cast from __longlong 0xfffc to __uint 0xfffc +cast from __longlong -0x4 to float -0x4 +cast from __longlong 0xfffffffc (0xfffffffc) + to __longlong 0xfffffffc (0xfffffffc) + +cast from __longlong 0xfffffffc (0xfffffffc) + to __ulonglong 0xfffffffc (0xfffffffc) + +cast from __ulonglong -0x4 to char -0x4 +cast from __ulonglong 0xfffc to __uchar 0xfc +cast from __ulonglong -0x4 to __int -0x4 +cast from __ulonglong 0xfffc to __uint 0xfffc +cast from __ulonglong -0x4 to float 0x0 +cast from __ulonglong 0xfffffffc (0xfffffffc) + to __longlong 0xfffffffc (0xfffffffc) + +cast from __ulonglong 0xfffffffc (0xfffffffc) + to __ulonglong 0xfffffffc (0xfffffffc) + +cast from char 0xa to char 0xa +cast from char 0xa to __uchar 0xa +cast from char 0xa to __int 0xa +cast from char 0xa to __uint 0xa +cast from char 0xa to float 0xa +cast from char 0xa (0xa) + to __longlong 0xa (0xa) + +cast from char 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from __uchar 0xa to char 0xa +cast from __uchar 0xa to __uchar 0xa +cast from __uchar 0xa to __int 0xa +cast from __uchar 0xa to __uint 0xa +cast from __uchar 0xa to float 0xa +cast from __uchar 0xa (0xa) + to __longlong 0xa (0xa) + +cast from __uchar 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from __int 0xa to char 0xa +cast from __int 0xa to __uchar 0xa +cast from __int 0xa to __int 0xa +cast from __int 0xa to __uint 0xa +cast from __int 0xa to float 0xa +cast from __int 0xa (0xa) + to __longlong 0xa (0xa) + +cast from __int 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from __uint 0xa to char 0xa +cast from __uint 0xa to __uchar 0xa +cast from __uint 0xa to __int 0xa +cast from __uint 0xa to __uint 0xa +cast from __uint 0xa to float 0xa +cast from __uint 0xa (0xa) + to __longlong 0xa (0xa) + +cast from __uint 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from float 0xa to char 0xa +cast from float 0xa to __uchar 0xa +cast from float 0xa to __int 0xa +cast from float 0xa to __uint 0xa +cast from float 0xa to float 0xa +cast from float 0xa (0xa) + to __longlong 0xa (0xa) + +cast from float 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from __longlong 0xa to char 0xa +cast from __longlong 0xa to __uchar 0xa +cast from __longlong 0xa to __int 0xa +cast from __longlong 0xa to __uint 0xa +cast from __longlong 0xa to float 0xa +cast from __longlong 0xa (0xa) + to __longlong 0xa (0xa) + +cast from __longlong 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from __ulonglong 0xa to char 0xa +cast from __ulonglong 0xa to __uchar 0xa +cast from __ulonglong 0xa to __int 0xa +cast from __ulonglong 0xa to __uint 0xa +cast from __ulonglong 0xa to float 0xa +cast from __ulonglong 0xa (0xa) + to __longlong 0xa (0xa) + +cast from __ulonglong 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from char -0xa to char -0xa +cast from char 0xfff6 to __uchar 0xf6 +cast from char -0xa to __int -0xa +cast from char 0xfff6 to __uint 0xfff6 +cast from char -0xa to float -0xa +cast from char 0xfffffff6 (0xfffffff6) + to __longlong 0xfffffff6 (0xfffffff6) + +cast from char 0xfffffff6 (0xfffffff6) + to __ulonglong 0xfffffff6 (0xfffffff6) + +cast from __uchar 0xf6 to char -0xa +cast from __uchar 0xf6 to __uchar 0xf6 +cast from __uchar 0xf6 to __int 0xf6 +cast from __uchar 0xf6 to __uint 0xf6 +cast from __uchar 0xf6 to float 0xf6 +cast from __uchar 0xf6 (0xf6) + to __longlong 0xf6 (0xf6) + +cast from __uchar 0xf6 (0xf6) + to __ulonglong 0xf6 (0xf6) + +cast from __int -0xa to char -0xa +cast from __int 0xfff6 to __uchar 0xf6 +cast from __int -0xa to __int -0xa +cast from __int 0xfff6 to __uint 0xfff6 +cast from __int -0xa to float -0xa +cast from __int 0xfffffff6 (0xfffffff6) + to __longlong 0xfffffff6 (0xfffffff6) + +cast from __int 0xfffffff6 (0xfffffff6) + to __ulonglong 0xfffffff6 (0xfffffff6) + +cast from __uint -0xa to char -0xa +cast from __uint 0xfff6 to __uchar 0xf6 +cast from __uint -0xa to __int -0xa +cast from __uint 0xfff6 to __uint 0xfff6 +cast from __uint -0xa to float -0xa +cast from __uint 0xfff6 (0xfff6) + to __longlong 0xfff6 (0xfff6) + +cast from __uint 0xfff6 (0xfff6) + to __ulonglong 0xfff6 (0xfff6) + +cast from float -0xa to char -0xa +cast from float 0xfff6 to __uchar 0xf6 +cast from float -0xa to __int -0xa +cast from float 0xfff6 to __uint 0xfff6 +cast from float -0xa to float -0xa +cast from float 0xfffffff6 (0xfffffff6) + to __longlong 0xfffffff6 (0xfffffff6) + +cast from float 0xfffffff6 (0xfffffff6) + to __ulonglong 0xfffffff6 (0xfffffff6) + +cast from __longlong -0xa to char -0xa +cast from __longlong 0xfff6 to __uchar 0xf6 +cast from __longlong -0xa to __int -0xa +cast from __longlong 0xfff6 to __uint 0xfff6 +cast from __longlong -0xa to float -0xa +cast from __longlong 0xfffffff6 (0xfffffff6) + to __longlong 0xfffffff6 (0xfffffff6) + +cast from __longlong 0xfffffff6 (0xfffffff6) + to __ulonglong 0xfffffff6 (0xfffffff6) + +cast from __ulonglong -0xa to char -0xa +cast from __ulonglong 0xfff6 to __uchar 0xf6 +cast from __ulonglong -0xa to __int -0xa +cast from __ulonglong 0xfff6 to __uint 0xfff6 +cast from __ulonglong -0xa to float 0x0 +cast from __ulonglong 0xfffffff6 (0xfffffff6) + to __longlong 0xfffffff6 (0xfffffff6) + +cast from __ulonglong 0xfffffff6 (0xfffffff6) + to __ulonglong 0xfffffff6 (0xfffffff6) + +cast from char 0x5 to char 0x5 +cast from char 0x5 to __uchar 0x5 +cast from char 0x5 to __int 0x5 +cast from char 0x5 to __uint 0x5 +cast from char 0x5 to float 0x5 +cast from char 0x5 (0x5) + to __longlong 0x5 (0x5) + +cast from char 0x5 (0x5) + to __ulonglong 0x5 (0x5) + +cast from __uchar 0x5 to char 0x5 +cast from __uchar 0x5 to __uchar 0x5 +cast from __uchar 0x5 to __int 0x5 +cast from __uchar 0x5 to __uint 0x5 +cast from __uchar 0x5 to float 0x5 +cast from __uchar 0x5 (0x5) + to __longlong 0x5 (0x5) + +cast from __uchar 0x5 (0x5) + to __ulonglong 0x5 (0x5) + +cast from __int 0x5 to char 0x5 +cast from __int 0x5 to __uchar 0x5 +cast from __int 0x5 to __int 0x5 +cast from __int 0x5 to __uint 0x5 +cast from __int 0x5 to float 0x5 +cast from __int 0x5 (0x5) + to __longlong 0x5 (0x5) + +cast from __int 0x5 (0x5) + to __ulonglong 0x5 (0x5) + +cast from __uint 0x5 to char 0x5 +cast from __uint 0x5 to __uchar 0x5 +cast from __uint 0x5 to __int 0x5 +cast from __uint 0x5 to __uint 0x5 +cast from __uint 0x5 to float 0x5 +cast from __uint 0x5 (0x5) + to __longlong 0x5 (0x5) + +cast from __uint 0x5 (0x5) + to __ulonglong 0x5 (0x5) + +cast from float 0x5 to char 0x5 +cast from float 0x5 to __uchar 0x5 +cast from float 0x5 to __int 0x5 +cast from float 0x5 to __uint 0x5 +cast from float 0x5 to float 0x5 +cast from float 0x5 (0x5) + to __longlong 0x5 (0x5) + +cast from float 0x5 (0x5) + to __ulonglong 0x5 (0x5) + +cast from __longlong 0x5 to char 0x5 +cast from __longlong 0x5 to __uchar 0x5 +cast from __longlong 0x5 to __int 0x5 +cast from __longlong 0x5 to __uint 0x5 +cast from __longlong 0x5 to float 0x5 +cast from __longlong 0x5 (0x5) + to __longlong 0x5 (0x5) + +cast from __longlong 0x5 (0x5) + to __ulonglong 0x5 (0x5) + +cast from __ulonglong 0x5 to char 0x5 +cast from __ulonglong 0x5 to __uchar 0x5 +cast from __ulonglong 0x5 to __int 0x5 +cast from __ulonglong 0x5 to __uint 0x5 +cast from __ulonglong 0x5 to float 0x5 +cast from __ulonglong 0x5 (0x5) + to __longlong 0x5 (0x5) + +cast from __ulonglong 0x5 (0x5) + to __ulonglong 0x5 (0x5) + +cast from char 0x7 to char 0x7 +cast from char 0x7 to __uchar 0x7 +cast from char 0x7 to __int 0x7 +cast from char 0x7 to __uint 0x7 +cast from char 0x7 to float 0x7 +cast from char 0x7 (0x7) + to __longlong 0x7 (0x7) + +cast from char 0x7 (0x7) + to __ulonglong 0x7 (0x7) + +cast from __uchar 0x7 to char 0x7 +cast from __uchar 0x7 to __uchar 0x7 +cast from __uchar 0x7 to __int 0x7 +cast from __uchar 0x7 to __uint 0x7 +cast from __uchar 0x7 to float 0x7 +cast from __uchar 0x7 (0x7) + to __longlong 0x7 (0x7) + +cast from __uchar 0x7 (0x7) + to __ulonglong 0x7 (0x7) + +cast from __int 0x7 to char 0x7 +cast from __int 0x7 to __uchar 0x7 +cast from __int 0x7 to __int 0x7 +cast from __int 0x7 to __uint 0x7 +cast from __int 0x7 to float 0x7 +cast from __int 0x7 (0x7) + to __longlong 0x7 (0x7) + +cast from __int 0x7 (0x7) + to __ulonglong 0x7 (0x7) + +cast from __uint 0x7 to char 0x7 +cast from __uint 0x7 to __uchar 0x7 +cast from __uint 0x7 to __int 0x7 +cast from __uint 0x7 to __uint 0x7 +cast from __uint 0x7 to float 0x7 +cast from __uint 0x7 (0x7) + to __longlong 0x7 (0x7) + +cast from __uint 0x7 (0x7) + to __ulonglong 0x7 (0x7) + +cast from float 0x7 to char 0x7 +cast from float 0x7 to __uchar 0x7 +cast from float 0x7 to __int 0x7 +cast from float 0x7 to __uint 0x7 +cast from float 0x7 to float 0x7 +cast from float 0x7 (0x7) + to __longlong 0x7 (0x7) + +cast from float 0x7 (0x7) + to __ulonglong 0x7 (0x7) + +cast from __longlong 0x7 to char 0x7 +cast from __longlong 0x7 to __uchar 0x7 +cast from __longlong 0x7 to __int 0x7 +cast from __longlong 0x7 to __uint 0x7 +cast from __longlong 0x7 to float 0x7 +cast from __longlong 0x7 (0x7) + to __longlong 0x7 (0x7) + +cast from __longlong 0x7 (0x7) + to __ulonglong 0x7 (0x7) + +cast from __ulonglong 0x7 to char 0x7 +cast from __ulonglong 0x7 to __uchar 0x7 +cast from __ulonglong 0x7 to __int 0x7 +cast from __ulonglong 0x7 to __uint 0x7 +cast from __ulonglong 0x7 to float 0x7 +cast from __ulonglong 0x7 (0x7) + to __longlong 0x7 (0x7) + +cast from __ulonglong 0x7 (0x7) + to __ulonglong 0x7 (0x7) + +cast from char 0x2a to char 0x2a +cast from char 0x2a to __uchar 0x2a +cast from char 0x2a to __int 0x2a +cast from char 0x2a to __uint 0x2a +cast from char 0x2a to float 0x2a +cast from char 0x2a (0x2a) + to __longlong 0x2a (0x2a) + +cast from char 0x2a (0x2a) + to __ulonglong 0x2a (0x2a) + +cast from __uchar 0x2a to char 0x2a +cast from __uchar 0x2a to __uchar 0x2a +cast from __uchar 0x2a to __int 0x2a +cast from __uchar 0x2a to __uint 0x2a +cast from __uchar 0x2a to float 0x2a +cast from __uchar 0x2a (0x2a) + to __longlong 0x2a (0x2a) + +cast from __uchar 0x2a (0x2a) + to __ulonglong 0x2a (0x2a) + +cast from __int 0x2a to char 0x2a +cast from __int 0x2a to __uchar 0x2a +cast from __int 0x2a to __int 0x2a +cast from __int 0x2a to __uint 0x2a +cast from __int 0x2a to float 0x2a +cast from __int 0x2a (0x2a) + to __longlong 0x2a (0x2a) + +cast from __int 0x2a (0x2a) + to __ulonglong 0x2a (0x2a) + +cast from __uint 0x2a to char 0x2a +cast from __uint 0x2a to __uchar 0x2a +cast from __uint 0x2a to __int 0x2a +cast from __uint 0x2a to __uint 0x2a +cast from __uint 0x2a to float 0x2a +cast from __uint 0x2a (0x2a) + to __longlong 0x2a (0x2a) + +cast from __uint 0x2a (0x2a) + to __ulonglong 0x2a (0x2a) + +cast from float 0x2a to char 0x2a +cast from float 0x2a to __uchar 0x2a +cast from float 0x2a to __int 0x2a +cast from float 0x2a to __uint 0x2a +cast from float 0x2a to float 0x2a +cast from float 0x2a (0x2a) + to __longlong 0x2a (0x2a) + +cast from float 0x2a (0x2a) + to __ulonglong 0x2a (0x2a) + +cast from __longlong 0x2a to char 0x2a +cast from __longlong 0x2a to __uchar 0x2a +cast from __longlong 0x2a to __int 0x2a +cast from __longlong 0x2a to __uint 0x2a +cast from __longlong 0x2a to float 0x2a +cast from __longlong 0x2a (0x2a) + to __longlong 0x2a (0x2a) + +cast from __longlong 0x2a (0x2a) + to __ulonglong 0x2a (0x2a) + +cast from __ulonglong 0x2a to char 0x2a +cast from __ulonglong 0x2a to __uchar 0x2a +cast from __ulonglong 0x2a to __int 0x2a +cast from __ulonglong 0x2a to __uint 0x2a +cast from __ulonglong 0x2a to float 0x2a +cast from __ulonglong 0x2a (0x2a) + to __longlong 0x2a (0x2a) + +cast from __ulonglong 0x2a (0x2a) + to __ulonglong 0x2a (0x2a) + +cast from char 0x17 to char 0x17 +cast from char 0x17 to __uchar 0x17 +cast from char 0x17 to __int 0x17 +cast from char 0x17 to __uint 0x17 +cast from char 0x17 to float 0x17 +cast from char 0x17 (0x17) + to __longlong 0x17 (0x17) + +cast from char 0x17 (0x17) + to __ulonglong 0x17 (0x17) + +cast from __uchar 0x17 to char 0x17 +cast from __uchar 0x17 to __uchar 0x17 +cast from __uchar 0x17 to __int 0x17 +cast from __uchar 0x17 to __uint 0x17 +cast from __uchar 0x17 to float 0x17 +cast from __uchar 0x17 (0x17) + to __longlong 0x17 (0x17) + +cast from __uchar 0x17 (0x17) + to __ulonglong 0x17 (0x17) + +cast from __int 0x17 to char 0x17 +cast from __int 0x17 to __uchar 0x17 +cast from __int 0x17 to __int 0x17 +cast from __int 0x17 to __uint 0x17 +cast from __int 0x17 to float 0x17 +cast from __int 0x17 (0x17) + to __longlong 0x17 (0x17) + +cast from __int 0x17 (0x17) + to __ulonglong 0x17 (0x17) + +cast from __uint 0x17 to char 0x17 +cast from __uint 0x17 to __uchar 0x17 +cast from __uint 0x17 to __int 0x17 +cast from __uint 0x17 to __uint 0x17 +cast from __uint 0x17 to float 0x17 +cast from __uint 0x17 (0x17) + to __longlong 0x17 (0x17) + +cast from __uint 0x17 (0x17) + to __ulonglong 0x17 (0x17) + +cast from float 0x17 to char 0x17 +cast from float 0x17 to __uchar 0x17 +cast from float 0x17 to __int 0x17 +cast from float 0x17 to __uint 0x17 +cast from float 0x17 to float 0x17 +cast from float 0x17 (0x17) + to __longlong 0x17 (0x17) + +cast from float 0x17 (0x17) + to __ulonglong 0x17 (0x17) + +cast from __longlong 0x17 to char 0x17 +cast from __longlong 0x17 to __uchar 0x17 +cast from __longlong 0x17 to __int 0x17 +cast from __longlong 0x17 to __uint 0x17 +cast from __longlong 0x17 to float 0x17 +cast from __longlong 0x17 (0x17) + to __longlong 0x17 (0x17) + +cast from __longlong 0x17 (0x17) + to __ulonglong 0x17 (0x17) + +cast from __ulonglong 0x17 to char 0x17 +cast from __ulonglong 0x17 to __uchar 0x17 +cast from __ulonglong 0x17 to __int 0x17 +cast from __ulonglong 0x17 to __uint 0x17 +cast from __ulonglong 0x17 to float 0x17 +cast from __ulonglong 0x17 (0x17) + to __longlong 0x17 (0x17) + +cast from __ulonglong 0x17 (0x17) + to __ulonglong 0x17 (0x17) + +cast from char -0x1 to char -0x1 +cast from char 0xffff to __uchar 0xff +cast from char -0x1 to __int -0x1 +cast from char 0xffff to __uint 0xffff +cast from char -0x1 to float -0x1 +cast from char 0xffffffff (0xffffffff) + to __longlong 0xffffffff (0xffffffff) + +cast from char 0xffffffff (0xffffffff) + to __ulonglong 0xffffffff (0xffffffff) + +cast from __uchar 0xff to char -0x1 +cast from __uchar 0xff to __uchar 0xff +cast from __uchar 0xff to __int 0xff +cast from __uchar 0xff to __uint 0xff +cast from __uchar 0xff to float 0xff +cast from __uchar 0xff (0xff) + to __longlong 0xff (0xff) + +cast from __uchar 0xff (0xff) + to __ulonglong 0xff (0xff) + +cast from __int 0x7fff to char -0x1 +cast from __int 0x7fff to __uchar 0xff +cast from __int 0x7fff to __int 0x7fff +cast from __int 0x7fff to __uint 0x7fff +cast from __int 0x7fff to float 0x7fff +cast from __int 0x7fff (0x7fff) + to __longlong 0x7fff (0x7fff) + +cast from __int 0x7fff (0x7fff) + to __ulonglong 0x7fff (0x7fff) + +cast from __uint 0x7fff to char -0x1 +cast from __uint 0x7fff to __uchar 0xff +cast from __uint 0x7fff to __int 0x7fff +cast from __uint 0x7fff to __uint 0x7fff +cast from __uint 0x7fff to float 0x7fff +cast from __uint 0x7fff (0x7fff) + to __longlong 0x7fff (0x7fff) + +cast from __uint 0x7fff (0x7fff) + to __ulonglong 0x7fff (0x7fff) + +cast from float 0x7fff to char -0x1 +cast from float 0x7fff to __uchar 0xff +cast from float 0x7fff to __int 0x7fff +cast from float 0x7fff to __uint 0x7fff +cast from float 0x7fff to float 0x7fff +cast from float 0x7fff (0x7fff) + to __longlong 0x7fff (0x7fff) + +cast from float 0x7fff (0x7fff) + to __ulonglong 0x7fff (0x7fff) + +cast from __longlong 0x7fff to char -0x1 +cast from __longlong 0x7fff to __uchar 0xff +cast from __longlong 0x7fff to __int 0x7fff +cast from __longlong 0x7fff to __uint 0x7fff +cast from __longlong 0x7fff to float 0x7fff +cast from __longlong 0x7fff (0x7fff) + to __longlong 0x7fff (0x7fff) + +cast from __longlong 0x7fff (0x7fff) + to __ulonglong 0x7fff (0x7fff) + +cast from __ulonglong 0x7fff to char -0x1 +cast from __ulonglong 0x7fff to __uchar 0xff +cast from __ulonglong 0x7fff to __int 0x7fff +cast from __ulonglong 0x7fff to __uint 0x7fff +cast from __ulonglong 0x7fff to float 0x7fff +cast from __ulonglong 0x7fff (0x7fff) + to __longlong 0x7fff (0x7fff) + +cast from __ulonglong 0x7fff (0x7fff) + to __ulonglong 0x7fff (0x7fff) + +cast from char 0x0 to char 0x0 +cast from char 0x0 to __uchar 0x0 +cast from char 0x0 to __int 0x0 +cast from char 0x0 to __uint 0x0 +cast from char 0x0 to float 0x0 +cast from char 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from char 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __uchar 0x0 to char 0x0 +cast from __uchar 0x0 to __uchar 0x0 +cast from __uchar 0x0 to __int 0x0 +cast from __uchar 0x0 to __uint 0x0 +cast from __uchar 0x0 to float 0x0 +cast from __uchar 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __uchar 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __int -0x8000 to char 0x0 +cast from __int 0x8000 to __uchar 0x0 +cast from __int -0x8000 to __int -0x8000 +cast from __int 0x8000 to __uint 0x8000 +cast from __int -0x8000 to float -0x8000 +cast from __int 0xffff8000 (0xffff8000) + to __longlong 0xffff8000 (0xffff8000) + +cast from __int 0xffff8000 (0xffff8000) + to __ulonglong 0xffff8000 (0xffff8000) + +cast from __uint -0x8000 to char 0x0 +cast from __uint 0x8000 to __uchar 0x0 +cast from __uint -0x8000 to __int -0x8000 +cast from __uint 0x8000 to __uint 0x8000 +cast from __uint -0x8000 to float -0x8000 +cast from __uint 0x8000 (0x8000) + to __longlong 0x8000 (0x8000) + +cast from __uint 0x8000 (0x8000) + to __ulonglong 0x8000 (0x8000) + +cast from float -0x8000 to char 0x0 +cast from float 0x8000 to __uchar 0x0 +cast from float -0x8000 to __int -0x8000 +cast from float 0x8000 to __uint 0x8000 +cast from float -0x8000 to float -0x8000 +cast from float 0xffff8000 (0xffff8000) + to __longlong 0xffff8000 (0xffff8000) + +cast from float 0xffff8000 (0xffff8000) + to __ulonglong 0xffff8000 (0xffff8000) + +cast from __longlong -0x8000 to char 0x0 +cast from __longlong 0x8000 to __uchar 0x0 +cast from __longlong -0x8000 to __int -0x8000 +cast from __longlong 0x8000 to __uint 0x8000 +cast from __longlong -0x8000 to float -0x8000 +cast from __longlong 0xffff8000 (0xffff8000) + to __longlong 0xffff8000 (0xffff8000) + +cast from __longlong 0xffff8000 (0xffff8000) + to __ulonglong 0xffff8000 (0xffff8000) + +cast from __ulonglong -0x8000 to char 0x0 +cast from __ulonglong 0x8000 to __uchar 0x0 +cast from __ulonglong -0x8000 to __int -0x8000 +cast from __ulonglong 0x8000 to __uint 0x8000 +cast from __ulonglong -0x8000 to float 0x0 +cast from __ulonglong 0xffff8000 (0xffff8000) + to __longlong 0xffff8000 (0xffff8000) + +cast from __ulonglong 0xffff8000 (0xffff8000) + to __ulonglong 0xffff8000 (0xffff8000) + +cast from char 0x18 to char 0x18 +cast from char 0x18 to __uchar 0x18 +cast from char 0x18 to __int 0x18 +cast from char 0x18 to __uint 0x18 +cast from char 0x18 to float 0x18 +cast from char 0x18 (0x18) + to __longlong 0x18 (0x18) + +cast from char 0x18 (0x18) + to __ulonglong 0x18 (0x18) + +cast from __uchar 0x18 to char 0x18 +cast from __uchar 0x18 to __uchar 0x18 +cast from __uchar 0x18 to __int 0x18 +cast from __uchar 0x18 to __uint 0x18 +cast from __uchar 0x18 to float 0x18 +cast from __uchar 0x18 (0x18) + to __longlong 0x18 (0x18) + +cast from __uchar 0x18 (0x18) + to __ulonglong 0x18 (0x18) + +cast from __int -0x3e8 to char 0x18 +cast from __int 0xfc18 to __uchar 0x18 +cast from __int -0x3e8 to __int -0x3e8 +cast from __int 0xfc18 to __uint 0xfc18 +cast from __int -0x3e8 to float -0x3e8 +cast from __int 0xfffffc18 (0xfffffc18) + to __longlong 0xfffffc18 (0xfffffc18) + +cast from __int 0xfffffc18 (0xfffffc18) + to __ulonglong 0xfffffc18 (0xfffffc18) + +cast from __uint -0x3e8 to char 0x18 +cast from __uint 0xfc18 to __uchar 0x18 +cast from __uint -0x3e8 to __int -0x3e8 +cast from __uint 0xfc18 to __uint 0xfc18 +cast from __uint -0x3e8 to float -0x3e8 +cast from __uint 0xfc18 (0xfc18) + to __longlong 0xfc18 (0xfc18) + +cast from __uint 0xfc18 (0xfc18) + to __ulonglong 0xfc18 (0xfc18) + +cast from float -0x3e8 to char 0x18 +cast from float 0xfc18 to __uchar 0x18 +cast from float -0x3e8 to __int -0x3e8 +cast from float 0xfc18 to __uint 0xfc18 +cast from float -0x3e8 to float -0x3e8 +cast from float 0xfffffc18 (0xfffffc18) + to __longlong 0xfffffc18 (0xfffffc18) + +cast from float 0xfffffc18 (0xfffffc18) + to __ulonglong 0xfffffc18 (0xfffffc18) + +cast from __longlong -0x3e8 to char 0x18 +cast from __longlong 0xfc18 to __uchar 0x18 +cast from __longlong -0x3e8 to __int -0x3e8 +cast from __longlong 0xfc18 to __uint 0xfc18 +cast from __longlong -0x3e8 to float -0x3e8 +cast from __longlong 0xfffffc18 (0xfffffc18) + to __longlong 0xfffffc18 (0xfffffc18) + +cast from __longlong 0xfffffc18 (0xfffffc18) + to __ulonglong 0xfffffc18 (0xfffffc18) + +cast from __ulonglong -0x3e8 to char 0x18 +cast from __ulonglong 0xfc18 to __uchar 0x18 +cast from __ulonglong -0x3e8 to __int -0x3e8 +cast from __ulonglong 0xfc18 to __uint 0xfc18 +cast from __ulonglong -0x3e8 to float 0x0 +cast from __ulonglong 0xfffffc18 (0xfffffc18) + to __longlong 0xfffffc18 (0xfffffc18) + +cast from __ulonglong 0xfffffc18 (0xfffffc18) + to __ulonglong 0xfffffc18 (0xfffffc18) + +cast from char -0x10 to char -0x10 +cast from char 0xfff0 to __uchar 0xf0 +cast from char -0x10 to __int -0x10 +cast from char 0xfff0 to __uint 0xfff0 +cast from char -0x10 to float -0x10 +cast from char 0xfffffff0 (0xfffffff0) + to __longlong 0xfffffff0 (0xfffffff0) + +cast from char 0xfffffff0 (0xfffffff0) + to __ulonglong 0xfffffff0 (0xfffffff0) + +cast from __uchar 0xf0 to char -0x10 +cast from __uchar 0xf0 to __uchar 0xf0 +cast from __uchar 0xf0 to __int 0xf0 +cast from __uchar 0xf0 to __uint 0xf0 +cast from __uchar 0xf0 to float 0xf0 +cast from __uchar 0xf0 (0xf0) + to __longlong 0xf0 (0xf0) + +cast from __uchar 0xf0 (0xf0) + to __ulonglong 0xf0 (0xf0) + +cast from __int -0x2710 to char -0x10 +cast from __int 0xd8f0 to __uchar 0xf0 +cast from __int -0x2710 to __int -0x2710 +cast from __int 0xd8f0 to __uint 0xd8f0 +cast from __int -0x2710 to float -0x2710 +cast from __int 0xffffd8f0 (0xffffd8f0) + to __longlong 0xffffd8f0 (0xffffd8f0) + +cast from __int 0xffffd8f0 (0xffffd8f0) + to __ulonglong 0xffffd8f0 (0xffffd8f0) + +cast from __uint -0x2710 to char -0x10 +cast from __uint 0xd8f0 to __uchar 0xf0 +cast from __uint -0x2710 to __int -0x2710 +cast from __uint 0xd8f0 to __uint 0xd8f0 +cast from __uint -0x2710 to float -0x2710 +cast from __uint 0xd8f0 (0xd8f0) + to __longlong 0xd8f0 (0xd8f0) + +cast from __uint 0xd8f0 (0xd8f0) + to __ulonglong 0xd8f0 (0xd8f0) + +cast from float -0x2710 to char -0x10 +cast from float 0xd8f0 to __uchar 0xf0 +cast from float -0x2710 to __int -0x2710 +cast from float 0xd8f0 to __uint 0xd8f0 +cast from float -0x2710 to float -0x2710 +cast from float 0xffffd8f0 (0xffffd8f0) + to __longlong 0xffffd8f0 (0xffffd8f0) + +cast from float 0xffffd8f0 (0xffffd8f0) + to __ulonglong 0xffffd8f0 (0xffffd8f0) + +cast from __longlong -0x2710 to char -0x10 +cast from __longlong 0xd8f0 to __uchar 0xf0 +cast from __longlong -0x2710 to __int -0x2710 +cast from __longlong 0xd8f0 to __uint 0xd8f0 +cast from __longlong -0x2710 to float -0x2710 +cast from __longlong 0xffffd8f0 (0xffffd8f0) + to __longlong 0xffffd8f0 (0xffffd8f0) + +cast from __longlong 0xffffd8f0 (0xffffd8f0) + to __ulonglong 0xffffd8f0 (0xffffd8f0) + +cast from __ulonglong -0x2710 to char -0x10 +cast from __ulonglong 0xd8f0 to __uchar 0xf0 +cast from __ulonglong -0x2710 to __int -0x2710 +cast from __ulonglong 0xd8f0 to __uint 0xd8f0 +cast from __ulonglong -0x2710 to float 0x0 +cast from __ulonglong 0xffffd8f0 (0xffffd8f0) + to __longlong 0xffffd8f0 (0xffffd8f0) + +cast from __ulonglong 0xffffd8f0 (0xffffd8f0) + to __ulonglong 0xffffd8f0 (0xffffd8f0) + +(int)float1[0x0] == 0x1 +(int)float1[0x1] == -0x1 +(int)float1[0x2] == 0x0 +(int)float1[0x3] == 0x2 +(int)float1[0x4] == 0x4240 +cast from char 0x1 to char 0x1 +cast from char 0x1 to __uchar 0x1 +cast from char 0x1 to __int 0x1 +cast from char 0x1 to __uint 0x1 +cast from char 0x1 to float 0x1 +cast from char 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from char 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __uchar 0x1 to char 0x1 +cast from __uchar 0x1 to __uchar 0x1 +cast from __uchar 0x1 to __int 0x1 +cast from __uchar 0x1 to __uint 0x1 +cast from __uchar 0x1 to float 0x1 +cast from __uchar 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __uchar 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __int 0x1 to char 0x1 +cast from __int 0x1 to __uchar 0x1 +cast from __int 0x1 to __int 0x1 +cast from __int 0x1 to __uint 0x1 +cast from __int 0x1 to float 0x1 +cast from __int 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __int 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __uint 0x1 to char 0x1 +cast from __uint 0x1 to __uchar 0x1 +cast from __uint 0x1 to __int 0x1 +cast from __uint 0x1 to __uint 0x1 +cast from __uint 0x1 to float 0x1 +cast from __uint 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __uint 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from float 0x1 to char 0x1 +cast from float 0x1 to __uchar 0x1 +cast from float 0x1 to __int 0x1 +cast from float 0x1 to __uint 0x1 +cast from float 0x1 to float 0x1 +cast from float 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from float 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __longlong 0x1 to char 0x1 +cast from __longlong 0x1 to __uchar 0x1 +cast from __longlong 0x1 to __int 0x1 +cast from __longlong 0x1 to __uint 0x1 +cast from __longlong 0x1 to float 0x1 +cast from __longlong 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __longlong 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __ulonglong 0x1 to char 0x1 +cast from __ulonglong 0x1 to __uchar 0x1 +cast from __ulonglong 0x1 to __int 0x1 +cast from __ulonglong 0x1 to __uint 0x1 +cast from __ulonglong 0x1 to float 0x1 +cast from __ulonglong 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __ulonglong 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from char -0x1 to char -0x1 +cast from char 0xffff to __uchar 0xff +cast from char -0x1 to __int -0x1 +cast from char 0xffff to __uint 0xffff +cast from char -0x1 to float -0x1 +cast from char 0xffffffff (0xffffffff) + to __longlong 0xffffffff (0xffffffff) + +cast from char 0xffffffff (0xffffffff) + to __ulonglong 0xffffffff (0xffffffff) + +cast from __uchar 0xff to char -0x1 +cast from __uchar 0xff to __uchar 0xff +cast from __uchar 0xff to __int 0xff +cast from __uchar 0xff to __uint 0xff +cast from __uchar 0xff to float 0xff +cast from __uchar 0xff (0xff) + to __longlong 0xff (0xff) + +cast from __uchar 0xff (0xff) + to __ulonglong 0xff (0xff) + +cast from __int -0x1 to char -0x1 +cast from __int 0xffff to __uchar 0xff +cast from __int -0x1 to __int -0x1 +cast from __int 0xffff to __uint 0xffff +cast from __int -0x1 to float -0x1 +cast from __int 0xffffffff (0xffffffff) + to __longlong 0xffffffff (0xffffffff) + +cast from __int 0xffffffff (0xffffffff) + to __ulonglong 0xffffffff (0xffffffff) + +cast from __uint -0x1 to char -0x1 +cast from __uint 0xffff to __uchar 0xff +cast from __uint -0x1 to __int -0x1 +cast from __uint 0xffff to __uint 0xffff +cast from __uint -0x1 to float -0x1 +cast from __uint 0xffff (0xffff) + to __longlong 0xffff (0xffff) + +cast from __uint 0xffff (0xffff) + to __ulonglong 0xffff (0xffff) + +cast from float -0x1 to char -0x1 +cast from float 0xffff to __uchar 0xff +cast from float -0x1 to __int -0x1 +cast from float 0xffff to __uint 0xffff +cast from float -0x1 to float -0x1 +cast from float 0xffffffff (0xffffffff) + to __longlong 0xffffffff (0xffffffff) + +cast from float 0xffffffff (0xffffffff) + to __ulonglong 0xffffffff (0xffffffff) + +cast from __longlong -0x1 to char -0x1 +cast from __longlong 0xffff to __uchar 0xff +cast from __longlong -0x1 to __int -0x1 +cast from __longlong 0xffff to __uint 0xffff +cast from __longlong -0x1 to float -0x1 +cast from __longlong 0xffffffff (0xffffffff) + to __longlong 0xffffffff (0xffffffff) + +cast from __longlong 0xffffffff (0xffffffff) + to __ulonglong 0xffffffff (0xffffffff) + +cast from __ulonglong -0x1 to char -0x1 +cast from __ulonglong 0xffff to __uchar 0xff +cast from __ulonglong -0x1 to __int -0x1 +cast from __ulonglong 0xffff to __uint 0xffff +cast from __ulonglong -0x1 to float 0x0 +cast from __ulonglong 0xffffffff (0xffffffff) + to __longlong 0xffffffff (0xffffffff) + +cast from __ulonglong 0xffffffff (0xffffffff) + to __ulonglong 0xffffffff (0xffffffff) + +cast from char 0x0 to char 0x0 +cast from char 0x0 to __uchar 0x0 +cast from char 0x0 to __int 0x0 +cast from char 0x0 to __uint 0x0 +cast from char 0x0 to float 0x0 +cast from char 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from char 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __uchar 0x0 to char 0x0 +cast from __uchar 0x0 to __uchar 0x0 +cast from __uchar 0x0 to __int 0x0 +cast from __uchar 0x0 to __uint 0x0 +cast from __uchar 0x0 to float 0x0 +cast from __uchar 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __uchar 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __int 0x0 to char 0x0 +cast from __int 0x0 to __uchar 0x0 +cast from __int 0x0 to __int 0x0 +cast from __int 0x0 to __uint 0x0 +cast from __int 0x0 to float 0x0 +cast from __int 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __int 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __uint 0x0 to char 0x0 +cast from __uint 0x0 to __uchar 0x0 +cast from __uint 0x0 to __int 0x0 +cast from __uint 0x0 to __uint 0x0 +cast from __uint 0x0 to float 0x0 +cast from __uint 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __uint 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from float 0x0 to char 0x0 +cast from float 0x0 to __uchar 0x0 +cast from float 0x0 to __int 0x0 +cast from float 0x0 to __uint 0x0 +cast from float 0x0 to float 0x0 +cast from float 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from float 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __longlong 0x0 to char 0x0 +cast from __longlong 0x0 to __uchar 0x0 +cast from __longlong 0x0 to __int 0x0 +cast from __longlong 0x0 to __uint 0x0 +cast from __longlong 0x0 to float 0x0 +cast from __longlong 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __longlong 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __ulonglong 0x0 to char 0x0 +cast from __ulonglong 0x0 to __uchar 0x0 +cast from __ulonglong 0x0 to __int 0x0 +cast from __ulonglong 0x0 to __uint 0x0 +cast from __ulonglong 0x0 to float 0x0 +cast from __ulonglong 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __ulonglong 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from char 0x2 to char 0x2 +cast from char 0x2 to __uchar 0x2 +cast from char 0x2 to __int 0x2 +cast from char 0x2 to __uint 0x2 +cast from char 0x2 to float 0x2 +cast from char 0x2 (0x2) + to __longlong 0x2 (0x2) + +cast from char 0x2 (0x2) + to __ulonglong 0x2 (0x2) + +cast from __uchar 0x2 to char 0x2 +cast from __uchar 0x2 to __uchar 0x2 +cast from __uchar 0x2 to __int 0x2 +cast from __uchar 0x2 to __uint 0x2 +cast from __uchar 0x2 to float 0x2 +cast from __uchar 0x2 (0x2) + to __longlong 0x2 (0x2) + +cast from __uchar 0x2 (0x2) + to __ulonglong 0x2 (0x2) + +cast from __int 0x2 to char 0x2 +cast from __int 0x2 to __uchar 0x2 +cast from __int 0x2 to __int 0x2 +cast from __int 0x2 to __uint 0x2 +cast from __int 0x2 to float 0x2 +cast from __int 0x2 (0x2) + to __longlong 0x2 (0x2) + +cast from __int 0x2 (0x2) + to __ulonglong 0x2 (0x2) + +cast from __uint 0x2 to char 0x2 +cast from __uint 0x2 to __uchar 0x2 +cast from __uint 0x2 to __int 0x2 +cast from __uint 0x2 to __uint 0x2 +cast from __uint 0x2 to float 0x2 +cast from __uint 0x2 (0x2) + to __longlong 0x2 (0x2) + +cast from __uint 0x2 (0x2) + to __ulonglong 0x2 (0x2) + +cast from float 0x2 to char 0x2 +cast from float 0x2 to __uchar 0x2 +cast from float 0x2 to __int 0x2 +cast from float 0x2 to __uint 0x2 +cast from float 0x2 to float 0x2 +cast from float 0x2 (0x2) + to __longlong 0x2 (0x2) + +cast from float 0x2 (0x2) + to __ulonglong 0x2 (0x2) + +cast from __longlong 0x2 to char 0x2 +cast from __longlong 0x2 to __uchar 0x2 +cast from __longlong 0x2 to __int 0x2 +cast from __longlong 0x2 to __uint 0x2 +cast from __longlong 0x2 to float 0x2 +cast from __longlong 0x2 (0x2) + to __longlong 0x2 (0x2) + +cast from __longlong 0x2 (0x2) + to __ulonglong 0x2 (0x2) + +cast from __ulonglong 0x2 to char 0x2 +cast from __ulonglong 0x2 to __uchar 0x2 +cast from __ulonglong 0x2 to __int 0x2 +cast from __ulonglong 0x2 to __uint 0x2 +cast from __ulonglong 0x2 to float 0x2 +cast from __ulonglong 0x2 (0x2) + to __longlong 0x2 (0x2) + +cast from __ulonglong 0x2 (0x2) + to __ulonglong 0x2 (0x2) + +cast from char 0x40 to char 0x40 +cast from char 0x40 to __uchar 0x40 +cast from char 0x40 to __int 0x40 +cast from char 0x40 to __uint 0x40 +cast from char 0x40 to float 0x40 +cast from char 0x40 (0x40) + to __longlong 0x40 (0x40) + +cast from char 0x40 (0x40) + to __ulonglong 0x40 (0x40) + +cast from __uchar 0x40 to char 0x40 +cast from __uchar 0x40 to __uchar 0x40 +cast from __uchar 0x40 to __int 0x40 +cast from __uchar 0x40 to __uint 0x40 +cast from __uchar 0x40 to float 0x40 +cast from __uchar 0x40 (0x40) + to __longlong 0x40 (0x40) + +cast from __uchar 0x40 (0x40) + to __ulonglong 0x40 (0x40) + +cast from __int 0x4240 to char 0x40 +cast from __int 0x4240 to __uchar 0x40 +cast from __int 0x4240 to __int 0x4240 +cast from __int 0x4240 to __uint 0x4240 +cast from __int 0x4240 to float 0x4240 +cast from __int 0x4240 (0x4240) + to __longlong 0x4240 (0x4240) + +cast from __int 0x4240 (0x4240) + to __ulonglong 0x4240 (0x4240) + +cast from __uint 0x4240 to char 0x40 +cast from __uint 0x4240 to __uchar 0x40 +cast from __uint 0x4240 to __int 0x4240 +cast from __uint 0x4240 to __uint 0x4240 +cast from __uint 0x4240 to float 0x4240 +cast from __uint 0x4240 (0x4240) + to __longlong 0x4240 (0x4240) + +cast from __uint 0x4240 (0x4240) + to __ulonglong 0x4240 (0x4240) + +cast from float 0x4240 to char 0x40 +cast from float 0x4240 to __uchar 0x40 +cast from float 0x4240 to __int 0x4240 +cast from float 0x4240 to __uint 0x4240 +cast from float 0x4240 to float 0x4240 +cast from float 0xf4240 (0xf4240) + to __longlong 0xf4240 (0xf4240) + +cast from float 0xf4240 (0xf4240) + to __ulonglong 0xf4240 (0xf4240) + +cast from __longlong 0x4240 to char 0x40 +cast from __longlong 0x4240 to __uchar 0x40 +cast from __longlong 0x4240 to __int 0x4240 +cast from __longlong 0x4240 to __uint 0x4240 +cast from __longlong 0x4240 to float 0x4240 +cast from __longlong 0xf4240 (0xf4240) + to __longlong 0xf4240 (0xf4240) + +cast from __longlong 0xf4240 (0xf4240) + to __ulonglong 0xf4240 (0xf4240) + +cast from __ulonglong 0x4240 to char 0x40 +cast from __ulonglong 0x4240 to __uchar 0x40 +cast from __ulonglong 0x4240 to __int 0x4240 +cast from __ulonglong 0x4240 to __uint 0x4240 +cast from __ulonglong 0x4240 to float 0x4240 +cast from __ulonglong 0xf4240 (0xf4240) + to __longlong 0xf4240 (0xf4240) + +cast from __ulonglong 0xf4240 (0xf4240) + to __ulonglong 0xf4240 (0xf4240) + +casting ll1[0x0] +cast from char -0x1 to char -0x1 +cast from char 0xffff to __uchar 0xff +cast from char -0x1 to __int -0x1 +cast from char 0xffff to __uint 0xffff +cast from char -0x1 to float -0x1 +cast from char 0xffffffff (0xffffffff) + to __longlong 0xffffffff (0xffffffff) + +cast from char 0xffffffff (0xffffffff) + to __ulonglong 0xffffffff (0xffffffff) + +cast from __uchar 0xff to char -0x1 +cast from __uchar 0xff to __uchar 0xff +cast from __uchar 0xff to __int 0xff +cast from __uchar 0xff to __uint 0xff +cast from __uchar 0xff to float 0xff +cast from __uchar 0xff (0xff) + to __longlong 0xff (0xff) + +cast from __uchar 0xff (0xff) + to __ulonglong 0xff (0xff) + +cast from __int -0x1 to char -0x1 +cast from __int 0xffff to __uchar 0xff +cast from __int -0x1 to __int -0x1 +cast from __int 0xffff to __uint 0xffff +cast from __int -0x1 to float -0x1 +cast from __int 0xffffffff (0xffffffff) + to __longlong 0xffffffff (0xffffffff) + +cast from __int 0xffffffff (0xffffffff) + to __ulonglong 0xffffffff (0xffffffff) + +cast from __uint -0x1 to char -0x1 +cast from __uint 0xffff to __uchar 0xff +cast from __uint -0x1 to __int -0x1 +cast from __uint 0xffff to __uint 0xffff +cast from __uint -0x1 to float -0x1 +cast from __uint 0xffff (0xffff) + to __longlong 0xffff (0xffff) + +cast from __uint 0xffff (0xffff) + to __ulonglong 0xffff (0xffff) + +cast from float -0x1 to char -0x1 +cast from float 0xffff to __uchar 0xff +cast from float -0x1 to __int -0x1 +cast from float 0xffff to __uint 0xffff +cast from float -0x1 to float -0x1 +cast from float 0xffffffff (0xffffffff) + to __longlong 0xffffffff (0xffffffff) + +cast from float 0xffffffff (0xffffffff) + to __ulonglong 0xffffffff (0xffffffff) + +cast from __longlong -0x1 to char -0x1 +cast from __longlong 0xffff to __uchar 0xff +cast from __longlong -0x1 to __int -0x1 +cast from __longlong 0xffff to __uint 0xffff +cast from __longlong -0x1 to float -0x1 +cast from __longlong 0xffffffff (0xffffffff) + to __longlong 0xffffffff (0xffffffff) + +cast from __longlong 0xffffffff (0xffffffff) + to __ulonglong 0xffffffff (0xffffffff) + +cast from __ulonglong -0x1 to char -0x1 +cast from __ulonglong 0xffff to __uchar 0xff +cast from __ulonglong -0x1 to __int -0x1 +cast from __ulonglong 0xffff to __uint 0xffff +cast from __ulonglong -0x1 to float 0x0 +cast from __ulonglong 0xffffffff (0xffffffff) + to __longlong 0xffffffff (0xffffffff) + +cast from __ulonglong 0xffffffff (0xffffffff) + to __ulonglong 0xffffffff (0xffffffff) + +cast from char -0x1 to char -0x1 +cast from char 0xffff to __uchar 0xff +cast from char -0x1 to __int -0x1 +cast from char 0xffff to __uint 0xffff +cast from char -0x1 to float -0x1 +cast from char 0xffffffff (0xffffffff) + to __longlong 0xffffffff (0xffffffff) + +cast from char 0xffffffff (0xffffffff) + to __ulonglong 0xffffffff (0xffffffff) + +cast from __uchar 0xff to char -0x1 +cast from __uchar 0xff to __uchar 0xff +cast from __uchar 0xff to __int 0xff +cast from __uchar 0xff to __uint 0xff +cast from __uchar 0xff to float 0xff +cast from __uchar 0xff (0xff) + to __longlong 0xff (0xff) + +cast from __uchar 0xff (0xff) + to __ulonglong 0xff (0xff) + +cast from __int -0x1 to char -0x1 +cast from __int 0xffff to __uchar 0xff +cast from __int -0x1 to __int -0x1 +cast from __int 0xffff to __uint 0xffff +cast from __int -0x1 to float -0x1 +cast from __int 0xffffffff (0xffffffff) + to __longlong 0xffffffff (0xffffffff) + +cast from __int 0xffffffff (0xffffffff) + to __ulonglong 0xffffffff (0xffffffff) + +cast from __uint -0x1 to char -0x1 +cast from __uint 0xffff to __uchar 0xff +cast from __uint -0x1 to __int -0x1 +cast from __uint 0xffff to __uint 0xffff +cast from __uint -0x1 to float -0x1 +cast from __uint 0xffff (0xffff) + to __longlong 0xffff (0xffff) + +cast from __uint 0xffff (0xffff) + to __ulonglong 0xffff (0xffff) + +cast from float 0x0 to char 0x0 +cast from float 0x0 to __uchar 0x0 +cast from float 0x0 to __int 0x0 +cast from float 0x0 to __uint 0x0 +cast from float 0x0 to float 0x0 +cast from float 0x80000000 (0x80000000) + to __longlong 0x80000000 (0x80000000) + +cast from float 0x80000000 (0x80000000) + to __ulonglong 0x0 (0x0) + +cast from __longlong -0x1 to char -0x1 +cast from __longlong 0xffff to __uchar 0xff +cast from __longlong -0x1 to __int -0x1 +cast from __longlong 0xffff to __uint 0xffff +cast from __longlong -0x1 to float -0x1 +cast from __longlong 0xffffffff (0xffffffff) + to __longlong 0xffffffff (0xffffffff) + +cast from __longlong 0xffffffff (0xffffffff) + to __ulonglong 0xffffffff (0xffffffff) + +cast from __ulonglong -0x1 to char -0x1 +cast from __ulonglong 0xffff to __uchar 0xff +cast from __ulonglong -0x1 to __int -0x1 +cast from __ulonglong 0xffff to __uint 0xffff +cast from __ulonglong -0x1 to float 0x0 +cast from __ulonglong 0xffffffff (0xffffffff) + to __longlong 0xffffffff (0xffffffff) + +cast from __ulonglong 0xffffffff (0xffffffff) + to __ulonglong 0xffffffff (0xffffffff) + +casting ll1[0x1] +cast from char 0x0 to char 0x0 +cast from char 0x0 to __uchar 0x0 +cast from char 0x0 to __int 0x0 +cast from char 0x0 to __uint 0x0 +cast from char 0x0 to float 0x0 +cast from char 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from char 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __uchar 0x0 to char 0x0 +cast from __uchar 0x0 to __uchar 0x0 +cast from __uchar 0x0 to __int 0x0 +cast from __uchar 0x0 to __uint 0x0 +cast from __uchar 0x0 to float 0x0 +cast from __uchar 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __uchar 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __int 0x0 to char 0x0 +cast from __int 0x0 to __uchar 0x0 +cast from __int 0x0 to __int 0x0 +cast from __int 0x0 to __uint 0x0 +cast from __int 0x0 to float 0x0 +cast from __int 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __int 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __uint 0x0 to char 0x0 +cast from __uint 0x0 to __uchar 0x0 +cast from __uint 0x0 to __int 0x0 +cast from __uint 0x0 to __uint 0x0 +cast from __uint 0x0 to float 0x0 +cast from __uint 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __uint 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from float 0x0 to char 0x0 +cast from float 0x0 to __uchar 0x0 +cast from float 0x0 to __int 0x0 +cast from float 0x0 to __uint 0x0 +cast from float 0x0 to float 0x0 +cast from float 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from float 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __longlong 0x0 to char 0x0 +cast from __longlong 0x0 to __uchar 0x0 +cast from __longlong 0x0 to __int 0x0 +cast from __longlong 0x0 to __uint 0x0 +cast from __longlong 0x0 to float 0x0 +cast from __longlong 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __longlong 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __ulonglong 0x0 to char 0x0 +cast from __ulonglong 0x0 to __uchar 0x0 +cast from __ulonglong 0x0 to __int 0x0 +cast from __ulonglong 0x0 to __uint 0x0 +cast from __ulonglong 0x0 to float 0x0 +cast from __ulonglong 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __ulonglong 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from char 0x0 to char 0x0 +cast from char 0x0 to __uchar 0x0 +cast from char 0x0 to __int 0x0 +cast from char 0x0 to __uint 0x0 +cast from char 0x0 to float 0x0 +cast from char 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from char 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __uchar 0x0 to char 0x0 +cast from __uchar 0x0 to __uchar 0x0 +cast from __uchar 0x0 to __int 0x0 +cast from __uchar 0x0 to __uint 0x0 +cast from __uchar 0x0 to float 0x0 +cast from __uchar 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __uchar 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __int 0x0 to char 0x0 +cast from __int 0x0 to __uchar 0x0 +cast from __int 0x0 to __int 0x0 +cast from __int 0x0 to __uint 0x0 +cast from __int 0x0 to float 0x0 +cast from __int 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __int 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __uint 0x0 to char 0x0 +cast from __uint 0x0 to __uchar 0x0 +cast from __uint 0x0 to __int 0x0 +cast from __uint 0x0 to __uint 0x0 +cast from __uint 0x0 to float 0x0 +cast from __uint 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __uint 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from float 0x0 to char 0x0 +cast from float 0x0 to __uchar 0x0 +cast from float 0x0 to __int 0x0 +cast from float 0x0 to __uint 0x0 +cast from float 0x0 to float 0x0 +cast from float 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from float 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __longlong 0x0 to char 0x0 +cast from __longlong 0x0 to __uchar 0x0 +cast from __longlong 0x0 to __int 0x0 +cast from __longlong 0x0 to __uint 0x0 +cast from __longlong 0x0 to float 0x0 +cast from __longlong 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __longlong 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __ulonglong 0x0 to char 0x0 +cast from __ulonglong 0x0 to __uchar 0x0 +cast from __ulonglong 0x0 to __int 0x0 +cast from __ulonglong 0x0 to __uint 0x0 +cast from __ulonglong 0x0 to float 0x0 +cast from __ulonglong 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __ulonglong 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +casting ll1[0x2] +cast from char 0x1 to char 0x1 +cast from char 0x1 to __uchar 0x1 +cast from char 0x1 to __int 0x1 +cast from char 0x1 to __uint 0x1 +cast from char 0x1 to float 0x1 +cast from char 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from char 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __uchar 0x1 to char 0x1 +cast from __uchar 0x1 to __uchar 0x1 +cast from __uchar 0x1 to __int 0x1 +cast from __uchar 0x1 to __uint 0x1 +cast from __uchar 0x1 to float 0x1 +cast from __uchar 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __uchar 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __int 0x1 to char 0x1 +cast from __int 0x1 to __uchar 0x1 +cast from __int 0x1 to __int 0x1 +cast from __int 0x1 to __uint 0x1 +cast from __int 0x1 to float 0x1 +cast from __int 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __int 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __uint 0x1 to char 0x1 +cast from __uint 0x1 to __uchar 0x1 +cast from __uint 0x1 to __int 0x1 +cast from __uint 0x1 to __uint 0x1 +cast from __uint 0x1 to float 0x1 +cast from __uint 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __uint 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from float 0x1 to char 0x1 +cast from float 0x1 to __uchar 0x1 +cast from float 0x1 to __int 0x1 +cast from float 0x1 to __uint 0x1 +cast from float 0x1 to float 0x1 +cast from float 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from float 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __longlong 0x1 to char 0x1 +cast from __longlong 0x1 to __uchar 0x1 +cast from __longlong 0x1 to __int 0x1 +cast from __longlong 0x1 to __uint 0x1 +cast from __longlong 0x1 to float 0x1 +cast from __longlong 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __longlong 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __ulonglong 0x1 to char 0x1 +cast from __ulonglong 0x1 to __uchar 0x1 +cast from __ulonglong 0x1 to __int 0x1 +cast from __ulonglong 0x1 to __uint 0x1 +cast from __ulonglong 0x1 to float 0x1 +cast from __ulonglong 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __ulonglong 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from char 0x1 to char 0x1 +cast from char 0x1 to __uchar 0x1 +cast from char 0x1 to __int 0x1 +cast from char 0x1 to __uint 0x1 +cast from char 0x1 to float 0x1 +cast from char 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from char 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __uchar 0x1 to char 0x1 +cast from __uchar 0x1 to __uchar 0x1 +cast from __uchar 0x1 to __int 0x1 +cast from __uchar 0x1 to __uint 0x1 +cast from __uchar 0x1 to float 0x1 +cast from __uchar 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __uchar 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __int 0x1 to char 0x1 +cast from __int 0x1 to __uchar 0x1 +cast from __int 0x1 to __int 0x1 +cast from __int 0x1 to __uint 0x1 +cast from __int 0x1 to float 0x1 +cast from __int 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __int 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __uint 0x1 to char 0x1 +cast from __uint 0x1 to __uchar 0x1 +cast from __uint 0x1 to __int 0x1 +cast from __uint 0x1 to __uint 0x1 +cast from __uint 0x1 to float 0x1 +cast from __uint 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __uint 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from float 0x1 to char 0x1 +cast from float 0x1 to __uchar 0x1 +cast from float 0x1 to __int 0x1 +cast from float 0x1 to __uint 0x1 +cast from float 0x1 to float 0x1 +cast from float 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from float 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __longlong 0x1 to char 0x1 +cast from __longlong 0x1 to __uchar 0x1 +cast from __longlong 0x1 to __int 0x1 +cast from __longlong 0x1 to __uint 0x1 +cast from __longlong 0x1 to float 0x1 +cast from __longlong 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __longlong 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __ulonglong 0x1 to char 0x1 +cast from __ulonglong 0x1 to __uchar 0x1 +cast from __ulonglong 0x1 to __int 0x1 +cast from __ulonglong 0x1 to __uint 0x1 +cast from __ulonglong 0x1 to float 0x1 +cast from __ulonglong 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __ulonglong 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +casting ll1[0x3] +cast from char 0xa to char 0xa +cast from char 0xa to __uchar 0xa +cast from char 0xa to __int 0xa +cast from char 0xa to __uint 0xa +cast from char 0xa to float 0xa +cast from char 0xa (0xa) + to __longlong 0xa (0xa) + +cast from char 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from __uchar 0xa to char 0xa +cast from __uchar 0xa to __uchar 0xa +cast from __uchar 0xa to __int 0xa +cast from __uchar 0xa to __uint 0xa +cast from __uchar 0xa to float 0xa +cast from __uchar 0xa (0xa) + to __longlong 0xa (0xa) + +cast from __uchar 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from __int 0xa to char 0xa +cast from __int 0xa to __uchar 0xa +cast from __int 0xa to __int 0xa +cast from __int 0xa to __uint 0xa +cast from __int 0xa to float 0xa +cast from __int 0xa (0xa) + to __longlong 0xa (0xa) + +cast from __int 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from __uint 0xa to char 0xa +cast from __uint 0xa to __uchar 0xa +cast from __uint 0xa to __int 0xa +cast from __uint 0xa to __uint 0xa +cast from __uint 0xa to float 0xa +cast from __uint 0xa (0xa) + to __longlong 0xa (0xa) + +cast from __uint 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from float 0xa to char 0xa +cast from float 0xa to __uchar 0xa +cast from float 0xa to __int 0xa +cast from float 0xa to __uint 0xa +cast from float 0xa to float 0xa +cast from float 0xa (0xa) + to __longlong 0xa (0xa) + +cast from float 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from __longlong 0xa to char 0xa +cast from __longlong 0xa to __uchar 0xa +cast from __longlong 0xa to __int 0xa +cast from __longlong 0xa to __uint 0xa +cast from __longlong 0xa to float 0xa +cast from __longlong 0xa (0xa) + to __longlong 0xa (0xa) + +cast from __longlong 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from __ulonglong 0xa to char 0xa +cast from __ulonglong 0xa to __uchar 0xa +cast from __ulonglong 0xa to __int 0xa +cast from __ulonglong 0xa to __uint 0xa +cast from __ulonglong 0xa to float 0xa +cast from __ulonglong 0xa (0xa) + to __longlong 0xa (0xa) + +cast from __ulonglong 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from char 0xa to char 0xa +cast from char 0xa to __uchar 0xa +cast from char 0xa to __int 0xa +cast from char 0xa to __uint 0xa +cast from char 0xa to float 0xa +cast from char 0xa (0xa) + to __longlong 0xa (0xa) + +cast from char 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from __uchar 0xa to char 0xa +cast from __uchar 0xa to __uchar 0xa +cast from __uchar 0xa to __int 0xa +cast from __uchar 0xa to __uint 0xa +cast from __uchar 0xa to float 0xa +cast from __uchar 0xa (0xa) + to __longlong 0xa (0xa) + +cast from __uchar 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from __int 0xa to char 0xa +cast from __int 0xa to __uchar 0xa +cast from __int 0xa to __int 0xa +cast from __int 0xa to __uint 0xa +cast from __int 0xa to float 0xa +cast from __int 0xa (0xa) + to __longlong 0xa (0xa) + +cast from __int 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from __uint 0xa to char 0xa +cast from __uint 0xa to __uchar 0xa +cast from __uint 0xa to __int 0xa +cast from __uint 0xa to __uint 0xa +cast from __uint 0xa to float 0xa +cast from __uint 0xa (0xa) + to __longlong 0xa (0xa) + +cast from __uint 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from float 0xa to char 0xa +cast from float 0xa to __uchar 0xa +cast from float 0xa to __int 0xa +cast from float 0xa to __uint 0xa +cast from float 0xa to float 0xa +cast from float 0xa (0xa) + to __longlong 0xa (0xa) + +cast from float 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from __longlong 0xa to char 0xa +cast from __longlong 0xa to __uchar 0xa +cast from __longlong 0xa to __int 0xa +cast from __longlong 0xa to __uint 0xa +cast from __longlong 0xa to float 0xa +cast from __longlong 0xa (0xa) + to __longlong 0xa (0xa) + +cast from __longlong 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from __ulonglong 0xa to char 0xa +cast from __ulonglong 0xa to __uchar 0xa +cast from __ulonglong 0xa to __int 0xa +cast from __ulonglong 0xa to __uint 0xa +cast from __ulonglong 0xa to float 0xa +cast from __ulonglong 0xa (0xa) + to __longlong 0xa (0xa) + +cast from __ulonglong 0xa (0xa) + to __ulonglong 0xa (0xa) + +casting ll1[0x4] +cast from char 0x64 to char 0x64 +cast from char 0x64 to __uchar 0x64 +cast from char 0x64 to __int 0x64 +cast from char 0x64 to __uint 0x64 +cast from char 0x64 to float 0x64 +cast from char 0x64 (0x64) + to __longlong 0x64 (0x64) + +cast from char 0x64 (0x64) + to __ulonglong 0x64 (0x64) + +cast from __uchar 0x64 to char 0x64 +cast from __uchar 0x64 to __uchar 0x64 +cast from __uchar 0x64 to __int 0x64 +cast from __uchar 0x64 to __uint 0x64 +cast from __uchar 0x64 to float 0x64 +cast from __uchar 0x64 (0x64) + to __longlong 0x64 (0x64) + +cast from __uchar 0x64 (0x64) + to __ulonglong 0x64 (0x64) + +cast from __int 0x64 to char 0x64 +cast from __int 0x64 to __uchar 0x64 +cast from __int 0x64 to __int 0x64 +cast from __int 0x64 to __uint 0x64 +cast from __int 0x64 to float 0x64 +cast from __int 0x64 (0x64) + to __longlong 0x64 (0x64) + +cast from __int 0x64 (0x64) + to __ulonglong 0x64 (0x64) + +cast from __uint 0x64 to char 0x64 +cast from __uint 0x64 to __uchar 0x64 +cast from __uint 0x64 to __int 0x64 +cast from __uint 0x64 to __uint 0x64 +cast from __uint 0x64 to float 0x64 +cast from __uint 0x64 (0x64) + to __longlong 0x64 (0x64) + +cast from __uint 0x64 (0x64) + to __ulonglong 0x64 (0x64) + +cast from float 0x64 to char 0x64 +cast from float 0x64 to __uchar 0x64 +cast from float 0x64 to __int 0x64 +cast from float 0x64 to __uint 0x64 +cast from float 0x64 to float 0x64 +cast from float 0x64 (0x64) + to __longlong 0x64 (0x64) + +cast from float 0x64 (0x64) + to __ulonglong 0x64 (0x64) + +cast from __longlong 0x64 to char 0x64 +cast from __longlong 0x64 to __uchar 0x64 +cast from __longlong 0x64 to __int 0x64 +cast from __longlong 0x64 to __uint 0x64 +cast from __longlong 0x64 to float 0x64 +cast from __longlong 0x64 (0x64) + to __longlong 0x64 (0x64) + +cast from __longlong 0x64 (0x64) + to __ulonglong 0x64 (0x64) + +cast from __ulonglong 0x64 to char 0x64 +cast from __ulonglong 0x64 to __uchar 0x64 +cast from __ulonglong 0x64 to __int 0x64 +cast from __ulonglong 0x64 to __uint 0x64 +cast from __ulonglong 0x64 to float 0x64 +cast from __ulonglong 0x64 (0x64) + to __longlong 0x64 (0x64) + +cast from __ulonglong 0x64 (0x64) + to __ulonglong 0x64 (0x64) + +cast from char 0x64 to char 0x64 +cast from char 0x64 to __uchar 0x64 +cast from char 0x64 to __int 0x64 +cast from char 0x64 to __uint 0x64 +cast from char 0x64 to float 0x64 +cast from char 0x64 (0x64) + to __longlong 0x64 (0x64) + +cast from char 0x64 (0x64) + to __ulonglong 0x64 (0x64) + +cast from __uchar 0x64 to char 0x64 +cast from __uchar 0x64 to __uchar 0x64 +cast from __uchar 0x64 to __int 0x64 +cast from __uchar 0x64 to __uint 0x64 +cast from __uchar 0x64 to float 0x64 +cast from __uchar 0x64 (0x64) + to __longlong 0x64 (0x64) + +cast from __uchar 0x64 (0x64) + to __ulonglong 0x64 (0x64) + +cast from __int 0x64 to char 0x64 +cast from __int 0x64 to __uchar 0x64 +cast from __int 0x64 to __int 0x64 +cast from __int 0x64 to __uint 0x64 +cast from __int 0x64 to float 0x64 +cast from __int 0x64 (0x64) + to __longlong 0x64 (0x64) + +cast from __int 0x64 (0x64) + to __ulonglong 0x64 (0x64) + +cast from __uint 0x64 to char 0x64 +cast from __uint 0x64 to __uchar 0x64 +cast from __uint 0x64 to __int 0x64 +cast from __uint 0x64 to __uint 0x64 +cast from __uint 0x64 to float 0x64 +cast from __uint 0x64 (0x64) + to __longlong 0x64 (0x64) + +cast from __uint 0x64 (0x64) + to __ulonglong 0x64 (0x64) + +cast from float 0x64 to char 0x64 +cast from float 0x64 to __uchar 0x64 +cast from float 0x64 to __int 0x64 +cast from float 0x64 to __uint 0x64 +cast from float 0x64 to float 0x64 +cast from float 0x64 (0x64) + to __longlong 0x64 (0x64) + +cast from float 0x64 (0x64) + to __ulonglong 0x64 (0x64) + +cast from __longlong 0x64 to char 0x64 +cast from __longlong 0x64 to __uchar 0x64 +cast from __longlong 0x64 to __int 0x64 +cast from __longlong 0x64 to __uint 0x64 +cast from __longlong 0x64 to float 0x64 +cast from __longlong 0x64 (0x64) + to __longlong 0x64 (0x64) + +cast from __longlong 0x64 (0x64) + to __ulonglong 0x64 (0x64) + +cast from __ulonglong 0x64 to char 0x64 +cast from __ulonglong 0x64 to __uchar 0x64 +cast from __ulonglong 0x64 to __int 0x64 +cast from __ulonglong 0x64 to __uint 0x64 +cast from __ulonglong 0x64 to float 0x64 +cast from __ulonglong 0x64 (0x64) + to __longlong 0x64 (0x64) + +cast from __ulonglong 0x64 (0x64) + to __ulonglong 0x64 (0x64) + +casting ll1[0x5] +cast from char 0x40 to char 0x40 +cast from char 0x40 to __uchar 0x40 +cast from char 0x40 to __int 0x40 +cast from char 0x40 to __uint 0x40 +cast from char 0x40 to float 0x40 +cast from char 0x40 (0x40) + to __longlong 0x40 (0x40) + +cast from char 0x40 (0x40) + to __ulonglong 0x40 (0x40) + +cast from __uchar 0x40 to char 0x40 +cast from __uchar 0x40 to __uchar 0x40 +cast from __uchar 0x40 to __int 0x40 +cast from __uchar 0x40 to __uint 0x40 +cast from __uchar 0x40 to float 0x40 +cast from __uchar 0x40 (0x40) + to __longlong 0x40 (0x40) + +cast from __uchar 0x40 (0x40) + to __ulonglong 0x40 (0x40) + +cast from __int 0x4240 to char 0x40 +cast from __int 0x4240 to __uchar 0x40 +cast from __int 0x4240 to __int 0x4240 +cast from __int 0x4240 to __uint 0x4240 +cast from __int 0x4240 to float 0x4240 +cast from __int 0x4240 (0x4240) + to __longlong 0x4240 (0x4240) + +cast from __int 0x4240 (0x4240) + to __ulonglong 0x4240 (0x4240) + +cast from __uint 0x4240 to char 0x40 +cast from __uint 0x4240 to __uchar 0x40 +cast from __uint 0x4240 to __int 0x4240 +cast from __uint 0x4240 to __uint 0x4240 +cast from __uint 0x4240 to float 0x4240 +cast from __uint 0x4240 (0x4240) + to __longlong 0x4240 (0x4240) + +cast from __uint 0x4240 (0x4240) + to __ulonglong 0x4240 (0x4240) + +cast from float 0x4240 to char 0x40 +cast from float 0x4240 to __uchar 0x40 +cast from float 0x4240 to __int 0x4240 +cast from float 0x4240 to __uint 0x4240 +cast from float 0x4240 to float 0x4240 +cast from float 0xf4240 (0xf4240) + to __longlong 0xf4240 (0xf4240) + +cast from float 0xf4240 (0xf4240) + to __ulonglong 0xf4240 (0xf4240) + +cast from __longlong 0x4240 to char 0x40 +cast from __longlong 0x4240 to __uchar 0x40 +cast from __longlong 0x4240 to __int 0x4240 +cast from __longlong 0x4240 to __uint 0x4240 +cast from __longlong 0x4240 to float 0x4240 +cast from __longlong 0xf4240 (0xf4240) + to __longlong 0xf4240 (0xf4240) + +cast from __longlong 0xf4240 (0xf4240) + to __ulonglong 0xf4240 (0xf4240) + +cast from __ulonglong 0x4240 to char 0x40 +cast from __ulonglong 0x4240 to __uchar 0x40 +cast from __ulonglong 0x4240 to __int 0x4240 +cast from __ulonglong 0x4240 to __uint 0x4240 +cast from __ulonglong 0x4240 to float 0x4240 +cast from __ulonglong 0xf4240 (0xf4240) + to __longlong 0xf4240 (0xf4240) + +cast from __ulonglong 0xf4240 (0xf4240) + to __ulonglong 0xf4240 (0xf4240) + +cast from char 0x40 to char 0x40 +cast from char 0x40 to __uchar 0x40 +cast from char 0x40 to __int 0x40 +cast from char 0x40 to __uint 0x40 +cast from char 0x40 to float 0x40 +cast from char 0x40 (0x40) + to __longlong 0x40 (0x40) + +cast from char 0x40 (0x40) + to __ulonglong 0x40 (0x40) + +cast from __uchar 0x40 to char 0x40 +cast from __uchar 0x40 to __uchar 0x40 +cast from __uchar 0x40 to __int 0x40 +cast from __uchar 0x40 to __uint 0x40 +cast from __uchar 0x40 to float 0x40 +cast from __uchar 0x40 (0x40) + to __longlong 0x40 (0x40) + +cast from __uchar 0x40 (0x40) + to __ulonglong 0x40 (0x40) + +cast from __int 0x4240 to char 0x40 +cast from __int 0x4240 to __uchar 0x40 +cast from __int 0x4240 to __int 0x4240 +cast from __int 0x4240 to __uint 0x4240 +cast from __int 0x4240 to float 0x4240 +cast from __int 0x4240 (0x4240) + to __longlong 0x4240 (0x4240) + +cast from __int 0x4240 (0x4240) + to __ulonglong 0x4240 (0x4240) + +cast from __uint 0x4240 to char 0x40 +cast from __uint 0x4240 to __uchar 0x40 +cast from __uint 0x4240 to __int 0x4240 +cast from __uint 0x4240 to __uint 0x4240 +cast from __uint 0x4240 to float 0x4240 +cast from __uint 0x4240 (0x4240) + to __longlong 0x4240 (0x4240) + +cast from __uint 0x4240 (0x4240) + to __ulonglong 0x4240 (0x4240) + +cast from float 0x4240 to char 0x40 +cast from float 0x4240 to __uchar 0x40 +cast from float 0x4240 to __int 0x4240 +cast from float 0x4240 to __uint 0x4240 +cast from float 0x4240 to float 0x4240 +cast from float 0xf4240 (0xf4240) + to __longlong 0xf4240 (0xf4240) + +cast from float 0xf4240 (0xf4240) + to __ulonglong 0xf4240 (0xf4240) + +cast from __longlong 0x4240 to char 0x40 +cast from __longlong 0x4240 to __uchar 0x40 +cast from __longlong 0x4240 to __int 0x4240 +cast from __longlong 0x4240 to __uint 0x4240 +cast from __longlong 0x4240 to float 0x4240 +cast from __longlong 0xf4240 (0xf4240) + to __longlong 0xf4240 (0xf4240) + +cast from __longlong 0xf4240 (0xf4240) + to __ulonglong 0xf4240 (0xf4240) + +cast from __ulonglong 0x4240 to char 0x40 +cast from __ulonglong 0x4240 to __uchar 0x40 +cast from __ulonglong 0x4240 to __int 0x4240 +cast from __ulonglong 0x4240 to __uint 0x4240 +cast from __ulonglong 0x4240 to float 0x4240 +cast from __ulonglong 0xf4240 (0xf4240) + to __longlong 0xf4240 (0xf4240) + +cast from __ulonglong 0xf4240 (0xf4240) + to __ulonglong 0xf4240 (0xf4240) + +cast from char -0x1 to char -0x1 +cast from char 0xffff to __uchar 0xff +cast from char -0x1 to __int -0x1 +cast from char 0xffff to __uint 0xffff +cast from char -0x1 to float -0x1 +cast from char 0xffffffff (0xffffffff) + to __longlong 0xffffffff (0xffffffff) + +cast from char 0xffffffff (0xffffffff) + to __ulonglong 0xffffffff (0xffffffff) + +cast from __uchar 0xff to char -0x1 +cast from __uchar 0xff to __uchar 0xff +cast from __uchar 0xff to __int 0xff +cast from __uchar 0xff to __uint 0xff +cast from __uchar 0xff to float 0xff +cast from __uchar 0xff (0xff) + to __longlong 0xff (0xff) + +cast from __uchar 0xff (0xff) + to __ulonglong 0xff (0xff) + +cast from __int -0x1 to char -0x1 +cast from __int 0xffff to __uchar 0xff +cast from __int -0x1 to __int -0x1 +cast from __int 0xffff to __uint 0xffff +cast from __int -0x1 to float -0x1 +cast from __int 0xffffffff (0xffffffff) + to __longlong 0xffffffff (0xffffffff) + +cast from __int 0xffffffff (0xffffffff) + to __ulonglong 0xffffffff (0xffffffff) + +cast from __uint -0x1 to char -0x1 +cast from __uint 0xffff to __uchar 0xff +cast from __uint -0x1 to __int -0x1 +cast from __uint 0xffff to __uint 0xffff +cast from __uint -0x1 to float -0x1 +cast from __uint 0xffff (0xffff) + to __longlong 0xffff (0xffff) + +cast from __uint 0xffff (0xffff) + to __ulonglong 0xffff (0xffff) + +cast from float -0x1 to char -0x1 +cast from float 0xffff to __uchar 0xff +cast from float -0x1 to __int -0x1 +cast from float 0xffff to __uint 0xffff +cast from float -0x1 to float -0x1 +cast from float 0xffffffff (0xffffffff) + to __longlong 0xffffffff (0xffffffff) + +cast from float 0xffffffff (0xffffffff) + to __ulonglong 0xffffffff (0xffffffff) + +cast from __longlong -0x1 to char -0x1 +cast from __longlong 0xffff to __uchar 0xff +cast from __longlong -0x1 to __int -0x1 +cast from __longlong 0xffff to __uint 0xffff +cast from __longlong -0x1 to float -0x1 +cast from __longlong 0xffffffff (0xffffffff) + to __longlong 0xffffffff (0xffffffff) + +cast from __longlong 0xffffffff (0xffffffff) + to __ulonglong 0xffffffff (0xffffffff) + +cast from __ulonglong -0x1 to char -0x1 +cast from __ulonglong 0xffff to __uchar 0xff +cast from __ulonglong -0x1 to __int -0x1 +cast from __ulonglong 0xffff to __uint 0xffff +cast from __ulonglong -0x1 to float 0x0 +cast from __ulonglong 0xffffffff (0xffffffff) + to __longlong 0xffffffff (0xffffffff) + +cast from __ulonglong 0xffffffff (0xffffffff) + to __ulonglong 0xffffffff (0xffffffff) + +cast from char -0x1 to char -0x1 +cast from char 0xffff to __uchar 0xff +cast from char -0x1 to __int -0x1 +cast from char 0xffff to __uint 0xffff +cast from char -0x1 to float -0x1 +cast from char 0xffffffff (0xffffffff) + to __longlong 0xffffffff (0xffffffff) + +cast from char 0xffffffff (0xffffffff) + to __ulonglong 0xffffffff (0xffffffff) + +cast from __uchar 0xff to char -0x1 +cast from __uchar 0xff to __uchar 0xff +cast from __uchar 0xff to __int 0xff +cast from __uchar 0xff to __uint 0xff +cast from __uchar 0xff to float 0xff +cast from __uchar 0xff (0xff) + to __longlong 0xff (0xff) + +cast from __uchar 0xff (0xff) + to __ulonglong 0xff (0xff) + +cast from __int 0xff to char -0x1 +cast from __int 0xff to __uchar 0xff +cast from __int 0xff to __int 0xff +cast from __int 0xff to __uint 0xff +cast from __int 0xff to float 0xff +cast from __int 0xff (0xff) + to __longlong 0xff (0xff) + +cast from __int 0xff (0xff) + to __ulonglong 0xff (0xff) + +cast from __uint 0xff to char -0x1 +cast from __uint 0xff to __uchar 0xff +cast from __uint 0xff to __int 0xff +cast from __uint 0xff to __uint 0xff +cast from __uint 0xff to float 0xff +cast from __uint 0xff (0xff) + to __longlong 0xff (0xff) + +cast from __uint 0xff (0xff) + to __ulonglong 0xff (0xff) + +cast from float 0xff to char -0x1 +cast from float 0xff to __uchar 0xff +cast from float 0xff to __int 0xff +cast from float 0xff to __uint 0xff +cast from float 0xff to float 0xff +cast from float 0xff (0xff) + to __longlong 0xff (0xff) + +cast from float 0xff (0xff) + to __ulonglong 0xff (0xff) + +cast from __longlong 0xff to char -0x1 +cast from __longlong 0xff to __uchar 0xff +cast from __longlong 0xff to __int 0xff +cast from __longlong 0xff to __uint 0xff +cast from __longlong 0xff to float 0xff +cast from __longlong 0xff (0xff) + to __longlong 0xff (0xff) + +cast from __longlong 0xff (0xff) + to __ulonglong 0xff (0xff) + +cast from __ulonglong 0xff to char -0x1 +cast from __ulonglong 0xff to __uchar 0xff +cast from __ulonglong 0xff to __int 0xff +cast from __ulonglong 0xff to __uint 0xff +cast from __ulonglong 0xff to float 0xff +cast from __ulonglong 0xff (0xff) + to __longlong 0xff (0xff) + +cast from __ulonglong 0xff (0xff) + to __ulonglong 0xff (0xff) + +cast from char 0x0 to char 0x0 +cast from char 0x0 to __uchar 0x0 +cast from char 0x0 to __int 0x0 +cast from char 0x0 to __uint 0x0 +cast from char 0x0 to float 0x0 +cast from char 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from char 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __uchar 0x0 to char 0x0 +cast from __uchar 0x0 to __uchar 0x0 +cast from __uchar 0x0 to __int 0x0 +cast from __uchar 0x0 to __uint 0x0 +cast from __uchar 0x0 to float 0x0 +cast from __uchar 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __uchar 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __int 0x0 to char 0x0 +cast from __int 0x0 to __uchar 0x0 +cast from __int 0x0 to __int 0x0 +cast from __int 0x0 to __uint 0x0 +cast from __int 0x0 to float 0x0 +cast from __int 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __int 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __uint 0x0 to char 0x0 +cast from __uint 0x0 to __uchar 0x0 +cast from __uint 0x0 to __int 0x0 +cast from __uint 0x0 to __uint 0x0 +cast from __uint 0x0 to float 0x0 +cast from __uint 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __uint 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from float 0x0 to char 0x0 +cast from float 0x0 to __uchar 0x0 +cast from float 0x0 to __int 0x0 +cast from float 0x0 to __uint 0x0 +cast from float 0x0 to float 0x0 +cast from float 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from float 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __longlong 0x0 to char 0x0 +cast from __longlong 0x0 to __uchar 0x0 +cast from __longlong 0x0 to __int 0x0 +cast from __longlong 0x0 to __uint 0x0 +cast from __longlong 0x0 to float 0x0 +cast from __longlong 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __longlong 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __ulonglong 0x0 to char 0x0 +cast from __ulonglong 0x0 to __uchar 0x0 +cast from __ulonglong 0x0 to __int 0x0 +cast from __ulonglong 0x0 to __uint 0x0 +cast from __ulonglong 0x0 to float 0x0 +cast from __ulonglong 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __ulonglong 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from char 0x0 to char 0x0 +cast from char 0x0 to __uchar 0x0 +cast from char 0x0 to __int 0x0 +cast from char 0x0 to __uint 0x0 +cast from char 0x0 to float 0x0 +cast from char 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from char 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __uchar 0x0 to char 0x0 +cast from __uchar 0x0 to __uchar 0x0 +cast from __uchar 0x0 to __int 0x0 +cast from __uchar 0x0 to __uint 0x0 +cast from __uchar 0x0 to float 0x0 +cast from __uchar 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __uchar 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __int 0x0 to char 0x0 +cast from __int 0x0 to __uchar 0x0 +cast from __int 0x0 to __int 0x0 +cast from __int 0x0 to __uint 0x0 +cast from __int 0x0 to float 0x0 +cast from __int 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __int 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __uint 0x0 to char 0x0 +cast from __uint 0x0 to __uchar 0x0 +cast from __uint 0x0 to __int 0x0 +cast from __uint 0x0 to __uint 0x0 +cast from __uint 0x0 to float 0x0 +cast from __uint 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __uint 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from float 0x0 to char 0x0 +cast from float 0x0 to __uchar 0x0 +cast from float 0x0 to __int 0x0 +cast from float 0x0 to __uint 0x0 +cast from float 0x0 to float 0x0 +cast from float 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from float 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __longlong 0x0 to char 0x0 +cast from __longlong 0x0 to __uchar 0x0 +cast from __longlong 0x0 to __int 0x0 +cast from __longlong 0x0 to __uint 0x0 +cast from __longlong 0x0 to float 0x0 +cast from __longlong 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __longlong 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from __ulonglong 0x0 to char 0x0 +cast from __ulonglong 0x0 to __uchar 0x0 +cast from __ulonglong 0x0 to __int 0x0 +cast from __ulonglong 0x0 to __uint 0x0 +cast from __ulonglong 0x0 to float 0x0 +cast from __ulonglong 0x0 (0x0) + to __longlong 0x0 (0x0) + +cast from __ulonglong 0x0 (0x0) + to __ulonglong 0x0 (0x0) + +cast from char 0x1 to char 0x1 +cast from char 0x1 to __uchar 0x1 +cast from char 0x1 to __int 0x1 +cast from char 0x1 to __uint 0x1 +cast from char 0x1 to float 0x1 +cast from char 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from char 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __uchar 0x1 to char 0x1 +cast from __uchar 0x1 to __uchar 0x1 +cast from __uchar 0x1 to __int 0x1 +cast from __uchar 0x1 to __uint 0x1 +cast from __uchar 0x1 to float 0x1 +cast from __uchar 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __uchar 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __int 0x1 to char 0x1 +cast from __int 0x1 to __uchar 0x1 +cast from __int 0x1 to __int 0x1 +cast from __int 0x1 to __uint 0x1 +cast from __int 0x1 to float 0x1 +cast from __int 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __int 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __uint 0x1 to char 0x1 +cast from __uint 0x1 to __uchar 0x1 +cast from __uint 0x1 to __int 0x1 +cast from __uint 0x1 to __uint 0x1 +cast from __uint 0x1 to float 0x1 +cast from __uint 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __uint 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from float 0x1 to char 0x1 +cast from float 0x1 to __uchar 0x1 +cast from float 0x1 to __int 0x1 +cast from float 0x1 to __uint 0x1 +cast from float 0x1 to float 0x1 +cast from float 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from float 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __longlong 0x1 to char 0x1 +cast from __longlong 0x1 to __uchar 0x1 +cast from __longlong 0x1 to __int 0x1 +cast from __longlong 0x1 to __uint 0x1 +cast from __longlong 0x1 to float 0x1 +cast from __longlong 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __longlong 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __ulonglong 0x1 to char 0x1 +cast from __ulonglong 0x1 to __uchar 0x1 +cast from __ulonglong 0x1 to __int 0x1 +cast from __ulonglong 0x1 to __uint 0x1 +cast from __ulonglong 0x1 to float 0x1 +cast from __ulonglong 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __ulonglong 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from char 0x1 to char 0x1 +cast from char 0x1 to __uchar 0x1 +cast from char 0x1 to __int 0x1 +cast from char 0x1 to __uint 0x1 +cast from char 0x1 to float 0x1 +cast from char 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from char 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __uchar 0x1 to char 0x1 +cast from __uchar 0x1 to __uchar 0x1 +cast from __uchar 0x1 to __int 0x1 +cast from __uchar 0x1 to __uint 0x1 +cast from __uchar 0x1 to float 0x1 +cast from __uchar 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __uchar 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __int 0x1 to char 0x1 +cast from __int 0x1 to __uchar 0x1 +cast from __int 0x1 to __int 0x1 +cast from __int 0x1 to __uint 0x1 +cast from __int 0x1 to float 0x1 +cast from __int 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __int 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __uint 0x1 to char 0x1 +cast from __uint 0x1 to __uchar 0x1 +cast from __uint 0x1 to __int 0x1 +cast from __uint 0x1 to __uint 0x1 +cast from __uint 0x1 to float 0x1 +cast from __uint 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __uint 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from float 0x1 to char 0x1 +cast from float 0x1 to __uchar 0x1 +cast from float 0x1 to __int 0x1 +cast from float 0x1 to __uint 0x1 +cast from float 0x1 to float 0x1 +cast from float 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from float 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __longlong 0x1 to char 0x1 +cast from __longlong 0x1 to __uchar 0x1 +cast from __longlong 0x1 to __int 0x1 +cast from __longlong 0x1 to __uint 0x1 +cast from __longlong 0x1 to float 0x1 +cast from __longlong 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __longlong 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from __ulonglong 0x1 to char 0x1 +cast from __ulonglong 0x1 to __uchar 0x1 +cast from __ulonglong 0x1 to __int 0x1 +cast from __ulonglong 0x1 to __uint 0x1 +cast from __ulonglong 0x1 to float 0x1 +cast from __ulonglong 0x1 (0x1) + to __longlong 0x1 (0x1) + +cast from __ulonglong 0x1 (0x1) + to __ulonglong 0x1 (0x1) + +cast from char 0xa to char 0xa +cast from char 0xa to __uchar 0xa +cast from char 0xa to __int 0xa +cast from char 0xa to __uint 0xa +cast from char 0xa to float 0xa +cast from char 0xa (0xa) + to __longlong 0xa (0xa) + +cast from char 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from __uchar 0xa to char 0xa +cast from __uchar 0xa to __uchar 0xa +cast from __uchar 0xa to __int 0xa +cast from __uchar 0xa to __uint 0xa +cast from __uchar 0xa to float 0xa +cast from __uchar 0xa (0xa) + to __longlong 0xa (0xa) + +cast from __uchar 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from __int 0xa to char 0xa +cast from __int 0xa to __uchar 0xa +cast from __int 0xa to __int 0xa +cast from __int 0xa to __uint 0xa +cast from __int 0xa to float 0xa +cast from __int 0xa (0xa) + to __longlong 0xa (0xa) + +cast from __int 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from __uint 0xa to char 0xa +cast from __uint 0xa to __uchar 0xa +cast from __uint 0xa to __int 0xa +cast from __uint 0xa to __uint 0xa +cast from __uint 0xa to float 0xa +cast from __uint 0xa (0xa) + to __longlong 0xa (0xa) + +cast from __uint 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from float 0xa to char 0xa +cast from float 0xa to __uchar 0xa +cast from float 0xa to __int 0xa +cast from float 0xa to __uint 0xa +cast from float 0xa to float 0xa +cast from float 0xa (0xa) + to __longlong 0xa (0xa) + +cast from float 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from __longlong 0xa to char 0xa +cast from __longlong 0xa to __uchar 0xa +cast from __longlong 0xa to __int 0xa +cast from __longlong 0xa to __uint 0xa +cast from __longlong 0xa to float 0xa +cast from __longlong 0xa (0xa) + to __longlong 0xa (0xa) + +cast from __longlong 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from __ulonglong 0xa to char 0xa +cast from __ulonglong 0xa to __uchar 0xa +cast from __ulonglong 0xa to __int 0xa +cast from __ulonglong 0xa to __uint 0xa +cast from __ulonglong 0xa to float 0xa +cast from __ulonglong 0xa (0xa) + to __longlong 0xa (0xa) + +cast from __ulonglong 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from char 0xa to char 0xa +cast from char 0xa to __uchar 0xa +cast from char 0xa to __int 0xa +cast from char 0xa to __uint 0xa +cast from char 0xa to float 0xa +cast from char 0xa (0xa) + to __longlong 0xa (0xa) + +cast from char 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from __uchar 0xa to char 0xa +cast from __uchar 0xa to __uchar 0xa +cast from __uchar 0xa to __int 0xa +cast from __uchar 0xa to __uint 0xa +cast from __uchar 0xa to float 0xa +cast from __uchar 0xa (0xa) + to __longlong 0xa (0xa) + +cast from __uchar 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from __int 0xa to char 0xa +cast from __int 0xa to __uchar 0xa +cast from __int 0xa to __int 0xa +cast from __int 0xa to __uint 0xa +cast from __int 0xa to float 0xa +cast from __int 0xa (0xa) + to __longlong 0xa (0xa) + +cast from __int 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from __uint 0xa to char 0xa +cast from __uint 0xa to __uchar 0xa +cast from __uint 0xa to __int 0xa +cast from __uint 0xa to __uint 0xa +cast from __uint 0xa to float 0xa +cast from __uint 0xa (0xa) + to __longlong 0xa (0xa) + +cast from __uint 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from float 0xa to char 0xa +cast from float 0xa to __uchar 0xa +cast from float 0xa to __int 0xa +cast from float 0xa to __uint 0xa +cast from float 0xa to float 0xa +cast from float 0xa (0xa) + to __longlong 0xa (0xa) + +cast from float 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from __longlong 0xa to char 0xa +cast from __longlong 0xa to __uchar 0xa +cast from __longlong 0xa to __int 0xa +cast from __longlong 0xa to __uint 0xa +cast from __longlong 0xa to float 0xa +cast from __longlong 0xa (0xa) + to __longlong 0xa (0xa) + +cast from __longlong 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from __ulonglong 0xa to char 0xa +cast from __ulonglong 0xa to __uchar 0xa +cast from __ulonglong 0xa to __int 0xa +cast from __ulonglong 0xa to __uint 0xa +cast from __ulonglong 0xa to float 0xa +cast from __ulonglong 0xa (0xa) + to __longlong 0xa (0xa) + +cast from __ulonglong 0xa (0xa) + to __ulonglong 0xa (0xa) + +cast from char 0x17 to char 0x17 +cast from char 0x17 to __uchar 0x17 +cast from char 0x17 to __int 0x17 +cast from char 0x17 to __uint 0x17 +cast from char 0x17 to float 0x17 +cast from char 0x17 (0x17) + to __longlong 0x17 (0x17) + +cast from char 0x17 (0x17) + to __ulonglong 0x17 (0x17) + +cast from __uchar 0x17 to char 0x17 +cast from __uchar 0x17 to __uchar 0x17 +cast from __uchar 0x17 to __int 0x17 +cast from __uchar 0x17 to __uint 0x17 +cast from __uchar 0x17 to float 0x17 +cast from __uchar 0x17 (0x17) + to __longlong 0x17 (0x17) + +cast from __uchar 0x17 (0x17) + to __ulonglong 0x17 (0x17) + +cast from __int 0x17 to char 0x17 +cast from __int 0x17 to __uchar 0x17 +cast from __int 0x17 to __int 0x17 +cast from __int 0x17 to __uint 0x17 +cast from __int 0x17 to float 0x17 +cast from __int 0x17 (0x17) + to __longlong 0x17 (0x17) + +cast from __int 0x17 (0x17) + to __ulonglong 0x17 (0x17) + +cast from __uint 0x17 to char 0x17 +cast from __uint 0x17 to __uchar 0x17 +cast from __uint 0x17 to __int 0x17 +cast from __uint 0x17 to __uint 0x17 +cast from __uint 0x17 to float 0x17 +cast from __uint 0x17 (0x17) + to __longlong 0x17 (0x17) + +cast from __uint 0x17 (0x17) + to __ulonglong 0x17 (0x17) + +cast from float 0x17 to char 0x17 +cast from float 0x17 to __uchar 0x17 +cast from float 0x17 to __int 0x17 +cast from float 0x17 to __uint 0x17 +cast from float 0x17 to float 0x17 +cast from float 0x17 (0x17) + to __longlong 0x17 (0x17) + +cast from float 0x17 (0x17) + to __ulonglong 0x17 (0x17) + +cast from __longlong 0x17 to char 0x17 +cast from __longlong 0x17 to __uchar 0x17 +cast from __longlong 0x17 to __int 0x17 +cast from __longlong 0x17 to __uint 0x17 +cast from __longlong 0x17 to float 0x17 +cast from __longlong 0x17 (0x17) + to __longlong 0x17 (0x17) + +cast from __longlong 0x17 (0x17) + to __ulonglong 0x17 (0x17) + +cast from __ulonglong 0x17 to char 0x17 +cast from __ulonglong 0x17 to __uchar 0x17 +cast from __ulonglong 0x17 to __int 0x17 +cast from __ulonglong 0x17 to __uint 0x17 +cast from __ulonglong 0x17 to float 0x17 +cast from __ulonglong 0x17 (0x17) + to __longlong 0x17 (0x17) + +cast from __ulonglong 0x17 (0x17) + to __ulonglong 0x17 (0x17) + +cast from char 0x17 to char 0x17 +cast from char 0x17 to __uchar 0x17 +cast from char 0x17 to __int 0x17 +cast from char 0x17 to __uint 0x17 +cast from char 0x17 to float 0x17 +cast from char 0x17 (0x17) + to __longlong 0x17 (0x17) + +cast from char 0x17 (0x17) + to __ulonglong 0x17 (0x17) + +cast from __uchar 0x17 to char 0x17 +cast from __uchar 0x17 to __uchar 0x17 +cast from __uchar 0x17 to __int 0x17 +cast from __uchar 0x17 to __uint 0x17 +cast from __uchar 0x17 to float 0x17 +cast from __uchar 0x17 (0x17) + to __longlong 0x17 (0x17) + +cast from __uchar 0x17 (0x17) + to __ulonglong 0x17 (0x17) + +cast from __int 0x17 to char 0x17 +cast from __int 0x17 to __uchar 0x17 +cast from __int 0x17 to __int 0x17 +cast from __int 0x17 to __uint 0x17 +cast from __int 0x17 to float 0x17 +cast from __int 0x17 (0x17) + to __longlong 0x17 (0x17) + +cast from __int 0x17 (0x17) + to __ulonglong 0x17 (0x17) + +cast from __uint 0x17 to char 0x17 +cast from __uint 0x17 to __uchar 0x17 +cast from __uint 0x17 to __int 0x17 +cast from __uint 0x17 to __uint 0x17 +cast from __uint 0x17 to float 0x17 +cast from __uint 0x17 (0x17) + to __longlong 0x17 (0x17) + +cast from __uint 0x17 (0x17) + to __ulonglong 0x17 (0x17) + +cast from float 0x17 to char 0x17 +cast from float 0x17 to __uchar 0x17 +cast from float 0x17 to __int 0x17 +cast from float 0x17 to __uint 0x17 +cast from float 0x17 to float 0x17 +cast from float 0x17 (0x17) + to __longlong 0x17 (0x17) + +cast from float 0x17 (0x17) + to __ulonglong 0x17 (0x17) + +cast from __longlong 0x17 to char 0x17 +cast from __longlong 0x17 to __uchar 0x17 +cast from __longlong 0x17 to __int 0x17 +cast from __longlong 0x17 to __uint 0x17 +cast from __longlong 0x17 to float 0x17 +cast from __longlong 0x17 (0x17) + to __longlong 0x17 (0x17) + +cast from __longlong 0x17 (0x17) + to __ulonglong 0x17 (0x17) + +cast from __ulonglong 0x17 to char 0x17 +cast from __ulonglong 0x17 to __uchar 0x17 +cast from __ulonglong 0x17 to __int 0x17 +cast from __ulonglong 0x17 to __uint 0x17 +cast from __ulonglong 0x17 to float 0x17 +cast from __ulonglong 0x17 (0x17) + to __longlong 0x17 (0x17) + +cast from __ulonglong 0x17 (0x17) + to __ulonglong 0x17 (0x17) + +cast from char 0x2a to char 0x2a +cast from char 0x2a to __uchar 0x2a +cast from char 0x2a to __int 0x2a +cast from char 0x2a to __uint 0x2a +cast from char 0x2a to float 0x2a +cast from char 0x2a (0x2a) + to __longlong 0x2a (0x2a) + +cast from char 0x2a (0x2a) + to __ulonglong 0x2a (0x2a) + +cast from __uchar 0x2a to char 0x2a +cast from __uchar 0x2a to __uchar 0x2a +cast from __uchar 0x2a to __int 0x2a +cast from __uchar 0x2a to __uint 0x2a +cast from __uchar 0x2a to float 0x2a +cast from __uchar 0x2a (0x2a) + to __longlong 0x2a (0x2a) + +cast from __uchar 0x2a (0x2a) + to __ulonglong 0x2a (0x2a) + +cast from __int 0x2a to char 0x2a +cast from __int 0x2a to __uchar 0x2a +cast from __int 0x2a to __int 0x2a +cast from __int 0x2a to __uint 0x2a +cast from __int 0x2a to float 0x2a +cast from __int 0x2a (0x2a) + to __longlong 0x2a (0x2a) + +cast from __int 0x2a (0x2a) + to __ulonglong 0x2a (0x2a) + +cast from __uint 0x2a to char 0x2a +cast from __uint 0x2a to __uchar 0x2a +cast from __uint 0x2a to __int 0x2a +cast from __uint 0x2a to __uint 0x2a +cast from __uint 0x2a to float 0x2a +cast from __uint 0x2a (0x2a) + to __longlong 0x2a (0x2a) + +cast from __uint 0x2a (0x2a) + to __ulonglong 0x2a (0x2a) + +cast from float 0x2a to char 0x2a +cast from float 0x2a to __uchar 0x2a +cast from float 0x2a to __int 0x2a +cast from float 0x2a to __uint 0x2a +cast from float 0x2a to float 0x2a +cast from float 0x2a (0x2a) + to __longlong 0x2a (0x2a) + +cast from float 0x2a (0x2a) + to __ulonglong 0x2a (0x2a) + +cast from __longlong 0x2a to char 0x2a +cast from __longlong 0x2a to __uchar 0x2a +cast from __longlong 0x2a to __int 0x2a +cast from __longlong 0x2a to __uint 0x2a +cast from __longlong 0x2a to float 0x2a +cast from __longlong 0x2a (0x2a) + to __longlong 0x2a (0x2a) + +cast from __longlong 0x2a (0x2a) + to __ulonglong 0x2a (0x2a) + +cast from __ulonglong 0x2a to char 0x2a +cast from __ulonglong 0x2a to __uchar 0x2a +cast from __ulonglong 0x2a to __int 0x2a +cast from __ulonglong 0x2a to __uint 0x2a +cast from __ulonglong 0x2a to float 0x2a +cast from __ulonglong 0x2a (0x2a) + to __longlong 0x2a (0x2a) + +cast from __ulonglong 0x2a (0x2a) + to __ulonglong 0x2a (0x2a) + +cast from char 0x2a to char 0x2a +cast from char 0x2a to __uchar 0x2a +cast from char 0x2a to __int 0x2a +cast from char 0x2a to __uint 0x2a +cast from char 0x2a to float 0x2a +cast from char 0x2a (0x2a) + to __longlong 0x2a (0x2a) + +cast from char 0x2a (0x2a) + to __ulonglong 0x2a (0x2a) + +cast from __uchar 0x2a to char 0x2a +cast from __uchar 0x2a to __uchar 0x2a +cast from __uchar 0x2a to __int 0x2a +cast from __uchar 0x2a to __uint 0x2a +cast from __uchar 0x2a to float 0x2a +cast from __uchar 0x2a (0x2a) + to __longlong 0x2a (0x2a) + +cast from __uchar 0x2a (0x2a) + to __ulonglong 0x2a (0x2a) + +cast from __int 0x2a to char 0x2a +cast from __int 0x2a to __uchar 0x2a +cast from __int 0x2a to __int 0x2a +cast from __int 0x2a to __uint 0x2a +cast from __int 0x2a to float 0x2a +cast from __int 0x2a (0x2a) + to __longlong 0x2a (0x2a) + +cast from __int 0x2a (0x2a) + to __ulonglong 0x2a (0x2a) + +cast from __uint 0x2a to char 0x2a +cast from __uint 0x2a to __uchar 0x2a +cast from __uint 0x2a to __int 0x2a +cast from __uint 0x2a to __uint 0x2a +cast from __uint 0x2a to float 0x2a +cast from __uint 0x2a (0x2a) + to __longlong 0x2a (0x2a) + +cast from __uint 0x2a (0x2a) + to __ulonglong 0x2a (0x2a) + +cast from float 0x2a to char 0x2a +cast from float 0x2a to __uchar 0x2a +cast from float 0x2a to __int 0x2a +cast from float 0x2a to __uint 0x2a +cast from float 0x2a to float 0x2a +cast from float 0x2a (0x2a) + to __longlong 0x2a (0x2a) + +cast from float 0x2a (0x2a) + to __ulonglong 0x2a (0x2a) + +cast from __longlong 0x2a to char 0x2a +cast from __longlong 0x2a to __uchar 0x2a +cast from __longlong 0x2a to __int 0x2a +cast from __longlong 0x2a to __uint 0x2a +cast from __longlong 0x2a to float 0x2a +cast from __longlong 0x2a (0x2a) + to __longlong 0x2a (0x2a) + +cast from __longlong 0x2a (0x2a) + to __ulonglong 0x2a (0x2a) + +cast from __ulonglong 0x2a to char 0x2a +cast from __ulonglong 0x2a to __uchar 0x2a +cast from __ulonglong 0x2a to __int 0x2a +cast from __ulonglong 0x2a to __uint 0x2a +cast from __ulonglong 0x2a to float 0x2a +cast from __ulonglong 0x2a (0x2a) + to __longlong 0x2a (0x2a) + +cast from __ulonglong 0x2a (0x2a) + to __ulonglong 0x2a (0x2a) + +cast from char 0x7f to char 0x7f +cast from char 0x7f to __uchar 0x7f +cast from char 0x7f to __int 0x7f +cast from char 0x7f to __uint 0x7f +cast from char 0x7f to float 0x7f +cast from char 0x7f (0x7f) + to __longlong 0x7f (0x7f) + +cast from char 0x7f (0x7f) + to __ulonglong 0x7f (0x7f) + +cast from __uchar 0x7f to char 0x7f +cast from __uchar 0x7f to __uchar 0x7f +cast from __uchar 0x7f to __int 0x7f +cast from __uchar 0x7f to __uint 0x7f +cast from __uchar 0x7f to float 0x7f +cast from __uchar 0x7f (0x7f) + to __longlong 0x7f (0x7f) + +cast from __uchar 0x7f (0x7f) + to __ulonglong 0x7f (0x7f) + +cast from __int 0x7f to char 0x7f +cast from __int 0x7f to __uchar 0x7f +cast from __int 0x7f to __int 0x7f +cast from __int 0x7f to __uint 0x7f +cast from __int 0x7f to float 0x7f +cast from __int 0x7f (0x7f) + to __longlong 0x7f (0x7f) + +cast from __int 0x7f (0x7f) + to __ulonglong 0x7f (0x7f) + +cast from __uint 0x7f to char 0x7f +cast from __uint 0x7f to __uchar 0x7f +cast from __uint 0x7f to __int 0x7f +cast from __uint 0x7f to __uint 0x7f +cast from __uint 0x7f to float 0x7f +cast from __uint 0x7f (0x7f) + to __longlong 0x7f (0x7f) + +cast from __uint 0x7f (0x7f) + to __ulonglong 0x7f (0x7f) + +cast from float 0x7f to char 0x7f +cast from float 0x7f to __uchar 0x7f +cast from float 0x7f to __int 0x7f +cast from float 0x7f to __uint 0x7f +cast from float 0x7f to float 0x7f +cast from float 0x7f (0x7f) + to __longlong 0x7f (0x7f) + +cast from float 0x7f (0x7f) + to __ulonglong 0x7f (0x7f) + +cast from __longlong 0x7f to char 0x7f +cast from __longlong 0x7f to __uchar 0x7f +cast from __longlong 0x7f to __int 0x7f +cast from __longlong 0x7f to __uint 0x7f +cast from __longlong 0x7f to float 0x7f +cast from __longlong 0x7f (0x7f) + to __longlong 0x7f (0x7f) + +cast from __longlong 0x7f (0x7f) + to __ulonglong 0x7f (0x7f) + +cast from __ulonglong 0x7f to char 0x7f +cast from __ulonglong 0x7f to __uchar 0x7f +cast from __ulonglong 0x7f to __int 0x7f +cast from __ulonglong 0x7f to __uint 0x7f +cast from __ulonglong 0x7f to float 0x7f +cast from __ulonglong 0x7f (0x7f) + to __longlong 0x7f (0x7f) + +cast from __ulonglong 0x7f (0x7f) + to __ulonglong 0x7f (0x7f) + +cast from char 0x7f to char 0x7f +cast from char 0x7f to __uchar 0x7f +cast from char 0x7f to __int 0x7f +cast from char 0x7f to __uint 0x7f +cast from char 0x7f to float 0x7f +cast from char 0x7f (0x7f) + to __longlong 0x7f (0x7f) + +cast from char 0x7f (0x7f) + to __ulonglong 0x7f (0x7f) + +cast from __uchar 0x7f to char 0x7f +cast from __uchar 0x7f to __uchar 0x7f +cast from __uchar 0x7f to __int 0x7f +cast from __uchar 0x7f to __uint 0x7f +cast from __uchar 0x7f to float 0x7f +cast from __uchar 0x7f (0x7f) + to __longlong 0x7f (0x7f) + +cast from __uchar 0x7f (0x7f) + to __ulonglong 0x7f (0x7f) + +cast from __int 0x7f to char 0x7f +cast from __int 0x7f to __uchar 0x7f +cast from __int 0x7f to __int 0x7f +cast from __int 0x7f to __uint 0x7f +cast from __int 0x7f to float 0x7f +cast from __int 0x7f (0x7f) + to __longlong 0x7f (0x7f) + +cast from __int 0x7f (0x7f) + to __ulonglong 0x7f (0x7f) + +cast from __uint 0x7f to char 0x7f +cast from __uint 0x7f to __uchar 0x7f +cast from __uint 0x7f to __int 0x7f +cast from __uint 0x7f to __uint 0x7f +cast from __uint 0x7f to float 0x7f +cast from __uint 0x7f (0x7f) + to __longlong 0x7f (0x7f) + +cast from __uint 0x7f (0x7f) + to __ulonglong 0x7f (0x7f) + +cast from float 0x7f to char 0x7f +cast from float 0x7f to __uchar 0x7f +cast from float 0x7f to __int 0x7f +cast from float 0x7f to __uint 0x7f +cast from float 0x7f to float 0x7f +cast from float 0x7f (0x7f) + to __longlong 0x7f (0x7f) + +cast from float 0x7f (0x7f) + to __ulonglong 0x7f (0x7f) + +cast from __longlong 0x7f to char 0x7f +cast from __longlong 0x7f to __uchar 0x7f +cast from __longlong 0x7f to __int 0x7f +cast from __longlong 0x7f to __uint 0x7f +cast from __longlong 0x7f to float 0x7f +cast from __longlong 0x7f (0x7f) + to __longlong 0x7f (0x7f) + +cast from __longlong 0x7f (0x7f) + to __ulonglong 0x7f (0x7f) + +cast from __ulonglong 0x7f to char 0x7f +cast from __ulonglong 0x7f to __uchar 0x7f +cast from __ulonglong 0x7f to __int 0x7f +cast from __ulonglong 0x7f to __uint 0x7f +cast from __ulonglong 0x7f to float 0x7f +cast from __ulonglong 0x7f (0x7f) + to __longlong 0x7f (0x7f) + +cast from __ulonglong 0x7f (0x7f) + to __ulonglong 0x7f (0x7f) + +int ~0x0 ~ -0x1 +xchar int ~0x0 ~ -0x1 +int ~0x0 ~ -0x1 +__uint ~0x0 ~ -0x1 +char ~0x0 ~ -0x1 +__uchar ~0x0 ~ 0xff +__longlong ~0x0 ~ -0x1 +__ulonglong ~0x0 ~ -0x1 +int !0x0 ! 0x1 +__uint !0x0 ! 0x1 +char !0x0 ! 0x1 +__uchar !0x0 ! 0x1 +__longlong !0x0 ! 0x1 +__ulonglong !0x0 ! 0x1 +int -0x0 - 0x0 +__uint -0x0 - 0x0 +char -0x0 - 0x0 +__uchar -0x0 - 0x0 +__longlong -0x0 - 0x0 +__ulonglong -0x0 - 0x0 +int ~-0x1 ~ 0x0 +xchar int ~-0x1 ~ 0x0 +int ~-0x1 ~ 0x0 +__uint ~-0x1 ~ 0x0 +char ~-0x1 ~ 0x0 +__uchar ~0xff ~ 0x0 +__longlong ~-0x1 ~ 0x0 +__ulonglong ~-0x1 ~ 0x0 +int !-0x1 ! 0x0 +__uint !-0x1 ! 0x0 +char !-0x1 ! 0x0 +__uchar !0xff ! 0x0 +__longlong !-0x1 ! 0x0 +__ulonglong !-0x1 ! 0x0 +int --0x1 - 0x1 +__uint --0x1 - 0x1 +char --0x1 - 0x1 +__uchar -0xff - 0x1 +__longlong --0x1 - 0x1 +__ulonglong --0x1 - 0x1 +int ~0x1 ~ -0x2 +xchar int ~0x1 ~ -0x2 +int ~0x1 ~ -0x2 +__uint ~0x1 ~ -0x2 +char ~0x1 ~ -0x2 +__uchar ~0x1 ~ 0xfe +__longlong ~0x1 ~ -0x2 +__ulonglong ~0x1 ~ -0x2 +int !0x1 ! 0x0 +__uint !0x1 ! 0x0 +char !0x1 ! 0x0 +__uchar !0x1 ! 0x0 +__longlong !0x1 ! 0x0 +__ulonglong !0x1 ! 0x0 +int -0x1 - -0x1 +__uint -0x1 - -0x1 +char -0x1 - -0x1 +__uchar -0x1 - 0xff +__longlong -0x1 - -0x1 +__ulonglong -0x1 - -0x1 +int ~0x2 ~ -0x3 +xchar int ~0x2 ~ -0x3 +int ~0x2 ~ -0x3 +__uint ~0x2 ~ -0x3 +char ~0x2 ~ -0x3 +__uchar ~0x2 ~ 0xfd +__longlong ~0x2 ~ -0x3 +__ulonglong ~0x2 ~ -0x3 +int !0x2 ! 0x0 +__uint !0x2 ! 0x0 +char !0x2 ! 0x0 +__uchar !0x2 ! 0x0 +__longlong !0x2 ! 0x0 +__ulonglong !0x2 ! 0x0 +int -0x2 - -0x2 +__uint -0x2 - -0x2 +char -0x2 - -0x2 +__uchar -0x2 - 0xfe +__longlong -0x2 - -0x2 +__ulonglong -0x2 - -0x2 +int ~-0x2 ~ 0x1 +xchar int ~-0x2 ~ 0x1 +int ~-0x2 ~ 0x1 +__uint ~-0x2 ~ 0x1 +char ~-0x2 ~ 0x1 +__uchar ~0xfe ~ 0x1 +__longlong ~-0x2 ~ 0x1 +__ulonglong ~-0x2 ~ 0x1 +int !-0x2 ! 0x0 +__uint !-0x2 ! 0x0 +char !-0x2 ! 0x0 +__uchar !0xfe ! 0x0 +__longlong !-0x2 ! 0x0 +__ulonglong !-0x2 ! 0x0 +int --0x2 - 0x2 +__uint --0x2 - 0x2 +char --0x2 - 0x2 +__uchar -0xfe - 0x2 +__longlong --0x2 - 0x2 +__ulonglong --0x2 - 0x2 +int ~0x4 ~ -0x5 +xchar int ~0x4 ~ -0x5 +int ~0x4 ~ -0x5 +__uint ~0x4 ~ -0x5 +char ~0x4 ~ -0x5 +__uchar ~0x4 ~ 0xfb +__longlong ~0x4 ~ -0x5 +__ulonglong ~0x4 ~ -0x5 +int !0x4 ! 0x0 +__uint !0x4 ! 0x0 +char !0x4 ! 0x0 +__uchar !0x4 ! 0x0 +__longlong !0x4 ! 0x0 +__ulonglong !0x4 ! 0x0 +int -0x4 - -0x4 +__uint -0x4 - -0x4 +char -0x4 - -0x4 +__uchar -0x4 - 0xfc +__longlong -0x4 - -0x4 +__ulonglong -0x4 - -0x4 +int ~-0x4 ~ 0x3 +xchar int ~-0x4 ~ 0x3 +int ~-0x4 ~ 0x3 +__uint ~-0x4 ~ 0x3 +char ~-0x4 ~ 0x3 +__uchar ~0xfc ~ 0x3 +__longlong ~-0x4 ~ 0x3 +__ulonglong ~-0x4 ~ 0x3 +int !-0x4 ! 0x0 +__uint !-0x4 ! 0x0 +char !-0x4 ! 0x0 +__uchar !0xfc ! 0x0 +__longlong !-0x4 ! 0x0 +__ulonglong !-0x4 ! 0x0 +int --0x4 - 0x4 +__uint --0x4 - 0x4 +char --0x4 - 0x4 +__uchar -0xfc - 0x4 +__longlong --0x4 - 0x4 +__ulonglong --0x4 - 0x4 +int ~0xa ~ -0xb +xchar int ~0xa ~ -0xb +int ~0xa ~ -0xb +__uint ~0xa ~ -0xb +char ~0xa ~ -0xb +__uchar ~0xa ~ 0xf5 +__longlong ~0xa ~ -0xb +__ulonglong ~0xa ~ -0xb +int !0xa ! 0x0 +__uint !0xa ! 0x0 +char !0xa ! 0x0 +__uchar !0xa ! 0x0 +__longlong !0xa ! 0x0 +__ulonglong !0xa ! 0x0 +int -0xa - -0xa +__uint -0xa - -0xa +char -0xa - -0xa +__uchar -0xa - 0xf6 +__longlong -0xa - -0xa +__ulonglong -0xa - -0xa +int ~-0xa ~ 0x9 +xchar int ~-0xa ~ 0x9 +int ~-0xa ~ 0x9 +__uint ~-0xa ~ 0x9 +char ~-0xa ~ 0x9 +__uchar ~0xf6 ~ 0x9 +__longlong ~-0xa ~ 0x9 +__ulonglong ~-0xa ~ 0x9 +int !-0xa ! 0x0 +__uint !-0xa ! 0x0 +char !-0xa ! 0x0 +__uchar !0xf6 ! 0x0 +__longlong !-0xa ! 0x0 +__ulonglong !-0xa ! 0x0 +int --0xa - 0xa +__uint --0xa - 0xa +char --0xa - 0xa +__uchar -0xf6 - 0xa +__longlong --0xa - 0xa +__ulonglong --0xa - 0xa +int ~0x5 ~ -0x6 +xchar int ~0x5 ~ -0x6 +int ~0x5 ~ -0x6 +__uint ~0x5 ~ -0x6 +char ~0x5 ~ -0x6 +__uchar ~0x5 ~ 0xfa +__longlong ~0x5 ~ -0x6 +__ulonglong ~0x5 ~ -0x6 +int !0x5 ! 0x0 +__uint !0x5 ! 0x0 +char !0x5 ! 0x0 +__uchar !0x5 ! 0x0 +__longlong !0x5 ! 0x0 +__ulonglong !0x5 ! 0x0 +int -0x5 - -0x5 +__uint -0x5 - -0x5 +char -0x5 - -0x5 +__uchar -0x5 - 0xfb +__longlong -0x5 - -0x5 +__ulonglong -0x5 - -0x5 +int ~0x7 ~ -0x8 +xchar int ~0x7 ~ -0x8 +int ~0x7 ~ -0x8 +__uint ~0x7 ~ -0x8 +char ~0x7 ~ -0x8 +__uchar ~0x7 ~ 0xf8 +__longlong ~0x7 ~ -0x8 +__ulonglong ~0x7 ~ -0x8 +int !0x7 ! 0x0 +__uint !0x7 ! 0x0 +char !0x7 ! 0x0 +__uchar !0x7 ! 0x0 +__longlong !0x7 ! 0x0 +__ulonglong !0x7 ! 0x0 +int -0x7 - -0x7 +__uint -0x7 - -0x7 +char -0x7 - -0x7 +__uchar -0x7 - 0xf9 +__longlong -0x7 - -0x7 +__ulonglong -0x7 - -0x7 +int ~0x2a ~ -0x2b +xchar int ~0x2a ~ -0x2b +int ~0x2a ~ -0x2b +__uint ~0x2a ~ -0x2b +char ~0x2a ~ -0x2b +__uchar ~0x2a ~ 0xd5 +__longlong ~0x2a ~ -0x2b +__ulonglong ~0x2a ~ -0x2b +int !0x2a ! 0x0 +__uint !0x2a ! 0x0 +char !0x2a ! 0x0 +__uchar !0x2a ! 0x0 +__longlong !0x2a ! 0x0 +__ulonglong !0x2a ! 0x0 +int -0x2a - -0x2a +__uint -0x2a - -0x2a +char -0x2a - -0x2a +__uchar -0x2a - 0xd6 +__longlong -0x2a - -0x2a +__ulonglong -0x2a - -0x2a +int ~0x17 ~ -0x18 +xchar int ~0x17 ~ -0x18 +int ~0x17 ~ -0x18 +__uint ~0x17 ~ -0x18 +char ~0x17 ~ -0x18 +__uchar ~0x17 ~ 0xe8 +__longlong ~0x17 ~ -0x18 +__ulonglong ~0x17 ~ -0x18 +int !0x17 ! 0x0 +__uint !0x17 ! 0x0 +char !0x17 ! 0x0 +__uchar !0x17 ! 0x0 +__longlong !0x17 ! 0x0 +__ulonglong !0x17 ! 0x0 +int -0x17 - -0x17 +__uint -0x17 - -0x17 +char -0x17 - -0x17 +__uchar -0x17 - 0xe9 +__longlong -0x17 - -0x17 +__ulonglong -0x17 - -0x17 +int ~0x7fff ~ -0x8000 +xchar int ~-0x1 ~ 0x0 +int ~0x7fff ~ -0x8000 +__uint ~0x7fff ~ -0x8000 +char ~-0x1 ~ 0x0 +__uchar ~0xff ~ 0x0 +__longlong ~0x7fff ~ -0x8000 +__ulonglong ~0x7fff ~ -0x8000 +int !0x7fff ! 0x0 +__uint !0x7fff ! 0x0 +char !-0x1 ! 0x0 +__uchar !0xff ! 0x0 +__longlong !0x7fff ! 0x0 +__ulonglong !0x7fff ! 0x0 +int -0x7fff - -0x7fff +__uint -0x7fff - -0x7fff +char --0x1 - 0x1 +__uchar -0xff - 0x1 +__longlong -0x7fff - -0x7fff +__ulonglong -0x7fff - -0x7fff +int ~-0x8000 ~ 0x7fff +xchar int ~0x0 ~ -0x1 +int ~-0x8000 ~ 0x7fff +__uint ~-0x8000 ~ 0x7fff +char ~0x0 ~ -0x1 +__uchar ~0x0 ~ 0xff +__longlong ~-0x8000 ~ 0x7fff +__ulonglong ~-0x8000 ~ 0x7fff +int !-0x8000 ! 0x0 +__uint !-0x8000 ! 0x0 +char !0x0 ! 0x1 +__uchar !0x0 ! 0x1 +__longlong !-0x8000 ! 0x0 +__ulonglong !-0x8000 ! 0x0 +int --0x8000 - -0x8000 +__uint --0x8000 - -0x8000 +char -0x0 - 0x0 +__uchar -0x0 - 0x0 +__longlong --0x8000 - -0x8000 +__ulonglong --0x8000 - -0x8000 +int ~-0x3e8 ~ 0x3e7 +xchar int ~0x18 ~ -0x19 +int ~-0x3e8 ~ 0x3e7 +__uint ~-0x3e8 ~ 0x3e7 +char ~0x18 ~ -0x19 +__uchar ~0x18 ~ 0xe7 +__longlong ~-0x3e8 ~ 0x3e7 +__ulonglong ~-0x3e8 ~ 0x3e7 +int !-0x3e8 ! 0x0 +__uint !-0x3e8 ! 0x0 +char !0x18 ! 0x0 +__uchar !0x18 ! 0x0 +__longlong !-0x3e8 ! 0x0 +__ulonglong !-0x3e8 ! 0x0 +int --0x3e8 - 0x3e8 +__uint --0x3e8 - 0x3e8 +char -0x18 - -0x18 +__uchar -0x18 - 0xe8 +__longlong --0x3e8 - 0x3e8 +__ulonglong --0x3e8 - 0x3e8 +int ~-0x2710 ~ 0x270f +xchar int ~-0x10 ~ 0xf +int ~-0x2710 ~ 0x270f +__uint ~-0x2710 ~ 0x270f +char ~-0x10 ~ 0xf +__uchar ~0xf0 ~ 0xf +__longlong ~-0x2710 ~ 0x270f +__ulonglong ~-0x2710 ~ 0x270f +int !-0x2710 ! 0x0 +__uint !-0x2710 ! 0x0 +char !-0x10 ! 0x0 +__uchar !0xf0 ! 0x0 +__longlong !-0x2710 ! 0x0 +__ulonglong !-0x2710 ! 0x0 +int --0x2710 - 0x2710 +__uint --0x2710 - 0x2710 +char --0x10 - 0x10 +__uchar -0xf0 - 0x10 +__longlong --0x2710 - 0x2710 +__ulonglong --0x2710 - 0x2710 +int !0x0 ! 0x1 +xchar int !0x0 ! 0x1 +int ~0x0 ~ -0x1 +__uint ~0x0 ~ -0x1 +char ~0x0 ~ -0x1 +__uchar ~0x0 ~ 0xff +__longlong ~0x0 ~ -0x1 +__ulonglong ~0x0 ~ -0x1 +int !0x0 ! 0x1 +__uint !0x0 ! 0x1 +char !0x0 ! 0x1 +__uchar !0x0 ! 0x1 +__longlong !0x0 ! 0x1 +__ulonglong !0x0 ! 0x1 +int -0x0 - 0x0 +__uint -0x0 - 0x0 +char -0x0 - 0x0 +__uchar -0x0 - 0x0 +__longlong -0x0 - 0x0 +__ulonglong -0x0 - 0x0 +int !-0x1 ! 0x0 +xchar int !-0x1 ! 0x0 +int ~-0x1 ~ 0x0 +__uint ~-0x1 ~ 0x0 +char ~-0x1 ~ 0x0 +__uchar ~0xff ~ 0x0 +__longlong ~-0x1 ~ 0x0 +__ulonglong ~-0x1 ~ 0x0 +int !-0x1 ! 0x0 +__uint !-0x1 ! 0x0 +char !-0x1 ! 0x0 +__uchar !0xff ! 0x0 +__longlong !-0x1 ! 0x0 +__ulonglong !-0x1 ! 0x0 +int --0x1 - 0x1 +__uint --0x1 - 0x1 +char --0x1 - 0x1 +__uchar -0xff - 0x1 +__longlong --0x1 - 0x1 +__ulonglong --0x1 - 0x1 +int !0x1 ! 0x0 +xchar int !0x1 ! 0x0 +int ~0x1 ~ -0x2 +__uint ~0x1 ~ -0x2 +char ~0x1 ~ -0x2 +__uchar ~0x1 ~ 0xfe +__longlong ~0x1 ~ -0x2 +__ulonglong ~0x1 ~ -0x2 +int !0x1 ! 0x0 +__uint !0x1 ! 0x0 +char !0x1 ! 0x0 +__uchar !0x1 ! 0x0 +__longlong !0x1 ! 0x0 +__ulonglong !0x1 ! 0x0 +int -0x1 - -0x1 +__uint -0x1 - -0x1 +char -0x1 - -0x1 +__uchar -0x1 - 0xff +__longlong -0x1 - -0x1 +__ulonglong -0x1 - -0x1 +int !0x2 ! 0x0 +xchar int !0x2 ! 0x0 +int ~0x2 ~ -0x3 +__uint ~0x2 ~ -0x3 +char ~0x2 ~ -0x3 +__uchar ~0x2 ~ 0xfd +__longlong ~0x2 ~ -0x3 +__ulonglong ~0x2 ~ -0x3 +int !0x2 ! 0x0 +__uint !0x2 ! 0x0 +char !0x2 ! 0x0 +__uchar !0x2 ! 0x0 +__longlong !0x2 ! 0x0 +__ulonglong !0x2 ! 0x0 +int -0x2 - -0x2 +__uint -0x2 - -0x2 +char -0x2 - -0x2 +__uchar -0x2 - 0xfe +__longlong -0x2 - -0x2 +__ulonglong -0x2 - -0x2 +int !-0x2 ! 0x0 +xchar int !-0x2 ! 0x0 +int ~-0x2 ~ 0x1 +__uint ~-0x2 ~ 0x1 +char ~-0x2 ~ 0x1 +__uchar ~0xfe ~ 0x1 +__longlong ~-0x2 ~ 0x1 +__ulonglong ~-0x2 ~ 0x1 +int !-0x2 ! 0x0 +__uint !-0x2 ! 0x0 +char !-0x2 ! 0x0 +__uchar !0xfe ! 0x0 +__longlong !-0x2 ! 0x0 +__ulonglong !-0x2 ! 0x0 +int --0x2 - 0x2 +__uint --0x2 - 0x2 +char --0x2 - 0x2 +__uchar -0xfe - 0x2 +__longlong --0x2 - 0x2 +__ulonglong --0x2 - 0x2 +int !0x4 ! 0x0 +xchar int !0x4 ! 0x0 +int ~0x4 ~ -0x5 +__uint ~0x4 ~ -0x5 +char ~0x4 ~ -0x5 +__uchar ~0x4 ~ 0xfb +__longlong ~0x4 ~ -0x5 +__ulonglong ~0x4 ~ -0x5 +int !0x4 ! 0x0 +__uint !0x4 ! 0x0 +char !0x4 ! 0x0 +__uchar !0x4 ! 0x0 +__longlong !0x4 ! 0x0 +__ulonglong !0x4 ! 0x0 +int -0x4 - -0x4 +__uint -0x4 - -0x4 +char -0x4 - -0x4 +__uchar -0x4 - 0xfc +__longlong -0x4 - -0x4 +__ulonglong -0x4 - -0x4 +int !-0x4 ! 0x0 +xchar int !-0x4 ! 0x0 +int ~-0x4 ~ 0x3 +__uint ~-0x4 ~ 0x3 +char ~-0x4 ~ 0x3 +__uchar ~0xfc ~ 0x3 +__longlong ~-0x4 ~ 0x3 +__ulonglong ~-0x4 ~ 0x3 +int !-0x4 ! 0x0 +__uint !-0x4 ! 0x0 +char !-0x4 ! 0x0 +__uchar !0xfc ! 0x0 +__longlong !-0x4 ! 0x0 +__ulonglong !-0x4 ! 0x0 +int --0x4 - 0x4 +__uint --0x4 - 0x4 +char --0x4 - 0x4 +__uchar -0xfc - 0x4 +__longlong --0x4 - 0x4 +__ulonglong --0x4 - 0x4 +int !0xa ! 0x0 +xchar int !0xa ! 0x0 +int ~0xa ~ -0xb +__uint ~0xa ~ -0xb +char ~0xa ~ -0xb +__uchar ~0xa ~ 0xf5 +__longlong ~0xa ~ -0xb +__ulonglong ~0xa ~ -0xb +int !0xa ! 0x0 +__uint !0xa ! 0x0 +char !0xa ! 0x0 +__uchar !0xa ! 0x0 +__longlong !0xa ! 0x0 +__ulonglong !0xa ! 0x0 +int -0xa - -0xa +__uint -0xa - -0xa +char -0xa - -0xa +__uchar -0xa - 0xf6 +__longlong -0xa - -0xa +__ulonglong -0xa - -0xa +int !-0xa ! 0x0 +xchar int !-0xa ! 0x0 +int ~-0xa ~ 0x9 +__uint ~-0xa ~ 0x9 +char ~-0xa ~ 0x9 +__uchar ~0xf6 ~ 0x9 +__longlong ~-0xa ~ 0x9 +__ulonglong ~-0xa ~ 0x9 +int !-0xa ! 0x0 +__uint !-0xa ! 0x0 +char !-0xa ! 0x0 +__uchar !0xf6 ! 0x0 +__longlong !-0xa ! 0x0 +__ulonglong !-0xa ! 0x0 +int --0xa - 0xa +__uint --0xa - 0xa +char --0xa - 0xa +__uchar -0xf6 - 0xa +__longlong --0xa - 0xa +__ulonglong --0xa - 0xa +int !0x5 ! 0x0 +xchar int !0x5 ! 0x0 +int ~0x5 ~ -0x6 +__uint ~0x5 ~ -0x6 +char ~0x5 ~ -0x6 +__uchar ~0x5 ~ 0xfa +__longlong ~0x5 ~ -0x6 +__ulonglong ~0x5 ~ -0x6 +int !0x5 ! 0x0 +__uint !0x5 ! 0x0 +char !0x5 ! 0x0 +__uchar !0x5 ! 0x0 +__longlong !0x5 ! 0x0 +__ulonglong !0x5 ! 0x0 +int -0x5 - -0x5 +__uint -0x5 - -0x5 +char -0x5 - -0x5 +__uchar -0x5 - 0xfb +__longlong -0x5 - -0x5 +__ulonglong -0x5 - -0x5 +int !0x7 ! 0x0 +xchar int !0x7 ! 0x0 +int ~0x7 ~ -0x8 +__uint ~0x7 ~ -0x8 +char ~0x7 ~ -0x8 +__uchar ~0x7 ~ 0xf8 +__longlong ~0x7 ~ -0x8 +__ulonglong ~0x7 ~ -0x8 +int !0x7 ! 0x0 +__uint !0x7 ! 0x0 +char !0x7 ! 0x0 +__uchar !0x7 ! 0x0 +__longlong !0x7 ! 0x0 +__ulonglong !0x7 ! 0x0 +int -0x7 - -0x7 +__uint -0x7 - -0x7 +char -0x7 - -0x7 +__uchar -0x7 - 0xf9 +__longlong -0x7 - -0x7 +__ulonglong -0x7 - -0x7 +int !0x2a ! 0x0 +xchar int !0x2a ! 0x0 +int ~0x2a ~ -0x2b +__uint ~0x2a ~ -0x2b +char ~0x2a ~ -0x2b +__uchar ~0x2a ~ 0xd5 +__longlong ~0x2a ~ -0x2b +__ulonglong ~0x2a ~ -0x2b +int !0x2a ! 0x0 +__uint !0x2a ! 0x0 +char !0x2a ! 0x0 +__uchar !0x2a ! 0x0 +__longlong !0x2a ! 0x0 +__ulonglong !0x2a ! 0x0 +int -0x2a - -0x2a +__uint -0x2a - -0x2a +char -0x2a - -0x2a +__uchar -0x2a - 0xd6 +__longlong -0x2a - -0x2a +__ulonglong -0x2a - -0x2a +int !0x17 ! 0x0 +xchar int !0x17 ! 0x0 +int ~0x17 ~ -0x18 +__uint ~0x17 ~ -0x18 +char ~0x17 ~ -0x18 +__uchar ~0x17 ~ 0xe8 +__longlong ~0x17 ~ -0x18 +__ulonglong ~0x17 ~ -0x18 +int !0x17 ! 0x0 +__uint !0x17 ! 0x0 +char !0x17 ! 0x0 +__uchar !0x17 ! 0x0 +__longlong !0x17 ! 0x0 +__ulonglong !0x17 ! 0x0 +int -0x17 - -0x17 +__uint -0x17 - -0x17 +char -0x17 - -0x17 +__uchar -0x17 - 0xe9 +__longlong -0x17 - -0x17 +__ulonglong -0x17 - -0x17 +int !0x7fff ! 0x0 +xchar int !-0x1 ! 0x0 +int ~0x7fff ~ -0x8000 +__uint ~0x7fff ~ -0x8000 +char ~-0x1 ~ 0x0 +__uchar ~0xff ~ 0x0 +__longlong ~0x7fff ~ -0x8000 +__ulonglong ~0x7fff ~ -0x8000 +int !0x7fff ! 0x0 +__uint !0x7fff ! 0x0 +char !-0x1 ! 0x0 +__uchar !0xff ! 0x0 +__longlong !0x7fff ! 0x0 +__ulonglong !0x7fff ! 0x0 +int -0x7fff - -0x7fff +__uint -0x7fff - -0x7fff +char --0x1 - 0x1 +__uchar -0xff - 0x1 +__longlong -0x7fff - -0x7fff +__ulonglong -0x7fff - -0x7fff +int !-0x8000 ! 0x0 +xchar int !0x0 ! 0x1 +int ~-0x8000 ~ 0x7fff +__uint ~-0x8000 ~ 0x7fff +char ~0x0 ~ -0x1 +__uchar ~0x0 ~ 0xff +__longlong ~-0x8000 ~ 0x7fff +__ulonglong ~-0x8000 ~ 0x7fff +int !-0x8000 ! 0x0 +__uint !-0x8000 ! 0x0 +char !0x0 ! 0x1 +__uchar !0x0 ! 0x1 +__longlong !-0x8000 ! 0x0 +__ulonglong !-0x8000 ! 0x0 +int --0x8000 - -0x8000 +__uint --0x8000 - -0x8000 +char -0x0 - 0x0 +__uchar -0x0 - 0x0 +__longlong --0x8000 - -0x8000 +__ulonglong --0x8000 - -0x8000 +int !-0x3e8 ! 0x0 +xchar int !0x18 ! 0x0 +int ~-0x3e8 ~ 0x3e7 +__uint ~-0x3e8 ~ 0x3e7 +char ~0x18 ~ -0x19 +__uchar ~0x18 ~ 0xe7 +__longlong ~-0x3e8 ~ 0x3e7 +__ulonglong ~-0x3e8 ~ 0x3e7 +int !-0x3e8 ! 0x0 +__uint !-0x3e8 ! 0x0 +char !0x18 ! 0x0 +__uchar !0x18 ! 0x0 +__longlong !-0x3e8 ! 0x0 +__ulonglong !-0x3e8 ! 0x0 +int --0x3e8 - 0x3e8 +__uint --0x3e8 - 0x3e8 +char -0x18 - -0x18 +__uchar -0x18 - 0xe8 +__longlong --0x3e8 - 0x3e8 +__ulonglong --0x3e8 - 0x3e8 +int !-0x2710 ! 0x0 +xchar int !-0x10 ! 0x0 +int ~-0x2710 ~ 0x270f +__uint ~-0x2710 ~ 0x270f +char ~-0x10 ~ 0xf +__uchar ~0xf0 ~ 0xf +__longlong ~-0x2710 ~ 0x270f +__ulonglong ~-0x2710 ~ 0x270f +int !-0x2710 ! 0x0 +__uint !-0x2710 ! 0x0 +char !-0x10 ! 0x0 +__uchar !0xf0 ! 0x0 +__longlong !-0x2710 ! 0x0 +__ulonglong !-0x2710 ! 0x0 +int --0x2710 - 0x2710 +__uint --0x2710 - 0x2710 +char --0x10 - 0x10 +__uchar -0xf0 - 0x10 +__longlong --0x2710 - 0x2710 +__ulonglong --0x2710 - 0x2710 +int -0x0 - 0x0 +xchar int -0x0 - 0x0 +int ~0x0 ~ -0x1 +__uint ~0x0 ~ -0x1 +char ~0x0 ~ -0x1 +__uchar ~0x0 ~ 0xff +__longlong ~0x0 ~ -0x1 +__ulonglong ~0x0 ~ -0x1 +int !0x0 ! 0x1 +__uint !0x0 ! 0x1 +char !0x0 ! 0x1 +__uchar !0x0 ! 0x1 +__longlong !0x0 ! 0x1 +__ulonglong !0x0 ! 0x1 +int -0x0 - 0x0 +__uint -0x0 - 0x0 +char -0x0 - 0x0 +__uchar -0x0 - 0x0 +__longlong -0x0 - 0x0 +__ulonglong -0x0 - 0x0 +int --0x1 - 0x1 +xchar int --0x1 - 0x1 +int ~-0x1 ~ 0x0 +__uint ~-0x1 ~ 0x0 +char ~-0x1 ~ 0x0 +__uchar ~0xff ~ 0x0 +__longlong ~-0x1 ~ 0x0 +__ulonglong ~-0x1 ~ 0x0 +int !-0x1 ! 0x0 +__uint !-0x1 ! 0x0 +char !-0x1 ! 0x0 +__uchar !0xff ! 0x0 +__longlong !-0x1 ! 0x0 +__ulonglong !-0x1 ! 0x0 +int --0x1 - 0x1 +__uint --0x1 - 0x1 +char --0x1 - 0x1 +__uchar -0xff - 0x1 +__longlong --0x1 - 0x1 +__ulonglong --0x1 - 0x1 +int -0x1 - -0x1 +xchar int -0x1 - -0x1 +int ~0x1 ~ -0x2 +__uint ~0x1 ~ -0x2 +char ~0x1 ~ -0x2 +__uchar ~0x1 ~ 0xfe +__longlong ~0x1 ~ -0x2 +__ulonglong ~0x1 ~ -0x2 +int !0x1 ! 0x0 +__uint !0x1 ! 0x0 +char !0x1 ! 0x0 +__uchar !0x1 ! 0x0 +__longlong !0x1 ! 0x0 +__ulonglong !0x1 ! 0x0 +int -0x1 - -0x1 +__uint -0x1 - -0x1 +char -0x1 - -0x1 +__uchar -0x1 - 0xff +__longlong -0x1 - -0x1 +__ulonglong -0x1 - -0x1 +int -0x2 - -0x2 +xchar int -0x2 - -0x2 +int ~0x2 ~ -0x3 +__uint ~0x2 ~ -0x3 +char ~0x2 ~ -0x3 +__uchar ~0x2 ~ 0xfd +__longlong ~0x2 ~ -0x3 +__ulonglong ~0x2 ~ -0x3 +int !0x2 ! 0x0 +__uint !0x2 ! 0x0 +char !0x2 ! 0x0 +__uchar !0x2 ! 0x0 +__longlong !0x2 ! 0x0 +__ulonglong !0x2 ! 0x0 +int -0x2 - -0x2 +__uint -0x2 - -0x2 +char -0x2 - -0x2 +__uchar -0x2 - 0xfe +__longlong -0x2 - -0x2 +__ulonglong -0x2 - -0x2 +int --0x2 - 0x2 +xchar int --0x2 - 0x2 +int ~-0x2 ~ 0x1 +__uint ~-0x2 ~ 0x1 +char ~-0x2 ~ 0x1 +__uchar ~0xfe ~ 0x1 +__longlong ~-0x2 ~ 0x1 +__ulonglong ~-0x2 ~ 0x1 +int !-0x2 ! 0x0 +__uint !-0x2 ! 0x0 +char !-0x2 ! 0x0 +__uchar !0xfe ! 0x0 +__longlong !-0x2 ! 0x0 +__ulonglong !-0x2 ! 0x0 +int --0x2 - 0x2 +__uint --0x2 - 0x2 +char --0x2 - 0x2 +__uchar -0xfe - 0x2 +__longlong --0x2 - 0x2 +__ulonglong --0x2 - 0x2 +int -0x4 - -0x4 +xchar int -0x4 - -0x4 +int ~0x4 ~ -0x5 +__uint ~0x4 ~ -0x5 +char ~0x4 ~ -0x5 +__uchar ~0x4 ~ 0xfb +__longlong ~0x4 ~ -0x5 +__ulonglong ~0x4 ~ -0x5 +int !0x4 ! 0x0 +__uint !0x4 ! 0x0 +char !0x4 ! 0x0 +__uchar !0x4 ! 0x0 +__longlong !0x4 ! 0x0 +__ulonglong !0x4 ! 0x0 +int -0x4 - -0x4 +__uint -0x4 - -0x4 +char -0x4 - -0x4 +__uchar -0x4 - 0xfc +__longlong -0x4 - -0x4 +__ulonglong -0x4 - -0x4 +int --0x4 - 0x4 +xchar int --0x4 - 0x4 +int ~-0x4 ~ 0x3 +__uint ~-0x4 ~ 0x3 +char ~-0x4 ~ 0x3 +__uchar ~0xfc ~ 0x3 +__longlong ~-0x4 ~ 0x3 +__ulonglong ~-0x4 ~ 0x3 +int !-0x4 ! 0x0 +__uint !-0x4 ! 0x0 +char !-0x4 ! 0x0 +__uchar !0xfc ! 0x0 +__longlong !-0x4 ! 0x0 +__ulonglong !-0x4 ! 0x0 +int --0x4 - 0x4 +__uint --0x4 - 0x4 +char --0x4 - 0x4 +__uchar -0xfc - 0x4 +__longlong --0x4 - 0x4 +__ulonglong --0x4 - 0x4 +int -0xa - -0xa +xchar int -0xa - -0xa +int ~0xa ~ -0xb +__uint ~0xa ~ -0xb +char ~0xa ~ -0xb +__uchar ~0xa ~ 0xf5 +__longlong ~0xa ~ -0xb +__ulonglong ~0xa ~ -0xb +int !0xa ! 0x0 +__uint !0xa ! 0x0 +char !0xa ! 0x0 +__uchar !0xa ! 0x0 +__longlong !0xa ! 0x0 +__ulonglong !0xa ! 0x0 +int -0xa - -0xa +__uint -0xa - -0xa +char -0xa - -0xa +__uchar -0xa - 0xf6 +__longlong -0xa - -0xa +__ulonglong -0xa - -0xa +int --0xa - 0xa +xchar int --0xa - 0xa +int ~-0xa ~ 0x9 +__uint ~-0xa ~ 0x9 +char ~-0xa ~ 0x9 +__uchar ~0xf6 ~ 0x9 +__longlong ~-0xa ~ 0x9 +__ulonglong ~-0xa ~ 0x9 +int !-0xa ! 0x0 +__uint !-0xa ! 0x0 +char !-0xa ! 0x0 +__uchar !0xf6 ! 0x0 +__longlong !-0xa ! 0x0 +__ulonglong !-0xa ! 0x0 +int --0xa - 0xa +__uint --0xa - 0xa +char --0xa - 0xa +__uchar -0xf6 - 0xa +__longlong --0xa - 0xa +__ulonglong --0xa - 0xa +int -0x5 - -0x5 +xchar int -0x5 - -0x5 +int ~0x5 ~ -0x6 +__uint ~0x5 ~ -0x6 +char ~0x5 ~ -0x6 +__uchar ~0x5 ~ 0xfa +__longlong ~0x5 ~ -0x6 +__ulonglong ~0x5 ~ -0x6 +int !0x5 ! 0x0 +__uint !0x5 ! 0x0 +char !0x5 ! 0x0 +__uchar !0x5 ! 0x0 +__longlong !0x5 ! 0x0 +__ulonglong !0x5 ! 0x0 +int -0x5 - -0x5 +__uint -0x5 - -0x5 +char -0x5 - -0x5 +__uchar -0x5 - 0xfb +__longlong -0x5 - -0x5 +__ulonglong -0x5 - -0x5 +int -0x7 - -0x7 +xchar int -0x7 - -0x7 +int ~0x7 ~ -0x8 +__uint ~0x7 ~ -0x8 +char ~0x7 ~ -0x8 +__uchar ~0x7 ~ 0xf8 +__longlong ~0x7 ~ -0x8 +__ulonglong ~0x7 ~ -0x8 +int !0x7 ! 0x0 +__uint !0x7 ! 0x0 +char !0x7 ! 0x0 +__uchar !0x7 ! 0x0 +__longlong !0x7 ! 0x0 +__ulonglong !0x7 ! 0x0 +int -0x7 - -0x7 +__uint -0x7 - -0x7 +char -0x7 - -0x7 +__uchar -0x7 - 0xf9 +__longlong -0x7 - -0x7 +__ulonglong -0x7 - -0x7 +int -0x2a - -0x2a +xchar int -0x2a - -0x2a +int ~0x2a ~ -0x2b +__uint ~0x2a ~ -0x2b +char ~0x2a ~ -0x2b +__uchar ~0x2a ~ 0xd5 +__longlong ~0x2a ~ -0x2b +__ulonglong ~0x2a ~ -0x2b +int !0x2a ! 0x0 +__uint !0x2a ! 0x0 +char !0x2a ! 0x0 +__uchar !0x2a ! 0x0 +__longlong !0x2a ! 0x0 +__ulonglong !0x2a ! 0x0 +int -0x2a - -0x2a +__uint -0x2a - -0x2a +char -0x2a - -0x2a +__uchar -0x2a - 0xd6 +__longlong -0x2a - -0x2a +__ulonglong -0x2a - -0x2a +int -0x17 - -0x17 +xchar int -0x17 - -0x17 +int ~0x17 ~ -0x18 +__uint ~0x17 ~ -0x18 +char ~0x17 ~ -0x18 +__uchar ~0x17 ~ 0xe8 +__longlong ~0x17 ~ -0x18 +__ulonglong ~0x17 ~ -0x18 +int !0x17 ! 0x0 +__uint !0x17 ! 0x0 +char !0x17 ! 0x0 +__uchar !0x17 ! 0x0 +__longlong !0x17 ! 0x0 +__ulonglong !0x17 ! 0x0 +int -0x17 - -0x17 +__uint -0x17 - -0x17 +char -0x17 - -0x17 +__uchar -0x17 - 0xe9 +__longlong -0x17 - -0x17 +__ulonglong -0x17 - -0x17 +int -0x7fff - -0x7fff +xchar int --0x1 - 0x1 +int ~0x7fff ~ -0x8000 +__uint ~0x7fff ~ -0x8000 +char ~-0x1 ~ 0x0 +__uchar ~0xff ~ 0x0 +__longlong ~0x7fff ~ -0x8000 +__ulonglong ~0x7fff ~ -0x8000 +int !0x7fff ! 0x0 +__uint !0x7fff ! 0x0 +char !-0x1 ! 0x0 +__uchar !0xff ! 0x0 +__longlong !0x7fff ! 0x0 +__ulonglong !0x7fff ! 0x0 +int -0x7fff - -0x7fff +__uint -0x7fff - -0x7fff +char --0x1 - 0x1 +__uchar -0xff - 0x1 +__longlong -0x7fff - -0x7fff +__ulonglong -0x7fff - -0x7fff +int --0x8000 - -0x8000 +xchar int -0x0 - 0x0 +int ~-0x8000 ~ 0x7fff +__uint ~-0x8000 ~ 0x7fff +char ~0x0 ~ -0x1 +__uchar ~0x0 ~ 0xff +__longlong ~-0x8000 ~ 0x7fff +__ulonglong ~-0x8000 ~ 0x7fff +int !-0x8000 ! 0x0 +__uint !-0x8000 ! 0x0 +char !0x0 ! 0x1 +__uchar !0x0 ! 0x1 +__longlong !-0x8000 ! 0x0 +__ulonglong !-0x8000 ! 0x0 +int --0x8000 - -0x8000 +__uint --0x8000 - -0x8000 +char -0x0 - 0x0 +__uchar -0x0 - 0x0 +__longlong --0x8000 - -0x8000 +__ulonglong --0x8000 - -0x8000 +int --0x3e8 - 0x3e8 +xchar int -0x18 - -0x18 +int ~-0x3e8 ~ 0x3e7 +__uint ~-0x3e8 ~ 0x3e7 +char ~0x18 ~ -0x19 +__uchar ~0x18 ~ 0xe7 +__longlong ~-0x3e8 ~ 0x3e7 +__ulonglong ~-0x3e8 ~ 0x3e7 +int !-0x3e8 ! 0x0 +__uint !-0x3e8 ! 0x0 +char !0x18 ! 0x0 +__uchar !0x18 ! 0x0 +__longlong !-0x3e8 ! 0x0 +__ulonglong !-0x3e8 ! 0x0 +int --0x3e8 - 0x3e8 +__uint --0x3e8 - 0x3e8 +char -0x18 - -0x18 +__uchar -0x18 - 0xe8 +__longlong --0x3e8 - 0x3e8 +__ulonglong --0x3e8 - 0x3e8 +int --0x2710 - 0x2710 +xchar int --0x10 - 0x10 +int ~-0x2710 ~ 0x270f +__uint ~-0x2710 ~ 0x270f +char ~-0x10 ~ 0xf +__uchar ~0xf0 ~ 0xf +__longlong ~-0x2710 ~ 0x270f +__ulonglong ~-0x2710 ~ 0x270f +int !-0x2710 ! 0x0 +__uint !-0x2710 ! 0x0 +char !-0x10 ! 0x0 +__uchar !0xf0 ! 0x0 +__longlong !-0x2710 ! 0x0 +__ulonglong !-0x2710 ! 0x0 +int --0x2710 - 0x2710 +__uint --0x2710 - 0x2710 +char --0x10 - 0x10 +__uchar -0xf0 - 0x10 +__longlong --0x2710 - 0x2710 +__ulonglong --0x2710 - 0x2710 +0x0,0x5,0x4,0x3,0x2, +int 0x0 || 0x0 == 0x0 (0x0) +__uint 0x0 || 0x0 == 0x0 (0x0) +char 0x0 || 0x0 == 0x0 (0x0) +__uchar 0x0 || 0x0 == 0x0 (0x0) +__longlong 0x0 || 0x0 == 0x0 (0x0) +__ulonglong 0x0 || 0x0 == 0x0 (0x0) +int 0x0 && 0x0 == 0x0 (0x0) +__uint 0x0 && 0x0 == 0x0 (0x0) +char 0x0 && 0x0 == 0x0 (0x0) +__uchar 0x0 && 0x0 == 0x0 (0x0) +__longlong 0x0 && 0x0 == 0x0 (0x0) +__ulonglong 0x0 && 0x0 == 0x0 (0x0) +int 0x0 || 0x1 == 0x1 (0x1) +__uint 0x0 || 0x1 == 0x1 (0x1) +char 0x0 || 0x1 == 0x1 (0x1) +__uchar 0x0 || 0x1 == 0x1 (0x1) +__longlong 0x0 || 0x1 == 0x1 (0x1) +__ulonglong 0x0 || 0x1 == 0x1 (0x1) +int 0x0 && 0x1 == 0x0 (0x0) +__uint 0x0 && 0x1 == 0x0 (0x0) +char 0x0 && 0x1 == 0x0 (0x0) +__uchar 0x0 && 0x1 == 0x0 (0x0) +__longlong 0x0 && 0x1 == 0x0 (0x0) +__ulonglong 0x0 && 0x1 == 0x0 (0x0) +int 0x0 || 0xffff == 0x1 (0x1) +__uint 0x0 || 0xffff == 0x1 (0x1) +char 0x0 || 0xffff == 0x1 (0x1) +__uchar 0x0 || 0xff == 0x1 (0x1) +__longlong 0x0 || 0xffff == 0x1 (0x1) +__ulonglong 0x0 || 0xffff == 0x1 (0x1) +int 0x0 && 0xffff == 0x0 (0x0) +__uint 0x0 && 0xffff == 0x0 (0x0) +char 0x0 && 0xffff == 0x0 (0x0) +__uchar 0x0 && 0xff == 0x0 (0x0) +__longlong 0x0 && 0xffff == 0x0 (0x0) +__ulonglong 0x0 && 0xffff == 0x0 (0x0) +int 0x0 || 0x2a == 0x1 (0x1) +__uint 0x0 || 0x2a == 0x1 (0x1) +char 0x0 || 0x2a == 0x1 (0x1) +__uchar 0x0 || 0x2a == 0x1 (0x1) +__longlong 0x0 || 0x2a == 0x1 (0x1) +__ulonglong 0x0 || 0x2a == 0x1 (0x1) +int 0x0 && 0x2a == 0x0 (0x0) +__uint 0x0 && 0x2a == 0x0 (0x0) +char 0x0 && 0x2a == 0x0 (0x0) +__uchar 0x0 && 0x2a == 0x0 (0x0) +__longlong 0x0 && 0x2a == 0x0 (0x0) +__ulonglong 0x0 && 0x2a == 0x0 (0x0) +int 0x0 || 0x17 == 0x1 (0x1) +__uint 0x0 || 0x17 == 0x1 (0x1) +char 0x0 || 0x17 == 0x1 (0x1) +__uchar 0x0 || 0x17 == 0x1 (0x1) +__longlong 0x0 || 0x17 == 0x1 (0x1) +__ulonglong 0x0 || 0x17 == 0x1 (0x1) +int 0x0 && 0x17 == 0x0 (0x0) +__uint 0x0 && 0x17 == 0x0 (0x0) +char 0x0 && 0x17 == 0x0 (0x0) +__uchar 0x0 && 0x17 == 0x0 (0x0) +__longlong 0x0 && 0x17 == 0x0 (0x0) +__ulonglong 0x0 && 0x17 == 0x0 (0x0) +int 0x0 || 0x7fff == 0x1 (0x1) +__uint 0x0 || 0x7fff == 0x1 (0x1) +char 0x0 || 0xffff == 0x1 (0x1) +__uchar 0x0 || 0xff == 0x1 (0x1) +__longlong 0x0 || 0x7fff == 0x1 (0x1) +__ulonglong 0x0 || 0x7fff == 0x1 (0x1) +int 0x0 && 0x7fff == 0x0 (0x0) +__uint 0x0 && 0x7fff == 0x0 (0x0) +char 0x0 && 0xffff == 0x0 (0x0) +__uchar 0x0 && 0xff == 0x0 (0x0) +__longlong 0x0 && 0x7fff == 0x0 (0x0) +__ulonglong 0x0 && 0x7fff == 0x0 (0x0) +int 0x0 || 0x8000 == 0x1 (0x1) +__uint 0x0 || 0x8000 == 0x1 (0x1) +char 0x0 || 0x0 == 0x0 (0x0) +__uchar 0x0 || 0x0 == 0x0 (0x0) +__longlong 0x0 || 0x8000 == 0x1 (0x1) +__ulonglong 0x0 || 0x8000 == 0x1 (0x1) +int 0x0 && 0x8000 == 0x0 (0x0) +__uint 0x0 && 0x8000 == 0x0 (0x0) +char 0x0 && 0x0 == 0x0 (0x0) +__uchar 0x0 && 0x0 == 0x0 (0x0) +__longlong 0x0 && 0x8000 == 0x0 (0x0) +__ulonglong 0x0 && 0x8000 == 0x0 (0x0) +int 0x1 || 0x0 == 0x1 (0x1) +__uint 0x1 || 0x0 == 0x1 (0x1) +char 0x1 || 0x0 == 0x1 (0x1) +__uchar 0x1 || 0x0 == 0x1 (0x1) +__longlong 0x1 || 0x0 == 0x1 (0x1) +__ulonglong 0x1 || 0x0 == 0x1 (0x1) +int 0x1 && 0x0 == 0x0 (0x0) +__uint 0x1 && 0x0 == 0x0 (0x0) +char 0x1 && 0x0 == 0x0 (0x0) +__uchar 0x1 && 0x0 == 0x0 (0x0) +__longlong 0x1 && 0x0 == 0x0 (0x0) +__ulonglong 0x1 && 0x0 == 0x0 (0x0) +int 0x1 || 0x1 == 0x1 (0x1) +__uint 0x1 || 0x1 == 0x1 (0x1) +char 0x1 || 0x1 == 0x1 (0x1) +__uchar 0x1 || 0x1 == 0x1 (0x1) +__longlong 0x1 || 0x1 == 0x1 (0x1) +__ulonglong 0x1 || 0x1 == 0x1 (0x1) +int 0x1 && 0x1 == 0x1 (0x1) +__uint 0x1 && 0x1 == 0x1 (0x1) +char 0x1 && 0x1 == 0x1 (0x1) +__uchar 0x1 && 0x1 == 0x1 (0x1) +__longlong 0x1 && 0x1 == 0x1 (0x1) +__ulonglong 0x1 && 0x1 == 0x1 (0x1) +int 0x1 || 0xffff == 0x1 (0x1) +__uint 0x1 || 0xffff == 0x1 (0x1) +char 0x1 || 0xffff == 0x1 (0x1) +__uchar 0x1 || 0xff == 0x1 (0x1) +__longlong 0x1 || 0xffff == 0x1 (0x1) +__ulonglong 0x1 || 0xffff == 0x1 (0x1) +int 0x1 && 0xffff == 0x1 (0x1) +__uint 0x1 && 0xffff == 0x1 (0x1) +char 0x1 && 0xffff == 0x1 (0x1) +__uchar 0x1 && 0xff == 0x1 (0x1) +__longlong 0x1 && 0xffff == 0x1 (0x1) +__ulonglong 0x1 && 0xffff == 0x1 (0x1) +int 0x1 || 0x2a == 0x1 (0x1) +__uint 0x1 || 0x2a == 0x1 (0x1) +char 0x1 || 0x2a == 0x1 (0x1) +__uchar 0x1 || 0x2a == 0x1 (0x1) +__longlong 0x1 || 0x2a == 0x1 (0x1) +__ulonglong 0x1 || 0x2a == 0x1 (0x1) +int 0x1 && 0x2a == 0x1 (0x1) +__uint 0x1 && 0x2a == 0x1 (0x1) +char 0x1 && 0x2a == 0x1 (0x1) +__uchar 0x1 && 0x2a == 0x1 (0x1) +__longlong 0x1 && 0x2a == 0x1 (0x1) +__ulonglong 0x1 && 0x2a == 0x1 (0x1) +int 0x1 || 0x17 == 0x1 (0x1) +__uint 0x1 || 0x17 == 0x1 (0x1) +char 0x1 || 0x17 == 0x1 (0x1) +__uchar 0x1 || 0x17 == 0x1 (0x1) +__longlong 0x1 || 0x17 == 0x1 (0x1) +__ulonglong 0x1 || 0x17 == 0x1 (0x1) +int 0x1 && 0x17 == 0x1 (0x1) +__uint 0x1 && 0x17 == 0x1 (0x1) +char 0x1 && 0x17 == 0x1 (0x1) +__uchar 0x1 && 0x17 == 0x1 (0x1) +__longlong 0x1 && 0x17 == 0x1 (0x1) +__ulonglong 0x1 && 0x17 == 0x1 (0x1) +int 0x1 || 0x7fff == 0x1 (0x1) +__uint 0x1 || 0x7fff == 0x1 (0x1) +char 0x1 || 0xffff == 0x1 (0x1) +__uchar 0x1 || 0xff == 0x1 (0x1) +__longlong 0x1 || 0x7fff == 0x1 (0x1) +__ulonglong 0x1 || 0x7fff == 0x1 (0x1) +int 0x1 && 0x7fff == 0x1 (0x1) +__uint 0x1 && 0x7fff == 0x1 (0x1) +char 0x1 && 0xffff == 0x1 (0x1) +__uchar 0x1 && 0xff == 0x1 (0x1) +__longlong 0x1 && 0x7fff == 0x1 (0x1) +__ulonglong 0x1 && 0x7fff == 0x1 (0x1) +int 0x1 || 0x8000 == 0x1 (0x1) +__uint 0x1 || 0x8000 == 0x1 (0x1) +char 0x1 || 0x0 == 0x1 (0x1) +__uchar 0x1 || 0x0 == 0x1 (0x1) +__longlong 0x1 || 0x8000 == 0x1 (0x1) +__ulonglong 0x1 || 0x8000 == 0x1 (0x1) +int 0x1 && 0x8000 == 0x1 (0x1) +__uint 0x1 && 0x8000 == 0x1 (0x1) +char 0x1 && 0x0 == 0x0 (0x0) +__uchar 0x1 && 0x0 == 0x0 (0x0) +__longlong 0x1 && 0x8000 == 0x1 (0x1) +__ulonglong 0x1 && 0x8000 == 0x1 (0x1) +int 0xffff || 0x0 == 0x1 (0x1) +__uint 0xffff || 0x0 == 0x1 (0x1) +char 0xffff || 0x0 == 0x1 (0x1) +__uchar 0xff || 0x0 == 0x1 (0x1) +__longlong 0xffff || 0x0 == 0x1 (0x1) +__ulonglong 0xffff || 0x0 == 0x1 (0x1) +int 0xffff && 0x0 == 0x0 (0x0) +__uint 0xffff && 0x0 == 0x0 (0x0) +char 0xffff && 0x0 == 0x0 (0x0) +__uchar 0xff && 0x0 == 0x0 (0x0) +__longlong 0xffff && 0x0 == 0x0 (0x0) +__ulonglong 0xffff && 0x0 == 0x0 (0x0) +int 0xffff || 0x1 == 0x1 (0x1) +__uint 0xffff || 0x1 == 0x1 (0x1) +char 0xffff || 0x1 == 0x1 (0x1) +__uchar 0xff || 0x1 == 0x1 (0x1) +__longlong 0xffff || 0x1 == 0x1 (0x1) +__ulonglong 0xffff || 0x1 == 0x1 (0x1) +int 0xffff && 0x1 == 0x1 (0x1) +__uint 0xffff && 0x1 == 0x1 (0x1) +char 0xffff && 0x1 == 0x1 (0x1) +__uchar 0xff && 0x1 == 0x1 (0x1) +__longlong 0xffff && 0x1 == 0x1 (0x1) +__ulonglong 0xffff && 0x1 == 0x1 (0x1) +int 0xffff || 0xffff == 0x1 (0x1) +__uint 0xffff || 0xffff == 0x1 (0x1) +char 0xffff || 0xffff == 0x1 (0x1) +__uchar 0xff || 0xff == 0x1 (0x1) +__longlong 0xffff || 0xffff == 0x1 (0x1) +__ulonglong 0xffff || 0xffff == 0x1 (0x1) +int 0xffff && 0xffff == 0x1 (0x1) +__uint 0xffff && 0xffff == 0x1 (0x1) +char 0xffff && 0xffff == 0x1 (0x1) +__uchar 0xff && 0xff == 0x1 (0x1) +__longlong 0xffff && 0xffff == 0x1 (0x1) +__ulonglong 0xffff && 0xffff == 0x1 (0x1) +int 0xffff || 0x2a == 0x1 (0x1) +__uint 0xffff || 0x2a == 0x1 (0x1) +char 0xffff || 0x2a == 0x1 (0x1) +__uchar 0xff || 0x2a == 0x1 (0x1) +__longlong 0xffff || 0x2a == 0x1 (0x1) +__ulonglong 0xffff || 0x2a == 0x1 (0x1) +int 0xffff && 0x2a == 0x1 (0x1) +__uint 0xffff && 0x2a == 0x1 (0x1) +char 0xffff && 0x2a == 0x1 (0x1) +__uchar 0xff && 0x2a == 0x1 (0x1) +__longlong 0xffff && 0x2a == 0x1 (0x1) +__ulonglong 0xffff && 0x2a == 0x1 (0x1) +int 0xffff || 0x17 == 0x1 (0x1) +__uint 0xffff || 0x17 == 0x1 (0x1) +char 0xffff || 0x17 == 0x1 (0x1) +__uchar 0xff || 0x17 == 0x1 (0x1) +__longlong 0xffff || 0x17 == 0x1 (0x1) +__ulonglong 0xffff || 0x17 == 0x1 (0x1) +int 0xffff && 0x17 == 0x1 (0x1) +__uint 0xffff && 0x17 == 0x1 (0x1) +char 0xffff && 0x17 == 0x1 (0x1) +__uchar 0xff && 0x17 == 0x1 (0x1) +__longlong 0xffff && 0x17 == 0x1 (0x1) +__ulonglong 0xffff && 0x17 == 0x1 (0x1) +int 0xffff || 0x7fff == 0x1 (0x1) +__uint 0xffff || 0x7fff == 0x1 (0x1) +char 0xffff || 0xffff == 0x1 (0x1) +__uchar 0xff || 0xff == 0x1 (0x1) +__longlong 0xffff || 0x7fff == 0x1 (0x1) +__ulonglong 0xffff || 0x7fff == 0x1 (0x1) +int 0xffff && 0x7fff == 0x1 (0x1) +__uint 0xffff && 0x7fff == 0x1 (0x1) +char 0xffff && 0xffff == 0x1 (0x1) +__uchar 0xff && 0xff == 0x1 (0x1) +__longlong 0xffff && 0x7fff == 0x1 (0x1) +__ulonglong 0xffff && 0x7fff == 0x1 (0x1) +int 0xffff || 0x8000 == 0x1 (0x1) +__uint 0xffff || 0x8000 == 0x1 (0x1) +char 0xffff || 0x0 == 0x1 (0x1) +__uchar 0xff || 0x0 == 0x1 (0x1) +__longlong 0xffff || 0x8000 == 0x1 (0x1) +__ulonglong 0xffff || 0x8000 == 0x1 (0x1) +int 0xffff && 0x8000 == 0x1 (0x1) +__uint 0xffff && 0x8000 == 0x1 (0x1) +char 0xffff && 0x0 == 0x0 (0x0) +__uchar 0xff && 0x0 == 0x0 (0x0) +__longlong 0xffff && 0x8000 == 0x1 (0x1) +__ulonglong 0xffff && 0x8000 == 0x1 (0x1) +int 0x2a || 0x0 == 0x1 (0x1) +__uint 0x2a || 0x0 == 0x1 (0x1) +char 0x2a || 0x0 == 0x1 (0x1) +__uchar 0x2a || 0x0 == 0x1 (0x1) +__longlong 0x2a || 0x0 == 0x1 (0x1) +__ulonglong 0x2a || 0x0 == 0x1 (0x1) +int 0x2a && 0x0 == 0x0 (0x0) +__uint 0x2a && 0x0 == 0x0 (0x0) +char 0x2a && 0x0 == 0x0 (0x0) +__uchar 0x2a && 0x0 == 0x0 (0x0) +__longlong 0x2a && 0x0 == 0x0 (0x0) +__ulonglong 0x2a && 0x0 == 0x0 (0x0) +int 0x2a || 0x1 == 0x1 (0x1) +__uint 0x2a || 0x1 == 0x1 (0x1) +char 0x2a || 0x1 == 0x1 (0x1) +__uchar 0x2a || 0x1 == 0x1 (0x1) +__longlong 0x2a || 0x1 == 0x1 (0x1) +__ulonglong 0x2a || 0x1 == 0x1 (0x1) +int 0x2a && 0x1 == 0x1 (0x1) +__uint 0x2a && 0x1 == 0x1 (0x1) +char 0x2a && 0x1 == 0x1 (0x1) +__uchar 0x2a && 0x1 == 0x1 (0x1) +__longlong 0x2a && 0x1 == 0x1 (0x1) +__ulonglong 0x2a && 0x1 == 0x1 (0x1) +int 0x2a || 0xffff == 0x1 (0x1) +__uint 0x2a || 0xffff == 0x1 (0x1) +char 0x2a || 0xffff == 0x1 (0x1) +__uchar 0x2a || 0xff == 0x1 (0x1) +__longlong 0x2a || 0xffff == 0x1 (0x1) +__ulonglong 0x2a || 0xffff == 0x1 (0x1) +int 0x2a && 0xffff == 0x1 (0x1) +__uint 0x2a && 0xffff == 0x1 (0x1) +char 0x2a && 0xffff == 0x1 (0x1) +__uchar 0x2a && 0xff == 0x1 (0x1) +__longlong 0x2a && 0xffff == 0x1 (0x1) +__ulonglong 0x2a && 0xffff == 0x1 (0x1) +int 0x2a || 0x2a == 0x1 (0x1) +__uint 0x2a || 0x2a == 0x1 (0x1) +char 0x2a || 0x2a == 0x1 (0x1) +__uchar 0x2a || 0x2a == 0x1 (0x1) +__longlong 0x2a || 0x2a == 0x1 (0x1) +__ulonglong 0x2a || 0x2a == 0x1 (0x1) +int 0x2a && 0x2a == 0x1 (0x1) +__uint 0x2a && 0x2a == 0x1 (0x1) +char 0x2a && 0x2a == 0x1 (0x1) +__uchar 0x2a && 0x2a == 0x1 (0x1) +__longlong 0x2a && 0x2a == 0x1 (0x1) +__ulonglong 0x2a && 0x2a == 0x1 (0x1) +int 0x2a || 0x17 == 0x1 (0x1) +__uint 0x2a || 0x17 == 0x1 (0x1) +char 0x2a || 0x17 == 0x1 (0x1) +__uchar 0x2a || 0x17 == 0x1 (0x1) +__longlong 0x2a || 0x17 == 0x1 (0x1) +__ulonglong 0x2a || 0x17 == 0x1 (0x1) +int 0x2a && 0x17 == 0x1 (0x1) +__uint 0x2a && 0x17 == 0x1 (0x1) +char 0x2a && 0x17 == 0x1 (0x1) +__uchar 0x2a && 0x17 == 0x1 (0x1) +__longlong 0x2a && 0x17 == 0x1 (0x1) +__ulonglong 0x2a && 0x17 == 0x1 (0x1) +int 0x2a || 0x7fff == 0x1 (0x1) +__uint 0x2a || 0x7fff == 0x1 (0x1) +char 0x2a || 0xffff == 0x1 (0x1) +__uchar 0x2a || 0xff == 0x1 (0x1) +__longlong 0x2a || 0x7fff == 0x1 (0x1) +__ulonglong 0x2a || 0x7fff == 0x1 (0x1) +int 0x2a && 0x7fff == 0x1 (0x1) +__uint 0x2a && 0x7fff == 0x1 (0x1) +char 0x2a && 0xffff == 0x1 (0x1) +__uchar 0x2a && 0xff == 0x1 (0x1) +__longlong 0x2a && 0x7fff == 0x1 (0x1) +__ulonglong 0x2a && 0x7fff == 0x1 (0x1) +int 0x2a || 0x8000 == 0x1 (0x1) +__uint 0x2a || 0x8000 == 0x1 (0x1) +char 0x2a || 0x0 == 0x1 (0x1) +__uchar 0x2a || 0x0 == 0x1 (0x1) +__longlong 0x2a || 0x8000 == 0x1 (0x1) +__ulonglong 0x2a || 0x8000 == 0x1 (0x1) +int 0x2a && 0x8000 == 0x1 (0x1) +__uint 0x2a && 0x8000 == 0x1 (0x1) +char 0x2a && 0x0 == 0x0 (0x0) +__uchar 0x2a && 0x0 == 0x0 (0x0) +__longlong 0x2a && 0x8000 == 0x1 (0x1) +__ulonglong 0x2a && 0x8000 == 0x1 (0x1) +int 0x17 || 0x0 == 0x1 (0x1) +__uint 0x17 || 0x0 == 0x1 (0x1) +char 0x17 || 0x0 == 0x1 (0x1) +__uchar 0x17 || 0x0 == 0x1 (0x1) +__longlong 0x17 || 0x0 == 0x1 (0x1) +__ulonglong 0x17 || 0x0 == 0x1 (0x1) +int 0x17 && 0x0 == 0x0 (0x0) +__uint 0x17 && 0x0 == 0x0 (0x0) +char 0x17 && 0x0 == 0x0 (0x0) +__uchar 0x17 && 0x0 == 0x0 (0x0) +__longlong 0x17 && 0x0 == 0x0 (0x0) +__ulonglong 0x17 && 0x0 == 0x0 (0x0) +int 0x17 || 0x1 == 0x1 (0x1) +__uint 0x17 || 0x1 == 0x1 (0x1) +char 0x17 || 0x1 == 0x1 (0x1) +__uchar 0x17 || 0x1 == 0x1 (0x1) +__longlong 0x17 || 0x1 == 0x1 (0x1) +__ulonglong 0x17 || 0x1 == 0x1 (0x1) +int 0x17 && 0x1 == 0x1 (0x1) +__uint 0x17 && 0x1 == 0x1 (0x1) +char 0x17 && 0x1 == 0x1 (0x1) +__uchar 0x17 && 0x1 == 0x1 (0x1) +__longlong 0x17 && 0x1 == 0x1 (0x1) +__ulonglong 0x17 && 0x1 == 0x1 (0x1) +int 0x17 || 0xffff == 0x1 (0x1) +__uint 0x17 || 0xffff == 0x1 (0x1) +char 0x17 || 0xffff == 0x1 (0x1) +__uchar 0x17 || 0xff == 0x1 (0x1) +__longlong 0x17 || 0xffff == 0x1 (0x1) +__ulonglong 0x17 || 0xffff == 0x1 (0x1) +int 0x17 && 0xffff == 0x1 (0x1) +__uint 0x17 && 0xffff == 0x1 (0x1) +char 0x17 && 0xffff == 0x1 (0x1) +__uchar 0x17 && 0xff == 0x1 (0x1) +__longlong 0x17 && 0xffff == 0x1 (0x1) +__ulonglong 0x17 && 0xffff == 0x1 (0x1) +int 0x17 || 0x2a == 0x1 (0x1) +__uint 0x17 || 0x2a == 0x1 (0x1) +char 0x17 || 0x2a == 0x1 (0x1) +__uchar 0x17 || 0x2a == 0x1 (0x1) +__longlong 0x17 || 0x2a == 0x1 (0x1) +__ulonglong 0x17 || 0x2a == 0x1 (0x1) +int 0x17 && 0x2a == 0x1 (0x1) +__uint 0x17 && 0x2a == 0x1 (0x1) +char 0x17 && 0x2a == 0x1 (0x1) +__uchar 0x17 && 0x2a == 0x1 (0x1) +__longlong 0x17 && 0x2a == 0x1 (0x1) +__ulonglong 0x17 && 0x2a == 0x1 (0x1) +int 0x17 || 0x17 == 0x1 (0x1) +__uint 0x17 || 0x17 == 0x1 (0x1) +char 0x17 || 0x17 == 0x1 (0x1) +__uchar 0x17 || 0x17 == 0x1 (0x1) +__longlong 0x17 || 0x17 == 0x1 (0x1) +__ulonglong 0x17 || 0x17 == 0x1 (0x1) +int 0x17 && 0x17 == 0x1 (0x1) +__uint 0x17 && 0x17 == 0x1 (0x1) +char 0x17 && 0x17 == 0x1 (0x1) +__uchar 0x17 && 0x17 == 0x1 (0x1) +__longlong 0x17 && 0x17 == 0x1 (0x1) +__ulonglong 0x17 && 0x17 == 0x1 (0x1) +int 0x17 || 0x7fff == 0x1 (0x1) +__uint 0x17 || 0x7fff == 0x1 (0x1) +char 0x17 || 0xffff == 0x1 (0x1) +__uchar 0x17 || 0xff == 0x1 (0x1) +__longlong 0x17 || 0x7fff == 0x1 (0x1) +__ulonglong 0x17 || 0x7fff == 0x1 (0x1) +int 0x17 && 0x7fff == 0x1 (0x1) +__uint 0x17 && 0x7fff == 0x1 (0x1) +char 0x17 && 0xffff == 0x1 (0x1) +__uchar 0x17 && 0xff == 0x1 (0x1) +__longlong 0x17 && 0x7fff == 0x1 (0x1) +__ulonglong 0x17 && 0x7fff == 0x1 (0x1) +int 0x17 || 0x8000 == 0x1 (0x1) +__uint 0x17 || 0x8000 == 0x1 (0x1) +char 0x17 || 0x0 == 0x1 (0x1) +__uchar 0x17 || 0x0 == 0x1 (0x1) +__longlong 0x17 || 0x8000 == 0x1 (0x1) +__ulonglong 0x17 || 0x8000 == 0x1 (0x1) +int 0x17 && 0x8000 == 0x1 (0x1) +__uint 0x17 && 0x8000 == 0x1 (0x1) +char 0x17 && 0x0 == 0x0 (0x0) +__uchar 0x17 && 0x0 == 0x0 (0x0) +__longlong 0x17 && 0x8000 == 0x1 (0x1) +__ulonglong 0x17 && 0x8000 == 0x1 (0x1) +int 0x7fff || 0x0 == 0x1 (0x1) +__uint 0x7fff || 0x0 == 0x1 (0x1) +char 0xffff || 0x0 == 0x1 (0x1) +__uchar 0xff || 0x0 == 0x1 (0x1) +__longlong 0x7fff || 0x0 == 0x1 (0x1) +__ulonglong 0x7fff || 0x0 == 0x1 (0x1) +int 0x7fff && 0x0 == 0x0 (0x0) +__uint 0x7fff && 0x0 == 0x0 (0x0) +char 0xffff && 0x0 == 0x0 (0x0) +__uchar 0xff && 0x0 == 0x0 (0x0) +__longlong 0x7fff && 0x0 == 0x0 (0x0) +__ulonglong 0x7fff && 0x0 == 0x0 (0x0) +int 0x7fff || 0x1 == 0x1 (0x1) +__uint 0x7fff || 0x1 == 0x1 (0x1) +char 0xffff || 0x1 == 0x1 (0x1) +__uchar 0xff || 0x1 == 0x1 (0x1) +__longlong 0x7fff || 0x1 == 0x1 (0x1) +__ulonglong 0x7fff || 0x1 == 0x1 (0x1) +int 0x7fff && 0x1 == 0x1 (0x1) +__uint 0x7fff && 0x1 == 0x1 (0x1) +char 0xffff && 0x1 == 0x1 (0x1) +__uchar 0xff && 0x1 == 0x1 (0x1) +__longlong 0x7fff && 0x1 == 0x1 (0x1) +__ulonglong 0x7fff && 0x1 == 0x1 (0x1) +int 0x7fff || 0xffff == 0x1 (0x1) +__uint 0x7fff || 0xffff == 0x1 (0x1) +char 0xffff || 0xffff == 0x1 (0x1) +__uchar 0xff || 0xff == 0x1 (0x1) +__longlong 0x7fff || 0xffff == 0x1 (0x1) +__ulonglong 0x7fff || 0xffff == 0x1 (0x1) +int 0x7fff && 0xffff == 0x1 (0x1) +__uint 0x7fff && 0xffff == 0x1 (0x1) +char 0xffff && 0xffff == 0x1 (0x1) +__uchar 0xff && 0xff == 0x1 (0x1) +__longlong 0x7fff && 0xffff == 0x1 (0x1) +__ulonglong 0x7fff && 0xffff == 0x1 (0x1) +int 0x7fff || 0x2a == 0x1 (0x1) +__uint 0x7fff || 0x2a == 0x1 (0x1) +char 0xffff || 0x2a == 0x1 (0x1) +__uchar 0xff || 0x2a == 0x1 (0x1) +__longlong 0x7fff || 0x2a == 0x1 (0x1) +__ulonglong 0x7fff || 0x2a == 0x1 (0x1) +int 0x7fff && 0x2a == 0x1 (0x1) +__uint 0x7fff && 0x2a == 0x1 (0x1) +char 0xffff && 0x2a == 0x1 (0x1) +__uchar 0xff && 0x2a == 0x1 (0x1) +__longlong 0x7fff && 0x2a == 0x1 (0x1) +__ulonglong 0x7fff && 0x2a == 0x1 (0x1) +int 0x7fff || 0x17 == 0x1 (0x1) +__uint 0x7fff || 0x17 == 0x1 (0x1) +char 0xffff || 0x17 == 0x1 (0x1) +__uchar 0xff || 0x17 == 0x1 (0x1) +__longlong 0x7fff || 0x17 == 0x1 (0x1) +__ulonglong 0x7fff || 0x17 == 0x1 (0x1) +int 0x7fff && 0x17 == 0x1 (0x1) +__uint 0x7fff && 0x17 == 0x1 (0x1) +char 0xffff && 0x17 == 0x1 (0x1) +__uchar 0xff && 0x17 == 0x1 (0x1) +__longlong 0x7fff && 0x17 == 0x1 (0x1) +__ulonglong 0x7fff && 0x17 == 0x1 (0x1) +int 0x7fff || 0x7fff == 0x1 (0x1) +__uint 0x7fff || 0x7fff == 0x1 (0x1) +char 0xffff || 0xffff == 0x1 (0x1) +__uchar 0xff || 0xff == 0x1 (0x1) +__longlong 0x7fff || 0x7fff == 0x1 (0x1) +__ulonglong 0x7fff || 0x7fff == 0x1 (0x1) +int 0x7fff && 0x7fff == 0x1 (0x1) +__uint 0x7fff && 0x7fff == 0x1 (0x1) +char 0xffff && 0xffff == 0x1 (0x1) +__uchar 0xff && 0xff == 0x1 (0x1) +__longlong 0x7fff && 0x7fff == 0x1 (0x1) +__ulonglong 0x7fff && 0x7fff == 0x1 (0x1) +int 0x7fff || 0x8000 == 0x1 (0x1) +__uint 0x7fff || 0x8000 == 0x1 (0x1) +char 0xffff || 0x0 == 0x1 (0x1) +__uchar 0xff || 0x0 == 0x1 (0x1) +__longlong 0x7fff || 0x8000 == 0x1 (0x1) +__ulonglong 0x7fff || 0x8000 == 0x1 (0x1) +int 0x7fff && 0x8000 == 0x1 (0x1) +__uint 0x7fff && 0x8000 == 0x1 (0x1) +char 0xffff && 0x0 == 0x0 (0x0) +__uchar 0xff && 0x0 == 0x0 (0x0) +__longlong 0x7fff && 0x8000 == 0x1 (0x1) +__ulonglong 0x7fff && 0x8000 == 0x1 (0x1) +int 0x8000 || 0x0 == 0x1 (0x1) +__uint 0x8000 || 0x0 == 0x1 (0x1) +char 0x0 || 0x0 == 0x0 (0x0) +__uchar 0x0 || 0x0 == 0x0 (0x0) +__longlong 0x8000 || 0x0 == 0x1 (0x1) +__ulonglong 0x8000 || 0x0 == 0x1 (0x1) +int 0x8000 && 0x0 == 0x0 (0x0) +__uint 0x8000 && 0x0 == 0x0 (0x0) +char 0x0 && 0x0 == 0x0 (0x0) +__uchar 0x0 && 0x0 == 0x0 (0x0) +__longlong 0x8000 && 0x0 == 0x0 (0x0) +__ulonglong 0x8000 && 0x0 == 0x0 (0x0) +int 0x8000 || 0x1 == 0x1 (0x1) +__uint 0x8000 || 0x1 == 0x1 (0x1) +char 0x0 || 0x1 == 0x1 (0x1) +__uchar 0x0 || 0x1 == 0x1 (0x1) +__longlong 0x8000 || 0x1 == 0x1 (0x1) +__ulonglong 0x8000 || 0x1 == 0x1 (0x1) +int 0x8000 && 0x1 == 0x1 (0x1) +__uint 0x8000 && 0x1 == 0x1 (0x1) +char 0x0 && 0x1 == 0x0 (0x0) +__uchar 0x0 && 0x1 == 0x0 (0x0) +__longlong 0x8000 && 0x1 == 0x1 (0x1) +__ulonglong 0x8000 && 0x1 == 0x1 (0x1) +int 0x8000 || 0xffff == 0x1 (0x1) +__uint 0x8000 || 0xffff == 0x1 (0x1) +char 0x0 || 0xffff == 0x1 (0x1) +__uchar 0x0 || 0xff == 0x1 (0x1) +__longlong 0x8000 || 0xffff == 0x1 (0x1) +__ulonglong 0x8000 || 0xffff == 0x1 (0x1) +int 0x8000 && 0xffff == 0x1 (0x1) +__uint 0x8000 && 0xffff == 0x1 (0x1) +char 0x0 && 0xffff == 0x0 (0x0) +__uchar 0x0 && 0xff == 0x0 (0x0) +__longlong 0x8000 && 0xffff == 0x1 (0x1) +__ulonglong 0x8000 && 0xffff == 0x1 (0x1) +int 0x8000 || 0x2a == 0x1 (0x1) +__uint 0x8000 || 0x2a == 0x1 (0x1) +char 0x0 || 0x2a == 0x1 (0x1) +__uchar 0x0 || 0x2a == 0x1 (0x1) +__longlong 0x8000 || 0x2a == 0x1 (0x1) +__ulonglong 0x8000 || 0x2a == 0x1 (0x1) +int 0x8000 && 0x2a == 0x1 (0x1) +__uint 0x8000 && 0x2a == 0x1 (0x1) +char 0x0 && 0x2a == 0x0 (0x0) +__uchar 0x0 && 0x2a == 0x0 (0x0) +__longlong 0x8000 && 0x2a == 0x1 (0x1) +__ulonglong 0x8000 && 0x2a == 0x1 (0x1) +int 0x8000 || 0x17 == 0x1 (0x1) +__uint 0x8000 || 0x17 == 0x1 (0x1) +char 0x0 || 0x17 == 0x1 (0x1) +__uchar 0x0 || 0x17 == 0x1 (0x1) +__longlong 0x8000 || 0x17 == 0x1 (0x1) +__ulonglong 0x8000 || 0x17 == 0x1 (0x1) +int 0x8000 && 0x17 == 0x1 (0x1) +__uint 0x8000 && 0x17 == 0x1 (0x1) +char 0x0 && 0x17 == 0x0 (0x0) +__uchar 0x0 && 0x17 == 0x0 (0x0) +__longlong 0x8000 && 0x17 == 0x1 (0x1) +__ulonglong 0x8000 && 0x17 == 0x1 (0x1) +int 0x8000 || 0x7fff == 0x1 (0x1) +__uint 0x8000 || 0x7fff == 0x1 (0x1) +char 0x0 || 0xffff == 0x1 (0x1) +__uchar 0x0 || 0xff == 0x1 (0x1) +__longlong 0x8000 || 0x7fff == 0x1 (0x1) +__ulonglong 0x8000 || 0x7fff == 0x1 (0x1) +int 0x8000 && 0x7fff == 0x1 (0x1) +__uint 0x8000 && 0x7fff == 0x1 (0x1) +char 0x0 && 0xffff == 0x0 (0x0) +__uchar 0x0 && 0xff == 0x0 (0x0) +__longlong 0x8000 && 0x7fff == 0x1 (0x1) +__ulonglong 0x8000 && 0x7fff == 0x1 (0x1) +int 0x8000 || 0x8000 == 0x1 (0x1) +__uint 0x8000 || 0x8000 == 0x1 (0x1) +char 0x0 || 0x0 == 0x0 (0x0) +__uchar 0x0 || 0x0 == 0x0 (0x0) +__longlong 0x8000 || 0x8000 == 0x1 (0x1) +__ulonglong 0x8000 || 0x8000 == 0x1 (0x1) +int 0x8000 && 0x8000 == 0x1 (0x1) +__uint 0x8000 && 0x8000 == 0x1 (0x1) +char 0x0 && 0x0 == 0x0 (0x0) +__uchar 0x0 && 0x0 == 0x0 (0x0) +__longlong 0x8000 && 0x8000 == 0x1 (0x1) +__ulonglong 0x8000 && 0x8000 == 0x1 (0x1) +0xbef0 +0xbac0 +0x2a +0x2 +0x17 +0x2a +0x3 +0x17 +0x2 +0x8 +0x8007 (0x8007) +0x8002 (0x8002) +0x1000 (0x1000) +0x8000 (0x8000) +0x40x0 +0x40000 (0x40000) +0xfffc0000 (0xfffc0000) +fritzhans 0x6 +hans2int OK +bubu +0xa0x20xafloat 0x2null +<= 10 + +0x0 +0x0 +eins +<= 10 +0x1 +0x10x0 +0x10x0 +zwei +<= 10 +0x20x1 +0x20x10x0 +0x20x10x0 +drei, nicht vier +<= 10 +0x30x20x1 +0x30x20x10x0 +0x30x20x10x0 +vier +<= 10 +0x40x30x20x1 +0x40x30x20x10x0 +0x40x30x20x10x0 +wos moanst? +<= 10 +0x50x40x30x20x1 +0x50x40x30x20x10x0 +0x50x40x30x20x10x0 +wos moanst? +<= 10 +0x60x50x40x30x20x1 +0x60x50x40x30x20x10x0 +0x60x50x40x30x20x10x0 +wos moanst? +<= 10 +0x70x60x50x40x30x20x1 +0x70x60x50x40x30x20x10x0 +0x70x60x50x40x30x20x10x0 +wos moanst? +<= 10 +0x80x70x60x50x40x30x20x1 +0x80x70x60x50x40x30x20x10x0 +0x80x70x60x50x40x30x20x10x0 +wos moanst? +<= 10 +0x90x80x70x60x50x40x30x20x1 +0x90x80x70x60x50x40x30x20x10x0 +0x90x80x70x60x50x40x30x20x10x0 +wos moanst? +<= 10 +0xa0x90x80x70x60x50x40x30x20x1 +0xa0x90x80x70x60x50x40x30x20x10x0 +0xa0x90x80x70x60x50x40x30x20x10x0 +wos moanst? +== 11 +0xb0xa0x90x80x70x60x50x40x30x20x1 +0xb0xa0x90x80x70x60x50x40x30x20x10x0 +0xb0xa0x90x80x70x60x50x40x30x20x10x0 +wos moanst? +> 11 +0xc0xb0xa0x90x80x70x60x50x40x30x20x1 +0xc0xb0xa0x90x80x70x60x50x40x30x20x10x0 +0xc0xb0xa0x90x80x70x60x50x40x30x20x10x0 +wos moanst? +> 11 +0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x1 +0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x10x0 +0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x10x0 +wos moanst? +> 11 +0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x1 +0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x10x0 +0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x10x0 +wos moanst? +> 11 +0xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x1 +0xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x10x0 +0xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x10x0 +wos moanst? +> 11 +0x100xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x1 +0x100xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x10x0 +0x100xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x10x0 +wos moanst? +> 11 +0x110x100xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x1 +0x110x100xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x10x0 +0x110x100xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x10x0 +wos moanst? +> 11 +0x120x110x100xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x1 +0x120x110x100xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x10x0 +0x120x110x100xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x10x0 +wos moanst? +> 11 +0x130x120x110x100xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x1 +0x130x120x110x100xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x10x0 +0x130x120x110x100xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x10x0 +wos moanst? +> 11 +0x140x130x120x110x100xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x1 +0x140x130x120x110x100xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x10x0 +0x140x130x120x110x100xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x10x0 +wos moanst? +> 11 +0x150x140x130x120x110x100xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x1 +0x150x140x130x120x110x100xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x10x0 +0x150x140x130x120x110x100xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x10x0 +wos moanst? +> 11 +0x160x150x140x130x120x110x100xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x1 +0x160x150x140x130x120x110x100xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x10x0 +0x160x150x140x130x120x110x100xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x10x0 +wos moanst? +> 11 +0x170x160x150x140x130x120x110x100xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x1 +0x170x160x150x140x130x120x110x100xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x10x0 +0x170x160x150x140x130x120x110x100xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x10x0 +wos moanst? +> 11 +0x180x170x160x150x140x130x120x110x100xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x1 +0x180x170x160x150x140x130x120x110x100xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x10x0 +0x180x170x160x150x140x130x120x110x100xf0xe0xd0xc0xb0xa0x90x80x70x60x50x40x30x20x10x0 +-0x1 +0xffff diff --git a/test/hw/test.lnk b/test/hw/test.lnk new file mode 100644 index 0000000..eb21a07 --- /dev/null +++ b/test/hw/test.lnk @@ -0,0 +1,8 @@ +[objects] +../../../libs/crt0_snes.obj +../../../libs/libm.obj +../../../libs/libtcc.obj +../../../libs/libc.obj +hw3.obj +hw3a.obj +asmfptest.obj diff --git a/test/mk b/test/mk new file mode 100755 index 0000000..42f38f0 --- /dev/null +++ b/test/mk @@ -0,0 +1,48 @@ +#!/bin/bash +tests="tests/* dg/*" +test -n "$1" && tests="$@" +export OPT816_QUIET=1 +for i in $tests +do + echo -n "$i: " + if ! ../816-tcc -I../include -DSTACK_SIZE=0x2000 -o ./suite.asm -c $i ; then + echo NOCOMPILE + continue + fi + if test "$OPTIMIZE" = "1" ; then + mv suite.asm suite.asm.pre + if ! python ../816-opt.py suite.asm.pre >suite.asm ; then + echo NOOPT + continue + fi + #if ! ./optimore-816r2/optimore-816 suite.asm suite2.asm >/dev/null ; then + # echo NOOPT2 + # continue + #else + # mv suite2.asm suite.asm + #fi + fi + if ! ../../wla_dx/wla-65816 -io ./suite.asm ./suite.obj ; then + echo NOASM + mkdir -p failtraces + mv suite.asm failtraces/${i#*/}.asm + continue + fi + if ! ../../wla_dx/wlalink/wlalink -Sno ../../libs/crt0_snes.obj ../../libs/libm.obj ../../libs/libtcc.obj ../../libs/libc.obj suite.obj ./test.smc ; then + echo NOLINK + mkdir -p failtraces + mv suite.asm failtraces/${i#*/}.asm + continue + fi + if ../../bsnes/bsnes ./test.smc 2>/dev/null >/dev/null ; then + echo PASS + rm -f failtraces/${i#*/}.{asm,trace} + else + echo "FAIL (exit code $?)" + mkdir -p failtraces + mv suite.asm failtraces/${i#*/}.asm + mv suite.asm.pre failtraces/${i#*/}.asm.pre + fi + xset r on +done +test -z "$NOCLEAN" && rm -f suite.asm .sym suite.obj test.smc diff --git a/test/not_applicable/20010904-1.c b/test/not_applicable/20010904-1.c new file mode 100644 index 0000000..92b258b --- /dev/null +++ b/test/not_applicable/20010904-1.c @@ -0,0 +1,11 @@ +typedef struct x { int a; int b; } __attribute__((aligned(32))) X; +typedef struct y { X x[32]; int c; } Y; + +Y y[2]; + +int main(void) +{ + if (((char *)&y[1] - (char *)&y[0]) & 31) + abort (); + exit (0); +} diff --git a/test/not_applicable/20010904-2.c b/test/not_applicable/20010904-2.c new file mode 100644 index 0000000..cbe4980 --- /dev/null +++ b/test/not_applicable/20010904-2.c @@ -0,0 +1,11 @@ +typedef struct x { int a; int b; } __attribute__((aligned(32))) X; +typedef struct y { X x; X y[31]; int c; } Y; + +Y y[2]; + +int main(void) +{ + if (((char *)&y[1] - (char *)&y[0]) & 31) + abort (); + exit (0); +} diff --git a/test/not_applicable/20021127-1.c b/test/not_applicable/20021127-1.c new file mode 100644 index 0000000..0b3ff9a --- /dev/null +++ b/test/not_applicable/20021127-1.c @@ -0,0 +1,14 @@ +long long a = -1; +long long llabs (long long); +void abort (void); +int +main() +{ + if (llabs (a) != 1) + abort (); + return 0; +} +long long llabs (long long b) +{ + abort (); +} diff --git a/test/not_applicable/20030330-1.c b/test/not_applicable/20030330-1.c new file mode 100644 index 0000000..639e47b --- /dev/null +++ b/test/not_applicable/20030330-1.c @@ -0,0 +1,14 @@ +/* PR opt/10011 */ +/* This is link test for builtin_constant_p simplification + DCE. */ + +extern void link_error(void); +static void usb_hub_port_wait_reset(unsigned int delay) +{ + int delay_time; + for (delay_time = 0; delay_time < 500; delay_time += delay) { + if (__builtin_constant_p(delay)) + link_error(); + } +} + +int main() { return 0; } diff --git a/test/not_applicable/20050607-1.c b/test/not_applicable/20050607-1.c new file mode 100644 index 0000000..41579bb --- /dev/null +++ b/test/not_applicable/20050607-1.c @@ -0,0 +1,16 @@ +/* PR middle-end/21850 */ + +extern void abort (void); + +typedef int V2SI __attribute__ ((vector_size (8))); + +int +main (void) +{ +#if (__INT_MAX__ == 2147483647) \ + && (__LONG_LONG_MAX__ == 9223372036854775807LL) + if (((int)(long long)(V2SI){ 2, 2 }) != 2) + abort (); +#endif + return 0; +} diff --git a/test/not_applicable/920501-2.c b/test/not_applicable/920501-2.c new file mode 100644 index 0000000..8709c2a --- /dev/null +++ b/test/not_applicable/920501-2.c @@ -0,0 +1,132 @@ +// does not work with 32-bit long longs + +#ifdef __65816__ +typedef unsigned long long __ulonglong; +typedef long long __longlong; +#else +typedef unsigned int __ulonglong; +typedef int __longlong; +#endif + +__ulonglong +gcd_ll (__ulonglong x, __ulonglong y) +{ + for (;;) + { + if (y == 0) + return (__ulonglong) x; + x = x % y; + if (x == 0) + return (__ulonglong) y; + y = y % x; + } +} + +__ulonglong +powmod_ll (__ulonglong b, __ulonglong e, __ulonglong m) +{ + __ulonglong t; + __ulonglong pow; + __longlong i; + + if (e == 0) + return 1; + + /* Find the most significant bit in E. */ + t = e; + for (i = 0; t != 0; i++) + t >>= 1; + + /* The most sign bit in E is handled outside of the loop, by beginning + with B in POW, and decrementing I. */ + pow = b; + i -= 2; + + for (; i >= 0; i--) + { + pow = pow * pow % m; + if ((1 << i) & e) + pow = pow * b % m; + } + + return pow; +} + +__ulonglong factab[10]; + +void +facts (t, a_int, x0, p) + __ulonglong t; + __longlong a_int; + __longlong x0; + __ulonglong p; +{ + __ulonglong *xp = factab; + __ulonglong x, y; + __ulonglong q = 1; + __ulonglong a = a_int; + __longlong i; + __ulonglong d; + __longlong j = 1; + __ulonglong tmp; + __longlong jj = 0; + + if(t != 134217727 || a_int != -1 || x0 != 3 || p != 27) exit(5); + + x = x0; + y = x0; + + if(x != 3 || y != 3) exit(6); + + for (i = 1; i < 5; i++) + { + x = powmod_ll (x, p, t) + a; + y = powmod_ll (y, p, t) + a; + y = powmod_ll (y, p, t) + a; + + if (x > y) + tmp = x - y; + else + tmp = y - x; + q = (__ulonglong) q * tmp % t; + + if (i == j) + { + jj += 1; + j += jj; + d = gcd_ll (q, t); + if (d != 1) + { + *xp++ = d; + t /= d; + if (t == 1) + { + return; + *xp = 0; + } + } + } + } +} + +main () +{ + __ulonglong t; + __ulonglong x0, a; + __ulonglong p; + + p = 27; + t = (1ULL << p) - 1; + if(t != 134217727) exit(3); + + a = -1; + x0 = 3; + + if(a != -1 || x0 != 3) exit(4); + facts (t, a, x0, p); + //exitl4(factab[0], factab[1], factab[2], factab[3]); + //printf("%lld %lld %lld %lld\n",factab[0], factab[1], factab[2], factab[3]); + if (factab[0] != 7 || factab[1] != 73 /* || factab[2] != 262657 */) + abort(); + exit (0); +} diff --git a/test/not_applicable/990413-2.c b/test/not_applicable/990413-2.c new file mode 100644 index 0000000..262140a --- /dev/null +++ b/test/not_applicable/990413-2.c @@ -0,0 +1,50 @@ +/* This tests for a bug in regstack that was breaking glibc's math library. */ + +extern void abort (void); + +static __inline double +minus_zero (void) +{ + union { double __d; int __i[2]; } __x; + __x.__i[0] = 0x0; + __x.__i[1] = 0x80000000; + return __x.__d; +} + +static __inline long double +__atan2l (long double __y, long double __x) +{ + register long double __value; + __asm __volatile__ ("fpatan\n\t" + : "=t" (__value) + : "0" (__x), "u" (__y) + : "st(1)"); + return __value; +} + +static __inline long double +__sqrtl (long double __x) +{ + register long double __result; + __asm __volatile__ ("fsqrt" : "=t" (__result) : "0" (__x)); + return __result; +} + +static __inline double +asin (double __x) +{ + return __atan2l (__x, __sqrtl (1.0 - __x * __x)); +} + +int +main (void) +{ + double x; + + x = minus_zero(); + x = asin (x); + + if (x != 0.0) /* actually -0.0, but 0.0 == -0.0 */ + abort (); + return 0; +} diff --git a/test/not_applicable/align-3.c b/test/not_applicable/align-3.c new file mode 100644 index 0000000..2838e77 --- /dev/null +++ b/test/not_applicable/align-3.c @@ -0,0 +1,12 @@ +void func(void) __attribute__((aligned(256))); + +void func(void) +{ +} + +int main() +{ + if (__alignof__(func) != 256) + abort (); + return 0; +} diff --git a/test/not_applicable/bf64-1.c b/test/not_applicable/bf64-1.c new file mode 100644 index 0000000..60028fb --- /dev/null +++ b/test/not_applicable/bf64-1.c @@ -0,0 +1,40 @@ +struct tmp +{ + long long int pad : 12; + long long int field : 52; +}; + +struct tmp2 +{ + long long int field : 52; + long long int pad : 12; +}; + +struct tmp +sub (struct tmp tmp) +{ + tmp.field |= 0x0008765412345678LL; + return tmp; +} + +struct tmp2 +sub2 (struct tmp2 tmp2) +{ + tmp2.field |= 0x0008765412345678LL; + return tmp2; +} + +main() +{ + struct tmp tmp = {0x123, 0xFFF000FFF000FLL}; + struct tmp2 tmp2 = {0xFFF000FFF000FLL, 0x123}; + + tmp = sub (tmp); + tmp2 = sub2 (tmp2); + + if (tmp.pad != 0x123 || tmp.field != 0xFFFFFF541FFF567FLL) + abort (); + if (tmp2.pad != 0x123 || tmp2.field != 0xFFFFFF541FFF567FLL) + abort (); + exit (0); +} diff --git a/test/not_applicable/bitfld-3.c b/test/not_applicable/bitfld-3.c new file mode 100644 index 0000000..52a4147 --- /dev/null +++ b/test/not_applicable/bitfld-3.c @@ -0,0 +1,54 @@ +/* Test that operations on bit-fields yield results reduced to bit-field + type. */ +/* Origin: Joseph Myers */ + +extern void exit (int); +extern void abort (void); + +struct s { + unsigned long long u33: 33; + unsigned long long u40: 40; + unsigned long long u41: 41; +}; + +struct s a = { 0x100000, 0x100000, 0x100000 }; +struct s b = { 0x100000000ULL, 0x100000000ULL, 0x100000000ULL }; +struct s c = { 0x1FFFFFFFFULL, 0, 0 }; + +int +main (void) +{ + if (a.u33 * a.u33 != 0 || a.u33 * a.u40 != 0 || a.u40 * a.u33 != 0 + || a.u40 * a.u40 != 0) + abort (); + if (a.u33 * a.u41 != 0x10000000000ULL + || a.u40 * a.u41 != 0x10000000000ULL + || a.u41 * a.u33 != 0x10000000000ULL + || a.u41 * a.u40 != 0x10000000000ULL + || a.u41 * a.u41 != 0x10000000000ULL) + abort (); + if (b.u33 + b.u33 != 0) + abort (); + if (b.u33 + b.u40 != 0x200000000ULL + || b.u33 + b.u41 != 0x200000000ULL + || b.u40 + b.u33 != 0x200000000ULL + || b.u40 + b.u40 != 0x200000000ULL + || b.u40 + b.u41 != 0x200000000ULL + || b.u41 + b.u33 != 0x200000000ULL + || b.u41 + b.u40 != 0x200000000ULL + || b.u41 + b.u41 != 0x200000000ULL) + abort (); + if (a.u33 - b.u33 != 0x100100000ULL + || a.u33 - b.u40 != 0xFF00100000ULL + || a.u33 - b.u41 != 0x1FF00100000ULL + || a.u40 - b.u33 != 0xFF00100000ULL + || a.u40 - b.u40 != 0xFF00100000ULL + || a.u40 - b.u41 != 0x1FF00100000ULL + || a.u41 - b.u33 != 0x1FF00100000ULL + || a.u41 - b.u40 != 0x1FF00100000ULL + || a.u41 - b.u41 != 0x1FF00100000ULL) + abort (); + if (++c.u33 != 0 || --c.u40 != 0xFFFFFFFFFFULL || c.u41-- != 0) + abort (); + exit (0); +} diff --git a/test/not_applicable/builtin-prefetch-1.c b/test/not_applicable/builtin-prefetch-1.c new file mode 100644 index 0000000..4ee05a9 --- /dev/null +++ b/test/not_applicable/builtin-prefetch-1.c @@ -0,0 +1,69 @@ +/* Test that __builtin_prefetch does no harm. + + Prefetch using all valid combinations of rw and locality values. + These must be compile-time constants. */ + +#define NO_TEMPORAL_LOCALITY 0 +#define LOW_TEMPORAL_LOCALITY 1 +#define MODERATE_TEMPORAL_LOCALITY 1 +#define HIGH_TEMPORAL_LOCALITY 3 + +#define WRITE_ACCESS 1 +#define READ_ACCESS 0 + +enum locality { none, low, moderate, high }; +enum rw { read, write }; + +int arr[10]; + +void +good_const (const int *p) +{ + __builtin_prefetch (p, 0, 0); + __builtin_prefetch (p, 0, 1); + __builtin_prefetch (p, 0, 2); + __builtin_prefetch (p, READ_ACCESS, 3); + __builtin_prefetch (p, 1, NO_TEMPORAL_LOCALITY); + __builtin_prefetch (p, 1, LOW_TEMPORAL_LOCALITY); + __builtin_prefetch (p, 1, MODERATE_TEMPORAL_LOCALITY); + __builtin_prefetch (p, WRITE_ACCESS, HIGH_TEMPORAL_LOCALITY); +} + +void +good_enum (const int *p) +{ + __builtin_prefetch (p, read, none); + __builtin_prefetch (p, read, low); + __builtin_prefetch (p, read, moderate); + __builtin_prefetch (p, read, high); + __builtin_prefetch (p, write, none); + __builtin_prefetch (p, write, low); + __builtin_prefetch (p, write, moderate); + __builtin_prefetch (p, write, high); +} + +void +good_expr (const int *p) +{ + __builtin_prefetch (p, 1 - 1, 6 - (2 * 3)); + __builtin_prefetch (p, 1 + 0, 1 + 2); +} + +void +good_vararg (const int *p) +{ + __builtin_prefetch (p, 0, 3); + __builtin_prefetch (p, 0); + __builtin_prefetch (p, 1); + __builtin_prefetch (p); +} + +int +main () +{ + good_const (arr); + good_enum (arr); + good_expr (arr); + good_vararg (arr); + exit (0); +} diff --git a/test/not_applicable/builtin-prefetch-2.c b/test/not_applicable/builtin-prefetch-2.c new file mode 100644 index 0000000..530a1b0 --- /dev/null +++ b/test/not_applicable/builtin-prefetch-2.c @@ -0,0 +1,152 @@ +/* Test that __builtin_prefetch does no harm. + + Prefetch data using a variety of storage classes and address + expressions. */ + +int glob_int_arr[100]; +int *glob_ptr_int = glob_int_arr; +int glob_int = 4; + +static stat_int_arr[100]; +static int *stat_ptr_int = stat_int_arr; +static int stat_int; + +struct S { + int a; + short b, c; + char d[8]; + struct S *next; +}; + +struct S str; +struct S *ptr_str = &str; + +/* Prefetch global variables using the address of the variable. */ + +void +simple_global () +{ + __builtin_prefetch (glob_int_arr, 0, 0); + __builtin_prefetch (glob_ptr_int, 0, 0); + __builtin_prefetch (&glob_int, 0, 0); +} + +/* Prefetch file-level static variables using the address of the variable. */ + +void +simple_file () +{ + __builtin_prefetch (stat_int_arr, 0, 0); + __builtin_prefetch (stat_ptr_int, 0, 0); + __builtin_prefetch (&stat_int, 0, 0); +} + +/* Prefetch local static variables using the address of the variable. */ + +void +simple_static_local () +{ + static int gx[100]; + static int *hx = gx; + static int ix; + __builtin_prefetch (gx, 0, 0); + __builtin_prefetch (hx, 0, 0); + __builtin_prefetch (&ix, 0, 0); +} + +/* Prefetch local stack variables using the address of the variable. */ + +void +simple_local () +{ + int gx[100]; + int *hx = gx; + int ix; + __builtin_prefetch (gx, 0, 0); + __builtin_prefetch (hx, 0, 0); + __builtin_prefetch (&ix, 0, 0); +} + +/* Prefetch arguments using the address of the variable. */ + +void +simple_arg (int g[100], int *h, int i) +{ + __builtin_prefetch (g, 0, 0); + __builtin_prefetch (h, 0, 0); + __builtin_prefetch (&i, 0, 0); +} + +/* Prefetch using address expressions involving global variables. */ + +void +expr_global (void) +{ + __builtin_prefetch (&str, 0, 0); + __builtin_prefetch (ptr_str, 0, 0); + __builtin_prefetch (&str.b, 0, 0); + __builtin_prefetch (&ptr_str->b, 0, 0); + __builtin_prefetch (&str.d, 0, 0); + __builtin_prefetch (&ptr_str->d, 0, 0); + __builtin_prefetch (str.next, 0, 0); + __builtin_prefetch (ptr_str->next, 0, 0); + __builtin_prefetch (str.next->d, 0, 0); + __builtin_prefetch (ptr_str->next->d, 0, 0); + + __builtin_prefetch (&glob_int_arr, 0, 0); + __builtin_prefetch (glob_ptr_int, 0, 0); + __builtin_prefetch (&glob_int_arr[2], 0, 0); + __builtin_prefetch (&glob_ptr_int[3], 0, 0); + __builtin_prefetch (glob_int_arr+3, 0, 0); + __builtin_prefetch (glob_int_arr+glob_int, 0, 0); + __builtin_prefetch (glob_ptr_int+5, 0, 0); + __builtin_prefetch (glob_ptr_int+glob_int, 0, 0); +} + +/* Prefetch using address expressions involving local variables. */ + +void +expr_local (void) +{ + int b[10]; + int *pb = b; + struct S t; + struct S *pt = &t; + int j = 4; + + __builtin_prefetch (&t, 0, 0); + __builtin_prefetch (pt, 0, 0); + __builtin_prefetch (&t.b, 0, 0); + __builtin_prefetch (&pt->b, 0, 0); + __builtin_prefetch (&t.d, 0, 0); + __builtin_prefetch (&pt->d, 0, 0); + __builtin_prefetch (t.next, 0, 0); + __builtin_prefetch (pt->next, 0, 0); + __builtin_prefetch (t.next->d, 0, 0); + __builtin_prefetch (pt->next->d, 0, 0); + + __builtin_prefetch (&b, 0, 0); + __builtin_prefetch (pb, 0, 0); + __builtin_prefetch (&b[2], 0, 0); + __builtin_prefetch (&pb[3], 0, 0); + __builtin_prefetch (b+3, 0, 0); + __builtin_prefetch (b+j, 0, 0); + __builtin_prefetch (pb+5, 0, 0); + __builtin_prefetch (pb+j, 0, 0); +} + +int +main () +{ + simple_global (); + simple_file (); + simple_static_local (); + simple_local (); + simple_arg (glob_int_arr, glob_ptr_int, glob_int); + + str.next = &str; + expr_global (); + expr_local (); + + exit (0); +} diff --git a/test/not_applicable/builtin-prefetch-3.c b/test/not_applicable/builtin-prefetch-3.c new file mode 100644 index 0000000..2e2e808 --- /dev/null +++ b/test/not_applicable/builtin-prefetch-3.c @@ -0,0 +1,113 @@ +/* Test that __builtin_prefetch does no harm. + + Prefetch data using a variety of storage classes and address + expressions with volatile variables and pointers. */ + +int glob_int_arr[100]; +int glob_int = 4; +volatile int glob_vol_int_arr[100]; +int * volatile glob_vol_ptr_int = glob_int_arr; +volatile int *glob_ptr_vol_int = glob_vol_int_arr; +volatile int * volatile glob_vol_ptr_vol_int = glob_vol_int_arr; +volatile int glob_vol_int; + +static stat_int_arr[100]; +static volatile int stat_vol_int_arr[100]; +static int * volatile stat_vol_ptr_int = stat_int_arr; +static volatile int *stat_ptr_vol_int = stat_vol_int_arr; +static volatile int * volatile stat_vol_ptr_vol_int = stat_vol_int_arr; +static volatile int stat_vol_int; + +struct S { + int a; + short b, c; + char d[8]; + struct S *next; +}; + +struct S str; +volatile struct S vol_str; +struct S * volatile vol_ptr_str = &str; +volatile struct S *ptr_vol_str = &vol_str; +volatile struct S * volatile vol_ptr_vol_str = &vol_str; + +/* Prefetch volatile global variables using the address of the variable. */ + +void +simple_vol_global () +{ + __builtin_prefetch (glob_vol_int_arr, 0, 0); + __builtin_prefetch (glob_vol_ptr_int, 0, 0); + __builtin_prefetch (glob_ptr_vol_int, 0, 0); + __builtin_prefetch (glob_vol_ptr_vol_int, 0, 0); + __builtin_prefetch (&glob_vol_int, 0, 0); +} + +/* Prefetch volatile static variables using the address of the variable. */ + +void +simple_vol_file () +{ + __builtin_prefetch (stat_vol_int_arr, 0, 0); + __builtin_prefetch (stat_vol_ptr_int, 0, 0); + __builtin_prefetch (stat_ptr_vol_int, 0, 0); + __builtin_prefetch (stat_vol_ptr_vol_int, 0, 0); + __builtin_prefetch (&stat_vol_int, 0, 0); +} + +/* Prefetch using address expressions involving volatile global variables. */ + +void +expr_vol_global (void) +{ + __builtin_prefetch (&vol_str, 0, 0); + __builtin_prefetch (ptr_vol_str, 0, 0); + __builtin_prefetch (vol_ptr_str, 0, 0); + __builtin_prefetch (vol_ptr_vol_str, 0, 0); + __builtin_prefetch (&vol_str.b, 0, 0); + __builtin_prefetch (&ptr_vol_str->b, 0, 0); + __builtin_prefetch (&vol_ptr_str->b, 0, 0); + __builtin_prefetch (&vol_ptr_vol_str->b, 0, 0); + __builtin_prefetch (&vol_str.d, 0, 0); + __builtin_prefetch (&vol_ptr_str->d, 0, 0); + __builtin_prefetch (&ptr_vol_str->d, 0, 0); + __builtin_prefetch (&vol_ptr_vol_str->d, 0, 0); + __builtin_prefetch (vol_str.next, 0, 0); + __builtin_prefetch (vol_ptr_str->next, 0, 0); + __builtin_prefetch (ptr_vol_str->next, 0, 0); + __builtin_prefetch (vol_ptr_vol_str->next, 0, 0); + __builtin_prefetch (vol_str.next->d, 0, 0); + __builtin_prefetch (vol_ptr_str->next->d, 0, 0); + __builtin_prefetch (ptr_vol_str->next->d, 0, 0); + __builtin_prefetch (vol_ptr_vol_str->next->d, 0, 0); + + __builtin_prefetch (&glob_vol_int_arr, 0, 0); + __builtin_prefetch (glob_vol_ptr_int, 0, 0); + __builtin_prefetch (glob_ptr_vol_int, 0, 0); + __builtin_prefetch (glob_vol_ptr_vol_int, 0, 0); + __builtin_prefetch (&glob_vol_int_arr[2], 0, 0); + __builtin_prefetch (&glob_vol_ptr_int[3], 0, 0); + __builtin_prefetch (&glob_ptr_vol_int[3], 0, 0); + __builtin_prefetch (&glob_vol_ptr_vol_int[3], 0, 0); + __builtin_prefetch (glob_vol_int_arr+3, 0, 0); + __builtin_prefetch (glob_vol_int_arr+glob_vol_int, 0, 0); + __builtin_prefetch (glob_vol_ptr_int+5, 0, 0); + __builtin_prefetch (glob_ptr_vol_int+5, 0, 0); + __builtin_prefetch (glob_vol_ptr_vol_int+5, 0, 0); + __builtin_prefetch (glob_vol_ptr_int+glob_vol_int, 0, 0); + __builtin_prefetch (glob_ptr_vol_int+glob_vol_int, 0, 0); + __builtin_prefetch (glob_vol_ptr_vol_int+glob_vol_int, 0, 0); +} + +int +main () +{ + simple_vol_global (); + simple_vol_file (); + + str.next = &str; + vol_str.next = &str; + expr_vol_global (); + + exit (0); +} diff --git a/test/not_applicable/builtin-prefetch-4.c b/test/not_applicable/builtin-prefetch-4.c new file mode 100644 index 0000000..ade892b --- /dev/null +++ b/test/not_applicable/builtin-prefetch-4.c @@ -0,0 +1,271 @@ +/* Test that __builtin_prefetch does no harm. + + Check that the expression containing the address to prefetch is + evaluated if it has side effects, even if the target does not support + data prefetch. Check changes to pointers and to array indices that are + either global variables or arguments. */ + +#define ARRSIZE 100 + +int arr[ARRSIZE]; +int *ptr = &arr[20]; +int arrindex = 4; + +/* Check that assignment within a prefetch argument is evaluated. */ + +int +assign_arg_ptr (int *p) +{ + int *q; + __builtin_prefetch ((q = p), 0, 0); + return q == p; +} + +int +assign_glob_ptr (void) +{ + int *q; + __builtin_prefetch ((q = ptr), 0, 0); + return q == ptr; +} + +int +assign_arg_idx (int *p, int i) +{ + int j; + __builtin_prefetch (&p[j = i], 0, 0); + return j == i; +} + +int +assign_glob_idx (void) +{ + int j; + __builtin_prefetch (&ptr[j = arrindex], 0, 0); + return j == arrindex; +} + +/* Check that pre/post increment/decrement within a prefetch argument are + evaluated. */ + +int +preinc_arg_ptr (int *p) +{ + int *q; + q = p + 1; + __builtin_prefetch (++p, 0, 0); + return p == q; +} + +int +preinc_glob_ptr (void) +{ + int *q; + q = ptr + 1; + __builtin_prefetch (++ptr, 0, 0); + return ptr == q; +} + +int +postinc_arg_ptr (int *p) +{ + int *q; + q = p + 1; + __builtin_prefetch (p++, 0, 0); + return p == q; +} + +int +postinc_glob_ptr (void) +{ + int *q; + q = ptr + 1; + __builtin_prefetch (ptr++, 0, 0); + return ptr == q; +} + +int +predec_arg_ptr (int *p) +{ + int *q; + q = p - 1; + __builtin_prefetch (--p, 0, 0); + return p == q; +} + +int +predec_glob_ptr (void) +{ + int *q; + q = ptr - 1; + __builtin_prefetch (--ptr, 0, 0); + return ptr == q; +} + +int +postdec_arg_ptr (int *p) +{ + int *q; + q = p - 1; + __builtin_prefetch (p--, 0, 0); + return p == q; +} + +int +postdec_glob_ptr (void) +{ + int *q; + q = ptr - 1; + __builtin_prefetch (ptr--, 0, 0); + return ptr == q; +} + +int +preinc_arg_idx (int *p, int i) +{ + int j = i + 1; + __builtin_prefetch (&p[++i], 0, 0); + return i == j; +} + + +int +preinc_glob_idx (void) +{ + int j = arrindex + 1; + __builtin_prefetch (&ptr[++arrindex], 0, 0); + return arrindex == j; +} + +int +postinc_arg_idx (int *p, int i) +{ + int j = i + 1; + __builtin_prefetch (&p[i++], 0, 0); + return i == j; +} + +int +postinc_glob_idx (void) +{ + int j = arrindex + 1; + __builtin_prefetch (&ptr[arrindex++], 0, 0); + return arrindex == j; +} + +int +predec_arg_idx (int *p, int i) +{ + int j = i - 1; + __builtin_prefetch (&p[--i], 0, 0); + return i == j; +} + +int +predec_glob_idx (void) +{ + int j = arrindex - 1; + __builtin_prefetch (&ptr[--arrindex], 0, 0); + return arrindex == j; +} + +int +postdec_arg_idx (int *p, int i) +{ + int j = i - 1; + __builtin_prefetch (&p[i--], 0, 0); + return i == j; +} + +int +postdec_glob_idx (void) +{ + int j = arrindex - 1; + __builtin_prefetch (&ptr[arrindex--], 0, 0); + return arrindex == j; +} + +/* Check that function calls within the first prefetch argument are + evaluated. */ + +int getptrcnt = 0; + +int * +getptr (int *p) +{ + getptrcnt++; + return p + 1; +} + +int +funccall_arg_ptr (int *p) +{ + __builtin_prefetch (getptr (p), 0, 0); + return getptrcnt == 1; +} + +int getintcnt = 0; + +int +getint (int i) +{ + getintcnt++; + return i + 1; +} + +int +funccall_arg_idx (int *p, int i) +{ + __builtin_prefetch (&p[getint (i)], 0, 0); + return getintcnt == 1; +} + +int +main () +{ + if (!assign_arg_ptr (ptr)) + abort (); + if (!assign_glob_ptr ()) + abort (); + if (!assign_arg_idx (ptr, 4)) + abort (); + if (!assign_glob_idx ()) + abort (); + if (!preinc_arg_ptr (ptr)) + abort (); + if (!preinc_glob_ptr ()) + abort (); + if (!postinc_arg_ptr (ptr)) + abort (); + if (!postinc_glob_ptr ()) + abort (); + if (!predec_arg_ptr (ptr)) + abort (); + if (!predec_glob_ptr ()) + abort (); + if (!postdec_arg_ptr (ptr)) + abort (); + if (!postdec_glob_ptr ()) + abort (); + if (!preinc_arg_idx (ptr, 3)) + abort (); + if (!preinc_glob_idx ()) + abort (); + if (!postinc_arg_idx (ptr, 3)) + abort (); + if (!postinc_glob_idx ()) + abort (); + if (!predec_arg_idx (ptr, 3)) + abort (); + if (!predec_glob_idx ()) + abort (); + if (!postdec_arg_idx (ptr, 3)) + abort (); + if (!postdec_glob_idx ()) + abort (); + if (!funccall_arg_ptr (ptr)) + abort (); + if (!funccall_arg_idx (ptr, 3)) + abort (); + exit (0); +} diff --git a/test/not_applicable/builtin-prefetch-5.c b/test/not_applicable/builtin-prefetch-5.c new file mode 100644 index 0000000..f42a2c0 --- /dev/null +++ b/test/not_applicable/builtin-prefetch-5.c @@ -0,0 +1,60 @@ +/* Test that __builtin_prefetch does no harm. + + Use addresses that are unlikely to be word-aligned. Some targets + have alignment requirements for prefetch addresses, so make sure the + compiler takes care of that. This fails if it aborts, anything else + is OK. */ + +struct S { + short a; + short b; + char c[8]; +} s; + +char arr[100]; +char *ptr = arr; +int idx = 3; + +void +arg_ptr (char *p) +{ + __builtin_prefetch (p, 0, 0); +} + +void +arg_idx (char *p, int i) +{ + __builtin_prefetch (&p[i], 0, 0); +} + +void +glob_ptr (void) +{ + __builtin_prefetch (ptr, 0, 0); +} + +void +glob_idx (void) +{ + __builtin_prefetch (&ptr[idx], 0, 0); +} + +int +main () +{ + __builtin_prefetch (&s.b, 0, 0); + __builtin_prefetch (&s.c[1], 0, 0); + + arg_ptr (&s.c[1]); + arg_ptr (ptr+3); + arg_idx (ptr, 3); + arg_idx (ptr+1, 2); + idx = 3; + glob_ptr (); + glob_idx (); + ptr++; + idx = 2; + glob_ptr (); + glob_idx (); + exit (0); +} diff --git a/test/not_applicable/builtin-prefetch-6.c b/test/not_applicable/builtin-prefetch-6.c new file mode 100644 index 0000000..f643c5c --- /dev/null +++ b/test/not_applicable/builtin-prefetch-6.c @@ -0,0 +1,46 @@ +/* Test that __builtin_prefetch does no harm. + + Data prefetch should not fault if used with an invalid address. */ + +#include + +#define ARRSIZE 65 +int *bad_addr[ARRSIZE]; +int arr_used; + +/* Fill bad_addr with a range of values in the hopes that on any target + some will be invalid addresses. */ +void +init_addrs (void) +{ + int i; + int bits_per_ptr = sizeof (void *) * 8; + for (i = 0; i < bits_per_ptr; i++) + bad_addr[i] = (void *)(1UL << i); + arr_used = bits_per_ptr + 1; /* The last element used is zero. */ +} + +void +prefetch_for_read (void) +{ + int i; + for (i = 0; i < ARRSIZE; i++) + __builtin_prefetch (bad_addr[i], 0, 0); +} + +void +prefetch_for_write (void) +{ + int i; + for (i = 0; i < ARRSIZE; i++) + __builtin_prefetch (bad_addr[i], 1, 0); +} + +int +main () +{ + init_addrs (); + prefetch_for_read (); + prefetch_for_write (); + exit (0); +} diff --git a/test/not_applicable/cbrt.c b/test/not_applicable/cbrt.c new file mode 100644 index 0000000..8659cc7 --- /dev/null +++ b/test/not_applicable/cbrt.c @@ -0,0 +1,92 @@ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== +*/ + +#ifndef __vax__ +static const unsigned long + B1 = 715094163, /* B1 = (682-0.03306235651)*2**20 */ + B2 = 696219795; /* B2 = (664-0.03306235651)*2**20 */ + +static const double + C = 5.42857142857142815906e-01, /* 19/35 = 0x3FE15F15, 0xF15F15F1 */ + D = -7.05306122448979611050e-01, /* -864/1225 = 0xBFE691DE, 0x2532C834 */ + E = 1.41428571428571436819e+00, /* 99/70 = 0x3FF6A0EA, 0x0EA0EA0F */ + F = 1.60714285714285720630e+00, /* 45/28 = 0x3FF9B6DB, 0x6DB6DB6E */ + G = 3.57142857142857150787e-01; /* 5/14 = 0x3FD6DB6D, 0xB6DB6DB7 */ + +double +cbrtl (double x) +{ + long hx; + double r,s,w; + double lt; + unsigned sign; + typedef unsigned unsigned32 __attribute__((mode(SI))); + union { + double t; + unsigned32 pt[2]; + } ut, ux; + int n0; + + ut.t = 1.0; + n0 = (ut.pt[0] == 0); + + ut.t = 0.0; + ux.t = x; + + hx = ux.pt[n0]; /* high word of x */ + sign=hx&0x80000000; /* sign= sign(x) */ + hx ^=sign; + if(hx>=0x7ff00000) return(x+x); /* cbrt(NaN,INF) is itself */ + if((hx| ux.pt[1-n0])==0) + return(ux.t); /* cbrt(0) is itself */ + + ux.pt[n0] = hx; + /* rough cbrt to 5 bits */ + if(hx<0x00100000) /* subnormal number */ + {ut.pt[n0]=0x43500000; /* set t= 2**54 */ + ut.t*=x; ut.pt[n0]=ut.pt[n0]/3+B2; + } + else + ut.pt[n0]=hx/3+B1; + + /* new cbrt to 23 bits, may be implemented in single precision */ + r=ut.t*ut.t/ux.t; + s=C+r*ut.t; + ut.t*=G+F/(s+E+D/s); + + /* chopped to 20 bits and make it larger than cbrt(x) */ + ut.pt[1-n0]=0; ut.pt[n0]+=0x00000001; + + /* one step newton iteration to 53 bits with error less than 0.667 ulps */ + s=ut.t*ut.t; /* t*t is exact */ + r=ux.t/s; + w=ut.t+ut.t; + r=(r-ut.t)/(w+r); /* r-s is exact */ + ut.t=ut.t+ut.t*r; + + /* restore the sign bit */ + ut.pt[n0] |= sign; + + lt = ut.t; + lt -= (lt - (x/(lt*lt))) * 0.333333333333333333333; + return lt; +} + +main () +{ + if ((int) (cbrtl (27.0) + 0.5) != 3) + abort (); + + exit (0); +} +#else +main () { exit (0); } +#endif diff --git a/test/not_applicable/dg/20001012-2.c b/test/not_applicable/dg/20001012-2.c new file mode 100644 index 0000000..32dc27c --- /dev/null +++ b/test/not_applicable/dg/20001012-2.c @@ -0,0 +1,36 @@ +/* { dg-do run { target fpic } } */ +/* { dg-options "-O2 -fpic" } */ + +extern void abort (void); +extern void exit (int); + +void foo (char *x, const char *y, ...) +{ +} + +double bar (const char *x, long y) +{ + return 0.0; +} + +typedef __SIZE_TYPE__ size_t; +extern size_t strlen (const char *); + +double baz (const char *x) +{ + if (x[0] != '\0') + { + char y[6 + strlen (x)]; + foo (y, "FOO", x); + return bar (y, 0); + } + + return (__extension__ ((union { unsigned __l __attribute__((__mode__(__SI__))); float __d; }) { __l: 0x3f800000UL }).__d); +} + +main () +{ + if (baz("") != 1.0) + abort (); + exit (0); +} diff --git a/test/not_applicable/dg/20011214-1.c b/test/not_applicable/dg/20011214-1.c new file mode 100644 index 0000000..dd05798 --- /dev/null +++ b/test/not_applicable/dg/20011214-1.c @@ -0,0 +1,17 @@ +/* { dg-do run } */ + +extern void abort (void); +extern void exit (int); + +#define small __attribute__((mode(QI))) int +int main() +{ + int x, y = 0x400; + + x = (small) y; /* { dg-bogus "ignored" } */ + if (sizeof (small) != sizeof (char)) /* { dg-bogus "ignored" } */ + abort (); + if (sizeof (x) != sizeof (char) && x == y) + abort (); + return 0; +} diff --git a/test/not_applicable/dg/20020312-2.c b/test/not_applicable/dg/20020312-2.c new file mode 100644 index 0000000..10b8a7c --- /dev/null +++ b/test/not_applicable/dg/20020312-2.c @@ -0,0 +1,139 @@ +/* PR 5878. + + We ICEd in verify_local_live_at_start because we incorrectly forced + the PIC register live between BAR and BAZ. We did this because the + definition of PIC_OFFSET_TABLE_REGNUM was incorrectly not INVALID_REGNUM + when !flag_pic for most targets. */ + +/* { dg-do run } */ +/* { dg-options "-O -fno-pic" } */ + +extern void abort (void); + +#if defined(__alpha__) +/* PIC register is $29, but is used even without -fpic. */ +#elif defined(__arc__) +# define PIC_REG "26" +#elif defined(__arm__) +# define PIC_REG "9" +#elif defined(AVR) +/* No pic register. */ +#elif defined(__cris__) +# define PIC_REG "0" +#elif defined(__fr30__) +/* No pic register. */ +#elif defined(__H8300__) || defined(__H8300H__) || defined(__H8300S__) +/* No pic register. */ +#elif defined(_IBMR2) +/* No pic register. */ +#elif defined(__i386__) +# define PIC_REG "ebx" +#elif defined(__ia64__) +/* PIC register is r1, but is used even without -fpic. */ +#elif defined(__M32R__) +/* No pic register. */ +#elif defined(__m68k__) +# define PIC_REG "a5" +#elif defined(__mc68hc1x__) +/* No pic register. */ +#elif defined(__mcore__) +/* No pic register. */ +#elif defined(__mips__) +/* PIC register is $28, but is used even without -fpic. */ +#elif defined(__MMIX__) +/* No pic register. */ +#elif defined(__mn10300__) +/* No pic register. */ +#elif defined(__hppa__) +/* PIC register is %r27 or %r19, but is used even without -fpic. */ +#elif defined(__pdp11__) +/* No pic register. */ +#elif defined(__powerpc__) || defined(__PPC__) || defined(__POWERPC__) +# ifdef __MACH__ +# define PIC_REG "31" +# else +# define PIC_REG "30" +# endif +#elif defined(__s390__) +# define PIC_REG "12" +#elif defined(__sparc__) +# define PIC_REG "l7" +#elif defined(__v850) +/* No pic register. */ +#elif defined(__vax__) +/* No pic register. */ +#elif defined(__xstormy16__) +/* No pic register. */ +#elif defined(__XTENSA__) +/* No pic register. */ +#elif defined(__sh__) +# define PIC_REG "r12" +#elif defined(__x86_64__) +/* No pic register. */ +#elif defined(__m32c__) +/* No pic register. */ +#elif defined(__SPU__) +# define PIC_REG "126" +#elif defined (__frv__) +# ifdef __FRV_FDPIC__ +# define PIC_REG "gr15" +# else +# define PIC_REG "gr17" +#endif +#else +//# error "Modify the test for your target." +#define PIC_REG "r0" +#endif + +#if defined PIC_REG && !defined __PIC__ && !defined __pic__ +register void *reg __asm__(PIC_REG); +#else +/* We really need a global register variable set to the PIC register + to expose the bug. Oh well, let the test case not fail. */ +static void *reg; +#endif + +void * __attribute__((noinline)) +dummy (void *x) +{ + return x; +} + +void +f (void) +{ + goto *dummy (&&bar); + for (;;) + { + foo: + reg = (void *) 1; + if (!reg) + goto baz; + reg = &&foo; + } + + bar: + baz: + reg = 0; +} + +int +main() +{ + void *old_reg = reg; + reg = (void *) 1; + + f (); + + /* Additionally test that the prologue/epilogue properly does *not* + save and restore global registers. Not possible when the PIC + register is in a register window, of course. On Darwin, you can't + call library routines from non-PIC code. */ +#if !defined (__sparc__) && !defined(__MACH__) + if (reg) + abort (); +#endif + + reg = old_reg; + return 0; +} diff --git a/test/not_applicable/dg/20030826-2.c b/test/not_applicable/dg/20030826-2.c new file mode 100644 index 0000000..32db091 --- /dev/null +++ b/test/not_applicable/dg/20030826-2.c @@ -0,0 +1,64 @@ +/* { dg-do run } */ +/* { dg-options "-O2 -fomit-frame-pointer" } */ +/* { dg-options "-O2 -fomit-frame-pointer -march=i386" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */ + +extern void abort (void); +extern void exit (int); + +struct S +{ + int *a; + unsigned char *b, c; +}; + +int u, v, w; + +void +foo (unsigned short x) +{ + u += x; +} + +int +bar (struct S **x, int *y) +{ + w += *y; + *y = w + 25; + return 0; +} + +int +baz (struct S **x) +{ + struct S *y = *x; + unsigned char *a = y->b; + + foo (*a); + + if (__builtin_expect (y->c != 0 || y->a == &v, 0)) + return 1; + + if (__builtin_expect (*a == 1, 0)) + { + int a, b = bar (x, &a); + + if (a) + return b; + } + + return 0; +} + +int +main (void) +{ + struct S a, *b = &a; + unsigned char c; + + __builtin_memset (b, 0, sizeof (a)); + a.a = &v; + a.b = &c; + if (baz (&b) != 1) + abort (); + exit (0); +} diff --git a/test/not_applicable/dg/20031102-1.c b/test/not_applicable/dg/20031102-1.c new file mode 100644 index 0000000..5a02a70 --- /dev/null +++ b/test/not_applicable/dg/20031102-1.c @@ -0,0 +1,37 @@ +/* PR optimization/12799 */ +/* Origin: Pratap Subrahmanyam */ + +/* { dg-do run } */ +/* { dg-options "-O2" } */ +/* { dg-options "-O2 -march=i686" { target { { i686-*-* x86_64-*-* } && ilp32 } } } */ + +/* Verify that reload_cse_move2add doesn't add unexpected CLOBBERs. */ + +extern void abort(void); + +int loo = 1; + +__inline__ char InlineFunc(void) +{ + return __builtin_expect(!!(loo == 1), 1); +} + +int FooBar(void) +{ + int i; + int var1 = InlineFunc() ? 2046 : 1023; + int var2 = InlineFunc() ? 512 : 1024; + + for (i = 0; i < var1; i++) + ; + + if (InlineFunc() && var2 != 512) + abort(); + + return 0; +} + +int main(void) +{ + return FooBar(); +} diff --git a/test/not_applicable/dg/20040625-1.c b/test/not_applicable/dg/20040625-1.c new file mode 100644 index 0000000..0a576a5 --- /dev/null +++ b/test/not_applicable/dg/20040625-1.c @@ -0,0 +1,37 @@ +/* { dg-do run } */ +/* { dg-options "-O2" } */ +/* { dg-options "-mminimal-toc" { target { { powerpc*-*-* && lp64 } || { powerpc-ibm-aix* } } } } */ + +extern void abort (void); +extern void exit (int); + +double __attribute__((noinline)) +foo (void) +{ + return 16441577472.0; +} + +double __attribute__((noinline)) +bar (double x) +{ + return x; +} + +int __attribute__((noinline)) +test (void) +{ + double x = foo (); + x = bar (x); + x /= 1024L * 1024L * 1024L; + x *= 70; + x = x < 70 ? x : 70; + x += 30; + return x; +} + +int main (void) +{ + if (test () != 100) + abort (); + exit (0); +} diff --git a/test/not_applicable/dg/20050826-1.c b/test/not_applicable/dg/20050826-1.c new file mode 100644 index 0000000..9101fb0 --- /dev/null +++ b/test/not_applicable/dg/20050826-1.c @@ -0,0 +1,46 @@ +/* Test whether strncmp has not been "optimized" into memcmp + nor any code with memcmp semantics. */ +/* { dg-do run { target i?86-*-linux* x86_64-*-linux* ia64-*-linux* alpha*-*-linux* powerpc*-*-linux* s390*-*-linux* sparc*-*-linux* *-*-darwin* } } */ +/* { dg-options "-O2" } */ +#include +#include +#include +/* Darwin spells this differently */ +#ifndef MAP_ANONYMOUS +#define MAP_ANONYMOUS MAP_ANON +#endif +#include + + struct Flags { + int filler[18]; + unsigned int a:14; + unsigned int b:14; + unsigned int c:1; + unsigned int d:1; + unsigned int e:1; + unsigned int f:1; + }; +static void __attribute__((noinline)) set (struct Flags *); +static void set (struct Flags *fp) +{ + fp->b = 5; + fp->d = 1; +} + +static int __attribute__((noinline)) bar (int); +static int bar(int x) { return !(x==1); } +int main (void) +{ + char *p = mmap (NULL, 131072, PROT_READ | PROT_WRITE, + MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); + struct Flags *fp; + if (p == MAP_FAILED) + return 0; + if (munmap (p + 65536, 65536) < 0) + return 0; + fp = (struct Flags*)(p + 65536 - sizeof(struct Flags)); + set(fp); + if (fp->b > 0) + return (bar(fp->d)); + return 1; +} diff --git a/test/not_applicable/dg/20061124-1.c b/test/not_applicable/dg/20061124-1.c new file mode 100644 index 0000000..dab57ef --- /dev/null +++ b/test/not_applicable/dg/20061124-1.c @@ -0,0 +1,21 @@ +/* { dg-do run } */ +/* { dg-require-effective-target sync_char_short } */ + +/* This testcase failed on s390 because no compare instruction for + the check of FLAG was emitted. */ + +unsigned short int count = 0; +int flag = 1; + +extern void abort (void); +extern void exit (int); + +int +main () +{ + __sync_add_and_fetch (&count, -1); + + if (!flag) + abort (); + exit (0); +} diff --git a/test/not_applicable/dg/asm-b.c b/test/not_applicable/dg/asm-b.c new file mode 100644 index 0000000..ec96839 --- /dev/null +++ b/test/not_applicable/dg/asm-b.c @@ -0,0 +1,39 @@ +/* { dg-do run { target powerpc*-*-* i?86-*-* x86_64-*-* } } */ +/* { dg-options "-O1" } */ +/* Test to make sure that inline-asm causes the tree optimizers to get the + V_MAY_DEFs and clobber memory. */ +/* Test from Jakub Jelinek, modified by Andrew Pinski to work on all powerpc targets. */ +extern void abort (void); + +unsigned short v = 0x0300; + +void +foo (unsigned short *p) +{ + *p = v; +} + +int +bar (void) +{ + unsigned short x; + volatile unsigned short *z; + foo (&x); + const unsigned int y = x; + z = &x; +#if defined (__powerpc__) || defined (__PPC__) || defined (__ppc__) || defined (_POWER) || defined (__ppc64__) + __asm __volatile ("sthbrx %1,0,%2" : "=m" (*z) : "r" (y), "r" (z)); +#elif defined __i386__ || defined __x86_64__ + __asm __volatile ("movb %b1,1(%2); movb %h1,(%2)" : "=m" (*z) : "r" (y), "r" +(z)); +#endif + return (x & 1) == 0; +} + +int +main (void) +{ + if (bar ()) + abort (); + return 0; +} diff --git a/test/not_applicable/dg/attr-ms_struct-1.c b/test/not_applicable/dg/attr-ms_struct-1.c new file mode 100644 index 0000000..4cbff01 --- /dev/null +++ b/test/not_applicable/dg/attr-ms_struct-1.c @@ -0,0 +1,165 @@ +/* Test for MS structure sizes. */ +/* { dg-do run { target *-*-interix* *-*-mingw* *-*-cygwin* i?86-*-darwin* } } */ +/* { dg-require-effective-target ilp32 } */ +/* { dg-options "-std=gnu99" } */ + +extern void abort (); + +#define ATTR __attribute__((__ms_struct__)) + +#define size_struct_0 1 +#define size_struct_1 4 +#define size_struct_2 24 +#define size_struct_3 8 +#define size_struct_4 32 +#define size_struct_5 12 +#define size_struct_6 40 +#define size_struct_7 8 +#define size_struct_8 20 +#define size_struct_9 32 + +struct _struct_0 +{ + char member_0; +} ATTR; +typedef struct _struct_0 struct_0; + +struct _struct_1 +{ + char member_0; + short member_1:13; +} ATTR; +typedef struct _struct_1 struct_1; + +struct _struct_2 +{ + double member_0; + unsigned char member_1:8; + long member_2:32; + unsigned char member_3:5; + short member_4:14; + short member_5:13; + unsigned char:0; +} ATTR; +typedef struct _struct_2 struct_2; + +struct _struct_3 +{ + unsigned long member_0:26; + unsigned char member_1:2; + +} ATTR; +typedef struct _struct_3 struct_3; + +struct _struct_4 +{ + unsigned char member_0:7; + double member_1; + double member_2; + short member_3:5; + char member_4:2; + +} ATTR; +typedef struct _struct_4 struct_4; + +struct _struct_5 +{ + unsigned short member_0:12; + long member_1:1; + unsigned short member_2:6; + +} ATTR; +typedef struct _struct_5 struct_5; + +struct _struct_6 +{ + unsigned char member_0:7; + unsigned long member_1:25; + char member_2:1; + double member_3; + short member_4:9; + double member_5; + +} ATTR; +typedef struct _struct_6 struct_6; + +struct _struct_7 +{ + double member_0; + +} ATTR; +typedef struct _struct_7 struct_7; + +struct _struct_8 +{ + unsigned char member_0:7; + long member_1:11; + long member_2:5; + long:0; + char member_4:8; + unsigned short member_5:4; + unsigned char member_6:3; + long member_7:23; + +} ATTR; +typedef struct _struct_8 struct_8; + +struct _struct_9 +{ + double member_0; + unsigned long member_1:6; + long member_2:17; + double member_3; + unsigned long member_4:22; + +} ATTR; +typedef struct _struct_9 struct_9; + +struct_0 test_struct_0 = { 123 }; +struct_1 test_struct_1 = { 82, 1081 }; +struct_2 test_struct_2 = { 20.0, 31, 407760, 1, 14916, 6712 }; +struct_3 test_struct_3 = { 64616999, 1 }; +struct_4 test_struct_4 = { 61, 20.0, 20.0, 12, 0 }; +struct_5 test_struct_5 = { 909, 1, 57 }; +struct_6 test_struct_6 = { 12, 21355796, 0, 20.0, 467, 20.0 }; +struct_7 test_struct_7 = { 20.0 }; +struct_8 test_struct_8 = { 126, 1821, 22, 125, 6, 0, 2432638 }; +struct_9 test_struct_9 = { 20.0, 3, 23957, 20.0, 1001631 }; + + +int +main (void) +{ + + if (size_struct_0 != sizeof (struct_0)) + abort (); + + if (size_struct_1 != sizeof (struct_1)) + abort (); + + if (size_struct_2 != sizeof (struct_2)) + abort (); + + if (size_struct_3 != sizeof (struct_3)) + abort (); + + if (size_struct_4 != sizeof (struct_4)) + abort (); + + if (size_struct_5 != sizeof (struct_5)) + abort (); + + if (size_struct_6 != sizeof (struct_6)) + abort (); + + if (size_struct_7 != sizeof (struct_7)) + abort (); + + if (size_struct_8 != sizeof (struct_8)) + abort (); + + if (size_struct_9 != sizeof (struct_9)) + abort (); + + return 0; +} diff --git a/test/not_applicable/dg/attr-ms_struct-2.c b/test/not_applicable/dg/attr-ms_struct-2.c new file mode 100644 index 0000000..5880452 --- /dev/null +++ b/test/not_applicable/dg/attr-ms_struct-2.c @@ -0,0 +1,36 @@ +/* Test for MS structure sizes. */ +/* { dg-do run { target *-*-interix* *-*-mingw* *-*-cygwin* i?86-*-darwin* } } */ +/* { dg-require-effective-target ilp32 } */ +/* { dg-options "-std=gnu99" } */ + +extern void abort (); + +#define ATTR __attribute__((__ms_struct__)) + +struct _struct_0 +{ + long member_0 : 25 ; + short member_1 : 6 ; + char member_2 : 2 ; + unsigned short member_3 : 1 ; + unsigned char member_4 : 7 ; + short member_5 : 16 ; + long : 0 ; + char member_7 ; + +} ATTR; +typedef struct _struct_0 struct_0; + +#define size_struct_0 20 + +struct_0 test_struct_0 = { 18557917, 17, 3, 0, 80, 6487, 93 }; + +int +main (void) +{ + + if (size_struct_0 != sizeof (struct_0)) + abort (); + + return 0; +} diff --git a/test/not_applicable/dg/attr-ms_struct-packed1.c b/test/not_applicable/dg/attr-ms_struct-packed1.c new file mode 100644 index 0000000..d885c6f --- /dev/null +++ b/test/not_applicable/dg/attr-ms_struct-packed1.c @@ -0,0 +1,25 @@ +/* Test for MS structure with packed attribute. */ +/* { dg-do run { target *-*-interix* *-*-mingw* *-*-cygwin* i?86-*-darwin* } } +/* { dg-options "-std=gnu99" } */ + +extern void abort (); + +union u +{ + int a; +} __attribute__((__ms_struct__, __packed__)); + +struct s +{ + char c; + union u u; +}; + +int +main (void) +{ + if (sizeof (struct s) != (sizeof (char) + sizeof (union u))) + abort (); + + return 0; +} diff --git a/test/not_applicable/dg/attr-weakref-1-darwin.c b/test/not_applicable/dg/attr-weakref-1-darwin.c new file mode 100644 index 0000000..c6835ed --- /dev/null +++ b/test/not_applicable/dg/attr-weakref-1-darwin.c @@ -0,0 +1,223 @@ +// { dg-do run { target { *-*-darwin* } } } +// { dg-require-weak "" } +// { dg-options "-O2" } +// { dg-options "-O2 -mmacosx-version-min=10.2" { target { powerpc-*-darwin* } } } +// { dg-additional-sources "attr-weakref-1a.c attr-weakref-1b.c" } + +// Copyright 2005 Free Software Foundation, Inc. +// Contributed by Alexandre Oliva + +// Torture test for weakrefs. The first letter of an identifier +// indicates whether/how it is defined; the second letter indicates +// whether it is part of a variable or function test; the number that +// follows is a test counter, and a letter that may follow enables +// multiple identifiers within the same test (e.g., multiple weakrefs +// or pointers to the same identifier). + +// Identifiers starting with W are weakrefs; those with p are +// pointers; those with g are global definitions; those with l are +// local definitions; those with w are expected to be weak undefined +// in the symbol table; those with u are expected to be marked as +// non-weak undefined in the symbol table. + +#include + +#define USED __attribute__((used)) + +typedef int vtype; + +extern vtype wv1; +static vtype Wv1a __attribute__((weakref ("wv1"))); +static vtype *pv1a USED = &Wv1a; + +vtype gv2; +static vtype Wv2a __attribute__((weakref ("gv2"))); +static vtype *pv2a USED = &Wv2a; + +static vtype lv3; +static vtype Wv3a __attribute__((weakref ("lv3"))); +static vtype *pv3a USED = &Wv3a; + +extern vtype uv4; +static vtype Wv4a __attribute__((weakref ("uv4"))); +static vtype *pv4a USED = &Wv4a; +static vtype *pv4 USED = &uv4; + +static vtype Wv5a __attribute__((weakref ("uv5"))); +static vtype *pv5a USED = &Wv5a; +extern vtype uv5; +static vtype *pv5 USED = &uv5; + +static vtype Wv6a __attribute__((weakref ("wv6"))); +static vtype *pv6a USED = &Wv6a; +extern vtype wv6; + +static vtype Wv7a __attribute__((weakref ("uv7"))); +static vtype* USED fv7 (void) { + return &Wv7a; +} +extern vtype uv7; +static vtype* USED fv7a (void) { + return &uv7; +} + +extern vtype uv8; +static vtype* USED fv8a (void) { + return &uv8; +} +static vtype Wv8a __attribute__((weakref ("uv8"))); +static vtype* USED fv8 (void) { + return &Wv8a; +} + +extern vtype wv9 __attribute__((weak)); +static vtype Wv9a __attribute__((weakref ("wv9"))); +static vtype *pv9a USED = &Wv9a; + +static vtype Wv10a __attribute__((weakref ("Wv10b"))); +static vtype Wv10b __attribute__((weakref ("Wv10c"))); +static vtype Wv10c __attribute__((weakref ("Wv10d"))); +static vtype Wv10d __attribute__((weakref ("wv10"))); +extern vtype wv10; + +extern vtype wv11; +static vtype Wv11d __attribute__((weakref ("wv11"))); +static vtype Wv11c __attribute__((weakref ("Wv11d"))); +static vtype Wv11b __attribute__((weakref ("Wv11c"))); +static vtype Wv11a __attribute__((weakref ("Wv11b"))); + +static vtype Wv12 __attribute__((weakref ("wv12"))); +extern vtype wv12 __attribute__((weak)); + +static vtype Wv13 __attribute__((weakref ("wv13"))); +extern vtype wv13 __attribute__((weak)); + +static vtype Wv14a __attribute__((weakref ("wv14"))); +static vtype Wv14b __attribute__((weakref ("wv14"))); +extern vtype wv14 __attribute__((weak)); + +typedef void ftype(void); + +extern ftype wf1; +static ftype Wf1a __attribute__((weakref ("wf1"))); +static ftype *pf1a USED = &Wf1a; +static ftype Wf1c __attribute__((weakref)); +extern ftype Wf1c __attribute__((alias ("wf1"))); +static ftype *pf1c USED = &Wf1c; + +void gf2(void) {} +static ftype Wf2a __attribute__((weakref ("gf2"))); +static ftype *pf2a USED = &Wf2a; + +static void lf3(void) {} +static ftype Wf3a __attribute__((weakref ("lf3"))); +static ftype *pf3a USED = &Wf3a; + +extern ftype uf4; +static ftype Wf4a __attribute__((weakref ("uf4"))); +static ftype *pf4a USED = &Wf4a; +static ftype *pf4 USED = &uf4; + +static ftype Wf5a __attribute__((weakref ("uf5"))); +static ftype *pf5a USED = &Wf5a; +extern ftype uf5; +static ftype *pf5 USED = &uf5; + +static ftype Wf6a __attribute__((weakref ("wf6"))); +static ftype *pf6a USED = &Wf6a; +extern ftype wf6; + +static ftype Wf7a __attribute__((weakref ("uf7"))); +static ftype* USED ff7 (void) { + return &Wf7a; +} +extern ftype uf7; +static ftype* USED ff7a (void) { + return &uf7; +} + +extern ftype uf8; +static ftype* USED ff8a (void) { + return &uf8; +} +static ftype Wf8a __attribute__((weakref ("uf8"))); +static ftype* USED ff8 (void) { + return &Wf8a; +} + +extern ftype wf9 __attribute__((weak)); +static ftype Wf9a __attribute__((weakref ("wf9"))); +static ftype *pf9a USED = &Wf9a; + +static ftype Wf10a __attribute__((weakref ("Wf10b"))); +static ftype Wf10b __attribute__((weakref ("Wf10c"))); +static ftype Wf10c __attribute__((weakref ("Wf10d"))); +static ftype Wf10d __attribute__((weakref ("wf10"))); +extern ftype wf10; + +extern ftype wf11; +static ftype Wf11d __attribute__((weakref ("wf11"))); +static ftype Wf11c __attribute__((weakref ("Wf11d"))); +static ftype Wf11b __attribute__((weakref ("Wf11c"))); +static ftype Wf11a __attribute__((weakref ("Wf11b"))); + +static ftype Wf12 __attribute__((weakref ("wf12"))); +extern ftype wf12 __attribute__((weak)); + +static ftype Wf13 __attribute__((weakref ("wf13"))); +extern ftype wf13 __attribute__((weak)); + +static ftype Wf14a __attribute__((weakref ("wf14"))); +static ftype Wf14b __attribute__((weakref ("wf14"))); +extern ftype wf14 __attribute__((weak)); + +#ifndef __APPLE__ +#define chk(p) do { if (!p) abort (); } while (0) +#else +#define chk(p) /* */ +#endif + +int main () { + chk (!pv1a); + chk (pv2a); + chk (pv3a); + chk (pv4a); + chk (pv4); + chk (pv5a); + chk (pv5); + chk (!pv6a); + chk (fv7 ()); + chk (fv7a ()); + chk (fv8 ()); + chk (fv8a ()); + chk (!pv9a); + chk (!&Wv10a); + chk (!&Wv11a); + chk (!&Wv12); + chk (!&wv12); + chk (!&wv13); + chk (!&Wv14a); + + chk (!pf1a); + chk (!pf1c); + chk (pf2a); + chk (pf3a); + chk (pf4a); + chk (pf4); + chk (pf5a); + chk (pf5); + chk (!pf6a); + chk (ff7 ()); + chk (ff7a ()); + chk (ff8 ()); + chk (ff8a ()); + chk (!pf9a); + chk (!&Wf10a); + chk (!&Wf11a); + chk (!&Wf12); + chk (!&wf12); + chk (!&wf13); + chk (!&Wf14a); + + exit (0); +} diff --git a/test/not_applicable/dg/bf-ms-attrib.c b/test/not_applicable/dg/bf-ms-attrib.c new file mode 100644 index 0000000..e3832d4 --- /dev/null +++ b/test/not_applicable/dg/bf-ms-attrib.c @@ -0,0 +1,39 @@ +/* bf-ms-attrib.c */ +/* Adapted from Donn Terry testcase + posted to GCC-patches + http://gcc.gnu.org/ml/gcc-patches/2000-08/msg00577.html */ + +/* { dg-do run { target *-*-interix* *-*-mingw* *-*-cygwin* } } */ + +/* We don't want the default "pedantic-errors" in this case, since we're + testing nonstandard stuff to begin with. */ +/* { dg-options "-ansi" } */ + +extern void abort(void); + +struct one_gcc { + int d; + unsigned char a; + unsigned short b:7; + char c; +} __attribute__((__gcc_struct__)) ; + + +struct one_ms { + int d; + unsigned char a; + unsigned short b:7; + char c; +} __attribute__((__ms_struct__)); + + +main() + { + /* As long as the sizes are as expected, we know attributes are working. + bf-ms-layout.c makes sure the right thing happens when the attribute + is on. */ + if (sizeof(struct one_ms) != 12) + abort(); + if (sizeof(struct one_gcc) != 8) + abort(); + } diff --git a/test/not_applicable/dg/bf-ms-layout-2.c b/test/not_applicable/dg/bf-ms-layout-2.c new file mode 100644 index 0000000..0bd472b --- /dev/null +++ b/test/not_applicable/dg/bf-ms-layout-2.c @@ -0,0 +1,236 @@ +/* bf-ms-layout.c */ + +/* Test for MS bitfield layout */ +/* Adapted from Donn Terry testcase + posted to GCC-patches + http://gcc.gnu.org/ml/gcc-patches/2000-08/msg00577.html */ + +/* { dg-do run { target *-*-interix* *-*-mingw* *-*-cygwin* i?86-*-darwin* } } */ +/* { dg-options "-D_TEST_MS_LAYOUT" } */ +/* This test uses the attribute instead of the command line option. */ + +#include +#include + +extern void abort(); + +#pragma pack(8) + +#ifdef __GNUC__ +#define ATTR __attribute__ ((ms_struct)) +#endif + +struct one { + int d; + unsigned char a; + unsigned short b:7; + char c; +} ATTR; + +struct two { + int d; + unsigned char a; + unsigned int b:7; + char c; +} ATTR; + +struct three { + short d; + unsigned short a:3; + unsigned short b:9; + unsigned char c:7; +} ATTR; + + +/* Bitfields of size 0 have some truly odd behaviors. */ + +struct four { + unsigned short a:3; + unsigned short b:9; + unsigned int :0; /* forces struct alignment to int */ + unsigned char c:7; +} ATTR; + +struct five { + char a; + int :0; /* ignored; prior field is not a bitfield. */ + char b; + char c; +} ATTR; + +struct six { + char a :8; + int :0; /* not ignored; prior field IS a bitfield, causes + struct alignment as well. */ + char b; + char c; +} ATTR; + +struct seven { + char a:8; + char :0; + int :0; /* Ignored; prior field is zero size bitfield. */ + char b; + char c; +} ATTR; + +struct eight { /* ms size 4 */ + short b:3; + char c; +} ATTR; + +#ifdef _MSC_VER +#define LONGLONG __int64 +#else +#define LONGLONG long long +#endif + +union nine { /* ms size 8 */ + LONGLONG a:3; + char c; +} ATTR; + +struct ten { /* ms size 16 */ + LONGLONG a:3; + LONGLONG b:3; + char c; +} ATTR; + + +#define val(s,f) (s.f) + +#define check_struct(_X) \ +{ \ + if (sizeof (struct _X) != exp_sizeof_##_X ) \ + abort(); \ + memcpy(&test_##_X, filler, sizeof(test_##_X));\ + if (val(test_##_X,c) != exp_##_X##_c) \ + abort(); \ +} + +#define check_union(_X) \ +{ \ + if (sizeof (union _X) != exp_sizeof_##_X ) \ + abort(); \ + memcpy(&test_##_X, filler, sizeof(test_##_X));\ + if (val(test_##_X,c) != exp_##_X##_c) \ + abort(); \ +} + +#define check_struct_size(_X) \ +{ \ + if (sizeof (struct _X) != exp_sizeof_##_X ) \ + abort(); \ +} + +#define check_struct_off(_X) \ +{ \ + memcpy(&test_##_X, filler, sizeof(test_##_X));\ + if (val(test_##_X,c) != exp_##_X##_c) \ + abort(); \ +} + +#define check_union_size(_X) \ +{ \ + if (sizeof (union _X) != exp_sizeof_##_X ) \ + abort(); \ +} + +#define check_union_off(_X) \ +{ \ + memcpy(&test_##_X, filler, sizeof(test_##_X));\ + if (val(test_##_X,c) != exp_##_X##_c) \ + abort(); \ +} + +int main(){ + + unsigned char filler[16]; + struct one test_one; + struct two test_two; + struct three test_three; + struct four test_four; + struct five test_five; + struct six test_six; + struct seven test_seven; + struct eight test_eight; + union nine test_nine; + struct ten test_ten; + +#if defined (_TEST_MS_LAYOUT) || defined (_MSC_VER) + size_t exp_sizeof_one = 12; + size_t exp_sizeof_two = 16; + size_t exp_sizeof_three =6; + size_t exp_sizeof_four = 8; + size_t exp_sizeof_five = 3; + size_t exp_sizeof_six = 8; + size_t exp_sizeof_seven = 3; + size_t exp_sizeof_eight = 4; + size_t exp_sizeof_nine = 8; + size_t exp_sizeof_ten = 16; + + unsigned char exp_one_c = 8; + unsigned char exp_two_c = 12; + unsigned char exp_three_c = 4; + unsigned char exp_four_c = 4; + char exp_five_c = 2; + char exp_six_c = 5; + char exp_seven_c = 2; + char exp_eight_c = 2; + char exp_nine_c = 0; + char exp_ten_c = 8; + +#else /* testing -mno-ms-bitfields */ + + size_t exp_sizeof_one = 8; + size_t exp_sizeof_two = 8; + size_t exp_sizeof_three = 6; + size_t exp_sizeof_four = 6; + size_t exp_sizeof_five = 6; + size_t exp_sizeof_six = 6; + size_t exp_sizeof_seven = 6; + size_t exp_sizeof_eight = 2; + size_t exp_sizeof_nine = 8; + size_t exp_sizeof_ten = 8; + + unsigned short exp_one_c = 6; + unsigned int exp_two_c = 6; + unsigned char exp_three_c = 64; + unsigned char exp_four_c = 4; + char exp_five_c = 5; + char exp_six_c = 5; + char exp_seven_c = 5; + char exp_eight_c = 1; + char exp_nine_c = 0; + char exp_ten_c = 1; + +#endif + + unsigned char i; + for ( i = 0; i < 16; i++ ) + filler[i] = i; + + check_struct_off (one); + check_struct_off (two); + check_struct_off (three); + check_struct_off (four); + check_struct_off (five); + check_struct_off (six); + check_struct_off (seven); + check_struct_off (eight); + check_union_off (nine); + check_struct_off (ten); + + check_struct_size (one); + check_struct_size (two); + check_struct_size (three); + check_struct_size (four); + check_struct_size (five); + check_struct_size (six); + check_struct_size (seven); + check_struct_size (eight); + check_union_size (nine); + check_struct_size (ten); + + return 0; +}; diff --git a/test/not_applicable/dg/bf-ms-layout.c b/test/not_applicable/dg/bf-ms-layout.c new file mode 100644 index 0000000..ad3ed9a --- /dev/null +++ b/test/not_applicable/dg/bf-ms-layout.c @@ -0,0 +1,232 @@ +/* bf-ms-layout.c */ + +/* Test for MS bitfield layout */ +/* Adapted from Donn Terry testcase + posted to GCC-patches + http://gcc.gnu.org/ml/gcc-patches/2000-08/msg00577.html */ + +/* { dg-do run { target *-*-interix* *-*-mingw* *-*-cygwin* i?86-*-darwin* } } */ +/* { dg-options "-mms-bitfields -D_TEST_MS_LAYOUT" } */ + +#include +#include + +extern void abort(); + +#pragma pack(8) + +struct one { + int d; + unsigned char a; + unsigned short b:7; + char c; +} ; + +struct two { + int d; + unsigned char a; + unsigned int b:7; + char c; +} ; + +struct three { + short d; + unsigned short a:3; + unsigned short b:9; + unsigned char c:7; +} ; + + +/* Bitfields of size 0 have some truly odd behaviors. */ + +struct four { + unsigned short a:3; + unsigned short b:9; + unsigned int :0; /* forces struct alignment to int */ + unsigned char c:7; +} ; + +struct five { + char a; + int :0; /* ignored; prior field is not a bitfield. */ + char b; + char c; +} ; + +struct six { + char a :8; + int :0; /* not ignored; prior field IS a bitfield, causes + struct alignment as well. */ + char b; + char c; +} ; + +struct seven { + char a:8; + char :0; + int :0; /* Ignored; prior field is zero size bitfield. */ + char b; + char c; +} ; + +struct eight { /* ms size 4 */ + short b:3; + char c; +} ; + +#ifdef _MSC_VER +#define LONGLONG __int64 +#else +#define LONGLONG long long +#endif + +#if 0 +union nine { /* ms size 8 */ + LONGLONG a:3; + char c; +} ; + +struct ten { /* ms size 16 */ + LONGLONG a:3; + LONGLONG b:3; + char c; +} ; +#endif + +#define val(s,f) (s.f) + +#define check_struct(_X) \ +{ \ + if (sizeof (struct _X) != exp_sizeof_##_X ) \ + abort(); \ + memcpy(&test_##_X, filler, sizeof(test_##_X));\ + if (val(test_##_X,c) != exp_##_X##_c) \ + abort(); \ +} + +#define check_union(_X) \ +{ \ + if (sizeof (union _X) != exp_sizeof_##_X ) \ + abort(); \ + memcpy(&test_##_X, filler, sizeof(test_##_X));\ + if (val(test_##_X,c) != exp_##_X##_c) \ + abort(); \ +} + +#define check_struct_size(_X) \ +{ \ + if (sizeof (struct _X) != exp_sizeof_##_X ) \ + abort(); \ +} + +#define check_struct_off(_X) \ +{ \ + memcpy(&test_##_X, filler, sizeof(test_##_X));\ + if (val(test_##_X,c) != exp_##_X##_c) \ + abort(); \ +} + +#define check_union_size(_X) \ +{ \ + if (sizeof (union _X) != exp_sizeof_##_X ) \ + abort(); \ +} + +#define check_union_off(_X) \ +{ \ + memcpy(&test_##_X, filler, sizeof(test_##_X));\ + if (val(test_##_X,c) != exp_##_X##_c) \ + abort(); \ +} + +int main(){ + + unsigned char filler[16]; + struct one test_one; + struct two test_two; + struct three test_three; + struct four test_four; + struct five test_five; + struct six test_six; + struct seven test_seven; + struct eight test_eight; +// union nine test_nine; +// struct ten test_ten; + +#if defined (_TEST_MS_LAYOUT) || defined (_MSC_VER) + size_t exp_sizeof_one = 12; + size_t exp_sizeof_two = 16; + size_t exp_sizeof_three =6; + size_t exp_sizeof_four = 8; + size_t exp_sizeof_five = 3; + size_t exp_sizeof_six = 8; + size_t exp_sizeof_seven = 3; + size_t exp_sizeof_eight = 4; + size_t exp_sizeof_nine = 8; + size_t exp_sizeof_ten = 16; + + unsigned char exp_one_c = 8; + unsigned char exp_two_c = 12; + unsigned char exp_three_c = 4; + unsigned char exp_four_c = 4; + char exp_five_c = 2; + char exp_six_c = 5; + char exp_seven_c = 2; + char exp_eight_c = 2; + char exp_nine_c = 0; + char exp_ten_c = 8; + +#else /* testing -mno-ms-bitfields */ + + size_t exp_sizeof_one = 8; + size_t exp_sizeof_two = 8; + size_t exp_sizeof_three = 6; + size_t exp_sizeof_four = 6; + size_t exp_sizeof_five = 6; + size_t exp_sizeof_six = 6; + size_t exp_sizeof_seven = 6; + size_t exp_sizeof_eight = 2; + size_t exp_sizeof_nine = 8; + size_t exp_sizeof_ten = 8; + + unsigned short exp_one_c = 6; + unsigned int exp_two_c = 6; + unsigned char exp_three_c = 64; + unsigned char exp_four_c = 4; + char exp_five_c = 5; + char exp_six_c = 5; + char exp_seven_c = 5; + char exp_eight_c = 1; + char exp_nine_c = 0; + char exp_ten_c = 1; + +#endif + + unsigned char i; + for ( i = 0; i < 16; i++ ) + filler[i] = i; + + check_struct_off (one); + check_struct_off (two); + check_struct_off (three); + check_struct_off (four); + check_struct_off (five); + check_struct_off (six); + check_struct_off (seven); + check_struct_off (eight); +// check_union_off (nine); +// check_struct_off (ten); + + check_struct_size (one); + check_struct_size (two); + check_struct_size (three); + check_struct_size (four); + check_struct_size (five); + check_struct_size (six); + check_struct_size (seven); + check_struct_size (eight); +// check_union_size (nine); +// check_struct_size (ten); + + return 0; +}; diff --git a/test/not_applicable/dg/bf-no-ms-layout.c b/test/not_applicable/dg/bf-no-ms-layout.c new file mode 100644 index 0000000..6623fc4 --- /dev/null +++ b/test/not_applicable/dg/bf-no-ms-layout.c @@ -0,0 +1,238 @@ +/* bf-no-ms-layout.c */ + +/* Test for gcc bitfield layout, with -mno-ms-bitfields */ +/* Adapted from Donn Terry testcase + posted to GCC-patches + http://gcc.gnu.org/ml/gcc-patches/2000-08/msg00577.html */ + +/* { dg-do run { target *-*-interix* *-*-mingw* *-*-cygwin* i?86-*-darwin } } */ +/* { dg-options "-mno-ms-bitfields" } */ + +#include +#include + +extern void abort(); + +#pragma pack(8) + +struct one { + int d; + unsigned char a; + unsigned short b:7; + char c; +}; + +struct two { + int d; + unsigned char a; + unsigned int b:7; + char c; +}; + +struct three { + short d; + unsigned short a:3; + unsigned short b:9; + unsigned char c:7; +}; + + +/* Bitfields of size 0 have some truly odd behaviors. */ + +struct four { + unsigned short a:3; + unsigned short b:9; + unsigned int :0; /* forces struct alignment to int */ + unsigned char c:7; +}; + +struct five { + char a; + int :0; /* ignored; prior field is not a bitfield. */ + char b; + char c; +}; + +struct six { + char a :8; + int :0; /* not ignored; prior field IS a bitfield, causes + struct alignment as well. */ + char b; + char c; +} ; + +struct seven { + char a:8; + char :0; + int :0; /* Ignored; prior field is zero size bitfield. */ + char b; + char c; +}; + +struct eight { /* ms size 4 */ + short b:3; + char c; +}; + +#ifdef _MSC_VER +#define LONGLONG __int64 +#else +#define LONGLONG long long +#endif + +#if 0 +union nine { /* ms size 8 */ + LONGLONG a:3; + char c; +}; + +struct ten { /* ms size 16 */ + LONGLONG a:3; + LONGLONG b:3; + char c; +}; +#endif + +#define val(s,f) (s.f) + +#define check_struct(_X) \ +{ \ + if (sizeof (struct _X) != exp_sizeof_##_X ) \ + abort(); \ + memcpy(&test_##_X, filler, sizeof(test_##_X));\ + if (val(test_##_X,c) != exp_##_X##_c) \ + abort(); \ +} + +#define check_union(_X) \ +{ \ + if (sizeof (union _X) != exp_sizeof_##_X ) \ + abort(); \ + memcpy(&test_##_X, filler, sizeof(test_##_X));\ + if (val(test_##_X,c) != exp_##_X##_c) \ + abort(); \ +} + +#define check_struct_size(_X) \ +{ \ + if (sizeof (struct _X) != exp_sizeof_##_X ) \ + abort(); \ +} + +#define check_struct_off(_X) \ +{ \ + memcpy(&test_##_X, filler, sizeof(test_##_X));\ + if (val(test_##_X,c) != exp_##_X##_c) \ + abort(); \ +} + +#define check_union_size(_X) \ +{ \ + if (sizeof (union _X) != exp_sizeof_##_X ) \ + abort(); \ +} + +#define check_union_off(_X) \ +{ \ + memcpy(&test_##_X, filler, sizeof(test_##_X));\ + if (val(test_##_X,c) != exp_##_X##_c) \ + abort(); \ +} + +int main(){ + + unsigned char filler[16]; + struct one test_one; + struct two test_two; + struct three test_three; + struct four test_four; + struct five test_five; + struct six test_six; + struct seven test_seven; + struct eight test_eight; +#if 0 + union nine test_nine; + struct ten test_ten; +#endif + +#if defined (_TEST_MS_LAYOUT) || defined (_MSC_VER) + size_t exp_sizeof_one = 12; + size_t exp_sizeof_two = 16; + size_t exp_sizeof_three =6; + size_t exp_sizeof_four = 8; + size_t exp_sizeof_five = 3; + size_t exp_sizeof_six = 8; + size_t exp_sizeof_seven = 3; + size_t exp_sizeof_eight = 4; + size_t exp_sizeof_nine = 8; + size_t exp_sizeof_ten = 16; + + unsigned char exp_one_c = 8; + unsigned char exp_two_c = 12; + unsigned char exp_three_c = 4; + unsigned char exp_four_c = 4; + char exp_five_c = 2; + char exp_six_c = 5; + char exp_seven_c = 2; + char exp_eight_c = 2; + char exp_nine_c = 0; + char exp_ten_c = 8; + +#else /* testing -mno-ms-bitfields */ + + size_t exp_sizeof_one = 8; + size_t exp_sizeof_two = 8; + size_t exp_sizeof_three = 6; + size_t exp_sizeof_four = 6; + size_t exp_sizeof_five = 6; + size_t exp_sizeof_six = 6; + size_t exp_sizeof_seven = 6; + size_t exp_sizeof_eight = 2; + size_t exp_sizeof_nine = 8; + size_t exp_sizeof_ten = 8; + + unsigned short exp_one_c = 6; + unsigned int exp_two_c = 6; + unsigned char exp_three_c = 64; + unsigned char exp_four_c = 4; + char exp_five_c = 5; + char exp_six_c = 5; + char exp_seven_c = 5; + char exp_eight_c = 1; + char exp_nine_c = 0; + char exp_ten_c = 1; + +#endif + + unsigned char i; + for ( i = 0; i < 16; i++ ) + filler[i] = i; + + check_struct_off (one); + check_struct_off (two); + check_struct_off (three); + check_struct_off (four); + check_struct_off (five); + check_struct_off (six); + check_struct_off (seven); + check_struct_off (eight); +#if 0 + check_union_off (nine); + check_struct_off (ten); +#endif + + check_struct_size (one); + check_struct_size (two); + check_struct_size (three); + check_struct_size (four); + check_struct_size (five); + check_struct_size (six); + check_struct_size (seven); + check_struct_size (eight); +#if 0 + check_union_size (nine); + check_struct_size (ten); +#endif + + return 0; +}; diff --git a/test/not_applicable/dg/c90-hexfloat-2.c b/test/not_applicable/dg/c90-hexfloat-2.c new file mode 100644 index 0000000..259471c --- /dev/null +++ b/test/not_applicable/dg/c90-hexfloat-2.c @@ -0,0 +1,24 @@ +/* Test for hex floating point constants: in C99 only. Preprocessor test. */ +/* Origin: Joseph Myers */ +/* { dg-do run } */ +/* { dg-options "-std=iso9899:1990 -pedantic-errors" } */ + +#define f ( +#define l ) +#define str(x) #x +#define xstr(x) str(x) + +/* C90: "0x1p+( 0x1p+)"; C99: "0x1p+f 0x1p+l" */ +const char *s = xstr(0x1p+f 0x1p+l); + +extern void abort (void); +extern int strcmp (const char *, const char *); + +int +main (void) +{ + if (strcmp (s, "0x1p+( 0x1p+)")) + abort (); + else + return 0; /* Correct C90 behavior. */ +} diff --git a/test/not_applicable/dg/cleanup-10.c b/test/not_applicable/dg/cleanup-10.c new file mode 100644 index 0000000..11b7403 --- /dev/null +++ b/test/not_applicable/dg/cleanup-10.c @@ -0,0 +1,116 @@ +/* { dg-do run { target hppa*-*-hpux* *-*-linux* powerpc*-*-darwin* *-*-darwin[912]* } } */ +/* { dg-options "-fexceptions -fnon-call-exceptions -O2" } */ +/* Verify that cleanups work with exception handling through signal frames + on alternate stack. */ + +#include +#include +#include +#include +#include + +static _Unwind_Reason_Code +force_unwind_stop (int version, _Unwind_Action actions, + _Unwind_Exception_Class exc_class, + struct _Unwind_Exception *exc_obj, + struct _Unwind_Context *context, + void *stop_parameter) +{ + if (actions & _UA_END_OF_STACK) + abort (); + return _URC_NO_REASON; +} + +static void force_unwind () +{ + struct _Unwind_Exception *exc = malloc (sizeof (*exc)); + memset (&exc->exception_class, 0, sizeof (exc->exception_class)); + exc->exception_cleanup = 0; + +#ifndef __USING_SJLJ_EXCEPTIONS__ + _Unwind_ForcedUnwind (exc, force_unwind_stop, 0); +#else + _Unwind_SjLj_ForcedUnwind (exc, force_unwind_stop, 0); +#endif + + abort (); +} + +int count; +char *null; + +static void counter (void *p __attribute__((unused))) +{ + ++count; +} + +static void handler (void *p __attribute__((unused))) +{ + if (count != 2) + abort (); + exit (0); +} + +static int __attribute__((noinline)) fn5 () +{ + char dummy __attribute__((cleanup (counter))); + force_unwind (); + return 0; +} + +static void fn4 (int sig, siginfo_t *info, void *ctx) +{ + char dummy __attribute__((cleanup (counter))); + fn5 (); + null = NULL; +} + +static void fn3 () +{ + abort (); +} + +static int __attribute__((noinline)) fn2 () +{ + *null = 0; + fn3 (); + return 0; +} + +static int __attribute__((noinline)) fn1 () +{ + stack_t ss; + struct sigaction s; + + ss.ss_size = 4 * sysconf (_SC_PAGESIZE); + if (ss.ss_size < SIGSTKSZ) + ss.ss_size = SIGSTKSZ; + ss.ss_sp = malloc (ss.ss_size); + if (ss.ss_sp == NULL) + exit (1); + ss.ss_flags = 0; + if (sigaltstack (&ss, NULL) < 0) + exit (1); + + sigemptyset (&s.sa_mask); + s.sa_sigaction = fn4; + s.sa_flags = SA_RESETHAND | SA_ONSTACK; + sigaction (SIGSEGV, &s, NULL); + sigaction (SIGBUS, &s, NULL); + fn2 (); + return 0; +} + +static int __attribute__((noinline)) fn0 () +{ + char dummy __attribute__((cleanup (handler))); + fn1 (); + null = 0; + return 0; +} + +int main() +{ + fn0 (); + abort (); +} diff --git a/test/not_applicable/dg/cleanup-11.c b/test/not_applicable/dg/cleanup-11.c new file mode 100644 index 0000000..d0c78d5 --- /dev/null +++ b/test/not_applicable/dg/cleanup-11.c @@ -0,0 +1,116 @@ +/* { dg-do run { target hppa*-*-hpux* *-*-linux* powerpc*-*-darwin* *-*-darwin[912]* } } */ +/* { dg-options "-fexceptions -fnon-call-exceptions -O2" } */ +/* Verify that cleanups work with exception handling through realtime signal + frames on alternate stack. */ + +#include +#include +#include +#include +#include + +static _Unwind_Reason_Code +force_unwind_stop (int version, _Unwind_Action actions, + _Unwind_Exception_Class exc_class, + struct _Unwind_Exception *exc_obj, + struct _Unwind_Context *context, + void *stop_parameter) +{ + if (actions & _UA_END_OF_STACK) + abort (); + return _URC_NO_REASON; +} + +static void force_unwind () +{ + struct _Unwind_Exception *exc = malloc (sizeof (*exc)); + memset (&exc->exception_class, 0, sizeof (exc->exception_class)); + exc->exception_cleanup = 0; + +#ifndef __USING_SJLJ_EXCEPTIONS__ + _Unwind_ForcedUnwind (exc, force_unwind_stop, 0); +#else + _Unwind_SjLj_ForcedUnwind (exc, force_unwind_stop, 0); +#endif + + abort (); +} + +int count; +char *null; + +static void counter (void *p __attribute__((unused))) +{ + ++count; +} + +static void handler (void *p __attribute__((unused))) +{ + if (count != 2) + abort (); + exit (0); +} + +static int __attribute__((noinline)) fn5 () +{ + char dummy __attribute__((cleanup (counter))); + force_unwind (); + return 0; +} + +static void fn4 (int sig, siginfo_t *info, void *ctx) +{ + char dummy __attribute__((cleanup (counter))); + fn5 (); + null = NULL; +} + +static void fn3 () +{ + abort (); +} + +static int __attribute__((noinline)) fn2 () +{ + *null = 0; + fn3 (); + return 0; +} + +static int __attribute__((noinline)) fn1 () +{ + stack_t ss; + struct sigaction s; + + ss.ss_size = 4 * sysconf (_SC_PAGESIZE); + if (ss.ss_size < SIGSTKSZ) + ss.ss_size = SIGSTKSZ; + ss.ss_sp = malloc (ss.ss_size); + if (ss.ss_sp == NULL) + exit (1); + ss.ss_flags = 0; + if (sigaltstack (&ss, NULL) < 0) + exit (1); + + sigemptyset (&s.sa_mask); + s.sa_sigaction = fn4; + s.sa_flags = SA_RESETHAND | SA_ONSTACK | SA_SIGINFO; + sigaction (SIGSEGV, &s, NULL); + sigaction (SIGBUS, &s, NULL); + fn2 (); + return 0; +} + +static int __attribute__((noinline)) fn0 () +{ + char dummy __attribute__((cleanup (handler))); + fn1 (); + null = 0; + return 0; +} + +int main() +{ + fn0 (); + abort (); +} diff --git a/test/not_applicable/dg/cleanup-12.c b/test/not_applicable/dg/cleanup-12.c new file mode 100644 index 0000000..90de90a --- /dev/null +++ b/test/not_applicable/dg/cleanup-12.c @@ -0,0 +1,69 @@ +/* PR middle-end/32758 */ +/* HP-UX libunwind.so doesn't provide _UA_END_OF_STACK */ +/* { dg-do run } */ +/* { dg-options "-O2 -fexceptions" } */ +/* { dg-skip-if "" { "ia64-*-hpux11.*" } { "*" } { "" } } */ +/* Verify unwind info in presence of alloca. */ + +#include +#include +#include + +static _Unwind_Reason_Code +force_unwind_stop (int version, _Unwind_Action actions, + _Unwind_Exception_Class exc_class, + struct _Unwind_Exception *exc_obj, + struct _Unwind_Context *context, + void *stop_parameter) +{ + if (actions & _UA_END_OF_STACK) + abort (); + return _URC_NO_REASON; +} + +static void force_unwind (void) +{ + struct _Unwind_Exception *exc = malloc (sizeof (*exc)); + memset (&exc->exception_class, 0, sizeof (exc->exception_class)); + exc->exception_cleanup = 0; + +#ifndef __USING_SJLJ_EXCEPTIONS__ + _Unwind_ForcedUnwind (exc, force_unwind_stop, 0); +#else + _Unwind_SjLj_ForcedUnwind (exc, force_unwind_stop, 0); +#endif + + abort (); +} + +__attribute__((noinline)) +void foo (void *x __attribute__((unused))) +{ + force_unwind (); +} + +__attribute__((noinline)) +int bar (unsigned int x) +{ + void *y = __builtin_alloca (x); + foo (y); + return 1; +} + +static void handler (void *p __attribute__((unused))) +{ + exit (0); +} + +__attribute__((noinline)) +static void doit () +{ + char dummy __attribute__((cleanup (handler))); + bar (1024); +} + +int main () +{ + doit (); + abort (); +} diff --git a/test/not_applicable/dg/cleanup-3.c b/test/not_applicable/dg/cleanup-3.c new file mode 100644 index 0000000..b5b01fd --- /dev/null +++ b/test/not_applicable/dg/cleanup-3.c @@ -0,0 +1,45 @@ +/* { dg-do run } */ +/* { dg-options "" } */ +/* Verify that the cleanup handler receives the proper contents + of the variable. */ + +extern void exit(int); +extern void abort(void); + +static int expected; + +static void +handler(int *p) +{ + if (*p != expected) + abort (); +} + +static void __attribute__((noinline)) +bar(void) +{ +} + +static void doit(int x, int y) +{ + int r __attribute__((cleanup (handler))); + if (x < y) + { + r = 0; + return; + } + + bar(); + r = x + y; +} + +int main() +{ + expected = 0; + doit (1, 2); + + expected = 3; + doit (2, 1); + + return 0; +} diff --git a/test/not_applicable/dg/cleanup-5.c b/test/not_applicable/dg/cleanup-5.c new file mode 100644 index 0000000..c335c1e --- /dev/null +++ b/test/not_applicable/dg/cleanup-5.c @@ -0,0 +1,53 @@ +/* HP-UX libunwind.so doesn't provide _UA_END_OF_STACK */ +/* { dg-do run } */ +/* { dg-options "-fexceptions" } */ +/* { dg-skip-if "" { "ia64-*-hpux11.*" } { "*" } { "" } } */ +/* Verify that cleanups work with exception handling. */ + +#include +#include +#include + +static _Unwind_Reason_Code +force_unwind_stop (int version, _Unwind_Action actions, + _Unwind_Exception_Class exc_class, + struct _Unwind_Exception *exc_obj, + struct _Unwind_Context *context, + void *stop_parameter) +{ + if (actions & _UA_END_OF_STACK) + abort (); + return _URC_NO_REASON; +} + +static void force_unwind () +{ + struct _Unwind_Exception *exc = malloc (sizeof (*exc)); + memset (&exc->exception_class, 0, sizeof (exc->exception_class)); + exc->exception_cleanup = 0; + +#ifndef __USING_SJLJ_EXCEPTIONS__ + _Unwind_ForcedUnwind (exc, force_unwind_stop, 0); +#else + _Unwind_SjLj_ForcedUnwind (exc, force_unwind_stop, 0); +#endif + + abort (); +} + +static void handler (void *p __attribute__((unused))) +{ + exit (0); +} + +static void doit () +{ + char dummy __attribute__((cleanup (handler))); + force_unwind (); +} + +int main() +{ + doit (); + abort (); +} diff --git a/test/not_applicable/dg/cleanup-7.c b/test/not_applicable/dg/cleanup-7.c new file mode 100644 index 0000000..eae3d52 --- /dev/null +++ b/test/not_applicable/dg/cleanup-7.c @@ -0,0 +1,22 @@ +/* { dg-do run } */ +/* { dg-options "" } */ +/* Verify that the search for function happens in the proper scope. */ + +extern void exit(int); +extern void abort(void); + +int main() +{ + auto void xyzzy(void *p __attribute__((unused))) + { + exit (0); + } + + auto void doit () + { + int x __attribute__((cleanup (xyzzy))); + } + + doit (); + abort (); +} diff --git a/test/not_applicable/dg/cleanup-8.c b/test/not_applicable/dg/cleanup-8.c new file mode 100644 index 0000000..d233560 --- /dev/null +++ b/test/not_applicable/dg/cleanup-8.c @@ -0,0 +1,99 @@ +/* { dg-do run { target hppa*-*-hpux* *-*-linux* powerpc*-*-darwin* *-*-darwin[912]* } } */ +/* { dg-options "-fexceptions -fnon-call-exceptions -O2" } */ +/* Verify that cleanups work with exception handling through signal + frames. */ + +#include +#include +#include +#include + +static _Unwind_Reason_Code +force_unwind_stop (int version, _Unwind_Action actions, + _Unwind_Exception_Class exc_class, + struct _Unwind_Exception *exc_obj, + struct _Unwind_Context *context, + void *stop_parameter) +{ + if (actions & _UA_END_OF_STACK) + abort (); + return _URC_NO_REASON; +} + +static void force_unwind () +{ + struct _Unwind_Exception *exc = malloc (sizeof (*exc)); + memset (&exc->exception_class, 0, sizeof (exc->exception_class)); + exc->exception_cleanup = 0; + +#ifndef __USING_SJLJ_EXCEPTIONS__ + _Unwind_ForcedUnwind (exc, force_unwind_stop, 0); +#else + _Unwind_SjLj_ForcedUnwind (exc, force_unwind_stop, 0); +#endif + + abort (); +} + +int count; +char *null; + +static void counter (void *p __attribute__((unused))) +{ + ++count; +} + +static void handler (void *p __attribute__((unused))) +{ + if (count != 2) + abort (); + exit (0); +} + +static int __attribute__((noinline)) fn5 () +{ + char dummy __attribute__((cleanup (counter))); + force_unwind (); + return 0; +} + +static void fn4 (int sig) +{ + char dummy __attribute__((cleanup (counter))); + fn5 (); + null = NULL; +} + +static void fn3 () +{ + abort (); +} + +static int __attribute__((noinline)) fn2 () +{ + *null = 0; + fn3 (); + return 0; +} + +static int __attribute__((noinline)) fn1 () +{ + signal (SIGSEGV, fn4); + signal (SIGBUS, fn4); + fn2 (); + return 0; +} + +static int __attribute__((noinline)) fn0 () +{ + char dummy __attribute__((cleanup (handler))); + fn1 (); + null = 0; + return 0; +} + +int main() +{ + fn0 (); + abort (); +} diff --git a/test/not_applicable/dg/cleanup-9.c b/test/not_applicable/dg/cleanup-9.c new file mode 100644 index 0000000..b73125a --- /dev/null +++ b/test/not_applicable/dg/cleanup-9.c @@ -0,0 +1,103 @@ +/* { dg-do run { target hppa*-*-hpux* *-*-linux* powerpc*-*-darwin* *-*-darwin[912]* } } */ +/* { dg-options "-fexceptions -fnon-call-exceptions -O2" } */ +/* Verify that cleanups work with exception handling through realtime + signal frames. */ + +#include +#include +#include +#include + +static _Unwind_Reason_Code +force_unwind_stop (int version, _Unwind_Action actions, + _Unwind_Exception_Class exc_class, + struct _Unwind_Exception *exc_obj, + struct _Unwind_Context *context, + void *stop_parameter) +{ + if (actions & _UA_END_OF_STACK) + abort (); + return _URC_NO_REASON; +} + +static void force_unwind () +{ + struct _Unwind_Exception *exc = malloc (sizeof (*exc)); + memset (&exc->exception_class, 0, sizeof (exc->exception_class)); + exc->exception_cleanup = 0; + +#ifndef __USING_SJLJ_EXCEPTIONS__ + _Unwind_ForcedUnwind (exc, force_unwind_stop, 0); +#else + _Unwind_SjLj_ForcedUnwind (exc, force_unwind_stop, 0); +#endif + + abort (); +} + +int count; +char *null; + +static void counter (void *p __attribute__((unused))) +{ + ++count; +} + +static void handler (void *p __attribute__((unused))) +{ + if (count != 2) + abort (); + exit (0); +} + +static int __attribute__((noinline)) fn5 () +{ + char dummy __attribute__((cleanup (counter))); + force_unwind (); + return 0; +} + +static void fn4 (int sig, siginfo_t *info, void *ctx) +{ + char dummy __attribute__((cleanup (counter))); + fn5 (); + null = NULL; +} + +static void fn3 () +{ + abort (); +} + +static int __attribute__((noinline)) fn2 () +{ + *null = 0; + fn3 (); + return 0; +} + +static int __attribute__((noinline)) fn1 () +{ + struct sigaction s; + sigemptyset (&s.sa_mask); + s.sa_sigaction = fn4; + s.sa_flags = SA_RESETHAND | SA_SIGINFO; + sigaction (SIGSEGV, &s, NULL); + sigaction (SIGBUS, &s, NULL); + fn2 (); + return 0; +} + +static int __attribute__((noinline)) fn0 () +{ + char dummy __attribute__((cleanup (handler))); + fn1 (); + null = 0; + return 0; +} + +int main() +{ + fn0 (); + abort (); +} diff --git a/test/not_applicable/dg/darwin-minversion-1.c b/test/not_applicable/dg/darwin-minversion-1.c new file mode 100644 index 0000000..d8a3243 --- /dev/null +++ b/test/not_applicable/dg/darwin-minversion-1.c @@ -0,0 +1,11 @@ +/* Basic test for -mmacosx-version-min switch on Darwin. */ +/* { dg-options "-mmacosx-version-min=10.1" } */ +/* { dg-do run { target *-*-darwin* } } */ + +int main(void) +{ +#if __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ != 1010 + fail me; +#endif + return 0; +} diff --git a/test/not_applicable/dg/darwin-minversion-2.c b/test/not_applicable/dg/darwin-minversion-2.c new file mode 100644 index 0000000..fd4975a --- /dev/null +++ b/test/not_applicable/dg/darwin-minversion-2.c @@ -0,0 +1,11 @@ +/* Basic test for -mmacosx-version-min switch on Darwin. */ +/* { dg-options "-mmacosx-version-min=10.1 -mmacosx-version-min=10.3" } */ +/* { dg-do run { target *-*-darwin* } } */ + +int main(void) +{ +#if __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ != 1030 + fail me; +#endif + return 0; +} diff --git a/test/not_applicable/dg/fwrapv-2.c b/test/not_applicable/dg/fwrapv-2.c new file mode 100644 index 0000000..cb4270e --- /dev/null +++ b/test/not_applicable/dg/fwrapv-2.c @@ -0,0 +1,28 @@ +/* Copyright (C) 2003 Free Software Foundation. + + Test that the -fno-wrapv command line option is accepted and enables + "unsafe" optimizations that rely on undefined arithmetic overflow. + + Written by Roger Sayle, 31st May 2003. */ + +/* { dg-do run } */ +/* { dg-options "-O2 -fno-wrapv" } */ + +#include + +extern void abort (); + +int test(int x) +{ + return (2*x)/2; +} + +main() +{ + int x = INT_MAX; + + if (test(x) != x) + abort (); + return 0; +} + diff --git a/test/not_applicable/dg/ia64-sync-1.c b/test/not_applicable/dg/ia64-sync-1.c new file mode 100644 index 0000000..8f4512e --- /dev/null +++ b/test/not_applicable/dg/ia64-sync-1.c @@ -0,0 +1,71 @@ +/* { dg-do run } */ +/* { dg-require-effective-target sync_int_long } */ +/* { dg-options } */ +/* { dg-options "-march=i486" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */ +/* { dg-options "-mcpu=v9" { target sparc*-*-* } } */ + +/* Test basic functionality of the intrinsics. The operations should + not be optimized away if no one checks the return values. */ + +extern void abort (void); +extern void *memcpy (void *, const void *, __SIZE_TYPE__); + +static int AI[12]; +static int init_noret_si[12] = { 0, 0, 0, 1, 0, 0, 0, 0, -1, 0, 0, 0 }; +static int test_noret_si[12] = { 1, 1, 1, 0, 1, 4, 22, -12, 7, 8, 9, 7 }; + +static void +do_noret_si (void) +{ + __sync_val_compare_and_swap(AI+0, 0, 1); + __sync_bool_compare_and_swap(AI+1, 0, 1); + __sync_lock_test_and_set(AI+2, 1); + __sync_lock_release(AI+3); + + __sync_fetch_and_add(AI+4, 1); + __sync_fetch_and_add(AI+5, 4); + __sync_fetch_and_add(AI+6, 22); + __sync_fetch_and_sub(AI+7, 12); + __sync_fetch_and_and(AI+8, 7); + __sync_fetch_and_or(AI+9, 8); + __sync_fetch_and_xor(AI+10, 9); + __sync_fetch_and_nand(AI+11, 7); +} + +static long AL[12]; +static long init_noret_di[12] = { 0, 0, 0, 1, 0, 0, 0, 0, -1, 0, 0, 0 }; +static long test_noret_di[12] = { 1, 1, 1, 0, 1, 4, 22, -12, 7, 8, 9, 7 }; + +static void +do_noret_di (void) +{ + __sync_val_compare_and_swap(AL+0, 0, 1); + __sync_bool_compare_and_swap(AL+1, 0, 1); + __sync_lock_test_and_set(AL+2, 1); + __sync_lock_release(AL+3); + + __sync_fetch_and_add(AL+4, 1); + __sync_fetch_and_add(AL+5, 4); + __sync_fetch_and_add(AL+6, 22); + __sync_fetch_and_sub(AL+7, 12); + __sync_fetch_and_and(AL+8, 7); + __sync_fetch_and_or(AL+9, 8); + __sync_fetch_and_xor(AL+10, 9); + __sync_fetch_and_nand(AL+11, 7); +} + +int main() +{ + memcpy(AI, init_noret_si, sizeof(init_noret_si)); + memcpy(AL, init_noret_di, sizeof(init_noret_di)); + + do_noret_si (); + do_noret_di (); + + if (memcmp (AI, test_noret_si, sizeof(test_noret_si))) + abort (); + if (memcmp (AL, test_noret_di, sizeof(test_noret_di))) + abort (); + + return 0; +} diff --git a/test/not_applicable/dg/ia64-sync-2.c b/test/not_applicable/dg/ia64-sync-2.c new file mode 100644 index 0000000..bb8c728 --- /dev/null +++ b/test/not_applicable/dg/ia64-sync-2.c @@ -0,0 +1,126 @@ +/* { dg-do run } */ +/* { dg-require-effective-target sync_int_long } */ +/* { dg-options } */ +/* { dg-options "-march=i486" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */ +/* { dg-options "-mcpu=v9" { target sparc*-*-* } } */ + +/* Test basic functionality of the intrinsics. */ + +extern void abort (void); +extern void *memcpy (void *, const void *, __SIZE_TYPE__); + +static int AI[18]; +static int init_si[18] = { 0,0,0,1,0,0,0,0,-1,0,0,0,0,0,-1,0,0,0 }; +static int test_si[18] = { 1,1,1,1,1,4,22,-12,7,8,9,7,1,-12,7,8,9,7 }; + +static void +do_si (void) +{ + if (__sync_val_compare_and_swap(AI+0, 0, 1) != 0) + abort (); + if (__sync_val_compare_and_swap(AI+0, 0, 1) != 1) + abort (); + if (__sync_bool_compare_and_swap(AI+1, 0, 1) != 1) + abort (); + if (__sync_bool_compare_and_swap(AI+1, 0, 1) != 0) + abort (); + + if (__sync_lock_test_and_set(AI+2, 1) != 0) + abort (); + + if (__sync_fetch_and_add(AI+4, 1) != 0) + abort (); + if (__sync_fetch_and_add(AI+5, 4) != 0) + abort (); + if (__sync_fetch_and_add(AI+6, 22) != 0) + abort (); + if (__sync_fetch_and_sub(AI+7, 12) != 0) + abort (); + if (__sync_fetch_and_and(AI+8, 7) != -1) + abort (); + if (__sync_fetch_and_or(AI+9, 8) != 0) + abort (); + if (__sync_fetch_and_xor(AI+10, 9) != 0) + abort (); + if (__sync_fetch_and_nand(AI+11, 7) != 0) + abort (); + + if (__sync_add_and_fetch(AI+12, 1) != 1) + abort (); + if (__sync_sub_and_fetch(AI+13, 12) != -12) + abort (); + if (__sync_and_and_fetch(AI+14, 7) != 7) + abort (); + if (__sync_or_and_fetch(AI+15, 8) != 8) + abort (); + if (__sync_xor_and_fetch(AI+16, 9) != 9) + abort (); + if (__sync_nand_and_fetch(AI+17, 7) != 7) + abort (); +} + +static long AL[18]; +static long init_di[18] = { 0,0,0,1,0,0,0,0,-1,0,0,0,0,0,-1,0,0,0 }; +static long test_di[18] = { 1,1,1,1,1,4,22,-12,7,8,9,7,1,-12,7,8,9,7 }; + +static void +do_di (void) +{ + if (__sync_val_compare_and_swap(AL+0, 0, 1) != 0) + abort (); + if (__sync_val_compare_and_swap(AL+0, 0, 1) != 1) + abort (); + if (__sync_bool_compare_and_swap(AL+1, 0, 1) != 1) + abort (); + if (__sync_bool_compare_and_swap(AL+1, 0, 1) != 0) + abort (); + + if (__sync_lock_test_and_set(AL+2, 1) != 0) + abort (); + + if (__sync_fetch_and_add(AL+4, 1) != 0) + abort (); + if (__sync_fetch_and_add(AL+5, 4) != 0) + abort (); + if (__sync_fetch_and_add(AL+6, 22) != 0) + abort (); + if (__sync_fetch_and_sub(AL+7, 12) != 0) + abort (); + if (__sync_fetch_and_and(AL+8, 7) != -1) + abort (); + if (__sync_fetch_and_or(AL+9, 8) != 0) + abort (); + if (__sync_fetch_and_xor(AL+10, 9) != 0) + abort (); + if (__sync_fetch_and_nand(AL+11, 7) != 0) + abort (); + + if (__sync_add_and_fetch(AL+12, 1) != 1) + abort (); + if (__sync_sub_and_fetch(AL+13, 12) != -12) + abort (); + if (__sync_and_and_fetch(AL+14, 7) != 7) + abort (); + if (__sync_or_and_fetch(AL+15, 8) != 8) + abort (); + if (__sync_xor_and_fetch(AL+16, 9) != 9) + abort (); + if (__sync_nand_and_fetch(AL+17, 7) != 7) + abort (); +} + +int main() +{ + memcpy(AI, init_si, sizeof(init_si)); + memcpy(AL, init_di, sizeof(init_di)); + + do_si (); + do_di (); + + if (memcmp (AI, test_si, sizeof(test_si))) + abort (); + if (memcmp (AL, test_di, sizeof(test_di))) + abort (); + + return 0; +} diff --git a/test/not_applicable/dg/ia64-sync-3.c b/test/not_applicable/dg/ia64-sync-3.c new file mode 100644 index 0000000..d093cdd --- /dev/null +++ b/test/not_applicable/dg/ia64-sync-3.c @@ -0,0 +1,78 @@ +/* { dg-do run } */ +/* { dg-require-effective-target sync_int_long } */ +/* { dg-options } */ +/* { dg-options "-march=i486" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */ +/* { dg-options "-mcpu=v9" { target sparc*-*-* } } */ + +/* Test basic functionality of the intrinsics. */ + +extern void abort (void); +extern void *memcpy (void *, const void *, __SIZE_TYPE__); + +static int AI[4]; +static int init_si[4] = { -30,-30,-50,-50 }; +static int test_si[4] = { -115,-115,25,25 }; + +static void +do_si (void) +{ + if (__sync_val_compare_and_swap(AI+0, -30, -115) != -30) + abort (); + if (__sync_val_compare_and_swap(AI+0, -30, -115) != -115) + abort (); + if (__sync_bool_compare_and_swap(AI+1, -30, -115) != 1) + abort (); + if (__sync_bool_compare_and_swap(AI+1, -30, -115) != 0) + abort (); + + if (__sync_val_compare_and_swap(AI+2, AI[2], 25) != -50) + abort (); + if (__sync_val_compare_and_swap(AI+2, AI[2], 25) != 25) + abort (); + if (__sync_bool_compare_and_swap(AI+3, AI[3], 25) != 1) + abort (); + if (__sync_bool_compare_and_swap(AI+3, AI[3], 25) != 1) + abort (); +} + +static long AL[4]; +static long init_di[4] = { -30,-30,-50,-50 }; +static long test_di[4] = { -115,-115,25,25 }; + +static void +do_di (void) +{ + if (__sync_val_compare_and_swap(AL+0, -30, -115) != -30) + abort (); + if (__sync_val_compare_and_swap(AL+0, -30, -115) != -115) + abort (); + if (__sync_bool_compare_and_swap(AL+1, -30, -115) != 1) + abort (); + if (__sync_bool_compare_and_swap(AL+1, -30, -115) != 0) + abort (); + + if (__sync_val_compare_and_swap(AL+2, AL[2], 25) != -50) + abort (); + if (__sync_val_compare_and_swap(AL+2, AL[2], 25) != 25) + abort (); + if (__sync_bool_compare_and_swap(AL+3, AL[3], 25) != 1) + abort (); + if (__sync_bool_compare_and_swap(AL+3, AL[3], 25) != 1) + abort (); +} + +int main() +{ + memcpy(AI, init_si, sizeof(init_si)); + memcpy(AL, init_di, sizeof(init_di)); + + do_si (); + do_di (); + + if (memcmp (AI, test_si, sizeof(test_si))) + abort (); + if (memcmp (AL, test_di, sizeof(test_di))) + abort (); + + return 0; +} diff --git a/test/not_applicable/dg/pack-test-5.c b/test/not_applicable/dg/pack-test-5.c new file mode 100644 index 0000000..7645043 --- /dev/null +++ b/test/not_applicable/dg/pack-test-5.c @@ -0,0 +1,21 @@ +/* PR c/11446: packed on a struct takes precedence over aligned on the type + of a field. */ +/* { dg-do run } */ + +extern void abort (void); + +struct A { + double d; +} __attribute__ ((aligned)); + +struct B { + char c; + struct A a; +} __attribute__ ((packed)); + +int main () +{ + if (sizeof (struct B) != sizeof (char) + sizeof (struct A)) + abort (); + return 0; +} diff --git a/test/not_applicable/dg/pic-macro-define.c b/test/not_applicable/dg/pic-macro-define.c new file mode 100644 index 0000000..7bda6fe --- /dev/null +++ b/test/not_applicable/dg/pic-macro-define.c @@ -0,0 +1,10 @@ +/* { dg-do run { target "i?86-*-*-darwin" powerpc*-*-darwin* } } */ +/* { dg-options "-fPIC" } */ + +#if defined __PIC__ +int main() { + return 0; +} +#else + error "NO __PIC__ DEFINED" +#endif diff --git a/test/not_applicable/dg/pragma-align-2.c b/test/not_applicable/dg/pragma-align-2.c new file mode 100644 index 0000000..e33f24a --- /dev/null +++ b/test/not_applicable/dg/pragma-align-2.c @@ -0,0 +1,66 @@ +/* { dg-do run { target *-*-solaris2.* } } */ + +void abort (void); + +#pragma align 1(x1) +#pragma align 2(x2) +#pragma align 4(x4) +#pragma align 8(x8,y8,z8) +#pragma align 16(x16) +#pragma align 32(x32) +#pragma align 64(x64) +#pragma align 128(x128) + +#define MACRO 128 +#define MACRO2(A) A + +#pragma align MACRO(y128) +#pragma align MACRO2(MACRO) (z128) + +#pragma align 8(not_defined) + +#pragma align 9(odd_align) /* { dg-error "invalid alignment" } */ +#pragma align 256(high_align) /* { dg-error "invalid alignment" } */ +#pragma align -1(neg_align) /* { dg-error "malformed" } */ +#pragma align bad_align /* { dg-error "malformed" } */ +#pragma align 1(bad_align /* { dg-error "malformed" } */ + +int x, x1, x2, x4, x8, y8, z8, x16, x32, x64, x128, y128, z128; + +#pragma align 16(x) /* { dg-error "must appear before" } */ + +int +main () +{ + if (__alignof__ (x4) < 4) + abort (); + + if (__alignof__ (x8) < 8) + abort (); + + if (__alignof__ (y8) < 8) + abort (); + + if (__alignof__ (z8) < 8) + abort (); + + if (__alignof__ (x16) < 16) + abort (); + + if (__alignof__ (x32) < 32) + abort (); + + if (__alignof__ (x64) < 64) + abort (); + + if (__alignof__ (x128) < 128) + abort (); + + if (__alignof__ (y128) < 128) + abort (); + + if (__alignof__ (z128) < 128) + abort (); + + return 0; +} diff --git a/test/not_applicable/dg/pragma-darwin.c b/test/not_applicable/dg/pragma-darwin.c new file mode 100644 index 0000000..f64095b --- /dev/null +++ b/test/not_applicable/dg/pragma-darwin.c @@ -0,0 +1,70 @@ +/* Darwin (Mac OS X) pragma exercises. */ + +/* { dg-do run { target *-*-darwin* } } */ +/* { dg-options "-O -Wunused" } */ + +/* The mark pragma is to help decorate IDEs. */ + +extern void abort(void); + +#pragma mark hey hey ho + +/* The options pragma used to do a lot, now it's only for emulating + m68k alignment rules in structs. */ + +#pragma options 23 /* { dg-warning "malformed '#pragma options'" } */ +#pragma options align /* { dg-warning "malformed '#pragma options'" } */ +#pragma options align natural /* { dg-warning "malformed '#pragma options'" } */ +#pragma options align=45 /* { dg-warning "malformed '#pragma options'" } */ +#pragma options align=foo /* { dg-warning "malformed '#pragma options align" } */ + +#ifndef __LP64__ +#pragma options align=mac68k +struct s1 { short f1; int f2; }; +#endif +#pragma options align=power +struct s2 { short f1; int f2; }; +#ifndef __LP64__ +#pragma options align=mac68k +struct s3 { short f1; int f2; }; +#endif +#pragma options align=reset +struct s4 { short f1; int f2; }; + +#pragma options align=natural foo /* { dg-warning "junk at end of '#pragma options'" } */ +/* { dg-warning "malformed '#pragma options align={mac68k|power|reset}', ignoring" "ignoring" { target *-*-* } 34 } */ + +/* Segment pragmas don't do anything anymore. */ + +#pragma segment foo + +int +main () +{ + int x, z; /* { dg-warning "unused variable 'z'" } */ + #pragma unused (x, y) + +#ifndef __LP64__ + if (sizeof (struct s1) != 6) + abort (); +#endif + if (sizeof (struct s2) != 8) + abort (); +#ifndef __LP64__ + if (sizeof (struct s3) != 6) + abort (); +#endif + if (sizeof (struct s4) != 8) + abort (); + return 0; +} + +void +unused_err_test () +{ + int a, b; + /* Trying to match on '(' or ')' gives regexp headaches, use . instead. */ +#pragma unused /* { dg-warning "missing '.' after '#pragma unused" } */ +#pragma unused (a /* { dg-warning "missing '.' after '#pragma unused" } */ +#pragma unused (b) foo /* { dg-warning "junk at end of '#pragma unused'" } */ +} diff --git a/test/not_applicable/dg/pragma-init-fini.c b/test/not_applicable/dg/pragma-init-fini.c new file mode 100644 index 0000000..8c5c53a --- /dev/null +++ b/test/not_applicable/dg/pragma-init-fini.c @@ -0,0 +1,50 @@ +/* Tests for #pragma init and #pragma fini. */ + +/* { dg-do run { target *-*-solaris2.* } } */ + +extern void abort (); + +#pragma init /* { dg-error "malformed" } */ +#pragma init () /* { dg-error "malformed" } */ +#pragma init init_func /* { dg-error "malformed" } */ + +#pragma fini /* { dg-error "malformed" } */ +#pragma fini () /* { dg-error "malformed" } */ +#pragma fini fini_func /* { dg-error "malformed" } */ + +#pragma init (init_func, init_static_func) + +int glob_1, glob_2; + +void init_func (void) +{ + glob_1 = 1; +} + +static void init_static_func (void) +{ + glob_2 = 2; +} + +#pragma fini (fini_func, fini_static_func) + +void fini_func (void) +{ + +} + +static void fini_static_func (void) +{ + +} + +int main() +{ + if (glob_1 != 1) + abort (); + + if (glob_2 != 2) + abort (); + + return 0; +} diff --git a/test/not_applicable/dg/setjmp-2.c b/test/not_applicable/dg/setjmp-2.c new file mode 100644 index 0000000..8ad874d --- /dev/null +++ b/test/not_applicable/dg/setjmp-2.c @@ -0,0 +1,48 @@ +/* PR middle-end/17813 */ +/* Origin: Tom Hughes */ +/* { dg-do run { target i?86-*-linux* x86_64-*-linux* } } */ +/* { dg-options "-O -fomit-frame-pointer" } */ +/* { dg-options "-O -fomit-frame-pointer -march=i386" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */ + +#include +#include +#include + +static jmp_buf segv_jmpbuf; + +static void segv_handler(int seg) +{ + __builtin_longjmp(segv_jmpbuf, 1); +} + +static int is_addressable(void *p, size_t size) +{ + volatile char * volatile cp = (volatile char *)p; + volatile int ret; + struct sigaction sa, origsa; + sigset_t mask; + + sa.sa_handler = segv_handler; + sa.sa_flags = 0; + sigfillset(&sa.sa_mask); + sigaction(SIGSEGV, &sa, &origsa); + sigprocmask(SIG_SETMASK, NULL, &mask); + + if (__builtin_setjmp(segv_jmpbuf) == 0) { + while(size--) + *cp++; + ret = 1; + } else + ret = 0; + + sigaction(SIGSEGV, &origsa, NULL); + sigprocmask(SIG_SETMASK, &mask, NULL); + + return ret; +} + +int main(int argc, char **argv) +{ + is_addressable(0x0, 1); + return 0; +} diff --git a/test/not_applicable/dg/sibcall-1.c b/test/not_applicable/dg/sibcall-1.c new file mode 100644 index 0000000..4521ace --- /dev/null +++ b/test/not_applicable/dg/sibcall-1.c @@ -0,0 +1,49 @@ +/* Simple check that sibling calls are performed from a + void non-leaf-function taking one int argument calling itself. + + Copyright (C) 2002 Free Software Foundation Inc. + Contributed by Hans-Peter Nilsson */ + +/* { dg-do run } */ +/* { dg-options "-O2 -foptimize-sibling-calls" } */ + +/* The option -foptimize-sibling-calls is the default, but serves as + marker. Self-recursion tail calls are optimized for all targets, + regardless of presence of sibcall patterns. */ + +extern void abort (void); +extern void exit (int); + +extern void recurser_void (int); +extern void track (int); + +int main () +{ + recurser_void (0); + exit (0); +} + +void +recurser_void (int n) +{ + if (n == 0 || n == 7) + track (n); + + if (n == 10) + return; + + recurser_void (n + 1); +} + +void *trackpoint; + +void +track (int n) +{ + char stackpos[1]; + + if (n == 0) + trackpoint = stackpos; + else if (n != 7 || trackpoint != stackpos) + abort (); +} diff --git a/test/not_applicable/dg/sibcall-2.c b/test/not_applicable/dg/sibcall-2.c new file mode 100644 index 0000000..4c226c4 --- /dev/null +++ b/test/not_applicable/dg/sibcall-2.c @@ -0,0 +1,50 @@ +/* Simple check that sibling calls are performed from a + void non-leaf-function taking no arguments calling itself. + + Copyright (C) 2002 Free Software Foundation Inc. + Contributed by Hans-Peter Nilsson */ + +/* { dg-do run } */ +/* { dg-options "-O2 -foptimize-sibling-calls" } */ + +/* The option -foptimize-sibling-calls is the default, but serves as + marker. Self-recursion tail calls are optimized for all targets, + regardless of presence of sibcall patterns. */ + +extern void abort (void); +extern void exit (int); + +extern void recurser_void (void); +extern void track (void); + +int n = 0; +int main () +{ + recurser_void (); + exit (0); +} + +void +recurser_void (void) +{ + if (n == 0 || n == 7) + track (); + + if (n == 10) + return; + n++; + recurser_void (); +} + +void *trackpoint; + +void +track () +{ + char stackpos[1]; + + if (n == 0) + trackpoint = stackpos; + else if (n != 7 || trackpoint != stackpos) + abort (); +} diff --git a/test/not_applicable/dg/sibcall-3.c b/test/not_applicable/dg/sibcall-3.c new file mode 100644 index 0000000..6e6b3ae --- /dev/null +++ b/test/not_applicable/dg/sibcall-3.c @@ -0,0 +1,78 @@ +/* Simple check that sibling calls are performed from a + void non-leaf-function taking one int argument calling a function which + is about the same as itself. + + Copyright (C) 2002 Free Software Foundation Inc. + Contributed by Hans-Peter Nilsson */ + +/* { dg-do run { xfail arc-*-* avr-*-* c4x-*-* cris-*-* h8300-*-* hppa*64*-*-* m32r-*-* m68hc1?-*-* mcore-*-* mn10300-*-* xstormy16-*-* v850*-*-* vax-*-* xtensa-*-* } } */ +/* -mlongcall disables sibcall patterns. */ +/* { dg-skip-if "" { powerpc*-*-* } { "-mlongcall" } { "" } } */ +/* { dg-options "-O2 -foptimize-sibling-calls" } */ + +/* The option -foptimize-sibling-calls is the default, but serves as + marker. This test is xfailed on targets without sibcall patterns + (except targets where the test does not work due to the return address + not saved on the regular stack). */ + +extern void abort (void); +extern void exit (int); + +/* Sibcalls are not supported in MIPS16 mode, which has direct calls but + not direct jumps. */ +#ifdef __mips +#define ATTR __attribute__((nomips16)) +#else +#define ATTR +#endif + +static ATTR void recurser_void1 (int); +static ATTR void recurser_void2 (int); +extern void track (int); + +int main () +{ + recurser_void1 (0); + exit (0); +} + +/* The functions should get the same stack-frame, and best way to make it + reasonably sure is to make them have the same contents (regarding the + n tests). */ + +static void __attribute__((noinline)) ATTR +recurser_void1 (int n) +{ + if (n == 0 || n == 7 || n == 8) + track (n); + + if (n == 10) + return; + + recurser_void2 (n + 1); +} + +static void __attribute__((noinline)) ATTR +recurser_void2 (int n) +{ + if (n == 0 || n == 7 || n == 8) + track (n); + + if (n == 10) + return; + + recurser_void1 (n + 1); +} + +void *trackpoint; + +void +track (int n) +{ + char stackpos[1]; + + if (n == 0) + trackpoint = stackpos; + else if ((n != 7 && n != 8) || trackpoint != stackpos) + abort (); +} diff --git a/test/not_applicable/dg/sibcall-4.c b/test/not_applicable/dg/sibcall-4.c new file mode 100644 index 0000000..c852c8a --- /dev/null +++ b/test/not_applicable/dg/sibcall-4.c @@ -0,0 +1,79 @@ +/* Simple check that sibling calls are performed from a + void non-leaf-function taking no arguments calling a function which + is about the same as itself. + + Copyright (C) 2002 Free Software Foundation Inc. + Contributed by Hans-Peter Nilsson */ + +/* { dg-do run { xfail arc-*-* avr-*-* c4x-*-* cris-*-* h8300-*-* hppa*64*-*-* m32r-*-* m68hc1?-*-* mcore-*-* mn10300-*-* xstormy16-*-* v850*-*-* vax-*-* xtensa-*-* } } */ +/* -mlongcall disables sibcall patterns. */ +/* { dg-skip-if "" { powerpc*-*-* } { "-mlongcall" } { "" } } */ +/* { dg-options "-O2 -foptimize-sibling-calls" } */ + +/* The option -foptimize-sibling-calls is the default, but serves as + marker. This test is xfailed on targets without sibcall patterns + (except targets where the test does not work due to the return address + not saved on the regular stack). */ + +extern void abort (void); +extern void exit (int); + +/* Sibcalls are not supported in MIPS16 mode, which has direct calls but + not direct jumps. */ +#ifdef __mips +#define ATTR __attribute__((nomips16)) +#else +#define ATTR +#endif + +static ATTR void recurser_void1 (void); +static ATTR void recurser_void2 (void); +extern void track (void); + +int n = 0; +int main () +{ + recurser_void1 (); + exit (0); +} + +/* The functions should get the same stack-frame, and best way to make it + reasonably sure is to make them have the same contents (regarding the + n tests). */ + +static void __attribute__((noinline)) ATTR +recurser_void1 (void) +{ + if (n == 0 || n == 7 || n == 8) + track (); + + if (n == 10) + return; + n++; + recurser_void2 (); +} + +static void __attribute__((noinline)) ATTR +recurser_void2 (void) +{ + if (n == 0 || n == 7 || n == 8) + track (); + + if (n == 10) + return; + n++; + recurser_void1 (); +} + +void *trackpoint; + +void +track () +{ + char stackpos[1]; + + if (n == 0) + trackpoint = stackpos; + else if ((n != 7 && n != 8) || trackpoint != stackpos) + abort (); +} diff --git a/test/not_applicable/dg/sibcall-6.c b/test/not_applicable/dg/sibcall-6.c new file mode 100644 index 0000000..f57f9c4 --- /dev/null +++ b/test/not_applicable/dg/sibcall-6.c @@ -0,0 +1,46 @@ +/* A simple check to see whether indirect calls are + being sibcall optimized on targets that do support + this notion, i.e. have the according call patterns + in place. + + Copyright (C) 2002 Free Software Foundation Inc. + Contributed by Andreas Bauer */ + +/* { dg-do run { target i?86-*-* x86_64-*-* s390*-*-* } } */ +/* { dg-skip-if "" { { i?86-*-* x86_64-*-* } && { ilp32 && fpic } } { "*" } { "" } } */ +/* { dg-options "-O2 -foptimize-sibling-calls" } */ + +extern void abort (void); +extern void exit (int); + +int foo (int); +int bar (int); + +int (*ptr) (int); +int *f_addr; + +int +main () +{ + ptr = bar; + foo (7); + exit (0); +} + +int +bar (b) + int b; +{ + if (f_addr == (int*) __builtin_return_address (0)) + return b; + else + abort (); +} + +int +foo (f) + int f; +{ + f_addr = (int*) __builtin_return_address (0); + return (*ptr)(f); +} diff --git a/test/not_applicable/dg/ssp-1.c b/test/not_applicable/dg/ssp-1.c new file mode 100644 index 0000000..e71522b --- /dev/null +++ b/test/not_applicable/dg/ssp-1.c @@ -0,0 +1,23 @@ +/* { dg-do run { target native } } */ +/* { dg-options "-fstack-protector" } */ +/* { dg-require-effective-target fstack_protector } */ + +#include + +static void +__stack_chk_fail (void) +{ + exit (0); /* pass */ +} + +int main () +{ + int i; + char foo[255]; + + // smash stack + for (i = 0; i <= 400; i++) + foo[i] = 42; + + return 1; /* fail */ +} diff --git a/test/not_applicable/dg/ssp-2.c b/test/not_applicable/dg/ssp-2.c new file mode 100644 index 0000000..493f3c9 --- /dev/null +++ b/test/not_applicable/dg/ssp-2.c @@ -0,0 +1,28 @@ +/* { dg-do run { target native } } */ +/* { dg-options "-fstack-protector" } */ +/* { dg-require-effective-target fstack_protector } */ + +#include + +void +__stack_chk_fail (void) +{ + exit (0); /* pass */ +} + +void +overflow() +{ + int i = 0; + char foo[30]; + + /* Overflow buffer. */ + for (i = 0; i < 50; i++) + foo[i] = 42; +} + +int main (void) +{ + overflow (); + return 1; /* fail */ +} diff --git a/test/not_applicable/dg/sync-2.c b/test/not_applicable/dg/sync-2.c new file mode 100644 index 0000000..9849a70 --- /dev/null +++ b/test/not_applicable/dg/sync-2.c @@ -0,0 +1,105 @@ +/* { dg-do run } */ +/* { dg-require-effective-target sync_char_short } */ +/* { dg-options "-march=i486" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */ +/* { dg-options "-mcpu=v9" { target sparc*-*-* } } */ + +/* Test functionality of the intrinsics for 'short' and 'char'. */ + +extern void abort (void); +extern void *memcpy (void *, const void *, __SIZE_TYPE__); + +#ifndef AI_ALIGN +#define AI_ALIGN +#endif + +static char AI[18] AI_ALIGN; +static char init_qi[18] = { 3,5,7,9,0,0,0,0,-1,0,0,0,0,0,-1,0,0,0 }; +static char test_qi[18] = { 3,5,7,9,1,4,22,-12,7,8,9,7,1,-12,7,8,9,7 }; + +static void +do_qi (void) +{ + if (__sync_fetch_and_add(AI+4, 1) != 0) + abort (); + if (__sync_fetch_and_add(AI+5, 4) != 0) + abort (); + if (__sync_fetch_and_add(AI+6, 22) != 0) + abort (); + if (__sync_fetch_and_sub(AI+7, 12) != 0) + abort (); + if (__sync_fetch_and_and(AI+8, 7) != (char)-1) + abort (); + if (__sync_fetch_and_or(AI+9, 8) != 0) + abort (); + if (__sync_fetch_and_xor(AI+10, 9) != 0) + abort (); + if (__sync_fetch_and_nand(AI+11, 7) != 0) + abort (); + + if (__sync_add_and_fetch(AI+12, 1) != 1) + abort (); + if (__sync_sub_and_fetch(AI+13, 12) != (char)-12) + abort (); + if (__sync_and_and_fetch(AI+14, 7) != 7) + abort (); + if (__sync_or_and_fetch(AI+15, 8) != 8) + abort (); + if (__sync_xor_and_fetch(AI+16, 9) != 9) + abort (); + if (__sync_nand_and_fetch(AI+17, 7) != 7) + abort (); +} + +static short AL[18]; +static short init_hi[18] = { 3,5,7,9,0,0,0,0,-1,0,0,0,0,0,-1,0,0,0 }; +static short test_hi[18] = { 3,5,7,9,1,4,22,-12,7,8,9,7,1,-12,7,8,9,7 }; + +static void +do_hi (void) +{ + if (__sync_fetch_and_add(AL+4, 1) != 0) + abort (); + if (__sync_fetch_and_add(AL+5, 4) != 0) + abort (); + if (__sync_fetch_and_add(AL+6, 22) != 0) + abort (); + if (__sync_fetch_and_sub(AL+7, 12) != 0) + abort (); + if (__sync_fetch_and_and(AL+8, 7) != -1) + abort (); + if (__sync_fetch_and_or(AL+9, 8) != 0) + abort (); + if (__sync_fetch_and_xor(AL+10, 9) != 0) + abort (); + if (__sync_fetch_and_nand(AL+11, 7) != 0) + abort (); + + if (__sync_add_and_fetch(AL+12, 1) != 1) + abort (); + if (__sync_sub_and_fetch(AL+13, 12) != -12) + abort (); + if (__sync_and_and_fetch(AL+14, 7) != 7) + abort (); + if (__sync_or_and_fetch(AL+15, 8) != 8) + abort (); + if (__sync_xor_and_fetch(AL+16, 9) != 9) + abort (); + if (__sync_nand_and_fetch(AL+17, 7) != 7) + abort (); +} + +int main() +{ + memcpy(AI, init_qi, sizeof(init_qi)); + memcpy(AL, init_hi, sizeof(init_hi)); + + do_qi (); + do_hi (); + + if (memcmp (AI, test_qi, sizeof(test_qi))) + abort (); + if (memcmp (AL, test_hi, sizeof(test_hi))) + abort (); + + return 0; +} diff --git a/test/not_applicable/dg/sync-3.c b/test/not_applicable/dg/sync-3.c new file mode 100644 index 0000000..bf8abb7 --- /dev/null +++ b/test/not_applicable/dg/sync-3.c @@ -0,0 +1,10 @@ +/* { dg-do run } */ +/* { dg-require-effective-target sync_char_short } */ +/* { dg-options "-O2" } */ +/* { dg-options "-march=i486 -O2" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */ +/* { dg-options "-mcpu=v9 -O2" { target sparc*-*-* } } */ + +/* Test functionality of the intrinsics for 'short' and 'char'. */ + +#define AI_ALIGN __attribute__((__aligned__ (4))) +#include "sync-2.c" diff --git a/test/not_applicable/dg/unix/20030711-1.c b/test/not_applicable/dg/unix/20030711-1.c new file mode 100644 index 0000000..e76f54f --- /dev/null +++ b/test/not_applicable/dg/unix/20030711-1.c @@ -0,0 +1,30 @@ +/* Test whether strncmp has not been "optimized" into memcmp + nor any code with memcmp semantics. */ +/* { dg-do run { target i?86-*-linux* x86_64-*-linux* ia64-*-linux* alpha*-*-linux* powerpc*-*-linux* s390*-*-linux* sparc*-*-linux* *-*-darwin* } } */ +/* { dg-options "-O2" } */ +#include +#include +#include +#ifndef MAP_ANONYMOUS +#define MAP_ANONYMOUS MAP_ANON +#endif +#include + +void __attribute__((noinline)) test (const char *p) +{ + if (__builtin_strncmp (p, "abcdefghijklmnopq", 17) == 0) + abort (); +} + +int main (void) +{ + char *p = mmap (NULL, 131072, PROT_READ | PROT_WRITE, + MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); + if (p == MAP_FAILED) + return 0; + if (munmap (p + 65536, 65536) < 0) + return 0; + __builtin_memcpy (p + 65536 - 5, "abcd", 5); + test (p + 65536 - 5); + return 0; +} diff --git a/test/not_applicable/dg/unix/20041106-1.c b/test/not_applicable/dg/unix/20041106-1.c new file mode 100644 index 0000000..f83e835 --- /dev/null +++ b/test/not_applicable/dg/unix/20041106-1.c @@ -0,0 +1,31 @@ +/* { dg-do run { target *-*-linux* *-*-solaris* } } */ +/* { dg-options -O2 } */ + +#include +#include +#include +#include + +struct S { long x __attribute__((packed)); }; /* { dg-warning "attribute ignored" "" { target default_packed } } */ +volatile long sink; + +void foo (struct S *s) +{ + sink = s->x; +} + +int main () +{ + size_t ps = getpagesize (); + char *ptr, *page; + struct S *s; + + ptr = malloc (3*ps); + page = (char *)(((size_t)ptr + (ps - 1)) & -ps); + munmap (page + ps, ps); + + s = (struct S *)(page + ps - sizeof(struct S)); + foo(s); + + return 0; +} diff --git a/test/not_applicable/dg/var-expand3.c b/test/not_applicable/dg/var-expand3.c new file mode 100644 index 0000000..6ccf59e --- /dev/null +++ b/test/not_applicable/dg/var-expand3.c @@ -0,0 +1,58 @@ +/* { dg-do run { target { powerpc*-*-* && powerpc_altivec_ok } } }} */ +/* { dg-options "-O2 -funroll-loops -ffast-math -fvariable-expansion-in-unroller -maltivec -dL" } */ + +#include "altivec.h" +extern void abort (void); +extern void exit (int); + +#define N 256 + +float in1[N] __attribute__ ((__aligned__ (16))) = {0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48, 51, 54, 57}; +float in2[N] __attribute__ ((__aligned__ (16))) = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19}; + +float +foo (int n) +{ + unsigned i; + vector float vp1, vp2, vp3, vaccum, vzero, vtmp; + float accum = 1.0; + + vzero = (vector float){0, 0, 0, 0}; + + vaccum = vzero; + + for (i = 0; i < n; i++) + { + vp1 = vec_ld (i * 16, in1); + vp2 = vec_ld (i * 16, in2); + + vaccum = vec_madd (vp1, vp2, vaccum); + + } + vtmp = vec_sld (vaccum, vaccum, 8); + vp1 = vec_add (vaccum, vtmp); + vtmp = vec_sld (vp1, vp1, 4); + vp2 = vec_add (vp1, vtmp); + + vec_ste (vp2, 0, &accum); + if (accum != 1518) + return 0; + + return accum; +} + +int +main (void) +{ + if (!foo (3)) + abort (); + + exit (0); +} + +/* { dg-final { scan-rtl-dump "Expanding Accumulator" "loop2_unroll" } } */ +/* { dg-final { cleanup-rtl-dump "loop*" } } */ + + + + diff --git a/test/not_applicable/eeprof-1.c b/test/not_applicable/eeprof-1.c new file mode 100644 index 0000000..248b8cc --- /dev/null +++ b/test/not_applicable/eeprof-1.c @@ -0,0 +1,73 @@ +#define ASSERT(X) if (!(X)) abort (); +#define NOCHK __attribute__ ((no_instrument_function)) + +int entry_calls, exit_calls; +void (*last_fn_entered)(); +void (*last_fn_exited)(); + +__attribute__ ((noinline)) +int main () NOCHK; + +__attribute__ ((noinline)) +void foo () +{ + ASSERT (last_fn_entered == foo); +} + +__attribute__ ((noinline)) +static void foo2 () +{ + ASSERT (entry_calls == 1 && exit_calls == 0); + ASSERT (last_fn_entered == foo2); + foo (); + ASSERT (entry_calls == 2 && exit_calls == 1); + ASSERT (last_fn_entered == foo); + ASSERT (last_fn_exited == foo); +} + +__attribute__ ((noinline)) +void nfoo (void) NOCHK; +void nfoo () +{ + ASSERT (entry_calls == 2 && exit_calls == 2); + ASSERT (last_fn_entered == foo); + ASSERT (last_fn_exited == foo2); + foo (); + ASSERT (entry_calls == 3 && exit_calls == 3); + ASSERT (last_fn_entered == foo); + ASSERT (last_fn_exited == foo); +} + +int main () +{ + ASSERT (entry_calls == 0 && exit_calls == 0); + + foo2 (); + + ASSERT (entry_calls == 2 && exit_calls == 2); + ASSERT (last_fn_entered == foo); + ASSERT (last_fn_exited == foo2); + + nfoo (); + + ASSERT (entry_calls == 3 && exit_calls == 3); + ASSERT (last_fn_entered == foo); + + return 0; +} + +void __cyg_profile_func_enter (void (*fn)(), void (*parent)()) NOCHK; +void __cyg_profile_func_exit (void (*fn)(), void (*parent)()) NOCHK; + +__attribute__ ((noinline)) +void __cyg_profile_func_enter (void (*fn)(), void (*parent)()) +{ + entry_calls++; + last_fn_entered = fn; +} +__attribute__ ((noinline)) +void __cyg_profile_func_exit (void (*fn)(), void (*parent)()) +{ + exit_calls++; + last_fn_exited = fn; +} diff --git a/test/not_applicable/mode-dependent-address.c b/test/not_applicable/mode-dependent-address.c new file mode 100644 index 0000000..5bf840c --- /dev/null +++ b/test/not_applicable/mode-dependent-address.c @@ -0,0 +1,49 @@ +#include +#include +#include + +void f883b (int8_t * result, + int16_t * __restrict arg1, + uint32_t * __restrict arg2, + uint64_t * __restrict arg3, + uint8_t * __restrict arg4) +{ + int idx; + for (idx=0;idx<96;idx += 1) { + result[idx] = (((((((((((-27 + 2+1)>>1) || arg4[idx]) < arg1[idx]) + ? (((-27 + 2+1)>>1) || arg4[idx]) + : arg1[idx]) + >> (arg2[idx] & 31)) ^ 1) - -32)>>7) | -5) & arg3[idx]); + } +} + +int8_t result[96]; +int16_t arg1[96]; +uint32_t arg2[96]; +uint64_t arg3[96]; +uint8_t arg4[96]; + +int main (void) +{ + int i; + int correct[] = {0x0,0x1,0x2,0x3,0x0,0x1,0x2,0x3,0x8,0x9,0xa,0xb,0x8,0x9, + 0xa,0xb,0x10,0x11,0x12,0x13,0x10,0x11,0x12,0x13, + 0x18,0x19,0x1a,0x1b,0x18,0x19,0x1a,0x1b,0x20,0x21,0x22, + 0x23,0x20,0x21,0x22,0x23,0x28,0x29,0x2a, + 0x2b,0x28,0x29,0x2a,0x2b,0x30,0x31,0x32,0x33, + 0x30,0x31,0x32,0x33,0x38,0x39,0x3a,0x3b,0x38,0x39,0x3a, + 0x3b,0x40,0x41,0x42,0x43,0x40,0x41,0x42,0x43,0x48,0x49, + 0x4a,0x4b,0x48,0x49,0x4a,0x4b,0x50,0x51, + 0x52,0x53,0x50,0x51,0x52,0x53,0x58,0x59,0x5a,0x5b, + 0x58,0x59,0x5a,0x5b}; + + for (i=0; i < 96; i++) + arg3[i] = arg2[i] = arg1[i] = arg4[i] = i; + + f883b(result, arg1, arg2, arg3, arg4); + + for (i=0; i < 96; i++) + if (result[i] != correct[i]) abort(); + + return 0; +} diff --git a/test/secondary/20030717-1.c b/test/secondary/20030717-1.c new file mode 100644 index 0000000..6a7f6de --- /dev/null +++ b/test/secondary/20030717-1.c @@ -0,0 +1,24 @@ +/* { dg-do run } */ +/* { dg-options "-O2" } */ + +extern void abort (void); + +int zero (void) +{ + return 0; +} + +int one (void) +{ + return 1; +} + +int main (void) +{ + int i = 1; + int r = (i ? one : zero)(); + if (r != 1) + abort(); + return 0; +} + diff --git a/test/secondary/bf-sign-2.c b/test/secondary/bf-sign-2.c new file mode 100644 index 0000000..acdfc0b --- /dev/null +++ b/test/secondary/bf-sign-2.c @@ -0,0 +1,68 @@ +/* + This test checks promotion of bitfields. Bitfields should be promoted + very much like chars and shorts: + + Bitfields (signed or unsigned) should be promoted to signed int if their + value will fit in a signed int, otherwise to an unsigned int if their + value will fit in an unsigned int, otherwise we don't promote them (ANSI/ISO + does not specify the behavior of bitfields larger than an unsigned int). + + We test the behavior by subtracting two from the promoted value: this will + result in a negitive value for signed types, a positive value for unsigned + types. This test (of course) assumes that the compiler is correctly + implementing signed and unsigned arithmetic. + */ + +struct X { + unsigned int u3:3; + signed long int s31:15; + signed long int s32:16; + unsigned long int u31:15; + unsigned long int u32:16; +// unsigned long long ull3 :3; +// unsigned long long ull35:21; + unsigned u15:15; +}; + +struct X x; + +main () +{ + if ((x.u3 - 2) >= 0) /* promoted value should be signed */ + abort (); + +#if 0 + if ((x.s31 - 2) >= 0) /* promoted value should be signed */ + abort (); + + if ((x.s32 - 2) >= 0) /* promoted value should be signed */ + abort (); + + if ((x.u15 - 2) >= 0) /* promoted value should be signed */ + abort (); + + /* Conditionalize check on whether integers are 4 bytes or larger, i.e. + larger than a 31 bit bitfield. */ + if (sizeof (int) >= 4) + { + if ((x.u31 - 2) >= 0) /* promoted value should be signed */ + abort (); + } + else + { + if ((x.u31 - 2) < 0) /* promoted value should be UNsigned */ + abort (); + } + + if ((x.u32 - 2) < 0) /* promoted value should be UNsigned */ + abort (); + + if ((x.ull3 - 2) >= 0) /* promoted value should be signed */ + abort (); + + if ((x.ull35 - 2) < 0) /* promoted value should be UNsigned */ + abort (); +#endif + + exit (0); +} diff --git a/test/secondary/builtin-types-compatible-p.c b/test/secondary/builtin-types-compatible-p.c new file mode 100644 index 0000000..a998ef7 --- /dev/null +++ b/test/secondary/builtin-types-compatible-p.c @@ -0,0 +1,35 @@ +int i; +double d; + +/* Make sure we return a constant. */ +float rootbeer[__builtin_types_compatible_p (int, typeof(i))]; + +typedef enum { hot, dog, poo, bear } dingos; +typedef enum { janette, laura, amanda } cranberry; + +typedef float same1; +typedef float same2; + +int main (void); + +int main (void) +{ + /* Compatible types. */ + if (!(__builtin_types_compatible_p (int, const int) + && __builtin_types_compatible_p (typeof (hot), int) + && __builtin_types_compatible_p (typeof (hot), typeof (laura)) + && __builtin_types_compatible_p (int[5], int[]) + && __builtin_types_compatible_p (same1, same2))) + abort (); + + /* Incompatible types. */ + if (__builtin_types_compatible_p (char *, int) + || __builtin_types_compatible_p (char *, const char *) + || __builtin_types_compatible_p (long double, double) + || __builtin_types_compatible_p (typeof (i), typeof (d)) + || __builtin_types_compatible_p (typeof (dingos), typeof (cranberry)) + || __builtin_types_compatible_p (char, int) + || __builtin_types_compatible_p (char *, char **)) + abort (); + exit (0); +} diff --git a/test/secondary/cmpdi-1.c b/test/secondary/cmpdi-1.c new file mode 100644 index 0000000..e3e9c86 --- /dev/null +++ b/test/secondary/cmpdi-1.c @@ -0,0 +1,218 @@ +#define F 140 +#define T 13 + +feq (x, y) + long long int x; + long long int y; +{ + if (x == y) + return T; + else + return F; +} + +fne (x, y) + long long int x; + long long int y; +{ + if (x != y) + return T; + else + return F; +} + +flt (x, y) + long long int x; + long long int y; +{ + if (x < y) + return T; + else + return F; +} + +fge (x, y) + long long int x; + long long int y; +{ + if (x >= y) + return T; + else + return F; +} + +fgt (x, y) + long long int x; + long long int y; +{ + if (x > y) + return T; + else + return F; +} + +fle (x, y) + long long int x; + long long int y; +{ + if (x <= y) + return T; + else + return F; +} + +fltu (x, y) + unsigned long long int x; + unsigned long long int y; +{ + if (x < y) + return T; + else + return F; +} + +fgeu (x, y) + unsigned long long int x; + unsigned long long int y; +{ + if (x >= y) + return T; + else + return F; +} + +fgtu (x, y) + unsigned long long int x; + unsigned long long int y; +{ + if (x > y) + return T; + else + return F; +} + +fleu (x, y) + unsigned long long int x; + unsigned long long int y; +{ + if (x <= y) + return T; + else + return F; +} + +long long args[] = +{ + 0LL, + 1LL, + -1LL, + 0x7fffffffffffffffLL, + 0x8000000000000000LL, + 0x8000000000000001LL, + 0x1A3F237394D36C58LL, + 0x93850E92CAAC1B04LL +}; + +int correct_results[] = +{ + T, F, F, T, F, T, F, T, F, T, + F, T, T, F, F, T, T, F, F, T, + F, T, F, T, T, F, T, F, F, T, + F, T, T, F, F, T, T, F, F, T, + F, T, F, T, T, F, T, F, F, T, + F, T, F, T, T, F, T, F, F, T, + F, T, T, F, F, T, T, F, F, T, + F, T, F, T, T, F, T, F, F, T, + F, T, F, T, T, F, F, T, T, F, + T, F, F, T, F, T, F, T, F, T, + F, T, F, T, T, F, T, F, F, T, + F, T, T, F, F, T, T, F, F, T, + F, T, F, T, T, F, T, F, F, T, + F, T, F, T, T, F, T, F, F, T, + F, T, T, F, F, T, T, F, F, T, + F, T, F, T, T, F, T, F, F, T, + F, T, T, F, F, T, F, T, T, F, + F, T, T, F, F, T, F, T, T, F, + T, F, F, T, F, T, F, T, F, T, + F, T, T, F, F, T, F, T, T, F, + F, T, F, T, T, F, F, T, T, F, + F, T, F, T, T, F, F, T, T, F, + F, T, T, F, F, T, F, T, T, F, + F, T, F, T, T, F, F, T, T, F, + F, T, F, T, T, F, F, T, T, F, + F, T, F, T, T, F, F, T, T, F, + F, T, F, T, T, F, T, F, F, T, + T, F, F, T, F, T, F, T, F, T, + F, T, F, T, T, F, T, F, F, T, + F, T, F, T, T, F, T, F, F, T, + F, T, F, T, T, F, F, T, T, F, + F, T, F, T, T, F, T, F, F, T, + F, T, T, F, F, T, F, T, T, F, + F, T, T, F, F, T, F, T, T, F, + F, T, T, F, F, T, T, F, F, T, + F, T, T, F, F, T, F, T, T, F, + T, F, F, T, F, T, F, T, F, T, + F, T, T, F, F, T, T, F, F, T, + F, T, T, F, F, T, F, T, T, F, + F, T, T, F, F, T, T, F, F, T, + F, T, T, F, F, T, F, T, T, F, + F, T, T, F, F, T, F, T, T, F, + F, T, T, F, F, T, T, F, F, T, + F, T, T, F, F, T, F, T, T, F, + F, T, F, T, T, F, F, T, T, F, + T, F, F, T, F, T, F, T, F, T, + F, T, T, F, F, T, F, T, T, F, + F, T, T, F, F, T, T, F, F, T, + F, T, F, T, T, F, F, T, T, F, + F, T, F, T, T, F, F, T, T, F, + F, T, F, T, T, F, T, F, F, T, + F, T, T, F, F, T, T, F, F, T, + F, T, F, T, T, F, T, F, F, T, + F, T, F, T, T, F, T, F, F, T, + T, F, F, T, F, T, F, T, F, T, + F, T, F, T, T, F, T, F, F, T, + F, T, T, F, F, T, F, T, T, F, + F, T, T, F, F, T, F, T, T, F, + F, T, T, F, F, T, T, F, F, T, + F, T, T, F, F, T, F, T, T, F, + F, T, F, T, T, F, F, T, T, F, + F, T, F, T, T, F, F, T, T, F, + F, T, T, F, F, T, F, T, T, F, + T, F, F, T, F, T, F, T, F, T +}; + +main () +{ + int i, j, *res = correct_results; + + for (i = 0; i < 8; i++) + { + long long arg0 = args[i]; + for (j = 0; j < 8; j++) + { + long long arg1 = args[j]; + + if (feq (arg0, arg1) != *res++) + abort (); + if (fne (arg0, arg1) != *res++) + abort (); + if (flt (arg0, arg1) != *res++) + abort (); + if (fge (arg0, arg1) != *res++) + abort (); + if (fgt (arg0, arg1) != *res++) + abort (); + if (fle (arg0, arg1) != *res++) + abort (); + if (fltu (arg0, arg1) != *res++) + abort (); + if (fgeu (arg0, arg1) != *res++) + abort (); + if (fgtu (arg0, arg1) != *res++) + abort (); + if (fleu (arg0, arg1) != *res++) + abort (); + } + } + exit (0); +} diff --git a/test/secondary/dg/c90-scope-1.c b/test/secondary/dg/c90-scope-1.c new file mode 100644 index 0000000..ad36b70 --- /dev/null +++ b/test/secondary/dg/c90-scope-1.c @@ -0,0 +1,34 @@ +/* Test for new block scopes in C99. Inspired by C99 Rationale (N897). */ +/* Origin: Joseph Myers */ +/* { dg-do run } */ +/* { dg-options "-std=iso9899:1990 -pedantic-errors" } */ + +struct foo { + char a; +}; + +extern void abort (void); +extern void exit (int); + +int +sfoo (void) +{ + if (sizeof (struct foo { int a; double b; char *c; void *d; })) + (void) 0; + return sizeof (struct foo); +} + +int +main (void) +{ + int t, u; + t = sfoo (); + u = sizeof (struct foo); + /* With C90 scoping rules the new declaration of struct foo is in scope + above; with C99 it is local to the if. + */ + if (t == u) + abort (); /* C99 rules apply. */ + else + exit (0); /* C90 rules apply. */ +} diff --git a/test/secondary/dg/c99-scope-1.c b/test/secondary/dg/c99-scope-1.c new file mode 100644 index 0000000..48ea3b0 --- /dev/null +++ b/test/secondary/dg/c99-scope-1.c @@ -0,0 +1,34 @@ +/* Test for new block scopes in C99. Inspired by C99 Rationale (N897). */ +/* Origin: Joseph Myers */ +/* { dg-do run } */ +/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */ + +struct foo { + char a; +}; + +extern void abort (void); +extern void exit (int); + +int +sfoo (void) +{ + if (sizeof (struct foo { int a; double b; char *c; void *d; })) + (void) 0; + return sizeof (struct foo); +} + +int +main (void) +{ + int t, u; + t = sfoo (); + u = sizeof (struct foo); + /* With C90 scoping rules the new declaration of struct foo is in scope + above; with C99 it is local to the if. + */ + if (t == u) + exit (0); /* C99 rules apply. */ + else + abort (); /* C90 rules apply. */ +} diff --git a/test/secondary/dg/c99-scope-2.c b/test/secondary/dg/c99-scope-2.c new file mode 100644 index 0000000..86ac272 --- /dev/null +++ b/test/secondary/dg/c99-scope-2.c @@ -0,0 +1,71 @@ +/* Test for new block scopes in C99. Test for each new scope. */ +/* Origin: Joseph Myers */ +/* { dg-do run } */ +/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */ + +extern void abort (void); +extern void exit (int); + +int +main (void) +{ + struct foo { int i0; }; + int a, b, c, d; + a = sizeof (struct foo); + if (b = sizeof (struct foo { int i0; int i1; })) + c = sizeof (struct foo { int i0; int i1; int i2; }); + if (!(a <= b && b <= c)) + abort (); + if ((b = sizeof (struct foo { int i0; int i1; })), 0) + c = sizeof (struct foo { int i0; int i1; int i2; }); + else + d = sizeof (struct foo { int i0; int i1; int i2; int i3; }); + if (!(a <= b && b <= d)) + abort (); + switch (b = sizeof (struct foo { int i0; int i1; })) + default: + c = sizeof (struct foo { int i0; int i1; int i2; }); + if (!(a <= b && b <= c)) + abort (); + do + c = sizeof (struct foo { int i0; int i1; int i2; }); + while ((b = sizeof (struct foo { int i0; int i1; })), 0); + if (!(a <= b && b <= c)) + abort (); + d = 1; + while ((b = sizeof (struct foo { int i0; int i1; })), d) + (c = sizeof (struct foo { int i0; int i1; int i2; })), d--; + if (!(a <= b && b <= c)) + abort (); + d = 1; + for ((b = sizeof (struct foo { int i0; int i1; })); d; d--) + c = sizeof (struct foo { int i0; int i1; int i2; }); + if (!(a <= b && b <= c)) + abort (); + d = 1; + for ((b = sizeof (struct foo { int i0; int i1; })); d; d--) + c = sizeof (struct foo); + if (!(a <= b && b == c)) + abort (); + d = 1; + for (; (b = sizeof (struct foo { int i0; int i1; })), d; d--) + c = sizeof (struct foo { int i0; int i1; int i2; }); + if (!(a <= b && b <= c)) + abort (); + d = 1; + for (; (b = sizeof (struct foo { int i0; int i1; })), d; d--) + c = sizeof (struct foo); + if (!(a <= b && b == c)) + abort (); + d = 1; + for (; d; (b = sizeof (struct foo { int i0; int i1; })), d--) + c = sizeof (struct foo { int i0; int i1; int i2; }); + if (!(a <= b && b <= c)) + abort (); + d = 1; + for (; d; (b = sizeof (struct foo { int i0; int i1; })), d--) + c = sizeof (struct foo); + if (!(a <= b && b == c)) + abort (); + exit (0); +} diff --git a/test/secondary/dg/max-1.c b/test/secondary/dg/max-1.c new file mode 100644 index 0000000..a3de3e0 --- /dev/null +++ b/test/secondary/dg/max-1.c @@ -0,0 +1,42 @@ +// long is smaller than a pointer, and long long <-> pointer conversion is not implemented + +/* PR middle-end/18548 */ +/* Test case reduced by Andrew Pinski */ +/* { dg-do run } */ +/* { dg-options "-O1 " } */ +/* Option -fno-tree-lrs removed By Andrew MacLeod since it is no longer + supported in the compiler beginning with GCC 4.3. */ +/* m32c has varying sized pointers */ +/* { dg-skip-if "" { "m32c-*-*" } { "*" } { "-mcpu=m32c" "-mcpu=m32cm" } } */ + +extern void abort (void); + +long fff[10]; + +void f(long a, long b) +{ + long crcc = b; + long d = *((long*)(a+1)); + int i; + + a = d >= b? d:b; + + + for(i=0;i<10;i++) + fff[i] = a; +} + +/* The variable a cannot be a local variable as we get better aliasing + now and decide that the store to a is dead. The better aliasing comes + from better representation of pointer arithmetic. */ +long a = 10; +int main(void) +{ + int i; + f((long)(&a)-1,0); + for(i = 0;i<10;i++) + if (fff[i]!=10) + abort (); + return 0; +} + diff --git a/test/secondary/dg/pr25805.c b/test/secondary/dg/pr25805.c new file mode 100644 index 0000000..71182c5 --- /dev/null +++ b/test/secondary/dg/pr25805.c @@ -0,0 +1,20 @@ +/* When -fzero-initialized-in-bss was in effect, we used to only allocate + storage for d1.a. */ +/* { dg-do run } */ +/* { dg-options "" } */ +extern void abort (void); +extern void exit (int); + +struct { int a; int x[]; } d1 = { 0, 0 }; +int d2 = 0; + +int +main () +{ + d2 = 1; + if (sizeof (d1) != sizeof (int)) + abort (); + if (d1.x[0] != 0) + abort (); + exit (0); +} diff --git a/test/secondary/dg/pr26427.c b/test/secondary/dg/pr26427.c new file mode 100644 index 0000000..3077221 --- /dev/null +++ b/test/secondary/dg/pr26427.c @@ -0,0 +1,24 @@ +/* { dg-warning "this target does not support" } */ +/* { dg-do run { target { *-*-darwin* } } } */ +/* { dg-options { -fsection-anchors -O } } */ +/* PR target/26427 */ + +struct a {}; +static const int d = 1; +static const struct a b = {}; +static const int c = 1; +int f(const int *, const struct a *, const int*, const int*); + +int g(void) { + return f(&c, &b, &d, &c); +} + +int f(const int *b, const struct a *c, const int *d, const int *e) { + return *b == *d; +} + +int main(void) { + if (!g()) + __builtin_abort(); + return 0; +} diff --git a/test/secondary/pr22098-1.c b/test/secondary/pr22098-1.c new file mode 100644 index 0000000..142530f --- /dev/null +++ b/test/secondary/pr22098-1.c @@ -0,0 +1,14 @@ +extern void abort (void); +extern void exit (int); +typedef __SIZE_TYPE__ size_t; +int +main (void) +{ + int a = 0; + int *p; + size_t b; + b = (size_t)(p = &(int []){0, 1, 2}[++a]); + if (a != 1 || *p != 1 || *(int *)b != 1) + abort (); + exit (0); +} diff --git a/test/secondary/pr22098-2.c b/test/secondary/pr22098-2.c new file mode 100644 index 0000000..249647d --- /dev/null +++ b/test/secondary/pr22098-2.c @@ -0,0 +1,14 @@ +extern void abort (void); +extern void exit (int); +typedef __SIZE_TYPE__ size_t; +int +main (void) +{ + int a = 0; + int *p; + size_t b; + b = (size_t)(p = &(int []){0, 1, 2}[1]); + if (*p != 1 || *(int *)b != 1) + abort (); + exit (0); +} diff --git a/test/secondary/pr22098-3.c b/test/secondary/pr22098-3.c new file mode 100644 index 0000000..4c8a1c6 --- /dev/null +++ b/test/secondary/pr22098-3.c @@ -0,0 +1,16 @@ +extern void abort (void); +extern void exit (int); +typedef __SIZE_TYPE__ size_t; +int n = 0; +int f (void) { return ++n; } +int +main (void) +{ + int a = 0; + int *p; + size_t b; + b = (size_t)(p = &(int []){0, f(), 2}[1]); + if (*p != 1 || *(int *)b != 1 || n != 1) + abort (); + exit (0); +} diff --git a/test/secondary/pr24135.c b/test/secondary/pr24135.c new file mode 100644 index 0000000..f099604 --- /dev/null +++ b/test/secondary/pr24135.c @@ -0,0 +1,45 @@ +#ifndef NO_TRAMPOLINES +extern void abort (void); + +int x(int a, int b) +{ + __label__ xlab; + __label__ xlab2; // TCC barfs here for some reason (commenting this out makes the test work) + + a = a + 2; +// void y(int b) +// { + switch (b) + { + case 1: goto xlab; + case 2: goto xlab; + } +// } +// y (b); + + xlab: + return a; + + xlab2: + a++; + return a; + +} + +int main () +{ + int i, j; + + for (j = 1; j <= 2; ++j) + for (i = 1; i <= 2; ++i) + { + int a = x (j, i); + if (a != 2 + j) + abort (); + } + + return 0; +} +#else +int main() { return 0; } +#endif diff --git a/test/secondary/pr28289.c b/test/secondary/pr28289.c new file mode 100644 index 0000000..39767be --- /dev/null +++ b/test/secondary/pr28289.c @@ -0,0 +1,34 @@ +extern int ok (int); +extern void exit (); +static int gen_x86_64_shrd (int); +static int +gen_x86_64_shrd(int a __attribute__ ((__unused__))) +{ + return 0; +} + +extern int gen_x86_shrd_1 (int); +extern void ix86_split_ashr (int); + +void +ix86_split_ashr (int mode) +{ + // looks like TCC doesn't get "(ok)(0)" + (mode != 0 + ? ok + : gen_x86_64_shrd) (0); +} + +volatile int one = 1; +int +main (void) +{ + ix86_split_ashr (one); + return 1; +} + +int +ok (int i) +{ + exit (i); +} diff --git a/test/secondary/scope-1.c b/test/secondary/scope-1.c new file mode 100644 index 0000000..a2914a2 --- /dev/null +++ b/test/secondary/scope-1.c @@ -0,0 +1,17 @@ +int v = 3; + +f () +{ + int v = 4; + { + extern int v; + if (v != 3) + exit (v); + } +} + +main () +{ + f (); + exit (0); +} diff --git a/test/secondary/zero-struct-2.c b/test/secondary/zero-struct-2.c new file mode 100644 index 0000000..ed1d5a0 --- /dev/null +++ b/test/secondary/zero-struct-2.c @@ -0,0 +1,20 @@ +void abort (void); +int ii; +typedef struct {} raw_spinlock_t; +typedef struct { + raw_spinlock_t raw_lock; +} spinlock_t; +raw_spinlock_t one_raw_spinlock (void) +{ + raw_spinlock_t raw_lock; + ii++; + return raw_lock; +} +int main(void) +{ + spinlock_t lock = (spinlock_t) { .raw_lock = one_raw_spinlock() }; + if (ii != 1) + abort (); + return 0; +} + diff --git a/test/strange/921215-1.c b/test/strange/921215-1.c new file mode 100644 index 0000000..56a79ae --- /dev/null +++ b/test/strange/921215-1.c @@ -0,0 +1,24 @@ + void p(void ((*f) (void ()))) + { + void r() + { + foo (); + } + + f(r); + } + + void q(void ((*f)())) + { + f(); + } +main() +{ +#ifndef NO_TRAMPOLINES + + p(q); +#endif + exit(0); +} + +foo(){} diff --git a/test/strange/970217-1.c b/test/strange/970217-1.c new file mode 100644 index 0000000..09e716a --- /dev/null +++ b/test/strange/970217-1.c @@ -0,0 +1,10 @@ +sub (int i, int array[i++]) +{ + return i; +} + +main() +{ + int array[10]; + exit (sub (10, array) != 11); +} diff --git a/test/strange/builtin-bitops-1.c b/test/strange/builtin-bitops-1.c new file mode 100644 index 0000000..31dab56 --- /dev/null +++ b/test/strange/builtin-bitops-1.c @@ -0,0 +1,270 @@ +#include +//#include + +#if 0 +#if __INT_MAX__ > 2147483647L +# if __INT_MAX__ >= 9223372036854775807L +# define BITSIZEOF_INT 64 +# else +# define BITSIZEOF_INT 32 +# endif +#else +# if __INT_MAX__ >= 2147483647L +# define BITSIZEOF_INT 32 +# else +# define BITSIZEOF_INT 16 +# endif +#endif + +#if __LONG_MAX__ > 2147483647L +# if __LONG_MAX__ >= 9223372036854775807L +# define BITSIZEOF_LONG 64 +# else +# define BITSIZEOF_LONG 32 +# endif +#else +# define BITSIZEOF_LONG 32 +#endif + +#if __LONG_LONG_MAX__ > 2147483647L +# if __LONG_LONG_MAX__ >= 9223372036854775807L +# define BITSIZEOF_LONG_LONG 64 +# else +# define BITSIZEOF_LONG_LONG 32 +# endif +#else +# define BITSIZEOF_LONG_LONG 32 +#endif + +#endif + +#define BITSIZEOF_INT 16 +#define BITSIZEOF_LONG 16 +#define BITSIZEOF_LONG_LONG 32 + +#define MAKE_FUNS(suffix, type) \ +int my_ffs##suffix(type x) { \ + int i; \ + if (x == 0) \ + return 0; \ + for (i = 0; i < CHAR_BIT * sizeof (type); i++) \ + if (x & ((type) 1 << i)) \ + break; \ + return i + 1; \ +} \ + \ +int my_ctz##suffix(type x) { \ + int i; \ + for (i = 0; i < CHAR_BIT * sizeof (type); i++) \ + if (x & ((type) 1 << i)) \ + break; \ + return i; \ +} \ + \ +int my_clz##suffix(type x) { \ + int i; \ + for (i = 0; i < CHAR_BIT * sizeof (type); i++) \ + if (x & ((type) 1 << ((CHAR_BIT * sizeof (type)) - i - 1))) \ + break; \ + return i; \ +} \ + \ +int my_popcount##suffix(type x) { \ + int i; \ + int count = 0; \ + for (i = 0; i < CHAR_BIT * sizeof (type); i++) \ + if (x & ((type) 1 << i)) \ + count++; \ + return count; \ +} \ + \ +int my_parity##suffix(type x) { \ + int i; \ + int count = 0; \ + for (i = 0; i < CHAR_BIT * sizeof (type); i++) \ + if (x & ((type) 1 << i)) \ + count++; \ + return count & 1; \ +} + +MAKE_FUNS (, unsigned); +MAKE_FUNS (l, unsigned long); +MAKE_FUNS (ll, unsigned long long); + +extern void abort (void); +extern void exit (int); + +#define NUMS16 \ + { \ + 0x0000U, \ + 0x0001U, \ + 0x8000U, \ + 0x0002U, \ + 0x4000U, \ + 0x0100U, \ + 0x0080U, \ + 0xa5a5U, \ + 0x5a5aU, \ + 0xcafeU, \ + 0xffffU \ + } + +#define NUMS32 \ + { \ + 0x00000000UL, \ + 0x00000001UL, \ + 0x80000000UL, \ + 0x00000002UL, \ + 0x40000000UL, \ + 0x00010000UL, \ + 0x00008000UL, \ + 0xa5a5a5a5UL, \ + 0x5a5a5a5aUL, \ + 0xcafe0000UL, \ + 0x00cafe00UL, \ + 0x0000cafeUL, \ + 0xffffffffUL \ + } + +#define NUMS64 \ + { \ + 0x0000000000000000ULL, \ + 0x0000000000000001ULL, \ + 0x8000000000000000ULL, \ + 0x0000000000000002ULL, \ + 0x4000000000000000ULL, \ + 0x0000000100000000ULL, \ + 0x0000000080000000ULL, \ + 0xa5a5a5a5a5a5a5a5ULL, \ + 0x5a5a5a5a5a5a5a5aULL, \ + 0xcafecafe00000000ULL, \ + 0x0000cafecafe0000ULL, \ + 0x00000000cafecafeULL, \ + 0xffffffffffffffffULL \ + } + +unsigned int ints[] = +#if BITSIZEOF_INT == 64 +NUMS64; +#elif BITSIZEOF_INT == 32 +NUMS32; +#else +NUMS16; +#endif + +unsigned long longs[] = +#if BITSIZEOF_LONG == 64 +NUMS64; +#else +NUMS16; +#endif + +unsigned long long longlongs[] = +#if BITSIZEOF_LONG_LONG == 64 +NUMS64; +#else +NUMS32; +#endif + +#define N(table) (sizeof (table) / sizeof (table[0])) + +int +main (void) +{ + int i; + + for (i = 0; i < N(ints); i++) + { + if (__builtin_ffs (ints[i]) != my_ffs (ints[i])) + abort (); + if (ints[i] != 0 + && __builtin_clz (ints[i]) != my_clz (ints[i])) + abort (); + if (ints[i] != 0 + && __builtin_ctz (ints[i]) != my_ctz (ints[i])) + abort (); + if (__builtin_popcount (ints[i]) != my_popcount (ints[i])) + abort (); + if (__builtin_parity (ints[i]) != my_parity (ints[i])) + abort (); + } + + for (i = 0; i < N(longs); i++) + { + if (__builtin_ffsl (longs[i]) != my_ffsl (longs[i])) + abort (); + if (longs[i] != 0 + && __builtin_clzl (longs[i]) != my_clzl (longs[i])) + abort (); + if (longs[i] != 0 + && __builtin_ctzl (longs[i]) != my_ctzl (longs[i])) + abort (); + if (__builtin_popcountl (longs[i]) != my_popcountl (longs[i])) + abort (); + if (__builtin_parityl (longs[i]) != my_parityl (longs[i])) + abort (); + } + + for (i = 0; i < N(longlongs); i++) + { + if (__builtin_ffsll (longlongs[i]) != my_ffsll (longlongs[i])) + abort (); + if (longlongs[i] != 0 + && __builtin_clzll (longlongs[i]) != my_clzll (longlongs[i])) + abort (); + if (longlongs[i] != 0 + && __builtin_ctzll (longlongs[i]) != my_ctzll (longlongs[i])) + abort (); + if (__builtin_popcountll (longlongs[i]) != my_popcountll (longlongs[i])) + abort (); + if (__builtin_parityll (longlongs[i]) != my_parityll (longlongs[i])) + abort (); + } + + /* Test constant folding. */ + +#define TEST(x, suffix) \ + if (__builtin_ffs##suffix (x) != my_ffs##suffix (x)) \ + abort (); \ + if (x != 0 && __builtin_clz##suffix (x) != my_clz##suffix (x)) \ + abort (); \ + if (x != 0 && __builtin_ctz##suffix (x) != my_ctz##suffix (x)) \ + abort (); \ + if (__builtin_popcount##suffix (x) != my_popcount##suffix (x)) \ + abort (); \ + if (__builtin_parity##suffix (x) != my_parity##suffix (x)) \ + abort (); + +#if BITSIZEOF_INT == 32 + TEST(0x00000000UL,); + TEST(0x00000001UL,); + TEST(0x80000000UL,); + TEST(0x40000000UL,); + TEST(0x00010000UL,); + TEST(0x00008000UL,); + TEST(0xa5a5a5a5UL,); + TEST(0x5a5a5a5aUL,); + TEST(0xcafe0000UL,); + TEST(0x00cafe00UL,); + TEST(0x0000cafeUL,); + TEST(0xffffffffUL,); +#endif + +#if BITSIZEOF_LONG_LONG == 64 + TEST(0x0000000000000000ULL, ll); + TEST(0x0000000000000001ULL, ll); + TEST(0x8000000000000000ULL, ll); + TEST(0x0000000000000002ULL, ll); + TEST(0x4000000000000000ULL, ll); + TEST(0x0000000100000000ULL, ll); + TEST(0x0000000080000000ULL, ll); + TEST(0xa5a5a5a5a5a5a5a5ULL, ll); + TEST(0x5a5a5a5a5a5a5a5aULL, ll); + TEST(0xcafecafe00000000ULL, ll); + TEST(0x0000cafecafe0000ULL, ll); + TEST(0x00000000cafecafeULL, ll); + TEST(0xffffffffffffffffULL, ll); +#endif + + exit (0); +} diff --git a/test/strange/dg/transparent-union-5.c b/test/strange/dg/transparent-union-5.c new file mode 100644 index 0000000..47e245e --- /dev/null +++ b/test/strange/dg/transparent-union-5.c @@ -0,0 +1,37 @@ +/* PR 24255 */ +/* { dg-do run } */ +/* { dg-options "-O" } */ + +extern void abort (void); + +union wait { int w_status; }; + +typedef union +{ + union wait *uptr; + int *iptr; +} WAIT_STATUS __attribute__ ((__transparent_union__)); + +int status; +union wait wstatus; + +void __attribute__((noinline)) +test1 (WAIT_STATUS s) +{ + if (s.iptr != &status) + abort (); +} + +void __attribute__((noinline)) +test2 (WAIT_STATUS s) +{ + if (s.uptr != &wstatus) + abort (); +} + +int main() +{ + test1 (&status); + test2 (&wstatus); + return 0; +} diff --git a/test/tests/20000112-1.c b/test/tests/20000112-1.c new file mode 100644 index 0000000..080b662 --- /dev/null +++ b/test/tests/20000112-1.c @@ -0,0 +1,21 @@ +#include + +static int +special_format (fmt) + const char *fmt; +{ + return (strchr (fmt, '*') != 0 + || strchr (fmt, 'V') != 0 + || strchr (fmt, 'S') != 0 + || strchr (fmt, 'n') != 0); +} + +main() +{ + if (special_format ("ee")) + abort (); + if (!special_format ("*e")) + abort (); + exit (0); +} + diff --git a/test/tests/20000113-1.c b/test/tests/20000113-1.c new file mode 100644 index 0000000..95b8d4c --- /dev/null +++ b/test/tests/20000113-1.c @@ -0,0 +1,25 @@ +struct x { + unsigned x1:1; + unsigned x2:2; + unsigned x3:3; +}; + +foobar (int x, int y, int z) +{ + struct x a = {x, y, z}; + struct x b = {x, y, z}; + struct x *c = &b; + + c->x3 += (a.x2 - a.x1) * c->x2; + if(a.x1 != 1) exit(2); + if(c->x3 != 5) exit(3); + if (a.x1 != 1 || c->x3 != 5) + abort (); + exit (0); +} + +main() +{ + foobar (1, 2, 3); +} + diff --git a/test/tests/20000121-1.c b/test/tests/20000121-1.c new file mode 100644 index 0000000..71f0914 --- /dev/null +++ b/test/tests/20000121-1.c @@ -0,0 +1,14 @@ +void big(long long u) { } + +void doit(unsigned int a,unsigned int b,char *id) +{ + big(*id); + big(a); + big(b); +} + +int main(void) +{ + doit(1,1,"\n"); + return 0; +} diff --git a/test/tests/20000205-1.c b/test/tests/20000205-1.c new file mode 100644 index 0000000..b605b84 --- /dev/null +++ b/test/tests/20000205-1.c @@ -0,0 +1,17 @@ +static int f (int a) +{ + if (a == 0) + return 0; + do + if (a & 128) + return 1; + while (f (0)); + return 0; +} + +int main(void) +{ + if (f (~128)) + abort (); + exit (0); +} diff --git a/test/tests/20000217-1.c b/test/tests/20000217-1.c new file mode 100644 index 0000000..42716af --- /dev/null +++ b/test/tests/20000217-1.c @@ -0,0 +1,17 @@ +unsigned short int showbug(unsigned short int *a, unsigned short int *b) +{ + *a += *b -8; + return (*a >= 8); +} + +int main() +{ + unsigned short int x = 0; + unsigned short int y = 10; + + if (showbug(&x, &y) != 0) + abort (); + + exit (0); +} + diff --git a/test/tests/20000223-1.c b/test/tests/20000223-1.c new file mode 100644 index 0000000..db6180b --- /dev/null +++ b/test/tests/20000223-1.c @@ -0,0 +1,61 @@ +/* Copyright (C) 2000 Free Software Foundation, Inc. + Contributed by Nathan Sidwell 23 Feb 2000 */ + +/* __alignof__ should never return a non-power of 2 + eg, sizeof(long double) might be 12, but that means it must be alignable + on a 4 byte boundary. */ + +void check (char const *type, int align) +{ + if ((align & -align) != align) + { + abort (); + } +} + +#define QUOTE_(s) #s +#define QUOTE(s) QUOTE_(s) + +#define check(t) check(QUOTE(t), __alignof__(t)) + +// This struct should have an alignment of the lcm of all the types. If one of +// the base alignments is not a power of two, then A cannot be power of two +// aligned. +struct A +{ + char c; + signed short ss; + unsigned short us; + signed int si; + unsigned int ui; + signed long sl; + unsigned long ul; + signed long long sll; + unsigned long long ull; + float f; + double d; + long double ld; + void *dp; + void (*fp)(); +}; + +int main () +{ + check (void); + check (char); + check (signed short); + check (unsigned short); + check (signed int); + check (unsigned int); + check (signed long); + check (unsigned long); + check (signed long long); + check (unsigned long long); + check (float); + check (double); + check (long double); + check (void *); + check (void (*)()); + check (struct A); + return 0; +} diff --git a/test/tests/20000224-1.c b/test/tests/20000224-1.c new file mode 100644 index 0000000..295cc47 --- /dev/null +++ b/test/tests/20000224-1.c @@ -0,0 +1,28 @@ +int loop_1 = 100; +int loop_2 = 7; +int flag = 0; + +int test (void) +{ + int i; + int counter = 0; + + while (loop_1 > counter) { + if (flag & 1) { + for (i = 0; i < loop_2; i++) { + counter++; + } + } + flag++; + } + return 1; +} + +int main() +{ + if (test () != 1) + abort (); + + exit (0); +} + diff --git a/test/tests/20000225-1.c b/test/tests/20000225-1.c new file mode 100644 index 0000000..6c409bc --- /dev/null +++ b/test/tests/20000225-1.c @@ -0,0 +1,21 @@ +int main () +{ + int nResult; + int b=0; + int i = -1; + + do + { + if (b!=0) { + abort (); + nResult=1; + } else { + nResult=0; + } + i++; + b=(i+2)*4; + } while (i < 0); + exit (0); +} + + diff --git a/test/tests/20000227-1.c b/test/tests/20000227-1.c new file mode 100644 index 0000000..395a02c --- /dev/null +++ b/test/tests/20000227-1.c @@ -0,0 +1,15 @@ +static const unsigned char f[] = "\0\377"; +static const unsigned char g[] = "\0ÿ"; + +int main(void) +{ + if (sizeof f != 3 || sizeof g != 3) + abort (); + if (f[0] != g[0]) + abort (); + if (f[1] != g[1]) + abort (); + if (f[2] != g[2]) + abort (); + return 0; +} diff --git a/test/tests/20000313-1.c b/test/tests/20000313-1.c new file mode 100644 index 0000000..5c9a556 --- /dev/null +++ b/test/tests/20000313-1.c @@ -0,0 +1,20 @@ +unsigned int buggy (unsigned int *param) +{ + unsigned int accu, zero = 0, borrow; + accu = - *param; + borrow = - (accu > zero); + *param += accu; + return borrow; +} + +int main (void) +{ + unsigned int param = 1; + unsigned int borrow = buggy (¶m); + + if (param != 0) + abort (); + if (borrow + 1 != 0) + abort (); + return 0; +} diff --git a/test/tests/20000314-1.c b/test/tests/20000314-1.c new file mode 100644 index 0000000..09de094 --- /dev/null +++ b/test/tests/20000314-1.c @@ -0,0 +1,17 @@ +int main () +{ + long winds = 0; + + while (winds != 0) + { + if (*(char *) winds) + break; + } + + if (winds == 0 || winds != 0 || *(char *) winds) + exit (0); + + abort (); +} + + diff --git a/test/tests/20000314-2.c b/test/tests/20000314-2.c new file mode 100644 index 0000000..f930145 --- /dev/null +++ b/test/tests/20000314-2.c @@ -0,0 +1,23 @@ +typedef unsigned long long uint32; +const uint32 bigconst = 1 << 18; + +int a = 1; + +static +uint32 getmask(void) +{ + if (a) + return bigconst; + else + return 0; +} + +main() +{ + uint32 f = getmask(); + if (sizeof (long long) == 4 + && f != bigconst) abort (); + exit (0); +} + + diff --git a/test/tests/20000314-3.c b/test/tests/20000314-3.c new file mode 100644 index 0000000..a141bfa --- /dev/null +++ b/test/tests/20000314-3.c @@ -0,0 +1,42 @@ +extern void abort (void); + +static char arg0[] = "arg0"; +static char arg1[] = "arg1"; + +static void attr_rtx (char *, char *); +static char *attr_string (char *); +static void attr_eq (char *, char *); + +static void +attr_rtx (char *varg0, char *varg1) +{ + if (varg0 != arg0) + abort (); + + if (varg1 != arg1) + abort (); + + return; +} + +static void +attr_eq (name, value) + char *name, *value; +{ + return attr_rtx (attr_string (name), + attr_string (value)); +} + +static char * +attr_string (str) + char *str; +{ + return str; +} + +int main() +{ + attr_eq (arg0, arg1); + exit (0); +} + diff --git a/test/tests/20000402-1.c b/test/tests/20000402-1.c new file mode 100644 index 0000000..d89ca6d --- /dev/null +++ b/test/tests/20000402-1.c @@ -0,0 +1,31 @@ +#include + +#if 0 //ULONG_LONG_MAX != 18446744073709551615ull && ULONG_MAX != 18446744073709551615ull +int main(void) { exit (0); } +#else +#if 1 //ULONG_MAX != 18446744073709551615ull +typedef unsigned long long ull; +#else +typedef unsigned long ull; +#endif + +void checkit(int); + +main () { + const ull a = 0x140000ULL; + const ull b = 0x8000ULL; + const ull c = a/b; + const ull d = 0x140000ULL / 0x8000ULL; + + checkit ((int) c); + checkit ((int) d); + + exit(0); +} + +void checkit (int a) +{ + if (a != 40) + abort(); +} +#endif diff --git a/test/tests/20000403-1.c b/test/tests/20000403-1.c new file mode 100644 index 0000000..8bcd6f1 --- /dev/null +++ b/test/tests/20000403-1.c @@ -0,0 +1,29 @@ +extern unsigned long aa[], bb[]; + +int seqgt (unsigned long a, unsigned short win, unsigned long b); + +int seqgt2 (unsigned long a, unsigned short win, unsigned long b); + +main() +{ + if (! seqgt (*aa, 0x1000, *bb) || ! seqgt2 (*aa, 0x1000, *bb)) + abort (); + + exit (0); +} + +int +seqgt (unsigned long a, unsigned short win, unsigned long b) +{ + return (long) ((a + win) - b) > 0; +} + +int +seqgt2 (unsigned long a, unsigned short win, unsigned long b) +{ + long l = ((a + win) - b); + return l > 0; +} + +unsigned long aa[] = { (1UL << (sizeof (long) * 8 - 1)) - 0xfff }; +unsigned long bb[] = { (1UL << (sizeof (long) * 8 - 1)) - 0xfff }; diff --git a/test/tests/20000412-1.c b/test/tests/20000412-1.c new file mode 100644 index 0000000..c9f7130 --- /dev/null +++ b/test/tests/20000412-1.c @@ -0,0 +1,17 @@ +short int i = -1; +const char * const wordlist[207]; + +const char * const * +foo(void) +{ + register const char * const *wordptr = &wordlist[207u + i]; + return wordptr; +} + +int +main() +{ + if (foo() != &wordlist[206]) + abort (); + exit(0); +} diff --git a/test/tests/20000412-2.c b/test/tests/20000412-2.c new file mode 100644 index 0000000..de3ebf9 --- /dev/null +++ b/test/tests/20000412-2.c @@ -0,0 +1,16 @@ +int f(int a,int *y) +{ + int x = a; + + if (a==0) + return *y; + + return f(a-1,&x); +} + +int main(int argc,char **argv) +{ + if (f (100, (int *) 0) != 1) + abort (); + exit (0); +} diff --git a/test/tests/20000412-3.c b/test/tests/20000412-3.c new file mode 100644 index 0000000..a5cb3ee --- /dev/null +++ b/test/tests/20000412-3.c @@ -0,0 +1,32 @@ +typedef struct { + char y; + char x[32]; +} X; + +int z (void) +{ + X xxx; + xxx.x[0] = + xxx.x[31] = '0'; + xxx.y = 0xf; + return f (xxx, xxx); +} + +int main (void) +{ + int val; + + val = z (); + if (val != 0x60) + abort (); + exit (0); +} + +int f(X x, X y) +{ + if (x.y != y.y) + return 'F'; + + return x.x[0] + y.x[0]; +} + diff --git a/test/tests/20000412-4.c b/test/tests/20000412-4.c new file mode 100644 index 0000000..f05b151 --- /dev/null +++ b/test/tests/20000412-4.c @@ -0,0 +1,26 @@ + void f(int i, int j, int radius, int width, int N) + { + const int diff = i-radius; + const int lowk = (diff>0 ? diff : 0 ); + int k; + + for(k=lowk; k<= 2; k++){ + int idx = ((k-i+radius)*width-j+radius); + if (idx < 0) + abort (); + } + + for(k=lowk; k<= 2; k++); + } + + + int main(int argc, char **argv) + { + int exc_rad=2; + int N=8; + int i; + for(i=1; i<4; i++) + f(i,1,exc_rad,2*exc_rad + 1, N); + exit (0); + } + diff --git a/test/tests/20000412-5.c b/test/tests/20000412-5.c new file mode 100644 index 0000000..c2efb15 --- /dev/null +++ b/test/tests/20000412-5.c @@ -0,0 +1,11 @@ +int main( void ) { + struct { + int node; + int type; + } lastglob[1] = { { 0 , 1 } }; + + if (lastglob[0].node != 0 || lastglob[0].type != 1) + abort (); + exit (0); +} + diff --git a/test/tests/20000412-6.c b/test/tests/20000412-6.c new file mode 100644 index 0000000..98e0030 --- /dev/null +++ b/test/tests/20000412-6.c @@ -0,0 +1,22 @@ +unsigned bug (unsigned short value, unsigned short *buffer, + unsigned short *bufend); + +unsigned short buf[] = {1, 4, 16, 64, 256}; +int main() +{ + if (bug (512, buf, buf + 3) != 491) + abort (); + + exit (0); +} + +unsigned +bug (unsigned short value, unsigned short *buffer, unsigned short *bufend) +{ + unsigned short *tmp; + + for (tmp = buffer; tmp < bufend; tmp++) + value -= *tmp; + + return value; +} diff --git a/test/tests/20000419-1.c b/test/tests/20000419-1.c new file mode 100644 index 0000000..6127d8b --- /dev/null +++ b/test/tests/20000419-1.c @@ -0,0 +1,22 @@ +struct foo { int a, b, c; }; + +void +brother (int a, int b, int c) +{ + if (a) + abort (); +} + +void +sister (struct foo f, int b, int c) +{ + brother ((f.b == b), b, c); +} + +int +main () +{ + struct foo f = { 7, 8, 9 }; + sister (f, 1, 2); + exit (0); +} diff --git a/test/tests/20000422-1.c b/test/tests/20000422-1.c new file mode 100644 index 0000000..f94d4c5 --- /dev/null +++ b/test/tests/20000422-1.c @@ -0,0 +1,39 @@ +int ops[13] = +{ + 11, 12, 46, 3, 2, 2, 3, 2, 1, 3, 2, 1, 2 +}; + +int correct[13] = +{ + 46, 12, 11, 3, 3, 3, 2, 2, 2, 2, 2, 1, 1 +}; + +int num = 13; + +int main() +{ + int i; + + for (i = 0; i < num; i++) + { + int j; + + for (j = num - 1; j > i; j--) + { + if (ops[j-1] < ops[j]) + { + int op = ops[j]; + ops[j] = ops[j-1]; + ops[j-1] = op; + } + } + } + + + for (i = 0; i < num; i++) + if (ops[i] != correct[i]) + abort (); + + exit (0); +} + diff --git a/test/tests/20000503-1.c b/test/tests/20000503-1.c new file mode 100644 index 0000000..bbf3262 --- /dev/null +++ b/test/tests/20000503-1.c @@ -0,0 +1,13 @@ +unsigned long +sub (int a) +{ + return ((0 > a - 2) ? 0 : a - 2) * sizeof (long); +} + +main () +{ + if (sub (0) != 0) + abort (); + + exit (0); +} diff --git a/test/tests/20000511-1.c b/test/tests/20000511-1.c new file mode 100644 index 0000000..b8a41f5 --- /dev/null +++ b/test/tests/20000511-1.c @@ -0,0 +1,33 @@ +void f (int value, int expect) +{ + if (value != expect) + abort (); +} + +int main() +{ + int a = 7, b = 6, c = 4, d = 7, e = 2; + + f (a||b%c, 1); + f (a?b%c:0, 2); + f (a=b%c, 2); + f (a*=b%c, 4); + f (a/=b%c, 2); + f (a%=b%c, 0); + f (a+=b%c, 2); + f (d||c&&e, 1); + f (d?c&&e:0, 1); + f (d=c&&e, 1); + f (d*=c&&e, 1); + f (d%=c&&e, 0); + f (d+=c&&e, 1); + f (d-=c&&e, 0); + f (d||c||e, 1); + f (d?c||e:0, 0); + f (d=c||e, 1); + f (d*=c||e, 1); + f (d%=c||e, 0); + f (d+=c||e, 1); + f (d-=c||e, 0); + exit (0); +} diff --git a/test/tests/20000519-1.c b/test/tests/20000519-1.c new file mode 100644 index 0000000..eec5bdd --- /dev/null +++ b/test/tests/20000519-1.c @@ -0,0 +1,30 @@ +#include + +int +bar (int a, va_list ap) +{ + int b; + + do + b = va_arg (ap, int); + while (b > 10); + + return a + b; +} + +int +foo (int a, ...) +{ + va_list ap; + + va_start (ap, a); + return bar (a, ap); +} + +int +main () +{ + if (foo (1, 2, 3) != 3) + abort (); + return 0; +} diff --git a/test/tests/20000519-2.c b/test/tests/20000519-2.c new file mode 100644 index 0000000..9635e32 --- /dev/null +++ b/test/tests/20000519-2.c @@ -0,0 +1,12 @@ +long x = -1L; + +int main() +{ + long b = (x != -1L); + + if (b) + abort(); + + exit(0); +} + diff --git a/test/tests/20000523-1.c b/test/tests/20000523-1.c new file mode 100644 index 0000000..6382ba4 --- /dev/null +++ b/test/tests/20000523-1.c @@ -0,0 +1,22 @@ +int +main (void) +{ + long long x; + int n; + + if (sizeof (long long) < 8) + exit (0); + + n = 9; + x = (((long long) n) << 55) / 0xff; + + if (x == 0) + abort (); + + x = (((long long) 9) << 55) / 0xff; + + if (x == 0) + abort (); + + exit (0); +} diff --git a/test/tests/20000528-1.c b/test/tests/20000528-1.c new file mode 100644 index 0000000..20692bf --- /dev/null +++ b/test/tests/20000528-1.c @@ -0,0 +1,13 @@ +/* Copyright (C) 2000 Free Software Foundation */ +/* Contributed by Alexandre Oliva */ + +unsigned long l = (unsigned long)-2; +unsigned short s; + +int main () { + long t = l; + s = t; + if (s != (unsigned short)-2) + abort (); + exit (0); +} diff --git a/test/tests/20000603-1.c b/test/tests/20000603-1.c new file mode 100644 index 0000000..e94a2c8 --- /dev/null +++ b/test/tests/20000603-1.c @@ -0,0 +1,22 @@ +/* It is not clear whether this test is conforming. See DR#236 + http://www.open-std.org/jtc1/sc22/wg14/www/docs/dr_236.htm. However, + there seems to be consensus that the presence of a union to aggregate + struct s1 and struct s2 should make it conforming. */ +struct s1 { double d; }; +struct s2 { double d; }; +union u { struct s1 x; struct s2 y; }; + +double f(struct s1 *a, struct s2 *b) +{ + a->d = 1.0; + return b->d + 1.0; +} + +int main() +{ + union u a; + a.x.d = 0.0; + if (f (&a.x, &a.y) != 2.0) + abort (); + return 0; +} diff --git a/test/tests/20000605-1.c b/test/tests/20000605-1.c new file mode 100644 index 0000000..b481ecb --- /dev/null +++ b/test/tests/20000605-1.c @@ -0,0 +1,48 @@ +typedef struct _RenderInfo RenderInfo; +struct _RenderInfo +{ + int y; + float scaley; + int src_y; +}; + +static void bar(void) { } + +static int +render_image_rgb_a (RenderInfo * info) +{ + int y, ye; + float error; + float step; + + y = info->y; + ye = 256; + + step = 1.0 / info->scaley; + + error = y * step; + error -= ((int) error) - step; + + for (; y < ye; y++) { + if (error >= 1.0) { + info->src_y += (int) error; + error -= (int) error; + bar(); + } + error += step; + } + return info->src_y; +} + +int main (void) +{ + RenderInfo info; + + info.y = 0; + info.src_y = 0; + info.scaley = 1.0; + + if (render_image_rgb_a(&info) != 256) + abort (); + exit(0); +} diff --git a/test/tests/20000605-2.c b/test/tests/20000605-2.c new file mode 100644 index 0000000..8a49bc6 --- /dev/null +++ b/test/tests/20000605-2.c @@ -0,0 +1,18 @@ +struct F { int i; }; + +void f1(struct F *x, struct F *y) +{ + int timeout = 0; + for (; ((const struct F*)x)->i < y->i ; x->i++) + if (++timeout > 5) + abort (); +} + +main() +{ + struct F x, y; + x.i = 0; + y.i = 1; + f1 (&x, &y); + exit (0); +} diff --git a/test/tests/20000605-3.c b/test/tests/20000605-3.c new file mode 100644 index 0000000..7ebb27f --- /dev/null +++ b/test/tests/20000605-3.c @@ -0,0 +1,18 @@ +struct F { int x; int y; }; + +int main() +{ + int timeout = 0; + int x = 0; + while (1) + { + const struct F i = { x++, }; + if (i.x > 0) + break; + if (++timeout > 5) + goto die; + } + return 0; + die: + abort (); +} diff --git a/test/tests/20000622-1.c b/test/tests/20000622-1.c new file mode 100644 index 0000000..d853ea8 --- /dev/null +++ b/test/tests/20000622-1.c @@ -0,0 +1,21 @@ +long foo(long a, long b, long c) +{ + if (a != 12 || b != 1 || c != 11) + abort(); + return 0; +} +long bar (long a, long b) +{ + return b; +} +void baz (long a, long b, void *c) +{ + long d; + d = (long)c; + foo(d, bar (a, 1), b); +} +int main() +{ + baz (10, 11, (void *)12); + exit(0); +} diff --git a/test/tests/20000703-1.c b/test/tests/20000703-1.c new file mode 100644 index 0000000..99f90b3 --- /dev/null +++ b/test/tests/20000703-1.c @@ -0,0 +1,39 @@ +void abort(void); +void exit(int); +struct baz +{ + char a[17]; + char b[3]; + unsigned int c; + unsigned int d; +}; + +void foo(struct baz *p, unsigned int c, unsigned int d) +{ + memcpy (p->b, "abc", 3); + p->c = c; + p->d = d; +} + +void bar(struct baz *p, unsigned int c, unsigned int d) +{ + ({ void *s = (p); + memset (s, '\0', sizeof (struct baz)); + s; }); + memcpy (p->a, "01234567890123456", 17); + memcpy (p->b, "abc", 3); + p->c = c; + p->d = d; +} + +int main() +{ + struct baz p; + foo(&p, 71, 18); + if (p.c != 71 || p.d != 18) + abort(); + bar(&p, 59, 26); + if (p.c != 59 || p.d != 26) + abort(); + exit(0); +} diff --git a/test/tests/20000706-1.c b/test/tests/20000706-1.c new file mode 100644 index 0000000..e8eb285 --- /dev/null +++ b/test/tests/20000706-1.c @@ -0,0 +1,31 @@ +extern void abort(void); +extern void exit(int); + +struct baz { + int a, b, c, d, e; +}; + +void bar(struct baz *x, int f, int g, int h, int i, int j) +{ + if (x->a != 1 || x->b != 2 || x->c != 3 || x->d != 4 || x->e != 5 || + f != 6 || g != 7 || h != 8 || i != 9 || j != 10) + abort(); +} + +void foo(struct baz x, char **y) +{ + bar(&x,6,7,8,9,10); +} + +int main() +{ + struct baz x; + + x.a = 1; + x.b = 2; + x.c = 3; + x.d = 4; + x.e = 5; + foo(x,(char **)0); + exit(0); +} diff --git a/test/tests/20000706-2.c b/test/tests/20000706-2.c new file mode 100644 index 0000000..faf2137 --- /dev/null +++ b/test/tests/20000706-2.c @@ -0,0 +1,31 @@ +extern void abort(void); +extern void exit(int); + +struct baz { + int a, b, c, d, e; +}; + +void bar(struct baz *x, int f, int g, int h, int i, int j) +{ + if (x->a != 1 || x->b != 2 || x->c != 3 || x->d != 4 || x->e != 5 || + f != 6 || g != 7 || h != 8 || i != 9 || j != 10) + abort(); +} + +void foo(char *z, struct baz x, char *y) +{ + bar(&x,6,7,8,9,10); +} + +int main() +{ + struct baz x; + + x.a = 1; + x.b = 2; + x.c = 3; + x.d = 4; + x.e = 5; + foo((char *)0,x,(char *)0); + exit(0); +} diff --git a/test/tests/20000706-3.c b/test/tests/20000706-3.c new file mode 100644 index 0000000..b5758d9 --- /dev/null +++ b/test/tests/20000706-3.c @@ -0,0 +1,27 @@ +extern void abort(void); +extern void exit(int); + +int c; + +void baz(int *p) +{ + c = *p; +} + +void bar(int b) +{ + if (c != 1 || b != 2) + abort(); +} + +void foo(int a, int b) +{ + baz(&a); + bar(b); +} + +int main() +{ + foo(1, 2); + exit(0); +} diff --git a/test/tests/20000706-4.c b/test/tests/20000706-4.c new file mode 100644 index 0000000..01cc879 --- /dev/null +++ b/test/tests/20000706-4.c @@ -0,0 +1,22 @@ +extern void abort(void); +extern void exit(int); + +int *c; + +void bar(int b) +{ + if (*c != 1 || b != 2) + abort(); +} + +void foo(int a, int b) +{ + c = &a; + bar(b); +} + +int main() +{ + foo(1, 2); + exit(0); +} diff --git a/test/tests/20000706-5.c b/test/tests/20000706-5.c new file mode 100644 index 0000000..18756f2 --- /dev/null +++ b/test/tests/20000706-5.c @@ -0,0 +1,28 @@ +extern void abort(void); +extern void exit(int); + +struct baz { int a, b, c; }; + +struct baz *c; + +void bar(int b) +{ + if (c->a != 1 || c->b != 2 || c->c != 3 || b != 4) + abort(); +} + +void foo(struct baz a, int b) +{ + c = &a; + bar(b); +} + +int main() +{ + struct baz a; + a.a = 1; + a.b = 2; + a.c = 3; + foo(a, 4); + exit(0); +} diff --git a/test/tests/20000707-1.c b/test/tests/20000707-1.c new file mode 100644 index 0000000..f1c50a9 --- /dev/null +++ b/test/tests/20000707-1.c @@ -0,0 +1,27 @@ +extern void abort(void); +extern void exit(int); + +struct baz { + int a, b, c; +}; + +void +foo (int a, int b, int c) +{ + if (a != 4) + abort (); +} + +void +bar (struct baz x, int b, int c) +{ + foo (x.b, b, c); +} + +int +main () +{ + struct baz x = { 3, 4, 5 }; + bar (x, 1, 2); + exit (0); +} diff --git a/test/tests/20000715-1.c b/test/tests/20000715-1.c new file mode 100644 index 0000000..43af114 --- /dev/null +++ b/test/tests/20000715-1.c @@ -0,0 +1,118 @@ +void abort(void); +void exit(int); + +void +test1(void) +{ + int x = 3, y = 2; + + if ((x < y ? x++ : y++) != 2) + abort (); + + if (x != 3) + abort (); + + if (y != 3) + abort (); +} + +void +test2(void) +{ + int x = 3, y = 2, z; + + z = (x < y) ? x++ : y++; + if (z != 2) + abort (); + + if (x != 3) + abort (); + + if (y != 3) + abort (); +} + +void +test3(void) +{ + int x = 3, y = 2; + int xx = 3, yy = 2; + + if ((xx < yy ? x++ : y++) != 2) + abort (); + + if (x != 3) + abort (); + + if (y != 3) + abort (); +} + +int x, y; + +static void +init_xy(void) +{ + x = 3; + y = 2; +} + +void +test4(void) +{ + init_xy(); + if ((x < y ? x++ : y++) != 2) + abort (); + + if (x != 3) + abort (); + + if (y != 3) + abort (); +} + +void +test5(void) +{ + int z; + + init_xy(); + z = (x < y) ? x++ : y++; + if (z != 2) + abort (); + + if (x != 3) + abort (); + + if (y != 3) + abort (); +} + +void +test6(void) +{ + int xx = 3, yy = 2; + int z; + + init_xy(); + z = (xx < y) ? x++ : y++; + if (z != 2) + abort (); + + if (x != 3) + abort (); + + if (y != 3) + abort (); +} + +int +main(){ + test1 (); + test2 (); + test3 (); + test4 (); + test5 (); + test6 (); + exit (0); +} diff --git a/test/tests/20000715-2.c b/test/tests/20000715-2.c new file mode 100644 index 0000000..bfee0c3 --- /dev/null +++ b/test/tests/20000715-2.c @@ -0,0 +1,14 @@ +extern void abort(void); +extern void exit(int); + +unsigned int foo(unsigned int a) +{ + return ((unsigned char)(a + 1)) * 4; +} + +int main(void) +{ + if (foo((unsigned char)~0)) + abort (); + exit(0); +} diff --git a/test/tests/20000717-1.c b/test/tests/20000717-1.c new file mode 100644 index 0000000..039ae5f --- /dev/null +++ b/test/tests/20000717-1.c @@ -0,0 +1,22 @@ +typedef struct trio { int a, b, c; } trio; + +int +bar (int i, trio t) +{ + if (t.a == t.b || t.a == t.c) + abort (); +} + +int +foo (trio t, int i) +{ + return bar (i, t); +} + +main () +{ + trio t = { 1, 2, 3 }; + + foo (t, 4); + exit (0); +} diff --git a/test/tests/20000717-2.c b/test/tests/20000717-2.c new file mode 100644 index 0000000..833adef --- /dev/null +++ b/test/tests/20000717-2.c @@ -0,0 +1,11 @@ +static void +compare (long long foo) +{ + if (foo < 65537LL) + abort(); +} +int main(void) +{ + compare (131071LL); + exit (0); +} diff --git a/test/tests/20000717-3.c b/test/tests/20000717-3.c new file mode 100644 index 0000000..e87d00b --- /dev/null +++ b/test/tests/20000717-3.c @@ -0,0 +1,26 @@ +int c = -1; + +foo (p) + int *p; +{ + int x; + int a; + + a = p[0]; + x = a + 5; + a = c; + p[0] = x - 15; + return a; +} + +int main() +{ + int b = 1; + int a = foo(&b); + + if (a != -1 || b != (1 + 5 - 15)) + abort (); + + exit (0); +} + diff --git a/test/tests/20000717-4.c b/test/tests/20000717-4.c new file mode 100644 index 0000000..c3d27bb --- /dev/null +++ b/test/tests/20000717-4.c @@ -0,0 +1,26 @@ +/* Extracted from gas. Incorrectly generated non-pic code at -O0 for + IA-64, which produces linker errors on some operating systems. */ + +struct +{ + int offset; + struct slot + { + int field[6]; + } + slot[4]; +} s; + +int +x () +{ + int toggle = 0; + int r = s.slot[0].field[!toggle]; + return r; +} + +int +main () +{ + return 0; +} diff --git a/test/tests/20000717-5.c b/test/tests/20000717-5.c new file mode 100644 index 0000000..49dcbbc --- /dev/null +++ b/test/tests/20000717-5.c @@ -0,0 +1,23 @@ +typedef struct trio { int a, b, c; } trio; + +int +bar (int i, int j, int k, trio t) +{ + if (t.a != 1 || t.b != 2 || t.c != 3 || + i != 4 || j != 5 || k != 6) + abort (); +} + +int +foo (trio t, int i, int j, int k) +{ + return bar (i, j, k, t); +} + +main () +{ + trio t = { 1, 2, 3 }; + + foo (t, 4, 5, 6); + exit (0); +} diff --git a/test/tests/20000722-1.c b/test/tests/20000722-1.c new file mode 100644 index 0000000..0ce3191 --- /dev/null +++ b/test/tests/20000722-1.c @@ -0,0 +1,24 @@ +struct s { char *p; int t; }; + +extern void bar (void); +extern void foo (struct s *); + +int main(void) +{ + bar (); + bar (); + exit (0); +} + +void +bar (void) +{ + foo (& (struct s) { "hi", 1 }); +} + +void foo (struct s *p) +{ + if (p->t != 1) + abort(); + p->t = 2; +} diff --git a/test/tests/20000726-1.c b/test/tests/20000726-1.c new file mode 100644 index 0000000..b0ecd29 --- /dev/null +++ b/test/tests/20000726-1.c @@ -0,0 +1,31 @@ +void adjust_xy (short *, short *); + +struct adjust_template +{ + short kx_x; + short kx_y; + short kx; + short kz; +}; + +static struct adjust_template adjust = {0, 0, 1, 1}; + +main () +{ + short x = 1, y = 1; + + adjust_xy (&x, &y); + + if (x != 1) + abort (); + + exit (0); +} + +void +adjust_xy (x, y) + short *x; + short *y; +{ + *x = adjust.kx_x * *x + adjust.kx_y * *y + adjust.kx; +} diff --git a/test/tests/20000731-1.c b/test/tests/20000731-1.c new file mode 100644 index 0000000..787c29a --- /dev/null +++ b/test/tests/20000731-1.c @@ -0,0 +1,24 @@ +double +foo (void) +{ + return 0.0; +} + +void +do_sibcall (void) +{ + (void) foo (); +} + +int +main (void) +{ + double x; + + for (x = 0; x < 20; x++) + do_sibcall (); + if (!(x >= 10)) + abort (); + exit (0); +} + diff --git a/test/tests/20000731-2.c b/test/tests/20000731-2.c new file mode 100644 index 0000000..112aa1c --- /dev/null +++ b/test/tests/20000731-2.c @@ -0,0 +1,16 @@ +int +main() +{ + int i = 1; + int j = 0; + + while (i != 1024 || j <= 0) { + i *= 2; + ++ j; + } + + if (j != 10) + abort (); + + exit (0); +} diff --git a/test/tests/20000801-1.c b/test/tests/20000801-1.c new file mode 100644 index 0000000..1bc386e --- /dev/null +++ b/test/tests/20000801-1.c @@ -0,0 +1,39 @@ +extern void abort(void); +extern void exit(int); + +void +foo (char *bp, unsigned n) +{ + register char c; + register char *ep = bp + n; + register char *sp; + + while (bp < ep) + { + sp = bp + 3; + c = *sp; + *sp = *bp; + *bp++ = c; + sp = bp + 1; + c = *sp; + *sp = *bp; + *bp++ = c; + bp += 2; + } +} + +int main(void) +{ + int one = 1; + + if (sizeof(int) != 4 * sizeof(char)) + exit(0); + + foo((char *)&one, sizeof(one)); + foo((char *)&one, sizeof(one)); + + if (one != 1) + abort(); + + exit(0); +} diff --git a/test/tests/20000801-2.c b/test/tests/20000801-2.c new file mode 100644 index 0000000..5bb17b5 --- /dev/null +++ b/test/tests/20000801-2.c @@ -0,0 +1,40 @@ +extern void abort(void); +extern void exit(int); +int bar(void); +int baz(void); + +struct foo { + struct foo *next; +}; + +struct foo *test(struct foo *node) +{ + while (node) { + if (bar() && !baz()) + break; + node = node->next; + } + return node; +} + +int bar (void) +{ + return 0; +} + +int baz (void) +{ + return 0; +} + +int main(void) +{ + struct foo a, b, *c; + + a.next = &b; + b.next = (struct foo *)0; + c = test(&a); + if (c) + abort(); + exit (0); +} diff --git a/test/tests/20000801-3.c b/test/tests/20000801-3.c new file mode 100644 index 0000000..8d47a81 --- /dev/null +++ b/test/tests/20000801-3.c @@ -0,0 +1,24 @@ +/* Origin: PR c/92 from Simon Marlow , adapted + to a testcase by Joseph Myers . +*/ + +typedef struct { } empty; + +typedef struct { + int i; + empty e; + int i2; +} st; + +st s = { .i = 0, .i2 = 1 }; + +extern void abort (void); + +int +main (void) +{ + if (s.i2 == 1) + exit (0); + else + abort (); +} diff --git a/test/tests/20000801-4.c b/test/tests/20000801-4.c new file mode 100644 index 0000000..d293f05 --- /dev/null +++ b/test/tests/20000801-4.c @@ -0,0 +1,30 @@ +/* Origin: PR c/128 from Martin Sebor , adapted + as a testcase by Joseph Myers . +*/ +/* Character arrays initialized by a string literal must have + uninitialized elements zeroed. This isn't clear in the 1990 + standard, but was fixed in TC2 and C99; see DRs #060, #092. +*/ +extern void abort (void); + +int +foo (void) +{ + char s[2] = ""; + return 0 == s[1]; +} + +char *t; + +int +main (void) +{ + { + char s[] = "x"; + t = s; + } + if (foo ()) + exit (0); + else + abort (); +} diff --git a/test/tests/20000808-1.c b/test/tests/20000808-1.c new file mode 100644 index 0000000..a905aad --- /dev/null +++ b/test/tests/20000808-1.c @@ -0,0 +1,56 @@ +typedef struct { + long int p_x, p_y; +} Point; + +void +bar () +{ +} + +void +f (p0, p1, p2, p3, p4, p5) + Point p0, p1, p2, p3, p4, p5; +{ + if (p0.p_x != 0 || p0.p_y != 1 + || p1.p_x != -1 || p1.p_y != 0 + || p2.p_x != 1 || p2.p_y != -1 + || p3.p_x != -1 || p3.p_y != 1 + || p4.p_x != 0 || p4.p_y != -1 + || p5.p_x != 1 || p5.p_y != 0) + abort (); +} + +void +foo () +{ + Point p0, p1, p2, p3, p4, p5; + + bar(); + + p0.p_x = 0; + p0.p_y = 1; + + p1.p_x = -1; + p1.p_y = 0; + + p2.p_x = 1; + p2.p_y = -1; + + p3.p_x = -1; + p3.p_y = 1; + + p4.p_x = 0; + p4.p_y = -1; + + p5.p_x = 1; + p5.p_y = 0; + + f (p0, p1, p2, p3, p4, p5); +} + +int +main() +{ + foo(); + exit(0); +} diff --git a/test/tests/20000815-1.c b/test/tests/20000815-1.c new file mode 100644 index 0000000..868487f --- /dev/null +++ b/test/tests/20000815-1.c @@ -0,0 +1,70 @@ +struct table_elt +{ + void *exp; + struct table_elt *next_same_hash; + struct table_elt *prev_same_hash; + struct table_elt *next_same_value; + struct table_elt *prev_same_value; + struct table_elt *first_same_value; + struct table_elt *related_value; + int cost; + int mode; + char in_memory; + char in_struct; + char is_const; + char flag; +}; + +struct write_data +{ + int sp : 1; + int var : 1; + int nonscalar : 1; + int all : 1; +}; + +int cse_rtx_addr_varies_p(void *); +void remove_from_table(struct table_elt *, int); +static struct table_elt *table[32]; + +void +invalidate_memory (writes) + struct write_data *writes; +{ + register int i; + register struct table_elt *p, *next; + int all = writes->all; + int nonscalar = writes->nonscalar; + + for (i = 0; i < 31; i++) + for (p = table[i]; p; p = next) + { + next = p->next_same_hash; + if (p->in_memory + && (all + || (nonscalar && p->in_struct) + || cse_rtx_addr_varies_p (p->exp))) + remove_from_table (p, i); + } +} + +int cse_rtx_addr_varies_p(void *x) { return 0; } +void remove_from_table(struct table_elt *x, int y) { abort (); } + +int +main() +{ + struct write_data writes; + struct table_elt elt; + + memset(&elt, 0, sizeof(elt)); + elt.in_memory = 1; + table[0] = &elt; + + memset(&writes, 0, sizeof(writes)); + writes.var = 1; + writes.nonscalar = 1; + + invalidate_memory(&writes); + return 0; +} diff --git a/test/tests/20000818-1.c b/test/tests/20000818-1.c new file mode 100644 index 0000000..0067644 --- /dev/null +++ b/test/tests/20000818-1.c @@ -0,0 +1,60 @@ +/* Copyright (C) 2000 Free Software Foundation. + + by Manfred Hollstein */ + +void *temporary_obstack; + +static int input (void); +static int ISALNUM (int ch); +static void obstack_1grow (void **ptr, int ch); + +int yylex (void); +int main (void); + +int main (void) +{ + int ch = yylex (); + + exit (0); +} + +int yylex (void) +{ + int ch; + +#ifndef WORK_AROUND + for (;;) + { + ch = input (); + if (ISALNUM (ch)) + obstack_1grow (&temporary_obstack, ch); + else if (ch != '_') + break; + } +#else + do + { + ch = input (); + if (ISALNUM (ch)) + obstack_1grow (&temporary_obstack, ch); + } while (ch == '_'); +#endif + + return ch; +} + +static int input (void) +{ + return 0; +} + +static int ISALNUM (int ch) +{ + return ((ch >= 'A' && ch <= 'Z') + || (ch >= 'a' && ch <= 'z') + || (ch >= '0' && ch <= '0')); +} + +static void obstack_1grow (void **ptr, int ch) +{ +} diff --git a/test/tests/20000819-1.c b/test/tests/20000819-1.c new file mode 100644 index 0000000..e1c2769 --- /dev/null +++ b/test/tests/20000819-1.c @@ -0,0 +1,17 @@ +int a[2] = { 2, 0 }; + +void foo(int *sp, int cnt) +{ + int *p, *top; + + top = sp; sp -= cnt; + + for(p = sp; p <= top; p++) + if (*p < 2) exit(0); +} + +int main() +{ + foo(a + 1, 1); + abort(); +} diff --git a/test/tests/20000910-1.c b/test/tests/20000910-1.c new file mode 100644 index 0000000..0c3c602 --- /dev/null +++ b/test/tests/20000910-1.c @@ -0,0 +1,27 @@ +/* Copyright (C) 2000 Free Software Foundation */ +/* by Alexandre Oliva */ + +#include + +void bar (int); +void foo (int *); + +int main () { + static int a[] = { 0, 1, 2 }; + int *i = &a[sizeof(a)/sizeof(*a)]; + + while (i-- > a) + foo (i); + + exit (0); +} + +void baz (int, int); + +void bar (int i) { baz (i, i); } +void foo (int *i) { bar (*i); } + +void baz (int i, int j) { + if (i != j) + abort (); +} diff --git a/test/tests/20000910-2.c b/test/tests/20000910-2.c new file mode 100644 index 0000000..0023d24 --- /dev/null +++ b/test/tests/20000910-2.c @@ -0,0 +1,28 @@ +/* Copyright (C) 2000 Free Software Foundation */ +/* by Alexandre Oliva */ + +#include +#include + +char *list[] = { "*", "e" }; + +static int bar (const char *fmt) { + return (strchr (fmt, '*') != 0); +} + +static void foo () { + int i; + for (i = 0; i < sizeof (list) / sizeof (*list); i++) { + const char *fmt = list[i]; + if (bar (fmt)) + continue; + if (i == 0) + abort (); + else + exit (0); + } +} + +int main () { + foo (); +} diff --git a/test/tests/20000914-1.c b/test/tests/20000914-1.c new file mode 100644 index 0000000..1e8bb0c --- /dev/null +++ b/test/tests/20000914-1.c @@ -0,0 +1,292 @@ +extern void *malloc(__SIZE_TYPE__); + +enum tree_code { +ERROR_MARK, +IDENTIFIER_NODE, +OP_IDENTIFIER, +TREE_LIST, +TREE_VEC, +BLOCK, +VOID_TYPE, +INTEGER_TYPE, +REAL_TYPE, +COMPLEX_TYPE, +VECTOR_TYPE, +ENUMERAL_TYPE, +BOOLEAN_TYPE, +CHAR_TYPE, +POINTER_TYPE, +OFFSET_TYPE, +REFERENCE_TYPE, +METHOD_TYPE, +FILE_TYPE, +ARRAY_TYPE, +SET_TYPE, +RECORD_TYPE, +UNION_TYPE, +QUAL_UNION_TYPE, +FUNCTION_TYPE, +LANG_TYPE, +INTEGER_CST, +REAL_CST, +COMPLEX_CST, +STRING_CST, +FUNCTION_DECL, +LABEL_DECL, +CONST_DECL, +TYPE_DECL, +VAR_DECL, +PARM_DECL, +RESULT_DECL, +FIELD_DECL, +NAMESPACE_DECL, +COMPONENT_REF, +BIT_FIELD_REF, +INDIRECT_REF, +BUFFER_REF, +ARRAY_REF, +CONSTRUCTOR, +COMPOUND_EXPR, +MODIFY_EXPR, +INIT_EXPR, +TARGET_EXPR, +COND_EXPR, +BIND_EXPR, +CALL_EXPR, +METHOD_CALL_EXPR, +WITH_CLEANUP_EXPR, +CLEANUP_POINT_EXPR, +PLACEHOLDER_EXPR, +WITH_RECORD_EXPR, +PLUS_EXPR, +MINUS_EXPR, +MULT_EXPR, +TRUNC_DIV_EXPR, +CEIL_DIV_EXPR, +FLOOR_DIV_EXPR, +ROUND_DIV_EXPR, +TRUNC_MOD_EXPR, +CEIL_MOD_EXPR, +FLOOR_MOD_EXPR, +ROUND_MOD_EXPR, +RDIV_EXPR, +EXACT_DIV_EXPR, +FIX_TRUNC_EXPR, +FIX_CEIL_EXPR, +FIX_FLOOR_EXPR, +FIX_ROUND_EXPR, +FLOAT_EXPR, +EXPON_EXPR, +NEGATE_EXPR, +MIN_EXPR, +MAX_EXPR, +ABS_EXPR, +FFS_EXPR, +LSHIFT_EXPR, +RSHIFT_EXPR, +LROTATE_EXPR, +RROTATE_EXPR, +BIT_IOR_EXPR, +BIT_XOR_EXPR, +BIT_AND_EXPR, +BIT_ANDTC_EXPR, +BIT_NOT_EXPR, +TRUTH_ANDIF_EXPR, +TRUTH_ORIF_EXPR, +TRUTH_AND_EXPR, +TRUTH_OR_EXPR, +TRUTH_XOR_EXPR, +TRUTH_NOT_EXPR, +LT_EXPR, +LE_EXPR, +GT_EXPR, +GE_EXPR, +EQ_EXPR, +NE_EXPR, +UNORDERED_EXPR, +ORDERED_EXPR, +UNLT_EXPR, +UNLE_EXPR, +UNGT_EXPR, +UNGE_EXPR, +UNEQ_EXPR, +IN_EXPR, +SET_LE_EXPR, +CARD_EXPR, +RANGE_EXPR, +CONVERT_EXPR, +NOP_EXPR, +NON_LVALUE_EXPR, +SAVE_EXPR, +UNSAVE_EXPR, +RTL_EXPR, +ADDR_EXPR, +REFERENCE_EXPR, +ENTRY_VALUE_EXPR, +COMPLEX_EXPR, +CONJ_EXPR, +REALPART_EXPR, +IMAGPART_EXPR, +PREDECREMENT_EXPR, +PREINCREMENT_EXPR, +POSTDECREMENT_EXPR, +POSTINCREMENT_EXPR, +VA_ARG_EXPR, +TRY_CATCH_EXPR, +TRY_FINALLY_EXPR, +GOTO_SUBROUTINE_EXPR, +POPDHC_EXPR, +POPDCC_EXPR, +LABEL_EXPR, +GOTO_EXPR, +RETURN_EXPR, +EXIT_EXPR, +LOOP_EXPR, +LABELED_BLOCK_EXPR, +EXIT_BLOCK_EXPR, +EXPR_WITH_FILE_LOCATION, +SWITCH_EXPR, + LAST_AND_UNUSED_TREE_CODE +}; +typedef union tree_node *tree; +struct tree_common +{ + union tree_node *chain; + union tree_node *type; + enum tree_code code : 8; + unsigned side_effects_flag : 1; + unsigned constant_flag : 1; + unsigned permanent_flag : 1; + unsigned addressable_flag : 1; + unsigned volatile_flag : 1; + unsigned readonly_flag : 1; + unsigned unsigned_flag : 1; + unsigned asm_written_flag: 1; + unsigned used_flag : 1; + unsigned nothrow_flag : 1; + unsigned static_flag : 1; + unsigned public_flag : 1; + unsigned private_flag : 1; + unsigned protected_flag : 1; + unsigned bounded_flag : 1; + unsigned lang_flag_0 : 1; + unsigned lang_flag_1 : 1; + unsigned lang_flag_2 : 1; + unsigned lang_flag_3 : 1; + unsigned lang_flag_4 : 1; + unsigned lang_flag_5 : 1; + unsigned lang_flag_6 : 1; +}; +union tree_node +{ + struct tree_common common; + }; +enum c_tree_code { + C_DUMMY_TREE_CODE = LAST_AND_UNUSED_TREE_CODE, +SRCLOC, +SIZEOF_EXPR, +ARROW_EXPR, +ALIGNOF_EXPR, +EXPR_STMT, +COMPOUND_STMT, +DECL_STMT, +IF_STMT, +FOR_STMT, +WHILE_STMT, +DO_STMT, +RETURN_STMT, +BREAK_STMT, +CONTINUE_STMT, +SWITCH_STMT, +GOTO_STMT, +LABEL_STMT, +ASM_STMT, +SCOPE_STMT, +CASE_LABEL, +STMT_EXPR, + LAST_C_TREE_CODE +}; +enum cplus_tree_code { + CP_DUMMY_TREE_CODE = LAST_C_TREE_CODE, +OFFSET_REF, +PTRMEM_CST, +NEW_EXPR, +VEC_NEW_EXPR, +DELETE_EXPR, +VEC_DELETE_EXPR, +SCOPE_REF, +MEMBER_REF, +TYPE_EXPR, +AGGR_INIT_EXPR, +THROW_EXPR, +EMPTY_CLASS_EXPR, +TEMPLATE_DECL, +TEMPLATE_PARM_INDEX, +TEMPLATE_TYPE_PARM, +TEMPLATE_TEMPLATE_PARM, +BOUND_TEMPLATE_TEMPLATE_PARM, +TYPENAME_TYPE, +TYPEOF_TYPE, +USING_DECL, +DEFAULT_ARG, +TEMPLATE_ID_EXPR, +CPLUS_BINDING, +OVERLOAD, +WRAPPER, +LOOKUP_EXPR, +FUNCTION_NAME, +MODOP_EXPR, +CAST_EXPR, +REINTERPRET_CAST_EXPR, +CONST_CAST_EXPR, +STATIC_CAST_EXPR, +DYNAMIC_CAST_EXPR, +DOTSTAR_EXPR, +TYPEID_EXPR, +PSEUDO_DTOR_EXPR, +SUBOBJECT, +CTOR_STMT, +CLEANUP_STMT, +START_CATCH_STMT, +CTOR_INITIALIZER, +RETURN_INIT, +TRY_BLOCK, +HANDLER, +TAG_DEFN, +IDENTITY_CONV, +LVALUE_CONV, +QUAL_CONV, +STD_CONV, +PTR_CONV, +PMEM_CONV, +BASE_CONV, +REF_BIND, +USER_CONV, +AMBIG_CONV, +RVALUE_CONV, + LAST_CPLUS_TREE_CODE +}; + +blah(){} + +convert_like_real (convs) + tree convs; +{ + switch (((enum tree_code) (convs)->common.code)) + { + case AMBIG_CONV: + return blah(); + default: + break; + }; + abort (); +} + +main() +{ + tree convs = (void *)malloc (sizeof (struct tree_common));; + + convs->common.code = AMBIG_CONV; + convert_like_real (convs); + exit (0); +} diff --git a/test/tests/20000917-1.c b/test/tests/20000917-1.c new file mode 100644 index 0000000..05b00ff --- /dev/null +++ b/test/tests/20000917-1.c @@ -0,0 +1,42 @@ +/* This bug exists in gcc-2.95, egcs-1.1.2, gcc-2.7.2 and probably + every other version as well. */ + +typedef struct int3 { int a, b, c; } int3; + +int3 +one (void) +{ + return (int3) { 1, 1, 1 }; +} + +int3 +zero (void) +{ + return (int3) { 0, 0, 0 }; +} + +int +main (void) +{ + int3 a; + + /* gcc allocates a temporary for the inner expression statement + to store the return value of `one'. + + gcc frees the temporaries for the inner expression statement. + + gcc realloates the same temporary slot to store the return + value of `zero'. + + gcc expands the call to zero ahead of the expansion of the + statement expressions. The temporary gets the value of `zero'. + + gcc expands statement expressions and the stale temporary is + clobbered with the value of `one'. The bad value is copied from + the temporary into *&a. */ + + *({ ({ one (); &a; }); }) = zero (); + if (a.a && a.b && a.c) + abort (); + exit (0); +} diff --git a/test/tests/20001009-1.c b/test/tests/20001009-1.c new file mode 100644 index 0000000..aa691ca --- /dev/null +++ b/test/tests/20001009-1.c @@ -0,0 +1,12 @@ +int a,b; +main() +{ + int c=-2; + int d=0xfe; + int e=a&1; + int f=b&2; + if ((char)(c|(e&f)) == (char)d) + return 0; + else + abort(); +} diff --git a/test/tests/20001009-2.c b/test/tests/20001009-2.c new file mode 100644 index 0000000..8d2ce5e --- /dev/null +++ b/test/tests/20001009-2.c @@ -0,0 +1,21 @@ +int b=1; +int foo() +{ + int a; + int c; + a=0xff; + for (;b;b--) + { + c=1; + //asm(""::"r"(c)); + c=(signed char)a; + } + if (c!=-1) + abort(); + return c; +} +int main() +{ + foo(); + return 0; +} diff --git a/test/tests/20001011-1.c b/test/tests/20001011-1.c new file mode 100644 index 0000000..ffdcb9f --- /dev/null +++ b/test/tests/20001011-1.c @@ -0,0 +1,14 @@ +extern void abort(void); +extern int strcmp(const char *, const char *); + +int foo(const char *a) +{ + return strcmp(a, "main"); +} + +int main(void) +{ + if(foo(__FUNCTION__)) + abort(); + return 0; +} diff --git a/test/tests/20001013-1.c b/test/tests/20001013-1.c new file mode 100644 index 0000000..0d139fc --- /dev/null +++ b/test/tests/20001013-1.c @@ -0,0 +1,17 @@ +struct x { + int a, b; +} z = { -4028, 4096 }; + +int foo(struct x *p, int y) +{ + if ((y & 0xff) != y || -p->b >= p->a) + return 1; + return 0; +} + +main() +{ + if (foo (&z, 10)) + abort (); + exit (0); +} diff --git a/test/tests/20001017-1.c b/test/tests/20001017-1.c new file mode 100644 index 0000000..f55886f --- /dev/null +++ b/test/tests/20001017-1.c @@ -0,0 +1,17 @@ + +void bug (double *Cref, char transb, int m, int n, int k, + double a, double *A, int fdA, double *B, int fdB, + double b, double *C, int fdC) +{ + if (C != Cref) abort (); +} + +int main (void) +{ + double A[1], B[1], C[1]; + + bug (C, 'B', 1, 2, 3, 4.0, A, 5, B, 6, 7.0, C, 8); + + return 0; +} + diff --git a/test/tests/20001017-2.c b/test/tests/20001017-2.c new file mode 100644 index 0000000..3263bb9 --- /dev/null +++ b/test/tests/20001017-2.c @@ -0,0 +1,17 @@ +void +fn_4parms (unsigned char a, long *b, long *c, unsigned int *d) +{ + if (*b != 1 || *c != 2 || *d != 3) + abort (); +} + +int +main () +{ + unsigned char a = 0; + unsigned long b = 1, c = 2; + unsigned int d = 3; + + fn_4parms (a, &b, &c, &d); + return 0; +} diff --git a/test/tests/20001024-1.c b/test/tests/20001024-1.c new file mode 100644 index 0000000..084fdaf --- /dev/null +++ b/test/tests/20001024-1.c @@ -0,0 +1,34 @@ +struct a; + +extern int baz (struct a *__restrict x); + +struct a { + long v; + long w; +}; + +struct b { + struct a c; + struct a d; +}; + +int bar (int x, const struct b *__restrict y, struct b *__restrict z) +{ + if (y->c.v || y->c.w != 25000 || y->d.v || y->d.w != 25000) + abort(); +} + +void foo(void) +{ + struct b x; + x.c.v = 0; + x.c.w = 25000; + x.d = x.c; + bar(0, &x, ((void *)0)); +} + +int main() +{ + foo(); + exit(0); +} diff --git a/test/tests/20001026-1.c b/test/tests/20001026-1.c new file mode 100644 index 0000000..9d4f28d --- /dev/null +++ b/test/tests/20001026-1.c @@ -0,0 +1,44 @@ +extern void abort (void); + +typedef struct { + long r[(19 + sizeof (long))/(sizeof (long))]; +} realvaluetype; + +typedef void *tree; + +static realvaluetype +real_value_from_int_cst (tree x, tree y) +{ + realvaluetype r; + int i; + for (i = 0; i < sizeof(r.r)/sizeof(long); ++i) + r.r[i] = -1; + return r; +} + +struct brfic_args +{ + tree type; + tree i; + realvaluetype d; +}; + +static void +build_real_from_int_cst_1 (data) + void * data; +{ + struct brfic_args *args = (struct brfic_args *) data; + args->d = real_value_from_int_cst (args->type, args->i); +} + +int main() +{ + struct brfic_args args; + + memset (&args, 0, sizeof(args)); + build_real_from_int_cst_1 (&args); + + if (args.d.r[0] == 0) + abort (); + return 0; +} diff --git a/test/tests/20001027-1.c b/test/tests/20001027-1.c new file mode 100644 index 0000000..89ac9a0 --- /dev/null +++ b/test/tests/20001027-1.c @@ -0,0 +1,11 @@ +int x,*p=&x; + +int main() +{ + int i=0; + x=1; + p[i]=2; + if (x != 2) + abort (); + exit (0); +} diff --git a/test/tests/20001031-1.c b/test/tests/20001031-1.c new file mode 100644 index 0000000..a2a6c83 --- /dev/null +++ b/test/tests/20001031-1.c @@ -0,0 +1,37 @@ +extern void abort (void); +extern void exit (int); + +void t1 (int x) +{ + if (x != 4100) + abort (); +} + +int t2 (void) +{ + int i; + t1 ((i = 4096) + 4); + return i; +} + +void t3 (long long x) +{ + if (x != 0x80000fffULL) + abort (); +} + +long long t4 (void) +{ + long long i; + t3 ((i = 4096) + 0x7fffffffULL); + return i; +} + +main () +{ + if (t2 () != 4096) + abort (); + if (t4 () != 4096) + abort (); + exit (0); +} diff --git a/test/tests/20001101.c b/test/tests/20001101.c new file mode 100644 index 0000000..930ee32 --- /dev/null +++ b/test/tests/20001101.c @@ -0,0 +1,40 @@ +extern void abort(void); + +typedef struct +{ + unsigned int unchanging : 1; +} struc, *rtx; + +rtx dummy ( int *a, rtx *b) +{ + *a = 1; + *b = (rtx)7; + return (rtx)1; +} + +void bogus (insn, thread, delay_list) + rtx insn; + rtx thread; + rtx delay_list; +{ + rtx new_thread; + int must_annul; + + delay_list = dummy ( &must_annul, &new_thread); + if (delay_list == 0 && new_thread ) + { + thread = new_thread; + } + if (delay_list && must_annul) + insn->unchanging = 1; + if (new_thread != thread ) + abort(); +} + +int main() +{ + struc baz; + bogus (&baz, (rtx)7, 0); + exit(0); + return 0; +} diff --git a/test/tests/20001108-1.c b/test/tests/20001108-1.c new file mode 100644 index 0000000..a2a3255 --- /dev/null +++ b/test/tests/20001108-1.c @@ -0,0 +1,25 @@ +long long +signed_poly (long long sum, long x) +{ + sum += (long long) (long) sum * (long long) x; + return sum; +} + +unsigned long long +unsigned_poly (unsigned long long sum, unsigned long x) +{ + sum += (unsigned long long) (unsigned long) sum * (unsigned long long) x; + return sum; +} + +int +main (void) +{ + if (signed_poly (2LL, -3) != -4LL) + abort (); + + if (unsigned_poly (2ULL, 3) != 8ULL) + abort (); + + exit (0); +} diff --git a/test/tests/20001111-1.c b/test/tests/20001111-1.c new file mode 100644 index 0000000..85617c2 --- /dev/null +++ b/test/tests/20001111-1.c @@ -0,0 +1,41 @@ + +static int next_buffer = 0; +void bar (void); + +static int t = 1, u = 0; + +long +foo (unsigned int offset) +{ + unsigned i, buffer; + int x; + char *data; + + i = u; + if (i) + return i * 0xce2f; + + buffer = next_buffer; + data = buffer * 0xce2f; + for (i = 0; i < 2; i++) + bar (); + buffer = next_buffer; + return buffer * 0xce2f + offset; + +} + +void +bar (void) +{ +} + +int +main () +{ + if (foo (3) != 3) + abort (); + next_buffer = 1; + if (foo (2) != 0xce2f + 2) + abort (); + exit (0); +} diff --git a/test/tests/20001112-1.c b/test/tests/20001112-1.c new file mode 100644 index 0000000..6ce2f66 --- /dev/null +++ b/test/tests/20001112-1.c @@ -0,0 +1,10 @@ +int main () +{ + long long i = 1; + + i = i * 2 + 1; + + if (i != 3) + abort (); + exit (0); +} diff --git a/test/tests/20001121-1.c b/test/tests/20001121-1.c new file mode 100644 index 0000000..3647456 --- /dev/null +++ b/test/tests/20001121-1.c @@ -0,0 +1,19 @@ +double d; + +__inline__ double foo (void) +{ + return d; +} + +__inline__ int bar (void) +{ + foo(); + return 0; +} + +int main (void) +{ + if (bar ()) + abort (); + exit (0); +} diff --git a/test/tests/20001124-1.c b/test/tests/20001124-1.c new file mode 100644 index 0000000..c0ec8cf --- /dev/null +++ b/test/tests/20001124-1.c @@ -0,0 +1,76 @@ + +struct inode { + long long i_size; + struct super_block *i_sb; +}; + +struct file { + long long f_pos; +}; + +struct super_block { + int s_blocksize; + unsigned char s_blocksize_bits; + int s_hs; +}; + +static char * +isofs_bread(unsigned int block) +{ + if (block) + abort (); + exit(0); +} + +static int +do_isofs_readdir(struct inode *inode, struct file *filp) +{ + int bufsize = inode->i_sb->s_blocksize; + unsigned char bufbits = inode->i_sb->s_blocksize_bits; + unsigned int block, offset; + char *bh = 0; + int hs; + + if (filp->f_pos >= inode->i_size) + return 0; + + offset = filp->f_pos & (bufsize - 1); + block = filp->f_pos >> bufbits; + hs = inode->i_sb->s_hs; + + while (filp->f_pos < inode->i_size) { + if (!bh) + bh = isofs_bread(block); + + hs += block << bufbits; + + if (hs == 0) + filp->f_pos++; + + if (offset >= bufsize) + offset &= bufsize - 1; + + if (*bh) + filp->f_pos++; + + filp->f_pos++; + } + return 0; +} + +struct super_block s; +struct inode i; +struct file f; + +int +main(int argc, char **argv) +{ + s.s_blocksize = 512; + s.s_blocksize_bits = 9; + i.i_size = 2048; + i.i_sb = &s; + f.f_pos = 0; + + do_isofs_readdir(&i,&f); + abort (); +} diff --git a/test/tests/20001130-1.c b/test/tests/20001130-1.c new file mode 100644 index 0000000..4a996ee --- /dev/null +++ b/test/tests/20001130-1.c @@ -0,0 +1,21 @@ +static inline int bar(void) { return 1; } +static int mem[3]; + +static int foo(int x) +{ + if (x != 0) + return x; + + mem[x++] = foo(bar()); + + if (x != 1) + abort(); + + return 0; +} + +int main() +{ + foo(0); + return 0; +} diff --git a/test/tests/20001130-2.c b/test/tests/20001130-2.c new file mode 100644 index 0000000..c4ef6c7 --- /dev/null +++ b/test/tests/20001130-2.c @@ -0,0 +1,31 @@ +static int which_alternative = 3; + +static const char *i960_output_ldconst (void); + +static const char * +output_25 (void) +{ + switch (which_alternative) + { + case 0: + return "mov %1,%0"; + case 1: + return i960_output_ldconst (); + case 2: + return "ld %1,%0"; + case 3: + return "st %1,%0"; + } +} + +static const char *i960_output_ldconst (void) +{ + return "foo"; +} +int main(void) +{ + const char *s = output_25 () ; + if (s[0] != 's') + abort (); + exit (0); +} diff --git a/test/tests/20001203-1.c b/test/tests/20001203-1.c new file mode 100644 index 0000000..803c6a8 --- /dev/null +++ b/test/tests/20001203-1.c @@ -0,0 +1,24 @@ +/* Origin: PR c/410 from Jan Echternach + , + adapted to a testcase by Joseph Myers . +*/ + +extern void exit (int); + +static void +foo (void) +{ + struct { + long a; + char b[1]; + } x = { 2, { 0 } }; +} + +int +main (void) +{ + int tmp; + foo (); + tmp = 1; + exit (0); +} diff --git a/test/tests/20001203-2.c b/test/tests/20001203-2.c new file mode 100644 index 0000000..03aabed --- /dev/null +++ b/test/tests/20001203-2.c @@ -0,0 +1,123 @@ +struct obstack +{ + long chunk_size; + struct _obstack_chunk *chunk; + char *object_base; + char *next_free; + char *chunk_limit; + int alignment_mask; + unsigned maybe_empty_object; +}; + +struct objfile + { + struct objfile *next; + struct obstack type_obstack; + }; + +struct type + { + unsigned length; + struct objfile *objfile; + short nfields; + struct field + { + union field_location + { + int bitpos; + unsigned long physaddr; + char *physname; + } + loc; + int bitsize; + struct type *type; + char *name; + } + *fields; + }; + +struct type *alloc_type (void); +void * xmalloc (unsigned int z); +void _obstack_newchunk (struct obstack *o, int i); +void get_discrete_bounds (long long *lowp, long long *highp); + +extern void *memset(void *, int, __SIZE_TYPE__); + +struct type * +create_array_type (struct type *result_type, struct type *element_type) +{ + long long low_bound, high_bound; + if (result_type == ((void *)0)) + { + result_type = alloc_type (); + } + get_discrete_bounds (&low_bound, &high_bound); + (result_type)->length = + (element_type)->length * (high_bound - low_bound + 1); + (result_type)->nfields = 1; + (result_type)->fields = + (struct field *) ((result_type)->objfile != ((void *)0) + ? ( + { + struct obstack *__h = + (&(result_type)->objfile -> type_obstack); + { + struct obstack *__o = (__h); + int __len = ((sizeof (struct field))); + if (__o->chunk_limit - __o->next_free < __len) + _obstack_newchunk (__o, __len); + __o->next_free += __len; (void) 0; + }; + ({ + struct obstack *__o1 = (__h); + void *value; + value = (void *) __o1->object_base; + if (__o1->next_free == value) + __o1->maybe_empty_object = 1; + __o1->next_free = (((((__o1->next_free) - (char *) 0) + +__o1->alignment_mask) + & ~ (__o1->alignment_mask)) + + (char *) 0); + if (__o1->next_free - (char *)__o1->chunk + > __o1->chunk_limit - (char *)__o1->chunk) + __o1->next_free = __o1->chunk_limit; + __o1->object_base = __o1->next_free; + value; + }); + }) : xmalloc (sizeof (struct field))); + return (result_type); +} + +struct type * +alloc_type (void) +{ + abort (); +} +void * xmalloc (unsigned int z) +{ + return 0; +} +void _obstack_newchunk (struct obstack *o, int i) +{ + abort (); +} +void +get_discrete_bounds (long long *lowp, long long *highp) +{ + *lowp = 0; + *highp = 2; +} + +int main(void) +{ + struct type element_type; + struct type result_type; + + memset (&element_type, 0, sizeof (struct type)); + memset (&result_type, 0, sizeof (struct type)); + element_type.length = 4; + create_array_type (&result_type, &element_type); + if (result_type.length != 12) + abort (); + exit (0); +} diff --git a/test/tests/20001221-1.c b/test/tests/20001221-1.c new file mode 100644 index 0000000..4b6cc2b --- /dev/null +++ b/test/tests/20001221-1.c @@ -0,0 +1,7 @@ +int main () +{ + unsigned long long a; + if (! (a = 0xfedcba9876543210ULL)) + abort (); + exit (0); +} diff --git a/test/tests/20001228-1.c b/test/tests/20001228-1.c new file mode 100644 index 0000000..9c93e79 --- /dev/null +++ b/test/tests/20001228-1.c @@ -0,0 +1,28 @@ +int foo1(void) +{ + union { + char a[sizeof (unsigned)]; + unsigned b; + } u; + + u.b = 0x01; + return u.a[0]; +} + +int foo2(void) +{ + volatile union { + char a[sizeof (unsigned)]; + unsigned b; + } u; + + u.b = 0x01; + return u.a[0]; +} + +int main(void) +{ + if (foo1() != foo2()) + abort (); + exit (0); +} diff --git a/test/tests/20001229-1.c b/test/tests/20001229-1.c new file mode 100644 index 0000000..39b58af --- /dev/null +++ b/test/tests/20001229-1.c @@ -0,0 +1,49 @@ +/* This testcase originally provoked an unaligned access fault on Alpha. + + Since Digital Unix and Linux (and probably others) by default fix + these up in the kernel, the failure was not visible unless one + is sitting at the console examining logs. + + So: If we know how, ask the kernel to deliver SIGBUS instead so + that the test case visibly fails. */ + +#if defined(__alpha__) && (defined(__linux__) || defined(__osf__)) +#ifdef __linux__ +#include +#include + +static inline int +setsysinfo(unsigned long op, void *buffer, unsigned long size, + int *start, void *arg, unsigned long flag) +{ + syscall(__NR_osf_setsysinfo, op, buffer, size, start, arg, flag); +} + +#else +#include +#include +#endif + +static void __attribute__((constructor)) +trap_unaligned(void) +{ + unsigned int buf[2]; + buf[0] = SSIN_UACPROC; + buf[1] = UAC_SIGBUS | UAC_NOPRINT; + setsysinfo(SSI_NVPAIRS, buf, 1, 0, 0, 0); +} +#endif /* alpha */ + +void foo(char *a, char *b) { } + +void showinfo() +{ + char uname[33] = "", tty[38] = "/dev/"; + foo(uname, tty); +} + +int main() +{ + showinfo (); + exit (0); +} diff --git a/test/tests/20010106-1.c b/test/tests/20010106-1.c new file mode 100644 index 0000000..9e149c3 --- /dev/null +++ b/test/tests/20010106-1.c @@ -0,0 +1,30 @@ +/* Copyright 2001 Free Software Foundation + Contributed by Alexandre Oliva */ + +int f(int i) { + switch (i) + { + case -2: + return 33; + case -1: + return 0; + case 0: + return 7; + case 1: + return 4; + case 2: + return 3; + case 3: + return 15; + case 4: + return 9; + default: + abort (); + } +} + +int main() { + if (f(-1)) + abort (); + exit (0); +} diff --git a/test/tests/20010114-1.c b/test/tests/20010114-1.c new file mode 100644 index 0000000..ee8295e --- /dev/null +++ b/test/tests/20010114-1.c @@ -0,0 +1,15 @@ +/* Origin: PR c/1540 from Mattias Lampe , + adapted to a testcase by Joseph Myers . + GCC 2.95.2 fails, CVS GCC of 2001-01-13 passes. */ +extern void abort (void); +extern void exit (int); + +int +main (void) +{ + int array1[1] = { 1 }; + int array2[2][1]= { { 1 }, { 0 } }; + if (array1[0] != 1) + abort (); + exit (0); +} diff --git a/test/tests/20010116-1.c b/test/tests/20010116-1.c new file mode 100644 index 0000000..b77d6fb --- /dev/null +++ b/test/tests/20010116-1.c @@ -0,0 +1,32 @@ +/* Distilled from optimization/863. */ + +extern void abort (void); +extern void exit (int); +extern void ok (int); + +typedef struct +{ + int x, y, z; +} Data; + +void find (Data *first, Data *last) +{ + int i; + for (i = (last - first) >> 2; i > 0; --i) + ok(i); + abort (); +} + +void ok(int i) +{ + if (i != 1) + abort (); + exit (0); +} + +int +main () +{ + Data DataList[4]; + find (DataList + 0, DataList + 4); +} diff --git a/test/tests/20010118-1.c b/test/tests/20010118-1.c new file mode 100644 index 0000000..ee5197c --- /dev/null +++ b/test/tests/20010118-1.c @@ -0,0 +1,37 @@ +typedef struct { + int a, b, c, d, e, f; +} A; + +void foo (A *v, int w, int x, int *y, int *z) +{ +} + +void +bar (A *v, int x, int y, int w, int h) +{ + if (v->a != x || v->b != y) { + int oldw = w; + int oldh = h; + int e = v->e; + int f = v->f; + int dx, dy; + foo(v, 0, 0, &w, &h); + dx = (oldw - w) * (double) e/2.0; + dy = (oldh - h) * (double) f/2.0; + x += dx; + y += dy; + v->a = x; + v->b = y; + v->c = w; + v->d = h; + } +} + +int main () +{ + A w = { 100, 110, 20, 30, -1, -1 }; + bar (&w,400,420,50,70); + if (w.d != 70) + abort(); + exit(0); +} diff --git a/test/tests/20010119-1.c b/test/tests/20010119-1.c new file mode 100644 index 0000000..c2a691a --- /dev/null +++ b/test/tests/20010119-1.c @@ -0,0 +1,23 @@ +#ifdef __OPTIMIZE__ +extern void undef (void); + +void bar (unsigned x) { } +void baz (unsigned x) { } + +extern inline void foo (int a, int b) +{ + int c = 0; + while (c++ < b) + (__builtin_constant_p (a) ? ((a) > 20000 ? undef () : bar (a)) : baz (a)); +} +#else +void foo (int a, int b) +{ +} +#endif + +int main (void) +{ + foo(10, 100); + exit (0); +} diff --git a/test/tests/20010123-1.c b/test/tests/20010123-1.c new file mode 100644 index 0000000..9c0989b --- /dev/null +++ b/test/tests/20010123-1.c @@ -0,0 +1,23 @@ +extern void abort (); +extern void exit (int); + +struct s +{ + int value; + char *string; +}; + +int main (void) +{ + int i; + for (i = 0; i < 4; i++) + { + struct s *t = & (struct s) { 3, "hey there" }; + if (t->value != 3) + abort(); + t->value = 4; + if (t->value != 4) + abort(); + } + exit (0); +} diff --git a/test/tests/20010206-1.c b/test/tests/20010206-1.c new file mode 100644 index 0000000..3aa8cad --- /dev/null +++ b/test/tests/20010206-1.c @@ -0,0 +1,16 @@ +int foo (void) +{ + int i; +#line 1 "20010206-1.c" + if (0) i = 1; else i +#line 1 "20010206-1.c" + = 26; + return i; +} + +int main () +{ + if (foo () != 26) + abort (); + exit (0); +} diff --git a/test/tests/20010221-1.c b/test/tests/20010221-1.c new file mode 100644 index 0000000..3caff81 --- /dev/null +++ b/test/tests/20010221-1.c @@ -0,0 +1,17 @@ + +int n = 2; + +main () +{ + int i, x = 45; + + for (i = 0; i < n; i++) + { + if (i != 0) + x = ( i > 0 ) ? i : 0; + } + + if (x != 1) + abort (); + exit (0); +} diff --git a/test/tests/20010222-1.c b/test/tests/20010222-1.c new file mode 100644 index 0000000..c3a2b18 --- /dev/null +++ b/test/tests/20010222-1.c @@ -0,0 +1,9 @@ +int a[2] = { 18, 6 }; + +int main () +{ + int b = (-3 * a[0] -3 * a[1]) / 12; + if (b != -6) + abort (); + exit (0); +} diff --git a/test/tests/20010224-1.c b/test/tests/20010224-1.c new file mode 100644 index 0000000..1d04fd1 --- /dev/null +++ b/test/tests/20010224-1.c @@ -0,0 +1,44 @@ +extern void abort (void); + +typedef signed short int16_t; +typedef unsigned short uint16_t; + +int16_t logadd (int16_t *a, int16_t *b); +void ba_compute_psd (int16_t start); + +int16_t masktab[6] = { 1, 2, 3, 4, 5}; +int16_t psd[6] = { 50, 40, 30, 20, 10}; +int16_t bndpsd[6] = { 1, 2, 3, 4, 5}; + +void ba_compute_psd (int16_t start) +{ + int i,j,k; + int16_t lastbin = 4; + + j = start; + k = masktab[start]; + + bndpsd[k] = psd[j]; + j++; + + for (i = j; i < lastbin; i++) { + bndpsd[k] = logadd(&bndpsd[k], &psd[j]); + j++; + } +} + +int16_t logadd (int16_t *a, int16_t *b) +{ + return *a + *b; +} + +int main (void) +{ + int i; + + ba_compute_psd (0); + + if (bndpsd[1] != 140) abort (); + return 0; +} + diff --git a/test/tests/20010325-1.c b/test/tests/20010325-1.c new file mode 100644 index 0000000..100679f --- /dev/null +++ b/test/tests/20010325-1.c @@ -0,0 +1,15 @@ +/* Origin: Joseph Myers . + + This tests for inconsistency in whether wide STRING_CSTs use the host + or the target endianness. */ + +extern void exit (int); +extern void abort (void); + +int +main (void) +{ + if (L"a" "b"[1] != L'b') + abort (); + exit (0); +} diff --git a/test/tests/20010329-1.c b/test/tests/20010329-1.c new file mode 100644 index 0000000..e28d6d7 --- /dev/null +++ b/test/tests/20010329-1.c @@ -0,0 +1,14 @@ +#include + +int main (void) +{ + void *x = ((void *)((unsigned int)INT_MAX + 2)); + void *y = ((void *)((unsigned long)LONG_MAX + 2)); + if (x >= ((void *)((unsigned int)INT_MAX + 1)) + && x <= ((void *)((unsigned int)INT_MAX + 6)) + && y >= ((void *)((unsigned long)LONG_MAX + 1)) + && y <= ((void *)((unsigned long)LONG_MAX + 6))) + exit (0); + else + abort (); +} diff --git a/test/tests/20010403-1.c b/test/tests/20010403-1.c new file mode 100644 index 0000000..6a8f2a4 --- /dev/null +++ b/test/tests/20010403-1.c @@ -0,0 +1,36 @@ +void b (int *); +void c (int, int); +void d (int); + +int e; + +void a (int x, int y) +{ + int f = x ? e : 0; + int z = y; + + b (&y); + c (z, y); + d (f); +} + +void b (int *y) +{ + (*y)++; +} + +void c (int x, int y) +{ + if (x == y) + abort (); +} + +void d (int x) +{ +} + +int main (void) +{ + a (0, 0); + exit (0); +} diff --git a/test/tests/20010409-1.c b/test/tests/20010409-1.c new file mode 100644 index 0000000..95a5dc3 --- /dev/null +++ b/test/tests/20010409-1.c @@ -0,0 +1,43 @@ +typedef __SIZE_TYPE__ size_t; +extern size_t strlen (const char *s); + +typedef struct A { + int a, b; +} A; + +typedef struct B { + struct A **a; + int b; +} B; + +A *a; +int b = 1, c; +B d[1]; + +void foo (A *x, const char *y, int z) +{ + c = y[4] + z * 25; +} + +A *bar (const char *v, int w, int x, const char *y, int z) +{ + if (w) + abort (); + exit (0); +} + +void test (const char *x, int *y) +{ + foo (d->a[d->b], "test", 200); + d->a[d->b] = bar (x, b ? 0 : 65536, strlen (x), "test", 201); + d->a[d->b]->a++; + if (y) + d->a[d->b]->b = *y; +} + +int main () +{ + d->b = 0; + d->a = &a; + test ("", 0); +} diff --git a/test/tests/20010422-1.c b/test/tests/20010422-1.c new file mode 100644 index 0000000..5c6bccc --- /dev/null +++ b/test/tests/20010422-1.c @@ -0,0 +1,15 @@ +unsigned int foo(unsigned int x) +{ + if (x < 5) + x = 4; + else + x = 8; + return x; +} + +int main(void) +{ + if (foo (8) != 8) + abort (); + exit (0); +} diff --git a/test/tests/20010518-1.c b/test/tests/20010518-1.c new file mode 100644 index 0000000..94b2d8f --- /dev/null +++ b/test/tests/20010518-1.c @@ -0,0 +1,28 @@ +/* Leaf functions with many arguments. */ + +int +add (int a, + int b, + int c, + int d, + int e, + int f, + int g, + int h, + int i, + int j, + int k, + int l, + int m) +{ + return a+b+c+d+e+f+g+h+i+j+k+l+m; +} + +int +main(void) +{ + if (add (1,2,3,4,5,6,7,8,9,10,11,12,13) != 91) + abort (); + + exit (0); +} diff --git a/test/tests/20010518-2.c b/test/tests/20010518-2.c new file mode 100644 index 0000000..1990f8e --- /dev/null +++ b/test/tests/20010518-2.c @@ -0,0 +1,38 @@ +/* Mis-aligned packed structures. */ + +typedef struct +{ + char b0; + char b1; + char b2; + char b3; + char b4; + char b5; +} __attribute__ ((packed)) b_struct; + + +typedef struct +{ + short a; + long b; + short c; + short d; + b_struct e; +} __attribute__ ((packed)) a_struct; + + +int +main(void) +{ + volatile a_struct *a; + volatile a_struct b; + + a = &b; + *a = (a_struct){1,2,3,4}; + a->e.b4 = 'c'; + + if (a->a != 1 || a->b != 2 || a->c != 3 || a->d != 4 || a->e.b4 != 'c') + abort (); + + exit (0); +} diff --git a/test/tests/20010520-1.c b/test/tests/20010520-1.c new file mode 100644 index 0000000..fa94418 --- /dev/null +++ b/test/tests/20010520-1.c @@ -0,0 +1,12 @@ +static unsigned int expr_hash_table_size = 1; + +int +main () +{ + int del = 1; + unsigned int i = 0; + + if (i < expr_hash_table_size && del) + exit (0); + abort (); +} diff --git a/test/tests/20010604-1.c b/test/tests/20010604-1.c new file mode 100644 index 0000000..e0deaf5 --- /dev/null +++ b/test/tests/20010604-1.c @@ -0,0 +1,14 @@ +#include + +int f (int a, int b, int c, _Bool d, _Bool e, _Bool f, char g) +{ + if (g != 1 || d != true || e != true || f != true) abort (); + return a + b + c; +} + +int main (void) +{ + if (f (1, 2, -3, true, true, true, '\001')) + abort (); + exit (0); +} diff --git a/test/tests/20010605-1.c b/test/tests/20010605-1.c new file mode 100644 index 0000000..f36e10b --- /dev/null +++ b/test/tests/20010605-1.c @@ -0,0 +1,11 @@ + inline int fff (int x) + { + return x*10; + } +int main () +{ + int v = 42; + + + return (fff (v) != 420); +} diff --git a/test/tests/20010711-1.c b/test/tests/20010711-1.c new file mode 100644 index 0000000..12971a5 --- /dev/null +++ b/test/tests/20010711-1.c @@ -0,0 +1,13 @@ +void foo (int *a) {} + +int main () +{ + int a; + if (&a == 0) + abort (); + else + { + foo (&a); + exit (0); + } +} diff --git a/test/tests/20010717-1.c b/test/tests/20010717-1.c new file mode 100644 index 0000000..65199da --- /dev/null +++ b/test/tests/20010717-1.c @@ -0,0 +1,22 @@ +extern void abort (void); + +int +main () +{ + int i, j; + unsigned long u, r1, r2; + + i = -16; + j = 1; + u = i + j; + + /* no sign extension upon shift */ + r1 = u >> 1; + /* sign extension upon shift, but there shouldn't be */ + r2 = ((unsigned long) (i + j)) >> 1; + + if (r1 != r2) + abort (); + + return 0; +} diff --git a/test/tests/20010723-1.c b/test/tests/20010723-1.c new file mode 100644 index 0000000..9d4b29f --- /dev/null +++ b/test/tests/20010723-1.c @@ -0,0 +1,16 @@ +int +test () +{ + int biv,giv; + for (biv = 0, giv = 0; giv != 8; biv++) + giv = biv*8; + return giv; +} + + +main() +{ + if (test () != 8) + abort (); + exit (0); +} diff --git a/test/tests/20010910-1.c b/test/tests/20010910-1.c new file mode 100644 index 0000000..185e29d --- /dev/null +++ b/test/tests/20010910-1.c @@ -0,0 +1,59 @@ +/* Test case contributed by Ingo Rohloff . + Code distilled from Linux kernel. */ + +/* Compile this program with a gcc-2.95.2 using + "gcc -O2" and run it. The result will be that + rx_ring[1].next == 0 (it should be == 14) + and + ep.skbuff[4] == 5 (it should be 0) +*/ + +extern void abort(void); + +struct epic_rx_desc +{ + unsigned int next; +}; + +struct epic_private +{ + struct epic_rx_desc *rx_ring; + unsigned int rx_skbuff[5]; +}; + +static void epic_init_ring(struct epic_private *ep) +{ + int i; + + for (i = 0; i < 5; i++) + { + ep->rx_ring[i].next = 10 + (i+1)*2; + ep->rx_skbuff[i] = 0; + } + ep->rx_ring[i-1].next = 10; +} + +static int check_rx_ring[5] = { 12,14,16,18,10 }; + +int main(void) +{ + struct epic_private ep; + struct epic_rx_desc rx_ring[5]; + int i; + + for (i=0;i<5;i++) + { + rx_ring[i].next=0; + ep.rx_skbuff[i]=5; + } + + ep.rx_ring=rx_ring; + epic_init_ring(&ep); + + for (i=0;i<5;i++) + { + if ( rx_ring[i].next != check_rx_ring[i] ) abort(); + if ( ep.rx_skbuff[i] != 0 ) abort(); + } + return 0; +} diff --git a/test/tests/20010915-1.c b/test/tests/20010915-1.c new file mode 100644 index 0000000..5a04bf5 --- /dev/null +++ b/test/tests/20010915-1.c @@ -0,0 +1,71 @@ +/* Bug in reorg.c, deleting the "++" in the last loop in main. + Origin: . */ + +extern void f (void); +extern int x (int, char **); +extern int r (const char *); +extern char *s (char *, char **); +extern char *m (char *); +char *u; +char *h; +int check = 0; +int o = 0; + +int main (int argc, char **argv) +{ + char *args[] = {"a", "b", "c", "d", "e"}; + if (x (5, args) != 0 || check != 2 || o != 5) + abort (); + exit (0); +} + +int x (int argc, char **argv) +{ + int opt = 0; + char *g = 0; + char *p = 0; + + if (argc > o && argc > 2 && argv[o]) + { + g = s (argv[o], &p); + if (g) + { + *g++ = '\0'; + h = s (g, &p); + if (g == p) + h = m (g); + } + u = s (argv[o], &p); + if (argv[o] == p) + u = m (argv[o]); + } + else + abort (); + + while (++o < argc) + if (r (argv[o]) == 0) + return 1; + + return 0; +} + +char *m (char *x) { abort (); } +char *s (char *v, char **pp) +{ + if (strcmp (v, "a") != 0 || check++ > 1) + abort (); + *pp = v+1; + return 0; +} + +int r (const char *f) +{ + static char c[2] = "b"; + static int cnt = 0; + + if (*f != *c || f[1] != c[1] || cnt > 3) + abort (); + c[0]++; + cnt++; + return 1; +} diff --git a/test/tests/20010924-1.c b/test/tests/20010924-1.c new file mode 100644 index 0000000..a849541 --- /dev/null +++ b/test/tests/20010924-1.c @@ -0,0 +1,84 @@ +/* Verify that flexible arrays can be initialized from STRING_CST + constructors. */ + +#if 1 +/* Baselines. */ +struct { + char a1c; + char *a1p; +} a1 = { + '4', + "62" +}; +#endif + +#if 1 +struct { + char a2c; + char a2p[2]; +} a2 = { + 'v', + "cq" +}; +#endif + +#if 1 +/* The tests. */ +struct { + char y4c; + char y4p[]; +} y4 = { + '9', + { 'e', 'b' } +}; + +struct { + char x3c; + char x3p[]; +} x3 = { + 'o', + "wx" +}; +#endif + + +main() +{ +#if 1 + if (a1.a1c != '4') + abort(); + if (a1.a1p[0] != '6') + abort(); + if (a1.a1p[1] != '2') + abort(); + if (a1.a1p[2] != '\0') + abort(); +#endif + +#if 1 + if (a2.a2c != 'v') + abort(); + if (a2.a2p[0] != 'c') + abort(); + if (a2.a2p[1] != 'q') + abort(); +#endif + +#if 1 + if (x3.x3c != 'o') + abort(); + if (x3.x3p[0] != 'w') + abort(); + if (x3.x3p[1] != 'x') + abort(); + + if (y4.y4c != '9') + abort(); + if (y4.y4p[0] != 'e') + abort(); + if (y4.y4p[1] != 'b') + abort(); +#endif + + return 0; +} diff --git a/test/tests/20010925-1.c b/test/tests/20010925-1.c new file mode 100644 index 0000000..90507e7 --- /dev/null +++ b/test/tests/20010925-1.c @@ -0,0 +1,24 @@ +extern void exit(int); +extern void abort (void); + +extern void * memcpy (void *, const void *, __SIZE_TYPE__); +int foo (void *, void *, unsigned int c); + +int src[10]; +int dst[10]; + +int main() +{ + if (foo (dst, src, 10) != 0) + abort(); + exit(0); +} + +int foo (void *a, void *b, unsigned int c) +{ + if (c == 0) + return 1; + + memcpy (a, b, c); + return 0; +} diff --git a/test/tests/20011008-3.c b/test/tests/20011008-3.c new file mode 100644 index 0000000..9cc4623 --- /dev/null +++ b/test/tests/20011008-3.c @@ -0,0 +1,105 @@ +extern void exit (int); +extern void abort (void); + +typedef unsigned int u_int32_t; +typedef unsigned char u_int8_t; +typedef int int32_t; + +typedef enum { + TXNLIST_DELETE, + TXNLIST_LSN, + TXNLIST_TXNID, + TXNLIST_PGNO +} db_txnlist_type; + +struct __db_lsn; typedef struct __db_lsn DB_LSN; +struct __db_lsn { + u_int32_t file; + u_int32_t offset; +}; +struct __db_txnlist; typedef struct __db_txnlist DB_TXNLIST; + +struct __db_txnlist { + db_txnlist_type type; + struct { struct __db_txnlist *le_next; struct __db_txnlist **le_prev; } links; + union { + struct { + u_int32_t txnid; + int32_t generation; + int32_t aborted; + } t; + struct { + + + u_int32_t flags; + int32_t fileid; + u_int32_t count; + char *fname; + } d; + struct { + int32_t ntxns; + int32_t maxn; + DB_LSN *lsn_array; + } l; + struct { + int32_t nentries; + int32_t maxentry; + char *fname; + int32_t fileid; + void *pgno_array; + u_int8_t uid[20]; + } p; + } u; +}; + +int log_compare (const DB_LSN *a, const DB_LSN *b) +{ + return 1; +} + + +int +__db_txnlist_lsnadd(int val, DB_TXNLIST *elp, DB_LSN *lsnp, u_int32_t flags) +{ + int i; + + for (i = 0; i < (!(flags & (0x1)) ? 1 : elp->u.l.ntxns); i++) + { + int __j; + DB_LSN __tmp; + val++; + for (__j = 0; __j < elp->u.l.ntxns - 1; __j++) + if (log_compare(&elp->u.l.lsn_array[__j], &elp->u.l.lsn_array[__j + 1]) < 0) + { + __tmp = elp->u.l.lsn_array[__j]; + elp->u.l.lsn_array[__j] = elp->u.l.lsn_array[__j + 1]; + elp->u.l.lsn_array[__j + 1] = __tmp; + } + } + + *lsnp = elp->u.l.lsn_array[0]; + return val; +} + +#ifndef STACK_SIZE +#define VLEN 1235 +#else +#define VLEN (STACK_SIZE/100) +#endif + +int main (void) +{ + DB_TXNLIST el; + DB_LSN lsn, lsn_a[VLEN]; + + el.u.l.ntxns = VLEN-1; + el.u.l.lsn_array = lsn_a; + + if (__db_txnlist_lsnadd (0, &el, &lsn, 0) != 1) + abort (); + + if (__db_txnlist_lsnadd (0, &el, &lsn, 1) != VLEN-1) + abort (); + + exit (0); +} diff --git a/test/tests/20011019-1.c b/test/tests/20011019-1.c new file mode 100644 index 0000000..ebaa411 --- /dev/null +++ b/test/tests/20011019-1.c @@ -0,0 +1,18 @@ +extern void exit (int); +extern void abort (void); + +struct { int a; int b[5]; } x; +int *y; + +int foo (void) +{ + return y - x.b; +} + +int main (void) +{ + y = x.b; + if (foo ()) + abort (); + exit (0); +} diff --git a/test/tests/20011024-1.c b/test/tests/20011024-1.c new file mode 100644 index 0000000..5b871bb --- /dev/null +++ b/test/tests/20011024-1.c @@ -0,0 +1,22 @@ +/* Test whether store motion recognizes pure functions as potentially reading + any memory. */ + +typedef __SIZE_TYPE__ size_t; +extern void *memcpy (void *dest, const void *src, size_t n); +extern size_t strlen (const char *s); +extern int strcmp (const char *s1, const char *s2) __attribute__((pure)); + +char buf[50]; + +static void foo (void) +{ + if (memcpy (buf, "abc", 4) != buf) abort (); + if (strcmp (buf, "abc")) abort (); + memcpy (buf, "abcdefgh", strlen ("abcdefgh") + 1); +} + +int main (void) +{ + foo (); + return 0; +} diff --git a/test/tests/20011109-1.c b/test/tests/20011109-1.c new file mode 100644 index 0000000..0f013d3 --- /dev/null +++ b/test/tests/20011109-1.c @@ -0,0 +1,58 @@ +void fail1(void) +{ + abort (); +} +void fail2(void) +{ + abort (); +} +void fail3(void) +{ + abort (); +} +void fail4(void) +{ + abort (); +} + + +void foo(long x) +{ + switch (x) + { + case -6: + fail1 (); break; + case 0: + fail2 (); break; + case 1: case 2: + break; + case 3: case 4: case 5: + fail3 (); + break; + default: + fail4 (); + break; + } + switch (x) + { + + case -3: + fail1 (); break; + case 0: case 4: + fail2 (); break; + case 1: case 3: + break; + case 2: case 8: + abort (); + break; + default: + fail4 (); + break; + } +} + +int main(void) +{ + foo (1); + exit (0); +} diff --git a/test/tests/20011109-2.c b/test/tests/20011109-2.c new file mode 100644 index 0000000..1abbbf2 --- /dev/null +++ b/test/tests/20011109-2.c @@ -0,0 +1,10 @@ +int main(void) +{ + char *c1 = "foo"; + char *c2 = "foo"; + int i; + for (i = 0; i < 3; i++) + if (c1[i] != c2[i]) + abort (); + exit (0); +} diff --git a/test/tests/20011113-1.c b/test/tests/20011113-1.c new file mode 100644 index 0000000..a2eb86b --- /dev/null +++ b/test/tests/20011113-1.c @@ -0,0 +1,55 @@ +typedef __SIZE_TYPE__ size_t; +extern void *memcpy (void *__restrict, const void *__restrict, size_t); +extern void abort (void); +extern void exit (int); + +typedef struct t +{ + unsigned a : 16; + unsigned b : 8; + unsigned c : 8; + long d[4]; +} *T; + +typedef struct { + long r[3]; +} U; + +T bar (U, unsigned int); + +T foo (T x) +{ + U d, u; + + memcpy (&u, &x->d[1], sizeof u); + d = u; + return bar (d, x->b); +} + +T baz (T x) +{ + U d, u; + + d.r[0] = 0x123456789; + d.r[1] = 0xfedcba987; + d.r[2] = 0xabcdef123; + memcpy (&u, &x->d[1], sizeof u); + d = u; + return bar (d, x->b); +} + +T bar (U d, unsigned int m) +{ + if (d.r[0] != 21 || d.r[1] != 22 || d.r[2] != 23) + abort (); + return 0; +} + +struct t t = { 26, 0, 0, { 0, 21, 22, 23 }}; + +int main (void) +{ + baz (&t); + foo (&t); + exit (0); +} diff --git a/test/tests/20011114-1.c b/test/tests/20011114-1.c new file mode 100644 index 0000000..9746c1e --- /dev/null +++ b/test/tests/20011114-1.c @@ -0,0 +1,11 @@ +char foo(char bar[]) +{ + return bar[1]; +} +extern char foo(char *); +int main(void) +{ + if (foo("xy") != 'y') + abort (); + exit (0); +} diff --git a/test/tests/20011115-1.c b/test/tests/20011115-1.c new file mode 100644 index 0000000..17a3565 --- /dev/null +++ b/test/tests/20011115-1.c @@ -0,0 +1,26 @@ +extern void exit (int); + +static inline int +foo (void) +{ +#ifdef __OPTIMIZE__ + extern int undefined_reference; + return undefined_reference; +#else + return 0; +#endif +} + +static inline int +bar (void) +{ + if (foo == foo) + return 1; + else + return foo (); +} + +int main (void) +{ + exit (0); +} diff --git a/test/tests/20011121-1.c b/test/tests/20011121-1.c new file mode 100644 index 0000000..3e3d03a --- /dev/null +++ b/test/tests/20011121-1.c @@ -0,0 +1,19 @@ +struct s +{ + int i[18]; + char f; + char b[2]; +}; + +struct s s1; + +int +main() +{ + struct s s2; + s2.b[0] = 100; + __builtin_memcpy(&s2, &s1, ((unsigned int) &((struct s *)0)->b)); + if (s2.b[0] != 100) + abort(); + exit(0); +} diff --git a/test/tests/20011126-1.c b/test/tests/20011126-1.c new file mode 100644 index 0000000..ede938b --- /dev/null +++ b/test/tests/20011126-1.c @@ -0,0 +1,19 @@ +/* Produced a overflow in ifcvt.c, causing S to contain 0xffffffff7fffffff. */ + +int a = 1; + +int main () +{ + long long s; + + s = a; + if (s < 0) + s = -2147483648LL; + else + s = 2147483647LL; + + if (s < 0) + abort (); + + return 0; +} diff --git a/test/tests/20011126-2.c b/test/tests/20011126-2.c new file mode 100644 index 0000000..f662505 --- /dev/null +++ b/test/tests/20011126-2.c @@ -0,0 +1,43 @@ +/* Problem originally visible on ia64. + + There is a partial redundancy of "in + 1" that makes GCSE want to + transform the final while loop to + + p = in + 1; + tmp = p; + ... + goto start; + top: + tmp = tmp + 1; + start: + in = tmp; + if (in < p) goto top; + + We miscalculate the number of loop iterations as (p - tmp) = 0 + instead of (p - in) = 1, which results in overflow in the doloop + optimization. */ + +static const char * +test (const char *in, char *out) +{ + while (1) + { + if (*in == 'a') + { + const char *p = in + 1; + while (*p == 'x') + ++p; + if (*p == 'b') + return p; + while (in < p) + *out++ = *in++; + } + } +} + +int main () +{ + char out[4]; + test ("aab", out); + return 0; +} diff --git a/test/tests/20011128-1.c b/test/tests/20011128-1.c new file mode 100644 index 0000000..d1f777a --- /dev/null +++ b/test/tests/20011128-1.c @@ -0,0 +1,5 @@ +main() +{ + char blah[33] = "01234567890123456789"; + exit (0); +} diff --git a/test/tests/20011217-1.c b/test/tests/20011217-1.c new file mode 100644 index 0000000..af9919f --- /dev/null +++ b/test/tests/20011217-1.c @@ -0,0 +1,12 @@ +int +main() +{ + double x = 1.0; + double y = 2.0; + + if ((y > x--) != 1) + abort (); + exit (0); +} + + diff --git a/test/tests/20011219-1.c b/test/tests/20011219-1.c new file mode 100644 index 0000000..d6455ab --- /dev/null +++ b/test/tests/20011219-1.c @@ -0,0 +1,49 @@ +/* This testcase failed on IA-32 at -O and above, because combine attached + a REG_LABEL note to jump instruction already using JUMP_LABEL. */ + +extern void abort (void); +extern void exit (int); + +enum X { A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q }; + +void +bar (const char *x, int y, const char *z) +{ +} + +long +foo (enum X x, const void *y) +{ + long a; + + switch (x) + { + case K: + a = *(long *)y; + break; + case L: + a = *(long *)y; + break; + case M: + a = *(long *)y; + break; + case N: + a = *(long *)y; + break; + case O: + a = *(long *)y; + break; + default: + bar ("foo", 1, "bar"); + } + return a; +} + +int +main () +{ + long i = 24; + if (foo (N, &i) != 24) + abort (); + exit (0); +} diff --git a/test/tests/20011223-1.c b/test/tests/20011223-1.c new file mode 100644 index 0000000..18fb720 --- /dev/null +++ b/test/tests/20011223-1.c @@ -0,0 +1,22 @@ +/* Origin: Joseph Myers . */ +/* Case labels in a switch statement are converted to the promoted + type of the controlling expression, not an unpromoted version. + Reported as PR c/2454 by + Andreas Krakowczyk . */ + +extern void exit (int); +extern void abort (void); + +static int i; + +int +main (void) +{ + i = -1; + switch ((signed char) i) { + case 255: + abort (); + default: + exit (0); + } +} diff --git a/test/tests/20020103-1.c b/test/tests/20020103-1.c new file mode 100644 index 0000000..c010aea --- /dev/null +++ b/test/tests/20020103-1.c @@ -0,0 +1,28 @@ +/* On h8300 port, the following used to be broken with -mh or -ms. */ + +extern void abort (void); +extern void exit (int); + +unsigned long +foo (unsigned long a) +{ + return a ^ 0x0000ffff; +} + +unsigned long +bar (unsigned long a) +{ + return a ^ 0xffff0000; +} + +int +main () +{ + if (foo (0) != 0x0000ffff) + abort (); + + if (bar (0) != 0xffff0000) + abort (); + + exit (0); +} diff --git a/test/tests/20020107-1.c b/test/tests/20020107-1.c new file mode 100644 index 0000000..10a2864 --- /dev/null +++ b/test/tests/20020107-1.c @@ -0,0 +1,28 @@ +/* This testcase failed because - 1 - buf was simplified into ~buf and when + later expanding it back into - buf + -1, -1 got lost. */ + +extern void abort (void); +extern void exit (int); + +static void +bar (int x) +{ + if (!x) + abort (); +} + +char buf[10]; + +inline char * +foo (char *tmp) +{ + //asm ("" : "=r" (tmp) : "0" (tmp)); + return tmp + 2; +} + +int +main (void) +{ + bar ((foo (buf) - 1 - buf) == 1); + exit (0); +} diff --git a/test/tests/20020108-1.c b/test/tests/20020108-1.c new file mode 100644 index 0000000..58f9667 --- /dev/null +++ b/test/tests/20020108-1.c @@ -0,0 +1,203 @@ +/* This file tests shifts in various integral modes. */ + +#include + +#define CAT(A, B) A ## B + +#define REPEAT_8 \ +REPEAT_FN ( 0) \ +REPEAT_FN ( 1) \ +REPEAT_FN ( 2) \ +REPEAT_FN ( 3) \ +REPEAT_FN ( 4) \ +REPEAT_FN ( 5) \ +REPEAT_FN ( 6) \ +REPEAT_FN ( 7) + +#define REPEAT_16 \ +REPEAT_8 \ +REPEAT_FN ( 8) \ +REPEAT_FN ( 9) \ +REPEAT_FN (10) \ +REPEAT_FN (11) \ +REPEAT_FN (12) \ +REPEAT_FN (13) \ +REPEAT_FN (14) \ +REPEAT_FN (15) + +#define REPEAT_32 \ +REPEAT_16 \ +REPEAT_FN (16) \ +REPEAT_FN (17) \ +REPEAT_FN (18) \ +REPEAT_FN (19) \ +REPEAT_FN (20) \ +REPEAT_FN (21) \ +REPEAT_FN (22) \ +REPEAT_FN (23) \ +REPEAT_FN (24) \ +REPEAT_FN (25) \ +REPEAT_FN (26) \ +REPEAT_FN (27) \ +REPEAT_FN (28) \ +REPEAT_FN (29) \ +REPEAT_FN (30) \ +REPEAT_FN (31) + +/* Define 8-bit shifts. */ +#if CHAR_BIT == 8 +typedef unsigned int u8 __attribute__((mode(QI))); +typedef signed int s8 __attribute__((mode(QI))); + +#define REPEAT_FN(COUNT) \ +u8 CAT (ashift_qi_, COUNT) (u8 n) { return n << COUNT; } +REPEAT_8 +#undef REPEAT_FN + +#define REPEAT_FN(COUNT) \ +u8 CAT (lshiftrt_qi_, COUNT) (u8 n) { return n >> COUNT; } +REPEAT_8 +#undef REPEAT_FN + +#define REPEAT_FN(COUNT) \ +s8 CAT (ashiftrt_qi_, COUNT) (s8 n) { return n >> COUNT; } +REPEAT_8 +#undef REPEAT_FN +#endif /* CHAR_BIT == 8 */ + +/* Define 16-bit shifts. */ +#if CHAR_BIT == 8 || CHAR_BIT == 16 +#if CHAR_BIT == 8 +typedef unsigned int u16 __attribute__((mode(HI))); +typedef signed int s16 __attribute__((mode(HI))); +#elif CHAR_BIT == 16 +typedef unsigned int u16 __attribute__((mode(QI))); +typedef signed int s16 __attribute__((mode(QI))); +#endif + +#define REPEAT_FN(COUNT) \ +u16 CAT (ashift_hi_, COUNT) (u16 n) { return n << COUNT; } +REPEAT_16 +#undef REPEAT_FN + +#define REPEAT_FN(COUNT) \ +u16 CAT (lshiftrt_hi_, COUNT) (u16 n) { return n >> COUNT; } +REPEAT_16 +#undef REPEAT_FN + +#define REPEAT_FN(COUNT) \ +s16 CAT (ashiftrt_hi_, COUNT) (s16 n) { return n >> COUNT; } +REPEAT_16 +#undef REPEAT_FN +#endif /* CHAR_BIT == 8 || CHAR_BIT == 16 */ + +/* Define 32-bit shifts. */ +#if CHAR_BIT == 8 || CHAR_BIT == 16 || CHAR_BIT == 32 +#if CHAR_BIT == 8 +typedef unsigned int u32 __attribute__((mode(SI))); +typedef signed int s32 __attribute__((mode(SI))); +#elif CHAR_BIT == 16 +typedef unsigned int u32 __attribute__((mode(HI))); +typedef signed int s32 __attribute__((mode(HI))); +#elif CHAR_BIT == 32 +typedef unsigned int u32 __attribute__((mode(QI))); +typedef signed int s32 __attribute__((mode(QI))); +#endif + +#define REPEAT_FN(COUNT) \ +u32 CAT (ashift_si_, COUNT) (u32 n) { return n << COUNT; } +REPEAT_32 +#undef REPEAT_FN + +#define REPEAT_FN(COUNT) \ +u32 CAT (lshiftrt_si_, COUNT) (u32 n) { return n >> COUNT; } +REPEAT_32 +#undef REPEAT_FN + +#define REPEAT_FN(COUNT) \ +s32 CAT (ashiftrt_si_, COUNT) (s32 n) { return n >> COUNT; } +REPEAT_32 +#undef REPEAT_FN +#endif /* CHAR_BIT == 8 || CHAR_BIT == 16 || CHAR_BIT == 32 */ + +extern void abort (void); +extern void exit (int); + +int +main () +{ + /* Test 8-bit shifts. */ +#if CHAR_BIT == 8 +# define REPEAT_FN(COUNT) \ + if (CAT (ashift_qi_, COUNT) (0xff) != (u8) ((u8)0xff << COUNT)) abort (); + REPEAT_8; +# undef REPEAT_FN + +# define REPEAT_FN(COUNT) \ + if (CAT (lshiftrt_qi_, COUNT) (0xff) != (u8) ((u8)0xff >> COUNT)) abort (); + REPEAT_8; +# undef REPEAT_FN + +# define REPEAT_FN(COUNT) \ + if (CAT (ashiftrt_qi_, COUNT) (-1) != -1) abort (); + REPEAT_8; +# undef REPEAT_FN + +# define REPEAT_FN(COUNT) \ + if (CAT (ashiftrt_qi_, COUNT) (0) != 0) abort (); + REPEAT_8; +# undef REPEAT_FN +#endif /* CHAR_BIT == 8 */ + + /* Test 16-bit shifts. */ +#if CHAR_BIT == 8 || CHAR_BIT == 16 +# define REPEAT_FN(COUNT) \ + if (CAT (ashift_hi_, COUNT) (0xffff) \ + != (u16) ((u16) 0xffff << COUNT)) abort (); + REPEAT_16; +# undef REPEAT_FN + +# define REPEAT_FN(COUNT) \ + if (CAT (lshiftrt_hi_, COUNT) (0xffff) \ + != (u16) ((u16) 0xffff >> COUNT)) abort (); + REPEAT_16; +# undef REPEAT_FN + +# define REPEAT_FN(COUNT) \ + if (CAT (ashiftrt_hi_, COUNT) (-1) != -1) abort (); + REPEAT_16; +# undef REPEAT_FN + +# define REPEAT_FN(COUNT) \ + if (CAT (ashiftrt_hi_, COUNT) (0) != 0) abort (); + REPEAT_16; +# undef REPEAT_FN +#endif /* CHAR_BIT == 8 || CHAR_BIT == 16 */ + + /* Test 32-bit shifts. */ +#if CHAR_BIT == 8 || CHAR_BIT == 16 || CHAR_BIT == 32 +# define REPEAT_FN(COUNT) \ + if (CAT (ashift_si_, COUNT) (0xffffffff) \ + != (u32) ((u32) 0xffffffff << COUNT)) abort (); + REPEAT_32; +# undef REPEAT_FN + +# define REPEAT_FN(COUNT) \ + if (CAT (lshiftrt_si_, COUNT) (0xffffffff) \ + != (u32) ((u32) 0xffffffff >> COUNT)) abort (); + REPEAT_32; +# undef REPEAT_FN + +# define REPEAT_FN(COUNT) \ + if (CAT (ashiftrt_si_, COUNT) (-1) != -1) abort (); + REPEAT_32; +# undef REPEAT_FN + +# define REPEAT_FN(COUNT) \ + if (CAT (ashiftrt_si_, COUNT) (0) != 0) abort (); + REPEAT_32; +# undef REPEAT_FN +#endif /* CHAR_BIT == 8 || CHAR_BIT == 16 || CHAR_BIT == 32 */ + + exit (0); +} diff --git a/test/tests/20020118-1.c b/test/tests/20020118-1.c new file mode 100644 index 0000000..fc53858 --- /dev/null +++ b/test/tests/20020118-1.c @@ -0,0 +1,33 @@ +/* This tests an insn length of sign extension on h8300 port. */ + +extern void exit (int); + +volatile signed char *q; +volatile signed int n; + +void +foo (void) +{ + signed char *p; + + for (;;) + { + p = (signed char *) q; n = p[2]; + p = (signed char *) q; n = p[2]; + p = (signed char *) q; n = p[2]; + p = (signed char *) q; n = p[2]; + p = (signed char *) q; n = p[2]; + p = (signed char *) q; n = p[2]; + p = (signed char *) q; n = p[2]; + p = (signed char *) q; n = p[2]; + p = (signed char *) q; n = p[2]; + p = (signed char *) q; n = p[2]; + p = (signed char *) q; n = p[2]; + } +} + +int +main () +{ + exit (0); +} diff --git a/test/tests/20020127-1.c b/test/tests/20020127-1.c new file mode 100644 index 0000000..88078dc --- /dev/null +++ b/test/tests/20020127-1.c @@ -0,0 +1,22 @@ +/* This used to fail on h8300. */ + +extern void abort (void); +extern void exit (int); + +unsigned long +foo (unsigned long n) +{ + return (~n >> 3) & 1; +} + +int +main () +{ + if (foo (1 << 3) != 0) + abort (); + + if (foo (0) != 1) + abort (); + + exit (0); +} diff --git a/test/tests/20020129-1.c b/test/tests/20020129-1.c new file mode 100644 index 0000000..6430c4c --- /dev/null +++ b/test/tests/20020129-1.c @@ -0,0 +1,51 @@ +/* This testcase failed at -O2 on IA-64, because scheduling did not take + into account conditional execution when using cselib for alias + analysis. */ + +struct D { int d1; struct D *d2; }; +struct C { struct D c1; long c2, c3, c4, c5, c6; }; +struct A { struct A *a1; struct C *a2; }; +struct B { struct C b1; struct A *b2; }; + +extern void abort (void); +extern void exit (int); + +void +foo (struct B *x, struct B *y) +{ + if (x->b2 == 0) + { + struct A *a; + + x->b2 = a = y->b2; + y->b2 = 0; + for (; a; a = a->a1) + a->a2 = &x->b1; + } + + if (y->b2 != 0) + abort (); + + if (x->b1.c3 == -1) + { + x->b1.c3 = y->b1.c3; + x->b1.c4 = y->b1.c4; + y->b1.c3 = -1; + y->b1.c4 = 0; + } + + if (y->b1.c3 != -1) + abort (); +} + +struct B x, y; + +int main () +{ + y.b1.c1.d1 = 6; + y.b1.c3 = 145; + y.b1.c4 = 2448; + x.b1.c3 = -1; + foo (&x, &y); + exit (0); +} diff --git a/test/tests/20020201-1.c b/test/tests/20020201-1.c new file mode 100644 index 0000000..b15f228 --- /dev/null +++ b/test/tests/20020201-1.c @@ -0,0 +1,37 @@ +/* Test whether division by constant works properly. */ + +extern void abort (void); +extern void exit (int); + +unsigned char cx = 7; +unsigned short sx = 14; +unsigned int ix = 21; +unsigned long lx = 28; +unsigned long long Lx = 35; + +int +main () +{ + unsigned char cy; + unsigned short sy; + unsigned int iy; + unsigned long ly; + unsigned long long Ly; + + cy = cx / 6; if (cy != 1) abort (); + cy = cx % 6; if (cy != 1) abort (); + + sy = sx / 6; if (sy != 2) abort (); + sy = sx % 6; if (sy != 2) abort (); + + iy = ix / 6; if (iy != 3) abort (); + iy = ix % 6; if (iy != 3) abort (); + + ly = lx / 6; if (ly != 4) abort (); + ly = lx % 6; if (ly != 4) abort (); + + Ly = Lx / 6; if (Ly != 5) abort (); + Ly = Lx % 6; if (Ly != 5) abort (); + + exit(0); +} diff --git a/test/tests/20020206-1.c b/test/tests/20020206-1.c new file mode 100644 index 0000000..8450800 --- /dev/null +++ b/test/tests/20020206-1.c @@ -0,0 +1,26 @@ +struct A { + unsigned int a, b, c; +}; + +extern void abort (void); +extern void exit (int); + +struct A bar (void) +{ + return (struct A) { 176, 52, 31 }; +} + +void baz (struct A *a) +{ + if (a->a != 176 || a->b != 52 || a->c != 31) + abort (); +} + +int main () +{ + struct A d; + + d = ({ ({ bar (); }); }); + baz (&d); + exit (0); +} diff --git a/test/tests/20020206-2.c b/test/tests/20020206-2.c new file mode 100644 index 0000000..097eb30 --- /dev/null +++ b/test/tests/20020206-2.c @@ -0,0 +1,24 @@ +/* Origin: PR c/5420 from David Mosberger . + This testcase was miscompiled when tail call optimizing, because a + compound literal initialization was emitted only in the tail call insn + chain, not in the normal call insn chain. */ + +typedef struct { unsigned short a; } A; + +extern void abort (void); +extern void exit (int); + +void foo (unsigned int x) +{ + if (x != 0x800 && x != 0x810) + abort (); +} + +int +main (int argc, char **argv) +{ + int i; + for (i = 0; i < 2; ++i) + foo (((A) { ((!(i >> 4) ? 8 : 64 + (i >> 4)) << 8) + (i << 4) } ).a); + exit (0); +} diff --git a/test/tests/20020213-1.c b/test/tests/20020213-1.c new file mode 100644 index 0000000..f9fefee --- /dev/null +++ b/test/tests/20020213-1.c @@ -0,0 +1,34 @@ +/* PR c/5681 + This testcase failed on IA-32 at -O0, because safe_from_p + incorrectly assumed it is safe to first write into a.a2 b-1 + and then read the original value from it. */ + +int bar (float); + +struct A { + float a1; + int a2; +} a; + +int b; + +void foo (void) +{ + a.a2 = bar (a.a1); + a.a2 = a.a2 < b - 1 ? a.a2 : b - 1; + if (a.a2 >= b - 1) + abort (); +} + +int bar (float x) +{ + return 2241; +} + +int main() +{ + a.a1 = 1.0f; + b = 3384; + foo (); + return 0; +} diff --git a/test/tests/20020215-1.c b/test/tests/20020215-1.c new file mode 100644 index 0000000..f1f46d5 --- /dev/null +++ b/test/tests/20020215-1.c @@ -0,0 +1,33 @@ +/* Test failed on an architecture that: + + - had 16-bit registers, + - passed 64-bit structures in registers, + - only allowed SImode values in even numbered registers. + + Before reload, s.i2 in foo() was represented as: + + (subreg:SI (reg:DI 0) 2) + + find_dummy_reload would return (reg:SI 1) for the subreg reload, + despite that not being a valid register. */ + +struct s +{ + short i1; + long i2; + short i3; +}; + +struct s foo (struct s s) +{ + s.i2++; + return s; +} + +int main () +{ + struct s s = foo ((struct s) { 1000, 2000L, 3000 }); + if (s.i1 != 1000 || s.i2 != 2001L || s.i3 != 3000) + abort (); + exit (0); +} diff --git a/test/tests/20020216-1.c b/test/tests/20020216-1.c new file mode 100644 index 0000000..bf62de5 --- /dev/null +++ b/test/tests/20020216-1.c @@ -0,0 +1,24 @@ +/* PR c/3444 + This used to fail because bitwise xor was improperly computed in char type + and sign extended to int type. */ + +extern void abort (); +extern void exit (int); + +signed char c = (signed char) 0xffffffff; + +int foo (void) +{ + return (unsigned short) c ^ (signed char) 0x99999999; +} + +int main (void) +{ + if ((unsigned char) -1 != 0xff + || sizeof (short) != 2 + || sizeof (int) != 4) + exit (0); + if (foo () != (int) 0xffff0066) + abort (); + exit (0); +} diff --git a/test/tests/20020219-1.c b/test/tests/20020219-1.c new file mode 100644 index 0000000..48200e3 --- /dev/null +++ b/test/tests/20020219-1.c @@ -0,0 +1,21 @@ +/* PR c/4308 + This testcase failed because 0x8000000000000000 >> 0 + was incorrectly folded into 0xffffffff00000000. */ + +extern void abort (void); +extern void exit (int); + +long long foo (void) +{ + long long C = 1ULL << 63, X; + int Y = 32; + X = C >> (Y & 31); + return X; +} + +int main (void) +{ + if (foo () != 1ULL << 63) + abort (); + exit (0); +} diff --git a/test/tests/20020225-1.c b/test/tests/20020225-1.c new file mode 100644 index 0000000..514730a --- /dev/null +++ b/test/tests/20020225-1.c @@ -0,0 +1,17 @@ +/* This testcase failed at -O2 on powerpc64 due to andsi3 writing + nonzero bits to the high 32 bits of a 64 bit register. */ + +extern void abort (void); +extern void exit (int); + +unsigned long foo (unsigned long base, unsigned int val) +{ + return base + (val & 0x80000001); +} + +int main (void) +{ + if (foo (0L, 0x0ffffff0) != 0L) + abort (); + exit (0); +} diff --git a/test/tests/20020225-2.c b/test/tests/20020225-2.c new file mode 100644 index 0000000..5c91596 --- /dev/null +++ b/test/tests/20020225-2.c @@ -0,0 +1,19 @@ +static int +test(int x) +{ + union + { + int i; + double d; + } a; + a.d = 0; + a.i = 1; + return x >> a.i; +} + +int main(void) +{ + if (test (5) != 2) + abort (); + exit (0); +} diff --git a/test/tests/20020226-1.c b/test/tests/20020226-1.c new file mode 100644 index 0000000..6372ffc --- /dev/null +++ b/test/tests/20020226-1.c @@ -0,0 +1,104 @@ +/* This tests the rotate patterns that some machines support. */ + +#include + +#ifndef CHAR_BIT +#define CHAR_BIT 8 +#endif + +#define ROR(a,b) (((a) >> (b)) | ((a) << ((sizeof (a) * CHAR_BIT) - (b)))) +#define ROL(a,b) (((a) << (b)) | ((a) >> ((sizeof (a) * CHAR_BIT) - (b)))) + +#define CHAR_VALUE ((unsigned char)0x1234U) +#define SHORT_VALUE ((unsigned short)0x1234U) +#define INT_VALUE 0x1234U +#define LONG_VALUE 0x12345678LU +#define LL_VALUE 0x12345678abcdef0LLU + +#define SHIFT1 4 +#define SHIFT2 ((sizeof (long long) * CHAR_BIT) - SHIFT1) + +unsigned char uc = CHAR_VALUE; +unsigned short us = SHORT_VALUE; +unsigned int ui = INT_VALUE; +unsigned long ul = LONG_VALUE; +unsigned long long ull = LL_VALUE; +int shift1 = SHIFT1; +int shift2 = SHIFT2; + +main () +{ + if (ROR (uc, shift1) != ROR (CHAR_VALUE, SHIFT1)) + abort (); + + if (ROR (uc, SHIFT1) != ROR (CHAR_VALUE, SHIFT1)) + abort (); + + if (ROR (us, shift1) != ROR (SHORT_VALUE, SHIFT1)) + abort (); + + if (ROR (us, SHIFT1) != ROR (SHORT_VALUE, SHIFT1)) + abort (); + + if (ROR (ui, shift1) != ROR (INT_VALUE, SHIFT1)) + abort (); + + if (ROR (ui, SHIFT1) != ROR (INT_VALUE, SHIFT1)) + abort (); + + if (ROR (ul, shift1) != ROR (LONG_VALUE, SHIFT1)) + abort (); + + if (ROR (ul, SHIFT1) != ROR (LONG_VALUE, SHIFT1)) + abort (); + + if (ROR (ull, shift1) != ROR (LL_VALUE, SHIFT1)) + abort (); + + if (ROR (ull, SHIFT1) != ROR (LL_VALUE, SHIFT1)) + abort (); + + if (ROR (ull, shift2) != ROR (LL_VALUE, SHIFT2)) + abort (); + + if (ROR (ull, SHIFT2) != ROR (LL_VALUE, SHIFT2)) + abort (); + + if (ROL (uc, shift1) != ROL (CHAR_VALUE, SHIFT1)) + abort (); + + if (ROL (uc, SHIFT1) != ROL (CHAR_VALUE, SHIFT1)) + abort (); + + if (ROL (us, shift1) != ROL (SHORT_VALUE, SHIFT1)) + abort (); + + if (ROL (us, SHIFT1) != ROL (SHORT_VALUE, SHIFT1)) + abort (); + + if (ROL (ui, shift1) != ROL (INT_VALUE, SHIFT1)) + abort (); + + if (ROL (ui, SHIFT1) != ROL (INT_VALUE, SHIFT1)) + abort (); + + if (ROL (ul, shift1) != ROL (LONG_VALUE, SHIFT1)) + abort (); + + if (ROL (ul, SHIFT1) != ROL (LONG_VALUE, SHIFT1)) + abort (); + + if (ROL (ull, shift1) != ROL (LL_VALUE, SHIFT1)) + abort (); + + if (ROL (ull, SHIFT1) != ROL (LL_VALUE, SHIFT1)) + abort (); + + if (ROL (ull, shift2) != ROL (LL_VALUE, SHIFT2)) + abort (); + + if (ROL (ull, SHIFT2) != ROL (LL_VALUE, SHIFT2)) + abort (); + + exit (0); +} diff --git a/test/tests/20020307-1.c b/test/tests/20020307-1.c new file mode 100644 index 0000000..c55b7ce --- /dev/null +++ b/test/tests/20020307-1.c @@ -0,0 +1,73 @@ +#define MASK(N) ((1UL << (N)) - 1) +#define BITS(N) ((1UL << ((N) - 1)) + 2) + +#define FUNC(N) void f##N(long j) { if ((j & MASK(N)) >= BITS(N)) abort();} + +FUNC(3) +FUNC(4) +FUNC(5) +FUNC(6) +FUNC(7) +FUNC(8) +FUNC(9) +FUNC(10) +FUNC(11) +FUNC(12) +FUNC(13) +FUNC(14) +FUNC(15) +#if 0 +FUNC(16) +FUNC(17) +FUNC(18) +FUNC(19) +FUNC(20) +FUNC(21) +FUNC(22) +FUNC(23) +FUNC(24) +FUNC(25) +FUNC(26) +FUNC(27) +FUNC(28) +FUNC(29) +FUNC(30) +FUNC(31) +#endif + +int main () +{ + f3(0); + f4(0); + f5(0); + f6(0); + f7(0); + f8(0); + f9(0); + f10(0); + f11(0); + f12(0); + f13(0); + f14(0); + f15(0); +#if 0 + f16(0); + f17(0); + f18(0); + f19(0); + f20(0); + f21(0); + f22(0); + f23(0); + f24(0); + f25(0); + f26(0); + f27(0); + f28(0); + f29(0); + f30(0); + f31(0); +#endif + + exit(0); +} diff --git a/test/tests/20020320-1.c b/test/tests/20020320-1.c new file mode 100644 index 0000000..05f72c6 --- /dev/null +++ b/test/tests/20020320-1.c @@ -0,0 +1,23 @@ +/* PR c/5354 */ +/* Verify that GCC preserves relevant stack slots. */ + +extern void abort(void); +extern void exit(int); + +struct large { int x, y[9]; }; + +int main() +{ + int fixed; + + fixed = ({ int temp1 = 2; temp1; }) - ({ int temp2 = 1; temp2; }); + if (fixed != 1) + abort(); + + fixed = ({ struct large temp3; temp3.x = 2; temp3; }).x + - ({ struct large temp4; temp4.x = 1; temp4; }).x; + if (fixed != 1) + abort(); + + exit(0); +} diff --git a/test/tests/20020321-1.c b/test/tests/20020321-1.c new file mode 100644 index 0000000..d06dd0a --- /dev/null +++ b/test/tests/20020321-1.c @@ -0,0 +1,20 @@ +/* PR 3177 */ +/* Produced a SIGILL on ia64 with sibcall from F to G. We hadn't + widened the register window to allow for the fourth outgoing + argument as an "in" register. */ + +float g (void *a, void *b, int e, int c, float d) +{ + return d; +} + +float f (void *a, void *b, int c, float d) +{ + return g (a, b, 0, c, d); +} + +int main () +{ + f (0, 0, 1, 1); + return 0; +} diff --git a/test/tests/20020328-1.c b/test/tests/20020328-1.c new file mode 100644 index 0000000..4b6f2bf --- /dev/null +++ b/test/tests/20020328-1.c @@ -0,0 +1,25 @@ +int b = 0; + +func () { } + +void +testit(int x) +{ + if (x != 20) + abort (); +} + +int +main() + +{ + int a = 0; + + if (b) + func(); + + /* simplify_and_const_int would incorrectly omit the mask in + the line below. */ + testit ((a + 23) & 0xfffffffc); + exit (0); +} diff --git a/test/tests/20020402-1.c b/test/tests/20020402-1.c new file mode 100644 index 0000000..fe2a6f6 --- /dev/null +++ b/test/tests/20020402-1.c @@ -0,0 +1,41 @@ +/* derived from PR c/2100 */ + +extern void abort (); +extern void exit (int); + +#define SMALL_N 2 +#define NUM_ELEM 4 + +int main(void) +{ + int listElem[NUM_ELEM]={30,2,10,5}; + int listSmall[SMALL_N]; + int i, j; + int posGreatest=-1, greatest=-1; + + for (i=0; i greatest) { + posGreatest = i; + greatest = listElem[i]; + } + } + + for (i=SMALL_N; i greatest) { + posGreatest = j; + greatest = listSmall[j]; + } + } + } + + if (listSmall[0] != 5 || listSmall[1] != 2) + abort (); + exit (0); +} + diff --git a/test/tests/20020402-2.c b/test/tests/20020402-2.c new file mode 100644 index 0000000..e14233f --- /dev/null +++ b/test/tests/20020402-2.c @@ -0,0 +1,230 @@ +/* PR 3967 + + local-alloc screwed up consideration of high+lo_sum and created + reg_equivs that it shouldn't have, resulting in lo_sum with + uninitialized data, resulting in segv. The test has to remain + relatively large, since register spilling is required to twig + the bug. */ + +unsigned long *Local1; +unsigned long *Local2; +unsigned long *Local3; +unsigned long *RDbf1; +unsigned long *RDbf2; +unsigned long *RDbf3; +unsigned long *IntVc1; +unsigned long *IntVc2; +unsigned long *IntCode3; +unsigned long *IntCode4; +unsigned long *IntCode5; +unsigned long *IntCode6; +unsigned long *Lom1; +unsigned long *Lom2; +unsigned long *Lom3; +unsigned long *Lom4; +unsigned long *Lom5; +unsigned long *Lom6; +unsigned long *Lom7; +unsigned long *Lom8; +unsigned long *Lom9; +unsigned long *Lom10; +unsigned long *RDbf11; +unsigned long *RDbf12; + +typedef struct + { + long a1; + unsigned long n1; + unsigned long local1; + unsigned long local2; + unsigned long local3; + unsigned long rdbf1; + unsigned long rdbf2; + unsigned long milli; + unsigned long frames1; + unsigned long frames2; + unsigned long nonShared; + long newPrivate; + long freeLimit; + unsigned long cache1; + unsigned long cache2; + unsigned long cache3; + unsigned long cache4; + unsigned long cache5; + unsigned long time6; + unsigned long frames7; + unsigned long page8; + unsigned long ot9; + unsigned long data10; + unsigned long bm11; + unsigned long misc12; + } +ShrPcCommonStatSType; + + +typedef struct + { + unsigned long sharedAttached; + unsigned long totalAttached; + long avgPercentShared; + unsigned long numberOfFreeFrames; + unsigned long localDirtyPageCount; + unsigned long globalDirtyPageCount; + long wakeupInterval; + unsigned long numActiveProcesses; + unsigned long numRecentActiveProcesses; + unsigned long gemDirtyPageKinds[10]; + unsigned long stoneDirtyPageKinds[10]; + unsigned long gemsInCacheCount; + long targetFreeFrameCount; + } +ShrPcMonStatSType; + +typedef struct + { + unsigned long c1; + unsigned long c2; + unsigned long c3; + unsigned long c4; + unsigned long c5; + unsigned long c6; + unsigned long c7; + unsigned long c8; + unsigned long c9; + unsigned long c10; + unsigned long c11; + unsigned long c12; + unsigned long a1; + unsigned long a2; + unsigned long a3; + unsigned long a4; + unsigned long a5; + unsigned long a6; + unsigned long a7; + unsigned long a8; + unsigned long a9; + unsigned long a10; + unsigned long a11; + unsigned long a12; + unsigned long a13; + unsigned long a14; + unsigned long a15; + unsigned long a16; + unsigned long a17; + unsigned long a18; + unsigned long a19; + unsigned long sessionStats[40]; + } +ShrPcGemStatSType; + +union ShrPcStatUnion + { + ShrPcMonStatSType monitor; + ShrPcGemStatSType gem; + }; + +typedef struct + { + int processId; + int sessionId; + ShrPcCommonStatSType cmn; + union ShrPcStatUnion u; + } ShrPcStatsSType; + +typedef struct + { + unsigned long *p1; + unsigned long *p2; + unsigned long *p3; + unsigned long *p4; + unsigned long *p5; + unsigned long *p6; + unsigned long *p7; + unsigned long *p8; + unsigned long *p9; + unsigned long *p10; + unsigned long *p11; + } +WorkEntrySType; + +WorkEntrySType Workspace; + +static void +setStatPointers (ShrPcStatsSType * statsPtr, long sessionId) +{ + statsPtr->sessionId = sessionId; + statsPtr->cmn.a1 = 0; + statsPtr->cmn.n1 = 5; + + Local1 = &statsPtr->cmn.local1; + Local2 = &statsPtr->cmn.local2; + Local3 = &statsPtr->cmn.local3; + RDbf1 = &statsPtr->cmn.rdbf1; + RDbf2 = &statsPtr->cmn.rdbf2; + RDbf3 = &statsPtr->cmn.milli; + *RDbf3 = 1; + + IntVc1 = &statsPtr->u.gem.a1; + IntVc2 = &statsPtr->u.gem.a2; + IntCode3 = &statsPtr->u.gem.a3; + IntCode4 = &statsPtr->u.gem.a4; + IntCode5 = &statsPtr->u.gem.a5; + IntCode6 = &statsPtr->u.gem.a6; + + { + WorkEntrySType *workSpPtr; + workSpPtr = &Workspace; + workSpPtr->p1 = &statsPtr->u.gem.a7; + workSpPtr->p2 = &statsPtr->u.gem.a8; + workSpPtr->p3 = &statsPtr->u.gem.a9; + workSpPtr->p4 = &statsPtr->u.gem.a10; + workSpPtr->p5 = &statsPtr->u.gem.a11; + workSpPtr->p6 = &statsPtr->u.gem.a12; + workSpPtr->p7 = &statsPtr->u.gem.a13; + workSpPtr->p8 = &statsPtr->u.gem.a14; + workSpPtr->p9 = &statsPtr->u.gem.a15; + workSpPtr->p10 = &statsPtr->u.gem.a16; + workSpPtr->p11 = &statsPtr->u.gem.a17; + } + Lom1 = &statsPtr->u.gem.c1; + Lom2 = &statsPtr->u.gem.c2; + Lom3 = &statsPtr->u.gem.c3; + Lom4 = &statsPtr->u.gem.c4; + Lom5 = &statsPtr->u.gem.c5; + Lom6 = &statsPtr->u.gem.c6; + Lom7 = &statsPtr->u.gem.c7; + Lom8 = &statsPtr->u.gem.c8; + Lom9 = &statsPtr->u.gem.c9; + Lom10 = &statsPtr->u.gem.c10; + RDbf11 = &statsPtr->u.gem.c11; + RDbf12 = &statsPtr->u.gem.c12; +} + +typedef struct +{ + ShrPcStatsSType stats; +} ShrPcPteSType; + +ShrPcPteSType MyPte; + +static void +initPte (void *shrpcPtr, long sessionId) +{ + ShrPcPteSType *ptePtr; + + ptePtr = &MyPte; + setStatPointers (&ptePtr->stats, sessionId); +} + +void +InitCache (int sessionId) +{ + initPte (0, sessionId); +} + +int +main (int argc, char *argv[]) +{ + InitCache (5); + return 0; +} diff --git a/test/tests/20020402-3.c b/test/tests/20020402-3.c new file mode 100644 index 0000000..eef2740 --- /dev/null +++ b/test/tests/20020402-3.c @@ -0,0 +1,81 @@ +/* extracted from gdb sources */ + +typedef unsigned long long CORE_ADDR; + +struct blockvector; + +struct symtab { + struct blockvector *blockvector; +}; + +struct sec { + void *unused; +}; + +struct symbol { + int len; + char *name; +}; + +struct block { + CORE_ADDR startaddr, endaddr; + struct symbol *function; + struct block *superblock; + unsigned char gcc_compile_flag; + int nsyms; + struct symbol syms[1]; +}; + +struct blockvector { + int nblocks; + struct block *block[2]; +}; + +struct blockvector *blockvector_for_pc_sect(register CORE_ADDR pc, + struct symtab *symtab) +{ + register struct block *b; + register int bot, top, half; + struct blockvector *bl; + + bl = symtab->blockvector; + b = bl->block[0]; + + bot = 0; + top = bl->nblocks; + + while (top - bot > 1) + { + half = (top - bot + 1) >> 1; + b = bl->block[bot + half]; + if (b->startaddr <= pc) + bot += half; + else + top = bot + half; + } + + while (bot >= 0) + { + b = bl->block[bot]; + if (b->endaddr > pc) + { + return bl; + } + bot--; + } + return 0; +} + +int main(void) +{ + struct block a = { 0, 0x10000, 0, 0, 1, 20 }; + struct block b = { 0x10000, 0x20000, 0, 0, 1, 20 }; + struct blockvector bv = { 2, { &a, &b } }; + struct symtab s = { &bv }; + + struct blockvector *ret; + + ret = blockvector_for_pc_sect(0x500, &s); + + return 0; +} diff --git a/test/tests/20020404-1.c b/test/tests/20020404-1.c new file mode 100644 index 0000000..e8ed4f7 --- /dev/null +++ b/test/tests/20020404-1.c @@ -0,0 +1,102 @@ +/* Extracted from GDB sources. */ + +typedef long long bfd_signed_vma; +typedef bfd_signed_vma file_ptr; + +typedef enum bfd_boolean {false, true} boolean; + +typedef unsigned long long bfd_size_type; + +typedef unsigned int flagword; + +typedef unsigned long long CORE_ADDR; +typedef unsigned long long bfd_vma; + +struct bfd_struct { + int x; +}; + +struct asection_struct { + unsigned int user_set_vma : 1; + bfd_vma vma; + bfd_vma lma; + unsigned int alignment_power; + unsigned int entsize; +}; + +typedef struct bfd_struct bfd; +typedef struct asection_struct asection; + +static bfd * +bfd_openw_with_cleanup (char *filename, const char *target, char *mode); + +static asection * +bfd_make_section_anyway (bfd *abfd, const char *name); + +static boolean +bfd_set_section_size (bfd *abfd, asection *sec, bfd_size_type val); + +static boolean +bfd_set_section_flags (bfd *abfd, asection *sec, flagword flags); + +static boolean +bfd_set_section_contents (bfd *abfd, asection *section, void * data, file_ptr offset, bfd_size_type count); + +static void +dump_bfd_file (char *filename, char *mode, + char *target, CORE_ADDR vaddr, + char *buf, int len) +{ + bfd *obfd; + asection *osection; + + obfd = bfd_openw_with_cleanup (filename, target, mode); + osection = bfd_make_section_anyway (obfd, ".newsec"); + bfd_set_section_size (obfd, osection, len); + (((osection)->vma = (osection)->lma= (vaddr)), ((osection)->user_set_vma = (boolean)true), true); + (((osection)->alignment_power = (0)),true); + bfd_set_section_flags (obfd, osection, 0x203); + osection->entsize = 0; + bfd_set_section_contents (obfd, osection, buf, 0, len); +} + +static bfd * +bfd_openw_with_cleanup (char *filename, const char *target, char *mode) +{ + static bfd foo_bfd = { 0 }; + return &foo_bfd; +} + +static asection * +bfd_make_section_anyway (bfd *abfd, const char *name) +{ + static asection foo_section = { false, 0x0, 0x0, 0 }; + + return &foo_section; +} + +static boolean +bfd_set_section_size (bfd *abfd, asection *sec, bfd_size_type val) +{ + return true; +} + +static boolean +bfd_set_section_flags (bfd *abfd, asection *sec, flagword flags) +{ +} + +static boolean +bfd_set_section_contents (bfd *abfd, asection *section, void * data, file_ptr offset, bfd_size_type count) +{ + if (count != (bfd_size_type)0x1eef) + abort(); +} + +static char hello[] = "hello"; + +int main(void) +{ + dump_bfd_file(0, 0, 0, (CORE_ADDR)0xdeadbeef, hello, (int)0x1eef); + exit(0); +} diff --git a/test/tests/20020413-1.c b/test/tests/20020413-1.c new file mode 100644 index 0000000..fdef9ee --- /dev/null +++ b/test/tests/20020413-1.c @@ -0,0 +1,36 @@ +void test(long double val, int *eval) +{ + long double tmp = 1.0l; + int i = 0; + + if (val < 0.0l) + val = -val; + + if (val >= tmp) + while (tmp < val) + { + tmp *= 2.0l; + if (i++ >= 10) + abort (); + } + else if (val != 0.0l) + while (val < tmp) + { + tmp /= 2.0l; + if (i++ >= 10) + abort (); + } + + *eval = i; +} + +int main(void) +{ + int eval; + + test(3.0, &eval); + test(3.5, &eval); + test(4.0, &eval); + test(5.0, &eval); + exit (0); +} diff --git a/test/tests/20020418-1.c b/test/tests/20020418-1.c new file mode 100644 index 0000000..bb3418f --- /dev/null +++ b/test/tests/20020418-1.c @@ -0,0 +1,27 @@ +/* ifcvt accidently deletes a referenced label while generating + conditional traps on machines having such patterns */ + +#define __builtin_expect(a, b) (a) +#define __builtin_trap() abort() + +struct foo { int a; }; + +void gcc_crash(struct foo *p) +{ + if (__builtin_expect(p->a < 52, 0)) + __builtin_trap(); + top: + p->a++; + if (p->a >= 62) + goto top; +} + +int main(void) +{ + struct foo x; + + x.a = 53; + gcc_crash(&x); + + exit (0); +} diff --git a/test/tests/20020423-1.c b/test/tests/20020423-1.c new file mode 100644 index 0000000..5f744b6 --- /dev/null +++ b/test/tests/20020423-1.c @@ -0,0 +1,33 @@ +/* PR c/5430 */ +/* Verify that the multiplicative folding code is not fooled + by the mix between signed variables and unsigned constants. */ + +extern void abort (void); +extern void exit (int); + +int main (void) +{ + int my_int = 924; + unsigned int result; + + result = ((my_int*2 + 4) - 8U) / 2; + if (result != 922U) + abort(); + + result = ((my_int*2 - 4U) + 2) / 2; + if (result != 923U) + abort(); + + result = (((my_int + 2) * 2) - 8U - 4) / 2; + if (result != 920U) + abort(); + result = (((my_int + 2) * 2) - (8U + 4)) / 2; + if (result != 920U) + abort(); + + result = ((my_int*4 + 2U) - 4U) / 2; + if (result != 1847U) + abort(); + + exit(0); +} diff --git a/test/tests/20020503-1.c b/test/tests/20020503-1.c new file mode 100644 index 0000000..6d45ca0 --- /dev/null +++ b/test/tests/20020503-1.c @@ -0,0 +1,31 @@ +/* PR 6534 */ +/* GCSE unified the two i<0 tests, but if-conversion to ui=abs(i) + insertted the code at the wrong place corrupting the i<0 test. */ + +void abort (void); +static char * +inttostr (long i, char buf[128]) +{ + unsigned long ui = i; + char *p = buf + 127; + *p = '\0'; + if (i < 0) + ui = -ui; + do + *--p = '0' + ui % 10; + while ((ui /= 10) != 0); + if (i < 0) + *--p = '-'; + return p; +} + +int +main () +{ + char buf[128], *p; + + p = inttostr (-1, buf); + if (*p != '-') + abort (); + return 0; +} diff --git a/test/tests/20020506-1.c b/test/tests/20020506-1.c new file mode 100644 index 0000000..bcbd45b --- /dev/null +++ b/test/tests/20020506-1.c @@ -0,0 +1,333 @@ +/* Copyright (C) 2002 Free Software Foundation. + + Test that (A & C1) op C2 optimizations behave correctly where C1 is + a constant power of 2, op is == or !=, and C2 is C1 or zero. + + Written by Roger Sayle, 5th May 2002. */ + +#include + +extern void abort (void); + +void test1 (signed char c, int set); +void test2 (unsigned char c, int set); +void test3 (short s, int set); +void test4 (unsigned short s, int set); +void test5 (int i, int set); +void test6 (unsigned int i, int set); +void test7 (long long l, int set); +void test8 (unsigned long long l, int set); + +#ifndef LONG_LONG_MAX +#define LONG_LONG_MAX __LONG_LONG_MAX__ +#endif +#ifndef LONG_LONG_MIN +#define LONG_LONG_MIN (-LONG_LONG_MAX-1) +#endif +#ifndef ULONG_LONG_MAX +#define ULONG_LONG_MAX (LONG_LONG_MAX * 2ULL + 1) +#endif + + +void +test1 (signed char c, int set) +{ + if ((c & (SCHAR_MAX+1)) == 0) + { + if (set) abort (); + } + else + if (!set) abort (); + + if ((c & (SCHAR_MAX+1)) != 0) + { + if (!set) abort (); + } + else + if (set) abort (); + + if ((c & (SCHAR_MAX+1)) == (SCHAR_MAX+1)) + { + if (!set) abort (); + } + else + if (set) abort (); + + if ((c & (SCHAR_MAX+1)) != (SCHAR_MAX+1)) + { + if (set) abort (); + } + else + if (!set) abort (); +} + +void +test2 (unsigned char c, int set) +{ + if ((c & (SCHAR_MAX+1)) == 0) + { + if (set) abort (); + } + else + if (!set) abort (); + + if ((c & (SCHAR_MAX+1)) != 0) + { + if (!set) abort (); + } + else + if (set) abort (); + + if ((c & (SCHAR_MAX+1)) == (SCHAR_MAX+1)) + { + if (!set) abort (); + } + else + if (set) abort (); + + if ((c & (SCHAR_MAX+1)) != (SCHAR_MAX+1)) + { + if (set) abort (); + } + else + if (!set) abort (); +} + +void +test3 (short s, int set) +{ + if ((s & (SHRT_MAX+1)) == 0) + { + if (set) abort (); + } + else + if (!set) abort (); + + if ((s & (SHRT_MAX+1)) != 0) + { + if (!set) abort (); + } + else + if (set) abort (); + + if ((s & (SHRT_MAX+1)) == (SHRT_MAX+1)) + { + if (!set) abort (); + } + else + if (set) abort (); + + if ((s & (SHRT_MAX+1)) != (SHRT_MAX+1)) + { + if (set) abort (); + } + else + if (!set) abort (); +} + +void +test4 (unsigned short s, int set) +{ + if ((s & (SHRT_MAX+1)) == 0) + { + if (set) abort (); + } + else + if (!set) abort (); + + if ((s & (SHRT_MAX+1)) != 0) + { + if (!set) abort (); + } + else + if (set) abort (); + + if ((s & (SHRT_MAX+1)) == (SHRT_MAX+1)) + { + if (!set) abort (); + } + else + if (set) abort (); + + if ((s & (SHRT_MAX+1)) != (SHRT_MAX+1)) + { + if (set) abort (); + } + else + if (!set) abort (); +} + +void +test5 (int i, int set) +{ + if ((i & (INT_MAX+1U)) == 0) + { + if (set) abort (); + } + else + if (!set) abort (); + + if ((i & (INT_MAX+1U)) != 0) + { + if (!set) abort (); + } + else + if (set) abort (); + + if ((i & (INT_MAX+1U)) == (INT_MAX+1U)) + { + if (!set) abort (); + } + else + if (set) abort (); + + if ((i & (INT_MAX+1U)) != (INT_MAX+1U)) + { + if (set) abort (); + } + else + if (!set) abort (); +} + +void +test6 (unsigned int i, int set) +{ + if ((i & (INT_MAX+1U)) == 0) + { + if (set) abort (); + } + else + if (!set) abort (); + + if ((i & (INT_MAX+1U)) != 0) + { + if (!set) abort (); + } + else + if (set) abort (); + + if ((i & (INT_MAX+1U)) == (INT_MAX+1U)) + { + if (!set) abort (); + } + else + if (set) abort (); + + if ((i & (INT_MAX+1U)) != (INT_MAX+1U)) + { + if (set) abort (); + } + else + if (!set) abort (); +} + +void +test7 (long long l, int set) +{ + if ((l & (LONG_LONG_MAX+1ULL)) == 0) + { + if (set) abort (); + } + else + if (!set) abort (); + + if ((l & (LONG_LONG_MAX+1ULL)) != 0) + { + if (!set) abort (); + } + else + if (set) abort (); + + if ((l & (LONG_LONG_MAX+1ULL)) == (LONG_LONG_MAX+1ULL)) + { + if (!set) abort (); + } + else + if (set) abort (); + + if ((l & (LONG_LONG_MAX+1ULL)) != (LONG_LONG_MAX+1ULL)) + { + if (set) abort (); + } + else + if (!set) abort (); +} + +void +test8 (unsigned long long l, int set) +{ + if ((l & (LONG_LONG_MAX+1ULL)) == 0) + { + if (set) abort (); + } + else + if (!set) abort (); + + if ((l & (LONG_LONG_MAX+1ULL)) != 0) + { + if (!set) abort (); + } + else + if (set) abort (); + + if ((l & (LONG_LONG_MAX+1ULL)) == (LONG_LONG_MAX+1ULL)) + { + if (!set) abort (); + } + else + if (set) abort (); + + if ((l & (LONG_LONG_MAX+1ULL)) != (LONG_LONG_MAX+1ULL)) + { + if (set) abort (); + } + else + if (!set) abort (); +} + +int +main () +{ + test1 (0, 0); + test1 (SCHAR_MAX, 0); + test1 (SCHAR_MIN, 1); + test1 (UCHAR_MAX, 1); + + test2 (0, 0); + test2 (SCHAR_MAX, 0); + test2 (SCHAR_MIN, 1); + test2 (UCHAR_MAX, 1); + + test3 (0, 0); + test3 (SHRT_MAX, 0); + test3 (SHRT_MIN, 1); + test3 (USHRT_MAX, 1); + + test4 (0, 0); + test4 (SHRT_MAX, 0); + test4 (SHRT_MIN, 1); + test4 (USHRT_MAX, 1); + + test5 (0, 0); + test5 (INT_MAX, 0); + test5 (INT_MIN, 1); + test5 (UINT_MAX, 1); + + test6 (0, 0); + test6 (INT_MAX, 0); + test6 (INT_MIN, 1); + test6 (UINT_MAX, 1); + + test7 (0, 0); + test7 (LONG_LONG_MAX, 0); + test7 (LONG_LONG_MIN, 1); + test7 (ULONG_LONG_MAX, 1); + + test8 (0, 0); + test8 (LONG_LONG_MAX, 0); + test8 (LONG_LONG_MIN, 1); + test8 (ULONG_LONG_MAX, 1); + + return 0; +} + diff --git a/test/tests/20020508-1.c b/test/tests/20020508-1.c new file mode 100644 index 0000000..42d0abe --- /dev/null +++ b/test/tests/20020508-1.c @@ -0,0 +1,104 @@ +/* This tests the rotate patterns that some machines support. */ + +#include + +#ifndef CHAR_BIT +#define CHAR_BIT 8 +#endif + +#define ROR(a,b) (((a) >> (b)) | ((a) << ((sizeof (a) * CHAR_BIT) - (b)))) +#define ROL(a,b) (((a) << (b)) | ((a) >> ((sizeof (a) * CHAR_BIT) - (b)))) + +#define CHAR_VALUE ((unsigned char)0xf234U) +#define SHORT_VALUE ((unsigned short)0xf234U) +#define INT_VALUE 0xf234U +#define LONG_VALUE 0xf234LU +#define LL_VALUE 0xf234567LLU + +#define SHIFT1 4 +#define SHIFT2 ((sizeof (long long) * CHAR_BIT) - SHIFT1) + +unsigned char uc = CHAR_VALUE; +unsigned short us = SHORT_VALUE; +unsigned int ui = INT_VALUE; +unsigned long ul = LONG_VALUE; +unsigned long long ull = LL_VALUE; +int shift1 = SHIFT1; +int shift2 = SHIFT2; + +main () +{ + if (ROR (uc, shift1) != ROR (CHAR_VALUE, SHIFT1)) + abort (); + + if (ROR (uc, SHIFT1) != ROR (CHAR_VALUE, SHIFT1)) + abort (); + + if (ROR (us, shift1) != ROR (SHORT_VALUE, SHIFT1)) + abort (); + + if (ROR (us, SHIFT1) != ROR (SHORT_VALUE, SHIFT1)) + abort (); + + if (ROR (ui, shift1) != ROR (INT_VALUE, SHIFT1)) + abort (); + + if (ROR (ui, SHIFT1) != ROR (INT_VALUE, SHIFT1)) + abort (); + + if (ROR (ul, shift1) != ROR (LONG_VALUE, SHIFT1)) + abort (); + + if (ROR (ul, SHIFT1) != ROR (LONG_VALUE, SHIFT1)) + abort (); + + if (ROR (ull, shift1) != ROR (LL_VALUE, SHIFT1)) + abort (); + + if (ROR (ull, SHIFT1) != ROR (LL_VALUE, SHIFT1)) + abort (); + + if (ROR (ull, shift2) != ROR (LL_VALUE, SHIFT2)) + abort (); + + if (ROR (ull, SHIFT2) != ROR (LL_VALUE, SHIFT2)) + abort (); + + if (ROL (uc, shift1) != ROL (CHAR_VALUE, SHIFT1)) + abort (); + + if (ROL (uc, SHIFT1) != ROL (CHAR_VALUE, SHIFT1)) + abort (); + + if (ROL (us, shift1) != ROL (SHORT_VALUE, SHIFT1)) + abort (); + + if (ROL (us, SHIFT1) != ROL (SHORT_VALUE, SHIFT1)) + abort (); + + if (ROL (ui, shift1) != ROL (INT_VALUE, SHIFT1)) + abort (); + + if (ROL (ui, SHIFT1) != ROL (INT_VALUE, SHIFT1)) + abort (); + + if (ROL (ul, shift1) != ROL (LONG_VALUE, SHIFT1)) + abort (); + + if (ROL (ul, SHIFT1) != ROL (LONG_VALUE, SHIFT1)) + abort (); + + if (ROL (ull, shift1) != ROL (LL_VALUE, SHIFT1)) + abort (); + + if (ROL (ull, SHIFT1) != ROL (LL_VALUE, SHIFT1)) + abort (); + + if (ROL (ull, shift2) != ROL (LL_VALUE, SHIFT2)) + abort (); + + if (ROL (ull, SHIFT2) != ROL (LL_VALUE, SHIFT2)) + abort (); + + exit (0); +} diff --git a/test/tests/20020508-2.c b/test/tests/20020508-2.c new file mode 100644 index 0000000..2290b2b --- /dev/null +++ b/test/tests/20020508-2.c @@ -0,0 +1,102 @@ +#include + +#ifndef CHAR_BIT +#define CHAR_BIT 8 +#endif + +#define ROR(a,b) (((a) >> (b)) | ((a) << ((sizeof (a) * CHAR_BIT) - (b)))) +#define ROL(a,b) (((a) << (b)) | ((a) >> ((sizeof (a) * CHAR_BIT) - (b)))) + +#define CHAR_VALUE ((char)0x1234) +#define SHORT_VALUE ((short)0x1234) +#define INT_VALUE ((int)0x1234) +#define LONG_VALUE ((long)0x1234L) +#define LL_VALUE ((long long)0x1234567LL) + +#define SHIFT1 4 +#define SHIFT2 ((sizeof (long long) * CHAR_BIT) - SHIFT1) + +char c = CHAR_VALUE; +short s = SHORT_VALUE; +int i = INT_VALUE; +long l = LONG_VALUE; +long long ll = LL_VALUE; +int shift1 = SHIFT1; +int shift2 = SHIFT2; + +main () +{ + if (ROR (c, shift1) != ROR (CHAR_VALUE, SHIFT1)) + abort (); + + if (ROR (c, SHIFT1) != ROR (CHAR_VALUE, SHIFT1)) + abort (); + + if (ROR (s, shift1) != ROR (SHORT_VALUE, SHIFT1)) + abort (); + + if (ROR (s, SHIFT1) != ROR (SHORT_VALUE, SHIFT1)) + abort (); + + if (ROR (i, shift1) != ROR (INT_VALUE, SHIFT1)) + abort (); + + if (ROR (i, SHIFT1) != ROR (INT_VALUE, SHIFT1)) + abort (); + + if (ROR (l, shift1) != ROR (LONG_VALUE, SHIFT1)) + abort (); + + if (ROR (l, SHIFT1) != ROR (LONG_VALUE, SHIFT1)) + abort (); + + if (ROR (ll, shift1) != ROR (LL_VALUE, SHIFT1)) + abort (); + + if (ROR (ll, SHIFT1) != ROR (LL_VALUE, SHIFT1)) + abort (); + + if (ROR (ll, shift2) != ROR (LL_VALUE, SHIFT2)) + abort (); + + if (ROR (ll, SHIFT2) != ROR (LL_VALUE, SHIFT2)) + abort (); + + if (ROL (c, shift1) != ROL (CHAR_VALUE, SHIFT1)) + abort (); + + if (ROL (c, SHIFT1) != ROL (CHAR_VALUE, SHIFT1)) + abort (); + + if (ROL (s, shift1) != ROL (SHORT_VALUE, SHIFT1)) + abort (); + + if (ROL (s, SHIFT1) != ROL (SHORT_VALUE, SHIFT1)) + abort (); + + if (ROL (i, shift1) != ROL (INT_VALUE, SHIFT1)) + abort (); + + if (ROL (i, SHIFT1) != ROL (INT_VALUE, SHIFT1)) + abort (); + + if (ROL (l, shift1) != ROL (LONG_VALUE, SHIFT1)) + abort (); + + if (ROL (l, SHIFT1) != ROL (LONG_VALUE, SHIFT1)) + abort (); + + if (ROL (ll, shift1) != ROL (LL_VALUE, SHIFT1)) + abort (); + + if (ROL (ll, SHIFT1) != ROL (LL_VALUE, SHIFT1)) + abort (); + + if (ROL (ll, shift2) != ROL (LL_VALUE, SHIFT2)) + abort (); + + if (ROL (ll, SHIFT2) != ROL (LL_VALUE, SHIFT2)) + abort (); + + exit (0); +} diff --git a/test/tests/20020508-3.c b/test/tests/20020508-3.c new file mode 100644 index 0000000..b018c0c --- /dev/null +++ b/test/tests/20020508-3.c @@ -0,0 +1,102 @@ +#include + +#ifndef CHAR_BIT +#define CHAR_BIT 8 +#endif + +#define ROR(a,b) (((a) >> (b)) | ((a) << ((sizeof (a) * CHAR_BIT) - (b)))) +#define ROL(a,b) (((a) << (b)) | ((a) >> ((sizeof (a) * CHAR_BIT) - (b)))) + +#define CHAR_VALUE ((char)0xf234) +#define SHORT_VALUE ((short)0xf234) +#define INT_VALUE ((int)0xf234) +#define LONG_VALUE ((long)0xf234L) +#define LL_VALUE ((long long)0xf234567LL) + +#define SHIFT1 4 +#define SHIFT2 ((sizeof (long long) * CHAR_BIT) - SHIFT1) + +char c = CHAR_VALUE; +short s = SHORT_VALUE; +int i = INT_VALUE; +long l = LONG_VALUE; +long long ll = LL_VALUE; +int shift1 = SHIFT1; +int shift2 = SHIFT2; + +main () +{ + if (ROR (c, shift1) != ROR (CHAR_VALUE, SHIFT1)) + abort (); + + if (ROR (c, SHIFT1) != ROR (CHAR_VALUE, SHIFT1)) + abort (); + + if (ROR (s, shift1) != ROR (SHORT_VALUE, SHIFT1)) + abort (); + + if (ROR (s, SHIFT1) != ROR (SHORT_VALUE, SHIFT1)) + abort (); + + if (ROR (i, shift1) != ROR (INT_VALUE, SHIFT1)) + abort (); + + if (ROR (i, SHIFT1) != ROR (INT_VALUE, SHIFT1)) + abort (); + + if (ROR (l, shift1) != ROR (LONG_VALUE, SHIFT1)) + abort (); + + if (ROR (l, SHIFT1) != ROR (LONG_VALUE, SHIFT1)) + abort (); + + if (ROR (ll, shift1) != ROR (LL_VALUE, SHIFT1)) + abort (); + + if (ROR (ll, SHIFT1) != ROR (LL_VALUE, SHIFT1)) + abort (); + + if (ROR (ll, shift2) != ROR (LL_VALUE, SHIFT2)) + abort (); + + if (ROR (ll, SHIFT2) != ROR (LL_VALUE, SHIFT2)) + abort (); + + if (ROL (c, shift1) != ROL (CHAR_VALUE, SHIFT1)) + abort (); + + if (ROL (c, SHIFT1) != ROL (CHAR_VALUE, SHIFT1)) + abort (); + + if (ROL (s, shift1) != ROL (SHORT_VALUE, SHIFT1)) + abort (); + + if (ROL (s, SHIFT1) != ROL (SHORT_VALUE, SHIFT1)) + abort (); + + if (ROL (i, shift1) != ROL (INT_VALUE, SHIFT1)) + abort (); + + if (ROL (i, SHIFT1) != ROL (INT_VALUE, SHIFT1)) + abort (); + + if (ROL (l, shift1) != ROL (LONG_VALUE, SHIFT1)) + abort (); + + if (ROL (l, SHIFT1) != ROL (LONG_VALUE, SHIFT1)) + abort (); + + if (ROL (ll, shift1) != ROL (LL_VALUE, SHIFT1)) + abort (); + + if (ROL (ll, SHIFT1) != ROL (LL_VALUE, SHIFT1)) + abort (); + + if (ROL (ll, shift2) != ROL (LL_VALUE, SHIFT2)) + abort (); + + if (ROL (ll, SHIFT2) != ROL (LL_VALUE, SHIFT2)) + abort (); + + exit (0); +} diff --git a/test/tests/20020510-1.c b/test/tests/20020510-1.c new file mode 100644 index 0000000..90fb277 --- /dev/null +++ b/test/tests/20020510-1.c @@ -0,0 +1,85 @@ +/* Copyright (C) 2002 Free Software Foundation. + + Test that optimizing ((c>=1) && (c<=127)) into (signed char)c < 0 + doesn't cause any problems for the compiler and behaves correctly. + + Written by Roger Sayle, 8th May 2002. */ + +#include + +extern void abort (void); + +void +testc (unsigned char c, int ok) +{ + if ((c>=1) && (c<=SCHAR_MAX)) + { + if (!ok) abort (); + } + else + if (ok) abort (); +} + +void +tests (unsigned short s, int ok) +{ + if ((s>=1) && (s<=SHRT_MAX)) + { + if (!ok) abort (); + } + else + if (ok) abort (); +} + +void +testi (unsigned int i, int ok) +{ + if ((i>=1) && (i<=INT_MAX)) + { + if (!ok) abort (); + } + else + if (ok) abort (); +} + +void +testl (unsigned long l, int ok) +{ + if ((l>=1) && (l<=LONG_MAX)) + { + if (!ok) abort (); + } + else + if (ok) abort (); +} + +int +main () +{ + testc (0, 0); + testc (1, 1); + testc (SCHAR_MAX, 1); + testc (SCHAR_MAX+1, 0); + testc (UCHAR_MAX, 0); + + tests (0, 0); + tests (1, 1); + tests (SHRT_MAX, 1); + tests (SHRT_MAX+1, 0); + tests (USHRT_MAX, 0); + + testi (0, 0); + testi (1, 1); + testi (INT_MAX, 1); + testi (INT_MAX+1U, 0); + testi (UINT_MAX, 0); + + testl (0, 0); + testl (1, 1); + testl (LONG_MAX, 1); + testl (LONG_MAX+1UL, 0); + testl (ULONG_MAX, 0); + + return 0; +} + diff --git a/test/tests/20020529-1.c b/test/tests/20020529-1.c new file mode 100644 index 0000000..d1b93c7 --- /dev/null +++ b/test/tests/20020529-1.c @@ -0,0 +1,78 @@ +/* PR target/6838 from cato@df.lth.se. + cris-elf got an ICE with -O2: the insn matching + (insn 49 48 52 (parallel[ + (set (mem/s:HI (plus:SI (reg/v/f:SI 0 r0 [24]) + (const_int 8 [0x8])) [5 .c+0 S2 A8]) + (reg:HI 2 r2 [27])) + (set (reg/f:SI 2 r2 [31]) + (plus:SI (reg/v/f:SI 0 r0 [24]) + (const_int 8 [0x8]))) + ] ) 24 {*mov_sidehi_mem} (nil) + (nil)) + forced a splitter through the output pattern "#", but there was no + matching splitter. */ + +struct xx + { + int a; + struct xx *b; + short c; + }; + +int f1 (struct xx *); +void f2 (void); + +int +foo (struct xx *p, int b, int c, int d) +{ + int a; + + for (;;) + { + a = f1(p); + if (a) + return (0); + if (b) + continue; + p->c = d; + if (p->a) + f2 (); + if (c) + f2 (); + d = p->c; + switch (a) + { + case 1: + if (p->b) + f2 (); + if (c) + f2 (); + default: + break; + } + } + return d; +} + +int main (void) +{ + struct xx s = {0, &s, 23}; + if (foo (&s, 0, 0, 0) != 0 || s.a != 0 || s.b != &s || s.c != 0) + abort (); + exit (0); +} + +int +f1 (struct xx *p) +{ + static int beenhere = 0; + if (beenhere++ > 1) + abort (); + return beenhere > 1; +} + +void +f2 (void) +{ + abort (); +} diff --git a/test/tests/20020611-1.c b/test/tests/20020611-1.c new file mode 100644 index 0000000..87fb717 --- /dev/null +++ b/test/tests/20020611-1.c @@ -0,0 +1,32 @@ +/* PR target/6997. Missing (set_attr "cc" "none") in sleu pattern in + cris.md. Testcase from hp@axis.com. */ + +int p; +int k; +unsigned int n; + +void x () +{ + unsigned int h; + + h = n <= 30; + if (h) + p = 1; + else + p = 0; + + if (h) + k = 1; + else + k = 0; +} + +unsigned int n = 30; + +main () +{ + x (); + if (p != 1 || k != 1) + abort (); + exit (0); +} diff --git a/test/tests/20020614-1.c b/test/tests/20020614-1.c new file mode 100644 index 0000000..bcbaed8 --- /dev/null +++ b/test/tests/20020614-1.c @@ -0,0 +1,41 @@ +/* PR c/6677 */ +/* Verify that GCC doesn't perform illegal simplifications + when folding constants. */ + +#include + +extern void abort (void); +extern void exit (int); + +int main (void) +{ + int i; + signed char j; + unsigned char k; + + i = SCHAR_MAX; + + j = ((signed char) (i << 1)) / 2; + + if (j != -1) + abort(); + + j = ((signed char) (i * 2)) / 2; + + if (j != -1) + abort(); + + i = UCHAR_MAX; + + k = ((unsigned char) (i << 1)) / 2; + + if (k != UCHAR_MAX/2) + abort(); + + k = ((unsigned char) (i * 2)) / 2; + + if (k != UCHAR_MAX/2) + abort(); + + exit(0); +} diff --git a/test/tests/20020615-1.c b/test/tests/20020615-1.c new file mode 100644 index 0000000..89bf7d0 --- /dev/null +++ b/test/tests/20020615-1.c @@ -0,0 +1,59 @@ +/* PR target/7042. When reorg.c changed branches into return insns, it + completely forgot about any current_function_epilogue_delay_list and + dropped those insns. Uncovered on cris-axis-elf, where an insn in an + epilogue delay-slot set the return-value register with the testcase + below. Derived from ghostscript-6.52 (GPL) by hp@axis.com. */ + +typedef struct font_hints_s { + int axes_swapped; + int x_inverted, y_inverted; +} font_hints; +typedef struct gs_fixed_point_s { + long x, y; +} gs_fixed_point; + +int +line_hints(const font_hints *fh, const gs_fixed_point *p0, + const gs_fixed_point *p1) +{ + long dx = p1->x - p0->x; + long dy = p1->y - p0->y; + long adx, ady; + int xi = fh->x_inverted, yi = fh->y_inverted; + int hints; + if (xi) + dx = -dx; + if (yi) + dy = -dy; + if (fh->axes_swapped) { + long t = dx; + int ti = xi; + dx = dy, xi = yi; + dy = t, yi = ti; + } + adx = dx < 0 ? -dx : dx; + ady = dy < 0 ? -dy : dy; + if (dy != 0 && (adx <= ady >> 4)) { + hints = dy > 0 ? 2 : 1; + if (xi) + hints ^= 3; + } else if (dx != 0 && (ady <= adx >> 4)) { + hints = dx < 0 ? 8 : 4; + if (yi) + hints ^= 12; + } else + hints = 0; + return hints; +} +int main () +{ + static font_hints fh[] = {{0, 1, 0}, {0, 0, 1}, {0, 0, 0}}; + static gs_fixed_point gsf[] + = {{0x30000, 0x13958}, {0x30000, 0x18189}, + {0x13958, 0x30000}, {0x18189, 0x30000}}; + if (line_hints (fh, gsf, gsf + 1) != 1 + || line_hints (fh + 1, gsf + 2, gsf + 3) != 8 + || line_hints (fh + 2, gsf + 2, gsf + 3) != 4) + abort (); + exit (0); +} diff --git a/test/tests/20020619-1.c b/test/tests/20020619-1.c new file mode 100644 index 0000000..5ed4d00 --- /dev/null +++ b/test/tests/20020619-1.c @@ -0,0 +1,32 @@ +static int ref(void) +{ + union { + char c[5]; + int i; + } u; + + __builtin_memset (&u, 0, sizeof(u)); + u.c[0] = 1; + u.c[1] = 2; + u.c[2] = 3; + u.c[3] = 4; + + return u.i; +} + +#define MAX(a,b) (a < b ? b : a) + +static int test(void) +{ + char c[MAX(5, sizeof(int))] __attribute__((aligned)) = { 1, 2, 3, 4 }; + return *(int *)c; +} + +int main() +{ + int a = test(); + int b = ref(); + if (a != b) + abort (); + return 0; +} diff --git a/test/tests/20020716-1.c b/test/tests/20020716-1.c new file mode 100644 index 0000000..7f55959 --- /dev/null +++ b/test/tests/20020716-1.c @@ -0,0 +1,36 @@ +extern void abort (void); +extern void exit (int); + +int sub1 (int val) +{ + return val; +} + +int testcond (int val) +{ + int flag1; + + { + int t1 = val; + { + int t2 = t1; + { + flag1 = sub1 (t2) ==0; + goto lab1; + }; + } + lab1: ; + } + + if (flag1 != 0) + return 0x4d0000; + else + return 0; +} + +int main (void) +{ + if (testcond (1)) + abort (); + exit (0); +} diff --git a/test/tests/20020720-1.c b/test/tests/20020720-1.c new file mode 100644 index 0000000..c70bc74 --- /dev/null +++ b/test/tests/20020720-1.c @@ -0,0 +1,36 @@ +/* Copyright (C) 2002 Free Software Foundation. + + Ensure that fabs(x) < 0.0 optimization is working. + + Written by Roger Sayle, 20th July 2002. */ + +extern void abort (void); +extern double fabs (double); +extern void link_error (void); + +void +foo (double x) +{ + double p, q; + + p = fabs (x); + q = 0.0; + if (p < q) + link_error (); +} + +int +main() +{ + foo (1.0); + return 0; +} + +#ifndef __OPTIMIZE__ +void +link_error () +{ + abort (); +} +#endif + diff --git a/test/tests/20020805-1.c b/test/tests/20020805-1.c new file mode 100644 index 0000000..e7d5179 --- /dev/null +++ b/test/tests/20020805-1.c @@ -0,0 +1,21 @@ +/* This testcase was miscompiled on IA-32, because fold-const + assumed associate_trees is always done on PLUS_EXPR. */ + +extern void abort (void); +extern void exit (int); + +void check (unsigned int m) +{ + if (m != (unsigned int) -1) + abort (); +} + +unsigned int n = 1; + +int main (void) +{ + unsigned int m; + m = (1 | (2 - n)) | (-n); + check (m); + exit (0); +} diff --git a/test/tests/20020810-1.c b/test/tests/20020810-1.c new file mode 100644 index 0000000..d338697 --- /dev/null +++ b/test/tests/20020810-1.c @@ -0,0 +1,38 @@ +/* PR target/7559 + This testcase was miscompiled on x86-64, because classify_argument + wrongly computed the offset of nested structure fields. */ + +extern void abort (void); + +struct A +{ + long x; +}; + +struct R +{ + struct A a, b; +}; + +struct R R = { 100, 200 }; + +void f (struct R r) +{ + if (r.a.x != R.a.x || r.b.x != R.b.x) + abort (); +} + +struct R g (void) +{ + return R; +} + +int main (void) +{ + struct R r; + f(R); + r = g(); + if (r.a.x != R.a.x || r.b.x != R.b.x) + abort (); + return 0; +} diff --git a/test/tests/20020819-1.c b/test/tests/20020819-1.c new file mode 100644 index 0000000..549da91 --- /dev/null +++ b/test/tests/20020819-1.c @@ -0,0 +1,22 @@ +foo () +{ + return 0; +} + +main() +{ + int i, j, k, ccp_bad = 0; + + for (i = 0; i < 10; i++) + { + for (j = 0; j < 10; j++) + if (foo ()) + ccp_bad = 1; + + k = ccp_bad != 0; + if (k) + abort (); + } + + exit (0); +} diff --git a/test/tests/20020904-1.c b/test/tests/20020904-1.c new file mode 100644 index 0000000..24eeb0c --- /dev/null +++ b/test/tests/20020904-1.c @@ -0,0 +1,19 @@ +/* PR c/7102 */ + +/* Verify that GCC zero-extends integer constants + in unsigned binary operations. */ + +typedef unsigned char u8; + +u8 fun(u8 y) +{ + u8 x=((u8)255)/y; + return x; +} + +int main(void) +{ + if (fun((u8)2) != 127) + abort (); + return 0; +} diff --git a/test/tests/20020911-1.c b/test/tests/20020911-1.c new file mode 100644 index 0000000..ec83022 --- /dev/null +++ b/test/tests/20020911-1.c @@ -0,0 +1,8 @@ +extern void abort (void); +unsigned short c = 0x8000; +int main() +{ + if ((c-0x8000) < 0 || (c-0x8000) > 0x7fff) + abort(); + return 0; +} diff --git a/test/tests/20020916-1.c b/test/tests/20020916-1.c new file mode 100644 index 0000000..3f2db15 --- /dev/null +++ b/test/tests/20020916-1.c @@ -0,0 +1,19 @@ +/* Distilled from try_pre_increment in flow.c. If-conversion inserted + new instructions at the wrong place on ppc. */ + +int foo(int a) +{ + int x; + x = 0; + if (a > 0) x = 1; + if (a < 0) x = 1; + return x; +} + +int main() +{ + if (foo(1) != 1) + abort(); + return 0; +} + diff --git a/test/tests/20021010-1.c b/test/tests/20021010-1.c new file mode 100644 index 0000000..d742ce4 --- /dev/null +++ b/test/tests/20021010-1.c @@ -0,0 +1,21 @@ +#include + +int +sub () +{ + int dummy = 0, a = 16; + + if (a / INT_MAX / 16 == 0) + return 0; + else + return a / INT_MAX / 16; +} + +int +main () +{ + if (sub () != 0) + abort (); + + exit (0); +} diff --git a/test/tests/20021010-2.c b/test/tests/20021010-2.c new file mode 100644 index 0000000..425a8f6 --- /dev/null +++ b/test/tests/20021010-2.c @@ -0,0 +1,37 @@ +/* cse.c failure on x86 target. + Contributed by Stuart Hastings 10 Oct 2002 */ +#include + +typedef signed short SInt16; + +typedef struct { + SInt16 minx; + SInt16 maxx; + SInt16 miny; + SInt16 maxy; +} IOGBounds; + +int expectedwidth = 50; + +unsigned int *global_vramPtr = (unsigned int *)0xa000; + +IOGBounds global_bounds = { 100, 150, 100, 150 }; +IOGBounds global_saveRect = { 75, 175, 75, 175 }; + +main() +{ + unsigned int *vramPtr; + int width; + IOGBounds saveRect = global_saveRect; + IOGBounds bounds = global_bounds; + + if (saveRect.minx < bounds.minx) saveRect.minx = bounds.minx; + if (saveRect.maxx > bounds.maxx) saveRect.maxx = bounds.maxx; + + vramPtr = global_vramPtr + (saveRect.miny - bounds.miny) ; + width = saveRect.maxx - saveRect.minx; + + if (width != expectedwidth) + abort (); + exit (0); +} diff --git a/test/tests/20021011-1.c b/test/tests/20021011-1.c new file mode 100644 index 0000000..b1b2c40 --- /dev/null +++ b/test/tests/20021011-1.c @@ -0,0 +1,24 @@ +/* PR opt/8165. */ + +extern void abort (void); + +char buf[64]; + +int +main (void) +{ + int i; + + __builtin_strcpy (buf, "mystring"); + if (__builtin_strcmp (buf, "mystring") != 0) + abort (); + + for (i = 0; i < 16; ++i) + { + __builtin_strcpy (buf + i, "mystring"); + if (__builtin_strcmp (buf + i, "mystring") != 0) + abort (); + } + + return 0; +} diff --git a/test/tests/20021015-1.c b/test/tests/20021015-1.c new file mode 100644 index 0000000..9d357c0 --- /dev/null +++ b/test/tests/20021015-1.c @@ -0,0 +1,30 @@ +/* PR opt/7409. */ + +extern void abort (void); + +char g_list[] = { '1' }; + +void g (void *p, char *list, int length, char **elementPtr, char **nextPtr) +{ + if (*nextPtr != g_list) + abort (); + + **nextPtr = 0; +} + +int main (void) +{ + char *list = g_list; + char *element; + int i, length = 100; + + for (i = 0; *list != 0; i++) + { + char *prevList = list; + g (0, list, length, &element, &list); + length -= (list - prevList); + } + + return 0; +} + diff --git a/test/tests/20021024-1.c b/test/tests/20021024-1.c new file mode 100644 index 0000000..02fb06c --- /dev/null +++ b/test/tests/20021024-1.c @@ -0,0 +1,43 @@ +/* Origin: PR target/6981 from Mattias Engdegaard . */ + +void exit (int); +void abort (void); + +unsigned long long *cp, m; + +void foo (void) +{ +} + +void bar (unsigned rop, unsigned long long *r) +{ + unsigned rs1, rs2, rd; + +top: + rs2 = (rop >> 11) & 0x1f; + rs1 = (rop >> 6) & 0x1f; + rd = rop & 0x1f; + + *cp = 1; + m = r[rs1] + r[rs2]; + *cp = 2; + foo(); + if (!rd) + goto top; + r[rd] = 1; +} + +int main(void) +{ + static unsigned long long r[64]; + unsigned long long cr; + cp = &cr; + + r[4] = 47; + r[8] = 11; + bar((8 << 11) | (4 << 6) | 15, r); + + if (m != 47 + 11) + abort (); + exit (0); +} diff --git a/test/tests/20021111-1.c b/test/tests/20021111-1.c new file mode 100644 index 0000000..b81fa0b --- /dev/null +++ b/test/tests/20021111-1.c @@ -0,0 +1,31 @@ +/* Origin: PR c/8467 */ + +extern void abort (void); +extern void exit (int); + +int aim_callhandler(int sess, int conn, unsigned short family, unsigned short type); + +int aim_callhandler(int sess, int conn, unsigned short family, unsigned short type) +{ + static int i = 0; + + if (!conn) + return 0; + + if (type == 0xffff) + { + return 0; + } + + if (i >= 1) + abort (); + + i++; + return aim_callhandler(sess, conn, family, (unsigned short) 0xffff); +} + +int main (void) +{ + aim_callhandler (0, 1, 0, 0); + exit (0); +} diff --git a/test/tests/20021118-1.c b/test/tests/20021118-1.c new file mode 100644 index 0000000..0c1f800 --- /dev/null +++ b/test/tests/20021118-1.c @@ -0,0 +1,15 @@ +struct s { int f[4]; }; + +int foo (struct s s, int x1, int x2, int x3, int x4, int x5, int x6, int x7) +{ + return s.f[3] + x7; +} + +int main () +{ + struct s s = { 1, 2, 3, 4 }; + + if (foo (s, 100, 200, 300, 400, 500, 600, 700) != 704) + abort (); + exit (0); +} diff --git a/test/tests/20021118-2.c b/test/tests/20021118-2.c new file mode 100644 index 0000000..5c8c548 --- /dev/null +++ b/test/tests/20021118-2.c @@ -0,0 +1,50 @@ +/* Originally added to test SH constant pool layout. t1() failed for + non-PIC and t2() failed for PIC. */ + +int t1 (float *f, int i, + void (*f1) (double), + void (*f2) (float, float)) +{ + f1 (3.0); + f[i] = f[i + 1]; + f2 (2.5f, 3.5f); +} + +int t2 (float *f, int i, + void (*f1) (double), + void (*f2) (float, float), + void (*f3) (float)) +{ + f3 (6.0f); + f1 (3.0); + f[i] = f[i + 1]; + f2 (2.5f, 3.5f); +} + +void f1 (double d) +{ + if (d != 3.0) + abort (); +} + +void f2 (float f1, float f2) +{ + if (f1 != 2.5f || f2 != 3.5f) + abort (); +} + +void f3 (float f) +{ + if (f != 6.0f) + abort (); +} + +int main () +{ + float f[3] = { 2.0f, 3.0f, 4.0f }; + t1 (f, 0, f1, f2); + t2 (f, 1, f1, f2, f3); + if (f[0] != 3.0f && f[1] != 4.0f) + abort (); + exit (0); +} diff --git a/test/tests/20021118-3.c b/test/tests/20021118-3.c new file mode 100644 index 0000000..8ec01ca --- /dev/null +++ b/test/tests/20021118-3.c @@ -0,0 +1,18 @@ +extern void abort (void); +extern void exit (int); + +int +foo (int x) +{ + if (x == -2 || -x - 100 >= 0) + abort (); + return 0; +} + +int +main () +{ + foo (-3); + foo (-99); + exit (0); +} diff --git a/test/tests/20021119-1.c b/test/tests/20021119-1.c new file mode 100644 index 0000000..c4ef460 --- /dev/null +++ b/test/tests/20021119-1.c @@ -0,0 +1,17 @@ +/* PR 8639. */ + +extern void abort(void); + +int foo (int i) +{ + int r; + r = (80 - 4 * i) / 20; + return r; +} + +int main () +{ + if (foo (1) != 3) + abort (); + return 0; +} diff --git a/test/tests/20021120-1.c b/test/tests/20021120-1.c new file mode 100644 index 0000000..491d5d6 --- /dev/null +++ b/test/tests/20021120-1.c @@ -0,0 +1,58 @@ +/* Macros to emit "L Nxx R" for each octal number xx between 000 and 037. */ +#define OP1(L, N, R, I, J) L N##I##J R +#define OP2(L, N, R, I) \ + OP1(L, N, R, 0, I), OP1(L, N, R, 1, I), \ + OP1(L, N, R, 2, I), OP1(L, N, R, 3, I) +#define OP(L, N, R) \ + OP2(L, N, R, 0), OP2(L, N, R, 1), OP2(L, N, R, 2), OP2(L, N, R, 3), \ + OP2(L, N, R, 4), OP2(L, N, R, 5), OP2(L, N, R, 6), OP2(L, N, R, 7) + +/* Declare 32 unique variables with prefix N. */ +#define DECLARE(N) OP (, N,) + +/* Copy 32 variables with prefix N from the array at ADDR. + Leave ADDR pointing to the end of the array. */ +#define COPYIN(N, ADDR) OP (, N, = *(ADDR++)) + +/* Likewise, but copy the other way. */ +#define COPYOUT(N, ADDR) OP (*(ADDR++) =, N,) + +/* Add the contents of the array at ADDR to 32 variables with prefix N. + Leave ADDR pointing to the end of the array. */ +#define ADD(N, ADDR) OP (, N, += *(ADDR++)) + +volatile double gd[32]; +volatile float gf[32]; + +void foo (int n) +{ + double DECLARE(d); + float DECLARE(f); + volatile double *pd; + volatile float *pf; + int i; + + pd = gd; COPYIN (d, pd); + for (i = 0; i < n; i++) + { + pf = gf; COPYIN (f, pf); + pd = gd; ADD (d, pd); + pd = gd; ADD (d, pd); + pd = gd; ADD (d, pd); + pf = gf; COPYOUT (f, pf); + } + pd = gd; COPYOUT (d, pd); +} + +int main () +{ + int i; + + for (i = 0; i < 32; i++) + gd[i] = i, gf[i] = i; + foo (1); + for (i = 0; i < 32; i++) + if (gd[i] != i * 4 || gf[i] != i) + abort (); + exit (0); +} diff --git a/test/tests/20021120-2.c b/test/tests/20021120-2.c new file mode 100644 index 0000000..d8876c0 --- /dev/null +++ b/test/tests/20021120-2.c @@ -0,0 +1,21 @@ +int g1, g2; + +void foo (int x) +{ + int y; + + if (x) + y = 793; + else + y = 793; + g1 = 7930 / y; + g2 = 7930 / x; +} + +int main () +{ + foo (793); + if (g1 != 10 || g2 != 10) + abort (); + exit (0); +} diff --git a/test/tests/20021120-3.c b/test/tests/20021120-3.c new file mode 100644 index 0000000..e875f1f --- /dev/null +++ b/test/tests/20021120-3.c @@ -0,0 +1,26 @@ +/* Test whether a partly call-clobbered register will be moved over a call. + Although the original test case didn't use any GNUisms, it proved + difficult to reduce without the named register extension. */ +#if __SH64__ == 32 +#define LOC asm ("r10") +#else +#define LOC +#endif + +unsigned int foo (char *c, unsigned int x, unsigned int y) +{ + register unsigned int z LOC; + + sprintf (c, "%d", x / y); + z = x + 1; + return z / (y + 1); +} + +int main () +{ + char c[16]; + + if (foo (c, ~1U, 4) != (~0U / 5)) + abort (); + exit (0); +} diff --git a/test/tests/20021204-1.c b/test/tests/20021204-1.c new file mode 100644 index 0000000..e92c408 --- /dev/null +++ b/test/tests/20021204-1.c @@ -0,0 +1,25 @@ +/* This test was miscompiled when using sibling call optimization, + because X ? Y : Y - 1 optimization changed X into !X in place + and haven't reverted it if do_store_flag was successful, so + when expanding the expression the second time it was + !X ? Y : Y - 1. */ + +extern void abort (void); +extern void exit (int); + +void foo (int x) +{ + if (x != 1) + abort (); +} + +int z; + +int main (int argc, char **argv) +{ + char *a = "test"; + char *b = a + 2; + + foo (z > 0 ? b - a : b - a - 1); + exit (0); +} diff --git a/test/tests/20021219-1.c b/test/tests/20021219-1.c new file mode 100644 index 0000000..2e658a5 --- /dev/null +++ b/test/tests/20021219-1.c @@ -0,0 +1,18 @@ +/* PR optimization/8988 */ +/* Contributed by Kevin Easton */ + +void foo(char *p1, char **p2) +{} + +int main(void) +{ + char str[] = "foo { xx }"; + char *ptr = str + 5; + + foo(ptr, &ptr); + + while (*ptr && (*ptr == 13 || *ptr == 32)) + ptr++; + + return 0; +} diff --git a/test/tests/20030105-1.c b/test/tests/20030105-1.c new file mode 100644 index 0000000..19f3b2d --- /dev/null +++ b/test/tests/20030105-1.c @@ -0,0 +1,20 @@ +int __attribute__ ((noinline)) +foo () +{ + const int a[8] = { 0, 1, 2, 3, 4, 5, 6, 7 }; + int i, sum; + + sum = 0; + for (i = 0; i < sizeof (a) / sizeof (*a); i++) + sum += a[i]; + + return sum; +} + +int +main () +{ + if (foo () != 28) + abort (); + exit (0); +} diff --git a/test/tests/20030117-1.c b/test/tests/20030117-1.c new file mode 100644 index 0000000..656bd61 --- /dev/null +++ b/test/tests/20030117-1.c @@ -0,0 +1,23 @@ +int foo (int, int, int); +int bar (int, int, int); + +int main (void) +{ + if (foo (5, 10, 21) != 12) + abort (); + + if (bar (9, 12, 15) != 150) + abort (); + + exit (0); +} + +int foo (int x, int y, int z) +{ + return (x + y + z) / 3; +} + +int bar (int x, int y, int z) +{ + return foo (x * x, y * y, z * z); +} diff --git a/test/tests/20030120-1.c b/test/tests/20030120-1.c new file mode 100644 index 0000000..0ac0ecf --- /dev/null +++ b/test/tests/20030120-1.c @@ -0,0 +1,50 @@ +/* On H8/300 port, NOTICE_UPDATE_CC had a bug that causes the final + pass to remove test insns that should be kept. */ + +unsigned short +test1 (unsigned short w) +{ + if ((w & 0xff00) == 0) + { + if (w == 0) + w = 2; + } + return w; +} + +unsigned long +test2 (unsigned long w) +{ + if ((w & 0xffff0000) == 0) + { + if (w == 0) + w = 2; + } + return w; +} + +int +test3 (unsigned short a) +{ + if (a & 1) + return 1; + else if (a) + return 1; + else + return 0; +} + +int +main () +{ + if (test1 (1) != 1) + abort (); + + if (test2 (1) != 1) + abort (); + + if (test3 (2) != 1) + abort (); + + exit (0); +} diff --git a/test/tests/20030120-2.c b/test/tests/20030120-2.c new file mode 100644 index 0000000..298bc4f --- /dev/null +++ b/test/tests/20030120-2.c @@ -0,0 +1,19 @@ +/* PR 8848 */ + +extern void abort (); + +int foo(int status) +{ + int s = 0; + if (status == 1) s=1; + if (status == 3) s=3; + if (status == 4) s=4; + return s; +} + +int main() +{ + if (foo (3) != 3) + abort (); + return 0; +} diff --git a/test/tests/20030125-1.c b/test/tests/20030125-1.c new file mode 100644 index 0000000..da9aafa --- /dev/null +++ b/test/tests/20030125-1.c @@ -0,0 +1,54 @@ +/* Verify whether math functions are simplified. */ +double sin(double); +double _floor(double); +float +t(float a) +{ + return sin(a); +} +float +q(float a) +{ + return floor(a); +} +double +q1(float a) +{ + return floor(a); +} +main() +{ +#ifdef __OPTIMIZE__ + if (t(0)!=0) + abort (); + if (q(0)!=0) + abort (); + if (q1(0)!=0) + abort (); +#endif + return 0; +} +__attribute__ ((noinline)) +double +_floor(double a) +{ + abort (); +} +__attribute__ ((noinline)) +float +floorf(float a) +{ + return a; +} +__attribute__ ((noinline)) +double +sin(double a) +{ + abort (); +} +__attribute__ ((noinline)) +float +sinf(float a) +{ + return a; +} diff --git a/test/tests/20030128-1.c b/test/tests/20030128-1.c new file mode 100644 index 0000000..ceca322 --- /dev/null +++ b/test/tests/20030128-1.c @@ -0,0 +1,10 @@ +unsigned char x = 50; +volatile short y = -5; + +int main () +{ + x /= y; + if (x != (unsigned char) -10) + abort (); + exit (0); +} diff --git a/test/tests/20030203-1.c b/test/tests/20030203-1.c new file mode 100644 index 0000000..3ce3d61 --- /dev/null +++ b/test/tests/20030203-1.c @@ -0,0 +1,23 @@ +void f(int); +int do_layer3(int single) +{ + int stereo1; + + if(single >= 0) /* stream is stereo, but force to mono */ + stereo1 = 1; + else + stereo1 = 2; + f(single); + + return stereo1; +} + +extern void abort (); +int main() +{ + if (do_layer3(-1) != 2) + abort (); + return 0; +} + +void f(int i) {} diff --git a/test/tests/20030209-1.c b/test/tests/20030209-1.c new file mode 100644 index 0000000..5845d67 --- /dev/null +++ b/test/tests/20030209-1.c @@ -0,0 +1,25 @@ +#ifdef STACK_SIZE +#if STACK_SIZE < 8*100*100 +#define SKIP +#endif +#endif + +#ifndef SKIP +double x[100][100]; +int main () +{ + int i; + + i = 99; + x[i][0] = 42; + if (x[99][0] != 42) + abort (); + exit (0); +} +#else +int +main () +{ + exit (0); +} +#endif diff --git a/test/tests/20030216-1.c b/test/tests/20030216-1.c new file mode 100644 index 0000000..2153bfd --- /dev/null +++ b/test/tests/20030216-1.c @@ -0,0 +1,10 @@ +void link_error (void); +const double one=1.0; +main () +{ +#ifdef __OPTIMIZE__ + if ((int) one != 1) + link_error (); +#endif + return 0; +} diff --git a/test/tests/20030218-1.c b/test/tests/20030218-1.c new file mode 100644 index 0000000..8dde794 --- /dev/null +++ b/test/tests/20030218-1.c @@ -0,0 +1,25 @@ +/* On H8, the predicate general_operand_src(op,mode) used to ignore + mode when op is a (mem (post_inc ...)). As a result, the pattern + for extendhisi2 was recognized as extendqisi2. */ + +extern void abort (); +extern void exit (int); + +short *q; + +long +foo (short *p) +{ + long b = *p; + q = p + 1; + return b; +} + +int +main () +{ + short a = 0xff00; + if (foo (&a) != (long) (short) 0xff00) + abort (); + exit (0); +} diff --git a/test/tests/20030221-1.c b/test/tests/20030221-1.c new file mode 100644 index 0000000..9dcee3e --- /dev/null +++ b/test/tests/20030221-1.c @@ -0,0 +1,17 @@ +/* PR optimization/8613 */ +/* Contributed by Glen Nakamura */ + +extern void abort (void); + +int main (void) +{ + char buf[16] = "1234567890"; + char *p = buf; + + *p++ = (char) __builtin_strlen (buf); + + if ((buf[0] != 10) || (p - buf != 1)) + abort (); + + return 0; +} diff --git a/test/tests/20030222-1.c b/test/tests/20030222-1.c new file mode 100644 index 0000000..617c4ee --- /dev/null +++ b/test/tests/20030222-1.c @@ -0,0 +1,28 @@ +/* Verify that we get the low part of the long long as an int. We + used to get it wrong on big-endian machines, if register allocation + succeeded at all. We use volatile to make sure the long long is + actually truncated to int, in case a single register is wide enough + for a long long. */ + +#include + +void +ll_to_int (long long x, volatile int *p) +{ + int i; + //asm ("" : "=r" (i) : "0" (x)); + i = x; + *p = i; +} + +int val = INT_MIN + 1; + +int main() { + volatile int i; + + ll_to_int ((long long)val, &i); + if (i != val) + abort (); + + exit (0); +} diff --git a/test/tests/20030224-2.c b/test/tests/20030224-2.c new file mode 100644 index 0000000..5b692fb --- /dev/null +++ b/test/tests/20030224-2.c @@ -0,0 +1,28 @@ +/* Make sure that we don't free any temp stack slots associated with + initializing marker before we're finished with them. */ + +extern void abort(); + +typedef struct { short v16; } __attribute__((packed)) jint16_t; + +struct node { + jint16_t magic; + jint16_t nodetype; + int totlen; +} __attribute__((packed)); + +struct node node, *node_p = &node; + +int main() +{ + struct node marker = { + .magic = (jint16_t) {0x1985}, + .nodetype = (jint16_t) {0x2003}, + .totlen = node_p->totlen + }; + if (marker.magic.v16 != 0x1985) + abort(); + if (marker.nodetype.v16 != 0x2003) + abort(); + return 0; +} diff --git a/test/tests/20030307-1.c b/test/tests/20030307-1.c new file mode 100644 index 0000000..3f4eb86 --- /dev/null +++ b/test/tests/20030307-1.c @@ -0,0 +1,26 @@ +/* PR optimization/8726 */ +/* Originator: Paul Eggert */ + +/* Verify that GCC doesn't miscompile tail calls on Sparc. */ + +extern void abort(void); + +int fcntl_lock(int fd, int op, long long offset, long long count, int type); + +int vfswrap_lock(char *fsp, int fd, int op, long long offset, long long count, int type) +{ + return fcntl_lock(fd, op, offset, count, type); +} + +int fcntl_lock(int fd, int op, long long offset, long long count, int type) +{ + return type; +} + +int main(void) +{ + if (vfswrap_lock (0, 1, 2, 3, 4, 5) != 5) + abort(); + + return 0; +} diff --git a/test/tests/20030313-1.c b/test/tests/20030313-1.c new file mode 100644 index 0000000..e979469 --- /dev/null +++ b/test/tests/20030313-1.c @@ -0,0 +1,82 @@ +struct A +{ + unsigned long p, q, r, s; +} x = { 13, 14, 15, 16 }; + +extern void abort (void); +extern void exit (int); + +static inline struct A * +bar (void) +{ +#if 1 + struct A *r; + + switch (8) + { + case 2: + exit (1); + break; + case 8: + r = &x; + break; + default: + exit (2); + break; + } + + if(r != &x) exit(42); + return r; +#else + return &x; +#endif +} + +void +foo (unsigned long *x, int y) +{ +#if 1 + if (y != 12) + exit (3); + if (x[0] != 1 || x[1] != 11) + exit (4); + if (x[2] != 2 || x[3] != 12) + exit (5); +#endif + if (x[4] != 3) exit(23); if(x[5] != 13) + exit (6); +#if 1 + if (x[6] != 4 || x[7] != 14) + exit (7); + if (x[8] != 5 || x[9] != 15) + exit (8); + if (x[10] != 6 || x[11] != 16) + exit (9); +#endif +} + +int +main (void) +{ + unsigned long a[40]; + int b = 0; + +#if 1 + a[b++] = 1; + a[b++] = 11; + a[b++] = 2; + a[b++] = 12; +#endif + a[b++] = 3; + a[b++] = bar()->p; +#if 1 + a[b++] = 4; + a[b++] = bar()->q; + a[b++] = 5; + a[b++] = bar()->r; + a[b++] = 6; + a[b++] = bar()->s; +#endif + foo (a, b); + exit (0); +} diff --git a/test/tests/20030316-1.c b/test/tests/20030316-1.c new file mode 100644 index 0000000..bde2e13 --- /dev/null +++ b/test/tests/20030316-1.c @@ -0,0 +1,12 @@ +/* PR target/9164 */ +/* The comparison operand was sign extended erraneously. */ + +int +main (void) +{ + long j = 0x40000000; + if ((unsigned int) (0x40000000 + j) < 0L) + abort (); + + return 0; +} diff --git a/test/tests/20030401-1.c b/test/tests/20030401-1.c new file mode 100644 index 0000000..0cc144a --- /dev/null +++ b/test/tests/20030401-1.c @@ -0,0 +1,27 @@ +/* Testcase for PR fortran/9974. This was a miscompilation of the g77 + front-end caused by the jump bypassing optimizations not handling + instructions inserted on CFG edges. */ + +extern void abort (); + +int bar () +{ + return 1; +} + +void foo (int x) +{ + unsigned char error = 0; + + if (! (error = ((x == 0) || bar ()))) + bar (); + if (! error) + abort (); +} + +int main() +{ + foo (1); + return 0; +} + diff --git a/test/tests/20030403-1.c b/test/tests/20030403-1.c new file mode 100644 index 0000000..cbf1351 --- /dev/null +++ b/test/tests/20030403-1.c @@ -0,0 +1,16 @@ +/* The non-destructive folder was always emitting >= when folding + comparisons to signed_max+1. */ + +#include + +int +main () +{ + unsigned long count = 8; + + if (count > INT_MAX) + abort (); + + return (0); +} + diff --git a/test/tests/20030404-1.c b/test/tests/20030404-1.c new file mode 100644 index 0000000..1dd1ec0 --- /dev/null +++ b/test/tests/20030404-1.c @@ -0,0 +1,23 @@ +/* This exposed a bug in tree-ssa-ccp.c. Since 'j' and 'i' are never + defined, CCP was not traversing the edges out of the if(), which caused + the PHI node for 'k' at the top of the while to only be visited once. + This ended up causing CCP to think that 'k' was the constant '1'. */ +main() +{ + int i, j, k; + + k = 0; + while (k < 10) + { + k++; + if (j > i) + j = 5; + else + j =3; + } + + if (k != 10) + abort (); + + return 0; +} diff --git a/test/tests/20030408-1.c b/test/tests/20030408-1.c new file mode 100644 index 0000000..c1d102c --- /dev/null +++ b/test/tests/20030408-1.c @@ -0,0 +1,69 @@ +/* PR optimization/8634 */ +/* Contributed by Glen Nakamura */ + +extern void abort (void); + +struct foo { + char a, b, c, d, e, f, g, h, i, j; +}; + +int test1 () +{ + const char X[8] = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H' }; + char buffer[8]; + __builtin_memcpy (buffer, X, 8); + if (buffer[0] != 'A' || buffer[1] != 'B' + || buffer[2] != 'C' || buffer[3] != 'D' + || buffer[4] != 'E' || buffer[5] != 'F' + || buffer[6] != 'G' || buffer[7] != 'H') + abort (); + return 0; +} + +int test2 () +{ + const char X[10] = { 'A', 'B', 'C', 'D', 'E' }; + char buffer[10]; + __builtin_memcpy (buffer, X, 10); + if (buffer[0] != 'A' || buffer[1] != 'B' + || buffer[2] != 'C' || buffer[3] != 'D' + || buffer[4] != 'E' || buffer[5] != '\0' + || buffer[6] != '\0' || buffer[7] != '\0' + || buffer[8] != '\0' || buffer[9] != '\0') + abort (); + return 0; +} + +int test3 () +{ + const struct foo X = { a : 'A', c : 'C', e : 'E', g : 'G', i : 'I' }; + char buffer[10]; + __builtin_memcpy (buffer, &X, 10); + if (buffer[0] != 'A' || buffer[1] != '\0' + || buffer[2] != 'C' || buffer[3] != '\0' + || buffer[4] != 'E' || buffer[5] != '\0' + || buffer[6] != 'G' || buffer[7] != '\0' + || buffer[8] != 'I' || buffer[9] != '\0') + abort (); + return 0; +} + +int test4 () +{ + const struct foo X = { .b = 'B', .d = 'D', .f = 'F', .h = 'H' , .j = 'J' }; + char buffer[10]; + __builtin_memcpy (buffer, &X, 10); + if (buffer[0] != '\0' || buffer[1] != 'B' + || buffer[2] != '\0' || buffer[3] != 'D' + || buffer[4] != '\0' || buffer[5] != 'F' + || buffer[6] != '\0' || buffer[7] != 'H' + || buffer[8] != '\0' || buffer[9] != 'J') + abort (); + return 0; +} + +int main () +{ + test1 (); test2 (); test3 (); test4 (); + return 0; +} diff --git a/test/tests/20030606-1.c b/test/tests/20030606-1.c new file mode 100644 index 0000000..51054d9 --- /dev/null +++ b/test/tests/20030606-1.c @@ -0,0 +1,27 @@ + +int * foo (int *x, int b) +{ + + *(x++) = 55; + if (b) + *(x++) = b; + + return x; +} + +main() +{ + int a[5]; + + memset (a, 1, sizeof (a)); + + if (foo(a, 0) - a != 1 || a[0] != 55 || a[1] != a[4]) + abort(); + + memset (a, 1, sizeof (a)); + + if (foo(a, 2) - a != 2 || a[0] != 55 || a[1] != 2) + abort(); + + exit (0); +} diff --git a/test/tests/20030613-1.c b/test/tests/20030613-1.c new file mode 100644 index 0000000..cb1623d --- /dev/null +++ b/test/tests/20030613-1.c @@ -0,0 +1,62 @@ +/* PR optimization/10955 */ +/* Originator: */ + +/* This used to fail on SPARC32 at -O3 because the loop unroller + wrongly thought it could eliminate a pseudo in a loop, while + the pseudo was used outside the loop. */ + +extern void abort(void); + +#define COMPLEX struct CS + +COMPLEX { + long x; + long y; +}; + + +static COMPLEX CCID (COMPLEX x) +{ + COMPLEX a; + + a.x = x.x; + a.y = x.y; + + return a; +} + + +static COMPLEX CPOW (COMPLEX x, int y) +{ + COMPLEX a; + a = x; + + while (--y > 0) + a=CCID(a); + + return a; +} + + +static int c5p (COMPLEX x) +{ + COMPLEX a,b; + a = CPOW (x, 2); + b = CCID( CPOW(a,2) ); + + return (b.x == b.y); +} + + +int main (void) +{ + COMPLEX x; + + x.x = -7; + x.y = -7; + + if (!c5p(x)) + abort(); + + return 0; +} diff --git a/test/tests/20030626-1.c b/test/tests/20030626-1.c new file mode 100644 index 0000000..8b985f0 --- /dev/null +++ b/test/tests/20030626-1.c @@ -0,0 +1,13 @@ +char buf[10]; + +extern void abort (void); +extern int sprintf (char*, const char*, ...); + +int main() +{ + int l = sprintf (buf, "foo\0bar"); + if (l != 3) + abort (); + return 0; +} + diff --git a/test/tests/20030626-2.c b/test/tests/20030626-2.c new file mode 100644 index 0000000..5483d0c --- /dev/null +++ b/test/tests/20030626-2.c @@ -0,0 +1,14 @@ +char buf[40]; + +extern int sprintf (char*, const char*, ...); +extern void abort (void); + +int main() +{ + int i = 0; + int l = sprintf (buf, "%s", i++ ? "string" : "other string"); + if (l != sizeof ("other string") - 1 || i != 1) + abort (); + return 0; +} + diff --git a/test/tests/20030714-1.c b/test/tests/20030714-1.c new file mode 100644 index 0000000..93c94b2 --- /dev/null +++ b/test/tests/20030714-1.c @@ -0,0 +1,193 @@ +/* derived from PR optimization/11440 */ + +extern void abort (void); +extern void exit (int); + +typedef _Bool bool; +const bool false = 0; +const bool true = 1; + +enum EPosition +{ + STATIC, RELATIVE, ABSOLUTE, FIXED +}; +typedef enum EPosition EPosition; + +enum EFloat +{ + FNONE = 0, FLEFT, FRIGHT +}; +typedef enum EFloat EFloat; + +struct RenderBox +{ + int unused[6]; + short m_verticalPosition; + + bool m_layouted : 1; + bool m_unused : 1; + bool m_minMaxKnown : 1; + bool m_floating : 1; + + bool m_positioned : 1; + bool m_overhangingContents : 1; + bool m_relPositioned : 1; + bool m_paintSpecial : 1; + + bool m_isAnonymous : 1; + bool m_recalcMinMax : 1; + bool m_isText : 1; + bool m_inline : 1; + + bool m_replaced : 1; + bool m_mouseInside : 1; + bool m_hasFirstLine : 1; + bool m_isSelectionBorder : 1; + + bool (*isTableCell) (struct RenderBox *this); +}; + +typedef struct RenderBox RenderBox; + +struct RenderStyle +{ + struct NonInheritedFlags + { + union + { + struct + { + unsigned int _display : 4; + unsigned int _bg_repeat : 2; + bool _bg_attachment : 1; + unsigned int _overflow : 4 ; + unsigned int _vertical_align : 4; + unsigned int _clear : 2; + EPosition _position : 2; + EFloat _floating : 2; + unsigned int _table_layout : 1; + bool _flowAroundFloats :1; + + unsigned int _styleType : 3; + bool _hasHover : 1; + bool _hasActive : 1; + bool _clipSpecified : 1; + unsigned int _unicodeBidi : 2; + int _unused : 1; + } f; + int _niflags; + } x; + } noninherited_flags; +}; + +typedef struct RenderStyle RenderStyle; + +extern void RenderObject_setStyle(RenderBox *this, RenderStyle *_style); +extern void removeFromSpecialObjects(RenderBox *this); + + + +void RenderBox_setStyle(RenderBox *thisin, RenderStyle *_style) +{ + RenderBox *this = thisin; + bool oldpos, tmp; + EPosition tmppo; + + tmp = this->m_positioned; + + oldpos = tmp; + + RenderObject_setStyle(this, _style); + + tmppo = _style->noninherited_flags.x.f._position; + + switch(tmppo) + { + case ABSOLUTE: + case FIXED: + { + bool ltrue = true; + this->m_positioned = ltrue; + break; + } + + default: + { + EFloat tmpf; + EPosition tmpp; + if (oldpos) + { + bool ltrue = true; + this->m_positioned = ltrue; + removeFromSpecialObjects(this); + } + { + bool lfalse = false; + this->m_positioned = lfalse; + } + + tmpf = _style->noninherited_flags.x.f._floating; + + if(!this->isTableCell (this) && !(tmpf == FNONE)) + { + bool ltrue = true; + this->m_floating = ltrue; + } + else + { + tmpp = _style->noninherited_flags.x.f._position; + if (tmpp == RELATIVE) + { + bool ltrue = true; + this->m_relPositioned = ltrue; + } + } + } + } +} + + + + +RenderBox g_this; +RenderStyle g__style; + +void RenderObject_setStyle(RenderBox *this, RenderStyle *_style) +{ + (void) this; + (void) _style; +} + +void removeFromSpecialObjects(RenderBox *this) +{ + (void) this; +} + +bool RenderBox_isTableCell (RenderBox *this) +{ + (void) this; + return false; +} + +int main (void) +{ + + g_this.m_relPositioned = false; + g_this.m_positioned = false; + g_this.m_floating = false; + g_this.isTableCell = RenderBox_isTableCell; + + g__style.noninherited_flags.x.f._position = FIXED; + g__style.noninherited_flags.x.f._floating = FNONE; + + RenderBox_setStyle (&g_this, &g__style); + + if (g_this.m_positioned != true) + abort (); + if (g_this.m_relPositioned != false) + abort (); + if (g_this.m_floating != false) + abort (); + + exit (0); +} diff --git a/test/tests/20030715-1.c b/test/tests/20030715-1.c new file mode 100644 index 0000000..a2a28ce --- /dev/null +++ b/test/tests/20030715-1.c @@ -0,0 +1,35 @@ +/* PR optimization/11320 */ +/* Origin: Andreas Schwab */ + +/* Verify that the scheduler correctly computes the dependencies + in the presence of conditional instructions. */ + +int strcmp (const char *, const char *); +int ap_standalone; + +const char *ap_check_cmd_context (void *a, int b) +{ + return 0; +} + +const char *server_type (void *a, void *b, char *arg) +{ + const char *err = ap_check_cmd_context (a, 0x01|0x02|0x04|0x08|0x10); + if (err) + return err; + + if (!strcmp (arg, "inetd")) + ap_standalone = 0; + else if (!strcmp (arg, "standalone")) + ap_standalone = 1; + else + return "ServerType must be either 'inetd' or 'standalone'"; + + return 0; +} + +int main () +{ + server_type (0, 0, "standalone"); + return 0; +} diff --git a/test/tests/20030717-1.c b/test/tests/20030717-1.c new file mode 100644 index 0000000..7e43e44 --- /dev/null +++ b/test/tests/20030717-1.c @@ -0,0 +1,69 @@ +/* PR target/11087 + This testcase was miscompiled on ppc64, because basic_induction_var called + convert_modes, yet did not expect it to emit any new instructions. + Those were emitted at the end of the function and destroyed during life + analysis, while the program used uninitialized pseudos created by + convert_modes. */ + +struct A +{ + unsigned short a1; + unsigned long a2; +}; + +struct B +{ + int b1, b2, b3, b4, b5; +}; + +struct C +{ + struct B c1[1]; + int c2, c3; +}; + +static +int foo (int x) +{ + return x < 0 ? -x : x; +} + +int bar (struct C *x, struct A *y) +{ + int a = x->c3; + const int b = y->a1 >> 9; + const unsigned long c = y->a2; + int d = a; + unsigned long e, f; + + f = foo (c - x->c1[d].b4); + do + { + if (d <= 0) + d = x->c2; + d--; + + e = foo (c-x->c1[d].b4); + if (e < f) + a = d; + } + while (d != x->c3); + x->c1[a].b4 = c + b; + return a; +} + +int +main () +{ + struct A a; + struct C b; + int c; + + a.a1 = 512; + a.a2 = 4242; + __builtin_memset (&b, 0, sizeof (b)); + b.c1[0].b3 = 424242; + b.c2 = 1; + c = bar (&b, &a); + return 0; +} diff --git a/test/tests/20030718-1.c b/test/tests/20030718-1.c new file mode 100644 index 0000000..2a113f9 --- /dev/null +++ b/test/tests/20030718-1.c @@ -0,0 +1,13 @@ +/* PR c/10320 + The function temp was not being emitted in a prerelease of 3.4 20030406. + Contributed by pinskia@physics.uc.edu */ + +static inline void temp(); +int main() +{ + temp(); + return 0; +} +static void temp(){} + + diff --git a/test/tests/20030821-1.c b/test/tests/20030821-1.c new file mode 100644 index 0000000..b82c2f2 --- /dev/null +++ b/test/tests/20030821-1.c @@ -0,0 +1,16 @@ +extern void abort (void); + +int +foo (int x) +{ + if ((int) (x & 0x80ffffff) != (int) (0x8000fffe)) + abort (); + + return 0; +} + +int +main () +{ + return foo (0x8000fffe); +} diff --git a/test/tests/20030828-1.c b/test/tests/20030828-1.c new file mode 100644 index 0000000..e8c1f01 --- /dev/null +++ b/test/tests/20030828-1.c @@ -0,0 +1,18 @@ +const int *p; + +int bar (void) +{ + return *p + 1; +} + +main () +{ + /* Variable 'i' is never used but it's aliased to a global pointer. The + alias analyzer was not considering that 'i' may be used in the call to + bar(). */ + const int i = 5; + p = &i; + if (bar() != 6) + abort (); + exit (0); +} diff --git a/test/tests/20030828-2.c b/test/tests/20030828-2.c new file mode 100644 index 0000000..0c3a195 --- /dev/null +++ b/test/tests/20030828-2.c @@ -0,0 +1,28 @@ +struct rtx_def +{ + int code; +}; + +main() +{ + int tmp[2]; + struct rtx_def *r, s; + int *p, *q; + + /* The alias analyzer was creating the same memory tag for r, p and q + because 'struct rtx_def *' is type-compatible with 'int *'. However, + the alias set of 'int[2]' is not the same as 'int *', so variable + 'tmp' was deemed not aliased with anything. */ + r = &s; + r->code = 39; + + /* If 'r' wasn't declared, then q and tmp would have had the same memory + tag. */ + p = tmp; + q = p + 1; + *q = 0; + tmp[1] = 39; + if (*q != 39) + abort (); + exit (0); +} diff --git a/test/tests/20030903-1.c b/test/tests/20030903-1.c new file mode 100644 index 0000000..95dad57 --- /dev/null +++ b/test/tests/20030903-1.c @@ -0,0 +1,21 @@ +/* Test that we don't let stmt.c think that the enumeration's values are + the entire set of possibilities. Such an assumption is false for C, + but true for other languages. */ + +enum X { X1 = 1, X2, X3, X4 }; +static volatile enum X test = 0; +static void y(int); + +int main() +{ + switch (test) + { + case X1: y(1); break; + case X2: y(2); break; + case X3: y(3); break; + case X4: y(4); break; + } + return 0; +} + +static void y(int x) { abort (); } diff --git a/test/tests/20030909-1.c b/test/tests/20030909-1.c new file mode 100644 index 0000000..2f14985 --- /dev/null +++ b/test/tests/20030909-1.c @@ -0,0 +1,35 @@ +void abort (); +void exit (int); + +void test(int x, int y) +{ + if (x == y) + abort (); +} + +void foo(int x, int y) +{ + if (x == y) + goto a; + else + { +a:; + if (x == y) + goto b; + else + { +b:; + if (x != y) + test (x, y); + } + } +} + +int main(void) +{ + foo (0, 0); + + exit (0); +} + + diff --git a/test/tests/20030913-1.c b/test/tests/20030913-1.c new file mode 100644 index 0000000..5e33f50 --- /dev/null +++ b/test/tests/20030913-1.c @@ -0,0 +1,26 @@ +/* Assignments via pointers pointing to global variables were being killed + by SSA-DCE. Test contributed by Paul Brook */ + +int glob; + +void +fn2(int ** q) +{ + *q = &glob; +} + +void test() +{ + int *p; + + fn2(&p); + + *p=42; +} + +int main() +{ + test(); + if (glob != 42) abort(); + exit (0); +} diff --git a/test/tests/20030914-1.c b/test/tests/20030914-1.c new file mode 100644 index 0000000..ab1c154 --- /dev/null +++ b/test/tests/20030914-1.c @@ -0,0 +1,26 @@ +/* On IRIX 6, PB is passed partially in registers and partially on the + stack, with an odd number of words in the register part. Check that + the long double stack argument (PC) is still accessed properly. */ + +struct s { int val[16]; }; + +long double f (int pa, struct s pb, long double pc) +{ + int i; + + for (i = 0; i < 16; i++) + pc += pb.val[i]; + return pc; +} + +int main () +{ + struct s x; + int i; + + for (i = 0; i < 16; i++) + x.val[i] = i + 1; + if (f (1, x, 10000.0L) != 10136.0L) + abort (); + exit (0); +} diff --git a/test/tests/20030914-2.c b/test/tests/20030914-2.c new file mode 100644 index 0000000..38a8198 --- /dev/null +++ b/test/tests/20030914-2.c @@ -0,0 +1,21 @@ +/* On IRIX 6, PA is passed partially in registers and partially on the + stack. We therefore have two potential uses of pretend_args_size: + one for the partial argument and one for the varargs save area. + Make sure that these uses don't conflict. */ + +struct s { int i[18]; }; + +int f (struct s pa, int pb, ...) +{ + return pb; +} + +struct s gs; + +int main () +{ + if (f (gs, 0x1234) != 0x1234) + abort (); + + exit (0); +} diff --git a/test/tests/20030916-1.c b/test/tests/20030916-1.c new file mode 100644 index 0000000..8b460c6 --- /dev/null +++ b/test/tests/20030916-1.c @@ -0,0 +1,35 @@ +/* "i" overflows in f(). Check that x[i] is not treated as a giv. */ +#include + +#if CHAR_BIT == 8 + +void f (unsigned int *x) +{ + unsigned char i; + int j; + + i = 0x10; + for (j = 0; j < 0x10; j++) + { + i += 0xe8; + x[i] = 0; + i -= 0xe7; + } +} + +int main () +{ + unsigned int x[256]; + int i; + + for (i = 0; i < 256; i++) + x[i] = 1; + f (x); + for (i = 0; i < 256; i++) + if (x[i] != (i >= 0x08 && i < 0xf8)) + abort (); + exit (0); +} +#else +int main () { exit (0); } +#endif diff --git a/test/tests/20030920-1.c b/test/tests/20030920-1.c new file mode 100644 index 0000000..2d22115 --- /dev/null +++ b/test/tests/20030920-1.c @@ -0,0 +1,15 @@ +extern void abort (void); + +int main() +{ + int hicount = 0; + unsigned char *c; + char *str = "\x7f\xff"; + for (c = (unsigned char *)str; *c ; c++) { + if (!(((unsigned int)(*c)) < 0x80)) hicount++; + } + if (hicount != 1) + abort (); + return 0; +} + diff --git a/test/tests/20030928-1.c b/test/tests/20030928-1.c new file mode 100644 index 0000000..77216c9 --- /dev/null +++ b/test/tests/20030928-1.c @@ -0,0 +1,32 @@ +#include + +#if INT_MAX <= 32767 +int main () { exit (0); } +#else +void get_addrs (const char**x, int *y) +{ + x[0] = "a1111" + (y[0] - 0x10000) * 2; + x[1] = "a1112" + (y[1] - 0x20000) * 2; + x[2] = "a1113" + (y[2] - 0x30000) * 2; + x[3] = "a1114" + (y[3] - 0x40000) * 2; + x[4] = "a1115" + (y[4] - 0x50000) * 2; + x[5] = "a1116" + (y[5] - 0x60000) * 2; + x[6] = "a1117" + (y[6] - 0x70000) * 2; + x[7] = "a1118" + (y[7] - 0x80000) * 2; +} + +int main () +{ + const char *x[8]; + int y[8]; + int i; + + for (i = 0; i < 8; i++) + y[i] = 0x10000 * (i + 1); + get_addrs (x, y); + for (i = 0; i < 8; i++) + if (*x[i] != 'a') + abort (); + exit (0); +} +#endif diff --git a/test/tests/20031003-1.c b/test/tests/20031003-1.c new file mode 100644 index 0000000..5d39d79 --- /dev/null +++ b/test/tests/20031003-1.c @@ -0,0 +1,27 @@ +/* PR optimization/9325 */ + +#include + +extern void abort (void); + +int f1() +{ + return (int)2147483648.0f; +} + +int f2() +{ + return (int)(float)(2147483647); +} + +int main() +{ +#if INT_MAX == 2147483647 + if (f1() != 2147483647) + abort (); + if (f2() != 2147483647) + abort (); +#endif + return 0; +} + diff --git a/test/tests/20031010-1.c b/test/tests/20031010-1.c new file mode 100644 index 0000000..54457f9 --- /dev/null +++ b/test/tests/20031010-1.c @@ -0,0 +1,34 @@ +/* A reminder to process ops in generate_expr_as_of_bb exactly once. */ + +long __attribute__((noinline)) +foo (long ct, long cf, _Bool p1, _Bool p2, _Bool p3) +{ + long diff; + + diff = ct - cf; + + if (p1) + { + if (p2) + { + if (p3) + { + long tmp = ct; + ct = cf; + cf = tmp; + } + diff = ct - cf; + } + + return diff; + } + + abort (); +} + +int main () +{ + if (foo(2, 3, 1, 1, 1) == 0) + abort (); + return 0; +} diff --git a/test/tests/20031011-1.c b/test/tests/20031011-1.c new file mode 100644 index 0000000..9aa40b8 --- /dev/null +++ b/test/tests/20031011-1.c @@ -0,0 +1,31 @@ +/* Check that MAX_EXPR and MIN_EXPR are working properly. */ + +#define MAX(X,Y) ((X) > (Y) ? (X) : (Y)) +#define MIN(X,Y) ((X) < (Y) ? (X) : (Y)) + +extern void abort (void); + +int main() +{ + int ll_bitsize, ll_bitpos; + int rl_bitsize, rl_bitpos; + int end_bit; + + ll_bitpos = 32; ll_bitsize = 32; + rl_bitpos = 0; rl_bitsize = 32; + + end_bit = MAX (ll_bitpos + ll_bitsize, rl_bitpos + rl_bitsize); + if (end_bit != 64) + abort (); + end_bit = MAX (rl_bitpos + rl_bitsize, ll_bitpos + ll_bitsize); + if (end_bit != 64) + abort (); + end_bit = MIN (ll_bitpos + ll_bitsize, rl_bitpos + rl_bitsize); + if (end_bit != 32) + abort (); + end_bit = MIN (rl_bitpos + rl_bitsize, ll_bitpos + ll_bitsize); + if (end_bit != 32) + abort (); + return 0; +} + diff --git a/test/tests/20031012-1.c b/test/tests/20031012-1.c new file mode 100644 index 0000000..a1f3de8 --- /dev/null +++ b/test/tests/20031012-1.c @@ -0,0 +1,32 @@ +/* PR optimization/8750 + Used to fail under Cygwin with + -O2 -fomit-frame-pointer + Testcase by David B. Trout */ + +#if defined(STACK_SIZE) && STACK_SIZE < 16000 +#define ARRAY_SIZE (STACK_SIZE / 2) +#define STRLEN (ARRAY_SIZE - 9) +#else +#define ARRAY_SIZE 15000 +#define STRLEN 13371 +#endif + +extern void *memset (void *, int, __SIZE_TYPE__); +extern void abort (void); + +static void foo () +{ + char a[ARRAY_SIZE]; + + a[0]=0; + memset( &a[0], 0xCD, STRLEN ); + a[STRLEN]=0; + if (strlen(a) != STRLEN) + abort (); +} + +int main ( int argc, char* argv[] ) +{ + foo(); + return 0; +} diff --git a/test/tests/20031020-1.c b/test/tests/20031020-1.c new file mode 100644 index 0000000..526ca04 --- /dev/null +++ b/test/tests/20031020-1.c @@ -0,0 +1,23 @@ +/* PR target/12654 + The Alpha backend tried to do a >= 1024 as (a - 1024) >= 0, which fails + for very large negative values. */ +/* Origin: tg@swox.com */ + +#include + +extern void abort (void); + +void __attribute__((noinline)) +foo (long x) +{ + if (x >= 1024) + abort (); +} + +int +main () +{ + foo (LONG_MIN); + foo (LONG_MIN + 10000); + return 0; +} diff --git a/test/tests/20031201-1.c b/test/tests/20031201-1.c new file mode 100644 index 0000000..7c8e0ea --- /dev/null +++ b/test/tests/20031201-1.c @@ -0,0 +1,76 @@ +/* Copyright (C) 2003 Free Software Foundation. + PR target/13256 + STRICT_LOW_PART was handled incorrectly in delay slots. + Origin: Hans-Peter Nilsson. */ + +typedef struct { unsigned int e0 : 16; unsigned int e1 : 16; } s1; +typedef struct { unsigned int e0 : 16; unsigned int e1 : 16; } s2; +typedef struct { s1 i12; s2 i16; } io; +static int test_length = 2; +static io *i; +static int m = 1; +static int d = 1; +static unsigned long test_t0; +static unsigned long test_t1; +void test(void) __attribute__ ((__noinline__)); +extern int f1 (void *port) __attribute__ ((__noinline__)); +extern void f0 (void) __attribute__ ((__noinline__)); +int +f1 (void *port) +{ + int fail_count = 0; + unsigned long tlen; + s1 x0 = {0}; + s2 x1 = {0}; + + i = port; + x0.e0 = x1.e0 = 32; + i->i12 = x0; + i->i16 = x1; + do f0(); while (test_t1); + x0.e0 = x1.e0 = 8; + i->i12 = x0; + i->i16 = x1; + test (); + if (m) + { + unsigned long e = 1000000000 / 460800 * test_length; + tlen = test_t1 - test_t0; + if (((tlen-e) & 0x7FFFFFFF) > 1000) + f0(); + } + if (d) + { + unsigned long e = 1000000000 / 460800 * test_length; + tlen = test_t1 - test_t0; + if (((tlen - e) & 0x7FFFFFFF) > 1000) + f0(); + } + return fail_count != 0 ? 1 : 0; +} + +int +main () +{ + io io0; + f1 (&io0); + abort (); +} + +void +test (void) +{ + io *iop = i; + if (iop->i12.e0 != 8 || iop->i16.e0 != 8) + abort (); + exit (0); +} + +void +f0 (void) +{ + static int washere = 0; + io *iop = i; + if (washere++ || iop->i12.e0 != 32 || iop->i16.e0 != 32) + abort (); +} diff --git a/test/tests/20031204-1.c b/test/tests/20031204-1.c new file mode 100644 index 0000000..a9c2f01 --- /dev/null +++ b/test/tests/20031204-1.c @@ -0,0 +1,49 @@ +/* PR optimization/13260 */ + +#include + +typedef unsigned long u32; + +u32 in_aton(const char* x) +{ + return 0x0a0b0c0d; +} + +u32 root_nfs_parse_addr(char *name) +{ + u32 addr; + int octets = 0; + char *cp, *cq; + + cp = cq = name; + while (octets < 4) { + while (*cp >= '0' && *cp <= '9') + cp++; + if (cp == cq || cp - cq > 3) + break; + if (*cp == '.' || octets == 3) + octets++; + if (octets < 4) + cp++; + cq = cp; + } + + if (octets == 4 && (*cp == ':' || *cp == '\0')) { + if (*cp == ':') + *cp++ = '\0'; + addr = in_aton(name); + strcpy(name, cp); + } else + addr = (-1); + + return addr; +} + +int +main() +{ + static char addr[] = "10.11.12.13:/hello"; + u32 result = root_nfs_parse_addr(addr); + if (result != 0x0a0b0c0d) { abort(); } + return 0; +} diff --git a/test/tests/20031211-1.c b/test/tests/20031211-1.c new file mode 100644 index 0000000..2361509 --- /dev/null +++ b/test/tests/20031211-1.c @@ -0,0 +1,13 @@ +struct a { unsigned int bitfield : 1; }; + +unsigned int x; + +main() +{ + struct a a = {0}; + x = 0xbeef; + a.bitfield |= x; + if (a.bitfield != 1) + abort (); + exit (0); +} diff --git a/test/tests/20031211-2.c b/test/tests/20031211-2.c new file mode 100644 index 0000000..555b17d --- /dev/null +++ b/test/tests/20031211-2.c @@ -0,0 +1,19 @@ +struct a +{ + unsigned int bitfield : 3; +}; + +int main() +{ + struct a a; + + a.bitfield = 131; + foo (a.bitfield); + exit (0); +} + +foo(unsigned int z) +{ + if (z != 3) + abort (); +} diff --git a/test/tests/20031214-1.c b/test/tests/20031214-1.c new file mode 100644 index 0000000..e52200c --- /dev/null +++ b/test/tests/20031214-1.c @@ -0,0 +1,32 @@ +/* PR optimization/10312 */ +/* Originator: Peter van Hoof

    */ + +/* Verify that the strength reduction pass doesn't find + illegitimate givs. */ + +struct +{ + double a; + int n[2]; +} g = { 0., { 1, 2}}; + +int k = 0; + +void +b (int *j) +{ +} + +int +main () +{ + int j; + + for (j = 0; j < 2; j++) + k = (k > g.n[j]) ? k : g.n[j]; + + k++; + b (&j); + + return 0; +} diff --git a/test/tests/20031215-1.c b/test/tests/20031215-1.c new file mode 100644 index 0000000..d62177b --- /dev/null +++ b/test/tests/20031215-1.c @@ -0,0 +1,38 @@ +/* PR middle-end/13400 */ +/* The following test used to fail at run-time with a write to read-only + memory, caused by if-conversion converting a conditional write into an + unconditional write. */ + +typedef struct {int c, l; char ch[3];} pstr; +const pstr ao = {2, 2, "OK"}; +const pstr * const a = &ao; + +void test1(void) +{ + if (a->ch[a->l]) { + ((char *)a->ch)[a->l] = 0; + } +} + +void test2(void) +{ + if (a->ch[a->l]) { + ((char *)a->ch)[a->l] = -1; + } +} + +void test3(void) +{ + if (a->ch[a->l]) { + ((char *)a->ch)[a->l] = 1; + } +} + +int main(void) +{ + test1(); + test2(); + test3(); + return 0; +} + diff --git a/test/tests/20031216-1.c b/test/tests/20031216-1.c new file mode 100644 index 0000000..59dc067 --- /dev/null +++ b/test/tests/20031216-1.c @@ -0,0 +1,23 @@ +/* PR optimization/13313 */ +/* Origin: Mike Lerwill */ + +extern void abort(void); + +void DisplayNumber (unsigned long v) +{ + if (v != 0x9aL) + abort(); +} + +unsigned long ReadNumber (void) +{ + return 0x09a0L; +} + +int main (void) +{ + unsigned long tmp; + tmp = (ReadNumber() & 0x0ff0L) >> 4; + DisplayNumber (tmp); + return 0; +} diff --git a/test/tests/20040208-1.c b/test/tests/20040208-1.c new file mode 100644 index 0000000..0235759 --- /dev/null +++ b/test/tests/20040208-1.c @@ -0,0 +1,10 @@ +int main () +{ + long double x; + + x = 0x1.0p-500L; + x *= 0x1.0p-522L; + if (x != 0x1.0p-1022L) + abort (); + exit (0); +} diff --git a/test/tests/20040208-2.c b/test/tests/20040208-2.c new file mode 100644 index 0000000..2359dc9 --- /dev/null +++ b/test/tests/20040208-2.c @@ -0,0 +1,11 @@ +int main () +{ + long double x, y; + + x = 0x1.fffffffffffff8p10L; + x *= 2; + y = 0x1.fffffffffffff8p11L; + if (memcmp (&x, &y, sizeof (x)) != 0) + abort (); + exit (0); +} diff --git a/test/tests/20040218-1.c b/test/tests/20040218-1.c new file mode 100644 index 0000000..4d1541a --- /dev/null +++ b/test/tests/20040218-1.c @@ -0,0 +1,37 @@ +/* PR target/14209. Bug in cris.md, shrinking access size of + postincrement. + Origin: . */ + +long int xb (long int *y) __attribute__ ((__noinline__)); +long int xw (long int *y) __attribute__ ((__noinline__)); +short int yb (short int *y) __attribute__ ((__noinline__)); + +long int xb (long int *y) +{ + long int xx = *y & 255; + return xx + y[1]; +} + +long int xw (long int *y) +{ + long int xx = *y & 65535; + return xx + y[1]; +} + +short int yb (short int *y) +{ + short int xx = *y & 255; + return xx + y[1]; +} + +int main (void) +{ + long int y[] = {-1, 16000}; + short int yw[] = {-1, 16000}; + + if (xb (y) != 16255 + || xw (y) != 81535 + || yb (yw) != 16255) + abort (); + exit (0); +} diff --git a/test/tests/20040223-1.c b/test/tests/20040223-1.c new file mode 100644 index 0000000..f1763b5 --- /dev/null +++ b/test/tests/20040223-1.c @@ -0,0 +1,18 @@ +#include +//#include + +void +a(void *x,int y) +{ + if (y != 1234) + abort (); +} + +char allaalla[100]; + +int +main() +{ + a(strcpy(/* alloca(100) */ allaalla,"abc"),1234); + return 0; +} diff --git a/test/tests/20040302-1.c b/test/tests/20040302-1.c new file mode 100644 index 0000000..07056c4 --- /dev/null +++ b/test/tests/20040302-1.c @@ -0,0 +1,24 @@ +int code[]={0,0,0,0,1}; + +void foo(int x) { + volatile int b; + b = 0xffffffff; +} + +void bar(int *pc) { + static const void *l[] = {&&lab0, &&end}; + + foo(0); + goto *l[*pc]; + lab0: + foo(0); + pc++; + goto *l[*pc]; + end: + return; +} + +int main() { + bar(code); + return 0; +} diff --git a/test/tests/20040307-1.c b/test/tests/20040307-1.c new file mode 100644 index 0000000..8ab8008 --- /dev/null +++ b/test/tests/20040307-1.c @@ -0,0 +1,25 @@ +int main() +{ + int b = 0; + + struct { + unsigned int bit0:1; + unsigned int bit1:1; + unsigned int bit2:1; + unsigned int bit3:1; + unsigned int bit4:1; + unsigned int bit5:1; + unsigned int bit6:1; + unsigned int bit7:1; + } sdata = {0x01}; + + while ( sdata.bit0-- > 0 ) { + b++ ; + if ( b > 100 ) break; + } + + if (b != 1) + abort (); + return 0; +} + diff --git a/test/tests/20040309-1.c b/test/tests/20040309-1.c new file mode 100644 index 0000000..49fa795 --- /dev/null +++ b/test/tests/20040309-1.c @@ -0,0 +1,24 @@ +extern void abort (); + +int foo(unsigned short x) +{ + unsigned short y; + y = x > 32767 ? x - 32768 : 0; + return y; +} + +int main() +{ + if (foo (0) != 0) + abort (); + if (foo (32767) != 0) + abort (); + if (foo (32768) != 0) + abort (); + if (foo (32769) != 1) + abort (); + if (foo (65535) != 32767) + abort (); + return 0; +} + diff --git a/test/tests/20040311-1.c b/test/tests/20040311-1.c new file mode 100644 index 0000000..013d869 --- /dev/null +++ b/test/tests/20040311-1.c @@ -0,0 +1,68 @@ +/* Copyright (C) 2004 Free Software Foundation. + + Check that constant folding and RTL simplification of -(x >> y) doesn't + break anything and produces the expected results. + + Written by Roger Sayle, 11th March 2004. */ + +extern void abort (void); + +#define INT_BITS (sizeof(int)*8) + +int test1(int x) +{ + return -(x >> (INT_BITS-1)); +} + +int test2(unsigned int x) +{ + return -((int)(x >> (INT_BITS-1))); +} + +int test3(int x) +{ + int y; + y = INT_BITS-1; + return -(x >> y); +} + +int test4(unsigned int x) +{ + int y; + y = INT_BITS-1; + return -((int)(x >> y)); +} + +int main() +{ + if (test1(0) != 0) + abort (); + if (test1(1) != 0) + abort (); + if (test1(-1) != 1) + abort (); + + if (test2(0) != 0) + abort (); + if (test2(1) != 0) + abort (); + if (test2((unsigned int)-1) != -1) + abort (); + + if (test3(0) != 0) + abort (); + if (test3(1) != 0) + abort (); + if (test3(-1) != 1) + abort (); + + if (test4(0) != 0) + abort (); + if (test4(1) != 0) + abort (); + if (test4((unsigned int)-1) != -1) + abort (); + + return 0; +} + diff --git a/test/tests/20040313-1.c b/test/tests/20040313-1.c new file mode 100644 index 0000000..c05fe73 --- /dev/null +++ b/test/tests/20040313-1.c @@ -0,0 +1,17 @@ +/* PR middle-end/14470 */ +/* Origin: Lodewijk Voge */ + +extern void abort(void); + +int main() +{ + int t[1025] = { 1024 }, d; + + d = 0; + d = t[d]++; + if (t[0] != 1025) + abort(); + if (d != 1024) + abort(); + return 0; +} diff --git a/test/tests/20040319-1.c b/test/tests/20040319-1.c new file mode 100644 index 0000000..357932d --- /dev/null +++ b/test/tests/20040319-1.c @@ -0,0 +1,17 @@ +int +blah (int zzz) +{ + int foo; + if (zzz >= 0) + return 1; + foo = (zzz >= 0 ? (zzz) : -(zzz)); + return foo; +} + +main() +{ + if (blah (-1) != 1) + abort (); + else + exit (0); +} diff --git a/test/tests/20040331-1.c b/test/tests/20040331-1.c new file mode 100644 index 0000000..2e8f9e8 --- /dev/null +++ b/test/tests/20040331-1.c @@ -0,0 +1,20 @@ +/* PR c++/14755 */ +extern void abort (void); +extern void exit (int); + +int +main (void) +{ +#if __INT_MAX__ >= 2147483647 + struct { int count: 31; } s = { 0 }; + while (s.count--) + abort (); +#elif __INT_MAX__ >= 32767 + struct { int count: 15; } s = { 0 }; + while (s.count--) + abort (); +#else + /* Don't bother because __INT_MAX__ is too small. */ +#endif + exit (0); +} diff --git a/test/tests/20040409-1.c b/test/tests/20040409-1.c new file mode 100644 index 0000000..1e81edb --- /dev/null +++ b/test/tests/20040409-1.c @@ -0,0 +1,142 @@ +#include + +extern void abort (); + +int test1(int x) +{ + return x ^ INT_MIN; +} + +unsigned int test1u(unsigned int x) +{ + return x ^ (unsigned int)INT_MIN; +} + +int test2(int x) +{ + return x + INT_MIN; +} + +unsigned int test2u(unsigned int x) +{ + return x + (unsigned int)INT_MIN; +} + +int test3(int x) +{ + return x - INT_MIN; +} + +unsigned int test3u(unsigned int x) +{ + return x - (unsigned int)INT_MIN; +} + +int test4(int x) +{ + int y = INT_MIN; + return x ^ y; +} + +unsigned int test4u(unsigned int x) +{ + unsigned int y = (unsigned int)INT_MIN; + return x ^ y; +} + +int test5(int x) +{ + int y = INT_MIN; + return x + y; +} + +unsigned int test5u(unsigned int x) +{ + unsigned int y = (unsigned int)INT_MIN; + return x + y; +} + +int test6(int x) +{ + int y = INT_MIN; + return x - y; +} + +unsigned int test6u(unsigned int x) +{ + unsigned int y = (unsigned int)INT_MIN; + return x - y; +} + + + +void test(int a, int b) +{ + if (test1(a) != b) + abort(); + if (test2(a) != b) + abort(); + if (test3(a) != b) + abort(); + if (test4(a) != b) + abort(); + if (test5(a) != b) + abort(); + if (test6(a) != b) + abort(); +} + +void testu(unsigned int a, unsigned int b) +{ + if (test1u(a) != b) + abort(); + if (test2u(a) != b) + abort(); + if (test3u(a) != b) + abort(); + if (test4u(a) != b) + abort(); + if (test5u(a) != b) + abort(); + if (test6u(a) != b) + abort(); +} + + +int main() +{ +#if INT_MAX == 2147483647 + test(0x00000000,0x80000000); + test(0x80000000,0x00000000); + test(0x12345678,0x92345678); + test(0x92345678,0x12345678); + test(0x7fffffff,0xffffffff); + test(0xffffffff,0x7fffffff); + + testu(0x00000000,0x80000000); + testu(0x80000000,0x00000000); + testu(0x12345678,0x92345678); + testu(0x92345678,0x12345678); + testu(0x7fffffff,0xffffffff); + testu(0xffffffff,0x7fffffff); +#endif + +#if INT_MAX == 32767 + test(0x0000,0x8000); + test(0x8000,0x0000); + test(0x1234,0x9234); + test(0x9234,0x1234); + test(0x7fff,0xffff); + test(0xffff,0x7fff); + + testu(0x0000,0x8000); + testu(0x8000,0x0000); + testu(0x1234,0x9234); + testu(0x9234,0x1234); + testu(0x7fff,0xffff); + testu(0xffff,0x7fff); +#endif + + return 0; +} + diff --git a/test/tests/20040409-2.c b/test/tests/20040409-2.c new file mode 100644 index 0000000..c83ff1a --- /dev/null +++ b/test/tests/20040409-2.c @@ -0,0 +1,243 @@ +#include + +extern void abort (); + +int test1(int x) +{ + return (x ^ INT_MIN) ^ 0x1234; +} + +unsigned int test1u(unsigned int x) +{ + return (x ^ (unsigned int)INT_MIN) ^ 0x1234; +} + +int test2(int x) +{ + return (x ^ 0x1234) ^ INT_MIN; +} + +unsigned int test2u(unsigned int x) +{ + return (x ^ 0x1234) ^ (unsigned int)INT_MIN; +} + +int test3(int x) +{ + return (x + INT_MIN) ^ 0x1234; +} + +unsigned int test3u(unsigned int x) +{ + return (x + (unsigned int)INT_MIN) ^ 0x1234; +} + +int test4(int x) +{ + return (x ^ 0x1234) + INT_MIN; +} + +unsigned int test4u(unsigned int x) +{ + return (x ^ 0x1234) + (unsigned int)INT_MIN; +} + +int test5(int x) +{ + return (x - INT_MIN) ^ 0x1234; +} + +unsigned int test5u(unsigned int x) +{ + return (x - (unsigned int)INT_MIN) ^ 0x1234; +} + +int test6(int x) +{ + return (x ^ 0x1234) - INT_MIN; +} + +unsigned int test6u(unsigned int x) +{ + return (x ^ 0x1234) - (unsigned int)INT_MIN; +} + +int test7(int x) +{ + int y = INT_MIN; + int z = 0x1234; + return (x ^ y) ^ z; +} + +unsigned int test7u(unsigned int x) +{ + unsigned int y = (unsigned int)INT_MIN; + unsigned int z = 0x1234; + return (x ^ y) ^ z; +} + +int test8(int x) +{ + int y = 0x1234; + int z = INT_MIN; + return (x ^ y) ^ z; +} + +unsigned int test8u(unsigned int x) +{ + unsigned int y = 0x1234; + unsigned int z = (unsigned int)INT_MIN; + return (x ^ y) ^ z; +} + +int test9(int x) +{ + int y = INT_MIN; + int z = 0x1234; + return (x + y) ^ z; +} + +unsigned int test9u(unsigned int x) +{ + unsigned int y = (unsigned int)INT_MIN; + unsigned int z = 0x1234; + return (x + y) ^ z; +} + +int test10(int x) +{ + int y = 0x1234; + int z = INT_MIN; + return (x ^ y) + z; +} + +unsigned int test10u(unsigned int x) +{ + unsigned int y = 0x1234; + unsigned int z = (unsigned int)INT_MIN; + return (x ^ y) + z; +} + +int test11(int x) +{ + int y = INT_MIN; + int z = 0x1234; + return (x - y) ^ z; +} + +unsigned int test11u(unsigned int x) +{ + unsigned int y = (unsigned int)INT_MIN; + unsigned int z = 0x1234; + return (x - y) ^ z; +} + +int test12(int x) +{ + int y = 0x1234; + int z = INT_MIN; + return (x ^ y) - z; +} + +unsigned int test12u(unsigned int x) +{ + unsigned int y = 0x1234; + unsigned int z = (unsigned int)INT_MIN; + return (x ^ y) - z; +} + + +void test(int a, int b) +{ + if (test1(a) != b) + abort(); + if (test2(a) != b) + abort(); + if (test3(a) != b) + abort(); + if (test4(a) != b) + abort(); + if (test5(a) != b) + abort(); + if (test6(a) != b) + abort(); + if (test7(a) != b) + abort(); + if (test8(a) != b) + abort(); + if (test9(a) != b) + abort(); + if (test10(a) != b) + abort(); + if (test11(a) != b) + abort(); + if (test12(a) != b) + abort(); +} + +void testu(unsigned int a, unsigned int b) +{ + if (test1u(a) != b) + abort(); + if (test2u(a) != b) + abort(); + if (test3u(a) != b) + abort(); + if (test4u(a) != b) + abort(); + if (test5u(a) != b) + abort(); + if (test6u(a) != b) + abort(); + if (test7u(a) != b) + abort(); + if (test8u(a) != b) + abort(); + if (test9u(a) != b) + abort(); + if (test10u(a) != b) + abort(); + if (test11u(a) != b) + abort(); + if (test12u(a) != b) + abort(); +} + + +int main() +{ +#if INT_MAX == 2147483647 + test(0x00000000,0x80001234); + test(0x00001234,0x80000000); + test(0x80000000,0x00001234); + test(0x80001234,0x00000000); + test(0x7fffffff,0xffffedcb); + test(0xffffffff,0x7fffedcb); + + testu(0x00000000,0x80001234); + testu(0x00001234,0x80000000); + testu(0x80000000,0x00001234); + testu(0x80001234,0x00000000); + testu(0x7fffffff,0xffffedcb); + testu(0xffffffff,0x7fffedcb); +#endif + +#if INT_MAX == 32767 + test(0x0000,0x9234); + test(0x1234,0x8000); + test(0x8000,0x1234); + test(0x9234,0x0000); + test(0x7fff,0xedcb); + test(0xffff,0x6dcb); + + testu(0x0000,0x9234); + testu(0x8000,0x1234); + testu(0x1234,0x8000); + testu(0x9234,0x0000); + testu(0x7fff,0xedcb); + testu(0xffff,0x6dcb); +#endif + + return 0; +} + diff --git a/test/tests/20040409-3.c b/test/tests/20040409-3.c new file mode 100644 index 0000000..07aa99c --- /dev/null +++ b/test/tests/20040409-3.c @@ -0,0 +1,142 @@ +#include + +extern void abort (); + +int test1(int x) +{ + return ~(x ^ INT_MIN); +} + +unsigned int test1u(unsigned int x) +{ + return ~(x ^ (unsigned int)INT_MIN); +} + +int test2(int x) +{ + return ~(x + INT_MIN); +} + +unsigned int test2u(unsigned int x) +{ + return ~(x + (unsigned int)INT_MIN); +} + +int test3(int x) +{ + return ~(x - INT_MIN); +} + +unsigned int test3u(unsigned int x) +{ + return ~(x - (unsigned int)INT_MIN); +} + +int test4(int x) +{ + int y = INT_MIN; + return ~(x ^ y); +} + +unsigned int test4u(unsigned int x) +{ + unsigned int y = (unsigned int)INT_MIN; + return ~(x ^ y); +} + +int test5(int x) +{ + int y = INT_MIN; + return ~(x + y); +} + +unsigned int test5u(unsigned int x) +{ + unsigned int y = (unsigned int)INT_MIN; + return ~(x + y); +} + +int test6(int x) +{ + int y = INT_MIN; + return ~(x - y); +} + +unsigned int test6u(unsigned int x) +{ + unsigned int y = (unsigned int)INT_MIN; + return ~(x - y); +} + + + +void test(int a, int b) +{ + if (test1(a) != b) + abort(); + if (test2(a) != b) + abort(); + if (test3(a) != b) + abort(); + if (test4(a) != b) + abort(); + if (test5(a) != b) + abort(); + if (test6(a) != b) + abort(); +} + +void testu(unsigned int a, unsigned int b) +{ + if (test1u(a) != b) + abort(); + if (test2u(a) != b) + abort(); + if (test3u(a) != b) + abort(); + if (test4u(a) != b) + abort(); + if (test5u(a) != b) + abort(); + if (test6u(a) != b) + abort(); +} + + +int main() +{ +#if INT_MAX == 2147483647 + test(0x00000000,0x7fffffff); + test(0x80000000,0xffffffff); + test(0x12345678,0x6dcba987); + test(0x92345678,0xedcba987); + test(0x7fffffff,0x00000000); + test(0xffffffff,0x80000000); + + testu(0x00000000,0x7fffffff); + testu(0x80000000,0xffffffff); + testu(0x12345678,0x6dcba987); + testu(0x92345678,0xedcba987); + testu(0x7fffffff,0x00000000); + testu(0xffffffff,0x80000000); +#endif + +#if INT_MAX == 32767 + test(0x0000,0x7fff); + test(0x8000,0xffff); + test(0x1234,0x6dcb); + test(0x9234,0xedcb); + test(0x7fff,0x0000); + test(0xffff,0x8000); + + testu(0x0000,0x7fff); + testu(0x8000,0xffff); + testu(0x1234,0x6dcb); + testu(0x9234,0xedcb); + testu(0x7fff,0x0000); + testu(0xffff,0x8000); +#endif + + return 0; +} + diff --git a/test/tests/20040625-1.c b/test/tests/20040625-1.c new file mode 100644 index 0000000..c33e396 --- /dev/null +++ b/test/tests/20040625-1.c @@ -0,0 +1,20 @@ +/* From PR target/16176 */ +struct s { struct s *next; } __attribute__ ((packed)); + +struct s * __attribute__ ((noinline)) +maybe_next (struct s *s, int t) +{ + if (t) + s = s->next; + return s; +} + +int main () +{ + struct s s1, s2; + + s1.next = &s2; + if (maybe_next (&s1, 1) != &s2) + abort (); + exit (0); +} diff --git a/test/tests/20040629-1.c b/test/tests/20040629-1.c new file mode 100644 index 0000000..2e89645 --- /dev/null +++ b/test/tests/20040629-1.c @@ -0,0 +1,144 @@ +/* Test arithmetics on bitfields. */ +#ifndef T + +extern void abort (void); +extern void exit (int); + +#ifndef FIELDS1 +#define FIELDS1 +#endif +#ifndef FIELDS2 +#define FIELDS2 +#endif + +struct { FIELDS1 unsigned int i : 6, j : 11, k : 15; FIELDS2 } b; +struct { FIELDS1 unsigned int i : 5, j : 1, k : 16; FIELDS2 } c; +struct { FIELDS1 unsigned int i : 16, j : 8, k : 8; FIELDS2 } d; + +unsigned int ret1 (void) { return b.i; } +unsigned int ret2 (void) { return b.j; } +unsigned int ret3 (void) { return b.k; } +unsigned int ret4 (void) { return c.i; } +unsigned int ret5 (void) { return c.j; } +unsigned int ret6 (void) { return c.k; } +unsigned int ret7 (void) { return d.i; } +unsigned int ret8 (void) { return d.j; } +unsigned int ret9 (void) { return d.k; } + +#define T(n, pre, post, op) \ +void fn1_##n (unsigned int x) { pre b.i post; } \ +void fn2_##n (unsigned int x) { pre b.j post; } \ +void fn3_##n (unsigned int x) { pre b.k post; } \ +void fn4_##n (unsigned int x) { pre c.i post; } \ +void fn5_##n (unsigned int x) { pre c.j post; } \ +void fn6_##n (unsigned int x) { pre c.k post; } \ +void fn7_##n (unsigned int x) { pre d.i post; } \ +void fn8_##n (unsigned int x) { pre d.j post; } \ +void fn9_##n (unsigned int x) { pre d.k post; } + +#include "20040629-1.c" +#undef T + +#define FAIL(n, i) abort () + +//#define bigding 33554432 +#define bigding 32354 +//#define smallding 264151 +#define smallding 2641 + +int +main (void) +{ +#define T(n, pre, post, op) \ + b.i = 51; \ + b.j = 636; \ + b.k = 31278; \ + c.i = 21; \ + c.j = 1; \ + c.k = bigding; \ + d.i = 26812; \ + d.j = 156; \ + d.k = 187; \ + fn1_##n (3); \ + if (ret1 () != (op (51, 3) & ((1 << 6) - 1))) \ + FAIL (n, 1); \ + b.i = 51; \ + fn2_##n (251); \ + if (ret2 () != (op (636, 251) & ((1 << 11) - 1))) \ + FAIL (n, 2); \ + b.j = 636; \ + fn3_##n (13279); \ + if (ret3 () != (op (31278, 13279) & ((1 << 15) - 1))) \ + FAIL (n, 3); \ + b.j = 31278; \ + fn4_##n (24); \ + if (ret4 () != (op (21, 24) & ((1 << 5) - 1))) \ + FAIL (n, 4); \ + c.i = 21; \ + fn5_##n (1); \ + if (ret5 () != (op (1, 1) & ((1 << 1) - 1))) \ + FAIL (n, 5); \ + c.j = 1; \ + fn6_##n (264151); \ + if (ret6 () != (op (bigding, 264151) & ((1 << 26) - 1))) \ + FAIL (n, 6); \ + c.k = bigding; \ + fn7_##n (713); \ + if (ret7 () != (op (26812, 713) & ((1 << 16) - 1))) \ + FAIL (n, 7); \ + d.i = 26812; \ + fn8_##n (17); \ + if (ret8 () != (op (156, 17) & ((1 << 8) - 1))) \ + FAIL (n, 8); \ + d.j = 156; \ + fn9_##n (199); \ + if (ret9 () != (op (187, 199) & ((1 << 8) - 1))) \ + FAIL (n, 9); \ + d.k = 187; + +#include "20040629-1.c" +#undef T + return 0; +} + +#else + +#ifndef opadd +#define opadd(x, y) (x + y) +#define opsub(x, y) (x - y) +#define opinc(x, y) (x + 1) +#define opdec(x, y) (x - 1) +#define opand(x, y) (x & y) +#define opior(x, y) (x | y) +#define opxor(x, y) (x ^ y) +#define opdiv(x, y) (x / y) +#define oprem(x, y) (x % y) +#define opadd3(x, y) (x + 3) +#define opsub7(x, y) (x - 7) +#define opand21(x, y) (x & 21) +#define opior19(x, y) (x | 19) +#define opxor37(x, y) (x ^ 37) +#define opdiv17(x, y) (x / 17) +#define oprem19(x, y) (x % 19) +#endif + +T(1, , += x, opadd) +T(2, ++, , opinc) +T(3, , ++, opinc) +T(4, , -= x, opsub) +T(5, --, , opdec) +T(6, , --, opdec) +T(7, , &= x, opand) +T(8, , |= x, opior) +T(9, , ^= x, opxor) +T(a, , /= x, opdiv) +T(b, , %= x, oprem) +T(c, , += 3, opadd3) +T(d, , -= 7, opsub7) +T(e, , &= 21, opand21) +T(f, , |= 19, opior19) +T(g, , ^= 37, opxor37) +T(h, , /= 17, opdiv17) +T(i, , %= 19, oprem19) + +#endif diff --git a/test/tests/20040703-1.c b/test/tests/20040703-1.c new file mode 100644 index 0000000..ea87585 --- /dev/null +++ b/test/tests/20040703-1.c @@ -0,0 +1,147 @@ +/* PR 16341 */ + +#define PART_PRECISION (sizeof (cpp_num_part) * 8) + +typedef unsigned int cpp_num_part; +typedef struct cpp_num cpp_num; +struct cpp_num +{ + cpp_num_part high; + cpp_num_part low; + int unsignedp; /* True if value should be treated as unsigned. */ + int overflow; /* True if the most recent calculation overflowed. */ +}; + +static int +num_positive (cpp_num num, unsigned int precision) +{ + if (precision > PART_PRECISION) + { + precision -= PART_PRECISION; + return (num.high & (cpp_num_part) 1 << (precision - 1)) == 0; + } + + return (num.low & (cpp_num_part) 1 << (precision - 1)) == 0; +} + +static cpp_num +num_trim (cpp_num num, unsigned int precision) +{ + if (precision > PART_PRECISION) + { + precision -= PART_PRECISION; + if (precision < PART_PRECISION) + num.high &= ((cpp_num_part) 1 << precision) - 1; + } + else + { + if (precision < PART_PRECISION) + num.low &= ((cpp_num_part) 1 << precision) - 1; + num.high = 0; + } + + return num; +} + +/* Shift NUM, of width PRECISION, right by N bits. */ +static cpp_num +num_rshift (cpp_num num, unsigned int precision, unsigned int n) +{ + cpp_num_part sign_mask; + int x = num_positive (num, precision); + + if (num.unsignedp || x) + sign_mask = 0; + else + sign_mask = ~(cpp_num_part) 0; + + if (n >= precision) + num.high = num.low = sign_mask; + else + { + /* Sign-extend. */ + if (precision < PART_PRECISION) + num.high = sign_mask, num.low |= sign_mask << precision; + else if (precision < 2 * PART_PRECISION) + num.high |= sign_mask << (precision - PART_PRECISION); + + if (n >= PART_PRECISION) + { + n -= PART_PRECISION; + num.low = num.high; + num.high = sign_mask; + } + + if (n) + { + num.low = (num.low >> n) | (num.high << (PART_PRECISION - n)); + num.high = (num.high >> n) | (sign_mask << (PART_PRECISION - n)); + } + } + + num = num_trim (num, precision); + num.overflow = 0; + return num; +} + #define num_zerop(num) ((num.low | num.high) == 0) +#define num_eq(num1, num2) (num1.low == num2.low && num1.high == num2.high) + +cpp_num +num_lshift (cpp_num num, unsigned int precision, unsigned int n) +{ + if (n >= precision) + { + num.overflow = !num.unsignedp && !num_zerop (num); + num.high = num.low = 0; + } + else + { + cpp_num orig; + unsigned int m = n; + + orig = num; + if (m >= PART_PRECISION) + { + m -= PART_PRECISION; + num.high = num.low; + num.low = 0; + } + if (m) + { + num.high = (num.high << m) | (num.low >> (PART_PRECISION - m)); + num.low <<= m; + } + num = num_trim (num, precision); + + if (num.unsignedp) + num.overflow = 0; + else + { + cpp_num maybe_orig = num_rshift (num, precision, n); + num.overflow = !num_eq (orig, maybe_orig); + } + } + + return num; +} + +unsigned int precision = 32; +unsigned int n = 8; + +cpp_num num = { 0, 3, 0, 0 }; + +int main() +{ + cpp_num res = num_lshift (num, 64, n); + + if (res.low != 0x300) + abort (); + + if (res.high != 0) + abort (); + + if (res.overflow != 0) + abort (); + + exit (0); +} diff --git a/test/tests/20040704-1.c b/test/tests/20040704-1.c new file mode 100644 index 0000000..c6b23d0 --- /dev/null +++ b/test/tests/20040704-1.c @@ -0,0 +1,14 @@ +/* PR 16348: Make sure that condition-first false loops DTRT. */ + +extern void abort (); + +int main() +{ + for (; 0 ;) + { + abort (); + label: + return 0; + } + goto label; +} diff --git a/test/tests/20040705-1.c b/test/tests/20040705-1.c new file mode 100644 index 0000000..a9ba88e --- /dev/null +++ b/test/tests/20040705-1.c @@ -0,0 +1,2 @@ +#define FIELDS1 long long l; +#include "20040629-1.c" diff --git a/test/tests/20040705-2.c b/test/tests/20040705-2.c new file mode 100644 index 0000000..a36fb6a --- /dev/null +++ b/test/tests/20040705-2.c @@ -0,0 +1,2 @@ +#define FIELDS2 long long l; +#include "20040629-1.c" diff --git a/test/tests/20040706-1.c b/test/tests/20040706-1.c new file mode 100644 index 0000000..6b0ab36 --- /dev/null +++ b/test/tests/20040706-1.c @@ -0,0 +1,9 @@ +int main () +{ + int i; + for (i = 0; i < 10; i++) + continue; + if (i < 10) + abort (); + exit (0); +} diff --git a/test/tests/20040707-1.c b/test/tests/20040707-1.c new file mode 100644 index 0000000..6fc15cc --- /dev/null +++ b/test/tests/20040707-1.c @@ -0,0 +1,12 @@ +struct s { char c1, c2; }; +void foo (struct s s) +{ + static struct s s1; + s1 = s; +} +int main () +{ + static struct s s2; + foo (s2); + exit (0); +} diff --git a/test/tests/20040709-1.c b/test/tests/20040709-1.c new file mode 100644 index 0000000..e6074fb --- /dev/null +++ b/test/tests/20040709-1.c @@ -0,0 +1,149 @@ +/* Test arithmetics on bitfields. */ + +extern void abort (void); +extern void exit (int); + +unsigned int +myrnd (void) +{ + static unsigned int s = 1388815473; + s *= 1103515245; + s += 12345; + return (s / 65536) % 2048; +} + +#define __builtin_classify_type(x) (0) + +#define T(S) \ +struct S s##S; \ +struct S retme##S (struct S x) \ +{ \ + return x; \ +} \ + \ +unsigned int fn1##S (unsigned int x) \ +{ \ + struct S y = s##S; \ + y.k += x; \ + y = retme##S (y); \ + return y.k; \ +} \ + \ +unsigned int fn2##S (unsigned int x) \ +{ \ + struct S y = s##S; \ + y.k += x; \ + y.k %= 15; \ + return y.k; \ +} \ + \ +unsigned int retit##S (void) \ +{ \ + return s##S.k; \ +} \ + \ +unsigned int fn3##S (unsigned int x) \ +{ \ + s##S.k += x; \ + return retit##S (); \ +} \ + \ +void test##S (void) \ +{ \ + int i; \ + unsigned int mask, v, a, r; \ + struct S x; \ + char *p = (char *) &s##S; \ + for (i = 0; i < sizeof (s##S); ++i) \ + *p++ = myrnd (); \ + if (__builtin_classify_type (s##S.l) == 8) \ + s##S.l = (int)5.25; \ + s##S.k = -1; \ + mask = s##S.k; \ + v = myrnd (); \ + a = myrnd (); \ + s##S.k = v; \ + x = s##S; \ + r = fn1##S (a); \ + if (x.i != s##S.i || x.j != s##S.j \ + || x.k != s##S.k || x.l != s##S.l \ + || ((v + a) & mask) != r) \ + abort (); \ + v = myrnd (); \ + a = myrnd (); \ + s##S.k = v; \ + x = s##S; \ + r = fn2##S (a); \ + if (x.i != s##S.i || x.j != s##S.j \ + || x.k != s##S.k || x.l != s##S.l \ + || ((((v + a) & mask) % 15) & mask) != r) \ + abort (); \ + v = myrnd (); \ + a = myrnd (); \ + s##S.k = v; \ + x = s##S; \ + r = fn3##S (a); \ + if (x.i != s##S.i || x.j != s##S.j \ + || s##S.k != r || x.l != s##S.l \ + || ((v + a) & mask) != r) \ + abort (); \ +} + +struct A { unsigned int i : 6, l : 1, j : 10, k : 15; }; T(A) +struct B { unsigned int i : 6, j : 11, k : 15; unsigned int l; }; T(B) +struct C { unsigned int l; unsigned int i : 6, j : 11, k : 15; }; T(C) +//struct D { unsigned long long l : 6, i : 6, j : 23, k : 29; }; T(D) +//struct E { unsigned long long l, i : 12, j : 23, k : 29; }; T(E) +//struct F { unsigned long long i : 12, j : 23, k : 29, l; }; T(F) +struct G { unsigned int i : 12, j : 13, k : 7; unsigned long long l; }; T(G) +struct H { unsigned int i : 12, j : 11, k : 9; unsigned long long l; }; T(H) +struct I { unsigned short i : 1, j : 6, k : 9; unsigned long long l; }; T(I) +struct J { unsigned short i : 1, j : 8, k : 7; unsigned short l; }; T(J) +struct K { unsigned int k : 6, l : 1, j : 10, i : 15; }; T(K) +struct L { unsigned int k : 6, j : 11, i : 15; unsigned int l; }; T(L) +struct M { unsigned int l; unsigned int k : 6, j : 11, i : 15; }; T(M) +//struct N { unsigned long long l : 6, k : 6, j : 23, i : 29; }; T(N) +//struct O { unsigned long long l, k : 12, j : 23, i : 29; }; T(O) +//struct P { unsigned long long k : 12, j : 23, i : 29, l; }; T(P) +struct Q { unsigned int k : 12, j : 13, i : 7; unsigned long long l; }; T(Q) +struct R { unsigned int k : 12, j : 11, i : 9; unsigned long long l; }; T(R) +struct S { unsigned short k : 1, j : 6, i : 9; unsigned long long l; }; T(S) +struct T { unsigned short k : 1, j : 8, i : 7; unsigned short l; }; T(T) +struct U { unsigned short j : 6, k : 1, i : 9; unsigned long long l; }; T(U) +struct V { unsigned short j : 8, k : 1, i : 7; unsigned short l; }; T(V) +struct W { long double l; unsigned int k : 12, j : 13, i : 7; }; T(W) +struct X { unsigned int k : 12, j : 13, i : 7; long double l; }; T(X) +struct Y { unsigned int k : 12, j : 11, i : 9; long double l; }; T(Y) +struct Z { long double l; unsigned int j : 13, i : 7, k : 12; }; T(Z) + +int +main (void) +{ + testA (); + testB (); + testC (); +// testD (); +// testE (); +// testF (); + testG (); + testH (); + testI (); + testJ (); + testK (); + testL (); + testM (); +// testN (); +// testO (); +// testP (); + testQ (); + testR (); + testS (); + testT (); + testU (); + testV (); + testW (); + testX (); + testY (); + testZ (); + exit (0); +} diff --git a/test/tests/20040709-2.c b/test/tests/20040709-2.c new file mode 100644 index 0000000..5d707e6 --- /dev/null +++ b/test/tests/20040709-2.c @@ -0,0 +1,156 @@ +// preprocessor deficiency +// inserting the macro by hand makes the test work + +/* Test arithmetics on bitfields. */ + +extern void abort (void); +extern void exit (int); + +unsigned int +myrnd (void) +{ + static unsigned int s = 1388815473; + s *= 1103515245; + s += 12345; + return (s / 65536) % 2048; +} + +#define T(S) \ +struct S s##S; \ +struct S retme##S (struct S x) \ +{ \ + return x; \ +} \ + \ +unsigned int fn1##S (unsigned int x) \ +{ \ + struct S y = s##S; \ + y.k += x; \ + y = retme##S (y); \ + return y.k; \ +} \ + \ +unsigned int fn2##S (unsigned int x) \ +{ \ + struct S y = s##S; \ + y.k += x; \ + y.k %= 15; \ + return y.k; \ +} \ + \ +unsigned int retit##S (void) \ +{ \ + return s##S.k; \ +} \ + \ +unsigned int fn3##S (unsigned int x) \ +{ \ + s##S.k += x; \ + return retit##S (); \ +} \ + \ +void test##S (void) \ +{ \ + int i; \ + unsigned int mask, v, a, r; \ + struct S x; \ + char *p = (char *) &s##S; \ + for (i = 0; i < sizeof (s##S); ++i) \ + *p++ = myrnd (); \ + if (0) /* __builtin_classify_type (s##S.l) == 8) */ \ + s##S.l = (int)5.25; \ + s##S.k = -1; \ + mask = s##S.k; \ + v = myrnd (); \ + a = myrnd (); \ + s##S.k = v; \ + x = s##S; \ + r = fn1##S (a); \ + if (x.i != s##S.i || x.j != s##S.j \ + || x.k != s##S.k || x.l != s##S.l \ + || ((v + a) & mask) != r) \ + abort (); \ + v = myrnd (); \ + a = myrnd (); \ + s##S.k = v; \ + x = s##S; \ + r = fn2##S (a); \ + if (x.i != s##S.i || x.j != s##S.j \ + || x.k != s##S.k || x.l != s##S.l \ + || ((((v + a) & mask) % 15) & mask) != r) \ + abort (); \ + v = myrnd (); \ + a = myrnd (); \ + s##S.k = v; \ + x = s##S; \ + r = fn3##S (a); \ + if (x.i != s##S.i || x.j != s##S.j \ + || s##S.k != r || x.l != s##S.l \ + || ((v + a) & mask) != r) \ + abort (); \ +} + +#define pck __attribute__((packed)) + +// TCC is more picky when it comes to where attributes can be placed. +// struct A pck {...}; breaks +// struct A {...} pck; works + +struct A { unsigned short i : 1, l : 1, j : 3, k : 11; } pck; T(A) +struct B { unsigned short i : 4, j : 1, k : 11; unsigned int l; } pck; T(B) +struct C { unsigned int l; unsigned short i : 4, j : 1, k : 11; } pck; T(C) +//struct D { unsigned long long l : 6, i : 6, j : 23, k : 29; } pck; T(D) +//struct E { unsigned long long l, i : 12, j : 23, k : 29; } pck; T(E) +//struct F { unsigned long long i : 12, j : 23, k : 29, l; } pck; T(F) +struct G { unsigned short i : 1, j : 1, k : 6; unsigned long long l; } pck; T(G) +struct H { unsigned short i : 6, j : 2, k : 8; unsigned long long l; } pck; T(H) +struct I { unsigned short i : 1, j : 6, k : 1; unsigned long long l; } pck; T(I) +struct J { unsigned short i : 1, j : 8, k : 7; unsigned short l; } pck; T(J) +struct K { unsigned int k : 6, l : 1, j : 10, i : 15; } pck; T(K) +struct L { unsigned int k : 6, j : 11, i : 15; unsigned int l; } pck; T(L) +struct M { unsigned int l; unsigned short k : 6, j : 11, i : 15; } pck; T(M) +//struct N { unsigned long long l : 6, k : 6, j : 23, i : 29; } pck; T(N) +//struct O { unsigned long long l, k : 12, j : 23, i : 29; } pck; T(O) +//struct P { unsigned long long k : 12, j : 23, i : 29, l; } pck; T(P) +struct Q { unsigned short k : 12, j : 1, i : 3; unsigned long long l; } pck; T(Q) +struct R { unsigned short k : 2, j : 11, i : 3; unsigned long long l; } pck; T(R) +struct S { unsigned short k : 1, j : 6, i : 9; unsigned long long l; } pck; T(S) +struct T { unsigned short k : 1, j : 8, i : 7; unsigned short l; } pck; T(T) +struct U { unsigned short j : 6, k : 1, i : 9; unsigned long long l; } pck; T(U) +struct V { unsigned short j : 8, k : 1, i : 7; unsigned short l; } pck; T(V) +struct W { long double l; unsigned int k : 12, j : 13, i : 7; } pck; T(W) +struct X { unsigned int k : 12, j : 13, i : 7; long double l; } pck; T(X) +struct Y { unsigned int k : 12, j : 11, i : 9; long double l; } pck; T(Y) +struct Z { long double l; unsigned int j : 13, i : 7, k : 12; } pck; T(Z) + +int +main (void) +{ + testA (); + testB (); + testC (); +// testD (); +// testE (); +// testF (); + testG (); + testH (); + testI (); + testJ (); + testK (); + testL (); + testM (); +// testN (); +// testO (); +// testP (); + testQ (); + testR (); + testS (); + testT (); + testU (); + testV (); + testW (); + testX (); + testY (); + testZ (); + exit (0); +} diff --git a/test/tests/20040805-1.c b/test/tests/20040805-1.c new file mode 100644 index 0000000..f09fc49 --- /dev/null +++ b/test/tests/20040805-1.c @@ -0,0 +1,31 @@ +#if __INT_MAX__ < 32768 || (defined(STACK_SIZE) && STACK_SIZE < 0x12000) +int main () { exit (0); } +#else +int a[2] = { 2, 3 }; + +static int __attribute__((noinline)) +bar (int x, void *b) +{ + a[0]++; + return x; +} + +static int __attribute__((noinline)) +foo (int x) +{ + char buf[0x10000]; + int y = a[0]; + a[1] = y; + x = bar (x, buf); + y = bar (y, buf); + return x + y; +} + +int +main () +{ + if (foo (100) != 102) + abort (); + exit (0); +} +#endif diff --git a/test/tests/20040820-1.c b/test/tests/20040820-1.c new file mode 100644 index 0000000..366607c --- /dev/null +++ b/test/tests/20040820-1.c @@ -0,0 +1,24 @@ +/* PR rtl-optimization/17099 */ + +extern void exit (int); +extern void abort (void); + +void +check (int a) +{ + if (a != 1) + abort (); +} + +void +test (int a, int b) +{ + check ((a ? 1 : 0) | (b ? 2 : 0)); +} + +int +main (void) +{ + test (1, 0); + exit (0); +} diff --git a/test/tests/20040823-1.c b/test/tests/20040823-1.c new file mode 100644 index 0000000..83bf402 --- /dev/null +++ b/test/tests/20040823-1.c @@ -0,0 +1,29 @@ +/* Ensure that we create VUSE operands also for noreturn functions. */ + +#include +#include + +int *pwarn; + +void bla (void) __attribute__ ((noreturn)); + +void bla (void) +{ + if (!*pwarn) + abort (); + + exit (0); +} + +int main (void) +{ + int warn; + + memset (&warn, 0, sizeof (warn)); + + pwarn = &warn; + + warn = 1; + + bla (); +} diff --git a/test/tests/20040831-1.c b/test/tests/20040831-1.c new file mode 100644 index 0000000..39773b3 --- /dev/null +++ b/test/tests/20040831-1.c @@ -0,0 +1,14 @@ +/* This testcase was being miscompiled, because operand_equal_p + returned that (unsigned long) d and (long) d are equal. */ +extern void abort (void); +extern void exit (int); + +int +main (void) +{ + double d = -12.0; + long l = (d > 10000) ? (unsigned long) d : (long) d; + if (l != -12) + abort (); + exit (0); +} diff --git a/test/tests/20040917-1.c b/test/tests/20040917-1.c new file mode 100644 index 0000000..73bc6c6 --- /dev/null +++ b/test/tests/20040917-1.c @@ -0,0 +1,32 @@ +/* submitted by kenneth zadeck */ + +static int test_var; + +/* the idea here is that not only is inlinable, inlinable but since it + is static, the cgraph node will not be marked as output. The + current version of the code ignores these cgraph nodes. */ + +void not_inlinable() __attribute__((noinline)); + +static void +inlinable () +{ + test_var = -10; +} + +void +not_inlinable () +{ + inlinable(); +} + +main () +{ + test_var = 10; + /* Variable test_var should be considered call-clobbered by the call + to not_inlinable(). */ + not_inlinable (); + if (test_var == 10) + abort (); + return 0; +} diff --git a/test/tests/20041011-1.c b/test/tests/20041011-1.c new file mode 100644 index 0000000..4524de9 --- /dev/null +++ b/test/tests/20041011-1.c @@ -0,0 +1,60 @@ +typedef unsigned long long ull; +volatile int gvol[32]; +ull gull; + +#define MULTI(X) \ + X( 1), X( 2), X( 3), X( 4), X( 5), X( 6), X( 7), X( 8), X( 9), X(10), \ + X(11), X(12), X(13), X(14), X(15), X(16), X(17), X(18), X(19), X(20), \ + X(21), X(22), X(23), X(24), X(25), X(26), X(27), X(28), X(29), X(30) + +#define DECLARE(INDEX) x##INDEX +#define COPYIN(INDEX) x##INDEX = gvol[INDEX] +#define COPYOUT(INDEX) gvol[INDEX] = x##INDEX + +#define BUILD_TEST(NAME, N) \ + ull __attribute__((noinline)) \ + NAME (int n, ull x) \ + { \ + while (n--) \ + { \ + int MULTI (DECLARE); \ + MULTI (COPYIN); \ + MULTI (COPYOUT); \ + x += N; \ + } \ + return x; \ + } + +#define RUN_TEST(NAME, N) \ + if (NAME (3, ~0ULL) != N * 3 - 1) \ + abort (); \ + if (NAME (3, 0xffffffffULL) \ + != N * 3 + 0xffffffffULL) \ + abort (); + +#define DO_TESTS(DO_TEST) \ + DO_TEST (t1, -2048) \ + DO_TEST (t2, -513) \ + DO_TEST (t3, -512) \ + DO_TEST (t4, -511) \ + DO_TEST (t5, -1) \ + DO_TEST (t6, 1) \ + DO_TEST (t7, 511) \ + DO_TEST (t8, 512) \ + DO_TEST (t9, 513) \ + DO_TEST (t10, gull) \ + DO_TEST (t11, -gull) + +DO_TESTS (BUILD_TEST) + +ull neg (ull x) { return -x; } + +int +main () +{ + gull = 100; + DO_TESTS (RUN_TEST) + if (neg (gull) != -100ULL) + abort (); + exit (0); +} diff --git a/test/tests/20041019-1.c b/test/tests/20041019-1.c new file mode 100644 index 0000000..3c56b31 --- /dev/null +++ b/test/tests/20041019-1.c @@ -0,0 +1,52 @@ +test_store_ccp (int i) +{ + int *p, a, b, c; + + if (i < 5) + p = &a; + else if (i > 8) + p = &b; + else + p = &c; + + *p = 10; + b = 3; + + /* STORE-CCP was wrongfully propagating 10 into *p. */ + return *p + 2; +} + + +test_store_copy_prop (int i) +{ + int *p, a, b, c; + + if (i < 5) + p = &a; + else if (i > 8) + p = &b; + else + p = &c; + + *p = i; + b = i + 1; + + /* STORE-COPY-PROP was wrongfully propagating i into *p. */ + return *p; +} + + +main() +{ + int x; + + x = test_store_ccp (10); + if (x == 12) + abort (); + + x = test_store_copy_prop (9); + if (x == 9) + abort (); + + return 0; +} diff --git a/test/tests/20041112-1.c b/test/tests/20041112-1.c new file mode 100644 index 0000000..0c6251c --- /dev/null +++ b/test/tests/20041112-1.c @@ -0,0 +1,40 @@ +/* This was failing on Alpha because the comparison (p != -1) was rewritten + as (p+1 != 0) and p+1 isn't allowed to wrap for pointers. */ + +extern void abort(void); + +typedef __SIZE_TYPE__ size_t; + +int global; + +static void *foo(int p) +{ + if (p == 0) + { + global++; + return &global; + } + + return (void *)(size_t)-1; +} + +int bar(void) +{ + void *p; + + p = foo(global); + if (p != (void *)(size_t)-1) + return 1; + + global++; + return 0; +} + +int main(void) +{ + global = 1; + if (bar () != 0) + abort(); + + return 0; +} diff --git a/test/tests/20041113-1.c b/test/tests/20041113-1.c new file mode 100644 index 0000000..8c07950 --- /dev/null +++ b/test/tests/20041113-1.c @@ -0,0 +1,24 @@ +#include + +void test (int x, ...) +{ + va_list ap; + int i; + va_start (ap, x); + if (va_arg (ap, int) != 1) + abort (); + if (va_arg (ap, int) != 2) + abort (); + if (va_arg (ap, int) != 3) + abort (); + if (va_arg (ap, int) != 4) + abort (); +} + +double a = 40.0; + +int main(int argc, char *argv[]) +{ + test(0, 1, 2, 3, (int)(a / 10.0)); + exit (0); +} diff --git a/test/tests/20041114-1.c b/test/tests/20041114-1.c new file mode 100644 index 0000000..4f82f8a --- /dev/null +++ b/test/tests/20041114-1.c @@ -0,0 +1,35 @@ +/* Verify that + + var <= 0 || ((long unsigned) (unsigned) (var - 1) < MAX_UNSIGNED_INT) + + gets folded to 1. */ + +#include + +void abort (void); +void link_failure (void); + +volatile int v; + +void +foo (int var) +{ + if (!(var <= 0 + || ((long unsigned) (unsigned) (var - 1) < UINT_MAX))) + link_failure (); +} + +int +main (int argc, char **argv) +{ + foo (v); + return 0; +} + +#ifndef __OPTIMIZE__ +void +link_failure (void) +{ + abort (); +} +#endif diff --git a/test/tests/20041126-1.c b/test/tests/20041126-1.c new file mode 100644 index 0000000..58855ae --- /dev/null +++ b/test/tests/20041126-1.c @@ -0,0 +1,26 @@ +extern int abs (int); +extern void abort (void); + +void +check (int *p) +{ + int i; + for (i = 0; i < 5; ++i) + if (p[i]) + abort (); + for (; i < 10; ++i) + if (p[i] != i + 1) + abort (); +} + +int +main (void) +{ + int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; + int i; + + for (i = -5; i < 0; i++) + a[abs (i - 10) - 11] = 0; + check (a); + return 0; +} diff --git a/test/tests/20041210-1.c b/test/tests/20041210-1.c new file mode 100644 index 0000000..ef266a0 --- /dev/null +++ b/test/tests/20041210-1.c @@ -0,0 +1,14 @@ +/* The FR-V port used to fail this test because the andcc patterns + wrongly claimed to set the C and V flags. */ +#include + +int x[4] = { INT_MIN / 2, INT_MAX, 2, 4 }; + +int +main () +{ + if (x[0] < x[1]) + if ((x[2] & x[3]) < 0) + abort (); + exit (0); +} diff --git a/test/tests/20041212-1.c b/test/tests/20041212-1.c new file mode 100644 index 0000000..ea2d0fb --- /dev/null +++ b/test/tests/20041212-1.c @@ -0,0 +1,15 @@ +/* A function pointer compared with a void pointer should not be canonicalized. + See PR middle-end/17564. */ +void *f (void) __attribute__ ((__noinline__)); +void * +f (void) +{ + return f; +} +int +main (void) +{ + if (f () != f) + abort (); + exit (0); +} diff --git a/test/tests/20041213-2.c b/test/tests/20041213-2.c new file mode 100644 index 0000000..212d638 --- /dev/null +++ b/test/tests/20041213-2.c @@ -0,0 +1,32 @@ +/* PR tree-optimization/18694 + + The dominator optimization didn't take the PHI evaluation order + into account when threading an edge. */ + +extern void abort (void) __attribute__((noreturn)); +extern void exit (int) __attribute__((noreturn)); + +void __attribute__((noinline)) +foo (int i) +{ + int next_n = 1; + int j = 0; + + for (; i != 0; i--) + { + int n; + + for (n = next_n; j < n; j++) + next_n++; + + if (j != n) + abort (); + } +} + +int +main (void) +{ + foo (2); + exit (0); +} diff --git a/test/tests/20041214-1.c b/test/tests/20041214-1.c new file mode 100644 index 0000000..5600246 --- /dev/null +++ b/test/tests/20041214-1.c @@ -0,0 +1,69 @@ +typedef long unsigned int size_t; +extern void abort (void); +extern char *strcpy (char *, const char *); +extern int strcmp (const char *, const char *); +//typedef __builtin_va_list va_list; +#include +static const char null[] = "(null)"; +int g (char *s, const char *format, va_list ap) +{ + const char *f; + const char *string; + char spec; + static const void *step0_jumps[] = { + &&do_precision, + &&do_form_integer, + &&do_form_string, + }; + f = format; + if (*f == '\0') + goto all_done; + do + { + spec = (*++f); + goto *(step0_jumps[2]); + + /* begin switch table. */ + do_precision: + ++f; + __builtin_va_arg (ap, int); + spec = *f; + goto *(step0_jumps[2]); + + do_form_integer: + __builtin_va_arg (ap, unsigned long int); + goto end; + + do_form_string: + string = __builtin_va_arg (ap, const char *); + strcpy (s, string); + + /* End of switch table. */ + end: + ++f; + } + while (*f != '\0'); + +all_done: + return 0; +} + +void +f (char *s, const char *f, ...) +{ + va_list ap; + __builtin_va_start (ap, f); + g (s, f, ap); + __builtin_va_end (ap); +} + +int +main (void) +{ + char buf[10]; + f (buf, "%s", "asdf", 0); + if (strcmp (buf, "asdf")) + abort (); + return 0; +} + diff --git a/test/tests/20041218-1.c b/test/tests/20041218-1.c new file mode 100644 index 0000000..4d113e4 --- /dev/null +++ b/test/tests/20041218-1.c @@ -0,0 +1,117 @@ +/* PR rtl-optimization/16968 */ +/* Testcase by Jakub Jelinek */ + +struct T +{ + unsigned int b, c, *d; + unsigned char e; +}; +struct S +{ + unsigned int a; + struct T f; +}; +struct U +{ + struct S g, h; +}; +struct V +{ + unsigned int i; + struct U j; +}; + +extern void exit (int); +extern void abort (void); + +void * +dummy1 (void *x) +{ + return ""; +} + +void * +dummy2 (void *x, void *y) +{ + exit (0); +} + +struct V * +baz (unsigned int x) +{ + static struct V v; + __builtin_memset (&v, 0x55, sizeof (v)); + return &v; +} + +int +check (void *x, struct S *y) +{ + if (y->a || y->f.b || y->f.c || y->f.d || y->f.e) + abort (); + return 1; +} + +static struct V * +bar (unsigned int x, void *y) +{ + const struct T t = { 0, 0, (void *) 0, 0 }; + struct V *u; + void *v; + v = dummy1 (y); + if (!v) + return (void *) 0; + + u = baz (sizeof (struct V)); + u->i = x; + u->j.g.a = 0; + u->j.g.f = t; + u->j.h.a = 0; + u->j.h.f = t; + + if (!check (v, &u->j.g) || !check (v, &u->j.h)) + return (void *) 0; + return u; +} + +int +foo (unsigned int *x, unsigned int y, void **z) +{ + void *v; + unsigned int i, j; + + *z = v = (void *) 0; + + for (i = 0; i < y; i++) + { + struct V *c; + + j = *x; + + switch (j) + { + case 1: + c = bar (j, x); + break; + default: + c = 0; + break; + } + if (c) + v = dummy2 (v, c); + else + return 1; + } + + *z = v; + return 0; +} + +int +main (void) +{ + unsigned int one = 1; + void *p; + foo (&one, 1, &p); + abort (); +} diff --git a/test/tests/20050104-1.c b/test/tests/20050104-1.c new file mode 100644 index 0000000..6083e9c --- /dev/null +++ b/test/tests/20050104-1.c @@ -0,0 +1,23 @@ +/* PR tree-optimization/19060 */ + +void abort (void); + +static +long long min () +{ + return -__LONG_LONG_MAX__ - 1; +} + +void +foo (long long j) +{ + if (j > 10 || j < min ()) + abort (); +} + +int +main (void) +{ + foo (10); + return 0; +} diff --git a/test/tests/20050106-1.c b/test/tests/20050106-1.c new file mode 100644 index 0000000..e49732d --- /dev/null +++ b/test/tests/20050106-1.c @@ -0,0 +1,19 @@ +/* PR tree-optimization/19283 */ + +void abort (void); + +static inline unsigned short +foo (unsigned int *p) +{ + return *p; +}; + +unsigned int u; + +int +main () +{ + if ((foo (&u) & 0x8000) != 0) + abort (); + return 0; +} diff --git a/test/tests/20050107-1.c b/test/tests/20050107-1.c new file mode 100644 index 0000000..903c54a --- /dev/null +++ b/test/tests/20050107-1.c @@ -0,0 +1,25 @@ +typedef enum { C = 1, D = 2 } B; +extern void abort (void); + +struct S +{ + B __attribute__ ((mode (byte))) a; + B __attribute__ ((mode (byte))) b; +}; + +void +foo (struct S *x) +{ + if (x->a != C || x->b != D) + abort (); +} + +int +main (void) +{ + struct S s; + s.a = C; + s.b = D; + foo (&s); + return 0; +} diff --git a/test/tests/20050111-1.c b/test/tests/20050111-1.c new file mode 100644 index 0000000..d6089f1 --- /dev/null +++ b/test/tests/20050111-1.c @@ -0,0 +1,39 @@ +/* PR middle-end/19084, rtl-optimization/19348 */ + +unsigned int +foo (unsigned long long x) +{ + unsigned int u; + + if (x == 0) + return 0; + u = (unsigned int) (x >> 32); + return u; +} + +unsigned long long +bar (unsigned short x) +{ + return (unsigned long long) x << 32; +} + +extern void abort (void); + +int +main (void) +{ + if (sizeof (long long) != 8) + return 0; + + if (foo (0) != 0) + abort (); + if (foo (0xffffffffULL) != 0) + abort (); + if (foo (0x25ff00ff00ULL) != 0x25) + abort (); + if (bar (0) != 0) + abort (); + if (bar (0x25) != 0x2500000000ULL) + abort (); + return 0; +} diff --git a/test/tests/20050119-1.c b/test/tests/20050119-1.c new file mode 100644 index 0000000..55f33a0 --- /dev/null +++ b/test/tests/20050119-1.c @@ -0,0 +1,37 @@ +/* PR c/19342 */ +typedef enum { A, B, C, D } E; + +struct S { + E __attribute__ ((mode (__byte__))) a; + E __attribute__ ((mode (__byte__))) b; + E __attribute__ ((mode (__byte__))) c; + E __attribute__ ((mode (__byte__))) d; +}; + +extern void abort (void); +extern void exit (int); + +void +foo (struct S *s) +{ + if (s->a != s->b) + abort (); + if (s->c != C) + abort (); +} + +int +main (void) +{ + struct S s[2]; + s[0].a = B; + s[0].b = B; + s[0].c = C; + s[0].d = D; + s[1].a = D; + s[1].b = C; + s[1].c = B; + s[1].d = A; + foo (s); + exit (0); +} diff --git a/test/tests/20050119-2.c b/test/tests/20050119-2.c new file mode 100644 index 0000000..568109c --- /dev/null +++ b/test/tests/20050119-2.c @@ -0,0 +1,40 @@ +/* PR middle-end/19874 */ +typedef enum { A, B, C, D } E; + +struct S { + E __attribute__ ((mode (__byte__))) a; + E __attribute__ ((mode (__byte__))) b; + E __attribute__ ((mode (__byte__))) c; + E __attribute__ ((mode (__byte__))) d; +}; + +extern void abort (void); +extern void exit (int); + +E +foo (struct S *s) +{ + if (s->a != s->b) + abort (); + if (s->c != C) + abort (); + return s->d; +} + +int +main (void) +{ + struct S s[2]; + s[0].a = B; + s[0].b = B; + s[0].c = C; + s[0].d = D; + s[1].a = D; + s[1].b = C; + s[1].c = B; + s[1].d = A; + if (foo (s) != D) + abort (); + exit (0); +} + diff --git a/test/tests/20050124-1.c b/test/tests/20050124-1.c new file mode 100644 index 0000000..9d039ef --- /dev/null +++ b/test/tests/20050124-1.c @@ -0,0 +1,41 @@ +/* PR rtl-optimization/19579 */ + +extern void abort (void); + +int +foo (int i, int j) +{ + int k = i + 1; + + if (j) + { + if (k > 0) + k++; + else if (k < 0) + k--; + } + + return k; +} + +int +main (void) +{ + if (foo (-2, 0) != -1) + abort (); + if (foo (-1, 0) != 0) + abort (); + if (foo (0, 0) != 1) + abort (); + if (foo (1, 0) != 2) + abort (); + if (foo (-2, 1) != -2) + abort (); + if (foo (-1, 1) != 0) + abort (); + if (foo (0, 1) != 2) + abort (); + if (foo (1, 1) != 3) + abort (); + return 0; +} diff --git a/test/tests/20050125-1.c b/test/tests/20050125-1.c new file mode 100644 index 0000000..266c2c8 --- /dev/null +++ b/test/tests/20050125-1.c @@ -0,0 +1,35 @@ +/* Verify that the CALL sideeffect isn't optimized away. */ +/* Contributed by Greg Parker 25 Jan 2005 */ + +#include +//#include + +struct parse { + char *next; + char *end; + int error; +}; + +int seterr(struct parse *p, int err) +{ + p->error = err; + return 0; +} + +void bracket_empty(struct parse *p) +{ + if (((p->next < p->end) && (*p->next++) == ']') || seterr(p, 7)) { } +} + +int main(int argc __attribute__((unused)), char **argv __attribute__((unused))) +{ + struct parse p; + p.next = p.end = (char *)0x12345; + + p.error = 0; + bracket_empty(&p); + if (p.error != 7) + abort (); + + return 0; +} diff --git a/test/tests/20050131-1.c b/test/tests/20050131-1.c new file mode 100644 index 0000000..cf8d26c --- /dev/null +++ b/test/tests/20050131-1.c @@ -0,0 +1,18 @@ +/* Verify that we do not lose side effects on a MOD expression. */ + +#include +//#include + +int +foo (int a) +{ + int x = 0 % a++; + return a; +} + +main() +{ + if (foo (9) != 10) + abort (); + exit (0); +} diff --git a/test/tests/20050203-1.c b/test/tests/20050203-1.c new file mode 100644 index 0000000..4be2e09 --- /dev/null +++ b/test/tests/20050203-1.c @@ -0,0 +1,29 @@ +/* Reduced testcase extracted from Samba source code. */ + +#include + +static void __attribute__((__noinline__)) + foo (unsigned char *p) { + *p = 0x81; +} + +static void __attribute__((__noinline__)) + bar (int x) { +// asm (""); +} + +int main() { + unsigned char b; + + foo(&b); + if (b & 0x80) + { + bar (b & 0x7f); + exit (0); + } + else + { + bar (b & 1); + abort (); + } +} diff --git a/test/tests/20050215-1.c b/test/tests/20050215-1.c new file mode 100644 index 0000000..f4920ce --- /dev/null +++ b/test/tests/20050215-1.c @@ -0,0 +1,25 @@ +/* PR middle-end/19857 */ + +typedef struct { char c[8]; } V +#ifdef __ELF__ + __attribute__ ((aligned (8))) +#endif + ; +typedef __SIZE_TYPE__ size_t; +V v; +void abort (void); + +int +main (void) +{ + V *w = &v; + if (((size_t) ((float *) ((size_t) w & ~(size_t) 3)) % 8) != 0 + || ((size_t) w & 1)) + { +#ifndef __ELF__ + if (((size_t) &v & 7) == 0) +#endif + abort (); + } + return 0; +} diff --git a/test/tests/20050218-1.c b/test/tests/20050218-1.c new file mode 100644 index 0000000..104174f --- /dev/null +++ b/test/tests/20050218-1.c @@ -0,0 +1,30 @@ +/* PR tree-optimization/19828 */ +typedef __SIZE_TYPE__ size_t; +extern size_t strlen (const char *s); +extern int strncmp (const char *s1, const char *s2, size_t n); +extern void abort (void); + +const char *a[16] = { "a", "bc", "de", "fgh" }; + +int +foo (char *x, const char *y, size_t n) +{ + size_t i, j = 0; + for (i = 0; i < n; i++) + { + if (strncmp (x + j, a[i], strlen (a[i])) != 0) + return 2; + j += strlen (a[i]); + if (y) + j += strlen (y); + } + return 0; +} + +int +main (void) +{ + if (foo ("abcde", (const char *) 0, 3) != 0) + abort (); + return 0; +} diff --git a/test/tests/20050224-1.c b/test/tests/20050224-1.c new file mode 100644 index 0000000..6812003 --- /dev/null +++ b/test/tests/20050224-1.c @@ -0,0 +1,33 @@ +/* Origin: Mikael Pettersson and the Linux kernel. */ + +extern void abort (void); +unsigned long a = 0xc0000000, b = 0xd0000000; +unsigned long c = 0xc01bb958, d = 0xc0264000; +unsigned long e = 0xc0288000, f = 0xc02d4378; + +void +foo (int x, int y, int z) +{ + if (x != 245 || y != 36 || z != 444) + abort (); +} + +int +main (void) +{ + unsigned long g; + int h = 0, i = 0, j = 0; + + if (sizeof (unsigned long) < 4) + return 0; + + for (g = a; g < b; g += 0x1000) + if (g < c) + h++; + else if (g >= d && g < e) + j++; + else if (g < f) + i++; + foo (i, j, h); + return 0; +} diff --git a/test/tests/20050410-1.c b/test/tests/20050410-1.c new file mode 100644 index 0000000..c4cd852 --- /dev/null +++ b/test/tests/20050410-1.c @@ -0,0 +1,13 @@ +int s = 200; +int __attribute__((noinline)) +foo (void) +{ + return (signed char) (s - 100) - 5; +} +int +main (void) +{ + if (foo () != 95) + abort (); + exit (0); +} diff --git a/test/tests/20050502-1.c b/test/tests/20050502-1.c new file mode 100644 index 0000000..331fe5f --- /dev/null +++ b/test/tests/20050502-1.c @@ -0,0 +1,67 @@ +/* PR rtl-optimization/21330 */ + +extern void abort (void); +extern int strcmp (const char *, const char *); + +int +__attribute__((noinline)) +bar (const char **x) +{ + return *(*x)++; +} + +int +__attribute__((noinline)) +baz (int c) +{ + return c != '@'; +} + +void +__attribute__((noinline)) +foo (const char **w, char *x, _Bool y, _Bool z) +{ + char c = bar (w); + int i = 0; + + while (1) + { + x[i++] = c; + c = bar (w); + if (y && c == '\'') + break; + if (z && c == '\"') + break; + if (!y && !z && !baz (c)) + break; + } + x[i] = 0; +} + +int +main (void) +{ + char buf[64]; + const char *p; + p = "abcde'fgh"; + foo (&p, buf, 1, 0); + if (strcmp (p, "fgh") != 0 || strcmp (buf, "abcde") != 0) + abort (); + p = "ABCDEFG\"HI"; + foo (&p, buf, 0, 1); + if (strcmp (p, "HI") != 0 || strcmp (buf, "ABCDEFG") != 0) + abort (); + p = "abcd\"e'fgh"; + foo (&p, buf, 1, 1); + if (strcmp (p, "e'fgh") != 0 || strcmp (buf, "abcd") != 0) + abort (); + p = "ABCDEF'G\"HI"; + foo (&p, buf, 1, 1); + if (strcmp (p, "G\"HI") != 0 || strcmp (buf, "ABCDEF") != 0) + abort (); + p = "abcdef@gh"; + foo (&p, buf, 0, 0); + if (strcmp (p, "gh") != 0 || strcmp (buf, "abcdef") != 0) + abort (); + return 0; +} diff --git a/test/tests/20050502-2.c b/test/tests/20050502-2.c new file mode 100644 index 0000000..eedcb6a --- /dev/null +++ b/test/tests/20050502-2.c @@ -0,0 +1,34 @@ +/* PR target/21297 */ +typedef __SIZE_TYPE__ size_t; +extern int memcmp (const char *, const char *, size_t); +extern void abort (); + +void +foo (char *x) +{ + int i; + for (i = 0; i < 2; i++); + x[i + i] = '\0'; +} + +void +bar (char *x) +{ + int i; + for (i = 0; i < 2; i++); + x[i + i + i + i] = '\0'; +} + +int +main (void) +{ + char x[] = "IJKLMNOPQR"; + foo (x); + if (memcmp (x, "IJKL\0NOPQR", sizeof x) != 0) + abort (); + x[4] = 'M'; + bar (x); + if (memcmp (x, "IJKLMNOP\0R", sizeof x) != 0) + abort (); + return 0; +} diff --git a/test/tests/20050613-1.c b/test/tests/20050613-1.c new file mode 100644 index 0000000..7c326d3 --- /dev/null +++ b/test/tests/20050613-1.c @@ -0,0 +1,27 @@ +/* PR tree-optimization/22043 */ + +extern void abort (void); + +struct A { int i; int j; int k; int l; }; +struct B { struct A a; int r[1]; }; +struct C { struct A a; int r[0]; }; +//struct D { struct A a; int r[]; }; + +void +foo (struct A *x) +{ + if (x->i != 0 || x->j != 5 || x->k != 0 || x->l != 0) + abort (); +} + +int +main () +{ + struct B b = { .a.j = 5 }; + struct C c = { .a.j = 5 }; + //struct D d = { .a.j = 5 }; + foo (&b.a); + foo (&c.a); + //foo (&d.a); + return 0; +} diff --git a/test/tests/20050713-1.c b/test/tests/20050713-1.c new file mode 100644 index 0000000..4d669cb --- /dev/null +++ b/test/tests/20050713-1.c @@ -0,0 +1,56 @@ +/* Test that sibling call is not used if there is an argument overlap. */ + +extern void abort (void); + +struct S +{ + int a, b, c; +}; + +int +foo2 (struct S x, struct S y) +{ + if (x.a != 3 || x.b != 4 || x.c != 5) + abort (); + if (y.a != 6 || y.b != 7 || y.c != 8) + abort (); + return 0; +} + +int +foo3 (struct S x, struct S y, struct S z) +{ + foo2 (x, y); + if (z.a != 9 || z.b != 10 || z.c != 11) + abort (); + return 0; +} + +int +bar2 (struct S x, struct S y) +{ + return foo2 (y, x); +} + +int +bar3 (struct S x, struct S y, struct S z) +{ + return foo3 (y, x, z); +} + +int +baz3 (struct S x, struct S y, struct S z) +{ + return foo3 (y, z, x); +} + +int +main (void) +{ + struct S a = { 3, 4, 5 }, b = { 6, 7, 8 }, c = { 9, 10, 11 }; + + bar2 (b, a); + bar3 (b, a, c); + baz3 (c, a, b); + return 0; +} diff --git a/test/tests/20050826-1.c b/test/tests/20050826-1.c new file mode 100644 index 0000000..bc7f940 --- /dev/null +++ b/test/tests/20050826-1.c @@ -0,0 +1,44 @@ +/* PR rtl-optimization/23561 */ + +struct A +{ + char a1[1]; + char a2[5]; + char a3[1]; + char a4[2048 - 7]; +} a; + +typedef __SIZE_TYPE__ size_t; +extern void *memset (void *, int, size_t); +extern void *memcpy (void *, const void *, size_t); +extern int memcmp (const void *, const void *, size_t); +extern void abort (void); + +void +bar (struct A *x) +{ + size_t i; + if (memcmp (x, "\1HELLO\1", sizeof "\1HELLO\1")) + abort (); + for (i = 0; i < sizeof (x->a4); i++) + if (x->a4[i]) + abort (); +} + +int +foo (void) +{ + memset (&a, 0, sizeof (a)); + a.a1[0] = 1; + memcpy (a.a2, "HELLO", sizeof "HELLO"); + a.a3[0] = 1; + bar (&a); + return 0; +} + +int +main (void) +{ + foo (); + return 0; +} diff --git a/test/tests/20050826-2.c b/test/tests/20050826-2.c new file mode 100644 index 0000000..0398049 --- /dev/null +++ b/test/tests/20050826-2.c @@ -0,0 +1,62 @@ +/* PR rtl-optimization/23560 */ + +struct rtattr +{ + unsigned short rta_len; + unsigned short rta_type; +}; + +__attribute__ ((noinline)) +int inet_check_attr (void *r, struct rtattr **rta) +{ + int i; + + for (i = 1; i <= 14; i++) + { + struct rtattr *attr = rta[i - 1]; + if (attr) + { + if (attr->rta_len - sizeof (struct rtattr) < 4) + return -22; + if (i != 9 && i != 8) + rta[i - 1] = attr + 1; + } + } + return 0; +} + +extern void abort (void); + +int +main (void) +{ + struct rtattr rt[2]; + struct rtattr *rta[14]; + int i; + + rt[0].rta_len = sizeof (struct rtattr) + 8; + rt[0].rta_type = 0; + rt[1] = rt[0]; + for (i = 0; i < 14; i++) + rta[i] = &rt[0]; + if (inet_check_attr (0, rta) != 0) + abort (); + for (i = 0; i < 14; i++) + if (rta[i] != &rt[i != 7 && i != 8]) + abort (); + for (i = 0; i < 14; i++) + rta[i] = &rt[0]; + rta[1] = 0; + rt[1].rta_len -= 8; + rta[5] = &rt[1]; + if (inet_check_attr (0, rta) != -22) + abort (); + for (i = 0; i < 14; i++) + if (i == 1 && rta[i] != 0) + abort (); + else if (i != 1 && i <= 5 && rta[i] != &rt[1]) + abort (); + else if (i > 5 && rta[i] != &rt[0]) + abort (); + return 0; +} diff --git a/test/tests/20051012-1.c b/test/tests/20051012-1.c new file mode 100644 index 0000000..f12f429 --- /dev/null +++ b/test/tests/20051012-1.c @@ -0,0 +1,24 @@ +extern void abort (void); + +struct type +{ + int *a; + + int b:16; + unsigned int p:9; +} t; + +unsigned int +foo () +{ + return t.p; +} + +int +main (void) +{ + t.p = 8; + if (foo (t) != 8) + abort (); + return 0; +} diff --git a/test/tests/20051021-1.c b/test/tests/20051021-1.c new file mode 100644 index 0000000..0cd2c89 --- /dev/null +++ b/test/tests/20051021-1.c @@ -0,0 +1,28 @@ +/* Verify that TRUTH_AND_EXPR is not wrongly changed to TRUTH_ANDIF_EXPR. */ + +extern void abort (void); + +int count = 0; + +int foo1(void) +{ + count++; + return 0; +} + +int foo2(void) +{ + count++; + return 0; +} + +int main(void) +{ + if ((foo1() == 1) & (foo2() == 1)) + abort (); + + if (count != 2) + abort (); + + return 0; +} diff --git a/test/tests/20051104-1.c b/test/tests/20051104-1.c new file mode 100644 index 0000000..1657877 --- /dev/null +++ b/test/tests/20051104-1.c @@ -0,0 +1,17 @@ +/* PR rtl-optimization/23567 */ + +struct +{ + int len; + char *name; +} s; + +int +main (void) +{ + s.len = 0; + s.name = ""; + if (s.name [s.len] != 0) + s.name [s.len] = 0; + return 0; +} diff --git a/test/tests/20051110-1.c b/test/tests/20051110-1.c new file mode 100644 index 0000000..9fa3df8 --- /dev/null +++ b/test/tests/20051110-1.c @@ -0,0 +1,31 @@ +void add_unwind_adjustsp (long); +void abort (void); + +unsigned char bytes[5]; + +void +add_unwind_adjustsp (long offset) +{ + int n; + unsigned long o; + + o = (long) ((offset - 0x204) >> 2); + + n = 0; + while (o) + { + bytes[n] = o & 0x7f; + o >>= 7; + if (o) + bytes[n] |= 0x80; + n++; + } +} + +int main(void) +{ + add_unwind_adjustsp (4132); + if (bytes[0] != 0x88 || bytes[1] != 0x07) + abort (); + return 0; +} diff --git a/test/tests/20051110-2.c b/test/tests/20051110-2.c new file mode 100644 index 0000000..57bfeeb --- /dev/null +++ b/test/tests/20051110-2.c @@ -0,0 +1,39 @@ +void add_unwind_adjustsp (long); +void abort (void); + +unsigned char bytes[5]; + +int flag; + +void +add_unwind_adjustsp (long offset) +{ + int n; + unsigned long o; + + o = (long) ((offset - 0x204) >> 2); + + n = 0; + do + { +a: + bytes[n] = o & 0x7f; + o >>= 7; + if (o) + { + bytes[n] |= 0x80; + if (flag) + goto a; + } + n++; + } + while (o); +} + +int main(void) +{ + add_unwind_adjustsp (4132); + if (bytes[0] != 0x88 || bytes[1] != 0x07) + abort (); + return 0; +} diff --git a/test/tests/20051113-1.c b/test/tests/20051113-1.c new file mode 100644 index 0000000..53b0097 --- /dev/null +++ b/test/tests/20051113-1.c @@ -0,0 +1,71 @@ +extern void *malloc(__SIZE_TYPE__); +extern void *memset(void *, int, __SIZE_TYPE__); +typedef struct +{ + short a; + unsigned short b; + unsigned short c; + unsigned long long Count; + long long Count2; +} __attribute__((packed)) Struct1; + +typedef struct +{ + short a; + unsigned short b; + unsigned short c; + unsigned long long d; + long long e; + long long f; +} __attribute__((packed)) Struct2; + +typedef union +{ + Struct1 a; + Struct2 b; +} Union; + +typedef struct +{ + int Count; + Union List[0]; +} __attribute__((packed)) Struct3; + +unsigned long long Sum (Struct3 *instrs) __attribute__((noinline)); +unsigned long long Sum (Struct3 *instrs) +{ + unsigned long long count = 0; + int i; + + for (i = 0; i < instrs->Count; i++) { + count += instrs->List[i].a.Count; + } + return count; +} +long long Sum2 (Struct3 *instrs) __attribute__((noinline)); +long long Sum2 (Struct3 *instrs) +{ + long long count = 0; + int i; + + for (i = 0; i < instrs->Count; i++) { + count += instrs->List[i].a.Count2; + } + return count; +} +main() { + Struct3 *p = malloc (sizeof (int) + 3 * sizeof(Union)); + memset(p, 0, sizeof(int) + 3*sizeof(Union)); + p->Count = 3; + p->List[0].a.Count = 555; + p->List[1].a.Count = 999; + p->List[2].a.Count = 0x10101ULL; + p->List[0].a.Count2 = 555; + p->List[1].a.Count2 = 999; + p->List[2].a.Count2 = 0x10101LL; + if (Sum(p) != 555 + 999 + 0x10101ULL) + abort(); + if (Sum2(p) != 555 + 999 + 0x10101LL) + abort(); + return 0; +} diff --git a/test/tests/20051215-1.c b/test/tests/20051215-1.c new file mode 100644 index 0000000..143a449 --- /dev/null +++ b/test/tests/20051215-1.c @@ -0,0 +1,28 @@ +/* PR rtl-optimization/24899 */ + +extern void abort (void); + +__attribute__ ((noinline)) int +foo (int x, int y, int *z) +{ + int a, b, c, d; + + a = b = 0; + for (d = 0; d < y; d++) + { + if (z) + b = d * *z; + for (c = 0; c < x; c++) + a += b; + } + + return a; +} + +int +main (void) +{ + if (foo (3, 2, 0) != 0) + abort (); + return 0; +} diff --git a/test/tests/20060102-1.c b/test/tests/20060102-1.c new file mode 100644 index 0000000..04b6a67 --- /dev/null +++ b/test/tests/20060102-1.c @@ -0,0 +1,17 @@ +extern void abort (); + +int f(int x) +{ + return (x >> (sizeof (x) * __CHAR_BIT__ - 1)) ? -1 : 1; +} + +volatile int one = 1; +int main (void) +{ + /* Test that the function above returns different values for + different signs. */ + if (f(one) == f(-one)) + abort (); + return 0; +} + diff --git a/test/tests/20060127-1.c b/test/tests/20060127-1.c new file mode 100644 index 0000000..fe73253 --- /dev/null +++ b/test/tests/20060127-1.c @@ -0,0 +1,17 @@ +void abort (); + +void +f (long long a) +{ + if ((a & 0xffffffffLL) != 0) + abort (); +} + +long long a = 0x1234567800000000LL; + +int +main () +{ + f (a); + return 0; +} diff --git a/test/tests/20060412-1.c b/test/tests/20060412-1.c new file mode 100644 index 0000000..a4cc4d4 --- /dev/null +++ b/test/tests/20060412-1.c @@ -0,0 +1,33 @@ +extern void abort (void); + +struct S +{ + long o; +}; + +struct T +{ + long o; + struct S m[82]; +}; + +struct T t; + +int +main () +{ + struct S *p, *q; + + p = (struct S *) &t; + p = &((struct T *) p)->m[0]; + q = p + 82; + while (--q > p) + q->o = -1; + q->o = 0; + + if (q > p) + abort (); + if (q - p > 0) + abort (); + return 0; +} diff --git a/test/tests/20060420-1.c b/test/tests/20060420-1.c new file mode 100644 index 0000000..fe62f6b --- /dev/null +++ b/test/tests/20060420-1.c @@ -0,0 +1,71 @@ +extern void abort (void); + +typedef float v4flt __attribute__ ((vector_size (16))); + +void __attribute__ ((noinline)) foo (float *dst, float **src, int a, int n) +{ + int i, j; + int z = sizeof (v4flt) / sizeof (float); + unsigned m = sizeof (v4flt) - 1; + + for (j = 0; j < n && (((unsigned long) dst + j) & m); ++j) + { + float t = src[0][j]; + for (i = 1; i < a; ++i) + t += src[i][j]; + dst[j] = t; + } + + for (; j < (n - (4 * z - 1)); j += 4 * z) + { + v4flt t0 = *(v4flt *) (src[0] + j + 0 * z); + v4flt t1 = *(v4flt *) (src[0] + j + 1 * z); + v4flt t2 = *(v4flt *) (src[0] + j + 2 * z); + v4flt t3 = *(v4flt *) (src[0] + j + 3 * z); + for (i = 1; i < a; ++i) + { + t0 += *(v4flt *) (src[i] + j + 0 * z); + t1 += *(v4flt *) (src[i] + j + 1 * z); + t2 += *(v4flt *) (src[i] + j + 2 * z); + t3 += *(v4flt *) (src[i] + j + 3 * z); + } + *(v4flt *) (dst + j + 0 * z) = t0; + *(v4flt *) (dst + j + 1 * z) = t1; + *(v4flt *) (dst + j + 2 * z) = t2; + *(v4flt *) (dst + j + 3 * z) = t3; + } + for (; j < n; ++j) + { + float t = src[0][j]; + for (i = 1; i < a; ++i) + t += src[i][j]; + dst[j] = t; + } +} + +float buffer[64]; + +int +main (void) +{ + int i; + float *dst, *src[2]; + + dst = buffer; + dst += (-(long int) buffer & (16 * sizeof (float) - 1)) / sizeof (float); + src[0] = dst + 16; + src[1] = dst + 32; + for (i = 0; i < 16; ++i) + { + src[0][i] = (float) i + 11 * (float) i; + src[1][i] = (float) i + 12 * (float) i; + } + foo (dst, src, 2, 16); + for (i = 0; i < 16; ++i) + { + float e = (float) i + 11 * (float) i + (float) i + 12 * (float) i; + if (dst[i] != e) + abort (); + } + return 0; +} diff --git a/test/tests/20060905-1.c b/test/tests/20060905-1.c new file mode 100644 index 0000000..eac884f --- /dev/null +++ b/test/tests/20060905-1.c @@ -0,0 +1,35 @@ +/* PR rtl-optimization/28386 */ +/* Origin: Volker Reichelt */ + +extern void abort(void); + +volatile char s[256][3]; + +char g; + +static void dummy(char a) +{ + g = a; +} + +static int foo(void) +{ + int i, j=0; + + for (i = 0; i < 256; i++) + if (i >= 128 && i < 256) + { + dummy (s[i - 128][0]); + ++j; + } + + return j; +} + +int main(void) +{ + if (foo () != 128) + abort (); + + return 0; +} diff --git a/test/tests/20060910-1.c b/test/tests/20060910-1.c new file mode 100644 index 0000000..78bf301 --- /dev/null +++ b/test/tests/20060910-1.c @@ -0,0 +1,37 @@ +/* PR rtl-optimization/28636 */ +/* Origin: Andreas Schwab */ + +extern void abort(void); + +struct input_ty +{ + unsigned char *buffer_position; + unsigned char *buffer_end; +}; + +int input_getc_complicated (struct input_ty *x) { return 0; } + +int check_header (struct input_ty *deeper) +{ + unsigned len; + for (len = 0; len < 6; len++) + if (((deeper)->buffer_position < (deeper)->buffer_end + ? *((deeper)->buffer_position)++ + : input_getc_complicated((deeper))) < 0) + return 0; + return 1; +} + +struct input_ty s; +unsigned char b[6]; + +int main (void) +{ + s.buffer_position = b; + s.buffer_end = b + sizeof b; + if (!check_header(&s)) + abort(); + if (s.buffer_position != s.buffer_end) + abort(); + return 0; +} diff --git a/test/tests/20060929-1.c b/test/tests/20060929-1.c new file mode 100644 index 0000000..76c447f --- /dev/null +++ b/test/tests/20060929-1.c @@ -0,0 +1,44 @@ +/* PR c/29154 */ + +extern void abort (void); + +void +foo (int **p, int *q) +{ + *(*p++)++ = *q++; +} + +void +bar (int **p, int *q) +{ + **p = *q++; + *(*p++)++; +} + +void +baz (int **p, int *q) +{ + **p = *q++; + (*p++)++; +} + +int +main (void) +{ + int i = 42, j = 0; + int *p = &i; + foo (&p, &j); + if (p - 1 != &i || j != 0 || i != 0) + abort (); + i = 43; + p = &i; + bar (&p, &j); + if (p - 1 != &i || j != 0 || i != 0) + abort (); + i = 44; + p = &i; + baz (&p, &j); + if (p - 1 != &i || j != 0 || i != 0) + abort (); + return 0; +} diff --git a/test/tests/20060930-1.c b/test/tests/20060930-1.c new file mode 100644 index 0000000..f12ee55 --- /dev/null +++ b/test/tests/20060930-1.c @@ -0,0 +1,42 @@ +/* PR rtl-optimization/28096 */ +/* Origin: Jan Stein */ + +extern void abort (void); + +int bar (int, int) __attribute__((noinline)); +int bar (int a, int b) +{ + if (b != 1) + abort (); +} + +void foo(int, int) __attribute__((noinline)); +void foo (int e, int n) +{ + int i, bb2, bb5; + + if (e > 0) + e = -e; + + for (i = 0; i < n; i++) + { + if (e >= 0) + { + bb2 = 0; + bb5 = 0; + } + else + { + bb5 = -e; + bb2 = bb5; + } + + bar (bb5, bb2); + } +} + +int main(void) +{ + foo (1, 1); + return 0; +} diff --git a/test/tests/20060930-2.c b/test/tests/20060930-2.c new file mode 100644 index 0000000..498f781 --- /dev/null +++ b/test/tests/20060930-2.c @@ -0,0 +1,31 @@ +/* PR middle-end/29272 */ + +extern void abort (void); + +struct S { struct S *s; } s; +struct T { struct T *t; } t; + +static inline void +foo (void *s) +{ + struct T *p = s; + __builtin_memcpy (&p->t, &t.t, sizeof (t.t)); +} + +void * +__attribute__((noinline)) +bar (void *p, struct S *q) +{ + q->s = &s; + foo (p); + return q->s; +} + +int +main (void) +{ + t.t = &t; + if (bar (&s, &s) != (void *) &t) + abort (); + return 0; +} diff --git a/test/tests/20061031-1.c b/test/tests/20061031-1.c new file mode 100644 index 0000000..0222e62 --- /dev/null +++ b/test/tests/20061031-1.c @@ -0,0 +1,29 @@ +/* PR rtl-optimization/29631 */ +/* Origin: Falk Hueffner */ + +const signed char nunmap[] = { 17, -1, 1 }; + +__attribute__((noinline)) +void ff(int i) { + //asm volatile(""); +} + +__attribute__((noinline)) +void f(short delta) +{ + short p0 = 2, s; + for (s = 0; s < 2; s++) + { + p0 += delta; + ff(s); + if (nunmap[p0] == 17) { + //asm volatile(""); + } + } +} + +int main(void) +{ + f(-1); + return 0; +} diff --git a/test/tests/20061101-1.c b/test/tests/20061101-1.c new file mode 100644 index 0000000..2351728 --- /dev/null +++ b/test/tests/20061101-1.c @@ -0,0 +1,32 @@ +/* PR rtl-optimization/28970 */ +/* Origin: Peter Bergner */ + +extern void abort (void); + +int tar (int i) +{ + if (i != 36863) + abort (); + + return -1; +} + +void bug(int q, int bcount) +{ + int j = 0; + int outgo = 0; + + while(j != -1) + { + outgo++; + if (outgo > q-1) + outgo = q-1; + j = tar (outgo*bcount); + } +} + +int main(void) +{ + bug(5, 36863); + return 0; +} diff --git a/test/tests/20061101-2.c b/test/tests/20061101-2.c new file mode 100644 index 0000000..d5b1046 --- /dev/null +++ b/test/tests/20061101-2.c @@ -0,0 +1,32 @@ +/* PR rtl-optimization/28970 */ +/* Origin: Peter Bergner */ + +extern void abort (void); + +int tar (long i) +{ + if (i != 36863) + abort (); + + return -1; +} + +void bug(int q, long bcount) +{ + int j = 0; + int outgo = 0; + + while(j != -1) + { + outgo++; + if (outgo > q-1) + outgo = q-1; + j = tar (outgo*bcount); + } +} + +int main(void) +{ + bug(5, 36863); + return 0; +} diff --git a/test/tests/20070201-1.c b/test/tests/20070201-1.c new file mode 100644 index 0000000..c676c34 --- /dev/null +++ b/test/tests/20070201-1.c @@ -0,0 +1,20 @@ +/* PR middle-end/30473 */ + +extern int sprintf (char *, const char *, ...); +extern void abort (void); + +char * +foo (char *buf, char *p) +{ + sprintf (buf, "abcde", p++); + return p; +} + +int +main (void) +{ + char buf[6]; + if (foo (buf, &buf[2]) != &buf[3]) + abort (); + return 0; +} diff --git a/test/tests/20070212-1.c b/test/tests/20070212-1.c new file mode 100644 index 0000000..efda7f9 --- /dev/null +++ b/test/tests/20070212-1.c @@ -0,0 +1,26 @@ +struct f +{ + int i; +}; + +int g(int i, int c, struct f *ff, int *p) +{ + int *t; + if (c) + t = &i; + else + t = &ff->i; + *p = 0; + return *t; +} + +extern void abort(void); + +int main() +{ + struct f f; + f.i = 1; + if (g(5, 0, &f, &f.i) != 0) + abort (); + return 0; +} diff --git a/test/tests/20070212-2.c b/test/tests/20070212-2.c new file mode 100644 index 0000000..a107d0e --- /dev/null +++ b/test/tests/20070212-2.c @@ -0,0 +1,19 @@ +int f(int k, int i1, int j1) +{ + int *f1; + if(k) + f1 = &i1; + else + f1 = &j1; + i1 = 0; + return *f1; +} + +extern void abort (void); + +int main() +{ + if (f(1, 1, 2) != 0) + abort (); + return 0; +} diff --git a/test/tests/20070212-3.c b/test/tests/20070212-3.c new file mode 100644 index 0000000..174be2b --- /dev/null +++ b/test/tests/20070212-3.c @@ -0,0 +1,30 @@ +struct foo { int i; int j; }; + +int bar (struct foo *k, int k2, int f, int f2) +{ + int *p, *q; + int res; + if (f) + p = &k->i; + else + p = &k->j; + res = *p; + k->i = 1; + if (f2) + q = p; + else + q = &k2; + return res + *q; +} + +extern void abort (void); + +int main() +{ + struct foo k; + k.i = 0; + k.j = 1; + if (bar (&k, 1, 1, 1) != 1) + abort (); + return 0; +} diff --git a/test/tests/20070424-1.c b/test/tests/20070424-1.c new file mode 100644 index 0000000..4a9f9c9 --- /dev/null +++ b/test/tests/20070424-1.c @@ -0,0 +1,27 @@ +extern void abort (void); +extern void exit (int); + +void do_exit (void) { exit (0); } +void do_abort (void) { abort (); } + +void foo (int x, int a) +{ + if (x < a) + goto doit; + do_exit (); + if (x != a) + goto doit; + + /* else */ + do_abort (); + return; + +doit: + do_abort (); +} + +int main() +{ + foo (1, 0); + return 0; +} diff --git a/test/tests/20070517-1.c b/test/tests/20070517-1.c new file mode 100644 index 0000000..c81cbc6 --- /dev/null +++ b/test/tests/20070517-1.c @@ -0,0 +1,41 @@ +/* PR rtl-optimization/31691 */ +/* Origin: Chi-Hua Chen */ + +extern void abort (void); + +static int get_kind(int) __attribute__ ((noinline)); + +static int get_kind(int v) +{ + volatile int k = v; + return k; +} + +static int some_call(void) __attribute__ ((noinline)); + +static int some_call(void) +{ + return 0; +} + +static void example (int arg) +{ + int tmp, kind = get_kind (arg); + + if (kind == 9 || kind == 10 || kind == 5) + { + if (some_call() == 0) + { + if (kind == 9 || kind == 10) + tmp = arg; + else + abort(); + } + } +} + +int main(void) +{ + example(10); + return 0; +} diff --git a/test/tests/20070623-1.c b/test/tests/20070623-1.c new file mode 100644 index 0000000..e9c7d2a --- /dev/null +++ b/test/tests/20070623-1.c @@ -0,0 +1,41 @@ +#include + +int __attribute__((noinline)) nge(int a, int b) {return -(a >= b);} +int __attribute__((noinline)) ngt(int a, int b) {return -(a > b);} +int __attribute__((noinline)) nle(int a, int b) {return -(a <= b);} +int __attribute__((noinline)) nlt(int a, int b) {return -(a < b);} +int __attribute__((noinline)) neq(int a, int b) {return -(a == b);} +int __attribute__((noinline)) nne(int a, int b) {return -(a != b);} +int __attribute__((noinline)) ngeu(unsigned a, unsigned b) {return -(a >= b);} +int __attribute__((noinline)) ngtu(unsigned a, unsigned b) {return -(a > b);} +int __attribute__((noinline)) nleu(unsigned a, unsigned b) {return -(a <= b);} +int __attribute__((noinline)) nltu(unsigned a, unsigned b) {return -(a < b);} + + +int main() +{ + if (nge(INT_MIN, INT_MAX) != 0) abort(); + if (nge(INT_MAX, INT_MIN) != -1) abort(); + if (ngt(INT_MIN, INT_MAX) != 0) abort(); + if (ngt(INT_MAX, INT_MIN) != -1) abort(); + if (nle(INT_MIN, INT_MAX) != -1) abort(); + if (nle(INT_MAX, INT_MIN) != 0) abort(); + if (nlt(INT_MIN, INT_MAX) != -1) abort(); + if (nlt(INT_MAX, INT_MIN) != 0) abort(); + + if (neq(INT_MIN, INT_MAX) != 0) abort(); + if (neq(INT_MAX, INT_MIN) != 0) abort(); + if (nne(INT_MIN, INT_MAX) != -1) abort(); + if (nne(INT_MAX, INT_MIN) != -1) abort(); + + if (ngeu(0, ~0U) != 0) abort(); + if (ngeu(~0U, 0) != -1) abort(); + if (ngtu(0, ~0U) != 0) abort(); + if (ngtu(~0U, 0) != -1) abort(); + if (nleu(0, ~0U) != -1) abort(); + if (nleu(~0U, 0) != 0) abort(); + if (nltu(0, ~0U) != -1) abort(); + if (nltu(~0U, 0) != 0) abort(); + + exit(0); +} diff --git a/test/tests/20070724-1.c b/test/tests/20070724-1.c new file mode 100644 index 0000000..011a903 --- /dev/null +++ b/test/tests/20070724-1.c @@ -0,0 +1,11 @@ +void abort (void); + +static unsigned char magic[] = "\235"; +static unsigned char value = '\235'; + +int main() +{ + if (value != magic[0]) + abort (); + return 0; +} diff --git a/test/tests/20071011-1.c b/test/tests/20071011-1.c new file mode 100644 index 0000000..6316585 --- /dev/null +++ b/test/tests/20071011-1.c @@ -0,0 +1,19 @@ +extern void abort(void); +void foo(int *p) +{ + int x; + int y; + x = *p; + *p = 0; + y = *p; + if (x != y) + return; + abort (); +} + +int main() +{ + int a = 1; + foo(&a); + return 0; +} diff --git a/test/tests/920202-1.c b/test/tests/920202-1.c new file mode 100644 index 0000000..e30ce2f --- /dev/null +++ b/test/tests/920202-1.c @@ -0,0 +1,18 @@ +static int rule_text_needs_stack_pop = 0; +static int input_stack_pos = 1; + +f (void) +{ + rule_text_needs_stack_pop = 1; + + if (input_stack_pos <= 0) + return 1; + else + return 0; +} + +main () +{ + f (); + exit (0); +} diff --git a/test/tests/920302-1.c b/test/tests/920302-1.c new file mode 100644 index 0000000..44a1e9b --- /dev/null +++ b/test/tests/920302-1.c @@ -0,0 +1,42 @@ +short optab[5]; +char buf[10]; +execute (ip) + register short *ip; +{ +#ifndef NO_LABEL_VALUES + register void *base = &&x; + char *bp = buf; + static void *tab[] = {&&x, &&y, &&z}; + if (ip == 0) + { + int i; + for (i = 0; i < 3; ++i) + optab[i] = (short)(tab[i] - base); + return; + } +x: *bp++='x'; + goto *(base + *ip++); +y: *bp++='y'; + goto *(base + *ip++); +z: *bp++='z'; + *bp=0; + return; +#else + strcpy (buf, "xyxyz"); +#endif +} + +short p[5]; + +main () +{ + execute ((short *) 0); + p[0] = optab[1]; + p[1] = optab[0]; + p[2] = optab[1]; + p[3] = optab[2]; + execute (&p); + if (strcmp (buf, "xyxyz")) + abort (); + exit (0); +} diff --git a/test/tests/920409-1.c b/test/tests/920409-1.c new file mode 100644 index 0000000..938ce7d --- /dev/null +++ b/test/tests/920409-1.c @@ -0,0 +1 @@ +x(){signed char c=-1;return c<0;}main(){if(x()!=1)abort();exit(0);} diff --git a/test/tests/920410-1.c b/test/tests/920410-1.c new file mode 100644 index 0000000..f5180f0 --- /dev/null +++ b/test/tests/920410-1.c @@ -0,0 +1,6 @@ +#define STACK_REQUIREMENT (40000 * 4 + 256) +#if defined (STACK_SIZE) && STACK_SIZE < STACK_REQUIREMENT +main () { exit (0); } +#else +main(){int d[40000];d[0]=0;exit(0);} +#endif diff --git a/test/tests/920411-1.c b/test/tests/920411-1.c new file mode 100644 index 0000000..e3e9810 --- /dev/null +++ b/test/tests/920411-1.c @@ -0,0 +1,24 @@ +long f (w) + char *w; +{ + long k, i, c = 0, x; + char *p = (char*) &x; + for (i = 0; i < 1; i++) + { + for (k = 0; k < sizeof (long); k++) + p[k] = w[k]; + c += x; + } + return c; +} + +main () +{ + int i; + char a[sizeof (long)]; + + for (i = sizeof (long); --i >= 0;) a[i] = ' '; + if (f (a) != ~0UL / (unsigned char) ~0 * ' ') + abort (); + exit (0); +} diff --git a/test/tests/920428-1.c b/test/tests/920428-1.c new file mode 100644 index 0000000..154af76 --- /dev/null +++ b/test/tests/920428-1.c @@ -0,0 +1,2 @@ +x(const char*s){char a[1];const char*ss=s;a[*s++]|=1;return(int)ss+1==(int)s;} +main(){if(x("")!=1)abort();exit(0);} diff --git a/test/tests/920429-1.c b/test/tests/920429-1.c new file mode 100644 index 0000000..f37bf68 --- /dev/null +++ b/test/tests/920429-1.c @@ -0,0 +1,3 @@ +typedef unsigned char t;int i,j; +t*f(t*p){t c;c=*p++;i=((c&2)?1:0);j=(c&7)+1;return p;} +main(){t*p0="ab",*p1;p1=f(p0);if(p0+1!=p1)abort();exit(0);} diff --git a/test/tests/920501-1.c b/test/tests/920501-1.c new file mode 100644 index 0000000..6f757ca --- /dev/null +++ b/test/tests/920501-1.c @@ -0,0 +1,3 @@ +int s[2]; +x(){if(!s[0]){s[1+s[1]]=s[1];return 1;}} +main(){s[0]=s[1]=0;if(x(0)!=1)abort();exit(0);} diff --git a/test/tests/920501-3.c b/test/tests/920501-3.c new file mode 100644 index 0000000..1031d73 --- /dev/null +++ b/test/tests/920501-3.c @@ -0,0 +1,35 @@ +int tab[9]; +execute(oip, ip) + unsigned short *oip, *ip; +{ +#ifndef NO_LABEL_VALUES + int x = 0; + int *xp = tab; +base: + x++; + if (x == 4) + { + *xp = 0; + return; + } + *xp++ = ip - oip; + goto *(&&base + *ip++); +#else + tab[0] = 0; + tab[1] = 1; + tab[2] = 2; + tab[3] = 0; +#endif +} + +main() +{ + unsigned short ip[10]; + int i; + for (i = 0; i < 10; i++) + ip[i] = 0; + execute(ip, ip); + if (tab[0] != 0 || tab[1] != 1 || tab[2] != 2 || tab[3] != 0) + abort(); + exit(0); +} diff --git a/test/tests/920501-4.c b/test/tests/920501-4.c new file mode 100644 index 0000000..3524dd5 --- /dev/null +++ b/test/tests/920501-4.c @@ -0,0 +1,27 @@ +#ifndef NO_LABEL_VALUES +int +x (int i) +{ + static const void *j[] = {&& x, && y, && z}; + + goto *j[i]; + + x: return 2; + y: return 3; + z: return 5; +} + +int +main (void) +{ + if ( x (0) != 2 + || x (1) != 3 + || x (2) != 5) + abort (); + + exit (0); +} +#else +int +main (void) { exit (0); } +#endif diff --git a/test/tests/920501-5.c b/test/tests/920501-5.c new file mode 100644 index 0000000..e352a91 --- /dev/null +++ b/test/tests/920501-5.c @@ -0,0 +1,19 @@ +#ifndef NO_LABEL_VALUES +x (int i) +{ + void *j[] = {&&x, &&y, &&z}; + goto *j[i]; + x:return 2; + y:return 3; + z:return 5; + +} +main () +{ + if (x (0) != 2 || x (1) != 3 || x (2) != 5) + abort(); + exit(0); +} +#else +main(){ exit (0); } +#endif diff --git a/test/tests/920501-6.c b/test/tests/920501-6.c new file mode 100644 index 0000000..f27effa --- /dev/null +++ b/test/tests/920501-6.c @@ -0,0 +1,91 @@ +//#include + +/* Convert a decimal string to a long long unsigned. No error check is + performed. */ + +long long unsigned +str2llu (str) + char *str; +{ + long long unsigned acc; + int d; + acc = *str++ - '0'; + for (;;) + { + d = *str++; + if (d == '\0') + break; + d -= '0'; + acc = acc * 10 + d; + } + + return acc; +} + +/* isqrt(t) - computes the square root of t. (tege 86-10-27) */ + +long unsigned +sqrtllu (long long unsigned t) +{ + long long unsigned s; + long long unsigned b; + + for (b = 0, s = t; b++, (s >>= 1) != 0; ) + ; + + s = 1LL << (b >> 1); + + if (b & 1) + s += s >> 1; + + do + { + b = t / s; + s = (s + b) >> 1; + } + while (b < s); + + return s; +} + + +int plist (p0, p1, tab) + long long unsigned p0, p1; + long long unsigned *tab; +{ + long long unsigned p; + long unsigned d; + long unsigned s; + long long unsigned *xp = tab; + + for (p = p0; p <= p1; p += 2) + { + s = sqrtllu (p); + + for (d = 3; d <= s; d += 2) + { + long long unsigned q = p % d; + if (q == 0) + goto not_prime; + } + + *xp++ = p; + not_prime:; + } + *xp = 0; + return xp - tab; +} + +main (argc, argv) + int argc; + char *argv[]; +{ + long long tab[10]; + int nprimes; + nprimes = plist (str2llu ("1234111111"), str2llu ("1234111127"), tab); + + if(tab[0]!=1234111117LL||tab[1]!=1234111121LL||tab[2]!=1234111127LL||tab[3]!=0) + abort(); + + exit(0); +} diff --git a/test/tests/920501-9.c b/test/tests/920501-9.c new file mode 100644 index 0000000..97f4839 --- /dev/null +++ b/test/tests/920501-9.c @@ -0,0 +1,27 @@ +#include + +long long proc1(){return 1LL;} +long long proc2(){return 0x1234LL;} +long long proc3(){return 0xabcd1234LL;} +long long proc4(){return -1LL;} +long long proc5(){return 0xabcdLL;} + +print_longlong(x,buf) + long long x; + char *buf; +{ + unsigned long l; + l= (x >> 16) & 0xffff; + if (l != 0) + sprintf(buf,"%lx%04.lx",l,((unsigned long)x & 0xffff)); + else + sprintf(buf,"%lx",((unsigned long)x & 0xffff)); +} + +main(){char buf[100]; +print_longlong(proc1(),buf);if(strcmp("1",buf))abort(); +print_longlong(proc2(),buf);if(strcmp("1234",buf))abort(); +print_longlong(proc3(),buf);if(strcmp("abcd1234",buf))abort(); +print_longlong(proc4(),buf);if(strcmp("ffffffff",buf))abort(); +print_longlong(proc5(),buf);if(strcmp("abcd",buf))abort(); +exit(0);} diff --git a/test/tests/920506-1.c b/test/tests/920506-1.c new file mode 100644 index 0000000..9a646a3 --- /dev/null +++ b/test/tests/920506-1.c @@ -0,0 +1,2 @@ +int l[]={0,1}; +main(){int*p=l;switch(*p++){case 0:exit(0);case 1:break;case 2:break;case 3:case 4:break;}abort();} diff --git a/test/tests/920520-1.c b/test/tests/920520-1.c new file mode 100644 index 0000000..068a12e --- /dev/null +++ b/test/tests/920520-1.c @@ -0,0 +1,36 @@ +foo(int *bar) +{ + *bar = 8; +} + +bugger() +{ + int oldDepth, newDepth; + + foo(&oldDepth); + + switch (oldDepth) + { + case 8: + case 500: + newDepth = 8; + break; + + case 5000: + newDepth = 500; + break; + + default: + newDepth = 17; + break; + } + + return newDepth - oldDepth; +} + +main() +{ + if (bugger() != 0) + abort (); + exit (0); +} diff --git a/test/tests/920603-1.c b/test/tests/920603-1.c new file mode 100644 index 0000000..bd27ca6 --- /dev/null +++ b/test/tests/920603-1.c @@ -0,0 +1,2 @@ +f(got){if(got!=0xffff)abort();} +main(){signed char c=-1;unsigned u=(unsigned short)c;f(u);exit(0);} diff --git a/test/tests/920604-1.c b/test/tests/920604-1.c new file mode 100644 index 0000000..d7d9be1 --- /dev/null +++ b/test/tests/920604-1.c @@ -0,0 +1,13 @@ +long long +mod (a, b) + long long a, b; +{ + return a % b; +} + +int +main () +{ + mod (1LL, 2LL); + exit (0); +} diff --git a/test/tests/920612-1.c b/test/tests/920612-1.c new file mode 100644 index 0000000..a70c0d2 --- /dev/null +++ b/test/tests/920612-1.c @@ -0,0 +1,2 @@ +f(j)int j;{return++j>0;} +main(){if(f((~0U)>>1))abort();exit(0);} diff --git a/test/tests/920612-2.c b/test/tests/920612-2.c new file mode 100644 index 0000000..670d7c0 --- /dev/null +++ b/test/tests/920612-2.c @@ -0,0 +1,15 @@ + int i = 0; + int a (int x) + { + while (x) + i++, x--; + return x; + } +main () +{ +#ifndef NO_TRAMPOLINES + if (a (2) != 0) + abort (); +#endif + exit (0); +} diff --git a/test/tests/920618-1.c b/test/tests/920618-1.c new file mode 100644 index 0000000..224f720 --- /dev/null +++ b/test/tests/920618-1.c @@ -0,0 +1 @@ +main(){if(1.17549435e-38F<=1.1)exit(0);abort();} diff --git a/test/tests/920625-1.c b/test/tests/920625-1.c new file mode 100644 index 0000000..ae2f415 --- /dev/null +++ b/test/tests/920625-1.c @@ -0,0 +1,38 @@ +#include + +typedef struct{double x,y;}point; +point pts[]={{1.0,2.0},{3.0,4.0},{5.0,6.0},{7.0,8.0}}; +static int va1(int nargs,...) +{ + va_list args; + int i; + point pi; + va_start(args,nargs); + for(i=0;i 1.84467440737096e+19) + abort(); +#endif + + if (16777217LL != (float)16777217e0) + abort(); + + exit(0); +} diff --git a/test/tests/920711-1.c b/test/tests/920711-1.c new file mode 100644 index 0000000..57d09c7 --- /dev/null +++ b/test/tests/920711-1.c @@ -0,0 +1,2 @@ +f(long long a){return (--a > 0);} +main(){if(f(0x80000000L)==0)abort();exit(0);} diff --git a/test/tests/920721-1.c b/test/tests/920721-1.c new file mode 100644 index 0000000..086b546 --- /dev/null +++ b/test/tests/920721-1.c @@ -0,0 +1,2 @@ +long f(short a,short b){return (long)a/b;} +main(){if(f(-32768,-1)!=32768L)abort();else exit(0);} diff --git a/test/tests/920721-3.c b/test/tests/920721-3.c new file mode 100644 index 0000000..61f605d --- /dev/null +++ b/test/tests/920721-3.c @@ -0,0 +1,26 @@ +static inline fu (unsigned short data) +{ + return data; +} +ru(i) +{ + if(fu(i++)!=5)abort(); + if(fu(++i)!=7)abort(); +} +static inline fs (signed short data) +{ + return data; +} +rs(i) +{ + if(fs(i++)!=5)abort(); + if(fs(++i)!=7)abort(); +} + + +main() +{ + ru(5); + rs(5); + exit(0); +} diff --git a/test/tests/920726-1.c b/test/tests/920726-1.c new file mode 100644 index 0000000..d6042c9 --- /dev/null +++ b/test/tests/920726-1.c @@ -0,0 +1,63 @@ +#include +#include + +struct spurious +{ + int anumber; +}; + +int first(char *buf, char *fmt, ...) +{ + int pos, number; + va_list args; + int dummy; + char *bp = buf; + + va_start(args, fmt); + for (pos = 0; fmt[pos]; pos++) + if (fmt[pos] == 'i') + { + number = va_arg(args, int); + sprintf(bp, "%d", number); + bp += strlen(bp); + } + else + *bp++ = fmt[pos]; + + va_end(args); + *bp = 0; + return dummy; +} + +struct spurious second(char *buf,char *fmt, ...) +{ + int pos, number; + va_list args; + struct spurious dummy; + char *bp = buf; + + va_start(args, fmt); + for (pos = 0; fmt[pos]; pos++) + if (fmt[pos] == 'i') + { + number = va_arg(args, int); + sprintf(bp, "%d", number); + bp += strlen(bp); + } + else + *bp++ = fmt[pos]; + + va_end(args); + *bp = 0; + return dummy; +} + +main() +{ + char buf1[100], buf2[100]; + first(buf1, "i i ", 5, 20); + second(buf2, "i i ", 5, 20); + if (strcmp ("5 20 ", buf1) || strcmp ("5 20 ", buf2)) + abort(); + exit(0); +} diff --git a/test/tests/920728-1.c b/test/tests/920728-1.c new file mode 100644 index 0000000..e08df36 --- /dev/null +++ b/test/tests/920728-1.c @@ -0,0 +1,24 @@ +typedef struct {int dims[0]; } *A; + +f(unsigned long long obj) +{ + unsigned char y = obj >> 24; + y &= ~4; + + if ((y==0)||(y!=251 )) + abort(); + + if(((int)obj&7)!=7)return; + + REST_OF_CODE_JUST_HERE_TO_TRIGGER_THE_BUG: + + { + unsigned char t = obj >> 24; + if (!(t==0)&&(t<=0x03)) + return 0; + return ((A)(obj&0x00FFFFFFL))->dims[1]; + } +} + +long long g(){return 0xff000000L;} +main (){int x;f(g());exit(0);} diff --git a/test/tests/920730-1.c b/test/tests/920730-1.c new file mode 100644 index 0000000..576e7a6 --- /dev/null +++ b/test/tests/920730-1.c @@ -0,0 +1,32 @@ +/* 920730-1.c */ +#include +f1() +{ + int b=INT_MIN; + return b>=INT_MIN; +} + +f2() +{ + int b=INT_MIN+1; + return b>= (unsigned)(INT_MAX+2); +} + +f3() +{ + int b=INT_MAX; + return b>=INT_MAX; +} + +f4() +{ + int b=-1; + return b>=UINT_MAX; +} + +main () +{ + if((f1()&f2()&f3()&f4())!=1) + abort(); + exit(0); +} diff --git a/test/tests/920731-1.c b/test/tests/920731-1.c new file mode 100644 index 0000000..de0fb58 --- /dev/null +++ b/test/tests/920731-1.c @@ -0,0 +1,2 @@ +f(x){int i;for(i=0;i<8&&(x&1)==0;x>>=1,i++);return i;} +main(){if(f(4)!=2)abort();exit(0);} diff --git a/test/tests/920810-1.c b/test/tests/920810-1.c new file mode 100644 index 0000000..f407194 --- /dev/null +++ b/test/tests/920810-1.c @@ -0,0 +1,23 @@ +//#include +#include +#include + +typedef struct{void*super;int name;int size;}t; +t*f(t*clas,int size) +{ + t*child=(t*)malloc(size); + memcpy(child,clas,clas->size); + child->super=clas; + child->name=0; + child->size=size; + return child; +} +main() +{ + t foo,*bar; + memset(&foo,37,sizeof(t)); + foo.size=sizeof(t); + bar=f(&foo,sizeof(t)); + if(bar->super!=&foo||bar->name!=0||bar->size!=sizeof(t))abort(); + exit(0); +} diff --git a/test/tests/920812-1.c b/test/tests/920812-1.c new file mode 100644 index 0000000..b49ab42 --- /dev/null +++ b/test/tests/920812-1.c @@ -0,0 +1,3 @@ +typedef int t; +f(t y){switch(y){case 1:return 1;}return 0;} +main(){if(f((t)1)!=1)abort();exit(0);} diff --git a/test/tests/920829-1.c b/test/tests/920829-1.c new file mode 100644 index 0000000..ae8103e --- /dev/null +++ b/test/tests/920829-1.c @@ -0,0 +1,2 @@ +long long c=286331153L,c3=286331153L*3; +main(){if(c*3!=c3)abort();exit(0);} diff --git a/test/tests/920908-1.c b/test/tests/920908-1.c new file mode 100644 index 0000000..98fbb5e --- /dev/null +++ b/test/tests/920908-1.c @@ -0,0 +1,28 @@ +/* REPRODUCED:RUN:SIGNAL MACHINE:mips OPTIONS: */ + +#include + +typedef struct{int A;}T; + +T f(int x,...) +{ +va_list ap; +T X; +va_start(ap,x); +X=va_arg(ap,T); +if(X.A!=10)abort(); +X=va_arg(ap,T); +if(X.A!=20)abort(); +va_end(ap); +return X; +} + +main() +{ +T X,Y; +int i; +X.A=10; +Y.A=20; +f(2,X,Y); +exit(0); +} diff --git a/test/tests/920908-2.c b/test/tests/920908-2.c new file mode 100644 index 0000000..31c1ae0 --- /dev/null +++ b/test/tests/920908-2.c @@ -0,0 +1,33 @@ +/* The bit-field below would have a problem if __INT_MAX__ is too + small. */ +#if __INT_MAX__ < 2147483647 +int +main (void) +{ + exit (0); +} +#else +/* +CONF:m68k-sun-sunos4.1.1 +OPTIONS:-O +*/ +struct T +{ +unsigned i:8; +unsigned c:24; +}; +f(struct T t) +{ +struct T s[1]; +s[0]=t; +return(char)s->c; +} +main() +{ +struct T t; +t.i=0xff; +t.c=0xffff11; +if(f(t)!=0x11)abort(); +exit(0); +} +#endif diff --git a/test/tests/920909-1.c b/test/tests/920909-1.c new file mode 100644 index 0000000..c888034 --- /dev/null +++ b/test/tests/920909-1.c @@ -0,0 +1,2 @@ +f(a){switch(a){case 0x402:return a+1;case 0x403:return a+2;case 0x404:return a+3;case 0x405:return a+4;case 0x406:return 1;case 0x407:return 4;}return 0;} +main(){if(f(1))abort();exit(0);} diff --git a/test/tests/920922-1.c b/test/tests/920922-1.c new file mode 100644 index 0000000..75c9edc --- /dev/null +++ b/test/tests/920922-1.c @@ -0,0 +1,14 @@ +unsigned long long* +f(p)unsigned long long*p; +{ + unsigned long long a = (*p++) >> 24; + return p + a; +} + +main () +{ + unsigned long long x = 0x80000000UL; + if (f(&x) != &x + 0x81) + abort(); + exit(0); +} diff --git a/test/tests/921006-1.c b/test/tests/921006-1.c new file mode 100644 index 0000000..50fbdb7 --- /dev/null +++ b/test/tests/921006-1.c @@ -0,0 +1,6 @@ +/* REPRODUCED:RUN:SIGNAL MACHINE:i386 OPTIONS:-O */ +main() +{ +if(strcmp("X","")<0)abort(); +exit(0); +} diff --git a/test/tests/921007-1.c b/test/tests/921007-1.c new file mode 100644 index 0000000..da38300 --- /dev/null +++ b/test/tests/921007-1.c @@ -0,0 +1,7 @@ +static int strcmp(){return-1;} +//#define strcmp __builtin_strcmp +main() +{ +if(strcmp("X","X\376")>=0)abort(); +exit(0); +} diff --git a/test/tests/921013-1.c b/test/tests/921013-1.c new file mode 100644 index 0000000..d041beb --- /dev/null +++ b/test/tests/921013-1.c @@ -0,0 +1,20 @@ +f(d,x,y,n) +int*d; +float*x,*y; +int n; +{ + while(n--){*d++=*x++==*y++;} +} + +main() +{ + int r[4]; + float a[]={5,1,3,5}; + float b[]={2,4,3,0}; + int i; + f(r,a,b,4); + for(i=0;i<4;i++) + if((a[i]==b[i])!=r[i]) + abort(); + exit(0); +} diff --git a/test/tests/921016-1.c b/test/tests/921016-1.c new file mode 100644 index 0000000..46f8a83 --- /dev/null +++ b/test/tests/921016-1.c @@ -0,0 +1,10 @@ +main() +{ +int j=1081; +struct +{ +signed int m:11; +}l; +if((l.m=j)==j)abort(); +exit(0); +} diff --git a/test/tests/921019-1.c b/test/tests/921019-1.c new file mode 100644 index 0000000..f48613a --- /dev/null +++ b/test/tests/921019-1.c @@ -0,0 +1,8 @@ +void *foo[]={(void *)&("X"[0])}; + +main () +{ + if (((char*)foo[0])[0] != 'X') + abort (); + exit (0); +} diff --git a/test/tests/921019-2.c b/test/tests/921019-2.c new file mode 100644 index 0000000..9003e7b --- /dev/null +++ b/test/tests/921019-2.c @@ -0,0 +1,8 @@ +main() +{ + double x,y=0.5; + x=y/0.2; + if(x!=x) + abort(); + exit(0); +} diff --git a/test/tests/921029-1.c b/test/tests/921029-1.c new file mode 100644 index 0000000..76fc974 --- /dev/null +++ b/test/tests/921029-1.c @@ -0,0 +1,42 @@ +typedef unsigned long long ULL; +ULL back; +ULL hpart, lpart; +ULL +build(long h, long l) +{ + hpart = h; + hpart <<= 32; + lpart = l; + lpart &= 0xFFFFFFFFLL; + back = hpart | lpart; + return back; +} + +main() +{ + if (build(0, 1) != 0x0000000000000001LL) + abort(); + if (build(0, 0) != 0x0000000000000000LL) + abort(); + if (build(0, 0xFFFFFFFF) != 0x00000000FFFFFFFFLL) + abort(); + if (build(0, 0xFFFFFFFE) != 0x00000000FFFFFFFELL) + abort(); + if (build(1, 1) != 0x0000000100000001LL) + abort(); + if (build(1, 0) != 0x0000000100000000LL) + abort(); + if (build(1, 0xFFFFFFFF) != 0x00000001FFFFFFFFLL) + abort(); + if (build(1, 0xFFFFFFFE) != 0x00000001FFFFFFFELL) + abort(); + if (build(0xFFFFFFFF, 1) != 0xFFFFFFFF00000001LL) + abort(); + if (build(0xFFFFFFFF, 0) != 0xFFFFFFFF00000000LL) + abort(); + if (build(0xFFFFFFFF, 0xFFFFFFFF) != 0xFFFFFFFFFFFFFFFFLL) + abort(); + if (build(0xFFFFFFFF, 0xFFFFFFFE) != 0xFFFFFFFFFFFFFFFELL) + abort(); + exit(0); +} diff --git a/test/tests/921104-1.c b/test/tests/921104-1.c new file mode 100644 index 0000000..4b6f4bc --- /dev/null +++ b/test/tests/921104-1.c @@ -0,0 +1,8 @@ +main () +{ + unsigned long val = 1; + + if (val > (unsigned long) ~0) + abort(); + exit (0); +} diff --git a/test/tests/921110-1.c b/test/tests/921110-1.c new file mode 100644 index 0000000..27ff96f --- /dev/null +++ b/test/tests/921110-1.c @@ -0,0 +1,7 @@ +extern int abort(); +typedef int (*frob)(); +frob f[] = {abort}; +main() +{ + exit(0); +} diff --git a/test/tests/921112-1.c b/test/tests/921112-1.c new file mode 100644 index 0000000..5946398 --- /dev/null +++ b/test/tests/921112-1.c @@ -0,0 +1,21 @@ +union u { + struct { int i1, i2; } t; + double d; +} x[2], v; + +f (x, v) + union u *x, v; +{ + *++x = v; +} + +main() +{ + x[1].t.i1 = x[1].t.i2 = 0; + v.t.i1 = 1; + v.t.i2 = 2; + f (x, v); + if (x[1].t.i1 != 1 || x[1].t.i2 != 2) + abort (); + exit (0); +} diff --git a/test/tests/921113-1.c b/test/tests/921113-1.c new file mode 100644 index 0000000..1aa96b2 --- /dev/null +++ b/test/tests/921113-1.c @@ -0,0 +1,63 @@ +#define STACK_REQUIREMENT (128 * 128 * 4 + 1024) +#if defined (STACK_SIZE) && STACK_SIZE < STACK_REQUIREMENT +main () { exit (0); } +#else + +typedef struct { + float wsx; +} struct_list; + +typedef struct_list *list_t; + +typedef struct { + float x, y; +} vector_t; + +w(float x, float y) {} + +f1(float x, float y) +{ + if (x != 0 || y != 0) + abort(); +} +f2(float x, float y) +{ + if (x != 1 || y != 1) + abort(); +} + +gitter(int count, vector_t pos[], list_t list, int *nww, vector_t limit[2], float r) +{ + float d; + static int gitt[128][128]; + + f1(limit[0].x, limit[0].y); + f2(limit[1].x, limit[1].y); + + *nww = 0; + + d = pos[0].x; + if (d <= 0.) + { + w(d, r); + if (d <= r * 0.5) + { + w(d, r); + list[0].wsx = 1; + } + } +} + +vector_t pos[1] = {{0., 0.}}; +vector_t limit[2] = {{0.,0.},{1.,1.}}; + +main() +{ + int nww; + struct_list list; + + gitter(1, pos, &list, &nww, limit, 1.); + exit(0); +} + +#endif diff --git a/test/tests/921117-1.c b/test/tests/921117-1.c new file mode 100644 index 0000000..2ed30fb --- /dev/null +++ b/test/tests/921117-1.c @@ -0,0 +1,22 @@ +struct s { + char text[11]; + int flag; +} cell; + +int +check (struct s p) +{ + if (p.flag != 99) + return 1; + return strcmp (p.text, "0123456789"); +} + +main () +{ + cell.flag = 99; + strcpy (cell.text, "0123456789"); + + if (check (cell)) + abort(); + exit (0); +} diff --git a/test/tests/921123-1.c b/test/tests/921123-1.c new file mode 100644 index 0000000..d3daf12 --- /dev/null +++ b/test/tests/921123-1.c @@ -0,0 +1,13 @@ +f(short *p) +{ + short x = *p; + return (--x < 0); +} + +main() +{ + short x = -10; + if (!f(&x)) + abort(); + exit(0); +} diff --git a/test/tests/921123-2.c b/test/tests/921123-2.c new file mode 100644 index 0000000..3028717 --- /dev/null +++ b/test/tests/921123-2.c @@ -0,0 +1,24 @@ +typedef struct +{ + unsigned short b0, b1, b2, b3; +} four_quarters; + +four_quarters x; +int a, b; + +void f (four_quarters j) +{ + b = j.b2; + a = j.b3; +} + +main () +{ + four_quarters x; + x.b0 = x.b1 = x.b2 = 0; + x.b3 = 38; + f(x); + if (a != 38) + abort(); + exit (0); +} diff --git a/test/tests/921124-1.c b/test/tests/921124-1.c new file mode 100644 index 0000000..51b090b --- /dev/null +++ b/test/tests/921124-1.c @@ -0,0 +1,19 @@ +f(x, d1, d2, d3) + double d1, d2, d3; +{ + return x; +} + +g(b,s,x,y,i,j) + char *b,*s; + double x,y; +{ + if (x != 1.0 || y != 2.0 || i != 3 || j != 4) + abort(); +} + +main() +{ + g("","", 1.0, 2.0, f(3, 0.0, 0.0, 0.0), f(4, 0.0, 0.0, 0.0)); + exit(0); +} diff --git a/test/tests/921202-1.c b/test/tests/921202-1.c new file mode 100644 index 0000000..df3813e --- /dev/null +++ b/test/tests/921202-1.c @@ -0,0 +1,41 @@ +#ifndef STACK_SIZE +#define VLEN 1055 +#else +#define VLEN ((STACK_SIZE/16) - 1) +#endif +main () +{ + long dx[VLEN]; + long dy[VLEN]; + long s1[VLEN]; + int cyx, cyy; + int i; + long size; + + for (;;) + { + size = VLEN; + mpn_random2 (s1, size); + + for (i = 0; i < 1; i++) + ; + + dy[size] = 0x1234; + + for (i = 0; i < 1; i++) + cyy = mpn_mul_1 (dy, s1, size); + + if (cyx != cyy || mpn_cmp (dx, dy, size + 1) != 0 || dx[size] != 0x1234) + { + foo ("", 8, cyy); mpn_print (dy, size); + } + exxit(); + } +} + +foo (){} +mpn_mul_1(){} +mpn_print (){} +mpn_random2(){} +mpn_cmp(){} +exxit(){exit(0);} diff --git a/test/tests/921202-2.c b/test/tests/921202-2.c new file mode 100644 index 0000000..48d4a41 --- /dev/null +++ b/test/tests/921202-2.c @@ -0,0 +1,13 @@ +int +f(long long x) +{ + x >>= 8; + return x & 0xff; +} + +main() +{ + if (f(0x0123456789ABCDEFLL) != 0xCD) + abort(); + exit (0); +} diff --git a/test/tests/921204-1.c b/test/tests/921204-1.c new file mode 100644 index 0000000..a7bba83 --- /dev/null +++ b/test/tests/921204-1.c @@ -0,0 +1,46 @@ +/* The bit-field below would have a problem if __INT_MAX__ is too + small. */ +#if __INT_MAX__ < 2147483647 +int +main (void) +{ + exit (0); +} +#else +typedef struct { + unsigned b0:1, f1:17, b18:1, b19:1, b20:1, f2:11; +} bf; + +typedef union { + bf b; + unsigned w; +} bu; + +bu +f(bu i) +{ + bu o = i; + + if (o.b.b0) + o.b.b18 = 1, + o.b.b20 = 1; + else + o.b.b18 = 0, + o.b.b20 = 0; + + return o; +} + +main() +{ + bu a; + bu r; + + a.w = 0x4000000; + a.b.b0 = 0; + r = f(a); + if (a.w != r.w) + abort(); + exit(0); +} +#endif diff --git a/test/tests/921207-1.c b/test/tests/921207-1.c new file mode 100644 index 0000000..5ee9d27 --- /dev/null +++ b/test/tests/921207-1.c @@ -0,0 +1,15 @@ +f() +{ + unsigned b = 0; + + if (b > ~0U) + b = ~0U; + + return b; +} +main() +{ + if (f()!=0) + abort(); + exit (0); +} diff --git a/test/tests/921208-1.c b/test/tests/921208-1.c new file mode 100644 index 0000000..143ef63 --- /dev/null +++ b/test/tests/921208-1.c @@ -0,0 +1,18 @@ +double +f(double x) +{ + return x*x; +} + +double +Int(double (*f)(double), double a) +{ + return (*f)(a); +} + +main() +{ + if (Int(&f,2.0) != 4.0) + abort(); + exit (0); +} diff --git a/test/tests/921208-2.c b/test/tests/921208-2.c new file mode 100644 index 0000000..aa7ae40 --- /dev/null +++ b/test/tests/921208-2.c @@ -0,0 +1,26 @@ +#define STACK_REQUIREMENT (100000 * 4 + 1024) +#if defined (STACK_SIZE) && STACK_SIZE < STACK_REQUIREMENT +main () { exit (0); } +#else + +g(){} + +f() +{ + int i; + float a[100]; + + for (i = 0; i < 1; i++) + { + g(1.0, 1.0 + i / 2.0 * 3.0); + g(2.0, 1.0 + i / 2.0 * 3.0); + } +} + +main () +{ + f(); + exit(0); +} + +#endif diff --git a/test/tests/921218-1.c b/test/tests/921218-1.c new file mode 100644 index 0000000..ab7bc19 --- /dev/null +++ b/test/tests/921218-1.c @@ -0,0 +1,11 @@ +f() +{ + return (unsigned char)("\377"[0]); +} + +main() +{ + if (f() != (unsigned char)(0377)) + abort(); + exit (0); +} diff --git a/test/tests/921218-2.c b/test/tests/921218-2.c new file mode 100644 index 0000000..b5d57e9 --- /dev/null +++ b/test/tests/921218-2.c @@ -0,0 +1,17 @@ +f() +{ + long l2; + unsigned short us; + unsigned long ul; + short s2; + + ul = us = l2 = s2 = -1; + return ul; +} + +main() +{ + if (f()!=(unsigned short)-1) + abort(); + exit(0); +} diff --git a/test/tests/930106-1.c b/test/tests/930106-1.c new file mode 100644 index 0000000..8081f92 --- /dev/null +++ b/test/tests/930106-1.c @@ -0,0 +1,27 @@ +#if defined (STACK_SIZE) +#define DUMMY_SIZE 9 +#else +#define DUMMY_SIZE 399999 +#endif + +double g() +{ + return 1.0; +} + +f() +{ + char dummy[DUMMY_SIZE]; + double f1, f2, f3; + f1 = g(); + f2 = g(); + f3 = g(); + return f1 + f2 + f3; +} + +main() +{ + if (f() != 3.0) + abort(); + exit(0); +} diff --git a/test/tests/930111-1.c b/test/tests/930111-1.c new file mode 100644 index 0000000..e908f14 --- /dev/null +++ b/test/tests/930111-1.c @@ -0,0 +1,22 @@ +main() +{ + if (wwrite((long long) 0) != 123) + abort(); + exit(0); +} + +int +wwrite(long long i) +{ + switch(i) + { + case 3: + case 10: + case 23: + case 28: + case 47: + return 0; + default: + return 123; + } +} diff --git a/test/tests/930123-1.c b/test/tests/930123-1.c new file mode 100644 index 0000000..7365bae --- /dev/null +++ b/test/tests/930123-1.c @@ -0,0 +1,16 @@ +f(int *x) +{ + *x = 0; +} + +main() +{ + int s, c, x; + char a[] = "c"; + + f(&s); + a[c = 0] = s == 0 ? (x=1, 'a') : (x=2, 'b'); + if (a[c] != 'a') + abort(); + exit (0); +} diff --git a/test/tests/930126-1.c b/test/tests/930126-1.c new file mode 100644 index 0000000..6de368d --- /dev/null +++ b/test/tests/930126-1.c @@ -0,0 +1,20 @@ +struct s { + unsigned long a:4, b:16; +}; + +struct s +f(struct s x) +{ + x.b = 0xcdef; + return x; +} + +main() +{ + static struct s i; + i.a = 12; + i = f(i); + if (i.a != 12 || i.b != 0xcdef) + abort(); + exit(0); +} diff --git a/test/tests/930208-1.c b/test/tests/930208-1.c new file mode 100644 index 0000000..464b69d --- /dev/null +++ b/test/tests/930208-1.c @@ -0,0 +1,23 @@ +typedef union { + long l; + struct { char b3, b2, b1, b0; } c; +} T; + +f (T u) +{ + ++u.c.b0; + ++u.c.b3; + return (u.c.b1 != 2 || u.c.b2 != 2); +} + +main () +{ + T u; + u.c.b1 = 2; + u.c.b2 = 2; + u.c.b0 = ~0; + u.c.b3 = ~0; + if (f (u)) + abort(); + exit (0); +} diff --git a/test/tests/930408-1.c b/test/tests/930408-1.c new file mode 100644 index 0000000..42ffc09 --- /dev/null +++ b/test/tests/930408-1.c @@ -0,0 +1,27 @@ +typedef enum foo E; +enum foo { e0, e1 }; + +struct { + E eval; +} s; + +p() +{ + abort(); +} + +f() +{ + switch (s.eval) + { + case e0: + p(); + } +} + +main() +{ + s.eval = e1; + f(); + exit(0); +} diff --git a/test/tests/930429-1.c b/test/tests/930429-1.c new file mode 100644 index 0000000..656d928 --- /dev/null +++ b/test/tests/930429-1.c @@ -0,0 +1,14 @@ +char * +f (char *p) +{ + short x = *p++ << 16; + return p; +} + +main () +{ + char *p = ""; + if (f (p) != p + 1) + abort (); + exit (0); +} diff --git a/test/tests/930429-2.c b/test/tests/930429-2.c new file mode 100644 index 0000000..e52c8b4 --- /dev/null +++ b/test/tests/930429-2.c @@ -0,0 +1,14 @@ +int +f (b) +{ + return (b >> 1) > 0; +} + +main () +{ + if (!f (9)) + abort (); + if (f (-9)) + abort (); + exit (0); +} diff --git a/test/tests/930513-2.c b/test/tests/930513-2.c new file mode 100644 index 0000000..3731f62 --- /dev/null +++ b/test/tests/930513-2.c @@ -0,0 +1,27 @@ +sub3 (i) + const int *i; +{ +} + +eq (a, b) +{ + static int i = 0; + if (a != i) + abort (); + i++; +} + +main () +{ + int i; + + for (i = 0; i < 4; i++) + { + const int j = i; + int k; + sub3 (&j); + k = j; + eq (k, k); + } + exit (0); +} diff --git a/test/tests/930518-1.c b/test/tests/930518-1.c new file mode 100644 index 0000000..44bdf96 --- /dev/null +++ b/test/tests/930518-1.c @@ -0,0 +1,24 @@ +int bar = 0; + +f (p) + int *p; +{ + int foo = 2; + + while (foo > bar) + { + foo -= bar; + *p++ = foo; + bar = 1; + } +} + +main () +{ + int tab[2]; + tab[0] = tab[1] = 0; + f (tab); + if (tab[0] != 2 || tab[1] != 1) + abort (); + exit (0); +} diff --git a/test/tests/930526-1.c b/test/tests/930526-1.c new file mode 100644 index 0000000..bbf63c6 --- /dev/null +++ b/test/tests/930526-1.c @@ -0,0 +1,18 @@ +inline +f (x) +{ + int *(p[25]); + int m[25*7]; + int i; + + for (i = 0; i < 25; i++) + p[i] = m + x*i; + + p[1][0] = 0; +} + +main () +{ + f (7); + exit (0); +} diff --git a/test/tests/930527-1.c b/test/tests/930527-1.c new file mode 100644 index 0000000..fef34bf --- /dev/null +++ b/test/tests/930527-1.c @@ -0,0 +1,11 @@ +f (unsigned char x) +{ + return (0x50 | (x >> 4)) ^ 0xff; +} + +main () +{ + if (f (0) != 0xaf) + abort (); + exit (0); +} diff --git a/test/tests/930529-1.c b/test/tests/930529-1.c new file mode 100644 index 0000000..906338e --- /dev/null +++ b/test/tests/930529-1.c @@ -0,0 +1,45 @@ +dd (x,d) { return x / d; } + +main () +{ + int i; + for (i = -3; i <= 3; i++) + { + if (dd (i, 1) != i / 1) + abort (); + if (dd (i, 2) != i / 2) + abort (); + if (dd (i, 3) != i / 3) + abort (); + if (dd (i, 4) != i / 4) + abort (); + if (dd (i, 5) != i / 5) + abort (); + if (dd (i, 6) != i / 6) + abort (); + if (dd (i, 7) != i / 7) + abort (); + if (dd (i, 8) != i / 8) + abort (); + } + for (i = ((unsigned) ~0 >> 1) - 3; i <= ((unsigned) ~0 >> 1) + 3; i++) + { + if (dd (i, 1) != i / 1) + abort (); + if (dd (i, 2) != i / 2) + abort (); + if (dd (i, 3) != i / 3) + abort (); + if (dd (i, 4) != i / 4) + abort (); + if (dd (i, 5) != i / 5) + abort (); + if (dd (i, 6) != i / 6) + abort (); + if (dd (i, 7) != i / 7) + abort (); + if (dd (i, 8) != i / 8) + abort (); + } + exit (0); +} diff --git a/test/tests/930603-1.c b/test/tests/930603-1.c new file mode 100644 index 0000000..6a84de0 --- /dev/null +++ b/test/tests/930603-1.c @@ -0,0 +1,22 @@ +float fx (x) + float x; +{ + return 1.0 + 3.0 / (2.302585093 * x); +} + +main () +{ + float fx (), inita (), initc (), a, b, c; + a = inita (); + c = initc (); + f (); + b = fx (c) + a; + f (); + if (a != 3.0 || b < 4.3257 || b > 4.3258 || c != 4.0) + abort (); + exit (0); +} + +float inita () { return 3.0; } +float initc () { return 4.0; } +f () {} diff --git a/test/tests/930603-2.c b/test/tests/930603-2.c new file mode 100644 index 0000000..8cf06a2 --- /dev/null +++ b/test/tests/930603-2.c @@ -0,0 +1,19 @@ +int w[2][2]; + +f () +{ + int i, j; + + for (i = 0; i < 2; i++) + for (j = 0; j < 2; j++) + if (i == j) + w[i][j] = 1; +} + +main () +{ + f (); + if (w[0][0] != 1 || w[1][1] != 1 || w[1][0] != 0 || w[0][1] != 0) + abort (); + exit (0); +} diff --git a/test/tests/930603-3.c b/test/tests/930603-3.c new file mode 100644 index 0000000..22e5aed --- /dev/null +++ b/test/tests/930603-3.c @@ -0,0 +1,30 @@ +f (b, c) + unsigned char *b; + int c; +{ + unsigned long v = 0; + switch (c) + { + case 'd': + v = ((unsigned long)b[0] << 8) + b[1]; + v >>= 9; + break; + + case 'k': + v = b[3] >> 4; + break; + + default: + abort (); + } + + return v; +} +main () +{ + char buf[4]; + buf[0] = 170; buf[1] = 5; + if (f (buf, 'd') != 85) + abort (); + exit (0); +} diff --git a/test/tests/930608-1.c b/test/tests/930608-1.c new file mode 100644 index 0000000..004a440 --- /dev/null +++ b/test/tests/930608-1.c @@ -0,0 +1,11 @@ +double f (double a) {} +double (* const a[]) (double) = {&f}; + +main () +{ + double (*p) (); + p = &f; + if (p != a[0]) + abort (); + exit (0); +} diff --git a/test/tests/930614-1.c b/test/tests/930614-1.c new file mode 100644 index 0000000..7b20634 --- /dev/null +++ b/test/tests/930614-1.c @@ -0,0 +1,19 @@ +f (double *ty) +{ + *ty = -1.0; +} + +main () +{ + double foo[6]; + double tx = 0.0, ty, d; + + f (&ty); + + if (ty < 0) + ty = -ty; + d = (tx > ty) ? tx : ty; + if (ty != d) + abort (); + exit (0); +} diff --git a/test/tests/930614-2.c b/test/tests/930614-2.c new file mode 100644 index 0000000..ab83a7e --- /dev/null +++ b/test/tests/930614-2.c @@ -0,0 +1,20 @@ +main () +{ + int i, j, k, l; + float x[8][2][8][2]; + + for (i = 0; i < 8; i++) + for (j = i; j < 8; j++) + for (k = 0; k < 2; k++) + for (l = 0; l < 2; l++) + { + if ((i == j) && (k == l)) + x[i][k][j][l] = 0.8; + else + x[i][k][j][l] = 0.8; + if (x[i][k][j][l] < 0.0) + abort (); + } + + exit (0); +} diff --git a/test/tests/930621-1.c b/test/tests/930621-1.c new file mode 100644 index 0000000..4bb7cdb --- /dev/null +++ b/test/tests/930621-1.c @@ -0,0 +1,29 @@ +/* The bit-field below would have a problem if __INT_MAX__ is too + small. */ +#if __INT_MAX__ < 2147483647 +int +main (void) +{ + exit (0); +} +#else +f () +{ + struct { + int x : 18; + int y : 14; + } foo; + + foo.x = 10; + foo.y = 20; + + return foo.y; +} + +main () +{ + if (f () != 20) + abort (); + exit (0); +} +#endif diff --git a/test/tests/930622-1.c b/test/tests/930622-1.c new file mode 100644 index 0000000..d733e13 --- /dev/null +++ b/test/tests/930622-1.c @@ -0,0 +1,22 @@ +int a = 1, b; + +g () { return 0; } +h (x) {} + +f () +{ + if (g () == -1) + return 0; + a = g (); + if (b >= 1) + h (a); + return 0; +} + +main () +{ + f (); + if (a != 0) + abort (); + exit (0); +} diff --git a/test/tests/930622-2.c b/test/tests/930622-2.c new file mode 100644 index 0000000..d049b00 --- /dev/null +++ b/test/tests/930622-2.c @@ -0,0 +1,24 @@ +long double +ll_to_ld (long long n) +{ + return n; +} + +long long +ld_to_ll (long double n) +{ + return n; +} + +main () +{ + long long n; + + if (ll_to_ld (10LL) != 10.0) + abort (); + + if (ld_to_ll (10.0) != 10) + abort (); + + exit (0); +} diff --git a/test/tests/930628-1.c b/test/tests/930628-1.c new file mode 100644 index 0000000..58c612d --- /dev/null +++ b/test/tests/930628-1.c @@ -0,0 +1,27 @@ +f (double x[2], double y[2]) +{ + if (x == y) + abort (); +} + +main () +{ + struct { int f[3]; double x[1][2]; } tp[4][2]; + int i, j, ki, kj, mi, mj; + float bdm[4][2][4][2]; + + for (i = 0; i < 4; i++) + for (j = i; j < 4; j++) + for (ki = 0; ki < 2; ki++) + for (kj = 0; kj < 2; kj++) + if ((j == i) && (ki == kj)) + bdm[i][ki][j][kj] = 1000.0; + else + { + for (mi = 0; mi < 1; mi++) + for (mj = 0; mj < 1; mj++) + f (tp[i][ki].x[mi], tp[j][kj].x[mj]); + bdm[i][ki][j][kj] = 1000.0; + } + exit (0); +} diff --git a/test/tests/930630-1.c b/test/tests/930630-1.c new file mode 100644 index 0000000..38ad1fd --- /dev/null +++ b/test/tests/930630-1.c @@ -0,0 +1,29 @@ +/* The bit-field below would have a problem if __INT_MAX__ is too + small. */ +#if __INT_MAX__ < 2147483647 +int +main (void) +{ + exit (0); +} +#else +main () +{ + struct + { + signed int bf0:17; + signed int bf1:7; + } bf; + + bf.bf1 = 7; + f (bf.bf1); + exit (0); +} + +f (x) + int x; +{ + if (x != 7) + abort (); +} +#endif diff --git a/test/tests/930702-1.c b/test/tests/930702-1.c new file mode 100644 index 0000000..8828a70 --- /dev/null +++ b/test/tests/930702-1.c @@ -0,0 +1,14 @@ +fp (double a, int b) +{ + if (a != 33 || b != 11) + abort (); +} + +main () +{ + int (*f) (double, int) = fp; + + fp (33, 11); + f (33, 11); + exit (0); +} diff --git a/test/tests/930713-1.c b/test/tests/930713-1.c new file mode 100644 index 0000000..6b4d5ab --- /dev/null +++ b/test/tests/930713-1.c @@ -0,0 +1,23 @@ +typedef struct +{ + char x; +} T; + +T +f (s1) + T s1; +{ + T s1a; + s1a.x = 17; + return s1a; +} + +main () +{ + T s1a, s1b; + s1a.x = 13; + s1b = f (s1a); + if (s1a.x != 13 || s1b.x != 17) + abort (); + exit (0); +} diff --git a/test/tests/930718-1.c b/test/tests/930718-1.c new file mode 100644 index 0000000..a8eacc2 --- /dev/null +++ b/test/tests/930718-1.c @@ -0,0 +1,34 @@ +typedef struct rtx_def +{ + int f1 :1; + int f2 :1; +} *rtx; + +static rtx +f (orig) + register rtx orig; +{ + if (orig->f1 || orig->f2) + return orig; + orig->f2 = 1; + return orig; +} + +void +f2 () +{ + abort (); +} + +main () +{ + struct rtx_def foo; + rtx bar; + + foo.f1 = 1; + foo.f2 = 0; + bar = f (&foo); + if (bar != &foo || bar->f2 != 0) + abort (); + exit (0); +} diff --git a/test/tests/930719-1.c b/test/tests/930719-1.c new file mode 100644 index 0000000..c6557ef --- /dev/null +++ b/test/tests/930719-1.c @@ -0,0 +1,23 @@ +int +f (foo, bar, com) +{ + unsigned align; + if (foo) + return 0; + while (1) + { + switch (bar) + { + case 1: + if (com != 0) + return align; + *(char *) 0 = 0; + } + } +} + +main () +{ + f (0, 1, 1); + exit (0); +} diff --git a/test/tests/930725-1.c b/test/tests/930725-1.c new file mode 100644 index 0000000..3bd738c --- /dev/null +++ b/test/tests/930725-1.c @@ -0,0 +1,21 @@ +int v; + +char * +g () +{ + return ""; +} + +char * +f () +{ + return (v == 0 ? g () : "abc"); +} + +main () +{ + v = 1; + if (!strcmp (f (), "abc")) + exit (0); + abort(); +} diff --git a/test/tests/930818-1.c b/test/tests/930818-1.c new file mode 100644 index 0000000..710e3ce --- /dev/null +++ b/test/tests/930818-1.c @@ -0,0 +1,15 @@ +static double one = 1.0; + +f() +{ + int colinear; + colinear = (one == 0.0); + if (colinear) + abort (); + return colinear; +} +main() +{ + if (f()) abort(); + exit (0); +} diff --git a/test/tests/930916-1.c b/test/tests/930916-1.c new file mode 100644 index 0000000..6302614 --- /dev/null +++ b/test/tests/930916-1.c @@ -0,0 +1,13 @@ +f (n) + unsigned n; +{ + if ((int) n >= 0) + abort (); +} + +main () +{ + unsigned x = ~0; + f (x); + exit (0); +} diff --git a/test/tests/930921-1.c b/test/tests/930921-1.c new file mode 100644 index 0000000..306eac4 --- /dev/null +++ b/test/tests/930921-1.c @@ -0,0 +1,15 @@ +f (x) + unsigned x; +{ + return (unsigned) (((unsigned long long) x * 0xAAAB) >> 16) >> 1; +} + +main () +{ + unsigned i; + + for (i = 0; i < 10000; i++) + if (f (i) != i / 3) + abort (); + exit (0); +} diff --git a/test/tests/930929-1.c b/test/tests/930929-1.c new file mode 100644 index 0000000..31f6954 --- /dev/null +++ b/test/tests/930929-1.c @@ -0,0 +1,36 @@ +sub1 (i) + int i; +{ + return i - (5 - i); +} + +sub2 (i) + int i; +{ + return i + (5 + i); +} + +sub3 (i) + int i; +{ + return i - (5 + i); +} + +sub4 (i) + int i; +{ + return i + (5 - i); +} + +main() +{ + if (sub1 (20) != 35) + abort (); + if (sub2 (20) != 45) + abort (); + if (sub3 (20) != -5) + abort (); + if (sub4 (20) != 5) + abort (); + exit (0); +} diff --git a/test/tests/930930-1.c b/test/tests/930930-1.c new file mode 100644 index 0000000..68fdbbf --- /dev/null +++ b/test/tests/930930-1.c @@ -0,0 +1,35 @@ +long *wm_TR; +long *wm_HB; +long *wm_SPB; + +long mem[100]; + +f (mr_TR, mr_SPB, mr_HB, reg1, reg2) + long *mr_TR; + long *mr_SPB; + long *mr_HB; + long *reg1; + long *reg2; +{ + long *x = mr_TR; + + for (;;) + { + if (reg1 < reg2) + goto out; + if ((long *) *reg1 < mr_HB && (long *) *reg1 >= mr_SPB) + *--mr_TR = *reg1; + reg1--; + } + out: + + if (x != mr_TR) + abort (); +} + +main () +{ + mem[99] = (long) mem; + f (mem + 100, mem + 6, mem + 8, mem + 99, mem + 99); + exit (0); +} diff --git a/test/tests/930930-2.c b/test/tests/930930-2.c new file mode 100644 index 0000000..eb34d11 --- /dev/null +++ b/test/tests/930930-2.c @@ -0,0 +1,30 @@ +int +test_endianness() +{ + union doubleword + { + double d; + unsigned long u[2]; + } dw; + dw.d = 10; + return dw.u[0] != 0 ? 1 : 0; +} + +int +test_endianness_vol() +{ + union doubleword + { + volatile double d; + volatile long u[2]; + } dw; + dw.d = 10; + return dw.u[0] != 0 ? 1 : 0; +} + +main () +{ + if (test_endianness () != test_endianness_vol ()) + abort (); + exit (0); +} diff --git a/test/tests/931002-1.c b/test/tests/931002-1.c new file mode 100644 index 0000000..8018f79 --- /dev/null +++ b/test/tests/931002-1.c @@ -0,0 +1,28 @@ +f (void (*func) ()) +{ + func (); +} + + void t0 () + { + } + + void t1 () + { + f (t0); + } + + void t2 () + { + t1 (); + } +main () +{ +#ifndef NO_TRAMPOLINES + + t1 (); + t1 (); + t2 (); +#endif + exit (0); +} diff --git a/test/tests/931004-1.c b/test/tests/931004-1.c new file mode 100644 index 0000000..9c89afd --- /dev/null +++ b/test/tests/931004-1.c @@ -0,0 +1,30 @@ +struct tiny +{ + int c; +}; + +f (int n, struct tiny x, struct tiny y, struct tiny z, long l) +{ + if (x.c != 10) + abort(); + + if (y.c != 11) + abort(); + + if (z.c != 12) + abort(); + + if (l != 123) + abort (); +} + +main () +{ + struct tiny x[3]; + x[0].c = 10; + x[1].c = 11; + x[2].c = 12; + f (3, x[0], x[1], x[2], (long) 123); + exit(0); +} + diff --git a/test/tests/931004-10.c b/test/tests/931004-10.c new file mode 100644 index 0000000..cf0125d --- /dev/null +++ b/test/tests/931004-10.c @@ -0,0 +1,44 @@ +#include + +struct tiny +{ + char c; + char d; +}; + +f (int n, ...) +{ + struct tiny x; + int i; + + va_list ap; + va_start (ap,n); + for (i = 0; i < n; i++) + { + x = va_arg (ap,struct tiny); + if (x.c != i + 10) + abort(); + if (x.d != i + 20) + abort(); + } + { + long x = va_arg (ap, long); + if (x != 123) + abort(); + } + va_end (ap); +} + +main () +{ + struct tiny x[3]; + x[0].c = 10; + x[1].c = 11; + x[2].c = 12; + x[0].d = 20; + x[1].d = 21; + x[2].d = 22; + f (3, x[0], x[1], x[2], (long) 123); + exit(0); +} + diff --git a/test/tests/931004-11.c b/test/tests/931004-11.c new file mode 100644 index 0000000..b604702 --- /dev/null +++ b/test/tests/931004-11.c @@ -0,0 +1,50 @@ +struct tiny +{ + char c; + char d; + char e; +}; + +f (int n, struct tiny x, struct tiny y, struct tiny z, long l) +{ + if (x.c != 10) + abort(); + if (x.d != 20) + abort(); + if (x.e != 30) + abort(); + + if (y.c != 11) + abort(); + if (y.d != 21) + abort(); + if (y.e != 31) + abort(); + + if (z.c != 12) + abort(); + if (z.d != 22) + abort(); + if (z.e != 32) + abort(); + + if (l != 123) + abort (); +} + +main () +{ + struct tiny x[3]; + x[0].c = 10; + x[1].c = 11; + x[2].c = 12; + x[0].d = 20; + x[1].d = 21; + x[2].d = 22; + x[0].e = 30; + x[1].e = 31; + x[2].e = 32; + f (3, x[0], x[1], x[2], (long) 123); + exit(0); +} + diff --git a/test/tests/931004-12.c b/test/tests/931004-12.c new file mode 100644 index 0000000..d3fc71e --- /dev/null +++ b/test/tests/931004-12.c @@ -0,0 +1,50 @@ +#include + +struct tiny +{ + char c; + char d; + char e; +}; + +f (int n, ...) +{ + struct tiny x; + int i; + + va_list ap; + va_start (ap,n); + for (i = 0; i < n; i++) + { + x = va_arg (ap,struct tiny); + if (x.c != i + 10) + abort(); + if (x.d != i + 20) + abort(); + if (x.e != i + 30) + abort(); + } + { + long x = va_arg (ap, long); + if (x != 123) + abort(); + } + va_end (ap); +} + +main () +{ + struct tiny x[3]; + x[0].c = 10; + x[1].c = 11; + x[2].c = 12; + x[0].d = 20; + x[1].d = 21; + x[2].d = 22; + x[0].e = 30; + x[1].e = 31; + x[2].e = 32; + f (3, x[0], x[1], x[2], (long) 123); + exit(0); +} + diff --git a/test/tests/931004-13.c b/test/tests/931004-13.c new file mode 100644 index 0000000..60422af --- /dev/null +++ b/test/tests/931004-13.c @@ -0,0 +1,60 @@ +struct tiny +{ + char c; + char d; + char e; + char f; +}; + +f (int n, struct tiny x, struct tiny y, struct tiny z, long l) +{ + if (x.c != 10) + abort(); + if (x.d != 20) + abort(); + if (x.e != 30) + abort(); + if (x.f != 40) + abort(); + + if (y.c != 11) + abort(); + if (y.d != 21) + abort(); + if (y.e != 31) + abort(); + if (y.f != 41) + abort(); + + if (z.c != 12) + abort(); + if (z.d != 22) + abort(); + if (z.e != 32) + abort(); + if (z.f != 42) + abort(); + + if (l != 123) + abort (); +} + +main () +{ + struct tiny x[3]; + x[0].c = 10; + x[1].c = 11; + x[2].c = 12; + x[0].d = 20; + x[1].d = 21; + x[2].d = 22; + x[0].e = 30; + x[1].e = 31; + x[2].e = 32; + x[0].f = 40; + x[1].f = 41; + x[2].f = 42; + f (3, x[0], x[1], x[2], (long) 123); + exit(0); +} + diff --git a/test/tests/931004-14.c b/test/tests/931004-14.c new file mode 100644 index 0000000..55c71bb --- /dev/null +++ b/test/tests/931004-14.c @@ -0,0 +1,56 @@ +#include + +struct tiny +{ + char c; + char d; + char e; + char f; +}; + +f (int n, ...) +{ + struct tiny x; + int i; + + va_list ap; + va_start (ap,n); + for (i = 0; i < n; i++) + { + x = va_arg (ap,struct tiny); + if (x.c != i + 10) + abort(); + if (x.d != i + 20) + abort(); + if (x.e != i + 30) + abort(); + if (x.f != i + 40) + abort(); + } + { + long x = va_arg (ap, long); + if (x != 123) + abort(); + } + va_end (ap); +} + +main () +{ + struct tiny x[3]; + x[0].c = 10; + x[1].c = 11; + x[2].c = 12; + x[0].d = 20; + x[1].d = 21; + x[2].d = 22; + x[0].e = 30; + x[1].e = 31; + x[2].e = 32; + x[0].f = 40; + x[1].f = 41; + x[2].f = 42; + f (3, x[0], x[1], x[2], (long) 123); + exit(0); +} + diff --git a/test/tests/931004-2.c b/test/tests/931004-2.c new file mode 100644 index 0000000..83bdea6 --- /dev/null +++ b/test/tests/931004-2.c @@ -0,0 +1,38 @@ +#include + +struct tiny +{ + int c; +}; + +f (int n, ...) +{ + struct tiny x; + int i; + + va_list ap; + va_start (ap,n); + for (i = 0; i < n; i++) + { + x = va_arg (ap,struct tiny); + if (x.c != i + 10) + abort(); + } + { + long x = va_arg (ap, long); + if (x != 123) + abort(); + } + va_end (ap); +} + +main () +{ + struct tiny x[3]; + x[0].c = 10; + x[1].c = 11; + x[2].c = 12; + f (3, x[0], x[1], x[2], (long) 123); + exit(0); +} + diff --git a/test/tests/931004-3.c b/test/tests/931004-3.c new file mode 100644 index 0000000..1e7a0fd --- /dev/null +++ b/test/tests/931004-3.c @@ -0,0 +1,30 @@ +struct tiny +{ + short c; +}; + +f (int n, struct tiny x, struct tiny y, struct tiny z, long l) +{ + if (x.c != 10) + abort(); + + if (y.c != 11) + abort(); + + if (z.c != 12) + abort(); + + if (l != 123) + abort (); +} + +main () +{ + struct tiny x[3]; + x[0].c = 10; + x[1].c = 11; + x[2].c = 12; + f (3, x[0], x[1], x[2], (long) 123); + exit(0); +} + diff --git a/test/tests/931004-4.c b/test/tests/931004-4.c new file mode 100644 index 0000000..f0d2331 --- /dev/null +++ b/test/tests/931004-4.c @@ -0,0 +1,38 @@ +#include + +struct tiny +{ + short c; +}; + +f (int n, ...) +{ + struct tiny x; + int i; + + va_list ap; + va_start (ap,n); + for (i = 0; i < n; i++) + { + x = va_arg (ap,struct tiny); + if (x.c != i + 10) + abort(); + } + { + long x = va_arg (ap, long); + if (x != 123) + abort(); + } + va_end (ap); +} + +main () +{ + struct tiny x[3]; + x[0].c = 10; + x[1].c = 11; + x[2].c = 12; + f (3, x[0], x[1], x[2], (long) 123); + exit(0); +} + diff --git a/test/tests/931004-5.c b/test/tests/931004-5.c new file mode 100644 index 0000000..9bef779 --- /dev/null +++ b/test/tests/931004-5.c @@ -0,0 +1,40 @@ +struct tiny +{ + short c; + short d; +}; + +f (int n, struct tiny x, struct tiny y, struct tiny z, long l) +{ + if (x.c != 10) + abort(); + if (x.d != 20) + abort(); + + if (y.c != 11) + abort(); + if (y.d != 21) + abort(); + + if (z.c != 12) + abort(); + if (z.d != 22) + abort(); + + if (l != 123) + abort (); +} + +main () +{ + struct tiny x[3]; + x[0].c = 10; + x[1].c = 11; + x[2].c = 12; + x[0].d = 20; + x[1].d = 21; + x[2].d = 22; + f (3, x[0], x[1], x[2], (long) 123); + exit(0); +} + diff --git a/test/tests/931004-6.c b/test/tests/931004-6.c new file mode 100644 index 0000000..6dca48f --- /dev/null +++ b/test/tests/931004-6.c @@ -0,0 +1,44 @@ +#include + +struct tiny +{ + short c; + short d; +}; + +f (int n, ...) +{ + struct tiny x; + int i; + + va_list ap; + va_start (ap,n); + for (i = 0; i < n; i++) + { + x = va_arg (ap,struct tiny); + if (x.c != i + 10) + abort(); + if (x.d != i + 20) + abort(); + } + { + long x = va_arg (ap, long); + if (x != 123) + abort(); + } + va_end (ap); +} + +main () +{ + struct tiny x[3]; + x[0].c = 10; + x[1].c = 11; + x[2].c = 12; + x[0].d = 20; + x[1].d = 21; + x[2].d = 22; + f (3, x[0], x[1], x[2], (long) 123); + exit(0); +} + diff --git a/test/tests/931004-7.c b/test/tests/931004-7.c new file mode 100644 index 0000000..8ab2fcb --- /dev/null +++ b/test/tests/931004-7.c @@ -0,0 +1,30 @@ +struct tiny +{ + char c; +}; + +f (int n, struct tiny x, struct tiny y, struct tiny z, long l) +{ + if (x.c != 10) + abort(); + + if (y.c != 11) + abort(); + + if (z.c != 12) + abort(); + + if (l != 123) + abort (); +} + +main () +{ + struct tiny x[3]; + x[0].c = 10; + x[1].c = 11; + x[2].c = 12; + f (3, x[0], x[1], x[2], (long) 123); + exit(0); +} + diff --git a/test/tests/931004-8.c b/test/tests/931004-8.c new file mode 100644 index 0000000..5fb97f6 --- /dev/null +++ b/test/tests/931004-8.c @@ -0,0 +1,38 @@ +#include + +struct tiny +{ + char c; +}; + +f (int n, ...) +{ + struct tiny x; + int i; + + va_list ap; + va_start (ap,n); + for (i = 0; i < n; i++) + { + x = va_arg (ap,struct tiny); + if (x.c != i + 10) + abort(); + } + { + long x = va_arg (ap, long); + if (x != 123) + abort(); + } + va_end (ap); +} + +main () +{ + struct tiny x[3]; + x[0].c = 10; + x[1].c = 11; + x[2].c = 12; + f (3, x[0], x[1], x[2], (long) 123); + exit(0); +} + diff --git a/test/tests/931004-9.c b/test/tests/931004-9.c new file mode 100644 index 0000000..07247f7 --- /dev/null +++ b/test/tests/931004-9.c @@ -0,0 +1,40 @@ +struct tiny +{ + char c; + char d; +}; + +f (int n, struct tiny x, struct tiny y, struct tiny z, long l) +{ + if (x.c != 10) + abort(); + if (x.d != 20) + abort(); + + if (y.c != 11) + abort(); + if (y.d != 21) + abort(); + + if (z.c != 12) + abort(); + if (z.d != 22) + abort(); + + if (l != 123) + abort (); +} + +main () +{ + struct tiny x[3]; + x[0].c = 10; + x[1].c = 11; + x[2].c = 12; + x[0].d = 20; + x[1].d = 21; + x[2].d = 22; + f (3, x[0], x[1], x[2], (long) 123); + exit(0); +} + diff --git a/test/tests/931005-1.c b/test/tests/931005-1.c new file mode 100644 index 0000000..5a7e031 --- /dev/null +++ b/test/tests/931005-1.c @@ -0,0 +1,23 @@ +typedef struct +{ + char x; +} T; + +T +f (s1) + T s1; +{ + T s1a; + s1a.x = s1.x; + return s1a; +} + +main () +{ + T s1a, s1b; + s1a.x = 100; + s1b = f (s1a); + if (s1b.x != 100) + abort (); + exit (0); +} diff --git a/test/tests/931009-1.c b/test/tests/931009-1.c new file mode 100644 index 0000000..2922280 --- /dev/null +++ b/test/tests/931009-1.c @@ -0,0 +1,26 @@ +main () +{ + f (); + exit (0); +} + +static +g (out, size, lo, hi) + int *out, size, lo, hi; +{ + int j; + + for (j = 0; j < size; j++) + out[j] = j * (hi - lo); +} + + +f () +{ + int a[2]; + + g (a, 2, 0, 1); + + if (a[0] != 0 || a[1] != 1) + abort (); +} diff --git a/test/tests/931012-1.c b/test/tests/931012-1.c new file mode 100644 index 0000000..d9c958d --- /dev/null +++ b/test/tests/931012-1.c @@ -0,0 +1,13 @@ +f (int b, int c) +{ + if (b != 0 && b != 1 && c != 0) + b = 0; + return b; +} + +main () +{ + if (!f (1, 2)) + abort(); + exit(0); +} diff --git a/test/tests/931017-1.c b/test/tests/931017-1.c new file mode 100644 index 0000000..5917bd9 --- /dev/null +++ b/test/tests/931017-1.c @@ -0,0 +1,54 @@ +int v; + +main () +{ + f (); + exit (0); +} + +h1 () +{ + return 0; +} + +h2 (e) + int *e; +{ + if (e != &v) + abort (); + return 0; +} + +g (c) + char *c; +{ + int i; + int b; + + do + { + i = h1 (); + if (i == -1) + return 0; + else if (i == 1) + h1 (); + } + while (i == 1); + + do + b = h2 (&v); + while (i == 5); + + if (i != 2) + return b; + *c = 'a'; + + return 0; +} + + +f () +{ + char c; + g (&c); +} diff --git a/test/tests/931018-1.c b/test/tests/931018-1.c new file mode 100644 index 0000000..7627985 --- /dev/null +++ b/test/tests/931018-1.c @@ -0,0 +1,18 @@ +unsigned int a[0x1000]; +extern const unsigned long v; + +main () +{ + f (v); + f (v); + exit (0); +} + +f (a) + unsigned long a; +{ + if (a != 0xdeadL) + abort(); +} + +const unsigned long v = 0xdeadL; diff --git a/test/tests/931031-1.c b/test/tests/931031-1.c new file mode 100644 index 0000000..e9ce337 --- /dev/null +++ b/test/tests/931031-1.c @@ -0,0 +1,34 @@ +/* The bit-field below would have a problem if __INT_MAX__ is too + small. */ +#if __INT_MAX__ < 2147483647 +int +main (void) +{ + exit (0); +} +#else +struct foo +{ + unsigned y:1; + unsigned x:32; +}; + +int +f (x) + struct foo x; +{ + int t = x.x; + if (t < 0) + return 1; + return t+1; +} + +main () +{ + struct foo x; + x.x = -1; + if (f (x) == 0) + abort (); + exit (0); +} +#endif diff --git a/test/tests/931102-1.c b/test/tests/931102-1.c new file mode 100644 index 0000000..489e7eb --- /dev/null +++ b/test/tests/931102-1.c @@ -0,0 +1,30 @@ +typedef union +{ + struct + { + char h, l; + } b; +} T; + +f (x) + int x; +{ + int num = 0; + T reg; + + reg.b.l = x; + while ((reg.b.l & 1) == 0) + { + num++; + reg.b.l >>= 1; + } + return num; +} + +main () +{ + if (f (2) != 1) + abort (); + exit (0); +} + diff --git a/test/tests/931102-2.c b/test/tests/931102-2.c new file mode 100644 index 0000000..6fc735c --- /dev/null +++ b/test/tests/931102-2.c @@ -0,0 +1,31 @@ +typedef union +{ + long align; + struct + { + short h, l; + } b; +} T; + +f (x) + int x; +{ + int num = 0; + T reg; + + reg.b.l = x; + while ((reg.b.l & 1) == 0) + { + num++; + reg.b.l >>= 1; + } + return num; +} + +main () +{ + if (f (2) != 1) + abort (); + exit (0); +} + diff --git a/test/tests/931110-1.c b/test/tests/931110-1.c new file mode 100644 index 0000000..5b33b26 --- /dev/null +++ b/test/tests/931110-1.c @@ -0,0 +1,18 @@ +typedef struct +{ + short f:3, g:3, h:10; +} small; + +struct +{ + int i; + small s[10]; +} x; + +main () +{ + int i; + for (i = 0; i < 10; i++) + x.s[i].f = 0; + exit (0); +} diff --git a/test/tests/931110-2.c b/test/tests/931110-2.c new file mode 100644 index 0000000..586615b --- /dev/null +++ b/test/tests/931110-2.c @@ -0,0 +1,12 @@ +main () +{ + static int a[] = {3, 4}; + register int *b; + int c; + + b = a; + c = *b++ % 8; + if (c != 3) + abort (); + exit (0); +} diff --git a/test/tests/931208-1.c b/test/tests/931208-1.c new file mode 100644 index 0000000..ee2bc9f --- /dev/null +++ b/test/tests/931208-1.c @@ -0,0 +1,14 @@ +f () +{ + unsigned long x, y = 1; + + x = ((y * 8192) - 216) / 16; + return x; +} + +main () +{ + if (f () != 498) + abort (); + exit (0); +} diff --git a/test/tests/931228-1.c b/test/tests/931228-1.c new file mode 100644 index 0000000..dcd3b65 --- /dev/null +++ b/test/tests/931228-1.c @@ -0,0 +1,15 @@ +f (x) +{ + x &= 010000; + x &= 007777; + x ^= 017777; + x &= 017770; + return x; +} + +main () +{ + if (f (-1) != 017770) + abort (); + exit (0); +} diff --git a/test/tests/940115-1.c b/test/tests/940115-1.c new file mode 100644 index 0000000..d0fac90 --- /dev/null +++ b/test/tests/940115-1.c @@ -0,0 +1,13 @@ +f (cp, end) + char *cp; + char *end; +{ + return (cp < end); +} + +main () +{ + if (! f ((char *) 0, (char *) 1)) + abort(); + exit (0); +} diff --git a/test/tests/940122-1.c b/test/tests/940122-1.c new file mode 100644 index 0000000..9dbf6ae --- /dev/null +++ b/test/tests/940122-1.c @@ -0,0 +1,21 @@ +char *a = 0; +char *b = 0; + +g (x) + int x; +{ + if ((!!a) != (!!b)) + abort (); +} + +f (x) + int x; +{ + g (x * x); +} + +main () +{ + f (100); + exit (0); +} diff --git a/test/tests/941014-1.c b/test/tests/941014-1.c new file mode 100644 index 0000000..98db917 --- /dev/null +++ b/test/tests/941014-1.c @@ -0,0 +1,15 @@ +int f (int a, int b) { } + +main () +{ + unsigned long addr1; + unsigned long addr2; + + addr1 = (unsigned long) &f; + addr1 += 5; + addr2 = 5 + (unsigned long) &f; + + if (addr1 != addr2) + abort (); + exit (0); +} diff --git a/test/tests/941015-1.c b/test/tests/941015-1.c new file mode 100644 index 0000000..5381072 --- /dev/null +++ b/test/tests/941015-1.c @@ -0,0 +1,35 @@ +int +foo1 (value) + long long value; +{ + register const long long constant = 0xc0008000LL; + + if (value < constant) + return 1; + else + return 2; +} + +int +foo2 (value) + unsigned long long value; +{ + register const unsigned long long constant = 0xc0008000LL; + + if (value < constant) + return 1; + else + return 2; +} + +main () +{ + unsigned long long value = 0xc0000001LL; + int x, y; + + x = foo1 (value); + y = foo2 (value); + if (x != y || x != 1) + abort (); + exit (0); +} diff --git a/test/tests/941021-1.c b/test/tests/941021-1.c new file mode 100644 index 0000000..9fc1cfa --- /dev/null +++ b/test/tests/941021-1.c @@ -0,0 +1,20 @@ +double glob_dbl; + +f (pdbl, value) + double *pdbl; + double value; +{ + if (pdbl == 0) + pdbl = &glob_dbl; + + *pdbl = value; +} + +main () +{ + f ((void *) 0, 55.1); + + if (glob_dbl != 55.1) + abort (); + exit (0); +} diff --git a/test/tests/941025-1.c b/test/tests/941025-1.c new file mode 100644 index 0000000..a4af572 --- /dev/null +++ b/test/tests/941025-1.c @@ -0,0 +1,12 @@ +long f (x, y) + long x,y; +{ + return (x > 1) ? y : (y & 1); +} + +main () +{ + if (f (2L, 0xdcdeL) != 0xdcdeL) + abort (); + exit (0); +} diff --git a/test/tests/941031-1.c b/test/tests/941031-1.c new file mode 100644 index 0000000..134f966 --- /dev/null +++ b/test/tests/941031-1.c @@ -0,0 +1,27 @@ +typedef long mpt; + +int +f (mpt us, mpt vs) +{ + long aus; + long avs; + + aus = us >= 0 ? us : -us; + avs = vs >= 0 ? vs : -vs; + + if (aus < avs) + { + long t = aus; + aus = avs; + avs = aus; + } + + return avs; +} + +main () +{ + if (f ((mpt) 3, (mpt) 17) != 17) + abort (); + exit (0); +} diff --git a/test/tests/941101-1.c b/test/tests/941101-1.c new file mode 100644 index 0000000..66b5f38 --- /dev/null +++ b/test/tests/941101-1.c @@ -0,0 +1,15 @@ +f () +{ + int var = 7; + + if ((var/7) == 1) + return var/7; + return 0; +} + +main () +{ + if (f () != 1) + abort (); + exit (0); +} diff --git a/test/tests/941110-1.c b/test/tests/941110-1.c new file mode 100644 index 0000000..b78256d --- /dev/null +++ b/test/tests/941110-1.c @@ -0,0 +1,16 @@ +f (const int x) +{ + int y = 0; + y = x ? y : -y; + { + const int *p = &x; + } + return y; +} + +main () +{ + if (f (0)) + abort (); + exit (0); +} diff --git a/test/tests/950221-1.c b/test/tests/950221-1.c new file mode 100644 index 0000000..07b7c87 --- /dev/null +++ b/test/tests/950221-1.c @@ -0,0 +1,57 @@ +struct parsefile +{ + long fd; + char *buf; +}; +struct parsefile basepf; +struct parsefile *parsefile = &basepf; +#ifdef STACK_SIZE +int filler[STACK_SIZE / (2*sizeof(int))]; +#else +int filler[0x3000]; +#endif +int el; + +char * +g1 (a, b) + int a; + int *b; +{ +} + +g2 (a) + long a; +{ + if (a != 0xdeadL) + abort (); + exit (0); +} + +f () +{ + register char *p, *q; + register int i; + register int something; + + if (parsefile->fd == 0 && el) + { + exit(5); + const char *rl_cp; + int len; + rl_cp = g1 (el, &len); + strcpy (p, rl_cp); + } + else + { + alabel: + i = g2 (parsefile->fd); + } +} + +main () +{ + el = 0; + parsefile->fd = 0xdeadL; + f (); + exit(42); +} diff --git a/test/tests/950322-1.c b/test/tests/950322-1.c new file mode 100644 index 0000000..28a1469 --- /dev/null +++ b/test/tests/950322-1.c @@ -0,0 +1,30 @@ +f (unsigned char *a) +{ + int i, j; + int x, y; + + j = a[1]; + i = a[0] - j; + if (i < 0) + { + x = 1; + y = -i; + } + else + { + x = 0; + y = i; + } + return x + y; +} + + +main () +{ + unsigned char a[2]; + a[0] = 8; + a[1] = 9; + if (f (a) != 2) + abort (); + exit (0); +} diff --git a/test/tests/950426-1.c b/test/tests/950426-1.c new file mode 100644 index 0000000..076032c --- /dev/null +++ b/test/tests/950426-1.c @@ -0,0 +1,32 @@ + +struct tag { + int m1; + char *m2[5]; +} s1, *p1; + +int i; + +main() +{ + s1.m1 = -1; + p1 = &s1; + + if ( func1( &p1->m1 ) == -1 ) + foo ("ok"); + else + abort (); + + i = 3; + s1.m2[3]= "123"; + + if ( strlen( (p1->m2[i])++ ) == 3 ) + foo ("ok"); + else + abort (); + + exit (0); +} + +func1(int *p) { return(*p); } + +foo (char *s) {} diff --git a/test/tests/950426-2.c b/test/tests/950426-2.c new file mode 100644 index 0000000..ddc7bce --- /dev/null +++ b/test/tests/950426-2.c @@ -0,0 +1,13 @@ +main() +{ + long long int i = -2147483647L - 1L; /* 0x80000000 */ + char ca = 1; + + if (i >> ca != -1073741824L) + abort (); + + if (i >> i / -2000000000L != -1073741824L) + abort (); + + exit (0); +} diff --git a/test/tests/950503-1.c b/test/tests/950503-1.c new file mode 100644 index 0000000..1c95b36 --- /dev/null +++ b/test/tests/950503-1.c @@ -0,0 +1,15 @@ +main () +{ + int tmp; + unsigned long long utmp1, utmp2; + + tmp = 16; + + utmp1 = (~((unsigned long long) 0)) >> tmp; + utmp2 = (~((unsigned long long) 0)) >> 16; + + if (utmp1 != utmp2) + abort (); + exit (0); +} + diff --git a/test/tests/950511-1.c b/test/tests/950511-1.c new file mode 100644 index 0000000..6584b0c --- /dev/null +++ b/test/tests/950511-1.c @@ -0,0 +1,11 @@ +main () +{ + unsigned long long xx; + unsigned long long *x = (unsigned long long *) &xx; + + *x = -3; + *x = *x * *x; + if (*x != 9) + abort (); + exit (0); +} diff --git a/test/tests/950512-1.c b/test/tests/950512-1.c new file mode 100644 index 0000000..8aa116d --- /dev/null +++ b/test/tests/950512-1.c @@ -0,0 +1,24 @@ +unsigned +f1 (x) +{ + return ((unsigned) (x != 0) - 3) / 2; +} + +unsigned long long +f2 (x) +{ + return ((unsigned long long) (x != 0) - 3) / 2; +} + +main () +{ + if (f1 (1) != (~(unsigned) 0) >> 1) + abort (); + if (f1 (0) != ((~(unsigned) 0) >> 1) - 1) + abort (); + if (f2 (1) != (~(unsigned long long) 0) >> 1) + abort (); + if (f2 (0) != ((~(unsigned long long) 0) >> 1) - 1) + abort (); + exit (0); +} diff --git a/test/tests/950605-1.c b/test/tests/950605-1.c new file mode 100644 index 0000000..d89a42e --- /dev/null +++ b/test/tests/950605-1.c @@ -0,0 +1,12 @@ +f (c) + unsigned char c; +{ + if (c != 0xFF) + abort (); +} + +main () +{ + f (-1); + exit (0); +} diff --git a/test/tests/950607-1.c b/test/tests/950607-1.c new file mode 100644 index 0000000..7b1503a --- /dev/null +++ b/test/tests/950607-1.c @@ -0,0 +1,9 @@ +main () +{ + struct { long status; } h; + + h.status = 0; + if (((h.status & 128) == 1) && ((h.status & 32) == 0)) + abort (); + exit (0); +} diff --git a/test/tests/950607-2.c b/test/tests/950607-2.c new file mode 100644 index 0000000..da18f73 --- /dev/null +++ b/test/tests/950607-2.c @@ -0,0 +1,41 @@ +typedef struct { + long int p_x, p_y; +} Point; + +int +f (Point basePt, Point pt1, Point pt2) +{ + long long vector; + + vector = + (long long) (pt1.p_x - basePt.p_x) * (long long) (pt2.p_y - basePt.p_y) - + (long long) (pt1.p_y - basePt.p_y) * (long long) (pt2.p_x - basePt.p_x); + + if (vector > (long long) 0) + return 0; + else if (vector < (long long) 0) + return 1; + else + return 2; +} + +main () +{ + Point b, p1, p2; + int answer; + + b.p_x = -23250; + b.p_y = 23250; + + p1.p_x = 23250; + p1.p_y = -23250; + + p2.p_x = -23250; + p2.p_y = -23250; + + answer = f (b, p1, p2); + + if (answer != 1) + abort (); + exit (0); +} diff --git a/test/tests/950612-1.c b/test/tests/950612-1.c new file mode 100644 index 0000000..f988527 --- /dev/null +++ b/test/tests/950612-1.c @@ -0,0 +1,48 @@ +unsigned int +f1 (int diff) +{ + return ((unsigned int) (diff < 0 ? -diff : diff)); +} + +unsigned int +f2 (unsigned int diff) +{ + return ((unsigned int) ((signed int) diff < 0 ? -diff : diff)); +} + +unsigned long long +f3 (long long diff) +{ + return ((unsigned long long) (diff < 0 ? -diff : diff)); +} + +unsigned long long +f4 (unsigned long long diff) +{ + return ((unsigned long long) ((signed long long) diff < 0 ? -diff : diff)); +} + +main () +{ + int i; + for (i = 0; i <= 10; i++) + { + if (f1 (i) != i) + abort (); + if (f1 (-i) != i) + abort (); + if (f2 (i) != i) + abort (); + if (f2 (-i) != i) + abort (); + if (f3 ((long long) i) != i) + abort (); + if (f3 ((long long) -i) != i) + abort (); + if (f4 ((long long) i) != i) + abort (); + if (f4 ((long long) -i) != i) + abort (); + } + exit (0); +} diff --git a/test/tests/950621-1.c b/test/tests/950621-1.c new file mode 100644 index 0000000..5fc5a90 --- /dev/null +++ b/test/tests/950621-1.c @@ -0,0 +1,20 @@ +struct s +{ + int a; + int b; + struct s *dummy; +}; + +f (struct s *sp) +{ + return sp && sp->a == -1 && sp->b == -1; +} + +main () +{ + struct s x; + x.a = x.b = -1; + if (f (&x) == 0) + abort (); + exit (0); +} diff --git a/test/tests/950628-1.c b/test/tests/950628-1.c new file mode 100644 index 0000000..e330ff5 --- /dev/null +++ b/test/tests/950628-1.c @@ -0,0 +1,31 @@ +typedef struct +{ + char hours, day, month; + short year; +} T; + +T g (void) +{ + T now; + + now.hours = 1; + now.day = 2; + now.month = 3; + now.year = 4; + return now; +} + +T f (void) +{ + T virk; + + virk = g (); + return virk; +} + +main () +{ + if (f ().hours != 1 || f ().day != 2 || f ().month != 3 || f ().year != 4) + abort (); + exit (0); +} diff --git a/test/tests/950704-1.c b/test/tests/950704-1.c new file mode 100644 index 0000000..190570b --- /dev/null +++ b/test/tests/950704-1.c @@ -0,0 +1,59 @@ +int errflag; + +long long +f (long long x, long long y) +{ + long long r; + + errflag = 0; + r = x + y; + if (x >= 0) + { + if ((y < 0) || (r >= 0)) + return r; + } + else + { + if ((y > 0) || (r < 0)) + return r; + } + errflag = 1; + return 0; +} + +main () +{ + f (0, 0); + if (errflag) + abort (); + + f (1, -1); + if (errflag) + abort (); + + f (-1, 1); + if (errflag) + abort (); + + f (0x80000000LL, 0x80000000LL); + if (!errflag) + abort (); + + f (0x80000000LL, -1LL); + if (!errflag) + abort (); + + f (0x7fffffffLL, 0x7fffffffLL); + if (!errflag) + abort (); + + f (0x7fffffffLL, 1LL); + if (!errflag) + abort (); + + f (0x7fffffffLL, 0x80000000LL); + if (errflag) + abort (); + + exit (0); +} diff --git a/test/tests/950706-1.c b/test/tests/950706-1.c new file mode 100644 index 0000000..2db1915 --- /dev/null +++ b/test/tests/950706-1.c @@ -0,0 +1,16 @@ +int +f (int n) +{ + return (n > 0) - (n < 0); +} + +main () +{ + if (f (-1) != -1) + abort (); + if (f (1) != 1) + abort (); + if (f (0) != 0) + abort (); + exit (0); +} diff --git a/test/tests/950710-1.c b/test/tests/950710-1.c new file mode 100644 index 0000000..26ff9b2 --- /dev/null +++ b/test/tests/950710-1.c @@ -0,0 +1,54 @@ +struct twelve +{ + int a; + int b; + int c; +}; + +struct pair +{ + int first; + int second; +}; + +struct pair +g () +{ + struct pair p; + return p; +} + +static void +f () +{ + int i; + for (i = 0; i < 1; i++) + { + int j; + for (j = 0; j < 1; j++) + { + if (0) + { + int k; + for (k = 0; k < 1; k++) + { + struct pair e = g (); + } + } + else + { + struct twelve a, b; + if ((((char *) &b - (char *) &a) < 0 + ? (-((char *) &b - (char *) &a)) + : ((char *) &b - (char *) &a)) < sizeof (a)) + abort (); + } + } + } +} + +main () +{ + f (); + exit (0); +} diff --git a/test/tests/950714-1.c b/test/tests/950714-1.c new file mode 100644 index 0000000..5dc44a9 --- /dev/null +++ b/test/tests/950714-1.c @@ -0,0 +1,17 @@ +int array[10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1}; + +main () +{ + int i, j; + int *p; + + for (i = 0; i < 10; i++) + for (p = &array[0]; p != &array[9]; p++) + if (*p == i) + goto label; + + label: + if (i != 1) + abort (); + exit (0); +} diff --git a/test/tests/950809-1.c b/test/tests/950809-1.c new file mode 100644 index 0000000..a33d42b --- /dev/null +++ b/test/tests/950809-1.c @@ -0,0 +1,33 @@ +struct S +{ + int *sp, fc, *sc, a[2]; +}; + +f (struct S *x) +{ + int *t = x->sc; + int t1 = t[0]; + int t2 = t[1]; + int t3 = t[2]; + int a0 = x->a[0]; + int a1 = x->a[1]; + t[2] = t1; + t[0] = a1; + x->a[1] = a0; + x->a[0] = t3; + x->fc = t2; + x->sp = t; +} + +main () +{ + struct S s; + static int sc[3] = {2, 3, 4}; + s.sc = sc; + s.a[0] = 10; + s.a[1] = 11; + f (&s); + if (s.sp[2] != 2) + abort (); + exit (0); +} diff --git a/test/tests/950906-1.c b/test/tests/950906-1.c new file mode 100644 index 0000000..31997d5 --- /dev/null +++ b/test/tests/950906-1.c @@ -0,0 +1,16 @@ +g (int i) +{ +} + +f (int i) +{ + g (0); + while ( ({ i--; }) ) + g (0); +} + +main () +{ + f (10); + exit (0); +} diff --git a/test/tests/950915-1.c b/test/tests/950915-1.c new file mode 100644 index 0000000..4ff87f6 --- /dev/null +++ b/test/tests/950915-1.c @@ -0,0 +1,15 @@ +long int a = 100; +long int b = 328; + +long +f () +{ + return ((long long) a * (long long) b) >> 8; +} + +main () +{ + if (f () < 0) + abort (); + exit (0); +} diff --git a/test/tests/950929-1.c b/test/tests/950929-1.c new file mode 100644 index 0000000..a35cd6a --- /dev/null +++ b/test/tests/950929-1.c @@ -0,0 +1,21 @@ +int f (char *p) { } + +main () +{ + char c; + char c2; + int i = 0; + char *pc = &c; + char *pc2 = &c2; + int *pi = &i; + + *pc2 = 1; + *pi = 1; + *pc2 &= *pi; + f (pc2); + *pc2 = 1; + *pc2 &= *pi; + if (*pc2 != 1) + abort (); + exit (0); +} diff --git a/test/tests/951003-1.c b/test/tests/951003-1.c new file mode 100644 index 0000000..269bf13 --- /dev/null +++ b/test/tests/951003-1.c @@ -0,0 +1,21 @@ +int f (i) { return 12; } +int g () { return 0; } + +main () +{ + int i, s; + + for (i = 0; i < 32; i++) + { + s = f (i); + + if (i == g ()) + s = 42; + if (i == 0 || s == 12) + ; + else + abort (); + } + + exit (0); +} diff --git a/test/tests/951115-1.c b/test/tests/951115-1.c new file mode 100644 index 0000000..03520c9 --- /dev/null +++ b/test/tests/951115-1.c @@ -0,0 +1,24 @@ +int var = 0; + +g () +{ + var = 1; +} + +f () +{ + int f2 = 0; + + if (f2 == 0) + ; + + g (); +} + +main () +{ + f (); + if (var != 1) + abort (); + exit (0); +} diff --git a/test/tests/951204-1.c b/test/tests/951204-1.c new file mode 100644 index 0000000..c4d585b --- /dev/null +++ b/test/tests/951204-1.c @@ -0,0 +1,18 @@ +f (char *x) +{ + *x = 'x'; +} + +main () +{ + int i; + char x = '\0'; + + for (i = 0; i < 100; ++i) + { + f (&x); + if (*(const char *) &x != 'x') + abort (); + } + exit (0); +} diff --git a/test/tests/960116-1.c b/test/tests/960116-1.c new file mode 100644 index 0000000..6d7624c --- /dev/null +++ b/test/tests/960116-1.c @@ -0,0 +1,20 @@ +static inline +p (int *p) +{ + return !((long) p & 1); +} + +int +f (int *q) +{ + if (p (q) && *q) + return 1; + return 0; +} + +main () +{ + if (f ((int*) 0xffffffff) != 0) + abort (); + exit (0); +} diff --git a/test/tests/960117-1.c b/test/tests/960117-1.c new file mode 100644 index 0000000..741455b --- /dev/null +++ b/test/tests/960117-1.c @@ -0,0 +1,46 @@ +static char id_space[2] [32 +1]; +typedef short COUNT; + +typedef char TEXT; + +union T_VALS +{ + TEXT *id __attribute__ ((aligned (2), packed)) ; +}; +typedef union T_VALS VALS; + +struct T_VAL +{ + COUNT pos __attribute__ ((aligned (2), packed)) ; + VALS vals __attribute__ ((aligned (2), packed)) ; +}; +typedef struct T_VAL VAL; + +VAL curval = {0}; + +static short idc = 0; +static int cur_line; +static int char_pos; + +typedef unsigned short WORD; + +WORD +get_id (char c) +{ + curval.vals.id[0] = c; +} + +WORD +get_tok () +{ + char c = 'c'; + curval.vals.id = id_space[idc]; + curval.pos = (cur_line << 10) | char_pos; + return get_id (c); +} + +main () +{ + get_tok (); + exit (0); +} diff --git a/test/tests/960209-1.c b/test/tests/960209-1.c new file mode 100644 index 0000000..decd2af --- /dev/null +++ b/test/tests/960209-1.c @@ -0,0 +1,43 @@ +struct a_struct +{ + unsigned char a_character; +}; + +struct a_struct an_array[5]; +struct a_struct *a_ptr; +int yabba = 1; + +int +f (a, b) + unsigned char a; + unsigned long b; +{ + long i, j, p, q, r, s; + + if (b != (unsigned long) 0) + { + if (yabba) + return -1; + s = 4000000 / b; + for (i = 0; i < 11; i++) + { + for (j = 0; j < 256; j++) + { + if (((p - s < 0) ? -s : 0) < (( q - s < 0) ? -s : q)) + r = i; + } + } + } + + if (yabba) + return 0; + a_ptr = &an_array[a]; + a_ptr->a_character = (unsigned char) r; +} + +main () +{ + if (f (1, 0UL) != 0) + abort (); + exit (0); +} diff --git a/test/tests/960215-1.c b/test/tests/960215-1.c new file mode 100644 index 0000000..9502b4b --- /dev/null +++ b/test/tests/960215-1.c @@ -0,0 +1,25 @@ +long double C = 2; +long double U = 1; +long double Y2 = 3; +long double Y1 = 1; +long double X, Y, Z, T, R, S; +main () +{ + X = (C + U) * Y2; + Y = C - U - U; + Z = C + U + U; + T = (C - U) * Y1; + X = X - (Z + U); + R = Y * Y1; + S = Z * Y2; + T = T - Y; + Y = (U - Y) + R; + Z = S - (Z + U + U); + R = (Y2 + U) * Y1; + Y1 = Y2 * Y1; + R = R - Y2; + Y1 = Y1 - 0.5L; + if (Z != 6) + abort (); + exit (0); +} diff --git a/test/tests/960218-1.c b/test/tests/960218-1.c new file mode 100644 index 0000000..7301a17 --- /dev/null +++ b/test/tests/960218-1.c @@ -0,0 +1,22 @@ +int glob; + +g (x) +{ + glob = x; + return 0; +} + +f (x) +{ + int a = ~x; + while (a) + a = g (a); +} + +main () +{ + f (3); + if (glob != -4) + abort (); + exit (0); +} diff --git a/test/tests/960219-1.c b/test/tests/960219-1.c new file mode 100644 index 0000000..d21bcfc --- /dev/null +++ b/test/tests/960219-1.c @@ -0,0 +1,11 @@ +f (int i) +{ + if (((1 << i) & 1) == 0) + abort (); +} + +main () +{ + f (0); + exit (0); +} diff --git a/test/tests/960301-1.c b/test/tests/960301-1.c new file mode 100644 index 0000000..d75efea --- /dev/null +++ b/test/tests/960301-1.c @@ -0,0 +1,22 @@ +struct foo { + unsigned : 12; + unsigned field : 4; +} foo; +unsigned oldfoo; + +int +bar (unsigned k) +{ + oldfoo = foo.field; + foo.field = k; + if (k) + return 1; + return 2; +} + +main () +{ + if (bar (1U) != 1) + abort (); + exit (0); +} diff --git a/test/tests/960302-1.c b/test/tests/960302-1.c new file mode 100644 index 0000000..7a9426a --- /dev/null +++ b/test/tests/960302-1.c @@ -0,0 +1,21 @@ +long a = 1; + +foo () +{ + switch (a % 2 % 2 % 2 % 2 % 2 % 2 % 2 % 2) + { + case 0: + return 0; + case 1: + return 1; + default: + return -1; + } +} + +main () +{ + if (foo () != 1) + abort (); + exit (0); +} diff --git a/test/tests/960311-1.c b/test/tests/960311-1.c new file mode 100644 index 0000000..77bf445 --- /dev/null +++ b/test/tests/960311-1.c @@ -0,0 +1,68 @@ +#ifdef DEBUG +#include +#define abort() printf ("error, line %d\n", __LINE__) +#endif + +int count; + +void a1() { ++count; } + +void +b (unsigned char data) +{ + if (data & 0x80) a1(); + data <<= 1; + + if (data & 0x80) a1(); + data <<= 1; + + if (data & 0x80) a1(); +} + +main () +{ + count = 0; + b (0); + if (count != 0) + abort (); + + count = 0; + b (0x80); + if (count != 1) + abort (); + + count = 0; + b (0x40); + if (count != 1) + abort (); + + count = 0; + b (0x20); + if (count != 1) + abort (); + + count = 0; + b (0xc0); + if (count != 2) + abort (); + + count = 0; + b (0xa0); + if (count != 2) + abort (); + + count = 0; + b (0x60); + if (count != 2) + abort (); + + count = 0; + b (0xe0); + if (count != 3) + abort (); + +#ifdef DEBUG + printf ("Done.\n"); +#endif + exit (0); +} diff --git a/test/tests/960311-2.c b/test/tests/960311-2.c new file mode 100644 index 0000000..0424a95 --- /dev/null +++ b/test/tests/960311-2.c @@ -0,0 +1,68 @@ +#ifdef DEBUG +#include +#define abort() printf ("error, line %d\n", __LINE__) +#endif + +int count; + +void a1() { ++count; } + +void +b (unsigned short data) +{ + if (data & 0x8000) a1(); + data <<= 1; + + if (data & 0x8000) a1(); + data <<= 1; + + if (data & 0x8000) a1(); +} + +main () +{ + count = 0; + b (0); + if (count != 0) + abort (); + + count = 0; + b (0x8000); + if (count != 1) + abort (); + + count = 0; + b (0x4000); + if (count != 1) + abort (); + + count = 0; + b (0x2000); + if (count != 1) + abort (); + + count = 0; + b (0xc000); + if (count != 2) + abort (); + + count = 0; + b (0xa000); + if (count != 2) + abort (); + + count = 0; + b (0x6000); + if (count != 2) + abort (); + + count = 0; + b (0xe000); + if (count != 3) + abort (); + +#ifdef DEBUG + printf ("Done.\n"); +#endif + exit (0); +} diff --git a/test/tests/960311-3.c b/test/tests/960311-3.c new file mode 100644 index 0000000..598a6db --- /dev/null +++ b/test/tests/960311-3.c @@ -0,0 +1,68 @@ +#ifdef DEBUG +#include +#define abort() printf ("error, line %d\n", __LINE__) +#endif + +int count; + +void a1() { ++count; } + +void +b (unsigned long long data) +{ + if (data & 0x80000000) a1(); + data <<= 1; + + if (data & 0x80000000) a1(); + data <<= 1; + + if (data & 0x80000000) a1(); +} + +main () +{ + count = 0; + b (0); + if (count != 0) + abort (); + + count = 0; + b (0x80000000); + if (count != 1) + abort (); + + count = 0; + b (0x40000000); + if (count != 1) + abort (); + + count = 0; + b (0x20000000); + if (count != 1) + abort (); + + count = 0; + b (0xc0000000); + if (count != 2) + abort (); + + count = 0; + b (0xa0000000); + if (count != 2) + abort (); + + count = 0; + b (0x60000000); + if (count != 2) + abort (); + + count = 0; + b (0xe0000000); + if (count != 3) + abort (); + +#ifdef DEBUG + printf ("Done.\n"); +#endif + exit (0); +} diff --git a/test/tests/960312-1.c b/test/tests/960312-1.c new file mode 100644 index 0000000..73a67ed --- /dev/null +++ b/test/tests/960312-1.c @@ -0,0 +1,34 @@ +struct S +{ + int *sp, fc, *sc, a[2]; +}; + +f (struct S *x) +{ + int *t = x->sc; + int t1 = t[0]; + int t2 = t[1]; + int t3 = t[2]; + int a0 = x->a[0]; + int a1 = x->a[1]; +// asm("": :"r" (t2), "r" (t3)); + t[2] = t1; + t[0] = a1; + x->a[1] = a0; + x->a[0] = t3; + x->fc = t2; + x->sp = t; +} + +main () +{ + struct S s; + static int sc[3] = {2, 3, 4}; + s.sc = sc; + s.a[0] = 10; + s.a[1] = 11; + f (&s); + if (s.sp[2] != 2) + abort (); + exit (0); +} diff --git a/test/tests/960317-1.c b/test/tests/960317-1.c new file mode 100644 index 0000000..8d7907d --- /dev/null +++ b/test/tests/960317-1.c @@ -0,0 +1,22 @@ +int +f (unsigned bitcount, int mant) +{ + int mask = -1 << bitcount; + { + if (! (mant & -mask)) + goto ab; + if (mant & ~mask) + goto auf; + } +ab: + return 0; +auf: + return 1; +} + +main () +{ + if (f (0, -1)) + abort (); + exit (0); +} diff --git a/test/tests/960321-1.c b/test/tests/960321-1.c new file mode 100644 index 0000000..97846e0 --- /dev/null +++ b/test/tests/960321-1.c @@ -0,0 +1,14 @@ +char a[10] = "deadbeef"; + +char +acc_a (long i) +{ + return a[i-30000L]; +} + +main () +{ + if (acc_a (30000L) != 'd') + abort (); + exit (0); +} diff --git a/test/tests/960326-1.c b/test/tests/960326-1.c new file mode 100644 index 0000000..f201373 --- /dev/null +++ b/test/tests/960326-1.c @@ -0,0 +1,16 @@ +struct s +{ + int a; + int b; + short c; + int d[3]; +}; + +struct s s = { .b = 3, .d = {2,0,0} }; + +main () +{ + if (s.b != 3) + abort (); + exit (0); +} diff --git a/test/tests/960327-1.c b/test/tests/960327-1.c new file mode 100644 index 0000000..bc82cb5 --- /dev/null +++ b/test/tests/960327-1.c @@ -0,0 +1,30 @@ +#include +g () +{ + return '\n'; +} + +f () +{ + char s[] = "abcedfg012345"; + char *sp = s + 12; + + switch (g ()) + { + case '\n': + break; + } + + while (*--sp == '0') + ; + sprintf (sp + 1, "X"); + + if (s[12] != 'X') + abort (); +} + +main () +{ + f (); + exit (0); +} diff --git a/test/tests/960402-1.c b/test/tests/960402-1.c new file mode 100644 index 0000000..3df94b7 --- /dev/null +++ b/test/tests/960402-1.c @@ -0,0 +1,11 @@ +f (signed long long int x) +{ + return x > 0xFFFFLL || x < -0x8000LL; +} + +main () +{ + if (f (0) != 0) + abort (); + exit (0); +} diff --git a/test/tests/960405-1.c b/test/tests/960405-1.c new file mode 100644 index 0000000..ea25f80 --- /dev/null +++ b/test/tests/960405-1.c @@ -0,0 +1,13 @@ +#define X 5.948657473873442e37 + +long double x = X + X; +long double y = 2.0 * X; + +main () +{ +#if ! defined (__vax__) && ! defined (_CRAY) + if (x != y) + abort (); +#endif + exit (0); +} diff --git a/test/tests/960416-1.c b/test/tests/960416-1.c new file mode 100644 index 0000000..f7cb056 --- /dev/null +++ b/test/tests/960416-1.c @@ -0,0 +1,63 @@ +typedef unsigned long int st; +typedef unsigned long long dt; +typedef union +{ + dt d; + struct + { + st h, l; + } + s; +} t_be; + +typedef union +{ + dt d; + struct + { + st l, h; + } + s; +} t_le; + +#define df(f, t) \ +int \ +f (t afh, t bfh) \ +{ \ + t hh; \ + t hp, lp, dp, m; \ + st ad, bd; \ + int s; \ + s = 0; \ + ad = afh.s.h - afh.s.l; \ + bd = bfh.s.l - bfh.s.h; \ + if (bd > bfh.s.l) \ + { \ + bd = -bd; \ + s = ~s; \ + } \ + lp.d = (dt) afh.s.l * bfh.s.l; \ + hp.d = (dt) afh.s.h * bfh.s.h; \ + dp.d = (dt) ad *bd; \ + dp.d ^= s; \ + hh.d = hp.d + hp.s.h + lp.s.h + dp.s.h; \ + m.d = (dt) lp.s.h + hp.s.l + lp.s.l + dp.s.l; \ + return hh.s.l + m.s.l; \ +} + +df(f_le, t_le) +df(f_be, t_be) + +main () +{ + t_be x; + x.s.h = 0x10000000U; + x.s.l = 0xe0000000U; + if (x.d == 0x10000000e0000000ULL + && f_be ((t_be) 0x100000000ULL, (t_be) 0x100000000ULL) != -1) + abort (); + if (x.d == 0xe000000010000000ULL + && f_le ((t_le) 0x100000000ULL, (t_le) 0x100000000ULL) != -1) + abort (); + exit (0); +} diff --git a/test/tests/960419-1.c b/test/tests/960419-1.c new file mode 100644 index 0000000..68bd2b9 --- /dev/null +++ b/test/tests/960419-1.c @@ -0,0 +1,17 @@ +static int i; + +void +check(x) + int x; +{ + if (!x) + abort(); +} + +main() +{ + int *p = &i; + + check(p != (void *)0); + exit (0); +} diff --git a/test/tests/960419-2.c b/test/tests/960419-2.c new file mode 100644 index 0000000..c9526dc --- /dev/null +++ b/test/tests/960419-2.c @@ -0,0 +1,13 @@ +#define SIZE 8 + +main() +{ + int a[SIZE] = {1}; + int i; + + for (i = 1; i < SIZE; i++) + if (a[i] != 0) + abort(); + + exit (0); +} diff --git a/test/tests/960512-1.c b/test/tests/960512-1.c new file mode 100644 index 0000000..f65570b --- /dev/null +++ b/test/tests/960512-1.c @@ -0,0 +1,21 @@ +#define __complex__ + +__complex__ +double f () +{ + int a[40]; + __complex__ double c; + + a[9] = 0; + c = a[9]; + return c; +} + +main () +{ + __complex__ double c; + + if (c = f ()) + abort (); + exit (0); +} diff --git a/test/tests/960513-1.c b/test/tests/960513-1.c new file mode 100644 index 0000000..acc263c --- /dev/null +++ b/test/tests/960513-1.c @@ -0,0 +1,25 @@ +long double +f (d, i) + long double d; + int i; +{ + long double e; + + d = -d; + e = d; + if (i == 1) + d *= 2; + d -= e * d; + d -= e * d; + d -= e * d; + d -= e * d; + d -= e * d; + return d; +} + +main () +{ + if (! (int) (f (2.0L, 1))) + abort (); + exit (0); +} diff --git a/test/tests/960521-1.c b/test/tests/960521-1.c new file mode 100644 index 0000000..9fc5821 --- /dev/null +++ b/test/tests/960521-1.c @@ -0,0 +1,30 @@ +#include + +int *a, *b; +int n; + +#ifdef STACK_SIZE +#define BLOCK_SIZE (STACK_SIZE / (sizeof (*a) + sizeof (*b))) +#else +#define BLOCK_SIZE 32768 +#endif +foo () +{ + int i; + for (i = 0; i < n; i++) + a[i] = -1; + for (i = 0; i < BLOCK_SIZE - 1; i++) + b[i] = -1; +} + +main () +{ + n = BLOCK_SIZE; + a = malloc (n * sizeof(*a)); + b = malloc (n * sizeof(*b)); + *b++ = 0; + foo (); + if (b[-1]) + abort (); + exit (0); +} diff --git a/test/tests/960608-1.c b/test/tests/960608-1.c new file mode 100644 index 0000000..1f47d02 --- /dev/null +++ b/test/tests/960608-1.c @@ -0,0 +1,34 @@ +typedef struct +{ + unsigned char a : 2; + unsigned char b : 3; + unsigned char c : 1; + unsigned char d : 1; + unsigned char e : 1; +} a_struct; + +foo (flags) + a_struct *flags; +{ + return (flags->c != 0 + || flags->d != 1 + || flags->e != 1 + || flags->a != 2 + || flags->b != 3); +} + +main () +{ + a_struct flags; + + flags.c = 0; + flags.d = 1; + flags.e = 1; + flags.a = 2; + flags.b = 3; + + if (foo (&flags) != 0) + abort (); + else + exit (0); +} diff --git a/test/tests/960801-1.c b/test/tests/960801-1.c new file mode 100644 index 0000000..9c9ff03 --- /dev/null +++ b/test/tests/960801-1.c @@ -0,0 +1,36 @@ +#if 0 +unsigned +f () +{ + long long l2; + unsigned short us; + unsigned long long ul; + short s2; + + ul = us = l2 = s2 = -1; + return ul; +} +#endif + +unsigned long long +g () +{ + long long l2; + unsigned short us; + unsigned long long ul; + short s2; + + ul = us = l2 = s2 = -1; + return ul; +} + +main () +{ +#if 0 + if (f () != (unsigned short) -1) + abort (); +#endif + if (g () != (unsigned short) -1) + abort (); + exit (0); +} diff --git a/test/tests/960802-1.c b/test/tests/960802-1.c new file mode 100644 index 0000000..b20fd57 --- /dev/null +++ b/test/tests/960802-1.c @@ -0,0 +1,36 @@ +long val = 0x5e00; + +long +f1 (void) +{ + return 0x13; +} + +long +f2 (void) +{ + return 0x5e00; +} + +void +f3 (long b) +{ + val = b; +} + +void +f4 () +{ + long v = f1 (); + long o = f2 (); + v = (v & 0x00ff) | (o & 0xff00); + f3 (v); +} + +main () +{ + f4 (); + if (val != 0x5e13) + abort (); + exit (0); +} diff --git a/test/tests/960830-1.c b/test/tests/960830-1.c new file mode 100644 index 0000000..d87b39e --- /dev/null +++ b/test/tests/960830-1.c @@ -0,0 +1,22 @@ +#ifdef __i386__ +f (rp) + unsigned int *rp; +{ + __asm__ ("mull %3" : "=a" (rp[0]), "=d" (rp[1]) : "%0" (7), "rm" (7)); +} + +main () +{ + unsigned int s[2]; + + f (s); + if (s[1] != 0 || s[0] != 49) + abort (); + exit (0); +} +#else +main () +{ + exit (0); +} +#endif diff --git a/test/tests/960909-1.c b/test/tests/960909-1.c new file mode 100644 index 0000000..de1ed93 --- /dev/null +++ b/test/tests/960909-1.c @@ -0,0 +1,29 @@ +int +ffs (x) + int x; +{ + int bit, mask; + + if (x == 0) + return 0; + + for (bit = 1, mask = 1; !(x & mask); bit++, mask <<= 1) + ; + + return bit; +} + +f (x) + int x; +{ + int y; + y = ffs (x) - 1; + if (y < 0) + abort (); +} + +main () +{ + f (1); + exit (0); +} diff --git a/test/tests/961004-1.c b/test/tests/961004-1.c new file mode 100644 index 0000000..7ebba2d --- /dev/null +++ b/test/tests/961004-1.c @@ -0,0 +1,22 @@ +int k = 0; + +main() +{ + int i; + int j; + + for (i = 0; i < 2; i++) + { + if (k) + { + if (j != 2) + abort (); + } + else + { + j = 2; + k++; + } + } + exit (0); +} diff --git a/test/tests/961017-1.c b/test/tests/961017-1.c new file mode 100644 index 0000000..88c9d95 --- /dev/null +++ b/test/tests/961017-1.c @@ -0,0 +1,8 @@ +main () +{ + unsigned char z = 0; + + do ; + while (--z > 0); + exit (0); +} diff --git a/test/tests/961017-2.c b/test/tests/961017-2.c new file mode 100644 index 0000000..f292b6b --- /dev/null +++ b/test/tests/961017-2.c @@ -0,0 +1,32 @@ +main () +{ + int i = 0; + + + if (sizeof (unsigned long int) == 2) + { + unsigned long int z = 0; + + do { + z -= 0x0040; + i++; + if (i > 0x0400) + abort (); + } while (z > 0); + exit (0); + } + else if (sizeof (unsigned int) == 2) + { + unsigned int z = 0; + + do { + z -= 0x0040; + i++; + if (i > 0x0400) + abort (); + } while (z > 0); + exit (0); + } + else + exit (0); +} diff --git a/test/tests/961026-1.c b/test/tests/961026-1.c new file mode 100644 index 0000000..942a6eb --- /dev/null +++ b/test/tests/961026-1.c @@ -0,0 +1,17 @@ +int +test (arg) + int arg; +{ + if (arg > 0 || arg == 0) + return 0; + return -1; +} + +main () +{ + if (test (0) != 0) + abort (); + if (test (-1) != -1) + abort (); + exit (0); +} diff --git a/test/tests/961112-1.c b/test/tests/961112-1.c new file mode 100644 index 0000000..4b1c312 --- /dev/null +++ b/test/tests/961112-1.c @@ -0,0 +1,13 @@ +f (x) +{ + if (x != 0 || x == 0) + return 0; + return 1; +} + +main () +{ + if (f (3)) + abort (); + exit (0); +} diff --git a/test/tests/961122-1.c b/test/tests/961122-1.c new file mode 100644 index 0000000..1f0a634 --- /dev/null +++ b/test/tests/961122-1.c @@ -0,0 +1,23 @@ +long long acc; + +addhi (short a) +{ + acc += (long long) a << 32; +} + +subhi (short a) +{ + acc -= (long long) a << 32; +} + +main () +{ + acc = 0xffff00000000ll; + addhi (1); + if (acc != 0x1000000000000ll) + abort (); + subhi (1); + if (acc != 0xffff00000000ll) + abort (); + exit (0); +} diff --git a/test/tests/961122-2.c b/test/tests/961122-2.c new file mode 100644 index 0000000..81e404e --- /dev/null +++ b/test/tests/961122-2.c @@ -0,0 +1,12 @@ +int +f (int a) +{ + return ((a >= 0 && a <= 10) && ! (a >= 0)); +} + +main () +{ + if (f (0)) + abort (); + exit (0); +} diff --git a/test/tests/961125-1.c b/test/tests/961125-1.c new file mode 100644 index 0000000..7fe3dd4 --- /dev/null +++ b/test/tests/961125-1.c @@ -0,0 +1,33 @@ +static char * +begfield (int tab, char *ptr, char *lim, int sword, int schar) +{ + if (tab) + { + while (ptr < lim && sword--) + { + while (ptr < lim && *ptr != tab) + ++ptr; + if (ptr < lim) + ++ptr; + } + } + else + { + while (1) + ; + } + + if (ptr + schar <= lim) + ptr += schar; + + return ptr; +} + +main () +{ + char *s = ":ab"; + char *lim = s + 3; + if (begfield (':', s, lim, 1, 1) != s + 2) + abort (); + exit (0); +} diff --git a/test/tests/961206-1.c b/test/tests/961206-1.c new file mode 100644 index 0000000..943ac66 --- /dev/null +++ b/test/tests/961206-1.c @@ -0,0 +1,52 @@ +int +sub1 (unsigned long long i) +{ + if (i < 0x80000000) + return 1; + else + return 0; +} + +int +sub2 (unsigned long long i) +{ + if (i <= 0x7FFFFFFF) + return 1; + else + return 0; +} + +int +sub3 (unsigned long long i) +{ + if (i >= 0x80000000) + return 0; + else + return 1; +} + +int +sub4 (unsigned long long i) +{ + if (i > 0x7FFFFFFF) + return 0; + else + return 1; +} + +main() +{ + if (sub1 (0x80000000ULL)) + abort (); + + if (sub2 (0x80000000ULL)) + abort (); + + if (sub3 (0x80000000ULL)) + abort (); + + if (sub4 (0x80000000ULL)) + abort (); + + exit (0); +} diff --git a/test/tests/961213-1.c b/test/tests/961213-1.c new file mode 100644 index 0000000..12bb27f --- /dev/null +++ b/test/tests/961213-1.c @@ -0,0 +1,22 @@ +int +g (unsigned long long int *v, int n, unsigned int a[], int b) +{ + int cnt; + *v = 0; + for (cnt = 0; cnt < n; ++cnt) + *v = *v * b + a[cnt]; + return n; +} + +main () +{ + int res; + unsigned int ar[] = { 10, 11, 12, 13, 14 }; + unsigned long long int v; + + res = g (&v, sizeof(ar)/sizeof(ar[0]), ar, 16); + if (v != 0xabcdeUL) + abort (); + + exit (0); +} diff --git a/test/tests/961223-1.c b/test/tests/961223-1.c new file mode 100644 index 0000000..9bc6cfa --- /dev/null +++ b/test/tests/961223-1.c @@ -0,0 +1,19 @@ +struct s { + double d; +}; + +inline struct s +sub (struct s s) +{ + s.d += 1.0; + return s; +} + +main () +{ + struct s t = { 2.0 }; + t = sub (t); + if (t.d != 3.0) + abort (); + exit (0); +} diff --git a/test/tests/970214-1.c b/test/tests/970214-1.c new file mode 100644 index 0000000..4a06dfe --- /dev/null +++ b/test/tests/970214-1.c @@ -0,0 +1,5 @@ +#define L 1 +main () +{ + exit (L'1' != L'1'); +} diff --git a/test/tests/970214-2.c b/test/tests/970214-2.c new file mode 100644 index 0000000..cb90076 --- /dev/null +++ b/test/tests/970214-2.c @@ -0,0 +1,5 @@ +#define m(L) (L'1' + (L)) +main () +{ + exit (m (0) != L'1'); +} diff --git a/test/tests/970923-1.c b/test/tests/970923-1.c new file mode 100644 index 0000000..1d78b47 --- /dev/null +++ b/test/tests/970923-1.c @@ -0,0 +1,27 @@ +int +ts(a) + int a; +{ + if (a < 1000 && a > 2000) + return 1; + else + return 0; +} + +int +tu(a) + unsigned int a; +{ + if (a < 1000 && a > 2000) + return 1; + else + return 0; +} + + +main() +{ + if (ts (0) || tu (0)) + abort (); + exit (0); +} diff --git a/test/tests/980205.c b/test/tests/980205.c new file mode 100644 index 0000000..da15d3c --- /dev/null +++ b/test/tests/980205.c @@ -0,0 +1,20 @@ +#include + +void fdouble (double one, ...) +{ + double value; + va_list ap; + + va_start (ap, one); + value = va_arg (ap, double); + va_end (ap); + + if (one != 1.0 || value != 2.0) + abort (); +} + +int main () +{ + fdouble (1.0, 2.0); + exit (0); +} diff --git a/test/tests/980223.c b/test/tests/980223.c new file mode 100644 index 0000000..4908734 --- /dev/null +++ b/test/tests/980223.c @@ -0,0 +1,31 @@ +typedef struct { char *addr; long type; } object; + +object bar (object blah) +{ + abort(); +} + +object foo (object x, object y) +{ + object z = *(object*)(x.addr); + if (z.type & 64) + { + y = *(object*)(z.addr+sizeof(object)); + z = *(object*)(z.addr); + if (z.type & 64) + y = bar(y); + } + return y; +} + +int nil; +object cons1[2] = { {(char *) &nil, 0}, {(char *) &nil, 0} }; +object cons2[2] = { {(char *) &cons1, 64}, {(char *) &nil, 0} }; + +main() +{ + object x = {(char *) &cons2, 64}; + object y = {(char *) &nil, 0}; + object three = foo(x,y); + return 0; +} diff --git a/test/tests/980424-1.c b/test/tests/980424-1.c new file mode 100644 index 0000000..514e917 --- /dev/null +++ b/test/tests/980424-1.c @@ -0,0 +1,22 @@ +int i, a[99]; + +void f (int one) +{ + if (one != 1) + abort (); +} + +void +g () +{ + f (a[i & 0x3f]); +} + +int +main () +{ + a[0] = 1; + i = 0x40; + g (); + exit (0); +} diff --git a/test/tests/980505-1.c b/test/tests/980505-1.c new file mode 100644 index 0000000..9052411 --- /dev/null +++ b/test/tests/980505-1.c @@ -0,0 +1,11 @@ +static int f(int) __attribute__((const)); +int main() +{ + int f1, f2, x; + x = 1; f1 = f(x); + x = 2; f2 = f(x); + if (f1 != 1 || f2 != 2) + abort (); + exit (0); +} +static int f(int x) { return x; } diff --git a/test/tests/980505-2.c b/test/tests/980505-2.c new file mode 100644 index 0000000..d0d8aa8 --- /dev/null +++ b/test/tests/980505-2.c @@ -0,0 +1,22 @@ +typedef unsigned short Uint16; +typedef unsigned int Uint; + +Uint f () +{ + Uint16 token; + Uint count; + static Uint16 values[1] = {0x9300}; + + token = values[0]; + count = token >> 8; + + return count; +} + +int +main () +{ + if (f () != 0x93) + abort (); + exit (0); +} diff --git a/test/tests/980506-1.c b/test/tests/980506-1.c new file mode 100644 index 0000000..a48b3ad --- /dev/null +++ b/test/tests/980506-1.c @@ -0,0 +1,26 @@ +struct decision +{ + char enforce_mode; + struct decision *next; +}; + + +static void +clear_modes (p) + register struct decision *p; +{ + goto blah; + +foo: + p->enforce_mode = 0; +blah: + if (p) + goto foo; +} + +main() +{ + struct decision *p = 0; + clear_modes (p); + exit (0); +} diff --git a/test/tests/980506-2.c b/test/tests/980506-2.c new file mode 100644 index 0000000..4dd9a2c --- /dev/null +++ b/test/tests/980506-2.c @@ -0,0 +1,22 @@ +static void *self(void *p){ return p; } + +int +f() +{ + struct { int i; } s, *sp; + int *ip = &s.i; + + s.i = 1; + sp = self(&s); + + *ip = 0; + return sp->i+1; +} + +main() +{ + if (f () != 1) + abort (); + else + exit (0); +} diff --git a/test/tests/980506-3.c b/test/tests/980506-3.c new file mode 100644 index 0000000..a943e9a --- /dev/null +++ b/test/tests/980506-3.c @@ -0,0 +1,24 @@ +unsigned char lookup_table [257]; + +static int +build_lookup (pattern) + unsigned char *pattern; +{ + int m; + + m = strlen (pattern) - 1; + + memset (lookup_table, ++m, 257); + return m; +} + +int main(argc, argv) + int argc; + char **argv; +{ + if (build_lookup ("bind") != 4) + abort (); + else + exit (0); +} + diff --git a/test/tests/980526-1.c b/test/tests/980526-1.c new file mode 100644 index 0000000..a792d8f --- /dev/null +++ b/test/tests/980526-1.c @@ -0,0 +1,39 @@ +int expect_do1 = 1, expect_do2 = 2; + +static int doit(int x){ +#if 0 + __label__ lbl1; + __label__ lbl2; +#endif + static int jtab_init = 0; + static void *jtab[2]; + + if(!jtab_init) { + jtab[0] = &&lbl1; + jtab[1] = &&lbl2; + jtab_init = 1; + } + goto *jtab[x]; +lbl1: + return 1; +lbl2: + return 2; +} + +static void do1(void) { + if (doit(0) != expect_do1) + abort (); +} + +static void do2(void){ + if (doit(1) != expect_do2) + abort (); +} + +int main(void){ +#ifndef NO_LABEL_VALUES + do1(); + do2(); +#endif + exit(0); +} diff --git a/test/tests/980526-2.c b/test/tests/980526-2.c new file mode 100644 index 0000000..2547147 --- /dev/null +++ b/test/tests/980526-2.c @@ -0,0 +1,57 @@ +typedef unsigned int dev_t; +typedef unsigned int kdev_t; + +static inline kdev_t to_kdev_t(int dev) +{ + int major, minor; + + if (sizeof(kdev_t) == 16) + return (kdev_t)dev; + major = (dev >> 8); + minor = (dev & 0xff); + return ((( major ) << 22 ) | ( minor )) ; + +} + +void do_mknod(const char * filename, int mode, kdev_t dev) +{ + if (dev==0x15800078) + exit(0); + else + abort(); +} + + +char * getname(const char * filename) +{ + register unsigned int a1,a2,a3,a4,a5,a6,a7,a8,a9; + a1 = (unsigned int)(filename) *5 + 1; + a2 = (unsigned int)(filename) *6 + 2; + a3 = (unsigned int)(filename) *7 + 3; + a4 = (unsigned int)(filename) *8 + 4; + a5 = (unsigned int)(filename) *9 + 5; + a6 = (unsigned int)(filename) *10 + 5; + a7 = (unsigned int)(filename) *11 + 5; + a8 = (unsigned int)(filename) *12 + 5; + a9 = (unsigned int)(filename) *13 + 5; + return (char *)(a1*a2+a3*a4+a5*a6+a7*a8+a9); +} + +int sys_mknod(const char * filename, int mode, dev_t dev) +{ + int error; + char * tmp; + + tmp = getname(filename); + error = ((long)( tmp )) ; + do_mknod(tmp,mode,to_kdev_t(dev)); + return error; +} + +int main(void) +{ + if (sizeof (int) < 4) + exit (0); + + return sys_mknod("test",1,0x12345678); +} diff --git a/test/tests/980526-3.c b/test/tests/980526-3.c new file mode 100644 index 0000000..a564174 --- /dev/null +++ b/test/tests/980526-3.c @@ -0,0 +1,20 @@ +int compare(x, y) +unsigned int x; +unsigned int y; +{ + if (x==y) + return 0; + else + return 1; +} + +main() +{ + unsigned int i, j, k, l; + i = 5; j = 2; k=0; l=2; + if (compare(5%(~(unsigned) 2), i%~j) + || compare(0, k%~l)) + abort(); + else + exit(0); +} diff --git a/test/tests/980602-1.c b/test/tests/980602-1.c new file mode 100644 index 0000000..2df7283 --- /dev/null +++ b/test/tests/980602-1.c @@ -0,0 +1,10 @@ +main() +{ + int i; + for (i = 1; i < 100; i++) + ; + if (i == 100) + exit (0); + abort (); +} + diff --git a/test/tests/980602-2.c b/test/tests/980602-2.c new file mode 100644 index 0000000..972553e --- /dev/null +++ b/test/tests/980602-2.c @@ -0,0 +1,21 @@ +/* The bit-field below would have a problem if __INT_MAX__ is too + small. */ +#if __INT_MAX__ < 2147483647 +int +main (void) +{ + exit (0); +} +#else +struct { + unsigned bit : 30; +} t; + +int main() +{ + if (!(t.bit++)) + exit (0); + else + abort (); +} +#endif diff --git a/test/tests/980604-1.c b/test/tests/980604-1.c new file mode 100644 index 0000000..8992a90 --- /dev/null +++ b/test/tests/980604-1.c @@ -0,0 +1,20 @@ +int a = 1; +int b = -1; + +int c = 1; +int d = 0; + +main () +{ + double e; + double f; + double g; + + f = c; + g = d; + e = (a < b) ? f : g; + if (e) + abort (); + exit(0); +} + diff --git a/test/tests/980605-1.c b/test/tests/980605-1.c new file mode 100644 index 0000000..2fc2691 --- /dev/null +++ b/test/tests/980605-1.c @@ -0,0 +1,78 @@ +#include + +#ifndef STACK_SIZE +#define STACK_SIZE 200000 +#endif + +__inline__ static int +dummy (x) +{ + int y; + y = (long) (x * 4711.3); + return y; +} + +int getval (void); + +int +f2 (double x) +{ + unsigned short s; + int a, b, c, d, e, f, g, h, i, j; + + a = getval (); + b = getval (); + c = getval (); + d = getval (); + e = getval (); + f = getval (); + g = getval (); + h = getval (); + i = getval (); + j = getval (); + + + s = x; + + return a + b + c + d + e + f + g + h + i + j + s; +} + +int x = 1; + +int +getval (void) +{ + return x++; +} + +char buf[10]; + +void +f () +{ + char ar[STACK_SIZE/2]; + int a, b, c, d, e, f, g, h, i, j, k; + + a = getval (); + b = getval (); + c = getval (); + d = getval (); + e = getval (); + f = getval (); + g = getval (); + h = getval (); + i = getval (); + j = getval (); + + k = f2 (17.0); + + sprintf (buf, "%d\n", a + b + c + d + e + f + g + h + i + j + k); + if (a + b + c + d + e + f + g + h + i + j + k != 227) + abort (); +} + +main () +{ + f (); + exit (0); +} diff --git a/test/tests/980608-1.c b/test/tests/980608-1.c new file mode 100644 index 0000000..b34d137 --- /dev/null +++ b/test/tests/980608-1.c @@ -0,0 +1,36 @@ +#include + +void f1(int a,int b,int c,int d,int e, int f,int g,int h,int i,int j, int k,int +l,int m,int n,int o) +{ + return; +} + +inline void debug(const char *msg,...) +{ + va_list ap; + va_start( ap, msg ); + + f1(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15); + + if ( va_arg(ap,int) != 101) + abort(); + if ( va_arg(ap,int) != 102) + abort(); + if ( va_arg(ap,int) != 103) + abort(); + if ( va_arg(ap,int) != 104) + abort(); + if ( va_arg(ap,int) != 105) + abort(); + if ( va_arg(ap,int) != 106) + abort(); + + va_end( ap ); +} + +int main(void) +{ + debug("%d %d %d %d %d %d\n", 101, 102, 103, 104, 105, 106); + exit(0); +} diff --git a/test/tests/980612-1.c b/test/tests/980612-1.c new file mode 100644 index 0000000..db24387 --- /dev/null +++ b/test/tests/980612-1.c @@ -0,0 +1,17 @@ +struct fd +{ + unsigned char a; + unsigned char b; +} f = { 5 }; + +struct fd *g() { return &f; } +int h() { return -1; } + +int main() +{ + struct fd *f = g(); + f->b = h(); + if (((f->a & 0x7f) & ~0x10) <= 2) + abort (); + exit (0); +} diff --git a/test/tests/980617-1.c b/test/tests/980617-1.c new file mode 100644 index 0000000..5f7768a --- /dev/null +++ b/test/tests/980617-1.c @@ -0,0 +1,14 @@ +void foo (unsigned int * p) +{ + if ((signed char)(*p & 0xFF) == 17 || (signed char)(*p & 0xFF) == 18) + return; + else + abort (); +} + +int main () +{ + int i = 0x30011; + foo(&i); + exit (0); +} diff --git a/test/tests/980618-1.c b/test/tests/980618-1.c new file mode 100644 index 0000000..59db7f2 --- /dev/null +++ b/test/tests/980618-1.c @@ -0,0 +1,16 @@ +void func(int, int); + +int main() +{ + int x = 7; + func(!x, !7); + exit (0); +} + +void func(int x, int y) +{ + if (x == y) + return; + else + abort (); +} diff --git a/test/tests/980701-1.c b/test/tests/980701-1.c new file mode 100644 index 0000000..391cc0e --- /dev/null +++ b/test/tests/980701-1.c @@ -0,0 +1,22 @@ +ns_name_skip (unsigned char **x, unsigned char *y) +{ + *x = 0; + return 0; +} + +unsigned char a[2]; + +int dn_skipname(unsigned char *ptr, unsigned char *eom) { + unsigned char *saveptr = ptr; + + if (ns_name_skip(&ptr, eom) == -1) + return (-1); + return (ptr - saveptr); +} + +main() +{ + if (dn_skipname (&a[0], &a[1]) == 0) + abort (); + exit (0); +} diff --git a/test/tests/980707-1.c b/test/tests/980707-1.c new file mode 100644 index 0000000..f8fcc32 --- /dev/null +++ b/test/tests/980707-1.c @@ -0,0 +1,46 @@ +#include +#include +#include + +char ** +buildargv (char *input) +{ + static char *arglist[256]; + int numargs = 0; + + while (1) + { + while (*input == ' ') + input++; + if (*input == 0) + break; + arglist [numargs++] = input; + while (*input != ' ' && *input != 0) + input++; + if (*input == 0) + break; + *(input++) = 0; + } + arglist [numargs] = NULL; + return arglist; +} + + +int main() +{ + char **args; + char input[256]; + int i; + + strcpy(input, " a b"); + args = buildargv(input); + + if (strcmp (args[0], "a")) + abort (); + if (strcmp (args[1], "b")) + abort (); + if (args[2] != NULL) + abort (); + + exit (0); +} diff --git a/test/tests/980709-1.c b/test/tests/980709-1.c new file mode 100644 index 0000000..cda8076 --- /dev/null +++ b/test/tests/980709-1.c @@ -0,0 +1,14 @@ +#include + +main() +{ + volatile double a; + double c; + a = 32.0; + c = pow(a, 1.0/3.0); + if (c + 0.1 > 3.174802 + && c - 0.1 < 3.174802) + exit (0); + else + abort (); +} diff --git a/test/tests/980716-1.c b/test/tests/980716-1.c new file mode 100644 index 0000000..91e5518 --- /dev/null +++ b/test/tests/980716-1.c @@ -0,0 +1,26 @@ +#include + +void +stub(int num, ...) +{ + va_list ap; + char *end; + int i; + + for (i = 0; i < 2; i++) { + va_start(ap, num); + while ( 1 ) { + end = va_arg(ap, char *); + if (!end) break; + } + va_end(ap); + } +} + +int +main() +{ + stub(1, "ab", "bc", "cx", 0); + exit (0); +} + diff --git a/test/tests/980929-1.c b/test/tests/980929-1.c new file mode 100644 index 0000000..1d9246e --- /dev/null +++ b/test/tests/980929-1.c @@ -0,0 +1,21 @@ +void f(int i) +{ + if (i != 1000) + abort (); +} + + +int main() +{ + int n=1000; + int i; + + f(n); + for(i=0; i<1; ++i) { + f(n); + n=666; + &n; + } + + exit (0); +} diff --git a/test/tests/981001-1.c b/test/tests/981001-1.c new file mode 100644 index 0000000..5c0340d --- /dev/null +++ b/test/tests/981001-1.c @@ -0,0 +1,38 @@ +#define NG 0x100L + +unsigned long long flg = 0; + +long long sub (int n) +{ + int a, b ; + + if (n >= 2) + { + if (n % 2 == 0) + { + a = sub (n / 2); + + return (a + 2 * sub (n / 2 - 1)) * a; + } + else + { + a = sub (n / 2 + 1); + b = sub (n / 2); + + return a * a + b * b; + } + } + else + return (long long) n; +} + +int main (void) +{ + if (sub (30) != 832040L) + flg |= NG; + + if (flg) + abort (); + + exit (0); +} diff --git a/test/tests/981019-1.c b/test/tests/981019-1.c new file mode 100644 index 0000000..5d1f009 --- /dev/null +++ b/test/tests/981019-1.c @@ -0,0 +1,44 @@ +extern int f2(void); +extern int f3(void); +extern void f1(void); + +void +ff(int fname, int part, int nparts) +{ + if (fname) /* bb 0 */ + { + if (nparts) /* bb 1 */ + f1(); /* bb 2 */ + } + else + fname = 2; /* bb 3 */ + + /* bb 4 is the branch to bb 10 + (bb 10 is physically at the end of the loop) */ + while (f3() /* bb 10 */) + { + if (nparts /* bb 5 */ && f2() /* bb 6 */) + { + f1(); /* bb 7 ... */ + nparts = part; + if (f3()) /* ... bb 7 */ + f1(); /* bb 8 */ + f1(); /* bb 9 */ + break; + } + } + + if (nparts) /* bb 11 */ + f1(); /* bb 12 */ + return; /* bb 13 */ +} + +int main(void) +{ + ff(0, 1, 0); + return 0; +} + +int f3(void) { static int x = 0; x = !x; return x; } +void f1(void) { abort(); } +int f2(void) { abort(); } diff --git a/test/tests/981130-1.c b/test/tests/981130-1.c new file mode 100644 index 0000000..72630b0 --- /dev/null +++ b/test/tests/981130-1.c @@ -0,0 +1,30 @@ +struct s { int a; int b;}; +struct s s1; +struct s s2 = { 1, 2, }; + +void +check (a, b) + int a; + int b; +{ + if (a == b) + exit (0); + else + abort (); +} + +int +main () +{ + int * p; + int x; + + s1.a = 9; + p = & s1.a; + s1 = s2; + x = * p; + + check (x, 1); +} + + diff --git a/test/tests/981206-1.c b/test/tests/981206-1.c new file mode 100644 index 0000000..12ec0ab --- /dev/null +++ b/test/tests/981206-1.c @@ -0,0 +1,17 @@ +/* Verify unaligned address aliasing on Alpha EV[45]. */ + +static unsigned short x, y; + +void foo() +{ + x = 0x345; + y = 0x567; +} + +int main() +{ + foo (); + if (x != 0x345 || y != 0x567) + abort (); + exit (0); +} diff --git a/test/tests/990106-1.c b/test/tests/990106-1.c new file mode 100644 index 0000000..6631bfd --- /dev/null +++ b/test/tests/990106-1.c @@ -0,0 +1,16 @@ +foo(bufp) +char *bufp; +{ + int x = 80; + return (*bufp++ = x ? 'a' : 'b'); +} + +main() +{ + char x; + + if (foo (&x) != 'a') + abort (); + + exit (0); +} diff --git a/test/tests/990106-2.c b/test/tests/990106-2.c new file mode 100644 index 0000000..b05fa89 --- /dev/null +++ b/test/tests/990106-2.c @@ -0,0 +1,22 @@ +unsigned calc_mp(unsigned mod) +{ + unsigned a,b,c; + c=-1; + a=c/mod; + b=0-a*mod; + if (b > mod) { a += 1; b-=mod; } + return b; +} + +int main(int argc, char *argv[]) +{ + unsigned x = 1234; + unsigned y = calc_mp(x); + + if ((sizeof (y) == 4 && y != 680) + || (sizeof (y) == 2 && y != 134)) + exit (y); + exit (0); +} + + diff --git a/test/tests/990117-1.c b/test/tests/990117-1.c new file mode 100644 index 0000000..9589ae7 --- /dev/null +++ b/test/tests/990117-1.c @@ -0,0 +1,16 @@ +int +foo (int x, int y, int i, int j) +{ + double tmp1 = ((double) x / y); + double tmp2 = ((double) i / j); + + return tmp1 < tmp2; +} + +main () +{ + if (foo (2, 24, 3, 4) == 0) + abort (); + return 0; +} + diff --git a/test/tests/990127-1.c b/test/tests/990127-1.c new file mode 100644 index 0000000..c495848 --- /dev/null +++ b/test/tests/990127-1.c @@ -0,0 +1,31 @@ +main() +{ + int a,b,c; + int *pa, *pb, *pc; + int **ppa, **ppb, **ppc; + int i,j,k,x,y,z; + + a = 10; + b = 20; + c = 30; + pa = &a; pb = &b; pc = &c; + ppa = &pa; ppb = &pb; ppc = &pc; + x = 0; y = 0; z = 0; + + for(i=0;i<10;i++){ + if( pa == &a ) pa = &b; + else pa = &a; + while( (*pa)-- ){ + x++; + if( (*pa) < 3 ) break; + else pa = &b; + } + x++; + pa = &b; + } + + if ((*pa) != -5 || (*pb) != -5 || x != 43) + abort (); + + exit (0); +} diff --git a/test/tests/990127-2.c b/test/tests/990127-2.c new file mode 100644 index 0000000..191485c --- /dev/null +++ b/test/tests/990127-2.c @@ -0,0 +1,20 @@ +void +fpEq (double x, double y) +{ + if (x-y > 0.0001 || y-x > 0.0001) + abort (); +} + +void +fpTest (double x, double y) +{ + double result1 = (35.7 * 100.0) / 45.0; + double result2 = (x * 100.0) / y; + fpEq (result1, result2); +} + +main () +{ + fpTest (35.7, 45.0); + exit (0); +} diff --git a/test/tests/990128-1.c b/test/tests/990128-1.c new file mode 100644 index 0000000..cfdab3e --- /dev/null +++ b/test/tests/990128-1.c @@ -0,0 +1,50 @@ +extern int printf (const char *,...); + +struct s { struct s *n; } *p; +struct s ss; +#define MAX 10 +struct s sss[MAX]; +int count = 0; + +void sub( struct s *p, struct s **pp ); +int look( struct s *p, struct s **pp ); + +main() +{ + struct s *pp; + struct s *next; + int i; + + p = &ss; + next = p; + for ( i = 0; i < MAX; i++ ) { + next->n = &sss[i]; + next = next->n; + } + next->n = 0; + + sub( p, &pp ); + if (count != MAX+2) + abort (); + + exit( 0 ); +} + +void sub( struct s *p, struct s **pp ) +{ + for ( ; look( p, pp ); ) { + if ( p ) + p = p->n; + else + break; + } +} + +int look( struct s *p, struct s **pp ) +{ + for ( ; p; p = p->n ) + ; + *pp = p; + count++; + return( 1 ); +} diff --git a/test/tests/990208-1.c b/test/tests/990208-1.c new file mode 100644 index 0000000..c0ba338 --- /dev/null +++ b/test/tests/990208-1.c @@ -0,0 +1,50 @@ +/* As a quality of implementation issue, we should not prevent inlining + of function explicitly marked inline just because a label therein had + its address taken. */ + +#ifndef NO_LABEL_VALUES +static void *ptr1, *ptr2; +static int i = 1; + +static __inline__ void doit(void **pptr, int cond) +{ + if (cond) { + here: + *pptr = &&here; + } +} + +__attribute__ ((noinline)) +static void f(int cond) +{ + doit (&ptr1, cond); +} + +__attribute__ ((noinline)) +static void g(int cond) +{ + doit (&ptr2, cond); +} + +__attribute__ ((noinline)) +void bar(void); + +int main() +{ + f (i); + bar(); + g (i); + +#ifdef __OPTIMIZE__ + if (ptr1 == ptr2) + abort (); +#endif + + exit (0); +} + +void bar(void) { } + +#else /* NO_LABEL_VALUES */ +int main() { exit(0); } +#endif diff --git a/test/tests/990211-1.c b/test/tests/990211-1.c new file mode 100644 index 0000000..e2fe7ee --- /dev/null +++ b/test/tests/990211-1.c @@ -0,0 +1,61 @@ +/* Copyright (C) 1999 Free Software Foundation, Inc. + Contributed by Nathan Sidwell 20 Jan 1999 */ + +/* check range combining boolean operations work */ + +extern void abort(); + +#define N 77 + +void func(int i) +{ + /* fold-const does some clever things with range tests. Make sure + we get (some of) them right */ + + /* these must fail, regardless of the value of i */ + if ((i < 0) && (i >= 0)) + abort(); + if ((i > 0) && (i <= 0)) + abort(); + if ((i >= 0) && (i < 0)) + abort(); + if ((i <= 0) && (i > 0)) + abort(); + + if ((i < N) && (i >= N)) + abort(); + if ((i > N) && (i <= N)) + abort(); + if ((i >= N) && (i < N)) + abort(); + if ((i <= N) && (i > N)) + abort(); + + /* these must pass, regardless of the value of i */ + if (! ((i < 0) || (i >= 0))) + abort(); + if (! ((i > 0) || (i <= 0))) + abort(); + if (! ((i >= 0) || (i < 0))) + abort(); + if (! ((i <= 0) || (i > 0))) + abort(); + + if (! ((i < N) || (i >= N))) + abort(); + if (! ((i > N) || (i <= N))) + abort(); + if (! ((i >= N) || (i < N))) + abort(); + if (! ((i <= N) || (i > N))) + abort(); + + return; +} + +int main() +{ + func(0); + func(1); + return 0; +} diff --git a/test/tests/990222-1.c b/test/tests/990222-1.c new file mode 100644 index 0000000..98b94f3 --- /dev/null +++ b/test/tests/990222-1.c @@ -0,0 +1,11 @@ +char line[4] = { '1', '9', '9', '\0' }; + +int main() +{ + char *ptr = line + 3; + + while ((*--ptr += 1) > '9') *ptr = '0'; + if (line[0] != '2' || line[1] != '0' || line[2] != '0') + abort(); + return 0; +} diff --git a/test/tests/990324-1.c b/test/tests/990324-1.c new file mode 100644 index 0000000..d9baa08 --- /dev/null +++ b/test/tests/990324-1.c @@ -0,0 +1,13 @@ +void f(long i) +{ + if ((signed char)i < 0 || (signed char)i == 0) + abort (); + else + exit (0); +} + +main() +{ + f(0xffffff01); +} + diff --git a/test/tests/990326-1.c b/test/tests/990326-1.c new file mode 100644 index 0000000..c4674c4 --- /dev/null +++ b/test/tests/990326-1.c @@ -0,0 +1,410 @@ +// more than one static local variable with the same name breaks +// because their names are all prefixed with the same string + +struct a { + char a, b; + short c; +}; + +int +a1() +{ + static struct a x = { 1, 2, ~1 }, y = { 65, 2, ~2 }; + + return (x.a == (y.a & ~64) && x.b == y.b); +} + +int +a2() +{ + static struct a x = { 1, 66, ~1 }, y = { 1, 2, ~2 }; + + return (x.a == y.a && (x.b & ~64) == y.b); +} + +int +a3() +{ + static struct a x = { 9, 66, ~1 }, y = { 33, 18, ~2 }; + + return ((x.a & ~8) == (y.a & ~32) && (x.b & ~64) == (y.b & ~16)); +} + +struct b { + int c; + short b, a; +}; + +int +b1() +{ + static struct b x = { ~1, 2, 1 }, y = { ~2, 2, 65 }; + + return (x.a == (y.a & ~64) && x.b == y.b); +} + +int +b2() +{ + static struct b x = { ~1, 66, 1 }, y = { ~2, 2, 1 }; + + return (x.a == y.a && (x.b & ~64) == y.b); +} + +int +b3() +{ + static struct b x = { ~1, 66, 9 }, y = { ~2, 18, 33 }; + + return ((x.a & ~8) == (y.a & ~32) && (x.b & ~64) == (y.b & ~16)); +} + +struct c { + unsigned int c:4, b:14, a:14; +} __attribute__ ((aligned)); + +int +c1() +{ + static struct c x = { ~1, 2, 1 }, y = { ~2, 2, 65 }; + + return (x.a == (y.a & ~64) && x.b == y.b); +} + +int +c2() +{ + static struct c x = { ~1, 66, 1 }, y = { ~2, 2, 1 }; + + return (x.a == y.a && (x.b & ~64) == y.b); +} + +int +c3() +{ + static struct c x = { ~1, 66, 9 }, y = { ~2, 18, 33 }; + + return ((x.a & ~8) == (y.a & ~32) && (x.b & ~64) == (y.b & ~16)); +} + +struct d { + unsigned int a:14, b:14, c:4; +} __attribute__ ((aligned)); + +int +d1() +{ + static struct d x = { 1, 2, ~1 }, y = { 65, 2, ~2 }; + + return (x.a == (y.a & ~64) && x.b == y.b); +} + +int +d2() +{ + static struct d x = { 1, 66, ~1 }, y = { 1, 2, ~2 }; + + return (x.a == y.a && (x.b & ~64) == y.b); +} + +int +d3() +{ + static struct d x = { 9, 66, ~1 }, y = { 33, 18, ~2 }; + + return ((x.a & ~8) == (y.a & ~32) && (x.b & ~64) == (y.b & ~16)); +} + +struct e { + int c:4, b:14, a:14; +} __attribute__ ((aligned)); + +int +e1() +{ + static struct e x = { ~1, -2, -65 }, y = { ~2, -2, -1 }; + + return (x.a == (y.a & ~64) && x.b == y.b); +} + +int +e2() +{ + static struct e x = { ~1, -2, -1 }, y = { ~2, -66, -1 }; + + return (x.a == y.a && (x.b & ~64) == y.b); +} + +int +e3() +{ + static struct e x = { ~1, -18, -33 }, y = { ~2, -66, -9 }; + + return ((x.a & ~8) == (y.a & ~32) && (x.b & ~64) == (y.b & ~16)); +} + +int +e4() +{ + static struct e x = { -1, -1, 0 }; + + return x.a == 0 && x.b & 0x2000; +} + +struct f { + int a:14, b:14, c:4; +} __attribute__ ((aligned)); + +int +f1() +{ + static struct f x = { -65, -2, ~1 }, y = { -1, -2, ~2 }; + + return (x.a == (y.a & ~64) && x.b == y.b); +} + +int +f2() +{ + static struct f x = { -1, -2, ~1 }, y = { -1, -66, ~2 }; + + return (x.a == y.a && (x.b & ~64) == y.b); +} + +int +f3() +{ + static struct f x = { -33, -18, ~1 }, y = { -9, -66, ~2 }; + + return ((x.a & ~8) == (y.a & ~32) && (x.b & ~64) == (y.b & ~16)); +} + +int +f4() +{ + static struct f x = { 0, -1, -1 }; + + return x.a == 0 && x.b & 0x2000; +} + +struct gx { + int c:4, b:14, a:14; +} __attribute__ ((aligned)); +struct gy { + int b:14, a:14, c:4; +} __attribute__ ((aligned)); + +int +g1() +{ + static struct gx x = { ~1, -2, -65 }; + static struct gy y = { -2, -1, ~2 }; + + return (x.a == (y.a & ~64) && x.b == y.b); +} + +int +g2() +{ + static struct gx x = { ~1, -2, -1 }; + static struct gy y = { -66, -1, ~2 }; + + return (x.a == y.a && (x.b & ~64) == y.b); +} + +int +g3() +{ + static struct gx x = { ~1, -18, -33 }; + static struct gy y = { -66, -9, ~2 }; + + return ((x.a & ~8) == (y.a & ~32) && (x.b & ~64) == (y.b & ~16)); +} + +int +g4() +{ + static struct gx x = { ~1, 0x0020, 0x0010 }; + static struct gy y = { 0x0200, 0x0100, ~2 }; + + return ((x.a & 0x00f0) == (y.a & 0x0f00) && + (x.b & 0x00f0) == (y.b & 0x0f00)); +} + +int +g5() +{ + static struct gx x = { ~1, 0x0200, 0x0100 }; + static struct gy y = { 0x0020, 0x0010, ~2 }; + + return ((x.a & 0x0f00) == (y.a & 0x00f0) && + (x.b & 0x0f00) == (y.b & 0x00f0)); +} + +int +g6() +{ + static struct gx x = { ~1, 0xfe20, 0xfd10 }; + static struct gy y = { 0xc22f, 0xc11f, ~2 }; + + return ((x.a & 0x03ff) == (y.a & 0x3ff0) && + (x.b & 0x03ff) == (y.b & 0x3ff0)); +} + +int +g7() +{ + static struct gx x = { ~1, 0xc22f, 0xc11f }; + static struct gy y = { 0xfe20, 0xfd10, ~2 }; + + return ((x.a & 0x3ff0) == (y.a & 0x03ff) && + (x.b & 0x3ff0) == (y.b & 0x03ff)); +} + +struct hx { + int a:14, b:14, c:4; +} __attribute__ ((aligned)); +struct hy { + int c:4, a:14, b:14; +} __attribute__ ((aligned)); + +int +h1() +{ + static struct hx x = { -65, -2, ~1 }; + static struct hy y = { ~2, -1, -2 }; + + return (x.a == (y.a & ~64) && x.b == y.b); +} + +int +h2() +{ + static struct hx x = { -1, -2, ~1 }; + static struct hy y = { ~2, -1, -66 }; + + return (x.a == y.a && (x.b & ~64) == y.b); +} + +int +h3() +{ + static struct hx x = { -33, -18, ~1 }; + static struct hy y = { ~2, -9, -66 }; + + return ((x.a & ~8) == (y.a & ~32) && (x.b & ~64) == (y.b & ~16)); +} + +int +h4() +{ + static struct hx x = { 0x0010, 0x0020, ~1 }; + static struct hy y = { ~2, 0x0100, 0x0200 }; + + return ((x.a & 0x00f0) == (y.a & 0x0f00) && + (x.b & 0x00f0) == (y.b & 0x0f00)); +} + +int +h5() +{ + static struct hx x = { 0x0100, 0x0200, ~1 }; + static struct hy y = { ~2, 0x0010, 0x0020 }; + + return ((x.a & 0x0f00) == (y.a & 0x00f0) && + (x.b & 0x0f00) == (y.b & 0x00f0)); +} + +int +h6() +{ + static struct hx x = { 0xfd10, 0xfe20, ~1 }; + static struct hy y = { ~2, 0xc11f, 0xc22f }; + + return ((x.a & 0x03ff) == (y.a & 0x3ff0) && + (x.b & 0x03ff) == (y.b & 0x3ff0)); +} + +int +h7() +{ + static struct hx x = { 0xc11f, 0xc22f, ~1 }; + static struct hy y = { ~2, 0xfd10, 0xfe20 }; + + return ((x.a & 0x3ff0) == (y.a & 0x03ff) && + (x.b & 0x3ff0) == (y.b & 0x03ff)); +} + +int +main() +{ + if (!a1 ()) + abort (); + if (!a2 ()) + abort (); + if (!a3 ()) + abort (); + if (!b1 ()) + abort (); + if (!b2 ()) + abort (); + if (!b3 ()) + abort (); + if (!c1 ()) + abort (); + if (!c2 ()) + abort (); + if (!c3 ()) + abort (); + if (!d1 ()) + abort (); + if (!d2 ()) + abort (); + if (!d3 ()) + abort (); + if (!e1 ()) + abort (); + if (!e2 ()) + abort (); + if (!e3 ()) + abort (); + if (!e4 ()) + abort (); + if (!f1 ()) + abort (); + if (!f2 ()) + abort (); + if (!f3 ()) + abort (); + if (!f4 ()) + abort (); + if (!g1 ()) + abort (); + if (!g2 ()) + abort (); + if (!g3 ()) + abort (); + if (g4 ()) + abort (); + if (g5 ()) + abort (); + if (!g6 ()) + abort (); + if (!g7 ()) + abort (); + if (!h1 ()) + abort (); + if (!h2 ()) + abort (); + if (!h3 ()) + abort (); + if (h4 ()) + abort (); + if (h5 ()) + abort (); + if (!h6 ()) + abort (); + if (!h7 ()) + abort (); + exit (0); +} diff --git a/test/tests/990404-1.c b/test/tests/990404-1.c new file mode 100644 index 0000000..be917d6 --- /dev/null +++ b/test/tests/990404-1.c @@ -0,0 +1,27 @@ + +int x[10] = { 0,1,2,3,4,5,6,7,8,9}; + +int +main() +{ + int niterations = 0, i; + + for (;;) { + int i, mi, max; + max = 0; + for (i = 0; i < 10 ; i++) { + if (x[i] > max) { + max = x[i]; + mi = i; + } + } + if (max == 0) + break; + x[mi] = 0; + niterations++; + if (niterations > 10) + abort (); + } + + exit (0); +} diff --git a/test/tests/990513-1.c b/test/tests/990513-1.c new file mode 100644 index 0000000..6ad228f --- /dev/null +++ b/test/tests/990513-1.c @@ -0,0 +1,26 @@ +#include + +void foo (int *BM_tab, int j) +{ + int *BM_tab_base; + + BM_tab_base = BM_tab; + BM_tab += 0400; + while (BM_tab_base != BM_tab) + { + *--BM_tab = j; + *--BM_tab = j; + *--BM_tab = j; + *--BM_tab = j; + } +} + +int main () +{ + int BM_tab[0400]; + memset (BM_tab, 0, sizeof (BM_tab)); + foo (BM_tab, 6); + if (BM_tab[0] != 6) + abort (); + return 0; +} diff --git a/test/tests/990524-1.c b/test/tests/990524-1.c new file mode 100644 index 0000000..6cfb349 --- /dev/null +++ b/test/tests/990524-1.c @@ -0,0 +1,26 @@ +char a[] = "12345"; +char b[] = "12345"; + +void loop (char * pz, char * pzDta) +{ + for (;;) { + switch (*(pz++) = *(pzDta++)) { + case 0: + goto loopDone2; + + case '"': + case '\\': + pz[-1] = '\\'; + *(pz++) = pzDta[-1]; + } + } loopDone2:; + + if (a - pz != b - pzDta) + abort (); +} + +main() +{ + loop (a, b); + exit (0); +} diff --git a/test/tests/990525-1.c b/test/tests/990525-1.c new file mode 100644 index 0000000..39b65d1 --- /dev/null +++ b/test/tests/990525-1.c @@ -0,0 +1,23 @@ +struct blah { + int m1, m2; +}; + +void die(struct blah arg) +{ + int i ; + struct blah buf[1]; + + for (i = 0; i < 1 ; buf[i++] = arg) + ; + if (buf[0].m1 != 1) { + abort (); + } +} + +int main() +{ + struct blah s = { 1, 2 }; + + die(s); + exit (0); +} diff --git a/test/tests/990525-2.c b/test/tests/990525-2.c new file mode 100644 index 0000000..7497852 --- /dev/null +++ b/test/tests/990525-2.c @@ -0,0 +1,39 @@ +typedef struct { + int v[4]; +} Test1; + +Test1 func2(); + +int func1() +{ + Test1 test; + test = func2(); + + if (test.v[0] != 10) + abort (); + if (test.v[1] != 20) + abort (); + if (test.v[2] != 30) + abort (); + if (test.v[3] != 40) + abort (); +} + +Test1 func2() +{ + Test1 tmp; + tmp.v[0] = 10; + tmp.v[1] = 20; + tmp.v[2] = 30; + tmp.v[3] = 40; + return tmp; +} + + +int main() +{ + func1(); + exit (0); +} + + diff --git a/test/tests/990527-1.c b/test/tests/990527-1.c new file mode 100644 index 0000000..a865cbb --- /dev/null +++ b/test/tests/990527-1.c @@ -0,0 +1,30 @@ +int sum; + +void +g (int i) +{ + sum += i; +} + +void +f(int j) +{ + int i; + + for (i = 0; i < 9; i++) + { + j++; + g (j); + j = 9; + } +} + +int +main () +{ + f (0); + if (sum != 81) + abort (); + exit (0); +} + diff --git a/test/tests/990531-1.c b/test/tests/990531-1.c new file mode 100644 index 0000000..358a742 --- /dev/null +++ b/test/tests/990531-1.c @@ -0,0 +1,23 @@ + unsigned long bad(int reg, unsigned long inWord) + { + union { + unsigned long word; + unsigned char byte[4]; + } data; + + data.word = inWord; + data.byte[reg] = 0; + + return data.word; + } + +main() +{ + /* XXX This test could be generalized. */ + if (sizeof (long) != 2) + exit (0); + + if (bad (0, 0xdead) == 0xdead) + abort (); + exit (0); +} diff --git a/test/tests/990604-1.c b/test/tests/990604-1.c new file mode 100644 index 0000000..4e23a8e --- /dev/null +++ b/test/tests/990604-1.c @@ -0,0 +1,19 @@ +int b; +void f () +{ + int i = 0; + if (b == 0) + do { + b = i; + i++; + } while (i < 10); +} + +int main () +{ + f (); + if (b != 9) + abort (); + return 0; +} + diff --git a/test/tests/990628-1.c b/test/tests/990628-1.c new file mode 100644 index 0000000..62fb834 --- /dev/null +++ b/test/tests/990628-1.c @@ -0,0 +1,58 @@ +#include + +struct { + long sqlcode; +} sqlca; + + +struct data_record { + int dummy; + int a[100]; +} *data_ptr, data_tmp; + + +int +num_records() +{ + return 1; +} + + +void +fetch() +{ + static int fetch_count; + + memset(&data_tmp, 0x55, sizeof(data_tmp)); + sqlca.sqlcode = (++fetch_count > 1 ? 100 : 0); +} + + +void +load_data() { + struct data_record *p; + int num = num_records(); + + data_ptr = malloc(num * sizeof(struct data_record)); + memset(data_ptr, 0xaa, num * sizeof(struct data_record)); + + fetch(); + p = data_ptr; + while (sqlca.sqlcode == 0) { + *p++ = data_tmp; + fetch(); + } +} + + +main() +{ + load_data(); + if (sizeof (int) == 2 && data_ptr[0].dummy != 0x5555) + abort (); +#if 0 + else if (sizeof (int) > 2 && data_ptr[0].dummy != 0x55555555) + abort (); +#endif + exit (0); +} diff --git a/test/tests/990804-1.c b/test/tests/990804-1.c new file mode 100644 index 0000000..130c0fb --- /dev/null +++ b/test/tests/990804-1.c @@ -0,0 +1,30 @@ +int gfbyte ( void ) +{ + return 0; +} + +int main( void ) +{ + int i,j,k ; + + i = gfbyte(); + + i = i + 1 ; + + if ( i == 0 ) + k = -0 ; + else + k = i + 0 ; + + if (i != 1) + abort (); + + k = 1 ; + if ( k <= i) + do + j = gfbyte () ; + while ( k++ < i ) ; + + exit (0); +} + diff --git a/test/tests/990811-1.c b/test/tests/990811-1.c new file mode 100644 index 0000000..95e1da9 --- /dev/null +++ b/test/tests/990811-1.c @@ -0,0 +1,31 @@ +struct s {long a; int b;}; + +int foo(int x, void *y) +{ + switch(x) { + case 0: return ((struct s*)y)->a; + case 1: return *(signed char*)y; + case 2: return *(short*)y; + } + abort(); +} + +int main () +{ + struct s s; + short sh[10]; + signed char c[10]; + int i; + + s.a = 1; + s.b = 2; + for (i = 0; i < 10; i++) { + sh[i] = i; + c[i] = i; + } + + if (foo(0, &s) != 1) abort(); + if (foo(1, c+3) != 3) abort(); + if (foo(2, sh+3) != 3) abort(); + exit(0); +} diff --git a/test/tests/990826-0.c b/test/tests/990826-0.c new file mode 100644 index 0000000..90f7b73 --- /dev/null +++ b/test/tests/990826-0.c @@ -0,0 +1,26 @@ +/* +From: niles@fan745.gsfc.nasa.gov +To: fortran@gnu.org +Subject: Re: Scary problems in g77 for RedHat 6.0. (glibc-2.1) +Date: Sun, 06 Jun 1999 23:37:23 -0400 +X-UIDL: 9c1e40c572e3b306464f703461764cd5 +*/ + +#include + +int +main() +{ + if (floor (0.1) != 0.) + abort (); + return 0; +} + +/* +It will result in 36028797018963968.000000 on Alpha RedHat Linux 6.0 +using glibc-2.1 at least on my 21064. This may result in g77 bug +reports concerning the INT() function, just so you know. + + Thanks, + Rick Niles. +*/ diff --git a/test/tests/990827-1.c b/test/tests/990827-1.c new file mode 100644 index 0000000..6116e78 --- /dev/null +++ b/test/tests/990827-1.c @@ -0,0 +1,21 @@ +unsigned test(unsigned one , unsigned bit) +{ + unsigned val= bit & 1; + unsigned zero= one >> 1; + + val++; + return zero + ( val>> 1 ); +} + +int main() +{ + if (test (1,0) != 0) + abort (); + if (test (1,1) != 1) + abort (); + if (test (1,65535) != 1) + abort (); + exit (0); + + return 0; +} diff --git a/test/tests/990829-1.c b/test/tests/990829-1.c new file mode 100644 index 0000000..82f8186 --- /dev/null +++ b/test/tests/990829-1.c @@ -0,0 +1,15 @@ +double test (const double le, const double ri) +{ + double val = ( ri - le ) / ( ri * ( le + 1.0 ) ); + return val; +} + +int main () +{ + double retval; + + retval = test(1.0,2.0); + if (retval < 0.24 || retval > 0.26) + abort (); + exit (0); +} diff --git a/test/tests/990923-1.c b/test/tests/990923-1.c new file mode 100644 index 0000000..f9b6f16 --- /dev/null +++ b/test/tests/990923-1.c @@ -0,0 +1,19 @@ +#define mask 0xff00L +#define value 0xab00L + +long +foo (long x) +{ + if ((x & mask) == value) + return x & 0xffL; + return 1; +} + +int +main (void) +{ + if (foo (value) != 0 || foo (0) != 1) + abort (); + + exit (0); +} diff --git a/test/tests/991014-1.c b/test/tests/991014-1.c new file mode 100644 index 0000000..7b1b5fa --- /dev/null +++ b/test/tests/991014-1.c @@ -0,0 +1,50 @@ + +typedef typeof(sizeof(char)) Size_t; + +#define bufsize ((1L << (8 * sizeof(Size_t) - 2))-256) + +struct huge_struct +{ + short buf[bufsize]; + int a; + int b; + int c; + int d; +}; + +union huge_union +{ + int a; + char buf[bufsize]; +}; + +unsigned long union_size() +{ + return sizeof(union huge_union); +} + +unsigned long struct_size() +{ + return sizeof(struct huge_struct); +} + +unsigned long struct_a_offset() +{ + return (unsigned long)(&((struct huge_struct *) 0)->a); +} + +int main() +{ + /* Check the exact sizeof value. bufsize is aligned on 256b. */ + if (union_size() != sizeof(char) * bufsize) + abort(); + + if (struct_size() != sizeof(short) * bufsize + 4*sizeof(int)) + abort(); + + if (struct_a_offset() < sizeof(short) * bufsize) + abort(); + + return 0; +} + diff --git a/test/tests/991016-1.c b/test/tests/991016-1.c new file mode 100644 index 0000000..c312234 --- /dev/null +++ b/test/tests/991016-1.c @@ -0,0 +1,55 @@ +/* Two of these types will, on current gcc targets, have the same + mode but have different alias sets. DOIT tries to get gcse to + invalidly hoist one of the values out of the loop. */ + +typedef int T0; +typedef long T1; +typedef long long T2; + +int +doit(int sel, int n, void *p) +{ + T0 * const p0 = p; + T1 * const p1 = p; + T2 * const p2 = p; + + switch (sel) + { + case 0: + do + *p0 += *p0; + while (--n); + return *p0 == 0; + + case 1: + do + *p1 += *p1; + while (--n); + return *p1 == 0; + + case 2: + do + *p2 += *p2; + while (--n); + return *p2 == 0; + + default: + abort (); + } +} + +int +main() +{ + T0 v0; T1 v1; T2 v2; + + v0 = 1; doit(0, 5, &v0); + v1 = 1; doit(1, 5, &v1); + v2 = 1; doit(2, 5, &v2); + + if (v0 != 32) abort (); + if (v1 != 32) abort (); + if (v2 != 32) abort (); + + exit (0); +} diff --git a/test/tests/991019-1.c b/test/tests/991019-1.c new file mode 100644 index 0000000..39726cd --- /dev/null +++ b/test/tests/991019-1.c @@ -0,0 +1,28 @@ +typedef struct { + double epsilon; +} material_type; + +material_type foo(double x) +{ + material_type m; + + m.epsilon = 1.0 + x; + return m; +} + +main() +{ + int i; + material_type x; + + /* We must iterate enough times to overflow the FP stack on the + x86. */ + for (i = 0; i < 10; i++) + { + x = foo (1.0); + if (x.epsilon != 1.0 + 1.0) + abort (); + } + + exit (0); +} diff --git a/test/tests/991023-1.c b/test/tests/991023-1.c new file mode 100644 index 0000000..697eb93 --- /dev/null +++ b/test/tests/991023-1.c @@ -0,0 +1,24 @@ + + +int blah; +foo() +{ + int i; + + for (i=0 ; i< 7 ; i++) + { + if (i == 7 - 1) + blah = 0xfcc; + else + blah = 0xfee; + } + return blah; +} + + +main() +{ + if (foo () != 0xfcc) + abort (); + exit (0); +} diff --git a/test/tests/991030-1.c b/test/tests/991030-1.c new file mode 100644 index 0000000..dff11d0 --- /dev/null +++ b/test/tests/991030-1.c @@ -0,0 +1,9 @@ +double x = 0x1.fp1; +int main() +{ + if (x != 3.875) + abort (); + exit (0); +} + + diff --git a/test/tests/991112-1.c b/test/tests/991112-1.c new file mode 100644 index 0000000..e43c7be --- /dev/null +++ b/test/tests/991112-1.c @@ -0,0 +1,19 @@ +/* This code was miscompiled at -O3 on x86. + Reported by Jim Meyering; distilled from bash. */ + +int rl_show_char (int c) { return 0; } + +int rl_character_len (int c, int pos) +{ + return isprint (c) ? 1 : 2; +} + +int main(void) +{ + int (*x)(int, int) = rl_character_len; + if (x('a', 1) != 1) + abort(); + if (x('\002', 1) != 2) + abort(); + return 0; +} diff --git a/test/tests/991201-1.c b/test/tests/991201-1.c new file mode 100644 index 0000000..16595a4 --- /dev/null +++ b/test/tests/991201-1.c @@ -0,0 +1,39 @@ +struct vc_data { + unsigned long space; + unsigned char vc_palette[16*3]; +}; + +struct vc { + struct vc_data *d; +}; + +struct vc_data a_con; +struct vc vc_cons[63] = { &a_con }; +int default_red[16]; +int default_grn[16]; +int default_blu[16]; + +extern void bar(int); + +void reset_palette(int currcons) +{ + int j, k; + for (j=k=0; j<16; j++) { + (vc_cons[currcons].d->vc_palette) [k++] = default_red[j]; + (vc_cons[currcons].d->vc_palette) [k++] = default_grn[j]; + (vc_cons[currcons].d->vc_palette) [k++] = default_blu[j]; + } + bar(k); +} + +void bar(int k) +{ + if (k != 16*3) + abort(); +} + +int main() +{ + reset_palette(0); + exit(0); +} diff --git a/test/tests/991202-1.c b/test/tests/991202-1.c new file mode 100644 index 0000000..502acc7 --- /dev/null +++ b/test/tests/991202-1.c @@ -0,0 +1,16 @@ +int x, y; + +int +main() +{ + x = 2; + y = x; + do + { + x = y; + y = 2 * y; + } + while ( ! ((y - x) >= 20)); + exit (0); +} + diff --git a/test/tests/991202-2.c b/test/tests/991202-2.c new file mode 100644 index 0000000..fa97e2d --- /dev/null +++ b/test/tests/991202-2.c @@ -0,0 +1,17 @@ + +int +f1 () +{ + unsigned long x, y = 1; + + x = ((y * 8192) - 216) % 16; + return x; +} + +int +main () +{ + if (f1 () != 8) + abort (); + exit (0); +} diff --git a/test/tests/991202-3.c b/test/tests/991202-3.c new file mode 100644 index 0000000..f5718b2 --- /dev/null +++ b/test/tests/991202-3.c @@ -0,0 +1,22 @@ + +unsigned int f (unsigned int a) +{ + return a * 65536 / 8; +} + +unsigned int g (unsigned int a) +{ + return a * 65536; +} + +unsigned int h (unsigned int a) +{ + return a / 8; +} + +int main () +{ + if (f (65536) != h (g (65536))) + abort (); + exit (0); +} diff --git a/test/tests/991216-1.c b/test/tests/991216-1.c new file mode 100644 index 0000000..bfedefb --- /dev/null +++ b/test/tests/991216-1.c @@ -0,0 +1,116 @@ +#define VALUE 0x123456789abcdefLL +#define AFTER 0x55 + +void +test1 (int a, long long value, int after) +{ + if (a != 1 + || value != VALUE + || after != AFTER) + abort (); +} + +void +test2 (int a, int b, long long value, int after) +{ + if (a != 1 + || b != 2 + || value != VALUE + || after != AFTER) + abort (); +} + +void +test3 (int a, int b, int c, long long value, int after) +{ + if (a != 1 + || b != 2 + || c != 3 + || value != VALUE + || after != AFTER) + abort (); +} + +void +test4 (int a, int b, int c, int d, long long value, int after) +{ + if (a != 1 + || b != 2 + || c != 3 + || d != 4 + || value != VALUE + || after != AFTER) + abort (); +} + +void +test5 (int a, int b, int c, int d, int e, long long value, int after) +{ + if (a != 1 + || b != 2 + || c != 3 + || d != 4 + || e != 5 + || value != VALUE + || after != AFTER) + abort (); +} + +void +test6 (int a, int b, int c, int d, int e, int f, long long value, int after) +{ + if (a != 1 + || b != 2 + || c != 3 + || d != 4 + || e != 5 + || f != 6 + || value != VALUE + || after != AFTER) + abort (); +} + +void +test7 (int a, int b, int c, int d, int e, int f, int g, long long value, int after) +{ + if (a != 1 + || b != 2 + || c != 3 + || d != 4 + || e != 5 + || f != 6 + || g != 7 + || value != VALUE + || after != AFTER) + abort (); +} + +void +test8 (int a, int b, int c, int d, int e, int f, int g, int h, long long value, int after) +{ + if (a != 1 + || b != 2 + || c != 3 + || d != 4 + || e != 5 + || f != 6 + || g != 7 + || h != 8 + || value != VALUE + || after != AFTER) + abort (); +} + +int +main () +{ + test1 (1, VALUE, AFTER); + test2 (1, 2, VALUE, AFTER); + test3 (1, 2, 3, VALUE, AFTER); + test4 (1, 2, 3, 4, VALUE, AFTER); + test5 (1, 2, 3, 4, 5, VALUE, AFTER); + test6 (1, 2, 3, 4, 5, 6, VALUE, AFTER); + test7 (1, 2, 3, 4, 5, 6, 7, VALUE, AFTER); + test8 (1, 2, 3, 4, 5, 6, 7, 8, VALUE, AFTER); + exit (0); +} diff --git a/test/tests/991216-2.c b/test/tests/991216-2.c new file mode 100644 index 0000000..0956135 --- /dev/null +++ b/test/tests/991216-2.c @@ -0,0 +1,40 @@ +#include + +#define VALUE 0x123456789abcdefLL +#define AFTER 0x55 + +void +test (int n, ...) +{ + va_list ap; + int i; + + va_start (ap, n); + for (i = 2; i <= n; i++) + { + if (va_arg (ap, int) != i) + abort (); + } + + if (va_arg (ap, long long) != VALUE) + abort (); + + if (va_arg (ap, int) != AFTER) + abort (); + + va_end (ap); +} + +int +main () +{ + test (1, VALUE, AFTER); + test (2, 2, VALUE, AFTER); + test (3, 2, 3, VALUE, AFTER); + test (4, 2, 3, 4, VALUE, AFTER); + test (5, 2, 3, 4, 5, VALUE, AFTER); + test (6, 2, 3, 4, 5, 6, VALUE, AFTER); + test (7, 2, 3, 4, 5, 6, 7, VALUE, AFTER); + test (8, 2, 3, 4, 5, 6, 7, 8, VALUE, AFTER); + exit (0); +} diff --git a/test/tests/991216-4.c b/test/tests/991216-4.c new file mode 100644 index 0000000..4cc4c8c --- /dev/null +++ b/test/tests/991216-4.c @@ -0,0 +1,16 @@ +/* Test against a problem with loop reversal. */ +static void bug(int size, int tries) +{ + int i; + int num = 0; + while (num < size) + { + for (i = 1; i < tries; i++) num++; + } +} + +int main() +{ + bug(5, 10); + exit (0); +} diff --git a/test/tests/991221-1.c b/test/tests/991221-1.c new file mode 100644 index 0000000..22952a4 --- /dev/null +++ b/test/tests/991221-1.c @@ -0,0 +1,13 @@ +int main( void ) +{ + unsigned long totalsize = 80; + unsigned long msize = 64; + + if (sizeof(long) != 4) + exit(0); + + if ( totalsize > (32767L * 2UL + 1) + || (msize != 0 && ((msize - 1) > (32767L * 2UL + 1) ))) + abort(); + exit( 0 ); +} diff --git a/test/tests/991227-1.c b/test/tests/991227-1.c new file mode 100644 index 0000000..46b0951 --- /dev/null +++ b/test/tests/991227-1.c @@ -0,0 +1,11 @@ +char* doit(int flag) +{ + return 1 + (flag ? "\0wrong\n" : "\0right\n"); +} +int main() +{ + char *result = doit(0); + if (*result == 'r' && result[1] == 'i') + exit(0); + abort(); +} diff --git a/test/tests/991228-1.c b/test/tests/991228-1.c new file mode 100644 index 0000000..c6fe78e --- /dev/null +++ b/test/tests/991228-1.c @@ -0,0 +1,25 @@ +__extension__ union { double d; int i[2]; } u = { d: -0.25 }; + +/* This assumes the endianness of words in a long long is the same as + that for doubles, which doesn't hold for a few platforms, but we + can probably special case them here, as appropriate. */ +long long endianness_test = 1; +#define MSW (*(int*)&endianness_test) + +int +signbit(double x) +{ + __extension__ union { double d; int i[2]; } u = { d: x }; + return u.i[MSW] < 0; +} + +int main(void) +{ + if (2*sizeof(int) != sizeof(double) || u.i[MSW] >= 0) + exit(0); + + if (!signbit(-0.25)) + abort(); + + exit(0); +} diff --git a/test/tests/alias-11.c b/test/tests/alias-11.c new file mode 100644 index 0000000..36175d7 --- /dev/null +++ b/test/tests/alias-11.c @@ -0,0 +1,111 @@ +/* { dg-do run } */ +/* { dg-require-alias "" } */ +/* { dg-options "-O2" } */ + +#include +#include +#include + +typedef struct dw_cfi_struct +{ + struct dw_cfi_struct *dw_cfi_next; + const char *dw_cfi_addr; +} +dw_cfi_node; + +typedef struct dw_fde_struct +{ + const char *dw_fde_current_label; + dw_cfi_node *dw_fde_cfi; +} +dw_fde_node; + +dw_cfi_node *cie_cfi_head; +unsigned fde_table_in_use; +dw_fde_node *fde_table; + +__inline__ void +add_cfi (dw_cfi_node **list_head, dw_cfi_node *cfi) +{ + dw_cfi_node **p; + + for (p = list_head; (*p) != ((void *)0); p = &(*p)->dw_cfi_next) + ; + + *p = cfi; +} + +__inline__ struct dw_cfi_struct * +new_cfi (void) +{ + dw_cfi_node *cfi = (dw_cfi_node *) malloc (sizeof (dw_cfi_node)); + + memset (cfi, 0, sizeof (dw_cfi_node)); + return cfi; +} + +char * +dwarf2out_cfi_label (void) +{ + static char label[20]; + static unsigned long label_num = 0; + + sprintf (label, "*.%s%u", "LCFI", (unsigned) (label_num++)); + return label; +} + +void +add_fde_cfi (const char *label, dw_cfi_node *cfi) +{ + if (label) + { + dw_fde_node *fde = fde_table + fde_table_in_use - 1; + + if (*label == 0) + label = dwarf2out_cfi_label (); + + if (fde->dw_fde_current_label == ((void *)0) + || strcmp (label, fde->dw_fde_current_label)) + { + dw_cfi_node *xcfi; + + fde->dw_fde_current_label = label = strdup (label); + + xcfi = new_cfi (); + xcfi->dw_cfi_addr = label; + add_cfi (&fde->dw_fde_cfi, xcfi); + } + + add_cfi (&fde->dw_fde_cfi, cfi); + } + else + add_cfi (&cie_cfi_head, cfi); +} + +int +main () +{ + dw_cfi_node *cfi; + dw_fde_node *fde; + + fde_table_in_use = 1; + fde_table = (dw_fde_node *) realloc (fde_table, + sizeof (dw_fde_node)); + memset (fde_table, 0, sizeof (dw_fde_node)); + cfi = new_cfi (); + add_fde_cfi ("", cfi); + + fde = &fde_table[0]; + cfi = fde->dw_fde_cfi; + + if (cfi == NULL) + abort (); + + if (cfi->dw_cfi_addr == NULL) + abort (); + + if (strcmp ("*.LCFI0", cfi->dw_cfi_addr)) + abort (); + + return 0; +} diff --git a/test/tests/align-1.c b/test/tests/align-1.c new file mode 100644 index 0000000..2dc1aad --- /dev/null +++ b/test/tests/align-1.c @@ -0,0 +1,9 @@ +typedef int new_int __attribute__ ((aligned(16))); +struct S { int x; }; + +int main() +{ + if (sizeof(struct S) != sizeof(int)) + abort (); + return 0; +} diff --git a/test/tests/align-2.c b/test/tests/align-2.c new file mode 100644 index 0000000..b886da7 --- /dev/null +++ b/test/tests/align-2.c @@ -0,0 +1,50 @@ +/* Simple alignment checks; + looking for compiler/assembler alignment disagreements, + agreement between struct initialization and access. */ +struct a_short { char c; short s; } s_c_s = { 'a', 13 }; +struct a_int { char c ; int i; } s_c_i = { 'b', 14 }; +struct b_int { short s; int i; } s_s_i = { 15, 16 }; +struct a_float { char c; float f; } s_c_f = { 'c', 17.0 }; +struct b_float { short s; float f; } s_s_f = { 18, 19.0 }; +struct a_double { char c; double d; } s_c_d = { 'd', 20.0 }; +struct b_double { short s; double d; } s_s_d = { 21, 22.0 }; +struct c_double { int i; double d; } s_i_d = { 23, 24.0 }; +struct d_double { float f; double d; } s_f_d = { 25.0, 26.0 }; +struct a_ldouble { char c; long double ld; } s_c_ld = { 'e', 27.0 }; +struct b_ldouble { short s; long double ld; } s_s_ld = { 28, 29.0 }; +struct c_ldouble { int i; long double ld; } s_i_ld = { 30, 31.0 }; +struct d_ldouble { float f; long double ld; } s_f_ld = { 32.0, 33.0 }; +struct e_ldouble { double d; long double ld; } s_d_ld = { 34.0, 35.0 }; + +int main () +{ + if (s_c_s.c != 'a') abort (); + if (s_c_s.s != 13) abort (); + if (s_c_i.c != 'b') abort (); + if (s_c_i.i != 14) abort (); + if (s_s_i.s != 15) abort (); + if (s_s_i.i != 16) abort (); + if (s_c_f.c != 'c') abort (); + if (s_c_f.f != 17.0) abort (); + if (s_s_f.s != 18) abort (); + if (s_s_f.f != 19.0) abort (); + if (s_c_d.c != 'd') abort (); + if (s_c_d.d != 20.0) abort (); + if (s_s_d.s != 21) abort (); + if (s_s_d.d != 22.0) abort (); + if (s_i_d.i != 23) abort (); + if (s_i_d.d != 24.0) abort (); + if (s_f_d.f != 25.0) abort (); + if (s_f_d.d != 26.0) abort (); + if (s_c_ld.c != 'e') abort (); + if (s_c_ld.ld != 27.0) abort (); + if (s_s_ld.s != 28) abort (); + if (s_s_ld.ld != 29.0) abort (); + if (s_i_ld.i != 30) abort (); + if (s_i_ld.ld != 31.0) abort (); + if (s_f_ld.f != 32.0) abort (); + if (s_f_ld.ld != 33.0) abort (); + if (s_d_ld.d != 34.0) abort (); + if (s_d_ld.ld != 35.0) abort (); + return 0; +} diff --git a/test/tests/anon-1.c b/test/tests/anon-1.c new file mode 100644 index 0000000..f8ab05f --- /dev/null +++ b/test/tests/anon-1.c @@ -0,0 +1,29 @@ +/* Copyright (C) 2001 Free Software Foundation, Inc. */ + +/* Source: Neil Booth, 4 Nov 2001, derived from PR 2820 - field lookup in + nested anonymous entities was broken. */ + +struct +{ + int x; + struct + { + int a; + union + { + int b; + } zz; + } yy; +} foo; + +int +main(int argc, char *argv[]) +{ + foo.yy.zz.b = 6; + foo.yy.a = 5; + + if (foo.yy.zz.b != 6) + abort (); + + return 0; +} diff --git a/test/tests/arith-1.c b/test/tests/arith-1.c new file mode 100644 index 0000000..58df322 --- /dev/null +++ b/test/tests/arith-1.c @@ -0,0 +1,15 @@ +unsigned +sat_add (unsigned i) +{ + unsigned ret = i + 1; + if (ret < i) + ret = i; + return ret; +} + +main () +{ + if (sat_add (~0U) != ~0U) + abort (); + exit (0); +} diff --git a/test/tests/arith-rand-ll.c b/test/tests/arith-rand-ll.c new file mode 100644 index 0000000..db91959 --- /dev/null +++ b/test/tests/arith-rand-ll.c @@ -0,0 +1,114 @@ +long long +simple_rand () +{ + static unsigned long long seed = 47114711; + unsigned long long this = seed * 1103515245 + 12345; + seed = this; + return this >> 8; +} + +unsigned long long int +random_bitstring () +{ + unsigned long long int x; + int n_bits; + long long ran; + int tot_bits = 0; + + x = 0; + for (;;) + { + ran = simple_rand (); + n_bits = (ran >> 1) % 16; + tot_bits += n_bits; + + if (n_bits == 0) + return x; + else + { + x <<= n_bits; + if (ran & 1) + x |= (1 << n_bits) - 1; + + if (tot_bits > 8 * sizeof (long long) + 6) + return x; + } + } +} + +#define ABS(x) ((x) >= 0 ? (x) : -(x)) + +main () +{ + long long int i; + + for (i = 0; i < 200; i++) + { + unsigned long long x, y; + x = random_bitstring (); + y = random_bitstring (); + + if (sizeof (int) == sizeof (long long)) + goto save_time; + + { unsigned long long xx = x, yy = y, r1, r2; + if (yy == 0) continue; + r1 = xx / yy; + r2 = xx % yy; + if (r2 >= yy || r1 * yy + r2 != xx) + abort (); + } + { signed long long xx = x, yy = y, r1, r2; + if ((unsigned long long) xx << 1 == 0 && yy == -1) + continue; + r1 = xx / yy; + r2 = xx % yy; + if (ABS (r2) >= (unsigned long long) ABS (yy) || (signed long long) (r1 * yy + r2) != xx) + abort (); + } + save_time: + { unsigned int xx = x, yy = y, r1, r2; + if (yy == 0) continue; + r1 = xx / yy; + r2 = xx % yy; + if (r2 >= yy || r1 * yy + r2 != xx) + abort (); + } + { signed int xx = x, yy = y, r1, r2; + if ((unsigned int) xx << 1 == 0 && yy == -1) + continue; + r1 = xx / yy; + r2 = xx % yy; + if (ABS (r2) >= (unsigned int) ABS (yy) || (signed int) (r1 * yy + r2) != xx || ((xx < 0) != (r2 < 0) && r2)) + abort (); + } + { unsigned short xx = x, yy = y, r1, r2; + if (yy == 0) continue; + r1 = xx / yy; + r2 = xx % yy; + if (r2 >= yy || r1 * yy + r2 != xx) + abort (); + } + { signed short xx = x, yy = y, r1, r2; + r1 = xx / yy; + r2 = xx % yy; + if (ABS (r2) >= (unsigned short) ABS (yy) || (signed short) (r1 * yy + r2) != xx) + abort (); + } + { unsigned char xx = x, yy = y, r1, r2; + if (yy == 0) continue; + r1 = xx / yy; + r2 = xx % yy; + if (r2 >= yy || r1 * yy + r2 != xx) + abort (); + } + { signed char xx = x, yy = y, r1, r2; + r1 = xx / yy; + r2 = xx % yy; + if (ABS (r2) >= (unsigned char) ABS (yy) || (signed char) (r1 * yy + r2) != xx) + abort (); + } + } + + exit (0); +} diff --git a/test/tests/arith-rand.c b/test/tests/arith-rand.c new file mode 100644 index 0000000..e97ca3d --- /dev/null +++ b/test/tests/arith-rand.c @@ -0,0 +1,114 @@ +long +simple_rand () +{ + static unsigned long seed = 47114711; + unsigned long this = seed * 11035 + 12345; + seed = this; + return this >> 8; +} + +unsigned long int +random_bitstring () +{ + unsigned long int x; + int n_bits; + long ran; + int tot_bits = 0; + + x = 0; + for (;;) + { + ran = simple_rand (); + n_bits = (ran >> 1) % 16; + tot_bits += n_bits; + + if (n_bits == 0) + return x; + else + { + x <<= n_bits; + if (ran & 1) + x |= (1 << n_bits) - 1; + + if (tot_bits > 8 * sizeof (long) + 6) + return x; + } + } +} + +#define ABS(x) ((x) >= 0 ? (x) : -(x)) + +main () +{ + long int i; + + for (i = 0; i < 1000; i++) + { + unsigned long x, y; + x = random_bitstring (); + y = random_bitstring (); + + if (sizeof (int) == sizeof (long)) + goto save_time; + + { unsigned long xx = x, yy = y, r1, r2; + if (yy == 0) continue; + r1 = xx / yy; + r2 = xx % yy; + if (r2 >= yy || r1 * yy + r2 != xx) + abort (); + } + { signed long xx = x, yy = y, r1, r2; + if ((unsigned long) xx << 1 == 0 && yy == -1) + continue; + r1 = xx / yy; + r2 = xx % yy; + if (ABS (r2) >= (unsigned long) ABS (yy) || (signed long) (r1 * yy + r2) != xx) + abort (); + } + save_time: + { unsigned int xx = x, yy = y, r1, r2; + if (yy == 0) continue; + r1 = xx / yy; + r2 = xx % yy; + if (r2 >= yy || r1 * yy + r2 != xx) + abort (); + } + { signed int xx = x, yy = y, r1, r2; + if ((unsigned int) xx << 1 == 0 && yy == -1) + continue; + r1 = xx / yy; + r2 = xx % yy; + if (ABS (r2) >= (unsigned int) ABS (yy) || (signed int) (r1 * yy + r2) != xx) + abort (); + } + { unsigned short xx = x, yy = y, r1, r2; + if (yy == 0) continue; + r1 = xx / yy; + r2 = xx % yy; + if (r2 >= yy || r1 * yy + r2 != xx) + abort (); + } + { signed short xx = x, yy = y, r1, r2; + r1 = xx / yy; + r2 = xx % yy; + if (ABS (r2) >= (unsigned short) ABS (yy) || (signed short) (r1 * yy + r2) != xx) + abort (); + } + { unsigned char xx = x, yy = y, r1, r2; + if (yy == 0) continue; + r1 = xx / yy; + r2 = xx % yy; + if (r2 >= yy || r1 * yy + r2 != xx) + abort (); + } + { signed char xx = x, yy = y, r1, r2; + r1 = xx / yy; + r2 = xx % yy; + if (ABS (r2) >= (unsigned char) ABS (yy) || (signed char) (r1 * yy + r2) != xx) + abort (); + } + } + + exit (0); +} diff --git a/test/tests/ashldi-1.c b/test/tests/ashldi-1.c new file mode 100644 index 0000000..b084771 --- /dev/null +++ b/test/tests/ashldi-1.c @@ -0,0 +1,221 @@ +#include + +extern void abort(void); +extern void exit(int); + +#if 0 //__LONG_LONG_MAX__ == 9223372036854775807LL +#define BITS 64 + +static unsigned long long const data[64] = { + 0x123456789abcdefULL, + 0x2468acf13579bdeULL, + 0x48d159e26af37bcULL, + 0x91a2b3c4d5e6f78ULL, + 0x123456789abcdef0ULL, + 0x2468acf13579bde0ULL, + 0x48d159e26af37bc0ULL, + 0x91a2b3c4d5e6f780ULL, + 0x23456789abcdef00ULL, + 0x468acf13579bde00ULL, + 0x8d159e26af37bc00ULL, + 0x1a2b3c4d5e6f7800ULL, + 0x3456789abcdef000ULL, + 0x68acf13579bde000ULL, + 0xd159e26af37bc000ULL, + 0xa2b3c4d5e6f78000ULL, + 0x456789abcdef0000ULL, + 0x8acf13579bde0000ULL, + 0x159e26af37bc0000ULL, + 0x2b3c4d5e6f780000ULL, + 0x56789abcdef00000ULL, + 0xacf13579bde00000ULL, + 0x59e26af37bc00000ULL, + 0xb3c4d5e6f7800000ULL, + 0x6789abcdef000000ULL, + 0xcf13579bde000000ULL, + 0x9e26af37bc000000ULL, + 0x3c4d5e6f78000000ULL, + 0x789abcdef0000000ULL, + 0xf13579bde0000000ULL, + 0xe26af37bc0000000ULL, + 0xc4d5e6f780000000ULL, + 0x89abcdef00000000ULL, + 0x13579bde00000000ULL, + 0x26af37bc00000000ULL, + 0x4d5e6f7800000000ULL, + 0x9abcdef000000000ULL, + 0x3579bde000000000ULL, + 0x6af37bc000000000ULL, + 0xd5e6f78000000000ULL, + 0xabcdef0000000000ULL, + 0x579bde0000000000ULL, + 0xaf37bc0000000000ULL, + 0x5e6f780000000000ULL, + 0xbcdef00000000000ULL, + 0x79bde00000000000ULL, + 0xf37bc00000000000ULL, + 0xe6f7800000000000ULL, + 0xcdef000000000000ULL, + 0x9bde000000000000ULL, + 0x37bc000000000000ULL, + 0x6f78000000000000ULL, + 0xdef0000000000000ULL, + 0xbde0000000000000ULL, + 0x7bc0000000000000ULL, + 0xf780000000000000ULL, + 0xef00000000000000ULL, + 0xde00000000000000ULL, + 0xbc00000000000000ULL, + 0x7800000000000000ULL, + 0xf000000000000000ULL, + 0xe000000000000000ULL, + 0xc000000000000000ULL, + 0x8000000000000000ULL +}; + +#elif 1 //__LONG_LONG_MAX__ == 2147483647LL +#define BITS 32 + +static unsigned long long const data[32] = { + 0x1234567fULL, + 0x2468acfeULL, + 0x48d159fcULL, + 0x91a2b3f8ULL, + 0x234567f0ULL, + 0x468acfe0ULL, + 0x8d159fc0ULL, + 0x1a2b3f80ULL, + 0x34567f00ULL, + 0x68acfe00ULL, + 0xd159fc00ULL, + 0xa2b3f800ULL, + 0x4567f000ULL, + 0x8acfe000ULL, + 0x159fc000ULL, + 0x2b3f8000ULL, + 0x567f0000ULL, + 0xacfe0000ULL, + 0x59fc0000ULL, + 0xb3f80000ULL, + 0x67f00000ULL, + 0xcfe00000ULL, + 0x9fc00000ULL, + 0x3f800000ULL, + 0x7f000000ULL, + 0xfe000000ULL, + 0xfc000000ULL, + 0xf8000000ULL, + 0xf0000000ULL, + 0xe0000000ULL, + 0xc0000000ULL, + 0x80000000ULL +}; + +#else +#error "Update the test case." +#endif + +static unsigned long long +variable_shift(unsigned long long x, int i) +{ + return x << i; +} + +static unsigned long long +constant_shift(unsigned long long x, int i) +{ + switch (i) + { + case 0: x = x << 0; break; + case 1: x = x << 1; break; + case 2: x = x << 2; break; + case 3: x = x << 3; break; + case 4: x = x << 4; break; + case 5: x = x << 5; break; + case 6: x = x << 6; break; + case 7: x = x << 7; break; + case 8: x = x << 8; break; + case 9: x = x << 9; break; + case 10: x = x << 10; break; + case 11: x = x << 11; break; + case 12: x = x << 12; break; + case 13: x = x << 13; break; + case 14: x = x << 14; break; + case 15: x = x << 15; break; + case 16: x = x << 16; break; + case 17: x = x << 17; break; + case 18: x = x << 18; break; + case 19: x = x << 19; break; + case 20: x = x << 20; break; + case 21: x = x << 21; break; + case 22: x = x << 22; break; + case 23: x = x << 23; break; + case 24: x = x << 24; break; + case 25: x = x << 25; break; + case 26: x = x << 26; break; + case 27: x = x << 27; break; + case 28: x = x << 28; break; + case 29: x = x << 29; break; + case 30: x = x << 30; break; + case 31: x = x << 31; break; +#if BITS > 32 + case 32: x = x << 32; break; + case 33: x = x << 33; break; + case 34: x = x << 34; break; + case 35: x = x << 35; break; + case 36: x = x << 36; break; + case 37: x = x << 37; break; + case 38: x = x << 38; break; + case 39: x = x << 39; break; + case 40: x = x << 40; break; + case 41: x = x << 41; break; + case 42: x = x << 42; break; + case 43: x = x << 43; break; + case 44: x = x << 44; break; + case 45: x = x << 45; break; + case 46: x = x << 46; break; + case 47: x = x << 47; break; + case 48: x = x << 48; break; + case 49: x = x << 49; break; + case 50: x = x << 50; break; + case 51: x = x << 51; break; + case 52: x = x << 52; break; + case 53: x = x << 53; break; + case 54: x = x << 54; break; + case 55: x = x << 55; break; + case 56: x = x << 56; break; + case 57: x = x << 57; break; + case 58: x = x << 58; break; + case 59: x = x << 59; break; + case 60: x = x << 60; break; + case 61: x = x << 61; break; + case 62: x = x << 62; break; + case 63: x = x << 63; break; +#endif + + default: + abort (); + } + return x; +} + +int +main() +{ + int i; + + for (i = 0; i < BITS; ++i) + { + unsigned long long y = variable_shift (data[0], i); + if (y != data[i]) + abort (); + } + for (i = 0; i < BITS; ++i) + { + unsigned long long y = constant_shift (data[0], i); + if (y != data[i]) + abort (); + } + + exit (0); +} diff --git a/test/tests/ashrdi-1.c b/test/tests/ashrdi-1.c new file mode 100644 index 0000000..d2d8a5d --- /dev/null +++ b/test/tests/ashrdi-1.c @@ -0,0 +1,337 @@ +#include + +extern void abort(void); +extern void exit(int); + +#if 0 //__LONG_LONG_MAX__ == 9223372036854775807LL +#define BITS 64 + +static long long const zext[64] = { + 0x7654321fedcba980LL, + 0x3b2a190ff6e5d4c0LL, + 0x1d950c87fb72ea60LL, + 0xeca8643fdb97530LL, + 0x7654321fedcba98LL, + 0x3b2a190ff6e5d4cLL, + 0x1d950c87fb72ea6LL, + 0xeca8643fdb9753LL, + 0x7654321fedcba9LL, + 0x3b2a190ff6e5d4LL, + 0x1d950c87fb72eaLL, + 0xeca8643fdb975LL, + 0x7654321fedcbaLL, + 0x3b2a190ff6e5dLL, + 0x1d950c87fb72eLL, + 0xeca8643fdb97LL, + 0x7654321fedcbLL, + 0x3b2a190ff6e5LL, + 0x1d950c87fb72LL, + 0xeca8643fdb9LL, + 0x7654321fedcLL, + 0x3b2a190ff6eLL, + 0x1d950c87fb7LL, + 0xeca8643fdbLL, + 0x7654321fedLL, + 0x3b2a190ff6LL, + 0x1d950c87fbLL, + 0xeca8643fdLL, + 0x7654321feLL, + 0x3b2a190ffLL, + 0x1d950c87fLL, + 0xeca8643fLL, + 0x7654321fLL, + 0x3b2a190fLL, + 0x1d950c87LL, + 0xeca8643LL, + 0x7654321LL, + 0x3b2a190LL, + 0x1d950c8LL, + 0xeca864LL, + 0x765432LL, + 0x3b2a19LL, + 0x1d950cLL, + 0xeca86LL, + 0x76543LL, + 0x3b2a1LL, + 0x1d950LL, + 0xeca8LL, + 0x7654LL, + 0x3b2aLL, + 0x1d95LL, + 0xecaLL, + 0x765LL, + 0x3b2LL, + 0x1d9LL, + 0xecLL, + 0x76LL, + 0x3bLL, + 0x1dLL, + 0xeLL, + 0x7LL, + 0x3LL, + 0x1LL, + 0LL +}; + +static long long const sext[64] = { + 0x8edcba9f76543210LL, + 0xc76e5d4fbb2a1908LL, + 0xe3b72ea7dd950c84LL, + 0xf1db9753eeca8642LL, + 0xf8edcba9f7654321LL, + 0xfc76e5d4fbb2a190LL, + 0xfe3b72ea7dd950c8LL, + 0xff1db9753eeca864LL, + 0xff8edcba9f765432LL, + 0xffc76e5d4fbb2a19LL, + 0xffe3b72ea7dd950cLL, + 0xfff1db9753eeca86LL, + 0xfff8edcba9f76543LL, + 0xfffc76e5d4fbb2a1LL, + 0xfffe3b72ea7dd950LL, + 0xffff1db9753eeca8LL, + 0xffff8edcba9f7654LL, + 0xffffc76e5d4fbb2aLL, + 0xffffe3b72ea7dd95LL, + 0xfffff1db9753eecaLL, + 0xfffff8edcba9f765LL, + 0xfffffc76e5d4fbb2LL, + 0xfffffe3b72ea7dd9LL, + 0xffffff1db9753eecLL, + 0xffffff8edcba9f76LL, + 0xffffffc76e5d4fbbLL, + 0xffffffe3b72ea7ddLL, + 0xfffffff1db9753eeLL, + 0xfffffff8edcba9f7LL, + 0xfffffffc76e5d4fbLL, + 0xfffffffe3b72ea7dLL, + 0xffffffff1db9753eLL, + 0xffffffff8edcba9fLL, + 0xffffffffc76e5d4fLL, + 0xffffffffe3b72ea7LL, + 0xfffffffff1db9753LL, + 0xfffffffff8edcba9LL, + 0xfffffffffc76e5d4LL, + 0xfffffffffe3b72eaLL, + 0xffffffffff1db975LL, + 0xffffffffff8edcbaLL, + 0xffffffffffc76e5dLL, + 0xffffffffffe3b72eLL, + 0xfffffffffff1db97LL, + 0xfffffffffff8edcbLL, + 0xfffffffffffc76e5LL, + 0xfffffffffffe3b72LL, + 0xffffffffffff1db9LL, + 0xffffffffffff8edcLL, + 0xffffffffffffc76eLL, + 0xffffffffffffe3b7LL, + 0xfffffffffffff1dbLL, + 0xfffffffffffff8edLL, + 0xfffffffffffffc76LL, + 0xfffffffffffffe3bLL, + 0xffffffffffffff1dLL, + 0xffffffffffffff8eLL, + 0xffffffffffffffc7LL, + 0xffffffffffffffe3LL, + 0xfffffffffffffff1LL, + 0xfffffffffffffff8LL, + 0xfffffffffffffffcLL, + 0xfffffffffffffffeLL, + 0xffffffffffffffffLL +}; + +#elif 1 //__LONG_LONG_MAX__ == 2147483647LL +#define BITS 32 + +static long long const zext[32] = { + 0x76543218LL, + 0x3b2a190cLL, + 0x1d950c86LL, + 0xeca8643LL, + 0x7654321LL, + 0x3b2a190LL, + 0x1d950c8LL, + 0xeca864LL, + 0x765432LL, + 0x3b2a19LL, + 0x1d950cLL, + 0xeca86LL, + 0x76543LL, + 0x3b2a1LL, + 0x1d950LL, + 0xeca8LL, + 0x7654LL, + 0x3b2aLL, + 0x1d95LL, + 0xecaLL, + 0x765LL, + 0x3b2LL, + 0x1d9LL, + 0xecLL, + 0x76LL, + 0x3bLL, + 0x1dLL, + 0xeLL, + 0x7LL, + 0x3LL, + 0x1LL, + 0LL +}; + +static long long const sext[32] = { + 0x87654321LL, + 0xc3b2a190LL, + 0xe1d950c8LL, + 0xf0eca864LL, + 0xf8765432LL, + 0xfc3b2a19LL, + 0xfe1d950cLL, + 0xff0eca86LL, + 0xff876543LL, + 0xffc3b2a1LL, + 0xffe1d950LL, + 0xfff0eca8LL, + 0xfff87654LL, + 0xfffc3b2aLL, + 0xfffe1d95LL, + 0xffff0ecaLL, + 0xffff8765LL, + 0xffffc3b2LL, + 0xffffe1d9LL, + 0xfffff0ecLL, + 0xfffff876LL, + 0xfffffc3bLL, + 0xfffffe1dLL, + 0xffffff0eLL, + 0xffffff87LL, + 0xffffffc3LL, + 0xffffffe1LL, + 0xfffffff0LL, + 0xfffffff8LL, + 0xfffffffcLL, + 0xfffffffeLL, + 0xffffffffLL +}; + +#else +#error "Update the test case." +#endif + +static long long +variable_shift(long long x, int i) +{ + return x >> i; +} + +static long long +constant_shift(long long x, int i) +{ + switch (i) + { + case 0: x = x >> 0; break; + case 1: x = x >> 1; break; + case 2: x = x >> 2; break; + case 3: x = x >> 3; break; + case 4: x = x >> 4; break; + case 5: x = x >> 5; break; + case 6: x = x >> 6; break; + case 7: x = x >> 7; break; + case 8: x = x >> 8; break; + case 9: x = x >> 9; break; + case 10: x = x >> 10; break; + case 11: x = x >> 11; break; + case 12: x = x >> 12; break; + case 13: x = x >> 13; break; + case 14: x = x >> 14; break; + case 15: x = x >> 15; break; + case 16: x = x >> 16; break; + case 17: x = x >> 17; break; + case 18: x = x >> 18; break; + case 19: x = x >> 19; break; + case 20: x = x >> 20; break; + case 21: x = x >> 21; break; + case 22: x = x >> 22; break; + case 23: x = x >> 23; break; + case 24: x = x >> 24; break; + case 25: x = x >> 25; break; + case 26: x = x >> 26; break; + case 27: x = x >> 27; break; + case 28: x = x >> 28; break; + case 29: x = x >> 29; break; + case 30: x = x >> 30; break; + case 31: x = x >> 31; break; +#if BITS > 32 + case 32: x = x >> 32; break; + case 33: x = x >> 33; break; + case 34: x = x >> 34; break; + case 35: x = x >> 35; break; + case 36: x = x >> 36; break; + case 37: x = x >> 37; break; + case 38: x = x >> 38; break; + case 39: x = x >> 39; break; + case 40: x = x >> 40; break; + case 41: x = x >> 41; break; + case 42: x = x >> 42; break; + case 43: x = x >> 43; break; + case 44: x = x >> 44; break; + case 45: x = x >> 45; break; + case 46: x = x >> 46; break; + case 47: x = x >> 47; break; + case 48: x = x >> 48; break; + case 49: x = x >> 49; break; + case 50: x = x >> 50; break; + case 51: x = x >> 51; break; + case 52: x = x >> 52; break; + case 53: x = x >> 53; break; + case 54: x = x >> 54; break; + case 55: x = x >> 55; break; + case 56: x = x >> 56; break; + case 57: x = x >> 57; break; + case 58: x = x >> 58; break; + case 59: x = x >> 59; break; + case 60: x = x >> 60; break; + case 61: x = x >> 61; break; + case 62: x = x >> 62; break; + case 63: x = x >> 63; break; +#endif + + default: + abort (); + } + return x; +} + +int +main() +{ + int i; + + for (i = 0; i < BITS; ++i) + { + long long y = variable_shift (zext[0], i); + if (y != zext[i]) + exitl4(y, zext[i], i, 0); //abort (); + } +#if 0 + for (i = 0; i < BITS; ++i) + { + long long y = variable_shift (sext[0], i); + if (y != sext[i]) + exit(i+1); //abort (); + } + for (i = 0; i < BITS; ++i) + { + long long y = constant_shift (zext[0], i); + if (y != zext[i]) + exit(i+1); //abort (); + } + for (i = 0; i < BITS; ++i) + { + long long y = constant_shift (sext[0], i); + if (y != sext[i]) + exit(i+1); abort (); + } +#endif + + exit (0); +} diff --git a/test/tests/bcp-1.c b/test/tests/bcp-1.c new file mode 100644 index 0000000..918ad0a --- /dev/null +++ b/test/tests/bcp-1.c @@ -0,0 +1,91 @@ +int global; +int func(void); + +/* These must fail. */ +int bad0(void) { return __builtin_constant_p(global); } +int bad1(void) { return __builtin_constant_p(global++); } +inline int bad2(int x) { return __builtin_constant_p(x++); } +inline int bad3(int x) { return __builtin_constant_p(x); } +inline int bad4(const char *x) { return __builtin_constant_p(x); } +int bad5(void) { return bad2(1); } +inline int bad6(int x) { return __builtin_constant_p(x+1); } +int bad7(void) { return __builtin_constant_p(func()); } +int bad8(void) { char buf[10]; return __builtin_constant_p(buf); } +int bad9(const char *x) { return __builtin_constant_p(x[123456]); } +int bad10(void) { return __builtin_constant_p(&global); } + +/* These must pass, or we've broken gcc2 functionality. */ +int good0(void) { return __builtin_constant_p(1); } +int good1(void) { return 1 ; } // constantitude of strings is optional in TCC return __builtin_constant_p("hi"); } +int good2(void) { return __builtin_constant_p((1234 + 45) & ~7); } + +/* These are extensions to gcc2. Failure indicates an optimization + regression. */ +int opt0(void) { return bad3(1); } +int opt1(void) { return bad6(1); } +int opt2(void) { return __builtin_constant_p("hi"[0]); } + +/* + * Opt3 is known to fail. It is one of the important cases that glibc + * was interested in though, so keep this around as a reminder. + * + * The solution is to add bits to recover bytes from constant pool + * elements given nothing but a constant pool label and an offset. + * When we can do that, and we can simplify strlen after the fact, + * then we can enable recognition of constant pool labels as constants. + */ + +/* int opt3(void) { return bad4("hi"); } */ + + +/* Call through tables so -finline-functions can't screw with us. */ +int (*bad_t0[])(void) = { + bad0, bad1, bad5, bad7, bad8, bad10 +}; + +int (*bad_t1[])(int x) = { + bad2, bad3, bad6 +}; + +int (*bad_t2[])(const char *x) = { + bad4, bad9 +}; + +int (*good_t0[])(void) = { + good0, good1, good2 +}; + +int (*opt_t0[])(void) = { + opt0, opt1, opt2 /* , opt3 */ +}; + +#define N(arr) (sizeof(arr)/sizeof(*arr)) + +int main() +{ + int i; + + for (i = 0; i < N(bad_t0); ++i) + if ((*bad_t0[i])()) + abort(); + + for (i = 0; i < N(bad_t1); ++i) + if ((*bad_t1[i])(1)) + abort(); + + for (i = 0; i < N(bad_t2); ++i) + if ((*bad_t2[i])("hi")) + abort(); + + for (i = 0; i < N(good_t0); ++i) + if (! (*good_t0[i])()) + abort(); + +#ifdef __OPTIMIZE__ + for (i = 0; i < N(opt_t0); ++i) + if (! (*opt_t0[i])()) + abort(); +#endif + + exit(0); +} diff --git a/test/tests/bf-layout-1.c b/test/tests/bf-layout-1.c new file mode 100644 index 0000000..62fbb5e --- /dev/null +++ b/test/tests/bf-layout-1.c @@ -0,0 +1,9 @@ +struct { long f8:4; long f24:12; } a; +struct { long f32:16; } b; + +main () +{ + if (sizeof (a) != sizeof (b)) + abort (); + exit (0); +} diff --git a/test/tests/bf-pack-1.c b/test/tests/bf-pack-1.c new file mode 100644 index 0000000..56efb81 --- /dev/null +++ b/test/tests/bf-pack-1.c @@ -0,0 +1,23 @@ +struct foo +{ + unsigned half:8; + unsigned long __attribute__((packed)) whole:16; +}; + +f (struct foo *q) +{ + if (q->half != 0x12) + abort (); + if (q->whole != 0x5678L) + abort (); +} + +main () +{ + struct foo bar; + + bar.half = 0x12; + bar.whole = 0x5678L; + f (&bar); + exit (0); +} diff --git a/test/tests/bf-sign-1.c b/test/tests/bf-sign-1.c new file mode 100644 index 0000000..3cc3eac --- /dev/null +++ b/test/tests/bf-sign-1.c @@ -0,0 +1,18 @@ +main () +{ + struct { + signed int s:3; + unsigned int u:3; + int i:3; + } x = {-1, -1, -1}; + + if (x.u != 7) + abort (); + if (x.s != - 1) + abort (); + + if (x.i != -1 && x.i != 7) + abort (); + + exit (0); +} diff --git a/test/tests/bitfld-1.c b/test/tests/bitfld-1.c new file mode 100644 index 0000000..c7b8bd5 --- /dev/null +++ b/test/tests/bitfld-1.c @@ -0,0 +1,56 @@ +/* Copyright 2002 Free Software Foundation, Inc. + + Tests correct signedness of operations on bitfields; in particular + that integer promotions are done correctly, including the case when + casts are present. + + The C front end was eliding the cast of an unsigned bitfield to + unsigned as a no-op, when in fact it forces a conversion to a + full-width unsigned int. (At the time of writing, the C++ front end + has a different bug; it erroneously promotes the uncast unsigned + bitfield to an unsigned int). + + Source: Neil Booth, 25 Jan 2002, based on PR 3325 (and 3326, which + is a different manifestation of the same bug). +*/ + +extern void abort (); + +int +main(int argc, char *argv[]) +{ + struct x { signed int i : 7; unsigned int u : 7; } bit; + + unsigned int u; + int i; + unsigned int unsigned_result = -13U % 61; + int signed_result = -13 % 61; + + bit.u = 61, u = 61; + bit.i = -13, i = -13; + + if (i % u != unsigned_result) + abort (); +#if 0 + if (i % (unsigned int) u != unsigned_result) + abort (); + + /* Somewhat counter-intuitively, bit.u is promoted to an int, making + the operands and result an int. */ + if (i % bit.u != signed_result) + abort (); + + if (bit.i % bit.u != signed_result) + abort (); + + /* But with a cast to unsigned int, the unsigned int is promoted to + itself as a no-op, and the operands and result are unsigned. */ + if (i % (unsigned int) bit.u != unsigned_result) + abort (); + + if (bit.i % (unsigned int) bit.u != unsigned_result) + abort (); +#endif + + return 0; +} diff --git a/test/tests/bitfld-2.c b/test/tests/bitfld-2.c new file mode 100644 index 0000000..445879b --- /dev/null +++ b/test/tests/bitfld-2.c @@ -0,0 +1,28 @@ +/* Test whether bit field boundaries aren't advanced if bit field type + has alignment large enough. */ +extern void abort (void); +extern void exit (int); + +struct A { + unsigned short a : 5; + unsigned short b : 5; + unsigned short c : 6; +}; + +struct B { + unsigned short a : 5; + unsigned short b : 3; + unsigned short c : 8; +}; + +int main () +{ + /* If short is not at least 16 bits wide, don't test anything. */ + if ((unsigned short) 65521 != 65521) + exit (0); + + if (sizeof (struct A) != sizeof (struct B)) + abort (); + + exit (0); +} diff --git a/test/tests/bitfld-4.c b/test/tests/bitfld-4.c new file mode 100644 index 0000000..1e9c33a --- /dev/null +++ b/test/tests/bitfld-4.c @@ -0,0 +1,21 @@ +/* When comparisons of bit-fields to unsigned constants got shortened, + the shortened signed constant was wrongly marked as overflowing, + leading to a later integer_zerop failure and misoptimization. + + Related to bug tree-optimization/16437 but shows the problem on + 32-bit systems. */ +/* Origin: Joseph Myers */ + +extern void abort (void); + +struct s { int a:12, b:16; }; + +struct s x = { -123, -456 }; + +int +main (void) +{ + if (x.a != -123U || x.b != -456U) + abort (); + return 0; +} diff --git a/test/tests/builtin-constant.c b/test/tests/builtin-constant.c new file mode 100644 index 0000000..9e5bfb8 --- /dev/null +++ b/test/tests/builtin-constant.c @@ -0,0 +1,26 @@ +/* PR optimization/8423. */ + +#define btest(x) __builtin_constant_p(x) ? "1" : "0" + +#ifdef __OPTIMIZE__ +void +foo (char *i) +{ + if (*i == '0') + abort (); +} +#else +void +foo (char *i) +{ +} +#endif + +int +main (void) +{ + int size = sizeof (int); + foo (btest (size)); + foo (btest (size)); + exit (0); +} diff --git a/test/tests/cmpsi-1.c b/test/tests/cmpsi-1.c new file mode 100644 index 0000000..9fce104 --- /dev/null +++ b/test/tests/cmpsi-1.c @@ -0,0 +1,32 @@ +f1 (unsigned int x, unsigned int y) +{ + if (x == 0) + dummy (); + x -= y; + /* 0xfffffff2 < 0x80000000? */ + if (x < ~(~(unsigned int) 0 >> 1)) + abort (); + return x; +} + +f2 (unsigned long int x, unsigned long int y) +{ + if (x == 0) + dummy (); + x -= y; + /* 0xfffffff2 < 0x80000000? */ + if (x < ~(~(unsigned long int) 0 >> 1)) + abort (); + return x; +} + + +dummy () {} + +main () +{ + /* 0x7ffffff3 0x80000001 */ + f1 ((~(unsigned int) 0 >> 1) - 12, ~(~(unsigned int) 0 >> 1) + 1); + f2 ((~(unsigned long int) 0 >> 1) - 12, ~(~(unsigned long int) 0 >> 1) + 1); + exit (0); +} diff --git a/test/tests/comp-goto-1.c b/test/tests/comp-goto-1.c new file mode 100644 index 0000000..3bf9a26 --- /dev/null +++ b/test/tests/comp-goto-1.c @@ -0,0 +1,164 @@ +#include + +#if !defined(NO_LABEL_VALUES) && (!defined(STACK_SIZE) || STACK_SIZE >= 4000) && __INT_MAX__ >= 2147483647 +typedef unsigned int uint32; +typedef signed int sint32; + +typedef uint32 reg_t; + +typedef unsigned long int host_addr_t; +typedef uint32 target_addr_t; +typedef sint32 target_saddr_t; + +typedef union +{ + struct + { + unsigned int offset:18; + unsigned int ignore:4; + unsigned int s1:8; + int :2; + signed int simm:14; + unsigned int s3:8; + unsigned int s2:8; + int pad2:2; + } f1; + long long ll; + double d; +} insn_t; + +typedef struct +{ + target_addr_t vaddr_tag; + unsigned long int rigged_paddr; +} tlb_entry_t; + +typedef struct +{ + insn_t *pc; + reg_t registers[256]; + insn_t *program; + tlb_entry_t tlb_tab[0x100]; +} environment_t; + +enum operations +{ + LOAD32_RR, + METAOP_DONE +}; + +host_addr_t +f () +{ + abort (); +} + +reg_t +simulator_kernel (int what, environment_t *env) +{ + register insn_t *pc = env->pc; + register reg_t *regs = env->registers; + register insn_t insn; + register int s1; + register reg_t r2; + register void *base_addr = &&sim_base_addr; + register tlb_entry_t *tlb = env->tlb_tab; + + if (what != 0) + { + int i; + static void *op_map[] = + { + &&L_LOAD32_RR, + &&L_METAOP_DONE, + }; + insn_t *program = env->program; + for (i = 0; i < what; i++) + program[i].f1.offset = op_map[program[i].f1.offset] - base_addr; + } + + sim_base_addr:; + + insn = *pc++; + r2 = (*(reg_t *) (((char *) regs) + (insn.f1.s2 << 2))); + s1 = (insn.f1.s1 << 2); + goto *(base_addr + insn.f1.offset); + + L_LOAD32_RR: + { + target_addr_t vaddr_page = r2 / 4096; + unsigned int x = vaddr_page % 0x100; + insn = *pc++; + + for (;;) + { + target_addr_t tag = tlb[x].vaddr_tag; + host_addr_t rigged_paddr = tlb[x].rigged_paddr; + + if (tag == vaddr_page) + { + *(reg_t *) (((char *) regs) + s1) = *(uint32 *) (rigged_paddr + r2); + r2 = *(reg_t *) (((char *) regs) + (insn.f1.s2 << 2)); + s1 = insn.f1.s1 << 2; + goto *(base_addr + insn.f1.offset); + } + + if (((target_saddr_t) tag < 0)) + { + *(reg_t *) (((char *) regs) + s1) = *(uint32 *) f (); + r2 = *(reg_t *) (((char *) regs) + (insn.f1.s2 << 2)); + s1 = insn.f1.s1 << 2; + goto *(base_addr + insn.f1.offset); + } + + x = (x - 1) % 0x100; + } + + L_METAOP_DONE: + return (*(reg_t *) (((char *) regs) + s1)); + } +} + +insn_t program[2 + 1]; + +void *malloc (); + +int +main () +{ + environment_t env; + insn_t insn; + int i, res; + host_addr_t a_page = (host_addr_t) malloc (2 * 4096); + target_addr_t a_vaddr = 0x123450; + target_addr_t vaddr_page = a_vaddr / 4096; + a_page = (a_page + 4096 - 1) & -4096; + + env.tlb_tab[((vaddr_page) % 0x100)].vaddr_tag = vaddr_page; + env.tlb_tab[((vaddr_page) % 0x100)].rigged_paddr = a_page - vaddr_page * 4096; + insn.f1.offset = LOAD32_RR; + env.registers[0] = 0; + env.registers[2] = a_vaddr; + *(sint32 *) (a_page + a_vaddr % 4096) = 88; + insn.f1.s1 = 0; + insn.f1.s2 = 2; + + for (i = 0; i < 2; i++) + program[i] = insn; + + insn.f1.offset = METAOP_DONE; + insn.f1.s1 = 0; + program[2] = insn; + + env.pc = program; + env.program = program; + + res = simulator_kernel (2 + 1, &env); + + if (res != 88) + abort (); + exit (0); +} +#else +main(){ exit (0); } +#endif diff --git a/test/tests/compare-1.c b/test/tests/compare-1.c new file mode 100644 index 0000000..78b4650 --- /dev/null +++ b/test/tests/compare-1.c @@ -0,0 +1,119 @@ +/* Copyright (C) 2002 Free Software Foundation. + + Test for correctness of composite comparisons. + + Written by Roger Sayle, 3rd June 2002. */ + +extern void abort (void); + +int ieq (int x, int y, int ok) +{ + if ((x<=y) && (x>=y)) + { + if (!ok) abort (); + } + else + if (ok) abort (); + + if ((x<=y) && (x==y)) + { + if (!ok) abort (); + } + else + if (ok) abort (); + + if ((x<=y) && (y<=x)) + { + if (!ok) abort (); + } + else + if (ok) abort (); + + if ((y==x) && (x<=y)) + { + if (!ok) abort (); + } + else + if (ok) abort (); +} + +int ine (int x, int y, int ok) +{ + if ((xy)) + { + if (!ok) abort (); + } + else + if (ok) abort (); +} + +int ilt (int x, int y, int ok) +{ + if ((xy) && (x!=y)) + { + if (!ok) abort (); + } + else + if (ok) abort (); +} + +int ige (int x, int y, int ok) +{ + if ((x>y) || (x==y)) + { + if (!ok) abort (); + } + else + if (ok) abort (); +} + +int +main () +{ + ieq (1, 4, 0); + ieq (3, 3, 1); + ieq (5, 2, 0); + + ine (1, 4, 1); + ine (3, 3, 0); + ine (5, 2, 1); + + ilt (1, 4, 1); + ilt (3, 3, 0); + ilt (5, 2, 0); + + ile (1, 4, 1); + ile (3, 3, 1); + ile (5, 2, 0); + + igt (1, 4, 0); + igt (3, 3, 0); + igt (5, 2, 1); + + ige (1, 4, 0); + ige (3, 3, 1); + ige (5, 2, 1); + + return 0; +} + diff --git a/test/tests/compare-2.c b/test/tests/compare-2.c new file mode 100644 index 0000000..858df29 --- /dev/null +++ b/test/tests/compare-2.c @@ -0,0 +1,24 @@ +/* Copyright (C) 2002 Free Software Foundation. + + Ensure that the composite comparison optimization doesn't misfire + and attempt to combine a signed comparison with an unsigned one. + + Written by Roger Sayle, 3rd June 2002. */ + +extern void abort (void); + +int +foo (int x, int y) +{ + /* If miscompiled the following may become "x == y". */ + return (x<=y) && ((unsigned int)x >= (unsigned int)y); +} + +int +main () +{ + if (! foo (-1,0)) + abort (); + return 0; +} + diff --git a/test/tests/compare-3.c b/test/tests/compare-3.c new file mode 100644 index 0000000..6549c90 --- /dev/null +++ b/test/tests/compare-3.c @@ -0,0 +1,86 @@ +/* Copyright (C) 2002 Free Software Foundation. + + Test for composite comparison always true/false optimization. + + Written by Roger Sayle, 7th June 2002. */ + +extern void link_error0 (); +extern void link_error1 (); + +void +test1 (int x, int y) +{ + if ((x==y) && (x!=y)) + link_error0(); +} + +void +test2 (int x, int y) +{ + if ((xy)) + link_error0(); +} + +void +test3 (int x, int y) +{ + if ((x=y) || (x +#include +#include +extern void abort(); + +typedef struct foo +{ + int uaattrid; + char *name; +} FOO; + +FOO Upgrade_items[] = +{ + {1, "1"}, + {2, "2"}, + {0, NULL} +}; + +int *Upgd_minor_ID = + (int *) &((Upgrade_items + 1)->uaattrid); + +int *Upgd_minor_ID1 = + (int *) &((Upgrade_items)->uaattrid); + +int *xy = (int*)&((Upgrade_items + 3)); + +int +main(int argc, char **argv) +{ + if (*Upgd_minor_ID != 2) + abort(); + + if (*Upgd_minor_ID1 != 1) + abort(); + return 0; +} diff --git a/test/tests/conversion.c b/test/tests/conversion.c new file mode 100644 index 0000000..fd9d4c3 --- /dev/null +++ b/test/tests/conversion.c @@ -0,0 +1,563 @@ +// some parts of this test have been manipulated to forgive some ineptitude +// on the part of TCC in handling FP conversions + +/* Test front-end conversions, optimizer conversions, and run-time + conversions between different arithmetic types. + + Constants are specified in a non-obvious way to make them work for + any word size. Their value on a 32-bit machine is indicated in the + comments. + + Note that this code is NOT intended for testing of accuracy of fp + conversions. */ + +float +u2f(u) + unsigned int u; +{ + return u; +} + +double +u2d(u) + unsigned int u; +{ + return u; +} + +long double +u2ld(u) + unsigned int u; +{ + return u; +} + +float +s2f(s) + int s; +{ + return s; +} + +double +s2d(s) + int s; +{ + return s; +} + +long double +s2ld(s) + int s; +{ + return s; +} + +int +fnear (float x, float y) +{ + float t = x - y; + return t == 0 || x / t > 1000.0; +} + +int +dnear (double x, double y) +{ + double t = x - y; + return t == 0 || x / t > 1000.0; +} + +int +ldnear (long double x, long double y) +{ + long double t = x - y; + return t == 0 || x / t > 1000.0; +} + +test_integer_to_float() +{ +#if 1 + if (u2f(0U) != (float) 0U) /* 0 */ + abort(); + if (!fnear (u2f(~0U), (float) ~0U)) /* 0xffffffff */ + abort(); + if (!fnear (u2f((~0U) >> 1), (float) ((~0U) >> 1))) /* 0x7fffffff */ + abort(); + if (u2f(~((~0U) >> 1)) != (float) ~((~0U) >> 1)) /* 0x80000000 */ + abort(); + + if (u2d(0U) != (double) 0U) /* 0 */ + abort(); + if (!dnear (u2d(~0U), (double) ~0U)) /* 0xffffffff */ + abort(); + if (!dnear (u2d((~0U) >> 1),(double) ((~0U) >> 1))) /* 0x7fffffff */ + abort(); + if (u2d(~((~0U) >> 1)) != (double) ~((~0U) >> 1)) /* 0x80000000 */ + abort(); + + if (u2ld(0U) != (long double) 0U) /* 0 */ + abort(); + if (!ldnear (u2ld(~0U), (long double) ~0U)) /* 0xffffffff */ + abort(); + if (!ldnear (u2ld((~0U) >> 1),(long double) ((~0U) >> 1))) /* 0x7fffffff */ + abort(); + if (u2ld(~((~0U) >> 1)) != (long double) ~((~0U) >> 1)) /* 0x80000000 */ + abort(); + + if (s2f(0) != (float) 0) /* 0 */ + abort(); + if (!fnear (s2f(~0), (float) ~0)) /* 0xffffffff */ + abort(); + if (!fnear (s2f((int)((~0U) >> 1)), (float)(int)((~0U) >> 1))) /* 0x7fffffff */ + abort(); +#endif + if (s2f((int)(~((~0U) >> 1))) != (float)(int)~((~0U) >> 1)) /* 0x80000000 */ + abort(); + +#if 1 + if (s2d(0) != (double) 0) /* 0 */ + abort(); + if (!dnear (s2d(~0), (double) ~0)) /* 0xffffffff */ + abort(); + if (!dnear (s2d((int)((~0U) >> 1)), (double)(int)((~0U) >> 1))) /* 0x7fffffff */ + abort(); + if (s2d((int)~((~0U) >> 1)) != (double)(int)~((~0U) >> 1)) /* 0x80000000 */ + abort(); + + if (s2ld(0) != (long double) 0) /* 0 */ + abort(); + if (!ldnear (s2ld(~0), (long double) ~0)) /* 0xffffffff */ + abort(); + if (!ldnear (s2ld((int)((~0U) >> 1)), (long double)(int)((~0U) >> 1))) /* 0x7fffffff */ + abort(); + if (s2ld((int)~((~0U) >> 1)) != (long double)(int)~((~0U) >> 1)) /* 0x80000000 */ + abort(); +#endif +} + +#if 1 //__GNUC__ +float +ull2f(u) + unsigned long long int u; +{ + return u; +} + +double +ull2d(u) + unsigned long long int u; +{ + return u; +} + +long double +ull2ld(u) + unsigned long long int u; +{ + return u; +} + +float +sll2f(s) + long long int s; +{ + return s; +} + +double +sll2d(s) + long long int s; +{ + return s; +} + +long double +sll2ld(s) + long long int s; +{ + return s; +} + +test_longlong_integer_to_float() +{ + if (ull2f(0ULL) != (float) 0ULL) /* 0 */ + abort(); + if (ull2f(~0ULL) != (float) ~0ULL) /* 0xffffffff */ + abort(); + if (ull2f((~0ULL) >> 1) != (float) ((~0ULL) >> 1)) /* 0x7fffffff */ + abort(); + if (ull2f(~((~0ULL) >> 1)) != (float) ~((~0ULL) >> 1)) /* 0x80000000 */ + abort(); + + if (ull2d(0ULL) != (double) 0ULL) /* 0 */ + abort(); +#if __HAVE_68881__ + /* Some 68881 targets return values in fp0, with excess precision. + But the compile-time conversion to double works correctly. */ + if (! dnear (ull2d(~0ULL), (double) ~0ULL)) /* 0xffffffff */ + abort(); + if (! dnear (ull2d((~0ULL) >> 1), (double) ((~0ULL) >> 1))) /* 0x7fffffff */ + abort(); +#else + if (ull2d(~0ULL) != (double) ~0ULL) /* 0xffffffff */ + abort(); + if (ull2d((~0ULL) >> 1) != (double) ((~0ULL) >> 1)) /* 0x7fffffff */ + abort(); +#endif + if (ull2d(~((~0ULL) >> 1)) != (double) ~((~0ULL) >> 1)) /* 0x80000000 */ + abort(); + + if (ull2ld(0ULL) != (long double) 0ULL) /* 0 */ + abort(); + if (ull2ld(~0ULL) != (long double) ~0ULL) /* 0xffffffff */ + abort(); + if (ull2ld((~0ULL) >> 1) != (long double) ((~0ULL) >> 1)) /* 0x7fffffff */ + abort(); + if (ull2ld(~((~0ULL) >> 1)) != (long double) ~((~0ULL) >> 1)) /* 0x80000000 */ + abort(); + + if (sll2f(0LL) != (float) 0LL) /* 0 */ + abort(); + if (sll2f(~0LL) != (float) ~0LL) /* 0xffffffff */ + abort(); + if (! fnear (sll2f((long long int)((~0ULL) >> 1)), (float)(long long int)((~0ULL) >> 1))) /* 0x7fffffff */ + abort(); + if (sll2f((long long int)(~((~0ULL) >> 1))) != (float)(long long int)~((~0ULL) >> 1)) /* 0x80000000 */ + abort(); + + if (sll2d(0LL) != (double) 0LL) /* 0 */ + abort(); + if (sll2d(~0LL) != (double) ~0LL) /* 0xffffffff */ + abort(); + if (!dnear (sll2d((long long int)((~0ULL) >> 1)), (double)(long long int)((~0ULL) >> 1))) /* 0x7fffffff */ + abort(); + if (! dnear (sll2d((long long int)~((~0ULL) >> 1)), (double)(long long int)~((~0ULL) >> 1))) /* 0x80000000 */ + abort(); + + if (sll2ld(0LL) != (long double) 0LL) /* 0 */ + abort(); + if (sll2ld(~0LL) != (long double) ~0LL) /* 0xffffffff */ + abort(); + if (!ldnear (sll2ld((long long int)((~0ULL) >> 1)), (long double)(long long int)((~0ULL) >> 1))) /* 0x7fffffff */ + abort(); + if (! ldnear (sll2ld((long long int)~((~0ULL) >> 1)), (long double)(long long int)~((~0ULL) >> 1))) /* 0x80000000 */ + abort(); +} +#endif + +unsigned int +f2u(float f) +{ + return (unsigned) f; +} + +unsigned int +d2u(double d) +{ + return (unsigned) d; +} + +unsigned int +ld2u(long double d) +{ + return (unsigned) d; +} + +int +f2s(float f) +{ + return (int) f; +} + +int +d2s(double d) +{ + return (int) d; +} + +int +ld2s(long double d) +{ + return (int) d; +} + +test_float_to_integer() +{ + if (f2u(0.0) != 0) + abort(); + if (f2u(0.999) != 0) + abort(); + if (f2u(1.0) != 1) + abort(); + if (f2u(1.99) != 1) + abort(); + if (f2u((float) ((~0U) >> 1)) != (~0U) >> 1 && /* 0x7fffffff */ + f2u((float) ((~0U) >> 1)) != ((~0U) >> 1) + 1) + abort(); + if (f2u((float) ~((~0U) >> 1)) != ~((~0U) >> 1)) /* 0x80000000 */ + abort(); + + /* These tests require double precision, so for hosts that don't offer + that much precision, just ignore these test. */ + if (sizeof (double) >= 8) { + if (d2u(0.0) != 0) + abort(); + if (d2u(0.999) != 0) + abort(); + if (d2u(1.0) != 1) + abort(); + if (d2u(1.99) != 1) + abort(); + if (d2u((double) (~0U)) != ~0U) /* 0xffffffff */ + abort(); + if (d2u((double) ((~0U) >> 1)) != (~0U) >> 1) /* 0x7fffffff */ + abort(); + if (d2u((double) ~((~0U) >> 1)) != ~((~0U) >> 1)) /* 0x80000000 */ + abort(); + } + + /* These tests require long double precision, so for hosts that don't offer + that much precision, just ignore these test. */ + if (sizeof (long double) >= 8) { + if (ld2u(0.0) != 0) + abort(); + if (ld2u(0.999) != 0) + abort(); + if (ld2u(1.0) != 1) + abort(); + if (ld2u(1.99) != 1) + abort(); + if (ld2u((long double) (~0U)) != ~0U) /* 0xffffffff */ + abort(); + if (ld2u((long double) ((~0U) >> 1)) != (~0U) >> 1) /* 0x7fffffff */ + abort(); + if (ld2u((long double) ~((~0U) >> 1)) != ~((~0U) >> 1)) /* 0x80000000 */ + abort(); + } + + if (f2s(0.0) != 0) + abort(); + if (f2s(0.999) != 0) + abort(); + if (f2s(1.0) != 1) + abort(); + if (f2s(1.99) != 1) + abort(); + if (f2s(-0.99) != 0) + abort(); + if (f2s(-1.0) != -1) + abort(); + if (f2s(-1.99) != -1) + abort(); + if (f2s((float)(int)~((~0U) >> 1)) != (int)~((~0U) >> 1)) /* 0x80000000 */ + abort(); + + /* These tests require double precision, so for hosts that don't offer + that much precision, just ignore these test. */ + if (sizeof (double) >= 8) { + if (d2s(0.0) != 0) + abort(); + if (d2s(0.999) != 0) + abort(); + if (d2s(1.0) != 1) + abort(); + if (d2s(1.99) != 1) + abort(); + if (d2s(-0.999) != 0) + abort(); + if (d2s(-1.0) != -1) + abort(); + if (d2s(-1.99) != -1) + abort(); + if (d2s((double) ((~0U) >> 1)) != (~0U) >> 1) /* 0x7fffffff */ + abort(); + if (d2s((double)(int)~((~0U) >> 1)) != (int)~((~0U) >> 1)) /* 0x80000000 */ + abort(); + } + + /* These tests require long double precision, so for hosts that don't offer + that much precision, just ignore these test. */ + if (sizeof (long double) >= 8) { + if (ld2s(0.0) != 0) + abort(); + if (ld2s(0.999) != 0) + abort(); + if (ld2s(1.0) != 1) + abort(); + if (ld2s(1.99) != 1) + abort(); + if (ld2s(-0.999) != 0) + abort(); + if (ld2s(-1.0) != -1) + abort(); + if (ld2s(-1.99) != -1) + abort(); + if (ld2s((long double) ((~0U) >> 1)) != (~0U) >> 1) /* 0x7fffffff */ + abort(); + if (ld2s((long double)(int)~((~0U) >> 1)) != (int)~((~0U) >> 1)) /* 0x80000000 */ + abort(); + } +} + +#if 1 //__GNUC__ +unsigned long long int +f2ull(float f) +{ + return (unsigned long long int) f; +} + +unsigned long long int +d2ull(double d) +{ + return (unsigned long long int) d; +} + +unsigned long long int +ld2ull(long double d) +{ + return (unsigned long long int) d; +} + +long long int +f2sll(float f) +{ + return (long long int) f; +} + +long long int +d2sll(double d) +{ + return (long long int) d; +} + +long long int +ld2sll(long double d) +{ + return (long long int) d; +} + +test_float_to_longlong_integer() +{ + if (f2ull(0.0) != 0LL) + abort(); + if (f2ull(0.999) != 0LL) + abort(); + if (f2ull(1.0) != 1LL) + abort(); + if (f2ull(1.99) != 1LL) + abort(); + + // TCC has problems with complicated constant expressions, at least if they are long longs + if (f2ull((float)0x7fffffffULL) != (~0ULL) >> 1 && /* 0x7fffffff */ + f2ull((float)0x7fffffffULL) != ((~0ULL) >> 1) + 1) + abort(); + if (f2ull((float)(0x80000000ULL)) != ~((~0ULL) >> 1)) /* 0x80000000 */ + abort(); +#if 0 + if (f2ull((float) ((~0ULL) >> 1)) != (~0ULL) >> 1 && /* 0x7fffffff */ + f2ull((float) ((~0ULL) >> 1)) != ((~0ULL) >> 1) + 1) + abort(); + if (f2ull((float) ~((~0ULL) >> 1)) != ~((~0ULL) >> 1)) /* 0x80000000 */ + abort(); +#endif + + if (d2ull(0.0) != 0LL) + abort(); + if (d2ull(0.999) != 0LL) + abort(); + if (d2ull(1.0) != 1LL) + abort(); + if (d2ull(1.99) != 1LL) + abort(); + if (d2ull((double) 0x7fffffffULL) != (~0ULL) >> 1 && /* 0x7fffffff */ + d2ull((double) 0x7fffffffULL) != ((~0ULL) >> 1) + 1) + abort(); + if (d2ull((double) 0x80000000ULL) != ~((~0ULL) >> 1)) /* 0x80000000 */ + abort(); +#if 0 + if (d2ull((double) ((~0ULL) >> 1)) != (~0ULL) >> 1 && /* 0x7fffffff */ + d2ull((double) ((~0ULL) >> 1)) != ((~0ULL) >> 1) + 1) + abort(); + if (d2ull((double) ~((~0ULL) >> 1)) != ~((~0ULL) >> 1)) /* 0x80000000 */ + abort(); +#endif + + if (ld2ull(0.0) != 0LL) + abort(); + if (ld2ull(0.999) != 0LL) + abort(); + if (ld2ull(1.0) != 1LL) + abort(); + if (ld2ull(1.99) != 1LL) + abort(); +#if 0 + if (ld2ull((long double) ((~0ULL) >> 1)) != (~0ULL) >> 1 && /* 0x7fffffff */ + ld2ull((long double) ((~0ULL) >> 1)) != ((~0ULL) >> 1) + 1) + abort(); + if (ld2ull((long double) ~((~0ULL) >> 1)) != ~((~0ULL) >> 1)) /* 0x80000000 */ + abort(); +#endif + + if (f2sll(0.0) != 0LL) + abort(); + if (f2sll(0.99) != 0LL) + abort(); + if (f2sll(1.0) != 1LL) + abort(); + if (f2sll(1.99) != 1LL) + abort(); +// if (f2sll(-0.99) != 0LL) +// abort(); + if (f2sll(-1.0) != -1LL) + abort(); +// if (f2sll(-1.99) != -1LL) +// abort(); + if (f2sll((float)(long long int)~((~0ULL) >> 1)) != (long long int)~((~0ULL) >> 1)) /* 0x80000000 */ + abort(); + + if (d2sll(0.0) != 0LL) + abort(); + if (d2sll(0.999) != 0LL) + abort(); + if (d2sll(1.0) != 1LL) + abort(); + if (d2sll(1.99) != 1LL) + abort(); +// if (d2sll(-0.999) != 0LL) +// abort(); + if (d2sll(-1.0) != -1LL) + abort(); +// if (d2sll(-1.99) != -1LL) +// abort(); + if (d2sll((double)(long long int)~((~0ULL) >> 1)) != (long long int)~((~0ULL) >> 1)) /* 0x80000000 */ + abort(); + + if (ld2sll(0.0) != 0LL) + abort(); + if (ld2sll(0.999) != 0LL) + abort(); + if (ld2sll(1.0) != 1LL) + abort(); + if (ld2sll(1.99) != 1LL) + abort(); +// if (ld2sll(-0.999) != 0LL) +// abort(); + if (ld2sll(-1.0) != -1LL) + abort(); +// if (ld2sll(-1.99) != -1LL) +// abort(); + if (ld2sll((long double)(long long int)~((~0ULL) >> 1)) != (long long int)~((~0ULL) >> 1)) /* 0x80000000 */ + abort(); +} +#endif + +main() +{ + test_integer_to_float(); + test_float_to_integer(); +#if 1 //__GNUC__ + test_longlong_integer_to_float(); + test_float_to_longlong_integer(); +#endif + exit(0); +} diff --git a/test/tests/cvt-1.c b/test/tests/cvt-1.c new file mode 100644 index 0000000..a1b9271 --- /dev/null +++ b/test/tests/cvt-1.c @@ -0,0 +1,28 @@ +static inline long +g1 (double x) +{ + return (double) (long) x; +} + +long +g2 (double f) +{ + return f; +} + +double +f (long i) +{ + if (g1 (i) != g2 (i)) + abort (); + return g2 (i); +} + +main () +{ + if (f (12345L) != 12345L) + abort (); + if (f (12345L) != g2 (12345L)) + abort (); + exit (0); +} diff --git a/test/tests/dbra-1.c b/test/tests/dbra-1.c new file mode 100644 index 0000000..20ae898 --- /dev/null +++ b/test/tests/dbra-1.c @@ -0,0 +1,95 @@ +f1 (a) + long a; +{ + int i; + for (i = 0; i < 10; i++) + { + if (--a == -1) + return i; + } + return -1; +} + +f2 (a) + long a; +{ + int i; + for (i = 0; i < 10; i++) + { + if (--a != -1) + return i; + } + return -1; +} + +f3 (a) + long a; +{ + int i; + for (i = 0; i < 10; i++) + { + if (--a == 0) + return i; + } + return -1; +} + +f4 (a) + long a; +{ + int i; + for (i = 0; i < 10; i++) + { + if (--a != 0) + return i; + } + return -1; +} + +f5 (a) + long a; +{ + int i; + for (i = 0; i < 10; i++) + { + if (++a == 0) + return i; + } + return -1; +} + +f6 (a) + long a; +{ + int i; + for (i = 0; i < 10; i++) + { + if (++a != 0) + return i; + } + return -1; +} + + +main() +{ + if (f1 (5L) != 5) + abort (); + if (f2 (1L) != 0) + abort (); + if (f2 (0L) != 1) + abort (); + if (f3 (5L) != 4) + abort (); + if (f4 (1L) != 1) + abort (); + if (f4 (0L) != 0) + abort (); + if (f5 (-5L) != 4) + abort (); + if (f6 (-1L) != 1) + abort (); + if (f6 (0L) != 0) + abort (); + exit (0); +} diff --git a/test/tests/divcmp-1.c b/test/tests/divcmp-1.c new file mode 100644 index 0000000..0a7f305 --- /dev/null +++ b/test/tests/divcmp-1.c @@ -0,0 +1,356 @@ +extern void abort(void); + +int test1(int x) +{ + return x/10 == 2; +} + +int test1u(unsigned int x) +{ + return x/10U == 2; +} + +int test2(int x) +{ + return x/10 == 0; +} + +int test2u(unsigned int x) +{ + return x/10U == 0; +} + +int test3(int x) +{ + return x/10 != 2; +} + +int test3u(unsigned int x) +{ + return x/10U != 2; +} + +int test4(int x) +{ + return x/10 != 0; +} + +int test4u(unsigned int x) +{ + return x/10U != 0; +} + +int test5(int x) +{ + return x/10 < 2; +} + +int test5u(unsigned int x) +{ + return x/10U < 2; +} + +int test6(int x) +{ + return x/10 < 0; +} + +int test7(int x) +{ + return x/10 <= 2; +} + +int test7u(unsigned int x) +{ + return x/10U <= 2; +} + +int test8(int x) +{ + return x/10 <= 0; +} + +int test8u(unsigned int x) +{ + return x/10U <= 0; +} + +int test9(int x) +{ + return x/10 > 2; +} + +int test9u(unsigned int x) +{ + return x/10U > 2; +} + +int test10(int x) +{ + return x/10 > 0; +} + +int test10u(unsigned int x) +{ + return x/10U > 0; +} + +int test11(int x) +{ + return x/10 >= 2; +} + +int test11u(unsigned int x) +{ + return x/10U >= 2; +} + +int test12(int x) +{ + return x/10 >= 0; +} + + +int main() +{ + if (test1(19) != 0) + abort (); + if (test1(20) != 1) + abort (); + if (test1(29) != 1) + abort (); + if (test1(30) != 0) + abort (); + + if (test1u(19) != 0) + abort (); + if (test1u(20) != 1) + abort (); + if (test1u(29) != 1) + abort (); + if (test1u(30) != 0) + abort (); + + if (test2(0) != 1) + abort (); + if (test2(9) != 1) + abort (); + if (test2(10) != 0) + abort (); + if (test2(-1) != 1) + abort (); + if (test2(-9) != 1) + abort (); + if (test2(-10) != 0) + abort (); + + if (test2u(0) != 1) + abort (); + if (test2u(9) != 1) + abort (); + if (test2u(10) != 0) + abort (); + if (test2u(-1) != 0) + abort (); + if (test2u(-9) != 0) + abort (); + if (test2u(-10) != 0) + abort (); + + if (test3(19) != 1) + abort (); + if (test3(20) != 0) + abort (); + if (test3(29) != 0) + abort (); + if (test3(30) != 1) + abort (); + + if (test3u(19) != 1) + abort (); + if (test3u(20) != 0) + abort (); + if (test3u(29) != 0) + abort (); + if (test3u(30) != 1) + abort (); + + if (test4(0) != 0) + abort (); + if (test4(9) != 0) + abort (); + if (test4(10) != 1) + abort (); + if (test4(-1) != 0) + abort (); + if (test4(-9) != 0) + abort (); + if (test4(-10) != 1) + abort (); + + if (test4u(0) != 0) + abort (); + if (test4u(9) != 0) + abort (); + if (test4u(10) != 1) + abort (); + if (test4u(-1) != 1) + abort (); + if (test4u(-9) != 1) + abort (); + if (test4u(-10) != 1) + abort (); + + if (test5(19) != 1) + abort (); + if (test5(20) != 0) + abort (); + if (test5(29) != 0) + abort (); + if (test5(30) != 0) + abort (); + + if (test5u(19) != 1) + abort (); + if (test5u(20) != 0) + abort (); + if (test5u(29) != 0) + abort (); + if (test5u(30) != 0) + abort (); + + if (test6(0) != 0) + abort (); + if (test6(9) != 0) + abort (); + if (test6(10) != 0) + abort (); + if (test6(-1) != 0) + abort (); + if (test6(-9) != 0) + abort (); + if (test6(-10) != 1) + abort (); + + if (test7(19) != 1) + abort (); + if (test7(20) != 1) + abort (); + if (test7(29) != 1) + abort (); + if (test7(30) != 0) + abort (); + + if (test7u(19) != 1) + abort (); + if (test7u(20) != 1) + abort (); + if (test7u(29) != 1) + abort (); + if (test7u(30) != 0) + abort (); + + if (test8(0) != 1) + abort (); + if (test8(9) != 1) + abort (); + if (test8(10) != 0) + abort (); + if (test8(-1) != 1) + abort (); + if (test8(-9) != 1) + abort (); + if (test8(-10) != 1) + abort (); + + if (test8u(0) != 1) + abort (); + if (test8u(9) != 1) + abort (); + if (test8u(10) != 0) + abort (); + if (test8u(-1) != 0) + abort (); + if (test8u(-9) != 0) + abort (); + if (test8u(-10) != 0) + abort (); + + if (test9(19) != 0) + abort (); + if (test9(20) != 0) + abort (); + if (test9(29) != 0) + abort (); + if (test9(30) != 1) + abort (); + + if (test9u(19) != 0) + abort (); + if (test9u(20) != 0) + abort (); + if (test9u(29) != 0) + abort (); + if (test9u(30) != 1) + abort (); + + if (test10(0) != 0) + abort (); + if (test10(9) != 0) + abort (); + if (test10(10) != 1) + abort (); + if (test10(-1) != 0) + abort (); + if (test10(-9) != 0) + abort (); + if (test10(-10) != 0) + abort (); + + if (test10u(0) != 0) + abort (); + if (test10u(9) != 0) + abort (); + if (test10u(10) != 1) + abort (); + if (test10u(-1) != 1) + abort (); + if (test10u(-9) != 1) + abort (); + if (test10u(-10) != 1) + abort (); + + if (test11(19) != 0) + abort (); + if (test11(20) != 1) + abort (); + if (test11(29) != 1) + abort (); + if (test11(30) != 1) + abort (); + + if (test11u(19) != 0) + abort (); + if (test11u(20) != 1) + abort (); + if (test11u(29) != 1) + abort (); + if (test11u(30) != 1) + abort (); + + if (test12(0) != 1) + abort (); + if (test12(9) != 1) + abort (); + if (test12(10) != 1) + abort (); + if (test12(-1) != 1) + abort (); + if (test12(-9) != 1) + abort (); + if (test12(-10) != 0) + abort (); + + return 0; +} + diff --git a/test/tests/divcmp-2.c b/test/tests/divcmp-2.c new file mode 100644 index 0000000..b059b8f --- /dev/null +++ b/test/tests/divcmp-2.c @@ -0,0 +1,92 @@ +extern void abort (void); + +int test1(int x) +{ + return x/10 == 2; +} + +int test2(int x) +{ + return x/10 == 0; +} + +int test3(int x) +{ + return x/10 == -2; +} + +int test4(int x) +{ + return x/-10 == 2; +} + +int test5(int x) +{ + return x/-10 == 0; +} + +int test6(int x) +{ + return x/-10 == -2; +} + + +int main() +{ + if (test1(19) != 0) + abort (); + if (test1(20) != 1) + abort (); + if (test1(29) != 1) + abort (); + if (test1(30) != 0) + abort (); + + if (test2(-10) != 0) + abort (); + if (test2(-9) != 1) + abort (); + if (test2(9) != 1) + abort (); + if (test2(10) != 0) + abort (); + + if (test3(-30) != 0) + abort (); + if (test3(-29) != 1) + abort (); + if (test3(-20) != 1) + abort (); + if (test3(-19) != 0) + abort (); + + if (test4(-30) != 0) + abort (); + if (test4(-29) != 1) + abort (); + if (test4(-20) != 1) + abort (); + if (test4(-19) != 0) + abort (); + + if (test5(-10) != 0) + abort (); + if (test5(-9) != 1) + abort (); + if (test5(9) != 1) + abort (); + if (test5(10) != 0) + abort (); + + if (test6(19) != 0) + abort (); + if (test6(20) != 1) + abort (); + if (test6(29) != 1) + abort (); + if (test6(30) != 0) + abort (); + + return 0; +} + diff --git a/test/tests/divcmp-3.c b/test/tests/divcmp-3.c new file mode 100644 index 0000000..ba52c9e --- /dev/null +++ b/test/tests/divcmp-3.c @@ -0,0 +1,97 @@ +extern void abort(void); + +int test1(char x) +{ + return x/100 == 3; +} + +int test1u(unsigned char x) +{ + return x/100 == 3; +} + +int test2(char x) +{ + return x/100 != 3; +} + +int test2u(unsigned char x) +{ + return x/100 != 3; +} + +int test3(char x) +{ + return x/100 < 3; +} + +int test3u(unsigned char x) +{ + return x/100 < 3; +} + +int test4(char x) +{ + return x/100 <= 3; +} + +int test4u(unsigned char x) +{ + return x/100 <= 3; +} + +int test5(char x) +{ + return x/100 > 3; +} + +int test5u(unsigned char x) +{ + return x/100 > 3; +} + +int test6(char x) +{ + return x/100 >= 3; +} + +int test6u(unsigned char x) +{ + return x/100 >= 3; +} + + +int main() +{ + int c; + + for (c=-128; c<256; c++) + { + if (test1(c) != 0) + abort (); + if (test1u(c) != 0) + abort (); + if (test2(c) != 1) + abort (); + if (test2u(c) != 1) + abort (); + if (test3(c) != 1) + abort (); + if (test3u(c) != 1) + abort (); + if (test4(c) != 1) + abort (); + if (test4u(c) != 1) + abort (); + if (test5(c) != 0) + abort (); + if (test5u(c) != 0) + abort (); + if (test6(c) != 0) + abort (); + if (test6u(c) != 0) + abort (); + } + return 0; +} + diff --git a/test/tests/divcmp-4.c b/test/tests/divcmp-4.c new file mode 100644 index 0000000..ebc09a1 --- /dev/null +++ b/test/tests/divcmp-4.c @@ -0,0 +1,202 @@ +/* PR middle-end/17894 */ + +extern void abort(void); + +int test1(int x) +{ + return x/-10 == 2; +} + +int test2(int x) +{ + return x/-10 == 0; +} + +int test3(int x) +{ + return x/-10 != 2; +} + +int test4(int x) +{ + return x/-10 != 0; +} + +int test5(int x) +{ + return x/-10 < 2; +} + +int test6(int x) +{ + return x/-10 < 0; +} + +int test7(int x) +{ + return x/-10 <= 2; +} + +int test8(int x) +{ + return x/-10 <= 0; +} + +int test9(int x) +{ + return x/-10 > 2; +} + +int test10(int x) +{ + return x/-10 > 0; +} + +int test11(int x) +{ + return x/-10 >= 2; +} + +int test12(int x) +{ + return x/-10 >= 0; +} + + +int main() +{ + if (test1(-30) != 0) + abort (); + if (test1(-29) != 1) + abort (); + if (test1(-20) != 1) + abort (); + if (test1(-19) != 0) + abort (); + + if (test2(0) != 1) + abort (); + if (test2(9) != 1) + abort (); + if (test2(10) != 0) + abort (); + if (test2(-1) != 1) + abort (); + if (test2(-9) != 1) + abort (); + if (test2(-10) != 0) + abort (); + + if (test3(-30) != 1) + abort (); + if (test3(-29) != 0) + abort (); + if (test3(-20) != 0) + abort (); + if (test3(-19) != 1) + abort (); + + if (test4(0) != 0) + abort (); + if (test4(9) != 0) + abort (); + if (test4(10) != 1) + abort (); + if (test4(-1) != 0) + abort (); + if (test4(-9) != 0) + abort (); + if (test4(-10) != 1) + abort (); + + if (test5(-30) != 0) + abort (); + if (test5(-29) != 0) + abort (); + if (test5(-20) != 0) + abort (); + if (test5(-19) != 1) + abort (); + + if (test6(0) != 0) + abort (); + if (test6(9) != 0) + abort (); + if (test6(10) != 1) + abort (); + if (test6(-1) != 0) + abort (); + if (test6(-9) != 0) + abort (); + if (test6(-10) != 0) + abort (); + + if (test7(-30) != 0) + abort (); + if (test7(-29) != 1) + abort (); + if (test7(-20) != 1) + abort (); + if (test7(-19) != 1) + abort (); + + if (test8(0) != 1) + abort (); + if (test8(9) != 1) + abort (); + if (test8(10) != 1) + abort (); + if (test8(-1) != 1) + abort (); + if (test8(-9) != 1) + abort (); + if (test8(-10) != 0) + abort (); + + if (test9(-30) != 1) + abort (); + if (test9(-29) != 0) + abort (); + if (test9(-20) != 0) + abort (); + if (test9(-19) != 0) + abort (); + + if (test10(0) != 0) + abort (); + if (test10(9) != 0) + abort (); + if (test10(10) != 0) + abort (); + if (test10(-1) != 0) + abort (); + if (test10(-9) != 0) + abort (); + if (test10(-10) != 1) + abort (); + + if (test11(-30) != 1) + abort (); + if (test11(-29) != 1) + abort (); + if (test11(-20) != 1) + abort (); + if (test11(-19) != 0) + abort (); + + if (test12(0) != 1) + abort (); + if (test12(9) != 1) + abort (); + if (test12(10) != 0) + abort (); + if (test12(-1) != 1) + abort (); + if (test12(-9) != 1) + abort (); + if (test12(-10) != 1) + abort (); + + return 0; +} + diff --git a/test/tests/divcmp-5.c b/test/tests/divcmp-5.c new file mode 100644 index 0000000..890cb30 --- /dev/null +++ b/test/tests/divcmp-5.c @@ -0,0 +1,31 @@ +/* PR middle-end/26561 */ + +extern void abort(void); + +int always_one_1 (int a) +{ + if (a/100 >= -9999) + return 1; + else + return 0; +} + +int always_one_2 (int a) +{ + if (a/100 < -9999) + return 0; + else + return 1; +} + +int main(void) +{ + if (always_one_1 (0) != 1) + abort (); + + if (always_one_2 (0) != 1) + abort (); + + return 0; +} + diff --git a/test/tests/divconst-1.c b/test/tests/divconst-1.c new file mode 100644 index 0000000..ce9dd60 --- /dev/null +++ b/test/tests/divconst-1.c @@ -0,0 +1,21 @@ +typedef struct +{ + unsigned a, b, c, d; +} t1; + +f (t1 *ps) +{ + ps->a = 10000; + ps->b = ps->a / 3; + ps->c = 10000; + ps->d = ps->c / 3; +} + +main () +{ + t1 s; + f (&s); + if (s.a != 10000 || s.b != 3333 || s.c != 10000 || s.d != 3333) + abort (); + exit (0); +} diff --git a/test/tests/divconst-2.c b/test/tests/divconst-2.c new file mode 100644 index 0000000..71804e9 --- /dev/null +++ b/test/tests/divconst-2.c @@ -0,0 +1,39 @@ +long +f (long x) +{ + return x / (-0x7fffL - 1L); +} + +long +r (long x) +{ + return x % (-0x7fffL - 1L); +} + +/* Since we have a negative divisor, this equation must hold for the + results of / and %; no specific results are guaranteed. */ +long +std_eqn (long num, long denom, long quot, long rem) +{ + /* For completeness, a check for "ABS (rem) < ABS (denom)" belongs here, + but causes trouble on 32-bit machines and isn't worthwhile. */ + return quot * (-0x7fffL - 1L) + rem == num; +} + +long nums[] = +{ + -1L, 0x7fffL, -0x7fffL - 1L +}; + +main () +{ + int i; + + for (i = 0; + i < sizeof (nums) / sizeof (nums[0]); + i++) + if (std_eqn (nums[i], -0x7fffL - 1L, f (nums[i]), r (nums[i])) == 0) + abort (); + + exit (0); +} diff --git a/test/tests/divconst-3.c b/test/tests/divconst-3.c new file mode 100644 index 0000000..d52a9ed --- /dev/null +++ b/test/tests/divconst-3.c @@ -0,0 +1,12 @@ +long long +f (long long x) +{ + return x / 100000000LL; +} + +main () +{ + if (f (100000000LL) != 1 || f (1000000000LL) != 10) + abort (); + exit (0); +} diff --git a/test/tests/divmod-1.c b/test/tests/divmod-1.c new file mode 100644 index 0000000..2bcd109 --- /dev/null +++ b/test/tests/divmod-1.c @@ -0,0 +1,77 @@ +div1 (signed char x) +{ + return x / -1; +} + +div2 (signed short x) +{ + return x / -1; +} + +div3 (signed char x, signed char y) +{ + return x / y; +} + +div4 (signed short x, signed short y) +{ + return x / y; +} + +mod1 (signed char x) +{ + return x % -1; +} + +mod2 (signed short x) +{ + return x % -1; +} + +mod3 (signed char x, signed char y) +{ + return x % y; +} + +mod4 (signed short x, signed short y) +{ + return x % y; +} + +signed long +mod5 (signed long x, signed long y) +{ + return x % y; +} + +unsigned long +mod6 (unsigned long x, unsigned long y) +{ + return x % y; +} + +main () +{ + if (div1 (-(1 << 7)) != 1 << 7) + abort (); + if (div2 (-(1 << 15)) != 1 << 15) + abort (); + if (div3 (-(1 << 7), -1) != 1 << 7) + abort (); + if (div4 (-(1 << 15), -1) != 1 << 15) + abort (); + if (mod1 (-(1 << 7)) != 0) + abort (); + if (mod2 (-(1 << 15)) != 0) + abort (); + if (mod3 (-(1 << 7), -1) != 0) + abort (); + if (mod4 (-(1 << 15), -1) != 0) + abort (); + if (mod5 (0x50000000, 2) != 0) + abort (); + if (mod6 (0x50000000, 2) != 0) + abort (); + + exit (0); +} diff --git a/test/tests/enum-1.c b/test/tests/enum-1.c new file mode 100644 index 0000000..381e354 --- /dev/null +++ b/test/tests/enum-1.c @@ -0,0 +1,43 @@ +typedef enum +{ + END = -1, + EMPTY = (1 << 8 ) , + BACKREF, + BEGLINE, + ENDLINE, + BEGWORD, + ENDWORD, + LIMWORD, + NOTLIMWORD, + QMARK, + STAR, + PLUS, + REPMN, + CAT, + OR, + ORTOP, + LPAREN, + RPAREN, + CSET +} token; + +static token tok; + +static int +atom () +{ + if ((tok >= 0 && tok < (1 << 8 ) ) || tok >= CSET || tok == BACKREF + || tok == BEGLINE || tok == ENDLINE || tok == BEGWORD + || tok == ENDWORD || tok == LIMWORD || tok == NOTLIMWORD) + return 1; + else + return 0; +} + +main () +{ + tok = 0; + if (atom () != 1) + abort (); + exit (0); +} diff --git a/test/tests/enum-2.c b/test/tests/enum-2.c new file mode 100644 index 0000000..dd6f640 --- /dev/null +++ b/test/tests/enum-2.c @@ -0,0 +1,22 @@ +/* Copyright (C) 2000 Free Software Foundation */ +/* by Alexandre Oliva */ + +enum foo { FOO, BAR }; + +/* Even though the underlying type of an enum is unspecified, the type + of enumeration constants is explicitly defined as int (6.4.4.3/2 in + the C99 Standard). Therefore, `i' must not be promoted to + `unsigned' in the comparison below; we must exit the loop when it + becomes negative. */ + +int +main () +{ + int i; + for (i = BAR; i >= FOO; --i) + if (i == -1) + abort (); + + exit (0); +} + diff --git a/test/tests/enum-3.c b/test/tests/enum-3.c new file mode 100644 index 0000000..1151dbe --- /dev/null +++ b/test/tests/enum-3.c @@ -0,0 +1,24 @@ +/* The composite type of int and an enum compatible with int might be + either of the two types, but it isn't an unsigned type. */ +/* Origin: Joseph Myers */ + +#include + +//#include + +extern void abort (void); +extern void exit (int); + +enum e { a = INT_MIN }; + +int *p; +enum e *q; +int +main (void) +{ + enum e x = a; + q = &x; + if (*(1 ? q : p) > 0) + abort (); + exit (0); +} diff --git a/test/tests/extzvsi.c b/test/tests/extzvsi.c new file mode 100644 index 0000000..81f1618 --- /dev/null +++ b/test/tests/extzvsi.c @@ -0,0 +1,41 @@ +/* The bit-field below would have a problem if __INT_MAX__ is too + small. */ +#if __INT_MAX__ < 2147483647 +int +main (void) +{ + exit (0); +} +#else +/* Failed on powerpc due to bad extzvsi pattern. */ + +struct ieee +{ + unsigned int negative:1; + unsigned int exponent:11; + unsigned int mantissa0:20; + unsigned int mantissa1:32; +} x; + +unsigned int +foo (void) +{ + unsigned int exponent; + + exponent = x.exponent; + if (exponent == 0) + return 1; + else if (exponent > 1) + return 2; + return 0; +} + +int +main (void) +{ + x.exponent = 1; + if (foo () != 0) + abort (); + return 0; +} +#endif diff --git a/test/tests/ffs-1.c b/test/tests/ffs-1.c new file mode 100644 index 0000000..da82e55 --- /dev/null +++ b/test/tests/ffs-1.c @@ -0,0 +1,12 @@ +__volatile int a = 0; + +extern void abort (void); +extern void exit (int); + +int +main (void) +{ + if (__builtin_ffs (a) != 0) + abort (); + exit (0); +} diff --git a/test/tests/ffs-2.c b/test/tests/ffs-2.c new file mode 100644 index 0000000..ae246ce --- /dev/null +++ b/test/tests/ffs-2.c @@ -0,0 +1,44 @@ +struct + { + int input; + int output; + } +ffstesttab[] = + { +#if __INT_MAX__ >= 2147483647 + /* at least 32-bit integers */ + { 0x80000000, 32 }, + { 0xa5a5a5a5, 1 }, + { 0x5a5a5a5a, 2 }, + { 0xcafe0000, 18 }, +#endif +#if __INT_MAX__ >= 32767 + /* at least 16-bit integers */ + { 0x8000, 16 }, + { 0xa5a5, 1 }, + { 0x5a5a, 2 }, + { 0x0ca0, 6 }, +#endif +#if __INT_MAX__ < 32767 +#error integers are too small +#endif + }; + +#define NFFSTESTS (sizeof (ffstesttab) / sizeof (ffstesttab[0])) + +extern void abort (void); +extern void exit (int); + +int +main (void) +{ + int i; + + for (i = 0; i < NFFSTESTS; i++) + { + if (__builtin_ffs (ffstesttab[i].input) != ffstesttab[i].output) + abort (); + } + + exit (0); +} diff --git a/test/tests/floatunsisf-1.c b/test/tests/floatunsisf-1.c new file mode 100644 index 0000000..a8107dd --- /dev/null +++ b/test/tests/floatunsisf-1.c @@ -0,0 +1,21 @@ +/* The fp-bit.c function __floatunsisf had a latent bug where guard bits + could be lost leading to incorrect rounding. */ +/* Origin: Joseph Myers */ + +extern void abort (void); +extern void exit (int); +#if __INT_MAX__ >= 0x7fffffff +volatile unsigned u = 0x8081; +#else +volatile unsigned long u = 0x8081; +#endif +volatile float f1, f2; +int +main (void) +{ + f1 = (float) u; + f2 = (float) 0x8081U; + if (f1 != f2) + abort (); + exit (0); +} diff --git a/test/tests/func-ptr-1.c b/test/tests/func-ptr-1.c new file mode 100644 index 0000000..55f0e10 --- /dev/null +++ b/test/tests/func-ptr-1.c @@ -0,0 +1,16 @@ +static double f (float a); +static double (*fp) (float a); + +main () +{ + fp = f; + if (fp ((float) 1) != 1.0) + abort (); + exit (0); +} + +static double +f (float a) +{ + return a; +} diff --git a/test/tests/gofast.c b/test/tests/gofast.c new file mode 100644 index 0000000..868aa85 --- /dev/null +++ b/test/tests/gofast.c @@ -0,0 +1,99 @@ +/* Program to test gcc's usage of the gofast library. */ + +/* The main guiding themes are to make it trivial to add test cases over time + and to make it easy for a program to parse the output to see if the right + libcalls are being made. */ + +//#include + +float fp_add (float a, float b) { return a + b; } +float fp_sub (float a, float b) { return a - b; } +float fp_mul (float a, float b) { return a * b; } +float fp_div (float a, float b) { return a / b; } +float fp_neg (float a) { return -a; } + +double dp_add (double a, double b) { return a + b; } +double dp_sub (double a, double b) { return a - b; } +double dp_mul (double a, double b) { return a * b; } +double dp_div (double a, double b) { return a / b; } +double dp_neg (double a) { return -a; } + +double fp_to_dp (float f) { return f; } +float dp_to_fp (double d) { return d; } + +int eqsf2 (float a, float b) { return a == b; } +int nesf2 (float a, float b) { return a != b; } +int gtsf2 (float a, float b) { return a > b; } +int gesf2 (float a, float b) { return a >= b; } +int ltsf2 (float a, float b) { return a < b; } +int lesf2 (float a, float b) { return a <= b; } + +int eqdf2 (double a, double b) { return a == b; } +int nedf2 (double a, double b) { return a != b; } +int gtdf2 (double a, double b) { return a > b; } +int gedf2 (double a, double b) { return a >= b; } +int ltdf2 (double a, double b) { return a < b; } +int ledf2 (double a, double b) { return a <= b; } + +float floatsisf (int i) { return i; } +double floatsidf (int i) { return i; } +int fixsfsi (float f) { return f; } +int fixdfsi (double d) { return d; } +unsigned int fixunssfsi (float f) { return f; } +unsigned int fixunsdfsi (double d) { return d; } + +int fail_count = 0; + +int +fail (char *msg) +{ + fail_count++; + //fprintf (stderr, "Test failed: %s\n", msg); +} + +int +main() +{ + if (fp_add (1, 1) != 2) fail ("fp_add 1+1"); + if (fp_sub (3, 2) != 1) fail ("fp_sub 3-2"); + if (fp_mul (2, 3) != 6) fail ("fp_mul 2*3"); + if (fp_div (3, 2) != 1.5) fail ("fp_div 3/2"); + if (fp_neg (1) != -1) fail ("fp_neg 1"); + + if (dp_add (1, 1) != 2) fail ("dp_add 1+1"); + if (dp_sub (3, 2) != 1) fail ("dp_sub 3-2"); + if (dp_mul (2, 3) != 6) fail ("dp_mul 2*3"); + if (dp_div (3, 2) != 1.5) fail ("dp_div 3/2"); + if (dp_neg (1) != -1) fail ("dp_neg 1"); + + if (fp_to_dp (1.5) != 1.5) fail ("fp_to_dp 1.5"); + if (dp_to_fp (1.5) != 1.5) fail ("dp_to_fp 1.5"); + + if (floatsisf (1) != 1) fail ("floatsisf 1"); + if (floatsidf (1) != 1) fail ("floatsidf 1"); + if (fixsfsi (1.42) != 1) fail ("fixsfsi 1.42"); + if (fixunssfsi (1.42) != 1) fail ("fixunssfsi 1.42"); + if (fixdfsi (1.42) != 1) fail ("fixdfsi 1.42"); + if (fixunsdfsi (1.42) != 1) fail ("fixunsdfsi 1.42"); + + if (eqsf2 (1, 1) == 0) fail ("eqsf2 1==1"); + if (eqsf2 (1, 2) != 0) fail ("eqsf2 1==2"); + if (nesf2 (1, 2) == 0) fail ("nesf2 1!=1"); + if (nesf2 (1, 1) != 0) fail ("nesf2 1!=1"); + if (gtsf2 (2, 1) == 0) fail ("gtsf2 2>1"); + if (gtsf2 (1, 1) != 0) fail ("gtsf2 1>1"); + if (gtsf2 (0, 1) != 0) fail ("gtsf2 0>1"); + if (gesf2 (2, 1) == 0) fail ("gesf2 2>=1"); + if (gesf2 (1, 1) == 0) fail ("gesf2 1>=1"); + if (gesf2 (0, 1) != 0) fail ("gesf2 0>=1"); + if (ltsf2 (1, 2) == 0) fail ("ltsf2 1<2"); + if (ltsf2 (1, 1) != 0) fail ("ltsf2 1<1"); + if (ltsf2 (1, 0) != 0) fail ("ltsf2 1<0"); + if (lesf2 (1, 2) == 0) fail ("lesf2 1<=2"); + if (lesf2 (1, 1) == 0) fail ("lesf2 1<=1"); + if (lesf2 (1, 0) != 0) fail ("lesf2 1<=0"); + + if (fail_count != 0) + exit (fail_count); + exit (0); +} diff --git a/test/tests/index-1.c b/test/tests/index-1.c new file mode 100644 index 0000000..b00090d --- /dev/null +++ b/test/tests/index-1.c @@ -0,0 +1,20 @@ +int a[] = +{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 32, 33, 34, 35, 36, 37, 38, 39 +}; + +int +f (long n) +{ + return a[n - 100000]; +} + +main () +{ + if (f (100030L) != 30) + abort(); + exit (0); +} diff --git a/test/tests/inst-check.c b/test/tests/inst-check.c new file mode 100644 index 0000000..ff4b00d --- /dev/null +++ b/test/tests/inst-check.c @@ -0,0 +1,14 @@ +#include + +f(m) +{ + int i,s=0; + for(i=0;i + +gt (a, b) +{ + return a > b; +} + +ge (a, b) +{ + return a >= b; +} + +lt (a, b) +{ + return a < b; +} + +le (a, b) +{ + return a <= b; +} + +void +true (c) +{ + if (!c) + abort(); +} + +void +false (c) +{ + if (c) + abort(); +} + +f () +{ + true (gt (2, 1)); + false (gt (1, 2)); + + true (gt (INT_MAX, 0)); + false (gt (0, INT_MAX)); + true (gt (INT_MAX, 1)); + false (gt (1, INT_MAX)); + + false (gt (INT_MIN, 0)); + true (gt (0, INT_MIN)); + false (gt (INT_MIN, 1)); + true (gt (1, INT_MIN)); + + true (gt (INT_MAX, INT_MIN)); + false (gt (INT_MIN, INT_MAX)); + + true (ge (2, 1)); + false (ge (1, 2)); + + true (ge (INT_MAX, 0)); + false (ge (0, INT_MAX)); + true (ge (INT_MAX, 1)); + false (ge (1, INT_MAX)); + + false (ge (INT_MIN, 0)); + true (ge (0, INT_MIN)); + false (ge (INT_MIN, 1)); + true (ge (1, INT_MIN)); + + true (ge (INT_MAX, INT_MIN)); + false (ge (INT_MIN, INT_MAX)); + + false (lt (2, 1)); + true (lt (1, 2)); + + false (lt (INT_MAX, 0)); + true (lt (0, INT_MAX)); + false (lt (INT_MAX, 1)); + true (lt (1, INT_MAX)); + + true (lt (INT_MIN, 0)); + false (lt (0, INT_MIN)); + true (lt (INT_MIN, 1)); + false (lt (1, INT_MIN)); + + false (lt (INT_MAX, INT_MIN)); + true (lt (INT_MIN, INT_MAX)); + + false (le (2, 1)); + true (le (1, 2)); + + false (le (INT_MAX, 0)); + true (le (0, INT_MAX)); + false (le (INT_MAX, 1)); + true (le (1, INT_MAX)); + + true (le (INT_MIN, 0)); + false (le (0, INT_MIN)); + true (le (INT_MIN, 1)); + false (le (1, INT_MIN)); + + false (le (INT_MAX, INT_MIN)); + true (le (INT_MIN, INT_MAX)); +} + +main () +{ + f (); + exit (0); +} diff --git a/test/tests/loop-1.c b/test/tests/loop-1.c new file mode 100644 index 0000000..81aeeb6 --- /dev/null +++ b/test/tests/loop-1.c @@ -0,0 +1,18 @@ +main () +{ + int i, j, k[3]; + + j = 0; + for (i=0; i < 3; i++) + { + k[i] = j++; + } + + for (i=2; i >= 0; i--) + { + if (k[i] != i) + abort (); + } + + exit (0); +} diff --git a/test/tests/loop-10.c b/test/tests/loop-10.c new file mode 100644 index 0000000..1a6afba --- /dev/null +++ b/test/tests/loop-10.c @@ -0,0 +1,31 @@ +/* Reduced from PR optimization/5076, PR optimization/2847 */ + +static int count = 0; + +static void +inc (void) +{ + count++; +} + +int +main (void) +{ + int iNbr = 1; + int test = 0; + while (test == 0) + { + inc (); + if (iNbr == 0) + break; + else + { + inc (); + iNbr--; + } + test = 1; + } + if (count != 2) + abort (); + return 0; +} diff --git a/test/tests/loop-11.c b/test/tests/loop-11.c new file mode 100644 index 0000000..ab240ce --- /dev/null +++ b/test/tests/loop-11.c @@ -0,0 +1,20 @@ +static int a[199]; + +static void +foo () +{ + int i; + for (i = 198; i >= 0; i--) + a[i] = i; +} + +int +main () +{ + int i; + foo (); + for (i = 0; i < 199; i++) + if (a[i] != i) + abort (); + return 0; +} diff --git a/test/tests/loop-12.c b/test/tests/loop-12.c new file mode 100644 index 0000000..1e34099 --- /dev/null +++ b/test/tests/loop-12.c @@ -0,0 +1,25 @@ +/* Checks that pure functions are not treated as const. */ + +char *p; + +static int __attribute__ ((pure)) +is_end_of_statement (void) +{ + return *p == '\n' || *p == ';' || *p == '!'; +} + +void foo (void) +{ + /* The is_end_of_statement call was moved out of the loop at one stage, + resulting in an endless loop. */ + while (!is_end_of_statement ()) + p++; +} + +int +main (void) +{ + p = "abc\n"; + foo (); + return 0; +} diff --git a/test/tests/loop-13.c b/test/tests/loop-13.c new file mode 100644 index 0000000..d56c829 --- /dev/null +++ b/test/tests/loop-13.c @@ -0,0 +1,36 @@ +/* PR opt/7130 */ +#define TYPE long + +void +scale (TYPE *alpha, TYPE *x, int n) +{ + int i, ix; + + if (*alpha != 1) + for (i = 0, ix = 0; i < n; i++, ix += 2) + { + TYPE tmpr, tmpi; + tmpr = *alpha * x[ix]; + tmpi = *alpha * x[ix + 1]; + x[ix] = tmpr; + x[ix + 1] = tmpi; + } +} + +int +main (void) +{ + int i; + TYPE x[10]; + TYPE alpha = 2; + + for (i = 0; i < 10; i++) + x[i] = i; + + scale (&alpha, x, 5); + + if (x[9] != 18) + abort (); + + return 0; +} diff --git a/test/tests/loop-14.c b/test/tests/loop-14.c new file mode 100644 index 0000000..8c99292 --- /dev/null +++ b/test/tests/loop-14.c @@ -0,0 +1,20 @@ +int a3[3]; + +void f(int *a) +{ + int i; + + for (i=3; --i;) + a[i] = 42 / i; +} + +int +main () +{ + f(a3); + + if (a3[1] != 42 || a3[2] != 21) + abort (); + + exit (0); +} diff --git a/test/tests/loop-15.c b/test/tests/loop-15.c new file mode 100644 index 0000000..8cb5125 --- /dev/null +++ b/test/tests/loop-15.c @@ -0,0 +1,40 @@ +/* Bombed with a segfault on powerpc-linux. doloop.c generated wrong + loop count. */ +void +foo (unsigned long *start, unsigned long *end) +{ + unsigned long *temp = end - 1; + + while (end > start) + *end-- = *temp--; +} + +int +main (void) +{ + unsigned long a[5]; + int start, end, k; + + for (start = 0; start < 5; start++) + for (end = 0; end < 5; end++) + { + for (k = 0; k < 5; k++) + a[k] = k; + + foo (a + start, a + end); + + for (k = 0; k <= start; k++) + if (a[k] != k) + abort (); + + for (k = start + 1; k <= end; k++) + if (a[k] != k - 1) + abort (); + + for (k = end + 1; k < 5; k++) + if (a[k] != k) + abort (); + } + + return 0; +} diff --git a/test/tests/loop-2.c b/test/tests/loop-2.c new file mode 100644 index 0000000..3227734 --- /dev/null +++ b/test/tests/loop-2.c @@ -0,0 +1,17 @@ +int a[2]; + +f (b) +{ + unsigned int i; + for (i = 0; i < b; i++) + a[i] = i - 2; +} + +main () +{ + a[0] = a[1] = 0; + f (2); + if (a[0] != -2 || a[1] != -1) + abort (); + exit (0); +} diff --git a/test/tests/loop-2b.c b/test/tests/loop-2b.c new file mode 100644 index 0000000..7f67bcd --- /dev/null +++ b/test/tests/loop-2b.c @@ -0,0 +1,22 @@ +#include + +int a[2]; + +f (int i) +{ + for (; i < INT_MAX; i++) + { + a[i] = -2; + if (&a[i] == &a[1]) + break; + } +} + +main () +{ + a[0] = a[1] = 0; + f (0); + if (a[0] != -2 || a[1] != -2) + abort (); + exit (0); +} diff --git a/test/tests/loop-2c.c b/test/tests/loop-2c.c new file mode 100644 index 0000000..9facf3b --- /dev/null +++ b/test/tests/loop-2c.c @@ -0,0 +1,23 @@ +int a[2]; + +__inline__ f (b, o) +{ + unsigned int i; + int *p; + for (p = &a[b], i = b; --i < ~0; ) + *--p = i * 3 + o; +} + +g(int b) +{ + f (b, (int)a); +} + +main () +{ + a[0] = a[1] = 0; + g (2); + if (a[0] != (int)a || a[1] != (int)a + 3) + abort (); + exit (0); +} diff --git a/test/tests/loop-2d.c b/test/tests/loop-2d.c new file mode 100644 index 0000000..19272bf --- /dev/null +++ b/test/tests/loop-2d.c @@ -0,0 +1,18 @@ +int a[2]; + +f (b) +{ + unsigned int i; + int *p; + for (p = &a[b], i = b; --i < ~0; ) + *--p = i * 3 + (int)a; +} + +main () +{ + a[0] = a[1] = 0; + f (2); + if (a[0] != (int)a || a[1] != (int)a + 3) + abort (); + exit (0); +} diff --git a/test/tests/loop-2e.c b/test/tests/loop-2e.c new file mode 100644 index 0000000..71c7a4d --- /dev/null +++ b/test/tests/loop-2e.c @@ -0,0 +1,39 @@ +void f (int *p, int **q) +{ + int i; + for (i = 0; i < 40; i++) + { + *q++ = &p[i]; + } +} + +int main () +{ + void *p; + int *q[40]; + __SIZE_TYPE__ start; + + /* Find the signed middle of the address space. */ + if (sizeof(start) == sizeof(int)) + start = (__SIZE_TYPE__) __INT_MAX__; + else if (sizeof(start) == sizeof(long)) + start = (__SIZE_TYPE__) __LONG_MAX__; + else if (sizeof(start) == sizeof(long long)) + start = (__SIZE_TYPE__) __LONG_LONG_MAX__; + else + return 0; + + /* Arbitrarily align the pointer. */ + start &= -32; + + /* Pretend that's good enough to start address arithmetic. */ + p = (void *)start; + + /* Verify that GIV replacement computes the correct results. */ + q[39] = 0; + f (p, q); + if (q[39] != (int *)p + 39) + abort (); + + return 0; +} diff --git a/test/tests/loop-2f.c b/test/tests/loop-2f.c new file mode 100644 index 0000000..9f544b9 --- /dev/null +++ b/test/tests/loop-2f.c @@ -0,0 +1,63 @@ +#include + +#ifdef __unix__ /* ??? Is that good enough? */ +#include +#include +#include +#include +#ifndef MAP_ANON +#ifdef MAP_ANONYMOUS +#define MAP_ANON MAP_ANONYMOUS +#else +#define MAP_ANON MAP_FILE +#endif +#endif +#ifndef MAP_FILE +#define MAP_FILE 0 +#endif +#ifndef MAP_FIXED +#define MAP_FIXED 0 +#endif +#endif + +#define MAP_START (void *)0x7fff8000 +#define MAP_LEN 0x10000 + +#define OFFSET (MAP_LEN/2 - 2 * sizeof (char)); + +f (int s, char *p) +{ + int i; + for (i = s; i >= 0 && &p[i] < &p[40]; i++) + { + p[i] = -2; + } +} + +main () +{ +#ifdef MAP_ANON + char *p; + int dev_zero; + + dev_zero = open ("/dev/zero", O_RDONLY); + /* -1 is OK when we have MAP_ANON; else mmap will flag an error. */ + if (INT_MAX != 0x7fffffffL || sizeof (char *) != sizeof (int)) + exit (0); + p = mmap (MAP_START, MAP_LEN, PROT_READ|PROT_WRITE, + MAP_ANON|MAP_FIXED|MAP_PRIVATE, dev_zero, 0); + if (p != (char *)-1) + { + p += OFFSET; + p[39] = 0; + f (0, p); + if (p[39] != (char)-2) + abort (); + p[39] = 0; + f (-1, p); + if (p[39] != 0) + abort (); + } +#endif + exit (0); +} diff --git a/test/tests/loop-2g.c b/test/tests/loop-2g.c new file mode 100644 index 0000000..8792dbf --- /dev/null +++ b/test/tests/loop-2g.c @@ -0,0 +1,63 @@ +#include + +#ifdef __unix__ /* ??? Is that good enough? */ +#include +#include +#include +#include +#ifndef MAP_ANON +#ifdef MAP_ANONYMOUS +#define MAP_ANON MAP_ANONYMOUS +#else +#define MAP_ANON MAP_FILE +#endif +#endif +#ifndef MAP_FILE +#define MAP_FILE 0 +#endif +#ifndef MAP_FIXED +#define MAP_FIXED 0 +#endif +#endif + +#define MAP_START (void *)0x7fff8000 +#define MAP_LEN 0x10000 + +#define OFFSET (MAP_LEN/2 - 2 * sizeof (char)); + +f (int s, char *p) +{ + int i; + for (i = s; &p[i] < &p[40] && i >= 0; i++) + { + p[i] = -2; + } +} + +main () +{ +#ifdef MAP_ANON + char *p; + int dev_zero; + + dev_zero = open ("/dev/zero", O_RDONLY); + /* -1 is OK when we have MAP_ANON; else mmap will flag an error. */ + if (INT_MAX != 0x7fffffffL || sizeof (char *) != sizeof (int)) + exit (0); + p = mmap (MAP_START, MAP_LEN, PROT_READ|PROT_WRITE, + MAP_ANON|MAP_FIXED|MAP_PRIVATE, dev_zero, 0); + if (p != (char *)-1) + { + p += OFFSET; + p[39] = 0; + f (0, p); + if (p[39] != (char)-2) + abort (); + p[39] = 0; + f (-1, p); + if (p[39] != 0) + abort (); + } +#endif + exit (0); +} diff --git a/test/tests/loop-3.c b/test/tests/loop-3.c new file mode 100644 index 0000000..e314a01 --- /dev/null +++ b/test/tests/loop-3.c @@ -0,0 +1,27 @@ +#include + +int n = 0; + +g (i) +{ + n++; +} + +f (m) +{ + int i; + i = m; + do + { + g (i * INT_MAX / 2); + } + while (--i > 0); +} + +main () +{ + f (4); + if (n != 4) + abort (); + exit (0); +} diff --git a/test/tests/loop-3b.c b/test/tests/loop-3b.c new file mode 100644 index 0000000..3de322c --- /dev/null +++ b/test/tests/loop-3b.c @@ -0,0 +1,28 @@ +#include + +int n = 0; + +g (i) +{ + n++; +} + +f (m) +{ + int i; + i = m; + do + { + g (i * 4); + i -= INT_MAX / 8; + } + while (i > 0); +} + +main () +{ + f (INT_MAX/8*4); + if (n != 4) + abort (); + exit (0); +} diff --git a/test/tests/loop-3c.c b/test/tests/loop-3c.c new file mode 100644 index 0000000..bc74c2e --- /dev/null +++ b/test/tests/loop-3c.c @@ -0,0 +1,31 @@ +#include + +void * a[255]; + +f (m) +{ + int i; + int sh = 0x100; + i = m; + do + { + a[sh >>= 1] = ((unsigned)i << 3) + (char*)a; + i += 4; + } + while (i < INT_MAX/2 + 1 + 4 * 4); +} + +main () +{ + a[0x10] = 0; + a[0x08] = 0; + f (INT_MAX/2 + INT_MAX/4 + 2); + if (a[0x10] || a[0x08]) + abort (); + a[0x10] = 0; + a[0x08] = 0; + f (INT_MAX/2 + 1); + if (! a[0x10] || a[0x08]) + abort (); + exit (0); +} diff --git a/test/tests/loop-4.c b/test/tests/loop-4.c new file mode 100644 index 0000000..f8784cf --- /dev/null +++ b/test/tests/loop-4.c @@ -0,0 +1,16 @@ +int +f() +{ + int j = 1; + long i; + for (i = -0x7000L; i < 0x6000L; i += 0x1000L) j <<= 1; + return j; +} + +int +main () +{ + if (f () != 8192) + abort (); + exit (0); +} diff --git a/test/tests/loop-4b.c b/test/tests/loop-4b.c new file mode 100644 index 0000000..6ebcdc1 --- /dev/null +++ b/test/tests/loop-4b.c @@ -0,0 +1,21 @@ +int +f() +{ + int j = 1; + long i; + i = 0x6000L; + do + { + j <<= 1; + i += 0x1000L; + } while (i < -0x6000L); + return j; +} + +int +main () +{ + if (f () != 2) + abort (); + exit (0); +} diff --git a/test/tests/loop-5.c b/test/tests/loop-5.c new file mode 100644 index 0000000..44ece27 --- /dev/null +++ b/test/tests/loop-5.c @@ -0,0 +1,36 @@ +static int ap(int i); +static void testit(void){ + int ir[4] = {0,1,2,3}; + int ix,n,m; + n=1; m=3; + for (ix=1;ix<=4;ix++) { + if (n == 1) m = 4; + else m = n-1; + ap(ir[n-1]); + n = m; + } +} + +static int t = 0; +static int a[4]; + +static int ap(int i){ + if (t > 3) + abort(); + a[t++] = i; + return 1; +} + +int main(void) +{ + testit(); + if (a[0] != 0) + abort(); + if (a[1] != 3) + abort(); + if (a[2] != 2) + abort(); + if (a[3] != 1) + abort(); + exit(0); +} diff --git a/test/tests/loop-6.c b/test/tests/loop-6.c new file mode 100644 index 0000000..42eb9e7 --- /dev/null +++ b/test/tests/loop-6.c @@ -0,0 +1,15 @@ +main() +{ + char c; + char d; + int nbits; + c = -1; + for (nbits = 1 ; nbits < 100; nbits++) { + d = (1 << nbits) - 1; + if (d == c) + break; + } + if (nbits == 100) + abort(); + exit(0); +} diff --git a/test/tests/loop-7.c b/test/tests/loop-7.c new file mode 100644 index 0000000..48a2599 --- /dev/null +++ b/test/tests/loop-7.c @@ -0,0 +1,19 @@ +void foo (unsigned int n) +{ + int i, j = -1; + + for (i = 0; i < 10 && j < 0; i++) + { + if ((1UL << i) == n) + j = i; + } + + if (j < 0) + abort (); +} + +main() +{ + foo (64); + exit (0); +} diff --git a/test/tests/loop-8.c b/test/tests/loop-8.c new file mode 100644 index 0000000..e8d8cb5 --- /dev/null +++ b/test/tests/loop-8.c @@ -0,0 +1,23 @@ +double a[3] = { 0.0, 1.0, 2.0 }; + +void bar (int x, double *y) +{ + if (x || *y != 1.0) + abort (); +} + +int main () +{ + double c; + int d; + for (d = 0; d < 3; d++) + { + c = a[d]; + if (c > 0.0) goto e; + } + bar(1, &c); + exit (1); +e: + bar(0, &c); + exit (0); +} diff --git a/test/tests/loop-9.c b/test/tests/loop-9.c new file mode 100644 index 0000000..5230575 --- /dev/null +++ b/test/tests/loop-9.c @@ -0,0 +1,21 @@ +/* Source: Neil Booth, from PR # 115. */ + +int false() +{ + return 0; +} + +extern void abort (void); + +int main (int argc,char *argv[]) +{ + int count = 0; + + while (false() || count < -123) + ++count; + + if (count) + abort (); + + return 0; +} diff --git a/test/tests/loop-ivopts-1.c b/test/tests/loop-ivopts-1.c new file mode 100644 index 0000000..13396fb --- /dev/null +++ b/test/tests/loop-ivopts-1.c @@ -0,0 +1,30 @@ +/* From PR 18977. */ +void foo(float * x); + +int main() +{ + float x[4]; + foo (x); + return 0; +} + +void foo (float *x) +{ + int i,j,k; + float temp; + static float t16[16]={1.,2.,3.,4.,5.,6.,7.,8.,9., + 10.,11.,12.,13.,14.,15.,16.}; + static float tmp[4]={0.,0.,0.,0.}; + + for (i=0; i<4; i++) { + k = 3 - i; + temp = t16[5*k]; + for(j=k+1; j<4; j++) { + tmp[k] = t16[k+ j*4] * temp; + } + } + x[0] = tmp[0]; + x[1] = tmp[1]; + x[2] = tmp[2]; + x[3] = tmp[3]; +} diff --git a/test/tests/loop-ivopts-2.c b/test/tests/loop-ivopts-2.c new file mode 100644 index 0000000..737640b --- /dev/null +++ b/test/tests/loop-ivopts-2.c @@ -0,0 +1,50 @@ +/* PR rtl-optimization/20290 */ + +/* We used to mis-optimize the second loop in main on at least ppc and + arm, because tree loop would change the loop to something like: + + ivtmp.65 = &l[i]; + ivtmp.16 = 113; + goto (); + +:; + *(ivtmp.65 + 4294967292B) = 9; + i = i + 1; + +:; + ivtmp.16 = ivtmp.16 - 1; + ivtmp.65 = ivtmp.65 + 4B; + if (ivtmp.16 != 0) goto ; + + We used to consider the increment of i as executed in every + iteration, so we'd miscompute the final value. */ + +extern void abort (void); + +void +check (unsigned int *l) +{ + int i; + for (i = 0; i < 288; i++) + if (l[i] != 7 + (i < 256 || i >= 280) + (i >= 144 && i < 256)) + abort (); +} + +int +main (void) +{ + int i; + unsigned int l[288]; + + for (i = 0; i < 144; i++) + l[i] = 8; + for (; i < 256; i++) + l[i] = 9; + for (; i < 280; i++) + l[i] = 7; + for (; i < 288; i++) + l[i] = 8; + check (l); + return 0; +} + diff --git a/test/tests/lshrdi-1.c b/test/tests/lshrdi-1.c new file mode 100644 index 0000000..b09c0cb --- /dev/null +++ b/test/tests/lshrdi-1.c @@ -0,0 +1,221 @@ +#include + +extern void abort(void); +extern void exit(int); + +#if 0 //__LONG_LONG_MAX__ == 9223372036854775807LL +#define BITS 64 + +static unsigned long long const zext[64] = { + 0x87654321fedcba90ULL, + 0x43b2a190ff6e5d48ULL, + 0x21d950c87fb72ea4ULL, + 0x10eca8643fdb9752ULL, + 0x87654321fedcba9ULL, + 0x43b2a190ff6e5d4ULL, + 0x21d950c87fb72eaULL, + 0x10eca8643fdb975ULL, + 0x87654321fedcbaULL, + 0x43b2a190ff6e5dULL, + 0x21d950c87fb72eULL, + 0x10eca8643fdb97ULL, + 0x87654321fedcbULL, + 0x43b2a190ff6e5ULL, + 0x21d950c87fb72ULL, + 0x10eca8643fdb9ULL, + 0x87654321fedcULL, + 0x43b2a190ff6eULL, + 0x21d950c87fb7ULL, + 0x10eca8643fdbULL, + 0x87654321fedULL, + 0x43b2a190ff6ULL, + 0x21d950c87fbULL, + 0x10eca8643fdULL, + 0x87654321feULL, + 0x43b2a190ffULL, + 0x21d950c87fULL, + 0x10eca8643fULL, + 0x87654321fULL, + 0x43b2a190fULL, + 0x21d950c87ULL, + 0x10eca8643ULL, + 0x87654321ULL, + 0x43b2a190ULL, + 0x21d950c8ULL, + 0x10eca864ULL, + 0x8765432ULL, + 0x43b2a19ULL, + 0x21d950cULL, + 0x10eca86ULL, + 0x876543ULL, + 0x43b2a1ULL, + 0x21d950ULL, + 0x10eca8ULL, + 0x87654ULL, + 0x43b2aULL, + 0x21d95ULL, + 0x10ecaULL, + 0x8765ULL, + 0x43b2ULL, + 0x21d9ULL, + 0x10ecULL, + 0x876ULL, + 0x43bULL, + 0x21dULL, + 0x10eULL, + 0x87ULL, + 0x43ULL, + 0x21ULL, + 0x10ULL, + 0x8ULL, + 0x4ULL, + 0x2ULL, + 0x1ULL +}; + +#elif 1 //__LONG_LONG_MAX__ == 2147483647LL +#define BITS 32 + +static unsigned long long const zext[32] = { + 0x87654321ULL, + 0x43b2a190ULL, + 0x21d950c8ULL, + 0x10eca864ULL, + 0x8765432ULL, + 0x43b2a19ULL, + 0x21d950cULL, + 0x10eca86ULL, + 0x876543ULL, + 0x43b2a1ULL, + 0x21d950ULL, + 0x10eca8ULL, + 0x87654ULL, + 0x43b2aULL, + 0x21d95ULL, + 0x10ecaULL, + 0x8765ULL, + 0x43b2ULL, + 0x21d9ULL, + 0x10ecULL, + 0x876ULL, + 0x43bULL, + 0x21dULL, + 0x10eULL, + 0x87ULL, + 0x43ULL, + 0x21ULL, + 0x10ULL, + 0x8ULL, + 0x4ULL, + 0x2ULL, + 0x1ULL, +}; + +#else +#error "Update the test case." +#endif + +static unsigned long long +variable_shift(unsigned long long x, int i) +{ + return x >> i; +} + +static unsigned long long +constant_shift(unsigned long long x, int i) +{ + switch (i) + { + case 0: x = x >> 0; break; + case 1: x = x >> 1; break; + case 2: x = x >> 2; break; + case 3: x = x >> 3; break; + case 4: x = x >> 4; break; + case 5: x = x >> 5; break; + case 6: x = x >> 6; break; + case 7: x = x >> 7; break; + case 8: x = x >> 8; break; + case 9: x = x >> 9; break; + case 10: x = x >> 10; break; + case 11: x = x >> 11; break; + case 12: x = x >> 12; break; + case 13: x = x >> 13; break; + case 14: x = x >> 14; break; + case 15: x = x >> 15; break; + case 16: x = x >> 16; break; + case 17: x = x >> 17; break; + case 18: x = x >> 18; break; + case 19: x = x >> 19; break; + case 20: x = x >> 20; break; + case 21: x = x >> 21; break; + case 22: x = x >> 22; break; + case 23: x = x >> 23; break; + case 24: x = x >> 24; break; + case 25: x = x >> 25; break; + case 26: x = x >> 26; break; + case 27: x = x >> 27; break; + case 28: x = x >> 28; break; + case 29: x = x >> 29; break; + case 30: x = x >> 30; break; + case 31: x = x >> 31; break; +#if BITS > 32 + case 32: x = x >> 32; break; + case 33: x = x >> 33; break; + case 34: x = x >> 34; break; + case 35: x = x >> 35; break; + case 36: x = x >> 36; break; + case 37: x = x >> 37; break; + case 38: x = x >> 38; break; + case 39: x = x >> 39; break; + case 40: x = x >> 40; break; + case 41: x = x >> 41; break; + case 42: x = x >> 42; break; + case 43: x = x >> 43; break; + case 44: x = x >> 44; break; + case 45: x = x >> 45; break; + case 46: x = x >> 46; break; + case 47: x = x >> 47; break; + case 48: x = x >> 48; break; + case 49: x = x >> 49; break; + case 50: x = x >> 50; break; + case 51: x = x >> 51; break; + case 52: x = x >> 52; break; + case 53: x = x >> 53; break; + case 54: x = x >> 54; break; + case 55: x = x >> 55; break; + case 56: x = x >> 56; break; + case 57: x = x >> 57; break; + case 58: x = x >> 58; break; + case 59: x = x >> 59; break; + case 60: x = x >> 60; break; + case 61: x = x >> 61; break; + case 62: x = x >> 62; break; + case 63: x = x >> 63; break; +#endif + + default: + abort (); + } + return x; +} + +int +main() +{ + int i; + + for (i = 0; i < BITS; ++i) + { + unsigned long long y = variable_shift (zext[0], i); + if (y != zext[i]) + abort (); + } + for (i = 0; i < BITS; ++i) + { + unsigned long long y = constant_shift (zext[0], i); + if (y != zext[i]) + abort (); + } + + exit (0); +} diff --git a/test/tests/mayalias-1.c b/test/tests/mayalias-1.c new file mode 100644 index 0000000..3f53bba --- /dev/null +++ b/test/tests/mayalias-1.c @@ -0,0 +1,21 @@ +/* Tests that the may_alias attribute works as expected. + Author: Osku Salerma Apr 2002. */ + +extern void abort(void); +extern void exit(int); + +typedef char __attribute__((__may_alias__)) short_a; + +int +main (void) +{ + int a = 0x1234; + short_a *b = (short_a*) &a; + + b[1] = 0; + + if (a == 0x1234) + abort(); + + exit(0); +} diff --git a/test/tests/mayalias-2.c b/test/tests/mayalias-2.c new file mode 100644 index 0000000..5a1a9d5 --- /dev/null +++ b/test/tests/mayalias-2.c @@ -0,0 +1,17 @@ +struct S { short x; }; +typedef struct S __attribute__((__may_alias__)) test; + +int f() { + int a=10; + test *p=(test *)&a; + p->x = 1; + return a; +} + +int main() { + if (f() == 10) + __builtin_abort(); + return 0; +} + + diff --git a/test/tests/mayalias-3.c b/test/tests/mayalias-3.c new file mode 100644 index 0000000..3d66791 --- /dev/null +++ b/test/tests/mayalias-3.c @@ -0,0 +1,27 @@ +struct S { short x; }; +typedef struct S __attribute__((__may_alias__)) test; + +test *p; + +int g(int *a) +{ + p = (test*)a; +} + +int f() +{ + int a; + g(&a); + a = 10; + test s={1}; + *p=s; + return a; +} + +int main() { + if (f() == 10) + __builtin_abort(); + return 0; +} + + diff --git a/test/tests/medce-1.c b/test/tests/medce-1.c new file mode 100644 index 0000000..328ed09 --- /dev/null +++ b/test/tests/medce-1.c @@ -0,0 +1,33 @@ + +extern void abort (void); +extern void link_error (void); + +static int ok = 0; + +void bar (void) +{ + ok = 1; +} + +void foo(int x) +{ + switch (x) + { + case 0: + if (0) + { + //link_error(); + case 1: + bar(); + } + } +} + +int main() +{ + foo (1); + if (!ok) + abort (); + return 0; +} + diff --git a/test/tests/memcpy-1.c b/test/tests/memcpy-1.c new file mode 100644 index 0000000..684854b --- /dev/null +++ b/test/tests/memcpy-1.c @@ -0,0 +1,63 @@ +#include + +#if defined (STACK_SIZE) +#define MEMCPY_SIZE (STACK_SIZE / 3) +#else +#define MEMCPY_SIZE (1 << 17) +#endif + + +void *copy (void *o, const void *i, unsigned l) +{ + return memcpy (o, i, l); +} + +main () +{ + unsigned i; + unsigned char src[MEMCPY_SIZE]; + unsigned char dst[MEMCPY_SIZE]; + + for (i = 0; i < MEMCPY_SIZE; i++) + src[i] = (unsigned char) i, dst[i] = 0; + + (void) memcpy (dst, src, MEMCPY_SIZE / 128); + + for (i = 0; i < MEMCPY_SIZE / 128; i++) + if (dst[i] != (unsigned char) i) + abort (); + + (void) memset (dst, 1, MEMCPY_SIZE / 128); + + for (i = 0; i < MEMCPY_SIZE / 128; i++) + if (dst[i] != 1) + abort (); + + (void) memcpy (dst, src, MEMCPY_SIZE); + + for (i = 0; i < MEMCPY_SIZE; i++) + if (dst[i] != (unsigned char) i) + abort (); + + (void) memset (dst, 0, MEMCPY_SIZE); + + for (i = 0; i < MEMCPY_SIZE; i++) + if (dst[i] != 0) + abort (); + + (void) copy (dst, src, MEMCPY_SIZE / 128); + + for (i = 0; i < MEMCPY_SIZE / 128; i++) + if (dst[i] != (unsigned char) i) + abort (); + + (void) memset (dst, 0, MEMCPY_SIZE); + + (void) copy (dst, src, MEMCPY_SIZE); + + for (i = 0; i < MEMCPY_SIZE; i++) + if (dst[i] != (unsigned char) i) + abort (); + + exit (0); +} diff --git a/test/tests/memcpy-2.c b/test/tests/memcpy-2.c new file mode 100644 index 0000000..f328b64 --- /dev/null +++ b/test/tests/memcpy-2.c @@ -0,0 +1,75 @@ +/* Copyright (C) 2002 Free Software Foundation. + + Test memcpy with various combinations of pointer alignments and lengths to + make sure any optimizations in the library are correct. + + Written by Michael Meissner, March 9, 2002. */ + +#include + +#ifndef MAX_OFFSET +#define MAX_OFFSET (sizeof (long long)) +#endif + +#ifndef MAX_COPY +#define MAX_COPY (10 * sizeof (long long)) +#endif + +#ifndef MAX_EXTRA +#define MAX_EXTRA (sizeof (long long)) +#endif + +#define MAX_LENGTH (MAX_OFFSET + MAX_COPY + MAX_EXTRA) + + +/* Use a sequence length that is not divisible by two, to make it more + likely to detect when words are mixed up. */ +#define SEQUENCE_LENGTH 31 + +static union { + char buf[MAX_LENGTH]; + long long align_int; + long double align_fp; +} u1, u2; + +main () +{ + int off1, off2, len, i; + char *p, *q, c; + + for (off1 = 0; off1 < MAX_OFFSET; off1++) + for (off2 = 0; off2 < MAX_OFFSET; off2++) + for (len = 1; len < MAX_COPY; len++) + { + for (i = 0, c = 'A'; i < MAX_LENGTH; i++, c++) + { + u1.buf[i] = 'a'; + if (c >= 'A' + SEQUENCE_LENGTH) + c = 'A'; + u2.buf[i] = c; + } + + p = memcpy (u1.buf + off1, u2.buf + off2, len); + if (p != u1.buf + off1) + abort (); + + q = u1.buf; + for (i = 0; i < off1; i++, q++) + if (*q != 'a') + abort (); + + for (i = 0, c = 'A' + off2; i < len; i++, q++, c++) + { + if (c >= 'A' + SEQUENCE_LENGTH) + c = 'A'; + if (*q != c) + abort (); + } + + for (i = 0; i < MAX_EXTRA; i++, q++) + if (*q != 'a') + abort (); + } + + exit (0); +} diff --git a/test/tests/memcpy-bi.c b/test/tests/memcpy-bi.c new file mode 100644 index 0000000..c64ed61 --- /dev/null +++ b/test/tests/memcpy-bi.c @@ -0,0 +1,51 @@ +/* Test builtin-memcpy (which may emit different code for different N). */ + +#define TESTSIZE 80 + +char src[TESTSIZE] __attribute__ ((aligned)); +char dst[TESTSIZE] __attribute__ ((aligned)); + +void +check (char *test, char *match, int n) +{ + if (memcmp (test, match, n)) + abort (); +} + +#define TN(n) \ +{ memset (dst, 0, n); memcpy (dst, src, n); check (dst, src, n); } +#define T(n) \ +TN (n) \ +TN ((n) + 1) \ +TN ((n) + 2) \ +TN ((n) + 3) + +main () +{ + int i,j; + + for (i = 0; i < sizeof (src); ++i) + src[i] = 'a' + i % 26; + + T (0); + T (4); + T (8); + T (12); + T (16); + T (20); + T (24); + T (28); + T (32); + T (36); + T (40); + T (44); + T (48); + T (52); + T (56); + T (60); + T (64); + T (68); + T (72); + T (76); + return 0; +} diff --git a/test/tests/memset-1.c b/test/tests/memset-1.c new file mode 100644 index 0000000..b0b70f3 --- /dev/null +++ b/test/tests/memset-1.c @@ -0,0 +1,96 @@ +/* Copyright (C) 2002 Free Software Foundation. + + Test memset with various combinations of pointer alignments and lengths to + make sure any optimizations in the library are correct. + + Written by Michael Meissner, March 9, 2002. */ + +#include + +#ifndef MAX_OFFSET +#define MAX_OFFSET (sizeof (long long)) +#endif + +#ifndef MAX_COPY +#define MAX_COPY (10 * sizeof (long long)) +#endif + +#ifndef MAX_EXTRA +#define MAX_EXTRA (sizeof (long long)) +#endif + +#define MAX_LENGTH (MAX_OFFSET + MAX_COPY + MAX_EXTRA) + +static union { + char buf[MAX_LENGTH]; + long long align_int; + long double align_fp; +} u; + +char A = 'A'; + +main () +{ + int off, len, i; + char *p, *q; + + for (off = 0; off < MAX_OFFSET; off++) + for (len = 1; len < MAX_COPY; len++) + { + for (i = 0; i < MAX_LENGTH; i++) + u.buf[i] = 'a'; + + p = memset (u.buf + off, '\0', len); + if (p != u.buf + off) + abort (); + + q = u.buf; + for (i = 0; i < off; i++, q++) + if (*q != 'a') + abort (); + + for (i = 0; i < len; i++, q++) + if (*q != '\0') + abort (); + + for (i = 0; i < MAX_EXTRA; i++, q++) + if (*q != 'a') + abort (); + + p = memset (u.buf + off, A, len); + if (p != u.buf + off) + abort (); + + q = u.buf; + for (i = 0; i < off; i++, q++) + if (*q != 'a') + abort (); + + for (i = 0; i < len; i++, q++) + if (*q != 'A') + abort (); + + for (i = 0; i < MAX_EXTRA; i++, q++) + if (*q != 'a') + abort (); + + p = memset (u.buf + off, 'B', len); + if (p != u.buf + off) + abort (); + + q = u.buf; + for (i = 0; i < off; i++, q++) + if (*q != 'a') + abort (); + + for (i = 0; i < len; i++, q++) + if (*q != 'B') + abort (); + + for (i = 0; i < MAX_EXTRA; i++, q++) + if (*q != 'a') + abort (); + } + + exit (0); +} diff --git a/test/tests/memset-2.c b/test/tests/memset-2.c new file mode 100644 index 0000000..376662e --- /dev/null +++ b/test/tests/memset-2.c @@ -0,0 +1,336 @@ +/* Copyright (C) 2002 Free Software Foundation. + + Test memset with various combinations of pointer alignments and constant + lengths to make sure any optimizations in the compiler are correct. + + Written by Roger Sayle, April 22, 2002. */ + +#include + +#ifndef MAX_OFFSET +#define MAX_OFFSET (sizeof (long long)) +#endif + +#ifndef MAX_COPY +#define MAX_COPY 15 +#endif + +#ifndef MAX_EXTRA +#define MAX_EXTRA (sizeof (long long)) +#endif + +#define MAX_LENGTH (MAX_OFFSET + MAX_COPY + MAX_EXTRA) + +static union { + char buf[MAX_LENGTH]; + long long align_int; + long double align_fp; +} u; + +char A = 'A'; + +void reset () +{ + int i; + + for (i = 0; i < MAX_LENGTH; i++) + u.buf[i] = 'a'; +} + +void check (int off, int len, int ch) +{ + char *q; + int i; + + q = u.buf; + for (i = 0; i < off; i++, q++) + if (*q != 'a') + abort (); + + for (i = 0; i < len; i++, q++) + if (*q != ch) + abort (); + + for (i = 0; i < MAX_EXTRA; i++, q++) + if (*q != 'a') + abort (); +} + +int main () +{ + int off; + char *p; + + /* len == 1 */ + for (off = 0; off < MAX_OFFSET; off++) + { + reset (); + + p = memset (u.buf + off, '\0', 1); + if (p != u.buf + off) abort (); + check (off, 1, '\0'); + + p = memset (u.buf + off, A, 1); + if (p != u.buf + off) abort (); + check (off, 1, 'A'); + + p = memset (u.buf + off, 'B', 1); + if (p != u.buf + off) abort (); + check (off, 1, 'B'); + } + + /* len == 2 */ + for (off = 0; off < MAX_OFFSET; off++) + { + reset (); + + p = memset (u.buf + off, '\0', 2); + if (p != u.buf + off) abort (); + check (off, 2, '\0'); + + p = memset (u.buf + off, A, 2); + if (p != u.buf + off) abort (); + check (off, 2, 'A'); + + p = memset (u.buf + off, 'B', 2); + if (p != u.buf + off) abort (); + check (off, 2, 'B'); + } + + /* len == 3 */ + for (off = 0; off < MAX_OFFSET; off++) + { + reset (); + + p = memset (u.buf + off, '\0', 3); + if (p != u.buf + off) abort (); + check (off, 3, '\0'); + + p = memset (u.buf + off, A, 3); + if (p != u.buf + off) abort (); + check (off, 3, 'A'); + + p = memset (u.buf + off, 'B', 3); + if (p != u.buf + off) abort (); + check (off, 3, 'B'); + } + + /* len == 4 */ + for (off = 0; off < MAX_OFFSET; off++) + { + reset (); + + p = memset (u.buf + off, '\0', 4); + if (p != u.buf + off) abort (); + check (off, 4, '\0'); + + p = memset (u.buf + off, A, 4); + if (p != u.buf + off) abort (); + check (off, 4, 'A'); + + p = memset (u.buf + off, 'B', 4); + if (p != u.buf + off) abort (); + check (off, 4, 'B'); + } + + /* len == 5 */ + for (off = 0; off < MAX_OFFSET; off++) + { + reset (); + + p = memset (u.buf + off, '\0', 5); + if (p != u.buf + off) abort (); + check (off, 5, '\0'); + + p = memset (u.buf + off, A, 5); + if (p != u.buf + off) abort (); + check (off, 5, 'A'); + + p = memset (u.buf + off, 'B', 5); + if (p != u.buf + off) abort (); + check (off, 5, 'B'); + } + + /* len == 6 */ + for (off = 0; off < MAX_OFFSET; off++) + { + reset (); + + p = memset (u.buf + off, '\0', 6); + if (p != u.buf + off) abort (); + check (off, 6, '\0'); + + p = memset (u.buf + off, A, 6); + if (p != u.buf + off) abort (); + check (off, 6, 'A'); + + p = memset (u.buf + off, 'B', 6); + if (p != u.buf + off) abort (); + check (off, 6, 'B'); + } + + /* len == 7 */ + for (off = 0; off < MAX_OFFSET; off++) + { + reset (); + + p = memset (u.buf + off, '\0', 7); + if (p != u.buf + off) abort (); + check (off, 7, '\0'); + + p = memset (u.buf + off, A, 7); + if (p != u.buf + off) abort (); + check (off, 7, 'A'); + + p = memset (u.buf + off, 'B', 7); + if (p != u.buf + off) abort (); + check (off, 7, 'B'); + } + + /* len == 8 */ + for (off = 0; off < MAX_OFFSET; off++) + { + reset (); + + p = memset (u.buf + off, '\0', 8); + if (p != u.buf + off) abort (); + check (off, 8, '\0'); + + p = memset (u.buf + off, A, 8); + if (p != u.buf + off) abort (); + check (off, 8, 'A'); + + p = memset (u.buf + off, 'B', 8); + if (p != u.buf + off) abort (); + check (off, 8, 'B'); + } + + /* len == 9 */ + for (off = 0; off < MAX_OFFSET; off++) + { + reset (); + + p = memset (u.buf + off, '\0', 9); + if (p != u.buf + off) abort (); + check (off, 9, '\0'); + + p = memset (u.buf + off, A, 9); + if (p != u.buf + off) abort (); + check (off, 9, 'A'); + + p = memset (u.buf + off, 'B', 9); + if (p != u.buf + off) abort (); + check (off, 9, 'B'); + } + + /* len == 10 */ + for (off = 0; off < MAX_OFFSET; off++) + { + reset (); + + p = memset (u.buf + off, '\0', 10); + if (p != u.buf + off) abort (); + check (off, 10, '\0'); + + p = memset (u.buf + off, A, 10); + if (p != u.buf + off) abort (); + check (off, 10, 'A'); + + p = memset (u.buf + off, 'B', 10); + if (p != u.buf + off) abort (); + check (off, 10, 'B'); + } + + /* len == 11 */ + for (off = 0; off < MAX_OFFSET; off++) + { + reset (); + + p = memset (u.buf + off, '\0', 11); + if (p != u.buf + off) abort (); + check (off, 11, '\0'); + + p = memset (u.buf + off, A, 11); + if (p != u.buf + off) abort (); + check (off, 11, 'A'); + + p = memset (u.buf + off, 'B', 11); + if (p != u.buf + off) abort (); + check (off, 11, 'B'); + } + + /* len == 12 */ + for (off = 0; off < MAX_OFFSET; off++) + { + reset (); + + p = memset (u.buf + off, '\0', 12); + if (p != u.buf + off) abort (); + check (off, 12, '\0'); + + p = memset (u.buf + off, A, 12); + if (p != u.buf + off) abort (); + check (off, 12, 'A'); + + p = memset (u.buf + off, 'B', 12); + if (p != u.buf + off) abort (); + check (off, 12, 'B'); + } + + /* len == 13 */ + for (off = 0; off < MAX_OFFSET; off++) + { + reset (); + + p = memset (u.buf + off, '\0', 13); + if (p != u.buf + off) abort (); + check (off, 13, '\0'); + + p = memset (u.buf + off, A, 13); + if (p != u.buf + off) abort (); + check (off, 13, 'A'); + + p = memset (u.buf + off, 'B', 13); + if (p != u.buf + off) abort (); + check (off, 13, 'B'); + } + + /* len == 14 */ + for (off = 0; off < MAX_OFFSET; off++) + { + reset (); + + p = memset (u.buf + off, '\0', 14); + if (p != u.buf + off) abort (); + check (off, 14, '\0'); + + p = memset (u.buf + off, A, 14); + if (p != u.buf + off) abort (); + check (off, 14, 'A'); + + p = memset (u.buf + off, 'B', 14); + if (p != u.buf + off) abort (); + check (off, 14, 'B'); + } + + /* len == 15 */ + for (off = 0; off < MAX_OFFSET; off++) + { + reset (); + + p = memset (u.buf + off, '\0', 15); + if (p != u.buf + off) abort (); + check (off, 15, '\0'); + + p = memset (u.buf + off, A, 15); + if (p != u.buf + off) abort (); + check (off, 15, 'A'); + + p = memset (u.buf + off, 'B', 15); + if (p != u.buf + off) abort (); + check (off, 15, 'B'); + } + + exit (0); +} + diff --git a/test/tests/memset-3.c b/test/tests/memset-3.c new file mode 100644 index 0000000..ed7fbc0 --- /dev/null +++ b/test/tests/memset-3.c @@ -0,0 +1,210 @@ +/* Copyright (C) 2002 Free Software Foundation. + + Test memset with various combinations of constant pointer alignments and + lengths to make sure any optimizations in the compiler are correct. + + Written by Roger Sayle, July 22, 2002. */ + +#include + +#ifndef MAX_OFFSET +#define MAX_OFFSET (8) +#endif + +#ifndef MAX_COPY +#define MAX_COPY 15 +#endif + +#ifndef MAX_EXTRA +#define MAX_EXTRA (8) +#endif + +#define MAX_LENGTH (MAX_OFFSET + MAX_COPY + MAX_EXTRA) + +static union { + char buf[MAX_LENGTH]; + long long align_int; + long double align_fp; +} u; + +char A = 'A'; + +void reset () +{ + int i; + + for (i = 0; i < MAX_LENGTH; i++) + u.buf[i] = 'a'; +} + +void check (int off, int len, int ch) +{ + char *q; + int i; + + q = u.buf; + for (i = 0; i < off; i++, q++) + if (*q != 'a') + abort (); + + for (i = 0; i < len; i++, q++) + if (*q != ch) + abort (); + + for (i = 0; i < MAX_EXTRA; i++, q++) + if (*q != 'a') + abort (); +} + +int main () +{ + int len; + char *p; + + /* off == 0 */ + for (len = 0; len < MAX_COPY; len++) + { + reset (); + + p = memset (u.buf, '\0', len); + if (p != u.buf) abort (); + check (0, len, '\0'); + + p = memset (u.buf, A, len); + if (p != u.buf) abort (); + check (0, len, 'A'); + + p = memset (u.buf, 'B', len); + if (p != u.buf) abort (); + check (0, len, 'B'); + } + + /* off == 1 */ + for (len = 0; len < MAX_COPY; len++) + { + reset (); + + p = memset (u.buf+1, '\0', len); + if (p != u.buf+1) abort (); + check (1, len, '\0'); + + p = memset (u.buf+1, A, len); + if (p != u.buf+1) abort (); + check (1, len, 'A'); + + p = memset (u.buf+1, 'B', len); + if (p != u.buf+1) abort (); + check (1, len, 'B'); + } + + /* off == 2 */ + for (len = 0; len < MAX_COPY; len++) + { + reset (); + + p = memset (u.buf+2, '\0', len); + if (p != u.buf+2) abort (); + check (2, len, '\0'); + + p = memset (u.buf+2, A, len); + if (p != u.buf+2) abort (); + check (2, len, 'A'); + + p = memset (u.buf+2, 'B', len); + if (p != u.buf+2) abort (); + check (2, len, 'B'); + } + + /* off == 3 */ + for (len = 0; len < MAX_COPY; len++) + { + reset (); + + p = memset (u.buf+3, '\0', len); + if (p != u.buf+3) abort (); + check (3, len, '\0'); + + p = memset (u.buf+3, A, len); + if (p != u.buf+3) abort (); + check (3, len, 'A'); + + p = memset (u.buf+3, 'B', len); + if (p != u.buf+3) abort (); + check (3, len, 'B'); + } + + /* off == 4 */ + for (len = 0; len < MAX_COPY; len++) + { + reset (); + + p = memset (u.buf+4, '\0', len); + if (p != u.buf+4) abort (); + check (4, len, '\0'); + + p = memset (u.buf+4, A, len); + if (p != u.buf+4) abort (); + check (4, len, 'A'); + + p = memset (u.buf+4, 'B', len); + if (p != u.buf+4) abort (); + check (4, len, 'B'); + } + + /* off == 5 */ + for (len = 0; len < MAX_COPY; len++) + { + reset (); + + p = memset (u.buf+5, '\0', len); + if (p != u.buf+5) abort (); + check (5, len, '\0'); + + p = memset (u.buf+5, A, len); + if (p != u.buf+5) abort (); + check (5, len, 'A'); + + p = memset (u.buf+5, 'B', len); + if (p != u.buf+5) abort (); + check (5, len, 'B'); + } + + /* off == 6 */ + for (len = 0; len < MAX_COPY; len++) + { + reset (); + + p = memset (u.buf+6, '\0', len); + if (p != u.buf+6) abort (); + check (6, len, '\0'); + + p = memset (u.buf+6, A, len); + if (p != u.buf+6) abort (); + check (6, len, 'A'); + + p = memset (u.buf+6, 'B', len); + if (p != u.buf+6) abort (); + check (6, len, 'B'); + } + + /* off == 7 */ + for (len = 0; len < MAX_COPY; len++) + { + reset (); + + p = memset (u.buf+7, '\0', len); + if (p != u.buf+7) abort (); + check (7, len, '\0'); + + p = memset (u.buf+7, A, len); + if (p != u.buf+7) abort (); + check (7, len, 'A'); + + p = memset (u.buf+7, 'B', len); + if (p != u.buf+7) abort (); + check (7, len, 'B'); + } + + exit (0); +} + diff --git a/test/tests/mod-1.c b/test/tests/mod-1.c new file mode 100644 index 0000000..b460df5 --- /dev/null +++ b/test/tests/mod-1.c @@ -0,0 +1,11 @@ +f (x, y) +{ + if (x % y != 0) + abort (); +} + +main () +{ + f (-5, 5); + exit (0); +} diff --git a/test/tests/multdi-1.c b/test/tests/multdi-1.c new file mode 100644 index 0000000..1ffcc57 --- /dev/null +++ b/test/tests/multdi-1.c @@ -0,0 +1,20 @@ +/* PR target/9348 */ + +#define u_l_l unsigned long long +#define l_l long long + +l_l mpy_res; + +u_l_l mpy (long a, long b) +{ + return (u_l_l) a * (u_l_l) b; +} + +int main(void) +{ + mpy_res = mpy(1,-1); + if (mpy_res != -1LL) + abort (); + return 0; +} + diff --git a/test/tests/multi-ix.c b/test/tests/multi-ix.c new file mode 100644 index 0000000..fdfa567 --- /dev/null +++ b/test/tests/multi-ix.c @@ -0,0 +1,191 @@ +/* Test for a reload bug: + if you have a memory reference using the indexed addressing + mode, and the base address is a pseudo containing an address in the frame + and this pseudo fails to get a hard register, we end up with a double PLUS, + so the frame address gets reloaded. Now, when the index got a hard register, + and it dies in this insn, push_reload will consider that hard register as + a reload register, and disregrad overlaps with rld[n_reloads].in . That is + fine as long as the add can be done with a single insn, but when the + constant is so large that it has to be reloaded into a register first, + that clobbers the index. */ + +#include + +#ifdef STACK_SIZE +/* We need to be careful that we don't blow our stack. Function f, in the + worst case, needs to fit on the stack: + + * 40 int[CHUNK] arrays; + * ~40 ints; + * ~40 pointers for stdarg passing. + + Subtract the last two off STACK_SIZE and figure out what the maximum + chunk size can be. We make the last bit conservative to account for + register saves and other processor-dependent saving. */ +#define CHUNK ((STACK_SIZE-40*sizeof(int)-256*sizeof(void *))/40/sizeof(int)) +#else +#define CHUNK 500 +#endif + +void s(int, ...); +void z(int, ...); +void c(int, ...); + +typedef int l[CHUNK]; + +void +f (int n) +{ + int i; + l a0, a1, a2, a3, a4, a5, a6, a7, a8, a9; + l a10, a11, a12, a13, a14, a15, a16, a17, a18, a19; + l a20, a21, a22, a23, a24, a25, a26, a27, a28, a29; + l a30, a31, a32, a33, a34, a35, a36, a37, a38, a39; + int i0, i1, i2, i3, i4, i5, i6, i7, i8, i9; + int i10, i11, i12, i13, i14, i15, i16, i17, i18, i19; + int i20, i21, i22, i23, i24, i25, i26, i27, i28, i29; + int i30, i31, i32, i33, i34, i35, i36, i37, i38, i39; + + for (i = 0; i < n; i++) + { + s (40, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, + a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, + a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, + a30, a31, a32, a33, a34, a35, a36, a37, a38, a39); + i0 = a0[0]; + i1 = a1[0]; + i2 = a2[0]; + i3 = a3[0]; + i4 = a4[0]; + i5 = a5[0]; + i6 = a6[0]; + i7 = a7[0]; + i8 = a8[0]; + i9 = a9[0]; + i10 = a10[0]; + i11 = a11[0]; + i12 = a12[0]; + i13 = a13[0]; + i14 = a14[0]; + i15 = a15[0]; + i16 = a16[0]; + i17 = a17[0]; + i18 = a18[0]; + i19 = a19[0]; + i20 = a20[0]; + i21 = a21[0]; + i22 = a22[0]; + i23 = a23[0]; + i24 = a24[0]; + i25 = a25[0]; + i26 = a26[0]; + i27 = a27[0]; + i28 = a28[0]; + i29 = a29[0]; + i30 = a30[0]; + i31 = a31[0]; + i32 = a32[0]; + i33 = a33[0]; + i34 = a34[0]; + i35 = a35[0]; + i36 = a36[0]; + i37 = a37[0]; + i38 = a38[0]; + i39 = a39[0]; + z (40, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, + a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, + a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, + a30, a31, a32, a33, a34, a35, a36, a37, a38, a39); + a0[i0] = i0; + a1[i1] = i1; + a2[i2] = i2; + a3[i3] = i3; + a4[i4] = i4; + a5[i5] = i5; + a6[i6] = i6; + a7[i7] = i7; + a8[i8] = i8; + a9[i9] = i9; + a10[i10] = i10; + a11[i11] = i11; + a12[i12] = i12; + a13[i13] = i13; + a14[i14] = i14; + a15[i15] = i15; + a16[i16] = i16; + a17[i17] = i17; + a18[i18] = i18; + a19[i19] = i19; + a20[i20] = i20; + a21[i21] = i21; + a22[i22] = i22; + a23[i23] = i23; + a24[i24] = i24; + a25[i25] = i25; + a26[i26] = i26; + a27[i27] = i27; + a28[i28] = i28; + a29[i29] = i29; + a30[i30] = i30; + a31[i31] = i31; + a32[i32] = i32; + a33[i33] = i33; + a34[i34] = i34; + a35[i35] = i35; + a36[i36] = i36; + a37[i37] = i37; + a38[i38] = i38; + a39[i39] = i39; + c (40, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, + a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, + a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, + a30, a31, a32, a33, a34, a35, a36, a37, a38, a39); + } +} + +int +main () +{ + f (1); + exit (0); +} + +void s(int n, ...) +{ + va_list list; + + va_start (list, n); + while (n--) + { + int *a = va_arg (list, int *); + a[0] = n; + } + va_end (list); +} + +void z(int n, ...) +{ + va_list list; + + va_start (list, n); + while (n--) + { + int *a = va_arg (list, int *); + __builtin_bzero (a, sizeof (l)); + } + va_end (list); +} + +void c(int n, ...) +{ + va_list list; + + va_start (list, n); + while (n--) + { + int *a = va_arg (list, int *); + if (a[n] != n) + abort (); + } + va_end (list); +} diff --git a/test/tests/nestfunc-4.c b/test/tests/nestfunc-4.c new file mode 100644 index 0000000..e028166 --- /dev/null +++ b/test/tests/nestfunc-4.c @@ -0,0 +1,37 @@ +/* Origin: hp@bitrange.com + Test that return values come out right from a 1000-level call chain to + functions without parameters that each need at least one "long" + preserved. Exposed problems related to the MMIX port. */ + +long level = 0; +extern long foo (void); +extern long bar (void); + +#ifdef STACK_SIZE +#define DEPTH ((STACK_SIZE) / 512 + 1) +#else +#define DEPTH 500 +#endif + +int +main (void) +{ + if (foo () == -42) + exit (0); + + abort (); +} + +long +foo (void) +{ + long tmp = ++level; + return bar () + tmp; +} + +long +bar (void) +{ + long tmp = level; + return tmp > DEPTH - 1 ? -42 - tmp : foo () - tmp; +} diff --git a/test/tests/p18298.c b/test/tests/p18298.c new file mode 100644 index 0000000..5aff51f --- /dev/null +++ b/test/tests/p18298.c @@ -0,0 +1,18 @@ +#include +#include +int strcmp (const char*, const char*); +char s[2048] = "a"; +inline bool foo(const char *str) { + return !strcmp(s,str); +} +int main() { +int i = 0; + while(!(foo(""))) { + i ++; + s[0] = '\0'; + if (i>2) + abort (); + } + return 0; +} + diff --git a/test/tests/packed-1.c b/test/tests/packed-1.c new file mode 100644 index 0000000..9b226ae --- /dev/null +++ b/test/tests/packed-1.c @@ -0,0 +1,19 @@ +short x1 = 17; + +struct +{ + short i __attribute__ ((packed)); +} t; + +f () +{ + t.i = x1; + if (t.i != 17) + abort (); +} + +main () +{ + f (); + exit (0); +} diff --git a/test/tests/packed-2.c b/test/tests/packed-2.c new file mode 100644 index 0000000..6c57900 --- /dev/null +++ b/test/tests/packed-2.c @@ -0,0 +1,12 @@ +typedef struct s { + unsigned short a; + unsigned long b __attribute__ ((packed)); +} s; + +s t; + +int main() +{ + t.b = 0; + return 0; +} diff --git a/test/tests/pending-4.c b/test/tests/pending-4.c new file mode 100644 index 0000000..8000621 --- /dev/null +++ b/test/tests/pending-4.c @@ -0,0 +1,33 @@ + +void dummy (x, y) + int *x; + int y; +{} + +int +main (argc, argv) + int argc; + char **argv; +{ + int number_columns=9; + int cnt0 = 0; + int cnt1 = 0; + int i,A1; + + for (i = number_columns-1; i != 0; i--) + { + if (i == 1) + { + dummy(&A1, i); + cnt0++; + } + else + { + dummy(&A1, i-1); + cnt1++; + } + } + if (cnt0 != 1 || cnt1 != 7) + abort (); + exit (0); +} diff --git a/test/tests/pr15262-1.c b/test/tests/pr15262-1.c new file mode 100644 index 0000000..f6a6fe4 --- /dev/null +++ b/test/tests/pr15262-1.c @@ -0,0 +1,47 @@ +/* PR 15262. + The alias analyzer only considers relations between pointers and + symbols. If two pointers P and Q point to the same symbol S, then + their respective memory tags will either be the same or they will + have S in their alias set. + + However, if there are no common symbols between P and Q, TBAA will + currently miss their alias relationship altogether. */ +struct A +{ + int t; + int i; +}; + +int foo () { return 3; } + +main () +{ + struct A loc, *locp; + float f, g, *p; + int T355, *T356; + + /* Avoid the partial hack in TBAA that would consider memory tags if + the program had no addressable symbols. */ + f = 3; + g = 2; + p = foo () ? &g : &f; + if (*p > 0.0) + g = 1; + + /* Store into *locp and cache its current value. */ + locp = malloc (sizeof (*locp)); + locp->i = 10; + T355 = locp->i; + + /* Take the address of one of locp's fields and write to it. */ + T356 = &locp->i; + *T356 = 1; + + /* Read the recently stored value. If TBAA fails, this will appear + as a redundant load that will be replaced with '10'. */ + T355 = locp->i; + if (T355 != 1) + abort (); + + return 0; +} diff --git a/test/tests/pr15262-2.c b/test/tests/pr15262-2.c new file mode 100644 index 0000000..82e8aab --- /dev/null +++ b/test/tests/pr15262-2.c @@ -0,0 +1,37 @@ +/* PR 15262. Similar to pr15262-1.c but with no obvious addresses + being taken in function foo(). Without IPA, by only looking inside + foo() we cannot tell for certain whether 'q' and 'b' alias each + other. */ +struct A +{ + int t; + int i; +}; + +struct B +{ + int *p; + float b; +}; + +float X; + +foo (struct B b, struct A *q, float *h) +{ + X += *h; + *(b.p) = 3; + q->t = 2; + return *(b.p); +} + +main() +{ + struct A a; + struct B b; + + b.p = &a.t; + if (foo (b, &a, &X) == 3) + abort (); + + return 0; +} diff --git a/test/tests/pr15262.c b/test/tests/pr15262.c new file mode 100644 index 0000000..2110f33 --- /dev/null +++ b/test/tests/pr15262.c @@ -0,0 +1,48 @@ +/* We used to mis-compile this testcase as we did not know that + &a+offsetof(b,a) was the same as &a.b */ +struct A +{ + int t; + int i; +}; + +void +bar (float *p) +{ + *p = 5.2; +} + +int +foo(struct A *locp, int i, int str) +{ + float f, g, *p; + int T355; + int *T356; + /* Currently, the alias analyzer has limited support for handling + aliases of structure fields when no other variables are aliased. + Introduce additional aliases to confuse it. */ + p = i ? &g : &f; + bar (p); + if (*p > 0.0) + str = 1; + + T355 = locp->i; + T356 = &locp->i; + *T356 = str; + T355 = locp->i; + + return T355; +} + +main () +{ + struct A loc; + int str; + + loc.i = 2; + str = foo (&loc, 10, 3); + if (str!=1) + abort (); + return 0; +} + diff --git a/test/tests/pr15296.c b/test/tests/pr15296.c new file mode 100644 index 0000000..d2468e4 --- /dev/null +++ b/test/tests/pr15296.c @@ -0,0 +1,73 @@ +/* PR optimization/15296. The delayed-branch scheduler caused code that + SEGV:d for CRIS; a register was set to -1 in a delay-slot for the + fall-through code, while that register held a pointer used in code at + the branch target. */ + +typedef int __attribute__ ((mode (__pointer__))) intptr_t; +typedef intptr_t W; +union u0 +{ + union u0 *r; + W i; +}; +struct s1 +{ + union u0 **m0; + union u0 m1[4]; +}; + +void f (void *, struct s1 *, const union u0 *, W, W, W) + __attribute__ ((__noinline__)); +void g (void *, char *) __attribute__ ((__noinline__)); + +void +f (void *a, struct s1 *b, const union u0 *h, W v0, W v1, W v4) +{ + union u0 *e = 0; + union u0 *k = 0; + union u0 **v5 = b->m0; + union u0 *c = b->m1; + union u0 **d = &v5[0]; +l0:; + if (v0 < v1) + goto l0; + if (v0 == 0) + goto l3; + v0 = v4; + if (v0 != 0) + goto l3; + c[0].r = *d; + v1 = -1; + e = c[0].r; + if (e != 0) + g (a, ""); + k = e + 3; + k->i = v1; + goto l4; +l3:; + c[0].i = v0; + e = c[1].r; + if (e != 0) + g (a, ""); + e = c[0].r; + if (e == 0) + g (a, ""); + k = e + 2; + k->r = c[1].r; +l4:; +} + +void g (void *a, char *b) { abort (); } + +int +main () +{ + union u0 uv[] = {{ .i = 111 }, { .i = 222 }, { .i = 333 }, { .i = 444 }}; + struct s1 s = { 0, {{ .i = 555 }, { .i = 0 }, { .i = 999 }, { .i = 777 }}}; + f (0, &s, 0, 20000, 10000, (W) uv); + if (s.m1[0].i != (W) uv || s.m1[1].i != 0 || s.m1[2].i != 999 + || s.m1[3].i != 777 || uv[0].i != 111 || uv[1].i != 222 + || uv[2].i != 0 || uv[3].i != 444) + abort (); + exit (0); +} diff --git a/test/tests/pr16790-1.c b/test/tests/pr16790-1.c new file mode 100644 index 0000000..dc6a774 --- /dev/null +++ b/test/tests/pr16790-1.c @@ -0,0 +1,41 @@ +/* PR middle-end/16790. */ + +extern void abort (); + +static void test1(unsigned int u1) +{ + unsigned int y_final_1; + signed short y_middle; + unsigned int y_final_2; + + y_final_1 = (unsigned int)( (signed short)(u1 * 2) * 3 ); + y_middle = (signed short)(u1 * 2); + y_final_2 = (unsigned int)( y_middle * 3 ); + + if (y_final_1 != y_final_2) + abort (); +} + + +static void test2(unsigned int u1) +{ + unsigned int y_final_1; + signed short y_middle; + unsigned int y_final_2; + + y_final_1 = (unsigned int)( (signed short)(u1 << 1) * 3 ); + y_middle = (signed short)(u1 << 1); + y_final_2 = (unsigned int)( y_middle * 3 ); + + if (y_final_1 != y_final_2) + abort (); +} + + +int main() +{ + test1(0x4000U); + test2(0x4000U); + return 0; +} + diff --git a/test/tests/pr17078-1.c b/test/tests/pr17078-1.c new file mode 100644 index 0000000..9380bf4 --- /dev/null +++ b/test/tests/pr17078-1.c @@ -0,0 +1,25 @@ +extern void abort(void); + +void test(int *ptr) +{ + int i = 1; + goto useless; + if (0) + { + useless: + i = 0; + } + else + i = 1; + *ptr = i; +} + +int main() +{ + int i = 1; + test(&i); + if (i) + abort (); + return 0; +} + diff --git a/test/tests/pr17133.c b/test/tests/pr17133.c new file mode 100644 index 0000000..63352c0 --- /dev/null +++ b/test/tests/pr17133.c @@ -0,0 +1,27 @@ +extern void abort (void); + +int foo = 0; +void *bar = 0; +unsigned int baz = 100; + +void *pure_alloc () +{ + void *res; + + while (1) + { + res = (void *) ((((unsigned int) (foo + bar))) & ~1); + foo += 2; + if (foo < baz) + return res; + foo = 0; + } +} + +int main () +{ + pure_alloc (); + if (!foo) + abort (); + return 0; +} diff --git a/test/tests/pr17252.c b/test/tests/pr17252.c new file mode 100644 index 0000000..bd1b6b9 --- /dev/null +++ b/test/tests/pr17252.c @@ -0,0 +1,21 @@ +/* PR 17252. When a char * pointer P takes its own address, storing + into *P changes P itself. */ + +char *a; + +main () +{ + /* Make 'a' point to itself. */ + a = (char *)&a; + + /* Change what 'a' is pointing to. */ + a[0]++; + + /* If a's memory tag does not contain 'a' in its alias set, we will + think that this predicate is superfluous and change it to + 'if (1)'. */ + if (a == (char *)&a) + abort (); + + return 0; +} diff --git a/test/tests/pr19005.c b/test/tests/pr19005.c new file mode 100644 index 0000000..c36b388 --- /dev/null +++ b/test/tests/pr19005.c @@ -0,0 +1,38 @@ +/* PR target/19005 */ +extern void abort (void); + +int v, s; + +void +bar (int a, int b) +{ + unsigned char x = v; + + if (!s) + { + if (a != x || b != (unsigned char) (x + 1)) + abort (); + } + else if (a != (unsigned char) (x + 1) || b != x) + abort (); + s ^= 1; +} + +int +foo (int x) +{ + unsigned char a = x, b = x + 1; + + bar (a, b); + a ^= b; b ^= a; a ^= b; + bar (a, b); + return 0; +} + +int +main (void) +{ + for (v = -10; v < 266; v++) + foo (v); + return 0; +} diff --git a/test/tests/pr19515.c b/test/tests/pr19515.c new file mode 100644 index 0000000..df0e107 --- /dev/null +++ b/test/tests/pr19515.c @@ -0,0 +1,17 @@ +/* PR 19515 */ + +typedef union { + char a2[8]; +}aun; + +void abort (void); + +int main(void) +{ + aun a = {{0}}; + + if (a.a2[2] != 0) + abort (); + return 0; +} + diff --git a/test/tests/pr19606.c b/test/tests/pr19606.c new file mode 100644 index 0000000..d1e836f --- /dev/null +++ b/test/tests/pr19606.c @@ -0,0 +1,34 @@ +/* PR c/19606 + The C front end used to shorten the type of a division to a type + that does not preserve the semantics of the original computation. + Make sure that won't happen. */ + +signed char a = -4; + +int +foo (void) +{ + return ((unsigned int) (signed int) a) / 2LL; +} + +int +bar (void) +{ + return ((unsigned int) (signed int) a) % 5LL; +} + +int +main (void) +{ + int r; + + r = foo (); + if (r != ((unsigned int) (signed int) (signed char) -4) / 2LL) + abort (); + + r = bar (); + if (r != ((unsigned int) (signed int) (signed char) -4) % 5LL) + abort (); + + exit (0); +} diff --git a/test/tests/pr19687.c b/test/tests/pr19687.c new file mode 100644 index 0000000..c300ab4 --- /dev/null +++ b/test/tests/pr19687.c @@ -0,0 +1,18 @@ +extern void abort (void); + +union U +{ + int i, j[4]; +}; + +int main () +{ + union U t = {}; + int i; + + for (i = 0; i < 4; ++i) + if (t.j[i] != 0) + abort (); + + return 0; +} diff --git a/test/tests/pr19689.c b/test/tests/pr19689.c new file mode 100644 index 0000000..8d8010f --- /dev/null +++ b/test/tests/pr19689.c @@ -0,0 +1,19 @@ +extern void abort (void); + +struct +{ + int b : 13; +} f; + +void foo (short j) +{ + f.b = j; +} + +int main() +{ + foo (-55); + if (f.b != -55) + abort (); + return 0; +} diff --git a/test/tests/pr20100-1.c b/test/tests/pr20100-1.c new file mode 100644 index 0000000..00263af --- /dev/null +++ b/test/tests/pr20100-1.c @@ -0,0 +1,76 @@ +/* PR tree-optimization/20100 + Pure function being treated as const. + Author: Hans-Peter Nilsson. */ + +static unsigned short g = 0; +static unsigned short p = 0; +unsigned char e; + +static unsigned short +next_g (void) +{ + return g == e - 1 ? 0 : g + 1; +} + +static unsigned short +curr_p (void) +{ + return p; +} + +static unsigned short +inc_g (void) +{ + return g = next_g (); +} + +static unsigned short +curr_g (void) +{ + return g; +} + +static char +ring_empty (void) +{ + if (curr_p () == curr_g ()) + return 1; + else + return 0; +} + +char +frob (unsigned short a, unsigned short b) +{ + g = a; + p = b; + inc_g (); + return ring_empty (); +} + +unsigned short +get_n (void) +{ + unsigned short n = 0; + unsigned short org_g; + org_g = curr_g (); + while (!ring_empty () && n < 5) + { + inc_g (); + n++; + } + + return n; +} + +void abort (void); +void exit (int); +int main (void) +{ + e = 3; + if (frob (0, 2) != 0 || g != 1 || p != 2 || e != 3 + || get_n () != 1 /* + || g != 2 || p != 2 */) + abort (); + exit (0); +} diff --git a/test/tests/pr20187-1.c b/test/tests/pr20187-1.c new file mode 100644 index 0000000..a1f0a09 --- /dev/null +++ b/test/tests/pr20187-1.c @@ -0,0 +1,15 @@ +int a = 0x101; +int b = 0x100; + +int +test (void) +{ + return (((unsigned char) (unsigned long long) ((a ? a : 1) & (a * b))) + ? 0 : 1); +} + +int +main (void) +{ + return 1 - test (); +} diff --git a/test/tests/pr20466-1.c b/test/tests/pr20466-1.c new file mode 100644 index 0000000..fb4787f --- /dev/null +++ b/test/tests/pr20466-1.c @@ -0,0 +1,26 @@ +int f (int **, int *, int *, int **, int **) __attribute__ ((__noinline__)); +int +f (int **ipp, int *i1p, int *i2p, int **i3, int **i4) +{ + **ipp = *i1p; + *ipp = i2p; + *i3 = *i4; + **ipp = 99; + return 3; +} + +extern void exit (int); +extern void abort (void); + +int main (void) +{ + int i = 42, i1 = 66, i2 = 1, i3 = -1, i4 = 55; + int *ip = &i; + int *i3p = &i3; + int *i4p = &i4; + + f (&ip, &i1, &i2, &i3p, &i4p); + if (i != 66 || ip != &i2 || i2 != 99 || i3 != -1 || i3p != i4p || i4 != 55) + abort (); + exit (0); +} diff --git a/test/tests/pr20527-1.c b/test/tests/pr20527-1.c new file mode 100644 index 0000000..81162df --- /dev/null +++ b/test/tests/pr20527-1.c @@ -0,0 +1,81 @@ +/* PR rtl-optimization/20527 + Mishandled postincrement. This test-case is derived from the + function BZ2_hbCreateDecodeTables in the file huffman.c from + bzip2-1.0.2, hence requiring the following disclaimer copied here: */ + +/*-- + This file is a part of bzip2 and/or libbzip2, a program and + library for lossless, block-sorting data compression. + + Copyright (C) 1996-2002 Julian R Seward. All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions + are met: + + 1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + 2. The origin of this software must not be misrepresented; you must + not claim that you wrote the original software. If you use this + software in a product, an acknowledgment in the product + documentation would be appreciated but is not required. + + 3. Altered source versions must be plainly marked as such, and must + not be misrepresented as being the original software. + + 4. The name of the author may not be used to endorse or promote + products derived from this software without specific prior written + permission. + + THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS + OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + Julian Seward, Cambridge, UK. + jseward@acm.org + bzip2/libbzip2 version 1.0 of 21 March 2000 + + This program is based on (at least) the work of: + Mike Burrows + David Wheeler + Peter Fenwick + Alistair Moffat + Radford Neal + Ian H. Witten + Robert Sedgewick + Jon L. Bentley + + For more information on these sources, see the manual. +--*/ + +void f (long *limit, long *base, long minLen, long maxLen) __attribute__ ((__noinline__)); +void f (long *limit, long *base, long minLen, long maxLen) +{ + long i; + long vec; + vec = 0; + for (i = minLen; i <= maxLen; i++) { + vec += (base[i+1] - base[i]); + limit[i] = vec-1; + } +} +extern void abort (void); +extern void exit (int); +long b[] = {1, 5, 11, 23}; +int main (void) +{ + long l[3]; + f (l, b, 0, 2); + if (l[0] != 3 || l[1] != 9 || l[2] != 21) + abort (); + exit (0); +} diff --git a/test/tests/pr20601-1.c b/test/tests/pr20601-1.c new file mode 100644 index 0000000..7c13c91 --- /dev/null +++ b/test/tests/pr20601-1.c @@ -0,0 +1,122 @@ +/* PR tree-optimization/20601 */ +extern void abort (void); +extern void exit (int); + +struct T +{ + char *t1; + char t2[4096]; + char **t3; +}; + +int a[5]; +int b; +char **c; +int d; +char **e; +struct T t; +char *f[16]; +char *g[] = { "a", "-u", "b", "c" }; + +__attribute__ ((__noreturn__)) void +foo (void) +{ + while (1); +} + +__attribute__ ((noinline)) char * +bar (char *x, unsigned int y) +{ + return 0; +} + +static inline char * +baz (char *x, unsigned int y) +{ + if (sizeof (t.t2) != (unsigned int) -1 && y > sizeof (t.t2)) + foo (); + return bar (x, y); +} + +static inline int +setup1 (int x) +{ + char *p; + int rval; + + if (!baz (t.t2, sizeof (t.t2))) + baz (t.t2, sizeof (t.t2)); + + if (x & 0x200) + { + char **h, **i = e; + + ++d; + e = f; + if (t.t1 && *t.t1) + e[0] = t.t1; + else + abort (); + + for (h = e + 1; (*h = *i); ++i, ++h) + ; + } + return 1; +} + +static inline int +setup2 (void) +{ + int j = 1; + + e = c + 1; + d = b - 1; + while (d > 0 && e[0][0] == '-') + { + if (e[0][1] != '\0' && e[0][2] != '\0') + abort (); + + switch (e[0][1]) + { + case 'u': + if (!e[1]) + abort (); + + t.t3 = &e[1]; + d--; + e++; + break; + case 'P': + j |= 0x1000; + break; + case '-': + d--; + e++; + if (j == 1) + j |= 0x600; + return j; + } + d--; + e++; + } + + if (d > 0 && !(j & 1)) + abort (); + + return j; +} + +int +main (void) +{ + int x; + c = g; + b = 4; + x = setup2 (); + t.t1 = "/bin/sh"; + setup1 (x); + /* PRE shouldn't transform x into the constant 0x601 here, it's not legal. */ + if ((x & 0x400) && !a[4]) + abort (); + exit (0); +} diff --git a/test/tests/pr20621-1.c b/test/tests/pr20621-1.c new file mode 100644 index 0000000..7990187 --- /dev/null +++ b/test/tests/pr20621-1.c @@ -0,0 +1,6 @@ +/* When generating o32 MIPS PIC, main's $gp save slot was out of range + of a single load instruction. */ +struct big { int i[sizeof (int) >= 4 && sizeof (void *) >= 4 ? 0x4000 : 4]; }; +struct big gb; +int foo (struct big b, int x) { return b.i[x]; } +int main (void) { return foo (gb, 0) + foo (gb, 1); } diff --git a/test/tests/pr21173.c b/test/tests/pr21173.c new file mode 100644 index 0000000..61459bc --- /dev/null +++ b/test/tests/pr21173.c @@ -0,0 +1,21 @@ +void abort (void); + +char q; +void *a[2]; + +void foo (char *p) +{ + int i; + for (i = 0; i < 2; i++) + a[i] += p - &q; +} + +int main (void) +{ + int i; + foo (&q); + for (i = 0; i < 2; i ++) + if (a[i]) + abort (); + return 0; +} diff --git a/test/tests/pr21331.c b/test/tests/pr21331.c new file mode 100644 index 0000000..4d95878 --- /dev/null +++ b/test/tests/pr21331.c @@ -0,0 +1,15 @@ +void abort (void); + +int bar (void) { return -1; } + +unsigned long +foo () +{ unsigned long retval; + retval = bar (); + if (retval == -1) return 0; + return 3; } + +main () +{ if (foo () != 0) abort (); + return 0; } + diff --git a/test/tests/pr21964-1.c b/test/tests/pr21964-1.c new file mode 100644 index 0000000..b7e1e0d --- /dev/null +++ b/test/tests/pr21964-1.c @@ -0,0 +1,16 @@ +void +foo (int n, int m) +{ + if (m == 0) + exit (0); + else if (n != 0) + abort (); + else + foo (n++, m - 1); +} + +int +main (void) +{ + foo (0, 4); +} diff --git a/test/tests/pr22348.c b/test/tests/pr22348.c new file mode 100644 index 0000000..9192d51 --- /dev/null +++ b/test/tests/pr22348.c @@ -0,0 +1,15 @@ +void abort (void); +void f(int i) +{ + if (i>4 + 3 * 16) + abort(); +} + +int main() +{ + unsigned int buflen, i; + buflen = 4 + 3 * 16; + for (i = 4; i < buflen; i+= 3) + f(i); + return 0; +} diff --git a/test/tests/pr22429.c b/test/tests/pr22429.c new file mode 100644 index 0000000..aa55b6e --- /dev/null +++ b/test/tests/pr22429.c @@ -0,0 +1,17 @@ +extern void abort (void); + +#define N (1 << (sizeof(int) * __CHAR_BIT__ - 2)) + +int f(int n) +{ + if (-N <= n && n <= N-1) + return 1; + return 0; +} + +int main () +{ + if (f (N)) + abort (); + return 0; +} diff --git a/test/tests/pr22493-1.c b/test/tests/pr22493-1.c new file mode 100644 index 0000000..bc0ff78 --- /dev/null +++ b/test/tests/pr22493-1.c @@ -0,0 +1,18 @@ +#include +extern void abort (); +extern void exit (int); +void f(int i) +{ + if (i>0) + abort(); + i = -i; + if (i<0) + return; + abort (); +} + +int main(int argc, char *argv[]) +{ + f(INT_MIN); + exit (0); +} diff --git a/test/tests/pr22630.c b/test/tests/pr22630.c new file mode 100644 index 0000000..d3a5649 --- /dev/null +++ b/test/tests/pr22630.c @@ -0,0 +1,23 @@ +void abort (void); + +int j; + +void bla (int *r) +{ + int *p, *q; + + p = q = r; + if (!p) + p = &j; + + if (p != q) + j = 1; +} + +int main (void) +{ + bla (0); + if (!j) + abort (); + return 0; +} diff --git a/test/tests/pr23047.c b/test/tests/pr23047.c new file mode 100644 index 0000000..7557fc2 --- /dev/null +++ b/test/tests/pr23047.c @@ -0,0 +1,16 @@ +#include +extern void abort (); +extern void exit (int); +void f(int i) +{ + i = i > 0 ? i : -i; + if (i<0) + return; + abort (); +} + +int main(int argc, char *argv[]) +{ + f(INT_MIN); + exit (0); +} diff --git a/test/tests/pr23324.c b/test/tests/pr23324.c new file mode 100644 index 0000000..c5f88f7 --- /dev/null +++ b/test/tests/pr23324.c @@ -0,0 +1,133 @@ +extern void abort (void); +#define A(x) if (!(x)) abort () + +static union at6 {} vv6 = {}; +static struct et6 +{ + struct bt6 + { + signed av6:6; + signed bv6:7; + signed cv6:6; + signed dv6:5; + unsigned char ev6; + unsigned int fv6; + long int gv6; + } mv6; + unsigned long int nv6; + signed ov6:12; + signed pv6:3; + signed qv6:2; + signed rv6:10; + union ct6 { long int hv6; float iv6; float jv6; } sv6; + int *tv6; + union dt6 { double kv6; float lv6; } uv6; +} wv6 = { + { 8, 9, 2, 4, '\x10', 67426805U, 1047191860L }, + 1366022414UL, 858, 1, 1, 305, + { 1069379046L }, (int *) 358273621U, + { 3318.041978 } +}; +static double xv6 = 19239.101269; +static long long int yv6 = 1207859169L; +static int zv6 = 660195606; + +static union at6 +callee_af6 (struct et6 ap6, double bp6, long long int cp6, int dp6) +{ + A (wv6.mv6.av6 == ap6.mv6.av6); + A (wv6.mv6.bv6 == ap6.mv6.bv6); + A (wv6.mv6.cv6 == ap6.mv6.cv6); + A (wv6.mv6.dv6 == ap6.mv6.dv6); + A (wv6.mv6.ev6 == ap6.mv6.ev6); + A (wv6.mv6.fv6 == ap6.mv6.fv6); + A (wv6.mv6.gv6 == ap6.mv6.gv6); + A (wv6.nv6 == ap6.nv6); + A (wv6.ov6 == ap6.ov6); + A (wv6.pv6 == ap6.pv6); + A (wv6.qv6 == ap6.qv6); + A (wv6.rv6 == ap6.rv6); + A (wv6.sv6.hv6 == ap6.sv6.hv6); + A (wv6.tv6 == ap6.tv6); + A (wv6.uv6.kv6 == ap6.uv6.kv6); + A (xv6 == bp6); + A (yv6 == cp6); + A (zv6 == dp6); + return vv6; +} + +static void +caller_bf6 (void) +{ + union at6 bav6; + bav6 = callee_af6 (wv6, xv6, yv6, zv6); +} + +static unsigned char uv7 = '\x46'; +static float vv7 = 96636.982442; +static double wv7 = 28450.711801; +static union ct7 {} xv7 = {}; +static struct et7 +{ + struct dt7 + { + float iv7; + unsigned short int jv7; + } kv7; + float lv7[0]; + signed mv7:9; + short int nv7; + double ov7; + float pv7; +} yv7 = { + { 30135.996213, 42435 }, + {}, 170, 22116, 26479.628148, 4082.960685 +}; +static union ft7 +{ + float qv7; + float *rv7; + unsigned int *sv7; +} zv7 = { 5042.227886 }; +static int bav7 = 1345451862; +static struct gt7 { double tv7; } bbv7 = { 47875.491954 }; +static long int bcv7[1] = { 1732133482L }; +static long long int bdv7 = 381678602L; + +static unsigned char +callee_af7 (float ap7, double bp7, union ct7 cp7, struct et7 dp7, + union ft7 ep7, int fp7, struct gt7 gp7, long int hp7[1], + long long int ip7) +{ + A (vv7 == ap7); + A (wv7 == bp7); + A (yv7.kv7.iv7 == dp7.kv7.iv7); + A (yv7.kv7.jv7 == dp7.kv7.jv7); + A (yv7.mv7 == dp7.mv7); + A (yv7.nv7 == dp7.nv7); + A (yv7.ov7 == dp7.ov7); + A (yv7.pv7 == dp7.pv7); + A (zv7.qv7 == ep7.qv7); + A (bav7 == fp7); + A (bbv7.tv7 == gp7.tv7); + A (bcv7[0] == hp7[0]); + A (bdv7 == ip7); + return uv7; +} + +static void +caller_bf7 (void) +{ + unsigned char bev7; + + bev7 = callee_af7 (vv7, wv7, xv7, yv7, zv7, bav7, bbv7, bcv7, bdv7); + A (uv7 == bev7); +} + +int +main () +{ + caller_bf6 (); + caller_bf7 (); + return 0; +} diff --git a/test/tests/pr23604.c b/test/tests/pr23604.c new file mode 100644 index 0000000..4c2b80d --- /dev/null +++ b/test/tests/pr23604.c @@ -0,0 +1,22 @@ +extern void abort (void); + +int g(int i, int j) +{ + if (i>-1) + if (i<2) + { + if (i != j) + { + if (j != 0) + return 0; + } + } + return 1; +} + +int main(void) +{ + if (!g(1, 0)) + abort (); + return 0; +} diff --git a/test/tests/pr23941.c b/test/tests/pr23941.c new file mode 100644 index 0000000..4dfd645 --- /dev/null +++ b/test/tests/pr23941.c @@ -0,0 +1,9 @@ +extern void abort (void); +double d = __FLT_MIN__ / 2.0; +int main() +{ + double x = __FLT_MIN__ / 2.0; + if (x != d) + abort (); + return 0; +} diff --git a/test/tests/pr24141.c b/test/tests/pr24141.c new file mode 100644 index 0000000..3012962 --- /dev/null +++ b/test/tests/pr24141.c @@ -0,0 +1,33 @@ +// reduced testcase, compile with -O2. Also, with --disable-checking +// gcc produces wrong code. + +void abort (void); +int i; + +void g (void) +{ + i = 1; +} + +void f (int a, int b) +{ + int c = 0; + if (a == 0) + c = 1; + if (c) + return; + if (c == 1) + c = 0; + if (b == 0) + c = 1; + if (c) + g (); +} + +int main (void) +{ + f (1, 0); + if (i != 1) + abort (); + return 0; +} diff --git a/test/tests/pr24142.c b/test/tests/pr24142.c new file mode 100644 index 0000000..eed3e8b --- /dev/null +++ b/test/tests/pr24142.c @@ -0,0 +1,19 @@ +void abort (void); + +int f (int a, int b) +{ + if (a == 1) + a = 0; + if (b == 0) + a = 1; + if (a != 0) + return 0; + return 1; +} + +int main (void) +{ + if (f (1, 1) != 1) + abort (); + return 0; +} diff --git a/test/tests/pr24716.c b/test/tests/pr24716.c new file mode 100644 index 0000000..c2473f8 --- /dev/null +++ b/test/tests/pr24716.c @@ -0,0 +1,59 @@ +/* PR24716, scalar evolution returning the wrong result + for pdest. */ + +int Link[] = { -1 }; +int W[] = { 2 }; + +extern void abort (void); + +int f (int k, int p) +{ + int pdest, j, D1361; + j = 0; + pdest = 0; + for (;;) { + if (pdest > 2) + do + j--, pdest++; + while (j > 2); + + if (j == 1) + break; + + while (pdest > p) + if (j == p) + pdest++; + + do + { + D1361 = W[k]; + do + if (D1361 != 0) + pdest = 1, W[k] = D1361 = 0; + while (p < 1); + } while (k > 0); + + do + { + p = 0; + k = Link[k]; + while (p < j) + if (k != -1) + pdest++, p++; + } + while (k != -1); + j = 1; + } + + /* The correct return value should be pdest (1 in the call from main). + DOM3 is mistaken and propagates a 0 here. */ + return pdest; +} + +int main () +{ + if (!f (0, 2)) + abort (); + return 0; +} + diff --git a/test/tests/pr24851.c b/test/tests/pr24851.c new file mode 100644 index 0000000..55a87e0 --- /dev/null +++ b/test/tests/pr24851.c @@ -0,0 +1,17 @@ +/* We used to handle pointer addition wrongly + at the time of recombining to an ARRAY_REF + in the case of + p + -4B + where -4B is represented as unsigned. */ + +void abort(void); +int main() +{ + int a[10], *p, *q; + q = &a[1]; + p = &q[-1]; + if (p >= &a[9]) + abort (); + return 0; +} + diff --git a/test/tests/pr25125.c b/test/tests/pr25125.c new file mode 100644 index 0000000..f08ebe7 --- /dev/null +++ b/test/tests/pr25125.c @@ -0,0 +1,27 @@ +extern void exit (int); +extern void abort (void); +extern unsigned short f (short a) __attribute__((__noinline__)); + +unsigned short +f (short a) +{ + short b; + + if (a > 0) + return 0; + b = ((int) a) + - (int) 32768; + return b; +} + +int +main (void) +{ + if (sizeof (short) < 2 + || sizeof (short) >= sizeof (int)) + exit (0); + + if (f (-32767) != 1) + abort (); + + exit (0); +} diff --git a/test/tests/pr25737.c b/test/tests/pr25737.c new file mode 100644 index 0000000..9da63ad --- /dev/null +++ b/test/tests/pr25737.c @@ -0,0 +1,23 @@ +extern void abort (void); + +struct delay_block { + struct delay_block *succ; +}; + +static struct delay_block Timer_Queue; + +struct delay_block* time_enqueue (struct delay_block *d) +{ + struct delay_block *q = Timer_Queue.succ; + d->succ = (void *)0; + return Timer_Queue.succ; +} + +int main(void) +{ + Timer_Queue.succ = &Timer_Queue; + if (time_enqueue (&Timer_Queue) != (void*)0) + abort (); + return 0; +} + diff --git a/test/tests/pr27073.c b/test/tests/pr27073.c new file mode 100644 index 0000000..a58e9ac --- /dev/null +++ b/test/tests/pr27073.c @@ -0,0 +1,25 @@ +void __attribute__((noinline)) +foo (int *p, int d1, int d2, int d3, + short count, int s1, int s2, int s3, int s4, int s5) +{ + int n = count; + while (n--) + { + *p++ = s1; + *p++ = s2; + *p++ = s3; + *p++ = s4; + *p++ = s5; + } +} + +int main() +{ + int x[10], i; + + foo (x, 0, 0, 0, 2, 100, 200, 300, 400, 500); + for (i = 0; i < 10; i++) + if (x[i] != (i % 5 + 1) * 100) + abort (); + exit (0); +} diff --git a/test/tests/pr27260.c b/test/tests/pr27260.c new file mode 100644 index 0000000..daec0c3 --- /dev/null +++ b/test/tests/pr27260.c @@ -0,0 +1,33 @@ +/* PR middle-end/27260 */ + +extern void abort (void); +extern void *memset (void *, int, __SIZE_TYPE__); + +char buf[65]; + +void +foo (int x) +{ + memset (buf, x != 2 ? 1 : 0, 64); +} + +int +main (void) +{ + int i; + buf[64] = 2; + for (i = 0; i < 64; i++) + if (buf[i] != 0) + abort (); + foo (0); + for (i = 0; i < 64; i++) + if (buf[i] != 1) + abort (); + foo (2); + for (i = 0; i < 64; i++) + if (buf[i] != 0) + abort (); + if (buf[64] != 2) + abort (); + return 0; +} diff --git a/test/tests/pr27285.c b/test/tests/pr27285.c new file mode 100644 index 0000000..44a6aaf --- /dev/null +++ b/test/tests/pr27285.c @@ -0,0 +1,46 @@ +/* PR tree-optimization/27285 */ + +extern void abort (void); + +struct S { unsigned char a, b, c, d[16]; }; + +void __attribute__ ((noinline)) +foo (struct S *x, struct S *y) +{ + int a, b; + unsigned char c, *d, *e; + + b = x->b; + d = x->d; + e = y->d; + a = 0; + while (b) + { + if (b >= 8) + { + c = 0xff; + b -= 8; + } + else + { + c = 0xff << (8 - b); + b = 0; + } + + e[a] = d[a] & c; + a++; + } +} + +int +main (void) +{ + struct S x = { 0, 25, 0, { 0xaa, 0xbb, 0xcc, 0xdd }}; + struct S y = { 0, 0, 0, { 0 }}; + + foo (&x, &y); + if (x.d[0] != y.d[0] || x.d[1] != y.d[1] + || x.d[2] != y.d[2] || (x.d[3] & 0x80) != y.d[3]) + abort (); + return 0; +} diff --git a/test/tests/pr27364.c b/test/tests/pr27364.c new file mode 100644 index 0000000..7eba084 --- /dev/null +++ b/test/tests/pr27364.c @@ -0,0 +1,13 @@ +int f(unsigned number_of_digits_to_use) +{ + if (number_of_digits_to_use >1294) + return 0; + return (number_of_digits_to_use * 3321 / 1000 + 1) /16; +} + +int main(void) +{ + if (f(11) != 2) + __builtin_abort (); + exit (0); +} diff --git a/test/tests/pr27671-1.c b/test/tests/pr27671-1.c new file mode 100644 index 0000000..dd2982c --- /dev/null +++ b/test/tests/pr27671-1.c @@ -0,0 +1,21 @@ +/* PR rtl-optimization/27671. + The combiner used to simplify "a ^ b == a" to "a" via + simplify_relational_operation_1 in simplify-rtx.c. */ + +extern void abort (void) __attribute__ ((noreturn)); +extern void exit (int) __attribute__ ((noreturn)); + +static int __attribute__((noinline)) +foo (int a, int b) +{ + int c = a ^ b; + if (c == a) + abort (); +} + +int +main (void) +{ + foo (0, 1); + exit (0); +} diff --git a/test/tests/pr28403.c b/test/tests/pr28403.c new file mode 100644 index 0000000..8f85ea0 --- /dev/null +++ b/test/tests/pr28403.c @@ -0,0 +1,23 @@ +typedef unsigned long long ull; +int global; + +int __attribute__((noinline)) +foo (int x1, int x2, int x3, int x4, int x5, int x6, int x7, int x8) +{ + global = x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8; +} + +ull __attribute__((noinline)) +bar (ull x) +{ + foo (1, 2, 1, 3, 1, 4, 1, 5); + return x >> global; +} + +int +main (void) +{ + if (bar (0x123456789abcdefULL) != (0x123456789abcdefULL >> 18)) + abort (); + exit (0); +} diff --git a/test/tests/pr28651.c b/test/tests/pr28651.c new file mode 100644 index 0000000..74656fd --- /dev/null +++ b/test/tests/pr28651.c @@ -0,0 +1,19 @@ +#include + +extern void abort (void); +int __attribute__((noinline)) +foo (unsigned int u) +{ + return (int)(u + 4) < (int)u; +} + +int +main (int argc, char *argv[]) +{ + unsigned int u = INT_MAX; + + if (foo (u) == 0) + abort(); + return 0; +} + diff --git a/test/tests/pr28778.c b/test/tests/pr28778.c new file mode 100644 index 0000000..f96a66c --- /dev/null +++ b/test/tests/pr28778.c @@ -0,0 +1,33 @@ +extern void abort(void); +typedef long GLint; +void aglChoosePixelFormat (const GLint *); + +void +find (const int *alistp) +{ + const int *blist; + int list[32]; + if (alistp) + blist = alistp; + else + { + list[3] = 42; + blist = list; + } + aglChoosePixelFormat ((GLint *) blist); +} + +void +aglChoosePixelFormat (const GLint * a) +{ + int *b = (int *) a; + if (b[3] != 42) + abort (); +} + +int +main (void) +{ + find (0); + return 0; +} diff --git a/test/tests/pr28982a.c b/test/tests/pr28982a.c new file mode 100644 index 0000000..5660a8d --- /dev/null +++ b/test/tests/pr28982a.c @@ -0,0 +1,65 @@ +/* PR rtl-optimization/28982. Function foo() does the equivalent of: + + float tmp_results[NVARS]; + for (int i = 0; i < NVARS; i++) + { + int inc = incs[i]; + float *ptr = ptrs[i], result = 0; + for (int j = 0; j < n; j++) + result += *ptr, ptr += inc; + tmp_results[i] = result; + } + memcpy (results, tmp_results, sizeof (results)); + + but without the outermost loop. The idea is to create high register + pressure and ensure that some INC and PTR variables are spilled. + + On ARM targets, sequences like "result += *ptr, ptr += inc" can + usually be implemented using (mem (post_modify ...)), and we do + indeed create such MEMs before reload for this testcase. However, + (post_modify ...) is not a valid address for coprocessor loads, so + for -mfloat-abi=softfp, reload reloads the POST_MODIFY into a base + register. GCC did not deal correctly with cases where the base and + index of the POST_MODIFY are themselves reloaded. */ +#define NITER 4 +#define NVARS 20 +#define MULTI(X) \ + X( 0), X( 1), X( 2), X( 3), X( 4), X( 5), X( 6), X( 7), X( 8), X( 9), \ + X(10), X(11), X(12), X(13), X(14), X(15), X(16), X(17), X(18), X(19) + +#define DECLAREI(INDEX) inc##INDEX = incs[INDEX] +#define DECLAREF(INDEX) *ptr##INDEX = ptrs[INDEX], result##INDEX = 0 +#define LOOP(INDEX) result##INDEX += *ptr##INDEX, ptr##INDEX += inc##INDEX +#define COPYOUT(INDEX) results[INDEX] = result##INDEX + +float *ptrs[NVARS]; +float results[NVARS]; +int incs[NVARS]; + +void __attribute__((noinline)) +foo (int n) +{ + int MULTI (DECLAREI); + float MULTI (DECLAREF); + while (n--) + MULTI (LOOP); + MULTI (COPYOUT); +} + +float input[NITER * NVARS]; + +int +main (void) +{ + int i; + + for (i = 0; i < NVARS; i++) + ptrs[i] = input + i, incs[i] = i; + for (i = 0; i < NITER * NVARS; i++) + input[i] = i; + foo (NITER); + for (i = 0; i < NVARS; i++) + if (results[i] != i * NITER * (NITER + 1) / 2) + return 1; + return 0; +} diff --git a/test/tests/pr28982b.c b/test/tests/pr28982b.c new file mode 100644 index 0000000..3f9f5ba --- /dev/null +++ b/test/tests/pr28982b.c @@ -0,0 +1,58 @@ +/* Like pr28982a.c, but with the spill slots outside the range of + a single sp-based load on ARM. This test tests for cases where + the addresses in the base and index reloads require further reloads. */ +#if defined(STACK_SIZE) && STACK_SIZE <= 0x80100 +int main (void) { return 0; } +#else +#define NITER 4 +#define NVARS 20 +#define MULTI(X) \ + X( 0), X( 1), X( 2), X( 3), X( 4), X( 5), X( 6), X( 7), X( 8), X( 9), \ + X(10), X(11), X(12), X(13), X(14), X(15), X(16), X(17), X(18), X(19) + +#define DECLAREI(INDEX) inc##INDEX = incs[INDEX] +#define DECLAREF(INDEX) *ptr##INDEX = ptrs[INDEX], result##INDEX = 0 +#define LOOP(INDEX) result##INDEX += *ptr##INDEX, ptr##INDEX += inc##INDEX +#define COPYOUT(INDEX) results[INDEX] = result##INDEX + +float *ptrs[NVARS]; +float results[NVARS]; +int incs[NVARS]; + +struct big { int i[0x10000]; }; +void __attribute__((noinline)) +bar (struct big b) +{ + incs[0] += b.i[0]; +} + +void __attribute__((noinline)) +foo (int n) +{ + struct big b = {}; + int MULTI (DECLAREI); + float MULTI (DECLAREF); + while (n--) + MULTI (LOOP); + MULTI (COPYOUT); + bar (b); +} + +float input[NITER * NVARS]; + +int +main (void) +{ + int i; + + for (i = 0; i < NVARS; i++) + ptrs[i] = input + i, incs[i] = i; + for (i = 0; i < NITER * NVARS; i++) + input[i] = i; + foo (NITER); + for (i = 0; i < NVARS; i++) + if (results[i] != i * NITER * (NITER + 1) / 2) + return 1; + return 0; +} +#endif diff --git a/test/tests/pr29006.c b/test/tests/pr29006.c new file mode 100644 index 0000000..87528cf --- /dev/null +++ b/test/tests/pr29006.c @@ -0,0 +1,3 @@ +struct s { char c; unsigned long long x; } __attribute__((__packed__)) ; +void __attribute__((__noinline__)) foo (struct s *s) { s->x = 0; } +int main (void) { struct s s = { 1, ~0ULL }; foo (&s); return s.x != 0; } diff --git a/test/tests/pr29156.c b/test/tests/pr29156.c new file mode 100644 index 0000000..20f5f99 --- /dev/null +++ b/test/tests/pr29156.c @@ -0,0 +1,32 @@ +extern void abort(void); +struct test1 +{ + int a; + int b; +}; +struct test2 +{ + float d; + struct test1 sub; +}; + +int global; + +int bla(struct test1 *xa, struct test2 *xb) +{ + global = 1; + xb->sub.a = 1; + xa->a = 8; + return xb->sub.a; +} + +int main(void) +{ + struct test2 pom; + + if (bla (&pom.sub, &pom) != 8) + abort (); + + return 0; +} + diff --git a/test/tests/pr29695-1.c b/test/tests/pr29695-1.c new file mode 100644 index 0000000..81ac934 --- /dev/null +++ b/test/tests/pr29695-1.c @@ -0,0 +1,83 @@ +/* PR middle-end/29695 */ + +extern void abort (void); + +int +f1 (void) +{ + int a = 128; + return (a & 0x80) ? 0x80 : 0; +} + +int +f2 (void) +{ + unsigned char a = 128; + return (a & 0x80) ? 0x80 : 0; +} + +int +f3 (void) +{ + unsigned char a = 128; + return (a & 0x80) ? 0x380 : 0; +} + +int +f4 (void) +{ + unsigned char a = 128; + return (a & 0x80) ? -128 : 0; +} + +long long +f5 (void) +{ + long long a = 0x80000000LL; + return (a & 0x80000000) ? 0x80000000LL : 0LL; +} + +long long +f6 (void) +{ + unsigned int a = 0x8000; + return (a & 0x8000) ? 0x80000000LL : 0LL; +} + +long long +f7 (void) +{ + unsigned int a = 0x8000; + return (a & 0x8000) ? 0x380000000LL : 0LL; +} + +long long +f8 (void) +{ + unsigned int a = 0x8000; + return (a & 0x8000) ? -2147483648LL : 0LL; +} + +int +main (void) +{ + if ((char) 128 != -128 || (int) 0x8000 != -32768) + return 0; + if (f1 () != 128) + abort (); + if (f2 () != 128) + abort (); + if (f3 () != 896) + abort (); + if (f4 () != -128) + abort (); + if (f5 () != 0x80000000LL) + abort (); + if (f6 () != 0x80000000LL) + abort (); + if (f7 () != 0x380000000LL) + abort (); + if (f8 () != -2147483648LL) + abort (); + return 0; +} diff --git a/test/tests/pr29695-2.c b/test/tests/pr29695-2.c new file mode 100644 index 0000000..7ac5845 --- /dev/null +++ b/test/tests/pr29695-2.c @@ -0,0 +1,80 @@ +/* PR middle-end/29695 */ + +extern void abort (void); + +int a = 128; +unsigned char b = 128; +long long c = 0x80000000LL; +unsigned int d = 0x8000; + +int +f1 (void) +{ + return (a & 0x80) ? 0x80 : 0; +} + +int +f2 (void) +{ + return (b & 0x80) ? 0x80 : 0; +} + +int +f3 (void) +{ + return (b & 0x80) ? 0x380 : 0; +} + +int +f4 (void) +{ + return (b & 0x80) ? -128 : 0; +} + +long long +f5 (void) +{ + return (c & 0x80000000) ? 0x80000000LL : 0LL; +} + +long long +f6 (void) +{ + return (d & 0x8000) ? 0x80000000LL : 0LL; +} + +long long +f7 (void) +{ + return (d & 0x8000) ? 0x380000000LL : 0LL; +} + +long long +f8 (void) +{ + return (d & 0x8000) ? -2147483648LL : 0LL; +} + +int +main (void) +{ + if ((char) 128 != -128 || (int) 0x8000 != -32768) + return 0; + if (f1 () != 128) + abort (); + if (f2 () != 128) + abort (); + if (f3 () != 896) + abort (); + if (f4 () != -128) + abort (); + if (f5 () != 0x80000000LL) + abort (); + if (f6 () != 0x80000000LL) + abort (); + if (f7 () != 0x380000000LL) + abort (); + if (f8 () != -2147483648LL) + abort (); + return 0; +} diff --git a/test/tests/pr29797-1.c b/test/tests/pr29797-1.c new file mode 100644 index 0000000..9bcc2a9 --- /dev/null +++ b/test/tests/pr29797-1.c @@ -0,0 +1,14 @@ +extern void abort(void); + +unsigned int bar(void) { return 32768; } + +int main() +{ + unsigned int nStyle = bar (); + if (nStyle & 32768) + nStyle |= 65536; + if (nStyle != (32768 | 65536)) + abort (); + return 0; +} + diff --git a/test/tests/pr29797-2.c b/test/tests/pr29797-2.c new file mode 100644 index 0000000..9313bf4 --- /dev/null +++ b/test/tests/pr29797-2.c @@ -0,0 +1,14 @@ +extern void abort(void); + +unsigned long bar(void) { return 32768; } + +int main() +{ + unsigned long nStyle = bar (); + if (nStyle & 32768) + nStyle |= 65536; + if (nStyle != (32768 | 65536)) + abort (); + return 0; +} + diff --git a/test/tests/pr29798.c b/test/tests/pr29798.c new file mode 100644 index 0000000..f7b90da --- /dev/null +++ b/test/tests/pr29798.c @@ -0,0 +1,26 @@ +extern void abort (); + +int +main () +{ + int i; + double oldrho; + double beta = 0.0; + double work = 1.0; + for (i = 1; i <= 2; i++) + { + double rho = work * work; + if (i != 1) + beta = rho / oldrho; + if (beta == 1.0) + abort (); + + /* All targets even remotely likely to ever get supported + use at least an even base, so there will never be any + floating-point rounding. All computation in this test + case is exact for even bases. */ + work /= 2.0; + oldrho = rho; + } + return 0; +} diff --git a/test/tests/pr30185.c b/test/tests/pr30185.c new file mode 100644 index 0000000..3e974ce --- /dev/null +++ b/test/tests/pr30185.c @@ -0,0 +1,28 @@ +/* PR target/30185 */ + +extern void abort (void); + +typedef struct S { char a; long long b; } S; + +S +foo (S x, S y) +{ + S z; + z.b = x.b / y.b; + return z; +} + +int +main (void) +{ + S a, b; + a.b = 32LL; + b.b = 4LL; + if (foo (a, b).b != 8LL) + abort (); + a.b = -8LL; + b.b = -2LL; + if (foo (a, b).b != 4LL) + abort (); + return 0; +} diff --git a/test/tests/pr30778.c b/test/tests/pr30778.c new file mode 100644 index 0000000..e83854f --- /dev/null +++ b/test/tests/pr30778.c @@ -0,0 +1,36 @@ +#include + +extern void *memset (void *, int, unsigned long); +extern void abort (void); + +struct reg_stat { + void *last_death; + void *last_set; + void *last_set_value; + int last_set_label; + char last_set_sign_bit_copies; + int last_set_mode : 8; + char last_set_invalid; + char sign_bit_copies; + long nonzero_bits; +}; + +static struct reg_stat *reg_stat; + +void __attribute__((noinline)) +init_reg_last (void) +{ + memset (reg_stat, 0, __builtin_offsetof (struct reg_stat, sign_bit_copies)); +} + +int main (void) +{ + struct reg_stat r; + + reg_stat = &r; + r.nonzero_bits = -1; + init_reg_last (); + if (r.nonzero_bits != -1) + abort (); + return 0; +} diff --git a/test/tests/pr31072.c b/test/tests/pr31072.c new file mode 100644 index 0000000..beb4b55 --- /dev/null +++ b/test/tests/pr31072.c @@ -0,0 +1,10 @@ +extern volatile int ReadyFlag_NotProperlyInitialized; + +volatile int ReadyFlag_NotProperlyInitialized=1; + +int main(void) +{ + if (ReadyFlag_NotProperlyInitialized != 1) + __builtin_abort (); + return 0; +} diff --git a/test/tests/pr31136.c b/test/tests/pr31136.c new file mode 100644 index 0000000..66c202c --- /dev/null +++ b/test/tests/pr31136.c @@ -0,0 +1,17 @@ +extern void abort (void); + +struct S { + unsigned b4:4; + unsigned b6:6; +} s; + +int main() +{ + s.b6 = 31; + s.b4 = s.b6; + s.b6 = s.b4; + if (s.b6 != 15) + abort (); + return 0; +} + diff --git a/test/tests/pr31169.c b/test/tests/pr31169.c new file mode 100644 index 0000000..447dd45 --- /dev/null +++ b/test/tests/pr31169.c @@ -0,0 +1,51 @@ +extern void abort(); + +#define HOST_WIDE_INT long +#define HOST_BITS_PER_WIDE_INT (sizeof(long)*8) + +struct tree_type +{ + unsigned int precision : 9; +}; + +int +sign_bit_p (struct tree_type *t, HOST_WIDE_INT val_hi, unsigned HOST_WIDE_INT val_lo) +{ + unsigned HOST_WIDE_INT mask_lo, lo; + HOST_WIDE_INT mask_hi, hi; + int width = t->precision; + + if (width > HOST_BITS_PER_WIDE_INT) + { + hi = (unsigned HOST_WIDE_INT) 1 << (width - HOST_BITS_PER_WIDE_INT - 1); + lo = 0; + + mask_hi = ((unsigned HOST_WIDE_INT) -1 + >> (2 * HOST_BITS_PER_WIDE_INT - width)); + mask_lo = -1; + } + else + { + hi = 0; + lo = (unsigned HOST_WIDE_INT) 1 << (width - 1); + + mask_hi = 0; + mask_lo = ((unsigned HOST_WIDE_INT) -1 + >> (HOST_BITS_PER_WIDE_INT - width)); + } + + if ((val_hi & mask_hi) == hi + && (val_lo & mask_lo) == lo) + return 1; + + return 0; +} + +int main() +{ + struct tree_type t; + t.precision = 1; + if (!sign_bit_p (&t, 0, -1)) + abort (); + return 0; +} diff --git a/test/tests/pr31448-2.c b/test/tests/pr31448-2.c new file mode 100644 index 0000000..2efec6f --- /dev/null +++ b/test/tests/pr31448-2.c @@ -0,0 +1,38 @@ +// constreg declared twice + +/* PR middle-end/31448, this used to ICE during expand because + reduce_to_bit_field_precision was not ready to handle constants. */ + +typedef struct _st { + long int iIndex : 8; + long int iIndex1 : 8; +} st; +st *next; +void g(void) +{ + st *next = 0; + int nIndx; + const static int constreg[] = { 0,}; + nIndx = 0; + next->iIndex = constreg[nIndx]; +} +void f(void) +{ + int nIndx; + const static long int constreg[] = { 0xFEFE,}; + nIndx = 0; + next->iIndex = constreg[nIndx]; + next->iIndex1 = constreg[nIndx]; +} +int main(void) +{ + st a; + next = &a; + f(); + if (next->iIndex != 0xFFFE) + __builtin_abort (); + if (next->iIndex1 != 0xFFFE) + __builtin_abort (); + return 0; +} + diff --git a/test/tests/pr31448.c b/test/tests/pr31448.c new file mode 100644 index 0000000..55a2a74 --- /dev/null +++ b/test/tests/pr31448.c @@ -0,0 +1,38 @@ +// constreg declared twice + +/* PR middle-end/31448, this used to ICE during expand because + reduce_to_bit_field_precision was not ready to handle constants. */ + +typedef struct _st { + int iIndex : 8; + int iIndex1 : 8; +} st; +st *next; +void g(void) +{ + st *next = 0; + int nIndx; + const static int constreg[] = { 0,}; + nIndx = 0; + next->iIndex = constreg[nIndx]; +} +void f(void) +{ + int nIndx; + const static int constreg[] = { 0xFEFE,}; + nIndx = 0; + next->iIndex = constreg[nIndx]; + next->iIndex1 = constreg[nIndx]; +} +int main(void) +{ + st a; + next = &a; + f(); + if (next->iIndex != 0xFFFE) + __builtin_abort (); + if (next->iIndex1 != 0xFFFE) + __builtin_abort (); + return 0; +} + diff --git a/test/tests/pr31605.c b/test/tests/pr31605.c new file mode 100644 index 0000000..12a57ac --- /dev/null +++ b/test/tests/pr31605.c @@ -0,0 +1,13 @@ +void put_field (unsigned int start, unsigned int len) +{ + int cur_bitshift = ((start + len) % 8) - 8; + if (cur_bitshift > -8) + exit (0); +} + +int +main () +{ + put_field (0, 1); + abort (); +} diff --git a/test/tests/pr32500.c b/test/tests/pr32500.c new file mode 100644 index 0000000..dae06ea --- /dev/null +++ b/test/tests/pr32500.c @@ -0,0 +1,26 @@ +extern void abort(void); +extern void exit(int); +void foo(int) __attribute__((noinline)); +void bar(void) __attribute__((noinline)); + +/* Make sure foo is not inlined or considered pure/const. */ +int x; +void foo(int i) { x = i; } +void bar(void) { exit(0); } + +int +main(int argc, char *argv[]) +{ + int i; + int numbers[4] = { 0xdead, 0xbeef, 0x1337, 0x4242 }; + + for (i = 1; i <= 12; i++) { + if (i <= 4) + foo(numbers[i]); + else if (i >= 7 && i <= 9) + bar(); + } + + abort(); +} + diff --git a/test/tests/pr33142.c b/test/tests/pr33142.c new file mode 100644 index 0000000..7bfc5b5 --- /dev/null +++ b/test/tests/pr33142.c @@ -0,0 +1,16 @@ +int abs(int j); +extern void abort(void); + +__attribute__((noinline)) int lisp_atan2(long dy, long dx) { + if (dx <= 0) + if (dy > 0) + return abs(dx) <= abs(dy); + return 0; +} + +int main() { + volatile long dy = 63, dx = -77; + if (lisp_atan2(dy, dx)) + abort(); + return 0; +} diff --git a/test/tests/pr33669.c b/test/tests/pr33669.c new file mode 100644 index 0000000..69d8625 --- /dev/null +++ b/test/tests/pr33669.c @@ -0,0 +1,40 @@ +extern void abort (void); + +typedef struct foo_t +{ + unsigned int blksz; + unsigned int bf_cnt; +} foo_t; + +#define _RNDUP(x, unit) ((((x) + (unit) - 1) / (unit)) * (unit)) +#define _RNDDOWN(x, unit) ((x) - ((x)%(unit))) + +long long +foo (foo_t *const pxp, long long offset, unsigned int extent) +{ + long long blkoffset = _RNDDOWN(offset, (long long )pxp->blksz); + unsigned int diff = (unsigned int)(offset - blkoffset); + unsigned int blkextent = _RNDUP(diff + extent, pxp->blksz); + + if (pxp->blksz < blkextent) + return -1LL; + + if (pxp->bf_cnt > pxp->blksz) + pxp->bf_cnt = pxp->blksz; + + return blkoffset; +} + +int +main () +{ + foo_t x; + long long xx; + + x.blksz = 8192; + x.bf_cnt = 0; + xx = foo (&x, 0, 4096); + if (xx != 0LL) + abort (); + return 0; +} diff --git a/test/tests/pr7284-1.c b/test/tests/pr7284-1.c new file mode 100644 index 0000000..13906a2 --- /dev/null +++ b/test/tests/pr7284-1.c @@ -0,0 +1,24 @@ +/* Signed left-shift is implementation-defined in C89 (and see + DR#081), not undefined. Bug 7284 from Al Grant (AlGrant at + myrealbox.com). */ + +/* { dg-options "-std=c89" } */ + +extern void abort (void); +extern void exit (int); + +int +f (int n) +{ + return (n << 8) / (1 << 7); +} + +volatile int x = 128; + +int +main (void) +{ + if (f(x) != -256) + abort (); + exit (0); +} diff --git a/test/tests/ptr-arith-1.c b/test/tests/ptr-arith-1.c new file mode 100644 index 0000000..46162b8 --- /dev/null +++ b/test/tests/ptr-arith-1.c @@ -0,0 +1,14 @@ +char * +f (char *s, unsigned int i) +{ + return &s[i + 3 - 1]; +} + +main () +{ + char *str = "abcdefghijkl"; + char *x2 = f (str, 12); + if (str + 14 != x2) + abort (); + exit (0); +} diff --git a/test/tests/pure-1.c b/test/tests/pure-1.c new file mode 100644 index 0000000..174477e --- /dev/null +++ b/test/tests/pure-1.c @@ -0,0 +1,91 @@ + +/* Origin: Kaveh Ghazi 2002-05-27. */ + +/* Use a different function for each test so the link failures + indicate which one is broken. */ +extern void link_error0 (void); +extern void link_error1 (void); +extern void link_error2 (void); +extern void link_error3 (void); +extern void link_error4 (void); +extern void link_error5 (void); +extern void link_error6 (void); +extern void link_error7 (void); + +extern int i; + +extern int func0 (int) __attribute__ ((__pure__)); +extern int func1 (int) __attribute__ ((__const__)); + +/* GCC should automatically detect attributes for these functions. + At -O3 They'll be inlined, but that's ok. */ +static int func2 (int a) { return i + a; } /* pure */ +static int func3 (int a) { return a * 3; } /* const */ +static int func4 (int a) { return func0(a) + a; } /* pure */ +static int func5 (int a) { return a + func1(a); } /* const */ +static int func6 (int a) { return func2(a) + a; } /* pure */ +static int func7 (int a) { return a + func3(a); } /* const */ + +int main () +{ + int i[10], r; + + i[0] = 0; + r = func0(0); + if (i[0]) + link_error0(); + + i[1] = 0; + r = func1(0); + if (i[1]) + link_error1(); + + i[2] = 0; + r = func2(0); + if (i[2]) + link_error2(); + + i[3] = 0; + r = func3(0); + if (i[3]) + link_error3(); + + i[4] = 0; + r = func4(0); + if (i[4]) + link_error4(); + + i[5] = 0; + r = func5(0); + if (i[5]) + link_error5(); + + i[6] = 0; + r = func6(0); + if (i[6]) + link_error6(); + + i[7] = 0; + r = func7(0); + if (i[7]) + link_error7(); + + return r; +} + +int func0 (int a) { return a - i; } /* pure */ +int func1 (int a) { return a - a; } /* const */ + +int i = 2; + +#ifndef __OPTIMIZE__ +/* Avoid link failures when not optimizing. */ +void link_error0() {} +void link_error1() {} +void link_error2() {} +void link_error3() {} +void link_error4() {} +void link_error5() {} +void link_error6() {} +void link_error7() {} +#endif /* ! __OPTIMIZE__ */ diff --git a/test/tests/regstack-1.c b/test/tests/regstack-1.c new file mode 100644 index 0000000..51fb858 --- /dev/null +++ b/test/tests/regstack-1.c @@ -0,0 +1,26 @@ +long double C = 5; +long double U = 1; +long double Y2 = 11; +long double Y1 = 17; +long double X, Y, Z, T, R, S; +main () +{ + X = (C + U) * Y2; + Y = C - U - U; + Z = C + U + U; + T = (C - U) * Y1; + X = X - (Z + U); + R = Y * Y1; + S = Z * Y2; + T = T - Y; + Y = (U - Y) + R; + Z = S - (Z + U + U); + R = (Y2 + U) * Y1; + Y1 = Y2 * Y1; + R = R - Y2; + Y1 = Y1 - 0.5L; + if (Z != 68. || Y != 49. || X != 58. || Y1 != 186.5 || R != 193. || S != 77. + || T != 65. || Y2 != 11.) + abort (); + exit (0); +} diff --git a/test/tests/restrict-1.c b/test/tests/restrict-1.c new file mode 100644 index 0000000..3c5696c --- /dev/null +++ b/test/tests/restrict-1.c @@ -0,0 +1,30 @@ +/* PR rtl-optimization/16536 + Origin: Jeremy Denise + Reduced: Wolfgang Bangerth + Volker Reichelt */ + +extern void abort (); + +typedef struct +{ + int i, dummy; +} A; + +inline A foo (const A* p, const A* q) +{ + return (A){p->i+q->i}; +} + +void bar (A* __restrict__ p) +{ + *p=foo(p,p); + if (p->i!=2) + abort(); +} + +int main () +{ + A a={1}; + bar(&a); + return 0; +} diff --git a/test/tests/shiftdi.c b/test/tests/shiftdi.c new file mode 100644 index 0000000..7717e9c --- /dev/null +++ b/test/tests/shiftdi.c @@ -0,0 +1,20 @@ +/* Failed on sparc with -mv8plus because sparc.c:set_extends() thought + erroneously that SImode ASHIFT chops the upper bits, it does not. */ + +typedef unsigned long long uint64; + +void g(uint64 x, int y, int z, uint64 *p) +{ + unsigned w = ((x >> y) & 0xffffULL) << (z & 0xf); + *p |= (w & 0xffffULL) << z; +} + +int main(void) +{ + uint64 a = 0; + g(0xdeadbeefULL, 0, 0, &a); + return (a == 0xbeef) ? 0 : 1; +} + + + diff --git a/test/tests/shiftopt-1.c b/test/tests/shiftopt-1.c new file mode 100644 index 0000000..fa9517a --- /dev/null +++ b/test/tests/shiftopt-1.c @@ -0,0 +1,73 @@ +/* Copyright (C) 2002 Free Software Foundation + + Check that constant folding of shift operations is working. + + Roger Sayle, 10th October 2002. */ + +extern void abort (void); +extern void link_error (void); + +void +utest (unsigned int x) +{ + if (x >> 0 != x) + link_error (); + + if (x << 0 != x) + link_error (); + + if (0 << x != 0) + link_error (); + + if (0 >> x != 0) + link_error (); + + if (-1 >> x != -1) + link_error (); + + if (~0 >> x != ~0) + link_error (); +} + +void +stest (int x) +{ + if (x >> 0 != x) + link_error (); + + if (x << 0 != x) + link_error (); + + if (0 << x != 0) + link_error (); + + if (0 >> x != 0) + link_error (); + + if (-1 >> x != -1) + link_error (); + + if (~0 >> x != ~0) + link_error (); +} + +int +main () +{ + utest(9); + utest(0); + + stest(9); + stest(0); + + return 0; +} + +#ifndef __OPTIMIZE__ +void +link_error () +{ + abort (); +} +#endif + diff --git a/test/tests/stdarg-1.c b/test/tests/stdarg-1.c new file mode 100644 index 0000000..0ff9759 --- /dev/null +++ b/test/tests/stdarg-1.c @@ -0,0 +1,156 @@ +#include + +extern void abort (void); + +int foo_arg, bar_arg; +long x; +double d; +va_list gap; +va_list *pap; + +void +foo (int v, va_list ap) +{ + switch (v) + { + case 5: foo_arg = va_arg (ap, int); break; + default: abort (); + } +} + +void +bar (int v) +{ + if (v == 0x4006) + { + if (va_arg (gap, double) != 17.0 + || va_arg (gap, long) != 129L) + abort (); + } + else if (v == 0x4008) + { + if (va_arg (*pap, long long) != 14LL + || va_arg (*pap, long double) != 131.0L + || va_arg (*pap, int) != 17) + abort (); + } + bar_arg = v; +} + +void +f0 (int i, ...) +{ +} + +void +f1 (int i, ...) +{ + va_list ap; + va_start (ap, i); + va_end (ap); +} + +void +f2 (int i, ...) +{ + va_list ap; + va_start (ap, i); + bar (d); + x = va_arg (ap, long); + bar (x); + va_end (ap); +} + +void +f3 (int i, ...) +{ + va_list ap; + va_start (ap, i); + d = va_arg (ap, double); + va_end (ap); +} + +void +f4 (int i, ...) +{ + va_list ap; + va_start (ap, i); + x = va_arg (ap, double); + foo (i, ap); + va_end (ap); +} + +void +f5 (int i, ...) +{ + va_list ap; + va_start (ap, i); + va_copy (gap, ap); + bar (i); + va_end (ap); + va_end (gap); +} + +void +f6 (int i, ...) +{ + va_list ap; + va_start (ap, i); + bar (d); + va_arg (ap, long); + va_arg (ap, long); + x = va_arg (ap, long); + bar (x); + va_end (ap); +} + +void +f7 (int i, ...) +{ + va_list ap; + va_start (ap, i); + pap = ≈ + bar (i); + va_end (ap); +} + +void +f8 (int i, ...) +{ + va_list ap; + va_start (ap, i); + pap = ≈ + bar (i); + d = va_arg (ap, double); + va_end (ap); +} + +int +main (void) +{ + f0 (1); + f1 (2); + d = 31.0; + f2 (3, 28L); + if (bar_arg != 28 || x != 28) + abort (); + f3 (4, 131.0); + if (d != 131.0) + abort (); + f4 (5, 16.0, 128); + if (x != 16 || foo_arg != 128) + abort (); + f5 (0x4006, 17.0, 129L); + if (bar_arg != 0x4006) + abort (); + f6 (7, 12L, 14L, -31L); + if (bar_arg != -31) + abort (); + f7 (0x4008, 14LL, 131.0L, 17, 26.0); + if (bar_arg != 0x4008) + abort (); + f8 (0x4008, 14LL, 131.0L, 17, 27.0); + if (bar_arg != 0x4008 || d != 27.0) + abort (); + return 0; +} diff --git a/test/tests/stdarg-2.c b/test/tests/stdarg-2.c new file mode 100644 index 0000000..40246f9 --- /dev/null +++ b/test/tests/stdarg-2.c @@ -0,0 +1,180 @@ +#include + +extern void abort (void); + +int foo_arg, bar_arg; +long x; +double d; +va_list gap; + +void +foo (int v, va_list ap) +{ + switch (v) + { + case 5: + foo_arg = va_arg (ap, int); + foo_arg += va_arg (ap, double); + foo_arg += va_arg (ap, long long); + break; + case 8: + foo_arg = va_arg (ap, long long); + foo_arg += va_arg (ap, double); + break; + case 11: + foo_arg = va_arg (ap, int); + foo_arg += va_arg (ap, long double); + break; + default: + abort (); + } +} + +void +bar (int v) +{ + if (v == 0x4002) + { + if (va_arg (gap, int) != 13 || va_arg (gap, double) != -14.0) + abort (); + } + bar_arg = v; +} + +void +f1 (int i, ...) +{ + va_start (gap, i); + x = va_arg (gap, long); + va_end (gap); +} + +void +f2 (int i, ...) +{ + va_start (gap, i); + bar (i); + va_end (gap); +} + +void +f3 (int i, ...) +{ + va_list aps[10]; + va_start (aps[4], i); + x = va_arg (aps[4], long); + va_end (aps[4]); +} + +void +f4 (int i, ...) +{ + va_list aps[10]; + va_start (aps[4], i); + bar (i); + va_end (aps[4]); +} + +void +f5 (int i, ...) +{ + va_list aps[10]; + va_start (aps[4], i); + foo (i, aps[4]); + va_end (aps[4]); +} + +struct A { int i; va_list g; va_list h[2]; }; + +void +f6 (int i, ...) +{ + struct A a; + va_start (a.g, i); + x = va_arg (a.g, long); + va_end (a.g); +} + +void +f7 (int i, ...) +{ + struct A a; + va_start (a.g, i); + bar (i); + va_end (a.g); +} + +void +f8 (int i, ...) +{ + struct A a; + va_start (a.g, i); + foo (i, a.g); + va_end (a.g); +} + +void +f10 (int i, ...) +{ + struct A a; + va_start (a.h[1], i); + x = va_arg (a.h[1], long); + va_end (a.h[1]); +} + +void +f11 (int i, ...) +{ + struct A a; + va_start (a.h[1], i); + bar (i); + va_end (a.h[1]); +} + +void +f12 (int i, ...) +{ + struct A a; + va_start (a.h[1], i); + foo (i, a.h[1]); + va_end (a.h[1]); +} + +int +main (void) +{ + f1 (1, 79L); + if (x != 79L) + abort (); + f2 (0x4002, 13, -14.0); + if (bar_arg != 0x4002) + abort (); + f3 (3, 2031L); + if (x != 2031) + abort (); + f4 (4, 18); + if (bar_arg != 4) + abort (); + f5 (5, 1, 19.0, 18LL); + if (foo_arg != 38) + abort (); + f6 (6, 18L); + if (x != 18L) + abort (); + f7 (7); + if (bar_arg != 7) + abort (); + f8 (8, 2031LL, 13.0); + if (foo_arg != 2044) + abort (); + f10 (9, 180L); + if (x != 180L) + abort (); + f11 (10); + if (bar_arg != 10) + abort (); + f12 (11, 2030, 12.0L); + if (foo_arg != 2042) + abort (); + return 0; +} diff --git a/test/tests/stdarg-3.c b/test/tests/stdarg-3.c new file mode 100644 index 0000000..ccc79e0 --- /dev/null +++ b/test/tests/stdarg-3.c @@ -0,0 +1,166 @@ +#include + +extern void abort (void); + +int foo_arg, bar_arg; +long x; +double d; +va_list gap; +struct S1 { int i; double d; int j; double e; } s1; +struct S2 { double d; long i; } s2; +int y; + +void +bar (int v) +{ + bar_arg = v; +} + +void +f1 (int i, ...) +{ + va_list ap; + va_start (ap, i); + while (i-- > 0) + x = va_arg (ap, long); + va_end (ap); +} + +void +f2 (int i, ...) +{ + va_list ap; + va_start (ap, i); + while (i-- > 0) + d = va_arg (ap, double); + va_end (ap); +} + +void +f3 (int i, ...) +{ + va_list ap; + int j = i; + while (j-- > 0) + { + va_start (ap, i); + x = va_arg (ap, long); + va_end (ap); + bar (x); + } +} + +void +f4 (int i, ...) +{ + va_list ap; + int j = i; + while (j-- > 0) + { + va_start (ap, i); + d = va_arg (ap, double); + va_end (ap); + bar (d + 4.0); + } +} + +void +f5 (int i, ...) +{ + va_list ap; + va_start (ap, i); + while (i-- > 0) + s1 = va_arg (ap, struct S1); + va_end (ap); +} + +void +f6 (int i, ...) +{ + va_list ap; + va_start (ap, i); + while (i-- > 0) + s2 = va_arg (ap, struct S2); + va_end (ap); +} + +void +f7 (int i, ...) +{ + va_list ap; + int j = i; + while (j-- > 0) + { + va_start (ap, i); + s1 = va_arg (ap, struct S1); + va_end (ap); + bar (s1.i); + } +} + +void +f8 (int i, ...) +{ + va_list ap; + int j = i; + while (j-- > 0) + { + va_start (ap, i); + s2 = va_arg (ap, struct S2); + y = va_arg (ap, int); + va_end (ap); + bar (s2.i); + } +} + +int +main (void) +{ + struct S1 a1, a3; + struct S2 a2, a4; + + f1 (7, 1L, 2L, 3L, 5L, 7L, 9L, 11L, 13L); + if (x != 11L) + abort (); + f2 (6, 1.0, 2.0, 4.0, 8.0, 16.0, 32.0, 64.0); + if (d != 32.0) + abort (); + f3 (2, 1L, 3L); + if (bar_arg != 1L || x != 1L) + abort (); + f4 (2, 17.0, 19.0); + if (bar_arg != 21 || d != 17.0) + abort (); + a1.i = 131; + a1.j = 251; + a1.d = 15.0; + a1.e = 191.0; + a3 = a1; + a3.j = 254; + a3.e = 178.0; + f5 (2, a1, a3, a1); + if (s1.i != 131 || s1.j != 254 || s1.d != 15.0 || s1.e != 178.0) + abort (); + f5 (3, a1, a3, a1); + if (s1.i != 131 || s1.j != 251 || s1.d != 15.0 || s1.e != 191.0) + abort (); + a2.i = 138; + a2.d = 16.0; + a4.i = 257; + a4.d = 176.0; + f6 (2, a2, a4, a2); + if (s2.i != 257 || s2.d != 176.0) + abort (); + f6 (3, a2, a4, a2); + if (s2.i != 138 || s2.d != 16.0) + abort (); + f7 (2, a3, a1, a1); + if (s1.i != 131 || s1.j != 254 || s1.d != 15.0 || s1.e != 178.0) + abort (); + if (bar_arg != 131) + abort (); + f8 (3, a4, a2, a2); + if (s2.i != 257 || s2.d != 176.0) + abort (); + return 0; +} diff --git a/test/tests/stdarg-4.c b/test/tests/stdarg-4.c new file mode 100644 index 0000000..f820bce --- /dev/null +++ b/test/tests/stdarg-4.c @@ -0,0 +1,137 @@ +#include + +extern void abort (void); +long x, y; + +inline void __attribute__((always_inline)) +f1i (va_list ap) +{ + x = va_arg (ap, double); + x += va_arg (ap, long); + x += va_arg (ap, double); +} + +void +f1 (int i, ...) +{ + va_list ap; + va_start (ap, i); + f1i (ap); + va_end (ap); +} + +inline void __attribute__((always_inline)) +f2i (va_list ap) +{ + y = va_arg (ap, int); + y += va_arg (ap, long); + y += va_arg (ap, double); + f1i (ap); +} + +void +f2 (int i, ...) +{ + va_list ap; + va_start (ap, i); + f2i (ap); + va_end (ap); +} + +long +f3h (int i, long arg0, long arg1, long arg2, long arg3) +{ + return i + arg0 + arg1 + arg2 + arg3; +} + +long +f3 (int i, ...) +{ + long t, arg0, arg1, arg2, arg3; + va_list ap; + + va_start (ap, i); + switch (i) + { + case 0: + t = f3h (i, 0, 0, 0, 0); + break; + case 1: + arg0 = va_arg (ap, long); + t = f3h (i, arg0, 0, 0, 0); + break; + case 2: + arg0 = va_arg (ap, long); + arg1 = va_arg (ap, long); + t = f3h (i, arg0, arg1, 0, 0); + break; + case 3: + arg0 = va_arg (ap, long); + arg1 = va_arg (ap, long); + arg2 = va_arg (ap, long); + t = f3h (i, arg0, arg1, arg2, 0); + break; + case 4: + arg0 = va_arg (ap, long); + arg1 = va_arg (ap, long); + arg2 = va_arg (ap, long); + arg3 = va_arg (ap, long); + t = f3h (i, arg0, arg1, arg2, arg3); + break; + default: + abort (); + } + va_end (ap); + + return t; +} + +void +f4 (int i, ...) +{ + va_list ap; + + va_start (ap, i); + switch (i) + { + case 4: + y = va_arg (ap, double); + break; + case 5: + y = va_arg (ap, double); + y += va_arg (ap, double); + break; + default: + abort (); + } + f1i (ap); + va_end (ap); +} + +int +main (void) +{ + f1 (3, 16.0, 128L, 32.0); + if (x != 176L) + abort (); + f2 (6, 5, 7L, 18.0, 19.0, 17L, 64.0); + if (x != 100L || y != 30L) + abort (); + if (f3 (0) != 0) + abort (); + if (f3 (1, 18L) != 19L) + abort (); + if (f3 (2, 18L, 100L) != 120L) + abort (); + if (f3 (3, 18L, 100L, 300L) != 421L) + abort (); + if (f3 (4, 18L, 71L, 64L, 86L) != 243L) + abort (); + f4 (4, 6.0, 9.0, 16L, 18.0); + if (x != 43L || y != 6L) + abort (); + f4 (5, 7.0, 21.0, 1.0, 17L, 126.0); + if (x != 144L || y != 28L) + abort (); + return 0; +} diff --git a/test/tests/strcmp-1.c b/test/tests/strcmp-1.c new file mode 100644 index 0000000..79999af --- /dev/null +++ b/test/tests/strcmp-1.c @@ -0,0 +1,131 @@ +/* Copyright (C) 2002 Free Software Foundation. + + Test strcmp with various combinations of pointer alignments and lengths to + make sure any optimizations in the library are correct. + + Written by Michael Meissner, March 9, 2002. */ + +#include +#include + +#ifndef MAX_OFFSET +#define MAX_OFFSET (sizeof (long long)) +#endif + +#ifndef MAX_TEST +#define MAX_TEST (8 * sizeof (long long)) +#endif + +#ifndef MAX_EXTRA +#define MAX_EXTRA (sizeof (long long)) +#endif + +#define MAX_LENGTH (MAX_OFFSET + MAX_TEST + MAX_EXTRA + 2) + +static union { + unsigned char buf[MAX_LENGTH]; + long long align_int; + long double align_fp; +} u1, u2; + +void +test (const unsigned char *s1, const unsigned char *s2, int expected) +{ + int value = strcmp ((char *) s1, (char *) s2); + + if (expected < 0 && value >= 0) + abort (); + else if (expected == 0 && value != 0) + abort (); + else if (expected > 0 && value <= 0) + abort (); +} + +main () +{ + size_t off1, off2, len, i; + unsigned char *buf1, *buf2; + unsigned char *mod1, *mod2; + unsigned char *p1, *p2; + + for (off1 = 0; off1 < MAX_OFFSET; off1++) + for (off2 = 0; off2 < MAX_OFFSET; off2++) + for (len = 0; len < MAX_TEST; len++) + { + p1 = u1.buf; + for (i = 0; i < off1; i++) + *p1++ = '\0'; + + buf1 = p1; + for (i = 0; i < len; i++) + *p1++ = 'a'; + + mod1 = p1; + for (i = 0; i < MAX_EXTRA+2; i++) + *p1++ = 'x'; + + p2 = u2.buf; + for (i = 0; i < off2; i++) + *p2++ = '\0'; + + buf2 = p2; + for (i = 0; i < len; i++) + *p2++ = 'a'; + + mod2 = p2; + for (i = 0; i < MAX_EXTRA+2; i++) + *p2++ = 'x'; + + mod1[0] = '\0'; + mod2[0] = '\0'; + test (buf1, buf2, 0); + + mod1[0] = 'a'; + mod1[1] = '\0'; + mod2[0] = '\0'; + test (buf1, buf2, +1); + + mod1[0] = '\0'; + mod2[0] = 'a'; + mod2[1] = '\0'; + test (buf1, buf2, -1); + + mod1[0] = 'b'; + mod1[1] = '\0'; + mod2[0] = 'c'; + mod2[1] = '\0'; + test (buf1, buf2, -1); + + mod1[0] = 'c'; + mod1[1] = '\0'; + mod2[0] = 'b'; + mod2[1] = '\0'; + test (buf1, buf2, +1); + + mod1[0] = 'b'; + mod1[1] = '\0'; + mod2[0] = (unsigned char)'\251'; + mod2[1] = '\0'; + test (buf1, buf2, -1); + + mod1[0] = (unsigned char)'\251'; + mod1[1] = '\0'; + mod2[0] = 'b'; + mod2[1] = '\0'; + test (buf1, buf2, +1); + + mod1[0] = (unsigned char)'\251'; + mod1[1] = '\0'; + mod2[0] = (unsigned char)'\252'; + mod2[1] = '\0'; + test (buf1, buf2, -1); + + mod1[0] = (unsigned char)'\252'; + mod1[1] = '\0'; + mod2[0] = (unsigned char)'\251'; + mod2[1] = '\0'; + test (buf1, buf2, +1); + } + + exit (0); +} diff --git a/test/tests/strcpy-1.c b/test/tests/strcpy-1.c new file mode 100644 index 0000000..9484e95 --- /dev/null +++ b/test/tests/strcpy-1.c @@ -0,0 +1,75 @@ +/* Copyright (C) 2002 Free Software Foundation. + + Test strcpy with various combinations of pointer alignments and lengths to + make sure any optimizations in the library are correct. */ + +#include + +#ifndef MAX_OFFSET +#define MAX_OFFSET (sizeof (long long)) +#endif + +#ifndef MAX_COPY +#define MAX_COPY (10 * sizeof (long long)) +#endif + +#ifndef MAX_EXTRA +#define MAX_EXTRA (sizeof (long long)) +#endif + +#define MAX_LENGTH (MAX_OFFSET + MAX_COPY + 1 + MAX_EXTRA) + +/* Use a sequence length that is not divisible by two, to make it more + likely to detect when words are mixed up. */ +#define SEQUENCE_LENGTH 31 + +static union { + char buf[MAX_LENGTH]; + long long align_int; + long double align_fp; +} u1, u2; + +main () +{ + int off1, off2, len, i; + char *p, *q, c; + + for (off1 = 0; off1 < MAX_OFFSET; off1++) + for (off2 = 0; off2 < MAX_OFFSET; off2++) + for (len = 1; len < MAX_COPY; len++) + { + for (i = 0, c = 'A'; i < MAX_LENGTH; i++, c++) + { + u1.buf[i] = 'a'; + if (c >= 'A' + SEQUENCE_LENGTH) + c = 'A'; + u2.buf[i] = c; + } + u2.buf[off2 + len] = '\0'; + + p = strcpy (u1.buf + off1, u2.buf + off2); + if (p != u1.buf + off1) + abort (); + + q = u1.buf; + for (i = 0; i < off1; i++, q++) + if (*q != 'a') + abort (); + + for (i = 0, c = 'A' + off2; i < len; i++, q++, c++) + { + if (c >= 'A' + SEQUENCE_LENGTH) + c = 'A'; + if (*q != c) + abort (); + } + + if (*q++ != '\0') + abort (); + for (i = 0; i < MAX_EXTRA; i++, q++) + if (*q != 'a') + abort (); + } + + exit (0); +} diff --git a/test/tests/strct-pack-1.c b/test/tests/strct-pack-1.c new file mode 100644 index 0000000..7b702f2 --- /dev/null +++ b/test/tests/strct-pack-1.c @@ -0,0 +1,25 @@ +typedef struct +{ + short s __attribute__ ((aligned(2), packed)); + double d __attribute__ ((aligned(2), packed)); +} TRIAL; + +int +check (TRIAL *t) +{ + if (t->s != 1 || t->d != 16.0) + return 1; + return 0; +} + +main () +{ + TRIAL trial; + + trial.s = 1; + trial.d = 16.0; + + if (check (&trial) != 0) + abort (); + exit (0); +} diff --git a/test/tests/strct-pack-2.c b/test/tests/strct-pack-2.c new file mode 100644 index 0000000..be76c76 --- /dev/null +++ b/test/tests/strct-pack-2.c @@ -0,0 +1,13 @@ +typedef struct +{ + short a __attribute__ ((aligned (2),packed)); + short *ap[2] __attribute__ ((aligned (2),packed)); +} A; + +main () +{ + short i, j = 1; + A a, *ap = &a; + ap->ap[j] = &i; + exit (0); +} diff --git a/test/tests/strct-pack-3.c b/test/tests/strct-pack-3.c new file mode 100644 index 0000000..8f91b04 --- /dev/null +++ b/test/tests/strct-pack-3.c @@ -0,0 +1,28 @@ +typedef struct +{ + short i __attribute__ ((aligned (2),packed)); + int f[2] __attribute__ ((aligned (2),packed)); +} A; + +f (ap) + A *ap; +{ + short i, j = 1; + + i = ap->f[1]; + i += ap->f[j]; + for (j = 0; j < 2; j++) + i += ap->f[j]; + + return i; +} + +main () +{ + A a; + a.f[0] = 100; + a.f[1] = 13; + if (f (&a) != 139) + abort (); + exit (0); +} diff --git a/test/tests/strct-pack-4.c b/test/tests/strct-pack-4.c new file mode 100644 index 0000000..56d315f --- /dev/null +++ b/test/tests/strct-pack-4.c @@ -0,0 +1,29 @@ +typedef struct +{ + unsigned char a __attribute__((packed)); + unsigned short b __attribute__((packed)); +} three_char_t; + +unsigned char +my_set_a (void) +{ + return 0xab; +} + +unsigned short +my_set_b (void) +{ + return 0x1234; +} + +main () +{ + three_char_t three_char; + + three_char.a = my_set_a (); + three_char.b = my_set_b (); + if (three_char.a != 0xab || three_char.b != 0x1234) + abort (); + exit (0); +} + diff --git a/test/tests/strct-stdarg-1.c b/test/tests/strct-stdarg-1.c new file mode 100644 index 0000000..508c954 --- /dev/null +++ b/test/tests/strct-stdarg-1.c @@ -0,0 +1,61 @@ +#include + +struct tiny +{ + char c; + char d; + char e; + char f; + char g; +}; + +f (int n, ...) +{ + struct tiny x; + int i; + + va_list ap; + va_start (ap,n); + for (i = 0; i < n; i++) + { + x = va_arg (ap,struct tiny); + if (x.c != i + 10) + abort(); + if (x.d != i + 20) + abort(); + if (x.e != i + 30) + abort(); + if (x.f != i + 40) + abort(); + if (x.g != i + 50) + abort(); + } + { + long x = va_arg (ap, long); + if (x != 123) + abort(); + } + va_end (ap); +} + +main () +{ + struct tiny x[3]; + x[0].c = 10; + x[1].c = 11; + x[2].c = 12; + x[0].d = 20; + x[1].d = 21; + x[2].d = 22; + x[0].e = 30; + x[1].e = 31; + x[2].e = 32; + x[0].f = 40; + x[1].f = 41; + x[2].f = 42; + x[0].g = 50; + x[1].g = 51; + x[2].g = 52; + f (3, x[0], x[1], x[2], (long) 123); + exit(0); +} diff --git a/test/tests/strct-varg-1.c b/test/tests/strct-varg-1.c new file mode 100644 index 0000000..ddd6f05 --- /dev/null +++ b/test/tests/strct-varg-1.c @@ -0,0 +1,42 @@ +#include + +struct s { int x, y; }; + +f (int attr, ...) +{ + struct s va_values; + va_list va; + int i; + + va_start (va, attr); + + if (attr != 2) + abort (); + + va_values = va_arg (va, struct s); + if (va_values.x != 0xaaaa || va_values.y != 0x5555) + abort (); + + attr = va_arg (va, int); + if (attr != 3) + abort (); + + va_values = va_arg (va, struct s); + if (va_values.x != 0xffff || va_values.y != 0x1111) + abort (); + + va_end (va); +} + +main () +{ + struct s a, b; + + a.x = 0xaaaa; + a.y = 0x5555; + b.x = 0xffff; + b.y = 0x1111; + + f (2, a, 3, b); + exit (0); +} diff --git a/test/tests/string-opt-17.c b/test/tests/string-opt-17.c new file mode 100644 index 0000000..76a351b --- /dev/null +++ b/test/tests/string-opt-17.c @@ -0,0 +1,45 @@ +/* Copyright (C) 2003 Free Software Foundation. + + Test strcpy optimizations don't evaluate side-effects twice. + + Written by Jakub Jelinek, June 23, 2003. */ + +typedef __SIZE_TYPE__ size_t; +extern char *strcpy (char *, const char *); +extern int memcmp (const void *, const void *, size_t); +extern void abort (void); +extern void exit (int); + +size_t +test1 (char *s, size_t i) +{ + strcpy (s, "foobarbaz" + i++); + return i; +} + +size_t +check2 (void) +{ + static size_t r = 5; + if (r != 5) + abort (); + return ++r; +} + +void +test2 (char *s) +{ + strcpy (s, "foobarbaz" + check2 ()); +} + +int +main (void) +{ + char buf[10]; + if (test1 (buf, 7) != 8 || memcmp (buf, "az", 3)) + abort (); + test2 (buf); + if (memcmp (buf, "baz", 4)) + abort (); + exit (0); +} diff --git a/test/tests/string-opt-18.c b/test/tests/string-opt-18.c new file mode 100644 index 0000000..610c4ca --- /dev/null +++ b/test/tests/string-opt-18.c @@ -0,0 +1,76 @@ +/* Copyright (C) 2003 Free Software Foundation. + + Test equal pointer optimizations don't break anything. + + Written by Roger Sayle, July 14, 2003. */ + +extern void abort (); +typedef __SIZE_TYPE__ size_t; + +extern void *memcpy(void*, const void*, size_t); +extern void *mempcpy(void*, const void*, size_t); +extern void *memmove(void*, const void*, size_t); +extern char *strcpy(char*, const char*); +extern int memcmp(const void*, const void*, size_t); +extern int strcmp(const char*, const char*); +extern int strncmp(const char*, const char*, size_t); + + +void test1 (void *ptr) +{ + if (memcpy(ptr,ptr,8) != ptr) + abort (); +} + +void test2 (char *ptr) +{ + if (mempcpy(ptr,ptr,8) != ptr+8) + abort (); +} + +void test3 (void *ptr) +{ + if (memmove(ptr,ptr,8) != ptr) + abort (); +} + +void test4 (char *ptr) +{ + if (strcpy(ptr,ptr) != ptr) + abort (); +} + +void test5 (void *ptr) +{ + if (memcmp(ptr,ptr,8) != 0) + abort (); +} + +void test6 (const char *ptr) +{ + if (strcmp(ptr,ptr) != 0) + abort (); +} + +void test7 (const char *ptr) +{ + if (strncmp(ptr,ptr,8) != 0) + abort (); +} + + +int main () +{ + char buf[10]; + + test1 (buf); + test2 (buf); + test3 (buf); + test4 (buf); + test5 (buf); + test6 (buf); + test7 (buf); + + return 0; +} + diff --git a/test/tests/string-opt-5.c b/test/tests/string-opt-5.c new file mode 100644 index 0000000..22e5330 --- /dev/null +++ b/test/tests/string-opt-5.c @@ -0,0 +1,106 @@ +/* Copyright (C) 2000 Free Software Foundation. + + Ensure builtin strlen, strcmp, strchr, strrchr and strncpy + perform correctly. + + Written by Jakub Jelinek, 11/7/2000. */ + +extern void abort (void); +extern __SIZE_TYPE__ strlen (const char *); +extern int strcmp (const char *, const char *); +extern char *strchr (const char *, int); +extern char *strrchr (const char *, int); +extern char *strncpy (char *, const char *, __SIZE_TYPE__); +extern void *memset (void *, int, __SIZE_TYPE__); +extern int memcmp (const void *, const void *, __SIZE_TYPE__); + +int x = 6; +int y = 1; +char *bar = "hi world"; +char buf [64]; + +int main() +{ + const char *const foo = "hello world"; + char dst [64]; + + if (strlen (bar) != 8) + abort (); + if (strlen (bar + (++x & 2)) != 6) + abort (); + if (x != 7) + abort (); + if (strlen (foo + (x++, 6)) != 5) + abort (); + if (x != 8) + abort (); + if (strlen (foo + (++x & 1)) != 10) + abort (); + if (x != 9) + abort (); + if (strcmp (foo + (x -= 6), "lo world")) + abort (); + if (x != 3) + abort (); + if (strcmp (foo, bar) >= 0) + abort (); + if (strcmp (foo, bar + (x++ & 1)) >= 0) + abort (); + if (x != 4) + abort (); + if (strchr (foo + (x++ & 7), 'l') != foo + 9) + abort (); + if (x != 5) + abort (); + if (strchr (bar, 'o') != bar + 4) + abort (); + if (strchr (bar, '\0') != bar + 8) + abort (); + if (strrchr (bar, 'x')) + abort (); + if (strrchr (bar, 'o') != bar + 4) + abort (); + if (strcmp (foo + (x++ & 1), "ello world" + (--y & 1))) + abort (); + if (x != 6 || y != 0) + abort (); + dst[5] = ' '; + dst[6] = '\0'; + x = 5; + y = 1; + if (strncpy (dst + 1, foo + (x++ & 3), 4) != dst + 1 + || x != 6 + || strcmp (dst + 1, "ello ")) + abort (); + memset (dst, ' ', sizeof dst); + if (strncpy (dst + (++x & 1), (y++ & 3) + "foo", 10) != dst + 1 + || x != 7 + || y != 2 + || memcmp (dst, " oo\0\0\0\0\0\0\0\0 ", 12)) + abort (); + memset (dst, ' ', sizeof dst); + if (strncpy (dst, "hello", 8) != dst || memcmp (dst, "hello\0\0\0 ", 9)) + abort (); + x = '!'; + memset (buf, ' ', sizeof buf); + if (memset (buf, x++, ++y) != buf + || x != '!' + 1 + || y != 3 + || memcmp (buf, "!!!", 3)) + abort (); + if (memset (buf + y++, '-', 8) != buf + 3 + || y != 4 + || memcmp (buf, "!!!--------", 11)) + abort (); + x = 10; + if (memset (buf + ++x, 0, y++) != buf + 11 + || x != 11 + || y != 5 + || memcmp (buf + 8, "---\0\0\0", 7)) + abort (); + if (memset (buf + (x += 4), 0, 6) != buf + 15 + || x != 15 + || memcmp (buf + 10, "-\0\0\0\0\0\0\0\0\0", 11)) + abort (); + return 0; +} diff --git a/test/tests/strlen-1.c b/test/tests/strlen-1.c new file mode 100644 index 0000000..c29592b --- /dev/null +++ b/test/tests/strlen-1.c @@ -0,0 +1,57 @@ +/* Copyright (C) 2002 Free Software Foundation. + + Test strlen with various combinations of pointer alignments and lengths to + make sure any optimizations in the library are correct. + + Written by Michael Meissner, March 9, 2002. */ + +#include +#include + +#ifndef MAX_OFFSET +#define MAX_OFFSET (sizeof (long long)) +#endif + +#ifndef MAX_TEST +#define MAX_TEST (8 * sizeof (long long)) +#endif + +#ifndef MAX_EXTRA +#define MAX_EXTRA (sizeof (long long)) +#endif + +#define MAX_LENGTH (MAX_OFFSET + MAX_TEST + MAX_EXTRA + 1) + +static union { + char buf[MAX_LENGTH]; + long long align_int; + long double align_fp; +} u; + +main () +{ + size_t off, len, len2, i; + char *p; + + for (off = 0; off < MAX_OFFSET; off++) + for (len = 0; len < MAX_TEST; len++) + { + p = u.buf; + for (i = 0; i < off; i++) + *p++ = '\0'; + + for (i = 0; i < len; i++) + *p++ = 'a'; + + *p++ = '\0'; + for (i = 0; i < MAX_EXTRA; i++) + *p++ = 'b'; + + p = u.buf + off; + len2 = strlen (p); + if (len != len2) + abort (); + } + + exit (0); +} diff --git a/test/tests/strncmp-1.c b/test/tests/strncmp-1.c new file mode 100644 index 0000000..dee904f --- /dev/null +++ b/test/tests/strncmp-1.c @@ -0,0 +1,140 @@ +/* Copyright (C) 2002 Free Software Foundation. + + Test strncmp with various combinations of pointer alignments and lengths to + make sure any optimizations in the library are correct. + + Written by Michael Meissner, March 9, 2002. */ + +#include +#include + +#ifndef MAX_OFFSET +#define MAX_OFFSET (sizeof (long long)) +#endif + +#ifndef MAX_TEST +#define MAX_TEST (8 * sizeof (long long)) +#endif + +#ifndef MAX_EXTRA +#define MAX_EXTRA (sizeof (long long)) +#endif + +#define MAX_LENGTH (MAX_OFFSET + MAX_TEST + MAX_EXTRA) + +static union { + unsigned char buf[MAX_LENGTH]; + long long align_int; + long double align_fp; +} u1, u2; + +void +test (const unsigned char *s1, const unsigned char *s2, size_t len, int expected) +{ + int value = strncmp ((char *) s1, (char *) s2, len); + + if (expected < 0 && value >= 0) + abort (); + else if (expected == 0 && value != 0) + abort (); + else if (expected > 0 && value <= 0) + abort (); +} + +main () +{ + size_t off1, off2, len, i; + unsigned char *buf1, *buf2; + unsigned char *mod1, *mod2; + unsigned char *p1, *p2; + + for (off1 = 0; off1 < MAX_OFFSET; off1++) + for (off2 = 0; off2 < MAX_OFFSET; off2++) + for (len = 0; len < MAX_TEST; len++) + { + p1 = u1.buf; + for (i = 0; i < off1; i++) + *p1++ = '\0'; + + buf1 = p1; + for (i = 0; i < len; i++) + *p1++ = 'a'; + + mod1 = p1; + for (i = 0; i < MAX_EXTRA; i++) + *p1++ = 'x'; + + p2 = u2.buf; + for (i = 0; i < off2; i++) + *p2++ = '\0'; + + buf2 = p2; + for (i = 0; i < len; i++) + *p2++ = 'a'; + + mod2 = p2; + for (i = 0; i < MAX_EXTRA; i++) + *p2++ = 'x'; + + mod1[0] = '\0'; + mod2[0] = '\0'; + test (buf1, buf2, MAX_LENGTH, 0); + test (buf1, buf2, len, 0); + + mod1[0] = 'a'; + mod1[1] = '\0'; + mod2[0] = '\0'; + test (buf1, buf2, MAX_LENGTH, +1); + test (buf1, buf2, len, 0); + + mod1[0] = '\0'; + mod2[0] = 'a'; + mod2[1] = '\0'; + test (buf1, buf2, MAX_LENGTH, -1); + test (buf1, buf2, len, 0); + + mod1[0] = 'b'; + mod1[1] = '\0'; + mod2[0] = 'c'; + mod2[1] = '\0'; + test (buf1, buf2, MAX_LENGTH, -1); + test (buf1, buf2, len, 0); + + mod1[0] = 'c'; + mod1[1] = '\0'; + mod2[0] = 'b'; + mod2[1] = '\0'; + test (buf1, buf2, MAX_LENGTH, +1); + test (buf1, buf2, len, 0); + + mod1[0] = 'b'; + mod1[1] = '\0'; + mod2[0] = (unsigned char)'\251'; + mod2[1] = '\0'; + test (buf1, buf2, MAX_LENGTH, -1); + test (buf1, buf2, len, 0); + + mod1[0] = (unsigned char)'\251'; + mod1[1] = '\0'; + mod2[0] = 'b'; + mod2[1] = '\0'; + test (buf1, buf2, MAX_LENGTH, +1); + test (buf1, buf2, len, 0); + + mod1[0] = (unsigned char)'\251'; + mod1[1] = '\0'; + mod2[0] = (unsigned char)'\252'; + mod2[1] = '\0'; + test (buf1, buf2, MAX_LENGTH, -1); + test (buf1, buf2, len, 0); + + mod1[0] = (unsigned char)'\252'; + mod1[1] = '\0'; + mod2[0] = (unsigned char)'\251'; + mod2[1] = '\0'; + test (buf1, buf2, MAX_LENGTH, +1); + test (buf1, buf2, len, 0); + } + + exit (0); +} diff --git a/test/tests/struct-cpy-1.c b/test/tests/struct-cpy-1.c new file mode 100644 index 0000000..52886fe --- /dev/null +++ b/test/tests/struct-cpy-1.c @@ -0,0 +1,43 @@ +/* powerpc64-linux gcc miscompiled this due to rs6000.c:expand_block_move + not setting mem aliasing info correctly for the code implementing the + structure assignment. */ + +struct termios +{ + unsigned int a; + unsigned int b; + unsigned int c; + unsigned int d; + unsigned char pad[28]; +}; + +struct tty_driver +{ + unsigned char pad1[38]; + struct termios t __attribute__ ((aligned (8))); +}; + +static struct termios zero_t; +static struct tty_driver pty; + +void ini (void) +{ + pty.t = zero_t; + pty.t.a = 1; + pty.t.b = 2; + pty.t.c = 3; + pty.t.d = 4; +} + +int main (void) +{ + extern void abort (void); + + ini (); + if (pty.t.a != 1 + || pty.t.b != 2 + || pty.t.c != 3 + || pty.t.d != 4) + abort (); + return 0; +} diff --git a/test/tests/struct-ini-1.c b/test/tests/struct-ini-1.c new file mode 100644 index 0000000..ab2d178 --- /dev/null +++ b/test/tests/struct-ini-1.c @@ -0,0 +1,15 @@ +struct S +{ + char f1; + int f2[2]; +}; + +struct S object = {'X', 8, 9}; + +main () +{ + if (object.f1 != 'X' || object.f2[0] != 8 || object.f2[1] != 9) + abort (); + exit (0); +} + diff --git a/test/tests/struct-ini-2.c b/test/tests/struct-ini-2.c new file mode 100644 index 0000000..c785257 --- /dev/null +++ b/test/tests/struct-ini-2.c @@ -0,0 +1,17 @@ +struct { + int a:4; + int :4; + int b:4; + int c:4; +} x = { 2,3,4 }; + +main () +{ + if (x.a != 2) + abort (); + if (x.b != 3) + abort (); + if (x.c != 4) + abort (); + exit (0); +} diff --git a/test/tests/struct-ini-3.c b/test/tests/struct-ini-3.c new file mode 100644 index 0000000..7d282ec --- /dev/null +++ b/test/tests/struct-ini-3.c @@ -0,0 +1,11 @@ +struct +{ + unsigned int f1:1, f2:1, f3:3, f4:3, f5:2, f6:1, f7:1; +} result = {1, 1, 7, 7, 3, 1, 1}; + +main () +{ + if ((result.f3 & ~7) != 0 || (result.f4 & ~7) != 0) + abort (); + exit (0); +} diff --git a/test/tests/struct-ini-4.c b/test/tests/struct-ini-4.c new file mode 100644 index 0000000..3342439 --- /dev/null +++ b/test/tests/struct-ini-4.c @@ -0,0 +1,15 @@ +struct s { + int a[3]; + int c[3]; +}; + +struct s s = { + c: {1, 2, 3} +}; + +main() +{ + if (s.c[0] != 1) + abort (); + exit (0); +} diff --git a/test/tests/struct-ret-1.c b/test/tests/struct-ret-1.c new file mode 100644 index 0000000..e5274ec --- /dev/null +++ b/test/tests/struct-ret-1.c @@ -0,0 +1,57 @@ +#include +#include + +char out[100]; + +typedef struct { double d; int i[3]; } B; +typedef struct { char c[33],c1; } X; + +char c1 = 'a'; +char c2 = 127; +char c3 = (char)128; +char c4 = (char)255; +char c5 = -1; + +double d1 = 0.1; +double d2 = 0.2; +double d3 = 0.3; +double d4 = 0.4; +double d5 = 0.5; +double d6 = 0.6; +double d7 = 0.7; +double d8 = 0.8; +double d9 = 0.9; + +B B1 = {0.1,{1,2,3}}; +B B2 = {0.2,{5,4,3}}; +X X1 = {"abcdefghijklmnopqrstuvwxyzABCDEF", 'G'}; +X X2 = {"123",'9'}; +X X3 = {"return-return-return",'R'}; + +X f (B a, char b, double c, B d) +{ + static X xr = {"return val", 'R'}; + X r; + r = xr; + r.c1 = b; + sprintf (out, "X f(B,char,double,B):({%g,{%d,%d,%d}},'%c',%g,{%g,{%d,%d,%d}})", + a.d, a.i[0], a.i[1], a.i[2], b, c, d.d, d.i[0], d.i[1], d.i[2]); + return r; +} + +X (*fp) (B, char, double, B) = &f; + +main () +{ + X Xr; + char tmp[100]; + + Xr = f (B1, c2, d3, B2); + strcpy (tmp, out); + Xr.c[0] = Xr.c1 = '\0'; + Xr = (*fp) (B1, c2, d3, B2); + if (strcmp (tmp, out)) + abort (); + + exit (0); +} diff --git a/test/tests/struct-ret-2.c b/test/tests/struct-ret-2.c new file mode 100644 index 0000000..06a40a7 --- /dev/null +++ b/test/tests/struct-ret-2.c @@ -0,0 +1,29 @@ +typedef struct +{ + unsigned char a __attribute__ ((packed)); + unsigned short b __attribute__ ((packed)); +} three_byte_t; + +unsigned char +f (void) +{ + return 0xab; +} + +unsigned short +g (void) +{ + return 0x1234; +} + +main () +{ + three_byte_t three_byte; + + three_byte.a = f (); + three_byte.b = g (); + if (three_byte.a != 0xab || three_byte.b != 0x1234) + abort (); + exit (0); +} + diff --git a/test/tests/switch-1.c b/test/tests/switch-1.c new file mode 100644 index 0000000..30cffed --- /dev/null +++ b/test/tests/switch-1.c @@ -0,0 +1,57 @@ +/* Copyright (C) 2003 Free Software Foundation. + + Test that switch statements suitable using case bit tests are + implemented correctly. + + Written by Roger Sayle, 01/25/2001. */ + +extern void abort (void); + +int +foo (int x) +{ + switch (x) + { + case 4: + case 6: + case 9: + case 11: + return 30; + } + return 31; +} + +int +main (int argc) +{ + int i, r; + + for (i=-1; i<66; i++) + { + r = foo (i); + if (i == 4) + { + if (r != 30) + abort (); + } + else if (i == 6) + { + if (r != 30) + abort (); + } + else if (i == 9) + { + if (r != 30) + abort (); + } + else if (i == 11) + { + if (r != 30) + abort (); + } + else if (r != 31) + abort (); + } + return 0; +} + diff --git a/test/tests/tcc-fabs.c b/test/tests/tcc-fabs.c new file mode 100644 index 0000000..a07bf9d --- /dev/null +++ b/test/tests/tcc-fabs.c @@ -0,0 +1,8 @@ +#include + +int main() +{ + if (fabs(20.0) != 20.0) abort(); + if (fabs(-20.0) != 20.0) abort(); + return 0; +} diff --git a/test/tests/tcc-pow.c b/test/tests/tcc-pow.c new file mode 100644 index 0000000..cf01da6 --- /dev/null +++ b/test/tests/tcc-pow.c @@ -0,0 +1,9 @@ +#include + +int main() +{ + float a = 2.0; + float b = 6.0; + if (fabs(pow(a,b) - 64.0) > .0002) abort(); + return 0; +} diff --git a/test/tests/tstdi-1.c b/test/tests/tstdi-1.c new file mode 100644 index 0000000..cef7758 --- /dev/null +++ b/test/tests/tstdi-1.c @@ -0,0 +1,139 @@ +#define FALSE 140 +#define TRUE 13 + +feq (x) + long long int x; +{ + if (x == 0) + return TRUE; + else + return FALSE; +} + +fne (x) + long long int x; +{ + if (x != 0) + return TRUE; + else + return FALSE; +} + +flt (x) + long long int x; +{ + if (x < 0) + return TRUE; + else + return FALSE; +} + +fge (x) + long long int x; +{ + if (x >= 0) + return TRUE; + else + return FALSE; +} + +fgt (x) + long long int x; +{ + if (x > 0) + return TRUE; + else + return FALSE; +} + +fle (x) + long long int x; +{ + if (x <= 0) + return TRUE; + else + return FALSE; +} + +main () +{ + if (feq (0LL) != TRUE) + abort (); + if (feq (-1LL) != FALSE) + abort (); + if (feq (0x80000000LL) != FALSE) + abort (); + if (feq (0x80000001LL) != FALSE) + abort (); + if (feq (1LL) != FALSE) + abort (); + if (feq (0x7fffffffLL) != FALSE) + abort (); + + if (fne (0LL) != FALSE) + abort (); + if (fne (-1LL) != TRUE) + abort (); + if (fne (0x80000000LL) != TRUE) + abort (); + if (fne (0x80000001LL) != TRUE) + abort (); + if (fne (1LL) != TRUE) + abort (); + if (fne (0x7fffffffLL) != TRUE) + abort (); + + if (flt (0LL) != FALSE) + abort (); + if (flt (-1LL) != TRUE) + abort (); + if (flt (0x80000000LL) != TRUE) + abort (); + if (flt (0x80000001LL) != TRUE) + abort (); + if (flt (1LL) != FALSE) + abort (); + if (flt (0x7fffffffLL) != FALSE) + abort (); + + if (fge (0LL) != TRUE) + abort (); + if (fge (-1LL) != FALSE) + abort (); + if (fge (0x80000000LL) != FALSE) + abort (); + if (fge (0x80000001LL) != FALSE) + abort (); + if (fge (1LL) != TRUE) + abort (); + if (fge (0x7fffffffLL) != TRUE) + abort (); + + if (fgt (0LL) != FALSE) + abort (); + if (fgt (-1LL) != FALSE) + abort (); + if (fgt (0x80000000LL) != FALSE) + abort (); + if (fgt (0x80000001LL) != FALSE) + abort (); + if (fgt (1LL) != TRUE) + abort (); + if (fgt (0x7fffffffLL) != TRUE) + abort (); + + if (fle (0LL) != TRUE) + abort (); + if (fle (-1LL) != TRUE) + abort (); + if (fle (0x80000000LL) != TRUE) + abort (); + if (fle (0x80000001LL) != TRUE) + abort (); + if (fle (1LL) != FALSE) + abort (); + if (fle (0x7fffffffLL) != FALSE) + abort (); + + exit (0); +} diff --git a/test/tests/unroll-1.c b/test/tests/unroll-1.c new file mode 100644 index 0000000..8812955 --- /dev/null +++ b/test/tests/unroll-1.c @@ -0,0 +1,19 @@ +inline int +f (int x) +{ + return (x + 1); +} + +int +main (void) +{ + int a = 0 ; + + while ( (f(f(f(f(f(f(f(f(f(f(1))))))))))) + a < 12 ) + { + a++; + exit (0); + } + if (a != 1) + abort(); +} diff --git a/test/tests/usmul.c b/test/tests/usmul.c new file mode 100644 index 0000000..28501b5 --- /dev/null +++ b/test/tests/usmul.c @@ -0,0 +1,33 @@ +int __attribute__ ((noinline)) foo (short x, unsigned short y) +{ + return x * y; +} + +int __attribute__ ((noinline)) bar (unsigned short x, short y) +{ + return x * y; +} + +int main () +{ + if (foo (-2, 0xffff) != -131070) + abort (); + if (foo (2, 0xffff) != 131070) + abort (); + if (foo (-32768, 0x8000) != -1073741824) + abort (); + if (foo (32767, 0x8000) != 1073709056) + abort (); + + if (bar (0xffff, -2) != -131070) + abort (); + if (bar (0xffff, 2) != 131070) + abort (); + if (bar (0x8000, -32768) != -1073741824) + abort (); + if (bar (0x8000, 32767) != 1073709056) + abort (); + + exit (0); +} + diff --git a/test/tests/va-arg-1.c b/test/tests/va-arg-1.c new file mode 100644 index 0000000..3f3b141 --- /dev/null +++ b/test/tests/va-arg-1.c @@ -0,0 +1,24 @@ +#include + +typedef unsigned long L; +f (L p0, L p1, L p2, L p3, L p4, L p5, L p6, L p7, L p8, ...) +{ + va_list select; + + va_start (select, p8); + + if (va_arg (select, L) != 10) + abort (); + if (va_arg (select, L) != 11) + abort (); + if (va_arg (select, L) != 0) + abort (); + + va_end (select); +} + +main () +{ + f (1L, 2L, 3L, 4L, 5L, 6L, 7L, 8L, 9L, 10L, 11L, 0L); + exit (0); +} diff --git a/test/tests/va-arg-10.c b/test/tests/va-arg-10.c new file mode 100644 index 0000000..5ce3453 --- /dev/null +++ b/test/tests/va-arg-10.c @@ -0,0 +1,248 @@ +/* This is a modfied version of va-arg-9.c to test va_copy. */ + +#include + +#ifndef va_copy +#define va_copy __va_copy +#endif + +extern __SIZE_TYPE__ strlen (const char *); + +int +to_hex (unsigned int a) +{ + static char hex[] = "0123456789abcdef"; + + if (a > 15) + abort (); + return hex[a]; +} + +void +fap (int i, char* format, va_list ap) +{ + va_list apc; + char *formatc; + + va_copy (apc, ap); + formatc = format; + + if (strlen (format) != 16 - i) + abort (); + while (*format) + if (*format++ != to_hex (va_arg (ap, int))) + abort (); + while (*formatc) + if (*formatc++ != to_hex (va_arg (apc, int))) + abort (); +} + +void +f0 (char* format, ...) +{ + va_list ap; + + va_start (ap, format); + fap(0, format, ap); + va_end(ap); +} + +void +f1 (int a1, char* format, ...) +{ + va_list ap; + + va_start(ap, format); + fap(1, format, ap); + va_end(ap); +} + +void +f2 (int a1, int a2, char* format, ...) +{ + va_list ap; + + va_start(ap, format); + fap(2, format, ap); + va_end(ap); +} + +void +f3 (int a1, int a2, int a3, char* format, ...) +{ + va_list ap; + + va_start(ap, format); + fap(3, format, ap); + va_end(ap); +} + +void +f4 (int a1, int a2, int a3, int a4, char* format, ...) +{ + va_list ap; + + va_start(ap, format); + fap(4, format, ap); + va_end(ap); +} + +void +f5 (int a1, int a2, int a3, int a4, int a5, + char* format, ...) +{ + va_list ap; + + va_start(ap, format); + fap(5, format, ap); + va_end(ap); +} + +void +f6 (int a1, int a2, int a3, int a4, int a5, + int a6, + char* format, ...) +{ + va_list ap; + + va_start(ap, format); + fap(6, format, ap); + va_end(ap); +} + +void +f7 (int a1, int a2, int a3, int a4, int a5, + int a6, int a7, + char* format, ...) +{ + va_list ap; + + va_start(ap, format); + fap(7, format, ap); + va_end(ap); +} + +void +f8 (int a1, int a2, int a3, int a4, int a5, + int a6, int a7, int a8, + char* format, ...) +{ + va_list ap; + + va_start(ap, format); + fap(8, format, ap); + va_end(ap); +} + +void +f9 (int a1, int a2, int a3, int a4, int a5, + int a6, int a7, int a8, int a9, + char* format, ...) +{ + va_list ap; + + va_start(ap, format); + fap(9, format, ap); + va_end(ap); +} + +void +f10 (int a1, int a2, int a3, int a4, int a5, + int a6, int a7, int a8, int a9, int a10, + char* format, ...) +{ + va_list ap; + + va_start(ap, format); + fap(10, format, ap); + va_end(ap); +} + +void +f11 (int a1, int a2, int a3, int a4, int a5, + int a6, int a7, int a8, int a9, int a10, + int a11, + char* format, ...) +{ + va_list ap; + + va_start(ap, format); + fap(11, format, ap); + va_end(ap); +} + +void +f12 (int a1, int a2, int a3, int a4, int a5, + int a6, int a7, int a8, int a9, int a10, + int a11, int a12, + char* format, ...) +{ + va_list ap; + + va_start(ap, format); + fap(12, format, ap); + va_end(ap); +} + +void +f13 (int a1, int a2, int a3, int a4, int a5, + int a6, int a7, int a8, int a9, int a10, + int a11, int a12, int a13, + char* format, ...) +{ + va_list ap; + + va_start(ap, format); + fap(13, format, ap); + va_end(ap); +} + +void +f14 (int a1, int a2, int a3, int a4, int a5, + int a6, int a7, int a8, int a9, int a10, + int a11, int a12, int a13, int a14, + char* format, ...) +{ + va_list ap; + + va_start(ap, format); + fap(14, format, ap); + va_end(ap); +} + +void +f15 (int a1, int a2, int a3, int a4, int a5, + int a6, int a7, int a8, int a9, int a10, + int a11, int a12, int a13, int a14, int a15, + char* format, ...) +{ + va_list ap; + + va_start(ap, format); + fap(15, format, ap); + va_end(ap); +} + +main () +{ + char *f = "0123456789abcdef"; + + f0 (f+0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); + f1 (0, f+1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); + f2 (0, 1, f+2, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); + f3 (0, 1, 2, f+3, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); + f4 (0, 1, 2, 3, f+4, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); + f5 (0, 1, 2, 3, 4, f+5, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); + f6 (0, 1, 2, 3, 4, 5, f+6, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); + f7 (0, 1, 2, 3, 4, 5, 6, f+7, 7, 8, 9, 10, 11, 12, 13, 14, 15); + f8 (0, 1, 2, 3, 4, 5, 6, 7, f+8, 8, 9, 10, 11, 12, 13, 14, 15); + f9 (0, 1, 2, 3, 4, 5, 6, 7, 8, f+9, 9, 10, 11, 12, 13, 14, 15); + f10 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, f+10, 10, 11, 12, 13, 14, 15); + f11 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, f+11, 11, 12, 13, 14, 15); + f12 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, f+12, 12, 13, 14, 15); + f13 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, f+13, 13, 14, 15); + f14 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, f+14, 14, 15); + f15 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, f+15, 15); + + exit (0); +} diff --git a/test/tests/va-arg-11.c b/test/tests/va-arg-11.c new file mode 100644 index 0000000..b178b88 --- /dev/null +++ b/test/tests/va-arg-11.c @@ -0,0 +1,29 @@ +/* Test va_arg when the result is ignored and only the pointer increment + side effect is used. */ +#include + +static int +foo (int a, ...) +{ + va_list va; + int i, res; + + va_start (va, a); + + for (i = 0; i < 4; ++i) + (void) va_arg (va, int); + + res = va_arg (va, int); + + va_end (va); + + return res; +} + +int +main (void) +{ + if (foo (5, 4, 3, 2, 1, 0)) + abort (); + exit (0); +} diff --git a/test/tests/va-arg-12.c b/test/tests/va-arg-12.c new file mode 100644 index 0000000..f2971d9 --- /dev/null +++ b/test/tests/va-arg-12.c @@ -0,0 +1,25 @@ +#include + +/*typedef unsigned long L;*/ +typedef double L; +void f (L p0, L p1, L p2, L p3, L p4, L p5, L p6, L p7, L p8, ...) +{ + va_list select; + + va_start (select, p8); + + if (va_arg (select, L) != 10.) + abort (); + if (va_arg (select, L) != 11.) + abort (); + if (va_arg (select, L) != 0.) + abort (); + + va_end (select); +} + +int main () +{ + f (1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 0.); + exit (0); +} diff --git a/test/tests/va-arg-13.c b/test/tests/va-arg-13.c new file mode 100644 index 0000000..65caf2b --- /dev/null +++ b/test/tests/va-arg-13.c @@ -0,0 +1,38 @@ +/* derived from mozilla source code */ + +#include + +typedef struct { + void *stream; + va_list ap; + int nChar; +} ScanfState; + +void dummy (va_list vap) +{ + if (va_arg (vap, int) != 1234) abort(); + return; +} + +void test (int fmt, ...) +{ + ScanfState state, *statep; + + statep = &state; + + va_start (statep->ap, fmt); + dummy (statep->ap); + va_end (statep->ap); + + va_start (state.ap, fmt); + dummy (state.ap); + va_end (state.ap); + + return; +} + +int main (void) +{ + test (456, 1234); + exit (0); +} diff --git a/test/tests/va-arg-14.c b/test/tests/va-arg-14.c new file mode 100644 index 0000000..d8b517a --- /dev/null +++ b/test/tests/va-arg-14.c @@ -0,0 +1,45 @@ +#include + +va_list global; + +void vat(va_list param, ...) +{ + va_list local; + + va_start (local, param); + va_copy (global, local); + va_copy (param, local); + if (va_arg (local, int) != 1) + abort(); + va_end (local); + if (va_arg (global, int) != 1) + abort(); + va_end (global); + if (va_arg (param, int) != 1) + abort(); + va_end (param); + + va_start (param, param); + va_start (global, param); + va_copy (local, param); + if (va_arg (local, int) != 1) + abort(); + va_end (local); + va_copy (local, global); + if (va_arg (local, int) != 1) + abort(); + va_end (local); + if (va_arg (global, int) != 1) + abort(); + va_end (global); + if (va_arg (param, int) != 1) + abort(); + va_end (param); +} + +int main(void) +{ + va_list t; + vat (t, 1); + exit (0); +} diff --git a/test/tests/va-arg-15.c b/test/tests/va-arg-15.c new file mode 100644 index 0000000..24411f8 --- /dev/null +++ b/test/tests/va-arg-15.c @@ -0,0 +1,44 @@ +#include + +void vafunction (char *dummy, ...) +{ + double darg; + int iarg; + int flag = 0; + int i; + va_list ap; + + va_start(ap, dummy); + for (i = 1; i <= 18; i++, flag++) + { + if (flag & 1) + { + darg = va_arg (ap, double); + if (darg != (double)i) + abort(); + } + else + { + iarg = va_arg (ap, int); + if (iarg != i) + abort(); + } + } + va_end(ap); +} + +int main (void) +{ + vafunction( "", + 1, 2., + 3, 4., + 5, 6., + 7, 8., + 9, 10., + 11, 12., + 13, 14., + 15, 16., + 17, 18. ); + exit(0); + return 0; +} diff --git a/test/tests/va-arg-16.c b/test/tests/va-arg-16.c new file mode 100644 index 0000000..1115ef0 --- /dev/null +++ b/test/tests/va-arg-16.c @@ -0,0 +1,41 @@ +#include + +typedef double TYPE; + +void vafunction (TYPE dummy1, TYPE dummy2, ...) +{ + va_list ap; + + va_start(ap, dummy2); + if (dummy1 != 888.) + abort(); + if (dummy2 != 999.) + abort(); + if (va_arg (ap, TYPE) != 1.) + abort(); + if (va_arg (ap, TYPE) != 2.) + abort(); + if (va_arg (ap, TYPE) != 3.) + abort(); + if (va_arg (ap, TYPE) != 4.) + abort(); + if (va_arg (ap, TYPE) != 5.) + abort(); + if (va_arg (ap, TYPE) != 6.) + abort(); + if (va_arg (ap, TYPE) != 7.) + abort(); + if (va_arg (ap, TYPE) != 8.) + abort(); + if (va_arg (ap, TYPE) != 9.) + abort(); + va_end(ap); +} + + +int main (void) +{ + vafunction( 888., 999., 1., 2., 3., 4., 5., 6., 7., 8., 9. ); + exit(0); + return 0; +} diff --git a/test/tests/va-arg-17.c b/test/tests/va-arg-17.c new file mode 100644 index 0000000..17850db --- /dev/null +++ b/test/tests/va-arg-17.c @@ -0,0 +1,37 @@ +#include + +typedef double TYPE; + +void vafunction (char *dummy, ...) +{ + va_list ap; + + va_start(ap, dummy); + if (va_arg (ap, TYPE) != 1.) + abort(); + if (va_arg (ap, TYPE) != 2.) + abort(); + if (va_arg (ap, TYPE) != 3.) + abort(); + if (va_arg (ap, TYPE) != 4.) + abort(); + if (va_arg (ap, TYPE) != 5.) + abort(); + if (va_arg (ap, TYPE) != 6.) + abort(); + if (va_arg (ap, TYPE) != 7.) + abort(); + if (va_arg (ap, TYPE) != 8.) + abort(); + if (va_arg (ap, TYPE) != 9.) + abort(); + va_end(ap); +} + + +int main (void) +{ + vafunction( "", 1., 2., 3., 4., 5., 6., 7., 8., 9. ); + exit(0); + return 0; +} diff --git a/test/tests/va-arg-18.c b/test/tests/va-arg-18.c new file mode 100644 index 0000000..00dd54f --- /dev/null +++ b/test/tests/va-arg-18.c @@ -0,0 +1,24 @@ +#include + +typedef double L; +void f (L p0, L p1, L p2, L p3, L p4, L p5, L p6, L p7, L p8, ...) +{ + va_list select; + + va_start (select, p8); + + if (va_arg (select, int) != 10) + abort (); + if (va_arg (select, int) != 11) + abort (); + if (va_arg (select, int) != 12) + abort (); + + va_end (select); +} + +int main () +{ + f (1., 2., 3., 4., 5., 6., 7., 8., 9., 10, 11, 12); + exit (0); +} diff --git a/test/tests/va-arg-19.c b/test/tests/va-arg-19.c new file mode 100644 index 0000000..9fdf49d --- /dev/null +++ b/test/tests/va-arg-19.c @@ -0,0 +1,37 @@ +#include + +typedef int TYPE; + +void vafunction (char *dummy, ...) +{ + va_list ap; + + va_start(ap, dummy); + if (va_arg (ap, TYPE) != 1) + abort(); + if (va_arg (ap, TYPE) != 2) + abort(); + if (va_arg (ap, TYPE) != 3) + abort(); + if (va_arg (ap, TYPE) != 4) + abort(); + if (va_arg (ap, TYPE) != 5) + abort(); + if (va_arg (ap, TYPE) != 6) + abort(); + if (va_arg (ap, TYPE) != 7) + abort(); + if (va_arg (ap, TYPE) != 8) + abort(); + if (va_arg (ap, TYPE) != 9) + abort(); + va_end(ap); +} + + +int main (void) +{ + vafunction( "", 1, 2, 3, 4, 5, 6, 7, 8, 9 ); + exit(0); + return 0; +} diff --git a/test/tests/va-arg-2.c b/test/tests/va-arg-2.c new file mode 100644 index 0000000..7675b3f --- /dev/null +++ b/test/tests/va-arg-2.c @@ -0,0 +1,292 @@ +/* The purpose of this test is to catch edge cases when arguments are passed + in regs and on the stack. We test 16 cases, trying to catch multiple + targets (some use 3 regs for argument passing, some use 12, etc.). + We test both the arguments and the `lastarg' (the argument to va_start). */ + +#include + +extern __SIZE_TYPE__ strlen (); + +int +to_hex (unsigned int a) +{ + static char hex[] = "0123456789abcdef"; + + if (a > 15) + abort (); + return hex[a]; +} + +void +f0 (char* format, ...) +{ + va_list ap; + + va_start (ap, format); + if (strlen (format) != 16 - 0) + abort (); + while (*format) + if (*format++ != to_hex (va_arg (ap, int))) + abort (); + va_end(ap); +} + +void +f1 (int a1, char* format, ...) +{ + va_list ap; + + va_start(ap, format); + if (strlen (format) != 16 - 1) + abort (); + while (*format) + if (*format++ != to_hex (va_arg (ap, int))) + abort (); + va_end(ap); +} + +void +f2 (int a1, int a2, char* format, ...) +{ + va_list ap; + + va_start(ap, format); + if (strlen (format) != 16 - 2) + abort (); + while (*format) + if (*format++ != to_hex (va_arg (ap, int))) + abort (); + va_end(ap); +} + +void +f3 (int a1, int a2, int a3, char* format, ...) +{ + va_list ap; + + va_start(ap, format); + if (strlen (format) != 16 - 3) + abort (); + while (*format) + if (*format++ != to_hex (va_arg (ap, int))) + abort (); + va_end(ap); +} + +void +f4 (int a1, int a2, int a3, int a4, char* format, ...) +{ + va_list ap; + + va_start(ap, format); + if (strlen (format) != 16 - 4) + abort (); + while (*format) + if (*format++ != to_hex (va_arg (ap, int))) + abort (); + va_end(ap); +} + +void +f5 (int a1, int a2, int a3, int a4, int a5, + char* format, ...) +{ + va_list ap; + + va_start(ap, format); + if (strlen (format) != 16 - 5) + abort (); + while (*format) + if (*format++ != to_hex (va_arg (ap, int))) + abort (); + va_end(ap); +} + +void +f6 (int a1, int a2, int a3, int a4, int a5, + int a6, + char* format, ...) +{ + va_list ap; + + va_start(ap, format); + if (strlen (format) != 16 - 6) + abort (); + while (*format) + if (*format++ != to_hex (va_arg (ap, int))) + abort (); + va_end(ap); +} + +void +f7 (int a1, int a2, int a3, int a4, int a5, + int a6, int a7, + char* format, ...) +{ + va_list ap; + + va_start(ap, format); + if (strlen (format) != 16 - 7) + abort (); + while (*format) + if (*format++ != to_hex (va_arg (ap, int))) + abort (); + va_end(ap); +} + +void +f8 (int a1, int a2, int a3, int a4, int a5, + int a6, int a7, int a8, + char* format, ...) +{ + va_list ap; + + va_start(ap, format); + if (strlen (format) != 16 - 8) + abort (); + while (*format) + if (*format++ != to_hex (va_arg (ap, int))) + abort (); + va_end(ap); +} + +void +f9 (int a1, int a2, int a3, int a4, int a5, + int a6, int a7, int a8, int a9, + char* format, ...) +{ + va_list ap; + + va_start(ap, format); + if (strlen (format) != 16 - 9) + abort (); + while (*format) + if (*format++ != to_hex (va_arg (ap, int))) + abort (); + va_end(ap); +} + +void +f10 (int a1, int a2, int a3, int a4, int a5, + int a6, int a7, int a8, int a9, int a10, + char* format, ...) +{ + va_list ap; + + va_start(ap, format); + if (strlen (format) != 16 - 10) + abort (); + while (*format) + if (*format++ != to_hex (va_arg (ap, int))) + abort (); + va_end(ap); +} + +void +f11 (int a1, int a2, int a3, int a4, int a5, + int a6, int a7, int a8, int a9, int a10, + int a11, + char* format, ...) +{ + va_list ap; + + va_start(ap, format); + if (strlen (format) != 16 - 11) + abort (); + while (*format) + if (*format++ != to_hex (va_arg (ap, int))) + abort (); + va_end(ap); +} + +void +f12 (int a1, int a2, int a3, int a4, int a5, + int a6, int a7, int a8, int a9, int a10, + int a11, int a12, + char* format, ...) +{ + va_list ap; + + va_start(ap, format); + if (strlen (format) != 16 - 12) + abort (); + while (*format) + if (*format++ != to_hex (va_arg (ap, int))) + abort (); + va_end(ap); +} + +void +f13 (int a1, int a2, int a3, int a4, int a5, + int a6, int a7, int a8, int a9, int a10, + int a11, int a12, int a13, + char* format, ...) +{ + va_list ap; + + va_start(ap, format); + if (strlen (format) != 16 - 13) + abort (); + while (*format) + if (*format++ != to_hex (va_arg (ap, int))) + abort (); + va_end(ap); +} + +void +f14 (int a1, int a2, int a3, int a4, int a5, + int a6, int a7, int a8, int a9, int a10, + int a11, int a12, int a13, int a14, + char* format, ...) +{ + va_list ap; + + va_start(ap, format); + if (strlen (format) != 16 - 14) + abort (); + while (*format) + if (*format++ != to_hex (va_arg (ap, int))) + abort (); + va_end(ap); +} + +void +f15 (int a1, int a2, int a3, int a4, int a5, + int a6, int a7, int a8, int a9, int a10, + int a11, int a12, int a13, int a14, int a15, + char* format, ...) +{ + va_list ap; + + va_start(ap, format); + if (strlen (format) != 16 - 15) + abort (); + while (*format) + if (*format++ != to_hex (va_arg (ap, int))) + abort (); + va_end(ap); +} + +main () +{ + char *f = "0123456789abcdef"; + + f0 (f+0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); + f1 (0, f+1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); + f2 (0, 1, f+2, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); + f3 (0, 1, 2, f+3, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); + f4 (0, 1, 2, 3, f+4, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); + f5 (0, 1, 2, 3, 4, f+5, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); + f6 (0, 1, 2, 3, 4, 5, f+6, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); + f7 (0, 1, 2, 3, 4, 5, 6, f+7, 7, 8, 9, 10, 11, 12, 13, 14, 15); + f8 (0, 1, 2, 3, 4, 5, 6, 7, f+8, 8, 9, 10, 11, 12, 13, 14, 15); + f9 (0, 1, 2, 3, 4, 5, 6, 7, 8, f+9, 9, 10, 11, 12, 13, 14, 15); + f10 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, f+10, 10, 11, 12, 13, 14, 15); + f11 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, f+11, 11, 12, 13, 14, 15); + f12 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, f+12, 12, 13, 14, 15); + f13 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, f+13, 13, 14, 15); + f14 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, f+14, 14, 15); + f15 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, f+15, 15); + + exit (0); +} diff --git a/test/tests/va-arg-20.c b/test/tests/va-arg-20.c new file mode 100644 index 0000000..2e8e564 --- /dev/null +++ b/test/tests/va-arg-20.c @@ -0,0 +1,22 @@ +#include + +void foo(va_list v) +{ + unsigned long long x = va_arg (v, unsigned long long); + if (x != 16LL) + abort(); +} + +void bar(char c, char d, ...) +{ + va_list v; + va_start(v, d); + foo(v); + va_end(v); +} + +int main(void) +{ + bar(0, 0, 16LL); + exit(0); +} diff --git a/test/tests/va-arg-22.c b/test/tests/va-arg-22.c new file mode 100644 index 0000000..360079b --- /dev/null +++ b/test/tests/va-arg-22.c @@ -0,0 +1,78 @@ +#include + +extern void abort (void); +extern void exit (int); + +void bar (int n, int c) +{ + static int lastn = -1, lastc = -1; + + if (lastn != n) + { + if (lastc != lastn) + abort (); + lastc = 0; + lastn = n; + } + + if (c != (char) (lastc ^ (n << 3))) + abort (); + lastc++; +} + +#define D(N) typedef struct { char x[N]; } A##N; +D(0) D(1) D(2) D(3) D(4) D(5) D(6) D(7) +D(8) D(9) D(10) D(11) D(12) D(13) D(14) D(15) +//D(16) D(31) D(32) D(35) D(72) +#undef D + +void foo (int size, ...) +{ +#define D(N) A##N a##N; +D(0) D(1) D(2) D(3) D(4) D(5) D(6) D(7) +D(8) D(9) D(10) D(11) D(12) D(13) D(14) D(15) +//D(16) D(31) D(32) D(35) D(72) +#undef D + va_list ap; + int i; + + if (size != 21) + abort (); + va_start (ap, size); +#define D(N) \ + a##N = va_arg (ap, typeof (a##N)); \ + for (i = 0; i < N; i++) \ + bar (N, a##N.x[i]); +D(0) D(1) D(2) D(3) D(4) D(5) D(6) D(7) +D(8) D(9) D(10) D(11) D(12) D(13) D(14) D(15) +//D(16) D(31) D(32) D(35) D(72) +#undef D + va_end (ap); +} + +int main (void) +{ +#define D(N) A##N a##N; +D(0) D(1) D(2) D(3) D(4) D(5) D(6) D(7) +D(8) D(9) D(10) D(11) D(12) D(13) D(14) D(15) +//D(16) D(31) D(32) D(35) D(72) +#undef D + int i; + +#define D(N) \ + for (i = 0; i < N; i++) \ + a##N.x[i] = i ^ (N << 3); +D(0) D(1) D(2) D(3) D(4) D(5) D(6) D(7) +D(8) D(9) D(10) D(11) D(12) D(13) D(14) D(15) +//D(16) D(31) D(32) D(35) D(72) +#undef D + + foo (21 +#define D(N) , a##N +D(0) D(1) D(2) D(3) D(4) D(5) D(6) D(7) +D(8) D(9) D(10) D(11) D(12) D(13) D(14) D(15) +//D(16) D(31) D(32) D(35) D(72) +#undef D + ); + exit (0); +} diff --git a/test/tests/va-arg-23.c b/test/tests/va-arg-23.c new file mode 100644 index 0000000..89a11cf --- /dev/null +++ b/test/tests/va-arg-23.c @@ -0,0 +1,26 @@ +/* PR 9700 */ +/* Alpha got the base address for the va_list incorrect when there was + a structure that was passed partially in registers and partially on + the stack. */ + +#include + +struct two { long x, y; }; + +void foo(int a, int b, int c, int d, int e, struct two f, int g, ...) +{ + va_list args; + int h; + + va_start(args, g); + h = va_arg(args, int); + if (g != 1 || h != 2) + abort (); +} + +int main() +{ + struct two t = { 0, 0 }; + foo(0, 0, 0, 0, 0, t, 1, 2); + return 0; +} diff --git a/test/tests/va-arg-26.c b/test/tests/va-arg-26.c new file mode 100644 index 0000000..8221e9c --- /dev/null +++ b/test/tests/va-arg-26.c @@ -0,0 +1,20 @@ +#include + +double f (float f1, float f2, float f3, float f4, + float f5, float f6, ...) +{ + va_list ap; + double d; + + va_start (ap, f6); + d = va_arg (ap, double); + va_end (ap); + return d; +} + +int main () +{ + if (f (1, 2, 3, 4, 5, 6, 7.0) != 7.0) + abort (); + exit (0); +} diff --git a/test/tests/va-arg-4.c b/test/tests/va-arg-4.c new file mode 100644 index 0000000..a824f64 --- /dev/null +++ b/test/tests/va-arg-4.c @@ -0,0 +1,33 @@ +/* On the i960 any arg bigger than 16 bytes causes all subsequent args + to be passed on the stack. We test this. */ + +#include + +typedef struct { + char a[32]; +} big; + +void +f (big x, char *s, ...) +{ + va_list ap; + + if (x.a[0] != 'a' || x.a[1] != 'b' || x.a[2] != 'c') + abort (); + va_start (ap, s); + if (va_arg (ap, int) != 42) + abort (); + if (va_arg (ap, int) != 'x') + abort (); + if (va_arg (ap, int) != 0) + abort (); + va_end (ap); +} + +main () +{ + static big x = { "abc" }; + + f (x, "", 42, 'x', 0); + exit (0); +} diff --git a/test/tests/va-arg-5.c b/test/tests/va-arg-5.c new file mode 100644 index 0000000..3d8b1a7 --- /dev/null +++ b/test/tests/va-arg-5.c @@ -0,0 +1,44 @@ +#include + +va_double (int n, ...) +{ + va_list args; + + va_start (args, n); + + if (va_arg (args, double) != 3.141592) + abort (); + if (va_arg (args, double) != 2.71827) + abort (); + if (va_arg (args, double) != 2.2360679) + abort (); + if (va_arg (args, double) != 2.1474836) + abort (); + + va_end (args); +} + +va_long_double (int n, ...) +{ + va_list args; + + va_start (args, n); + + if (va_arg (args, long double) != 3.141592L) + abort (); + if (va_arg (args, long double) != 2.71827L) + abort (); + if (va_arg (args, long double) != 2.2360679L) + abort (); + if (va_arg (args, long double) != 2.1474836L) + abort (); + + va_end (args); +} + +main () +{ + va_double (4, 3.141592, 2.71827, 2.2360679, 2.1474836); + va_long_double (4, 3.141592L, 2.71827L, 2.2360679L, 2.1474836L); + exit (0); +} diff --git a/test/tests/va-arg-6.c b/test/tests/va-arg-6.c new file mode 100644 index 0000000..e8d495d --- /dev/null +++ b/test/tests/va-arg-6.c @@ -0,0 +1,35 @@ +#include + +f (int n, ...) +{ + va_list args; + + va_start (args, n); + + if (va_arg (args, int) != 10) + abort (); + if (va_arg (args, long long) != 10000000000LL) + abort (); + if (va_arg (args, int) != 11) + abort (); + if (va_arg (args, long double) != 3.14L) + abort (); + if (va_arg (args, int) != 12) + abort (); + if (va_arg (args, int) != 13) + abort (); + if (va_arg (args, long long) != 20000000000LL) + abort (); + if (va_arg (args, int) != 14) + abort (); + if (va_arg (args, double) != 2.72) + abort (); + + va_end(args); +} + +main () +{ + f (4, 10, 10000000000LL, 11, 3.14L, 12, 13, 20000000000LL, 14, 2.72); + exit (0); +} diff --git a/test/tests/va-arg-7.c b/test/tests/va-arg-7.c new file mode 100644 index 0000000..f45219a --- /dev/null +++ b/test/tests/va-arg-7.c @@ -0,0 +1,31 @@ +/* Origin: Franz Sirl */ + +#include + +inline void +debug(int i1, int i2, int i3, int i4, int i5, int i6, int i7, + double f1, double f2, double f3, double f4, double f5, + double f6, double f7, double f8, double f9, ...) +{ + va_list ap; + + va_start (ap, f9); + + if (va_arg (ap,int) != 8) + abort (); + if (va_arg (ap,int) != 9) + abort (); + if (va_arg (ap,int) != 10) + abort (); + + va_end (ap); +} + +int +main(void) +{ + debug (1, 2, 3, 4, 5, 6, 7, + 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, + 8, 9, 10); + exit (0); +} diff --git a/test/tests/va-arg-8.c b/test/tests/va-arg-8.c new file mode 100644 index 0000000..65408a3 --- /dev/null +++ b/test/tests/va-arg-8.c @@ -0,0 +1,41 @@ +/* Origin: Franz Sirl */ + +#include +#include + +#if 1 //__LONG_LONG_MAX__ == 9223372036854775807LL + +typedef long long int INT64; + +inline void +debug(int i1, int i2, int i3, int i4, int i5, + int i6, int i7, int i8, int i9, ...) +{ + va_list ap; + + va_start (ap, i9); + + if (va_arg (ap,int) != 10) + abort (); + if (va_arg (ap,INT64) != 0x12345678LL) + abort (); + + va_end (ap); +} + +int +main(void) +{ + debug(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0x12345678LL); + exit(0); +} + +#else + +int +main(void) +{ + exit(0); +} + +#endif /* long long 64 bits */ diff --git a/test/tests/va-arg-9.c b/test/tests/va-arg-9.c new file mode 100644 index 0000000..f0a92dc --- /dev/null +++ b/test/tests/va-arg-9.c @@ -0,0 +1,236 @@ +/* This is a modfied version of va-arg-2.c to test passing a va_list as + a parameter to another function. */ + +#include + +extern __SIZE_TYPE__ strlen (const char *); + +int +to_hex (unsigned int a) +{ + static char hex[] = "0123456789abcdef"; + + if (a > 15) + abort (); + return hex[a]; +} + +void +fap (int i, char* format, va_list ap) +{ + if (strlen (format) != 16 - i) + abort (); + while (*format) + if (*format++ != to_hex (va_arg (ap, int))) + abort (); +} + +void +f0 (char* format, ...) +{ + va_list ap; + + va_start (ap, format); + fap(0, format, ap); + va_end(ap); +} + +void +f1 (int a1, char* format, ...) +{ + va_list ap; + + va_start(ap, format); + fap(1, format, ap); + va_end(ap); +} + +void +f2 (int a1, int a2, char* format, ...) +{ + va_list ap; + + va_start(ap, format); + fap(2, format, ap); + va_end(ap); +} + +void +f3 (int a1, int a2, int a3, char* format, ...) +{ + va_list ap; + + va_start(ap, format); + fap(3, format, ap); + va_end(ap); +} + +void +f4 (int a1, int a2, int a3, int a4, char* format, ...) +{ + va_list ap; + + va_start(ap, format); + fap(4, format, ap); + va_end(ap); +} + +void +f5 (int a1, int a2, int a3, int a4, int a5, + char* format, ...) +{ + va_list ap; + + va_start(ap, format); + fap(5, format, ap); + va_end(ap); +} + +void +f6 (int a1, int a2, int a3, int a4, int a5, + int a6, + char* format, ...) +{ + va_list ap; + + va_start(ap, format); + fap(6, format, ap); + va_end(ap); +} + +void +f7 (int a1, int a2, int a3, int a4, int a5, + int a6, int a7, + char* format, ...) +{ + va_list ap; + + va_start(ap, format); + fap(7, format, ap); + va_end(ap); +} + +void +f8 (int a1, int a2, int a3, int a4, int a5, + int a6, int a7, int a8, + char* format, ...) +{ + va_list ap; + + va_start(ap, format); + fap(8, format, ap); + va_end(ap); +} + +void +f9 (int a1, int a2, int a3, int a4, int a5, + int a6, int a7, int a8, int a9, + char* format, ...) +{ + va_list ap; + + va_start(ap, format); + fap(9, format, ap); + va_end(ap); +} + +void +f10 (int a1, int a2, int a3, int a4, int a5, + int a6, int a7, int a8, int a9, int a10, + char* format, ...) +{ + va_list ap; + + va_start(ap, format); + fap(10, format, ap); + va_end(ap); +} + +void +f11 (int a1, int a2, int a3, int a4, int a5, + int a6, int a7, int a8, int a9, int a10, + int a11, + char* format, ...) +{ + va_list ap; + + va_start(ap, format); + fap(11, format, ap); + va_end(ap); +} + +void +f12 (int a1, int a2, int a3, int a4, int a5, + int a6, int a7, int a8, int a9, int a10, + int a11, int a12, + char* format, ...) +{ + va_list ap; + + va_start(ap, format); + fap(12, format, ap); + va_end(ap); +} + +void +f13 (int a1, int a2, int a3, int a4, int a5, + int a6, int a7, int a8, int a9, int a10, + int a11, int a12, int a13, + char* format, ...) +{ + va_list ap; + + va_start(ap, format); + fap(13, format, ap); + va_end(ap); +} + +void +f14 (int a1, int a2, int a3, int a4, int a5, + int a6, int a7, int a8, int a9, int a10, + int a11, int a12, int a13, int a14, + char* format, ...) +{ + va_list ap; + + va_start(ap, format); + fap(14, format, ap); + va_end(ap); +} + +void +f15 (int a1, int a2, int a3, int a4, int a5, + int a6, int a7, int a8, int a9, int a10, + int a11, int a12, int a13, int a14, int a15, + char* format, ...) +{ + va_list ap; + + va_start(ap, format); + fap(15, format, ap); + va_end(ap); +} + +main () +{ + char *f = "0123456789abcdef"; + + f0 (f+0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); + f1 (0, f+1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); + f2 (0, 1, f+2, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); + f3 (0, 1, 2, f+3, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); + f4 (0, 1, 2, 3, f+4, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); + f5 (0, 1, 2, 3, 4, f+5, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); + f6 (0, 1, 2, 3, 4, 5, f+6, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); + f7 (0, 1, 2, 3, 4, 5, 6, f+7, 7, 8, 9, 10, 11, 12, 13, 14, 15); + f8 (0, 1, 2, 3, 4, 5, 6, 7, f+8, 8, 9, 10, 11, 12, 13, 14, 15); + f9 (0, 1, 2, 3, 4, 5, 6, 7, 8, f+9, 9, 10, 11, 12, 13, 14, 15); + f10 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, f+10, 10, 11, 12, 13, 14, 15); + f11 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, f+11, 11, 12, 13, 14, 15); + f12 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, f+12, 12, 13, 14, 15); + f13 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, f+13, 13, 14, 15); + f14 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, f+14, 14, 15); + f15 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, f+15, 15); + + exit (0); +} diff --git a/test/tests/vrp-1.c b/test/tests/vrp-1.c new file mode 100644 index 0000000..ac42e6c --- /dev/null +++ b/test/tests/vrp-1.c @@ -0,0 +1,20 @@ + +extern void abort (); +extern void exit (int); + +int f (int a) { + if (a != 2) { + a = -a; + if (a == 2) + return 0; + return 1; + } + return 1; +} + +int main (int argc, char *argv[]) { + if (f (-2)) + abort (); + exit (0); +} + diff --git a/test/tests/vrp-2.c b/test/tests/vrp-2.c new file mode 100644 index 0000000..69ed3e7 --- /dev/null +++ b/test/tests/vrp-2.c @@ -0,0 +1,19 @@ +extern void abort (); +extern void exit (int); + +int f (int a) { + if (a != 2) { + a = a > 0 ? a : -a; + if (a == 2) + return 0; + return 1; + } + return 1; +} + +int main (int argc, char *argv[]) { + if (f (-2)) + abort (); + exit (0); +} + diff --git a/test/tests/vrp-3.c b/test/tests/vrp-3.c new file mode 100644 index 0000000..bc0e490 --- /dev/null +++ b/test/tests/vrp-3.c @@ -0,0 +1,21 @@ +extern void abort (); +extern void exit (int); + +int f (int a) { + if (a < 12) { + if (a > -15) { + a = a > 0 ? a : -a; + if (a == 2) + return 0; + return 1; + } + } + return 1; +} + +int main (int argc, char *argv[]) { + if (f (-2)) + abort (); + exit (0); +} + diff --git a/test/tests/vrp-4.c b/test/tests/vrp-4.c new file mode 100644 index 0000000..23f2922 --- /dev/null +++ b/test/tests/vrp-4.c @@ -0,0 +1,20 @@ +extern void exit (int); +extern void abort (); + +void test(int x, int y) +{ + int c; + + if (x == 1) abort(); + if (y == 1) abort(); + + c = x / y; + + if (c != 1) abort(); +} + +int main() +{ + test(2, 2); + exit (0); +} diff --git a/test/tests/vrp-5.c b/test/tests/vrp-5.c new file mode 100644 index 0000000..6d062e7 --- /dev/null +++ b/test/tests/vrp-5.c @@ -0,0 +1,22 @@ +extern void exit (int); +extern void abort (); + +void test(unsigned int a, unsigned int b) +{ + if (a < 5) + abort(); + if (b < 5) + abort(); + if (a + b != 0U) + abort(); +} + +int main(int argc, char *argv[]) +{ + unsigned int x = 0x8000; + test(x, x); + exit (0); +} + + + diff --git a/test/tests/vrp-6.c b/test/tests/vrp-6.c new file mode 100644 index 0000000..689ac2b --- /dev/null +++ b/test/tests/vrp-6.c @@ -0,0 +1,33 @@ +#include + +extern void exit (int); +extern void abort (); + +void test01(unsigned int a, unsigned int b) +{ + if (a < 5) + abort(); + if (b < 5) + abort(); + if (a - b != 5) + abort(); +} + +void test02(unsigned int a, unsigned int b) +{ + if (a >= 12) + if (b > 15) + if (a - b < UINT_MAX - 15U) + abort (); +} + +int main(int argc, char *argv[]) +{ + unsigned x = 0x8000; + test01(x + 5, x); + test02(14, 16); + exit (0); +} + + + diff --git a/test/tests/vrp-7.c b/test/tests/vrp-7.c new file mode 100644 index 0000000..b4c9e62 --- /dev/null +++ b/test/tests/vrp-7.c @@ -0,0 +1,20 @@ + +void abort (void); + +struct T +{ + int b : 1; +} t; + +void __attribute__((noinline)) foo (int f) +{ + t.b = (f & 0x10) ? 1 : 0; +} + +int main (void) +{ + foo (0x10); + if (!t.b) + abort (); + return 0; +} diff --git a/test/tests/widechar-1.c b/test/tests/widechar-1.c new file mode 100644 index 0000000..45b9d89 --- /dev/null +++ b/test/tests/widechar-1.c @@ -0,0 +1,14 @@ +#define C L'\400' + +#if C +#define zero (!C) +#else +#define zero C +#endif + +main() +{ + if (zero != 0) + abort (); + exit (0); +} diff --git a/test/tests/widechar-2.c b/test/tests/widechar-2.c new file mode 100644 index 0000000..9e6a73b --- /dev/null +++ b/test/tests/widechar-2.c @@ -0,0 +1,11 @@ +#include + +const wchar_t ws[] = L"foo"; + +int +main (void) +{ + if (ws[0] != L'f' || ws[1] != L'o' || ws[2] != L'o' || ws[3] != L'\0') + abort(); + exit(0); +} diff --git a/test/tests/zero-struct-1.c b/test/tests/zero-struct-1.c new file mode 100644 index 0000000..d673adf --- /dev/null +++ b/test/tests/zero-struct-1.c @@ -0,0 +1,23 @@ +struct g{}; +char y[3]; +char *f = &y[0]; +char *ff = &y[0]; +void h(void) +{ + struct g t; + *((struct g*)(f++)) = *((struct g*)(ff++)); + *((struct g*)(f++)) = (struct g){}; + t = *((struct g*)(ff++)); +} + +void abort (void); + +int main(void) +{ + h(); + if (f != &y[2]) + abort(); + if (ff != &y[2]) + abort(); + return 0; +} diff --git a/test/tests/zerolen-1.c b/test/tests/zerolen-1.c new file mode 100644 index 0000000..632ad4b --- /dev/null +++ b/test/tests/zerolen-1.c @@ -0,0 +1,32 @@ +extern void abort (void); +extern void exit (int); + +union iso_directory_record { + char carr[4]; + struct { + unsigned char name_len [1]; + char name [0]; + } u; +} entry; + +void set(union iso_directory_record *); + +int main (void) +{ + union iso_directory_record *de; + + de = &entry; + set(de); + + if (de->u.name_len[0] == 1 && de->u.name[0] == 0) + exit (0); + else + abort (); +} + +void set (union iso_directory_record *p) +{ + p->carr[0] = 1; + p->carr[1] = 0; + return; +} diff --git a/test/tests/zerolen-2.c b/test/tests/zerolen-2.c new file mode 100644 index 0000000..446e582 --- /dev/null +++ b/test/tests/zerolen-2.c @@ -0,0 +1,18 @@ +extern void abort(void); + +typedef int word __attribute__((mode(word))); + +struct foo +{ + word x; + word y[0]; +}; + +int main() +{ + if (sizeof(word) != sizeof(struct foo)) + abort(); + if (__alignof__(word) != __alignof__(struct foo)) + abort(); + return 0; +} diff --git a/test/unimplemented/20050929-1.c b/test/unimplemented/20050929-1.c new file mode 100644 index 0000000..7be2eb8 --- /dev/null +++ b/test/unimplemented/20050929-1.c @@ -0,0 +1,20 @@ +/* PR middle-end/24109 */ + +extern void abort (void); + +struct A { int i; int j; }; +struct B { struct A *a; struct A *b; }; +struct C { struct B *c; struct A *d; }; +struct C e = { &(struct B) { &(struct A) { 1, 2 }, &(struct A) { 3, 4 } }, &(struct A) { 5, 6 } }; + +int +main (void) +{ + if (e.c->a->i != 1 || e.c->a->j != 2) + abort (); + if (e.c->b->i != 3 || e.c->b->j != 4) + abort (); + if (e.d->i != 5 || e.d->j != 6) + abort (); + return 0; +} diff --git a/test/unimplemented/alloca/20010122-1.c b/test/unimplemented/alloca/20010122-1.c new file mode 100644 index 0000000..280e3d4 --- /dev/null +++ b/test/unimplemented/alloca/20010122-1.c @@ -0,0 +1,202 @@ + +extern void exit (int); +extern void abort (void); +extern void *alloca (__SIZE_TYPE__); +char *dummy (void); + +#define NOINLINE __attribute__((noinline)) + +void *save_ret1[6]; +void *test4a (char *); +void *test5a (char *); +void *test6a (char *); + +void NOINLINE *test1 (void) +{ + void * temp; + temp = __builtin_return_address (0); + return temp; +} + +void NOINLINE *test2 (void) +{ + void * temp; + dummy (); + temp = __builtin_return_address (0); + return temp; +} + +void NOINLINE *test3 (void) +{ + void * temp; + temp = __builtin_return_address (0); + dummy (); + return temp; +} + +void NOINLINE *test4 (void) +{ + char * save = (char*) alloca (4); + + return test4a (save); +} + +void *NOINLINE test4a (char * p) +{ + void * temp; + temp = __builtin_return_address (1); + return temp; +} + +void NOINLINE *test5 (void) +{ + char * save = (char*) alloca (4); + + return test5a (save); +} + +void NOINLINE *test5a (char * p) +{ + void * temp; + dummy (); + temp = __builtin_return_address (1); + return temp; +} + +void NOINLINE *test6 (void) +{ + char * save = (char*) alloca (4); + + return test6a (save); +} + +void NOINLINE *test6a (char * p) +{ + void * temp; + temp = __builtin_return_address (1); + dummy (); + return temp; +} + +void *(*func1[6])(void) = { test1, test2, test3, test4, test5, test6 }; + +char * NOINLINE call_func1 (int i) +{ + save_ret1[i] = func1[i] (); +} + +static void *ret_addr; +void *save_ret2[6]; +void test10a (char *); +void test11a (char *); +void test12a (char *); + +void NOINLINE test7 (void) +{ + ret_addr = __builtin_return_address (0); + return; +} + +void NOINLINE test8 (void) +{ + dummy (); + ret_addr = __builtin_return_address (0); + return; +} + +void NOINLINE test9 (void) +{ + ret_addr = __builtin_return_address (0); + dummy (); + return; +} + +void NOINLINE test10 (void) +{ + char * save = (char*) alloca (4); + + test10a (save); +} + +void NOINLINE test10a (char * p) +{ + ret_addr = __builtin_return_address (1); + return; +} + +void NOINLINE test11 (void) +{ + char * save = (char*) alloca (4); + + test11a (save); +} + +void NOINLINE test11a (char * p) +{ + dummy (); + ret_addr = __builtin_return_address (1); + return; +} + +void NOINLINE test12 (void) +{ + char * save = (char*) alloca (4); + + test12a (save); +} + +void NOINLINE test12a (char * p) +{ + ret_addr = __builtin_return_address (1); + dummy (); + return; +} + +char * dummy (void) +{ + char * save = (char*) alloca (4); + + return save; +} + +void (*func2[6])(void) = { test7, test8, test9, test10, test11, test12 }; + +void NOINLINE call_func2 (int i) +{ + func2[i] (); + save_ret2[i] = ret_addr; +} + +int main (void) +{ + int i; + + for (i = 0; i < 6; i++) { + call_func1(i); + } + + if (save_ret1[0] != save_ret1[1] + || save_ret1[1] != save_ret1[2]) + abort (); + if (save_ret1[3] != save_ret1[4] + || save_ret1[4] != save_ret1[5]) + abort (); + if (save_ret1[3] && save_ret1[0] != save_ret1[3]) + abort (); + + + for (i = 0; i < 6; i++) { + call_func2(i); + } + + if (save_ret2[0] != save_ret2[1] + || save_ret2[1] != save_ret2[2]) + abort (); + if (save_ret2[3] != save_ret2[4] + || save_ret2[4] != save_ret2[5]) + abort (); + if (save_ret2[3] && save_ret2[0] != save_ret2[3]) + abort (); + + exit (0); +} diff --git a/test/unimplemented/alloca/20020314-1.c b/test/unimplemented/alloca/20020314-1.c new file mode 100644 index 0000000..28288c8 --- /dev/null +++ b/test/unimplemented/alloca/20020314-1.c @@ -0,0 +1,36 @@ +void f(void * a, double y) +{ +} + +double g (double a, double b, double c, double d) +{ + double x, y, z; + void *p; + + x = a + b; + y = c * d; + + p = alloca (16); + + f(p, y); + z = x * y * a; + + return z + b; +} + +main () +{ + double a, b, c, d; + a = 1.0; + b = 0.0; + c = 10.0; + d = 0.0; + + if (g (a, b, c, d) != 0.0) + abort (); + + if (a != 1.0 || b != 0.0 || c != 10.0 || d != 0.0) + abort (); + + exit (0); +} diff --git a/test/unimplemented/alloca/20021113-1.c b/test/unimplemented/alloca/20021113-1.c new file mode 100644 index 0000000..420926d --- /dev/null +++ b/test/unimplemented/alloca/20021113-1.c @@ -0,0 +1,17 @@ +/* This program tests a data flow bug that would cause constant propagation + to propagate constants through function calls. */ + +foo (int *p) +{ + *p = 10; +} + +main() +{ + int *ptr = alloca (sizeof (int)); + *ptr = 5; + foo (ptr); + if (*ptr == 5) + abort (); + exit (0); +} diff --git a/test/unimplemented/alloca/20040811-1.c b/test/unimplemented/alloca/20040811-1.c new file mode 100644 index 0000000..62f377a --- /dev/null +++ b/test/unimplemented/alloca/20040811-1.c @@ -0,0 +1,19 @@ +/* Ensure that we deallocate X when branching back before its + declaration. */ + +void *volatile p; + +int +main (void) +{ + int n = 0; + lab:; + int x[n % 1000 + 1]; + x[0] = 1; + x[n % 1000] = 2; + p = x; + n++; + if (n < 1000000) + goto lab; + return 0; +} diff --git a/test/unimplemented/alloca/941202-1.c b/test/unimplemented/alloca/941202-1.c new file mode 100644 index 0000000..72d0b33 --- /dev/null +++ b/test/unimplemented/alloca/941202-1.c @@ -0,0 +1,21 @@ +g (x, y) +{ + if (x != 3) + abort (); +} + +static inline +f (int i) +{ + int *tmp; + + tmp = (int *) alloca (sizeof (i)); + *tmp = i; + g (*tmp, 0); +} + +main () +{ + f (3); + exit (0); +}; diff --git a/test/unimplemented/alloca/alloca-1.c b/test/unimplemented/alloca/alloca-1.c new file mode 100644 index 0000000..a8d1384 --- /dev/null +++ b/test/unimplemented/alloca/alloca-1.c @@ -0,0 +1,21 @@ +/* Verify that alloca storage is sufficiently aligned. */ +/* ??? May fail if BIGGEST_ALIGNMENT > STACK_BOUNDARY. Which, I guess + can only happen on !STRICT_ALIGNMENT targets. */ + +typedef __SIZE_TYPE__ size_t; + +struct dummy { int x __attribute__((aligned)); }; +#define BIGGEST_ALIGNMENT __alignof__(struct dummy) + +_Bool foo(void) +{ + char *p = __builtin_alloca(32); + return ((size_t)p & (BIGGEST_ALIGNMENT - 1)) == 0; +} + +int main() +{ + if (!foo()) + abort (); + return 0; +} diff --git a/test/unimplemented/alloca/built-in-setjmp.c b/test/unimplemented/alloca/built-in-setjmp.c new file mode 100644 index 0000000..9da7878 --- /dev/null +++ b/test/unimplemented/alloca/built-in-setjmp.c @@ -0,0 +1,39 @@ +extern int strcmp(const char *, const char *); +extern char *strcpy(char *, const char *); +extern void abort(void); +extern void exit(int); + +void *buf[20]; + +void __attribute__((noinline)) +sub2 (void) +{ + __builtin_longjmp (buf, 1); +} + +int +main () +{ + char *p = (char *) __builtin_alloca (20); + + strcpy (p, "test"); + + if (__builtin_setjmp (buf)) + { + if (strcmp (p, "test") != 0) + abort (); + + exit (0); + } + + { + int *q = (int *) __builtin_alloca (p[2] * sizeof (int)); + int i; + + for (i = 0; i < p[2]; i++) + q[i] = 0; + + while (1) + sub2 (); + } +} diff --git a/test/unimplemented/asm/990130-1.c b/test/unimplemented/asm/990130-1.c new file mode 100644 index 0000000..c38ecdd --- /dev/null +++ b/test/unimplemented/asm/990130-1.c @@ -0,0 +1,23 @@ +int count = 0; +int dummy; + +static int * +bar(void) +{ + ++count; + return &dummy; +} + +static void +foo(void) +{ + asm("" : "+r"(*bar())); +} + +main() +{ + foo(); + if (count != 1) + abort(); + exit(0); +} diff --git a/test/unimplemented/builtin/20030811-1.c b/test/unimplemented/builtin/20030811-1.c new file mode 100644 index 0000000..2ac59c0 --- /dev/null +++ b/test/unimplemented/builtin/20030811-1.c @@ -0,0 +1,35 @@ +/* Origin: PR target/11535 from H. J. Lu */ + +void vararg (int i, ...) +{ + (void) i; +} + +int i0[0], i1; + +void test1 (void) +{ + int a = (int) (long long) __builtin_return_address (0); + vararg (0, a); +} + +void test2 (void) +{ + i0[0] = (int) (long long) __builtin_return_address (0); +} + +void test3 (void) +{ + i1 = (int) (long long) __builtin_return_address (0); +} + +void test4 (void) +{ + volatile long long a = (long long) __builtin_return_address (0); + i0[0] = (int) a; +} + +int main (void) +{ + return 0; +} diff --git a/test/unimplemented/builtin/frame-address.c b/test/unimplemented/builtin/frame-address.c new file mode 100644 index 0000000..942f5c5 --- /dev/null +++ b/test/unimplemented/builtin/frame-address.c @@ -0,0 +1,43 @@ +int check_fa_work (const char *, const char *) __attribute__((noinline)); +int check_fa_mid (const char *) __attribute__((noinline)); +int check_fa (char *) __attribute__((noinline)); +int how_much (void) __attribute__((noinline)); + +int check_fa_work (const char *c, const char *f) +{ + const char d = 0; + + if (c >= &d) + return c >= f && f >= &d; + else + return c <= f && f <= &d; +} + +int check_fa_mid (const char *c) +{ + const char *f = __builtin_frame_address (0); + + /* Prevent a tail call to check_fa_work, eliding the current stack frame. */ + return check_fa_work (c, f) != 0; +} + +int check_fa (char *unused) +{ + const char c = 0; + + return check_fa_mid (&c); +} + +int how_much (void) +{ + return 8; +} + +int main (void) +{ + char *unused = __builtin_alloca (how_much ()); + + if (!check_fa(unused)) + abort(); + return 0; +} diff --git a/test/unimplemented/builtin/pr17377.c b/test/unimplemented/builtin/pr17377.c new file mode 100644 index 0000000..0be6f0a --- /dev/null +++ b/test/unimplemented/builtin/pr17377.c @@ -0,0 +1,59 @@ +/* PR target/17377 + Bug in code emitted by "return" pattern on CRIS: missing pop of + forced return address on stack. */ +int calls = 0; + +void *f (int) __attribute__ ((__noinline__)); +void * +f (int i) +{ + /* The code does a little brittle song and dance to trig the "return" + pattern instead of the function epilogue. This must still be a + leaf function for the bug to be exposed. */ + + if (calls++ == 0) + return __builtin_return_address (0); + + switch (i) + { + case 1: + return f; + case 0: + return __builtin_return_address (0); + } + return 0; +} + +int x; + +void *y (int i) __attribute__ ((__noinline__)); +void * +y (int i) +{ + x = 0; + + /* This must not be a sibling call: the return address must appear + constant for different calls to this function. Postincrementing x + catches otherwise unidentified multiple returns (e.g. through the + return-address register and then this epilogue popping the address + stored on stack in "f"). */ + return (char *) f (i) + x++; +} + +int +main (void) +{ + void *v = y (4); + if (y (1) != f + /* Can't reasonably check the validity of the return address + above, but it's not that important: the test-case will probably + crash on the first call to f with the bug present, or it will + run wild including returning early (in y or here), so we also + try and check the number of calls. */ + || y (0) != v + || y (3) != 0 + || y (-1) != 0 + || calls != 5) + abort (); + exit (0); +} diff --git a/test/unimplemented/calloc/20020406-1.c b/test/unimplemented/calloc/20020406-1.c new file mode 100644 index 0000000..69a82f6 --- /dev/null +++ b/test/unimplemented/calloc/20020406-1.c @@ -0,0 +1,126 @@ +// Origin: abbott@dima.unige.it +// PR c/5120 + +extern void * malloc (__SIZE_TYPE__); +extern void * calloc (__SIZE_TYPE__, __SIZE_TYPE__); + +typedef unsigned int FFelem; + +FFelem FFmul(const FFelem x, const FFelem y) +{ + return x; +} + + +struct DUPFFstruct +{ + int maxdeg; + int deg; + FFelem *coeffs; +}; + +typedef struct DUPFFstruct *DUPFF; + + +int DUPFFdeg(const DUPFF f) +{ + return f->deg; +} + + +DUPFF DUPFFnew(const int maxdeg) +{ + DUPFF ans = (DUPFF)malloc(sizeof(struct DUPFFstruct)); + ans->coeffs = 0; + if (maxdeg >= 0) ans->coeffs = (FFelem*)calloc(maxdeg+1,sizeof(FFelem)); + ans->maxdeg = maxdeg; + ans->deg = -1; + return ans; +} + +void DUPFFfree(DUPFF x) +{ +} + +void DUPFFswap(DUPFF x, DUPFF y) +{ +} + + +DUPFF DUPFFcopy(const DUPFF x) +{ + return x; +} + + +void DUPFFshift_add(DUPFF f, const DUPFF g, int deg, const FFelem coeff) +{ +} + + +DUPFF DUPFFexgcd(DUPFF *fcofac, DUPFF *gcofac, const DUPFF f, const DUPFF g) +{ + DUPFF u, v, uf, ug, vf, vg; + FFelem q, lcu, lcvrecip, p; + int df, dg, du, dv; + + printf("DUPFFexgcd called on degrees %d and %d\n", DUPFFdeg(f), DUPFFdeg(g)); + if (DUPFFdeg(f) < DUPFFdeg(g)) return DUPFFexgcd(gcofac, fcofac, g, f); /*** BUG IN THIS LINE ***/ + if (DUPFFdeg(f) != 2 || DUPFFdeg(g) != 1) abort(); + if (f->coeffs[0] == 0) return f; + /****** NEVER REACH HERE IN THE EXAMPLE ******/ + p = 2; + + df = DUPFFdeg(f); if (df < 0) df = 0; /* both inputs are zero */ + dg = DUPFFdeg(g); if (dg < 0) dg = 0; /* one input is zero */ + u = DUPFFcopy(f); + v = DUPFFcopy(g); + + uf = DUPFFnew(dg); uf->coeffs[0] = 1; uf->deg = 0; + ug = DUPFFnew(df); + vf = DUPFFnew(dg); + vg = DUPFFnew(df); vg->coeffs[0] = 1; vg->deg = 0; + + while (DUPFFdeg(v) > 0) + { + dv = DUPFFdeg(v); + lcvrecip = FFmul(1, v->coeffs[dv]); + while (DUPFFdeg(u) >= dv) + { + du = DUPFFdeg(u); + lcu = u->coeffs[du]; + q = FFmul(lcu, lcvrecip); + DUPFFshift_add(u, v, du-dv, p-q); + DUPFFshift_add(uf, vf, du-dv, p-q); + DUPFFshift_add(ug, vg, du-dv, p-q); + } + DUPFFswap(u, v); + DUPFFswap(uf, vf); + DUPFFswap(ug, vg); + } + if (DUPFFdeg(v) == 0) + { + DUPFFswap(u, v); + DUPFFswap(uf, vf); + DUPFFswap(ug, vg); + } + DUPFFfree(vf); + DUPFFfree(vg); + DUPFFfree(v); + *fcofac = uf; + *gcofac = ug; + return u; +} + + + +int main() +{ + DUPFF f, g, cf, cg, h; + f = DUPFFnew(1); f->coeffs[1] = 1; f->deg = 1; + g = DUPFFnew(2); g->coeffs[2] = 1; g->deg = 2; + + printf("calling DUPFFexgcd on degrees %d and %d\n", DUPFFdeg(f), DUPFFdeg(g)) ; + h = DUPFFexgcd(&cf, &cg, f, g); + return 0; +} diff --git a/test/unimplemented/complex/20010605-2.c b/test/unimplemented/complex/20010605-2.c new file mode 100644 index 0000000..09c7f76 --- /dev/null +++ b/test/unimplemented/complex/20010605-2.c @@ -0,0 +1,36 @@ +void foo (), bar (), baz (); +int main () +{ + __complex__ double x; + __complex__ float y; + __complex__ long double z; + __real__ x = 1.0; + __imag__ x = 2.0; + foo (x); + __real__ y = 3.0f; + __imag__ y = 4.0f; + bar (y); + __real__ z = 5.0L; + __imag__ z = 6.0L; + baz (z); + exit (0); +} + +void foo (__complex__ double x) +{ + if (__real__ x != 1.0 || __imag__ x != 2.0) + abort (); +} + +void bar (__complex__ float x) +{ + if (__real__ x != 3.0f || __imag__ x != 4.0f) + abort (); +} + +void baz (__complex__ long double x) +{ + if (__real__ x != 5.0L || __imag__ x != 6.0L) + abort (); +} + diff --git a/test/unimplemented/complex/20020227-1.c b/test/unimplemented/complex/20020227-1.c new file mode 100644 index 0000000..0f83088 --- /dev/null +++ b/test/unimplemented/complex/20020227-1.c @@ -0,0 +1,30 @@ +/* This testcase failed on mmix-knuth-mmixware. Problem was with storing + to an unaligned mem:SC, gcc tried doing it by parts from a (concat:SC + (reg:SF 293) (reg:SF 294)). */ + +typedef __complex__ float cf; +struct x { char c; cf f; } __attribute__ ((__packed__)); +extern void f2 (struct x*); +extern void f1 (void); +int +main (void) +{ + f1 (); + exit (0); +} + +void +f1 (void) +{ + struct x s; + s.f = 1; + s.c = 42; + f2 (&s); +} + +void +f2 (struct x *y) +{ + if (y->f != 1 || y->c != 42) + abort (); +} diff --git a/test/unimplemented/complex/20020411-1.c b/test/unimplemented/complex/20020411-1.c new file mode 100644 index 0000000..89e2bae --- /dev/null +++ b/test/unimplemented/complex/20020411-1.c @@ -0,0 +1,25 @@ +/* PR optimization/6177 + This testcase ICEd because expr.c did not expect to see a CONCAT + as array rtl. */ + +extern void abort (void); +extern void exit (int); + +__complex__ float foo (void) +{ + __complex__ float f[1]; + __real__ f[0] = 1.0; + __imag__ f[0] = 1.0; + f[0] = __builtin_conjf (f[0]); + return f[0]; +} + +int main (void) +{ + __complex__ double d[1]; + d[0] = foo (); + if (__real__ d[0] != 1.0 + || __imag__ d[0] != -1.0) + abort (); + exit (0); +} diff --git a/test/unimplemented/complex/20030910-1.c b/test/unimplemented/complex/20030910-1.c new file mode 100644 index 0000000..6c84913 --- /dev/null +++ b/test/unimplemented/complex/20030910-1.c @@ -0,0 +1,13 @@ +/* The gimplifier was inserting unwanted temporaries for REALPART_EXPR + nodes. These need to be treated like a COMPONENT_REF so their address can + be taken. */ + +int main() +{ + __complex double dc; + double *dp = &(__real dc); + *dp = 3.14; + if ((__real dc) != 3.14) abort(); + exit (0); +} + diff --git a/test/unimplemented/complex/20041124-1.c b/test/unimplemented/complex/20041124-1.c new file mode 100644 index 0000000..51ce253 --- /dev/null +++ b/test/unimplemented/complex/20041124-1.c @@ -0,0 +1,10 @@ +struct s { _Complex unsigned short x; }; +struct s gs = { 100 + 200i }; +struct s __attribute__((noinline)) foo (void) { return gs; } + +int main () +{ + if (foo ().x != gs.x) + abort (); + exit (0); +} diff --git a/test/unimplemented/complex/20041201-1.c b/test/unimplemented/complex/20041201-1.c new file mode 100644 index 0000000..ec588b2 --- /dev/null +++ b/test/unimplemented/complex/20041201-1.c @@ -0,0 +1,15 @@ +/* PR rtl-opt/15289 */ + +typedef struct { _Complex char a; _Complex char b; } Scc2; + +Scc2 s = { 1+2i, 3+4i }; + +int checkScc2 (Scc2 s) +{ + return s.a != 1+2i || s.b != 3+4i; +} + +int main (void) +{ + return checkScc2 (s); +} diff --git a/test/unimplemented/complex/20050121-1.c b/test/unimplemented/complex/20050121-1.c new file mode 100644 index 0000000..9d5dec4 --- /dev/null +++ b/test/unimplemented/complex/20050121-1.c @@ -0,0 +1,63 @@ +/* PR middle-end/19551 */ + +extern void abort (); + +#define T(type, name) \ +__attribute__((pure)) _Complex type \ +foo_##name (int x) \ +{ \ + _Complex type r; \ + __real r = x + 1; \ + __imag r = x - 1; \ + return r; \ +} \ + \ +void \ +bar_##name (type *x) \ +{ \ + *x = __real foo_##name (5); \ +} \ + \ +void \ +baz_##name (type *x) \ +{ \ + *x = __imag foo_##name (5); \ +} + +typedef long double ldouble_t; +typedef long long llong; + +T (float, float) +T (double, double) +T (long double, ldouble_t) +T (char, char) +T (short, short) +T (int, int) +T (long, long) +T (long long, llong) +#undef T + +int +main (void) +{ +#define T(type, name) \ + { \ + type var = 0; \ + bar_##name (&var); \ + if (var != 6) \ + abort (); \ + var = 0; \ + baz_##name (&var); \ + if (var != 4) \ + abort (); \ + } + T (float, float) + T (double, double) + T (long double, ldouble_t) + T (char, char) + T (short, short) + T (int, int) + T (long, long) + T (long long, llong) + return 0; +} diff --git a/test/unimplemented/complex/20070614-1.c b/test/unimplemented/complex/20070614-1.c new file mode 100644 index 0000000..fa44f7f --- /dev/null +++ b/test/unimplemented/complex/20070614-1.c @@ -0,0 +1,33 @@ +extern void abort (void); + +_Complex v = 3.0 + 1.0iF; + +void +foo (_Complex z, int *x) +{ + if (z != v) + abort (); +} + +_Complex bar (_Complex z) __attribute__ ((pure)); +_Complex +bar (_Complex z) +{ + return v; +} + +int +baz (void) +{ + int a, i; + for (i = 0; i < 6; i++) + foo (bar (1.0iF * i), &a); + return 0; +} + +int +main () +{ + baz (); + return 0; +} diff --git a/test/unimplemented/complex/complex-1.c b/test/unimplemented/complex/complex-1.c new file mode 100644 index 0000000..5910179 --- /dev/null +++ b/test/unimplemented/complex/complex-1.c @@ -0,0 +1,40 @@ +double +g0 (double x) +{ + return 1.0; +} + +double +g1 (double x) +{ + return -1.0; +} + +double +g2 (double x) +{ + return 0.0; +} + +__complex__ double +xcexp (__complex__ double x) +{ + double r; + + r = g0 (__real__ x); + __real__ x = r * g1 (__imag__ x); + __imag__ x = r * g2 (__imag__ x); + return x; +} + +main () +{ + __complex__ double x; + + x = xcexp (1.0i); + if (__real__ x != -1.0) + abort (); + if (__imag__ x != 0.0) + abort (); + exit (0); +} diff --git a/test/unimplemented/complex/complex-2.c b/test/unimplemented/complex/complex-2.c new file mode 100644 index 0000000..9634c79 --- /dev/null +++ b/test/unimplemented/complex/complex-2.c @@ -0,0 +1,27 @@ +__complex__ double +f (__complex__ double x, __complex__ double y) +{ + x += y; + return x; +} + +__complex__ double ag = 1.0 + 1.0i; +__complex__ double bg = -2.0 + 2.0i; + +main () +{ + __complex__ double a, b, c; + + a = ag; + b = -2.0 + 2.0i; + c = f (a, b); + + if (a != 1.0 + 1.0i) + abort (); + if (b != -2.0 + 2.0i) + abort (); + if (c != -1.0 + 3.0i) + abort (); + + exit (0); +} diff --git a/test/unimplemented/complex/complex-3.c b/test/unimplemented/complex/complex-3.c new file mode 100644 index 0000000..4297cf1 --- /dev/null +++ b/test/unimplemented/complex/complex-3.c @@ -0,0 +1,25 @@ +struct complex +{ + float r; + float i; +}; + +struct complex cmplx (float, float); + +struct complex +f (float a, float b) +{ + struct complex c; + c.r = a; + c.i = b; + return c; +} + +main () +{ + struct complex z = f (1.0, 0.0); + + if (z.r != 1.0 || z.i != 0.0) + abort (); + exit (0); +} diff --git a/test/unimplemented/complex/complex-4.c b/test/unimplemented/complex/complex-4.c new file mode 100644 index 0000000..1c458d2 --- /dev/null +++ b/test/unimplemented/complex/complex-4.c @@ -0,0 +1,9 @@ +main () +{ + if ((__complex__ double) 0.0 != (__complex__ double) (-0.0)) + abort (); + + if (0.0 != -0.0) + abort (); + exit (0); +} diff --git a/test/unimplemented/complex/complex-5.c b/test/unimplemented/complex/complex-5.c new file mode 100644 index 0000000..a333808 --- /dev/null +++ b/test/unimplemented/complex/complex-5.c @@ -0,0 +1,20 @@ +float __complex__ +p (float __complex__ a, float __complex__ b) +{ + return a + b; +} + +float __complex__ x = 1.0 + 14.0 * (1.0fi); +float __complex__ y = 7.0 + 5.0 * (1.0fi); +float __complex__ w = 8.0 + 19.0 * (1.0fi); +float __complex__ z; + +main () +{ + + z = p (x,y); + y = p (x, 1.0f / z); + if (z != w) + abort (); + exit (0); +} diff --git a/test/unimplemented/complex/complex-6.c b/test/unimplemented/complex/complex-6.c new file mode 100644 index 0000000..bbb8c8d --- /dev/null +++ b/test/unimplemented/complex/complex-6.c @@ -0,0 +1,59 @@ +/* This test tests complex conjugate and passing/returning of + complex parameter. */ + +#include +#include + +int err; + +#define TEST(TYPE, FUNC) \ +__complex__ TYPE \ +ctest_ ## FUNC (__complex__ TYPE x) \ +{ \ + __complex__ TYPE res; \ + \ + res = ~x; \ + \ + return res; \ +} \ + \ +void \ +test_ ## FUNC (void) \ +{ \ + __complex__ TYPE res, x; \ + \ + x = 1.0 + 2.0i; \ + \ + res = ctest_ ## FUNC (x); \ + \ + if (res != 1.0 - 2.0i) \ + { \ + printf ("test_" #FUNC " failed\n"); \ + ++err; \ + } \ +} + + +TEST(float, float) +TEST(double, double) +TEST(long double, long_double) +TEST(int, int) +TEST(long int, long_int) + +int +main (void) +{ + + err = 0; + + test_float (); + test_double (); + test_long_double (); + test_int (); + test_long_int (); + + if (err != 0) + abort (); + + return 0; +} diff --git a/test/unimplemented/complex/complex-7.c b/test/unimplemented/complex/complex-7.c new file mode 100644 index 0000000..c5bf89d --- /dev/null +++ b/test/unimplemented/complex/complex-7.c @@ -0,0 +1,56 @@ +/* Test argument passing of complex values. The MIPS64 compiler had a + bug when they were split between registers and the stack. */ +/* Origin: Joseph Myers */ + +volatile _Complex float f1 = 1.1f + 2.2if; +volatile _Complex float f2 = 3.3f + 4.4if; +volatile _Complex float f3 = 5.5f + 6.6if; +volatile _Complex float f4 = 7.7f + 8.8if; +volatile _Complex float f5 = 9.9f + 10.1if; +volatile _Complex double d1 = 1.1 + 2.2i; +volatile _Complex double d2 = 3.3 + 4.4i; +volatile _Complex double d3 = 5.5 + 6.6i; +volatile _Complex double d4 = 7.7 + 8.8i; +volatile _Complex double d5 = 9.9 + 10.1i; +volatile _Complex long double ld1 = 1.1L + 2.2iL; +volatile _Complex long double ld2 = 3.3L + 4.4iL; +volatile _Complex long double ld3 = 5.5L + 6.6iL; +volatile _Complex long double ld4 = 7.7L + 8.8iL; +volatile _Complex long double ld5 = 9.9L + 10.1iL; + +extern void abort (void); +extern void exit (int); + +__attribute__((noinline)) void +check_float (int a, _Complex float a1, _Complex float a2, + _Complex float a3, _Complex float a4, _Complex float a5) +{ + if (a1 != f1 || a2 != f2 || a3 != f3 || a4 != f4 || a5 != f5) + abort (); +} + +__attribute__((noinline)) void +check_double (int a, _Complex double a1, _Complex double a2, + _Complex double a3, _Complex double a4, _Complex double a5) +{ + if (a1 != d1 || a2 != d2 || a3 != d3 || a4 != d4 || a5 != d5) + abort (); +} + +__attribute__((noinline)) void +check_long_double (int a, _Complex long double a1, _Complex long double a2, + _Complex long double a3, _Complex long double a4, + _Complex long double a5) +{ + if (a1 != ld1 || a2 != ld2 || a3 != ld3 || a4 != ld4 || a5 != ld5) + abort (); +} + +int +main (void) +{ + check_float (0, f1, f2, f3, f4, f5); + check_double (0, d1, d2, d3, d4, d5); + check_long_double (0, ld1, ld2, ld3, ld4, ld5); + exit (0); +} diff --git a/test/unimplemented/dg/20020201-1.c b/test/unimplemented/dg/20020201-1.c new file mode 100644 index 0000000..6002c59 --- /dev/null +++ b/test/unimplemented/dg/20020201-1.c @@ -0,0 +1,42 @@ +/* Check that arc profiling instrumentation code does not cause problems for + a program that calls functions that are likely to be in a shared library. + This was added to check the fix for PR target/5469, which prevents arc + profiling code from being inserted between a call and the restore of the + call-clobbered global pointer. */ + +/* { dg-options "-fprofile-arcs" } */ +/* { dg-do run { target native } } */ + +extern void abort (void); +extern void exit (int); + +int rand (void); +void srand (unsigned int seed); + +int globvar; + +void +leave (int i) +{ + if (i != 0) + abort (); + exit (0); +} + +void +doit () +{ + srand (12); + globvar = rand (); + if (rand () > 0) + globvar = 0; + leave (globvar); +} + +int +main () +{ + doit (); +} + +/* { dg-final { cleanup-coverage-files } } */ diff --git a/test/unimplemented/dg/alias-7.c b/test/unimplemented/dg/alias-7.c new file mode 100644 index 0000000..591c302 --- /dev/null +++ b/test/unimplemented/dg/alias-7.c @@ -0,0 +1,20 @@ +/* { dg-do run } */ +/* { dg-require-alias "" } */ +/* { dg-options "-O2" } */ + +extern void abort (void); + +#define ASMNAME(cname) ASMNAME2 (__USER_LABEL_PREFIX__, cname) +#define ASMNAME2(prefix, cname) STRING (prefix) cname +#define STRING(x) #x + +int foo __asm__ (ASMNAME ("foo")) __attribute__((nocommon)); +extern __typeof (foo) bar __attribute__ ((weak, alias ("foo"))); + +int +main (void) +{ + if (&foo != &bar || foo || bar) + abort (); + return bar; +} diff --git a/test/unimplemented/dg/attr-weakref-1.c b/test/unimplemented/dg/attr-weakref-1.c new file mode 100644 index 0000000..19a511b --- /dev/null +++ b/test/unimplemented/dg/attr-weakref-1.c @@ -0,0 +1,227 @@ +// { dg-do run } +// { dg-require-weak "" } +// On darwin, we use attr-weakref-1-darwin.c. +// This test requires support for undefined weak symbols. This support +// is not available on hppa*-*-hpux*. The test is skipped rather than +// xfailed to suppress the warning that would otherwise arise. +// { dg-skip-if "" { "*-*-darwin*" "hppa*-*-hpux*" } "*" { "" } } +// { dg-options "-O2" } +// { dg-additional-sources "attr-weakref-1a.c" } + +// Copyright 2005 Free Software Foundation, Inc. +// Contributed by Alexandre Oliva + +// Torture test for weakrefs. The first letter of an identifier +// indicates whether/how it is defined; the second letter indicates +// whether it is part of a variable or function test; the number that +// follows is a test counter, and a letter that may follow enables +// multiple identifiers within the same test (e.g., multiple weakrefs +// or pointers to the same identifier). + +// Identifiers starting with W are weakrefs; those with p are +// pointers; those with g are global definitions; those with l are +// local definitions; those with w are expected to be weak undefined +// in the symbol table; those with u are expected to be marked as +// non-weak undefined in the symbol table. + +#include + +#define USED __attribute__((used)) + +typedef int vtype; + +extern vtype wv1; +static vtype Wv1a __attribute__((weakref ("wv1"))); +static vtype *pv1a USED = &Wv1a; + +vtype gv2; +static vtype Wv2a __attribute__((weakref ("gv2"))); +static vtype *pv2a USED = &Wv2a; + +static vtype lv3; +static vtype Wv3a __attribute__((weakref ("lv3"))); +static vtype *pv3a USED = &Wv3a; + +extern vtype uv4; +static vtype Wv4a __attribute__((weakref ("uv4"))); +static vtype *pv4a USED = &Wv4a; +static vtype *pv4 USED = &uv4; + +static vtype Wv5a __attribute__((weakref ("uv5"))); +static vtype *pv5a USED = &Wv5a; +extern vtype uv5; +static vtype *pv5 USED = &uv5; + +static vtype Wv6a __attribute__((weakref ("wv6"))); +static vtype *pv6a USED = &Wv6a; +extern vtype wv6; + +static vtype Wv7a __attribute__((weakref ("uv7"))); +static vtype* USED fv7 (void) { + return &Wv7a; +} +extern vtype uv7; +static vtype* USED fv7a (void) { + return &uv7; +} + +extern vtype uv8; +static vtype* USED fv8a (void) { + return &uv8; +} +static vtype Wv8a __attribute__((weakref ("uv8"))); +static vtype* USED fv8 (void) { + return &Wv8a; +} + +extern vtype wv9 __attribute__((weak)); +static vtype Wv9a __attribute__((weakref ("wv9"))); +static vtype *pv9a USED = &Wv9a; + +static vtype Wv10a __attribute__((weakref ("Wv10b"))); +static vtype Wv10b __attribute__((weakref ("Wv10c"))); +static vtype Wv10c __attribute__((weakref ("Wv10d"))); +static vtype Wv10d __attribute__((weakref ("wv10"))); +extern vtype wv10; + +extern vtype wv11; +static vtype Wv11d __attribute__((weakref ("wv11"))); +static vtype Wv11c __attribute__((weakref ("Wv11d"))); +static vtype Wv11b __attribute__((weakref ("Wv11c"))); +static vtype Wv11a __attribute__((weakref ("Wv11b"))); + +static vtype Wv12 __attribute__((weakref ("wv12"))); +extern vtype wv12 __attribute__((weak)); + +static vtype Wv13 __attribute__((weakref ("wv13"))); +extern vtype wv13 __attribute__((weak)); + +static vtype Wv14a __attribute__((weakref ("wv14"))); +static vtype Wv14b __attribute__((weakref ("wv14"))); +extern vtype wv14 __attribute__((weak)); + +typedef void ftype(void); + +extern ftype wf1; +static ftype Wf1a __attribute__((weakref ("wf1"))); +static ftype *pf1a USED = &Wf1a; +static ftype Wf1c __attribute__((weakref)); +extern ftype Wf1c __attribute__((alias ("wf1"))); +static ftype *pf1c USED = &Wf1c; + +void gf2(void) {} +static ftype Wf2a __attribute__((weakref ("gf2"))); +static ftype *pf2a USED = &Wf2a; + +static void lf3(void) {} +static ftype Wf3a __attribute__((weakref ("lf3"))); +static ftype *pf3a USED = &Wf3a; + +extern ftype uf4; +static ftype Wf4a __attribute__((weakref ("uf4"))); +static ftype *pf4a USED = &Wf4a; +static ftype *pf4 USED = &uf4; + +static ftype Wf5a __attribute__((weakref ("uf5"))); +static ftype *pf5a USED = &Wf5a; +extern ftype uf5; +static ftype *pf5 USED = &uf5; + +static ftype Wf6a __attribute__((weakref ("wf6"))); +static ftype *pf6a USED = &Wf6a; +extern ftype wf6; + +static ftype Wf7a __attribute__((weakref ("uf7"))); +static ftype* USED ff7 (void) { + return &Wf7a; +} +extern ftype uf7; +static ftype* USED ff7a (void) { + return &uf7; +} + +extern ftype uf8; +static ftype* USED ff8a (void) { + return &uf8; +} +static ftype Wf8a __attribute__((weakref ("uf8"))); +static ftype* USED ff8 (void) { + return &Wf8a; +} + +extern ftype wf9 __attribute__((weak)); +static ftype Wf9a __attribute__((weakref ("wf9"))); +static ftype *pf9a USED = &Wf9a; + +static ftype Wf10a __attribute__((weakref ("Wf10b"))); +static ftype Wf10b __attribute__((weakref ("Wf10c"))); +static ftype Wf10c __attribute__((weakref ("Wf10d"))); +static ftype Wf10d __attribute__((weakref ("wf10"))); +extern ftype wf10; + +extern ftype wf11; +static ftype Wf11d __attribute__((weakref ("wf11"))); +static ftype Wf11c __attribute__((weakref ("Wf11d"))); +static ftype Wf11b __attribute__((weakref ("Wf11c"))); +static ftype Wf11a __attribute__((weakref ("Wf11b"))); + +static ftype Wf12 __attribute__((weakref ("wf12"))); +extern ftype wf12 __attribute__((weak)); + +static ftype Wf13 __attribute__((weakref ("wf13"))); +extern ftype wf13 __attribute__((weak)); + +static ftype Wf14a __attribute__((weakref ("wf14"))); +static ftype Wf14b __attribute__((weakref ("wf14"))); +extern ftype wf14 __attribute__((weak)); + +#ifndef __APPLE__ +#define chk(p) do { if (!p) abort (); } while (0) +#else +#define chk(p) /* */ +#endif + +int main () { + chk (!pv1a); + chk (pv2a); + chk (pv3a); + chk (pv4a); + chk (pv4); + chk (pv5a); + chk (pv5); + chk (!pv6a); + chk (fv7 ()); + chk (fv7a ()); + chk (fv8 ()); + chk (fv8a ()); + chk (!pv9a); + chk (!&Wv10a); + chk (!&Wv11a); + chk (!&Wv12); + chk (!&wv12); + chk (!&wv13); + chk (!&Wv14a); + + chk (!pf1a); + chk (!pf1c); + chk (pf2a); + chk (pf3a); + chk (pf4a); + chk (pf4); + chk (pf5a); + chk (pf5); + chk (!pf6a); + chk (ff7 ()); + chk (ff7a ()); + chk (ff8 ()); + chk (ff8a ()); + chk (!pf9a); + chk (!&Wf10a); + chk (!&Wf11a); + chk (!&Wf12); + chk (!&wf12); + chk (!&wf13); + chk (!&Wf14a); + + exit (0); +} diff --git a/test/unimplemented/dg/bitfld-9.c b/test/unimplemented/dg/bitfld-9.c new file mode 100644 index 0000000..1b293a6 --- /dev/null +++ b/test/unimplemented/dg/bitfld-9.c @@ -0,0 +1,124 @@ +/* Test -funsigned-bitfields works. */ +/* Origin: Joseph Myers */ +/* { dg-do run } */ +/* { dg-options "-funsigned-bitfields -fsigned-char" } */ + +typedef char c; +typedef signed char sc; +typedef unsigned char uc; +typedef short s; +typedef signed short ss; +typedef unsigned short us; +typedef n; +typedef int i; +typedef signed int si; +typedef unsigned int ui; +typedef long l; +typedef signed long sl; +typedef unsigned long ul; +typedef long long ll; +typedef signed long long sll; +typedef unsigned long long ull; + +typedef c ct; +typedef sc sct; +typedef uc uct; +typedef s st; +typedef ss sst; +typedef us ust; +typedef n nt; +typedef i it; +typedef si sit; +typedef ui uit; +typedef l lt; +typedef sl slt; +typedef ul ult; +typedef ll llt; +typedef sll sllt; +typedef ull ullt; + +struct foo { + char char0 : 1; + c char1 : 1; + ct char2 : 1; + signed char schar0 : 1; + sc schar1 : 1; + sct schar2 : 1; + unsigned char uchar0 : 1; + uc uchar1 : 1; + uct uchar2 : 1; + short short0 : 1; + s short1 : 1; + st short2 : 1; + signed short sshort0 : 1; + ss sshort1 : 1; + sst sshort2 : 1; + unsigned short ushort0 : 1; + us ushort1 : 1; + ust ushort2 : 1; + __attribute__((dummy)) int0 : 1; /* { dg-warning "attribute directive ignored" } */ + n int1 : 1; + nt int2 : 1; + int int3 : 1; + i int4 : 1; + it int5 : 1; + signed int sint0 : 1; + si sint1 : 1; + sit sint2 : 1; + unsigned int uint0 : 1; + ui uint1 : 1; + uit uint2 : 1; + long long0 : 1; + l long1 : 1; + lt long2 : 1; + signed long slong0 : 1; + sl slong1 : 1; + slt slong2 : 1; + unsigned long ulong0 : 1; + ul ulong1 : 1; + ult ulong2 : 1; +#if 0 + long long llong0 : 1; + ll llong1 : 1; + llt llong2 : 1; + signed long long sllong0 : 1; + sll sllong1 : 1; + sllt sllong2 : 1; + unsigned long long ullong0 : 1; + ull ullong1 : 1; + ullt ullong2 : 1; +#endif +}; + +struct foo x; + +extern void abort (void); +extern void exit (int); +extern void *memset (void *, int, __SIZE_TYPE__); + +int +main (void) +{ + memset (&x, (unsigned char)-1, sizeof(x)); + if (x.char0 != 1 || x.char1 != 1 || x.char2 != 1 + || x.schar0 != -1 || x.schar1 != -1 || x.schar2 != -1 + || x.uchar0 != 1 || x.uchar1 != 1 || x.uchar2 != 1 + || x.short0 != 1 || x.short1 != 1 || x.short2 != 1 + || x.sshort0 != -1 || x.sshort1 != -1 || x.sshort2 != -1 + || x.ushort0 != 1 || x.ushort1 != 1 || x.ushort2 != 1 + || x.int0 != 1 || x.int1 != 1 || x.int2 != 1 + || x.int3 != 1 || x.int4 != 1 || x.int5 != 1 + || x.sint0 != -1 || x.sint1 != -1 || x.sint2 != -1 + || x.uint0 != 1 || x.uint1 != 1 || x.uint2 != 1 + || x.long0 != 1 || x.long1 != 1 || x.long2 != 1 + || x.slong0 != -1 || x.slong1 != -1 || x.slong2 != -1 + || x.ulong0 != 1 || x.ulong1 != 1 || x.ulong2 != 1 +#if 0 + || x.llong0 != 1 || x.llong1 != 1 || x.llong2 != 1 + || x.sllong0 != -1 || x.sllong1 != -1 || x.sllong2 != -1 + || x.ullong0 != 1 || x.ullong1 != 1 || x.ullong2 != 1 +#endif + ) + abort (); + exit (0); +} diff --git a/test/unimplemented/dg/builtin/builtin-apply2.c b/test/unimplemented/dg/builtin/builtin-apply2.c new file mode 100644 index 0000000..a1ba20f --- /dev/null +++ b/test/unimplemented/dg/builtin/builtin-apply2.c @@ -0,0 +1,30 @@ +/* PR target/12503 */ +/* Origin: */ + +/* Verify that __builtin_apply behaves correctly on targets + with pre-pushed arguments (e.g. SPARC). */ + +/* { dg-do run } */ + + +#define INTEGER_ARG 5 + +extern void abort(void); + +void foo(char *name, double d, double e, double f, int g) +{ + if (g != INTEGER_ARG) + abort(); +} + +void bar(char *name, ...) +{ + __builtin_apply(foo, __builtin_apply_args(), 64); +} + +int main(void) +{ + bar("eeee", 5.444567, 8.90765, 4.567789, INTEGER_ARG); + + return 0; +} diff --git a/test/unimplemented/dg/builtin/builtin-apply3.c b/test/unimplemented/dg/builtin/builtin-apply3.c new file mode 100644 index 0000000..1335d09 --- /dev/null +++ b/test/unimplemented/dg/builtin/builtin-apply3.c @@ -0,0 +1,31 @@ +/* PR middle-end/12210 */ +/* Origin: Ossadchy Yury A. */ + +/* This used to fail on i686 because the argument was not copied + to the right location by __builtin_apply after the direct call. */ + +/* { dg-do run } */ + + +#define INTEGER_ARG 5 + +extern void abort(void); + +void foo(int arg) +{ + if (arg != INTEGER_ARG) + abort(); +} + +void bar(int arg) +{ + foo(arg); + __builtin_apply(foo, __builtin_apply_args(), 16); +} + +int main(void) +{ + bar(INTEGER_ARG); + + return 0; +} diff --git a/test/unimplemented/dg/builtin/builtin-apply4.c b/test/unimplemented/dg/builtin/builtin-apply4.c new file mode 100644 index 0000000..289694e --- /dev/null +++ b/test/unimplemented/dg/builtin/builtin-apply4.c @@ -0,0 +1,30 @@ +/* PR tree-optimization/20076 */ +/* { dg-options "-O2" } */ +/* { dg-do run } */ + +extern void abort (void); + +double +foo (int arg) +{ + if (arg != 116) + abort(); + return arg + 1; +} + +inline double +bar (int arg) +{ + foo (arg); + __builtin_return (__builtin_apply ((void (*) ()) foo, + __builtin_apply_args (), 16)); +} + +int +main (int argc, char **argv) +{ + if (bar (116) != 117.0) + abort (); + + return 0; +} diff --git a/test/unimplemented/dg/builtin/builtin-bswap-2.c b/test/unimplemented/dg/builtin/builtin-bswap-2.c new file mode 100644 index 0000000..745fed9 --- /dev/null +++ b/test/unimplemented/dg/builtin/builtin-bswap-2.c @@ -0,0 +1,20 @@ +/* { dg-do run } */ +/* { dg-require-effective-target stdint_types } */ +/* { dg-options "" } */ +#include + +extern void abort (void); + +int main (void) +{ + uint32_t a = 4; + uint32_t b; + + b = __builtin_bswap32 (a); + a = __builtin_bswap32 (b); + + if (b == 4 || a != 4) + abort (); + + return 0; +} diff --git a/test/unimplemented/dg/builtin/builtin-bswap-3.c b/test/unimplemented/dg/builtin/builtin-bswap-3.c new file mode 100644 index 0000000..031817e --- /dev/null +++ b/test/unimplemented/dg/builtin/builtin-bswap-3.c @@ -0,0 +1,20 @@ +/* { dg-do run } */ +/* { dg-require-effective-target stdint_types } */ +/* { dg-options "" } */ +#include + +extern void abort (void); + +int main (void) +{ + uint32_t a = 0x80000000; + uint32_t b; + + b = __builtin_bswap32 (a); + a = __builtin_bswap32 (b); + + if (b != 0x80 || a != 0x80000000) + abort (); + + return 0; +} diff --git a/test/unimplemented/dg/builtin/builtin-bswap-4.c b/test/unimplemented/dg/builtin/builtin-bswap-4.c new file mode 100644 index 0000000..03e190a --- /dev/null +++ b/test/unimplemented/dg/builtin/builtin-bswap-4.c @@ -0,0 +1,60 @@ +/* { dg-do run } */ +/* { dg-require-effective-target stdint_types } */ +/* { dg-options "-Wall" } */ + +#include + +#define MAKE_FUN(suffix, type) \ + type my_bswap##suffix(type x) { \ + type result = 0; \ + int shift; \ + for (shift = 0; shift < 8 * sizeof (type); shift += 8) \ + { \ + result <<= 8; \ + result |= (x >> shift) & 0xff; \ + } \ + return result; \ + } \ + +MAKE_FUN(32, uint32_t); +MAKE_FUN(64, uint64_t); + +extern void abort (void); + +#define NUMS32 \ + { \ + 0x00000000UL, \ + 0x11223344UL, \ + 0xffffffffUL, \ + } + +#define NUMS64 \ + { \ + 0x0000000000000000ULL, \ + 0x1122334455667788ULL, \ + 0xffffffffffffffffULL, \ + } + +uint32_t uint32_ts[] = + NUMS32; + +uint64_t uint64_ts[] = + NUMS64; + +#define N(table) (sizeof (table) / sizeof (table[0])) + +int +main (void) +{ + int i; + + for (i = 0; i < N(uint32_ts); i++) + if (__builtin_bswap32 (uint32_ts[i]) != my_bswap32 (uint32_ts[i])) + abort (); + + for (i = 0; i < N(uint64_ts); i++) + if (__builtin_bswap64 (uint64_ts[i]) != my_bswap64 (uint64_ts[i])) + abort (); + + return 0; +} diff --git a/test/unimplemented/dg/builtin/builtin-bswap-5.c b/test/unimplemented/dg/builtin/builtin-bswap-5.c new file mode 100644 index 0000000..ccac966 --- /dev/null +++ b/test/unimplemented/dg/builtin/builtin-bswap-5.c @@ -0,0 +1,16 @@ +/* { dg-do run } */ +/* { dg-options "-O" } */ +int +main (void) +{ + /* Test constant folding. */ + extern void link_error (void); + + if (__builtin_bswap32(0xaabbccdd) != 0xddccbbaa) + link_error (); + + if (__builtin_bswap64(0x1122334455667788ULL) != 0x8877665544332211ULL) + link_error (); + + return 0; +} diff --git a/test/unimplemented/dg/builtin/builtin-choose-expr.c b/test/unimplemented/dg/builtin/builtin-choose-expr.c new file mode 100644 index 0000000..045dc6c --- /dev/null +++ b/test/unimplemented/dg/builtin/builtin-choose-expr.c @@ -0,0 +1,88 @@ +/* { dg-do run } */ +/* { dg-options "-O1 -Wall" } */ + +#define choose __builtin_choose_expr + +/* Check the type of __builtin_choose_expr between E1 and E2, both + ways round and with both 0 and 1 as the condition. */ +#define ASSERT_COND_TYPE(E1, E2) \ + do { \ + typedef __typeof(E1) T1; \ + typedef __typeof(E2) T2; \ + typedef T1 **T1pp; \ + typedef T2 **T2pp; \ + typedef __typeof(choose (1, (E1), (E2))) T1a; \ + typedef __typeof(choose (0, (E2), (E1))) T1b; \ + typedef __typeof(choose (1, (E2), (E1))) T2a; \ + typedef __typeof(choose (0, (E1), (E2))) T2b; \ + typedef T1a **T1app; \ + typedef T1b **T1bpp; \ + typedef T2a **T2app; \ + typedef T2b **T2bpp; \ + T1pp t1 = 0; \ + T2pp t2 = 0; \ + T1app t1a = 0; \ + T1bpp t1b = 0; \ + T2app t2a = 0; \ + T2bpp t2b = 0; \ + t1 = t1a; \ + t1 = t1b; \ + t2 = t2a; \ + t2 = t2b; \ + } while (0) + + +extern void abort (); +extern void exit (); + +void bad () +{ + abort (); +} + +void good () +{ + exit (0); +} + +int main (void) +{ + signed char sc1, sc2; + void *v1; + int i, j; + double dd; + float f; + typedef void (*fpt)(void); + fpt triple; + struct S { int x, y; } pour, some, sugar; + union u { int p; } united, nations; + + if (__builtin_choose_expr (0, 12, 0) + || !__builtin_choose_expr (45, 5, 0) + || !__builtin_choose_expr (45, 3, 0)) + abort (); + + ASSERT_COND_TYPE (sc1, sc2); + ASSERT_COND_TYPE (v1, sc1); + ASSERT_COND_TYPE (i, j); + ASSERT_COND_TYPE (dd, main); + ASSERT_COND_TYPE ((float)dd, i); + ASSERT_COND_TYPE (4, f); + ASSERT_COND_TYPE (triple, some); + ASSERT_COND_TYPE (united, nations); + ASSERT_COND_TYPE (nations, main); + + pour.y = 69; + __builtin_choose_expr (0, bad (), sugar) = pour; + if (sugar.y != 69) + abort (); + + __builtin_choose_expr (sizeof (int), f, bad ()) = 3.5F; + + if (f != 3.5F) + abort (); + + __builtin_choose_expr (1, good, bad)(); + + exit (0); +} diff --git a/test/unimplemented/dg/builtin/builtin-object-size-1.c b/test/unimplemented/dg/builtin/builtin-object-size-1.c new file mode 100644 index 0000000..404b711 --- /dev/null +++ b/test/unimplemented/dg/builtin/builtin-object-size-1.c @@ -0,0 +1,436 @@ +/* { dg-do run } */ +/* { dg-options "-O2" } */ + +typedef __SIZE_TYPE__ size_t; +extern void abort (void); +extern void exit (int); +extern void *malloc (size_t); +extern void *calloc (size_t, size_t); +extern void *alloca (size_t); +extern void *memcpy (void *, const void *, size_t); +extern void *memset (void *, int, size_t); +extern char *strcpy (char *, const char *); + +struct A +{ + char a[10]; + int b; + char c[10]; +} y, w[4]; + +extern char exta[]; +extern char extb[30]; +extern struct A zerol[0]; + +void +__attribute__ ((noinline)) +test1 (void *q, int x) +{ + struct A a; + void *p = &a.a[3], *r; + char var[x + 10]; + if (x < 0) + r = &a.a[9]; + else + r = &a.c[1]; + if (__builtin_object_size (p, 0) + != sizeof (a) - __builtin_offsetof (struct A, a) - 3) + abort (); + if (__builtin_object_size (&a.c[9], 0) + != sizeof (a) - __builtin_offsetof (struct A, c) - 9) + abort (); + if (__builtin_object_size (q, 0) != (size_t) -1) + abort (); + if (__builtin_object_size (r, 0) + != sizeof (a) - __builtin_offsetof (struct A, a) - 9) + abort (); + if (x < 6) + r = &w[2].a[1]; + else + r = &a.a[6]; + if (__builtin_object_size (&y, 0) + != sizeof (y)) + abort (); + if (__builtin_object_size (w, 0) + != sizeof (w)) + abort (); + if (__builtin_object_size (&y.b, 0) + != sizeof (a) - __builtin_offsetof (struct A, b)) + abort (); + if (__builtin_object_size (r, 0) + != 2 * sizeof (w[0]) - __builtin_offsetof (struct A, a) - 1) + abort (); + if (x < 20) + r = malloc (30); + else + r = calloc (2, 16); + if (__builtin_object_size (r, 0) != 2 * 16) + abort (); + if (x < 20) + r = malloc (30); + else + r = calloc (2, 14); + if (__builtin_object_size (r, 0) != 30) + abort (); + if (x < 30) + r = malloc (sizeof (a)); + else + r = &a.a[3]; + if (__builtin_object_size (r, 0) != sizeof (a)) + abort (); + r = memcpy (r, "a", 2); + if (__builtin_object_size (r, 0) != sizeof (a)) + abort (); + r = memcpy (r + 2, "b", 2) + 2; + if (__builtin_object_size (r, 0) != sizeof (a) - 4) + abort (); + r = &a.a[4]; + r = memset (r, 'a', 2); + if (__builtin_object_size (r, 0) + != sizeof (a) - __builtin_offsetof (struct A, a) - 4) + abort (); + r = memset (r + 2, 'b', 2) + 2; + if (__builtin_object_size (r, 0) + != sizeof (a) - __builtin_offsetof (struct A, a) - 8) + abort (); + r = &a.a[1]; + r = strcpy (r, "ab"); + if (__builtin_object_size (r, 0) + != sizeof (a) - __builtin_offsetof (struct A, a) - 1) + abort (); + r = strcpy (r + 2, "cd") + 2; + if (__builtin_object_size (r, 0) + != sizeof (a) - __builtin_offsetof (struct A, a) - 5) + abort (); + if (__builtin_object_size (exta, 0) != (size_t) -1) + abort (); + if (__builtin_object_size (exta + 10, 0) != (size_t) -1) + abort (); + if (__builtin_object_size (&exta[5], 0) != (size_t) -1) + abort (); + if (__builtin_object_size (extb, 0) != sizeof (extb)) + abort (); + if (__builtin_object_size (extb + 10, 0) != sizeof (extb) - 10) + abort (); + if (__builtin_object_size (&extb[5], 0) != sizeof (extb) - 5) + abort (); + if (__builtin_object_size (var, 0) != (size_t) -1) + abort (); + if (__builtin_object_size (var + 10, 0) != (size_t) -1) + abort (); + if (__builtin_object_size (&var[5], 0) != (size_t) -1) + abort (); + if (__builtin_object_size (zerol, 0) != 0) + abort (); + if (__builtin_object_size (&zerol, 0) != 0) + abort (); + if (__builtin_object_size (&zerol[0], 0) != 0) + abort (); + if (__builtin_object_size (zerol[0].a, 0) != 0) + abort (); + if (__builtin_object_size (&zerol[0].a[0], 0) != 0) + abort (); + if (__builtin_object_size (&zerol[0].b, 0) != 0) + abort (); + if (__builtin_object_size ("abcdefg", 0) != sizeof ("abcdefg")) + abort (); + if (__builtin_object_size ("abcd\0efg", 0) != sizeof ("abcd\0efg")) + abort (); + if (__builtin_object_size (&"abcd\0efg", 0) != sizeof ("abcd\0efg")) + abort (); + if (__builtin_object_size (&"abcd\0efg"[0], 0) != sizeof ("abcd\0efg")) + abort (); + if (__builtin_object_size (&"abcd\0efg"[4], 0) != sizeof ("abcd\0efg") - 4) + abort (); + if (__builtin_object_size ("abcd\0efg" + 5, 0) != sizeof ("abcd\0efg") - 5) + abort (); + if (__builtin_object_size (L"abcdefg", 0) != sizeof (L"abcdefg")) + abort (); + r = (char *) L"abcd\0efg"; + if (__builtin_object_size (r + 2, 0) != sizeof (L"abcd\0efg") - 2) + abort (); +} + +size_t l1 = 1; + +void +__attribute__ ((noinline)) +test2 (void) +{ + struct B { char buf1[10]; char buf2[10]; } a; + char *r, buf3[20]; + int i; + + if (sizeof (a) != 20) + return; + + r = buf3; + for (i = 0; i < 4; ++i) + { + if (i == l1 - 1) + r = &a.buf1[1]; + else if (i == l1) + r = &a.buf2[7]; + else if (i == l1 + 1) + r = &buf3[5]; + else if (i == l1 + 2) + r = &a.buf1[9]; + } + if (__builtin_object_size (r, 0) != 20) + abort (); + r = &buf3[20]; + for (i = 0; i < 4; ++i) + { + if (i == l1 - 1) + r = &a.buf1[7]; + else if (i == l1) + r = &a.buf2[7]; + else if (i == l1 + 1) + r = &buf3[5]; + else if (i == l1 + 2) + r = &a.buf1[9]; + } + if (__builtin_object_size (r, 0) != 15) + abort (); + r += 8; + if (__builtin_object_size (r, 0) != 7) + abort (); + if (__builtin_object_size (r + 6, 0) != 1) + abort (); + r = &buf3[18]; + for (i = 0; i < 4; ++i) + { + if (i == l1 - 1) + r = &a.buf1[9]; + else if (i == l1) + r = &a.buf2[9]; + else if (i == l1 + 1) + r = &buf3[5]; + else if (i == l1 + 2) + r = &a.buf1[4]; + } + if (__builtin_object_size (r + 12, 0) != 4) + abort (); +} + +void +__attribute__ ((noinline)) +test3 (void) +{ + char buf4[10]; + struct B { struct A a[2]; struct A b; char c[4]; char d; double e; + _Complex double f; } x; + double y; + _Complex double z; + double *dp; + + if (__builtin_object_size (buf4, 0) != sizeof (buf4)) + abort (); + if (__builtin_object_size (&buf4, 0) != sizeof (buf4)) + abort (); + if (__builtin_object_size (&buf4[0], 0) != sizeof (buf4)) + abort (); + if (__builtin_object_size (&buf4[1], 0) != sizeof (buf4) - 1) + abort (); + if (__builtin_object_size (&x, 0) != sizeof (x)) + abort (); + if (__builtin_object_size (&x.a, 0) != sizeof (x)) + abort (); + if (__builtin_object_size (&x.a[0], 0) != sizeof (x)) + abort (); + if (__builtin_object_size (&x.a[0].a, 0) != sizeof (x)) + abort (); + if (__builtin_object_size (&x.a[0].a[0], 0) != sizeof (x)) + abort (); + if (__builtin_object_size (&x.a[0].a[3], 0) != sizeof (x) - 3) + abort (); + if (__builtin_object_size (&x.a[0].b, 0) + != sizeof (x) - __builtin_offsetof (struct A, b)) + abort (); + if (__builtin_object_size (&x.a[1].c, 0) + != sizeof (x) - sizeof (struct A) - __builtin_offsetof (struct A, c)) + abort (); + if (__builtin_object_size (&x.a[1].c[0], 0) + != sizeof (x) - sizeof (struct A) - __builtin_offsetof (struct A, c)) + abort (); + if (__builtin_object_size (&x.a[1].c[3], 0) + != sizeof (x) - sizeof (struct A) - __builtin_offsetof (struct A, c) - 3) + abort (); + if (__builtin_object_size (&x.b, 0) + != sizeof (x) - __builtin_offsetof (struct B, b)) + abort (); + if (__builtin_object_size (&x.b.a, 0) + != sizeof (x) - __builtin_offsetof (struct B, b)) + abort (); + if (__builtin_object_size (&x.b.a[0], 0) + != sizeof (x) - __builtin_offsetof (struct B, b)) + abort (); + if (__builtin_object_size (&x.b.a[3], 0) + != sizeof (x) - __builtin_offsetof (struct B, b) - 3) + abort (); + if (__builtin_object_size (&x.b.b, 0) + != sizeof (x) - __builtin_offsetof (struct B, b) + - __builtin_offsetof (struct A, b)) + abort (); + if (__builtin_object_size (&x.b.c, 0) + != sizeof (x) - __builtin_offsetof (struct B, b) + - __builtin_offsetof (struct A, c)) + abort (); + if (__builtin_object_size (&x.b.c[0], 0) + != sizeof (x) - __builtin_offsetof (struct B, b) + - __builtin_offsetof (struct A, c)) + abort (); + if (__builtin_object_size (&x.b.c[3], 0) + != sizeof (x) - __builtin_offsetof (struct B, b) + - __builtin_offsetof (struct A, c) - 3) + abort (); + if (__builtin_object_size (&x.c, 0) + != sizeof (x) - __builtin_offsetof (struct B, c)) + abort (); + if (__builtin_object_size (&x.c[0], 0) + != sizeof (x) - __builtin_offsetof (struct B, c)) + abort (); + if (__builtin_object_size (&x.c[1], 0) + != sizeof (x) - __builtin_offsetof (struct B, c) - 1) + abort (); + if (__builtin_object_size (&x.d, 0) + != sizeof (x) - __builtin_offsetof (struct B, d)) + abort (); + if (__builtin_object_size (&x.e, 0) + != sizeof (x) - __builtin_offsetof (struct B, e)) + abort (); + if (__builtin_object_size (&x.f, 0) + != sizeof (x) - __builtin_offsetof (struct B, f)) + abort (); + dp = &__real__ x.f; + if (__builtin_object_size (dp, 0) + != sizeof (x) - __builtin_offsetof (struct B, f)) + abort (); + dp = &__imag__ x.f; + if (__builtin_object_size (dp, 0) + != sizeof (x) - __builtin_offsetof (struct B, f) + - sizeof (x.f) / 2) + abort (); + dp = &y; + if (__builtin_object_size (dp, 0) != sizeof (y)) + abort (); + if (__builtin_object_size (&z, 0) != sizeof (z)) + abort (); + dp = &__real__ z; + if (__builtin_object_size (dp, 0) != sizeof (z)) + abort (); + dp = &__imag__ z; + if (__builtin_object_size (dp, 0) != sizeof (z) / 2) + abort (); +} + +struct S { unsigned int a; }; + +char * +__attribute__ ((noinline)) +test4 (char *x, int y) +{ + register int i; + struct A *p; + + for (i = 0; i < y; i++) + { + p = (struct A *) x; + x = (char *) &p[1]; + if (__builtin_object_size (p, 0) != (size_t) -1) + abort (); + } + return x; +} + +void +__attribute__ ((noinline)) +test5 (size_t x) +{ + char buf[64]; + char *p = &buf[8]; + size_t i; + + for (i = 0; i < x; ++i) + p = p + 4; + /* My understanding of ISO C99 6.5.6 is that a conforming + program will not end up with p equal to &buf[0] + through &buf[7], i.e. calling this function with say + UINTPTR_MAX / 4 results in undefined behaviour. + If that's true, then the maximum number of remaining + bytes from p until end of the object is 56, otherwise + it would be 64 (or conservative (size_t) -1 == unknown). */ + if (__builtin_object_size (p, 0) != sizeof (buf) - 8) + abort (); + memset (p, ' ', sizeof (buf) - 8 - 4 * 4); +} + +void +__attribute__ ((noinline)) +test6 (size_t x) +{ + struct T { char buf[64]; char buf2[64]; } t; + char *p = &t.buf[8]; + size_t i; + + for (i = 0; i < x; ++i) + p = p + 4; + if (__builtin_object_size (p, 0) != sizeof (t) - 8) + abort (); + memset (p, ' ', sizeof (t) - 8 - 4 * 4); +} + +void +__attribute__ ((noinline)) +test7 (void) +{ + char buf[64]; + struct T { char buf[64]; char buf2[64]; } t; + char *p = &buf[64], *q = &t.buf[64]; + + if (__builtin_object_size (p + 64, 0) != 0) + abort (); + if (__builtin_object_size (q + 63, 0) != sizeof (t) - 64 - 63) + abort (); + if (__builtin_object_size (q + 64, 0) != sizeof (t) - 64 - 64) + abort (); + if (__builtin_object_size (q + 256, 0) != 0) + abort (); +} + +void +__attribute__ ((noinline)) +test8 (void) +{ + struct T { char buf[10]; char buf2[10]; } t; + char *p = &t.buf2[-4]; + char *q = &t.buf2[0]; + if (__builtin_object_size (p, 0) != sizeof (t) - 10 + 4) + abort (); + if (__builtin_object_size (q, 0) != sizeof (t) - 10) + abort (); + /* GCC only handles additions, not subtractions. */ + q = q - 8; + if (__builtin_object_size (q, 0) != (size_t) -1 + && __builtin_object_size (q, 0) != sizeof (t) - 10 + 8) + abort (); + p = &t.buf[-4]; + if (__builtin_object_size (p, 0) != 0) + abort (); +} + +int +main (void) +{ + struct S s[10]; + __asm ("" : "=r" (l1) : "0" (l1)); + test1 (main, 6); + test2 (); + test3 (); + test4 ((char *) s, 10); + test5 (4); + test6 (4); + test7 (); + test8 (); + exit (0); +} diff --git a/test/unimplemented/dg/builtin/builtin-object-size-2.c b/test/unimplemented/dg/builtin/builtin-object-size-2.c new file mode 100644 index 0000000..4071c25 --- /dev/null +++ b/test/unimplemented/dg/builtin/builtin-object-size-2.c @@ -0,0 +1,393 @@ +/* { dg-do run } */ +/* { dg-options "-O2" } */ + +typedef __SIZE_TYPE__ size_t; +extern void abort (void); +extern void exit (int); +extern void *malloc (size_t); +extern void *calloc (size_t, size_t); +extern void *alloca (size_t); +extern void *memcpy (void *, const void *, size_t); +extern void *memset (void *, int, size_t); +extern char *strcpy (char *, const char *); + +struct A +{ + char a[10]; + int b; + char c[10]; +} y, w[4]; + +extern char exta[]; +extern char extb[30]; +extern struct A extc[]; +struct A zerol[0]; + +void +__attribute__ ((noinline)) +test1 (void *q, int x) +{ + struct A a; + void *p = &a.a[3], *r; + char var[x + 10]; + struct A vara[x + 10]; + if (x < 0) + r = &a.a[9]; + else + r = &a.c[1]; + if (__builtin_object_size (p, 1) != sizeof (a.a) - 3) + abort (); + if (__builtin_object_size (&a.c[9], 1) + != sizeof (a.c) - 9) + abort (); + if (__builtin_object_size (q, 1) != (size_t) -1) + abort (); + if (__builtin_object_size (r, 1) != sizeof (a.c) - 1) + abort (); + if (x < 6) + r = &w[2].a[1]; + else + r = &a.a[6]; + if (__builtin_object_size (&y, 1) != sizeof (y)) + abort (); + if (__builtin_object_size (w, 1) != sizeof (w)) + abort (); + if (__builtin_object_size (&y.b, 1) != sizeof (a.b)) + abort (); + if (__builtin_object_size (r, 1) != sizeof (a.a) - 1) + abort (); + if (x < 20) + r = malloc (30); + else + r = calloc (2, 16); + if (__builtin_object_size (r, 1) != 2 * 16) + abort (); + if (x < 20) + r = malloc (30); + else + r = calloc (2, 14); + if (__builtin_object_size (r, 1) != 30) + abort (); + if (x < 30) + r = malloc (sizeof (a)); + else + r = &a.a[3]; + if (__builtin_object_size (r, 1) != sizeof (a)) + abort (); + r = memcpy (r, "a", 2); + if (__builtin_object_size (r, 1) != sizeof (a)) + abort (); + r = memcpy (r + 2, "b", 2) + 2; + if (__builtin_object_size (r, 1) != sizeof (a) - 4) + abort (); + r = &a.a[4]; + r = memset (r, 'a', 2); + if (__builtin_object_size (r, 1) != sizeof (a.a) - 4) + abort (); + r = memset (r + 2, 'b', 2) + 2; + if (__builtin_object_size (r, 1) != sizeof (a.a) - 8) + abort (); + r = &a.a[1]; + r = strcpy (r, "ab"); + if (__builtin_object_size (r, 1) != sizeof (a.a) - 1) + abort (); + r = strcpy (r + 2, "cd") + 2; + if (__builtin_object_size (r, 1) != sizeof (a.a) - 5) + abort (); + if (__builtin_object_size (exta, 1) != (size_t) -1) + abort (); + if (__builtin_object_size (exta + 10, 1) != (size_t) -1) + abort (); + if (__builtin_object_size (&exta[5], 1) != (size_t) -1) + abort (); + if (__builtin_object_size (extb, 1) != sizeof (extb)) + abort (); + if (__builtin_object_size (extb + 10, 1) != sizeof (extb) - 10) + abort (); + if (__builtin_object_size (&extb[5], 1) != sizeof (extb) - 5) + abort (); + if (__builtin_object_size (extc, 1) != (size_t) -1) + abort (); + if (__builtin_object_size (extc + 10, 1) != (size_t) -1) + abort (); + if (__builtin_object_size (&extc[5], 1) != (size_t) -1) + abort (); + if (__builtin_object_size (&extc->a, 1) != (size_t) -1) + abort (); + if (__builtin_object_size (&(extc + 10)->b, 1) != (size_t) -1) + abort (); + if (__builtin_object_size (&extc[5].c[3], 1) != (size_t) -1) + abort (); + if (__builtin_object_size (var, 1) != (size_t) -1) + abort (); + if (__builtin_object_size (var + 10, 1) != (size_t) -1) + abort (); + if (__builtin_object_size (&var[5], 1) != (size_t) -1) + abort (); + if (__builtin_object_size (vara, 1) != (size_t) -1) + abort (); + if (__builtin_object_size (vara + 10, 1) != (size_t) -1) + abort (); + if (__builtin_object_size (&vara[5], 1) != (size_t) -1) + abort (); + if (__builtin_object_size (&vara[0].a, 1) != (size_t) -1) + abort (); + if (__builtin_object_size (&vara[10].a[0], 1) != (size_t) -1) + abort (); + if (__builtin_object_size (&vara[5].a[4], 1) != (size_t) -1) + abort (); + if (__builtin_object_size (&vara[5].b, 1) != (size_t) -1) + abort (); + if (__builtin_object_size (&vara[7].c[7], 1) != (size_t) -1) + abort (); + if (__builtin_object_size (zerol, 1) != 0) + abort (); + if (__builtin_object_size (&zerol, 1) != 0) + abort (); + if (__builtin_object_size (&zerol[0], 1) != 0) + abort (); + if (__builtin_object_size (zerol[0].a, 1) != 0) + abort (); + if (__builtin_object_size (&zerol[0].a[0], 1) != 0) + abort (); + if (__builtin_object_size (&zerol[0].b, 1) != 0) + abort (); + if (__builtin_object_size ("abcdefg", 1) != sizeof ("abcdefg")) + abort (); + if (__builtin_object_size ("abcd\0efg", 1) != sizeof ("abcd\0efg")) + abort (); + if (__builtin_object_size (&"abcd\0efg", 1) != sizeof ("abcd\0efg")) + abort (); + if (__builtin_object_size (&"abcd\0efg"[0], 1) != sizeof ("abcd\0efg")) + abort (); + if (__builtin_object_size (&"abcd\0efg"[4], 1) != sizeof ("abcd\0efg") - 4) + abort (); + if (__builtin_object_size ("abcd\0efg" + 5, 1) != sizeof ("abcd\0efg") - 5) + abort (); + if (__builtin_object_size (L"abcdefg", 1) != sizeof (L"abcdefg")) + abort (); + r = (char *) L"abcd\0efg"; + if (__builtin_object_size (r + 2, 1) != sizeof (L"abcd\0efg") - 2) + abort (); +} + +size_t l1 = 1; + +void +__attribute__ ((noinline)) +test2 (void) +{ + struct B { char buf1[10]; char buf2[10]; } a; + char *r, buf3[20]; + int i; + + if (sizeof (a) != 20) + return; + + r = buf3; + for (i = 0; i < 4; ++i) + { + if (i == l1 - 1) + r = &a.buf1[1]; + else if (i == l1) + r = &a.buf2[7]; + else if (i == l1 + 1) + r = &buf3[5]; + else if (i == l1 + 2) + r = &a.buf1[9]; + } + if (__builtin_object_size (r, 1) != sizeof (buf3)) + abort (); + r = &buf3[20]; + for (i = 0; i < 4; ++i) + { + if (i == l1 - 1) + r = &a.buf1[7]; + else if (i == l1) + r = &a.buf2[7]; + else if (i == l1 + 1) + r = &buf3[5]; + else if (i == l1 + 2) + r = &a.buf1[9]; + } + if (__builtin_object_size (r, 1) != sizeof (buf3) - 5) + abort (); + r += 8; + if (__builtin_object_size (r, 1) != sizeof (buf3) - 13) + abort (); + if (__builtin_object_size (r + 6, 1) != sizeof (buf3) - 19) + abort (); +} + +void +__attribute__ ((noinline)) +test3 (void) +{ + char buf4[10]; + struct B { struct A a[2]; struct A b; char c[4]; char d; double e; + _Complex double f; } x; + double y; + _Complex double z; + double *dp; + + if (__builtin_object_size (buf4, 1) != sizeof (buf4)) + abort (); + if (__builtin_object_size (&buf4, 1) != sizeof (buf4)) + abort (); + if (__builtin_object_size (&buf4[0], 1) != sizeof (buf4)) + abort (); + if (__builtin_object_size (&buf4[1], 1) != sizeof (buf4) - 1) + abort (); + if (__builtin_object_size (&x, 1) != sizeof (x)) + abort (); + if (__builtin_object_size (&x.a, 1) != sizeof (x.a)) + abort (); + if (__builtin_object_size (&x.a[0], 1) != sizeof (x.a)) + abort (); + if (__builtin_object_size (&x.a[0].a, 1) != sizeof (x.a[0].a)) + abort (); + if (__builtin_object_size (&x.a[0].a[0], 1) != sizeof (x.a[0].a)) + abort (); + if (__builtin_object_size (&x.a[0].a[3], 1) != sizeof (x.a[0].a) - 3) + abort (); + if (__builtin_object_size (&x.a[0].b, 1) != sizeof (x.a[0].b)) + abort (); + if (__builtin_object_size (&x.a[1].c, 1) != sizeof (x.a[1].c)) + abort (); + if (__builtin_object_size (&x.a[1].c[0], 1) != sizeof (x.a[1].c)) + abort (); + if (__builtin_object_size (&x.a[1].c[3], 1) != sizeof (x.a[1].c) - 3) + abort (); + if (__builtin_object_size (&x.b, 1) != sizeof (x.b)) + abort (); + if (__builtin_object_size (&x.b.a, 1) != sizeof (x.b.a)) + abort (); + if (__builtin_object_size (&x.b.a[0], 1) != sizeof (x.b.a)) + abort (); + if (__builtin_object_size (&x.b.a[3], 1) != sizeof (x.b.a) - 3) + abort (); + if (__builtin_object_size (&x.b.b, 1) != sizeof (x.b.b)) + abort (); + if (__builtin_object_size (&x.b.c, 1) != sizeof (x.b.c)) + abort (); + if (__builtin_object_size (&x.b.c[0], 1) != sizeof (x.b.c)) + abort (); + if (__builtin_object_size (&x.b.c[3], 1) != sizeof (x.b.c) - 3) + abort (); + if (__builtin_object_size (&x.c, 1) != sizeof (x.c)) + abort (); + if (__builtin_object_size (&x.c[0], 1) != sizeof (x.c)) + abort (); + if (__builtin_object_size (&x.c[1], 1) != sizeof (x.c) - 1) + abort (); + if (__builtin_object_size (&x.d, 1) != sizeof (x.d)) + abort (); + if (__builtin_object_size (&x.e, 1) != sizeof (x.e)) + abort (); + if (__builtin_object_size (&x.f, 1) != sizeof (x.f)) + abort (); + dp = &__real__ x.f; + if (__builtin_object_size (dp, 1) != sizeof (x.f) / 2) + abort (); + dp = &__imag__ x.f; + if (__builtin_object_size (dp, 1) != sizeof (x.f) / 2) + abort (); + dp = &y; + if (__builtin_object_size (dp, 1) != sizeof (y)) + abort (); + if (__builtin_object_size (&z, 1) != sizeof (z)) + abort (); + dp = &__real__ z; + if (__builtin_object_size (dp, 1) != sizeof (z) / 2) + abort (); + dp = &__imag__ z; + if (__builtin_object_size (dp, 1) != sizeof (z) / 2) + abort (); +} + +struct S { unsigned int a; }; + +char * +__attribute__ ((noinline)) +test4 (char *x, int y) +{ + register int i; + struct A *p; + + for (i = 0; i < y; i++) + { + p = (struct A *) x; + x = (char *) &p[1]; + if (__builtin_object_size (p, 1) != (size_t) -1) + abort (); + } + return x; +} + +void +__attribute__ ((noinline)) +test5 (size_t x) +{ + struct T { char buf[64]; char buf2[64]; } t; + char *p = &t.buf[8]; + size_t i; + + for (i = 0; i < x; ++i) + p = p + 4; + if (__builtin_object_size (p, 1) != sizeof (t.buf) - 8) + abort (); + memset (p, ' ', sizeof (t.buf) - 8 - 4 * 4); +} + +void +__attribute__ ((noinline)) +test6 (void) +{ + char buf[64]; + struct T { char buf[64]; char buf2[64]; } t; + char *p = &buf[64], *q = &t.buf[64]; + + if (__builtin_object_size (p + 64, 1) != 0) + abort (); + if (__builtin_object_size (q + 0, 1) != 0) + abort (); + if (__builtin_object_size (q + 64, 1) != 0) + abort (); +} + +void +__attribute__ ((noinline)) +test7 (void) +{ + struct T { char buf[10]; char buf2[10]; } t; + char *p = &t.buf2[-4]; + char *q = &t.buf2[0]; + if (__builtin_object_size (p, 1) != 0) + abort (); + if (__builtin_object_size (q, 1) != sizeof (t.buf2)) + abort (); + q = &t.buf[10]; + if (__builtin_object_size (q, 1) != 0) + abort (); + q = &t.buf[11]; + if (__builtin_object_size (q, 1) != 0) + abort (); + p = &t.buf[-4]; + if (__builtin_object_size (p, 1) != 0) + abort (); +} + +int +main (void) +{ + struct S s[10]; + __asm ("" : "=r" (l1) : "0" (l1)); + test1 (main, 6); + test2 (); + test3 (); + test4 ((char *) s, 10); + test5 (4); + test6 (); + test7 (); + exit (0); +} diff --git a/test/unimplemented/dg/builtin/builtin-object-size-3.c b/test/unimplemented/dg/builtin/builtin-object-size-3.c new file mode 100644 index 0000000..572ecda --- /dev/null +++ b/test/unimplemented/dg/builtin/builtin-object-size-3.c @@ -0,0 +1,446 @@ +/* { dg-do run } */ +/* { dg-options "-O2" } */ + +typedef __SIZE_TYPE__ size_t; +extern void abort (void); +extern void exit (int); +extern void *malloc (size_t); +extern void *calloc (size_t, size_t); +extern void *alloca (size_t); +extern void *memcpy (void *, const void *, size_t); +extern void *memset (void *, int, size_t); +extern char *strcpy (char *, const char *); + +struct A +{ + char a[10]; + int b; + char c[10]; +} y, w[4]; + +extern char exta[]; +extern char extb[30]; +extern struct A zerol[0]; + +void +__attribute__ ((noinline)) +test1 (void *q, int x) +{ + struct A a; + void *p = &a.a[3], *r; + char var[x + 10]; + if (x < 0) + r = &a.a[9]; + else + r = &a.c[1]; + if (__builtin_object_size (p, 2) + != sizeof (a) - __builtin_offsetof (struct A, a) - 3) + abort (); + if (__builtin_object_size (&a.c[9], 2) + != sizeof (a) - __builtin_offsetof (struct A, c) - 9) + abort (); + if (__builtin_object_size (q, 2) != 0) + abort (); + if (__builtin_object_size (r, 2) + != sizeof (a) - __builtin_offsetof (struct A, c) - 1) + abort (); + if (x < 6) + r = &w[2].a[1]; + else + r = &a.a[6]; + if (__builtin_object_size (&y, 2) + != sizeof (y)) + abort (); + if (__builtin_object_size (w, 2) + != sizeof (w)) + abort (); + if (__builtin_object_size (&y.b, 2) + != sizeof (a) - __builtin_offsetof (struct A, b)) + abort (); + if (__builtin_object_size (r, 2) + != sizeof (a) - __builtin_offsetof (struct A, a) - 6) + abort (); + if (x < 20) + r = malloc (30); + else + r = calloc (2, 16); + if (__builtin_object_size (r, 2) != 30) + abort (); + if (x < 20) + r = malloc (30); + else + r = calloc (2, 14); + if (__builtin_object_size (r, 2) != 2 * 14) + abort (); + if (x < 30) + r = malloc (sizeof (a)); + else + r = &a.a[3]; + if (__builtin_object_size (r, 2) + != sizeof (a) - __builtin_offsetof (struct A, a) - 3) + abort (); + r = memcpy (r, "a", 2); + if (__builtin_object_size (r, 2) + != sizeof (a) - __builtin_offsetof (struct A, a) - 3) + abort (); + r = memcpy (r + 2, "b", 2) + 2; + if (__builtin_object_size (r, 2) + != sizeof (a) - __builtin_offsetof (struct A, a) - 3 - 4) + abort (); + r = &a.a[4]; + r = memset (r, 'a', 2); + if (__builtin_object_size (r, 2) + != sizeof (a) - __builtin_offsetof (struct A, a) - 4) + abort (); + r = memset (r + 2, 'b', 2) + 2; + if (__builtin_object_size (r, 2) + != sizeof (a) - __builtin_offsetof (struct A, a) - 8) + abort (); + r = &a.a[1]; + r = strcpy (r, "ab"); + if (__builtin_object_size (r, 2) + != sizeof (a) - __builtin_offsetof (struct A, a) - 1) + abort (); + r = strcpy (r + 2, "cd") + 2; + if (__builtin_object_size (r, 2) + != sizeof (a) - __builtin_offsetof (struct A, a) - 5) + abort (); + if (__builtin_object_size (exta, 2) != 0) + abort (); + if (__builtin_object_size (exta + 10, 2) != 0) + abort (); + if (__builtin_object_size (&exta[5], 2) != 0) + abort (); + if (__builtin_object_size (extb, 2) != sizeof (extb)) + abort (); + if (__builtin_object_size (extb + 10, 2) != sizeof (extb) - 10) + abort (); + if (__builtin_object_size (&extb[5], 2) != sizeof (extb) - 5) + abort (); + if (__builtin_object_size (var, 2) != 0) + abort (); + if (__builtin_object_size (var + 10, 2) != 0) + abort (); + if (__builtin_object_size (&var[5], 2) != 0) + abort (); + if (__builtin_object_size (zerol, 2) != 0) + abort (); + if (__builtin_object_size (&zerol, 2) != 0) + abort (); + if (__builtin_object_size (&zerol[0], 2) != 0) + abort (); + if (__builtin_object_size (zerol[0].a, 2) != 0) + abort (); + if (__builtin_object_size (&zerol[0].a[0], 2) != 0) + abort (); + if (__builtin_object_size (&zerol[0].b, 2) != 0) + abort (); + if (__builtin_object_size ("abcdefg", 2) != sizeof ("abcdefg")) + abort (); + if (__builtin_object_size ("abcd\0efg", 2) != sizeof ("abcd\0efg")) + abort (); + if (__builtin_object_size (&"abcd\0efg", 2) != sizeof ("abcd\0efg")) + abort (); + if (__builtin_object_size (&"abcd\0efg"[0], 2) != sizeof ("abcd\0efg")) + abort (); + if (__builtin_object_size (&"abcd\0efg"[4], 2) != sizeof ("abcd\0efg") - 4) + abort (); + if (__builtin_object_size ("abcd\0efg" + 5, 2) != sizeof ("abcd\0efg") - 5) + abort (); + if (__builtin_object_size (L"abcdefg", 2) != sizeof (L"abcdefg")) + abort (); + r = (char *) L"abcd\0efg"; + if (__builtin_object_size (r + 2, 2) != sizeof (L"abcd\0efg") - 2) + abort (); +} + +size_t l1 = 1; + +void +__attribute__ ((noinline)) +test2 (void) +{ + struct B { char buf1[10]; char buf2[10]; } a; + char *r, buf3[20]; + int i; + + if (sizeof (a) != 20) + return; + + r = buf3; + for (i = 0; i < 4; ++i) + { + if (i == l1 - 1) + r = &a.buf1[1]; + else if (i == l1) + r = &a.buf2[7]; + else if (i == l1 + 1) + r = &buf3[5]; + else if (i == l1 + 2) + r = &a.buf1[9]; + } + if (__builtin_object_size (r, 2) != 3) + abort (); + r = &buf3[20]; + for (i = 0; i < 4; ++i) + { + if (i == l1 - 1) + r = &a.buf1[7]; + else if (i == l1) + r = &a.buf2[7]; + else if (i == l1 + 1) + r = &buf3[5]; + else if (i == l1 + 2) + r = &a.buf1[9]; + } + if (__builtin_object_size (r, 2) != 0) + abort (); + r = &buf3[2]; + for (i = 0; i < 4; ++i) + { + if (i == l1 - 1) + r = &a.buf1[1]; + else if (i == l1) + r = &a.buf1[2]; + else if (i == l1 + 1) + r = &buf3[5]; + else if (i == l1 + 2) + r = &a.buf1[4]; + } + if (__builtin_object_size (r, 2) != 15) + abort (); + r += 8; + if (__builtin_object_size (r, 2) != 7) + abort (); + if (__builtin_object_size (r + 6, 2) != 1) + abort (); + r = &buf3[18]; + for (i = 0; i < 4; ++i) + { + if (i == l1 - 1) + r = &a.buf1[9]; + else if (i == l1) + r = &a.buf2[9]; + else if (i == l1 + 1) + r = &buf3[5]; + else if (i == l1 + 2) + r = &a.buf1[4]; + } + if (__builtin_object_size (r + 12, 2) != 0) + abort (); +} + +void +__attribute__ ((noinline)) +test3 (void) +{ + char buf4[10]; + struct B { struct A a[2]; struct A b; char c[4]; char d; double e; + _Complex double f; } x; + double y; + _Complex double z; + double *dp; + + if (__builtin_object_size (buf4, 2) != sizeof (buf4)) + abort (); + if (__builtin_object_size (&buf4, 2) != sizeof (buf4)) + abort (); + if (__builtin_object_size (&buf4[0], 2) != sizeof (buf4)) + abort (); + if (__builtin_object_size (&buf4[1], 2) != sizeof (buf4) - 1) + abort (); + if (__builtin_object_size (&x, 2) != sizeof (x)) + abort (); + if (__builtin_object_size (&x.a, 2) != sizeof (x)) + abort (); + if (__builtin_object_size (&x.a[0], 2) != sizeof (x)) + abort (); + if (__builtin_object_size (&x.a[0].a, 2) != sizeof (x)) + abort (); + if (__builtin_object_size (&x.a[0].a[0], 2) != sizeof (x)) + abort (); + if (__builtin_object_size (&x.a[0].a[3], 2) != sizeof (x) - 3) + abort (); + if (__builtin_object_size (&x.a[0].b, 2) + != sizeof (x) - __builtin_offsetof (struct A, b)) + abort (); + if (__builtin_object_size (&x.a[1].c, 2) + != sizeof (x) - sizeof (struct A) - __builtin_offsetof (struct A, c)) + abort (); + if (__builtin_object_size (&x.a[1].c[0], 2) + != sizeof (x) - sizeof (struct A) - __builtin_offsetof (struct A, c)) + abort (); + if (__builtin_object_size (&x.a[1].c[3], 2) + != sizeof (x) - sizeof (struct A) - __builtin_offsetof (struct A, c) - 3) + abort (); + if (__builtin_object_size (&x.b, 2) + != sizeof (x) - __builtin_offsetof (struct B, b)) + abort (); + if (__builtin_object_size (&x.b.a, 2) + != sizeof (x) - __builtin_offsetof (struct B, b)) + abort (); + if (__builtin_object_size (&x.b.a[0], 2) + != sizeof (x) - __builtin_offsetof (struct B, b)) + abort (); + if (__builtin_object_size (&x.b.a[3], 2) + != sizeof (x) - __builtin_offsetof (struct B, b) - 3) + abort (); + if (__builtin_object_size (&x.b.b, 2) + != sizeof (x) - __builtin_offsetof (struct B, b) + - __builtin_offsetof (struct A, b)) + abort (); + if (__builtin_object_size (&x.b.c, 2) + != sizeof (x) - __builtin_offsetof (struct B, b) + - __builtin_offsetof (struct A, c)) + abort (); + if (__builtin_object_size (&x.b.c[0], 2) + != sizeof (x) - __builtin_offsetof (struct B, b) + - __builtin_offsetof (struct A, c)) + abort (); + if (__builtin_object_size (&x.b.c[3], 2) + != sizeof (x) - __builtin_offsetof (struct B, b) + - __builtin_offsetof (struct A, c) - 3) + abort (); + if (__builtin_object_size (&x.c, 2) + != sizeof (x) - __builtin_offsetof (struct B, c)) + abort (); + if (__builtin_object_size (&x.c[0], 2) + != sizeof (x) - __builtin_offsetof (struct B, c)) + abort (); + if (__builtin_object_size (&x.c[1], 2) + != sizeof (x) - __builtin_offsetof (struct B, c) - 1) + abort (); + if (__builtin_object_size (&x.d, 2) + != sizeof (x) - __builtin_offsetof (struct B, d)) + abort (); + if (__builtin_object_size (&x.e, 2) + != sizeof (x) - __builtin_offsetof (struct B, e)) + abort (); + if (__builtin_object_size (&x.f, 2) + != sizeof (x) - __builtin_offsetof (struct B, f)) + abort (); + dp = &__real__ x.f; + if (__builtin_object_size (dp, 2) + != sizeof (x) - __builtin_offsetof (struct B, f)) + abort (); + dp = &__imag__ x.f; + if (__builtin_object_size (dp, 2) + != sizeof (x) - __builtin_offsetof (struct B, f) + - sizeof (x.f) / 2) + abort (); + dp = &y; + if (__builtin_object_size (dp, 2) != sizeof (y)) + abort (); + if (__builtin_object_size (&z, 2) != sizeof (z)) + abort (); + dp = &__real__ z; + if (__builtin_object_size (dp, 2) != sizeof (z)) + abort (); + dp = &__imag__ z; + if (__builtin_object_size (dp, 2) != sizeof (z) / 2) + abort (); +} + +struct S { unsigned int a; }; + +char * +__attribute__ ((noinline)) +test4 (char *x, int y) +{ + register int i; + struct A *p; + + for (i = 0; i < y; i++) + { + p = (struct A *) x; + x = (char *) &p[1]; + if (__builtin_object_size (p, 2) != 0) + abort (); + } + return x; +} + +void +__attribute__ ((noinline)) +test5 (size_t x) +{ + char buf[64]; + char *p = &buf[8]; + size_t i; + + for (i = 0; i < x; ++i) + p = p + 4; + if (__builtin_object_size (p, 2) != 0) + abort (); + memset (p, ' ', sizeof (buf) - 8 - 4 * 4); +} + +void +__attribute__ ((noinline)) +test6 (size_t x) +{ + struct T { char buf[64]; char buf2[64]; } t; + char *p = &t.buf[8]; + size_t i; + + for (i = 0; i < x; ++i) + p = p + 4; + if (__builtin_object_size (p, 2) != 0) + abort (); + memset (p, ' ', sizeof (t) - 8 - 4 * 4); +} + +void +__attribute__ ((noinline)) +test7 (void) +{ + char buf[64]; + struct T { char buf[64]; char buf2[64]; } t; + char *p = &buf[64], *q = &t.buf[64]; + + if (__builtin_object_size (p + 64, 2) != 0) + abort (); + if (__builtin_object_size (q + 63, 2) != sizeof (t) - 64 - 63) + abort (); + if (__builtin_object_size (q + 64, 2) != sizeof (t) - 64 - 64) + abort (); + if (__builtin_object_size (q + 256, 2) != 0) + abort (); +} + +void +__attribute__ ((noinline)) +test8 (void) +{ + struct T { char buf[10]; char buf2[10]; } t; + char *p = &t.buf2[-4]; + char *q = &t.buf2[0]; + if (__builtin_object_size (p, 2) != sizeof (t) - 10 + 4) + abort (); + if (__builtin_object_size (q, 2) != sizeof (t) - 10) + abort (); + /* GCC only handles additions, not subtractions. */ + q = q - 8; + if (__builtin_object_size (q, 2) != 0 + && __builtin_object_size (q, 2) != sizeof (t) - 10 + 8) + abort (); + p = &t.buf[-4]; + if (__builtin_object_size (p, 2) != 0) + abort (); +} + +int +main (void) +{ + struct S s[10]; + __asm ("" : "=r" (l1) : "0" (l1)); + test1 (main, 6); + test2 (); + test3 (); + test4 ((char *) s, 10); + test5 (4); + test6 (4); + test7 (); + test8 (); + exit (0); +} diff --git a/test/unimplemented/dg/builtin/builtin-object-size-4.c b/test/unimplemented/dg/builtin/builtin-object-size-4.c new file mode 100644 index 0000000..453c2d0 --- /dev/null +++ b/test/unimplemented/dg/builtin/builtin-object-size-4.c @@ -0,0 +1,407 @@ +/* { dg-do run } */ +/* { dg-options "-O2" } */ + +typedef __SIZE_TYPE__ size_t; +extern void abort (void); +extern void exit (int); +extern void *malloc (size_t); +extern void *calloc (size_t, size_t); +extern void *alloca (size_t); +extern void *memcpy (void *, const void *, size_t); +extern void *memset (void *, int, size_t); +extern char *strcpy (char *, const char *); + +struct A +{ + char a[10]; + int b; + char c[10]; +} y, w[4]; + +extern char exta[]; +extern char extb[30]; +extern struct A extc[]; +struct A zerol[0]; + +void +__attribute__ ((noinline)) +test1 (void *q, int x) +{ + struct A a; + void *p = &a.a[3], *r; + char var[x + 10]; + struct A vara[x + 10]; + if (x < 0) + r = &a.a[9]; + else + r = &a.c[1]; + if (__builtin_object_size (p, 3) != sizeof (a.a) - 3) + abort (); + if (__builtin_object_size (&a.c[9], 3) + != sizeof (a.c) - 9) + abort (); + if (__builtin_object_size (q, 3) != 0) + abort (); + if (__builtin_object_size (r, 3) != sizeof (a.a) - 9) + abort (); + if (x < 6) + r = &w[2].a[1]; + else + r = &a.a[6]; + if (__builtin_object_size (&y, 3) != sizeof (y)) + abort (); + if (__builtin_object_size (w, 3) != sizeof (w)) + abort (); + if (__builtin_object_size (&y.b, 3) != sizeof (a.b)) + abort (); + if (__builtin_object_size (r, 3) != sizeof (a.a) - 6) + abort (); + if (x < 20) + r = malloc (30); + else + r = calloc (2, 16); + if (__builtin_object_size (r, 3) != 30) + abort (); + if (x < 20) + r = malloc (30); + else + r = calloc (2, 14); + if (__builtin_object_size (r, 3) != 2 * 14) + abort (); + if (x < 30) + r = malloc (sizeof (a)); + else + r = &a.a[3]; + if (__builtin_object_size (r, 3) != sizeof (a.a) - 3) + abort (); + r = memcpy (r, "a", 2); + if (__builtin_object_size (r, 3) != sizeof (a.a) - 3) + abort (); + r = memcpy (r + 2, "b", 2) + 2; + if (__builtin_object_size (r, 3) != sizeof (a.a) - 3 - 4) + abort (); + r = &a.a[4]; + r = memset (r, 'a', 2); + if (__builtin_object_size (r, 3) != sizeof (a.a) - 4) + abort (); + r = memset (r + 2, 'b', 2) + 2; + if (__builtin_object_size (r, 3) != sizeof (a.a) - 8) + abort (); + r = &a.a[1]; + r = strcpy (r, "ab"); + if (__builtin_object_size (r, 3) != sizeof (a.a) - 1) + abort (); + r = strcpy (r + 2, "cd") + 2; + if (__builtin_object_size (r, 3) != sizeof (a.a) - 5) + abort (); + if (__builtin_object_size (exta, 3) != 0) + abort (); + if (__builtin_object_size (exta + 10, 3) != 0) + abort (); + if (__builtin_object_size (&exta[5], 3) != 0) + abort (); + if (__builtin_object_size (extb, 3) != sizeof (extb)) + abort (); + if (__builtin_object_size (extb + 10, 3) != sizeof (extb) - 10) + abort (); + if (__builtin_object_size (&extb[5], 3) != sizeof (extb) - 5) + abort (); + if (__builtin_object_size (extc, 3) != 0) + abort (); + if (__builtin_object_size (extc + 10, 3) != 0) + abort (); + if (__builtin_object_size (&extc[5], 3) != 0) + abort (); + if (__builtin_object_size (&extc->a, 3) != 0) + abort (); + if (__builtin_object_size (&(extc + 10)->b, 3) != 0) + abort (); + if (__builtin_object_size (&extc[5].c[3], 3) != 0) + abort (); + if (__builtin_object_size (var, 3) != 0) + abort (); + if (__builtin_object_size (var + 10, 3) != 0) + abort (); + if (__builtin_object_size (&var[5], 3) != 0) + abort (); + if (__builtin_object_size (vara, 3) != 0) + abort (); + if (__builtin_object_size (vara + 10, 3) != 0) + abort (); + if (__builtin_object_size (&vara[5], 3) != 0) + abort (); + if (__builtin_object_size (&vara[0].a, 3) != 0) + abort (); + if (__builtin_object_size (&vara[10].a[0], 3) != 0) + abort (); + if (__builtin_object_size (&vara[5].a[4], 3) != 0) + abort (); + if (__builtin_object_size (&vara[5].b, 3) != 0) + abort (); + if (__builtin_object_size (&vara[7].c[7], 3) != 0) + abort (); + if (__builtin_object_size (zerol, 3) != 0) + abort (); + if (__builtin_object_size (&zerol, 3) != 0) + abort (); + if (__builtin_object_size (&zerol[0], 3) != 0) + abort (); + if (__builtin_object_size (zerol[0].a, 3) != 0) + abort (); + if (__builtin_object_size (&zerol[0].a[0], 3) != 0) + abort (); + if (__builtin_object_size (&zerol[0].b, 3) != 0) + abort (); + if (__builtin_object_size ("abcdefg", 3) != sizeof ("abcdefg")) + abort (); + if (__builtin_object_size ("abcd\0efg", 3) != sizeof ("abcd\0efg")) + abort (); + if (__builtin_object_size (&"abcd\0efg", 3) != sizeof ("abcd\0efg")) + abort (); + if (__builtin_object_size (&"abcd\0efg"[0], 3) != sizeof ("abcd\0efg")) + abort (); + if (__builtin_object_size (&"abcd\0efg"[4], 3) != sizeof ("abcd\0efg") - 4) + abort (); + if (__builtin_object_size ("abcd\0efg" + 5, 3) != sizeof ("abcd\0efg") - 5) + abort (); + if (__builtin_object_size (L"abcdefg", 3) != sizeof (L"abcdefg")) + abort (); + r = (char *) L"abcd\0efg"; + if (__builtin_object_size (r + 2, 3) != sizeof (L"abcd\0efg") - 2) + abort (); +} + +size_t l1 = 1; + +void +__attribute__ ((noinline)) +test2 (void) +{ + struct B { char buf1[10]; char buf2[10]; } a; + char *r, buf3[20]; + int i; + + if (sizeof (a) != 20) + return; + + r = buf3; + for (i = 0; i < 4; ++i) + { + if (i == l1 - 1) + r = &a.buf1[1]; + else if (i == l1) + r = &a.buf2[7]; + else if (i == l1 + 1) + r = &buf3[5]; + else if (i == l1 + 2) + r = &a.buf1[9]; + } + if (__builtin_object_size (r, 3) != sizeof (a.buf1) - 9) + abort (); + r = &buf3[20]; + for (i = 0; i < 4; ++i) + { + if (i == l1 - 1) + r = &a.buf1[7]; + else if (i == l1) + r = &a.buf2[7]; + else if (i == l1 + 1) + r = &buf3[5]; + else if (i == l1 + 2) + r = &a.buf1[9]; + } + if (__builtin_object_size (r, 3) != 0) + abort (); + r = &buf3[1]; + for (i = 0; i < 4; ++i) + { + if (i == l1 - 1) + r = &a.buf1[6]; + else if (i == l1) + r = &a.buf2[4]; + else if (i == l1 + 1) + r = &buf3[5]; + else if (i == l1 + 2) + r = &a.buf1[2]; + } + if (__builtin_object_size (r, 3) != sizeof (a.buf1) - 6) + abort (); + r += 2; + if (__builtin_object_size (r, 3) != sizeof (a.buf1) - 6 - 2) + abort (); + if (__builtin_object_size (r + 1, 3) != sizeof (a.buf1) - 6 - 3) + abort (); +} + +void +__attribute__ ((noinline)) +test3 (void) +{ + char buf4[10]; + struct B { struct A a[2]; struct A b; char c[4]; char d; double e; + _Complex double f; } x; + double y; + _Complex double z; + double *dp; + + if (__builtin_object_size (buf4, 3) != sizeof (buf4)) + abort (); + if (__builtin_object_size (&buf4, 3) != sizeof (buf4)) + abort (); + if (__builtin_object_size (&buf4[0], 3) != sizeof (buf4)) + abort (); + if (__builtin_object_size (&buf4[1], 3) != sizeof (buf4) - 1) + abort (); + if (__builtin_object_size (&x, 3) != sizeof (x)) + abort (); + if (__builtin_object_size (&x.a, 3) != sizeof (x.a)) + abort (); + if (__builtin_object_size (&x.a[0], 3) != sizeof (x.a)) + abort (); + if (__builtin_object_size (&x.a[0].a, 3) != sizeof (x.a[0].a)) + abort (); + if (__builtin_object_size (&x.a[0].a[0], 3) != sizeof (x.a[0].a)) + abort (); + if (__builtin_object_size (&x.a[0].a[3], 3) != sizeof (x.a[0].a) - 3) + abort (); + if (__builtin_object_size (&x.a[0].b, 3) != sizeof (x.a[0].b)) + abort (); + if (__builtin_object_size (&x.a[1].c, 3) != sizeof (x.a[1].c)) + abort (); + if (__builtin_object_size (&x.a[1].c[0], 3) != sizeof (x.a[1].c)) + abort (); + if (__builtin_object_size (&x.a[1].c[3], 3) != sizeof (x.a[1].c) - 3) + abort (); + if (__builtin_object_size (&x.b, 3) != sizeof (x.b)) + abort (); + if (__builtin_object_size (&x.b.a, 3) != sizeof (x.b.a)) + abort (); + if (__builtin_object_size (&x.b.a[0], 3) != sizeof (x.b.a)) + abort (); + if (__builtin_object_size (&x.b.a[3], 3) != sizeof (x.b.a) - 3) + abort (); + if (__builtin_object_size (&x.b.b, 3) != sizeof (x.b.b)) + abort (); + if (__builtin_object_size (&x.b.c, 3) != sizeof (x.b.c)) + abort (); + if (__builtin_object_size (&x.b.c[0], 3) != sizeof (x.b.c)) + abort (); + if (__builtin_object_size (&x.b.c[3], 3) != sizeof (x.b.c) - 3) + abort (); + if (__builtin_object_size (&x.c, 3) != sizeof (x.c)) + abort (); + if (__builtin_object_size (&x.c[0], 3) != sizeof (x.c)) + abort (); + if (__builtin_object_size (&x.c[1], 3) != sizeof (x.c) - 1) + abort (); + if (__builtin_object_size (&x.d, 3) != sizeof (x.d)) + abort (); + if (__builtin_object_size (&x.e, 3) != sizeof (x.e)) + abort (); + if (__builtin_object_size (&x.f, 3) != sizeof (x.f)) + abort (); + dp = &__real__ x.f; + if (__builtin_object_size (dp, 3) != sizeof (x.f) / 2) + abort (); + dp = &__imag__ x.f; + if (__builtin_object_size (dp, 3) != sizeof (x.f) / 2) + abort (); + dp = &y; + if (__builtin_object_size (dp, 3) != sizeof (y)) + abort (); + if (__builtin_object_size (&z, 3) != sizeof (z)) + abort (); + dp = &__real__ z; + if (__builtin_object_size (dp, 3) != sizeof (z) / 2) + abort (); + dp = &__imag__ z; + if (__builtin_object_size (dp, 3) != sizeof (z) / 2) + abort (); +} + +struct S { unsigned int a; }; + +char * +__attribute__ ((noinline)) +test4 (char *x, int y) +{ + register int i; + struct A *p; + + for (i = 0; i < y; i++) + { + p = (struct A *) x; + x = (char *) &p[1]; + if (__builtin_object_size (p, 3) != 0) + abort (); + } + return x; +} + +void +__attribute__ ((noinline)) +test5 (size_t x) +{ + struct T { char buf[64]; char buf2[64]; } t; + char *p = &t.buf[8]; + size_t i; + + for (i = 0; i < x; ++i) + p = p + 4; + if (__builtin_object_size (p, 3) != 0) + abort (); + memset (p, ' ', sizeof (t.buf) - 8 - 4 * 4); +} + +void +__attribute__ ((noinline)) +test6 (void) +{ + char buf[64]; + struct T { char buf[64]; char buf2[64]; } t; + char *p = &buf[64], *q = &t.buf[64]; + + if (__builtin_object_size (p + 64, 3) != 0) + abort (); + if (__builtin_object_size (q + 0, 3) != 0) + abort (); + if (__builtin_object_size (q + 64, 3) != 0) + abort (); +} + +void +__attribute__ ((noinline)) +test7 (void) +{ + struct T { char buf[10]; char buf2[10]; } t; + char *p = &t.buf2[-4]; + char *q = &t.buf2[0]; + if (__builtin_object_size (p, 3) != 0) + abort (); + if (__builtin_object_size (q, 3) != sizeof (t.buf2)) + abort (); + q = &t.buf[10]; + if (__builtin_object_size (q, 3) != 0) + abort (); + q = &t.buf[11]; + if (__builtin_object_size (q, 3) != 0) + abort (); + p = &t.buf[-4]; + if (__builtin_object_size (p, 3) != 0) + abort (); +} + +int +main (void) +{ + struct S s[10]; + __asm ("" : "=r" (l1) : "0" (l1)); + test1 (main, 6); + test2 (); + test3 (); + test4 ((char *) s, 10); + test5 (4); + test6 (); + test7 (); + exit (0); +} diff --git a/test/unimplemented/dg/builtin/builtin-prefetch-1.c b/test/unimplemented/dg/builtin/builtin-prefetch-1.c new file mode 100644 index 0000000..11beb4e --- /dev/null +++ b/test/unimplemented/dg/builtin/builtin-prefetch-1.c @@ -0,0 +1,45 @@ +/* Test that __builtin_prefetch does no harm. + + Prefetch using some invalid rw and locality values. These must be + compile-time constants. */ + +/* { dg-do run } */ + +extern void exit (int); + +enum locality { none, low, moderate, high, bogus }; +enum rw { read, write }; + +int arr[10]; + +void +good (int *p) +{ + __builtin_prefetch (p, 0, 0); + __builtin_prefetch (p, 0, 1); + __builtin_prefetch (p, 0, 2); + __builtin_prefetch (p, 0, 3); + __builtin_prefetch (p, 1, 0); + __builtin_prefetch (p, 1, 1); + __builtin_prefetch (p, 1, 2); + __builtin_prefetch (p, 1, 3); +} + +void +bad (int *p) +{ + __builtin_prefetch (p, -1, 0); /* { dg-warning "invalid second argument to '__builtin_prefetch'; using zero" } */ + __builtin_prefetch (p, 2, 0); /* { dg-warning "invalid second argument to '__builtin_prefetch'; using zero" } */ + __builtin_prefetch (p, bogus, 0); /* { dg-warning "invalid second argument to '__builtin_prefetch'; using zero" } */ + __builtin_prefetch (p, 0, -1); /* { dg-warning "invalid third argument to '__builtin_prefetch'; using zero" } */ + __builtin_prefetch (p, 0, 4); /* { dg-warning "invalid third argument to '__builtin_prefetch'; using zero" } */ + __builtin_prefetch (p, 0, bogus); /* { dg-warning "invalid third argument to '__builtin_prefetch'; using zero" } */ +} + +int +main () +{ + good (arr); + bad (arr); + exit (0); +} diff --git a/test/unimplemented/dg/builtin/builtin-return-1.c b/test/unimplemented/dg/builtin/builtin-return-1.c new file mode 100644 index 0000000..75c9acd --- /dev/null +++ b/test/unimplemented/dg/builtin/builtin-return-1.c @@ -0,0 +1,34 @@ +/* PR middle-end/11151 */ +/* Originator: Andrew Church */ +/* { dg-do run } */ + +/* This used to fail on SPARC because the (undefined) return + value of 'bar' was overwriting that of 'foo'. */ + +extern void abort(void); + +int foo(int n) +{ + return n+1; +} + +int bar(int n) +{ + __builtin_return(__builtin_apply((void (*)(void))foo, __builtin_apply_args(), 64)); +} + +char *g; + +int main(void) +{ + /* Allocate 64 bytes on the stack to make sure that __builtin_apply + can read at least 64 bytes above the return address. */ + char dummy[64]; + + g = dummy; + + if (bar(1) != 2) + abort(); + + return 0; +} diff --git a/test/unimplemented/dg/builtin/builtins-64.c b/test/unimplemented/dg/builtin/builtins-64.c new file mode 100644 index 0000000..6e84633 --- /dev/null +++ b/test/unimplemented/dg/builtin/builtins-64.c @@ -0,0 +1,8 @@ +/* { dg-do run } */ + +int main () +{ + char *mem = __builtin_alloca (40); + __builtin___clear_cache (mem, mem + 40); + return 0; +} diff --git a/test/unimplemented/dg/builtin/pr19402-2.c b/test/unimplemented/dg/builtin/pr19402-2.c new file mode 100644 index 0000000..1902227 --- /dev/null +++ b/test/unimplemented/dg/builtin/pr19402-2.c @@ -0,0 +1,82 @@ +/* { dg-do run } */ +/* { dg-options "-fno-inline -Os" } */ + +void abort(void); + + +float powif(float x, int n) +{ + return __builtin_powif(x, n); +} + +double powi(double x, int n) +{ + return __builtin_powi(x, n); +} + +long double powil(long double x, int n) +{ + return __builtin_powil(x, n); +} + + +float powcif(float x) +{ + return __builtin_powif(x, 5); +} + +double powci(double x) +{ + return __builtin_powi(x, 5); +} + +long double powcil(long double x) +{ + return __builtin_powil(x, 5); +} + + +float powicf(int n) +{ + return __builtin_powif(2.0, n); +} + +double powic(int n) +{ + return __builtin_powi(2.0, n); +} + +long double powicl(int n) +{ + return __builtin_powil(2.0, n); +} + + +int main() +{ + if (__builtin_powi(1.0, 5) != 1.0) + abort(); + if (__builtin_powif(1.0, 5) != 1.0) + abort(); + if (__builtin_powil(1.0, 5) != 1.0) + abort(); + if (powci(1.0) != 1.0) + abort(); + if (powcif(1.0) != 1.0) + abort(); + if (powcil(1.0) != 1.0) + abort(); + if (powi(1.0, -5) != 1.0) + abort(); + if (powif(1.0, -5) != 1.0) + abort(); + if (powil(1.0, -5) != 1.0) + abort(); + if (powic(1) != 2.0) + abort(); + if (powicf(1) != 2.0) + abort(); + if (powicl(1) != 2.0) + abort(); + return 0; +} diff --git a/test/unimplemented/dg/builtin/pr28796-2.c b/test/unimplemented/dg/builtin/pr28796-2.c new file mode 100644 index 0000000..6a9eff8 --- /dev/null +++ b/test/unimplemented/dg/builtin/pr28796-2.c @@ -0,0 +1,10 @@ +/* { dg-do run } */ +/* { dg-options "-O2 -funsafe-math-optimizations -fno-finite-math-only" } */ +/* { dg-options "-mieee -O2 -funsafe-math-optimizations -fno-finite-math-only" { target alpha*-*-* } } */ + +#include "tg-tests.h" + +int main(void) +{ + return main_tests (); +} diff --git a/test/unimplemented/dg/builtin/pr30957-1.c b/test/unimplemented/dg/builtin/pr30957-1.c new file mode 100644 index 0000000..26d5de7 --- /dev/null +++ b/test/unimplemented/dg/builtin/pr30957-1.c @@ -0,0 +1,30 @@ +/* { dg-do run { xfail vax-*-* powerpc-*-*spe } } */ +/* { dg-options "-O2 -funroll-loops -funsafe-math-optimizations -fvariable-expansion-in-unroller -dL" } */ + +extern void abort (void); +extern void exit (int); + +float +foo (float d, int n) +{ + unsigned i; + float accum = d; + + for (i = 0; i < n; i++) + accum += d; + + return accum; +} + +int +main () +{ + if (__builtin_copysignf (1.0, foo (0.0 / -5.0, 10)) != -1.0) + abort (); + exit (0); +} + +/* { dg-final { scan-rtl-dump "Expanding Accumulator" "loop2_unroll" } } */ +/* { dg-final { cleanup-rtl-dump "loop*" } } */ + + diff --git a/test/unimplemented/dg/builtin/tg-tests.h b/test/unimplemented/dg/builtin/tg-tests.h new file mode 100644 index 0000000..9d31e4b --- /dev/null +++ b/test/unimplemented/dg/builtin/tg-tests.h @@ -0,0 +1,119 @@ +/* Test various type-generic builtins by calling "main_tests()". */ + +void __attribute__ ((__noinline__)) +foo_1 (float f, double d, long double ld, + int res_unord, int res_isnan, int res_isinf, + int res_isfin, int res_isnorm) +{ + if (__builtin_isunordered (f, 0) != res_unord) + __builtin_abort (); + if (__builtin_isunordered (0, f) != res_unord) + __builtin_abort (); + if (__builtin_isunordered (d, 0) != res_unord) + __builtin_abort (); + if (__builtin_isunordered (0, d) != res_unord) + __builtin_abort (); + if (__builtin_isunordered (ld, 0) != res_unord) + __builtin_abort (); + if (__builtin_isunordered (0, ld) != res_unord) + __builtin_abort (); + + if (__builtin_isnan (f) != res_isnan) + __builtin_abort (); + if (__builtin_isnan (d) != res_isnan) + __builtin_abort (); + if (__builtin_isnan (ld) != res_isnan) + __builtin_abort (); + if (__builtin_isnanf (f) != res_isnan) + __builtin_abort (); + if (__builtin_isnanl (ld) != res_isnan) + __builtin_abort (); + + if (__builtin_isinf (f) != res_isinf) + __builtin_abort (); + if (__builtin_isinf (d) != res_isinf) + __builtin_abort (); + if (__builtin_isinf (ld) != res_isinf) + __builtin_abort (); + if (__builtin_isinff (f) != res_isinf) + __builtin_abort (); + if (__builtin_isinfl (ld) != res_isinf) + __builtin_abort (); + + if (__builtin_isnormal (f) != res_isnorm) + __builtin_abort (); + if (__builtin_isnormal (d) != res_isnorm) + __builtin_abort (); + if (__builtin_isnormal (ld) != res_isnorm) + __builtin_abort (); + + if (__builtin_isfinite (f) != res_isfin) + __builtin_abort (); + if (__builtin_isfinite (d) != res_isfin) + __builtin_abort (); + if (__builtin_isfinite (ld) != res_isfin) + __builtin_abort (); + + if (__builtin_finitef (f) != res_isfin) + __builtin_abort (); + if (__builtin_finite (f) != res_isfin) + __builtin_abort (); + if (__builtin_finite (d) != res_isfin) + __builtin_abort (); + if (__builtin_finitel (d) != res_isfin) + __builtin_abort (); + if (__builtin_finitel (ld) != res_isfin) + __builtin_abort (); +} + +void __attribute__ ((__noinline__)) +foo (float f, double d, long double ld, + int res_unord, int res_isnan, int res_isinf, + int res_isfin, int res_isnorm) +{ + foo_1 (f, d, ld, res_unord, res_isnan, res_isinf, res_isfin, res_isnorm); + /* Try all the values negated as well. */ + foo_1 (-f, -d, -ld, res_unord, res_isnan, res_isinf, res_isfin, res_isnorm); +} + +int __attribute__ ((__noinline__)) +main_tests (void) +{ + float f; + double d; + long double ld; + + /* Test NaN. */ + f = __builtin_nanf(""); d = __builtin_nan(""); ld = __builtin_nanl(""); + foo(f, d, ld, /*unord=*/ 1, /*isnan=*/ 1, /*isinf=*/ 0, /*isfin=*/ 0, /*isnorm=*/ 0); + + /* Test infinity. */ + f = __builtin_inff(); d = __builtin_inf(); ld = __builtin_infl(); + foo(f, d, ld, /*unord=*/ 0, /*isnan=*/ 0, /*isinf=*/ 1, /*isfin=*/ 0, /*isnorm=*/ 0); + + /* Test zero. */ + f = 0; d = 0; ld = 0; + foo(f, d, ld, /*unord=*/ 0, /*isnan=*/ 0, /*isinf=*/ 0, /*isfin=*/ 1, /*isnorm=*/ 0); + + /* Test one. */ + f = 1; d = 1; ld = 1; + foo(f, d, ld, /*unord=*/ 0, /*isnan=*/ 0, /*isinf=*/ 0, /*isfin=*/ 1, /*isnorm=*/ 1); + + /* Test minimum values. */ + f = __FLT_MIN__; d = __DBL_MIN__; ld = __LDBL_MIN__; + foo(f, d, ld, /*unord=*/ 0, /*isnan=*/ 0, /*isinf=*/ 0, /*isfin=*/ 1, /*isnorm=*/ 1); + + /* Test subnormal values. */ + f = __FLT_MIN__/2; d = __DBL_MIN__/2; ld = __LDBL_MIN__/2; + foo(f, d, ld, /*unord=*/ 0, /*isnan=*/ 0, /*isinf=*/ 0, /*isfin=*/ 1, /*isnorm=*/ 0); + + /* Test maximum values. */ + f = __FLT_MAX__; d = __DBL_MAX__; ld = __LDBL_MAX__; + foo(f, d, ld, /*unord=*/ 0, /*isnan=*/ 0, /*isinf=*/ 0, /*isfin=*/ 1, /*isnorm=*/ 1); + + /* Test overflow values. */ + f = __FLT_MAX__*2; d = __DBL_MAX__*2; ld = __LDBL_MAX__*2; + foo(f, d, ld, /*unord=*/ 0, /*isnan=*/ 0, /*isinf=*/ 1, /*isfin=*/ 0, /*isnorm=*/ 0); + + return 0; +} diff --git a/test/unimplemented/dg/builtin/va-arg-pack-len-1.c b/test/unimplemented/dg/builtin/va-arg-pack-len-1.c new file mode 100644 index 0000000..409c345 --- /dev/null +++ b/test/unimplemented/dg/builtin/va-arg-pack-len-1.c @@ -0,0 +1,122 @@ +/* { dg-do run } */ +/* { dg-options "-O2" } */ + +#include + +extern int error_open_missing_mode (void) + __attribute__((__error__ ("open with O_CREAT needs 3 arguments, only 2 were given"))); +extern int warn_open_too_many_arguments (void) + __attribute__((__warning__ ("open called with more than 3 arguments"))); +extern void abort (void); + +char expected_char; + +__attribute__((noinline)) int +myopen2 (const char *path, int oflag) +{ + if (expected_char++ != path[0] || path[1] != '\0') + abort (); + switch (path[0]) + { + case 'f': + if (oflag != 0x2) + abort (); + break; + case 'g': + if (oflag != 0x43) + abort (); + /* In real __open_2 this would terminate the program: + open with O_CREAT without third argument. */ + return -6; + default: + abort (); + } + return 0; +} + +__attribute__((noinline)) int +myopenva (const char *path, int oflag, ...) +{ + int mode = 0; + va_list ap; + if ((oflag & 0x40) != 0) + { + va_start (ap, oflag); + mode = va_arg (ap, int); + va_end (ap); + } + if (expected_char++ != path[0] || path[1] != '\0') + abort (); + switch (path[0]) + { + case 'a': + if (oflag != 0x43 || mode != 0644) + abort (); + break; + case 'b': + if (oflag != 0x3) + abort (); + break; + case 'c': + if (oflag != 0x2) + abort (); + break; + case 'd': + if (oflag != 0x43 || mode != 0600) + abort (); + break; + case 'e': + if (oflag != 0x3) + abort (); + break; + default: + abort (); + } + return 0; +} + +extern inline __attribute__((always_inline, gnu_inline)) int +myopen (const char *path, int oflag, ...) +{ + if (__builtin_va_arg_pack_len () > 1) + warn_open_too_many_arguments (); + + if (__builtin_constant_p (oflag)) + { + if ((oflag & 0x40) != 0 && __builtin_va_arg_pack_len () < 1) + { + error_open_missing_mode (); + return myopen2 (path, oflag); + } + return myopenva (path, oflag, __builtin_va_arg_pack ()); + } + + if (__builtin_va_arg_pack_len () < 1) + return myopen2 (path, oflag); + + return myopenva (path, oflag, __builtin_va_arg_pack ()); +} + +volatile int l0; + +int +main (void) +{ + expected_char = 'a'; + if (myopen ("a", 0x43, 0644)) + abort (); + if (myopen ("b", 0x3, 0755)) + abort (); + if (myopen ("c", 0x2)) + abort (); + if (myopen ("d", l0 + 0x43, 0600)) + abort (); + if (myopen ("e", l0 + 0x3, 0700)) + abort (); + if (myopen ("f", l0 + 0x2)) + abort (); + /* Invalid use of myopen, but only detectable at runtime. */ + if (myopen ("g", l0 + 0x43) != -6) + abort (); + return 0; +} diff --git a/test/unimplemented/dg/c90-digraph-1.c b/test/unimplemented/dg/c90-digraph-1.c new file mode 100644 index 0000000..9396d13 --- /dev/null +++ b/test/unimplemented/dg/c90-digraph-1.c @@ -0,0 +1,24 @@ +/* Test for recognition of digraphs: should be recognized in C94 and C99 + mode, but not in C90 mode. Also check correct stringizing. +*/ +/* Origin: Joseph Myers */ +/* { dg-do run } */ +/* { dg-options "-std=iso9899:1990 -pedantic-errors" } */ + +#define str(x) xstr(x) +#define xstr(x) #x +#define foo(p, q) str(p %:%: q) + +extern void abort (void); +extern int strcmp (const char *, const char *); + +int +main (void) +{ + const char *t = foo (1, 2); + const char *u = str (<:); + if (strcmp (t, "1 %:%: 2") || strcmp (u, "<:")) + abort (); + else + return 0; +} diff --git a/test/unimplemented/dg/c94-digraph-1.c b/test/unimplemented/dg/c94-digraph-1.c new file mode 100644 index 0000000..55d7714 --- /dev/null +++ b/test/unimplemented/dg/c94-digraph-1.c @@ -0,0 +1,24 @@ +/* Test for recognition of digraphs: should be recognized in C94 and C99 + mode, but not in C90 mode. Also check correct stringizing. +*/ +/* Origin: Joseph Myers */ +/* { dg-do run } */ +/* { dg-options "-std=iso9899:199409 -pedantic-errors" } */ + +#define str(x) xstr(x) +#define xstr(x) #x +#define foo(p, q) str(p %:%: q) + +extern void abort (void); +extern int strcmp (const char *, const char *); + +int +main (void) +{ + const char *t = foo (1, 2); + const char *u = str (<:); + if (strcmp (t, "12") || strcmp (u, "<:")) + abort (); + else + return 0; +} diff --git a/test/unimplemented/dg/c99-digraph-1.c b/test/unimplemented/dg/c99-digraph-1.c new file mode 100644 index 0000000..318aa70 --- /dev/null +++ b/test/unimplemented/dg/c99-digraph-1.c @@ -0,0 +1,24 @@ +/* Test for recognition of digraphs: should be recognized in C94 and C99 + mode, but not in C90 mode. Also check correct stringizing. +*/ +/* Origin: Joseph Myers */ +/* { dg-do run } */ +/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */ + +#define str(x) xstr(x) +#define xstr(x) #x +#define foo(p, q) str(p %:%: q) + +extern void abort (void); +extern int strcmp (const char *, const char *); + +int +main (void) +{ + const char *t = foo (1, 2); + const char *u = str (<:); + if (strcmp (t, "12") || strcmp (u, "<:")) + abort (); + else + return 0; +} diff --git a/test/unimplemented/dg/c99/c99-complit-1.c b/test/unimplemented/dg/c99/c99-complit-1.c new file mode 100644 index 0000000..94e15db --- /dev/null +++ b/test/unimplemented/dg/c99/c99-complit-1.c @@ -0,0 +1,112 @@ +/* Test for compound literals: in C99 only. Test for valid uses. */ +/* Origin: Joseph Myers */ +/* { dg-do run } */ +/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */ + +extern void abort (void); +extern void exit (int); + +struct s { int a; int b; }; +union u { int c; int d; }; + +int *i0a = &(int) { 0 }; +int *i0b = &(int) { 0 }; +int *i1a = &(int) { 1 }; +int *i1b = &(int) { 1 }; +const int *i0c = &(const int) { 0 }; + +struct s *s0 = &(struct s) { 1, 2 }; +struct s *s1 = &(struct s) { 1, 2 }; +const struct s *s2 = &(const struct s) { 1, 2 }; + +union u *u0 = &(union u) { 3 }; +union u *u1 = &(union u) { 3 }; +const union u *u2 = &(const union u) { 3 }; + +int *a0 = (int []) { 1, 2, 3 }; +const int *a1 = (const int []) { 1, 2, 3 }; + +char *p = (char []){ "foo" }; + +int +main (void) +{ + if (i0a == i0b || i0a == i0c || i0b == i0c) + abort (); + if (i1a == i1b) + abort (); + if (*i0a != 0 || *i0b != 0 || *i1a != 1 || *i1b != 1 || *i0c != 0) + abort (); + *i0a = 1; + *i1a = 0; + if (*i0a != 1 || *i0b != 0 || *i1a != 0 || *i1b != 1 || *i0c != 0) + abort (); + if (s0 == s1 || s1 == s2 || s2 == s0) + abort (); + if (s0->a != 1 || s0->b != 2 || s1->a != 1 || s1->b != 2 + || s2->a != 1 || s2->b != 2) + abort (); + s0->a = 2; + s1->b = 1; + if (s0->a != 2 || s0->b != 2 || s1->a != 1 || s1->b != 1 + || s2->a != 1 || s2->b != 2) + abort (); + if (u0 == u1 || u1 == u2 || u2 == u0) + abort (); + if (u0->c != 3 || u1->c != 3 || u2->c != 3) + abort (); + u0->d = 2; + if (u0->d != 2 || u1->c != 3 || u2->c != 3) + abort (); + if (a0 == a1) + abort (); + if (a0[0] != 1 || a0[1] != 2 || a0[2] != 3 + || a1[0] != 1 || a1[1] != 2 || a1[2] != 3) + abort (); + a0[0] = 3; + if (a0[0] != 3 || a0[1] != 2 || a0[2] != 3 + || a1[0] != 1 || a1[1] != 2 || a1[2] != 3) + abort (); + if (p[0] != 'f' || p[1] != 'o' || p[2] != 'o' || p[3] != 0) + abort (); + p[0] = 'g'; + if (p[0] != 'g' || p[1] != 'o' || p[2] != 'o' || p[3] != 0) + abort (); + if (sizeof((int []) { 1, 2 ,3 }) != 3 * sizeof(int)) + abort (); + if (sizeof((int []) { [3] = 4 }) != 4 * sizeof(int)) + abort (); + struct s *y; + for (int i = 0; i < 3; i++) { + struct s *x = &(struct s) { 1, i }; + if (x->a != 1 || x->b != i) + abort (); + x->a++; + x->b--; + if (x->a != 2 || x->b != i - 1) + abort (); + if (i && y != x) + abort (); + y = x; + } + int *z; + for (int i = 0; i < 4; i++) { + int *x = (int []){ 0, i, i + 2, i - 3 }; + if (x[0] != 0 || x[1] != i || x[2] != i + 2 || x[3] != i - 3) + abort (); + x[0] = x[1]; + x[1] *= x[2]; + x[2] -= x[3]; + x[3] += 7; + if (x[0] != i || x[1] != i * (i + 2) || x[2] != 5 || x[3] != i + 4) + abort (); + if (i && z != x) + abort (); + z = x; + } + (int) { 0 } = 1; + (struct s) { 0, 1 }.a = 3; + (union u) { 3 }.c = 4; + (int []){ 1, 2 }[0] = 0; + exit (0); +} diff --git a/test/unimplemented/dg/c99/c99-fordecl-1.c b/test/unimplemented/dg/c99/c99-fordecl-1.c new file mode 100644 index 0000000..faaab1e --- /dev/null +++ b/test/unimplemented/dg/c99/c99-fordecl-1.c @@ -0,0 +1,35 @@ +/* Test for C99 declarations in for loops. */ +/* Origin: Joseph Myers */ +/* { dg-do run } */ +/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */ + +extern void abort (void); +extern void exit (int); + +int +main (void) +{ + int j = 0; + int i = -1; + for (int i = 1; i <= 10; i++) + j += i; + if (j != 55) + abort (); + if (i != -1) + abort (); + j = 0; + for (auto int i = 1; i <= 10; i++) + j += i; + if (j != 55) + abort (); + if (i != -1) + abort (); + j = 0; + for (register int i = 1; i <= 10; i++) + j += i; + if (j != 55) + abort (); + if (i != -1) + abort (); + exit (0); +} diff --git a/test/unimplemented/dg/c99/c99-init-1.c b/test/unimplemented/dg/c99/c99-init-1.c new file mode 100644 index 0000000..95803c2 --- /dev/null +++ b/test/unimplemented/dg/c99/c99-init-1.c @@ -0,0 +1,78 @@ +/* Test for C99 designated initializers */ +/* Origin: Jakub Jelinek */ +/* { dg-do run } */ +/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */ + +typedef __SIZE_TYPE__ size_t; +typedef __WCHAR_TYPE__ wchar_t; +extern int memcmp (const void *, const void *, size_t); +extern void abort (void); +extern void exit (int); + +int a[10] = { 10, 0, 12, 13, 14, 0, 0, 17, 0, 0 }; +int b[10] = { 10, [4] = 15, [2] = 12, [4] = 14, [7] = 17 }; +int c[10] = { 10, [4] = 15, [2] = 12, [3] = 13, 14, [7] = 17 }; +struct A { + int B; + short C[2]; +}; +struct A d[] = { { 0, { 1, 2 } }, { 0, { 0, 0 } }, { 10, { 11, 12 } } }; +struct A e[] = { 0, 1, 2, [2] = 10, 11, 12 }; +struct A f[] = { 0, 1, 2, [2].C = 11, 12, 13 }; +struct A g[] = { 0, 1, 2, [2].C[1] = 12, 13, 14 }; +struct A h[] = { 0, 1, 2, [2] = { .C[1] = 12 }, 13, 14 }; +struct A i[] = { 0, 1, 2, [2] = { .C = { [1] = 12 } }, 13, 14 }; +union D { + int E; + double F; + struct A G; +}; +union D j[] = { [4] = 1, [4].F = 1.0, [1].G.C[1] = 4 }; +struct H { + char I[6]; + int J; +} k[] = { { { "foo" }, 1 }, [0].I[0] = 'b' }; +struct K { + wchar_t L[6]; + int M; +} l[] = { { { L"foo" }, 1 }, [0].L[2] = L'x', [0].L[4] = L'y' }; +struct H m[] = { { { "foo" }, 1 }, [0] = { .I[0] = 'b' } }; +struct H n[] = { { { "foo" }, 1 }, [0].I = { "a" }, [0].J = 2 }; +int o = { 22 }; + +int main (void) +{ + if (b[3]) + abort (); + b[3] = 13; + if (memcmp (a, b, sizeof (a)) || memcmp (a, c, sizeof (a))) + abort (); + if (memcmp (d, e, sizeof (d)) || sizeof (d) != sizeof (e)) + abort (); + if (f[2].B != 0 || g[2].B != 0 || g[2].C[0] != 0) + abort (); + if (memcmp (g, h, sizeof (g)) || memcmp (g, i, sizeof (g))) + abort (); + f[2].B = 10; + g[2].B = 10; + g[2].C[0] = 11; + if (memcmp (d, f, sizeof (d)) || memcmp (d, g, sizeof (d))) + abort (); + if (f[3].B != 13 || g[3].B != 13 || g[3].C[0] != 14) + abort (); + if (j[0].E || j[1].G.B || j[1].G.C[0] || j[1].G.C[1] != 4) + abort (); + if (j[2].E || j[3].E || j[4].F != 1.0) + abort (); + if (memcmp (k[0].I, "boo\0\0", 6) || k[0].J != 1) + abort (); + if (memcmp (l[0].L, L"fox\0y", 6 * sizeof(wchar_t)) || l[0].M != 1) + abort (); + if (memcmp (m[0].I, "b\0\0\0\0", 6) || m[0].J) + abort (); + if (memcmp (n[0].I, "a\0\0\0\0", 6) || n[0].J != 2) + abort (); + if (o != 22) + abort (); + exit (0); +} diff --git a/test/unimplemented/dg/cleanup-2.c b/test/unimplemented/dg/cleanup-2.c new file mode 100644 index 0000000..2c79802 --- /dev/null +++ b/test/unimplemented/dg/cleanup-2.c @@ -0,0 +1,22 @@ +/* { dg-do run } */ +/* { dg-options "" } */ +/* Verify that cleanup works in the most basic of ways. */ + +extern void exit(int); +extern void abort(void); + +static void handler(void *p __attribute__((unused))) +{ + exit (0); +} + +static void doit(void) +{ + int x __attribute__((cleanup (handler))); +} + +int main() +{ + doit (); + abort (); +} diff --git a/test/unimplemented/dg/cleanup-4.c b/test/unimplemented/dg/cleanup-4.c new file mode 100644 index 0000000..a548755 --- /dev/null +++ b/test/unimplemented/dg/cleanup-4.c @@ -0,0 +1,39 @@ +/* { dg-do run } */ +/* { dg-options "" } */ +/* Verify cleanup execution on non-trivial exit from a block. */ + +extern void exit(int); +extern void abort(void); + +static int counter; + +static void +handler(int *p) +{ + counter += *p; +} + +static void __attribute__((noinline)) +bar(void) +{ +} + +static void doit(int n, int n2) +{ + int i; + for (i = 0; i < n; ++i) + { + int dummy __attribute__((cleanup (handler))) = i; + if (i == n2) + break; + bar(); + } +} + +int main() +{ + doit (10, 6); + if (counter != 0 + 1 + 2 + 3 + 4 + 5 + 6) + abort (); + return 0; +} diff --git a/test/unimplemented/dg/complex/complex-1.c b/test/unimplemented/dg/complex/complex-1.c new file mode 100644 index 0000000..7153433 --- /dev/null +++ b/test/unimplemented/dg/complex/complex-1.c @@ -0,0 +1,31 @@ +/* { dg-do run } */ +/* { dg-options "-O" } */ + +/* Verify that the 6th complex floating-point argument is + correctly passed as unnamed argument on SPARC64. */ + +extern void abort(void); + +void foo(long arg1, long arg2, long arg3, long arg4, long arg5, ...) +{ + __builtin_va_list ap; + _Complex float cf; + + __builtin_va_start(ap, arg5); + cf = __builtin_va_arg(ap, _Complex float); + __builtin_va_end(ap); + + if (__imag__ cf != 2.0f) + abort(); +} + +int bar(long arg1, long arg2, long arg3, long arg4, long arg5, _Complex float arg6) +{ + foo(arg1, arg2, arg3, arg4, arg5, arg6); + return 0; +} + +int main(void) +{ + return bar(0, 0, 0, 0, 0, 2.0fi); +} diff --git a/test/unimplemented/dg/complex/complex-3.c b/test/unimplemented/dg/complex/complex-3.c new file mode 100644 index 0000000..54ec82c --- /dev/null +++ b/test/unimplemented/dg/complex/complex-3.c @@ -0,0 +1,25 @@ +/* Verify that rtl expansion cleanup doesn't get too aggressive about + code dealing with complex CONCATs. */ +/* { dg-do run } */ +/* { dg-options "-O -fno-tree-sra" } */ + +extern void abort (void); +extern void exit (int); + +__complex__ float foo (void) +{ + __complex__ float f[1]; + __real__ f[0] = 1; + __imag__ f[0] = 1; + f[0] = __builtin_conjf (f[0]); + return f[0]; +} + +int main (void) +{ + __complex__ double d[1]; + d[0] = foo (); + if (__real__ d[0] != 1 || __imag__ d[0] != -1) + abort (); + exit (0); +} diff --git a/test/unimplemented/dg/complex/pr30360.c b/test/unimplemented/dg/complex/pr30360.c new file mode 100644 index 0000000..d4dae0d --- /dev/null +++ b/test/unimplemented/dg/complex/pr30360.c @@ -0,0 +1,25 @@ +/* PR c/30360 */ +/* { dg-do run { target i?86-*-linux* x86_64-*-linux* ia64-*-linux* s390*-*-linux* } } */ +/* { dg-options "-O2 -std=gnu99" } */ + +#define I (__extension__ 1.0iF) +#define H(x) asm ("" : "=m" (x) : "m" (x)) +extern void abort (void); + +int +main (void) +{ + _Complex double a = 1.0 + 1.0 * I, b = 0.0, c; + H (a); + H (b); + c = a / b; + if (!__builtin_isinf (__real__ c) && !__builtin_isinf (__imag__ c)) + abort (); + a = 0.0; + H (a); + H (b); + c = a / b; + if (!__builtin_isnan (__real__ c) || !__builtin_isnan (__imag__ c)) + abort (); + return 0; +} diff --git a/test/unimplemented/dg/enum1.c b/test/unimplemented/dg/enum1.c new file mode 100644 index 0000000..096defc --- /dev/null +++ b/test/unimplemented/dg/enum1.c @@ -0,0 +1,23 @@ +/* { dg-do run } */ +/* { dg-options "-std=gnu89" } */ + +/* In standard C, enumeration constants always have type int. If they + are not representables are int, they're ill-formed. In GNU C, we + give such ill-formed constructs well-defined meaning. Make sure it + works. */ + +#include + +enum foo +{ + foo1 = 0, + foo2 = 0xffffffffULL, + foo3 = 0xf0fffffeULL +}; + +int main () +{ + if (sizeof (enum foo) != sizeof (unsigned long long)) + abort (); + exit (0); +} diff --git a/test/unimplemented/dg/gnu89-init-1.c b/test/unimplemented/dg/gnu89-init-1.c new file mode 100644 index 0000000..07bf823 --- /dev/null +++ b/test/unimplemented/dg/gnu89-init-1.c @@ -0,0 +1,69 @@ +/* Test for GNU extensions to compound literals */ +/* Origin: Jakub Jelinek */ +/* { dg-do run } */ +/* { dg-options "-std=gnu89" } */ + +extern void abort (void); +extern void exit (int); + +struct A { int i; int j; int k[4]; }; +struct B { }; +struct C { int i; }; +struct D { int i; struct C j; }; + +/* As a GNU extension, we allow initialization of objects with static storage + duration by compound literals. It is handled as if the object + was initialized only with the bracket enclosed list if compound literal's + and object types match. If the object being initialized has array type + of unknown size, the size is determined by compound literal's initializer + list, not by size of the compound literal. */ + +struct A a = (struct A) { .j = 6, .k[2] = 12 }; +struct B b = (struct B) { }; +int c[] = (int []) { [2] = 6, 7, 8 }; +int d[] = (int [3]) { 1 }; +int e[2] = (int []) { 1, 2 }; +int f[2] = (int [2]) { 1 }; +struct C g[3] = { [2] = (struct C) { 13 }, [1] = (const struct C) { 12 } }; +struct D h = { .j = (struct C) { 15 }, .i = 14 }; +struct D i[2] = { [1].j = (const struct C) { 17 }, + [0] = { 0, (struct C) { 16 } } }; +struct C j[2][3] = { [0 ... 1] = { [0 ... 2] = (struct C) { 26 } } }; +struct C k[3][2] = { [0 ... 2][0 ... 1] = (const struct C) { 27 } }; + +int main (void) +{ + if (a.i || a.j != 6 || a.k[0] || a.k[1] || a.k[2] != 12 || a.k[3]) + abort (); + if (c[0] || c[1] || c[2] != 6 || c[3] != 7 || c[4] != 8) + abort (); + if (sizeof (c) != 5 * sizeof (int)) + abort (); + if (d[0] != 1 || d[1] || d[2]) + abort (); + if (sizeof (d) != 3 * sizeof (int)) + abort (); + if (e[0] != 1 || e[1] != 2) + abort (); + if (sizeof (e) != 2 * sizeof (int)) + abort (); + if (f[0] != 1 || f[1]) + abort (); + if (sizeof (f) != 2 * sizeof (int)) + abort (); + if (g[0].i || g[1].i != 12 || g[2].i != 13) + abort (); + if (h.i != 14 || h.j.i != 15) + abort (); + if (i[0].i || i[0].j.i != 16 || i[1].i || i[1].j.i != 17) + abort (); + if (j[0][0].i != 26 || j[0][1].i != 26 || j[0][2].i != 26) + abort (); + if (j[1][0].i != 26 || j[1][1].i != 26 || j[1][2].i != 26) + abort (); + if (k[0][0].i != 27 || k[0][1].i != 27 || k[1][0].i != 27) + abort (); + if (k[1][1].i != 27 || k[2][0].i != 27 || k[2][1].i != 27) + abort (); + exit (0); +} diff --git a/test/unimplemented/dg/gnu99-init-1.c b/test/unimplemented/dg/gnu99-init-1.c new file mode 100644 index 0000000..009c851 --- /dev/null +++ b/test/unimplemented/dg/gnu99-init-1.c @@ -0,0 +1,80 @@ +/* Test for GNU extensions to C99 designated initializers */ +/* Origin: Jakub Jelinek */ +/* { dg-do run } */ +/* { dg-options "-std=gnu99" } */ + +typedef __SIZE_TYPE__ size_t; +extern int memcmp (const void *, const void *, size_t); +extern void abort (void); +extern void exit (int); + +int a[][2][4] = { [2 ... 4][0 ... 1][2 ... 3] = 1, [2] = 2, [2][0][2] = 3 }; +struct E {}; +struct F { struct E H; }; +struct G { int I; struct E J; int K; }; +struct H { int I; struct F J; int K; }; +struct G k = { .J = {}, 1 }; +struct H l = { .J.H = {}, 2 }; +struct H m = { .J = {}, 3 }; +struct I { int J; int K[3]; int L; }; +struct M { int N; struct I O[3]; int P; }; +struct M n[] = { [0 ... 5].O[1 ... 2].K[0 ... 1] = 4, 5, 6, 7 }; +struct M o[] = { [0 ... 5].O = { [1 ... 2].K[0 ... 1] = 4 }, + [5].O[2].K[2] = 5, 6, 7 }; +struct M p[] = { [0 ... 5].O[1 ... 2].K = { [0 ... 1] = 4 }, + [5].O[2].K[2] = 5, 6, 7 }; +int q[3][3] = { [0 ... 1] = { [1 ... 2] = 23 }, [1][2] = 24 }; +int r[1] = { [0 ... 1 - 1] = 27 }; + +int main (void) +{ + int x, y, z; + + if (a[2][0][0] != 2 || a[2][0][2] != 3) + abort (); + a[2][0][0] = 0; + a[2][0][2] = 1; + for (x = 0; x <= 4; x++) + for (y = 0; y <= 1; y++) + for (z = 0; z <= 3; z++) + if (a[x][y][z] != (x >= 2 && z >= 2)) + abort (); + if (k.I || l.I || m.I || k.K != 1 || l.K != 2 || m.K != 3) + abort (); + for (x = 0; x <= 5; x++) + { + if (n[x].N || n[x].O[0].J || n[x].O[0].L) + abort (); + for (y = 0; y <= 2; y++) + if (n[x].O[0].K[y]) + abort (); + for (y = 1; y <= 2; y++) + { + if (n[x].O[y].J) + abort (); + if (n[x].O[y].K[0] != 4) + abort (); + if (n[x].O[y].K[1] != 4) + abort (); + if ((x < 5 || y < 2) && (n[x].O[y].K[2] || n[x].O[y].L)) + abort (); + } + if (x < 5 && n[x].P) + abort (); + } + if (n[5].O[2].K[2] != 5 || n[5].O[2].L != 6 || n[5].P != 7) + abort (); + if (memcmp (n, o, sizeof (n)) || sizeof (n) != sizeof (o)) + abort (); + if (memcmp (n, p, sizeof (n)) || sizeof (n) != sizeof (p)) + abort (); + if (q[0][0] || q[0][1] != 23 || q[0][2] != 23) + abort (); + if (q[1][0] || q[1][1] != 23 || q[1][2] != 24) + abort (); + if (q[2][0] || q[2][1] || q[2][2]) + abort (); + if (r[0] != 27) + abort (); + exit (0); +} diff --git a/test/unimplemented/dg/initpri1.c b/test/unimplemented/dg/initpri1.c new file mode 100644 index 0000000..794ea2b --- /dev/null +++ b/test/unimplemented/dg/initpri1.c @@ -0,0 +1,62 @@ +/* { dg-do run { target init_priority } } */ + +extern void abort (); + +int i; +int j; + +void c1() __attribute__((constructor (500))); +void c2() __attribute__((constructor (700))); +void c3() __attribute__((constructor (600))); + +void c1() { + if (i++ != 0) + abort (); +} + +void c2() { + if (i++ != 2) + abort (); +} + +void c3() { + if (i++ != 1) + abort (); +} + +void d1() __attribute__((destructor (500))); +void d2() __attribute__((destructor (700))); +void d3() __attribute__((destructor (600))); + +void d1() { + if (--i != 0) + abort (); +} + +void d2() { + if (--i != 2) + abort (); +} + +void d3() { + if (j != 2) + abort (); + if (--i != 1) + abort (); +} + +void cd4() __attribute__((constructor (800), destructor (800))); + +void cd4() { + if (i != 3) + abort (); + ++j; +} + +int main () { + if (i != 3) + return 1; + if (j != 1) + abort (); + return 0; +} diff --git a/test/unimplemented/dg/llbitfields/bf-spl1.c b/test/unimplemented/dg/llbitfields/bf-spl1.c new file mode 100644 index 0000000..523c6df --- /dev/null +++ b/test/unimplemented/dg/llbitfields/bf-spl1.c @@ -0,0 +1,59 @@ +/* { dg-do run { target m68k-*-* fido-*-* sparc-*-* } } */ +/* { dg-options { -O2 } } */ + +extern void abort (void); + +typedef float SFtype __attribute__ ((mode (SF))); +typedef float DFtype __attribute__ ((mode (DF))); + +typedef int HItype __attribute__ ((mode (HI))); +typedef int SItype __attribute__ ((mode (SI))); +typedef int DItype __attribute__ ((mode (DI))); + +typedef unsigned int UHItype __attribute__ ((mode (HI))); +typedef unsigned int USItype __attribute__ ((mode (SI))); +typedef unsigned int UDItype __attribute__ ((mode (DI))); + +typedef UDItype fractype; +typedef USItype halffractype; +typedef DFtype FLO_type; +typedef DItype intfrac; + + +typedef union +{ + long long foo; + FLO_type value; + struct + { + fractype fraction:16 /*__attribute__ ((packed)) */; + unsigned int exp:11 /* __attribute__ ((packed)) */; + unsigned int sign:1 /* __attribute__ ((packed)) */; + } + bits; +} FLO_union_type; + +void foo (long long a); +long long x; + +void +pack_d () +{ + FLO_union_type dst = { 0x0123456LL }; + + x = dst.bits.fraction; +} + +main () +{ + pack_d (); + foo (x); + return 0; +} + +void +foo (long long a) +{ + if (a != 0x0123LL) + abort (); +} diff --git a/test/unimplemented/dg/localfn/nested-func-4.c b/test/unimplemented/dg/localfn/nested-func-4.c new file mode 100644 index 0000000..36a8c40 --- /dev/null +++ b/test/unimplemented/dg/localfn/nested-func-4.c @@ -0,0 +1,25 @@ +/* { dg-do run } */ +/* { dg-options "-pg" } */ +/* { dg-options "-pg -static" { target hppa*-*-hpux* } } */ +/* { dg-require-profiling "-pg" } */ + +extern void abort(void); + +void foo(int i) +{ + void bar(void) + { + if (i != 2) + abort (); + } + + bar(); +} + +int main(void) +{ + foo (2); + return 0; +} + +/* { dg-final { cleanup-profile-file } } */ diff --git a/test/unimplemented/dg/localfn/non-local-goto-1.c b/test/unimplemented/dg/localfn/non-local-goto-1.c new file mode 100644 index 0000000..2bace07 --- /dev/null +++ b/test/unimplemented/dg/localfn/non-local-goto-1.c @@ -0,0 +1,56 @@ +/* { dg-do run } */ +/* { dg-options "-O2" } */ + +extern void abort (void); + +int global; + +static foo(void) __attribute__((noinline)); + +static foo(void) +{ + global = 1; +} + +static bar(void) +{ + foo (); +} + +int execute(int cmd) +{ + __label__ start; + + void raise(void) + { + goto start; + } + + int last; + + bar (); + + last = 0; + +start: + + if (last == 0) + while (1) + { + last = 1; + raise (); + } + + if (last == 0) + return 0; + else + return cmd; +} + +int main(void) +{ + if (execute (1) == 0) + abort (); + + return 0; +} diff --git a/test/unimplemented/dg/localfn/non-local-goto-2.c b/test/unimplemented/dg/localfn/non-local-goto-2.c new file mode 100644 index 0000000..24ed650 --- /dev/null +++ b/test/unimplemented/dg/localfn/non-local-goto-2.c @@ -0,0 +1,57 @@ +/* { dg-do run } */ +/* { dg-options "-O2" } */ + +extern void abort (void); + +int global; + +static foo(void) __attribute__((noinline)); + +static foo(void) +{ + global = 1; +} + +static bar(void) +{ + foo (); + global = 0; +} + +int execute(int cmd) +{ + __label__ start; + + void raise(void) + { + goto start; + } + + int last; + + bar (); + + last = 0; + +start: + + if (last == 0) + while (1) + { + last = 1; + raise (); + } + + if (last == 0) + return 0; + else + return cmd; +} + +int main(void) +{ + if (execute (1) == 0) + abort (); + + return 0; +} diff --git a/test/unimplemented/dg/localfn/pr18963-1.c b/test/unimplemented/dg/localfn/pr18963-1.c new file mode 100644 index 0000000..df43c65 --- /dev/null +++ b/test/unimplemented/dg/localfn/pr18963-1.c @@ -0,0 +1,29 @@ +/* { dg-do run } */ +/* { dg-options "" } */ + +static int barf (); + +int foo () +{ + auto int barf (); + int j = 4; + + int barf () { + return j; + } + + return barf (); +} + +static int barf () { + return 3; +} + +extern void exit (int); +extern void abort (); + +int main (int argc, char *argv[]) { + if (foo () != 4) + abort (); + exit (0); +} diff --git a/test/unimplemented/dg/localfn/trampoline-1.c b/test/unimplemented/dg/localfn/trampoline-1.c new file mode 100644 index 0000000..8807862 --- /dev/null +++ b/test/unimplemented/dg/localfn/trampoline-1.c @@ -0,0 +1,51 @@ +/* PR target/12865 */ +/* Origin: Waldek Hebisch */ + +/* { dg-do run } */ +/* { dg-options "-O2" } */ + +/* This used to fail on various versions of Solaris 2 because the + trampoline couldn't be made executable. */ + +extern void abort(void); +extern double fabs(double); + +void foo (void) +{ + const int correct[1100] = {1, 0, -2, 0, 1, 0, 1, -1, -10, -30, -67}; + int i; + + double x1 (void) {return 1; } + double x2 (void) {return -1;} + double x3 (void) {return -1;} + double x4 (void) {return 1; } + double x5 (void) {return 0; } + + typedef double pfun(void); + + double a (int k, pfun x1, pfun x2, pfun x3, pfun x4, pfun x5) + { + double b (void) + { + k = k - 1; + return a (k, b, x1, x2, x3, x4 ); + } + + if (k <= 0) + return x4 () + x5 (); + else + return b (); + } + + for (i=0; i<=10; i++) + { + if (fabs(a( i, x1, x2, x3, x4, x5 ) - correct [i]) > 0.1) + abort(); + } +} + +int main (void) +{ + foo (); + return 0; +} diff --git a/test/unimplemented/dg/math/builtins-32.c b/test/unimplemented/dg/math/builtins-32.c new file mode 100644 index 0000000..3d2a361 --- /dev/null +++ b/test/unimplemented/dg/math/builtins-32.c @@ -0,0 +1,58 @@ +/* Copyright (C) 2004 Free Software Foundation. + + Check that constant folding of signbit, signbitf and signbitl math + functions doesn't break anything and produces the expected results. + + Written by Roger Sayle, 28th January 2004. */ + +/* { dg-do run } */ +/* { dg-options "-O2" } */ + +extern void abort(void); + +extern int signbit(double); +extern int signbitf(float); +extern int signbitl(long double); + +int test (double x) +{ + return signbit(x); +} + +int testf (float x) +{ + return signbitf(x); +} + +int testl (long double x) +{ + return signbitl(x); +} + + +int main() +{ + if (test (0.0) != 0) + abort (); + if (test (1.0) != 0) + abort (); + if (test (-2.0) == 0) + abort (); + + if (testf (0.0f) != 0) + abort (); + if (testf (1.0f) != 0) + abort (); + if (testf (-2.0f) == 0) + abort (); + + if (testl (0.0l) != 0) + abort (); + if (testl (1.0l) != 0) + abort (); + if (testl (-2.0l) == 0) + abort (); + + return 0; +} + diff --git a/test/unimplemented/dg/math/builtins-47.c b/test/unimplemented/dg/math/builtins-47.c new file mode 100644 index 0000000..b25ee1b --- /dev/null +++ b/test/unimplemented/dg/math/builtins-47.c @@ -0,0 +1,20 @@ +/* { dg-do run } */ +/* { dg-options "-ffast-math -fdump-tree-gimple" } */ + +extern double sqrt (double); +extern double pow (double, double); +extern void abort (void); + +int main () +{ + double x = -1.0; + if (sqrt (pow (x, 2)) != 1.0) + abort(); + if (sqrt (x*x) != 1.0) + abort(); + return 0; +} + +/* { dg-final { scan-tree-dump-times "sqrt" 0 "gimple" } } */ +/* { dg-final { scan-tree-dump-times "pow" 0 "gimple" } } */ +/* { dg-final { cleanup-tree-dump "gimple" } } */ diff --git a/test/unimplemented/dg/math/builtins-48.c b/test/unimplemented/dg/math/builtins-48.c new file mode 100644 index 0000000..43710b8 --- /dev/null +++ b/test/unimplemented/dg/math/builtins-48.c @@ -0,0 +1,181 @@ +/* { dg-do run } */ +/* { dg-options "-O2" } */ + +extern double fabs(double); +extern float fabsf(float); +extern void abort(void); + + +double test1(double x) +{ + return (-x)*(-x); +} + +float test1f(float x) +{ + return (-x)*(-x); +} + +double test2(double x) +{ + return fabs(x)*fabs(x); +} + +float test2f(float x) +{ + return fabsf(x)*fabsf(x); +} + +double test3(double x, double y) +{ + return (x*-y)*(x*-y); +} + +float test3f(float x, float y) +{ + return (x*-y)*(x*-y); +} + +double test4(double x, double y) +{ + return (x/-y)*(x/-y); +} + +float test4f(float x, float y) +{ + return (x/-y)*(x/-y); +} + +int main() +{ + if (test1(1.0) != 1.0) + abort(); + if (test1(2.0) != 4.0) + abort(); + if (test1(0.0) != 0.0) + abort(); + if (test1(-1.0) != 1.0) + abort(); + if (test1(-2.0) != 4.0) + abort(); + + if (test1f(1.0f) != 1.0f) + abort(); + if (test1f(2.0f) != 4.0f) + abort(); + if (test1f(0.0f) != 0.0f) + abort(); + if (test1f(-1.0f) != 1.0f) + abort(); + if (test1f(-2.0f) != 4.0f) + abort(); + + if (test2(1.0) != 1.0) + abort(); + if (test2(2.0) != 4.0) + abort(); + if (test2(0.0) != 0.0) + abort(); + if (test2(-1.0) != 1.0) + abort(); + if (test2(-2.0) != 4.0) + abort(); + + if (test2f(1.0f) != 1.0f) + abort(); + if (test2f(2.0f) != 4.0f) + abort(); + if (test2f(0.0f) != 0.0f) + abort(); + if (test2f(-1.0f) != 1.0f) + abort(); + if (test2f(-2.0f) != 4.0f) + abort(); + + if (test3(1.0,1.0) != 1.0) + abort(); + if (test3(1.0,-1.0) != 1.0) + abort(); + if (test3(1.0,2.0) != 4.0) + abort(); + if (test3(1.0,-2.0) != 4.0) + abort(); + if (test3(2.0,1.0) != 4.0) + abort(); + if (test3(2.0,-1.0) != 4.0) + abort(); + if (test3(2.0,2.0) != 16.0) + abort(); + if (test3(2.0,-2.0) != 16.0) + abort(); + if (test3(-2.0,1.0) != 4.0) + abort(); + if (test3(-2.0,-1.0) != 4.0) + abort(); + if (test3(-2.0,2.0) != 16.0) + abort(); + if (test3(-2.0,-2.0) != 16.0) + abort(); + + if (test3f(1.0f,1.0f) != 1.0f) + abort(); + if (test3f(1.0f,-1.0f) != 1.0f) + abort(); + if (test3f(1.0f,2.0f) != 4.0f) + abort(); + if (test3f(1.0f,-2.0f) != 4.0f) + abort(); + if (test3f(2.0f,1.0f) != 4.0f) + abort(); + if (test3f(2.0f,-1.0f) != 4.0f) + abort(); + if (test3f(2.0f,2.0f) != 16.0f) + abort(); + if (test3f(2.0f,-2.0f) != 16.0f) + abort(); + if (test3f(-2.0f,1.0f) != 4.0f) + abort(); + if (test3f(-2.0f,-1.0f) != 4.0f) + abort(); + if (test3f(-2.0f,2.0f) != 16.0f) + abort(); + if (test3f(-2.0f,-2.0f) != 16.0f) + abort(); + + if (test4(1.0,1.0) != 1.0) + abort(); + if (test4(1.0,-1.0) != 1.0) + abort(); + if (test4(-1.0,1.0) != 1.0) + abort(); + if (test4(-1.0,-1.0) != 1.0) + abort(); + if (test4(6.0,3.0) != 4.0) + abort(); + if (test4(6.0,-3.0) != 4.0) + abort(); + if (test4(-6.0,3.0) != 4.0) + abort(); + if (test4(-6.0,-3.0) != 4.0) + abort(); + + if (test4f(1.0f,1.0f) != 1.0f) + abort(); + if (test4f(1.0f,-1.0f) != 1.0f) + abort(); + if (test4f(-1.0f,1.0f) != 1.0f) + abort(); + if (test4f(-1.0f,-1.0f) != 1.0f) + abort(); + if (test4f(6.0f,3.0f) != 4.0f) + abort(); + if (test4f(6.0f,-3.0f) != 4.0f) + abort(); + if (test4f(-6.0f,3.0f) != 4.0f) + abort(); + if (test4f(-6.0f,-3.0f) != 4.0f) + abort(); + + return 0; +} + diff --git a/test/unimplemented/dg/math/builtins-49.c b/test/unimplemented/dg/math/builtins-49.c new file mode 100644 index 0000000..fdeaad4 --- /dev/null +++ b/test/unimplemented/dg/math/builtins-49.c @@ -0,0 +1,181 @@ +/* { dg-do run } */ +/* { dg-options "-O2" } */ + +extern double fabs(double); +extern float fabsf(float); +extern void abort(void); + + +double test1(double x) +{ + return fabs(-x); +} + +float test1f(float x) +{ + return fabsf(-x); +} + +double test2(double x) +{ + return fabs(fabs(x)); +} + +float test2f(float x) +{ + return fabsf(fabsf(x)); +} + +double test3(double x, double y) +{ + return fabs(x*-y); +} + +float test3f(float x, float y) +{ + return fabsf(x*-y); +} + +double test4(double x, double y) +{ + return fabs(x/-y); +} + +float test4f(float x, float y) +{ + return fabsf(x/-y); +} + +int main() +{ + if (test1(1.0) != 1.0) + abort(); + if (test1(2.0) != 2.0) + abort(); + if (test1(0.0) != 0.0) + abort(); + if (test1(-1.0) != 1.0) + abort(); + if (test1(-2.0) != 2.0) + abort(); + + if (test1f(1.0f) != 1.0f) + abort(); + if (test1f(2.0f) != 2.0f) + abort(); + if (test1f(0.0f) != 0.0f) + abort(); + if (test1f(-1.0f) != 1.0f) + abort(); + if (test1f(-2.0f) != 2.0f) + abort(); + + if (test2(1.0) != 1.0) + abort(); + if (test2(2.0) != 2.0) + abort(); + if (test2(0.0) != 0.0) + abort(); + if (test2(-1.0) != 1.0) + abort(); + if (test2(-2.0) != 2.0) + abort(); + + if (test2f(1.0f) != 1.0f) + abort(); + if (test2f(2.0f) != 2.0f) + abort(); + if (test2f(0.0f) != 0.0f) + abort(); + if (test2f(-1.0f) != 1.0f) + abort(); + if (test2f(-2.0f) != 2.0f) + abort(); + + if (test3(1.0,1.0) != 1.0) + abort(); + if (test3(1.0,-1.0) != 1.0) + abort(); + if (test3(1.0,2.0) != 2.0) + abort(); + if (test3(1.0,-2.0) != 2.0) + abort(); + if (test3(2.0,1.0) != 2.0) + abort(); + if (test3(2.0,-1.0) != 2.0) + abort(); + if (test3(2.0,2.0) != 4.0) + abort(); + if (test3(2.0,-2.0) != 4.0) + abort(); + if (test3(-2.0,1.0) != 2.0) + abort(); + if (test3(-2.0,-1.0) != 2.0) + abort(); + if (test3(-2.0,2.0) != 4.0) + abort(); + if (test3(-2.0,-2.0) != 4.0) + abort(); + + if (test3f(1.0f,1.0f) != 1.0f) + abort(); + if (test3f(1.0f,-1.0f) != 1.0f) + abort(); + if (test3f(1.0f,2.0f) != 2.0f) + abort(); + if (test3f(1.0f,-2.0f) != 2.0f) + abort(); + if (test3f(2.0f,1.0f) != 2.0f) + abort(); + if (test3f(2.0f,-1.0f) != 2.0f) + abort(); + if (test3f(2.0f,2.0f) != 4.0f) + abort(); + if (test3f(2.0f,-2.0f) != 4.0f) + abort(); + if (test3f(-2.0f,1.0f) != 2.0f) + abort(); + if (test3f(-2.0f,-1.0f) != 2.0f) + abort(); + if (test3f(-2.0f,2.0f) != 4.0f) + abort(); + if (test3f(-2.0f,-2.0f) != 4.0f) + abort(); + + if (test4(1.0,1.0) != 1.0) + abort(); + if (test4(1.0,-1.0) != 1.0) + abort(); + if (test4(-1.0,1.0) != 1.0) + abort(); + if (test4(-1.0,-1.0) != 1.0) + abort(); + if (test4(6.0,3.0) != 2.0) + abort(); + if (test4(6.0,-3.0) != 2.0) + abort(); + if (test4(-6.0,3.0) != 2.0) + abort(); + if (test4(-6.0,-3.0) != 2.0) + abort(); + + if (test4f(1.0f,1.0f) != 1.0f) + abort(); + if (test4f(1.0f,-1.0f) != 1.0f) + abort(); + if (test4f(-1.0f,1.0f) != 1.0f) + abort(); + if (test4f(-1.0f,-1.0f) != 1.0f) + abort(); + if (test4f(6.0f,3.0f) != 2.0f) + abort(); + if (test4f(6.0f,-3.0f) != 2.0f) + abort(); + if (test4f(-6.0f,3.0f) != 2.0f) + abort(); + if (test4f(-6.0f,-3.0f) != 2.0f) + abort(); + + return 0; +} + diff --git a/test/unimplemented/dg/math/builtins-50.c b/test/unimplemented/dg/math/builtins-50.c new file mode 100644 index 0000000..2d32d1e --- /dev/null +++ b/test/unimplemented/dg/math/builtins-50.c @@ -0,0 +1,159 @@ +/* { dg-do run } */ +/* { dg-options "-O2" } */ + +extern double copysign(double,double); +extern float copysignf(float,float); +extern double fabs(double); +extern float fabsf(float); +extern void abort(void); + + +double test1(double x, double y) +{ + return copysign(-x,y); +} + +float test1f(float x, float y) +{ + return copysignf(-x,y); +} + +double test2(double x, double y) +{ + return copysign(fabs(x),y); +} + +float test2f(float x, float y) +{ + return copysignf(fabsf(x),y); +} + +double test3(double x, double y, double z) +{ + return copysign(x*-y,z); +} + +float test3f(float x, float y, float z) +{ + return copysignf(x*-y,z); +} + +double test4(double x, double y, double z) +{ + return copysign(x/-y,z); +} + +float test4f(float x, float y, float z) +{ + return copysignf(x/-y,z); +} + +int main() +{ + if (test1(3.0,2.0) != 3.0) + abort(); + if (test1(3.0,-2.0) != -3.0) + abort(); + if (test1(-3.0,2.0) != 3.0) + abort(); + if (test1(-3.0,-2.0) != -3.0) + abort(); + + if (test1f(3.0f,2.0f) != 3.0f) + abort(); + if (test1f(3.0f,-2.0f) != -3.0f) + abort(); + if (test1f(-3.0f,2.0f) != 3.0f) + abort(); + if (test1f(-3.0f,-2.0f) != -3.0f) + abort(); + + if (test2(3.0,2.0) != 3.0) + abort(); + if (test2(3.0,-2.0) != -3.0) + abort(); + if (test2(-3.0,2.0) != 3.0) + abort(); + if (test2(-3.0,-2.0) != -3.0) + abort(); + + if (test2f(3.0f,2.0f) != 3.0f) + abort(); + if (test2f(3.0f,-2.0f) != -3.0f) + abort(); + if (test2f(-3.0f,2.0f) != 3.0f) + abort(); + if (test2f(-3.0f,-2.0f) != -3.0f) + abort(); + + if (test3(2.0,3.0,4.0) != 6.0) + abort(); + if (test3(2.0,3.0,-4.0) != -6.0) + abort(); + if (test3(2.0,-3.0,4.0) != 6.0) + abort(); + if (test3(2.0,-3.0,-4.0) != -6.0) + abort(); + if (test3(-2.0,3.0,4.0) != 6.0) + abort(); + if (test3(-2.0,3.0,-4.0) != -6.0) + abort(); + if (test3(-2.0,-3.0,4.0) != 6.0) + abort(); + if (test3(-2.0,-3.0,-4.0) != -6.0) + abort(); + + if (test3f(2.0f,3.0f,4.0f) != 6.0f) + abort(); + if (test3f(2.0f,3.0f,-4.0f) != -6.0f) + abort(); + if (test3f(2.0f,-3.0f,4.0f) != 6.0f) + abort(); + if (test3f(2.0f,-3.0f,-4.0f) != -6.0f) + abort(); + if (test3f(-2.0f,3.0f,4.0f) != 6.0f) + abort(); + if (test3f(-2.0f,3.0f,-4.0f) != -6.0f) + abort(); + if (test3f(-2.0f,-3.0f,4.0f) != 6.0f) + abort(); + if (test3f(-2.0f,-3.0f,-4.0f) != -6.0f) + abort(); + + if (test4(8.0,2.0,3.0) != 4.0) + abort(); + if (test4(8.0,2.0,-3.0) != -4.0) + abort(); + if (test4(8.0,-2.0,3.0) != 4.0) + abort(); + if (test4(8.0,-2.0,-3.0) != -4.0) + abort(); + if (test4(-8.0,2.0,3.0) != 4.0) + abort(); + if (test4(-8.0,2.0,-3.0) != -4.0) + abort(); + if (test4(-8.0,-2.0,3.0) != 4.0) + abort(); + if (test4(-8.0,-2.0,-3.0) != -4.0) + abort(); + + if (test4f(8.0f,2.0f,3.0f) != 4.0f) + abort(); + if (test4f(8.0f,2.0f,-3.0f) != -4.0f) + abort(); + if (test4f(8.0f,-2.0f,3.0f) != 4.0f) + abort(); + if (test4f(8.0f,-2.0f,-3.0f) != -4.0f) + abort(); + if (test4f(-8.0f,2.0f,3.0f) != 4.0f) + abort(); + if (test4f(-8.0f,2.0f,-3.0f) != -4.0f) + abort(); + if (test4f(-8.0f,-2.0f,3.0f) != 4.0f) + abort(); + if (test4f(-8.0f,-2.0f,-3.0f) != -4.0f) + abort(); + + return 0; +} + diff --git a/test/unimplemented/dg/math/builtins-51.c b/test/unimplemented/dg/math/builtins-51.c new file mode 100644 index 0000000..fdfc9be --- /dev/null +++ b/test/unimplemented/dg/math/builtins-51.c @@ -0,0 +1,157 @@ +/* { dg-do run } */ +/* { dg-options "-O2 -ffast-math" } */ + +extern double pow(double, double); +extern double fabs(double); +extern void abort(void); + +double test2_1(double x) +{ + return pow(x,2.0); +} + +double test2_2(double x) +{ + return pow(-x,2.0); +} + +double test2_3(double x) +{ + return pow(fabs(x),2.0); +} + +double test3_1(double x) +{ + return pow(x,3.0); +} + +double test3_2(double x) +{ + return pow(-x,3.0); +} + +double test3_3(double x) +{ + return pow(fabs(x),3.0); +} + +double test6_1(double x) +{ + return pow(x,6.0); +} + +double test6_2(double x) +{ + return pow(-x,6.0); +} + +double test6_3(double x) +{ + return pow(fabs(x),6.0); +} + + +int main() +{ + if (test2_1(1.0) != 1.0) + abort(); + if (test2_1(2.0) != 4.0) + abort(); + if (test2_1(0.0) != 0.0) + abort(); + if (test2_1(-1.0) != 1.0) + abort(); + if (test2_1(-2.0) != 4.0) + abort(); + + if (test2_2(1.0) != 1.0) + abort(); + if (test2_2(2.0) != 4.0) + abort(); + if (test2_2(0.0) != 0.0) + abort(); + if (test2_2(-1.0) != 1.0) + abort(); + if (test2_2(-2.0) != 4.0) + abort(); + + if (test2_3(1.0) != 1.0) + abort(); + if (test2_3(2.0) != 4.0) + abort(); + if (test2_3(0.0) != 0.0) + abort(); + if (test2_3(-1.0) != 1.0) + abort(); + if (test2_3(2.0) != 4.0) + abort(); + + if (test3_1(1.0) != 1.0) + abort(); + if (test3_1(2.0) != 8.0) + abort(); + if (test3_1(0.0) != 0.0) + abort(); + if (test3_1(-1.0) != -1.0) + abort(); + if (test3_1(-2.0) != -8.0) + abort(); + + if (test3_2(1.0) != -1.0) + abort(); + if (test3_2(2.0) != -8.0) + abort(); + if (test3_2(0.0) != -0.0) + abort(); + if (test3_2(-1.0) != 1.0) + abort(); + if (test3_2(-2.0) != 8.0) + abort(); + + if (test3_3(1.0) != 1.0) + abort(); + if (test3_3(2.0) != 8.0) + abort(); + if (test3_3(0.0) != 0.0) + abort(); + if (test3_3(-1.0) != 1.0) + abort(); + if (test3_3(-2.0) != 8.0) + abort(); + + if (test6_1(1.0) != 1.0) + abort(); + if (test6_1(2.0) != 64.0) + abort(); + if (test6_1(0.0) != 0.0) + abort(); + if (test6_1(-1.0) != 1.0) + abort(); + if (test6_1(-2.0) != 64.0) + abort(); + + if (test6_2(1.0) != 1.0) + abort(); + if (test6_2(2.0) != 64.0) + abort(); + if (test6_2(0.0) != 0.0) + abort(); + if (test6_2(-1.0) != 1.0) + abort(); + if (test6_2(-2.0) != 64.0) + abort(); + + if (test6_3(1.0) != 1.0) + abort(); + if (test6_3(2.0) != 64.0) + abort(); + if (test6_3(0.0) != 0.0) + abort(); + if (test6_3(-1.0) != 1.0) + abort(); + if (test6_3(-2.0) != 64.0) + abort(); + + return 0; +} + diff --git a/test/unimplemented/dg/math/builtins-6.c b/test/unimplemented/dg/math/builtins-6.c new file mode 100644 index 0000000..2ebb0b2 --- /dev/null +++ b/test/unimplemented/dg/math/builtins-6.c @@ -0,0 +1,80 @@ +/* Copyright (C) 2003 Free Software Foundation. + + Verify that constant folding comparisons against built-in math functions + don't cause any problems for the compiler, and produce expected results. + + Written by Roger Sayle, 15th March 2003. */ + +/* { dg-do run } */ +/* { dg-options "-O2 -ffast-math" } */ + +#include + +extern void abort (void); +extern double sqrt (double); + +int test1(double x) +{ + return sqrt(x) < -9.0; +} + +int test2(double x) +{ + return sqrt(x) > -9.0; +} + +int test3(double x) +{ + return sqrt(x) < 9.0; +} + +int test4(double x) +{ + return sqrt(x) > 9.0; +} + +int test5(double x) +{ + return sqrt(x) < DBL_MAX; +} + +int test6(double x) +{ + return sqrt(x) > DBL_MAX; +} + +int main() +{ + double x; + + x = 80.0; + if (test1 (x)) + abort (); + if (! test2 (x)) + abort (); + if (! test3 (x)) + abort (); + if (test4 (x)) + abort (); + if (! test5 (x)) + abort (); + if (test6 (x)) + abort (); + + x = 100.0; + if (test1 (x)) + abort (); + if (! test2 (x)) + abort (); + if (test3 (x)) + abort (); + if (! test4 (x)) + abort (); + if (! test5 (x)) + abort (); + if (test6 (x)) + abort (); + + return 0; +} + diff --git a/test/unimplemented/dg/math/builtins-8.c b/test/unimplemented/dg/math/builtins-8.c new file mode 100644 index 0000000..be17774 --- /dev/null +++ b/test/unimplemented/dg/math/builtins-8.c @@ -0,0 +1,40 @@ +/* Copyright (C) 2003, 2006 Free Software Foundation. + + Verify that built-in math function constant folding of functions + with one constant argument is correctly performed by the compiler. + + Written by Roger Sayle, 30th March 2003. */ + +/* { dg-do run } */ +/* { dg-options "-O2 -ffast-math" } */ + +extern void abort(void); +extern double pow(double, double); +extern double sqrt(double); +extern double cbrt(double); + +void test(double x) +{ + if (pow(x,-1.0) != 1.0/x) + abort (); + + if (pow(x,2.0) != x*x) + abort (); + + if (pow(x,-2.0) != 1.0/(x*x)) + abort (); + + if (pow(x,0.5) != sqrt(x)) + abort (); + + if (pow(x,1.0/3.0) != cbrt(x)) + abort (); +} + +int main() +{ + test (1.0); + test (2.0); + return 0; +} + diff --git a/test/unimplemented/dg/math/c99-math-double-1.c b/test/unimplemented/dg/math/c99-math-double-1.c new file mode 100644 index 0000000..6441a59 --- /dev/null +++ b/test/unimplemented/dg/math/c99-math-double-1.c @@ -0,0 +1,22 @@ +/* { dg-do run { target *-*-solaris2.1[0-9]* } } */ +/* { dg-options "-std=c99 -O" } */ + +#include +#include "c99-math.h" + +int main(void) +{ + volatile double nan = NAN; + volatile double inf = INFINITY; + volatile double huge = HUGE_VAL; + volatile double norm1 = __DBL_MIN__; + volatile double norm2 = 1; + volatile double norm3 = __DBL_MAX__; + volatile double sub = __DBL_MIN__ / 2; + volatile double zero = 0.0; + + C99_MATH_TESTS (nan, inf, huge, norm1, norm2, norm3, sub, zero, /*neg=*/0) + C99_MATH_TESTS (-nan, -inf, -huge, -norm1, -norm2, -norm3, -sub, -zero, /*neg=*/1) + + return 0; +} diff --git a/test/unimplemented/dg/math/c99-math-float-1.c b/test/unimplemented/dg/math/c99-math-float-1.c new file mode 100644 index 0000000..36a7396 --- /dev/null +++ b/test/unimplemented/dg/math/c99-math-float-1.c @@ -0,0 +1,22 @@ +/* { dg-do run { target *-*-solaris2.1[0-9]* } } */ +/* { dg-options "-std=c99 -O" } */ + +#include +#include "c99-math.h" + +int main(void) +{ + volatile float nan = NAN; + volatile float inf = INFINITY; + volatile float huge = HUGE_VALF; + volatile float norm1 = __FLT_MIN__; + volatile float norm2 = 1; + volatile float norm3 = __FLT_MAX__; + volatile float sub = __FLT_MIN__ / 2; + volatile float zero = 0.0f; + + C99_MATH_TESTS (nan, inf, huge, norm1, norm2, norm3, sub, zero, /*neg=*/0) + C99_MATH_TESTS (-nan, -inf, -huge, -norm1, -norm2, -norm3, -sub, -zero, /*neg=*/1) + + return 0; +} diff --git a/test/unimplemented/dg/math/c99-math-long-double-1.c b/test/unimplemented/dg/math/c99-math-long-double-1.c new file mode 100644 index 0000000..d8146c2 --- /dev/null +++ b/test/unimplemented/dg/math/c99-math-long-double-1.c @@ -0,0 +1,22 @@ +/* { dg-do run { target *-*-solaris2.1[0-9]* } } */ +/* { dg-options "-std=c99 -O" } */ + +#include +#include "c99-math.h" + +int main(void) +{ + volatile long double nan = NAN; + volatile long double inf = INFINITY; + volatile long double huge = HUGE_VALL; + volatile long double norm1 = __LDBL_MIN__; + volatile long double norm2 = 1; + volatile long double norm3 = __LDBL_MAX__; + volatile long double sub = __LDBL_MIN__ / 2; + volatile long double zero = 0.0l; + + C99_MATH_TESTS (nan, inf, huge, norm1, norm2, norm3, sub, zero, /*neg=*/0) + C99_MATH_TESTS (-nan, -inf, -huge, -norm1, -norm2, -norm3, -sub, -zero, /*neg=*/1) + + return 0; +} diff --git a/test/unimplemented/dg/math/c99-math.h b/test/unimplemented/dg/math/c99-math.h new file mode 100644 index 0000000..81f2e6d --- /dev/null +++ b/test/unimplemented/dg/math/c99-math.h @@ -0,0 +1,236 @@ +#include +#include + +extern void abort(void); + +#define C99_MATH_TESTS(nan, inf, huge, norm1, norm2, norm3, sub, zero, neg) \ +{ \ + if (feclearexcept (FE_ALL_EXCEPT) != 0) \ + abort(); \ + \ + \ + if (fpclassify (nan) != FP_NAN) \ + abort (); \ + \ + if (fpclassify (inf) != FP_INFINITE) \ + abort (); \ + \ + if (fpclassify (huge) != FP_INFINITE) \ + abort (); \ + \ + if (fpclassify (norm1) != FP_NORMAL) \ + abort (); \ + \ + if (fpclassify (norm2) != FP_NORMAL) \ + abort (); \ + \ + if (fpclassify (norm3) != FP_NORMAL) \ + abort (); \ + \ + if (fpclassify (sub) != FP_SUBNORMAL) \ + abort (); \ + \ + if (fpclassify (zero) != FP_ZERO) \ + abort (); \ + \ + \ + if (!isnan (nan)) \ + abort (); \ + \ + if (isnan (inf)) \ + abort (); \ + \ + if (isnan (huge)) \ + abort (); \ + \ + if (isnan (norm1)) \ + abort (); \ + \ + if (isnan (norm2)) \ + abort (); \ + \ + if (isnan (norm3)) \ + abort (); \ + \ + if (isnan (sub)) \ + abort (); \ + \ + if (isnan (zero)) \ + abort (); \ + \ + \ + if (isinf (nan)) \ + abort (); \ + \ + if (!isinf (inf)) \ + abort (); \ + \ + if (!isinf (huge)) \ + abort (); \ + \ + if (isinf (norm1)) \ + abort (); \ + \ + if (isinf (norm2)) \ + abort (); \ + \ + if (isinf (norm3)) \ + abort (); \ + \ + if (isinf (sub)) \ + abort (); \ + \ + if (isinf (zero)) \ + abort (); \ + \ + \ + if (isfinite (nan)) \ + abort (); \ + \ + if (isfinite (inf)) \ + abort (); \ + \ + if (isfinite (huge)) \ + abort (); \ + \ + if (!isfinite (norm1)) \ + abort (); \ + \ + if (!isfinite (norm2)) \ + abort (); \ + \ + if (!isfinite (norm3)) \ + abort (); \ + \ + if (!isfinite (sub)) \ + abort (); \ + \ + if (!isfinite (zero)) \ + abort (); \ + \ + \ + if (isnormal (nan)) \ + abort (); \ + \ + if (isnormal (inf)) \ + abort (); \ + \ + if (isnormal (huge)) \ + abort (); \ + \ + if (!isnormal (norm1)) \ + abort (); \ + \ + if (!isnormal (norm2)) \ + abort (); \ + \ + if (!isnormal (norm3)) \ + abort (); \ + \ + if (isnormal (sub)) \ + abort (); \ + \ + if (isnormal (zero)) \ + abort (); \ + \ + \ + if (!!signbit (nan) != neg) \ + abort (); \ + \ + if (!!signbit (inf) != neg) \ + abort (); \ + \ + if (!!signbit (huge) != neg) \ + abort (); \ + \ + if (!!signbit (norm1) != neg) \ + abort (); \ + \ + if (!!signbit (norm2) != neg) \ + abort (); \ + \ + if (!!signbit (norm3) != neg) \ + abort (); \ + \ + if (!!signbit (sub) != neg) \ + abort (); \ + \ + if (!!signbit (zero) != neg) \ + abort (); \ + \ + \ + if (neg) \ + { \ + if (!isless ((inf), (norm1))) \ + abort (); \ + \ + if (!isless ((inf), (norm2))) \ + abort (); \ + \ + if (!isless ((inf), (norm3))) \ + abort (); \ + \ + if (!islessequal ((inf), (huge))) \ + abort (); \ + \ + if (!isgreater ((norm1), (inf))) \ + abort (); \ + \ + if (!isgreater ((norm2), (inf))) \ + abort (); \ + \ + if (!isgreater ((norm3), (inf))) \ + abort (); \ + \ + if (!isgreaterequal ((huge), (inf))) \ + abort (); \ + } \ + else \ + { \ + if (!isgreater ((inf), (norm1))) \ + abort (); \ + \ + if (!isgreater ((inf), (norm2))) \ + abort (); \ + \ + if (!isgreater ((inf), (norm3))) \ + abort (); \ + \ + if (!isgreaterequal ((inf), (huge))) \ + abort (); \ + \ + if (!isless ((norm1), (inf))) \ + abort (); \ + \ + if (!isless ((norm2), (inf))) \ + abort (); \ + \ + if (!isless ((norm3), (inf))) \ + abort (); \ + \ + if (!islessequal ((huge), (inf))) \ + abort (); \ + } \ + \ + if (!islessgreater ((inf), (norm1))) \ + abort (); \ + \ + if (!islessgreater ((inf), (norm2))) \ + abort (); \ + \ + if (!islessgreater ((inf), (norm3))) \ + abort (); \ + \ + if (!isunordered ((nan), (norm1))) \ + abort (); \ + \ + if (!isunordered ((nan), (norm2))) \ + abort (); \ + \ + if (!isunordered ((nan), (norm3))) \ + abort (); \ + \ + \ + if (fetestexcept (FE_ALL_EXCEPT) != 0) \ + abort(); \ +} diff --git a/test/unimplemented/dg/nonconstarraysize/20050527-1.c b/test/unimplemented/dg/nonconstarraysize/20050527-1.c new file mode 100644 index 0000000..1b32324 --- /dev/null +++ b/test/unimplemented/dg/nonconstarraysize/20050527-1.c @@ -0,0 +1,55 @@ +/* PR c/21536 */ +/* { dg-do run } */ +/* { dg-options "-O2 -Wuninitialized" } */ + +typedef __SIZE_TYPE__ size_t; +extern void *malloc (size_t); +extern void free (void *); + +void * +foo (int x, int y) +{ + void *d = malloc (x * y * sizeof (double)); + double (*e)[x][y] = d; + x += 10; + y += 10; + if (x > 18) + (*e)[x - 12][y - 12] = 0.0; + else + (*e)[x - 11][y - 11] = 1.0; + return d; +} + +void * +bar (int x, int y) +{ + void *d = malloc (x * y * sizeof (double)); + struct S + { + double (*e)[x][y]; + double (*f)[x][y]; + } s; + s.e = d; + s.f = d; + x += 10; + y += 10; + if (x > 18) + (*s.e)[x - 12][y - 12] = 0.0; + else + (*s.e)[x - 11][y - 11] = 1.0; + if (x > 16) + (*s.f)[x - 13][y - 13] = 0.0; + else + (*s.f)[x - 14][y - 14] = 1.0; + return d; +} + +int +main () +{ + void *d1 = foo (10, 10); + void *d2 = bar (10, 10); + free (d1); + free (d2); + return 0; +} diff --git a/test/unimplemented/dg/nonconstarraysize/array-4.c b/test/unimplemented/dg/nonconstarraysize/array-4.c new file mode 100644 index 0000000..b3e4f6c --- /dev/null +++ b/test/unimplemented/dg/nonconstarraysize/array-4.c @@ -0,0 +1,25 @@ +/* { dg-do run } */ +/* { dg-options "" } */ + +/* Verify that GCC's initialized flexible array member extension + works properly. */ + +extern void abort(void); +extern void exit(int); + +struct f { int w; int x[]; }; +struct g { int w; int x[0]; }; + +static struct f f = { 4, { 0, 1, 2, 3 } }; +static int junk1[] = { -1, -1, -1, -1 }; +static struct g g = { 4, { 0, 1, 2, 3 } }; /* { dg-warning "(excess elements)|(near initialization)" "" } */ +static int junk2[] = { -1, -1, -1, -1 }; + +int main() +{ + int i; + for (i = 0; i < f.w; ++i) + if (f.x[i] != i) + abort (); + exit(0); +} diff --git a/test/unimplemented/dg/nonconstarraysize/packed-vla.c b/test/unimplemented/dg/nonconstarraysize/packed-vla.c new file mode 100644 index 0000000..04ccb96 --- /dev/null +++ b/test/unimplemented/dg/nonconstarraysize/packed-vla.c @@ -0,0 +1,31 @@ +/* PR middle-end/27945 */ +/* { dg-do run } */ +/* { dg-options "" } */ + +extern int printf (const char *, ...); +extern void abort (); + +int func(int levels) +{ + struct bar { + unsigned char a; + int b[levels]; + } __attribute__ ((__packed__)) bar; + + struct foo { + unsigned char a; + int b[4]; + } __attribute__ ((__packed__)) foo; + + printf("foo %d\n", sizeof(foo)); + printf("bar %d\n", sizeof(bar)); + + if (sizeof (foo) != sizeof (bar)) + abort (); +} + +int main() +{ + func(4); + return 0; +} diff --git a/test/unimplemented/dg/nonconstarraysize/typename-vla-1.c b/test/unimplemented/dg/nonconstarraysize/typename-vla-1.c new file mode 100644 index 0000000..1616513 --- /dev/null +++ b/test/unimplemented/dg/nonconstarraysize/typename-vla-1.c @@ -0,0 +1,17 @@ +/* PR c/21536 */ +/* { dg-do run } */ +/* { dg-options "-O2 -Wuninitialized" } */ + +extern void abort (void); +extern void exit (int); + +int +main (void) +{ + int a = 1; + if (sizeof (*(++a, (char (*)[a])0)) != 2) + abort (); + exit (0); +} + + diff --git a/test/unimplemented/dg/nonconstarraysize/vla-4.c b/test/unimplemented/dg/nonconstarraysize/vla-4.c new file mode 100644 index 0000000..17dd484 --- /dev/null +++ b/test/unimplemented/dg/nonconstarraysize/vla-4.c @@ -0,0 +1,48 @@ +/* { dg-do run } */ +/* { dg-options "-std=c99 -pedantic-errors" } */ +/* PR c/18740 */ + +static int i; + +int foo(int n) +{ + int (*t)[/*n*/10]; + i = 0; + int j = 0; + char b[1][/*n*/10+3]; /* Variable length array. */ + int d[3][/*n*/10]; /* Variable length array. */ + sizeof (b[i++ + sizeof(j++)]); /* Outer sizeof is evaluated for vla, but not the inner one. */ + if (i != 1 || j != 0) + return 1; + __typeof__(b[i++]) c1; /* typeof is evauluated when given a vm */ + if (i != 2) + return 1; + __typeof__(t + (i++,0)) c2; /* typeof is evauluated when given a vm */ + if (i != 3) + return 1; + __typeof__(i + (i++,0)) c3; /* typeof is not evauluated when not given a vm */ + if (i != 3) + return 1; + sizeof (d[i++]); /* sizeof is evaluated for vla. */ + if (i != 4) + return 1; + __alignof__(__typeof__(t + (i++,0))); /* typeof is not evauluated when given a vm inside alignof*/ + if (i != 4) + return 1; + sizeof(__typeof__(t + (i++,0))); /* typeof is not evauluated when given a vm inside sizeof*/ + if (i != 4) + return 1; + return 0; +} + +int foo6(int a, int b[a][a], int (*c)[sizeof(*b)]) { + return sizeof (*c); +} + +int main() { + int b[10][10]; + int (*c)[sizeof(int)*10]; + if (foo6(10, b, c) != 10*sizeof(int)*sizeof(int)) + return 1; + return foo(10); +} diff --git a/test/unimplemented/dg/struct-ret-libc.c b/test/unimplemented/dg/struct-ret-libc.c new file mode 100644 index 0000000..723e1cd --- /dev/null +++ b/test/unimplemented/dg/struct-ret-libc.c @@ -0,0 +1,16 @@ +/* Test evolved from source from Simona Perri + and Gerald Pfeifer. + + Copyright (C) 2003 Free Software Foundation */ + +/* { dg-do run } */ + +#include + +int main () +{ + div_t d = div (20, 5); + if ((d.quot != 4) || (d.rem)) + abort (); + exit (0); +} diff --git a/test/unimplemented/dg/ucnid-1.c b/test/unimplemented/dg/ucnid-1.c new file mode 100644 index 0000000..ed89cfd --- /dev/null +++ b/test/unimplemented/dg/ucnid-1.c @@ -0,0 +1,25 @@ +/* { dg-do run } */ +/* { dg-options "-std=c99 -fextended-identifiers" } */ +void abort (void); + +int main (void) +{ + int \u00C0 = 1; + int \u00C1 = 2; + int \U000000C2 = 3; + int wh\u00ff = 4; + int a\u00c4b\u0441\U000003b4e = 5; + + if (\u00C0 != 1) + abort (); + if (\u00c1 != 2) + abort (); + if (\u00C2 != 3) + abort (); + if (wh\u00ff != 4) + abort (); + if (a\u00c4b\u0441\U000003b4e != 5) + abort (); + + return 0; +} diff --git a/test/unimplemented/dg/ucnid-2.c b/test/unimplemented/dg/ucnid-2.c new file mode 100644 index 0000000..d8e9186 --- /dev/null +++ b/test/unimplemented/dg/ucnid-2.c @@ -0,0 +1,27 @@ +/* { dg-do run } */ +/* { dg-xfail-if "" { powerpc-ibm-aix* *-*-solaris2.* } { "*" } { "" } } */ +/* { dg-options "-std=c99 -fextended-identifiers" } */ +void abort (void); + +static int \u00C0 = 1; +static int \u00C1 = 2; +static int \U000000C2 = 3; +static int wh\u00ff = 4; +static int a\u00c4b\u0441\U000003b4e = 5; + +int main (void) +{ + + if (\u00C0 != 1) + abort (); + if (\u00c1 != 2) + abort (); + if (\u00C2 != 3) + abort (); + if (wh\u00ff != 4) + abort (); + if (a\u00c4b\u0441\U000003b4e != 5) + abort (); + + return 0; +} diff --git a/test/unimplemented/dg/ucnid-3.c b/test/unimplemented/dg/ucnid-3.c new file mode 100644 index 0000000..1f3481b --- /dev/null +++ b/test/unimplemented/dg/ucnid-3.c @@ -0,0 +1,27 @@ +/* { dg-do run } */ +/* { dg-xfail-if "" { powerpc-ibm-aix* *-*-solaris2.* } { "*" } { "" } } */ +/* { dg-options "-std=c99 -fextended-identifiers" } */ +void abort (void); + +int \u00C0 = 1; +int \u00C1 = 2; +int \U000000C2 = 3; +int wh\u00ff = 4; +int a\u00c4b\u0441\U000003b4e = 5; + +int main (void) +{ + + if (\u00C0 != 1) + abort (); + if (\u00c1 != 2) + abort (); + if (\u00C2 != 3) + abort (); + if (wh\u00ff != 4) + abort (); + if (a\u00c4b\u0441\U000003b4e != 5) + abort (); + + return 0; +} diff --git a/test/unimplemented/dg/ucnid-4.c b/test/unimplemented/dg/ucnid-4.c new file mode 100644 index 0000000..0f1a128 --- /dev/null +++ b/test/unimplemented/dg/ucnid-4.c @@ -0,0 +1,27 @@ +/* { dg-do run } */ +/* { dg-xfail-if "" { powerpc-ibm-aix* *-*-solaris2.* } { "*" } { "" } } */ +/* { dg-options "-std=c99 -fextended-identifiers" } */ +void abort (void); + +int \u00C0(void) { return 1; } +int \u00C1(void) { return 2; } +int \U000000C2(void) { return 3; } +int wh\u00ff(void) { return 4; } +int a\u00c4b\u0441\U000003b4e(void) { return 5; } + +int main (void) +{ + + if (\u00C0() != 1) + abort (); + if (\u00c1() != 2) + abort (); + if (\u00C2() != 3) + abort (); + if (wh\u00ff() != 4) + abort (); + if (a\u00c4b\u0441\U000003b4e() != 5) + abort (); + + return 0; +} diff --git a/test/unimplemented/dg/ucnid-5.c b/test/unimplemented/dg/ucnid-5.c new file mode 100644 index 0000000..8cd8606 --- /dev/null +++ b/test/unimplemented/dg/ucnid-5.c @@ -0,0 +1,15 @@ +/* { dg-do run } */ +/* { dg-xfail-if "" { "powerpc-ibm-aix*" } { "*" } { "" } } */ +/* { dg-options "-std=c99 -fdollars-in-identifiers -fextended-identifiers" } */ +void abort (void); + +int a$b(void) { return 1; } + +int main (void) +{ + + if (a\u0024b() != 1) + abort (); + + return 0; +} diff --git a/test/unimplemented/dg/ucnid-6.c b/test/unimplemented/dg/ucnid-6.c new file mode 100644 index 0000000..37433a1 --- /dev/null +++ b/test/unimplemented/dg/ucnid-6.c @@ -0,0 +1,28 @@ +/* { dg-do run */ +/* { dg-xfail-if "" { "powerpc-ibm-aix*" } { "*" } { "" } } */ +/* { dg-options "-std=c99 -fextended-identifiers -save-temps" } */ +void abort (void); + +int \u00C0(void) { return 1; } +int \u00C1(void) { return 2; } +int \U000000C2(void) { return 3; } +int wh\u00ff(void) { return 4; } +int a\u00c4b\u0441\U000003b4e(void) { return 5; } + +int main (void) +{ + + if (\u00C0() != 1) + abort (); + if (\u00c1() != 2) + abort (); + if (\u00C2() != 3) + abort (); + if (wh\u00ff() != 4) + abort (); + if (a\u00c4b\u0441\U000003b4e() != 5) + abort (); + + return 0; +} +/* { dg-final { cleanup-saved-temps } } */ diff --git a/test/unimplemented/dg/vector/pr29091.c b/test/unimplemented/dg/vector/pr29091.c new file mode 100644 index 0000000..6e06c63 --- /dev/null +++ b/test/unimplemented/dg/vector/pr29091.c @@ -0,0 +1,44 @@ +/* PR c/29091 */ +/* { dg-do run } */ +/* { dg-options "-O2" } */ + +extern void abort (void); + +__attribute__ ((vector_size (sizeof (int) * 4))) int a = { 1, 2 }; +int d = 3; +__attribute__ ((vector_size (sizeof (int) * 4))) int b = { 4, 5, 6 }; +int e = 7; +__attribute__ ((vector_size (sizeof (int) * 4))) int c = { }; + +int +main (void) +{ + int *p = (int *) &a; + if (p[0] != 1) + abort (); + if (p[1] != 2) + abort (); + if (p[2] != 0) + abort (); + if (p[3] != 0) + abort (); + p = (int *) &b; + if (p[0] != 4) + abort (); + if (p[1] != 5) + abort (); + if (p[2] != 6) + abort (); + if (p[3] != 0) + abort (); + p = (int *) &c; + if (p[0] != 0) + abort (); + if (p[1] != 0) + abort (); + if (p[2] != 0) + abort (); + if (p[3] != 0) + abort (); + return 0; +} diff --git a/test/unimplemented/dg/vector/pr32912-2.c b/test/unimplemented/dg/vector/pr32912-2.c new file mode 100644 index 0000000..6f02874 --- /dev/null +++ b/test/unimplemented/dg/vector/pr32912-2.c @@ -0,0 +1,43 @@ +/* { dg-do run } */ +/* { dg-options "-O2 -w" } */ + +extern void abort (void); + +typedef int __m128i __attribute__ ((__vector_size__ (16))); + +__m128i +foo (void) +{ + __m128i x = { 0x11111111, 0x22222222, 0x44444444 }; + return x; +} + +__m128i +bar (void) +{ + __m128i x = { 0x11111111, 0x22222222, 0x44444444 }; + return ~x; +} + +int +main (void) +{ + union { __m128i v; int i[sizeof (__m128i) / sizeof (int)]; } u, v; + int i; + + u.v = foo (); + v.v = bar (); + for (i = 0; i < sizeof (u.i) / sizeof (u.i[0]); i++) + { + if (u.i[i] != ~v.i[i]) + abort (); + if (i < 3) + { + if (u.i[i] != (0x11111111 << i)) + abort (); + } + else if (u.i[i]) + abort (); + } + return 0; +} diff --git a/test/unimplemented/llbitfields/991118-1.c b/test/unimplemented/llbitfields/991118-1.c new file mode 100644 index 0000000..77ba888 --- /dev/null +++ b/test/unimplemented/llbitfields/991118-1.c @@ -0,0 +1,79 @@ +struct tmp +{ + long long int pad : 12; + long long int field : 52; +}; + +struct tmp2 +{ + long long int field : 52; + long long int pad : 12; +}; + +struct tmp3 +{ + long long int pad : 11; + long long int field : 53; +}; + +struct tmp4 +{ + long long int field : 53; + long long int pad : 11; +}; + +struct tmp +sub (struct tmp tmp) +{ + tmp.field ^= 0x0008765412345678LL; + return tmp; +} + +struct tmp2 +sub2 (struct tmp2 tmp2) +{ + tmp2.field ^= 0x0008765412345678LL; + return tmp2; +} + +struct tmp3 +sub3 (struct tmp3 tmp3) +{ + tmp3.field ^= 0x0018765412345678LL; + return tmp3; +} + +struct tmp4 +sub4 (struct tmp4 tmp4) +{ + tmp4.field ^= 0x0018765412345678LL; + return tmp4; +} + +struct tmp tmp = {0x123, 0x123456789ABCDLL}; +struct tmp2 tmp2 = {0x123456789ABCDLL, 0x123}; +struct tmp3 tmp3 = {0x123, 0x1FFFF00000000LL}; +struct tmp4 tmp4 = {0x1FFFF00000000LL, 0x123}; + +main() +{ + + if (sizeof (long long) != 8) + exit (0); + + tmp = sub (tmp); + tmp2 = sub2 (tmp2); + + if (tmp.pad != 0x123 || tmp.field != 0xFFF9551175BDFDB5LL) + abort (); + if (tmp2.pad != 0x123 || tmp2.field != 0xFFF9551175BDFDB5LL) + abort (); + + tmp3 = sub3 (tmp3); + tmp4 = sub4 (tmp4); + if (tmp3.pad != 0x123 || tmp3.field != 0xFFF989AB12345678LL) + abort (); + if (tmp4.pad != 0x123 || tmp4.field != 0xFFF989AB12345678LL) + abort (); + exit (0); +} diff --git a/test/unimplemented/llconsts/20060110-1.c b/test/unimplemented/llconsts/20060110-1.c new file mode 100644 index 0000000..13fc98a --- /dev/null +++ b/test/unimplemented/llconsts/20060110-1.c @@ -0,0 +1,16 @@ +extern void abort (void); + +long long +f (long long a) +{ + return (a << 16) >> 16; +} +long long a = 0x12345678LL; +long long b = (0x12345678LL << 16) >> 16; +int +main () +{ + if (f (a) != b) + abort (); + return 0; +} diff --git a/test/unimplemented/llconsts/20060110-2.c b/test/unimplemented/llconsts/20060110-2.c new file mode 100644 index 0000000..93e6f89 --- /dev/null +++ b/test/unimplemented/llconsts/20060110-2.c @@ -0,0 +1,19 @@ +extern void abort (void); + +long long +f (long long a, long long b) +{ + return ((a + b) << 16) >> 16; +} + +long long a = 0x12345678LL; +long long b = 0x23456787LL; +long long c = ((0x12345678LL + 0x23456787LL) << 16) >> 16; + +int +main () +{ + if (f (a, b) != c) + abort (); + return 0; +} diff --git a/test/unimplemented/localfn/20000822-1.c b/test/unimplemented/localfn/20000822-1.c new file mode 100644 index 0000000..f4a084b --- /dev/null +++ b/test/unimplemented/localfn/20000822-1.c @@ -0,0 +1,28 @@ +#ifndef NO_TRAMPOLINES +int f0(int (*fn)(int *), int *p) +{ + return (*fn) (p); +} + +int f1(void) +{ + int i = 0; + + int f2(int *p) + { + i = 1; + return *p + 1; + } + + return f0(f2, &i); +} +#endif + +int main() +{ +#ifndef NO_TRAMPOLINES + if (f1() != 2) + abort (); +#endif + return 0; +} diff --git a/test/unimplemented/localfn/20030501-1.c b/test/unimplemented/localfn/20030501-1.c new file mode 100644 index 0000000..f47dc29 --- /dev/null +++ b/test/unimplemented/localfn/20030501-1.c @@ -0,0 +1,17 @@ +int +main (int argc, char **argv) +{ + int size = 10; + + { + int retframe_block() + { + return size + 5; + } + + if (retframe_block() != 15) + abort (); + exit (0); + + } +} diff --git a/test/unimplemented/localfn/20040520-1.c b/test/unimplemented/localfn/20040520-1.c new file mode 100644 index 0000000..b424837 --- /dev/null +++ b/test/unimplemented/localfn/20040520-1.c @@ -0,0 +1,17 @@ +/* PR 15454 */ + +void abort (); +int main () { + int foo; + int bar (void) + { + int baz = 0; + if (foo!=45) + baz = foo; + return baz; + } + foo = 1; + if (!bar ()) + abort (); + return 0; +} diff --git a/test/unimplemented/localfn/20061220-1.c b/test/unimplemented/localfn/20061220-1.c new file mode 100644 index 0000000..188f92c --- /dev/null +++ b/test/unimplemented/localfn/20061220-1.c @@ -0,0 +1,72 @@ +/* PR middle-end/30262 */ +extern void abort (void); + +int +foo (void) +{ + unsigned int x = 0; + + void nested (void) + { + x = 254; + } + + nested (); + asm volatile ("" :: "r" (x)); + asm volatile ("" :: "m" (x)); + asm volatile ("" :: "mr" (x)); + asm volatile ("" : "=r" (x) : "0" (x)); + asm volatile ("" : "=m" (x) : "m" (x)); + return x; +} + +int +bar (void) +{ + unsigned int x = 0; + + void nested (void) + { + asm volatile ("" :: "r" (x)); + asm volatile ("" :: "m" (x)); + asm volatile ("" :: "mr" (x)); + x += 4; + asm volatile ("" : "=r" (x) : "0" (x)); + asm volatile ("" : "=m" (x) : "m" (x)); + } + + nested (); + return x; +} + +int +baz (void) +{ + unsigned int x = 0; + + void nested (void) + { + void nested2 (void) + { + asm volatile ("" :: "r" (x)); + asm volatile ("" :: "m" (x)); + asm volatile ("" :: "mr" (x)); + x += 4; + asm volatile ("" : "=r" (x) : "0" (x)); + asm volatile ("" : "=m" (x) : "m" (x)); + } + nested2 (); + nested2 (); + } + + nested (); + return x; +} + +int +main (void) +{ + if (foo () != 254 || bar () != 4 || baz () != 8) + abort (); + return 0; +} diff --git a/test/unimplemented/localfn/920415-1.c b/test/unimplemented/localfn/920415-1.c new file mode 100644 index 0000000..2d6335a --- /dev/null +++ b/test/unimplemented/localfn/920415-1.c @@ -0,0 +1,5 @@ +#ifndef NO_LABEL_VALUES +main(){__label__ l;void*x(){return&&l;}goto*x();abort();return;l:exit(0);} +#else +main(){ exit (0); } +#endif diff --git a/test/unimplemented/localfn/920428-2.c b/test/unimplemented/localfn/920428-2.c new file mode 100644 index 0000000..f8c2e5f --- /dev/null +++ b/test/unimplemented/localfn/920428-2.c @@ -0,0 +1,7 @@ +#if !defined (NO_LABEL_VALUES) && !defined (NO_TRAMPOLINES) +s(i){if(i>0){__label__ l1;int f(int i){if(i==2)goto l1;return 0;}return f(i);l1:;}return 1;} +x(){return s(0)==1&&s(1)==0&&s(2)==1;} +main(){if(x()!=1)abort();exit(0);} +#else +main(){ exit (0); } +#endif diff --git a/test/unimplemented/localfn/920501-7.c b/test/unimplemented/localfn/920501-7.c new file mode 100644 index 0000000..c23717d --- /dev/null +++ b/test/unimplemented/localfn/920501-7.c @@ -0,0 +1,30 @@ +#ifdef STACK_SIZE +#define DEPTH ((STACK_SIZE) / 512 + 1) +#else +#define DEPTH 1000 +#endif + +#if ! defined (NO_LABEL_VALUES) && !defined (NO_TRAMPOLINES) +x(a) +{ + __label__ xlab; + void y(a) + { + if (a==0) + goto xlab; + y (a-1); + } + y (a); + xlab:; + return a; +} +#endif + +main () +{ +#if ! defined (NO_LABEL_VALUES) && !defined (NO_TRAMPOLINES) + if (x (DEPTH) != DEPTH) + abort (); +#endif + exit (0); +} diff --git a/test/unimplemented/localfn/920721-4.c b/test/unimplemented/localfn/920721-4.c new file mode 100644 index 0000000..3cccc5b --- /dev/null +++ b/test/unimplemented/localfn/920721-4.c @@ -0,0 +1,60 @@ +#ifndef NO_LABEL_VALUES +int try (int num) { + __label__ lab1, lab2, lab3, lab4, lab5, lab6, default_lab; + + void *do_switch (int num) { + switch(num) { + case 1: + return &&lab1; + case 2: + return &&lab2; + case 3: + return &&lab3; + case 4: + return &&lab4; + case 5: + return &&lab5; + case 6: + return &&lab6; + default: + return &&default_lab; + } + } + + goto *do_switch (num); + + lab1: + return 1; + + lab2: + return 2; + + lab3: + return 3; + + lab4: + return 4; + + lab5: + return 5; + + lab6: + return 6; + + default_lab: + return -1; +} + +main() +{ + int i; + for (i = 1; i <= 6; i++) + { + if (try (i) != i) + abort(); + } + exit(0); +} +#else +main(){ exit (0); } +#endif diff --git a/test/unimplemented/localfn/921017-1.c b/test/unimplemented/localfn/921017-1.c new file mode 100644 index 0000000..ab68fc0 --- /dev/null +++ b/test/unimplemented/localfn/921017-1.c @@ -0,0 +1,17 @@ +f(n) +{ + int a[n]; + int g(i) + { + return a[i]; + } + a[1]=4711; + return g(1); +} +main() +{ +#ifndef NO_TRAMPOLINES + if(f(2)!=4711)abort(); +#endif + exit(0); +} diff --git a/test/unimplemented/localfn/comp-goto-2.c b/test/unimplemented/localfn/comp-goto-2.c new file mode 100644 index 0000000..771cd95 --- /dev/null +++ b/test/unimplemented/localfn/comp-goto-2.c @@ -0,0 +1,36 @@ +/* A slight variation of 920501-7.c. */ + +#ifdef STACK_SIZE +#define DEPTH ((STACK_SIZE) / 512 + 1) +#else +#define DEPTH 1000 +#endif + +#if ! defined (NO_LABEL_VALUES) && !defined (NO_TRAMPOLINES) +x(a) +{ + __label__ xlab; + void y(a) + { + void *x = &&llab; + if (a==-1) + goto *x; + if (a==0) + goto xlab; + llab: + y (a-1); + } + y (a); + xlab:; + return a; +} +#endif + +main () +{ +#if ! defined (NO_LABEL_VALUES) && !defined (NO_TRAMPOLINES) + if (x (DEPTH) != DEPTH) + abort (); +#endif + exit (0); +} diff --git a/test/unimplemented/localfn/nest-stdar-1.c b/test/unimplemented/localfn/nest-stdar-1.c new file mode 100644 index 0000000..492670b --- /dev/null +++ b/test/unimplemented/localfn/nest-stdar-1.c @@ -0,0 +1,19 @@ +#include + +main () +{ + double f (int x, ...) + { + va_list args; + double a; + + va_start (args, x); + a = va_arg (args, double); + va_end (args); + return a; + } + + if (f (1, (double)1) != 1.0) + abort (); + exit (0); +} diff --git a/test/unimplemented/localfn/nestfunc-1.c b/test/unimplemented/localfn/nestfunc-1.c new file mode 100644 index 0000000..e34a56b --- /dev/null +++ b/test/unimplemented/localfn/nestfunc-1.c @@ -0,0 +1,28 @@ +int +g (int a, int b, int (*gi) (int, int)) +{ + if ((*gi) (a, b)) + return a; + else + return b; +} + +f () +{ +#ifndef NO_TRAMPOLINES + int i, j; + int f2 (int a, int b) + { + return a > b; + } + + if (g (1, 2, f2) != 2) + abort (); +#endif +} + +main () +{ + f (); + exit (0); +} diff --git a/test/unimplemented/localfn/nestfunc-2.c b/test/unimplemented/localfn/nestfunc-2.c new file mode 100644 index 0000000..0308755 --- /dev/null +++ b/test/unimplemented/localfn/nestfunc-2.c @@ -0,0 +1,49 @@ +extern int foo (int, int, int (*) (int, int, int, int, int, int, int)); + +int z; + +int +main (void) +{ +#ifndef NO_TRAMPOLINES + int sum = 0; + int i; + + int nested (int a, int b, int c, int d, int e, int f, int g) + { + z = c + d + e + f + g; + + if (a > 2 * b) + return a - b; + else + return b - a; + } + + for (i = 0; i < 10; ++i) + { + int j; + + for (j = 0; j < 10; ++j) + { + int k; + + for (k = 0; k < 10; ++k) + sum += foo (i, j > k ? j - k : k - j, nested); + } + } + + if (sum != 2300) + abort (); + + if (z != 0x1b) + abort (); +#endif + + exit (0); +} + +int +foo (int a, int b, int (* fp) (int, int, int, int, int, int, int)) +{ + return fp (a, b, a, b, a, b, a); +} diff --git a/test/unimplemented/localfn/nestfunc-3.c b/test/unimplemented/localfn/nestfunc-3.c new file mode 100644 index 0000000..9d09b19 --- /dev/null +++ b/test/unimplemented/localfn/nestfunc-3.c @@ -0,0 +1,60 @@ + +extern long foo (long, long, long (*) (long, long)); +extern long use (long (*) (long, long), long, long); + +int +main (void) +{ +#ifndef NO_TRAMPOLINES + long sum = 0; + long i; + + long nested_0 (long a, long b) + { + if (a > 2 * b) + return a - b; + else + return b - a; + } + + long nested_1 (long a, long b) + { + return use (nested_0, b, a) + sum; + } + + long nested_2 (long a, long b) + { + return nested_1 (b, a); + } + + for (i = 0; i < 10; ++i) + { + long j; + + for (j = 0; j < 10; ++j) + { + long k; + + for (k = 0; k < 10; ++k) + sum += foo (i, j > k ? j - k : k - j, nested_2); + } + } + + if ((sum & 0xffffffff) != 0xbecfcbf5) + abort (); +#endif + + exit (0); +} + +long +use (long (* func)(long, long), long a, long b) +{ + return func (b, a); +} + +long +foo (long a, long b, long (* func) (long, long)) +{ + return func (a, b); +} diff --git a/test/unimplemented/localfn/nestfunc-5.c b/test/unimplemented/localfn/nestfunc-5.c new file mode 100644 index 0000000..88e74cc --- /dev/null +++ b/test/unimplemented/localfn/nestfunc-5.c @@ -0,0 +1,36 @@ +extern void abort (void); +extern void exit (int); + +#ifndef NO_TRAMPOLINES +static void recursive (int n, void (*proc) (void)) +{ + __label__ l1; + + void do_goto (void) + { + goto l1; + } + + if (n == 3) + recursive (n - 1, do_goto); + else if (n > 0) + recursive (n - 1, proc); + else + (*proc) (); + return; + +l1: + if (n == 3) + exit (0); + else + abort (); +} + +int main () +{ + recursive (10, abort); + abort (); +} +#else +int main () { return 0; } +#endif diff --git a/test/unimplemented/localfn/nestfunc-6.c b/test/unimplemented/localfn/nestfunc-6.c new file mode 100644 index 0000000..c8e8243 --- /dev/null +++ b/test/unimplemented/localfn/nestfunc-6.c @@ -0,0 +1,29 @@ +/* Test that the GP gets properly restored, either by the nonlocal + receiver or the nested function. */ + +#ifndef NO_TRAMPOLINES + +typedef __SIZE_TYPE__ size_t; +extern void abort (void); +extern void exit (int); +extern void qsort(void *, size_t, size_t, int (*)(const void *, const void *)); + +int main () +{ + __label__ nonlocal; + int compare (const void *a, const void *b) + { + goto nonlocal; + } + + char array[3]; + qsort (array, 3, 1, compare); + abort (); + + nonlocal: + exit (0); +} + +#else +int main() { return 0; } +#endif diff --git a/test/unimplemented/localfn/nestfunc-7.c b/test/unimplemented/localfn/nestfunc-7.c new file mode 100644 index 0000000..5b3d34b --- /dev/null +++ b/test/unimplemented/localfn/nestfunc-7.c @@ -0,0 +1,44 @@ +struct A +{ + int one; + int two; + int three; + int four; + int five; + int six; +}; + +static int test (void) +{ + int base; + + struct A Foo (void) + { + struct A a; + + a.one = base + 1; + a.two = base + 2; + a.three = base + 3; + a.four = base + 4; + a.five = base + 5; + a.six = base + 6; + + return a; + } + + base = 10; + struct A a = Foo (); + + return (a.one == 11 + && a.two == 12 + && a.three == 13 + && a.four == 14 + && a.five == 15 + && a.six == 16); +} + +int main (void) +{ + return !test (); +} + diff --git a/test/unimplemented/math/float-floor.c b/test/unimplemented/math/float-floor.c new file mode 100644 index 0000000..4225c49 --- /dev/null +++ b/test/unimplemented/math/float-floor.c @@ -0,0 +1,15 @@ +double d = 1024.0 - 1.0 / 32768.0; +extern double floor(double); +extern float floorf(float); +extern void abort(); + +int main() { + + double df = floor(d); + float f1 = (float)floor(d); + + if ((int)df != 1023 || (int)f1 != 1023) + abort (); + + return 0; +} diff --git a/test/unimplemented/nonconstarraysize/20010209-1.c b/test/unimplemented/nonconstarraysize/20010209-1.c new file mode 100644 index 0000000..e04d605 --- /dev/null +++ b/test/unimplemented/nonconstarraysize/20010209-1.c @@ -0,0 +1,21 @@ +int b; +int foo (void) +{ + int x[b]; + int bar (int t[b]) + { + int i; + for (i = 0; i < b; i++) + t[i] = i + (i > 0 ? t[i-1] : 0); + return t[b-1]; + } + return bar (x); +} + +int main () +{ + b = 6; + if (foo () != 15) + abort (); + exit (0); +} diff --git a/test/unimplemented/nonconstarraysize/20020412-1.c b/test/unimplemented/nonconstarraysize/20020412-1.c new file mode 100644 index 0000000..df0efe0 --- /dev/null +++ b/test/unimplemented/nonconstarraysize/20020412-1.c @@ -0,0 +1,56 @@ +/* PR c/3711 + This testcase ICEd on IA-32 at -O0 and was miscompiled otherwise, + because std_expand_builtin_va_arg didn't handle variable size types. */ + +#include + +extern void abort (void); +extern void exit (int); + +void bar (int c) +{ + static int d = '0'; + + if (c != d++) + abort (); + if (c < '0' || c > '9') + abort (); +} + +void foo (int size, ...) +{ + struct + { + char x[size]; + } d; + va_list ap; + int i; + + va_start (ap, size); + d = va_arg (ap, typeof (d)); + for (i = 0; i < size; i++) + bar (d.x[i]); + d = va_arg (ap, typeof (d)); + for (i = 0; i < size; i++) + bar (d.x[i]); + va_end (ap); +} + +int main (void) +{ + int z = 5; + struct { char a[z]; } x, y; + + x.a[0] = '0'; + x.a[1] = '1'; + x.a[2] = '2'; + x.a[3] = '3'; + x.a[4] = '4'; + y.a[0] = '5'; + y.a[1] = '6'; + y.a[2] = '7'; + y.a[3] = '8'; + y.a[4] = '9'; + foo (z, x, y); + exit (0); +} diff --git a/test/unimplemented/nonconstarraysize/20040308-1.c b/test/unimplemented/nonconstarraysize/20040308-1.c new file mode 100644 index 0000000..4c63535 --- /dev/null +++ b/test/unimplemented/nonconstarraysize/20040308-1.c @@ -0,0 +1,21 @@ +/* This used to fail on SPARC with an unaligned memory access. */ + +void foo(int n) +{ + struct S { + int i[n]; + unsigned int b:1; + int i2; + } __attribute__ ((packed)) __attribute__ ((aligned (4))); + + struct S s; + + s.i2 = 0; +} + +int main(void) +{ + foo(4); + + return 0; +} diff --git a/test/unimplemented/nonconstarraysize/20040411-1.c b/test/unimplemented/nonconstarraysize/20040411-1.c new file mode 100644 index 0000000..8db4562 --- /dev/null +++ b/test/unimplemented/nonconstarraysize/20040411-1.c @@ -0,0 +1,23 @@ +int +sub1 (int i, int j) +{ + typedef int c[i+2]; + int x[10], y[10]; + + if (j == 2) + { + memcpy (x, y, 10 * sizeof (int)); + return sizeof (c); + } + else + return sizeof (c) * 3; +} + +int +main () +{ + if (sub1 (20, 3) != 66 * sizeof (int)) + abort (); + + return 0; +} diff --git a/test/unimplemented/nonconstarraysize/20040423-1.c b/test/unimplemented/nonconstarraysize/20040423-1.c new file mode 100644 index 0000000..ace797e --- /dev/null +++ b/test/unimplemented/nonconstarraysize/20040423-1.c @@ -0,0 +1,30 @@ +int +sub1 (int i, int j) +{ + typedef struct + { + int c[i+2]; + }c; + int x[10], y[10]; + + if (j == 2) + { + memcpy (x, y, 10 * sizeof (int)); + return sizeof (c); + } + else + return sizeof (c) * 3; +} + +int +main () +{ + typedef struct + { + int c[22]; + }c; + if (sub1 (20, 3) != sizeof (c)*3) + abort (); + + return 0; +} diff --git a/test/unimplemented/nonconstarraysize/20041218-2.c b/test/unimplemented/nonconstarraysize/20041218-2.c new file mode 100644 index 0000000..d44b54d --- /dev/null +++ b/test/unimplemented/nonconstarraysize/20041218-2.c @@ -0,0 +1,15 @@ +extern void abort (void); + +int test(int n) +{ + struct s { char b[n]; } __attribute__((packed)); + n++; + return sizeof(struct s); +} + +int main() +{ + if (test(123) != 123) + abort (); + return 0; +} diff --git a/test/unimplemented/nonconstarraysize/20070919-1.c b/test/unimplemented/nonconstarraysize/20070919-1.c new file mode 100644 index 0000000..ade3d7e --- /dev/null +++ b/test/unimplemented/nonconstarraysize/20070919-1.c @@ -0,0 +1,41 @@ +/* PR c/33238 */ + +typedef __SIZE_TYPE__ size_t; +int memcmp (const void *, const void *, size_t); +void abort (void); + +void +__attribute__((noinline)) +bar (void *x, void *y) +{ + struct S { char w[8]; } *p = x, *q = y; + if (memcmp (p->w, "zyxwvut", 8) != 0) + abort (); + if (memcmp (q[0].w, "abcdefg", 8) != 0) + abort (); + if (memcmp (q[1].w, "ABCDEFG", 8) != 0) + abort (); + if (memcmp (q[2].w, "zyxwvut", 8) != 0) + abort (); + if (memcmp (q[3].w, "zyxwvut", 8) != 0) + abort (); +} + +void +__attribute__((noinline)) +foo (void *x, int y) +{ + struct S { char w[y]; } *p = x, a; + int i; + a = ({ struct S b; b = p[2]; p[3] = b; }); + bar (&a, x); +} + +int +main (void) +{ + struct S { char w[8]; } p[4] + = { "abcdefg", "ABCDEFG", "zyxwvut", "ZYXWVUT" }; + foo (p, 8); + return 0; +} diff --git a/test/unimplemented/nonconstarraysize/920721-2.c b/test/unimplemented/nonconstarraysize/920721-2.c new file mode 100644 index 0000000..2f25dc1 --- /dev/null +++ b/test/unimplemented/nonconstarraysize/920721-2.c @@ -0,0 +1,4 @@ +f(){} +main(){int n=2; +double x[n]; +f();exit(0);} diff --git a/test/unimplemented/nonconstarraysize/920929-1.c b/test/unimplemented/nonconstarraysize/920929-1.c new file mode 100644 index 0000000..e43444e --- /dev/null +++ b/test/unimplemented/nonconstarraysize/920929-1.c @@ -0,0 +1,13 @@ +/* REPRODUCED:RUN:SIGNAL MACHINE:sparc OPTIONS: */ +f(int n) +{ +int i; +double v[n]; +for(i=0;i +#include + +char buf[50]; +int +va (int a, double b, int c, ...) +{ + va_list ap; + int d, e, f, g, h, i, j, k, l, m, n, o, p; + va_start (ap, c); + + d = va_arg (ap, int); + e = va_arg (ap, int); + f = va_arg (ap, int); + g = va_arg (ap, int); + h = va_arg (ap, int); + i = va_arg (ap, int); + j = va_arg (ap, int); + k = va_arg (ap, int); + l = va_arg (ap, int); + m = va_arg (ap, int); + n = va_arg (ap, int); + o = va_arg (ap, int); + p = va_arg (ap, int); + + sprintf (buf, + "%d,%f,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d", + a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p); + va_end (ap); +} + +main() +{ + va (1, 1.0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); + if (strcmp ("1,1.000000,2,3,4,5,6,7,8,9,10,11,12,13,14,15", buf)) + abort(); + exit(0); +} diff --git a/test/unimplemented/printf/930513-1.c b/test/unimplemented/printf/930513-1.c new file mode 100644 index 0000000..0c376d9 --- /dev/null +++ b/test/unimplemented/printf/930513-1.c @@ -0,0 +1,18 @@ +/* no FP conversions in printf */ + +#include +char buf[2]; + +f (fp) + int (*fp)(char *, const char *, ...); +{ + (*fp)(buf, "%.0f", 5.0); +} + +main () +{ + f (&sprintf); + if (buf[0] != '5' || buf[1] != 0) + abort (); + exit (0); +} diff --git a/test/unimplemented/printf/941014-2.c b/test/unimplemented/printf/941014-2.c new file mode 100644 index 0000000..7cebcd0 --- /dev/null +++ b/test/unimplemented/printf/941014-2.c @@ -0,0 +1,35 @@ +/* printf() missing */ + +#include +#include + +typedef struct { + unsigned short a; + unsigned short b; +} foo_t; + +void a1 (unsigned long offset) {} + +volatile foo_t * +f () +{ + volatile foo_t *foo_p = (volatile foo_t *)malloc (sizeof (foo_t)); + + a1((unsigned long)foo_p-30); + if (foo_p->a & 0xf000) + printf("%d\n", foo_p->a); + foo_p->b = 0x0100; + a1 ((unsigned long)foo_p + 2); + a1 ((unsigned long)foo_p - 30); + return foo_p; +} + +main () +{ + volatile foo_t *foo_p; + + foo_p = f (); + if (foo_p->b != 0x0100) + abort (); + exit (0); +} diff --git a/test/unimplemented/printf/fprintf-1.c b/test/unimplemented/printf/fprintf-1.c new file mode 100644 index 0000000..f16252b --- /dev/null +++ b/test/unimplemented/printf/fprintf-1.c @@ -0,0 +1,23 @@ +#include +#include + +int +main (void) +{ +#define test(ret, args...) \ + fprintf (stdout, args); \ + if (fprintf (stdout, args) != ret) \ + abort (); + test (5, "hello"); + test (6, "hello\n"); + test (1, "a"); + test (0, ""); + test (5, "%s", "hello"); + test (6, "%s", "hello\n"); + test (1, "%s", "a"); + test (0, "%s", ""); + test (1, "%c", 'x'); + test (7, "%s\n", "hello\n"); + test (2, "%d\n", 0); + return 0; +} diff --git a/test/unimplemented/printf/fprintf-chk-1.c b/test/unimplemented/printf/fprintf-chk-1.c new file mode 100644 index 0000000..918ff8e --- /dev/null +++ b/test/unimplemented/printf/fprintf-chk-1.c @@ -0,0 +1,49 @@ +#include +#include +#include + +volatile int should_optimize; + +int +__attribute__((noinline)) +__fprintf_chk (FILE *f, int flag, const char *fmt, ...) +{ + va_list ap; + int ret; +#ifdef __OPTIMIZE__ + if (should_optimize) + abort (); +#endif + should_optimize = 1; + va_start (ap, fmt); + ret = vfprintf (f, fmt, ap); + va_end (ap); + return ret; +} + +int +main (void) +{ +#define test(ret, opt, args...) \ + should_optimize = opt; \ + __fprintf_chk (stdout, 1, args); \ + if (!should_optimize) \ + abort (); \ + should_optimize = 0; \ + if (__fprintf_chk (stdout, 1, args) != ret) \ + abort (); \ + if (!should_optimize) \ + abort (); + test (5, 1, "hello"); + test (6, 1, "hello\n"); + test (1, 1, "a"); + test (0, 1, ""); + test (5, 1, "%s", "hello"); + test (6, 1, "%s", "hello\n"); + test (1, 1, "%s", "a"); + test (0, 1, "%s", ""); + test (1, 1, "%c", 'x'); + test (7, 0, "%s\n", "hello\n"); + test (2, 0, "%d\n", 0); + return 0; +} diff --git a/test/unimplemented/printf/printf-1.c b/test/unimplemented/printf/printf-1.c new file mode 100644 index 0000000..0ffcd5d --- /dev/null +++ b/test/unimplemented/printf/printf-1.c @@ -0,0 +1,23 @@ +#include +#include + +int +main (void) +{ +#define test(ret, args...) \ + printf (args); \ + if (printf (args) != ret) \ + abort (); + test (5, "hello"); + test (6, "hello\n"); + test (1, "a"); + test (0, ""); + test (5, "%s", "hello"); + test (6, "%s", "hello\n"); + test (1, "%s", "a"); + test (0, "%s", ""); + test (1, "%c", 'x'); + test (7, "%s\n", "hello\n"); + test (2, "%d\n", 0); + return 0; +} diff --git a/test/unimplemented/printf/printf-chk-1.c b/test/unimplemented/printf/printf-chk-1.c new file mode 100644 index 0000000..8f9a79c --- /dev/null +++ b/test/unimplemented/printf/printf-chk-1.c @@ -0,0 +1,49 @@ +#include +#include +#include + +volatile int should_optimize; + +int +__attribute__((noinline)) +__printf_chk (int flag, const char *fmt, ...) +{ + va_list ap; + int ret; +#ifdef __OPTIMIZE__ + if (should_optimize) + abort (); +#endif + should_optimize = 1; + va_start (ap, fmt); + ret = vprintf (fmt, ap); + va_end (ap); + return ret; +} + +int +main (void) +{ +#define test(ret, opt, args...) \ + should_optimize = opt; \ + __printf_chk (1, args); \ + if (!should_optimize) \ + abort (); \ + should_optimize = 0; \ + if (__printf_chk (1, args) != ret) \ + abort (); \ + if (!should_optimize) \ + abort (); + test (5, 0, "hello"); + test (6, 1, "hello\n"); + test (1, 1, "a"); + test (0, 1, ""); + test (5, 0, "%s", "hello"); + test (6, 1, "%s", "hello\n"); + test (1, 1, "%s", "a"); + test (0, 1, "%s", ""); + test (1, 1, "%c", 'x'); + test (7, 1, "%s\n", "hello\n"); + test (2, 0, "%d\n", 0); + return 0; +} diff --git a/test/unimplemented/printf/va-arg-21.c b/test/unimplemented/printf/va-arg-21.c new file mode 100644 index 0000000..044541b --- /dev/null +++ b/test/unimplemented/printf/va-arg-21.c @@ -0,0 +1,48 @@ +/* Copyright (C) 2000 Free Software Foundation. + + If the argument to va_end() has side effects, test whether side + effects from that argument are honored. + + Written by Kaveh R. Ghazi, 10/31/2000. */ + +#include +#include +#include + +#ifndef __GNUC__ +#define __attribute__(x) +#endif + +static void __attribute__ ((__format__ (__printf__, 1, 2))) +doit (const char *s, ...) +{ + va_list *ap_array[3], **ap_ptr = ap_array; + + ap_array[0] = malloc (sizeof(va_list)); + ap_array[1] = NULL; + ap_array[2] = malloc (sizeof(va_list)); + + va_start (*ap_array[0], s); + vprintf (s, **ap_ptr); + /* Increment the va_list pointer once. */ + va_end (**ap_ptr++); + + /* Increment the va_list pointer a second time. */ + ap_ptr++; + + va_start (*ap_array[2], s); + /* If we failed to increment ap_ptr twice, then the parameter passed + in here will dereference NULL and should cause a crash. */ + vprintf (s, **ap_ptr); + va_end (**ap_ptr); + + /* Just in case, If *ap_ptr is NULL abort anyway. */ + if (*ap_ptr == 0) + abort(); +} + +int main() +{ + doit ("%s", "hello world\n"); + exit (0); +} diff --git a/test/unimplemented/printf/va-arg-24.c b/test/unimplemented/printf/va-arg-24.c new file mode 100644 index 0000000..811b11f --- /dev/null +++ b/test/unimplemented/printf/va-arg-24.c @@ -0,0 +1,96 @@ +/* The purpose of this code is to test argument passing of a tuple of + 11 integers, with the break point between named and unnamed arguments + at every possible position. */ + +#include +#include +#include + +static int errors = 0; + +static void +verify (const char *tcase, int n[11]) +{ + int i; + for (i = 0; i <= 10; i++) + if (n[i] != i) + { + printf (" %s: n[%d] = %d expected %d\n", tcase, i, n[i], i); + errors++; + } +} + +#define STR(x) #x + +#define p(i) int q##i, +#define P(i) n[i] = q##i; + +#define p0 p(0) +#define p1 p(1) +#define p2 p(2) +#define p3 p(3) +#define p4 p(4) +#define p5 p(5) +#define p6 p(6) +#define p7 p(7) +#define p8 p(8) +#define p9 p(9) + +#define P0 P(0) +#define P1 P(1) +#define P2 P(2) +#define P3 P(3) +#define P4 P(4) +#define P5 P(5) +#define P6 P(6) +#define P7 P(7) +#define P8 P(8) +#define P9 P(9) + +#define TCASE(x, params, vecinit) \ +static void \ +varargs##x (params ...) \ +{ \ + va_list ap; \ + int n[11]; \ + int i; \ + \ + va_start (ap, q##x); \ + vecinit \ + for (i = x + 1; i <= 10; i++) \ + n[i] = va_arg (ap, int); \ + va_end (ap); \ + \ + verify (STR(varargs##x), n); \ +} + +#define TEST(x) varargs##x (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10) + +TCASE(0, p0 , P0 ) +TCASE(1, p0 p1 , P0 P1 ) +TCASE(2, p0 p1 p2 , P0 P1 P2 ) +TCASE(3, p0 p1 p2 p3 , P0 P1 P2 P3 ) +TCASE(4, p0 p1 p2 p3 p4 , P0 P1 P2 P3 P4 ) +TCASE(5, p0 p1 p2 p3 p4 p5 , P0 P1 P2 P3 P4 P5 ) +TCASE(6, p0 p1 p2 p3 p4 p5 p6 , P0 P1 P2 P3 P4 P5 P6 ) +TCASE(7, p0 p1 p2 p3 p4 p5 p6 p7 , P0 P1 P2 P3 P4 P5 P6 P7 ) +TCASE(8, p0 p1 p2 p3 p4 p5 p6 p7 p8 , P0 P1 P2 P3 P4 P5 P6 P7 P8 ) +TCASE(9, p0 p1 p2 p3 p4 p5 p6 p7 p8 p9, P0 P1 P2 P3 P4 P5 P6 P7 P8 P9) + +int main(void) +{ + TEST(0); + TEST(1); + TEST(2); + TEST(3); + TEST(4); + TEST(5); + TEST(6); + TEST(7); + TEST(8); + TEST(9); + + if (errors) + abort (); + exit (0); +} diff --git a/test/unimplemented/printf/vfprintf-1.c b/test/unimplemented/printf/vfprintf-1.c new file mode 100644 index 0000000..c003804 --- /dev/null +++ b/test/unimplemented/printf/vfprintf-1.c @@ -0,0 +1,53 @@ +#ifndef test +#include +#include +#include + +void +inner (int x, ...) +{ + va_list ap, ap2; + va_start (ap, x); + va_start (ap2, x); + + switch (x) + { +#define test(n, ret, fmt, args) \ + case n: \ + vfprintf (stdout, fmt, ap); \ + if (vfprintf (stdout, fmt, ap2) != ret) \ + abort (); \ + break; +#include "vfprintf-1.c" +#undef test + default: + abort (); + } + + va_end (ap); + va_end (ap2); +} + +int +main (void) +{ +#define test(n, ret, fmt, args) \ + inner args; +#include "vfprintf-1.c" +#undef test + return 0; +} + +#else + test (0, 5, "hello", (0)); + test (1, 6, "hello\n", (1)); + test (2, 1, "a", (2)); + test (3, 0, "", (3)); + test (4, 5, "%s", (4, "hello")); + test (5, 6, "%s", (5, "hello\n")); + test (6, 1, "%s", (6, "a")); + test (7, 0, "%s", (7, "")); + test (8, 1, "%c", (8, 'x')); + test (9, 7, "%s\n", (9, "hello\n")); + test (10, 2, "%d\n", (10, 0)); +#endif diff --git a/test/unimplemented/printf/vfprintf-chk-1.c b/test/unimplemented/printf/vfprintf-chk-1.c new file mode 100644 index 0000000..f8f964c --- /dev/null +++ b/test/unimplemented/printf/vfprintf-chk-1.c @@ -0,0 +1,73 @@ +#ifndef test +#include +#include +#include + +volatile int should_optimize; + +int +__attribute__((noinline)) +__vfprintf_chk (FILE *f, int flag, const char *fmt, va_list ap) +{ +#ifdef __OPTIMIZE__ + if (should_optimize) + abort (); +#endif + should_optimize = 1; + return vfprintf (f, fmt, ap); +} + +void +inner (int x, ...) +{ + va_list ap, ap2; + va_start (ap, x); + va_start (ap2, x); + + switch (x) + { +#define test(n, ret, opt, fmt, args) \ + case n: \ + should_optimize = opt; \ + __vfprintf_chk (stdout, 1, fmt, ap); \ + if (! should_optimize) \ + abort (); \ + should_optimize = 0; \ + if (__vfprintf_chk (stdout, 1, fmt, ap2) != ret) \ + abort (); \ + if (! should_optimize) \ + abort (); \ + break; +#include "vfprintf-chk-1.c" +#undef test + default: + abort (); + } + + va_end (ap); + va_end (ap2); +} + +int +main (void) +{ +#define test(n, ret, opt, fmt, args) \ + inner args; +#include "vfprintf-chk-1.c" +#undef test + return 0; +} + +#else + test (0, 5, 1, "hello", (0)); + test (1, 6, 1, "hello\n", (1)); + test (2, 1, 1, "a", (2)); + test (3, 0, 1, "", (3)); + test (4, 5, 0, "%s", (4, "hello")); + test (5, 6, 0, "%s", (5, "hello\n")); + test (6, 1, 0, "%s", (6, "a")); + test (7, 0, 0, "%s", (7, "")); + test (8, 1, 0, "%c", (8, 'x')); + test (9, 7, 0, "%s\n", (9, "hello\n")); + test (10, 2, 0, "%d\n", (10, 0)); +#endif diff --git a/test/unimplemented/printf/vprintf-1.c b/test/unimplemented/printf/vprintf-1.c new file mode 100644 index 0000000..9f1b8bf --- /dev/null +++ b/test/unimplemented/printf/vprintf-1.c @@ -0,0 +1,53 @@ +#ifndef test +#include +#include +#include + +void +inner (int x, ...) +{ + va_list ap, ap2; + va_start (ap, x); + va_start (ap2, x); + + switch (x) + { +#define test(n, ret, fmt, args) \ + case n: \ + vprintf (fmt, ap); \ + if (vprintf (fmt, ap2) != ret) \ + abort (); \ + break; +#include "vprintf-1.c" +#undef test + default: + abort (); + } + + va_end (ap); + va_end (ap2); +} + +int +main (void) +{ +#define test(n, ret, fmt, args) \ + inner args; +#include "vprintf-1.c" +#undef test + return 0; +} + +#else + test (0, 5, "hello", (0)); + test (1, 6, "hello\n", (1)); + test (2, 1, "a", (2)); + test (3, 0, "", (3)); + test (4, 5, "%s", (4, "hello")); + test (5, 6, "%s", (5, "hello\n")); + test (6, 1, "%s", (6, "a")); + test (7, 0, "%s", (7, "")); + test (8, 1, "%c", (8, 'x')); + test (9, 7, "%s\n", (9, "hello\n")); + test (10, 2, "%d\n", (10, 0)); +#endif diff --git a/test/unimplemented/printf/vprintf-chk-1.c b/test/unimplemented/printf/vprintf-chk-1.c new file mode 100644 index 0000000..ca62f8b --- /dev/null +++ b/test/unimplemented/printf/vprintf-chk-1.c @@ -0,0 +1,73 @@ +#ifndef test +#include +#include +#include + +volatile int should_optimize; + +int +__attribute__((noinline)) +__vprintf_chk (int flag, const char *fmt, va_list ap) +{ +#ifdef __OPTIMIZE__ + if (should_optimize) + abort (); +#endif + should_optimize = 1; + return vprintf (fmt, ap); +} + +void +inner (int x, ...) +{ + va_list ap, ap2; + va_start (ap, x); + va_start (ap2, x); + + switch (x) + { +#define test(n, ret, opt, fmt, args) \ + case n: \ + should_optimize = opt; \ + __vprintf_chk (1, fmt, ap); \ + if (! should_optimize) \ + abort (); \ + should_optimize = 0; \ + if (__vprintf_chk (1, fmt, ap2) != ret) \ + abort (); \ + if (! should_optimize) \ + abort (); \ + break; +#include "vprintf-chk-1.c" +#undef test + default: + abort (); + } + + va_end (ap); + va_end (ap2); +} + +int +main (void) +{ +#define test(n, ret, opt, fmt, args) \ + inner args; +#include "vprintf-chk-1.c" +#undef test + return 0; +} + +#else + test (0, 5, 0, "hello", (0)); + test (1, 6, 1, "hello\n", (1)); + test (2, 1, 1, "a", (2)); + test (3, 0, 1, "", (3)); + test (4, 5, 0, "%s", (4, "hello")); + test (5, 6, 0, "%s", (5, "hello\n")); + test (6, 1, 0, "%s", (6, "a")); + test (7, 0, 0, "%s", (7, "")); + test (8, 1, 0, "%c", (8, 'x')); + test (9, 7, 0, "%s\n", (9, "hello\n")); + test (10, 2, 0, "%d\n", (10, 0)); +#endif diff --git a/test/unimplemented/uninitedunsizedarray/20030109-1.c b/test/unimplemented/uninitedunsizedarray/20030109-1.c new file mode 100644 index 0000000..1bea931 --- /dev/null +++ b/test/unimplemented/uninitedunsizedarray/20030109-1.c @@ -0,0 +1,20 @@ +/* PR c/8032 */ +/* Verify that an empty initializer inside a partial + parent initializer doesn't confuse GCC. */ + +struct X +{ + int a; + int b; + int z[]; +}; + +struct X x = { .b = 40, .z = {} }; + +int main () +{ + if (x.b != 40) + abort (); + + return 0; +} diff --git a/test/unimplemented/va-arg-pack-1.c b/test/unimplemented/va-arg-pack-1.c new file mode 100644 index 0000000..baefe87 --- /dev/null +++ b/test/unimplemented/va-arg-pack-1.c @@ -0,0 +1,143 @@ +/* __builtin_va_arg_pack () builtin tests. */ + +#include + +extern void abort (void); + +int v1 = 8; +long int v2 = 3; +void *v3 = (void *) &v2; +struct A { char c[16]; } v4 = { "foo" }; +long double v5 = 40; +char seen[20]; +int cnt; + +__attribute__ ((noinline)) int +foo1 (int x, int y, ...) +{ + int i; + long int l; + void *v; + struct A a; + long double ld; + va_list ap; + + va_start (ap, y); + if (x < 0 || x >= 20 || seen[x]) + abort (); + seen[x] = ++cnt; + if (y != 6) + abort (); + i = va_arg (ap, int); + if (i != 5) + abort (); + switch (x) + { + case 0: + i = va_arg (ap, int); + if (i != 9 || v1 != 9) + abort (); + a = va_arg (ap, struct A); + if (__builtin_memcmp (a.c, v4.c, sizeof (a.c)) != 0) + abort (); + v = (void *) va_arg (ap, struct A *); + if (v != (void *) &v4) + abort (); + l = va_arg (ap, long int); + if (l != 3 || v2 != 4) + abort (); + break; + case 1: + ld = va_arg (ap, long double); + if (ld != 41 || v5 != ld) + abort (); + i = va_arg (ap, int); + if (i != 8) + abort (); + v = va_arg (ap, void *); + if (v != &v2) + abort (); + break; + case 2: + break; + default: + abort (); + } + va_end (ap); + return x; +} + +__attribute__ ((noinline)) int +foo2 (int x, int y, ...) +{ + long long int ll; + void *v; + struct A a, b; + long double ld; + va_list ap; + + va_start (ap, y); + if (x < 0 || x >= 20 || seen[x]) + abort (); + seen[x] = ++cnt | 64; + if (y != 10) + abort (); + switch (x) + { + case 11: + break; + case 12: + ld = va_arg (ap, long double); + if (ld != 41 || v5 != 40) + abort (); + a = va_arg (ap, struct A); + if (__builtin_memcmp (a.c, v4.c, sizeof (a.c)) != 0) + abort (); + b = va_arg (ap, struct A); + if (__builtin_memcmp (b.c, v4.c, sizeof (b.c)) != 0) + abort (); + v = va_arg (ap, void *); + if (v != &v2) + abort (); + ll = va_arg (ap, long long int); + if (ll != 16LL) + abort (); + break; + case 2: + break; + default: + abort (); + } + va_end (ap); + return x + 8; +} + +__attribute__ ((noinline)) int +foo3 (void) +{ + return 6; +} + +extern inline __attribute__ ((always_inline, gnu_inline)) int +bar (int x, ...) +{ + if (x < 10) + return foo1 (x, foo3 (), 5, __builtin_va_arg_pack ()); + return foo2 (x, foo3 () + 4, __builtin_va_arg_pack ()); +} + +int +main (void) +{ + if (bar (0, ++v1, v4, &v4, v2++) != 0) + abort (); + if (bar (1, ++v5, 8, v3) != 1) + abort (); + if (bar (2) != 2) + abort (); + if (bar (v1 + 2) != 19) + abort (); + if (bar (v1 + 3, v5--, v4, v4, v3, 16LL) != 20) + abort (); + return 0; +} diff --git a/test/unimplemented/vector/20050316-1.c b/test/unimplemented/vector/20050316-1.c new file mode 100644 index 0000000..2a1c625 --- /dev/null +++ b/test/unimplemented/vector/20050316-1.c @@ -0,0 +1,69 @@ +/* PR rtl-optimization/16104 */ + +extern void abort (void); + +typedef int V2SI __attribute__ ((vector_size (8))); +typedef unsigned int V2USI __attribute__ ((vector_size (8))); +typedef short V2HI __attribute__ ((vector_size (4))); +typedef unsigned int V2UHI __attribute__ ((vector_size (4))); + +int +test1 (void) +{ + return (long long) (V2SI) 0LL; +} + +int +test2 (V2SI x) +{ + return (long long) x; +} + +V2SI +test3 (void) +{ + return (V2SI) (long long) (int) (V2HI) 0; +} + +V2SI +test4 (V2HI x) +{ + return (V2SI) (long long) (int) x; +} + +V2SI +test5 (V2USI x) +{ + return (V2SI) x; +} + +int +main (void) +{ + if (sizeof (short) != 2 || sizeof (int) != 4 || sizeof (long long) != 8) + return 0; + + if (test1 () != 0) + abort (); + + V2SI x = { 2, 2 }; + if (test2 (x) != 2) + abort (); + + union { V2SI x; int y[2]; V2USI z; long long l; } u; + u.x = test3 (); + if (u.y[0] != 0 || u.y[1] != 0) + abort (); + + V2HI y = { 4, 4 }; + union { V2SI x; long long y; } v; + v.x = test4 (y); + if (v.y != 0x40004) + abort (); + + V2USI z = { 6, 6 }; + u.x = test5 (z); + if (u.y[0] != 6 || u.y[1] != 6) + abort (); + return 0; +} diff --git a/test/unimplemented/vector/20050316-2.c b/test/unimplemented/vector/20050316-2.c new file mode 100644 index 0000000..c648777 --- /dev/null +++ b/test/unimplemented/vector/20050316-2.c @@ -0,0 +1,49 @@ +extern void abort (void); + +typedef int V2SI __attribute__ ((vector_size (8))); +typedef unsigned int V2USI __attribute__ ((vector_size (8))); +typedef float V2SF __attribute__ ((vector_size (8))); +typedef short V2HI __attribute__ ((vector_size (4))); +typedef unsigned int V2UHI __attribute__ ((vector_size (4))); + +long long +test1 (V2SF x) +{ + return (long long) (V2SI) x; +} + +long long +test2 (V2SF x) +{ + return (long long) x; +} + +long long +test3 (V2SI x) +{ + return (long long) (V2SF) x; +} + +int +main (void) +{ + if (sizeof (short) != 2 || sizeof (int) != 4 || sizeof (long long) != 8) + return 0; + + V2SF x = { 2.0, 2.0 }; + union { long long l; float f[2]; int i[2]; } u; + u.l = test1 (x); + if (u.f[0] != 2.0 || u.f[1] != 2.0) + abort (); + + V2SF y = { 6.0, 6.0 }; + u.l = test2 (y); + if (u.f[0] != 6.0 || u.f[1] != 6.0) + abort (); + + V2SI z = { 4, 4 }; + u.l = test3 (z); + if (u.i[0] != 4 || u.i[1] != 4) + abort (); + return 0; +} diff --git a/test/unimplemented/vector/20050316-3.c b/test/unimplemented/vector/20050316-3.c new file mode 100644 index 0000000..773243f --- /dev/null +++ b/test/unimplemented/vector/20050316-3.c @@ -0,0 +1,36 @@ +extern void abort (void); + +typedef int V2SI __attribute__ ((vector_size (8))); +typedef unsigned int V2USI __attribute__ ((vector_size (8))); +typedef short V2HI __attribute__ ((vector_size (4))); +typedef unsigned int V2UHI __attribute__ ((vector_size (4))); + +V2USI +test1 (V2SI x) +{ + return (V2USI) (V2SI) (long long) x; +} + +long long +test2 (V2SI x) +{ + return (long long) (V2USI) (V2SI) (long long) x; +} + +int +main (void) +{ + if (sizeof (short) != 2 || sizeof (int) != 4 || sizeof (long long) != 8) + return 0; + + union { V2SI x; int y[2]; V2USI z; long long l; } u; + V2SI a = { -3, -3 }; + u.z = test1 (a); + if (u.y[0] != -3 || u.y[1] != -3) + abort (); + + u.l = test2 (a); + if (u.y[0] != -3 || u.y[1] != -3) + abort (); + return 0; +} diff --git a/test/unimplemented/vector/20050604-1.c b/test/unimplemented/vector/20050604-1.c new file mode 100644 index 0000000..70097aa --- /dev/null +++ b/test/unimplemented/vector/20050604-1.c @@ -0,0 +1,39 @@ +/* PR regression/21897 */ + +extern void abort (void); + +typedef short v4hi __attribute__ ((vector_size (8))); +typedef float v4sf __attribute__ ((vector_size (16))); + +union +{ + v4hi v; + short s[4]; +} u; + +union +{ + v4sf v; + float f[4]; +} v; + +void +foo (void) +{ + unsigned int i; + for (i = 0; i < 2; i++) + u.v += (v4hi) { 12, 14 }; + for (i = 0; i < 2; i++) + v.v += (v4sf) { 18.0, 20.0, 22 }; +} + +int +main (void) +{ + foo (); + if (u.s[0] != 24 || u.s[1] != 28 || u.s[2] || u.s[3]) + abort (); + if (v.f[0] != 36.0 || v.f[1] != 40.0 || v.f[2] != 44.0 || v.f[3] != 0.0) + abort (); + return 0; +} diff --git a/test/unimplemented/vector/pr23135.c b/test/unimplemented/vector/pr23135.c new file mode 100644 index 0000000..57b5f7c --- /dev/null +++ b/test/unimplemented/vector/pr23135.c @@ -0,0 +1,134 @@ +/* Based on execute/simd-1.c, modified by joern.rennecke@st.com to + trigger a reload bug. Verified for gcc mainline from 20050722 13:00 UTC + for sh-elf -m4 -O2. */ +#ifndef STACK_SIZE +#define STACK_SIZE (256*1024) +#endif + +typedef struct { char c[STACK_SIZE/2]; } big_t; + +typedef int __attribute__((mode(SI))) __attribute__((vector_size (8))) vecint; +typedef int __attribute__((mode(SI))) siint; + +vecint i = { 150, 100 }; +vecint j = { 10, 13 }; +vecint k; + +union { + vecint v; + siint i[2]; +} res; + +void +verify (siint a1, siint a2, siint b1, siint b2, big_t big) +{ + if (a1 != b1 + || a2 != b2) + abort (); +} + +int +main () +{ + big_t big; + vecint k0, k1, k2, k3, k4, k5, k6, k7; + + k0 = i + j; + res.v = k0; + + verify (res.i[0], res.i[1], 160, 113, big); + + k1 = i * j; + res.v = k1; + + verify (res.i[0], res.i[1], 1500, 1300, big); + + k2 = i / j; +/* This is the observed failure - reload 0 has the wrong type and thus the + conflict with reload 1 is missed: + +(insn:HI 94 92 96 1 pr23135.c:46 (parallel [ + (set (subreg:SI (reg:DI 253) 0) + (div:SI (reg:SI 4 r4) + (reg:SI 5 r5))) + (clobber (reg:SI 146 pr)) + (clobber (reg:DF 64 fr0)) + (clobber (reg:DF 66 fr2)) + (use (reg:PSI 151 )) + (use (reg/f:SI 256)) + ]) 60 {divsi3_i4} (insn_list:REG_DEP_TRUE 90 (insn_list:REG_DEP_TRUE 89 +(insn_list:REG_DEP_TRUE 42 (insn_list:REG_DEP_TRUE 83 (insn_list:REG_DEP_TRUE 92 + (insn_list:REG_DEP_TRUE 91 (nil))))))) + (expr_list:REG_DEAD (reg:SI 4 r4) + (expr_list:REG_DEAD (reg:SI 5 r5) + (expr_list:REG_UNUSED (reg:DF 66 fr2) + (expr_list:REG_UNUSED (reg:DF 64 fr0) + (expr_list:REG_UNUSED (reg:SI 146 pr) + (insn_list:REG_RETVAL 91 (nil)))))))) + +Reloads for insn # 94 +Reload 0: reload_in (SI) = (plus:SI (reg/f:SI 14 r14) + (const_int 64 [0x40])) + GENERAL_REGS, RELOAD_FOR_OUTADDR_ADDRESS (opnum = 0) + reload_in_reg: (plus:SI (reg/f:SI 14 r14) + (const_int 64 [0x40])) + reload_reg_rtx: (reg:SI 3 r3) +Reload 1: GENERAL_REGS, RELOAD_FOR_OUTPUT_ADDRESS (opnum = 0), can't combine, se +condary_reload_p + reload_reg_rtx: (reg:SI 3 r3) +Reload 2: reload_out (SI) = (mem:SI (plus:SI (plus:SI (reg/f:SI 14 r14) + (const_int 64 [0x40])) + (const_int 28 [0x1c])) [ 16 S8 A32]) + FPUL_REGS, RELOAD_FOR_OUTPUT (opnum = 0) + reload_out_reg: (subreg:SI (reg:DI 253) 0) + reload_reg_rtx: (reg:SI 150 fpul) + secondary_out_reload = 1 + +Reload 3: reload_in (SI) = (symbol_ref:SI ("__sdivsi3_i4") [flags 0x1]) + GENERAL_REGS, RELOAD_FOR_INPUT (opnum = 1), can't combine + reload_in_reg: (reg/f:SI 256) + reload_reg_rtx: (reg:SI 3 r3) + */ + + + res.v = k2; + + verify (res.i[0], res.i[1], 15, 7, big); + + k3 = i & j; + res.v = k3; + + verify (res.i[0], res.i[1], 2, 4, big); + + k4 = i | j; + res.v = k4; + + verify (res.i[0], res.i[1], 158, 109, big); + + k5 = i ^ j; + res.v = k5; + + verify (res.i[0], res.i[1], 156, 105, big); + + k6 = -i; + res.v = k6; + verify (res.i[0], res.i[1], -150, -100, big); + + k7 = ~i; + res.v = k7; + verify (res.i[0], res.i[1], -151, -101, big); + + k = k0 + k1 + k3 + k4 + k5 + k6 + k7; + res.v = k; + verify (res.i[0], res.i[1], 1675, 1430, big); + + k = k0 * k1 * k3 * k4 * k5 * k6 * k7; + res.v = k; + verify (res.i[0], res.i[1], 1456467968, -1579586240, big); + + k = k0 / k1 / k2 / k3 / k4 / k5 / k6 / k7; + res.v = k; + verify (res.i[0], res.i[1], 0, 0, big); + + exit (0); +} diff --git a/test/unimplemented/vector/simd-1.c b/test/unimplemented/vector/simd-1.c new file mode 100644 index 0000000..97d8206 --- /dev/null +++ b/test/unimplemented/vector/simd-1.c @@ -0,0 +1,74 @@ +/* Origin: Aldy Hernandez + + Purpose: Test generic SIMD support. This test should work + regardless of if the target has SIMD instructions. +*/ + +typedef int __attribute__((mode(SI))) __attribute__((vector_size (16))) vecint; +typedef int __attribute__((mode(SI))) siint; + +vecint i = { 150, 100, 150, 200 }; +vecint j = { 10, 13, 20, 30 }; +vecint k; + +union { + vecint v; + siint i[4]; +} res; + +/* This should go away once we can use == and != on vector types. */ +void +verify (siint a1, siint a2, siint a3, siint a4, + siint b1, siint b2, siint b3, siint b4) +{ + if (a1 != b1 + || a2 != b2 + || a3 != b3 + || a4 != b4) + abort (); +} + +int +main () +{ + k = i + j; + res.v = k; + + verify (res.i[0], res.i[1], res.i[2], res.i[3], 160, 113, 170, 230); + + k = i * j; + res.v = k; + + verify (res.i[0], res.i[1], res.i[2], res.i[3], 1500, 1300, 3000, 6000); + + k = i / j; + res.v = k; + + verify (res.i[0], res.i[1], res.i[2], res.i[3], 15, 7, 7, 6); + + k = i & j; + res.v = k; + + verify (res.i[0], res.i[1], res.i[2], res.i[3], 2, 4, 20, 8); + + k = i | j; + res.v = k; + + verify (res.i[0], res.i[1], res.i[2], res.i[3], 158, 109, 150, 222); + + k = i ^ j; + res.v = k; + + verify (res.i[0], res.i[1], res.i[2], res.i[3], 156, 105, 130, 214); + + k = -i; + res.v = k; + verify (res.i[0], res.i[1], res.i[2], res.i[3], + -150, -100, -150, -200); + + k = ~i; + res.v = k; + verify (res.i[0], res.i[1], res.i[2], res.i[3], -151, -101, -151, -201); + + exit (0); +} diff --git a/test/unimplemented/vector/simd-2.c b/test/unimplemented/vector/simd-2.c new file mode 100644 index 0000000..d4f506a --- /dev/null +++ b/test/unimplemented/vector/simd-2.c @@ -0,0 +1,72 @@ +/* + Purpose: Test generic SIMD support, V8HImode. This test should work + regardless of if the target has SIMD instructions. +*/ + +typedef short __attribute__((vector_size (16))) vecint; + +vecint i = { 150, 100, 150, 200, 0, 0, 0, 0 }; +vecint j = { 10, 13, 20, 30, 1, 1, 1, 1 }; +vecint k; + +union { + vecint v; + short i[8]; +} res; + +/* This should go away once we can use == and != on vector types. */ +void +verify (int a1, int a2, int a3, int a4, + int b1, int b2, int b3, int b4) +{ + if (a1 != b1 + || a2 != b2 + || a3 != b3 + || a4 != b4) + abort (); +} + +int +main () +{ + k = i + j; + res.v = k; + + verify (res.i[0], res.i[1], res.i[2], res.i[3], 160, 113, 170, 230); + + k = i * j; + res.v = k; + + verify (res.i[0], res.i[1], res.i[2], res.i[3], 1500, 1300, 3000, 6000); + + k = i / j; + res.v = k; + + verify (res.i[0], res.i[1], res.i[2], res.i[3], 15, 7, 7, 6); + + k = i & j; + res.v = k; + + verify (res.i[0], res.i[1], res.i[2], res.i[3], 2, 4, 20, 8); + + k = i | j; + res.v = k; + + verify (res.i[0], res.i[1], res.i[2], res.i[3], 158, 109, 150, 222); + + k = i ^ j; + res.v = k; + + verify (res.i[0], res.i[1], res.i[2], res.i[3], 156, 105, 130, 214); + + k = -i; + res.v = k; + verify (res.i[0], res.i[1], res.i[2], res.i[3], + -150, -100, -150, -200); + + k = ~i; + res.v = k; + verify (res.i[0], res.i[1], res.i[2], res.i[3], -151, -101, -151, -201); + + exit (0); +} diff --git a/test/unimplemented/vector/simd-4.c b/test/unimplemented/vector/simd-4.c new file mode 100644 index 0000000..5b9c785 --- /dev/null +++ b/test/unimplemented/vector/simd-4.c @@ -0,0 +1,20 @@ +#include +typedef int32_t __attribute__((vector_size(8))) v2si; +int64_t s64; + +static inline int64_t +__ev_convert_s64 (v2si a) +{ + return (int64_t) a; +} + +int main() +{ + union { int64_t ll; int32_t i[2]; } endianness_test; + endianness_test.ll = 1; + int32_t little_endian = endianness_test.i[0]; + s64 = __ev_convert_s64 ((v2si){1,0xffffffff}); + if (s64 != (little_endian ? 0xffffffff00000001LL : 0x1ffffffffLL)) + abort (); + return 0; +} diff --git a/test/unimplemented/vector/simd-5.c b/test/unimplemented/vector/simd-5.c new file mode 100644 index 0000000..f058432 --- /dev/null +++ b/test/unimplemented/vector/simd-5.c @@ -0,0 +1,59 @@ +/* Test saving and restoring of SIMD registers. */ + +typedef short Q __attribute__((vector_size(8))); + +Q q1 = {1, 2}, q2 = {3, 4}, q3 = {5, 6}, q4 = {7, 8}; + +Q w1, w2, w3, w4; +Q z1, z2, z3, z4; + +volatile int dummy; + +void __attribute__((__noinline__)) +func0 (void) +{ + dummy = 1; +} + +void __attribute__((__noinline__)) +func1 (void) +{ + Q a, b; + a = q1 * q2; + b = q3 * q4; + w1 = a; + w2 = b; + func0 (); + w3 = a; + w4 = b; +} + +void __attribute__((__noinline__)) +func2 (void) +{ + Q a, b; + a = q1 + q2; + b = q3 - q4; + z1 = a; + z2 = b; + func1 (); + z3 = a; + z4 = b; +} + +int +main (void) +{ + func2 (); + + if (memcmp (&w1, &w3, sizeof (Q)) != 0) + abort (); + if (memcmp (&w2, &w4, sizeof (Q)) != 0) + abort (); + if (memcmp (&z1, &z3, sizeof (Q)) != 0) + abort (); + if (memcmp (&z2, &z4, sizeof (Q)) != 0) + abort (); + + return 0; +} diff --git a/test/unimplemented/vector/simd-6.c b/test/unimplemented/vector/simd-6.c new file mode 100644 index 0000000..ca4aabc --- /dev/null +++ b/test/unimplemented/vector/simd-6.c @@ -0,0 +1,22 @@ +extern void abort (void); +extern int memcmp (const void *, const void *, __SIZE_TYPE__); + +typedef unsigned char v8qi __attribute__((vector_size(8))); + +v8qi foo(v8qi x, v8qi y) +{ + return x * y; +} + +int main() +{ + v8qi a = { 1, 2, 3, 4, 5, 6, 7, 8 }; + v8qi b = { 3, 3, 3, 3, 3, 3, 3, 3 }; + v8qi c = { 3, 6, 9, 12, 15, 18, 21, 24 }; + v8qi r; + + r = foo (a, b); + if (memcmp (&r, &c, 8) != 0) + abort (); + return 0; +} diff --git a/test/unimplemented/vector/va-arg-25.c b/test/unimplemented/vector/va-arg-25.c new file mode 100644 index 0000000..b9f3a1b --- /dev/null +++ b/test/unimplemented/vector/va-arg-25.c @@ -0,0 +1,37 @@ +/* Varargs and vectors! */ + +#include +#include + +#define vector __attribute__((vector_size(16))) + +const vector unsigned int v1 = {10,11,12,13}; +const vector unsigned int v2 = {20,21,22,23}; + +void foo(int a, ...) +{ + va_list args; + vector unsigned int v; + + va_start (args, a); + v = va_arg (args, vector unsigned int); + if (a != 1 || memcmp (&v, &v1, sizeof (v)) != 0) + abort (); + a = va_arg (args, int); + if (a != 2) + abort (); + v = va_arg (args, vector unsigned int); + if (memcmp (&v, &v2, sizeof (v)) != 0) + abort (); + va_end (args); +} + +int main(void) +{ +#if INT_MAX == 2147483647 + foo (1, (vector unsigned int){10,11,12,13}, 2, + (vector unsigned int){20,21,22,23}); +#endif + return 0; +} + diff --git a/test/unimplemented/wchar_t-1.c b/test/unimplemented/wchar_t-1.c new file mode 100644 index 0000000..7e90cc0 --- /dev/null +++ b/test/unimplemented/wchar_t-1.c @@ -0,0 +1,17 @@ +/* { dg-options "-finput-charset=utf-8" } */ +typedef __WCHAR_TYPE__ wchar_t; +wchar_t x[] = L"Ä"; +wchar_t y = L'Ä'; +extern void abort (void); +extern void exit (int); + +int main (void) +{ + if (sizeof (x) / sizeof (wchar_t) != 2) + abort (); + if (x[0] != L'Ä' || x[1] != L'\0') + abort (); + if (y != L'Ä') + abort (); + exit (0); +} diff --git a/texi2pod.pl b/texi2pod.pl new file mode 100755 index 0000000..d86e176 --- /dev/null +++ b/texi2pod.pl @@ -0,0 +1,427 @@ +#! /usr/bin/perl -w + +# Copyright (C) 1999, 2000, 2001 Free Software Foundation, Inc. + +# This file is part of GNU CC. + +# GNU CC is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2, or (at your option) +# any later version. + +# GNU CC is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GNU CC; see the file COPYING. If not, write to +# the Free Software Foundation, 59 Temple Place - Suite 330, +# Boston MA 02111-1307, USA. + +# This does trivial (and I mean _trivial_) conversion of Texinfo +# markup to Perl POD format. It's intended to be used to extract +# something suitable for a manpage from a Texinfo document. + +$output = 0; +$skipping = 0; +%sects = (); +$section = ""; +@icstack = (); +@endwstack = (); +@skstack = (); +@instack = (); +$shift = ""; +%defs = (); +$fnno = 1; +$inf = ""; +$ibase = ""; + +while ($_ = shift) { + if (/^-D(.*)$/) { + if ($1 ne "") { + $flag = $1; + } else { + $flag = shift; + } + $value = ""; + ($flag, $value) = ($flag =~ /^([^=]+)(?:=(.+))?/); + die "no flag specified for -D\n" + unless $flag ne ""; + die "flags may only contain letters, digits, hyphens, dashes and underscores\n" + unless $flag =~ /^[a-zA-Z0-9_-]+$/; + $defs{$flag} = $value; + } elsif (/^-/) { + usage(); + } else { + $in = $_, next unless defined $in; + $out = $_, next unless defined $out; + usage(); + } +} + +if (defined $in) { + $inf = gensym(); + open($inf, "<$in") or die "opening \"$in\": $!\n"; + $ibase = $1 if $in =~ m|^(.+)/[^/]+$|; +} else { + $inf = \*STDIN; +} + +if (defined $out) { + open(STDOUT, ">$out") or die "opening \"$out\": $!\n"; +} + +while(defined $inf) { +while(<$inf>) { + # Certain commands are discarded without further processing. + /^\@(?: + [a-z]+index # @*index: useful only in complete manual + |need # @need: useful only in printed manual + |(?:end\s+)?group # @group .. @end group: ditto + |page # @page: ditto + |node # @node: useful only in .info file + |(?:end\s+)?ifnottex # @ifnottex .. @end ifnottex: use contents + )\b/x and next; + + chomp; + + # Look for filename and title markers. + /^\@setfilename\s+([^.]+)/ and $fn = $1, next; + /^\@settitle\s+([^.]+)/ and $tl = postprocess($1), next; + + # Identify a man title but keep only the one we are interested in. + /^\@c\s+man\s+title\s+([A-Za-z0-9-]+)\s+(.+)/ and do { + if (exists $defs{$1}) { + $fn = $1; + $tl = postprocess($2); + } + next; + }; + + # Look for blocks surrounded by @c man begin SECTION ... @c man end. + # This really oughta be @ifman ... @end ifman and the like, but such + # would require rev'ing all other Texinfo translators. + /^\@c\s+man\s+begin\s+([A-Z]+)\s+([A-Za-z0-9-]+)/ and do { + $output = 1 if exists $defs{$2}; + $sect = $1; + next; + }; + /^\@c\s+man\s+begin\s+([A-Z]+)/ and $sect = $1, $output = 1, next; + /^\@c\s+man\s+end/ and do { + $sects{$sect} = "" unless exists $sects{$sect}; + $sects{$sect} .= postprocess($section); + $section = ""; + $output = 0; + next; + }; + + # handle variables + /^\@set\s+([a-zA-Z0-9_-]+)\s*(.*)$/ and do { + $defs{$1} = $2; + next; + }; + /^\@clear\s+([a-zA-Z0-9_-]+)/ and do { + delete $defs{$1}; + next; + }; + + next unless $output; + + # Discard comments. (Can't do it above, because then we'd never see + # @c man lines.) + /^\@c\b/ and next; + + # End-block handler goes up here because it needs to operate even + # if we are skipping. + /^\@end\s+([a-z]+)/ and do { + # Ignore @end foo, where foo is not an operation which may + # cause us to skip, if we are presently skipping. + my $ended = $1; + next if $skipping && $ended !~ /^(?:ifset|ifclear|ignore|menu|iftex)$/; + + die "\@end $ended without \@$ended at line $.\n" unless defined $endw; + die "\@$endw ended by \@end $ended at line $.\n" unless $ended eq $endw; + + $endw = pop @endwstack; + + if ($ended =~ /^(?:ifset|ifclear|ignore|menu|iftex)$/) { + $skipping = pop @skstack; + next; + } elsif ($ended =~ /^(?:example|smallexample|display)$/) { + $shift = ""; + $_ = ""; # need a paragraph break + } elsif ($ended =~ /^(?:itemize|enumerate|[fv]?table)$/) { + $_ = "\n=back\n"; + $ic = pop @icstack; + } else { + die "unknown command \@end $ended at line $.\n"; + } + }; + + # We must handle commands which can cause skipping even while we + # are skipping, otherwise we will not process nested conditionals + # correctly. + /^\@ifset\s+([a-zA-Z0-9_-]+)/ and do { + push @endwstack, $endw; + push @skstack, $skipping; + $endw = "ifset"; + $skipping = 1 unless exists $defs{$1}; + next; + }; + + /^\@ifclear\s+([a-zA-Z0-9_-]+)/ and do { + push @endwstack, $endw; + push @skstack, $skipping; + $endw = "ifclear"; + $skipping = 1 if exists $defs{$1}; + next; + }; + + /^\@(ignore|menu|iftex)\b/ and do { + push @endwstack, $endw; + push @skstack, $skipping; + $endw = $1; + $skipping = 1; + next; + }; + + next if $skipping; + + # Character entities. First the ones that can be replaced by raw text + # or discarded outright: + s/\@copyright\{\}/(c)/g; + s/\@dots\{\}/.../g; + s/\@enddots\{\}/..../g; + s/\@([.!? ])/$1/g; + s/\@[:-]//g; + s/\@bullet(?:\{\})?/*/g; + s/\@TeX\{\}/TeX/g; + s/\@pounds\{\}/\#/g; + s/\@minus(?:\{\})?/-/g; + s/\\,/,/g; + + # Now the ones that have to be replaced by special escapes + # (which will be turned back into text by unmunge()) + s/&/&/g; + s/\@\{/{/g; + s/\@\}/}/g; + s/\@\@/&at;/g; + + # Inside a verbatim block, handle @var specially. + if ($shift ne "") { + s/\@var\{([^\}]*)\}/<$1>/g; + } + + # POD doesn't interpret E<> inside a verbatim block. + if ($shift eq "") { + s//>/g; + } else { + s//>/g; + } + + # Single line command handlers. + + /^\@include\s+(.+)$/ and do { + push @instack, $inf; + $inf = gensym(); + + # Try cwd and $ibase. + open($inf, "<" . $1) + or open($inf, "<" . $ibase . "/" . $1) + or die "cannot open $1 or $ibase/$1: $!\n"; + next; + }; + + /^\@(?:section|unnumbered|unnumberedsec|center)\s+(.+)$/ + and $_ = "\n=head2 $1\n"; + /^\@subsection\s+(.+)$/ + and $_ = "\n=head3 $1\n"; + + # Block command handlers: + /^\@itemize\s+(\@[a-z]+|\*|-)/ and do { + push @endwstack, $endw; + push @icstack, $ic; + $ic = $1; + $_ = "\n=over 4\n"; + $endw = "itemize"; + }; + + /^\@enumerate(?:\s+([a-zA-Z0-9]+))?/ and do { + push @endwstack, $endw; + push @icstack, $ic; + if (defined $1) { + $ic = $1 . "."; + } else { + $ic = "1."; + } + $_ = "\n=over 4\n"; + $endw = "enumerate"; + }; + + /^\@([fv]?table)\s+(\@[a-z]+)/ and do { + push @endwstack, $endw; + push @icstack, $ic; + $endw = $1; + $ic = $2; + $ic =~ s/\@(?:samp|strong|key|gcctabopt|option|env)/B/; + $ic =~ s/\@(?:code|kbd)/C/; + $ic =~ s/\@(?:dfn|var|emph|cite|i)/I/; + $ic =~ s/\@(?:file)/F/; + $_ = "\n=over 4\n"; + }; + + /^\@((?:small)?example|display)/ and do { + push @endwstack, $endw; + $endw = $1; + $shift = "\t"; + $_ = ""; # need a paragraph break + }; + + /^\@itemx?\s*(.+)?$/ and do { + if (defined $1) { + # Entity escapes prevent munging by the <> processing below. + $_ = "\n=item $ic\<$1\>\n"; + } else { + $_ = "\n=item $ic\n"; + $ic =~ y/A-Ya-y/B-Zb-z/; + $ic =~ s/(\d+)/$1 + 1/eg; + } + }; + + $section .= $shift.$_."\n"; +} +# End of current file. +close($inf); +$inf = pop @instack; +} + +die "No filename or title\n" unless defined $fn && defined $tl; + +$sects{NAME} = "$fn \- $tl\n"; +$sects{FOOTNOTES} .= "=back\n" if exists $sects{FOOTNOTES}; + +for $sect (qw(NAME SYNOPSIS DESCRIPTION OPTIONS ENVIRONMENT FILES + BUGS NOTES FOOTNOTES SEEALSO AUTHOR COPYRIGHT)) { + if(exists $sects{$sect}) { + $head = $sect; + $head =~ s/SEEALSO/SEE ALSO/; + print "=head1 $head\n\n"; + print scalar unmunge ($sects{$sect}); + print "\n"; + } +} + +sub usage +{ + die "usage: $0 [-D toggle...] [infile [outfile]]\n"; +} + +sub postprocess +{ + local $_ = $_[0]; + + # @value{foo} is replaced by whatever 'foo' is defined as. + while (m/(\@value\{([a-zA-Z0-9_-]+)\})/g) { + if (! exists $defs{$2}) { + print STDERR "Option $2 not defined\n"; + s/\Q$1\E//; + } else { + $value = $defs{$2}; + s/\Q$1\E/$value/; + } + } + + # Formatting commands. + # Temporary escape for @r. + s/\@r\{([^\}]*)\}/R<$1>/g; + s/\@(?:dfn|var|emph|cite|i)\{([^\}]*)\}/I<$1>/g; + s/\@(?:code|kbd)\{([^\}]*)\}/C<$1>/g; + s/\@(?:gccoptlist|samp|strong|key|option|env|command|b)\{([^\}]*)\}/B<$1>/g; + s/\@sc\{([^\}]*)\}/\U$1/g; + s/\@file\{([^\}]*)\}/F<$1>/g; + s/\@w\{([^\}]*)\}/S<$1>/g; + s/\@(?:dmn|math)\{([^\}]*)\}/$1/g; + + # Cross references are thrown away, as are @noindent and @refill. + # (@noindent is impossible in .pod, and @refill is unnecessary.) + # @* is also impossible in .pod; we discard it and any newline that + # follows it. Similarly, our macro @gol must be discarded. + + s/\(?\@xref\{(?:[^\}]*)\}(?:[^.<]|(?:<[^<>]*>))*\.\)?//g; + s/\s+\(\@pxref\{(?:[^\}]*)\}\)//g; + s/;\s+\@pxref\{(?:[^\}]*)\}//g; + s/\@noindent\s*//g; + s/\@refill//g; + s/\@gol//g; + s/\@\*\s*\n?//g; + + # @uref can take one, two, or three arguments, with different + # semantics each time. @url and @email are just like @uref with + # one argument, for our purposes. + s/\@(?:uref|url|email)\{([^\},]*)\}/<B<$1>>/g; + s/\@uref\{([^\},]*),([^\},]*)\}/$2 (C<$1>)/g; + s/\@uref\{([^\},]*),([^\},]*),([^\},]*)\}/$3/g; + + # Turn B blah> into B I B to + # match Texinfo semantics of @emph inside @samp. Also handle @r + # inside bold. + s/<//g; + 1 while s/B<((?:[^<>]|I<[^<>]*>)*)R<([^>]*)>/B<$1>${2}B]*)I<([^>]+)>/B<$1>I<$2>B]*)B<([^>]+)>/I<$1>B<$2>I//g; + s/([BI])<(\s+)([^>]+)>/$2$1<$3>/g; + s/([BI])<([^>]+?)(\s+)>/$1<$2>$3/g; + + # Extract footnotes. This has to be done after all other + # processing because otherwise the regexp will choke on formatting + # inside @footnote. + while (/\@footnote/g) { + s/\@footnote\{([^\}]+)\}/[$fnno]/; + add_footnote($1, $fnno); + $fnno++; + } + + return $_; +} + +sub unmunge +{ + # Replace escaped symbols with their equivalents. + local $_ = $_[0]; + + s/</E/g; + s/>/E/g; + s/{/\{/g; + s/}/\}/g; + s/&at;/\@/g; + s/&/&/g; + return $_; +} + +sub add_footnote +{ + unless (exists $sects{FOOTNOTES}) { + $sects{FOOTNOTES} = "\n=over 4\n\n"; + } + + $sects{FOOTNOTES} .= "=item $fnno.\n\n"; $fnno++; + $sects{FOOTNOTES} .= $_[0]; + $sects{FOOTNOTES} .= "\n\n"; +} + +# stolen from Symbol.pm +{ + my $genseq = 0; + sub gensym + { + my $name = "GEN" . $genseq++; + my $ref = \*{$name}; + delete $::{$name}; + return $ref; + } +} diff --git a/varargs.h b/varargs.h new file mode 100644 index 0000000..daee29e --- /dev/null +++ b/varargs.h @@ -0,0 +1,11 @@ +#ifndef _VARARGS_H +#define _VARARGS_H + +#include + +#define va_dcl +#define va_alist __va_alist +#undef va_start +#define va_start(ap) ap = __builtin_varargs_start + +#endif