Mercurial > repo

view interps/c-intercal/oilout03.c @ 12518:2d8fe55c6e65 draft default tip

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
<int-e> learn The password of the month is release incident pilot.
author HackEso <hackeso@esolangs.org>
date Sun, 03 Nov 2024 00:31:02 +0000
parents 859f9b4339e6
children
line wrap: on
line source

/* Automatically generated output, edit source and recompile to change */
#include "oil.h"
int optimize_pass1_3(node *np)
{  int opted=0;
  unsigned long c,c1,c2,c3,c4,c5,c6,c7,c8,c9;
  unsigned long x,x1,x2,x3,x4,x5,x6,x7,x8,x9,r;
  int tempw;
  node *tp;
  checknodeactbits(np);
  if(np->opcode==C_AND &&
     np->rval->opcode==C_XOR &&
     np->rval->lval->width==32)
  do
  {
    if(!nodessame(np->lval,np->rval->rval)) break;
    x2=np->rval->rval->constant; c2=np->rval->rval->optdata;
    x1=np->rval->lval->constant; c1=np->rval->lval->optdata;
    OPTING(cxorand32);
    tp=newnode();
    MAYBENEWNODE(tp);
    tp->opcode=C_AND;
    tp->width=32;
    MAYBENEWNODE(tp->lval);
    tp->lval->opcode=C_NOT;
    tp->lval->width=32;
    tp->lval->rval=np->rval->lval;
    np->rval->lval=0;
    tp->rval=np->rval->rval;
    np->rval->rval=0;
    nodefree(np->lval); nodefree(np->rval);
    tempw=np->width; *np=*tp; np->width=tempw; free(tp);
  } while(0);

  checknodeactbits(np);
  if(np->opcode==C_AND &&
     np->rval->opcode==C_XOR &&
     np->rval->rval->width==32)
  do
  {
    if(!nodessame(np->lval,np->rval->lval)) break;
    x2=np->rval->lval->constant; c2=np->rval->lval->optdata;
    x1=np->rval->rval->constant; c1=np->rval->rval->optdata;
    OPTING(cxorand32);
    tp=newnode();
    MAYBENEWNODE(tp);
    tp->opcode=C_AND;
    tp->width=32;
    MAYBENEWNODE(tp->lval);
    tp->lval->opcode=C_NOT;
    tp->lval->width=32;
    tp->lval->rval=np->rval->rval;
    np->rval->rval=0;
    tp->rval=np->rval->lval;
    np->rval->lval=0;
    nodefree(np->lval); nodefree(np->rval);
    tempw=np->width; *np=*tp; np->width=tempw; free(tp);
  } while(0);

  checknodeactbits(np);
  if(np->opcode==SELECT &&
     (np->rval->opcode==MESH || np->rval->opcode==MESH32))
  do
  {
    x2=np->rval->constant; c2=np->rval->optdata;
    x1=np->lval->constant; c1=np->lval->optdata;
    x=x2; c=c2; if(!(x==xselx(x))) break;
    OPTING(xselpow2m1);
    tp=newnode();
    MAYBENEWNODE(tp);
    tp->opcode=C_AND;
    tp->width=32;
    tp->lval=np->lval;
    np->lval=0;
    tp->rval=np->rval;
    np->rval=0;
    nodefree(np->lval); nodefree(np->rval);
    tempw=np->width; *np=*tp; np->width=tempw; free(tp);
  } while(0);

  checknodeactbits(np);
  if(np->opcode==SELECT &&
     (np->rval->opcode==MESH || np->rval->opcode==MESH32))
  do
  {
    x2=np->rval->constant; c2=np->rval->optdata;
    x1=np->lval->constant; c1=np->lval->optdata;
    x=x2; c=c2; if(!(xselx(x)==1)) break;
    OPTING(xselpow2);
    tp=newnode();
    MAYBENEWNODE(tp);
    tp->opcode=C_LOGICALNOT;
    tp->width=16;
    MAYBENEWNODE(tp->rval);
    tp->rval->opcode=C_LOGICALNOT;
    tp->rval->width=16;
    MAYBENEWNODE(tp->rval->rval);
    tp->rval->rval->opcode=C_AND;
    tp->rval->rval->width=32;
    tp->rval->rval->lval=np->lval;
    np->lval=0;
    tp->rval->rval->rval=np->rval;
    np->rval=0;
    nodefree(np->lval); nodefree(np->rval);
    tempw=np->width; *np=*tp; np->width=tempw; free(tp);
  } while(0);

  checknodeactbits(np);
  if(np->opcode==SELECT &&
     np->lval->opcode==SELECT &&
     (np->rval->opcode==MESH || np->rval->opcode==MESH32) &&
     np->rval->constant==1LU)
  do
  {
    if(!nodessame(np->lval->lval,np->lval->rval)) break;
    x1=np->lval->rval->constant; c1=np->lval->rval->optdata;
    OPTING(xselxsel1);
    tp=newnode();
    MAYBENEWNODE(tp);
    tp->opcode=C_LOGICALNOT;
    tp->width=16;
    MAYBENEWNODE(tp->rval);
    tp->rval->opcode=C_LOGICALNOT;
    tp->rval->width=16;
    tp->rval->rval=np->lval->rval;
    np->lval->rval=0;
    nodefree(np->lval); nodefree(np->rval);
    tempw=np->width; *np=*tp; np->width=tempw; free(tp);
  } while(0);

  checknodeactbits(np);
  if(np->opcode==C_AND &&
     np->lval->opcode==SELECT &&
     (np->rval->opcode==MESH || np->rval->opcode==MESH32) &&
     np->rval->constant==1LU)
  do
  {
    if(!nodessame(np->lval->lval,np->lval->rval)) break;
    x1=np->lval->rval->constant; c1=np->lval->rval->optdata;
    OPTING(xselxsel1);
    tp=newnode();
    MAYBENEWNODE(tp);
    tp->opcode=C_LOGICALNOT;
    tp->width=16;
    MAYBENEWNODE(tp->rval);
    tp->rval->opcode=C_LOGICALNOT;
    tp->rval->width=16;
    tp->rval->rval=np->lval->rval;
    np->lval->rval=0;
    nodefree(np->lval); nodefree(np->rval);
    tempw=np->width; *np=*tp; np->width=tempw; free(tp);
  } while(0);

  checknodeactbits(np);
  if(np->opcode==C_AND &&
     (np->lval->opcode==MESH || np->lval->opcode==MESH32) &&
     np->lval->constant==1LU &&
     np->rval->opcode==SELECT)
  do
  {
    if(!nodessame(np->rval->lval,np->rval->rval)) break;
    x1=np->rval->rval->constant; c1=np->rval->rval->optdata;
    OPTING(xselxsel1);
    tp=newnode();
    MAYBENEWNODE(tp);
    tp->opcode=C_LOGICALNOT;
    tp->width=16;
    MAYBENEWNODE(tp->rval);
    tp->rval->opcode=C_LOGICALNOT;
    tp->rval->width=16;
    tp->rval->rval=np->rval->rval;
    np->rval->rval=0;
    nodefree(np->lval); nodefree(np->rval);
    tempw=np->width; *np=*tp; np->width=tempw; free(tp);
  } while(0);

  checknodeactbits(np);
  if(np->opcode==C_AND &&
     np->lval->opcode==SELECT)
  do
  {
    x2=np->rval->constant; c2=np->rval->optdata;
    if(!nodessame(np->lval->lval,np->lval->rval)) break;
    x1=np->lval->rval->constant; c1=np->lval->rval->optdata;
    x=x2; c=c2; if(!(c==1)) break;
    OPTING(xselxsel1);
    tp=newnode();
    MAYBENEWNODE(tp);
    tp->opcode=C_LOGICALAND;
    tp->width=16;
    tp->lval=np->lval->rval;
    np->lval->rval=0;
    tp->rval=np->rval;
    np->rval=0;
    nodefree(np->lval); nodefree(np->rval);
    tempw=np->width; *np=*tp; np->width=tempw; free(tp);
  } while(0);

  checknodeactbits(np);
  if(np->opcode==C_AND &&
     np->rval->opcode==SELECT)
  do
  {
    x2=np->lval->constant; c2=np->lval->optdata;
    if(!nodessame(np->rval->lval,np->rval->rval)) break;
    x1=np->rval->rval->constant; c1=np->rval->rval->optdata;
    x=x2; c=c2; if(!(c==1)) break;
    OPTING(xselxsel1);
    tp=newnode();
    MAYBENEWNODE(tp);
    tp->opcode=C_LOGICALAND;
    tp->width=16;
    tp->lval=np->rval->rval;
    np->rval->rval=0;
    tp->rval=np->lval;
    np->lval=0;
    nodefree(np->lval); nodefree(np->rval);
    tempw=np->width; *np=*tp; np->width=tempw; free(tp);
  } while(0);

  checknodeactbits(np);
  if(np->opcode==SELECT &&
     np->lval->opcode==SELECT &&
     (np->lval->lval->opcode==MESH || np->lval->lval->opcode==MESH32) &&
     (np->rval->opcode==MESH || np->rval->opcode==MESH32) &&
     np->rval->constant==1LU)
  do
  {
    x2=np->lval->rval->constant; c2=np->lval->rval->optdata;
    x1=np->lval->lval->constant; c1=np->lval->lval->optdata;
    x=x1; c=c1; if(!(x==xselx(x))) break;
    OPTING(pow2m1selx);
    tp=newnode();
    MAYBENEWNODE(tp);
    tp->opcode=C_LOGICALNOT;
    tp->width=16;
    MAYBENEWNODE(tp->rval);
    tp->rval->opcode=C_LOGICALNOT;
    tp->rval->width=16;
    MAYBENEWNODE(tp->rval->rval);
    tp->rval->rval->opcode=C_AND;
    tp->rval->rval->width=32;
    tp->rval->rval->lval=np->lval->lval;
    np->lval->lval=0;
    tp->rval->rval->rval=np->lval->rval;
    np->lval->rval=0;
    nodefree(np->lval); nodefree(np->rval);
    tempw=np->width; *np=*tp; np->width=tempw; free(tp);
  } while(0);

  checknodeactbits(np);
  if(np->opcode==C_LOGICALNOT &&
     np->rval->opcode==SELECT)
  do
  {
    x2=np->rval->rval->constant; c2=np->rval->rval->optdata;
    x1=np->rval->lval->constant; c1=np->rval->lval->optdata;
    OPTING(notselect);
    tp=newnode();
    MAYBENEWNODE(tp);
    tp->opcode=C_LOGICALNOT;
    tp->width=16;
    MAYBENEWNODE(tp->rval);
    tp->rval->opcode=C_AND;
    tp->rval->width=32;
    tp->rval->lval=np->rval->lval;
    np->rval->lval=0;
    tp->rval->rval=np->rval->rval;
    np->rval->rval=0;
    nodefree(np->lval); nodefree(np->rval);
    tempw=np->width; *np=*tp; np->width=tempw; free(tp);
  } while(0);

  checknodeactbits(np);
  if(np->opcode==MINGLE &&
     np->lval->opcode==SELECT &&
     (np->lval->rval->opcode==MESH || np->lval->rval->opcode==MESH32) &&
     np->lval->rval->constant==2863311530LU)
  do
  {
    x2=np->rval->constant; c2=np->rval->optdata;
    x1=np->lval->lval->constant; c1=np->lval->lval->optdata;
    OPTING(selectmingle1);
    tp=newnode();
    MAYBENEWNODE(tp);
    tp->opcode=C_OR;
    tp->width=32;
    MAYBENEWNODE(tp->lval);
    tp->lval->opcode=C_AND;
    tp->lval->width=32;
    tp->lval->lval=np->lval->lval;
    np->lval->lval=0;
    MAYBENEWNODE(tp->lval->rval);
    tp->lval->rval->opcode=MESH32;
    tp->lval->rval->width=32;
    tp->lval->rval->constant=(2863311530LU);
    MAYBENEWNODE(tp->rval);
    tp->rval->opcode=MINGLE;
    tp->rval->width=32;
    MAYBENEWNODE(tp->rval->lval);
    tp->rval->lval->opcode=MESH32;
    tp->rval->lval->width=32;
    tp->rval->lval->constant=(0LU);
    tp->rval->rval=np->rval;
    np->rval=0;
    nodefree(np->lval); nodefree(np->rval);
    tempw=np->width; *np=*tp; np->width=tempw; free(tp);
  } while(0);

  checknodeactbits(np);
  if(np->opcode==MINGLE &&
     np->rval->opcode==SELECT &&
     (np->rval->rval->opcode==MESH || np->rval->rval->opcode==MESH32) &&
     np->rval->rval->constant==1431655765LU)
  do
  {
    x2=np->rval->lval->constant; c2=np->rval->lval->optdata;
    x1=np->lval->constant; c1=np->lval->optdata;
    OPTING(selectmingle2);
    tp=newnode();
    MAYBENEWNODE(tp);
    tp->opcode=C_OR;
    tp->width=32;
    MAYBENEWNODE(tp->lval);
    tp->lval->opcode=MINGLE;
    tp->lval->width=32;
    tp->lval->lval=np->lval;
    np->lval=0;
    MAYBENEWNODE(tp->lval->rval);
    tp->lval->rval->opcode=MESH32;
    tp->lval->rval->width=32;
    tp->lval->rval->constant=(0LU);
    MAYBENEWNODE(tp->rval);
    tp->rval->opcode=C_AND;
    tp->rval->width=32;
    tp->rval->lval=np->rval->lval;
    np->rval->lval=0;
    MAYBENEWNODE(tp->rval->rval);
    tp->rval->rval->opcode=MESH32;
    tp->rval->rval->width=32;
    tp->rval->rval->constant=(1431655765LU);
    nodefree(np->lval); nodefree(np->rval);
    tempw=np->width; *np=*tp; np->width=tempw; free(tp);
  } while(0);

  checknodeactbits(np);
  if(np->opcode==MINGLE &&
     np->lval->opcode==SELECT &&
     (np->lval->rval->opcode==MESH || np->lval->rval->opcode==MESH32) &&
     np->lval->rval->constant==1431655765LU)
  do
  {
    x2=np->rval->constant; c2=np->rval->optdata;
    x1=np->lval->lval->constant; c1=np->lval->lval->optdata;
    OPTING(selectmingle3);
    tp=newnode();
    MAYBENEWNODE(tp);
    tp->opcode=C_OR;
    tp->width=32;
    MAYBENEWNODE(tp->lval);
    tp->lval->opcode=C_LSHIFTBY;
    tp->lval->width=32;
    MAYBENEWNODE(tp->lval->lval);
    tp->lval->lval->opcode=C_AND;
    tp->lval->lval->width=32;
    tp->lval->lval->lval=np->lval->lval;
    np->lval->lval=0;
    MAYBENEWNODE(tp->lval->lval->rval);
    tp->lval->lval->rval->opcode=MESH32;
    tp->lval->lval->rval->width=32;
    tp->lval->lval->rval->constant=(1431655765LU);
    MAYBENEWNODE(tp->lval->rval);
    tp->lval->rval->opcode=MESH32;
    tp->lval->rval->width=32;
    tp->lval->rval->constant=(1LU);
    MAYBENEWNODE(tp->rval);
    tp->rval->opcode=MINGLE;
    tp->rval->width=32;
    MAYBENEWNODE(tp->rval->lval);
    tp->rval->lval->opcode=MESH32;
    tp->rval->lval->width=32;
    tp->rval->lval->constant=(0LU);
    tp->rval->rval=np->rval;
    np->rval=0;
    nodefree(np->lval); nodefree(np->rval);
    tempw=np->width; *np=*tp; np->width=tempw; free(tp);
  } while(0);

  checknodeactbits(np);
  if(np->opcode==MINGLE &&
     np->rval->opcode==SELECT &&
     (np->rval->rval->opcode==MESH || np->rval->rval->opcode==MESH32) &&
     np->rval->rval->constant==2863311530LU)
  do
  {
    x2=np->rval->lval->constant; c2=np->rval->lval->optdata;
    x1=np->lval->constant; c1=np->lval->optdata;
    OPTING(selectmingle4);
    tp=newnode();
    MAYBENEWNODE(tp);
    tp->opcode=C_OR;
    tp->width=32;
    MAYBENEWNODE(tp->lval);
    tp->lval->opcode=C_RSHIFTBY;
    tp->lval->width=32;
    MAYBENEWNODE(tp->lval->lval);
    tp->lval->lval->opcode=C_AND;
    tp->lval->lval->width=32;
    tp->lval->lval->lval=np->rval->lval;
    np->rval->lval=0;
    MAYBENEWNODE(tp->lval->lval->rval);
    tp->lval->lval->rval->opcode=MESH32;
    tp->lval->lval->rval->width=32;
    tp->lval->lval->rval->constant=(2863311530LU);
    MAYBENEWNODE(tp->lval->rval);
    tp->lval->rval->opcode=MESH32;
    tp->lval->rval->width=32;
    tp->lval->rval->constant=(1LU);
    MAYBENEWNODE(tp->rval);
    tp->rval->opcode=MINGLE;
    tp->rval->width=32;
    tp->rval->lval=np->lval;
    np->lval=0;
    MAYBENEWNODE(tp->rval->rval);
    tp->rval->rval->opcode=MESH32;
    tp->rval->rval->width=32;
    tp->rval->rval->constant=(0LU);
    nodefree(np->lval); nodefree(np->rval);
    tempw=np->width; *np=*tp; np->width=tempw; free(tp);
  } while(0);

  checknodeactbits(np);
  if(np->opcode==SELECT &&
     np->lval->opcode==MINGLE &&
     (np->rval->opcode==MESH || np->rval->opcode==MESH32) &&
     np->rval->constant==3579139412LU)
  do
  {
    x2=np->lval->rval->constant; c2=np->lval->rval->optdata;
    x1=np->lval->lval->constant; c1=np->lval->lval->optdata;
    x=x1; c=c1; if(!(!(c&4294901760UL))) break;
    x=x2; c=c2; if(!(!(c&4294901760UL))) break;
    OPTING(selectmingle5);
    tp=newnode();
    MAYBENEWNODE(tp);
    tp->opcode=C_OR;
    tp->width=32;
    MAYBENEWNODE(tp->lval);
    tp->lval->opcode=C_AND;
    tp->lval->width=32;
    tp->lval->lval=np->lval->lval;
    np->lval->lval=0;
    MAYBENEWNODE(tp->lval->rval);
    tp->lval->rval->opcode=MESH32;
    tp->lval->rval->width=32;
    tp->lval->rval->constant=(32768LU);
    MAYBENEWNODE(tp->rval);
    tp->rval->opcode=C_RSHIFTBY;
    tp->rval->width=32;
    tp->rval->lval=np->lval->rval;
    np->lval->rval=0;
    MAYBENEWNODE(tp->rval->rval);
    tp->rval->rval->opcode=MESH32;
    tp->rval->rval->width=32;
    tp->rval->rval->constant=(1LU);
    nodefree(np->lval); nodefree(np->rval);
    tempw=np->width; *np=*tp; np->width=tempw; free(tp);
  } while(0);

  checknodeactbits(np);
  if(np->opcode==C_AND &&
     np->lval->opcode==OR &&
     np->lval->width==16 &&
     (np->rval->opcode==MESH || np->rval->opcode==MESH32) &&
     np->rval->constant==32768LU)
  do
  {
    x1=np->lval->rval->constant; c1=np->lval->rval->optdata;
    x=x1; c=c1; if(!(!(c&4294934528UL))) break;
    OPTING(or16and);
    tp=newnode();
    MAYBENEWNODE(tp);
    tp->opcode=C_LSHIFTBY;
    tp->width=32;
    MAYBENEWNODE(tp->lval);
    tp->lval->opcode=C_AND;
    tp->lval->width=32;
    tp->lval->lval=np->lval->rval;
    np->lval->rval=0;
    MAYBENEWNODE(tp->lval->rval);
    tp->lval->rval->opcode=MESH32;
    tp->lval->rval->width=32;
    tp->lval->rval->constant=(1LU);
    MAYBENEWNODE(tp->rval);
    tp->rval->opcode=MESH32;
    tp->rval->width=32;
    tp->rval->constant=(15LU);
    nodefree(np->lval); nodefree(np->rval);
    tempw=np->width; *np=*tp; np->width=tempw; free(tp);
  } while(0);

  checknodeactbits(np);
  if(np->opcode==C_AND &&
     np->lval->opcode==XOR &&
     np->lval->width==16 &&
     (np->rval->opcode==MESH || np->rval->opcode==MESH32) &&
     np->rval->constant==32768LU)
  do
  {
    x1=np->lval->rval->constant; c1=np->lval->rval->optdata;
    x=x1; c=c1; if(!(!(c&4294934528UL))) break;
    OPTING(xor16and);
    tp=newnode();
    MAYBENEWNODE(tp);
    tp->opcode=C_LSHIFTBY;
    tp->width=32;
    MAYBENEWNODE(tp->lval);
    tp->lval->opcode=C_AND;
    tp->lval->width=32;
    tp->lval->lval=np->lval->rval;
    np->lval->rval=0;
    MAYBENEWNODE(tp->lval->rval);
    tp->lval->rval->opcode=MESH32;
    tp->lval->rval->width=32;
    tp->lval->rval->constant=(1LU);
    MAYBENEWNODE(tp->rval);
    tp->rval->opcode=MESH32;
    tp->rval->width=32;
    tp->rval->constant=(15LU);
    nodefree(np->lval); nodefree(np->rval);
    tempw=np->width; *np=*tp; np->width=tempw; free(tp);
  } while(0);

  checknodeactbits(np);
  if(np->opcode==MINGLE &&
     (np->lval->opcode==MESH || np->lval->opcode==MESH32) &&
     np->lval->constant==0LU &&
     np->rval->opcode==C_LSHIFTBY &&
     np->rval->lval->opcode==SELECT &&
     (np->rval->lval->rval->opcode==MESH || np->rval->lval->rval->opcode==MESH32) &&
     np->rval->lval->rval->constant==715827882LU &&
     (np->rval->rval->opcode==MESH || np->rval->rval->opcode==MESH32) &&
     np->rval->rval->constant==1LU)
  do
  {
    x1=np->rval->lval->lval->constant; c1=np->rval->lval->lval->optdata;
    OPTING(lshift32half);
    tp=newnode();
    MAYBENEWNODE(tp);
    tp->opcode=C_LSHIFTBY;
    tp->width=32;
    MAYBENEWNODE(tp->lval);
    tp->lval->opcode=C_AND;
    tp->lval->width=32;
    tp->lval->lval=np->rval->lval->lval;
    np->rval->lval->lval=0;
    MAYBENEWNODE(tp->lval->rval);
    tp->lval->rval->opcode=MESH32;
    tp->lval->rval->width=32;
    tp->lval->rval->constant=(715827882LU);
    MAYBENEWNODE(tp->rval);
    tp->rval->opcode=MESH32;
    tp->rval->width=32;
    tp->rval->constant=(1LU);
    nodefree(np->lval); nodefree(np->rval);
    tempw=np->width; *np=*tp; np->width=tempw; free(tp);
  } while(0);

  r=1LU; while(r<=31LU) {
  checknodeactbits(np);
  if(np->opcode==SELECT &&
     (np->rval->opcode==MESH || np->rval->opcode==MESH32))
  do
  {
    x2=np->rval->constant; c2=np->rval->optdata;
    x1=np->lval->constant; c1=np->lval->optdata;
    x=x2; c=c2; if(!(xselx(x)<<r==x&&x)) break;
    OPTING(rshift);
    tp=newnode();
    MAYBENEWNODE(tp);
    tp->opcode=C_RSHIFTBY;
    tp->width=32;
    MAYBENEWNODE(tp->lval);
    tp->lval->opcode=C_AND;
    tp->lval->width=32;
    tp->lval->lval=np->lval;
    np->lval=0;
    tp->lval->rval=np->rval;
    np->rval=0;
    MAYBENEWNODE(tp->rval);
    tp->rval->opcode=MESH32;
    tp->rval->width=32;
    tp->rval->constant=(r);
    nodefree(np->lval); nodefree(np->rval);
    tempw=np->width; *np=*tp; np->width=tempw; free(tp);
  } while(0);

  r++;
  }
  r=0LU; while(r<=14LU) {
  checknodeactbits(np);
  if(np->opcode==SELECT &&
     np->lval->opcode==MINGLE &&
     (np->lval->rval->opcode==MESH || np->lval->rval->opcode==MESH32) &&
     (np->rval->opcode==MESH || np->rval->opcode==MESH32))
  do
  {
    x3=np->rval->constant; c3=np->rval->optdata;
    x2=np->lval->rval->constant; c2=np->lval->rval->optdata;
    x1=np->lval->lval->constant; c1=np->lval->lval->optdata;
    x=x1; c=c1; if(!(c<=65535&&!(c&((1LU<<r)-1LU)))) break;
    x=x2; c=c2; if(!(!(x&(4294967294LU<<r)))) break;
    x=x3; c=c3; if(!(!(x&(1431655765LU<<(r*2+2))))) break;
    OPTING(lshift16);
    tp=newnode();
    MAYBENEWNODE(tp);
    tp->opcode=C_OR;
    tp->width=32;
    MAYBENEWNODE(tp->lval);
    tp->lval->opcode=C_LSHIFTBY;
    tp->lval->width=32;
    MAYBENEWNODE(tp->lval->lval);
    tp->lval->lval->opcode=SELECT;
    tp->lval->lval->width=32;
    MAYBENEWNODE(tp->lval->lval->lval);
    tp->lval->lval->lval->opcode=C_RSHIFTBY;
    tp->lval->lval->lval->width=32;
    tp->lval->lval->lval->lval=np->lval->lval;
    np->lval->lval=0;
    MAYBENEWNODE(tp->lval->lval->lval->rval);
    tp->lval->lval->lval->rval->opcode=MESH32;
    tp->lval->lval->lval->rval->width=32;
    tp->lval->lval->lval->rval->constant=(r);
    MAYBENEWNODE(tp->lval->lval->rval);
    tp->lval->lval->rval->opcode=MESH32;
    tp->lval->lval->rval->width=32;
    tp->lval->lval->rval->constant=(iselect(x3>>(r*2+1),1431655765LU));
    MAYBENEWNODE(tp->lval->rval);
    tp->lval->rval->opcode=MESH32;
    tp->lval->rval->width=32;
    tp->lval->rval->constant=(setbitcount(x3&((2LU<<(r*2))-1)));
    MAYBENEWNODE(tp->rval);
    tp->rval->opcode=MESH32;
    tp->rval->width=32;
    tp->rval->constant=(iselect(mingle(0,x2),x3));
    nodefree(np->lval); nodefree(np->rval);
    tempw=np->width; *np=*tp; np->width=tempw; free(tp);
  } while(0);

  checknodeactbits(np);
  if(np->opcode==SELECT &&
     np->lval->opcode==MINGLE &&
     np->lval->lval->opcode==C_OR &&
     (np->lval->lval->rval->opcode==MESH || np->lval->lval->rval->opcode==MESH32) &&
     (np->lval->rval->opcode==MESH || np->lval->rval->opcode==MESH32) &&
     (np->rval->opcode==MESH || np->rval->opcode==MESH32))
  do
  {
    x4=np->lval->lval->rval->constant; c4=np->lval->lval->rval->optdata;
    x3=np->rval->constant; c3=np->rval->optdata;
    x2=np->lval->rval->constant; c2=np->lval->rval->optdata;
    x1=np->lval->lval->lval->constant; c1=np->lval->lval->lval->optdata;
    x=x1; c=c1; if(!(c<=65535&&!(c&((1LU<<r)-1LU)))) break;
    x=x4; c=c4; if(!(x<=65535&&!(c&~((1LU<<r)-1LU)))) break;
    x=x2; c=c2; if(!(!(x&(4294967294LU<<r)))) break;
    x=x3; c=c3; if(!(!(x&(1431655765LU<<(r*2+2))))) break;
    OPTING(lshift16);
    tp=newnode();
    MAYBENEWNODE(tp);
    tp->opcode=C_OR;
    tp->width=32;
    MAYBENEWNODE(tp->lval);
    tp->lval->opcode=C_LSHIFTBY;
    tp->lval->width=32;
    MAYBENEWNODE(tp->lval->lval);
    tp->lval->lval->opcode=SELECT;
    tp->lval->lval->width=32;
    MAYBENEWNODE(tp->lval->lval->lval);
    tp->lval->lval->lval->opcode=C_RSHIFTBY;
    tp->lval->lval->lval->width=32;
    tp->lval->lval->lval->lval=np->lval->lval->lval;
    np->lval->lval->lval=0;
    MAYBENEWNODE(tp->lval->lval->lval->rval);
    tp->lval->lval->lval->rval->opcode=MESH32;
    tp->lval->lval->lval->rval->width=32;
    tp->lval->lval->lval->rval->constant=(r);
    MAYBENEWNODE(tp->lval->lval->rval);
    tp->lval->lval->rval->opcode=MESH32;
    tp->lval->lval->rval->width=32;
    tp->lval->lval->rval->constant=(iselect(x3>>(r*2+1),1431655765LU));
    MAYBENEWNODE(tp->lval->rval);
    tp->lval->rval->opcode=MESH32;
    tp->lval->rval->width=32;
    tp->lval->rval->constant=(setbitcount(x3&((2LU<<(r*2))-1)));
    MAYBENEWNODE(tp->rval);
    tp->rval->opcode=MESH32;
    tp->rval->width=32;
    tp->rval->constant=(iselect(mingle(x4,x2),x3));
    nodefree(np->lval); nodefree(np->rval);
    tempw=np->width; *np=*tp; np->width=tempw; free(tp);
  } while(0);

  checknodeactbits(np);
  if(np->opcode==SELECT &&
     np->lval->opcode==MINGLE &&
     np->lval->lval->opcode==C_OR &&
     (np->lval->lval->lval->opcode==MESH || np->lval->lval->lval->opcode==MESH32) &&
     (np->lval->rval->opcode==MESH || np->lval->rval->opcode==MESH32) &&
     (np->rval->opcode==MESH || np->rval->opcode==MESH32))
  do
  {
    x4=np->lval->lval->lval->constant; c4=np->lval->lval->lval->optdata;
    x3=np->rval->constant; c3=np->rval->optdata;
    x2=np->lval->rval->constant; c2=np->lval->rval->optdata;
    x1=np->lval->lval->rval->constant; c1=np->lval->lval->rval->optdata;
    x=x4; c=c4; if(!(x<=65535&&!(c&~((1LU<<r)-1LU)))) break;
    x=x1; c=c1; if(!(c<=65535&&!(c&((1LU<<r)-1LU)))) break;
    x=x2; c=c2; if(!(!(x&(4294967294LU<<r)))) break;
    x=x3; c=c3; if(!(!(x&(1431655765LU<<(r*2+2))))) break;
    OPTING(lshift16);
    tp=newnode();
    MAYBENEWNODE(tp);
    tp->opcode=C_OR;
    tp->width=32;
    MAYBENEWNODE(tp->lval);
    tp->lval->opcode=C_LSHIFTBY;
    tp->lval->width=32;
    MAYBENEWNODE(tp->lval->lval);
    tp->lval->lval->opcode=SELECT;
    tp->lval->lval->width=32;
    MAYBENEWNODE(tp->lval->lval->lval);
    tp->lval->lval->lval->opcode=C_RSHIFTBY;
    tp->lval->lval->lval->width=32;
    tp->lval->lval->lval->lval=np->lval->lval->rval;
    np->lval->lval->rval=0;
    MAYBENEWNODE(tp->lval->lval->lval->rval);
    tp->lval->lval->lval->rval->opcode=MESH32;
    tp->lval->lval->lval->rval->width=32;
    tp->lval->lval->lval->rval->constant=(r);
    MAYBENEWNODE(tp->lval->lval->rval);
    tp->lval->lval->rval->opcode=MESH32;
    tp->lval->lval->rval->width=32;
    tp->lval->lval->rval->constant=(iselect(x3>>(r*2+1),1431655765LU));
    MAYBENEWNODE(tp->lval->rval);
    tp->lval->rval->opcode=MESH32;
    tp->lval->rval->width=32;
    tp->lval->rval->constant=(setbitcount(x3&((2LU<<(r*2))-1)));
    MAYBENEWNODE(tp->rval);
    tp->rval->opcode=MESH32;
    tp->rval->width=32;
    tp->rval->constant=(iselect(mingle(x4,x2),x3));
    nodefree(np->lval); nodefree(np->rval);
    tempw=np->width; *np=*tp; np->width=tempw; free(tp);
  } while(0);

  r++;
  }
  c=c1=c2=c3=c4=c5=c6=c7=c8=c9=0;
  x=x1=x2=x3=x4=x5=x6=x7=x8=x9=r=0;
  if(c+c1+c2+c3+c4+c5+c6+c7+c8+c9+r+
     x+x1+x2+x3+x4+x5+x6+x7+x8+x9) raise(SIGSEGV);
  return opted;
}