typedef unsigned char uint8_t;
#define bGrow(from) ((unsigned)(((from)*1.2)+(3<<2>>1)))
typedef signed int32_t;
#define break(x) {x;break;}
#define bMin(a,b) (((a)<(b))?(a):(b))
#define UINT32_MAX 4294967295
#define bCollate(l,r) ((l)<(r)?-1:(l)>(r)?1:0)
#define bMax(a,b) (((a)>(b))?(a):(b))
typedef unsigned uint32_t;
typedef struct bColor{uint8_t r,g,b,a;}bColor;
typedef struct bString{unsigned size,capacity;unsigned char* data;}bString;
int bStringReplaceC(bString *bs,char *from,char *to);
bColor bColorFromRGB(uint8_t r,uint8_t g,uint8_t b);
bString bStringFrom(char *c,unsigned len);
void bStringFree(bString *bs);
bColor bColorFromSVG(char *color){
 bString bs=bStringFrom(color,0);
 bColor ret={.a=255};
 if(bs.size==0)return ret;
 unsigned num=0,next=0,i,j=24,x1,x2;
 uint32_t clr[]={4176505121,4285342207,1847818912,619114746,32828,16738084,425993727,1847947289,637206517
  ,3789881203,3674169639,3446810553,1680359301,672351627,1621423214,2147492137,2959419776,1730797252,
  697335920,2424336487,4126503721,4278200821,908787711,707972506,16776960,2289510701,1999187353,707631496
  ,769720319,2431553590,3635241517,4200869350,1731056378,768857043,3553874791,3070193709,1713647297,
  1680845517,790859371,8421376,1174368816,4278202368,909181093,825412914,16711680,25394,4285411840,
  976473579,871262331,3439329378,1438281523,2473604051,1949555568,869060936,2232797046,4293946932,
  4285805808,741717097,905310463,4209436160,4289538614,13871,557252736,930780905,2411499374,2163239992,
  3766040704,1866072063,972749567,1468739072,1516896314,3161668813,2034012047,1038182721,760389733,
  3233836093,4284563136,2034150878,1635778560,3573514020,3959058017,4034552279,6422527,1660944128,
  707437884,4126500194,4285096668,1969407204,1653061854,3794504310,98,3526648831,1029906025,1675426047,
  2694733665,2506384995,2137547757,1818427647,1666220031,1008000114,4278221155,3664078079,1768169637,
  1684629865,1768515945,2417913700,4278215935,912589015,1704524696,2867392100,4004476005,3681969646,
  1768330096,1713513138,4042981228,2334289766,4285883938,879230720,1744828664,3705461857,2155901543,
  2154981248,1634304128,1767660749,2181057383,3007082089,7367025,1986632442,1810956287,2332068644,
  1328490859,791243599,795561807,1798269781,9240368,1677735531,1211788032,1651215165,1804271616,
  2341142627,2260231275,2842127115,1735109033,1806281129,2363945064,3082644331,2574216043,1919667250,
  1795162251,3519938676,9729643,2272881619,1634532046,1812003964,3455778661,3841945453,536899253,
  1819257522,1877407229,3597720178,4026491248,4285100245,1819331520,1893572829,3873484911,352284784,
  7565459,1970339775,1920991360,65381,2163876211,1177121650,1702081666,1945040383,3956180843,4278218867,
  3529602175,1752468660,1960361944,1197735791,3762320756,3999889104,1752690306,11788021};
 uint8_t pass1[]="darligmedslalavyelreeaqudeeoraornpaleagumsgololindiluehtswhinde",c[4]={0},r[2]={0};
 uint8_t p2[]="allolimamingpesate\"w#mblhtiuve&e+e,a.mhoergnks-csn)bnarosi;v",*b=(uint8_t*)&clr,*d;
 for(i=0;i<63;i+=3)c[0]=pass1[i],c[1]=pass1[i+1],c[2]=pass1[i+2],bStringReplaceC(&bs,c,"");d=bs.data;
 for(i=0,j='!',c[2]=0;i<'<';j++,i+=2)c[0]=p2[i],c[1]=p2[i+1],r[0]=(char)j,bStringReplaceC(&bs,c,r);
 for(i=0;i<735;i+=5)if(b[i]==d[0]&&b[i+1]==d[1])break(ret=bColorFromRGB(b[i+2],b[i+3],b[i+4]));
 bStringFree(&bs);
 return ret;
}
void *realloc(void *memory,size_t size);
void *memset(void *dest,int val,size_t size);
size_t strlen(const char *str);
void *memmove(void *dest,const void *src,size_t size);
void *memcpy(void *dest,const void *src,size_t size);
void free(void *memory);
#define bAddU32Ovflo(a,b) ((a)>UINT32_MAX-(b))
#define ARRAY_EXTRA 3
int bStringSetCapacity(bString *bs,unsigned capacity){
 void *r=bAddU32Ovflo(capacity,ARRAY_EXTRA)?0:realloc(bs->data,(bs->capacity=capacity)+ARRAY_EXTRA);
 return r?(memset((bs->data=(uint8_t*)r)+(bs->size),0,ARRAY_EXTRA)!=0):(bs->capacity=(unsigned)-2,0);
}
unsigned bStrlen(char *str){return str?(unsigned)strlen(str):0;}
bString bStringFrom(char *c,unsigned len){
 bString bs={0};
 bStringSetCapacity(&bs,len||!c?len:(len=(unsigned)bStrlen(c)));
 if(bs.capacity!=(unsigned)-2){
  if(c&&(bs.data&&len>0)&&bs.capacity>=len)memcpy(bs.data,c,len);
  if(len>0&&c)memset(bs.data+(bs.size=len),0,ARRAY_EXTRA);
 }
 return bs;
}
void bStringFree(bString *bs){
 if(bs->capacity!=(unsigned)-1)free(bs->data);
 memset(bs,0,sizeof(*bs));
}
#define bDECLARE_ARRAY(name,type)\
 typedef struct name{unsigned size,capacity;type *data;}name;\
 void name##Free(name *array);\
 void name##SetCapacity(name *array,unsigned capacity);\
 void name##Reserve(name *array,unsigned capacity);\
 void name##Add(name *array,type value);\
 void name##Insert(name *array,type value,unsigned index,unsigned amount);\
 void name##Remove(name *array,unsigned index,unsigned amount);\
 unsigned name##Find(name array,type value);\
 unsigned name##FindLowerBound(name array,type value);
#define bDEFINE_ARRAY(name,type,freefunc,collator)\
 void name##Free(name *array){\
  for(unsigned i=0;i<array->size;i++)freefunc(array->data+i);\
  free(array->data);\
  memset(array,0,sizeof(*array));\
 }\
 void name##SetCapacity(name *array,unsigned capacity){\
  void *r=realloc(array->data,(((array->capacity=capacity)+ARRAY_EXTRA)*sizeof(type)));\
  if(r)array->data=r;\
  else array->capacity=(unsigned)-2;\
 }\
 void name##Reserve(name *array,unsigned capacity){\
  if(capacity>array->capacity)name##SetCapacity(array,bGrow(capacity));\
 }\
 void name##Add(name *array,type value){\
  name##Reserve(array,array->size+1);\
  if(array->capacity!=(unsigned)-2)array->data[array->size++]=value;\
 }
void bFreeDefault(void *v){}
int bCollateUint32(uint32_t *l,uint32_t *r){return bCollate(*l,*r);}
bDECLARE_ARRAY(bArrayUint,uint32_t);
bDEFINE_ARRAY(bArrayUint,uint32_t,bFreeDefault,bCollateUint32);
const uint8_t bUpperToLower[256]={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,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61
 ,62,63,64,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,
 121,122,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,
 117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,
 143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,
 169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,
 195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,
 221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,
 247,248,249,250,251,252,253,254,255};
#define bLower(x) (bUpperToLower[(unsigned char)(x)])
#if defined _MSC_VER
typedef __unaligned uint32_t bUnaligned32;
#else
typedef uint32_t bUnaligned32 __attribute__((aligned(1),may_alias));
#endif
unsigned bStringFindChar(bString bs,char c,unsigned from,int ignoreCase,int reverse){
 if(ignoreCase)c=bLower(c);
 if(reverse){
  for(unsigned i=bMin(from,bs.size-1);i<bs.size;i--)
   if((ignoreCase?(bLower(bs.data[i])):(bs.data[i]))==c)return i;
  return (unsigned)-1;
 }
 unsigned ret=(unsigned)-1;
 if(ignoreCase){
  for(unsigned i=from,s;i<bs.size&&ret==-1;i+=4){
   s=*((bUnaligned32*)((char*)bs.data+i));
   if(bLower(((s&255)))==c)ret=i;
   else if(bLower(((s&65280)>>8))==c)ret=i+1;
   else if(bLower(((s&16711680)>>16))==c)ret=i+2;
   else if(bLower(((s&4278190080)>>24))==c)ret=i+3;
  }
 }else{
  for(unsigned i=from,s,cc=(unsigned)c;i<bs.size&&ret==-1;i+=4){
   s=*((bUnaligned32*)((char*)bs.data+i));
   if(((s&255))==cc)ret=i;
   else if(((s&65280)>>8)==cc)ret=i+1;
   else if(((s&16711680)>>16)==cc)ret=i+2;
   else if(((s&4278190080)>>24)==cc)ret=i+3;
  }
 }
 return ret<bs.size?ret:(unsigned)-1;
}
bString bStringStatic(char *c,unsigned len){
 return (bString){len==0?bStrlen(c):len,(unsigned)-1,(unsigned char*)c};
}
int bCollateStringAscii(bString *l,bString *r){
 for(unsigned c,i=0,j=0;i<l->size&&j<r->size;i++,j++)if((c=(l->data[i]-r->data[j]))!=0)return c;
 return l->size<r->size?-1:l->size>r->size?1:0;
}
int bCollateStringFast(bString *l,bString *r){
 int coll=bCollateUint32(&l->size,&r->size);
 return coll==0?bCollateStringAscii(l,r):coll;
}
unsigned lower32(uint32_t c){
 union {uint32_t u;char ch[4];}u={.u=c};
 for(unsigned i=0;i<4;i++)u.ch[i]=bLower(u.ch[i]);
 return u.u;
}
typedef unsigned short uint16_t;
unsigned bStringFind(bString bs,bString find,unsigned from,int ignoreCase){
 if(bs.size==0||from+find.size>bs.size)return (unsigned)-1;
 if(find.size==1)return bStringFindChar(bs,find.data[0],from,ignoreCase,0);
 if(find.size==2||find.size==3){
  uint16_t s=ignoreCase?((bLower(find.data[0]))|((bLower(find.data[1]))<<8))
   :(find.data[0]|find.data[1]<<8);
  for(unsigned i=from,n=(unsigned)-1,p;i<bs.size;i+=3){
   bUnaligned32 t=*(bUnaligned32*)((char*)bs.data+i);
   if(ignoreCase)t=lower32(t);
   if((t&65535)==s)p=0;
   else if(((t&16776960)>>8)==s)p=1;
   else if(((t&4294967040)>>16)==s)p=2;
   else continue;
   if(find.size==2)return (i+p+find.size)<=bs.size?(i+p):n;
   else if(ignoreCase&&(bLower(find.data[2])==bLower(bs.data[i+p+2])))return (i+p+2<bs.size)?i:n;
   else if(find.data[2]==bs.data[i+p+2])return (i+p+2<bs.size)?i+p:n;
  }
 }else if(find.size<7){
  unsigned s=*(bUnaligned32*)find.data;
  if(ignoreCase)s=lower32(s);
  for(unsigned i=from;i<bs.size;){
   bUnaligned32 t=*(bUnaligned32*)((char*)bs.data+i);
   if(ignoreCase)t=lower32(t);
   if(s==t){
    if(find.size==4)return i;
    bString st0=bStringStatic(find.data+4,find.size-4),st1=bStringStatic((char*)bs.data+i+4,st0.size);
    if(bCollateStringFast(&st0,&st1)==0)return i;
    else i++;
    continue;
   }
   if((t>>8)==(s&16777215))i+=1;
   else if((t>>16)==(s&65535))i+=2;
   else if((t>>24)==(s&255))i+=3;
   else i+=4;
  }
 }else{
  unsigned skip[256],i,j=find.size;
  for(i=0;i<256;i++)skip[i]=(unsigned)-1;
  if(ignoreCase){
   for(i=0;i<find.size;i++)skip[bLower(find.data[i])]=i;
   for(i=from;i<(bs.size-j+1);j=find.size){
    while((j>0)&&(bLower(find.data[j-1])==bLower(bs.data[i+j-1])))j--;
    if(j==0)return i;
    else i+=bMax(1,(int32_t)((j-1)-skip[bLower(bs.data[i+(j-1)])]));
   }
  }else{
   for(i=0;i<find.size;i++)skip[find.data[i]]=i;
   for(i=from;i<(bs.size-j+1);j=find.size){
    while((j>0)&&(find.data[j-1]==bs.data[i+j-1]))j--;
    if(j==0)return i;
    else i+=bMax(1,(int32_t)((j-1)-skip[bs.data[i+(j-1)]]));
   }
  }
 }
 return (unsigned)-1;
}
int bStringReplace(bString *bs,bString from,bString to){
 bArrayUint r={0};
 for(unsigned pos=0;pos<bs->size;)
  if((pos=bStringFind(*bs,from,pos,0))<bs->size)bArrayUintAdd(&r,pos),pos+=from.size;
 if(r.size==0)return bArrayUintFree(&r),0;
 if(to.size>from.size){
  unsigned oldsz=bs->size;
  bStringSetCapacity(bs,(bs->size=bs->size+(r.size*(to.size-from.size))));
  memset(bs->data+bs->size,0,ARRAY_EXTRA);
  for(unsigned i=r.size-1,o=0,f=from.size,t=to.size;i<r.size;i--,o+=(t-f)){
   memmove(bs->data+(r.data[i]+o+t),bs->data+(r.data[i]+o+f),oldsz-(r.data[i]+f));
   memcpy(bs->data+(r.data[i]+o),to.data,t);
  }
 }else if(to.size<from.size){
  if(bs->size-(r.size*(from.size-to.size))==0)bStringFree(bs);
  else{
   for(unsigned i=0,f=from.size,t=to.size,offs=0;i<r.size;i++,offs+=(f-t),bs->size-=(f-t)){
    memcpy(bs->data+(r.data[i]-offs),to.data,t);
    memmove(bs->data+(r.data[i]-offs+t),bs->data+(r.data[i]-offs+f),bs->size-(r.data[i]-offs+f));
   }
   memset(bs->data+bs->size,0,ARRAY_EXTRA);
  }
 }else if(to.size==from.size)for(unsigned i=0;i<r.size;i++)memcpy(bs->data+r.data[i],to.data,to.size);
 bArrayUintFree(&r);
 return 0;
}
int bStringReplaceC(bString *bs,char *from,char *to){
 bString f=bStringFrom(from,0),t=bStringFrom(to,0);
 int ret=bStringReplace(bs,f,t);
 bStringFree(&t),bStringFree(&f);
 return ret;
}
bColor bColorFromRGBA(uint8_t r,uint8_t g,uint8_t b,uint8_t a){return (bColor){.r=r,.g=g,.b=b,.a=a};}
bColor bColorFromRGB(uint8_t r,uint8_t g,uint8_t b){return bColorFromRGBA(r,g,b,255);}