#include 
#include "units.h"
#include "test.h"
// 1 ----------------------------------------------------------------
UnsignedChar temp_UnsignedChar[25];
int UnsignedChar_index=0;
// 2 ----------------------------------------------------------------
Char temp_Char[25];
int Char_index=0;
// 3 ----------------------------------------------------------------
UnsignedShort temp_UnsignedShort[25];
int UnsignedShort_index=0;
// 4 ----------------------------------------------------------------
Short temp_Short[25];
int Short_index=0;
// 5 ----------------------------------------------------------------
UnsignedInt temp_UnsignedInt[25];
int UnsignedInt_index=0;
// 6 ----------------------------------------------------------------
Int temp_Int[25];
int Int_index=0;
// 7 ----------------------------------------------------------------
UnsignedLong temp_UnsignedLong[25];
int UnsignedLong_index=0;
// 8 ----------------------------------------------------------------
Long temp_Long[25];
int Long_index=0;
// 11 ----------------------------------------------------------------
Float temp_Float[25];
int Float_index=0;
// 12 ----------------------------------------------------------------
Double temp_Double[25];
int Double_index=0;
// *********************************************************************************************************
// First class UnsignedChar constructor
// *********************************************************************************************************
UnsignedChar::UnsignedChar() {
  val=0;
  state=UNDEF;
  u.init();
}
// *********************************************************************************************************
// Second class UnsignedChar constructor
// *********************************************************************************************************
UnsignedChar::UnsignedChar(char* str) {
  val=0;
  state=UNDEF;
  u.init(str);
}
// *********************************************************************************************************
// First class UnsignedChar destructor
// *********************************************************************************************************
UnsignedChar::~UnsignedChar() {
  val=0;
  state=UNDEF;
  u.init();
}
// **********************************************************************************************************
UnsignedChar UnsignedChar::operator +   (UnsignedChar& r) { // 1a
  UnsignedChar num;
  num.val = (val + r.val);
  num.u = (u +   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedChar UnsignedChar::operator -   (UnsignedChar& r) { // 1a
  UnsignedChar num;
  num.val = (val - r.val);
  num.u = (u -   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedChar UnsignedChar::operator *   (UnsignedChar& r) { // 1a
  UnsignedChar num;
  num.val = (val * r.val);
  num.u = (u *   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedChar UnsignedChar::operator /   (UnsignedChar& r) { // 1a
  UnsignedChar num;
  num.val = (val / r.val);
  num.u = (u /   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedChar UnsignedChar::operator +=  (UnsignedChar& r) { // 1a
  UnsignedChar num;
  num.val = (val += r.val);
  num.u = (u +=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedChar UnsignedChar::operator -=  (UnsignedChar& r) { // 1a
  UnsignedChar num;
  num.val = (val -= r.val);
  num.u = (u -=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedChar UnsignedChar::operator *=  (UnsignedChar& r) { // 1a
  UnsignedChar num;
  num.val = (val *= r.val);
  num.u = (u *=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedChar UnsignedChar::operator /=  (UnsignedChar& r) { // 1a
  UnsignedChar num;
  num.val = (val /= r.val);
  num.u = (u /=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedChar operator +   (UnsignedChar& l , unsigned char& r) {   // 6a
  UnsignedChar num;
  num.val = (l.val + r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedChar operator +   (unsigned char& l , UnsignedChar& r) {   // 8a
  UnsignedChar num;
  num.val = (l + r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedChar operator -   (UnsignedChar& l , unsigned char& r) {   // 6a
  UnsignedChar num;
  num.val = (l.val - r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedChar operator -   (unsigned char& l , UnsignedChar& r) {   // 8a
  UnsignedChar num;
  num.val = (l - r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedChar operator *   (UnsignedChar& l , unsigned char& r) {   // 6a
  UnsignedChar num;
  num.val = (l.val * r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedChar operator *   (unsigned char& l , UnsignedChar& r) {   // 8a
  UnsignedChar num;
  num.val = (l * r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedChar operator /   (UnsignedChar& l , unsigned char& r) {   // 6a
  UnsignedChar num;
  num.val = (l.val / r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedChar operator /   (unsigned char& l , UnsignedChar& r) {   // 8a
  UnsignedChar num;
  num.val = (l / r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedChar operator +=  (UnsignedChar& l , unsigned char& r) {   // 6a
  UnsignedChar num;
  num.val = (unsigned char)(l.val += (unsigned char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedChar operator +=  (unsigned char& l , UnsignedChar& r) {   // 8a
  UnsignedChar num;
  num.val = (unsigned char)(l += (unsigned char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedChar operator -=  (UnsignedChar& l , unsigned char& r) {   // 6a
  UnsignedChar num;
  num.val = (unsigned char)(l.val -= (unsigned char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedChar operator -=  (unsigned char& l , UnsignedChar& r) {   // 8a
  UnsignedChar num;
  num.val = (unsigned char)(l -= (unsigned char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedChar operator *=  (UnsignedChar& l , unsigned char& r) {   // 6a
  UnsignedChar num;
  num.val = (unsigned char)(l.val *= (unsigned char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedChar operator *=  (unsigned char& l , UnsignedChar& r) {   // 8a
  UnsignedChar num;
  num.val = (unsigned char)(l *= (unsigned char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedChar operator /=  (UnsignedChar& l , unsigned char& r) {   // 6a
  UnsignedChar num;
  num.val = (unsigned char)(l.val /= (unsigned char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedChar operator /=  (unsigned char& l , UnsignedChar& r) {   // 8a
  UnsignedChar num;
  num.val = (unsigned char)(l /= (unsigned char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator +   (UnsignedChar& l , Char& r) { // 3a
  Char num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
Char operator -   (UnsignedChar& l , Char& r) { // 3a
  Char num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
Char operator *   (UnsignedChar& l , Char& r) { // 3a
  Char num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
Char operator /   (UnsignedChar& l , Char& r) { // 3a
  Char num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
Char operator +=  (UnsignedChar& l , Char& r) { // 3a
  Char num;
  num.val = (char)(l.val += (unsigned char)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
Char operator -=  (UnsignedChar& l , Char& r) { // 3a
  Char num;
  num.val = (char)(l.val -= (unsigned char)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
Char operator *=  (UnsignedChar& l , Char& r) { // 3a
  Char num;
  num.val = (char)(l.val *= (unsigned char)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
Char operator /=  (UnsignedChar& l , Char& r) { // 3a
  Char num;
  num.val = (char)(l.val /= (unsigned char)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
Char operator +   (UnsignedChar& l , char& r) {   // 6a
  Char num;
  num.val = ((char)l.val + r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator +   (unsigned char& l , Char& r) {   // 8a
  Char num;
  num.val = ((char)l + r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator -   (UnsignedChar& l , char& r) {   // 6a
  Char num;
  num.val = ((char)l.val - r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator -   (unsigned char& l , Char& r) {   // 8a
  Char num;
  num.val = ((char)l - r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator *   (UnsignedChar& l , char& r) {   // 6a
  Char num;
  num.val = ((char)l.val * r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator *   (unsigned char& l , Char& r) {   // 8a
  Char num;
  num.val = ((char)l * r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator /   (UnsignedChar& l , char& r) {   // 6a
  Char num;
  num.val = ((char)l.val / r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator /   (unsigned char& l , Char& r) {   // 8a
  Char num;
  num.val = ((char)l / r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator +=  (UnsignedChar& l , char& r) {   // 6a
  Char num;
  num.val = (char)(l.val += (unsigned char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator +=  (unsigned char& l , Char& r) {   // 8a
  Char num;
  num.val = (char)(l += (unsigned char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator -=  (UnsignedChar& l , char& r) {   // 6a
  Char num;
  num.val = (char)(l.val -= (unsigned char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator -=  (unsigned char& l , Char& r) {   // 8a
  Char num;
  num.val = (char)(l -= (unsigned char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator *=  (UnsignedChar& l , char& r) {   // 6a
  Char num;
  num.val = (char)(l.val *= (unsigned char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator *=  (unsigned char& l , Char& r) {   // 8a
  Char num;
  num.val = (char)(l *= (unsigned char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator /=  (UnsignedChar& l , char& r) {   // 6a
  Char num;
  num.val = (char)(l.val /= (unsigned char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator /=  (unsigned char& l , Char& r) {   // 8a
  Char num;
  num.val = (char)(l /= (unsigned char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator +   (UnsignedChar& l , UnsignedShort& r) { // 3a
  UnsignedShort num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator -   (UnsignedChar& l , UnsignedShort& r) { // 3a
  UnsignedShort num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator *   (UnsignedChar& l , UnsignedShort& r) { // 3a
  UnsignedShort num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator /   (UnsignedChar& l , UnsignedShort& r) { // 3a
  UnsignedShort num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator +=  (UnsignedChar& l , UnsignedShort& r) { // 3a
  UnsignedShort num;
  num.val = (unsigned short)(l.val += (unsigned char)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator -=  (UnsignedChar& l , UnsignedShort& r) { // 3a
  UnsignedShort num;
  num.val = (unsigned short)(l.val -= (unsigned char)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator *=  (UnsignedChar& l , UnsignedShort& r) { // 3a
  UnsignedShort num;
  num.val = (unsigned short)(l.val *= (unsigned char)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator /=  (UnsignedChar& l , UnsignedShort& r) { // 3a
  UnsignedShort num;
  num.val = (unsigned short)(l.val /= (unsigned char)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator +   (UnsignedChar& l , unsigned short& r) {   // 6a
  UnsignedShort num;
  num.val = ((unsigned short)l.val + r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator +   (unsigned char& l , UnsignedShort& r) {   // 8a
  UnsignedShort num;
  num.val = ((unsigned short)l + r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator -   (UnsignedChar& l , unsigned short& r) {   // 6a
  UnsignedShort num;
  num.val = ((unsigned short)l.val - r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator -   (unsigned char& l , UnsignedShort& r) {   // 8a
  UnsignedShort num;
  num.val = ((unsigned short)l - r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator *   (UnsignedChar& l , unsigned short& r) {   // 6a
  UnsignedShort num;
  num.val = ((unsigned short)l.val * r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator *   (unsigned char& l , UnsignedShort& r) {   // 8a
  UnsignedShort num;
  num.val = ((unsigned short)l * r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator /   (UnsignedChar& l , unsigned short& r) {   // 6a
  UnsignedShort num;
  num.val = ((unsigned short)l.val / r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator /   (unsigned char& l , UnsignedShort& r) {   // 8a
  UnsignedShort num;
  num.val = ((unsigned short)l / r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator +=  (UnsignedChar& l , unsigned short& r) {   // 6a
  UnsignedShort num;
  num.val = (unsigned short)(l.val += (unsigned char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator +=  (unsigned char& l , UnsignedShort& r) {   // 8a
  UnsignedShort num;
  num.val = (unsigned short)(l += (unsigned char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator -=  (UnsignedChar& l , unsigned short& r) {   // 6a
  UnsignedShort num;
  num.val = (unsigned short)(l.val -= (unsigned char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator -=  (unsigned char& l , UnsignedShort& r) {   // 8a
  UnsignedShort num;
  num.val = (unsigned short)(l -= (unsigned char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator *=  (UnsignedChar& l , unsigned short& r) {   // 6a
  UnsignedShort num;
  num.val = (unsigned short)(l.val *= (unsigned char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator *=  (unsigned char& l , UnsignedShort& r) {   // 8a
  UnsignedShort num;
  num.val = (unsigned short)(l *= (unsigned char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator /=  (UnsignedChar& l , unsigned short& r) {   // 6a
  UnsignedShort num;
  num.val = (unsigned short)(l.val /= (unsigned char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator /=  (unsigned char& l , UnsignedShort& r) {   // 8a
  UnsignedShort num;
  num.val = (unsigned short)(l /= (unsigned char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator +   (UnsignedChar& l , Short& r) { // 3a
  Short num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
Short operator -   (UnsignedChar& l , Short& r) { // 3a
  Short num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
Short operator *   (UnsignedChar& l , Short& r) { // 3a
  Short num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
Short operator /   (UnsignedChar& l , Short& r) { // 3a
  Short num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
Short operator +=  (UnsignedChar& l , Short& r) { // 3a
  Short num;
  num.val = (short)(l.val += (unsigned char)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
Short operator -=  (UnsignedChar& l , Short& r) { // 3a
  Short num;
  num.val = (short)(l.val -= (unsigned char)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
Short operator *=  (UnsignedChar& l , Short& r) { // 3a
  Short num;
  num.val = (short)(l.val *= (unsigned char)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
Short operator /=  (UnsignedChar& l , Short& r) { // 3a
  Short num;
  num.val = (short)(l.val /= (unsigned char)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
Short operator +   (UnsignedChar& l , short& r) {   // 6a
  Short num;
  num.val = ((short)l.val + r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator +   (unsigned char& l , Short& r) {   // 8a
  Short num;
  num.val = ((short)l + r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator -   (UnsignedChar& l , short& r) {   // 6a
  Short num;
  num.val = ((short)l.val - r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator -   (unsigned char& l , Short& r) {   // 8a
  Short num;
  num.val = ((short)l - r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator *   (UnsignedChar& l , short& r) {   // 6a
  Short num;
  num.val = ((short)l.val * r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator *   (unsigned char& l , Short& r) {   // 8a
  Short num;
  num.val = ((short)l * r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator /   (UnsignedChar& l , short& r) {   // 6a
  Short num;
  num.val = ((short)l.val / r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator /   (unsigned char& l , Short& r) {   // 8a
  Short num;
  num.val = ((short)l / r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator +=  (UnsignedChar& l , short& r) {   // 6a
  Short num;
  num.val = (short)(l.val += (unsigned char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator +=  (unsigned char& l , Short& r) {   // 8a
  Short num;
  num.val = (short)(l += (unsigned char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator -=  (UnsignedChar& l , short& r) {   // 6a
  Short num;
  num.val = (short)(l.val -= (unsigned char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator -=  (unsigned char& l , Short& r) {   // 8a
  Short num;
  num.val = (short)(l -= (unsigned char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator *=  (UnsignedChar& l , short& r) {   // 6a
  Short num;
  num.val = (short)(l.val *= (unsigned char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator *=  (unsigned char& l , Short& r) {   // 8a
  Short num;
  num.val = (short)(l *= (unsigned char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator /=  (UnsignedChar& l , short& r) {   // 6a
  Short num;
  num.val = (short)(l.val /= (unsigned char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator /=  (unsigned char& l , Short& r) {   // 8a
  Short num;
  num.val = (short)(l /= (unsigned char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator +   (UnsignedChar& l , UnsignedInt& r) { // 3a
  UnsignedInt num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator -   (UnsignedChar& l , UnsignedInt& r) { // 3a
  UnsignedInt num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator *   (UnsignedChar& l , UnsignedInt& r) { // 3a
  UnsignedInt num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator /   (UnsignedChar& l , UnsignedInt& r) { // 3a
  UnsignedInt num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator +=  (UnsignedChar& l , UnsignedInt& r) { // 3a
  UnsignedInt num;
  num.val = (unsigned int)(l.val += (unsigned char)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator -=  (UnsignedChar& l , UnsignedInt& r) { // 3a
  UnsignedInt num;
  num.val = (unsigned int)(l.val -= (unsigned char)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator *=  (UnsignedChar& l , UnsignedInt& r) { // 3a
  UnsignedInt num;
  num.val = (unsigned int)(l.val *= (unsigned char)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator /=  (UnsignedChar& l , UnsignedInt& r) { // 3a
  UnsignedInt num;
  num.val = (unsigned int)(l.val /= (unsigned char)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator +   (UnsignedChar& l , unsigned int& r) {   // 6a
  UnsignedInt num;
  num.val = ((unsigned int)l.val + r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator +   (unsigned char& l , UnsignedInt& r) {   // 8a
  UnsignedInt num;
  num.val = ((unsigned int)l + r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator -   (UnsignedChar& l , unsigned int& r) {   // 6a
  UnsignedInt num;
  num.val = ((unsigned int)l.val - r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator -   (unsigned char& l , UnsignedInt& r) {   // 8a
  UnsignedInt num;
  num.val = ((unsigned int)l - r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator *   (UnsignedChar& l , unsigned int& r) {   // 6a
  UnsignedInt num;
  num.val = ((unsigned int)l.val * r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator *   (unsigned char& l , UnsignedInt& r) {   // 8a
  UnsignedInt num;
  num.val = ((unsigned int)l * r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator /   (UnsignedChar& l , unsigned int& r) {   // 6a
  UnsignedInt num;
  num.val = ((unsigned int)l.val / r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator /   (unsigned char& l , UnsignedInt& r) {   // 8a
  UnsignedInt num;
  num.val = ((unsigned int)l / r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator +=  (UnsignedChar& l , unsigned int& r) {   // 6a
  UnsignedInt num;
  num.val = (unsigned int)(l.val += (unsigned char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator +=  (unsigned char& l , UnsignedInt& r) {   // 8a
  UnsignedInt num;
  num.val = (unsigned int)(l += (unsigned char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator -=  (UnsignedChar& l , unsigned int& r) {   // 6a
  UnsignedInt num;
  num.val = (unsigned int)(l.val -= (unsigned char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator -=  (unsigned char& l , UnsignedInt& r) {   // 8a
  UnsignedInt num;
  num.val = (unsigned int)(l -= (unsigned char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator *=  (UnsignedChar& l , unsigned int& r) {   // 6a
  UnsignedInt num;
  num.val = (unsigned int)(l.val *= (unsigned char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator *=  (unsigned char& l , UnsignedInt& r) {   // 8a
  UnsignedInt num;
  num.val = (unsigned int)(l *= (unsigned char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator /=  (UnsignedChar& l , unsigned int& r) {   // 6a
  UnsignedInt num;
  num.val = (unsigned int)(l.val /= (unsigned char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator /=  (unsigned char& l , UnsignedInt& r) {   // 8a
  UnsignedInt num;
  num.val = (unsigned int)(l /= (unsigned char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator +   (UnsignedChar& l , Int& r) { // 3a
  Int num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
Int operator -   (UnsignedChar& l , Int& r) { // 3a
  Int num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
Int operator *   (UnsignedChar& l , Int& r) { // 3a
  Int num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
Int operator /   (UnsignedChar& l , Int& r) { // 3a
  Int num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
Int operator +=  (UnsignedChar& l , Int& r) { // 3a
  Int num;
  num.val = (int)(l.val += (unsigned char)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator -=  (UnsignedChar& l , Int& r) { // 3a
  Int num;
  num.val = (int)(l.val -= (unsigned char)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator *=  (UnsignedChar& l , Int& r) { // 3a
  Int num;
  num.val = (int)(l.val *= (unsigned char)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator /=  (UnsignedChar& l , Int& r) { // 3a
  Int num;
  num.val = (int)(l.val /= (unsigned char)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator +   (UnsignedChar& l , int& r) {   // 6a
  Int num;
  num.val = ((int)l.val + r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator +   (unsigned char& l , Int& r) {   // 8a
  Int num;
  num.val = ((int)l + r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator -   (UnsignedChar& l , int& r) {   // 6a
  Int num;
  num.val = ((int)l.val - r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator -   (unsigned char& l , Int& r) {   // 8a
  Int num;
  num.val = ((int)l - r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator *   (UnsignedChar& l , int& r) {   // 6a
  Int num;
  num.val = ((int)l.val * r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator *   (unsigned char& l , Int& r) {   // 8a
  Int num;
  num.val = ((int)l * r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator /   (UnsignedChar& l , int& r) {   // 6a
  Int num;
  num.val = ((int)l.val / r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator /   (unsigned char& l , Int& r) {   // 8a
  Int num;
  num.val = ((int)l / r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator +=  (UnsignedChar& l , int& r) {   // 6a
  Int num;
  num.val = (int)(l.val += (unsigned char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator +=  (unsigned char& l , Int& r) {   // 8a
  Int num;
  num.val = (int)(l += (unsigned char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator -=  (UnsignedChar& l , int& r) {   // 6a
  Int num;
  num.val = (int)(l.val -= (unsigned char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator -=  (unsigned char& l , Int& r) {   // 8a
  Int num;
  num.val = (int)(l -= (unsigned char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator *=  (UnsignedChar& l , int& r) {   // 6a
  Int num;
  num.val = (int)(l.val *= (unsigned char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator *=  (unsigned char& l , Int& r) {   // 8a
  Int num;
  num.val = (int)(l *= (unsigned char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator /=  (UnsignedChar& l , int& r) {   // 6a
  Int num;
  num.val = (int)(l.val /= (unsigned char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator /=  (unsigned char& l , Int& r) {   // 8a
  Int num;
  num.val = (int)(l /= (unsigned char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +   (UnsignedChar& l , UnsignedLong& r) { // 3a
  UnsignedLong num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -   (UnsignedChar& l , UnsignedLong& r) { // 3a
  UnsignedLong num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *   (UnsignedChar& l , UnsignedLong& r) { // 3a
  UnsignedLong num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /   (UnsignedChar& l , UnsignedLong& r) { // 3a
  UnsignedLong num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +=  (UnsignedChar& l , UnsignedLong& r) { // 3a
  UnsignedLong num;
  num.val = (unsigned long)(l.val += (unsigned char)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -=  (UnsignedChar& l , UnsignedLong& r) { // 3a
  UnsignedLong num;
  num.val = (unsigned long)(l.val -= (unsigned char)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *=  (UnsignedChar& l , UnsignedLong& r) { // 3a
  UnsignedLong num;
  num.val = (unsigned long)(l.val *= (unsigned char)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /=  (UnsignedChar& l , UnsignedLong& r) { // 3a
  UnsignedLong num;
  num.val = (unsigned long)(l.val /= (unsigned char)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +   (UnsignedChar& l , unsigned long& r) {   // 6a
  UnsignedLong num;
  num.val = ((unsigned long)l.val + r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +   (unsigned char& l , UnsignedLong& r) {   // 8a
  UnsignedLong num;
  num.val = ((unsigned long)l + r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -   (UnsignedChar& l , unsigned long& r) {   // 6a
  UnsignedLong num;
  num.val = ((unsigned long)l.val - r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -   (unsigned char& l , UnsignedLong& r) {   // 8a
  UnsignedLong num;
  num.val = ((unsigned long)l - r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *   (UnsignedChar& l , unsigned long& r) {   // 6a
  UnsignedLong num;
  num.val = ((unsigned long)l.val * r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *   (unsigned char& l , UnsignedLong& r) {   // 8a
  UnsignedLong num;
  num.val = ((unsigned long)l * r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /   (UnsignedChar& l , unsigned long& r) {   // 6a
  UnsignedLong num;
  num.val = ((unsigned long)l.val / r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /   (unsigned char& l , UnsignedLong& r) {   // 8a
  UnsignedLong num;
  num.val = ((unsigned long)l / r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +=  (UnsignedChar& l , unsigned long& r) {   // 6a
  UnsignedLong num;
  num.val = (unsigned long)(l.val += (unsigned char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +=  (unsigned char& l , UnsignedLong& r) {   // 8a
  UnsignedLong num;
  num.val = (unsigned long)(l += (unsigned char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -=  (UnsignedChar& l , unsigned long& r) {   // 6a
  UnsignedLong num;
  num.val = (unsigned long)(l.val -= (unsigned char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -=  (unsigned char& l , UnsignedLong& r) {   // 8a
  UnsignedLong num;
  num.val = (unsigned long)(l -= (unsigned char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *=  (UnsignedChar& l , unsigned long& r) {   // 6a
  UnsignedLong num;
  num.val = (unsigned long)(l.val *= (unsigned char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *=  (unsigned char& l , UnsignedLong& r) {   // 8a
  UnsignedLong num;
  num.val = (unsigned long)(l *= (unsigned char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /=  (UnsignedChar& l , unsigned long& r) {   // 6a
  UnsignedLong num;
  num.val = (unsigned long)(l.val /= (unsigned char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /=  (unsigned char& l , UnsignedLong& r) {   // 8a
  UnsignedLong num;
  num.val = (unsigned long)(l /= (unsigned char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator +   (UnsignedChar& l , Long& r) { // 3a
  Long num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
Long operator -   (UnsignedChar& l , Long& r) { // 3a
  Long num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
Long operator *   (UnsignedChar& l , Long& r) { // 3a
  Long num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
Long operator /   (UnsignedChar& l , Long& r) { // 3a
  Long num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
Long operator +=  (UnsignedChar& l , Long& r) { // 3a
  Long num;
  num.val = (long)(l.val += (unsigned char)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator -=  (UnsignedChar& l , Long& r) { // 3a
  Long num;
  num.val = (long)(l.val -= (unsigned char)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator *=  (UnsignedChar& l , Long& r) { // 3a
  Long num;
  num.val = (long)(l.val *= (unsigned char)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator /=  (UnsignedChar& l , Long& r) { // 3a
  Long num;
  num.val = (long)(l.val /= (unsigned char)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator +   (UnsignedChar& l , long& r) {   // 6a
  Long num;
  num.val = ((long)l.val + r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator +   (unsigned char& l , Long& r) {   // 8a
  Long num;
  num.val = ((long)l + r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator -   (UnsignedChar& l , long& r) {   // 6a
  Long num;
  num.val = ((long)l.val - r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator -   (unsigned char& l , Long& r) {   // 8a
  Long num;
  num.val = ((long)l - r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator *   (UnsignedChar& l , long& r) {   // 6a
  Long num;
  num.val = ((long)l.val * r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator *   (unsigned char& l , Long& r) {   // 8a
  Long num;
  num.val = ((long)l * r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator /   (UnsignedChar& l , long& r) {   // 6a
  Long num;
  num.val = ((long)l.val / r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator /   (unsigned char& l , Long& r) {   // 8a
  Long num;
  num.val = ((long)l / r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator +=  (UnsignedChar& l , long& r) {   // 6a
  Long num;
  num.val = (long)(l.val += (unsigned char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator +=  (unsigned char& l , Long& r) {   // 8a
  Long num;
  num.val = (long)(l += (unsigned char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator -=  (UnsignedChar& l , long& r) {   // 6a
  Long num;
  num.val = (long)(l.val -= (unsigned char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator -=  (unsigned char& l , Long& r) {   // 8a
  Long num;
  num.val = (long)(l -= (unsigned char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator *=  (UnsignedChar& l , long& r) {   // 6a
  Long num;
  num.val = (long)(l.val *= (unsigned char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator *=  (unsigned char& l , Long& r) {   // 8a
  Long num;
  num.val = (long)(l *= (unsigned char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator /=  (UnsignedChar& l , long& r) {   // 6a
  Long num;
  num.val = (long)(l.val /= (unsigned char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator /=  (unsigned char& l , Long& r) {   // 8a
  Long num;
  num.val = (long)(l /= (unsigned char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator +   (UnsignedChar& l , Float& r) { // 3a
  Float num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
Float operator -   (UnsignedChar& l , Float& r) { // 3a
  Float num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
Float operator *   (UnsignedChar& l , Float& r) { // 3a
  Float num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
Float operator /   (UnsignedChar& l , Float& r) { // 3a
  Float num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
Float operator +=  (UnsignedChar& l , Float& r) { // 3a
  Float num;
  num.val = (float)(l.val += (unsigned char)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
Float operator -=  (UnsignedChar& l , Float& r) { // 3a
  Float num;
  num.val = (float)(l.val -= (unsigned char)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
Float operator *=  (UnsignedChar& l , Float& r) { // 3a
  Float num;
  num.val = (float)(l.val *= (unsigned char)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
Float operator /=  (UnsignedChar& l , Float& r) { // 3a
  Float num;
  num.val = (float)(l.val /= (unsigned char)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
Float operator +   (UnsignedChar& l , float& r) {   // 6a
  Float num;
  num.val = ((float)l.val + r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator +   (unsigned char& l , Float& r) {   // 8a
  Float num;
  num.val = ((float)l + r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator -   (UnsignedChar& l , float& r) {   // 6a
  Float num;
  num.val = ((float)l.val - r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator -   (unsigned char& l , Float& r) {   // 8a
  Float num;
  num.val = ((float)l - r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator *   (UnsignedChar& l , float& r) {   // 6a
  Float num;
  num.val = ((float)l.val * r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator *   (unsigned char& l , Float& r) {   // 8a
  Float num;
  num.val = ((float)l * r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator /   (UnsignedChar& l , float& r) {   // 6a
  Float num;
  num.val = ((float)l.val / r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator /   (unsigned char& l , Float& r) {   // 8a
  Float num;
  num.val = ((float)l / r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator +=  (UnsignedChar& l , float& r) {   // 6a
  Float num;
  num.val = (float)(l.val += (unsigned char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator +=  (unsigned char& l , Float& r) {   // 8a
  Float num;
  num.val = (float)(l += (unsigned char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator -=  (UnsignedChar& l , float& r) {   // 6a
  Float num;
  num.val = (float)(l.val -= (unsigned char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator -=  (unsigned char& l , Float& r) {   // 8a
  Float num;
  num.val = (float)(l -= (unsigned char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator *=  (UnsignedChar& l , float& r) {   // 6a
  Float num;
  num.val = (float)(l.val *= (unsigned char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator *=  (unsigned char& l , Float& r) {   // 8a
  Float num;
  num.val = (float)(l *= (unsigned char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator /=  (UnsignedChar& l , float& r) {   // 6a
  Float num;
  num.val = (float)(l.val /= (unsigned char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator /=  (unsigned char& l , Float& r) {   // 8a
  Float num;
  num.val = (float)(l /= (unsigned char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator +   (UnsignedChar& l , Double& r) { // 3a
  Double num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
Double operator -   (UnsignedChar& l , Double& r) { // 3a
  Double num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
Double operator *   (UnsignedChar& l , Double& r) { // 3a
  Double num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
Double operator /   (UnsignedChar& l , Double& r) { // 3a
  Double num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
Double operator +=  (UnsignedChar& l , Double& r) { // 3a
  Double num;
  num.val = (double)(l.val += (unsigned char)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
Double operator -=  (UnsignedChar& l , Double& r) { // 3a
  Double num;
  num.val = (double)(l.val -= (unsigned char)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
Double operator *=  (UnsignedChar& l , Double& r) { // 3a
  Double num;
  num.val = (double)(l.val *= (unsigned char)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
Double operator /=  (UnsignedChar& l , Double& r) { // 3a
  Double num;
  num.val = (double)(l.val /= (unsigned char)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
Double operator +   (UnsignedChar& l , double& r) {   // 6a
  Double num;
  num.val = ((double)l.val + r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator +   (unsigned char& l , Double& r) {   // 8a
  Double num;
  num.val = ((double)l + r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator -   (UnsignedChar& l , double& r) {   // 6a
  Double num;
  num.val = ((double)l.val - r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator -   (unsigned char& l , Double& r) {   // 8a
  Double num;
  num.val = ((double)l - r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator *   (UnsignedChar& l , double& r) {   // 6a
  Double num;
  num.val = ((double)l.val * r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator *   (unsigned char& l , Double& r) {   // 8a
  Double num;
  num.val = ((double)l * r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator /   (UnsignedChar& l , double& r) {   // 6a
  Double num;
  num.val = ((double)l.val / r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator /   (unsigned char& l , Double& r) {   // 8a
  Double num;
  num.val = ((double)l / r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator +=  (UnsignedChar& l , double& r) {   // 6a
  Double num;
  num.val = (double)(l.val += (unsigned char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator +=  (unsigned char& l , Double& r) {   // 8a
  Double num;
  num.val = (double)(l += (unsigned char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator -=  (UnsignedChar& l , double& r) {   // 6a
  Double num;
  num.val = (double)(l.val -= (unsigned char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator -=  (unsigned char& l , Double& r) {   // 8a
  Double num;
  num.val = (double)(l -= (unsigned char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator *=  (UnsignedChar& l , double& r) {   // 6a
  Double num;
  num.val = (double)(l.val *= (unsigned char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator *=  (unsigned char& l , Double& r) {   // 8a
  Double num;
  num.val = (double)(l *= (unsigned char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator /=  (UnsignedChar& l , double& r) {   // 6a
  Double num;
  num.val = (double)(l.val /= (unsigned char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator /=  (unsigned char& l , Double& r) {   // 8a
  Double num;
  num.val = (double)(l /= (unsigned char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedChar UnsignedChar::operator %   (UnsignedChar& r) { // 1i
  UnsignedChar num;
  num.val = (val % r.val);
  num.u = (u %   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedChar UnsignedChar::operator &   (UnsignedChar& r) { // 1i
  UnsignedChar num;
  num.val = (val & r.val);
  num.u = (u &   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedChar UnsignedChar::operator ^   (UnsignedChar& r) { // 1i
  UnsignedChar num;
  num.val = (val ^ r.val);
  num.u = (u ^   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedChar UnsignedChar::operator |   (UnsignedChar& r) { // 1i
  UnsignedChar num;
  num.val = (val | r.val);
  num.u = (u |   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedChar UnsignedChar::operator <<  (UnsignedChar& r) { // 1i
  UnsignedChar num;
  num.val = (val << r.val);
  num.u = (u <<  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedChar UnsignedChar::operator >>  (UnsignedChar& r) { // 1i
  UnsignedChar num;
  num.val = (val >> r.val);
  num.u = (u >>  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedChar UnsignedChar::operator %=  (UnsignedChar& r) { // 1i
  UnsignedChar num;
  num.val = (val %= r.val);
  num.u = (u %=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedChar UnsignedChar::operator &=  (UnsignedChar& r) { // 1i
  UnsignedChar num;
  num.val = (val &= r.val);
  num.u = (u &=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedChar UnsignedChar::operator |=  (UnsignedChar& r) { // 1i
  UnsignedChar num;
  num.val = (val |= r.val);
  num.u = (u |=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedChar UnsignedChar::operator ^=  (UnsignedChar& r) { // 1i
  UnsignedChar num;
  num.val = (val ^= r.val);
  num.u = (u ^=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedChar UnsignedChar::operator <<= (UnsignedChar& r) { // 1i
  UnsignedChar num;
  num.val = (val <<= r.val);
  num.u = (u <<= r.u);
  return num;
}

// **********************************************************************************************************
UnsignedChar UnsignedChar::operator >>= (UnsignedChar& r) { // 1i
  UnsignedChar num;
  num.val = (val >>= r.val);
  num.u = (u >>= r.u);
  return num;
}

// **********************************************************************************************************
UnsignedChar operator %   (UnsignedChar& l , unsigned char& r) { // 6i
  UnsignedChar num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedChar operator %   (unsigned char& l , UnsignedChar& r) { // 8i
  UnsignedChar num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedChar operator &   (UnsignedChar& l , unsigned char& r) { // 6i
  UnsignedChar num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedChar operator &   (unsigned char& l , UnsignedChar& r) { // 8i
  UnsignedChar num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedChar operator ^   (UnsignedChar& l , unsigned char& r) { // 6i
  UnsignedChar num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedChar operator ^   (unsigned char& l , UnsignedChar& r) { // 8i
  UnsignedChar num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedChar operator |   (UnsignedChar& l , unsigned char& r) { // 6i
  UnsignedChar num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedChar operator |   (unsigned char& l , UnsignedChar& r) { // 8i
  UnsignedChar num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedChar operator <<  (UnsignedChar& l , unsigned char& r) { // 6i
  UnsignedChar num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedChar operator <<  (unsigned char& l , UnsignedChar& r) { // 8i
  UnsignedChar num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedChar operator >>  (UnsignedChar& l , unsigned char& r) { // 6i
  UnsignedChar num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedChar operator >>  (unsigned char& l , UnsignedChar& r) { // 8i
  UnsignedChar num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedChar operator %=  (UnsignedChar& l , unsigned char& r) { // 6i
  UnsignedChar num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedChar operator %=  (unsigned char& l , UnsignedChar& r) { // 8i
  UnsignedChar num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedChar operator &=  (UnsignedChar& l , unsigned char& r) { // 6i
  UnsignedChar num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedChar operator &=  (unsigned char& l , UnsignedChar& r) { // 8i
  UnsignedChar num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedChar operator |=  (UnsignedChar& l , unsigned char& r) { // 6i
  UnsignedChar num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedChar operator |=  (unsigned char& l , UnsignedChar& r) { // 8i
  UnsignedChar num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedChar operator ^=  (UnsignedChar& l , unsigned char& r) { // 6i
  UnsignedChar num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedChar operator ^=  (unsigned char& l , UnsignedChar& r) { // 8i
  UnsignedChar num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedChar operator <<= (UnsignedChar& l , unsigned char& r) { // 6i
  UnsignedChar num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedChar operator <<= (unsigned char& l , UnsignedChar& r) { // 8i
  UnsignedChar num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedChar operator >>= (UnsignedChar& l , unsigned char& r) { // 6i
  UnsignedChar num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedChar operator >>= (unsigned char& l , UnsignedChar& r) { // 8i
  UnsignedChar num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator %   (UnsignedChar& l , Char& r) { // 3i
  Char num;
  num.val = (l.val % r.val);
  num.u = (l.u %   r.u);
  return num;
}

// **********************************************************************************************************
Char operator &   (UnsignedChar& l , Char& r) { // 3i
  Char num;
  num.val = (l.val & r.val);
  num.u = (l.u &   r.u);
  return num;
}

// **********************************************************************************************************
Char operator ^   (UnsignedChar& l , Char& r) { // 3i
  Char num;
  num.val = (l.val ^ r.val);
  num.u = (l.u ^   r.u);
  return num;
}

// **********************************************************************************************************
Char operator |   (UnsignedChar& l , Char& r) { // 3i
  Char num;
  num.val = (l.val | r.val);
  num.u = (l.u |   r.u);
  return num;
}

// **********************************************************************************************************
Char operator <<  (UnsignedChar& l , Char& r) { // 3i
  Char num;
  num.val = (l.val << r.val);
  num.u = (l.u <<  r.u);
  return num;
}

// **********************************************************************************************************
Char operator >>  (UnsignedChar& l , Char& r) { // 3i
  Char num;
  num.val = (l.val >> r.val);
  num.u = (l.u >>  r.u);
  return num;
}

// **********************************************************************************************************
Char operator %=  (UnsignedChar& l , Char& r) { // 3i
  Char num;
  num.val = (l.val %= r.val);
  num.u = (l.u %=  r.u);
  return num;
}

// **********************************************************************************************************
Char operator &=  (UnsignedChar& l , Char& r) { // 3i
  Char num;
  num.val = (l.val &= r.val);
  num.u = (l.u &=  r.u);
  return num;
}

// **********************************************************************************************************
Char operator |=  (UnsignedChar& l , Char& r) { // 3i
  Char num;
  num.val = (l.val |= r.val);
  num.u = (l.u |=  r.u);
  return num;
}

// **********************************************************************************************************
Char operator ^=  (UnsignedChar& l , Char& r) { // 3i
  Char num;
  num.val = (l.val ^= r.val);
  num.u = (l.u ^=  r.u);
  return num;
}

// **********************************************************************************************************
Char operator <<= (UnsignedChar& l , Char& r) { // 3i
  Char num;
  num.val = (l.val <<= r.val);
  num.u = (l.u <<= r.u);
  return num;
}

// **********************************************************************************************************
Char operator >>= (UnsignedChar& l , Char& r) { // 3i
  Char num;
  num.val = (l.val >>= r.val);
  num.u = (l.u >>= r.u);
  return num;
}

// **********************************************************************************************************
Char operator %   (UnsignedChar& l , char& r) { // 6i
  Char num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator %   (unsigned char& l , Char& r) { // 8i
  Char num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator &   (UnsignedChar& l , char& r) { // 6i
  Char num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator &   (unsigned char& l , Char& r) { // 8i
  Char num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator ^   (UnsignedChar& l , char& r) { // 6i
  Char num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator ^   (unsigned char& l , Char& r) { // 8i
  Char num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator |   (UnsignedChar& l , char& r) { // 6i
  Char num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator |   (unsigned char& l , Char& r) { // 8i
  Char num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator <<  (UnsignedChar& l , char& r) { // 6i
  Char num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator <<  (unsigned char& l , Char& r) { // 8i
  Char num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator >>  (UnsignedChar& l , char& r) { // 6i
  Char num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator >>  (unsigned char& l , Char& r) { // 8i
  Char num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator %=  (UnsignedChar& l , char& r) { // 6i
  Char num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator %=  (unsigned char& l , Char& r) { // 8i
  Char num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator &=  (UnsignedChar& l , char& r) { // 6i
  Char num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator &=  (unsigned char& l , Char& r) { // 8i
  Char num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator |=  (UnsignedChar& l , char& r) { // 6i
  Char num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator |=  (unsigned char& l , Char& r) { // 8i
  Char num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator ^=  (UnsignedChar& l , char& r) { // 6i
  Char num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator ^=  (unsigned char& l , Char& r) { // 8i
  Char num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator <<= (UnsignedChar& l , char& r) { // 6i
  Char num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator <<= (unsigned char& l , Char& r) { // 8i
  Char num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator >>= (UnsignedChar& l , char& r) { // 6i
  Char num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator >>= (unsigned char& l , Char& r) { // 8i
  Char num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator %   (UnsignedChar& l , UnsignedShort& r) { // 3i
  UnsignedShort num;
  num.val = (l.val % r.val);
  num.u = (l.u %   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator &   (UnsignedChar& l , UnsignedShort& r) { // 3i
  UnsignedShort num;
  num.val = (l.val & r.val);
  num.u = (l.u &   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator ^   (UnsignedChar& l , UnsignedShort& r) { // 3i
  UnsignedShort num;
  num.val = (l.val ^ r.val);
  num.u = (l.u ^   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator |   (UnsignedChar& l , UnsignedShort& r) { // 3i
  UnsignedShort num;
  num.val = (l.val | r.val);
  num.u = (l.u |   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator <<  (UnsignedChar& l , UnsignedShort& r) { // 3i
  UnsignedShort num;
  num.val = (l.val << r.val);
  num.u = (l.u <<  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator >>  (UnsignedChar& l , UnsignedShort& r) { // 3i
  UnsignedShort num;
  num.val = (l.val >> r.val);
  num.u = (l.u >>  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator %=  (UnsignedChar& l , UnsignedShort& r) { // 3i
  UnsignedShort num;
  num.val = (l.val %= r.val);
  num.u = (l.u %=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator &=  (UnsignedChar& l , UnsignedShort& r) { // 3i
  UnsignedShort num;
  num.val = (l.val &= r.val);
  num.u = (l.u &=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator |=  (UnsignedChar& l , UnsignedShort& r) { // 3i
  UnsignedShort num;
  num.val = (l.val |= r.val);
  num.u = (l.u |=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator ^=  (UnsignedChar& l , UnsignedShort& r) { // 3i
  UnsignedShort num;
  num.val = (l.val ^= r.val);
  num.u = (l.u ^=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator <<= (UnsignedChar& l , UnsignedShort& r) { // 3i
  UnsignedShort num;
  num.val = (l.val <<= r.val);
  num.u = (l.u <<= r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator >>= (UnsignedChar& l , UnsignedShort& r) { // 3i
  UnsignedShort num;
  num.val = (l.val >>= r.val);
  num.u = (l.u >>= r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator %   (UnsignedChar& l , unsigned short& r) { // 6i
  UnsignedShort num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator %   (unsigned char& l , UnsignedShort& r) { // 8i
  UnsignedShort num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator &   (UnsignedChar& l , unsigned short& r) { // 6i
  UnsignedShort num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator &   (unsigned char& l , UnsignedShort& r) { // 8i
  UnsignedShort num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator ^   (UnsignedChar& l , unsigned short& r) { // 6i
  UnsignedShort num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator ^   (unsigned char& l , UnsignedShort& r) { // 8i
  UnsignedShort num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator |   (UnsignedChar& l , unsigned short& r) { // 6i
  UnsignedShort num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator |   (unsigned char& l , UnsignedShort& r) { // 8i
  UnsignedShort num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator <<  (UnsignedChar& l , unsigned short& r) { // 6i
  UnsignedShort num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator <<  (unsigned char& l , UnsignedShort& r) { // 8i
  UnsignedShort num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator >>  (UnsignedChar& l , unsigned short& r) { // 6i
  UnsignedShort num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator >>  (unsigned char& l , UnsignedShort& r) { // 8i
  UnsignedShort num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator %=  (UnsignedChar& l , unsigned short& r) { // 6i
  UnsignedShort num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator %=  (unsigned char& l , UnsignedShort& r) { // 8i
  UnsignedShort num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator &=  (UnsignedChar& l , unsigned short& r) { // 6i
  UnsignedShort num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator &=  (unsigned char& l , UnsignedShort& r) { // 8i
  UnsignedShort num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator |=  (UnsignedChar& l , unsigned short& r) { // 6i
  UnsignedShort num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator |=  (unsigned char& l , UnsignedShort& r) { // 8i
  UnsignedShort num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator ^=  (UnsignedChar& l , unsigned short& r) { // 6i
  UnsignedShort num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator ^=  (unsigned char& l , UnsignedShort& r) { // 8i
  UnsignedShort num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator <<= (UnsignedChar& l , unsigned short& r) { // 6i
  UnsignedShort num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator <<= (unsigned char& l , UnsignedShort& r) { // 8i
  UnsignedShort num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator >>= (UnsignedChar& l , unsigned short& r) { // 6i
  UnsignedShort num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator >>= (unsigned char& l , UnsignedShort& r) { // 8i
  UnsignedShort num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator %   (UnsignedChar& l , Short& r) { // 3i
  Short num;
  num.val = (l.val % r.val);
  num.u = (l.u %   r.u);
  return num;
}

// **********************************************************************************************************
Short operator &   (UnsignedChar& l , Short& r) { // 3i
  Short num;
  num.val = (l.val & r.val);
  num.u = (l.u &   r.u);
  return num;
}

// **********************************************************************************************************
Short operator ^   (UnsignedChar& l , Short& r) { // 3i
  Short num;
  num.val = (l.val ^ r.val);
  num.u = (l.u ^   r.u);
  return num;
}

// **********************************************************************************************************
Short operator |   (UnsignedChar& l , Short& r) { // 3i
  Short num;
  num.val = (l.val | r.val);
  num.u = (l.u |   r.u);
  return num;
}

// **********************************************************************************************************
Short operator <<  (UnsignedChar& l , Short& r) { // 3i
  Short num;
  num.val = (l.val << r.val);
  num.u = (l.u <<  r.u);
  return num;
}

// **********************************************************************************************************
Short operator >>  (UnsignedChar& l , Short& r) { // 3i
  Short num;
  num.val = (l.val >> r.val);
  num.u = (l.u >>  r.u);
  return num;
}

// **********************************************************************************************************
Short operator %=  (UnsignedChar& l , Short& r) { // 3i
  Short num;
  num.val = (l.val %= r.val);
  num.u = (l.u %=  r.u);
  return num;
}

// **********************************************************************************************************
Short operator &=  (UnsignedChar& l , Short& r) { // 3i
  Short num;
  num.val = (l.val &= r.val);
  num.u = (l.u &=  r.u);
  return num;
}

// **********************************************************************************************************
Short operator |=  (UnsignedChar& l , Short& r) { // 3i
  Short num;
  num.val = (l.val |= r.val);
  num.u = (l.u |=  r.u);
  return num;
}

// **********************************************************************************************************
Short operator ^=  (UnsignedChar& l , Short& r) { // 3i
  Short num;
  num.val = (l.val ^= r.val);
  num.u = (l.u ^=  r.u);
  return num;
}

// **********************************************************************************************************
Short operator <<= (UnsignedChar& l , Short& r) { // 3i
  Short num;
  num.val = (l.val <<= r.val);
  num.u = (l.u <<= r.u);
  return num;
}

// **********************************************************************************************************
Short operator >>= (UnsignedChar& l , Short& r) { // 3i
  Short num;
  num.val = (l.val >>= r.val);
  num.u = (l.u >>= r.u);
  return num;
}

// **********************************************************************************************************
Short operator %   (UnsignedChar& l , short& r) { // 6i
  Short num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator %   (unsigned char& l , Short& r) { // 8i
  Short num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator &   (UnsignedChar& l , short& r) { // 6i
  Short num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator &   (unsigned char& l , Short& r) { // 8i
  Short num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator ^   (UnsignedChar& l , short& r) { // 6i
  Short num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator ^   (unsigned char& l , Short& r) { // 8i
  Short num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator |   (UnsignedChar& l , short& r) { // 6i
  Short num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator |   (unsigned char& l , Short& r) { // 8i
  Short num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator <<  (UnsignedChar& l , short& r) { // 6i
  Short num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator <<  (unsigned char& l , Short& r) { // 8i
  Short num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator >>  (UnsignedChar& l , short& r) { // 6i
  Short num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator >>  (unsigned char& l , Short& r) { // 8i
  Short num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator %=  (UnsignedChar& l , short& r) { // 6i
  Short num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator %=  (unsigned char& l , Short& r) { // 8i
  Short num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator &=  (UnsignedChar& l , short& r) { // 6i
  Short num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator &=  (unsigned char& l , Short& r) { // 8i
  Short num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator |=  (UnsignedChar& l , short& r) { // 6i
  Short num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator |=  (unsigned char& l , Short& r) { // 8i
  Short num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator ^=  (UnsignedChar& l , short& r) { // 6i
  Short num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator ^=  (unsigned char& l , Short& r) { // 8i
  Short num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator <<= (UnsignedChar& l , short& r) { // 6i
  Short num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator <<= (unsigned char& l , Short& r) { // 8i
  Short num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator >>= (UnsignedChar& l , short& r) { // 6i
  Short num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator >>= (unsigned char& l , Short& r) { // 8i
  Short num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator %   (UnsignedChar& l , UnsignedInt& r) { // 3i
  UnsignedInt num;
  num.val = (l.val % r.val);
  num.u = (l.u %   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator &   (UnsignedChar& l , UnsignedInt& r) { // 3i
  UnsignedInt num;
  num.val = (l.val & r.val);
  num.u = (l.u &   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator ^   (UnsignedChar& l , UnsignedInt& r) { // 3i
  UnsignedInt num;
  num.val = (l.val ^ r.val);
  num.u = (l.u ^   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator |   (UnsignedChar& l , UnsignedInt& r) { // 3i
  UnsignedInt num;
  num.val = (l.val | r.val);
  num.u = (l.u |   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator <<  (UnsignedChar& l , UnsignedInt& r) { // 3i
  UnsignedInt num;
  num.val = (l.val << r.val);
  num.u = (l.u <<  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator >>  (UnsignedChar& l , UnsignedInt& r) { // 3i
  UnsignedInt num;
  num.val = (l.val >> r.val);
  num.u = (l.u >>  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator %=  (UnsignedChar& l , UnsignedInt& r) { // 3i
  UnsignedInt num;
  num.val = (l.val %= r.val);
  num.u = (l.u %=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator &=  (UnsignedChar& l , UnsignedInt& r) { // 3i
  UnsignedInt num;
  num.val = (l.val &= r.val);
  num.u = (l.u &=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator |=  (UnsignedChar& l , UnsignedInt& r) { // 3i
  UnsignedInt num;
  num.val = (l.val |= r.val);
  num.u = (l.u |=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator ^=  (UnsignedChar& l , UnsignedInt& r) { // 3i
  UnsignedInt num;
  num.val = (l.val ^= r.val);
  num.u = (l.u ^=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator <<= (UnsignedChar& l , UnsignedInt& r) { // 3i
  UnsignedInt num;
  num.val = (l.val <<= r.val);
  num.u = (l.u <<= r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator >>= (UnsignedChar& l , UnsignedInt& r) { // 3i
  UnsignedInt num;
  num.val = (l.val >>= r.val);
  num.u = (l.u >>= r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator %   (UnsignedChar& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator %   (unsigned char& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator &   (UnsignedChar& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator &   (unsigned char& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator ^   (UnsignedChar& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator ^   (unsigned char& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator |   (UnsignedChar& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator |   (unsigned char& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator <<  (UnsignedChar& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator <<  (unsigned char& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator >>  (UnsignedChar& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator >>  (unsigned char& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator %=  (UnsignedChar& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator %=  (unsigned char& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator &=  (UnsignedChar& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator &=  (unsigned char& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator |=  (UnsignedChar& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator |=  (unsigned char& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator ^=  (UnsignedChar& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator ^=  (unsigned char& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator <<= (UnsignedChar& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator <<= (unsigned char& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator >>= (UnsignedChar& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator >>= (unsigned char& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator %   (UnsignedChar& l , Int& r) { // 3i
  Int num;
  num.val = (l.val % r.val);
  num.u = (l.u %   r.u);
  return num;
}

// **********************************************************************************************************
Int operator &   (UnsignedChar& l , Int& r) { // 3i
  Int num;
  num.val = (l.val & r.val);
  num.u = (l.u &   r.u);
  return num;
}

// **********************************************************************************************************
Int operator ^   (UnsignedChar& l , Int& r) { // 3i
  Int num;
  num.val = (l.val ^ r.val);
  num.u = (l.u ^   r.u);
  return num;
}

// **********************************************************************************************************
Int operator |   (UnsignedChar& l , Int& r) { // 3i
  Int num;
  num.val = (l.val | r.val);
  num.u = (l.u |   r.u);
  return num;
}

// **********************************************************************************************************
Int operator <<  (UnsignedChar& l , Int& r) { // 3i
  Int num;
  num.val = (l.val << r.val);
  num.u = (l.u <<  r.u);
  return num;
}

// **********************************************************************************************************
Int operator >>  (UnsignedChar& l , Int& r) { // 3i
  Int num;
  num.val = (l.val >> r.val);
  num.u = (l.u >>  r.u);
  return num;
}

// **********************************************************************************************************
Int operator %=  (UnsignedChar& l , Int& r) { // 3i
  Int num;
  num.val = (l.val %= r.val);
  num.u = (l.u %=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator &=  (UnsignedChar& l , Int& r) { // 3i
  Int num;
  num.val = (l.val &= r.val);
  num.u = (l.u &=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator |=  (UnsignedChar& l , Int& r) { // 3i
  Int num;
  num.val = (l.val |= r.val);
  num.u = (l.u |=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator ^=  (UnsignedChar& l , Int& r) { // 3i
  Int num;
  num.val = (l.val ^= r.val);
  num.u = (l.u ^=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator <<= (UnsignedChar& l , Int& r) { // 3i
  Int num;
  num.val = (l.val <<= r.val);
  num.u = (l.u <<= r.u);
  return num;
}

// **********************************************************************************************************
Int operator >>= (UnsignedChar& l , Int& r) { // 3i
  Int num;
  num.val = (l.val >>= r.val);
  num.u = (l.u >>= r.u);
  return num;
}

// **********************************************************************************************************
Int operator %   (UnsignedChar& l , int& r) { // 6i
  Int num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator %   (unsigned char& l , Int& r) { // 8i
  Int num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator &   (UnsignedChar& l , int& r) { // 6i
  Int num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator &   (unsigned char& l , Int& r) { // 8i
  Int num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator ^   (UnsignedChar& l , int& r) { // 6i
  Int num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator ^   (unsigned char& l , Int& r) { // 8i
  Int num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator |   (UnsignedChar& l , int& r) { // 6i
  Int num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator |   (unsigned char& l , Int& r) { // 8i
  Int num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator <<  (UnsignedChar& l , int& r) { // 6i
  Int num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator <<  (unsigned char& l , Int& r) { // 8i
  Int num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator >>  (UnsignedChar& l , int& r) { // 6i
  Int num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator >>  (unsigned char& l , Int& r) { // 8i
  Int num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator %=  (UnsignedChar& l , int& r) { // 6i
  Int num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator %=  (unsigned char& l , Int& r) { // 8i
  Int num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator &=  (UnsignedChar& l , int& r) { // 6i
  Int num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator &=  (unsigned char& l , Int& r) { // 8i
  Int num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator |=  (UnsignedChar& l , int& r) { // 6i
  Int num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator |=  (unsigned char& l , Int& r) { // 8i
  Int num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator ^=  (UnsignedChar& l , int& r) { // 6i
  Int num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator ^=  (unsigned char& l , Int& r) { // 8i
  Int num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator <<= (UnsignedChar& l , int& r) { // 6i
  Int num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator <<= (unsigned char& l , Int& r) { // 8i
  Int num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator >>= (UnsignedChar& l , int& r) { // 6i
  Int num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator >>= (unsigned char& l , Int& r) { // 8i
  Int num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %   (UnsignedChar& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val % r.val);
  num.u = (l.u %   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &   (UnsignedChar& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val & r.val);
  num.u = (l.u &   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^   (UnsignedChar& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val ^ r.val);
  num.u = (l.u ^   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |   (UnsignedChar& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val | r.val);
  num.u = (l.u |   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<  (UnsignedChar& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val << r.val);
  num.u = (l.u <<  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>  (UnsignedChar& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val >> r.val);
  num.u = (l.u >>  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %=  (UnsignedChar& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val %= r.val);
  num.u = (l.u %=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &=  (UnsignedChar& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val &= r.val);
  num.u = (l.u &=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |=  (UnsignedChar& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val |= r.val);
  num.u = (l.u |=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^=  (UnsignedChar& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val ^= r.val);
  num.u = (l.u ^=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<= (UnsignedChar& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val <<= r.val);
  num.u = (l.u <<= r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>= (UnsignedChar& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val >>= r.val);
  num.u = (l.u >>= r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %   (UnsignedChar& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %   (unsigned char& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &   (UnsignedChar& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &   (unsigned char& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^   (UnsignedChar& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^   (unsigned char& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |   (UnsignedChar& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |   (unsigned char& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<  (UnsignedChar& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<  (unsigned char& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>  (UnsignedChar& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>  (unsigned char& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %=  (UnsignedChar& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %=  (unsigned char& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &=  (UnsignedChar& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &=  (unsigned char& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |=  (UnsignedChar& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |=  (unsigned char& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^=  (UnsignedChar& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^=  (unsigned char& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<= (UnsignedChar& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<= (unsigned char& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>= (UnsignedChar& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>= (unsigned char& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator %   (UnsignedChar& l , Long& r) { // 3i
  Long num;
  num.val = (l.val % r.val);
  num.u = (l.u %   r.u);
  return num;
}

// **********************************************************************************************************
Long operator &   (UnsignedChar& l , Long& r) { // 3i
  Long num;
  num.val = (l.val & r.val);
  num.u = (l.u &   r.u);
  return num;
}

// **********************************************************************************************************
Long operator ^   (UnsignedChar& l , Long& r) { // 3i
  Long num;
  num.val = (l.val ^ r.val);
  num.u = (l.u ^   r.u);
  return num;
}

// **********************************************************************************************************
Long operator |   (UnsignedChar& l , Long& r) { // 3i
  Long num;
  num.val = (l.val | r.val);
  num.u = (l.u |   r.u);
  return num;
}

// **********************************************************************************************************
Long operator <<  (UnsignedChar& l , Long& r) { // 3i
  Long num;
  num.val = (l.val << r.val);
  num.u = (l.u <<  r.u);
  return num;
}

// **********************************************************************************************************
Long operator >>  (UnsignedChar& l , Long& r) { // 3i
  Long num;
  num.val = (l.val >> r.val);
  num.u = (l.u >>  r.u);
  return num;
}

// **********************************************************************************************************
Long operator %=  (UnsignedChar& l , Long& r) { // 3i
  Long num;
  num.val = (l.val %= r.val);
  num.u = (l.u %=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator &=  (UnsignedChar& l , Long& r) { // 3i
  Long num;
  num.val = (l.val &= r.val);
  num.u = (l.u &=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator |=  (UnsignedChar& l , Long& r) { // 3i
  Long num;
  num.val = (l.val |= r.val);
  num.u = (l.u |=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator ^=  (UnsignedChar& l , Long& r) { // 3i
  Long num;
  num.val = (l.val ^= r.val);
  num.u = (l.u ^=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator <<= (UnsignedChar& l , Long& r) { // 3i
  Long num;
  num.val = (l.val <<= r.val);
  num.u = (l.u <<= r.u);
  return num;
}

// **********************************************************************************************************
Long operator >>= (UnsignedChar& l , Long& r) { // 3i
  Long num;
  num.val = (l.val >>= r.val);
  num.u = (l.u >>= r.u);
  return num;
}

// **********************************************************************************************************
Long operator %   (UnsignedChar& l , long& r) { // 6i
  Long num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator %   (unsigned char& l , Long& r) { // 8i
  Long num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator &   (UnsignedChar& l , long& r) { // 6i
  Long num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator &   (unsigned char& l , Long& r) { // 8i
  Long num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator ^   (UnsignedChar& l , long& r) { // 6i
  Long num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator ^   (unsigned char& l , Long& r) { // 8i
  Long num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator |   (UnsignedChar& l , long& r) { // 6i
  Long num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator |   (unsigned char& l , Long& r) { // 8i
  Long num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator <<  (UnsignedChar& l , long& r) { // 6i
  Long num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator <<  (unsigned char& l , Long& r) { // 8i
  Long num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator >>  (UnsignedChar& l , long& r) { // 6i
  Long num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator >>  (unsigned char& l , Long& r) { // 8i
  Long num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator %=  (UnsignedChar& l , long& r) { // 6i
  Long num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator %=  (unsigned char& l , Long& r) { // 8i
  Long num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator &=  (UnsignedChar& l , long& r) { // 6i
  Long num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator &=  (unsigned char& l , Long& r) { // 8i
  Long num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator |=  (UnsignedChar& l , long& r) { // 6i
  Long num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator |=  (unsigned char& l , Long& r) { // 8i
  Long num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator ^=  (UnsignedChar& l , long& r) { // 6i
  Long num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator ^=  (unsigned char& l , Long& r) { // 8i
  Long num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator <<= (UnsignedChar& l , long& r) { // 6i
  Long num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator <<= (unsigned char& l , Long& r) { // 8i
  Long num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator >>= (UnsignedChar& l , long& r) { // 6i
  Long num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator >>= (unsigned char& l , Long& r) { // 8i
  Long num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedChar UnsignedChar::operator ++(void) { // 1p, Prefix operator
   ++val;
  return *this;
}

// **********************************************************************************************************
UnsignedChar UnsignedChar::operator --(void) { // 1p, Prefix operator
   --val;
  assert(val>=1);
  return *this;
}

// **********************************************************************************************************
UnsignedChar UnsignedChar::operator ++(int) { // 1p, Postfix operator
   val++;
  return *this;
}

// **********************************************************************************************************
UnsignedChar UnsignedChar::operator --(int) { // 1p, Postfix operator
  assert(val>=1);
   val--;
  return *this;
}

// *********************************************************************************************************
// First class Char constructor
// *********************************************************************************************************
Char::Char() {
  val=0;
  state=UNDEF;
  u.init();
}
// *********************************************************************************************************
// Second class Char constructor
// *********************************************************************************************************
Char::Char(char* str) {
  val=0;
  state=UNDEF;
  u.init(str);
}
// *********************************************************************************************************
// First class Char destructor
// *********************************************************************************************************
Char::~Char() {
  val=0;
  state=UNDEF;
  u.init();
}
// **********************************************************************************************************
Char operator +   (Char& l , UnsignedChar& r) { // 3a
  Char num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
Char operator -   (Char& l , UnsignedChar& r) { // 3a
  Char num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
Char operator *   (Char& l , UnsignedChar& r) { // 3a
  Char num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
Char operator /   (Char& l , UnsignedChar& r) { // 3a
  Char num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
Char operator +=  (Char& l , UnsignedChar& r) { // 3a
  Char num;
  num.val = (char)(l.val += (char)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
Char operator -=  (Char& l , UnsignedChar& r) { // 3a
  Char num;
  num.val = (char)(l.val -= (char)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
Char operator *=  (Char& l , UnsignedChar& r) { // 3a
  Char num;
  num.val = (char)(l.val *= (char)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
Char operator /=  (Char& l , UnsignedChar& r) { // 3a
  Char num;
  num.val = (char)(l.val /= (char)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
Char operator +   (Char& l , unsigned char& r) {   // 6a
  Char num;
  num.val = (l.val + (char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator +   (char& l , UnsignedChar& r) {   // 8a
  Char num;
  num.val = (l + (char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator -   (Char& l , unsigned char& r) {   // 6a
  Char num;
  num.val = (l.val - (char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator -   (char& l , UnsignedChar& r) {   // 8a
  Char num;
  num.val = (l - (char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator *   (Char& l , unsigned char& r) {   // 6a
  Char num;
  num.val = (l.val * (char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator *   (char& l , UnsignedChar& r) {   // 8a
  Char num;
  num.val = (l * (char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator /   (Char& l , unsigned char& r) {   // 6a
  Char num;
  num.val = (l.val / (char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator /   (char& l , UnsignedChar& r) {   // 8a
  Char num;
  num.val = (l / (char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator +=  (Char& l , unsigned char& r) {   // 6a
  Char num;
  num.val = (char)(l.val += (char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator +=  (char& l , UnsignedChar& r) {   // 8a
  Char num;
  num.val = (char)(l += (char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator -=  (Char& l , unsigned char& r) {   // 6a
  Char num;
  num.val = (char)(l.val -= (char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator -=  (char& l , UnsignedChar& r) {   // 8a
  Char num;
  num.val = (char)(l -= (char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator *=  (Char& l , unsigned char& r) {   // 6a
  Char num;
  num.val = (char)(l.val *= (char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator *=  (char& l , UnsignedChar& r) {   // 8a
  Char num;
  num.val = (char)(l *= (char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator /=  (Char& l , unsigned char& r) {   // 6a
  Char num;
  num.val = (char)(l.val /= (char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator /=  (char& l , UnsignedChar& r) {   // 8a
  Char num;
  num.val = (char)(l /= (char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char Char::operator +   (Char& r) { // 1a
  Char num;
  num.val = (val + r.val);
  num.u = (u +   r.u);
  return num;
}

// **********************************************************************************************************
Char Char::operator -   (Char& r) { // 1a
  Char num;
  num.val = (val - r.val);
  num.u = (u -   r.u);
  return num;
}

// **********************************************************************************************************
Char Char::operator *   (Char& r) { // 1a
  Char num;
  num.val = (val * r.val);
  num.u = (u *   r.u);
  return num;
}

// **********************************************************************************************************
Char Char::operator /   (Char& r) { // 1a
  Char num;
  num.val = (val / r.val);
  num.u = (u /   r.u);
  return num;
}

// **********************************************************************************************************
Char Char::operator +=  (Char& r) { // 1a
  Char num;
  num.val = (val += r.val);
  num.u = (u +=  r.u);
  return num;
}

// **********************************************************************************************************
Char Char::operator -=  (Char& r) { // 1a
  Char num;
  num.val = (val -= r.val);
  num.u = (u -=  r.u);
  return num;
}

// **********************************************************************************************************
Char Char::operator *=  (Char& r) { // 1a
  Char num;
  num.val = (val *= r.val);
  num.u = (u *=  r.u);
  return num;
}

// **********************************************************************************************************
Char Char::operator /=  (Char& r) { // 1a
  Char num;
  num.val = (val /= r.val);
  num.u = (u /=  r.u);
  return num;
}

// **********************************************************************************************************
Char operator +   (Char& l , char& r) {   // 6a
  Char num;
  num.val = (l.val + r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator +   (char& l , Char& r) {   // 8a
  Char num;
  num.val = (l + r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator -   (Char& l , char& r) {   // 6a
  Char num;
  num.val = (l.val - r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator -   (char& l , Char& r) {   // 8a
  Char num;
  num.val = (l - r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator *   (Char& l , char& r) {   // 6a
  Char num;
  num.val = (l.val * r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator *   (char& l , Char& r) {   // 8a
  Char num;
  num.val = (l * r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator /   (Char& l , char& r) {   // 6a
  Char num;
  num.val = (l.val / r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator /   (char& l , Char& r) {   // 8a
  Char num;
  num.val = (l / r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator +=  (Char& l , char& r) {   // 6a
  Char num;
  num.val = (char)(l.val += (char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator +=  (char& l , Char& r) {   // 8a
  Char num;
  num.val = (char)(l += (char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator -=  (Char& l , char& r) {   // 6a
  Char num;
  num.val = (char)(l.val -= (char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator -=  (char& l , Char& r) {   // 8a
  Char num;
  num.val = (char)(l -= (char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator *=  (Char& l , char& r) {   // 6a
  Char num;
  num.val = (char)(l.val *= (char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator *=  (char& l , Char& r) {   // 8a
  Char num;
  num.val = (char)(l *= (char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator /=  (Char& l , char& r) {   // 6a
  Char num;
  num.val = (char)(l.val /= (char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator /=  (char& l , Char& r) {   // 8a
  Char num;
  num.val = (char)(l /= (char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator +   (Char& l , UnsignedShort& r) { // 3a
  UnsignedShort num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator -   (Char& l , UnsignedShort& r) { // 3a
  UnsignedShort num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator *   (Char& l , UnsignedShort& r) { // 3a
  UnsignedShort num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator /   (Char& l , UnsignedShort& r) { // 3a
  UnsignedShort num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator +=  (Char& l , UnsignedShort& r) { // 3a
  UnsignedShort num;
  num.val = (unsigned short)(l.val += (char)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator -=  (Char& l , UnsignedShort& r) { // 3a
  UnsignedShort num;
  num.val = (unsigned short)(l.val -= (char)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator *=  (Char& l , UnsignedShort& r) { // 3a
  UnsignedShort num;
  num.val = (unsigned short)(l.val *= (char)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator /=  (Char& l , UnsignedShort& r) { // 3a
  UnsignedShort num;
  num.val = (unsigned short)(l.val /= (char)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator +   (Char& l , unsigned short& r) {   // 6a
  UnsignedShort num;
  num.val = ((unsigned short)l.val + r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator +   (char& l , UnsignedShort& r) {   // 8a
  UnsignedShort num;
  num.val = ((unsigned short)l + r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator -   (Char& l , unsigned short& r) {   // 6a
  UnsignedShort num;
  num.val = ((unsigned short)l.val - r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator -   (char& l , UnsignedShort& r) {   // 8a
  UnsignedShort num;
  num.val = ((unsigned short)l - r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator *   (Char& l , unsigned short& r) {   // 6a
  UnsignedShort num;
  num.val = ((unsigned short)l.val * r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator *   (char& l , UnsignedShort& r) {   // 8a
  UnsignedShort num;
  num.val = ((unsigned short)l * r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator /   (Char& l , unsigned short& r) {   // 6a
  UnsignedShort num;
  num.val = ((unsigned short)l.val / r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator /   (char& l , UnsignedShort& r) {   // 8a
  UnsignedShort num;
  num.val = ((unsigned short)l / r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator +=  (Char& l , unsigned short& r) {   // 6a
  UnsignedShort num;
  num.val = (unsigned short)(l.val += (char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator +=  (char& l , UnsignedShort& r) {   // 8a
  UnsignedShort num;
  num.val = (unsigned short)(l += (char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator -=  (Char& l , unsigned short& r) {   // 6a
  UnsignedShort num;
  num.val = (unsigned short)(l.val -= (char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator -=  (char& l , UnsignedShort& r) {   // 8a
  UnsignedShort num;
  num.val = (unsigned short)(l -= (char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator *=  (Char& l , unsigned short& r) {   // 6a
  UnsignedShort num;
  num.val = (unsigned short)(l.val *= (char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator *=  (char& l , UnsignedShort& r) {   // 8a
  UnsignedShort num;
  num.val = (unsigned short)(l *= (char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator /=  (Char& l , unsigned short& r) {   // 6a
  UnsignedShort num;
  num.val = (unsigned short)(l.val /= (char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator /=  (char& l , UnsignedShort& r) {   // 8a
  UnsignedShort num;
  num.val = (unsigned short)(l /= (char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator +   (Char& l , Short& r) { // 3a
  Short num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
Short operator -   (Char& l , Short& r) { // 3a
  Short num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
Short operator *   (Char& l , Short& r) { // 3a
  Short num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
Short operator /   (Char& l , Short& r) { // 3a
  Short num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
Short operator +=  (Char& l , Short& r) { // 3a
  Short num;
  num.val = (short)(l.val += (char)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
Short operator -=  (Char& l , Short& r) { // 3a
  Short num;
  num.val = (short)(l.val -= (char)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
Short operator *=  (Char& l , Short& r) { // 3a
  Short num;
  num.val = (short)(l.val *= (char)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
Short operator /=  (Char& l , Short& r) { // 3a
  Short num;
  num.val = (short)(l.val /= (char)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
Short operator +   (Char& l , short& r) {   // 6a
  Short num;
  num.val = ((short)l.val + r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator +   (char& l , Short& r) {   // 8a
  Short num;
  num.val = ((short)l + r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator -   (Char& l , short& r) {   // 6a
  Short num;
  num.val = ((short)l.val - r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator -   (char& l , Short& r) {   // 8a
  Short num;
  num.val = ((short)l - r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator *   (Char& l , short& r) {   // 6a
  Short num;
  num.val = ((short)l.val * r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator *   (char& l , Short& r) {   // 8a
  Short num;
  num.val = ((short)l * r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator /   (Char& l , short& r) {   // 6a
  Short num;
  num.val = ((short)l.val / r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator /   (char& l , Short& r) {   // 8a
  Short num;
  num.val = ((short)l / r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator +=  (Char& l , short& r) {   // 6a
  Short num;
  num.val = (short)(l.val += (char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator +=  (char& l , Short& r) {   // 8a
  Short num;
  num.val = (short)(l += (char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator -=  (Char& l , short& r) {   // 6a
  Short num;
  num.val = (short)(l.val -= (char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator -=  (char& l , Short& r) {   // 8a
  Short num;
  num.val = (short)(l -= (char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator *=  (Char& l , short& r) {   // 6a
  Short num;
  num.val = (short)(l.val *= (char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator *=  (char& l , Short& r) {   // 8a
  Short num;
  num.val = (short)(l *= (char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator /=  (Char& l , short& r) {   // 6a
  Short num;
  num.val = (short)(l.val /= (char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator /=  (char& l , Short& r) {   // 8a
  Short num;
  num.val = (short)(l /= (char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator +   (Char& l , UnsignedInt& r) { // 3a
  UnsignedInt num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator -   (Char& l , UnsignedInt& r) { // 3a
  UnsignedInt num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator *   (Char& l , UnsignedInt& r) { // 3a
  UnsignedInt num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator /   (Char& l , UnsignedInt& r) { // 3a
  UnsignedInt num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator +=  (Char& l , UnsignedInt& r) { // 3a
  UnsignedInt num;
  num.val = (unsigned int)(l.val += (char)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator -=  (Char& l , UnsignedInt& r) { // 3a
  UnsignedInt num;
  num.val = (unsigned int)(l.val -= (char)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator *=  (Char& l , UnsignedInt& r) { // 3a
  UnsignedInt num;
  num.val = (unsigned int)(l.val *= (char)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator /=  (Char& l , UnsignedInt& r) { // 3a
  UnsignedInt num;
  num.val = (unsigned int)(l.val /= (char)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator +   (Char& l , unsigned int& r) {   // 6a
  UnsignedInt num;
  num.val = ((unsigned int)l.val + r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator +   (char& l , UnsignedInt& r) {   // 8a
  UnsignedInt num;
  num.val = ((unsigned int)l + r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator -   (Char& l , unsigned int& r) {   // 6a
  UnsignedInt num;
  num.val = ((unsigned int)l.val - r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator -   (char& l , UnsignedInt& r) {   // 8a
  UnsignedInt num;
  num.val = ((unsigned int)l - r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator *   (Char& l , unsigned int& r) {   // 6a
  UnsignedInt num;
  num.val = ((unsigned int)l.val * r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator *   (char& l , UnsignedInt& r) {   // 8a
  UnsignedInt num;
  num.val = ((unsigned int)l * r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator /   (Char& l , unsigned int& r) {   // 6a
  UnsignedInt num;
  num.val = ((unsigned int)l.val / r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator /   (char& l , UnsignedInt& r) {   // 8a
  UnsignedInt num;
  num.val = ((unsigned int)l / r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator +=  (Char& l , unsigned int& r) {   // 6a
  UnsignedInt num;
  num.val = (unsigned int)(l.val += (char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator +=  (char& l , UnsignedInt& r) {   // 8a
  UnsignedInt num;
  num.val = (unsigned int)(l += (char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator -=  (Char& l , unsigned int& r) {   // 6a
  UnsignedInt num;
  num.val = (unsigned int)(l.val -= (char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator -=  (char& l , UnsignedInt& r) {   // 8a
  UnsignedInt num;
  num.val = (unsigned int)(l -= (char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator *=  (Char& l , unsigned int& r) {   // 6a
  UnsignedInt num;
  num.val = (unsigned int)(l.val *= (char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator *=  (char& l , UnsignedInt& r) {   // 8a
  UnsignedInt num;
  num.val = (unsigned int)(l *= (char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator /=  (Char& l , unsigned int& r) {   // 6a
  UnsignedInt num;
  num.val = (unsigned int)(l.val /= (char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator /=  (char& l , UnsignedInt& r) {   // 8a
  UnsignedInt num;
  num.val = (unsigned int)(l /= (char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator +   (Char& l , Int& r) { // 3a
  Int num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
Int operator -   (Char& l , Int& r) { // 3a
  Int num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
Int operator *   (Char& l , Int& r) { // 3a
  Int num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
Int operator /   (Char& l , Int& r) { // 3a
  Int num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
Int operator +=  (Char& l , Int& r) { // 3a
  Int num;
  num.val = (int)(l.val += (char)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator -=  (Char& l , Int& r) { // 3a
  Int num;
  num.val = (int)(l.val -= (char)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator *=  (Char& l , Int& r) { // 3a
  Int num;
  num.val = (int)(l.val *= (char)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator /=  (Char& l , Int& r) { // 3a
  Int num;
  num.val = (int)(l.val /= (char)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator +   (Char& l , int& r) {   // 6a
  Int num;
  num.val = ((int)l.val + r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator +   (char& l , Int& r) {   // 8a
  Int num;
  num.val = ((int)l + r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator -   (Char& l , int& r) {   // 6a
  Int num;
  num.val = ((int)l.val - r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator -   (char& l , Int& r) {   // 8a
  Int num;
  num.val = ((int)l - r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator *   (Char& l , int& r) {   // 6a
  Int num;
  num.val = ((int)l.val * r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator *   (char& l , Int& r) {   // 8a
  Int num;
  num.val = ((int)l * r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator /   (Char& l , int& r) {   // 6a
  Int num;
  num.val = ((int)l.val / r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator /   (char& l , Int& r) {   // 8a
  Int num;
  num.val = ((int)l / r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator +=  (Char& l , int& r) {   // 6a
  Int num;
  num.val = (int)(l.val += (char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator +=  (char& l , Int& r) {   // 8a
  Int num;
  num.val = (int)(l += (char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator -=  (Char& l , int& r) {   // 6a
  Int num;
  num.val = (int)(l.val -= (char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator -=  (char& l , Int& r) {   // 8a
  Int num;
  num.val = (int)(l -= (char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator *=  (Char& l , int& r) {   // 6a
  Int num;
  num.val = (int)(l.val *= (char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator *=  (char& l , Int& r) {   // 8a
  Int num;
  num.val = (int)(l *= (char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator /=  (Char& l , int& r) {   // 6a
  Int num;
  num.val = (int)(l.val /= (char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator /=  (char& l , Int& r) {   // 8a
  Int num;
  num.val = (int)(l /= (char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +   (Char& l , UnsignedLong& r) { // 3a
  UnsignedLong num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -   (Char& l , UnsignedLong& r) { // 3a
  UnsignedLong num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *   (Char& l , UnsignedLong& r) { // 3a
  UnsignedLong num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /   (Char& l , UnsignedLong& r) { // 3a
  UnsignedLong num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +=  (Char& l , UnsignedLong& r) { // 3a
  UnsignedLong num;
  num.val = (unsigned long)(l.val += (char)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -=  (Char& l , UnsignedLong& r) { // 3a
  UnsignedLong num;
  num.val = (unsigned long)(l.val -= (char)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *=  (Char& l , UnsignedLong& r) { // 3a
  UnsignedLong num;
  num.val = (unsigned long)(l.val *= (char)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /=  (Char& l , UnsignedLong& r) { // 3a
  UnsignedLong num;
  num.val = (unsigned long)(l.val /= (char)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +   (Char& l , unsigned long& r) {   // 6a
  UnsignedLong num;
  num.val = ((unsigned long)l.val + r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +   (char& l , UnsignedLong& r) {   // 8a
  UnsignedLong num;
  num.val = ((unsigned long)l + r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -   (Char& l , unsigned long& r) {   // 6a
  UnsignedLong num;
  num.val = ((unsigned long)l.val - r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -   (char& l , UnsignedLong& r) {   // 8a
  UnsignedLong num;
  num.val = ((unsigned long)l - r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *   (Char& l , unsigned long& r) {   // 6a
  UnsignedLong num;
  num.val = ((unsigned long)l.val * r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *   (char& l , UnsignedLong& r) {   // 8a
  UnsignedLong num;
  num.val = ((unsigned long)l * r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /   (Char& l , unsigned long& r) {   // 6a
  UnsignedLong num;
  num.val = ((unsigned long)l.val / r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /   (char& l , UnsignedLong& r) {   // 8a
  UnsignedLong num;
  num.val = ((unsigned long)l / r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +=  (Char& l , unsigned long& r) {   // 6a
  UnsignedLong num;
  num.val = (unsigned long)(l.val += (char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +=  (char& l , UnsignedLong& r) {   // 8a
  UnsignedLong num;
  num.val = (unsigned long)(l += (char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -=  (Char& l , unsigned long& r) {   // 6a
  UnsignedLong num;
  num.val = (unsigned long)(l.val -= (char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -=  (char& l , UnsignedLong& r) {   // 8a
  UnsignedLong num;
  num.val = (unsigned long)(l -= (char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *=  (Char& l , unsigned long& r) {   // 6a
  UnsignedLong num;
  num.val = (unsigned long)(l.val *= (char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *=  (char& l , UnsignedLong& r) {   // 8a
  UnsignedLong num;
  num.val = (unsigned long)(l *= (char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /=  (Char& l , unsigned long& r) {   // 6a
  UnsignedLong num;
  num.val = (unsigned long)(l.val /= (char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /=  (char& l , UnsignedLong& r) {   // 8a
  UnsignedLong num;
  num.val = (unsigned long)(l /= (char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator +   (Char& l , Long& r) { // 3a
  Long num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
Long operator -   (Char& l , Long& r) { // 3a
  Long num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
Long operator *   (Char& l , Long& r) { // 3a
  Long num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
Long operator /   (Char& l , Long& r) { // 3a
  Long num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
Long operator +=  (Char& l , Long& r) { // 3a
  Long num;
  num.val = (long)(l.val += (char)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator -=  (Char& l , Long& r) { // 3a
  Long num;
  num.val = (long)(l.val -= (char)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator *=  (Char& l , Long& r) { // 3a
  Long num;
  num.val = (long)(l.val *= (char)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator /=  (Char& l , Long& r) { // 3a
  Long num;
  num.val = (long)(l.val /= (char)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator +   (Char& l , long& r) {   // 6a
  Long num;
  num.val = ((long)l.val + r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator +   (char& l , Long& r) {   // 8a
  Long num;
  num.val = ((long)l + r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator -   (Char& l , long& r) {   // 6a
  Long num;
  num.val = ((long)l.val - r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator -   (char& l , Long& r) {   // 8a
  Long num;
  num.val = ((long)l - r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator *   (Char& l , long& r) {   // 6a
  Long num;
  num.val = ((long)l.val * r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator *   (char& l , Long& r) {   // 8a
  Long num;
  num.val = ((long)l * r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator /   (Char& l , long& r) {   // 6a
  Long num;
  num.val = ((long)l.val / r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator /   (char& l , Long& r) {   // 8a
  Long num;
  num.val = ((long)l / r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator +=  (Char& l , long& r) {   // 6a
  Long num;
  num.val = (long)(l.val += (char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator +=  (char& l , Long& r) {   // 8a
  Long num;
  num.val = (long)(l += (char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator -=  (Char& l , long& r) {   // 6a
  Long num;
  num.val = (long)(l.val -= (char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator -=  (char& l , Long& r) {   // 8a
  Long num;
  num.val = (long)(l -= (char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator *=  (Char& l , long& r) {   // 6a
  Long num;
  num.val = (long)(l.val *= (char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator *=  (char& l , Long& r) {   // 8a
  Long num;
  num.val = (long)(l *= (char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator /=  (Char& l , long& r) {   // 6a
  Long num;
  num.val = (long)(l.val /= (char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator /=  (char& l , Long& r) {   // 8a
  Long num;
  num.val = (long)(l /= (char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator +   (Char& l , Float& r) { // 3a
  Float num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
Float operator -   (Char& l , Float& r) { // 3a
  Float num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
Float operator *   (Char& l , Float& r) { // 3a
  Float num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
Float operator /   (Char& l , Float& r) { // 3a
  Float num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
Float operator +=  (Char& l , Float& r) { // 3a
  Float num;
  num.val = (float)(l.val += (char)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
Float operator -=  (Char& l , Float& r) { // 3a
  Float num;
  num.val = (float)(l.val -= (char)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
Float operator *=  (Char& l , Float& r) { // 3a
  Float num;
  num.val = (float)(l.val *= (char)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
Float operator /=  (Char& l , Float& r) { // 3a
  Float num;
  num.val = (float)(l.val /= (char)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
Float operator +   (Char& l , float& r) {   // 6a
  Float num;
  num.val = ((float)l.val + r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator +   (char& l , Float& r) {   // 8a
  Float num;
  num.val = ((float)l + r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator -   (Char& l , float& r) {   // 6a
  Float num;
  num.val = ((float)l.val - r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator -   (char& l , Float& r) {   // 8a
  Float num;
  num.val = ((float)l - r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator *   (Char& l , float& r) {   // 6a
  Float num;
  num.val = ((float)l.val * r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator *   (char& l , Float& r) {   // 8a
  Float num;
  num.val = ((float)l * r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator /   (Char& l , float& r) {   // 6a
  Float num;
  num.val = ((float)l.val / r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator /   (char& l , Float& r) {   // 8a
  Float num;
  num.val = ((float)l / r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator +=  (Char& l , float& r) {   // 6a
  Float num;
  num.val = (float)(l.val += (char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator +=  (char& l , Float& r) {   // 8a
  Float num;
  num.val = (float)(l += (char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator -=  (Char& l , float& r) {   // 6a
  Float num;
  num.val = (float)(l.val -= (char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator -=  (char& l , Float& r) {   // 8a
  Float num;
  num.val = (float)(l -= (char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator *=  (Char& l , float& r) {   // 6a
  Float num;
  num.val = (float)(l.val *= (char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator *=  (char& l , Float& r) {   // 8a
  Float num;
  num.val = (float)(l *= (char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator /=  (Char& l , float& r) {   // 6a
  Float num;
  num.val = (float)(l.val /= (char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator /=  (char& l , Float& r) {   // 8a
  Float num;
  num.val = (float)(l /= (char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator +   (Char& l , Double& r) { // 3a
  Double num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
Double operator -   (Char& l , Double& r) { // 3a
  Double num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
Double operator *   (Char& l , Double& r) { // 3a
  Double num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
Double operator /   (Char& l , Double& r) { // 3a
  Double num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
Double operator +=  (Char& l , Double& r) { // 3a
  Double num;
  num.val = (double)(l.val += (char)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
Double operator -=  (Char& l , Double& r) { // 3a
  Double num;
  num.val = (double)(l.val -= (char)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
Double operator *=  (Char& l , Double& r) { // 3a
  Double num;
  num.val = (double)(l.val *= (char)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
Double operator /=  (Char& l , Double& r) { // 3a
  Double num;
  num.val = (double)(l.val /= (char)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
Double operator +   (Char& l , double& r) {   // 6a
  Double num;
  num.val = ((double)l.val + r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator +   (char& l , Double& r) {   // 8a
  Double num;
  num.val = ((double)l + r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator -   (Char& l , double& r) {   // 6a
  Double num;
  num.val = ((double)l.val - r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator -   (char& l , Double& r) {   // 8a
  Double num;
  num.val = ((double)l - r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator *   (Char& l , double& r) {   // 6a
  Double num;
  num.val = ((double)l.val * r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator *   (char& l , Double& r) {   // 8a
  Double num;
  num.val = ((double)l * r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator /   (Char& l , double& r) {   // 6a
  Double num;
  num.val = ((double)l.val / r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator /   (char& l , Double& r) {   // 8a
  Double num;
  num.val = ((double)l / r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator +=  (Char& l , double& r) {   // 6a
  Double num;
  num.val = (double)(l.val += (char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator +=  (char& l , Double& r) {   // 8a
  Double num;
  num.val = (double)(l += (char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator -=  (Char& l , double& r) {   // 6a
  Double num;
  num.val = (double)(l.val -= (char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator -=  (char& l , Double& r) {   // 8a
  Double num;
  num.val = (double)(l -= (char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator *=  (Char& l , double& r) {   // 6a
  Double num;
  num.val = (double)(l.val *= (char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator *=  (char& l , Double& r) {   // 8a
  Double num;
  num.val = (double)(l *= (char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator /=  (Char& l , double& r) {   // 6a
  Double num;
  num.val = (double)(l.val /= (char)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator /=  (char& l , Double& r) {   // 8a
  Double num;
  num.val = (double)(l /= (char)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator %   (Char& l , UnsignedChar& r) { // 3i
  Char num;
  num.val = (l.val % r.val);
  num.u = (l.u %   r.u);
  return num;
}

// **********************************************************************************************************
Char operator &   (Char& l , UnsignedChar& r) { // 3i
  Char num;
  num.val = (l.val & r.val);
  num.u = (l.u &   r.u);
  return num;
}

// **********************************************************************************************************
Char operator ^   (Char& l , UnsignedChar& r) { // 3i
  Char num;
  num.val = (l.val ^ r.val);
  num.u = (l.u ^   r.u);
  return num;
}

// **********************************************************************************************************
Char operator |   (Char& l , UnsignedChar& r) { // 3i
  Char num;
  num.val = (l.val | r.val);
  num.u = (l.u |   r.u);
  return num;
}

// **********************************************************************************************************
Char operator <<  (Char& l , UnsignedChar& r) { // 3i
  Char num;
  num.val = (l.val << r.val);
  num.u = (l.u <<  r.u);
  return num;
}

// **********************************************************************************************************
Char operator >>  (Char& l , UnsignedChar& r) { // 3i
  Char num;
  num.val = (l.val >> r.val);
  num.u = (l.u >>  r.u);
  return num;
}

// **********************************************************************************************************
Char operator %=  (Char& l , UnsignedChar& r) { // 3i
  Char num;
  num.val = (l.val %= r.val);
  num.u = (l.u %=  r.u);
  return num;
}

// **********************************************************************************************************
Char operator &=  (Char& l , UnsignedChar& r) { // 3i
  Char num;
  num.val = (l.val &= r.val);
  num.u = (l.u &=  r.u);
  return num;
}

// **********************************************************************************************************
Char operator |=  (Char& l , UnsignedChar& r) { // 3i
  Char num;
  num.val = (l.val |= r.val);
  num.u = (l.u |=  r.u);
  return num;
}

// **********************************************************************************************************
Char operator ^=  (Char& l , UnsignedChar& r) { // 3i
  Char num;
  num.val = (l.val ^= r.val);
  num.u = (l.u ^=  r.u);
  return num;
}

// **********************************************************************************************************
Char operator <<= (Char& l , UnsignedChar& r) { // 3i
  Char num;
  num.val = (l.val <<= r.val);
  num.u = (l.u <<= r.u);
  return num;
}

// **********************************************************************************************************
Char operator >>= (Char& l , UnsignedChar& r) { // 3i
  Char num;
  num.val = (l.val >>= r.val);
  num.u = (l.u >>= r.u);
  return num;
}

// **********************************************************************************************************
Char operator %   (Char& l , unsigned char& r) { // 6i
  Char num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator %   (char& l , UnsignedChar& r) { // 8i
  Char num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator &   (Char& l , unsigned char& r) { // 6i
  Char num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator &   (char& l , UnsignedChar& r) { // 8i
  Char num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator ^   (Char& l , unsigned char& r) { // 6i
  Char num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator ^   (char& l , UnsignedChar& r) { // 8i
  Char num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator |   (Char& l , unsigned char& r) { // 6i
  Char num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator |   (char& l , UnsignedChar& r) { // 8i
  Char num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator <<  (Char& l , unsigned char& r) { // 6i
  Char num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator <<  (char& l , UnsignedChar& r) { // 8i
  Char num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator >>  (Char& l , unsigned char& r) { // 6i
  Char num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator >>  (char& l , UnsignedChar& r) { // 8i
  Char num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator %=  (Char& l , unsigned char& r) { // 6i
  Char num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator %=  (char& l , UnsignedChar& r) { // 8i
  Char num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator &=  (Char& l , unsigned char& r) { // 6i
  Char num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator &=  (char& l , UnsignedChar& r) { // 8i
  Char num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator |=  (Char& l , unsigned char& r) { // 6i
  Char num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator |=  (char& l , UnsignedChar& r) { // 8i
  Char num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator ^=  (Char& l , unsigned char& r) { // 6i
  Char num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator ^=  (char& l , UnsignedChar& r) { // 8i
  Char num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator <<= (Char& l , unsigned char& r) { // 6i
  Char num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator <<= (char& l , UnsignedChar& r) { // 8i
  Char num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator >>= (Char& l , unsigned char& r) { // 6i
  Char num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator >>= (char& l , UnsignedChar& r) { // 8i
  Char num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char Char::operator %   (Char& r) { // 1i
  Char num;
  num.val = (val % r.val);
  num.u = (u %   r.u);
  return num;
}

// **********************************************************************************************************
Char Char::operator &   (Char& r) { // 1i
  Char num;
  num.val = (val & r.val);
  num.u = (u &   r.u);
  return num;
}

// **********************************************************************************************************
Char Char::operator ^   (Char& r) { // 1i
  Char num;
  num.val = (val ^ r.val);
  num.u = (u ^   r.u);
  return num;
}

// **********************************************************************************************************
Char Char::operator |   (Char& r) { // 1i
  Char num;
  num.val = (val | r.val);
  num.u = (u |   r.u);
  return num;
}

// **********************************************************************************************************
Char Char::operator <<  (Char& r) { // 1i
  Char num;
  num.val = (val << r.val);
  num.u = (u <<  r.u);
  return num;
}

// **********************************************************************************************************
Char Char::operator >>  (Char& r) { // 1i
  Char num;
  num.val = (val >> r.val);
  num.u = (u >>  r.u);
  return num;
}

// **********************************************************************************************************
Char Char::operator %=  (Char& r) { // 1i
  Char num;
  num.val = (val %= r.val);
  num.u = (u %=  r.u);
  return num;
}

// **********************************************************************************************************
Char Char::operator &=  (Char& r) { // 1i
  Char num;
  num.val = (val &= r.val);
  num.u = (u &=  r.u);
  return num;
}

// **********************************************************************************************************
Char Char::operator |=  (Char& r) { // 1i
  Char num;
  num.val = (val |= r.val);
  num.u = (u |=  r.u);
  return num;
}

// **********************************************************************************************************
Char Char::operator ^=  (Char& r) { // 1i
  Char num;
  num.val = (val ^= r.val);
  num.u = (u ^=  r.u);
  return num;
}

// **********************************************************************************************************
Char Char::operator <<= (Char& r) { // 1i
  Char num;
  num.val = (val <<= r.val);
  num.u = (u <<= r.u);
  return num;
}

// **********************************************************************************************************
Char Char::operator >>= (Char& r) { // 1i
  Char num;
  num.val = (val >>= r.val);
  num.u = (u >>= r.u);
  return num;
}

// **********************************************************************************************************
Char operator %   (Char& l , char& r) { // 6i
  Char num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator %   (char& l , Char& r) { // 8i
  Char num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator &   (Char& l , char& r) { // 6i
  Char num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator &   (char& l , Char& r) { // 8i
  Char num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator ^   (Char& l , char& r) { // 6i
  Char num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator ^   (char& l , Char& r) { // 8i
  Char num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator |   (Char& l , char& r) { // 6i
  Char num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator |   (char& l , Char& r) { // 8i
  Char num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator <<  (Char& l , char& r) { // 6i
  Char num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator <<  (char& l , Char& r) { // 8i
  Char num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator >>  (Char& l , char& r) { // 6i
  Char num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator >>  (char& l , Char& r) { // 8i
  Char num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator %=  (Char& l , char& r) { // 6i
  Char num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator %=  (char& l , Char& r) { // 8i
  Char num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator &=  (Char& l , char& r) { // 6i
  Char num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator &=  (char& l , Char& r) { // 8i
  Char num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator |=  (Char& l , char& r) { // 6i
  Char num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator |=  (char& l , Char& r) { // 8i
  Char num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator ^=  (Char& l , char& r) { // 6i
  Char num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator ^=  (char& l , Char& r) { // 8i
  Char num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator <<= (Char& l , char& r) { // 6i
  Char num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator <<= (char& l , Char& r) { // 8i
  Char num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char operator >>= (Char& l , char& r) { // 6i
  Char num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Char operator >>= (char& l , Char& r) { // 8i
  Char num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator %   (Char& l , UnsignedShort& r) { // 3i
  UnsignedShort num;
  num.val = (l.val % r.val);
  num.u = (l.u %   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator &   (Char& l , UnsignedShort& r) { // 3i
  UnsignedShort num;
  num.val = (l.val & r.val);
  num.u = (l.u &   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator ^   (Char& l , UnsignedShort& r) { // 3i
  UnsignedShort num;
  num.val = (l.val ^ r.val);
  num.u = (l.u ^   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator |   (Char& l , UnsignedShort& r) { // 3i
  UnsignedShort num;
  num.val = (l.val | r.val);
  num.u = (l.u |   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator <<  (Char& l , UnsignedShort& r) { // 3i
  UnsignedShort num;
  num.val = (l.val << r.val);
  num.u = (l.u <<  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator >>  (Char& l , UnsignedShort& r) { // 3i
  UnsignedShort num;
  num.val = (l.val >> r.val);
  num.u = (l.u >>  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator %=  (Char& l , UnsignedShort& r) { // 3i
  UnsignedShort num;
  num.val = (l.val %= r.val);
  num.u = (l.u %=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator &=  (Char& l , UnsignedShort& r) { // 3i
  UnsignedShort num;
  num.val = (l.val &= r.val);
  num.u = (l.u &=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator |=  (Char& l , UnsignedShort& r) { // 3i
  UnsignedShort num;
  num.val = (l.val |= r.val);
  num.u = (l.u |=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator ^=  (Char& l , UnsignedShort& r) { // 3i
  UnsignedShort num;
  num.val = (l.val ^= r.val);
  num.u = (l.u ^=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator <<= (Char& l , UnsignedShort& r) { // 3i
  UnsignedShort num;
  num.val = (l.val <<= r.val);
  num.u = (l.u <<= r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator >>= (Char& l , UnsignedShort& r) { // 3i
  UnsignedShort num;
  num.val = (l.val >>= r.val);
  num.u = (l.u >>= r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator %   (Char& l , unsigned short& r) { // 6i
  UnsignedShort num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator %   (char& l , UnsignedShort& r) { // 8i
  UnsignedShort num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator &   (Char& l , unsigned short& r) { // 6i
  UnsignedShort num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator &   (char& l , UnsignedShort& r) { // 8i
  UnsignedShort num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator ^   (Char& l , unsigned short& r) { // 6i
  UnsignedShort num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator ^   (char& l , UnsignedShort& r) { // 8i
  UnsignedShort num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator |   (Char& l , unsigned short& r) { // 6i
  UnsignedShort num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator |   (char& l , UnsignedShort& r) { // 8i
  UnsignedShort num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator <<  (Char& l , unsigned short& r) { // 6i
  UnsignedShort num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator <<  (char& l , UnsignedShort& r) { // 8i
  UnsignedShort num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator >>  (Char& l , unsigned short& r) { // 6i
  UnsignedShort num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator >>  (char& l , UnsignedShort& r) { // 8i
  UnsignedShort num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator %=  (Char& l , unsigned short& r) { // 6i
  UnsignedShort num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator %=  (char& l , UnsignedShort& r) { // 8i
  UnsignedShort num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator &=  (Char& l , unsigned short& r) { // 6i
  UnsignedShort num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator &=  (char& l , UnsignedShort& r) { // 8i
  UnsignedShort num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator |=  (Char& l , unsigned short& r) { // 6i
  UnsignedShort num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator |=  (char& l , UnsignedShort& r) { // 8i
  UnsignedShort num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator ^=  (Char& l , unsigned short& r) { // 6i
  UnsignedShort num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator ^=  (char& l , UnsignedShort& r) { // 8i
  UnsignedShort num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator <<= (Char& l , unsigned short& r) { // 6i
  UnsignedShort num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator <<= (char& l , UnsignedShort& r) { // 8i
  UnsignedShort num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator >>= (Char& l , unsigned short& r) { // 6i
  UnsignedShort num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator >>= (char& l , UnsignedShort& r) { // 8i
  UnsignedShort num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator %   (Char& l , Short& r) { // 3i
  Short num;
  num.val = (l.val % r.val);
  num.u = (l.u %   r.u);
  return num;
}

// **********************************************************************************************************
Short operator &   (Char& l , Short& r) { // 3i
  Short num;
  num.val = (l.val & r.val);
  num.u = (l.u &   r.u);
  return num;
}

// **********************************************************************************************************
Short operator ^   (Char& l , Short& r) { // 3i
  Short num;
  num.val = (l.val ^ r.val);
  num.u = (l.u ^   r.u);
  return num;
}

// **********************************************************************************************************
Short operator |   (Char& l , Short& r) { // 3i
  Short num;
  num.val = (l.val | r.val);
  num.u = (l.u |   r.u);
  return num;
}

// **********************************************************************************************************
Short operator <<  (Char& l , Short& r) { // 3i
  Short num;
  num.val = (l.val << r.val);
  num.u = (l.u <<  r.u);
  return num;
}

// **********************************************************************************************************
Short operator >>  (Char& l , Short& r) { // 3i
  Short num;
  num.val = (l.val >> r.val);
  num.u = (l.u >>  r.u);
  return num;
}

// **********************************************************************************************************
Short operator %=  (Char& l , Short& r) { // 3i
  Short num;
  num.val = (l.val %= r.val);
  num.u = (l.u %=  r.u);
  return num;
}

// **********************************************************************************************************
Short operator &=  (Char& l , Short& r) { // 3i
  Short num;
  num.val = (l.val &= r.val);
  num.u = (l.u &=  r.u);
  return num;
}

// **********************************************************************************************************
Short operator |=  (Char& l , Short& r) { // 3i
  Short num;
  num.val = (l.val |= r.val);
  num.u = (l.u |=  r.u);
  return num;
}

// **********************************************************************************************************
Short operator ^=  (Char& l , Short& r) { // 3i
  Short num;
  num.val = (l.val ^= r.val);
  num.u = (l.u ^=  r.u);
  return num;
}

// **********************************************************************************************************
Short operator <<= (Char& l , Short& r) { // 3i
  Short num;
  num.val = (l.val <<= r.val);
  num.u = (l.u <<= r.u);
  return num;
}

// **********************************************************************************************************
Short operator >>= (Char& l , Short& r) { // 3i
  Short num;
  num.val = (l.val >>= r.val);
  num.u = (l.u >>= r.u);
  return num;
}

// **********************************************************************************************************
Short operator %   (Char& l , short& r) { // 6i
  Short num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator %   (char& l , Short& r) { // 8i
  Short num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator &   (Char& l , short& r) { // 6i
  Short num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator &   (char& l , Short& r) { // 8i
  Short num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator ^   (Char& l , short& r) { // 6i
  Short num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator ^   (char& l , Short& r) { // 8i
  Short num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator |   (Char& l , short& r) { // 6i
  Short num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator |   (char& l , Short& r) { // 8i
  Short num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator <<  (Char& l , short& r) { // 6i
  Short num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator <<  (char& l , Short& r) { // 8i
  Short num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator >>  (Char& l , short& r) { // 6i
  Short num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator >>  (char& l , Short& r) { // 8i
  Short num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator %=  (Char& l , short& r) { // 6i
  Short num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator %=  (char& l , Short& r) { // 8i
  Short num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator &=  (Char& l , short& r) { // 6i
  Short num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator &=  (char& l , Short& r) { // 8i
  Short num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator |=  (Char& l , short& r) { // 6i
  Short num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator |=  (char& l , Short& r) { // 8i
  Short num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator ^=  (Char& l , short& r) { // 6i
  Short num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator ^=  (char& l , Short& r) { // 8i
  Short num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator <<= (Char& l , short& r) { // 6i
  Short num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator <<= (char& l , Short& r) { // 8i
  Short num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator >>= (Char& l , short& r) { // 6i
  Short num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator >>= (char& l , Short& r) { // 8i
  Short num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator %   (Char& l , UnsignedInt& r) { // 3i
  UnsignedInt num;
  num.val = (l.val % r.val);
  num.u = (l.u %   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator &   (Char& l , UnsignedInt& r) { // 3i
  UnsignedInt num;
  num.val = (l.val & r.val);
  num.u = (l.u &   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator ^   (Char& l , UnsignedInt& r) { // 3i
  UnsignedInt num;
  num.val = (l.val ^ r.val);
  num.u = (l.u ^   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator |   (Char& l , UnsignedInt& r) { // 3i
  UnsignedInt num;
  num.val = (l.val | r.val);
  num.u = (l.u |   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator <<  (Char& l , UnsignedInt& r) { // 3i
  UnsignedInt num;
  num.val = (l.val << r.val);
  num.u = (l.u <<  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator >>  (Char& l , UnsignedInt& r) { // 3i
  UnsignedInt num;
  num.val = (l.val >> r.val);
  num.u = (l.u >>  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator %=  (Char& l , UnsignedInt& r) { // 3i
  UnsignedInt num;
  num.val = (l.val %= r.val);
  num.u = (l.u %=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator &=  (Char& l , UnsignedInt& r) { // 3i
  UnsignedInt num;
  num.val = (l.val &= r.val);
  num.u = (l.u &=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator |=  (Char& l , UnsignedInt& r) { // 3i
  UnsignedInt num;
  num.val = (l.val |= r.val);
  num.u = (l.u |=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator ^=  (Char& l , UnsignedInt& r) { // 3i
  UnsignedInt num;
  num.val = (l.val ^= r.val);
  num.u = (l.u ^=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator <<= (Char& l , UnsignedInt& r) { // 3i
  UnsignedInt num;
  num.val = (l.val <<= r.val);
  num.u = (l.u <<= r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator >>= (Char& l , UnsignedInt& r) { // 3i
  UnsignedInt num;
  num.val = (l.val >>= r.val);
  num.u = (l.u >>= r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator %   (Char& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator %   (char& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator &   (Char& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator &   (char& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator ^   (Char& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator ^   (char& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator |   (Char& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator |   (char& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator <<  (Char& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator <<  (char& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator >>  (Char& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator >>  (char& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator %=  (Char& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator %=  (char& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator &=  (Char& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator &=  (char& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator |=  (Char& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator |=  (char& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator ^=  (Char& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator ^=  (char& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator <<= (Char& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator <<= (char& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator >>= (Char& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator >>= (char& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator %   (Char& l , Int& r) { // 3i
  Int num;
  num.val = (l.val % r.val);
  num.u = (l.u %   r.u);
  return num;
}

// **********************************************************************************************************
Int operator &   (Char& l , Int& r) { // 3i
  Int num;
  num.val = (l.val & r.val);
  num.u = (l.u &   r.u);
  return num;
}

// **********************************************************************************************************
Int operator ^   (Char& l , Int& r) { // 3i
  Int num;
  num.val = (l.val ^ r.val);
  num.u = (l.u ^   r.u);
  return num;
}

// **********************************************************************************************************
Int operator |   (Char& l , Int& r) { // 3i
  Int num;
  num.val = (l.val | r.val);
  num.u = (l.u |   r.u);
  return num;
}

// **********************************************************************************************************
Int operator <<  (Char& l , Int& r) { // 3i
  Int num;
  num.val = (l.val << r.val);
  num.u = (l.u <<  r.u);
  return num;
}

// **********************************************************************************************************
Int operator >>  (Char& l , Int& r) { // 3i
  Int num;
  num.val = (l.val >> r.val);
  num.u = (l.u >>  r.u);
  return num;
}

// **********************************************************************************************************
Int operator %=  (Char& l , Int& r) { // 3i
  Int num;
  num.val = (l.val %= r.val);
  num.u = (l.u %=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator &=  (Char& l , Int& r) { // 3i
  Int num;
  num.val = (l.val &= r.val);
  num.u = (l.u &=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator |=  (Char& l , Int& r) { // 3i
  Int num;
  num.val = (l.val |= r.val);
  num.u = (l.u |=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator ^=  (Char& l , Int& r) { // 3i
  Int num;
  num.val = (l.val ^= r.val);
  num.u = (l.u ^=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator <<= (Char& l , Int& r) { // 3i
  Int num;
  num.val = (l.val <<= r.val);
  num.u = (l.u <<= r.u);
  return num;
}

// **********************************************************************************************************
Int operator >>= (Char& l , Int& r) { // 3i
  Int num;
  num.val = (l.val >>= r.val);
  num.u = (l.u >>= r.u);
  return num;
}

// **********************************************************************************************************
Int operator %   (Char& l , int& r) { // 6i
  Int num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator %   (char& l , Int& r) { // 8i
  Int num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator &   (Char& l , int& r) { // 6i
  Int num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator &   (char& l , Int& r) { // 8i
  Int num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator ^   (Char& l , int& r) { // 6i
  Int num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator ^   (char& l , Int& r) { // 8i
  Int num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator |   (Char& l , int& r) { // 6i
  Int num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator |   (char& l , Int& r) { // 8i
  Int num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator <<  (Char& l , int& r) { // 6i
  Int num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator <<  (char& l , Int& r) { // 8i
  Int num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator >>  (Char& l , int& r) { // 6i
  Int num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator >>  (char& l , Int& r) { // 8i
  Int num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator %=  (Char& l , int& r) { // 6i
  Int num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator %=  (char& l , Int& r) { // 8i
  Int num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator &=  (Char& l , int& r) { // 6i
  Int num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator &=  (char& l , Int& r) { // 8i
  Int num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator |=  (Char& l , int& r) { // 6i
  Int num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator |=  (char& l , Int& r) { // 8i
  Int num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator ^=  (Char& l , int& r) { // 6i
  Int num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator ^=  (char& l , Int& r) { // 8i
  Int num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator <<= (Char& l , int& r) { // 6i
  Int num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator <<= (char& l , Int& r) { // 8i
  Int num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator >>= (Char& l , int& r) { // 6i
  Int num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator >>= (char& l , Int& r) { // 8i
  Int num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %   (Char& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val % r.val);
  num.u = (l.u %   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &   (Char& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val & r.val);
  num.u = (l.u &   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^   (Char& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val ^ r.val);
  num.u = (l.u ^   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |   (Char& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val | r.val);
  num.u = (l.u |   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<  (Char& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val << r.val);
  num.u = (l.u <<  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>  (Char& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val >> r.val);
  num.u = (l.u >>  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %=  (Char& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val %= r.val);
  num.u = (l.u %=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &=  (Char& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val &= r.val);
  num.u = (l.u &=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |=  (Char& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val |= r.val);
  num.u = (l.u |=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^=  (Char& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val ^= r.val);
  num.u = (l.u ^=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<= (Char& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val <<= r.val);
  num.u = (l.u <<= r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>= (Char& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val >>= r.val);
  num.u = (l.u >>= r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %   (Char& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %   (char& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &   (Char& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &   (char& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^   (Char& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^   (char& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |   (Char& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |   (char& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<  (Char& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<  (char& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>  (Char& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>  (char& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %=  (Char& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %=  (char& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &=  (Char& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &=  (char& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |=  (Char& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |=  (char& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^=  (Char& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^=  (char& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<= (Char& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<= (char& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>= (Char& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>= (char& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator %   (Char& l , Long& r) { // 3i
  Long num;
  num.val = (l.val % r.val);
  num.u = (l.u %   r.u);
  return num;
}

// **********************************************************************************************************
Long operator &   (Char& l , Long& r) { // 3i
  Long num;
  num.val = (l.val & r.val);
  num.u = (l.u &   r.u);
  return num;
}

// **********************************************************************************************************
Long operator ^   (Char& l , Long& r) { // 3i
  Long num;
  num.val = (l.val ^ r.val);
  num.u = (l.u ^   r.u);
  return num;
}

// **********************************************************************************************************
Long operator |   (Char& l , Long& r) { // 3i
  Long num;
  num.val = (l.val | r.val);
  num.u = (l.u |   r.u);
  return num;
}

// **********************************************************************************************************
Long operator <<  (Char& l , Long& r) { // 3i
  Long num;
  num.val = (l.val << r.val);
  num.u = (l.u <<  r.u);
  return num;
}

// **********************************************************************************************************
Long operator >>  (Char& l , Long& r) { // 3i
  Long num;
  num.val = (l.val >> r.val);
  num.u = (l.u >>  r.u);
  return num;
}

// **********************************************************************************************************
Long operator %=  (Char& l , Long& r) { // 3i
  Long num;
  num.val = (l.val %= r.val);
  num.u = (l.u %=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator &=  (Char& l , Long& r) { // 3i
  Long num;
  num.val = (l.val &= r.val);
  num.u = (l.u &=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator |=  (Char& l , Long& r) { // 3i
  Long num;
  num.val = (l.val |= r.val);
  num.u = (l.u |=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator ^=  (Char& l , Long& r) { // 3i
  Long num;
  num.val = (l.val ^= r.val);
  num.u = (l.u ^=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator <<= (Char& l , Long& r) { // 3i
  Long num;
  num.val = (l.val <<= r.val);
  num.u = (l.u <<= r.u);
  return num;
}

// **********************************************************************************************************
Long operator >>= (Char& l , Long& r) { // 3i
  Long num;
  num.val = (l.val >>= r.val);
  num.u = (l.u >>= r.u);
  return num;
}

// **********************************************************************************************************
Long operator %   (Char& l , long& r) { // 6i
  Long num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator %   (char& l , Long& r) { // 8i
  Long num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator &   (Char& l , long& r) { // 6i
  Long num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator &   (char& l , Long& r) { // 8i
  Long num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator ^   (Char& l , long& r) { // 6i
  Long num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator ^   (char& l , Long& r) { // 8i
  Long num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator |   (Char& l , long& r) { // 6i
  Long num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator |   (char& l , Long& r) { // 8i
  Long num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator <<  (Char& l , long& r) { // 6i
  Long num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator <<  (char& l , Long& r) { // 8i
  Long num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator >>  (Char& l , long& r) { // 6i
  Long num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator >>  (char& l , Long& r) { // 8i
  Long num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator %=  (Char& l , long& r) { // 6i
  Long num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator %=  (char& l , Long& r) { // 8i
  Long num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator &=  (Char& l , long& r) { // 6i
  Long num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator &=  (char& l , Long& r) { // 8i
  Long num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator |=  (Char& l , long& r) { // 6i
  Long num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator |=  (char& l , Long& r) { // 8i
  Long num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator ^=  (Char& l , long& r) { // 6i
  Long num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator ^=  (char& l , Long& r) { // 8i
  Long num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator <<= (Char& l , long& r) { // 6i
  Long num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator <<= (char& l , Long& r) { // 8i
  Long num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator >>= (Char& l , long& r) { // 6i
  Long num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator >>= (char& l , Long& r) { // 8i
  Long num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Char Char::operator ++(void) { // 1p, Prefix operator
   ++val;
  return *this;
}

// **********************************************************************************************************
Char Char::operator --(void) { // 1p, Prefix operator
   --val;
  return *this;
}

// **********************************************************************************************************
Char Char::operator ++(int) { // 1p, Postfix operator
   val++;
  return *this;
}

// **********************************************************************************************************
Char Char::operator --(int) { // 1p, Postfix operator
   val--;
  return *this;
}

// *********************************************************************************************************
// First class UnsignedShort constructor
// *********************************************************************************************************
UnsignedShort::UnsignedShort() {
  val=0;
  state=UNDEF;
  u.init();
}
// *********************************************************************************************************
// Second class UnsignedShort constructor
// *********************************************************************************************************
UnsignedShort::UnsignedShort(char* str) {
  val=0;
  state=UNDEF;
  u.init(str);
}
// *********************************************************************************************************
// First class UnsignedShort destructor
// *********************************************************************************************************
UnsignedShort::~UnsignedShort() {
  val=0;
  state=UNDEF;
  u.init();
}
// **********************************************************************************************************
UnsignedShort operator +   (UnsignedShort& l , UnsignedChar& r) { // 3a
  UnsignedShort num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator -   (UnsignedShort& l , UnsignedChar& r) { // 3a
  UnsignedShort num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator *   (UnsignedShort& l , UnsignedChar& r) { // 3a
  UnsignedShort num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator /   (UnsignedShort& l , UnsignedChar& r) { // 3a
  UnsignedShort num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator +=  (UnsignedShort& l , UnsignedChar& r) { // 3a
  UnsignedShort num;
  num.val = (unsigned short)(l.val += (unsigned short)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator -=  (UnsignedShort& l , UnsignedChar& r) { // 3a
  UnsignedShort num;
  num.val = (unsigned short)(l.val -= (unsigned short)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator *=  (UnsignedShort& l , UnsignedChar& r) { // 3a
  UnsignedShort num;
  num.val = (unsigned short)(l.val *= (unsigned short)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator /=  (UnsignedShort& l , UnsignedChar& r) { // 3a
  UnsignedShort num;
  num.val = (unsigned short)(l.val /= (unsigned short)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator +   (UnsignedShort& l , unsigned char& r) {   // 6a
  UnsignedShort num;
  num.val = (l.val + (unsigned short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator +   (unsigned short& l , UnsignedChar& r) {   // 8a
  UnsignedShort num;
  num.val = (l + (unsigned short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator -   (UnsignedShort& l , unsigned char& r) {   // 6a
  UnsignedShort num;
  num.val = (l.val - (unsigned short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator -   (unsigned short& l , UnsignedChar& r) {   // 8a
  UnsignedShort num;
  num.val = (l - (unsigned short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator *   (UnsignedShort& l , unsigned char& r) {   // 6a
  UnsignedShort num;
  num.val = (l.val * (unsigned short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator *   (unsigned short& l , UnsignedChar& r) {   // 8a
  UnsignedShort num;
  num.val = (l * (unsigned short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator /   (UnsignedShort& l , unsigned char& r) {   // 6a
  UnsignedShort num;
  num.val = (l.val / (unsigned short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator /   (unsigned short& l , UnsignedChar& r) {   // 8a
  UnsignedShort num;
  num.val = (l / (unsigned short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator +=  (UnsignedShort& l , unsigned char& r) {   // 6a
  UnsignedShort num;
  num.val = (unsigned short)(l.val += (unsigned short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator +=  (unsigned short& l , UnsignedChar& r) {   // 8a
  UnsignedShort num;
  num.val = (unsigned short)(l += (unsigned short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator -=  (UnsignedShort& l , unsigned char& r) {   // 6a
  UnsignedShort num;
  num.val = (unsigned short)(l.val -= (unsigned short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator -=  (unsigned short& l , UnsignedChar& r) {   // 8a
  UnsignedShort num;
  num.val = (unsigned short)(l -= (unsigned short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator *=  (UnsignedShort& l , unsigned char& r) {   // 6a
  UnsignedShort num;
  num.val = (unsigned short)(l.val *= (unsigned short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator *=  (unsigned short& l , UnsignedChar& r) {   // 8a
  UnsignedShort num;
  num.val = (unsigned short)(l *= (unsigned short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator /=  (UnsignedShort& l , unsigned char& r) {   // 6a
  UnsignedShort num;
  num.val = (unsigned short)(l.val /= (unsigned short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator /=  (unsigned short& l , UnsignedChar& r) {   // 8a
  UnsignedShort num;
  num.val = (unsigned short)(l /= (unsigned short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator +   (UnsignedShort& l , Char& r) { // 3a
  UnsignedShort num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator -   (UnsignedShort& l , Char& r) { // 3a
  UnsignedShort num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator *   (UnsignedShort& l , Char& r) { // 3a
  UnsignedShort num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator /   (UnsignedShort& l , Char& r) { // 3a
  UnsignedShort num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator +=  (UnsignedShort& l , Char& r) { // 3a
  UnsignedShort num;
  num.val = (unsigned short)(l.val += (unsigned short)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator -=  (UnsignedShort& l , Char& r) { // 3a
  UnsignedShort num;
  num.val = (unsigned short)(l.val -= (unsigned short)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator *=  (UnsignedShort& l , Char& r) { // 3a
  UnsignedShort num;
  num.val = (unsigned short)(l.val *= (unsigned short)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator /=  (UnsignedShort& l , Char& r) { // 3a
  UnsignedShort num;
  num.val = (unsigned short)(l.val /= (unsigned short)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator +   (UnsignedShort& l , char& r) {   // 6a
  UnsignedShort num;
  num.val = (l.val + (unsigned short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator +   (unsigned short& l , Char& r) {   // 8a
  UnsignedShort num;
  num.val = (l + (unsigned short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator -   (UnsignedShort& l , char& r) {   // 6a
  UnsignedShort num;
  num.val = (l.val - (unsigned short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator -   (unsigned short& l , Char& r) {   // 8a
  UnsignedShort num;
  num.val = (l - (unsigned short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator *   (UnsignedShort& l , char& r) {   // 6a
  UnsignedShort num;
  num.val = (l.val * (unsigned short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator *   (unsigned short& l , Char& r) {   // 8a
  UnsignedShort num;
  num.val = (l * (unsigned short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator /   (UnsignedShort& l , char& r) {   // 6a
  UnsignedShort num;
  num.val = (l.val / (unsigned short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator /   (unsigned short& l , Char& r) {   // 8a
  UnsignedShort num;
  num.val = (l / (unsigned short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator +=  (UnsignedShort& l , char& r) {   // 6a
  UnsignedShort num;
  num.val = (unsigned short)(l.val += (unsigned short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator +=  (unsigned short& l , Char& r) {   // 8a
  UnsignedShort num;
  num.val = (unsigned short)(l += (unsigned short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator -=  (UnsignedShort& l , char& r) {   // 6a
  UnsignedShort num;
  num.val = (unsigned short)(l.val -= (unsigned short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator -=  (unsigned short& l , Char& r) {   // 8a
  UnsignedShort num;
  num.val = (unsigned short)(l -= (unsigned short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator *=  (UnsignedShort& l , char& r) {   // 6a
  UnsignedShort num;
  num.val = (unsigned short)(l.val *= (unsigned short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator *=  (unsigned short& l , Char& r) {   // 8a
  UnsignedShort num;
  num.val = (unsigned short)(l *= (unsigned short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator /=  (UnsignedShort& l , char& r) {   // 6a
  UnsignedShort num;
  num.val = (unsigned short)(l.val /= (unsigned short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator /=  (unsigned short& l , Char& r) {   // 8a
  UnsignedShort num;
  num.val = (unsigned short)(l /= (unsigned short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort UnsignedShort::operator +   (UnsignedShort& r) { // 1a
  UnsignedShort num;
  num.val = (val + r.val);
  num.u = (u +   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort UnsignedShort::operator -   (UnsignedShort& r) { // 1a
  UnsignedShort num;
  num.val = (val - r.val);
  num.u = (u -   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort UnsignedShort::operator *   (UnsignedShort& r) { // 1a
  UnsignedShort num;
  num.val = (val * r.val);
  num.u = (u *   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort UnsignedShort::operator /   (UnsignedShort& r) { // 1a
  UnsignedShort num;
  num.val = (val / r.val);
  num.u = (u /   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort UnsignedShort::operator +=  (UnsignedShort& r) { // 1a
  UnsignedShort num;
  num.val = (val += r.val);
  num.u = (u +=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort UnsignedShort::operator -=  (UnsignedShort& r) { // 1a
  UnsignedShort num;
  num.val = (val -= r.val);
  num.u = (u -=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort UnsignedShort::operator *=  (UnsignedShort& r) { // 1a
  UnsignedShort num;
  num.val = (val *= r.val);
  num.u = (u *=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort UnsignedShort::operator /=  (UnsignedShort& r) { // 1a
  UnsignedShort num;
  num.val = (val /= r.val);
  num.u = (u /=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator +   (UnsignedShort& l , unsigned short& r) {   // 6a
  UnsignedShort num;
  num.val = (l.val + r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator +   (unsigned short& l , UnsignedShort& r) {   // 8a
  UnsignedShort num;
  num.val = (l + r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator -   (UnsignedShort& l , unsigned short& r) {   // 6a
  UnsignedShort num;
  num.val = (l.val - r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator -   (unsigned short& l , UnsignedShort& r) {   // 8a
  UnsignedShort num;
  num.val = (l - r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator *   (UnsignedShort& l , unsigned short& r) {   // 6a
  UnsignedShort num;
  num.val = (l.val * r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator *   (unsigned short& l , UnsignedShort& r) {   // 8a
  UnsignedShort num;
  num.val = (l * r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator /   (UnsignedShort& l , unsigned short& r) {   // 6a
  UnsignedShort num;
  num.val = (l.val / r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator /   (unsigned short& l , UnsignedShort& r) {   // 8a
  UnsignedShort num;
  num.val = (l / r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator +=  (UnsignedShort& l , unsigned short& r) {   // 6a
  UnsignedShort num;
  num.val = (unsigned short)(l.val += (unsigned short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator +=  (unsigned short& l , UnsignedShort& r) {   // 8a
  UnsignedShort num;
  num.val = (unsigned short)(l += (unsigned short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator -=  (UnsignedShort& l , unsigned short& r) {   // 6a
  UnsignedShort num;
  num.val = (unsigned short)(l.val -= (unsigned short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator -=  (unsigned short& l , UnsignedShort& r) {   // 8a
  UnsignedShort num;
  num.val = (unsigned short)(l -= (unsigned short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator *=  (UnsignedShort& l , unsigned short& r) {   // 6a
  UnsignedShort num;
  num.val = (unsigned short)(l.val *= (unsigned short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator *=  (unsigned short& l , UnsignedShort& r) {   // 8a
  UnsignedShort num;
  num.val = (unsigned short)(l *= (unsigned short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator /=  (UnsignedShort& l , unsigned short& r) {   // 6a
  UnsignedShort num;
  num.val = (unsigned short)(l.val /= (unsigned short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator /=  (unsigned short& l , UnsignedShort& r) {   // 8a
  UnsignedShort num;
  num.val = (unsigned short)(l /= (unsigned short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator +   (UnsignedShort& l , Short& r) { // 3a
  Short num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
Short operator -   (UnsignedShort& l , Short& r) { // 3a
  Short num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
Short operator *   (UnsignedShort& l , Short& r) { // 3a
  Short num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
Short operator /   (UnsignedShort& l , Short& r) { // 3a
  Short num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
Short operator +=  (UnsignedShort& l , Short& r) { // 3a
  Short num;
  num.val = (short)(l.val += (unsigned short)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
Short operator -=  (UnsignedShort& l , Short& r) { // 3a
  Short num;
  num.val = (short)(l.val -= (unsigned short)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
Short operator *=  (UnsignedShort& l , Short& r) { // 3a
  Short num;
  num.val = (short)(l.val *= (unsigned short)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
Short operator /=  (UnsignedShort& l , Short& r) { // 3a
  Short num;
  num.val = (short)(l.val /= (unsigned short)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
Short operator +   (UnsignedShort& l , short& r) {   // 6a
  Short num;
  num.val = ((short)l.val + r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator +   (unsigned short& l , Short& r) {   // 8a
  Short num;
  num.val = ((short)l + r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator -   (UnsignedShort& l , short& r) {   // 6a
  Short num;
  num.val = ((short)l.val - r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator -   (unsigned short& l , Short& r) {   // 8a
  Short num;
  num.val = ((short)l - r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator *   (UnsignedShort& l , short& r) {   // 6a
  Short num;
  num.val = ((short)l.val * r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator *   (unsigned short& l , Short& r) {   // 8a
  Short num;
  num.val = ((short)l * r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator /   (UnsignedShort& l , short& r) {   // 6a
  Short num;
  num.val = ((short)l.val / r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator /   (unsigned short& l , Short& r) {   // 8a
  Short num;
  num.val = ((short)l / r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator +=  (UnsignedShort& l , short& r) {   // 6a
  Short num;
  num.val = (short)(l.val += (unsigned short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator +=  (unsigned short& l , Short& r) {   // 8a
  Short num;
  num.val = (short)(l += (unsigned short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator -=  (UnsignedShort& l , short& r) {   // 6a
  Short num;
  num.val = (short)(l.val -= (unsigned short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator -=  (unsigned short& l , Short& r) {   // 8a
  Short num;
  num.val = (short)(l -= (unsigned short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator *=  (UnsignedShort& l , short& r) {   // 6a
  Short num;
  num.val = (short)(l.val *= (unsigned short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator *=  (unsigned short& l , Short& r) {   // 8a
  Short num;
  num.val = (short)(l *= (unsigned short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator /=  (UnsignedShort& l , short& r) {   // 6a
  Short num;
  num.val = (short)(l.val /= (unsigned short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator /=  (unsigned short& l , Short& r) {   // 8a
  Short num;
  num.val = (short)(l /= (unsigned short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator +   (UnsignedShort& l , UnsignedInt& r) { // 3a
  UnsignedInt num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator -   (UnsignedShort& l , UnsignedInt& r) { // 3a
  UnsignedInt num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator *   (UnsignedShort& l , UnsignedInt& r) { // 3a
  UnsignedInt num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator /   (UnsignedShort& l , UnsignedInt& r) { // 3a
  UnsignedInt num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator +=  (UnsignedShort& l , UnsignedInt& r) { // 3a
  UnsignedInt num;
  num.val = (unsigned int)(l.val += (unsigned short)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator -=  (UnsignedShort& l , UnsignedInt& r) { // 3a
  UnsignedInt num;
  num.val = (unsigned int)(l.val -= (unsigned short)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator *=  (UnsignedShort& l , UnsignedInt& r) { // 3a
  UnsignedInt num;
  num.val = (unsigned int)(l.val *= (unsigned short)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator /=  (UnsignedShort& l , UnsignedInt& r) { // 3a
  UnsignedInt num;
  num.val = (unsigned int)(l.val /= (unsigned short)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator +   (UnsignedShort& l , unsigned int& r) {   // 6a
  UnsignedInt num;
  num.val = ((unsigned int)l.val + r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator +   (unsigned short& l , UnsignedInt& r) {   // 8a
  UnsignedInt num;
  num.val = ((unsigned int)l + r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator -   (UnsignedShort& l , unsigned int& r) {   // 6a
  UnsignedInt num;
  num.val = ((unsigned int)l.val - r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator -   (unsigned short& l , UnsignedInt& r) {   // 8a
  UnsignedInt num;
  num.val = ((unsigned int)l - r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator *   (UnsignedShort& l , unsigned int& r) {   // 6a
  UnsignedInt num;
  num.val = ((unsigned int)l.val * r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator *   (unsigned short& l , UnsignedInt& r) {   // 8a
  UnsignedInt num;
  num.val = ((unsigned int)l * r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator /   (UnsignedShort& l , unsigned int& r) {   // 6a
  UnsignedInt num;
  num.val = ((unsigned int)l.val / r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator /   (unsigned short& l , UnsignedInt& r) {   // 8a
  UnsignedInt num;
  num.val = ((unsigned int)l / r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator +=  (UnsignedShort& l , unsigned int& r) {   // 6a
  UnsignedInt num;
  num.val = (unsigned int)(l.val += (unsigned short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator +=  (unsigned short& l , UnsignedInt& r) {   // 8a
  UnsignedInt num;
  num.val = (unsigned int)(l += (unsigned short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator -=  (UnsignedShort& l , unsigned int& r) {   // 6a
  UnsignedInt num;
  num.val = (unsigned int)(l.val -= (unsigned short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator -=  (unsigned short& l , UnsignedInt& r) {   // 8a
  UnsignedInt num;
  num.val = (unsigned int)(l -= (unsigned short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator *=  (UnsignedShort& l , unsigned int& r) {   // 6a
  UnsignedInt num;
  num.val = (unsigned int)(l.val *= (unsigned short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator *=  (unsigned short& l , UnsignedInt& r) {   // 8a
  UnsignedInt num;
  num.val = (unsigned int)(l *= (unsigned short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator /=  (UnsignedShort& l , unsigned int& r) {   // 6a
  UnsignedInt num;
  num.val = (unsigned int)(l.val /= (unsigned short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator /=  (unsigned short& l , UnsignedInt& r) {   // 8a
  UnsignedInt num;
  num.val = (unsigned int)(l /= (unsigned short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator +   (UnsignedShort& l , Int& r) { // 3a
  Int num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
Int operator -   (UnsignedShort& l , Int& r) { // 3a
  Int num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
Int operator *   (UnsignedShort& l , Int& r) { // 3a
  Int num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
Int operator /   (UnsignedShort& l , Int& r) { // 3a
  Int num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
Int operator +=  (UnsignedShort& l , Int& r) { // 3a
  Int num;
  num.val = (int)(l.val += (unsigned short)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator -=  (UnsignedShort& l , Int& r) { // 3a
  Int num;
  num.val = (int)(l.val -= (unsigned short)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator *=  (UnsignedShort& l , Int& r) { // 3a
  Int num;
  num.val = (int)(l.val *= (unsigned short)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator /=  (UnsignedShort& l , Int& r) { // 3a
  Int num;
  num.val = (int)(l.val /= (unsigned short)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator +   (UnsignedShort& l , int& r) {   // 6a
  Int num;
  num.val = ((int)l.val + r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator +   (unsigned short& l , Int& r) {   // 8a
  Int num;
  num.val = ((int)l + r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator -   (UnsignedShort& l , int& r) {   // 6a
  Int num;
  num.val = ((int)l.val - r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator -   (unsigned short& l , Int& r) {   // 8a
  Int num;
  num.val = ((int)l - r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator *   (UnsignedShort& l , int& r) {   // 6a
  Int num;
  num.val = ((int)l.val * r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator *   (unsigned short& l , Int& r) {   // 8a
  Int num;
  num.val = ((int)l * r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator /   (UnsignedShort& l , int& r) {   // 6a
  Int num;
  num.val = ((int)l.val / r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator /   (unsigned short& l , Int& r) {   // 8a
  Int num;
  num.val = ((int)l / r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator +=  (UnsignedShort& l , int& r) {   // 6a
  Int num;
  num.val = (int)(l.val += (unsigned short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator +=  (unsigned short& l , Int& r) {   // 8a
  Int num;
  num.val = (int)(l += (unsigned short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator -=  (UnsignedShort& l , int& r) {   // 6a
  Int num;
  num.val = (int)(l.val -= (unsigned short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator -=  (unsigned short& l , Int& r) {   // 8a
  Int num;
  num.val = (int)(l -= (unsigned short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator *=  (UnsignedShort& l , int& r) {   // 6a
  Int num;
  num.val = (int)(l.val *= (unsigned short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator *=  (unsigned short& l , Int& r) {   // 8a
  Int num;
  num.val = (int)(l *= (unsigned short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator /=  (UnsignedShort& l , int& r) {   // 6a
  Int num;
  num.val = (int)(l.val /= (unsigned short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator /=  (unsigned short& l , Int& r) {   // 8a
  Int num;
  num.val = (int)(l /= (unsigned short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +   (UnsignedShort& l , UnsignedLong& r) { // 3a
  UnsignedLong num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -   (UnsignedShort& l , UnsignedLong& r) { // 3a
  UnsignedLong num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *   (UnsignedShort& l , UnsignedLong& r) { // 3a
  UnsignedLong num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /   (UnsignedShort& l , UnsignedLong& r) { // 3a
  UnsignedLong num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +=  (UnsignedShort& l , UnsignedLong& r) { // 3a
  UnsignedLong num;
  num.val = (unsigned long)(l.val += (unsigned short)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -=  (UnsignedShort& l , UnsignedLong& r) { // 3a
  UnsignedLong num;
  num.val = (unsigned long)(l.val -= (unsigned short)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *=  (UnsignedShort& l , UnsignedLong& r) { // 3a
  UnsignedLong num;
  num.val = (unsigned long)(l.val *= (unsigned short)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /=  (UnsignedShort& l , UnsignedLong& r) { // 3a
  UnsignedLong num;
  num.val = (unsigned long)(l.val /= (unsigned short)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +   (UnsignedShort& l , unsigned long& r) {   // 6a
  UnsignedLong num;
  num.val = ((unsigned long)l.val + r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +   (unsigned short& l , UnsignedLong& r) {   // 8a
  UnsignedLong num;
  num.val = ((unsigned long)l + r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -   (UnsignedShort& l , unsigned long& r) {   // 6a
  UnsignedLong num;
  num.val = ((unsigned long)l.val - r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -   (unsigned short& l , UnsignedLong& r) {   // 8a
  UnsignedLong num;
  num.val = ((unsigned long)l - r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *   (UnsignedShort& l , unsigned long& r) {   // 6a
  UnsignedLong num;
  num.val = ((unsigned long)l.val * r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *   (unsigned short& l , UnsignedLong& r) {   // 8a
  UnsignedLong num;
  num.val = ((unsigned long)l * r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /   (UnsignedShort& l , unsigned long& r) {   // 6a
  UnsignedLong num;
  num.val = ((unsigned long)l.val / r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /   (unsigned short& l , UnsignedLong& r) {   // 8a
  UnsignedLong num;
  num.val = ((unsigned long)l / r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +=  (UnsignedShort& l , unsigned long& r) {   // 6a
  UnsignedLong num;
  num.val = (unsigned long)(l.val += (unsigned short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +=  (unsigned short& l , UnsignedLong& r) {   // 8a
  UnsignedLong num;
  num.val = (unsigned long)(l += (unsigned short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -=  (UnsignedShort& l , unsigned long& r) {   // 6a
  UnsignedLong num;
  num.val = (unsigned long)(l.val -= (unsigned short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -=  (unsigned short& l , UnsignedLong& r) {   // 8a
  UnsignedLong num;
  num.val = (unsigned long)(l -= (unsigned short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *=  (UnsignedShort& l , unsigned long& r) {   // 6a
  UnsignedLong num;
  num.val = (unsigned long)(l.val *= (unsigned short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *=  (unsigned short& l , UnsignedLong& r) {   // 8a
  UnsignedLong num;
  num.val = (unsigned long)(l *= (unsigned short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /=  (UnsignedShort& l , unsigned long& r) {   // 6a
  UnsignedLong num;
  num.val = (unsigned long)(l.val /= (unsigned short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /=  (unsigned short& l , UnsignedLong& r) {   // 8a
  UnsignedLong num;
  num.val = (unsigned long)(l /= (unsigned short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator +   (UnsignedShort& l , Long& r) { // 3a
  Long num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
Long operator -   (UnsignedShort& l , Long& r) { // 3a
  Long num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
Long operator *   (UnsignedShort& l , Long& r) { // 3a
  Long num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
Long operator /   (UnsignedShort& l , Long& r) { // 3a
  Long num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
Long operator +=  (UnsignedShort& l , Long& r) { // 3a
  Long num;
  num.val = (long)(l.val += (unsigned short)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator -=  (UnsignedShort& l , Long& r) { // 3a
  Long num;
  num.val = (long)(l.val -= (unsigned short)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator *=  (UnsignedShort& l , Long& r) { // 3a
  Long num;
  num.val = (long)(l.val *= (unsigned short)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator /=  (UnsignedShort& l , Long& r) { // 3a
  Long num;
  num.val = (long)(l.val /= (unsigned short)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator +   (UnsignedShort& l , long& r) {   // 6a
  Long num;
  num.val = ((long)l.val + r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator +   (unsigned short& l , Long& r) {   // 8a
  Long num;
  num.val = ((long)l + r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator -   (UnsignedShort& l , long& r) {   // 6a
  Long num;
  num.val = ((long)l.val - r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator -   (unsigned short& l , Long& r) {   // 8a
  Long num;
  num.val = ((long)l - r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator *   (UnsignedShort& l , long& r) {   // 6a
  Long num;
  num.val = ((long)l.val * r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator *   (unsigned short& l , Long& r) {   // 8a
  Long num;
  num.val = ((long)l * r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator /   (UnsignedShort& l , long& r) {   // 6a
  Long num;
  num.val = ((long)l.val / r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator /   (unsigned short& l , Long& r) {   // 8a
  Long num;
  num.val = ((long)l / r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator +=  (UnsignedShort& l , long& r) {   // 6a
  Long num;
  num.val = (long)(l.val += (unsigned short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator +=  (unsigned short& l , Long& r) {   // 8a
  Long num;
  num.val = (long)(l += (unsigned short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator -=  (UnsignedShort& l , long& r) {   // 6a
  Long num;
  num.val = (long)(l.val -= (unsigned short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator -=  (unsigned short& l , Long& r) {   // 8a
  Long num;
  num.val = (long)(l -= (unsigned short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator *=  (UnsignedShort& l , long& r) {   // 6a
  Long num;
  num.val = (long)(l.val *= (unsigned short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator *=  (unsigned short& l , Long& r) {   // 8a
  Long num;
  num.val = (long)(l *= (unsigned short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator /=  (UnsignedShort& l , long& r) {   // 6a
  Long num;
  num.val = (long)(l.val /= (unsigned short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator /=  (unsigned short& l , Long& r) {   // 8a
  Long num;
  num.val = (long)(l /= (unsigned short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator +   (UnsignedShort& l , Float& r) { // 3a
  Float num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
Float operator -   (UnsignedShort& l , Float& r) { // 3a
  Float num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
Float operator *   (UnsignedShort& l , Float& r) { // 3a
  Float num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
Float operator /   (UnsignedShort& l , Float& r) { // 3a
  Float num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
Float operator +=  (UnsignedShort& l , Float& r) { // 3a
  Float num;
  num.val = (float)(l.val += (unsigned short)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
Float operator -=  (UnsignedShort& l , Float& r) { // 3a
  Float num;
  num.val = (float)(l.val -= (unsigned short)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
Float operator *=  (UnsignedShort& l , Float& r) { // 3a
  Float num;
  num.val = (float)(l.val *= (unsigned short)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
Float operator /=  (UnsignedShort& l , Float& r) { // 3a
  Float num;
  num.val = (float)(l.val /= (unsigned short)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
Float operator +   (UnsignedShort& l , float& r) {   // 6a
  Float num;
  num.val = ((float)l.val + r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator +   (unsigned short& l , Float& r) {   // 8a
  Float num;
  num.val = ((float)l + r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator -   (UnsignedShort& l , float& r) {   // 6a
  Float num;
  num.val = ((float)l.val - r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator -   (unsigned short& l , Float& r) {   // 8a
  Float num;
  num.val = ((float)l - r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator *   (UnsignedShort& l , float& r) {   // 6a
  Float num;
  num.val = ((float)l.val * r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator *   (unsigned short& l , Float& r) {   // 8a
  Float num;
  num.val = ((float)l * r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator /   (UnsignedShort& l , float& r) {   // 6a
  Float num;
  num.val = ((float)l.val / r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator /   (unsigned short& l , Float& r) {   // 8a
  Float num;
  num.val = ((float)l / r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator +=  (UnsignedShort& l , float& r) {   // 6a
  Float num;
  num.val = (float)(l.val += (unsigned short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator +=  (unsigned short& l , Float& r) {   // 8a
  Float num;
  num.val = (float)(l += (unsigned short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator -=  (UnsignedShort& l , float& r) {   // 6a
  Float num;
  num.val = (float)(l.val -= (unsigned short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator -=  (unsigned short& l , Float& r) {   // 8a
  Float num;
  num.val = (float)(l -= (unsigned short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator *=  (UnsignedShort& l , float& r) {   // 6a
  Float num;
  num.val = (float)(l.val *= (unsigned short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator *=  (unsigned short& l , Float& r) {   // 8a
  Float num;
  num.val = (float)(l *= (unsigned short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator /=  (UnsignedShort& l , float& r) {   // 6a
  Float num;
  num.val = (float)(l.val /= (unsigned short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator /=  (unsigned short& l , Float& r) {   // 8a
  Float num;
  num.val = (float)(l /= (unsigned short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator +   (UnsignedShort& l , Double& r) { // 3a
  Double num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
Double operator -   (UnsignedShort& l , Double& r) { // 3a
  Double num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
Double operator *   (UnsignedShort& l , Double& r) { // 3a
  Double num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
Double operator /   (UnsignedShort& l , Double& r) { // 3a
  Double num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
Double operator +=  (UnsignedShort& l , Double& r) { // 3a
  Double num;
  num.val = (double)(l.val += (unsigned short)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
Double operator -=  (UnsignedShort& l , Double& r) { // 3a
  Double num;
  num.val = (double)(l.val -= (unsigned short)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
Double operator *=  (UnsignedShort& l , Double& r) { // 3a
  Double num;
  num.val = (double)(l.val *= (unsigned short)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
Double operator /=  (UnsignedShort& l , Double& r) { // 3a
  Double num;
  num.val = (double)(l.val /= (unsigned short)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
Double operator +   (UnsignedShort& l , double& r) {   // 6a
  Double num;
  num.val = ((double)l.val + r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator +   (unsigned short& l , Double& r) {   // 8a
  Double num;
  num.val = ((double)l + r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator -   (UnsignedShort& l , double& r) {   // 6a
  Double num;
  num.val = ((double)l.val - r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator -   (unsigned short& l , Double& r) {   // 8a
  Double num;
  num.val = ((double)l - r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator *   (UnsignedShort& l , double& r) {   // 6a
  Double num;
  num.val = ((double)l.val * r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator *   (unsigned short& l , Double& r) {   // 8a
  Double num;
  num.val = ((double)l * r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator /   (UnsignedShort& l , double& r) {   // 6a
  Double num;
  num.val = ((double)l.val / r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator /   (unsigned short& l , Double& r) {   // 8a
  Double num;
  num.val = ((double)l / r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator +=  (UnsignedShort& l , double& r) {   // 6a
  Double num;
  num.val = (double)(l.val += (unsigned short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator +=  (unsigned short& l , Double& r) {   // 8a
  Double num;
  num.val = (double)(l += (unsigned short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator -=  (UnsignedShort& l , double& r) {   // 6a
  Double num;
  num.val = (double)(l.val -= (unsigned short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator -=  (unsigned short& l , Double& r) {   // 8a
  Double num;
  num.val = (double)(l -= (unsigned short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator *=  (UnsignedShort& l , double& r) {   // 6a
  Double num;
  num.val = (double)(l.val *= (unsigned short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator *=  (unsigned short& l , Double& r) {   // 8a
  Double num;
  num.val = (double)(l *= (unsigned short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator /=  (UnsignedShort& l , double& r) {   // 6a
  Double num;
  num.val = (double)(l.val /= (unsigned short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator /=  (unsigned short& l , Double& r) {   // 8a
  Double num;
  num.val = (double)(l /= (unsigned short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator %   (UnsignedShort& l , UnsignedChar& r) { // 3i
  UnsignedShort num;
  num.val = (l.val % r.val);
  num.u = (l.u %   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator &   (UnsignedShort& l , UnsignedChar& r) { // 3i
  UnsignedShort num;
  num.val = (l.val & r.val);
  num.u = (l.u &   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator ^   (UnsignedShort& l , UnsignedChar& r) { // 3i
  UnsignedShort num;
  num.val = (l.val ^ r.val);
  num.u = (l.u ^   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator |   (UnsignedShort& l , UnsignedChar& r) { // 3i
  UnsignedShort num;
  num.val = (l.val | r.val);
  num.u = (l.u |   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator <<  (UnsignedShort& l , UnsignedChar& r) { // 3i
  UnsignedShort num;
  num.val = (l.val << r.val);
  num.u = (l.u <<  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator >>  (UnsignedShort& l , UnsignedChar& r) { // 3i
  UnsignedShort num;
  num.val = (l.val >> r.val);
  num.u = (l.u >>  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator %=  (UnsignedShort& l , UnsignedChar& r) { // 3i
  UnsignedShort num;
  num.val = (l.val %= r.val);
  num.u = (l.u %=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator &=  (UnsignedShort& l , UnsignedChar& r) { // 3i
  UnsignedShort num;
  num.val = (l.val &= r.val);
  num.u = (l.u &=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator |=  (UnsignedShort& l , UnsignedChar& r) { // 3i
  UnsignedShort num;
  num.val = (l.val |= r.val);
  num.u = (l.u |=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator ^=  (UnsignedShort& l , UnsignedChar& r) { // 3i
  UnsignedShort num;
  num.val = (l.val ^= r.val);
  num.u = (l.u ^=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator <<= (UnsignedShort& l , UnsignedChar& r) { // 3i
  UnsignedShort num;
  num.val = (l.val <<= r.val);
  num.u = (l.u <<= r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator >>= (UnsignedShort& l , UnsignedChar& r) { // 3i
  UnsignedShort num;
  num.val = (l.val >>= r.val);
  num.u = (l.u >>= r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator %   (UnsignedShort& l , unsigned char& r) { // 6i
  UnsignedShort num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator %   (unsigned short& l , UnsignedChar& r) { // 8i
  UnsignedShort num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator &   (UnsignedShort& l , unsigned char& r) { // 6i
  UnsignedShort num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator &   (unsigned short& l , UnsignedChar& r) { // 8i
  UnsignedShort num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator ^   (UnsignedShort& l , unsigned char& r) { // 6i
  UnsignedShort num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator ^   (unsigned short& l , UnsignedChar& r) { // 8i
  UnsignedShort num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator |   (UnsignedShort& l , unsigned char& r) { // 6i
  UnsignedShort num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator |   (unsigned short& l , UnsignedChar& r) { // 8i
  UnsignedShort num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator <<  (UnsignedShort& l , unsigned char& r) { // 6i
  UnsignedShort num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator <<  (unsigned short& l , UnsignedChar& r) { // 8i
  UnsignedShort num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator >>  (UnsignedShort& l , unsigned char& r) { // 6i
  UnsignedShort num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator >>  (unsigned short& l , UnsignedChar& r) { // 8i
  UnsignedShort num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator %=  (UnsignedShort& l , unsigned char& r) { // 6i
  UnsignedShort num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator %=  (unsigned short& l , UnsignedChar& r) { // 8i
  UnsignedShort num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator &=  (UnsignedShort& l , unsigned char& r) { // 6i
  UnsignedShort num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator &=  (unsigned short& l , UnsignedChar& r) { // 8i
  UnsignedShort num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator |=  (UnsignedShort& l , unsigned char& r) { // 6i
  UnsignedShort num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator |=  (unsigned short& l , UnsignedChar& r) { // 8i
  UnsignedShort num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator ^=  (UnsignedShort& l , unsigned char& r) { // 6i
  UnsignedShort num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator ^=  (unsigned short& l , UnsignedChar& r) { // 8i
  UnsignedShort num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator <<= (UnsignedShort& l , unsigned char& r) { // 6i
  UnsignedShort num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator <<= (unsigned short& l , UnsignedChar& r) { // 8i
  UnsignedShort num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator >>= (UnsignedShort& l , unsigned char& r) { // 6i
  UnsignedShort num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator >>= (unsigned short& l , UnsignedChar& r) { // 8i
  UnsignedShort num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator %   (UnsignedShort& l , Char& r) { // 3i
  UnsignedShort num;
  num.val = (l.val % r.val);
  num.u = (l.u %   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator &   (UnsignedShort& l , Char& r) { // 3i
  UnsignedShort num;
  num.val = (l.val & r.val);
  num.u = (l.u &   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator ^   (UnsignedShort& l , Char& r) { // 3i
  UnsignedShort num;
  num.val = (l.val ^ r.val);
  num.u = (l.u ^   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator |   (UnsignedShort& l , Char& r) { // 3i
  UnsignedShort num;
  num.val = (l.val | r.val);
  num.u = (l.u |   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator <<  (UnsignedShort& l , Char& r) { // 3i
  UnsignedShort num;
  num.val = (l.val << r.val);
  num.u = (l.u <<  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator >>  (UnsignedShort& l , Char& r) { // 3i
  UnsignedShort num;
  num.val = (l.val >> r.val);
  num.u = (l.u >>  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator %=  (UnsignedShort& l , Char& r) { // 3i
  UnsignedShort num;
  num.val = (l.val %= r.val);
  num.u = (l.u %=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator &=  (UnsignedShort& l , Char& r) { // 3i
  UnsignedShort num;
  num.val = (l.val &= r.val);
  num.u = (l.u &=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator |=  (UnsignedShort& l , Char& r) { // 3i
  UnsignedShort num;
  num.val = (l.val |= r.val);
  num.u = (l.u |=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator ^=  (UnsignedShort& l , Char& r) { // 3i
  UnsignedShort num;
  num.val = (l.val ^= r.val);
  num.u = (l.u ^=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator <<= (UnsignedShort& l , Char& r) { // 3i
  UnsignedShort num;
  num.val = (l.val <<= r.val);
  num.u = (l.u <<= r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator >>= (UnsignedShort& l , Char& r) { // 3i
  UnsignedShort num;
  num.val = (l.val >>= r.val);
  num.u = (l.u >>= r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator %   (UnsignedShort& l , char& r) { // 6i
  UnsignedShort num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator %   (unsigned short& l , Char& r) { // 8i
  UnsignedShort num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator &   (UnsignedShort& l , char& r) { // 6i
  UnsignedShort num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator &   (unsigned short& l , Char& r) { // 8i
  UnsignedShort num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator ^   (UnsignedShort& l , char& r) { // 6i
  UnsignedShort num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator ^   (unsigned short& l , Char& r) { // 8i
  UnsignedShort num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator |   (UnsignedShort& l , char& r) { // 6i
  UnsignedShort num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator |   (unsigned short& l , Char& r) { // 8i
  UnsignedShort num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator <<  (UnsignedShort& l , char& r) { // 6i
  UnsignedShort num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator <<  (unsigned short& l , Char& r) { // 8i
  UnsignedShort num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator >>  (UnsignedShort& l , char& r) { // 6i
  UnsignedShort num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator >>  (unsigned short& l , Char& r) { // 8i
  UnsignedShort num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator %=  (UnsignedShort& l , char& r) { // 6i
  UnsignedShort num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator %=  (unsigned short& l , Char& r) { // 8i
  UnsignedShort num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator &=  (UnsignedShort& l , char& r) { // 6i
  UnsignedShort num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator &=  (unsigned short& l , Char& r) { // 8i
  UnsignedShort num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator |=  (UnsignedShort& l , char& r) { // 6i
  UnsignedShort num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator |=  (unsigned short& l , Char& r) { // 8i
  UnsignedShort num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator ^=  (UnsignedShort& l , char& r) { // 6i
  UnsignedShort num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator ^=  (unsigned short& l , Char& r) { // 8i
  UnsignedShort num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator <<= (UnsignedShort& l , char& r) { // 6i
  UnsignedShort num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator <<= (unsigned short& l , Char& r) { // 8i
  UnsignedShort num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator >>= (UnsignedShort& l , char& r) { // 6i
  UnsignedShort num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator >>= (unsigned short& l , Char& r) { // 8i
  UnsignedShort num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort UnsignedShort::operator %   (UnsignedShort& r) { // 1i
  UnsignedShort num;
  num.val = (val % r.val);
  num.u = (u %   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort UnsignedShort::operator &   (UnsignedShort& r) { // 1i
  UnsignedShort num;
  num.val = (val & r.val);
  num.u = (u &   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort UnsignedShort::operator ^   (UnsignedShort& r) { // 1i
  UnsignedShort num;
  num.val = (val ^ r.val);
  num.u = (u ^   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort UnsignedShort::operator |   (UnsignedShort& r) { // 1i
  UnsignedShort num;
  num.val = (val | r.val);
  num.u = (u |   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort UnsignedShort::operator <<  (UnsignedShort& r) { // 1i
  UnsignedShort num;
  num.val = (val << r.val);
  num.u = (u <<  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort UnsignedShort::operator >>  (UnsignedShort& r) { // 1i
  UnsignedShort num;
  num.val = (val >> r.val);
  num.u = (u >>  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort UnsignedShort::operator %=  (UnsignedShort& r) { // 1i
  UnsignedShort num;
  num.val = (val %= r.val);
  num.u = (u %=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort UnsignedShort::operator &=  (UnsignedShort& r) { // 1i
  UnsignedShort num;
  num.val = (val &= r.val);
  num.u = (u &=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort UnsignedShort::operator |=  (UnsignedShort& r) { // 1i
  UnsignedShort num;
  num.val = (val |= r.val);
  num.u = (u |=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort UnsignedShort::operator ^=  (UnsignedShort& r) { // 1i
  UnsignedShort num;
  num.val = (val ^= r.val);
  num.u = (u ^=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort UnsignedShort::operator <<= (UnsignedShort& r) { // 1i
  UnsignedShort num;
  num.val = (val <<= r.val);
  num.u = (u <<= r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort UnsignedShort::operator >>= (UnsignedShort& r) { // 1i
  UnsignedShort num;
  num.val = (val >>= r.val);
  num.u = (u >>= r.u);
  return num;
}

// **********************************************************************************************************
UnsignedShort operator %   (UnsignedShort& l , unsigned short& r) { // 6i
  UnsignedShort num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator %   (unsigned short& l , UnsignedShort& r) { // 8i
  UnsignedShort num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator &   (UnsignedShort& l , unsigned short& r) { // 6i
  UnsignedShort num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator &   (unsigned short& l , UnsignedShort& r) { // 8i
  UnsignedShort num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator ^   (UnsignedShort& l , unsigned short& r) { // 6i
  UnsignedShort num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator ^   (unsigned short& l , UnsignedShort& r) { // 8i
  UnsignedShort num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator |   (UnsignedShort& l , unsigned short& r) { // 6i
  UnsignedShort num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator |   (unsigned short& l , UnsignedShort& r) { // 8i
  UnsignedShort num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator <<  (UnsignedShort& l , unsigned short& r) { // 6i
  UnsignedShort num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator <<  (unsigned short& l , UnsignedShort& r) { // 8i
  UnsignedShort num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator >>  (UnsignedShort& l , unsigned short& r) { // 6i
  UnsignedShort num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator >>  (unsigned short& l , UnsignedShort& r) { // 8i
  UnsignedShort num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator %=  (UnsignedShort& l , unsigned short& r) { // 6i
  UnsignedShort num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator %=  (unsigned short& l , UnsignedShort& r) { // 8i
  UnsignedShort num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator &=  (UnsignedShort& l , unsigned short& r) { // 6i
  UnsignedShort num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator &=  (unsigned short& l , UnsignedShort& r) { // 8i
  UnsignedShort num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator |=  (UnsignedShort& l , unsigned short& r) { // 6i
  UnsignedShort num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator |=  (unsigned short& l , UnsignedShort& r) { // 8i
  UnsignedShort num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator ^=  (UnsignedShort& l , unsigned short& r) { // 6i
  UnsignedShort num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator ^=  (unsigned short& l , UnsignedShort& r) { // 8i
  UnsignedShort num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator <<= (UnsignedShort& l , unsigned short& r) { // 6i
  UnsignedShort num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator <<= (unsigned short& l , UnsignedShort& r) { // 8i
  UnsignedShort num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator >>= (UnsignedShort& l , unsigned short& r) { // 6i
  UnsignedShort num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort operator >>= (unsigned short& l , UnsignedShort& r) { // 8i
  UnsignedShort num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator %   (UnsignedShort& l , Short& r) { // 3i
  Short num;
  num.val = (l.val % r.val);
  num.u = (l.u %   r.u);
  return num;
}

// **********************************************************************************************************
Short operator &   (UnsignedShort& l , Short& r) { // 3i
  Short num;
  num.val = (l.val & r.val);
  num.u = (l.u &   r.u);
  return num;
}

// **********************************************************************************************************
Short operator ^   (UnsignedShort& l , Short& r) { // 3i
  Short num;
  num.val = (l.val ^ r.val);
  num.u = (l.u ^   r.u);
  return num;
}

// **********************************************************************************************************
Short operator |   (UnsignedShort& l , Short& r) { // 3i
  Short num;
  num.val = (l.val | r.val);
  num.u = (l.u |   r.u);
  return num;
}

// **********************************************************************************************************
Short operator <<  (UnsignedShort& l , Short& r) { // 3i
  Short num;
  num.val = (l.val << r.val);
  num.u = (l.u <<  r.u);
  return num;
}

// **********************************************************************************************************
Short operator >>  (UnsignedShort& l , Short& r) { // 3i
  Short num;
  num.val = (l.val >> r.val);
  num.u = (l.u >>  r.u);
  return num;
}

// **********************************************************************************************************
Short operator %=  (UnsignedShort& l , Short& r) { // 3i
  Short num;
  num.val = (l.val %= r.val);
  num.u = (l.u %=  r.u);
  return num;
}

// **********************************************************************************************************
Short operator &=  (UnsignedShort& l , Short& r) { // 3i
  Short num;
  num.val = (l.val &= r.val);
  num.u = (l.u &=  r.u);
  return num;
}

// **********************************************************************************************************
Short operator |=  (UnsignedShort& l , Short& r) { // 3i
  Short num;
  num.val = (l.val |= r.val);
  num.u = (l.u |=  r.u);
  return num;
}

// **********************************************************************************************************
Short operator ^=  (UnsignedShort& l , Short& r) { // 3i
  Short num;
  num.val = (l.val ^= r.val);
  num.u = (l.u ^=  r.u);
  return num;
}

// **********************************************************************************************************
Short operator <<= (UnsignedShort& l , Short& r) { // 3i
  Short num;
  num.val = (l.val <<= r.val);
  num.u = (l.u <<= r.u);
  return num;
}

// **********************************************************************************************************
Short operator >>= (UnsignedShort& l , Short& r) { // 3i
  Short num;
  num.val = (l.val >>= r.val);
  num.u = (l.u >>= r.u);
  return num;
}

// **********************************************************************************************************
Short operator %   (UnsignedShort& l , short& r) { // 6i
  Short num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator %   (unsigned short& l , Short& r) { // 8i
  Short num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator &   (UnsignedShort& l , short& r) { // 6i
  Short num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator &   (unsigned short& l , Short& r) { // 8i
  Short num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator ^   (UnsignedShort& l , short& r) { // 6i
  Short num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator ^   (unsigned short& l , Short& r) { // 8i
  Short num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator |   (UnsignedShort& l , short& r) { // 6i
  Short num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator |   (unsigned short& l , Short& r) { // 8i
  Short num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator <<  (UnsignedShort& l , short& r) { // 6i
  Short num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator <<  (unsigned short& l , Short& r) { // 8i
  Short num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator >>  (UnsignedShort& l , short& r) { // 6i
  Short num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator >>  (unsigned short& l , Short& r) { // 8i
  Short num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator %=  (UnsignedShort& l , short& r) { // 6i
  Short num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator %=  (unsigned short& l , Short& r) { // 8i
  Short num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator &=  (UnsignedShort& l , short& r) { // 6i
  Short num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator &=  (unsigned short& l , Short& r) { // 8i
  Short num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator |=  (UnsignedShort& l , short& r) { // 6i
  Short num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator |=  (unsigned short& l , Short& r) { // 8i
  Short num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator ^=  (UnsignedShort& l , short& r) { // 6i
  Short num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator ^=  (unsigned short& l , Short& r) { // 8i
  Short num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator <<= (UnsignedShort& l , short& r) { // 6i
  Short num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator <<= (unsigned short& l , Short& r) { // 8i
  Short num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator >>= (UnsignedShort& l , short& r) { // 6i
  Short num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator >>= (unsigned short& l , Short& r) { // 8i
  Short num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator %   (UnsignedShort& l , UnsignedInt& r) { // 3i
  UnsignedInt num;
  num.val = (l.val % r.val);
  num.u = (l.u %   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator &   (UnsignedShort& l , UnsignedInt& r) { // 3i
  UnsignedInt num;
  num.val = (l.val & r.val);
  num.u = (l.u &   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator ^   (UnsignedShort& l , UnsignedInt& r) { // 3i
  UnsignedInt num;
  num.val = (l.val ^ r.val);
  num.u = (l.u ^   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator |   (UnsignedShort& l , UnsignedInt& r) { // 3i
  UnsignedInt num;
  num.val = (l.val | r.val);
  num.u = (l.u |   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator <<  (UnsignedShort& l , UnsignedInt& r) { // 3i
  UnsignedInt num;
  num.val = (l.val << r.val);
  num.u = (l.u <<  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator >>  (UnsignedShort& l , UnsignedInt& r) { // 3i
  UnsignedInt num;
  num.val = (l.val >> r.val);
  num.u = (l.u >>  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator %=  (UnsignedShort& l , UnsignedInt& r) { // 3i
  UnsignedInt num;
  num.val = (l.val %= r.val);
  num.u = (l.u %=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator &=  (UnsignedShort& l , UnsignedInt& r) { // 3i
  UnsignedInt num;
  num.val = (l.val &= r.val);
  num.u = (l.u &=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator |=  (UnsignedShort& l , UnsignedInt& r) { // 3i
  UnsignedInt num;
  num.val = (l.val |= r.val);
  num.u = (l.u |=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator ^=  (UnsignedShort& l , UnsignedInt& r) { // 3i
  UnsignedInt num;
  num.val = (l.val ^= r.val);
  num.u = (l.u ^=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator <<= (UnsignedShort& l , UnsignedInt& r) { // 3i
  UnsignedInt num;
  num.val = (l.val <<= r.val);
  num.u = (l.u <<= r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator >>= (UnsignedShort& l , UnsignedInt& r) { // 3i
  UnsignedInt num;
  num.val = (l.val >>= r.val);
  num.u = (l.u >>= r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator %   (UnsignedShort& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator %   (unsigned short& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator &   (UnsignedShort& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator &   (unsigned short& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator ^   (UnsignedShort& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator ^   (unsigned short& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator |   (UnsignedShort& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator |   (unsigned short& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator <<  (UnsignedShort& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator <<  (unsigned short& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator >>  (UnsignedShort& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator >>  (unsigned short& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator %=  (UnsignedShort& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator %=  (unsigned short& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator &=  (UnsignedShort& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator &=  (unsigned short& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator |=  (UnsignedShort& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator |=  (unsigned short& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator ^=  (UnsignedShort& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator ^=  (unsigned short& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator <<= (UnsignedShort& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator <<= (unsigned short& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator >>= (UnsignedShort& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator >>= (unsigned short& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator %   (UnsignedShort& l , Int& r) { // 3i
  Int num;
  num.val = (l.val % r.val);
  num.u = (l.u %   r.u);
  return num;
}

// **********************************************************************************************************
Int operator &   (UnsignedShort& l , Int& r) { // 3i
  Int num;
  num.val = (l.val & r.val);
  num.u = (l.u &   r.u);
  return num;
}

// **********************************************************************************************************
Int operator ^   (UnsignedShort& l , Int& r) { // 3i
  Int num;
  num.val = (l.val ^ r.val);
  num.u = (l.u ^   r.u);
  return num;
}

// **********************************************************************************************************
Int operator |   (UnsignedShort& l , Int& r) { // 3i
  Int num;
  num.val = (l.val | r.val);
  num.u = (l.u |   r.u);
  return num;
}

// **********************************************************************************************************
Int operator <<  (UnsignedShort& l , Int& r) { // 3i
  Int num;
  num.val = (l.val << r.val);
  num.u = (l.u <<  r.u);
  return num;
}

// **********************************************************************************************************
Int operator >>  (UnsignedShort& l , Int& r) { // 3i
  Int num;
  num.val = (l.val >> r.val);
  num.u = (l.u >>  r.u);
  return num;
}

// **********************************************************************************************************
Int operator %=  (UnsignedShort& l , Int& r) { // 3i
  Int num;
  num.val = (l.val %= r.val);
  num.u = (l.u %=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator &=  (UnsignedShort& l , Int& r) { // 3i
  Int num;
  num.val = (l.val &= r.val);
  num.u = (l.u &=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator |=  (UnsignedShort& l , Int& r) { // 3i
  Int num;
  num.val = (l.val |= r.val);
  num.u = (l.u |=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator ^=  (UnsignedShort& l , Int& r) { // 3i
  Int num;
  num.val = (l.val ^= r.val);
  num.u = (l.u ^=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator <<= (UnsignedShort& l , Int& r) { // 3i
  Int num;
  num.val = (l.val <<= r.val);
  num.u = (l.u <<= r.u);
  return num;
}

// **********************************************************************************************************
Int operator >>= (UnsignedShort& l , Int& r) { // 3i
  Int num;
  num.val = (l.val >>= r.val);
  num.u = (l.u >>= r.u);
  return num;
}

// **********************************************************************************************************
Int operator %   (UnsignedShort& l , int& r) { // 6i
  Int num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator %   (unsigned short& l , Int& r) { // 8i
  Int num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator &   (UnsignedShort& l , int& r) { // 6i
  Int num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator &   (unsigned short& l , Int& r) { // 8i
  Int num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator ^   (UnsignedShort& l , int& r) { // 6i
  Int num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator ^   (unsigned short& l , Int& r) { // 8i
  Int num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator |   (UnsignedShort& l , int& r) { // 6i
  Int num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator |   (unsigned short& l , Int& r) { // 8i
  Int num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator <<  (UnsignedShort& l , int& r) { // 6i
  Int num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator <<  (unsigned short& l , Int& r) { // 8i
  Int num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator >>  (UnsignedShort& l , int& r) { // 6i
  Int num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator >>  (unsigned short& l , Int& r) { // 8i
  Int num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator %=  (UnsignedShort& l , int& r) { // 6i
  Int num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator %=  (unsigned short& l , Int& r) { // 8i
  Int num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator &=  (UnsignedShort& l , int& r) { // 6i
  Int num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator &=  (unsigned short& l , Int& r) { // 8i
  Int num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator |=  (UnsignedShort& l , int& r) { // 6i
  Int num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator |=  (unsigned short& l , Int& r) { // 8i
  Int num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator ^=  (UnsignedShort& l , int& r) { // 6i
  Int num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator ^=  (unsigned short& l , Int& r) { // 8i
  Int num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator <<= (UnsignedShort& l , int& r) { // 6i
  Int num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator <<= (unsigned short& l , Int& r) { // 8i
  Int num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator >>= (UnsignedShort& l , int& r) { // 6i
  Int num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator >>= (unsigned short& l , Int& r) { // 8i
  Int num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %   (UnsignedShort& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val % r.val);
  num.u = (l.u %   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &   (UnsignedShort& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val & r.val);
  num.u = (l.u &   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^   (UnsignedShort& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val ^ r.val);
  num.u = (l.u ^   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |   (UnsignedShort& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val | r.val);
  num.u = (l.u |   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<  (UnsignedShort& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val << r.val);
  num.u = (l.u <<  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>  (UnsignedShort& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val >> r.val);
  num.u = (l.u >>  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %=  (UnsignedShort& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val %= r.val);
  num.u = (l.u %=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &=  (UnsignedShort& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val &= r.val);
  num.u = (l.u &=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |=  (UnsignedShort& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val |= r.val);
  num.u = (l.u |=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^=  (UnsignedShort& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val ^= r.val);
  num.u = (l.u ^=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<= (UnsignedShort& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val <<= r.val);
  num.u = (l.u <<= r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>= (UnsignedShort& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val >>= r.val);
  num.u = (l.u >>= r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %   (UnsignedShort& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %   (unsigned short& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &   (UnsignedShort& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &   (unsigned short& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^   (UnsignedShort& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^   (unsigned short& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |   (UnsignedShort& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |   (unsigned short& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<  (UnsignedShort& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<  (unsigned short& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>  (UnsignedShort& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>  (unsigned short& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %=  (UnsignedShort& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %=  (unsigned short& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &=  (UnsignedShort& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &=  (unsigned short& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |=  (UnsignedShort& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |=  (unsigned short& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^=  (UnsignedShort& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^=  (unsigned short& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<= (UnsignedShort& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<= (unsigned short& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>= (UnsignedShort& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>= (unsigned short& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator %   (UnsignedShort& l , Long& r) { // 3i
  Long num;
  num.val = (l.val % r.val);
  num.u = (l.u %   r.u);
  return num;
}

// **********************************************************************************************************
Long operator &   (UnsignedShort& l , Long& r) { // 3i
  Long num;
  num.val = (l.val & r.val);
  num.u = (l.u &   r.u);
  return num;
}

// **********************************************************************************************************
Long operator ^   (UnsignedShort& l , Long& r) { // 3i
  Long num;
  num.val = (l.val ^ r.val);
  num.u = (l.u ^   r.u);
  return num;
}

// **********************************************************************************************************
Long operator |   (UnsignedShort& l , Long& r) { // 3i
  Long num;
  num.val = (l.val | r.val);
  num.u = (l.u |   r.u);
  return num;
}

// **********************************************************************************************************
Long operator <<  (UnsignedShort& l , Long& r) { // 3i
  Long num;
  num.val = (l.val << r.val);
  num.u = (l.u <<  r.u);
  return num;
}

// **********************************************************************************************************
Long operator >>  (UnsignedShort& l , Long& r) { // 3i
  Long num;
  num.val = (l.val >> r.val);
  num.u = (l.u >>  r.u);
  return num;
}

// **********************************************************************************************************
Long operator %=  (UnsignedShort& l , Long& r) { // 3i
  Long num;
  num.val = (l.val %= r.val);
  num.u = (l.u %=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator &=  (UnsignedShort& l , Long& r) { // 3i
  Long num;
  num.val = (l.val &= r.val);
  num.u = (l.u &=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator |=  (UnsignedShort& l , Long& r) { // 3i
  Long num;
  num.val = (l.val |= r.val);
  num.u = (l.u |=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator ^=  (UnsignedShort& l , Long& r) { // 3i
  Long num;
  num.val = (l.val ^= r.val);
  num.u = (l.u ^=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator <<= (UnsignedShort& l , Long& r) { // 3i
  Long num;
  num.val = (l.val <<= r.val);
  num.u = (l.u <<= r.u);
  return num;
}

// **********************************************************************************************************
Long operator >>= (UnsignedShort& l , Long& r) { // 3i
  Long num;
  num.val = (l.val >>= r.val);
  num.u = (l.u >>= r.u);
  return num;
}

// **********************************************************************************************************
Long operator %   (UnsignedShort& l , long& r) { // 6i
  Long num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator %   (unsigned short& l , Long& r) { // 8i
  Long num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator &   (UnsignedShort& l , long& r) { // 6i
  Long num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator &   (unsigned short& l , Long& r) { // 8i
  Long num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator ^   (UnsignedShort& l , long& r) { // 6i
  Long num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator ^   (unsigned short& l , Long& r) { // 8i
  Long num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator |   (UnsignedShort& l , long& r) { // 6i
  Long num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator |   (unsigned short& l , Long& r) { // 8i
  Long num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator <<  (UnsignedShort& l , long& r) { // 6i
  Long num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator <<  (unsigned short& l , Long& r) { // 8i
  Long num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator >>  (UnsignedShort& l , long& r) { // 6i
  Long num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator >>  (unsigned short& l , Long& r) { // 8i
  Long num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator %=  (UnsignedShort& l , long& r) { // 6i
  Long num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator %=  (unsigned short& l , Long& r) { // 8i
  Long num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator &=  (UnsignedShort& l , long& r) { // 6i
  Long num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator &=  (unsigned short& l , Long& r) { // 8i
  Long num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator |=  (UnsignedShort& l , long& r) { // 6i
  Long num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator |=  (unsigned short& l , Long& r) { // 8i
  Long num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator ^=  (UnsignedShort& l , long& r) { // 6i
  Long num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator ^=  (unsigned short& l , Long& r) { // 8i
  Long num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator <<= (UnsignedShort& l , long& r) { // 6i
  Long num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator <<= (unsigned short& l , Long& r) { // 8i
  Long num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator >>= (UnsignedShort& l , long& r) { // 6i
  Long num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator >>= (unsigned short& l , Long& r) { // 8i
  Long num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedShort UnsignedShort::operator ++(void) { // 1p, Prefix operator
   ++val;
  return *this;
}

// **********************************************************************************************************
UnsignedShort UnsignedShort::operator --(void) { // 1p, Prefix operator
   --val;
  assert(val>=1);
  return *this;
}

// **********************************************************************************************************
UnsignedShort UnsignedShort::operator ++(int) { // 1p, Postfix operator
   val++;
  return *this;
}

// **********************************************************************************************************
UnsignedShort UnsignedShort::operator --(int) { // 1p, Postfix operator
  assert(val>=1);
   val--;
  return *this;
}

// *********************************************************************************************************
// First class Short constructor
// *********************************************************************************************************
Short::Short() {
  val=0;
  state=UNDEF;
  u.init();
}
// *********************************************************************************************************
// Second class Short constructor
// *********************************************************************************************************
Short::Short(char* str) {
  val=0;
  state=UNDEF;
  u.init(str);
}
// *********************************************************************************************************
// First class Short destructor
// *********************************************************************************************************
Short::~Short() {
  val=0;
  state=UNDEF;
  u.init();
}
// **********************************************************************************************************
Short operator +   (Short& l , UnsignedChar& r) { // 3a
  Short num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
Short operator -   (Short& l , UnsignedChar& r) { // 3a
  Short num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
Short operator *   (Short& l , UnsignedChar& r) { // 3a
  Short num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
Short operator /   (Short& l , UnsignedChar& r) { // 3a
  Short num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
Short operator +=  (Short& l , UnsignedChar& r) { // 3a
  Short num;
  num.val = (short)(l.val += (short)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
Short operator -=  (Short& l , UnsignedChar& r) { // 3a
  Short num;
  num.val = (short)(l.val -= (short)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
Short operator *=  (Short& l , UnsignedChar& r) { // 3a
  Short num;
  num.val = (short)(l.val *= (short)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
Short operator /=  (Short& l , UnsignedChar& r) { // 3a
  Short num;
  num.val = (short)(l.val /= (short)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
Short operator +   (Short& l , unsigned char& r) {   // 6a
  Short num;
  num.val = (l.val + (short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator +   (short& l , UnsignedChar& r) {   // 8a
  Short num;
  num.val = (l + (short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator -   (Short& l , unsigned char& r) {   // 6a
  Short num;
  num.val = (l.val - (short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator -   (short& l , UnsignedChar& r) {   // 8a
  Short num;
  num.val = (l - (short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator *   (Short& l , unsigned char& r) {   // 6a
  Short num;
  num.val = (l.val * (short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator *   (short& l , UnsignedChar& r) {   // 8a
  Short num;
  num.val = (l * (short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator /   (Short& l , unsigned char& r) {   // 6a
  Short num;
  num.val = (l.val / (short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator /   (short& l , UnsignedChar& r) {   // 8a
  Short num;
  num.val = (l / (short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator +=  (Short& l , unsigned char& r) {   // 6a
  Short num;
  num.val = (short)(l.val += (short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator +=  (short& l , UnsignedChar& r) {   // 8a
  Short num;
  num.val = (short)(l += (short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator -=  (Short& l , unsigned char& r) {   // 6a
  Short num;
  num.val = (short)(l.val -= (short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator -=  (short& l , UnsignedChar& r) {   // 8a
  Short num;
  num.val = (short)(l -= (short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator *=  (Short& l , unsigned char& r) {   // 6a
  Short num;
  num.val = (short)(l.val *= (short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator *=  (short& l , UnsignedChar& r) {   // 8a
  Short num;
  num.val = (short)(l *= (short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator /=  (Short& l , unsigned char& r) {   // 6a
  Short num;
  num.val = (short)(l.val /= (short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator /=  (short& l , UnsignedChar& r) {   // 8a
  Short num;
  num.val = (short)(l /= (short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator +   (Short& l , Char& r) { // 3a
  Short num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
Short operator -   (Short& l , Char& r) { // 3a
  Short num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
Short operator *   (Short& l , Char& r) { // 3a
  Short num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
Short operator /   (Short& l , Char& r) { // 3a
  Short num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
Short operator +=  (Short& l , Char& r) { // 3a
  Short num;
  num.val = (short)(l.val += (short)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
Short operator -=  (Short& l , Char& r) { // 3a
  Short num;
  num.val = (short)(l.val -= (short)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
Short operator *=  (Short& l , Char& r) { // 3a
  Short num;
  num.val = (short)(l.val *= (short)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
Short operator /=  (Short& l , Char& r) { // 3a
  Short num;
  num.val = (short)(l.val /= (short)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
Short operator +   (Short& l , char& r) {   // 6a
  Short num;
  num.val = (l.val + (short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator +   (short& l , Char& r) {   // 8a
  Short num;
  num.val = (l + (short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator -   (Short& l , char& r) {   // 6a
  Short num;
  num.val = (l.val - (short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator -   (short& l , Char& r) {   // 8a
  Short num;
  num.val = (l - (short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator *   (Short& l , char& r) {   // 6a
  Short num;
  num.val = (l.val * (short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator *   (short& l , Char& r) {   // 8a
  Short num;
  num.val = (l * (short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator /   (Short& l , char& r) {   // 6a
  Short num;
  num.val = (l.val / (short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator /   (short& l , Char& r) {   // 8a
  Short num;
  num.val = (l / (short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator +=  (Short& l , char& r) {   // 6a
  Short num;
  num.val = (short)(l.val += (short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator +=  (short& l , Char& r) {   // 8a
  Short num;
  num.val = (short)(l += (short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator -=  (Short& l , char& r) {   // 6a
  Short num;
  num.val = (short)(l.val -= (short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator -=  (short& l , Char& r) {   // 8a
  Short num;
  num.val = (short)(l -= (short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator *=  (Short& l , char& r) {   // 6a
  Short num;
  num.val = (short)(l.val *= (short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator *=  (short& l , Char& r) {   // 8a
  Short num;
  num.val = (short)(l *= (short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator /=  (Short& l , char& r) {   // 6a
  Short num;
  num.val = (short)(l.val /= (short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator /=  (short& l , Char& r) {   // 8a
  Short num;
  num.val = (short)(l /= (short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator +   (Short& l , UnsignedShort& r) { // 3a
  Short num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
Short operator -   (Short& l , UnsignedShort& r) { // 3a
  Short num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
Short operator *   (Short& l , UnsignedShort& r) { // 3a
  Short num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
Short operator /   (Short& l , UnsignedShort& r) { // 3a
  Short num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
Short operator +=  (Short& l , UnsignedShort& r) { // 3a
  Short num;
  num.val = (short)(l.val += (short)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
Short operator -=  (Short& l , UnsignedShort& r) { // 3a
  Short num;
  num.val = (short)(l.val -= (short)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
Short operator *=  (Short& l , UnsignedShort& r) { // 3a
  Short num;
  num.val = (short)(l.val *= (short)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
Short operator /=  (Short& l , UnsignedShort& r) { // 3a
  Short num;
  num.val = (short)(l.val /= (short)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
Short operator +   (Short& l , unsigned short& r) {   // 6a
  Short num;
  num.val = (l.val + (short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator +   (short& l , UnsignedShort& r) {   // 8a
  Short num;
  num.val = (l + (short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator -   (Short& l , unsigned short& r) {   // 6a
  Short num;
  num.val = (l.val - (short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator -   (short& l , UnsignedShort& r) {   // 8a
  Short num;
  num.val = (l - (short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator *   (Short& l , unsigned short& r) {   // 6a
  Short num;
  num.val = (l.val * (short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator *   (short& l , UnsignedShort& r) {   // 8a
  Short num;
  num.val = (l * (short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator /   (Short& l , unsigned short& r) {   // 6a
  Short num;
  num.val = (l.val / (short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator /   (short& l , UnsignedShort& r) {   // 8a
  Short num;
  num.val = (l / (short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator +=  (Short& l , unsigned short& r) {   // 6a
  Short num;
  num.val = (short)(l.val += (short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator +=  (short& l , UnsignedShort& r) {   // 8a
  Short num;
  num.val = (short)(l += (short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator -=  (Short& l , unsigned short& r) {   // 6a
  Short num;
  num.val = (short)(l.val -= (short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator -=  (short& l , UnsignedShort& r) {   // 8a
  Short num;
  num.val = (short)(l -= (short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator *=  (Short& l , unsigned short& r) {   // 6a
  Short num;
  num.val = (short)(l.val *= (short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator *=  (short& l , UnsignedShort& r) {   // 8a
  Short num;
  num.val = (short)(l *= (short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator /=  (Short& l , unsigned short& r) {   // 6a
  Short num;
  num.val = (short)(l.val /= (short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator /=  (short& l , UnsignedShort& r) {   // 8a
  Short num;
  num.val = (short)(l /= (short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short Short::operator +   (Short& r) { // 1a
  Short num;
  num.val = (val + r.val);
  num.u = (u +   r.u);
  return num;
}

// **********************************************************************************************************
Short Short::operator -   (Short& r) { // 1a
  Short num;
  num.val = (val - r.val);
  num.u = (u -   r.u);
  return num;
}

// **********************************************************************************************************
Short Short::operator *   (Short& r) { // 1a
  Short num;
  num.val = (val * r.val);
  num.u = (u *   r.u);
  return num;
}

// **********************************************************************************************************
Short Short::operator /   (Short& r) { // 1a
  Short num;
  num.val = (val / r.val);
  num.u = (u /   r.u);
  return num;
}

// **********************************************************************************************************
Short Short::operator +=  (Short& r) { // 1a
  Short num;
  num.val = (val += r.val);
  num.u = (u +=  r.u);
  return num;
}

// **********************************************************************************************************
Short Short::operator -=  (Short& r) { // 1a
  Short num;
  num.val = (val -= r.val);
  num.u = (u -=  r.u);
  return num;
}

// **********************************************************************************************************
Short Short::operator *=  (Short& r) { // 1a
  Short num;
  num.val = (val *= r.val);
  num.u = (u *=  r.u);
  return num;
}

// **********************************************************************************************************
Short Short::operator /=  (Short& r) { // 1a
  Short num;
  num.val = (val /= r.val);
  num.u = (u /=  r.u);
  return num;
}

// **********************************************************************************************************
Short operator +   (Short& l , short& r) {   // 6a
  Short num;
  num.val = (l.val + r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator +   (short& l , Short& r) {   // 8a
  Short num;
  num.val = (l + r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator -   (Short& l , short& r) {   // 6a
  Short num;
  num.val = (l.val - r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator -   (short& l , Short& r) {   // 8a
  Short num;
  num.val = (l - r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator *   (Short& l , short& r) {   // 6a
  Short num;
  num.val = (l.val * r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator *   (short& l , Short& r) {   // 8a
  Short num;
  num.val = (l * r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator /   (Short& l , short& r) {   // 6a
  Short num;
  num.val = (l.val / r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator /   (short& l , Short& r) {   // 8a
  Short num;
  num.val = (l / r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator +=  (Short& l , short& r) {   // 6a
  Short num;
  num.val = (short)(l.val += (short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator +=  (short& l , Short& r) {   // 8a
  Short num;
  num.val = (short)(l += (short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator -=  (Short& l , short& r) {   // 6a
  Short num;
  num.val = (short)(l.val -= (short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator -=  (short& l , Short& r) {   // 8a
  Short num;
  num.val = (short)(l -= (short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator *=  (Short& l , short& r) {   // 6a
  Short num;
  num.val = (short)(l.val *= (short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator *=  (short& l , Short& r) {   // 8a
  Short num;
  num.val = (short)(l *= (short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator /=  (Short& l , short& r) {   // 6a
  Short num;
  num.val = (short)(l.val /= (short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator /=  (short& l , Short& r) {   // 8a
  Short num;
  num.val = (short)(l /= (short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator +   (Short& l , UnsignedInt& r) { // 3a
  UnsignedInt num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator -   (Short& l , UnsignedInt& r) { // 3a
  UnsignedInt num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator *   (Short& l , UnsignedInt& r) { // 3a
  UnsignedInt num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator /   (Short& l , UnsignedInt& r) { // 3a
  UnsignedInt num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator +=  (Short& l , UnsignedInt& r) { // 3a
  UnsignedInt num;
  num.val = (unsigned int)(l.val += (short)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator -=  (Short& l , UnsignedInt& r) { // 3a
  UnsignedInt num;
  num.val = (unsigned int)(l.val -= (short)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator *=  (Short& l , UnsignedInt& r) { // 3a
  UnsignedInt num;
  num.val = (unsigned int)(l.val *= (short)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator /=  (Short& l , UnsignedInt& r) { // 3a
  UnsignedInt num;
  num.val = (unsigned int)(l.val /= (short)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator +   (Short& l , unsigned int& r) {   // 6a
  UnsignedInt num;
  num.val = ((unsigned int)l.val + r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator +   (short& l , UnsignedInt& r) {   // 8a
  UnsignedInt num;
  num.val = ((unsigned int)l + r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator -   (Short& l , unsigned int& r) {   // 6a
  UnsignedInt num;
  num.val = ((unsigned int)l.val - r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator -   (short& l , UnsignedInt& r) {   // 8a
  UnsignedInt num;
  num.val = ((unsigned int)l - r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator *   (Short& l , unsigned int& r) {   // 6a
  UnsignedInt num;
  num.val = ((unsigned int)l.val * r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator *   (short& l , UnsignedInt& r) {   // 8a
  UnsignedInt num;
  num.val = ((unsigned int)l * r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator /   (Short& l , unsigned int& r) {   // 6a
  UnsignedInt num;
  num.val = ((unsigned int)l.val / r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator /   (short& l , UnsignedInt& r) {   // 8a
  UnsignedInt num;
  num.val = ((unsigned int)l / r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator +=  (Short& l , unsigned int& r) {   // 6a
  UnsignedInt num;
  num.val = (unsigned int)(l.val += (short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator +=  (short& l , UnsignedInt& r) {   // 8a
  UnsignedInt num;
  num.val = (unsigned int)(l += (short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator -=  (Short& l , unsigned int& r) {   // 6a
  UnsignedInt num;
  num.val = (unsigned int)(l.val -= (short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator -=  (short& l , UnsignedInt& r) {   // 8a
  UnsignedInt num;
  num.val = (unsigned int)(l -= (short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator *=  (Short& l , unsigned int& r) {   // 6a
  UnsignedInt num;
  num.val = (unsigned int)(l.val *= (short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator *=  (short& l , UnsignedInt& r) {   // 8a
  UnsignedInt num;
  num.val = (unsigned int)(l *= (short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator /=  (Short& l , unsigned int& r) {   // 6a
  UnsignedInt num;
  num.val = (unsigned int)(l.val /= (short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator /=  (short& l , UnsignedInt& r) {   // 8a
  UnsignedInt num;
  num.val = (unsigned int)(l /= (short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator +   (Short& l , Int& r) { // 3a
  Int num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
Int operator -   (Short& l , Int& r) { // 3a
  Int num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
Int operator *   (Short& l , Int& r) { // 3a
  Int num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
Int operator /   (Short& l , Int& r) { // 3a
  Int num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
Int operator +=  (Short& l , Int& r) { // 3a
  Int num;
  num.val = (int)(l.val += (short)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator -=  (Short& l , Int& r) { // 3a
  Int num;
  num.val = (int)(l.val -= (short)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator *=  (Short& l , Int& r) { // 3a
  Int num;
  num.val = (int)(l.val *= (short)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator /=  (Short& l , Int& r) { // 3a
  Int num;
  num.val = (int)(l.val /= (short)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator +   (Short& l , int& r) {   // 6a
  Int num;
  num.val = ((int)l.val + r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator +   (short& l , Int& r) {   // 8a
  Int num;
  num.val = ((int)l + r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator -   (Short& l , int& r) {   // 6a
  Int num;
  num.val = ((int)l.val - r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator -   (short& l , Int& r) {   // 8a
  Int num;
  num.val = ((int)l - r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator *   (Short& l , int& r) {   // 6a
  Int num;
  num.val = ((int)l.val * r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator *   (short& l , Int& r) {   // 8a
  Int num;
  num.val = ((int)l * r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator /   (Short& l , int& r) {   // 6a
  Int num;
  num.val = ((int)l.val / r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator /   (short& l , Int& r) {   // 8a
  Int num;
  num.val = ((int)l / r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator +=  (Short& l , int& r) {   // 6a
  Int num;
  num.val = (int)(l.val += (short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator +=  (short& l , Int& r) {   // 8a
  Int num;
  num.val = (int)(l += (short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator -=  (Short& l , int& r) {   // 6a
  Int num;
  num.val = (int)(l.val -= (short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator -=  (short& l , Int& r) {   // 8a
  Int num;
  num.val = (int)(l -= (short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator *=  (Short& l , int& r) {   // 6a
  Int num;
  num.val = (int)(l.val *= (short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator *=  (short& l , Int& r) {   // 8a
  Int num;
  num.val = (int)(l *= (short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator /=  (Short& l , int& r) {   // 6a
  Int num;
  num.val = (int)(l.val /= (short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator /=  (short& l , Int& r) {   // 8a
  Int num;
  num.val = (int)(l /= (short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +   (Short& l , UnsignedLong& r) { // 3a
  UnsignedLong num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -   (Short& l , UnsignedLong& r) { // 3a
  UnsignedLong num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *   (Short& l , UnsignedLong& r) { // 3a
  UnsignedLong num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /   (Short& l , UnsignedLong& r) { // 3a
  UnsignedLong num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +=  (Short& l , UnsignedLong& r) { // 3a
  UnsignedLong num;
  num.val = (unsigned long)(l.val += (short)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -=  (Short& l , UnsignedLong& r) { // 3a
  UnsignedLong num;
  num.val = (unsigned long)(l.val -= (short)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *=  (Short& l , UnsignedLong& r) { // 3a
  UnsignedLong num;
  num.val = (unsigned long)(l.val *= (short)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /=  (Short& l , UnsignedLong& r) { // 3a
  UnsignedLong num;
  num.val = (unsigned long)(l.val /= (short)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +   (Short& l , unsigned long& r) {   // 6a
  UnsignedLong num;
  num.val = ((unsigned long)l.val + r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +   (short& l , UnsignedLong& r) {   // 8a
  UnsignedLong num;
  num.val = ((unsigned long)l + r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -   (Short& l , unsigned long& r) {   // 6a
  UnsignedLong num;
  num.val = ((unsigned long)l.val - r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -   (short& l , UnsignedLong& r) {   // 8a
  UnsignedLong num;
  num.val = ((unsigned long)l - r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *   (Short& l , unsigned long& r) {   // 6a
  UnsignedLong num;
  num.val = ((unsigned long)l.val * r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *   (short& l , UnsignedLong& r) {   // 8a
  UnsignedLong num;
  num.val = ((unsigned long)l * r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /   (Short& l , unsigned long& r) {   // 6a
  UnsignedLong num;
  num.val = ((unsigned long)l.val / r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /   (short& l , UnsignedLong& r) {   // 8a
  UnsignedLong num;
  num.val = ((unsigned long)l / r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +=  (Short& l , unsigned long& r) {   // 6a
  UnsignedLong num;
  num.val = (unsigned long)(l.val += (short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +=  (short& l , UnsignedLong& r) {   // 8a
  UnsignedLong num;
  num.val = (unsigned long)(l += (short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -=  (Short& l , unsigned long& r) {   // 6a
  UnsignedLong num;
  num.val = (unsigned long)(l.val -= (short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -=  (short& l , UnsignedLong& r) {   // 8a
  UnsignedLong num;
  num.val = (unsigned long)(l -= (short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *=  (Short& l , unsigned long& r) {   // 6a
  UnsignedLong num;
  num.val = (unsigned long)(l.val *= (short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *=  (short& l , UnsignedLong& r) {   // 8a
  UnsignedLong num;
  num.val = (unsigned long)(l *= (short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /=  (Short& l , unsigned long& r) {   // 6a
  UnsignedLong num;
  num.val = (unsigned long)(l.val /= (short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /=  (short& l , UnsignedLong& r) {   // 8a
  UnsignedLong num;
  num.val = (unsigned long)(l /= (short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator +   (Short& l , Long& r) { // 3a
  Long num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
Long operator -   (Short& l , Long& r) { // 3a
  Long num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
Long operator *   (Short& l , Long& r) { // 3a
  Long num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
Long operator /   (Short& l , Long& r) { // 3a
  Long num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
Long operator +=  (Short& l , Long& r) { // 3a
  Long num;
  num.val = (long)(l.val += (short)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator -=  (Short& l , Long& r) { // 3a
  Long num;
  num.val = (long)(l.val -= (short)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator *=  (Short& l , Long& r) { // 3a
  Long num;
  num.val = (long)(l.val *= (short)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator /=  (Short& l , Long& r) { // 3a
  Long num;
  num.val = (long)(l.val /= (short)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator +   (Short& l , long& r) {   // 6a
  Long num;
  num.val = ((long)l.val + r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator +   (short& l , Long& r) {   // 8a
  Long num;
  num.val = ((long)l + r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator -   (Short& l , long& r) {   // 6a
  Long num;
  num.val = ((long)l.val - r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator -   (short& l , Long& r) {   // 8a
  Long num;
  num.val = ((long)l - r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator *   (Short& l , long& r) {   // 6a
  Long num;
  num.val = ((long)l.val * r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator *   (short& l , Long& r) {   // 8a
  Long num;
  num.val = ((long)l * r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator /   (Short& l , long& r) {   // 6a
  Long num;
  num.val = ((long)l.val / r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator /   (short& l , Long& r) {   // 8a
  Long num;
  num.val = ((long)l / r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator +=  (Short& l , long& r) {   // 6a
  Long num;
  num.val = (long)(l.val += (short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator +=  (short& l , Long& r) {   // 8a
  Long num;
  num.val = (long)(l += (short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator -=  (Short& l , long& r) {   // 6a
  Long num;
  num.val = (long)(l.val -= (short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator -=  (short& l , Long& r) {   // 8a
  Long num;
  num.val = (long)(l -= (short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator *=  (Short& l , long& r) {   // 6a
  Long num;
  num.val = (long)(l.val *= (short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator *=  (short& l , Long& r) {   // 8a
  Long num;
  num.val = (long)(l *= (short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator /=  (Short& l , long& r) {   // 6a
  Long num;
  num.val = (long)(l.val /= (short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator /=  (short& l , Long& r) {   // 8a
  Long num;
  num.val = (long)(l /= (short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator +   (Short& l , Float& r) { // 3a
  Float num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
Float operator -   (Short& l , Float& r) { // 3a
  Float num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
Float operator *   (Short& l , Float& r) { // 3a
  Float num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
Float operator /   (Short& l , Float& r) { // 3a
  Float num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
Float operator +=  (Short& l , Float& r) { // 3a
  Float num;
  num.val = (float)(l.val += (short)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
Float operator -=  (Short& l , Float& r) { // 3a
  Float num;
  num.val = (float)(l.val -= (short)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
Float operator *=  (Short& l , Float& r) { // 3a
  Float num;
  num.val = (float)(l.val *= (short)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
Float operator /=  (Short& l , Float& r) { // 3a
  Float num;
  num.val = (float)(l.val /= (short)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
Float operator +   (Short& l , float& r) {   // 6a
  Float num;
  num.val = ((float)l.val + r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator +   (short& l , Float& r) {   // 8a
  Float num;
  num.val = ((float)l + r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator -   (Short& l , float& r) {   // 6a
  Float num;
  num.val = ((float)l.val - r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator -   (short& l , Float& r) {   // 8a
  Float num;
  num.val = ((float)l - r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator *   (Short& l , float& r) {   // 6a
  Float num;
  num.val = ((float)l.val * r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator *   (short& l , Float& r) {   // 8a
  Float num;
  num.val = ((float)l * r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator /   (Short& l , float& r) {   // 6a
  Float num;
  num.val = ((float)l.val / r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator /   (short& l , Float& r) {   // 8a
  Float num;
  num.val = ((float)l / r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator +=  (Short& l , float& r) {   // 6a
  Float num;
  num.val = (float)(l.val += (short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator +=  (short& l , Float& r) {   // 8a
  Float num;
  num.val = (float)(l += (short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator -=  (Short& l , float& r) {   // 6a
  Float num;
  num.val = (float)(l.val -= (short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator -=  (short& l , Float& r) {   // 8a
  Float num;
  num.val = (float)(l -= (short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator *=  (Short& l , float& r) {   // 6a
  Float num;
  num.val = (float)(l.val *= (short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator *=  (short& l , Float& r) {   // 8a
  Float num;
  num.val = (float)(l *= (short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator /=  (Short& l , float& r) {   // 6a
  Float num;
  num.val = (float)(l.val /= (short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator /=  (short& l , Float& r) {   // 8a
  Float num;
  num.val = (float)(l /= (short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator +   (Short& l , Double& r) { // 3a
  Double num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
Double operator -   (Short& l , Double& r) { // 3a
  Double num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
Double operator *   (Short& l , Double& r) { // 3a
  Double num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
Double operator /   (Short& l , Double& r) { // 3a
  Double num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
Double operator +=  (Short& l , Double& r) { // 3a
  Double num;
  num.val = (double)(l.val += (short)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
Double operator -=  (Short& l , Double& r) { // 3a
  Double num;
  num.val = (double)(l.val -= (short)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
Double operator *=  (Short& l , Double& r) { // 3a
  Double num;
  num.val = (double)(l.val *= (short)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
Double operator /=  (Short& l , Double& r) { // 3a
  Double num;
  num.val = (double)(l.val /= (short)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
Double operator +   (Short& l , double& r) {   // 6a
  Double num;
  num.val = ((double)l.val + r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator +   (short& l , Double& r) {   // 8a
  Double num;
  num.val = ((double)l + r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator -   (Short& l , double& r) {   // 6a
  Double num;
  num.val = ((double)l.val - r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator -   (short& l , Double& r) {   // 8a
  Double num;
  num.val = ((double)l - r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator *   (Short& l , double& r) {   // 6a
  Double num;
  num.val = ((double)l.val * r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator *   (short& l , Double& r) {   // 8a
  Double num;
  num.val = ((double)l * r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator /   (Short& l , double& r) {   // 6a
  Double num;
  num.val = ((double)l.val / r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator /   (short& l , Double& r) {   // 8a
  Double num;
  num.val = ((double)l / r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator +=  (Short& l , double& r) {   // 6a
  Double num;
  num.val = (double)(l.val += (short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator +=  (short& l , Double& r) {   // 8a
  Double num;
  num.val = (double)(l += (short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator -=  (Short& l , double& r) {   // 6a
  Double num;
  num.val = (double)(l.val -= (short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator -=  (short& l , Double& r) {   // 8a
  Double num;
  num.val = (double)(l -= (short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator *=  (Short& l , double& r) {   // 6a
  Double num;
  num.val = (double)(l.val *= (short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator *=  (short& l , Double& r) {   // 8a
  Double num;
  num.val = (double)(l *= (short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator /=  (Short& l , double& r) {   // 6a
  Double num;
  num.val = (double)(l.val /= (short)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator /=  (short& l , Double& r) {   // 8a
  Double num;
  num.val = (double)(l /= (short)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator %   (Short& l , UnsignedChar& r) { // 3i
  Short num;
  num.val = (l.val % r.val);
  num.u = (l.u %   r.u);
  return num;
}

// **********************************************************************************************************
Short operator &   (Short& l , UnsignedChar& r) { // 3i
  Short num;
  num.val = (l.val & r.val);
  num.u = (l.u &   r.u);
  return num;
}

// **********************************************************************************************************
Short operator ^   (Short& l , UnsignedChar& r) { // 3i
  Short num;
  num.val = (l.val ^ r.val);
  num.u = (l.u ^   r.u);
  return num;
}

// **********************************************************************************************************
Short operator |   (Short& l , UnsignedChar& r) { // 3i
  Short num;
  num.val = (l.val | r.val);
  num.u = (l.u |   r.u);
  return num;
}

// **********************************************************************************************************
Short operator <<  (Short& l , UnsignedChar& r) { // 3i
  Short num;
  num.val = (l.val << r.val);
  num.u = (l.u <<  r.u);
  return num;
}

// **********************************************************************************************************
Short operator >>  (Short& l , UnsignedChar& r) { // 3i
  Short num;
  num.val = (l.val >> r.val);
  num.u = (l.u >>  r.u);
  return num;
}

// **********************************************************************************************************
Short operator %=  (Short& l , UnsignedChar& r) { // 3i
  Short num;
  num.val = (l.val %= r.val);
  num.u = (l.u %=  r.u);
  return num;
}

// **********************************************************************************************************
Short operator &=  (Short& l , UnsignedChar& r) { // 3i
  Short num;
  num.val = (l.val &= r.val);
  num.u = (l.u &=  r.u);
  return num;
}

// **********************************************************************************************************
Short operator |=  (Short& l , UnsignedChar& r) { // 3i
  Short num;
  num.val = (l.val |= r.val);
  num.u = (l.u |=  r.u);
  return num;
}

// **********************************************************************************************************
Short operator ^=  (Short& l , UnsignedChar& r) { // 3i
  Short num;
  num.val = (l.val ^= r.val);
  num.u = (l.u ^=  r.u);
  return num;
}

// **********************************************************************************************************
Short operator <<= (Short& l , UnsignedChar& r) { // 3i
  Short num;
  num.val = (l.val <<= r.val);
  num.u = (l.u <<= r.u);
  return num;
}

// **********************************************************************************************************
Short operator >>= (Short& l , UnsignedChar& r) { // 3i
  Short num;
  num.val = (l.val >>= r.val);
  num.u = (l.u >>= r.u);
  return num;
}

// **********************************************************************************************************
Short operator %   (Short& l , unsigned char& r) { // 6i
  Short num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator %   (short& l , UnsignedChar& r) { // 8i
  Short num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator &   (Short& l , unsigned char& r) { // 6i
  Short num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator &   (short& l , UnsignedChar& r) { // 8i
  Short num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator ^   (Short& l , unsigned char& r) { // 6i
  Short num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator ^   (short& l , UnsignedChar& r) { // 8i
  Short num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator |   (Short& l , unsigned char& r) { // 6i
  Short num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator |   (short& l , UnsignedChar& r) { // 8i
  Short num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator <<  (Short& l , unsigned char& r) { // 6i
  Short num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator <<  (short& l , UnsignedChar& r) { // 8i
  Short num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator >>  (Short& l , unsigned char& r) { // 6i
  Short num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator >>  (short& l , UnsignedChar& r) { // 8i
  Short num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator %=  (Short& l , unsigned char& r) { // 6i
  Short num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator %=  (short& l , UnsignedChar& r) { // 8i
  Short num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator &=  (Short& l , unsigned char& r) { // 6i
  Short num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator &=  (short& l , UnsignedChar& r) { // 8i
  Short num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator |=  (Short& l , unsigned char& r) { // 6i
  Short num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator |=  (short& l , UnsignedChar& r) { // 8i
  Short num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator ^=  (Short& l , unsigned char& r) { // 6i
  Short num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator ^=  (short& l , UnsignedChar& r) { // 8i
  Short num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator <<= (Short& l , unsigned char& r) { // 6i
  Short num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator <<= (short& l , UnsignedChar& r) { // 8i
  Short num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator >>= (Short& l , unsigned char& r) { // 6i
  Short num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator >>= (short& l , UnsignedChar& r) { // 8i
  Short num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator %   (Short& l , Char& r) { // 3i
  Short num;
  num.val = (l.val % r.val);
  num.u = (l.u %   r.u);
  return num;
}

// **********************************************************************************************************
Short operator &   (Short& l , Char& r) { // 3i
  Short num;
  num.val = (l.val & r.val);
  num.u = (l.u &   r.u);
  return num;
}

// **********************************************************************************************************
Short operator ^   (Short& l , Char& r) { // 3i
  Short num;
  num.val = (l.val ^ r.val);
  num.u = (l.u ^   r.u);
  return num;
}

// **********************************************************************************************************
Short operator |   (Short& l , Char& r) { // 3i
  Short num;
  num.val = (l.val | r.val);
  num.u = (l.u |   r.u);
  return num;
}

// **********************************************************************************************************
Short operator <<  (Short& l , Char& r) { // 3i
  Short num;
  num.val = (l.val << r.val);
  num.u = (l.u <<  r.u);
  return num;
}

// **********************************************************************************************************
Short operator >>  (Short& l , Char& r) { // 3i
  Short num;
  num.val = (l.val >> r.val);
  num.u = (l.u >>  r.u);
  return num;
}

// **********************************************************************************************************
Short operator %=  (Short& l , Char& r) { // 3i
  Short num;
  num.val = (l.val %= r.val);
  num.u = (l.u %=  r.u);
  return num;
}

// **********************************************************************************************************
Short operator &=  (Short& l , Char& r) { // 3i
  Short num;
  num.val = (l.val &= r.val);
  num.u = (l.u &=  r.u);
  return num;
}

// **********************************************************************************************************
Short operator |=  (Short& l , Char& r) { // 3i
  Short num;
  num.val = (l.val |= r.val);
  num.u = (l.u |=  r.u);
  return num;
}

// **********************************************************************************************************
Short operator ^=  (Short& l , Char& r) { // 3i
  Short num;
  num.val = (l.val ^= r.val);
  num.u = (l.u ^=  r.u);
  return num;
}

// **********************************************************************************************************
Short operator <<= (Short& l , Char& r) { // 3i
  Short num;
  num.val = (l.val <<= r.val);
  num.u = (l.u <<= r.u);
  return num;
}

// **********************************************************************************************************
Short operator >>= (Short& l , Char& r) { // 3i
  Short num;
  num.val = (l.val >>= r.val);
  num.u = (l.u >>= r.u);
  return num;
}

// **********************************************************************************************************
Short operator %   (Short& l , char& r) { // 6i
  Short num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator %   (short& l , Char& r) { // 8i
  Short num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator &   (Short& l , char& r) { // 6i
  Short num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator &   (short& l , Char& r) { // 8i
  Short num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator ^   (Short& l , char& r) { // 6i
  Short num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator ^   (short& l , Char& r) { // 8i
  Short num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator |   (Short& l , char& r) { // 6i
  Short num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator |   (short& l , Char& r) { // 8i
  Short num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator <<  (Short& l , char& r) { // 6i
  Short num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator <<  (short& l , Char& r) { // 8i
  Short num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator >>  (Short& l , char& r) { // 6i
  Short num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator >>  (short& l , Char& r) { // 8i
  Short num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator %=  (Short& l , char& r) { // 6i
  Short num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator %=  (short& l , Char& r) { // 8i
  Short num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator &=  (Short& l , char& r) { // 6i
  Short num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator &=  (short& l , Char& r) { // 8i
  Short num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator |=  (Short& l , char& r) { // 6i
  Short num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator |=  (short& l , Char& r) { // 8i
  Short num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator ^=  (Short& l , char& r) { // 6i
  Short num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator ^=  (short& l , Char& r) { // 8i
  Short num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator <<= (Short& l , char& r) { // 6i
  Short num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator <<= (short& l , Char& r) { // 8i
  Short num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator >>= (Short& l , char& r) { // 6i
  Short num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator >>= (short& l , Char& r) { // 8i
  Short num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator %   (Short& l , UnsignedShort& r) { // 3i
  Short num;
  num.val = (l.val % r.val);
  num.u = (l.u %   r.u);
  return num;
}

// **********************************************************************************************************
Short operator &   (Short& l , UnsignedShort& r) { // 3i
  Short num;
  num.val = (l.val & r.val);
  num.u = (l.u &   r.u);
  return num;
}

// **********************************************************************************************************
Short operator ^   (Short& l , UnsignedShort& r) { // 3i
  Short num;
  num.val = (l.val ^ r.val);
  num.u = (l.u ^   r.u);
  return num;
}

// **********************************************************************************************************
Short operator |   (Short& l , UnsignedShort& r) { // 3i
  Short num;
  num.val = (l.val | r.val);
  num.u = (l.u |   r.u);
  return num;
}

// **********************************************************************************************************
Short operator <<  (Short& l , UnsignedShort& r) { // 3i
  Short num;
  num.val = (l.val << r.val);
  num.u = (l.u <<  r.u);
  return num;
}

// **********************************************************************************************************
Short operator >>  (Short& l , UnsignedShort& r) { // 3i
  Short num;
  num.val = (l.val >> r.val);
  num.u = (l.u >>  r.u);
  return num;
}

// **********************************************************************************************************
Short operator %=  (Short& l , UnsignedShort& r) { // 3i
  Short num;
  num.val = (l.val %= r.val);
  num.u = (l.u %=  r.u);
  return num;
}

// **********************************************************************************************************
Short operator &=  (Short& l , UnsignedShort& r) { // 3i
  Short num;
  num.val = (l.val &= r.val);
  num.u = (l.u &=  r.u);
  return num;
}

// **********************************************************************************************************
Short operator |=  (Short& l , UnsignedShort& r) { // 3i
  Short num;
  num.val = (l.val |= r.val);
  num.u = (l.u |=  r.u);
  return num;
}

// **********************************************************************************************************
Short operator ^=  (Short& l , UnsignedShort& r) { // 3i
  Short num;
  num.val = (l.val ^= r.val);
  num.u = (l.u ^=  r.u);
  return num;
}

// **********************************************************************************************************
Short operator <<= (Short& l , UnsignedShort& r) { // 3i
  Short num;
  num.val = (l.val <<= r.val);
  num.u = (l.u <<= r.u);
  return num;
}

// **********************************************************************************************************
Short operator >>= (Short& l , UnsignedShort& r) { // 3i
  Short num;
  num.val = (l.val >>= r.val);
  num.u = (l.u >>= r.u);
  return num;
}

// **********************************************************************************************************
Short operator %   (Short& l , unsigned short& r) { // 6i
  Short num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator %   (short& l , UnsignedShort& r) { // 8i
  Short num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator &   (Short& l , unsigned short& r) { // 6i
  Short num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator &   (short& l , UnsignedShort& r) { // 8i
  Short num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator ^   (Short& l , unsigned short& r) { // 6i
  Short num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator ^   (short& l , UnsignedShort& r) { // 8i
  Short num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator |   (Short& l , unsigned short& r) { // 6i
  Short num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator |   (short& l , UnsignedShort& r) { // 8i
  Short num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator <<  (Short& l , unsigned short& r) { // 6i
  Short num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator <<  (short& l , UnsignedShort& r) { // 8i
  Short num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator >>  (Short& l , unsigned short& r) { // 6i
  Short num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator >>  (short& l , UnsignedShort& r) { // 8i
  Short num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator %=  (Short& l , unsigned short& r) { // 6i
  Short num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator %=  (short& l , UnsignedShort& r) { // 8i
  Short num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator &=  (Short& l , unsigned short& r) { // 6i
  Short num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator &=  (short& l , UnsignedShort& r) { // 8i
  Short num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator |=  (Short& l , unsigned short& r) { // 6i
  Short num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator |=  (short& l , UnsignedShort& r) { // 8i
  Short num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator ^=  (Short& l , unsigned short& r) { // 6i
  Short num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator ^=  (short& l , UnsignedShort& r) { // 8i
  Short num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator <<= (Short& l , unsigned short& r) { // 6i
  Short num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator <<= (short& l , UnsignedShort& r) { // 8i
  Short num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator >>= (Short& l , unsigned short& r) { // 6i
  Short num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator >>= (short& l , UnsignedShort& r) { // 8i
  Short num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short Short::operator %   (Short& r) { // 1i
  Short num;
  num.val = (val % r.val);
  num.u = (u %   r.u);
  return num;
}

// **********************************************************************************************************
Short Short::operator &   (Short& r) { // 1i
  Short num;
  num.val = (val & r.val);
  num.u = (u &   r.u);
  return num;
}

// **********************************************************************************************************
Short Short::operator ^   (Short& r) { // 1i
  Short num;
  num.val = (val ^ r.val);
  num.u = (u ^   r.u);
  return num;
}

// **********************************************************************************************************
Short Short::operator |   (Short& r) { // 1i
  Short num;
  num.val = (val | r.val);
  num.u = (u |   r.u);
  return num;
}

// **********************************************************************************************************
Short Short::operator <<  (Short& r) { // 1i
  Short num;
  num.val = (val << r.val);
  num.u = (u <<  r.u);
  return num;
}

// **********************************************************************************************************
Short Short::operator >>  (Short& r) { // 1i
  Short num;
  num.val = (val >> r.val);
  num.u = (u >>  r.u);
  return num;
}

// **********************************************************************************************************
Short Short::operator %=  (Short& r) { // 1i
  Short num;
  num.val = (val %= r.val);
  num.u = (u %=  r.u);
  return num;
}

// **********************************************************************************************************
Short Short::operator &=  (Short& r) { // 1i
  Short num;
  num.val = (val &= r.val);
  num.u = (u &=  r.u);
  return num;
}

// **********************************************************************************************************
Short Short::operator |=  (Short& r) { // 1i
  Short num;
  num.val = (val |= r.val);
  num.u = (u |=  r.u);
  return num;
}

// **********************************************************************************************************
Short Short::operator ^=  (Short& r) { // 1i
  Short num;
  num.val = (val ^= r.val);
  num.u = (u ^=  r.u);
  return num;
}

// **********************************************************************************************************
Short Short::operator <<= (Short& r) { // 1i
  Short num;
  num.val = (val <<= r.val);
  num.u = (u <<= r.u);
  return num;
}

// **********************************************************************************************************
Short Short::operator >>= (Short& r) { // 1i
  Short num;
  num.val = (val >>= r.val);
  num.u = (u >>= r.u);
  return num;
}

// **********************************************************************************************************
Short operator %   (Short& l , short& r) { // 6i
  Short num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator %   (short& l , Short& r) { // 8i
  Short num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator &   (Short& l , short& r) { // 6i
  Short num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator &   (short& l , Short& r) { // 8i
  Short num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator ^   (Short& l , short& r) { // 6i
  Short num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator ^   (short& l , Short& r) { // 8i
  Short num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator |   (Short& l , short& r) { // 6i
  Short num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator |   (short& l , Short& r) { // 8i
  Short num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator <<  (Short& l , short& r) { // 6i
  Short num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator <<  (short& l , Short& r) { // 8i
  Short num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator >>  (Short& l , short& r) { // 6i
  Short num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator >>  (short& l , Short& r) { // 8i
  Short num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator %=  (Short& l , short& r) { // 6i
  Short num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator %=  (short& l , Short& r) { // 8i
  Short num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator &=  (Short& l , short& r) { // 6i
  Short num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator &=  (short& l , Short& r) { // 8i
  Short num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator |=  (Short& l , short& r) { // 6i
  Short num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator |=  (short& l , Short& r) { // 8i
  Short num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator ^=  (Short& l , short& r) { // 6i
  Short num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator ^=  (short& l , Short& r) { // 8i
  Short num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator <<= (Short& l , short& r) { // 6i
  Short num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator <<= (short& l , Short& r) { // 8i
  Short num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short operator >>= (Short& l , short& r) { // 6i
  Short num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Short operator >>= (short& l , Short& r) { // 8i
  Short num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator %   (Short& l , UnsignedInt& r) { // 3i
  UnsignedInt num;
  num.val = (l.val % r.val);
  num.u = (l.u %   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator &   (Short& l , UnsignedInt& r) { // 3i
  UnsignedInt num;
  num.val = (l.val & r.val);
  num.u = (l.u &   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator ^   (Short& l , UnsignedInt& r) { // 3i
  UnsignedInt num;
  num.val = (l.val ^ r.val);
  num.u = (l.u ^   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator |   (Short& l , UnsignedInt& r) { // 3i
  UnsignedInt num;
  num.val = (l.val | r.val);
  num.u = (l.u |   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator <<  (Short& l , UnsignedInt& r) { // 3i
  UnsignedInt num;
  num.val = (l.val << r.val);
  num.u = (l.u <<  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator >>  (Short& l , UnsignedInt& r) { // 3i
  UnsignedInt num;
  num.val = (l.val >> r.val);
  num.u = (l.u >>  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator %=  (Short& l , UnsignedInt& r) { // 3i
  UnsignedInt num;
  num.val = (l.val %= r.val);
  num.u = (l.u %=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator &=  (Short& l , UnsignedInt& r) { // 3i
  UnsignedInt num;
  num.val = (l.val &= r.val);
  num.u = (l.u &=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator |=  (Short& l , UnsignedInt& r) { // 3i
  UnsignedInt num;
  num.val = (l.val |= r.val);
  num.u = (l.u |=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator ^=  (Short& l , UnsignedInt& r) { // 3i
  UnsignedInt num;
  num.val = (l.val ^= r.val);
  num.u = (l.u ^=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator <<= (Short& l , UnsignedInt& r) { // 3i
  UnsignedInt num;
  num.val = (l.val <<= r.val);
  num.u = (l.u <<= r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator >>= (Short& l , UnsignedInt& r) { // 3i
  UnsignedInt num;
  num.val = (l.val >>= r.val);
  num.u = (l.u >>= r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator %   (Short& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator %   (short& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator &   (Short& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator &   (short& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator ^   (Short& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator ^   (short& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator |   (Short& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator |   (short& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator <<  (Short& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator <<  (short& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator >>  (Short& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator >>  (short& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator %=  (Short& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator %=  (short& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator &=  (Short& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator &=  (short& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator |=  (Short& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator |=  (short& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator ^=  (Short& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator ^=  (short& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator <<= (Short& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator <<= (short& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator >>= (Short& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator >>= (short& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator %   (Short& l , Int& r) { // 3i
  Int num;
  num.val = (l.val % r.val);
  num.u = (l.u %   r.u);
  return num;
}

// **********************************************************************************************************
Int operator &   (Short& l , Int& r) { // 3i
  Int num;
  num.val = (l.val & r.val);
  num.u = (l.u &   r.u);
  return num;
}

// **********************************************************************************************************
Int operator ^   (Short& l , Int& r) { // 3i
  Int num;
  num.val = (l.val ^ r.val);
  num.u = (l.u ^   r.u);
  return num;
}

// **********************************************************************************************************
Int operator |   (Short& l , Int& r) { // 3i
  Int num;
  num.val = (l.val | r.val);
  num.u = (l.u |   r.u);
  return num;
}

// **********************************************************************************************************
Int operator <<  (Short& l , Int& r) { // 3i
  Int num;
  num.val = (l.val << r.val);
  num.u = (l.u <<  r.u);
  return num;
}

// **********************************************************************************************************
Int operator >>  (Short& l , Int& r) { // 3i
  Int num;
  num.val = (l.val >> r.val);
  num.u = (l.u >>  r.u);
  return num;
}

// **********************************************************************************************************
Int operator %=  (Short& l , Int& r) { // 3i
  Int num;
  num.val = (l.val %= r.val);
  num.u = (l.u %=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator &=  (Short& l , Int& r) { // 3i
  Int num;
  num.val = (l.val &= r.val);
  num.u = (l.u &=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator |=  (Short& l , Int& r) { // 3i
  Int num;
  num.val = (l.val |= r.val);
  num.u = (l.u |=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator ^=  (Short& l , Int& r) { // 3i
  Int num;
  num.val = (l.val ^= r.val);
  num.u = (l.u ^=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator <<= (Short& l , Int& r) { // 3i
  Int num;
  num.val = (l.val <<= r.val);
  num.u = (l.u <<= r.u);
  return num;
}

// **********************************************************************************************************
Int operator >>= (Short& l , Int& r) { // 3i
  Int num;
  num.val = (l.val >>= r.val);
  num.u = (l.u >>= r.u);
  return num;
}

// **********************************************************************************************************
Int operator %   (Short& l , int& r) { // 6i
  Int num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator %   (short& l , Int& r) { // 8i
  Int num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator &   (Short& l , int& r) { // 6i
  Int num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator &   (short& l , Int& r) { // 8i
  Int num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator ^   (Short& l , int& r) { // 6i
  Int num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator ^   (short& l , Int& r) { // 8i
  Int num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator |   (Short& l , int& r) { // 6i
  Int num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator |   (short& l , Int& r) { // 8i
  Int num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator <<  (Short& l , int& r) { // 6i
  Int num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator <<  (short& l , Int& r) { // 8i
  Int num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator >>  (Short& l , int& r) { // 6i
  Int num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator >>  (short& l , Int& r) { // 8i
  Int num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator %=  (Short& l , int& r) { // 6i
  Int num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator %=  (short& l , Int& r) { // 8i
  Int num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator &=  (Short& l , int& r) { // 6i
  Int num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator &=  (short& l , Int& r) { // 8i
  Int num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator |=  (Short& l , int& r) { // 6i
  Int num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator |=  (short& l , Int& r) { // 8i
  Int num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator ^=  (Short& l , int& r) { // 6i
  Int num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator ^=  (short& l , Int& r) { // 8i
  Int num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator <<= (Short& l , int& r) { // 6i
  Int num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator <<= (short& l , Int& r) { // 8i
  Int num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator >>= (Short& l , int& r) { // 6i
  Int num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator >>= (short& l , Int& r) { // 8i
  Int num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %   (Short& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val % r.val);
  num.u = (l.u %   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &   (Short& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val & r.val);
  num.u = (l.u &   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^   (Short& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val ^ r.val);
  num.u = (l.u ^   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |   (Short& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val | r.val);
  num.u = (l.u |   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<  (Short& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val << r.val);
  num.u = (l.u <<  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>  (Short& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val >> r.val);
  num.u = (l.u >>  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %=  (Short& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val %= r.val);
  num.u = (l.u %=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &=  (Short& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val &= r.val);
  num.u = (l.u &=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |=  (Short& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val |= r.val);
  num.u = (l.u |=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^=  (Short& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val ^= r.val);
  num.u = (l.u ^=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<= (Short& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val <<= r.val);
  num.u = (l.u <<= r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>= (Short& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val >>= r.val);
  num.u = (l.u >>= r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %   (Short& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %   (short& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &   (Short& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &   (short& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^   (Short& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^   (short& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |   (Short& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |   (short& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<  (Short& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<  (short& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>  (Short& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>  (short& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %=  (Short& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %=  (short& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &=  (Short& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &=  (short& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |=  (Short& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |=  (short& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^=  (Short& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^=  (short& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<= (Short& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<= (short& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>= (Short& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>= (short& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator %   (Short& l , Long& r) { // 3i
  Long num;
  num.val = (l.val % r.val);
  num.u = (l.u %   r.u);
  return num;
}

// **********************************************************************************************************
Long operator &   (Short& l , Long& r) { // 3i
  Long num;
  num.val = (l.val & r.val);
  num.u = (l.u &   r.u);
  return num;
}

// **********************************************************************************************************
Long operator ^   (Short& l , Long& r) { // 3i
  Long num;
  num.val = (l.val ^ r.val);
  num.u = (l.u ^   r.u);
  return num;
}

// **********************************************************************************************************
Long operator |   (Short& l , Long& r) { // 3i
  Long num;
  num.val = (l.val | r.val);
  num.u = (l.u |   r.u);
  return num;
}

// **********************************************************************************************************
Long operator <<  (Short& l , Long& r) { // 3i
  Long num;
  num.val = (l.val << r.val);
  num.u = (l.u <<  r.u);
  return num;
}

// **********************************************************************************************************
Long operator >>  (Short& l , Long& r) { // 3i
  Long num;
  num.val = (l.val >> r.val);
  num.u = (l.u >>  r.u);
  return num;
}

// **********************************************************************************************************
Long operator %=  (Short& l , Long& r) { // 3i
  Long num;
  num.val = (l.val %= r.val);
  num.u = (l.u %=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator &=  (Short& l , Long& r) { // 3i
  Long num;
  num.val = (l.val &= r.val);
  num.u = (l.u &=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator |=  (Short& l , Long& r) { // 3i
  Long num;
  num.val = (l.val |= r.val);
  num.u = (l.u |=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator ^=  (Short& l , Long& r) { // 3i
  Long num;
  num.val = (l.val ^= r.val);
  num.u = (l.u ^=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator <<= (Short& l , Long& r) { // 3i
  Long num;
  num.val = (l.val <<= r.val);
  num.u = (l.u <<= r.u);
  return num;
}

// **********************************************************************************************************
Long operator >>= (Short& l , Long& r) { // 3i
  Long num;
  num.val = (l.val >>= r.val);
  num.u = (l.u >>= r.u);
  return num;
}

// **********************************************************************************************************
Long operator %   (Short& l , long& r) { // 6i
  Long num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator %   (short& l , Long& r) { // 8i
  Long num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator &   (Short& l , long& r) { // 6i
  Long num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator &   (short& l , Long& r) { // 8i
  Long num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator ^   (Short& l , long& r) { // 6i
  Long num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator ^   (short& l , Long& r) { // 8i
  Long num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator |   (Short& l , long& r) { // 6i
  Long num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator |   (short& l , Long& r) { // 8i
  Long num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator <<  (Short& l , long& r) { // 6i
  Long num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator <<  (short& l , Long& r) { // 8i
  Long num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator >>  (Short& l , long& r) { // 6i
  Long num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator >>  (short& l , Long& r) { // 8i
  Long num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator %=  (Short& l , long& r) { // 6i
  Long num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator %=  (short& l , Long& r) { // 8i
  Long num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator &=  (Short& l , long& r) { // 6i
  Long num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator &=  (short& l , Long& r) { // 8i
  Long num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator |=  (Short& l , long& r) { // 6i
  Long num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator |=  (short& l , Long& r) { // 8i
  Long num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator ^=  (Short& l , long& r) { // 6i
  Long num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator ^=  (short& l , Long& r) { // 8i
  Long num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator <<= (Short& l , long& r) { // 6i
  Long num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator <<= (short& l , Long& r) { // 8i
  Long num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator >>= (Short& l , long& r) { // 6i
  Long num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator >>= (short& l , Long& r) { // 8i
  Long num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Short Short::operator ++(void) { // 1p, Prefix operator
   ++val;
  return *this;
}

// **********************************************************************************************************
Short Short::operator --(void) { // 1p, Prefix operator
   --val;
  return *this;
}

// **********************************************************************************************************
Short Short::operator ++(int) { // 1p, Postfix operator
   val++;
  return *this;
}

// **********************************************************************************************************
Short Short::operator --(int) { // 1p, Postfix operator
   val--;
  return *this;
}

// *********************************************************************************************************
// First class UnsignedInt constructor
// *********************************************************************************************************
UnsignedInt::UnsignedInt() {
  val=0;
  state=UNDEF;
  u.init();
}
// *********************************************************************************************************
// Second class UnsignedInt constructor
// *********************************************************************************************************
UnsignedInt::UnsignedInt(char* str) {
  val=0;
  state=UNDEF;
  u.init(str);
}
// *********************************************************************************************************
// First class UnsignedInt destructor
// *********************************************************************************************************
UnsignedInt::~UnsignedInt() {
  val=0;
  state=UNDEF;
  u.init();
}
// **********************************************************************************************************
UnsignedInt operator +   (UnsignedInt& l , UnsignedChar& r) { // 3a
  UnsignedInt num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator -   (UnsignedInt& l , UnsignedChar& r) { // 3a
  UnsignedInt num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator *   (UnsignedInt& l , UnsignedChar& r) { // 3a
  UnsignedInt num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator /   (UnsignedInt& l , UnsignedChar& r) { // 3a
  UnsignedInt num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator +=  (UnsignedInt& l , UnsignedChar& r) { // 3a
  UnsignedInt num;
  num.val = (unsigned int)(l.val += (unsigned int)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator -=  (UnsignedInt& l , UnsignedChar& r) { // 3a
  UnsignedInt num;
  num.val = (unsigned int)(l.val -= (unsigned int)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator *=  (UnsignedInt& l , UnsignedChar& r) { // 3a
  UnsignedInt num;
  num.val = (unsigned int)(l.val *= (unsigned int)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator /=  (UnsignedInt& l , UnsignedChar& r) { // 3a
  UnsignedInt num;
  num.val = (unsigned int)(l.val /= (unsigned int)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator +   (UnsignedInt& l , unsigned char& r) {   // 6a
  UnsignedInt num;
  num.val = (l.val + (unsigned int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator +   (unsigned int& l , UnsignedChar& r) {   // 8a
  UnsignedInt num;
  num.val = (l + (unsigned int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator -   (UnsignedInt& l , unsigned char& r) {   // 6a
  UnsignedInt num;
  num.val = (l.val - (unsigned int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator -   (unsigned int& l , UnsignedChar& r) {   // 8a
  UnsignedInt num;
  num.val = (l - (unsigned int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator *   (UnsignedInt& l , unsigned char& r) {   // 6a
  UnsignedInt num;
  num.val = (l.val * (unsigned int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator *   (unsigned int& l , UnsignedChar& r) {   // 8a
  UnsignedInt num;
  num.val = (l * (unsigned int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator /   (UnsignedInt& l , unsigned char& r) {   // 6a
  UnsignedInt num;
  num.val = (l.val / (unsigned int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator /   (unsigned int& l , UnsignedChar& r) {   // 8a
  UnsignedInt num;
  num.val = (l / (unsigned int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator +=  (UnsignedInt& l , unsigned char& r) {   // 6a
  UnsignedInt num;
  num.val = (unsigned int)(l.val += (unsigned int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator +=  (unsigned int& l , UnsignedChar& r) {   // 8a
  UnsignedInt num;
  num.val = (unsigned int)(l += (unsigned int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator -=  (UnsignedInt& l , unsigned char& r) {   // 6a
  UnsignedInt num;
  num.val = (unsigned int)(l.val -= (unsigned int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator -=  (unsigned int& l , UnsignedChar& r) {   // 8a
  UnsignedInt num;
  num.val = (unsigned int)(l -= (unsigned int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator *=  (UnsignedInt& l , unsigned char& r) {   // 6a
  UnsignedInt num;
  num.val = (unsigned int)(l.val *= (unsigned int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator *=  (unsigned int& l , UnsignedChar& r) {   // 8a
  UnsignedInt num;
  num.val = (unsigned int)(l *= (unsigned int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator /=  (UnsignedInt& l , unsigned char& r) {   // 6a
  UnsignedInt num;
  num.val = (unsigned int)(l.val /= (unsigned int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator /=  (unsigned int& l , UnsignedChar& r) {   // 8a
  UnsignedInt num;
  num.val = (unsigned int)(l /= (unsigned int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator +   (UnsignedInt& l , Char& r) { // 3a
  UnsignedInt num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator -   (UnsignedInt& l , Char& r) { // 3a
  UnsignedInt num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator *   (UnsignedInt& l , Char& r) { // 3a
  UnsignedInt num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator /   (UnsignedInt& l , Char& r) { // 3a
  UnsignedInt num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator +=  (UnsignedInt& l , Char& r) { // 3a
  UnsignedInt num;
  num.val = (unsigned int)(l.val += (unsigned int)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator -=  (UnsignedInt& l , Char& r) { // 3a
  UnsignedInt num;
  num.val = (unsigned int)(l.val -= (unsigned int)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator *=  (UnsignedInt& l , Char& r) { // 3a
  UnsignedInt num;
  num.val = (unsigned int)(l.val *= (unsigned int)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator /=  (UnsignedInt& l , Char& r) { // 3a
  UnsignedInt num;
  num.val = (unsigned int)(l.val /= (unsigned int)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator +   (UnsignedInt& l , char& r) {   // 6a
  UnsignedInt num;
  num.val = (l.val + (unsigned int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator +   (unsigned int& l , Char& r) {   // 8a
  UnsignedInt num;
  num.val = (l + (unsigned int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator -   (UnsignedInt& l , char& r) {   // 6a
  UnsignedInt num;
  num.val = (l.val - (unsigned int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator -   (unsigned int& l , Char& r) {   // 8a
  UnsignedInt num;
  num.val = (l - (unsigned int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator *   (UnsignedInt& l , char& r) {   // 6a
  UnsignedInt num;
  num.val = (l.val * (unsigned int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator *   (unsigned int& l , Char& r) {   // 8a
  UnsignedInt num;
  num.val = (l * (unsigned int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator /   (UnsignedInt& l , char& r) {   // 6a
  UnsignedInt num;
  num.val = (l.val / (unsigned int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator /   (unsigned int& l , Char& r) {   // 8a
  UnsignedInt num;
  num.val = (l / (unsigned int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator +=  (UnsignedInt& l , char& r) {   // 6a
  UnsignedInt num;
  num.val = (unsigned int)(l.val += (unsigned int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator +=  (unsigned int& l , Char& r) {   // 8a
  UnsignedInt num;
  num.val = (unsigned int)(l += (unsigned int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator -=  (UnsignedInt& l , char& r) {   // 6a
  UnsignedInt num;
  num.val = (unsigned int)(l.val -= (unsigned int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator -=  (unsigned int& l , Char& r) {   // 8a
  UnsignedInt num;
  num.val = (unsigned int)(l -= (unsigned int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator *=  (UnsignedInt& l , char& r) {   // 6a
  UnsignedInt num;
  num.val = (unsigned int)(l.val *= (unsigned int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator *=  (unsigned int& l , Char& r) {   // 8a
  UnsignedInt num;
  num.val = (unsigned int)(l *= (unsigned int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator /=  (UnsignedInt& l , char& r) {   // 6a
  UnsignedInt num;
  num.val = (unsigned int)(l.val /= (unsigned int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator /=  (unsigned int& l , Char& r) {   // 8a
  UnsignedInt num;
  num.val = (unsigned int)(l /= (unsigned int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator +   (UnsignedInt& l , UnsignedShort& r) { // 3a
  UnsignedInt num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator -   (UnsignedInt& l , UnsignedShort& r) { // 3a
  UnsignedInt num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator *   (UnsignedInt& l , UnsignedShort& r) { // 3a
  UnsignedInt num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator /   (UnsignedInt& l , UnsignedShort& r) { // 3a
  UnsignedInt num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator +=  (UnsignedInt& l , UnsignedShort& r) { // 3a
  UnsignedInt num;
  num.val = (unsigned int)(l.val += (unsigned int)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator -=  (UnsignedInt& l , UnsignedShort& r) { // 3a
  UnsignedInt num;
  num.val = (unsigned int)(l.val -= (unsigned int)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator *=  (UnsignedInt& l , UnsignedShort& r) { // 3a
  UnsignedInt num;
  num.val = (unsigned int)(l.val *= (unsigned int)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator /=  (UnsignedInt& l , UnsignedShort& r) { // 3a
  UnsignedInt num;
  num.val = (unsigned int)(l.val /= (unsigned int)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator +   (UnsignedInt& l , unsigned short& r) {   // 6a
  UnsignedInt num;
  num.val = (l.val + (unsigned int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator +   (unsigned int& l , UnsignedShort& r) {   // 8a
  UnsignedInt num;
  num.val = (l + (unsigned int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator -   (UnsignedInt& l , unsigned short& r) {   // 6a
  UnsignedInt num;
  num.val = (l.val - (unsigned int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator -   (unsigned int& l , UnsignedShort& r) {   // 8a
  UnsignedInt num;
  num.val = (l - (unsigned int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator *   (UnsignedInt& l , unsigned short& r) {   // 6a
  UnsignedInt num;
  num.val = (l.val * (unsigned int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator *   (unsigned int& l , UnsignedShort& r) {   // 8a
  UnsignedInt num;
  num.val = (l * (unsigned int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator /   (UnsignedInt& l , unsigned short& r) {   // 6a
  UnsignedInt num;
  num.val = (l.val / (unsigned int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator /   (unsigned int& l , UnsignedShort& r) {   // 8a
  UnsignedInt num;
  num.val = (l / (unsigned int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator +=  (UnsignedInt& l , unsigned short& r) {   // 6a
  UnsignedInt num;
  num.val = (unsigned int)(l.val += (unsigned int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator +=  (unsigned int& l , UnsignedShort& r) {   // 8a
  UnsignedInt num;
  num.val = (unsigned int)(l += (unsigned int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator -=  (UnsignedInt& l , unsigned short& r) {   // 6a
  UnsignedInt num;
  num.val = (unsigned int)(l.val -= (unsigned int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator -=  (unsigned int& l , UnsignedShort& r) {   // 8a
  UnsignedInt num;
  num.val = (unsigned int)(l -= (unsigned int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator *=  (UnsignedInt& l , unsigned short& r) {   // 6a
  UnsignedInt num;
  num.val = (unsigned int)(l.val *= (unsigned int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator *=  (unsigned int& l , UnsignedShort& r) {   // 8a
  UnsignedInt num;
  num.val = (unsigned int)(l *= (unsigned int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator /=  (UnsignedInt& l , unsigned short& r) {   // 6a
  UnsignedInt num;
  num.val = (unsigned int)(l.val /= (unsigned int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator /=  (unsigned int& l , UnsignedShort& r) {   // 8a
  UnsignedInt num;
  num.val = (unsigned int)(l /= (unsigned int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator +   (UnsignedInt& l , Short& r) { // 3a
  UnsignedInt num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator -   (UnsignedInt& l , Short& r) { // 3a
  UnsignedInt num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator *   (UnsignedInt& l , Short& r) { // 3a
  UnsignedInt num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator /   (UnsignedInt& l , Short& r) { // 3a
  UnsignedInt num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator +=  (UnsignedInt& l , Short& r) { // 3a
  UnsignedInt num;
  num.val = (unsigned int)(l.val += (unsigned int)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator -=  (UnsignedInt& l , Short& r) { // 3a
  UnsignedInt num;
  num.val = (unsigned int)(l.val -= (unsigned int)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator *=  (UnsignedInt& l , Short& r) { // 3a
  UnsignedInt num;
  num.val = (unsigned int)(l.val *= (unsigned int)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator /=  (UnsignedInt& l , Short& r) { // 3a
  UnsignedInt num;
  num.val = (unsigned int)(l.val /= (unsigned int)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator +   (UnsignedInt& l , short& r) {   // 6a
  UnsignedInt num;
  num.val = (l.val + (unsigned int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator +   (unsigned int& l , Short& r) {   // 8a
  UnsignedInt num;
  num.val = (l + (unsigned int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator -   (UnsignedInt& l , short& r) {   // 6a
  UnsignedInt num;
  num.val = (l.val - (unsigned int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator -   (unsigned int& l , Short& r) {   // 8a
  UnsignedInt num;
  num.val = (l - (unsigned int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator *   (UnsignedInt& l , short& r) {   // 6a
  UnsignedInt num;
  num.val = (l.val * (unsigned int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator *   (unsigned int& l , Short& r) {   // 8a
  UnsignedInt num;
  num.val = (l * (unsigned int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator /   (UnsignedInt& l , short& r) {   // 6a
  UnsignedInt num;
  num.val = (l.val / (unsigned int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator /   (unsigned int& l , Short& r) {   // 8a
  UnsignedInt num;
  num.val = (l / (unsigned int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator +=  (UnsignedInt& l , short& r) {   // 6a
  UnsignedInt num;
  num.val = (unsigned int)(l.val += (unsigned int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator +=  (unsigned int& l , Short& r) {   // 8a
  UnsignedInt num;
  num.val = (unsigned int)(l += (unsigned int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator -=  (UnsignedInt& l , short& r) {   // 6a
  UnsignedInt num;
  num.val = (unsigned int)(l.val -= (unsigned int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator -=  (unsigned int& l , Short& r) {   // 8a
  UnsignedInt num;
  num.val = (unsigned int)(l -= (unsigned int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator *=  (UnsignedInt& l , short& r) {   // 6a
  UnsignedInt num;
  num.val = (unsigned int)(l.val *= (unsigned int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator *=  (unsigned int& l , Short& r) {   // 8a
  UnsignedInt num;
  num.val = (unsigned int)(l *= (unsigned int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator /=  (UnsignedInt& l , short& r) {   // 6a
  UnsignedInt num;
  num.val = (unsigned int)(l.val /= (unsigned int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator /=  (unsigned int& l , Short& r) {   // 8a
  UnsignedInt num;
  num.val = (unsigned int)(l /= (unsigned int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt UnsignedInt::operator +   (UnsignedInt& r) { // 1a
  UnsignedInt num;
  num.val = (val + r.val);
  num.u = (u +   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt UnsignedInt::operator -   (UnsignedInt& r) { // 1a
  UnsignedInt num;
  num.val = (val - r.val);
  num.u = (u -   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt UnsignedInt::operator *   (UnsignedInt& r) { // 1a
  UnsignedInt num;
  num.val = (val * r.val);
  num.u = (u *   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt UnsignedInt::operator /   (UnsignedInt& r) { // 1a
  UnsignedInt num;
  num.val = (val / r.val);
  num.u = (u /   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt UnsignedInt::operator +=  (UnsignedInt& r) { // 1a
  UnsignedInt num;
  num.val = (val += r.val);
  num.u = (u +=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt UnsignedInt::operator -=  (UnsignedInt& r) { // 1a
  UnsignedInt num;
  num.val = (val -= r.val);
  num.u = (u -=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt UnsignedInt::operator *=  (UnsignedInt& r) { // 1a
  UnsignedInt num;
  num.val = (val *= r.val);
  num.u = (u *=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt UnsignedInt::operator /=  (UnsignedInt& r) { // 1a
  UnsignedInt num;
  num.val = (val /= r.val);
  num.u = (u /=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator +   (UnsignedInt& l , unsigned int& r) {   // 6a
  UnsignedInt num;
  num.val = (l.val + r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator +   (unsigned int& l , UnsignedInt& r) {   // 8a
  UnsignedInt num;
  num.val = (l + r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator -   (UnsignedInt& l , unsigned int& r) {   // 6a
  UnsignedInt num;
  num.val = (l.val - r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator -   (unsigned int& l , UnsignedInt& r) {   // 8a
  UnsignedInt num;
  num.val = (l - r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator *   (UnsignedInt& l , unsigned int& r) {   // 6a
  UnsignedInt num;
  num.val = (l.val * r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator *   (unsigned int& l , UnsignedInt& r) {   // 8a
  UnsignedInt num;
  num.val = (l * r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator /   (UnsignedInt& l , unsigned int& r) {   // 6a
  UnsignedInt num;
  num.val = (l.val / r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator /   (unsigned int& l , UnsignedInt& r) {   // 8a
  UnsignedInt num;
  num.val = (l / r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator +=  (UnsignedInt& l , unsigned int& r) {   // 6a
  UnsignedInt num;
  num.val = (unsigned int)(l.val += (unsigned int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator +=  (unsigned int& l , UnsignedInt& r) {   // 8a
  UnsignedInt num;
  num.val = (unsigned int)(l += (unsigned int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator -=  (UnsignedInt& l , unsigned int& r) {   // 6a
  UnsignedInt num;
  num.val = (unsigned int)(l.val -= (unsigned int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator -=  (unsigned int& l , UnsignedInt& r) {   // 8a
  UnsignedInt num;
  num.val = (unsigned int)(l -= (unsigned int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator *=  (UnsignedInt& l , unsigned int& r) {   // 6a
  UnsignedInt num;
  num.val = (unsigned int)(l.val *= (unsigned int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator *=  (unsigned int& l , UnsignedInt& r) {   // 8a
  UnsignedInt num;
  num.val = (unsigned int)(l *= (unsigned int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator /=  (UnsignedInt& l , unsigned int& r) {   // 6a
  UnsignedInt num;
  num.val = (unsigned int)(l.val /= (unsigned int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator /=  (unsigned int& l , UnsignedInt& r) {   // 8a
  UnsignedInt num;
  num.val = (unsigned int)(l /= (unsigned int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator +   (UnsignedInt& l , Int& r) { // 3a
  Int num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
Int operator -   (UnsignedInt& l , Int& r) { // 3a
  Int num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
Int operator *   (UnsignedInt& l , Int& r) { // 3a
  Int num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
Int operator /   (UnsignedInt& l , Int& r) { // 3a
  Int num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
Int operator +=  (UnsignedInt& l , Int& r) { // 3a
  Int num;
  num.val = (int)(l.val += (unsigned int)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator -=  (UnsignedInt& l , Int& r) { // 3a
  Int num;
  num.val = (int)(l.val -= (unsigned int)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator *=  (UnsignedInt& l , Int& r) { // 3a
  Int num;
  num.val = (int)(l.val *= (unsigned int)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator /=  (UnsignedInt& l , Int& r) { // 3a
  Int num;
  num.val = (int)(l.val /= (unsigned int)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator +   (UnsignedInt& l , int& r) {   // 6a
  Int num;
  num.val = ((int)l.val + r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator +   (unsigned int& l , Int& r) {   // 8a
  Int num;
  num.val = ((int)l + r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator -   (UnsignedInt& l , int& r) {   // 6a
  Int num;
  num.val = ((int)l.val - r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator -   (unsigned int& l , Int& r) {   // 8a
  Int num;
  num.val = ((int)l - r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator *   (UnsignedInt& l , int& r) {   // 6a
  Int num;
  num.val = ((int)l.val * r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator *   (unsigned int& l , Int& r) {   // 8a
  Int num;
  num.val = ((int)l * r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator /   (UnsignedInt& l , int& r) {   // 6a
  Int num;
  num.val = ((int)l.val / r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator /   (unsigned int& l , Int& r) {   // 8a
  Int num;
  num.val = ((int)l / r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator +=  (UnsignedInt& l , int& r) {   // 6a
  Int num;
  num.val = (int)(l.val += (unsigned int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator +=  (unsigned int& l , Int& r) {   // 8a
  Int num;
  num.val = (int)(l += (unsigned int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator -=  (UnsignedInt& l , int& r) {   // 6a
  Int num;
  num.val = (int)(l.val -= (unsigned int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator -=  (unsigned int& l , Int& r) {   // 8a
  Int num;
  num.val = (int)(l -= (unsigned int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator *=  (UnsignedInt& l , int& r) {   // 6a
  Int num;
  num.val = (int)(l.val *= (unsigned int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator *=  (unsigned int& l , Int& r) {   // 8a
  Int num;
  num.val = (int)(l *= (unsigned int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator /=  (UnsignedInt& l , int& r) {   // 6a
  Int num;
  num.val = (int)(l.val /= (unsigned int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator /=  (unsigned int& l , Int& r) {   // 8a
  Int num;
  num.val = (int)(l /= (unsigned int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +   (UnsignedInt& l , UnsignedLong& r) { // 3a
  UnsignedLong num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -   (UnsignedInt& l , UnsignedLong& r) { // 3a
  UnsignedLong num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *   (UnsignedInt& l , UnsignedLong& r) { // 3a
  UnsignedLong num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /   (UnsignedInt& l , UnsignedLong& r) { // 3a
  UnsignedLong num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +=  (UnsignedInt& l , UnsignedLong& r) { // 3a
  UnsignedLong num;
  num.val = (unsigned long)(l.val += (unsigned int)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -=  (UnsignedInt& l , UnsignedLong& r) { // 3a
  UnsignedLong num;
  num.val = (unsigned long)(l.val -= (unsigned int)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *=  (UnsignedInt& l , UnsignedLong& r) { // 3a
  UnsignedLong num;
  num.val = (unsigned long)(l.val *= (unsigned int)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /=  (UnsignedInt& l , UnsignedLong& r) { // 3a
  UnsignedLong num;
  num.val = (unsigned long)(l.val /= (unsigned int)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +   (UnsignedInt& l , unsigned long& r) {   // 6a
  UnsignedLong num;
  num.val = ((unsigned long)l.val + r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +   (unsigned int& l , UnsignedLong& r) {   // 8a
  UnsignedLong num;
  num.val = ((unsigned long)l + r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -   (UnsignedInt& l , unsigned long& r) {   // 6a
  UnsignedLong num;
  num.val = ((unsigned long)l.val - r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -   (unsigned int& l , UnsignedLong& r) {   // 8a
  UnsignedLong num;
  num.val = ((unsigned long)l - r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *   (UnsignedInt& l , unsigned long& r) {   // 6a
  UnsignedLong num;
  num.val = ((unsigned long)l.val * r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *   (unsigned int& l , UnsignedLong& r) {   // 8a
  UnsignedLong num;
  num.val = ((unsigned long)l * r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /   (UnsignedInt& l , unsigned long& r) {   // 6a
  UnsignedLong num;
  num.val = ((unsigned long)l.val / r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /   (unsigned int& l , UnsignedLong& r) {   // 8a
  UnsignedLong num;
  num.val = ((unsigned long)l / r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +=  (UnsignedInt& l , unsigned long& r) {   // 6a
  UnsignedLong num;
  num.val = (unsigned long)(l.val += (unsigned int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +=  (unsigned int& l , UnsignedLong& r) {   // 8a
  UnsignedLong num;
  num.val = (unsigned long)(l += (unsigned int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -=  (UnsignedInt& l , unsigned long& r) {   // 6a
  UnsignedLong num;
  num.val = (unsigned long)(l.val -= (unsigned int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -=  (unsigned int& l , UnsignedLong& r) {   // 8a
  UnsignedLong num;
  num.val = (unsigned long)(l -= (unsigned int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *=  (UnsignedInt& l , unsigned long& r) {   // 6a
  UnsignedLong num;
  num.val = (unsigned long)(l.val *= (unsigned int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *=  (unsigned int& l , UnsignedLong& r) {   // 8a
  UnsignedLong num;
  num.val = (unsigned long)(l *= (unsigned int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /=  (UnsignedInt& l , unsigned long& r) {   // 6a
  UnsignedLong num;
  num.val = (unsigned long)(l.val /= (unsigned int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /=  (unsigned int& l , UnsignedLong& r) {   // 8a
  UnsignedLong num;
  num.val = (unsigned long)(l /= (unsigned int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator +   (UnsignedInt& l , Long& r) { // 3a
  Long num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
Long operator -   (UnsignedInt& l , Long& r) { // 3a
  Long num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
Long operator *   (UnsignedInt& l , Long& r) { // 3a
  Long num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
Long operator /   (UnsignedInt& l , Long& r) { // 3a
  Long num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
Long operator +=  (UnsignedInt& l , Long& r) { // 3a
  Long num;
  num.val = (long)(l.val += (unsigned int)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator -=  (UnsignedInt& l , Long& r) { // 3a
  Long num;
  num.val = (long)(l.val -= (unsigned int)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator *=  (UnsignedInt& l , Long& r) { // 3a
  Long num;
  num.val = (long)(l.val *= (unsigned int)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator /=  (UnsignedInt& l , Long& r) { // 3a
  Long num;
  num.val = (long)(l.val /= (unsigned int)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator +   (UnsignedInt& l , long& r) {   // 6a
  Long num;
  num.val = ((long)l.val + r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator +   (unsigned int& l , Long& r) {   // 8a
  Long num;
  num.val = ((long)l + r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator -   (UnsignedInt& l , long& r) {   // 6a
  Long num;
  num.val = ((long)l.val - r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator -   (unsigned int& l , Long& r) {   // 8a
  Long num;
  num.val = ((long)l - r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator *   (UnsignedInt& l , long& r) {   // 6a
  Long num;
  num.val = ((long)l.val * r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator *   (unsigned int& l , Long& r) {   // 8a
  Long num;
  num.val = ((long)l * r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator /   (UnsignedInt& l , long& r) {   // 6a
  Long num;
  num.val = ((long)l.val / r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator /   (unsigned int& l , Long& r) {   // 8a
  Long num;
  num.val = ((long)l / r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator +=  (UnsignedInt& l , long& r) {   // 6a
  Long num;
  num.val = (long)(l.val += (unsigned int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator +=  (unsigned int& l , Long& r) {   // 8a
  Long num;
  num.val = (long)(l += (unsigned int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator -=  (UnsignedInt& l , long& r) {   // 6a
  Long num;
  num.val = (long)(l.val -= (unsigned int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator -=  (unsigned int& l , Long& r) {   // 8a
  Long num;
  num.val = (long)(l -= (unsigned int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator *=  (UnsignedInt& l , long& r) {   // 6a
  Long num;
  num.val = (long)(l.val *= (unsigned int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator *=  (unsigned int& l , Long& r) {   // 8a
  Long num;
  num.val = (long)(l *= (unsigned int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator /=  (UnsignedInt& l , long& r) {   // 6a
  Long num;
  num.val = (long)(l.val /= (unsigned int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator /=  (unsigned int& l , Long& r) {   // 8a
  Long num;
  num.val = (long)(l /= (unsigned int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator +   (UnsignedInt& l , Float& r) { // 3a
  Float num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
Float operator -   (UnsignedInt& l , Float& r) { // 3a
  Float num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
Float operator *   (UnsignedInt& l , Float& r) { // 3a
  Float num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
Float operator /   (UnsignedInt& l , Float& r) { // 3a
  Float num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
Float operator +=  (UnsignedInt& l , Float& r) { // 3a
  Float num;
  num.val = (float)(l.val += (unsigned int)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
Float operator -=  (UnsignedInt& l , Float& r) { // 3a
  Float num;
  num.val = (float)(l.val -= (unsigned int)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
Float operator *=  (UnsignedInt& l , Float& r) { // 3a
  Float num;
  num.val = (float)(l.val *= (unsigned int)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
Float operator /=  (UnsignedInt& l , Float& r) { // 3a
  Float num;
  num.val = (float)(l.val /= (unsigned int)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
Float operator +   (UnsignedInt& l , float& r) {   // 6a
  Float num;
  num.val = ((float)l.val + r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator +   (unsigned int& l , Float& r) {   // 8a
  Float num;
  num.val = ((float)l + r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator -   (UnsignedInt& l , float& r) {   // 6a
  Float num;
  num.val = ((float)l.val - r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator -   (unsigned int& l , Float& r) {   // 8a
  Float num;
  num.val = ((float)l - r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator *   (UnsignedInt& l , float& r) {   // 6a
  Float num;
  num.val = ((float)l.val * r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator *   (unsigned int& l , Float& r) {   // 8a
  Float num;
  num.val = ((float)l * r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator /   (UnsignedInt& l , float& r) {   // 6a
  Float num;
  num.val = ((float)l.val / r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator /   (unsigned int& l , Float& r) {   // 8a
  Float num;
  num.val = ((float)l / r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator +=  (UnsignedInt& l , float& r) {   // 6a
  Float num;
  num.val = (float)(l.val += (unsigned int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator +=  (unsigned int& l , Float& r) {   // 8a
  Float num;
  num.val = (float)(l += (unsigned int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator -=  (UnsignedInt& l , float& r) {   // 6a
  Float num;
  num.val = (float)(l.val -= (unsigned int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator -=  (unsigned int& l , Float& r) {   // 8a
  Float num;
  num.val = (float)(l -= (unsigned int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator *=  (UnsignedInt& l , float& r) {   // 6a
  Float num;
  num.val = (float)(l.val *= (unsigned int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator *=  (unsigned int& l , Float& r) {   // 8a
  Float num;
  num.val = (float)(l *= (unsigned int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator /=  (UnsignedInt& l , float& r) {   // 6a
  Float num;
  num.val = (float)(l.val /= (unsigned int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator /=  (unsigned int& l , Float& r) {   // 8a
  Float num;
  num.val = (float)(l /= (unsigned int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator +   (UnsignedInt& l , Double& r) { // 3a
  Double num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
Double operator -   (UnsignedInt& l , Double& r) { // 3a
  Double num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
Double operator *   (UnsignedInt& l , Double& r) { // 3a
  Double num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
Double operator /   (UnsignedInt& l , Double& r) { // 3a
  Double num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
Double operator +=  (UnsignedInt& l , Double& r) { // 3a
  Double num;
  num.val = (double)(l.val += (unsigned int)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
Double operator -=  (UnsignedInt& l , Double& r) { // 3a
  Double num;
  num.val = (double)(l.val -= (unsigned int)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
Double operator *=  (UnsignedInt& l , Double& r) { // 3a
  Double num;
  num.val = (double)(l.val *= (unsigned int)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
Double operator /=  (UnsignedInt& l , Double& r) { // 3a
  Double num;
  num.val = (double)(l.val /= (unsigned int)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
Double operator +   (UnsignedInt& l , double& r) {   // 6a
  Double num;
  num.val = ((double)l.val + r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator +   (unsigned int& l , Double& r) {   // 8a
  Double num;
  num.val = ((double)l + r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator -   (UnsignedInt& l , double& r) {   // 6a
  Double num;
  num.val = ((double)l.val - r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator -   (unsigned int& l , Double& r) {   // 8a
  Double num;
  num.val = ((double)l - r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator *   (UnsignedInt& l , double& r) {   // 6a
  Double num;
  num.val = ((double)l.val * r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator *   (unsigned int& l , Double& r) {   // 8a
  Double num;
  num.val = ((double)l * r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator /   (UnsignedInt& l , double& r) {   // 6a
  Double num;
  num.val = ((double)l.val / r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator /   (unsigned int& l , Double& r) {   // 8a
  Double num;
  num.val = ((double)l / r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator +=  (UnsignedInt& l , double& r) {   // 6a
  Double num;
  num.val = (double)(l.val += (unsigned int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator +=  (unsigned int& l , Double& r) {   // 8a
  Double num;
  num.val = (double)(l += (unsigned int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator -=  (UnsignedInt& l , double& r) {   // 6a
  Double num;
  num.val = (double)(l.val -= (unsigned int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator -=  (unsigned int& l , Double& r) {   // 8a
  Double num;
  num.val = (double)(l -= (unsigned int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator *=  (UnsignedInt& l , double& r) {   // 6a
  Double num;
  num.val = (double)(l.val *= (unsigned int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator *=  (unsigned int& l , Double& r) {   // 8a
  Double num;
  num.val = (double)(l *= (unsigned int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator /=  (UnsignedInt& l , double& r) {   // 6a
  Double num;
  num.val = (double)(l.val /= (unsigned int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator /=  (unsigned int& l , Double& r) {   // 8a
  Double num;
  num.val = (double)(l /= (unsigned int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator %   (UnsignedInt& l , UnsignedChar& r) { // 3i
  UnsignedInt num;
  num.val = (l.val % r.val);
  num.u = (l.u %   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator &   (UnsignedInt& l , UnsignedChar& r) { // 3i
  UnsignedInt num;
  num.val = (l.val & r.val);
  num.u = (l.u &   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator ^   (UnsignedInt& l , UnsignedChar& r) { // 3i
  UnsignedInt num;
  num.val = (l.val ^ r.val);
  num.u = (l.u ^   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator |   (UnsignedInt& l , UnsignedChar& r) { // 3i
  UnsignedInt num;
  num.val = (l.val | r.val);
  num.u = (l.u |   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator <<  (UnsignedInt& l , UnsignedChar& r) { // 3i
  UnsignedInt num;
  num.val = (l.val << r.val);
  num.u = (l.u <<  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator >>  (UnsignedInt& l , UnsignedChar& r) { // 3i
  UnsignedInt num;
  num.val = (l.val >> r.val);
  num.u = (l.u >>  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator %=  (UnsignedInt& l , UnsignedChar& r) { // 3i
  UnsignedInt num;
  num.val = (l.val %= r.val);
  num.u = (l.u %=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator &=  (UnsignedInt& l , UnsignedChar& r) { // 3i
  UnsignedInt num;
  num.val = (l.val &= r.val);
  num.u = (l.u &=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator |=  (UnsignedInt& l , UnsignedChar& r) { // 3i
  UnsignedInt num;
  num.val = (l.val |= r.val);
  num.u = (l.u |=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator ^=  (UnsignedInt& l , UnsignedChar& r) { // 3i
  UnsignedInt num;
  num.val = (l.val ^= r.val);
  num.u = (l.u ^=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator <<= (UnsignedInt& l , UnsignedChar& r) { // 3i
  UnsignedInt num;
  num.val = (l.val <<= r.val);
  num.u = (l.u <<= r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator >>= (UnsignedInt& l , UnsignedChar& r) { // 3i
  UnsignedInt num;
  num.val = (l.val >>= r.val);
  num.u = (l.u >>= r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator %   (UnsignedInt& l , unsigned char& r) { // 6i
  UnsignedInt num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator %   (unsigned int& l , UnsignedChar& r) { // 8i
  UnsignedInt num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator &   (UnsignedInt& l , unsigned char& r) { // 6i
  UnsignedInt num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator &   (unsigned int& l , UnsignedChar& r) { // 8i
  UnsignedInt num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator ^   (UnsignedInt& l , unsigned char& r) { // 6i
  UnsignedInt num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator ^   (unsigned int& l , UnsignedChar& r) { // 8i
  UnsignedInt num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator |   (UnsignedInt& l , unsigned char& r) { // 6i
  UnsignedInt num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator |   (unsigned int& l , UnsignedChar& r) { // 8i
  UnsignedInt num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator <<  (UnsignedInt& l , unsigned char& r) { // 6i
  UnsignedInt num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator <<  (unsigned int& l , UnsignedChar& r) { // 8i
  UnsignedInt num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator >>  (UnsignedInt& l , unsigned char& r) { // 6i
  UnsignedInt num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator >>  (unsigned int& l , UnsignedChar& r) { // 8i
  UnsignedInt num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator %=  (UnsignedInt& l , unsigned char& r) { // 6i
  UnsignedInt num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator %=  (unsigned int& l , UnsignedChar& r) { // 8i
  UnsignedInt num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator &=  (UnsignedInt& l , unsigned char& r) { // 6i
  UnsignedInt num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator &=  (unsigned int& l , UnsignedChar& r) { // 8i
  UnsignedInt num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator |=  (UnsignedInt& l , unsigned char& r) { // 6i
  UnsignedInt num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator |=  (unsigned int& l , UnsignedChar& r) { // 8i
  UnsignedInt num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator ^=  (UnsignedInt& l , unsigned char& r) { // 6i
  UnsignedInt num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator ^=  (unsigned int& l , UnsignedChar& r) { // 8i
  UnsignedInt num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator <<= (UnsignedInt& l , unsigned char& r) { // 6i
  UnsignedInt num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator <<= (unsigned int& l , UnsignedChar& r) { // 8i
  UnsignedInt num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator >>= (UnsignedInt& l , unsigned char& r) { // 6i
  UnsignedInt num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator >>= (unsigned int& l , UnsignedChar& r) { // 8i
  UnsignedInt num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator %   (UnsignedInt& l , Char& r) { // 3i
  UnsignedInt num;
  num.val = (l.val % r.val);
  num.u = (l.u %   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator &   (UnsignedInt& l , Char& r) { // 3i
  UnsignedInt num;
  num.val = (l.val & r.val);
  num.u = (l.u &   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator ^   (UnsignedInt& l , Char& r) { // 3i
  UnsignedInt num;
  num.val = (l.val ^ r.val);
  num.u = (l.u ^   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator |   (UnsignedInt& l , Char& r) { // 3i
  UnsignedInt num;
  num.val = (l.val | r.val);
  num.u = (l.u |   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator <<  (UnsignedInt& l , Char& r) { // 3i
  UnsignedInt num;
  num.val = (l.val << r.val);
  num.u = (l.u <<  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator >>  (UnsignedInt& l , Char& r) { // 3i
  UnsignedInt num;
  num.val = (l.val >> r.val);
  num.u = (l.u >>  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator %=  (UnsignedInt& l , Char& r) { // 3i
  UnsignedInt num;
  num.val = (l.val %= r.val);
  num.u = (l.u %=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator &=  (UnsignedInt& l , Char& r) { // 3i
  UnsignedInt num;
  num.val = (l.val &= r.val);
  num.u = (l.u &=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator |=  (UnsignedInt& l , Char& r) { // 3i
  UnsignedInt num;
  num.val = (l.val |= r.val);
  num.u = (l.u |=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator ^=  (UnsignedInt& l , Char& r) { // 3i
  UnsignedInt num;
  num.val = (l.val ^= r.val);
  num.u = (l.u ^=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator <<= (UnsignedInt& l , Char& r) { // 3i
  UnsignedInt num;
  num.val = (l.val <<= r.val);
  num.u = (l.u <<= r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator >>= (UnsignedInt& l , Char& r) { // 3i
  UnsignedInt num;
  num.val = (l.val >>= r.val);
  num.u = (l.u >>= r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator %   (UnsignedInt& l , char& r) { // 6i
  UnsignedInt num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator %   (unsigned int& l , Char& r) { // 8i
  UnsignedInt num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator &   (UnsignedInt& l , char& r) { // 6i
  UnsignedInt num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator &   (unsigned int& l , Char& r) { // 8i
  UnsignedInt num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator ^   (UnsignedInt& l , char& r) { // 6i
  UnsignedInt num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator ^   (unsigned int& l , Char& r) { // 8i
  UnsignedInt num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator |   (UnsignedInt& l , char& r) { // 6i
  UnsignedInt num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator |   (unsigned int& l , Char& r) { // 8i
  UnsignedInt num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator <<  (UnsignedInt& l , char& r) { // 6i
  UnsignedInt num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator <<  (unsigned int& l , Char& r) { // 8i
  UnsignedInt num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator >>  (UnsignedInt& l , char& r) { // 6i
  UnsignedInt num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator >>  (unsigned int& l , Char& r) { // 8i
  UnsignedInt num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator %=  (UnsignedInt& l , char& r) { // 6i
  UnsignedInt num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator %=  (unsigned int& l , Char& r) { // 8i
  UnsignedInt num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator &=  (UnsignedInt& l , char& r) { // 6i
  UnsignedInt num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator &=  (unsigned int& l , Char& r) { // 8i
  UnsignedInt num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator |=  (UnsignedInt& l , char& r) { // 6i
  UnsignedInt num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator |=  (unsigned int& l , Char& r) { // 8i
  UnsignedInt num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator ^=  (UnsignedInt& l , char& r) { // 6i
  UnsignedInt num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator ^=  (unsigned int& l , Char& r) { // 8i
  UnsignedInt num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator <<= (UnsignedInt& l , char& r) { // 6i
  UnsignedInt num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator <<= (unsigned int& l , Char& r) { // 8i
  UnsignedInt num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator >>= (UnsignedInt& l , char& r) { // 6i
  UnsignedInt num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator >>= (unsigned int& l , Char& r) { // 8i
  UnsignedInt num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator %   (UnsignedInt& l , UnsignedShort& r) { // 3i
  UnsignedInt num;
  num.val = (l.val % r.val);
  num.u = (l.u %   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator &   (UnsignedInt& l , UnsignedShort& r) { // 3i
  UnsignedInt num;
  num.val = (l.val & r.val);
  num.u = (l.u &   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator ^   (UnsignedInt& l , UnsignedShort& r) { // 3i
  UnsignedInt num;
  num.val = (l.val ^ r.val);
  num.u = (l.u ^   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator |   (UnsignedInt& l , UnsignedShort& r) { // 3i
  UnsignedInt num;
  num.val = (l.val | r.val);
  num.u = (l.u |   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator <<  (UnsignedInt& l , UnsignedShort& r) { // 3i
  UnsignedInt num;
  num.val = (l.val << r.val);
  num.u = (l.u <<  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator >>  (UnsignedInt& l , UnsignedShort& r) { // 3i
  UnsignedInt num;
  num.val = (l.val >> r.val);
  num.u = (l.u >>  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator %=  (UnsignedInt& l , UnsignedShort& r) { // 3i
  UnsignedInt num;
  num.val = (l.val %= r.val);
  num.u = (l.u %=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator &=  (UnsignedInt& l , UnsignedShort& r) { // 3i
  UnsignedInt num;
  num.val = (l.val &= r.val);
  num.u = (l.u &=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator |=  (UnsignedInt& l , UnsignedShort& r) { // 3i
  UnsignedInt num;
  num.val = (l.val |= r.val);
  num.u = (l.u |=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator ^=  (UnsignedInt& l , UnsignedShort& r) { // 3i
  UnsignedInt num;
  num.val = (l.val ^= r.val);
  num.u = (l.u ^=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator <<= (UnsignedInt& l , UnsignedShort& r) { // 3i
  UnsignedInt num;
  num.val = (l.val <<= r.val);
  num.u = (l.u <<= r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator >>= (UnsignedInt& l , UnsignedShort& r) { // 3i
  UnsignedInt num;
  num.val = (l.val >>= r.val);
  num.u = (l.u >>= r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator %   (UnsignedInt& l , unsigned short& r) { // 6i
  UnsignedInt num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator %   (unsigned int& l , UnsignedShort& r) { // 8i
  UnsignedInt num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator &   (UnsignedInt& l , unsigned short& r) { // 6i
  UnsignedInt num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator &   (unsigned int& l , UnsignedShort& r) { // 8i
  UnsignedInt num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator ^   (UnsignedInt& l , unsigned short& r) { // 6i
  UnsignedInt num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator ^   (unsigned int& l , UnsignedShort& r) { // 8i
  UnsignedInt num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator |   (UnsignedInt& l , unsigned short& r) { // 6i
  UnsignedInt num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator |   (unsigned int& l , UnsignedShort& r) { // 8i
  UnsignedInt num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator <<  (UnsignedInt& l , unsigned short& r) { // 6i
  UnsignedInt num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator <<  (unsigned int& l , UnsignedShort& r) { // 8i
  UnsignedInt num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator >>  (UnsignedInt& l , unsigned short& r) { // 6i
  UnsignedInt num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator >>  (unsigned int& l , UnsignedShort& r) { // 8i
  UnsignedInt num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator %=  (UnsignedInt& l , unsigned short& r) { // 6i
  UnsignedInt num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator %=  (unsigned int& l , UnsignedShort& r) { // 8i
  UnsignedInt num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator &=  (UnsignedInt& l , unsigned short& r) { // 6i
  UnsignedInt num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator &=  (unsigned int& l , UnsignedShort& r) { // 8i
  UnsignedInt num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator |=  (UnsignedInt& l , unsigned short& r) { // 6i
  UnsignedInt num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator |=  (unsigned int& l , UnsignedShort& r) { // 8i
  UnsignedInt num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator ^=  (UnsignedInt& l , unsigned short& r) { // 6i
  UnsignedInt num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator ^=  (unsigned int& l , UnsignedShort& r) { // 8i
  UnsignedInt num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator <<= (UnsignedInt& l , unsigned short& r) { // 6i
  UnsignedInt num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator <<= (unsigned int& l , UnsignedShort& r) { // 8i
  UnsignedInt num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator >>= (UnsignedInt& l , unsigned short& r) { // 6i
  UnsignedInt num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator >>= (unsigned int& l , UnsignedShort& r) { // 8i
  UnsignedInt num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator %   (UnsignedInt& l , Short& r) { // 3i
  UnsignedInt num;
  num.val = (l.val % r.val);
  num.u = (l.u %   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator &   (UnsignedInt& l , Short& r) { // 3i
  UnsignedInt num;
  num.val = (l.val & r.val);
  num.u = (l.u &   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator ^   (UnsignedInt& l , Short& r) { // 3i
  UnsignedInt num;
  num.val = (l.val ^ r.val);
  num.u = (l.u ^   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator |   (UnsignedInt& l , Short& r) { // 3i
  UnsignedInt num;
  num.val = (l.val | r.val);
  num.u = (l.u |   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator <<  (UnsignedInt& l , Short& r) { // 3i
  UnsignedInt num;
  num.val = (l.val << r.val);
  num.u = (l.u <<  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator >>  (UnsignedInt& l , Short& r) { // 3i
  UnsignedInt num;
  num.val = (l.val >> r.val);
  num.u = (l.u >>  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator %=  (UnsignedInt& l , Short& r) { // 3i
  UnsignedInt num;
  num.val = (l.val %= r.val);
  num.u = (l.u %=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator &=  (UnsignedInt& l , Short& r) { // 3i
  UnsignedInt num;
  num.val = (l.val &= r.val);
  num.u = (l.u &=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator |=  (UnsignedInt& l , Short& r) { // 3i
  UnsignedInt num;
  num.val = (l.val |= r.val);
  num.u = (l.u |=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator ^=  (UnsignedInt& l , Short& r) { // 3i
  UnsignedInt num;
  num.val = (l.val ^= r.val);
  num.u = (l.u ^=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator <<= (UnsignedInt& l , Short& r) { // 3i
  UnsignedInt num;
  num.val = (l.val <<= r.val);
  num.u = (l.u <<= r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator >>= (UnsignedInt& l , Short& r) { // 3i
  UnsignedInt num;
  num.val = (l.val >>= r.val);
  num.u = (l.u >>= r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator %   (UnsignedInt& l , short& r) { // 6i
  UnsignedInt num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator %   (unsigned int& l , Short& r) { // 8i
  UnsignedInt num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator &   (UnsignedInt& l , short& r) { // 6i
  UnsignedInt num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator &   (unsigned int& l , Short& r) { // 8i
  UnsignedInt num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator ^   (UnsignedInt& l , short& r) { // 6i
  UnsignedInt num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator ^   (unsigned int& l , Short& r) { // 8i
  UnsignedInt num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator |   (UnsignedInt& l , short& r) { // 6i
  UnsignedInt num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator |   (unsigned int& l , Short& r) { // 8i
  UnsignedInt num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator <<  (UnsignedInt& l , short& r) { // 6i
  UnsignedInt num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator <<  (unsigned int& l , Short& r) { // 8i
  UnsignedInt num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator >>  (UnsignedInt& l , short& r) { // 6i
  UnsignedInt num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator >>  (unsigned int& l , Short& r) { // 8i
  UnsignedInt num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator %=  (UnsignedInt& l , short& r) { // 6i
  UnsignedInt num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator %=  (unsigned int& l , Short& r) { // 8i
  UnsignedInt num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator &=  (UnsignedInt& l , short& r) { // 6i
  UnsignedInt num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator &=  (unsigned int& l , Short& r) { // 8i
  UnsignedInt num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator |=  (UnsignedInt& l , short& r) { // 6i
  UnsignedInt num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator |=  (unsigned int& l , Short& r) { // 8i
  UnsignedInt num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator ^=  (UnsignedInt& l , short& r) { // 6i
  UnsignedInt num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator ^=  (unsigned int& l , Short& r) { // 8i
  UnsignedInt num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator <<= (UnsignedInt& l , short& r) { // 6i
  UnsignedInt num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator <<= (unsigned int& l , Short& r) { // 8i
  UnsignedInt num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator >>= (UnsignedInt& l , short& r) { // 6i
  UnsignedInt num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator >>= (unsigned int& l , Short& r) { // 8i
  UnsignedInt num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt UnsignedInt::operator %   (UnsignedInt& r) { // 1i
  UnsignedInt num;
  num.val = (val % r.val);
  num.u = (u %   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt UnsignedInt::operator &   (UnsignedInt& r) { // 1i
  UnsignedInt num;
  num.val = (val & r.val);
  num.u = (u &   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt UnsignedInt::operator ^   (UnsignedInt& r) { // 1i
  UnsignedInt num;
  num.val = (val ^ r.val);
  num.u = (u ^   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt UnsignedInt::operator |   (UnsignedInt& r) { // 1i
  UnsignedInt num;
  num.val = (val | r.val);
  num.u = (u |   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt UnsignedInt::operator <<  (UnsignedInt& r) { // 1i
  UnsignedInt num;
  num.val = (val << r.val);
  num.u = (u <<  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt UnsignedInt::operator >>  (UnsignedInt& r) { // 1i
  UnsignedInt num;
  num.val = (val >> r.val);
  num.u = (u >>  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt UnsignedInt::operator %=  (UnsignedInt& r) { // 1i
  UnsignedInt num;
  num.val = (val %= r.val);
  num.u = (u %=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt UnsignedInt::operator &=  (UnsignedInt& r) { // 1i
  UnsignedInt num;
  num.val = (val &= r.val);
  num.u = (u &=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt UnsignedInt::operator |=  (UnsignedInt& r) { // 1i
  UnsignedInt num;
  num.val = (val |= r.val);
  num.u = (u |=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt UnsignedInt::operator ^=  (UnsignedInt& r) { // 1i
  UnsignedInt num;
  num.val = (val ^= r.val);
  num.u = (u ^=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt UnsignedInt::operator <<= (UnsignedInt& r) { // 1i
  UnsignedInt num;
  num.val = (val <<= r.val);
  num.u = (u <<= r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt UnsignedInt::operator >>= (UnsignedInt& r) { // 1i
  UnsignedInt num;
  num.val = (val >>= r.val);
  num.u = (u >>= r.u);
  return num;
}

// **********************************************************************************************************
UnsignedInt operator %   (UnsignedInt& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator %   (unsigned int& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator &   (UnsignedInt& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator &   (unsigned int& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator ^   (UnsignedInt& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator ^   (unsigned int& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator |   (UnsignedInt& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator |   (unsigned int& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator <<  (UnsignedInt& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator <<  (unsigned int& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator >>  (UnsignedInt& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator >>  (unsigned int& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator %=  (UnsignedInt& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator %=  (unsigned int& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator &=  (UnsignedInt& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator &=  (unsigned int& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator |=  (UnsignedInt& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator |=  (unsigned int& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator ^=  (UnsignedInt& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator ^=  (unsigned int& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator <<= (UnsignedInt& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator <<= (unsigned int& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator >>= (UnsignedInt& l , unsigned int& r) { // 6i
  UnsignedInt num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt operator >>= (unsigned int& l , UnsignedInt& r) { // 8i
  UnsignedInt num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator %   (UnsignedInt& l , Int& r) { // 3i
  Int num;
  num.val = (l.val % r.val);
  num.u = (l.u %   r.u);
  return num;
}

// **********************************************************************************************************
Int operator &   (UnsignedInt& l , Int& r) { // 3i
  Int num;
  num.val = (l.val & r.val);
  num.u = (l.u &   r.u);
  return num;
}

// **********************************************************************************************************
Int operator ^   (UnsignedInt& l , Int& r) { // 3i
  Int num;
  num.val = (l.val ^ r.val);
  num.u = (l.u ^   r.u);
  return num;
}

// **********************************************************************************************************
Int operator |   (UnsignedInt& l , Int& r) { // 3i
  Int num;
  num.val = (l.val | r.val);
  num.u = (l.u |   r.u);
  return num;
}

// **********************************************************************************************************
Int operator <<  (UnsignedInt& l , Int& r) { // 3i
  Int num;
  num.val = (l.val << r.val);
  num.u = (l.u <<  r.u);
  return num;
}

// **********************************************************************************************************
Int operator >>  (UnsignedInt& l , Int& r) { // 3i
  Int num;
  num.val = (l.val >> r.val);
  num.u = (l.u >>  r.u);
  return num;
}

// **********************************************************************************************************
Int operator %=  (UnsignedInt& l , Int& r) { // 3i
  Int num;
  num.val = (l.val %= r.val);
  num.u = (l.u %=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator &=  (UnsignedInt& l , Int& r) { // 3i
  Int num;
  num.val = (l.val &= r.val);
  num.u = (l.u &=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator |=  (UnsignedInt& l , Int& r) { // 3i
  Int num;
  num.val = (l.val |= r.val);
  num.u = (l.u |=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator ^=  (UnsignedInt& l , Int& r) { // 3i
  Int num;
  num.val = (l.val ^= r.val);
  num.u = (l.u ^=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator <<= (UnsignedInt& l , Int& r) { // 3i
  Int num;
  num.val = (l.val <<= r.val);
  num.u = (l.u <<= r.u);
  return num;
}

// **********************************************************************************************************
Int operator >>= (UnsignedInt& l , Int& r) { // 3i
  Int num;
  num.val = (l.val >>= r.val);
  num.u = (l.u >>= r.u);
  return num;
}

// **********************************************************************************************************
Int operator %   (UnsignedInt& l , int& r) { // 6i
  Int num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator %   (unsigned int& l , Int& r) { // 8i
  Int num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator &   (UnsignedInt& l , int& r) { // 6i
  Int num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator &   (unsigned int& l , Int& r) { // 8i
  Int num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator ^   (UnsignedInt& l , int& r) { // 6i
  Int num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator ^   (unsigned int& l , Int& r) { // 8i
  Int num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator |   (UnsignedInt& l , int& r) { // 6i
  Int num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator |   (unsigned int& l , Int& r) { // 8i
  Int num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator <<  (UnsignedInt& l , int& r) { // 6i
  Int num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator <<  (unsigned int& l , Int& r) { // 8i
  Int num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator >>  (UnsignedInt& l , int& r) { // 6i
  Int num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator >>  (unsigned int& l , Int& r) { // 8i
  Int num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator %=  (UnsignedInt& l , int& r) { // 6i
  Int num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator %=  (unsigned int& l , Int& r) { // 8i
  Int num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator &=  (UnsignedInt& l , int& r) { // 6i
  Int num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator &=  (unsigned int& l , Int& r) { // 8i
  Int num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator |=  (UnsignedInt& l , int& r) { // 6i
  Int num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator |=  (unsigned int& l , Int& r) { // 8i
  Int num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator ^=  (UnsignedInt& l , int& r) { // 6i
  Int num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator ^=  (unsigned int& l , Int& r) { // 8i
  Int num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator <<= (UnsignedInt& l , int& r) { // 6i
  Int num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator <<= (unsigned int& l , Int& r) { // 8i
  Int num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator >>= (UnsignedInt& l , int& r) { // 6i
  Int num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator >>= (unsigned int& l , Int& r) { // 8i
  Int num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %   (UnsignedInt& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val % r.val);
  num.u = (l.u %   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &   (UnsignedInt& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val & r.val);
  num.u = (l.u &   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^   (UnsignedInt& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val ^ r.val);
  num.u = (l.u ^   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |   (UnsignedInt& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val | r.val);
  num.u = (l.u |   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<  (UnsignedInt& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val << r.val);
  num.u = (l.u <<  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>  (UnsignedInt& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val >> r.val);
  num.u = (l.u >>  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %=  (UnsignedInt& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val %= r.val);
  num.u = (l.u %=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &=  (UnsignedInt& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val &= r.val);
  num.u = (l.u &=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |=  (UnsignedInt& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val |= r.val);
  num.u = (l.u |=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^=  (UnsignedInt& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val ^= r.val);
  num.u = (l.u ^=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<= (UnsignedInt& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val <<= r.val);
  num.u = (l.u <<= r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>= (UnsignedInt& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val >>= r.val);
  num.u = (l.u >>= r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %   (UnsignedInt& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %   (unsigned int& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &   (UnsignedInt& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &   (unsigned int& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^   (UnsignedInt& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^   (unsigned int& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |   (UnsignedInt& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |   (unsigned int& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<  (UnsignedInt& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<  (unsigned int& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>  (UnsignedInt& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>  (unsigned int& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %=  (UnsignedInt& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %=  (unsigned int& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &=  (UnsignedInt& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &=  (unsigned int& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |=  (UnsignedInt& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |=  (unsigned int& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^=  (UnsignedInt& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^=  (unsigned int& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<= (UnsignedInt& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<= (unsigned int& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>= (UnsignedInt& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>= (unsigned int& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator %   (UnsignedInt& l , Long& r) { // 3i
  Long num;
  num.val = (l.val % r.val);
  num.u = (l.u %   r.u);
  return num;
}

// **********************************************************************************************************
Long operator &   (UnsignedInt& l , Long& r) { // 3i
  Long num;
  num.val = (l.val & r.val);
  num.u = (l.u &   r.u);
  return num;
}

// **********************************************************************************************************
Long operator ^   (UnsignedInt& l , Long& r) { // 3i
  Long num;
  num.val = (l.val ^ r.val);
  num.u = (l.u ^   r.u);
  return num;
}

// **********************************************************************************************************
Long operator |   (UnsignedInt& l , Long& r) { // 3i
  Long num;
  num.val = (l.val | r.val);
  num.u = (l.u |   r.u);
  return num;
}

// **********************************************************************************************************
Long operator <<  (UnsignedInt& l , Long& r) { // 3i
  Long num;
  num.val = (l.val << r.val);
  num.u = (l.u <<  r.u);
  return num;
}

// **********************************************************************************************************
Long operator >>  (UnsignedInt& l , Long& r) { // 3i
  Long num;
  num.val = (l.val >> r.val);
  num.u = (l.u >>  r.u);
  return num;
}

// **********************************************************************************************************
Long operator %=  (UnsignedInt& l , Long& r) { // 3i
  Long num;
  num.val = (l.val %= r.val);
  num.u = (l.u %=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator &=  (UnsignedInt& l , Long& r) { // 3i
  Long num;
  num.val = (l.val &= r.val);
  num.u = (l.u &=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator |=  (UnsignedInt& l , Long& r) { // 3i
  Long num;
  num.val = (l.val |= r.val);
  num.u = (l.u |=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator ^=  (UnsignedInt& l , Long& r) { // 3i
  Long num;
  num.val = (l.val ^= r.val);
  num.u = (l.u ^=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator <<= (UnsignedInt& l , Long& r) { // 3i
  Long num;
  num.val = (l.val <<= r.val);
  num.u = (l.u <<= r.u);
  return num;
}

// **********************************************************************************************************
Long operator >>= (UnsignedInt& l , Long& r) { // 3i
  Long num;
  num.val = (l.val >>= r.val);
  num.u = (l.u >>= r.u);
  return num;
}

// **********************************************************************************************************
Long operator %   (UnsignedInt& l , long& r) { // 6i
  Long num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator %   (unsigned int& l , Long& r) { // 8i
  Long num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator &   (UnsignedInt& l , long& r) { // 6i
  Long num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator &   (unsigned int& l , Long& r) { // 8i
  Long num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator ^   (UnsignedInt& l , long& r) { // 6i
  Long num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator ^   (unsigned int& l , Long& r) { // 8i
  Long num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator |   (UnsignedInt& l , long& r) { // 6i
  Long num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator |   (unsigned int& l , Long& r) { // 8i
  Long num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator <<  (UnsignedInt& l , long& r) { // 6i
  Long num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator <<  (unsigned int& l , Long& r) { // 8i
  Long num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator >>  (UnsignedInt& l , long& r) { // 6i
  Long num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator >>  (unsigned int& l , Long& r) { // 8i
  Long num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator %=  (UnsignedInt& l , long& r) { // 6i
  Long num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator %=  (unsigned int& l , Long& r) { // 8i
  Long num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator &=  (UnsignedInt& l , long& r) { // 6i
  Long num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator &=  (unsigned int& l , Long& r) { // 8i
  Long num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator |=  (UnsignedInt& l , long& r) { // 6i
  Long num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator |=  (unsigned int& l , Long& r) { // 8i
  Long num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator ^=  (UnsignedInt& l , long& r) { // 6i
  Long num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator ^=  (unsigned int& l , Long& r) { // 8i
  Long num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator <<= (UnsignedInt& l , long& r) { // 6i
  Long num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator <<= (unsigned int& l , Long& r) { // 8i
  Long num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator >>= (UnsignedInt& l , long& r) { // 6i
  Long num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator >>= (unsigned int& l , Long& r) { // 8i
  Long num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedInt UnsignedInt::operator ++(void) { // 1p, Prefix operator
   ++val;
  return *this;
}

// **********************************************************************************************************
UnsignedInt UnsignedInt::operator --(void) { // 1p, Prefix operator
   --val;
  assert(val>=1);
  return *this;
}

// **********************************************************************************************************
UnsignedInt UnsignedInt::operator ++(int) { // 1p, Postfix operator
   val++;
  return *this;
}

// **********************************************************************************************************
UnsignedInt UnsignedInt::operator --(int) { // 1p, Postfix operator
  assert(val>=1);
   val--;
  return *this;
}

// *********************************************************************************************************
// First class Int constructor
// *********************************************************************************************************
Int::Int() {
  val=0;
  state=UNDEF;
  u.init();
}
// *********************************************************************************************************
// Second class Int constructor
// *********************************************************************************************************
Int::Int(char* str) {
  val=0;
  state=UNDEF;
  u.init(str);
}
// *********************************************************************************************************
// First class Int destructor
// *********************************************************************************************************
Int::~Int() {
  val=0;
  state=UNDEF;
  u.init();
}
// **********************************************************************************************************
Int operator +   (Int& l , UnsignedChar& r) { // 3a
  Int num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
Int operator -   (Int& l , UnsignedChar& r) { // 3a
  Int num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
Int operator *   (Int& l , UnsignedChar& r) { // 3a
  Int num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
Int operator /   (Int& l , UnsignedChar& r) { // 3a
  Int num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
Int operator +=  (Int& l , UnsignedChar& r) { // 3a
  Int num;
  num.val = (int)(l.val += (int)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator -=  (Int& l , UnsignedChar& r) { // 3a
  Int num;
  num.val = (int)(l.val -= (int)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator *=  (Int& l , UnsignedChar& r) { // 3a
  Int num;
  num.val = (int)(l.val *= (int)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator /=  (Int& l , UnsignedChar& r) { // 3a
  Int num;
  num.val = (int)(l.val /= (int)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator +   (Int& l , unsigned char& r) {   // 6a
  Int num;
  num.val = (l.val + (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator +   (int& l , UnsignedChar& r) {   // 8a
  Int num;
  num.val = (l + (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator -   (Int& l , unsigned char& r) {   // 6a
  Int num;
  num.val = (l.val - (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator -   (int& l , UnsignedChar& r) {   // 8a
  Int num;
  num.val = (l - (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator *   (Int& l , unsigned char& r) {   // 6a
  Int num;
  num.val = (l.val * (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator *   (int& l , UnsignedChar& r) {   // 8a
  Int num;
  num.val = (l * (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator /   (Int& l , unsigned char& r) {   // 6a
  Int num;
  num.val = (l.val / (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator /   (int& l , UnsignedChar& r) {   // 8a
  Int num;
  num.val = (l / (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator +=  (Int& l , unsigned char& r) {   // 6a
  Int num;
  num.val = (int)(l.val += (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator +=  (int& l , UnsignedChar& r) {   // 8a
  Int num;
  num.val = (int)(l += (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator -=  (Int& l , unsigned char& r) {   // 6a
  Int num;
  num.val = (int)(l.val -= (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator -=  (int& l , UnsignedChar& r) {   // 8a
  Int num;
  num.val = (int)(l -= (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator *=  (Int& l , unsigned char& r) {   // 6a
  Int num;
  num.val = (int)(l.val *= (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator *=  (int& l , UnsignedChar& r) {   // 8a
  Int num;
  num.val = (int)(l *= (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator /=  (Int& l , unsigned char& r) {   // 6a
  Int num;
  num.val = (int)(l.val /= (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator /=  (int& l , UnsignedChar& r) {   // 8a
  Int num;
  num.val = (int)(l /= (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator +   (Int& l , Char& r) { // 3a
  Int num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
Int operator -   (Int& l , Char& r) { // 3a
  Int num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
Int operator *   (Int& l , Char& r) { // 3a
  Int num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
Int operator /   (Int& l , Char& r) { // 3a
  Int num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
Int operator +=  (Int& l , Char& r) { // 3a
  Int num;
  num.val = (int)(l.val += (int)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator -=  (Int& l , Char& r) { // 3a
  Int num;
  num.val = (int)(l.val -= (int)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator *=  (Int& l , Char& r) { // 3a
  Int num;
  num.val = (int)(l.val *= (int)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator /=  (Int& l , Char& r) { // 3a
  Int num;
  num.val = (int)(l.val /= (int)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator +   (Int& l , char& r) {   // 6a
  Int num;
  num.val = (l.val + (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator +   (int& l , Char& r) {   // 8a
  Int num;
  num.val = (l + (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator -   (Int& l , char& r) {   // 6a
  Int num;
  num.val = (l.val - (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator -   (int& l , Char& r) {   // 8a
  Int num;
  num.val = (l - (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator *   (Int& l , char& r) {   // 6a
  Int num;
  num.val = (l.val * (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator *   (int& l , Char& r) {   // 8a
  Int num;
  num.val = (l * (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator /   (Int& l , char& r) {   // 6a
  Int num;
  num.val = (l.val / (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator /   (int& l , Char& r) {   // 8a
  Int num;
  num.val = (l / (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator +=  (Int& l , char& r) {   // 6a
  Int num;
  num.val = (int)(l.val += (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator +=  (int& l , Char& r) {   // 8a
  Int num;
  num.val = (int)(l += (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator -=  (Int& l , char& r) {   // 6a
  Int num;
  num.val = (int)(l.val -= (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator -=  (int& l , Char& r) {   // 8a
  Int num;
  num.val = (int)(l -= (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator *=  (Int& l , char& r) {   // 6a
  Int num;
  num.val = (int)(l.val *= (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator *=  (int& l , Char& r) {   // 8a
  Int num;
  num.val = (int)(l *= (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator /=  (Int& l , char& r) {   // 6a
  Int num;
  num.val = (int)(l.val /= (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator /=  (int& l , Char& r) {   // 8a
  Int num;
  num.val = (int)(l /= (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator +   (Int& l , UnsignedShort& r) { // 3a
  Int num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
Int operator -   (Int& l , UnsignedShort& r) { // 3a
  Int num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
Int operator *   (Int& l , UnsignedShort& r) { // 3a
  Int num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
Int operator /   (Int& l , UnsignedShort& r) { // 3a
  Int num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
Int operator +=  (Int& l , UnsignedShort& r) { // 3a
  Int num;
  num.val = (int)(l.val += (int)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator -=  (Int& l , UnsignedShort& r) { // 3a
  Int num;
  num.val = (int)(l.val -= (int)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator *=  (Int& l , UnsignedShort& r) { // 3a
  Int num;
  num.val = (int)(l.val *= (int)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator /=  (Int& l , UnsignedShort& r) { // 3a
  Int num;
  num.val = (int)(l.val /= (int)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator +   (Int& l , unsigned short& r) {   // 6a
  Int num;
  num.val = (l.val + (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator +   (int& l , UnsignedShort& r) {   // 8a
  Int num;
  num.val = (l + (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator -   (Int& l , unsigned short& r) {   // 6a
  Int num;
  num.val = (l.val - (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator -   (int& l , UnsignedShort& r) {   // 8a
  Int num;
  num.val = (l - (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator *   (Int& l , unsigned short& r) {   // 6a
  Int num;
  num.val = (l.val * (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator *   (int& l , UnsignedShort& r) {   // 8a
  Int num;
  num.val = (l * (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator /   (Int& l , unsigned short& r) {   // 6a
  Int num;
  num.val = (l.val / (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator /   (int& l , UnsignedShort& r) {   // 8a
  Int num;
  num.val = (l / (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator +=  (Int& l , unsigned short& r) {   // 6a
  Int num;
  num.val = (int)(l.val += (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator +=  (int& l , UnsignedShort& r) {   // 8a
  Int num;
  num.val = (int)(l += (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator -=  (Int& l , unsigned short& r) {   // 6a
  Int num;
  num.val = (int)(l.val -= (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator -=  (int& l , UnsignedShort& r) {   // 8a
  Int num;
  num.val = (int)(l -= (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator *=  (Int& l , unsigned short& r) {   // 6a
  Int num;
  num.val = (int)(l.val *= (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator *=  (int& l , UnsignedShort& r) {   // 8a
  Int num;
  num.val = (int)(l *= (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator /=  (Int& l , unsigned short& r) {   // 6a
  Int num;
  num.val = (int)(l.val /= (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator /=  (int& l , UnsignedShort& r) {   // 8a
  Int num;
  num.val = (int)(l /= (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator +   (Int& l , Short& r) { // 3a
  Int num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
Int operator -   (Int& l , Short& r) { // 3a
  Int num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
Int operator *   (Int& l , Short& r) { // 3a
  Int num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
Int operator /   (Int& l , Short& r) { // 3a
  Int num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
Int operator +=  (Int& l , Short& r) { // 3a
  Int num;
  num.val = (int)(l.val += (int)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator -=  (Int& l , Short& r) { // 3a
  Int num;
  num.val = (int)(l.val -= (int)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator *=  (Int& l , Short& r) { // 3a
  Int num;
  num.val = (int)(l.val *= (int)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator /=  (Int& l , Short& r) { // 3a
  Int num;
  num.val = (int)(l.val /= (int)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator +   (Int& l , short& r) {   // 6a
  Int num;
  num.val = (l.val + (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator +   (int& l , Short& r) {   // 8a
  Int num;
  num.val = (l + (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator -   (Int& l , short& r) {   // 6a
  Int num;
  num.val = (l.val - (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator -   (int& l , Short& r) {   // 8a
  Int num;
  num.val = (l - (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator *   (Int& l , short& r) {   // 6a
  Int num;
  num.val = (l.val * (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator *   (int& l , Short& r) {   // 8a
  Int num;
  num.val = (l * (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator /   (Int& l , short& r) {   // 6a
  Int num;
  num.val = (l.val / (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator /   (int& l , Short& r) {   // 8a
  Int num;
  num.val = (l / (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator +=  (Int& l , short& r) {   // 6a
  Int num;
  num.val = (int)(l.val += (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator +=  (int& l , Short& r) {   // 8a
  Int num;
  num.val = (int)(l += (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator -=  (Int& l , short& r) {   // 6a
  Int num;
  num.val = (int)(l.val -= (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator -=  (int& l , Short& r) {   // 8a
  Int num;
  num.val = (int)(l -= (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator *=  (Int& l , short& r) {   // 6a
  Int num;
  num.val = (int)(l.val *= (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator *=  (int& l , Short& r) {   // 8a
  Int num;
  num.val = (int)(l *= (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator /=  (Int& l , short& r) {   // 6a
  Int num;
  num.val = (int)(l.val /= (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator /=  (int& l , Short& r) {   // 8a
  Int num;
  num.val = (int)(l /= (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator +   (Int& l , UnsignedInt& r) { // 3a
  Int num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
Int operator -   (Int& l , UnsignedInt& r) { // 3a
  Int num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
Int operator *   (Int& l , UnsignedInt& r) { // 3a
  Int num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
Int operator /   (Int& l , UnsignedInt& r) { // 3a
  Int num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
Int operator +=  (Int& l , UnsignedInt& r) { // 3a
  Int num;
  num.val = (int)(l.val += (int)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator -=  (Int& l , UnsignedInt& r) { // 3a
  Int num;
  num.val = (int)(l.val -= (int)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator *=  (Int& l , UnsignedInt& r) { // 3a
  Int num;
  num.val = (int)(l.val *= (int)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator /=  (Int& l , UnsignedInt& r) { // 3a
  Int num;
  num.val = (int)(l.val /= (int)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator +   (Int& l , unsigned int& r) {   // 6a
  Int num;
  num.val = (l.val + (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator +   (int& l , UnsignedInt& r) {   // 8a
  Int num;
  num.val = (l + (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator -   (Int& l , unsigned int& r) {   // 6a
  Int num;
  num.val = (l.val - (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator -   (int& l , UnsignedInt& r) {   // 8a
  Int num;
  num.val = (l - (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator *   (Int& l , unsigned int& r) {   // 6a
  Int num;
  num.val = (l.val * (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator *   (int& l , UnsignedInt& r) {   // 8a
  Int num;
  num.val = (l * (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator /   (Int& l , unsigned int& r) {   // 6a
  Int num;
  num.val = (l.val / (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator /   (int& l , UnsignedInt& r) {   // 8a
  Int num;
  num.val = (l / (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator +=  (Int& l , unsigned int& r) {   // 6a
  Int num;
  num.val = (int)(l.val += (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator +=  (int& l , UnsignedInt& r) {   // 8a
  Int num;
  num.val = (int)(l += (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator -=  (Int& l , unsigned int& r) {   // 6a
  Int num;
  num.val = (int)(l.val -= (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator -=  (int& l , UnsignedInt& r) {   // 8a
  Int num;
  num.val = (int)(l -= (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator *=  (Int& l , unsigned int& r) {   // 6a
  Int num;
  num.val = (int)(l.val *= (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator *=  (int& l , UnsignedInt& r) {   // 8a
  Int num;
  num.val = (int)(l *= (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator /=  (Int& l , unsigned int& r) {   // 6a
  Int num;
  num.val = (int)(l.val /= (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator /=  (int& l , UnsignedInt& r) {   // 8a
  Int num;
  num.val = (int)(l /= (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int Int::operator +   (Int& r) { // 1a
  Int num;
  num.val = (val + r.val);
  num.u = (u +   r.u);
  return num;
}

// **********************************************************************************************************
Int Int::operator -   (Int& r) { // 1a
  Int num;
  num.val = (val - r.val);
  num.u = (u -   r.u);
  return num;
}

// **********************************************************************************************************
Int Int::operator *   (Int& r) { // 1a
  Int num;
  num.val = (val * r.val);
  num.u = (u *   r.u);
  return num;
}

// **********************************************************************************************************
Int Int::operator /   (Int& r) { // 1a
  Int num;
  num.val = (val / r.val);
  num.u = (u /   r.u);
  return num;
}

// **********************************************************************************************************
Int Int::operator +=  (Int& r) { // 1a
  Int num;
  num.val = (val += r.val);
  num.u = (u +=  r.u);
  return num;
}

// **********************************************************************************************************
Int Int::operator -=  (Int& r) { // 1a
  Int num;
  num.val = (val -= r.val);
  num.u = (u -=  r.u);
  return num;
}

// **********************************************************************************************************
Int Int::operator *=  (Int& r) { // 1a
  Int num;
  num.val = (val *= r.val);
  num.u = (u *=  r.u);
  return num;
}

// **********************************************************************************************************
Int Int::operator /=  (Int& r) { // 1a
  Int num;
  num.val = (val /= r.val);
  num.u = (u /=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator +   (Int& l , int& r) {   // 6a
  Int num;
  num.val = (l.val + r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator +   (int& l , Int& r) {   // 8a
  Int num;
  num.val = (l + r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator -   (Int& l , int& r) {   // 6a
  Int num;
  num.val = (l.val - r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator -   (int& l , Int& r) {   // 8a
  Int num;
  num.val = (l - r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator *   (Int& l , int& r) {   // 6a
  Int num;
  num.val = (l.val * r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator *   (int& l , Int& r) {   // 8a
  Int num;
  num.val = (l * r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator /   (Int& l , int& r) {   // 6a
  Int num;
  num.val = (l.val / r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator /   (int& l , Int& r) {   // 8a
  Int num;
  num.val = (l / r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator +=  (Int& l , int& r) {   // 6a
  Int num;
  num.val = (int)(l.val += (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator +=  (int& l , Int& r) {   // 8a
  Int num;
  num.val = (int)(l += (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator -=  (Int& l , int& r) {   // 6a
  Int num;
  num.val = (int)(l.val -= (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator -=  (int& l , Int& r) {   // 8a
  Int num;
  num.val = (int)(l -= (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator *=  (Int& l , int& r) {   // 6a
  Int num;
  num.val = (int)(l.val *= (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator *=  (int& l , Int& r) {   // 8a
  Int num;
  num.val = (int)(l *= (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator /=  (Int& l , int& r) {   // 6a
  Int num;
  num.val = (int)(l.val /= (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator /=  (int& l , Int& r) {   // 8a
  Int num;
  num.val = (int)(l /= (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +   (Int& l , UnsignedLong& r) { // 3a
  UnsignedLong num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -   (Int& l , UnsignedLong& r) { // 3a
  UnsignedLong num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *   (Int& l , UnsignedLong& r) { // 3a
  UnsignedLong num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /   (Int& l , UnsignedLong& r) { // 3a
  UnsignedLong num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +=  (Int& l , UnsignedLong& r) { // 3a
  UnsignedLong num;
  num.val = (unsigned long)(l.val += (int)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -=  (Int& l , UnsignedLong& r) { // 3a
  UnsignedLong num;
  num.val = (unsigned long)(l.val -= (int)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *=  (Int& l , UnsignedLong& r) { // 3a
  UnsignedLong num;
  num.val = (unsigned long)(l.val *= (int)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /=  (Int& l , UnsignedLong& r) { // 3a
  UnsignedLong num;
  num.val = (unsigned long)(l.val /= (int)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +   (Int& l , unsigned long& r) {   // 6a
  UnsignedLong num;
  num.val = ((unsigned long)l.val + r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +   (int& l , UnsignedLong& r) {   // 8a
  UnsignedLong num;
  num.val = ((unsigned long)l + r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -   (Int& l , unsigned long& r) {   // 6a
  UnsignedLong num;
  num.val = ((unsigned long)l.val - r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -   (int& l , UnsignedLong& r) {   // 8a
  UnsignedLong num;
  num.val = ((unsigned long)l - r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *   (Int& l , unsigned long& r) {   // 6a
  UnsignedLong num;
  num.val = ((unsigned long)l.val * r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *   (int& l , UnsignedLong& r) {   // 8a
  UnsignedLong num;
  num.val = ((unsigned long)l * r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /   (Int& l , unsigned long& r) {   // 6a
  UnsignedLong num;
  num.val = ((unsigned long)l.val / r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /   (int& l , UnsignedLong& r) {   // 8a
  UnsignedLong num;
  num.val = ((unsigned long)l / r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +=  (Int& l , unsigned long& r) {   // 6a
  UnsignedLong num;
  num.val = (unsigned long)(l.val += (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +=  (int& l , UnsignedLong& r) {   // 8a
  UnsignedLong num;
  num.val = (unsigned long)(l += (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -=  (Int& l , unsigned long& r) {   // 6a
  UnsignedLong num;
  num.val = (unsigned long)(l.val -= (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -=  (int& l , UnsignedLong& r) {   // 8a
  UnsignedLong num;
  num.val = (unsigned long)(l -= (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *=  (Int& l , unsigned long& r) {   // 6a
  UnsignedLong num;
  num.val = (unsigned long)(l.val *= (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *=  (int& l , UnsignedLong& r) {   // 8a
  UnsignedLong num;
  num.val = (unsigned long)(l *= (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /=  (Int& l , unsigned long& r) {   // 6a
  UnsignedLong num;
  num.val = (unsigned long)(l.val /= (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /=  (int& l , UnsignedLong& r) {   // 8a
  UnsignedLong num;
  num.val = (unsigned long)(l /= (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator +   (Int& l , Long& r) { // 3a
  Long num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
Long operator -   (Int& l , Long& r) { // 3a
  Long num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
Long operator *   (Int& l , Long& r) { // 3a
  Long num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
Long operator /   (Int& l , Long& r) { // 3a
  Long num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
Long operator +=  (Int& l , Long& r) { // 3a
  Long num;
  num.val = (long)(l.val += (int)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator -=  (Int& l , Long& r) { // 3a
  Long num;
  num.val = (long)(l.val -= (int)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator *=  (Int& l , Long& r) { // 3a
  Long num;
  num.val = (long)(l.val *= (int)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator /=  (Int& l , Long& r) { // 3a
  Long num;
  num.val = (long)(l.val /= (int)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator +   (Int& l , long& r) {   // 6a
  Long num;
  num.val = ((long)l.val + r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator +   (int& l , Long& r) {   // 8a
  Long num;
  num.val = ((long)l + r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator -   (Int& l , long& r) {   // 6a
  Long num;
  num.val = ((long)l.val - r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator -   (int& l , Long& r) {   // 8a
  Long num;
  num.val = ((long)l - r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator *   (Int& l , long& r) {   // 6a
  Long num;
  num.val = ((long)l.val * r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator *   (int& l , Long& r) {   // 8a
  Long num;
  num.val = ((long)l * r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator /   (Int& l , long& r) {   // 6a
  Long num;
  num.val = ((long)l.val / r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator /   (int& l , Long& r) {   // 8a
  Long num;
  num.val = ((long)l / r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator +=  (Int& l , long& r) {   // 6a
  Long num;
  num.val = (long)(l.val += (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator +=  (int& l , Long& r) {   // 8a
  Long num;
  num.val = (long)(l += (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator -=  (Int& l , long& r) {   // 6a
  Long num;
  num.val = (long)(l.val -= (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator -=  (int& l , Long& r) {   // 8a
  Long num;
  num.val = (long)(l -= (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator *=  (Int& l , long& r) {   // 6a
  Long num;
  num.val = (long)(l.val *= (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator *=  (int& l , Long& r) {   // 8a
  Long num;
  num.val = (long)(l *= (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator /=  (Int& l , long& r) {   // 6a
  Long num;
  num.val = (long)(l.val /= (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator /=  (int& l , Long& r) {   // 8a
  Long num;
  num.val = (long)(l /= (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator +   (Int& l , Float& r) { // 3a
  Float num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
Float operator -   (Int& l , Float& r) { // 3a
  Float num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
Float operator *   (Int& l , Float& r) { // 3a
  Float num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
Float operator /   (Int& l , Float& r) { // 3a
  Float num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
Float operator +=  (Int& l , Float& r) { // 3a
  Float num;
  num.val = (float)(l.val += (int)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
Float operator -=  (Int& l , Float& r) { // 3a
  Float num;
  num.val = (float)(l.val -= (int)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
Float operator *=  (Int& l , Float& r) { // 3a
  Float num;
  num.val = (float)(l.val *= (int)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
Float operator /=  (Int& l , Float& r) { // 3a
  Float num;
  num.val = (float)(l.val /= (int)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
Float operator +   (Int& l , float& r) {   // 6a
  Float num;
  num.val = ((float)l.val + r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator +   (int& l , Float& r) {   // 8a
  Float num;
  num.val = ((float)l + r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator -   (Int& l , float& r) {   // 6a
  Float num;
  num.val = ((float)l.val - r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator -   (int& l , Float& r) {   // 8a
  Float num;
  num.val = ((float)l - r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator *   (Int& l , float& r) {   // 6a
  Float num;
  num.val = ((float)l.val * r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator *   (int& l , Float& r) {   // 8a
  Float num;
  num.val = ((float)l * r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator /   (Int& l , float& r) {   // 6a
  Float num;
  num.val = ((float)l.val / r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator /   (int& l , Float& r) {   // 8a
  Float num;
  num.val = ((float)l / r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator +=  (Int& l , float& r) {   // 6a
  Float num;
  num.val = (float)(l.val += (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator +=  (int& l , Float& r) {   // 8a
  Float num;
  num.val = (float)(l += (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator -=  (Int& l , float& r) {   // 6a
  Float num;
  num.val = (float)(l.val -= (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator -=  (int& l , Float& r) {   // 8a
  Float num;
  num.val = (float)(l -= (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator *=  (Int& l , float& r) {   // 6a
  Float num;
  num.val = (float)(l.val *= (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator *=  (int& l , Float& r) {   // 8a
  Float num;
  num.val = (float)(l *= (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator /=  (Int& l , float& r) {   // 6a
  Float num;
  num.val = (float)(l.val /= (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator /=  (int& l , Float& r) {   // 8a
  Float num;
  num.val = (float)(l /= (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator +   (Int& l , Double& r) { // 3a
  Double num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
Double operator -   (Int& l , Double& r) { // 3a
  Double num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
Double operator *   (Int& l , Double& r) { // 3a
  Double num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
Double operator /   (Int& l , Double& r) { // 3a
  Double num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
Double operator +=  (Int& l , Double& r) { // 3a
  Double num;
  num.val = (double)(l.val += (int)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
Double operator -=  (Int& l , Double& r) { // 3a
  Double num;
  num.val = (double)(l.val -= (int)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
Double operator *=  (Int& l , Double& r) { // 3a
  Double num;
  num.val = (double)(l.val *= (int)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
Double operator /=  (Int& l , Double& r) { // 3a
  Double num;
  num.val = (double)(l.val /= (int)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
Double operator +   (Int& l , double& r) {   // 6a
  Double num;
  num.val = ((double)l.val + r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator +   (int& l , Double& r) {   // 8a
  Double num;
  num.val = ((double)l + r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator -   (Int& l , double& r) {   // 6a
  Double num;
  num.val = ((double)l.val - r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator -   (int& l , Double& r) {   // 8a
  Double num;
  num.val = ((double)l - r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator *   (Int& l , double& r) {   // 6a
  Double num;
  num.val = ((double)l.val * r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator *   (int& l , Double& r) {   // 8a
  Double num;
  num.val = ((double)l * r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator /   (Int& l , double& r) {   // 6a
  Double num;
  num.val = ((double)l.val / r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator /   (int& l , Double& r) {   // 8a
  Double num;
  num.val = ((double)l / r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator +=  (Int& l , double& r) {   // 6a
  Double num;
  num.val = (double)(l.val += (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator +=  (int& l , Double& r) {   // 8a
  Double num;
  num.val = (double)(l += (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator -=  (Int& l , double& r) {   // 6a
  Double num;
  num.val = (double)(l.val -= (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator -=  (int& l , Double& r) {   // 8a
  Double num;
  num.val = (double)(l -= (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator *=  (Int& l , double& r) {   // 6a
  Double num;
  num.val = (double)(l.val *= (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator *=  (int& l , Double& r) {   // 8a
  Double num;
  num.val = (double)(l *= (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator /=  (Int& l , double& r) {   // 6a
  Double num;
  num.val = (double)(l.val /= (int)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator /=  (int& l , Double& r) {   // 8a
  Double num;
  num.val = (double)(l /= (int)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator %   (Int& l , UnsignedChar& r) { // 3i
  Int num;
  num.val = (l.val % r.val);
  num.u = (l.u %   r.u);
  return num;
}

// **********************************************************************************************************
Int operator &   (Int& l , UnsignedChar& r) { // 3i
  Int num;
  num.val = (l.val & r.val);
  num.u = (l.u &   r.u);
  return num;
}

// **********************************************************************************************************
Int operator ^   (Int& l , UnsignedChar& r) { // 3i
  Int num;
  num.val = (l.val ^ r.val);
  num.u = (l.u ^   r.u);
  return num;
}

// **********************************************************************************************************
Int operator |   (Int& l , UnsignedChar& r) { // 3i
  Int num;
  num.val = (l.val | r.val);
  num.u = (l.u |   r.u);
  return num;
}

// **********************************************************************************************************
Int operator <<  (Int& l , UnsignedChar& r) { // 3i
  Int num;
  num.val = (l.val << r.val);
  num.u = (l.u <<  r.u);
  return num;
}

// **********************************************************************************************************
Int operator >>  (Int& l , UnsignedChar& r) { // 3i
  Int num;
  num.val = (l.val >> r.val);
  num.u = (l.u >>  r.u);
  return num;
}

// **********************************************************************************************************
Int operator %=  (Int& l , UnsignedChar& r) { // 3i
  Int num;
  num.val = (l.val %= r.val);
  num.u = (l.u %=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator &=  (Int& l , UnsignedChar& r) { // 3i
  Int num;
  num.val = (l.val &= r.val);
  num.u = (l.u &=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator |=  (Int& l , UnsignedChar& r) { // 3i
  Int num;
  num.val = (l.val |= r.val);
  num.u = (l.u |=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator ^=  (Int& l , UnsignedChar& r) { // 3i
  Int num;
  num.val = (l.val ^= r.val);
  num.u = (l.u ^=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator <<= (Int& l , UnsignedChar& r) { // 3i
  Int num;
  num.val = (l.val <<= r.val);
  num.u = (l.u <<= r.u);
  return num;
}

// **********************************************************************************************************
Int operator >>= (Int& l , UnsignedChar& r) { // 3i
  Int num;
  num.val = (l.val >>= r.val);
  num.u = (l.u >>= r.u);
  return num;
}

// **********************************************************************************************************
Int operator %   (Int& l , unsigned char& r) { // 6i
  Int num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator %   (int& l , UnsignedChar& r) { // 8i
  Int num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator &   (Int& l , unsigned char& r) { // 6i
  Int num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator &   (int& l , UnsignedChar& r) { // 8i
  Int num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator ^   (Int& l , unsigned char& r) { // 6i
  Int num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator ^   (int& l , UnsignedChar& r) { // 8i
  Int num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator |   (Int& l , unsigned char& r) { // 6i
  Int num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator |   (int& l , UnsignedChar& r) { // 8i
  Int num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator <<  (Int& l , unsigned char& r) { // 6i
  Int num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator <<  (int& l , UnsignedChar& r) { // 8i
  Int num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator >>  (Int& l , unsigned char& r) { // 6i
  Int num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator >>  (int& l , UnsignedChar& r) { // 8i
  Int num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator %=  (Int& l , unsigned char& r) { // 6i
  Int num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator %=  (int& l , UnsignedChar& r) { // 8i
  Int num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator &=  (Int& l , unsigned char& r) { // 6i
  Int num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator &=  (int& l , UnsignedChar& r) { // 8i
  Int num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator |=  (Int& l , unsigned char& r) { // 6i
  Int num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator |=  (int& l , UnsignedChar& r) { // 8i
  Int num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator ^=  (Int& l , unsigned char& r) { // 6i
  Int num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator ^=  (int& l , UnsignedChar& r) { // 8i
  Int num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator <<= (Int& l , unsigned char& r) { // 6i
  Int num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator <<= (int& l , UnsignedChar& r) { // 8i
  Int num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator >>= (Int& l , unsigned char& r) { // 6i
  Int num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator >>= (int& l , UnsignedChar& r) { // 8i
  Int num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator %   (Int& l , Char& r) { // 3i
  Int num;
  num.val = (l.val % r.val);
  num.u = (l.u %   r.u);
  return num;
}

// **********************************************************************************************************
Int operator &   (Int& l , Char& r) { // 3i
  Int num;
  num.val = (l.val & r.val);
  num.u = (l.u &   r.u);
  return num;
}

// **********************************************************************************************************
Int operator ^   (Int& l , Char& r) { // 3i
  Int num;
  num.val = (l.val ^ r.val);
  num.u = (l.u ^   r.u);
  return num;
}

// **********************************************************************************************************
Int operator |   (Int& l , Char& r) { // 3i
  Int num;
  num.val = (l.val | r.val);
  num.u = (l.u |   r.u);
  return num;
}

// **********************************************************************************************************
Int operator <<  (Int& l , Char& r) { // 3i
  Int num;
  num.val = (l.val << r.val);
  num.u = (l.u <<  r.u);
  return num;
}

// **********************************************************************************************************
Int operator >>  (Int& l , Char& r) { // 3i
  Int num;
  num.val = (l.val >> r.val);
  num.u = (l.u >>  r.u);
  return num;
}

// **********************************************************************************************************
Int operator %=  (Int& l , Char& r) { // 3i
  Int num;
  num.val = (l.val %= r.val);
  num.u = (l.u %=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator &=  (Int& l , Char& r) { // 3i
  Int num;
  num.val = (l.val &= r.val);
  num.u = (l.u &=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator |=  (Int& l , Char& r) { // 3i
  Int num;
  num.val = (l.val |= r.val);
  num.u = (l.u |=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator ^=  (Int& l , Char& r) { // 3i
  Int num;
  num.val = (l.val ^= r.val);
  num.u = (l.u ^=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator <<= (Int& l , Char& r) { // 3i
  Int num;
  num.val = (l.val <<= r.val);
  num.u = (l.u <<= r.u);
  return num;
}

// **********************************************************************************************************
Int operator >>= (Int& l , Char& r) { // 3i
  Int num;
  num.val = (l.val >>= r.val);
  num.u = (l.u >>= r.u);
  return num;
}

// **********************************************************************************************************
Int operator %   (Int& l , char& r) { // 6i
  Int num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator %   (int& l , Char& r) { // 8i
  Int num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator &   (Int& l , char& r) { // 6i
  Int num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator &   (int& l , Char& r) { // 8i
  Int num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator ^   (Int& l , char& r) { // 6i
  Int num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator ^   (int& l , Char& r) { // 8i
  Int num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator |   (Int& l , char& r) { // 6i
  Int num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator |   (int& l , Char& r) { // 8i
  Int num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator <<  (Int& l , char& r) { // 6i
  Int num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator <<  (int& l , Char& r) { // 8i
  Int num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator >>  (Int& l , char& r) { // 6i
  Int num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator >>  (int& l , Char& r) { // 8i
  Int num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator %=  (Int& l , char& r) { // 6i
  Int num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator %=  (int& l , Char& r) { // 8i
  Int num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator &=  (Int& l , char& r) { // 6i
  Int num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator &=  (int& l , Char& r) { // 8i
  Int num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator |=  (Int& l , char& r) { // 6i
  Int num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator |=  (int& l , Char& r) { // 8i
  Int num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator ^=  (Int& l , char& r) { // 6i
  Int num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator ^=  (int& l , Char& r) { // 8i
  Int num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator <<= (Int& l , char& r) { // 6i
  Int num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator <<= (int& l , Char& r) { // 8i
  Int num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator >>= (Int& l , char& r) { // 6i
  Int num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator >>= (int& l , Char& r) { // 8i
  Int num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator %   (Int& l , UnsignedShort& r) { // 3i
  Int num;
  num.val = (l.val % r.val);
  num.u = (l.u %   r.u);
  return num;
}

// **********************************************************************************************************
Int operator &   (Int& l , UnsignedShort& r) { // 3i
  Int num;
  num.val = (l.val & r.val);
  num.u = (l.u &   r.u);
  return num;
}

// **********************************************************************************************************
Int operator ^   (Int& l , UnsignedShort& r) { // 3i
  Int num;
  num.val = (l.val ^ r.val);
  num.u = (l.u ^   r.u);
  return num;
}

// **********************************************************************************************************
Int operator |   (Int& l , UnsignedShort& r) { // 3i
  Int num;
  num.val = (l.val | r.val);
  num.u = (l.u |   r.u);
  return num;
}

// **********************************************************************************************************
Int operator <<  (Int& l , UnsignedShort& r) { // 3i
  Int num;
  num.val = (l.val << r.val);
  num.u = (l.u <<  r.u);
  return num;
}

// **********************************************************************************************************
Int operator >>  (Int& l , UnsignedShort& r) { // 3i
  Int num;
  num.val = (l.val >> r.val);
  num.u = (l.u >>  r.u);
  return num;
}

// **********************************************************************************************************
Int operator %=  (Int& l , UnsignedShort& r) { // 3i
  Int num;
  num.val = (l.val %= r.val);
  num.u = (l.u %=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator &=  (Int& l , UnsignedShort& r) { // 3i
  Int num;
  num.val = (l.val &= r.val);
  num.u = (l.u &=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator |=  (Int& l , UnsignedShort& r) { // 3i
  Int num;
  num.val = (l.val |= r.val);
  num.u = (l.u |=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator ^=  (Int& l , UnsignedShort& r) { // 3i
  Int num;
  num.val = (l.val ^= r.val);
  num.u = (l.u ^=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator <<= (Int& l , UnsignedShort& r) { // 3i
  Int num;
  num.val = (l.val <<= r.val);
  num.u = (l.u <<= r.u);
  return num;
}

// **********************************************************************************************************
Int operator >>= (Int& l , UnsignedShort& r) { // 3i
  Int num;
  num.val = (l.val >>= r.val);
  num.u = (l.u >>= r.u);
  return num;
}

// **********************************************************************************************************
Int operator %   (Int& l , unsigned short& r) { // 6i
  Int num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator %   (int& l , UnsignedShort& r) { // 8i
  Int num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator &   (Int& l , unsigned short& r) { // 6i
  Int num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator &   (int& l , UnsignedShort& r) { // 8i
  Int num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator ^   (Int& l , unsigned short& r) { // 6i
  Int num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator ^   (int& l , UnsignedShort& r) { // 8i
  Int num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator |   (Int& l , unsigned short& r) { // 6i
  Int num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator |   (int& l , UnsignedShort& r) { // 8i
  Int num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator <<  (Int& l , unsigned short& r) { // 6i
  Int num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator <<  (int& l , UnsignedShort& r) { // 8i
  Int num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator >>  (Int& l , unsigned short& r) { // 6i
  Int num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator >>  (int& l , UnsignedShort& r) { // 8i
  Int num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator %=  (Int& l , unsigned short& r) { // 6i
  Int num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator %=  (int& l , UnsignedShort& r) { // 8i
  Int num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator &=  (Int& l , unsigned short& r) { // 6i
  Int num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator &=  (int& l , UnsignedShort& r) { // 8i
  Int num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator |=  (Int& l , unsigned short& r) { // 6i
  Int num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator |=  (int& l , UnsignedShort& r) { // 8i
  Int num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator ^=  (Int& l , unsigned short& r) { // 6i
  Int num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator ^=  (int& l , UnsignedShort& r) { // 8i
  Int num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator <<= (Int& l , unsigned short& r) { // 6i
  Int num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator <<= (int& l , UnsignedShort& r) { // 8i
  Int num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator >>= (Int& l , unsigned short& r) { // 6i
  Int num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator >>= (int& l , UnsignedShort& r) { // 8i
  Int num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator %   (Int& l , Short& r) { // 3i
  Int num;
  num.val = (l.val % r.val);
  num.u = (l.u %   r.u);
  return num;
}

// **********************************************************************************************************
Int operator &   (Int& l , Short& r) { // 3i
  Int num;
  num.val = (l.val & r.val);
  num.u = (l.u &   r.u);
  return num;
}

// **********************************************************************************************************
Int operator ^   (Int& l , Short& r) { // 3i
  Int num;
  num.val = (l.val ^ r.val);
  num.u = (l.u ^   r.u);
  return num;
}

// **********************************************************************************************************
Int operator |   (Int& l , Short& r) { // 3i
  Int num;
  num.val = (l.val | r.val);
  num.u = (l.u |   r.u);
  return num;
}

// **********************************************************************************************************
Int operator <<  (Int& l , Short& r) { // 3i
  Int num;
  num.val = (l.val << r.val);
  num.u = (l.u <<  r.u);
  return num;
}

// **********************************************************************************************************
Int operator >>  (Int& l , Short& r) { // 3i
  Int num;
  num.val = (l.val >> r.val);
  num.u = (l.u >>  r.u);
  return num;
}

// **********************************************************************************************************
Int operator %=  (Int& l , Short& r) { // 3i
  Int num;
  num.val = (l.val %= r.val);
  num.u = (l.u %=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator &=  (Int& l , Short& r) { // 3i
  Int num;
  num.val = (l.val &= r.val);
  num.u = (l.u &=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator |=  (Int& l , Short& r) { // 3i
  Int num;
  num.val = (l.val |= r.val);
  num.u = (l.u |=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator ^=  (Int& l , Short& r) { // 3i
  Int num;
  num.val = (l.val ^= r.val);
  num.u = (l.u ^=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator <<= (Int& l , Short& r) { // 3i
  Int num;
  num.val = (l.val <<= r.val);
  num.u = (l.u <<= r.u);
  return num;
}

// **********************************************************************************************************
Int operator >>= (Int& l , Short& r) { // 3i
  Int num;
  num.val = (l.val >>= r.val);
  num.u = (l.u >>= r.u);
  return num;
}

// **********************************************************************************************************
Int operator %   (Int& l , short& r) { // 6i
  Int num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator %   (int& l , Short& r) { // 8i
  Int num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator &   (Int& l , short& r) { // 6i
  Int num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator &   (int& l , Short& r) { // 8i
  Int num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator ^   (Int& l , short& r) { // 6i
  Int num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator ^   (int& l , Short& r) { // 8i
  Int num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator |   (Int& l , short& r) { // 6i
  Int num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator |   (int& l , Short& r) { // 8i
  Int num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator <<  (Int& l , short& r) { // 6i
  Int num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator <<  (int& l , Short& r) { // 8i
  Int num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator >>  (Int& l , short& r) { // 6i
  Int num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator >>  (int& l , Short& r) { // 8i
  Int num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator %=  (Int& l , short& r) { // 6i
  Int num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator %=  (int& l , Short& r) { // 8i
  Int num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator &=  (Int& l , short& r) { // 6i
  Int num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator &=  (int& l , Short& r) { // 8i
  Int num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator |=  (Int& l , short& r) { // 6i
  Int num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator |=  (int& l , Short& r) { // 8i
  Int num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator ^=  (Int& l , short& r) { // 6i
  Int num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator ^=  (int& l , Short& r) { // 8i
  Int num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator <<= (Int& l , short& r) { // 6i
  Int num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator <<= (int& l , Short& r) { // 8i
  Int num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator >>= (Int& l , short& r) { // 6i
  Int num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator >>= (int& l , Short& r) { // 8i
  Int num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator %   (Int& l , UnsignedInt& r) { // 3i
  Int num;
  num.val = (l.val % r.val);
  num.u = (l.u %   r.u);
  return num;
}

// **********************************************************************************************************
Int operator &   (Int& l , UnsignedInt& r) { // 3i
  Int num;
  num.val = (l.val & r.val);
  num.u = (l.u &   r.u);
  return num;
}

// **********************************************************************************************************
Int operator ^   (Int& l , UnsignedInt& r) { // 3i
  Int num;
  num.val = (l.val ^ r.val);
  num.u = (l.u ^   r.u);
  return num;
}

// **********************************************************************************************************
Int operator |   (Int& l , UnsignedInt& r) { // 3i
  Int num;
  num.val = (l.val | r.val);
  num.u = (l.u |   r.u);
  return num;
}

// **********************************************************************************************************
Int operator <<  (Int& l , UnsignedInt& r) { // 3i
  Int num;
  num.val = (l.val << r.val);
  num.u = (l.u <<  r.u);
  return num;
}

// **********************************************************************************************************
Int operator >>  (Int& l , UnsignedInt& r) { // 3i
  Int num;
  num.val = (l.val >> r.val);
  num.u = (l.u >>  r.u);
  return num;
}

// **********************************************************************************************************
Int operator %=  (Int& l , UnsignedInt& r) { // 3i
  Int num;
  num.val = (l.val %= r.val);
  num.u = (l.u %=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator &=  (Int& l , UnsignedInt& r) { // 3i
  Int num;
  num.val = (l.val &= r.val);
  num.u = (l.u &=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator |=  (Int& l , UnsignedInt& r) { // 3i
  Int num;
  num.val = (l.val |= r.val);
  num.u = (l.u |=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator ^=  (Int& l , UnsignedInt& r) { // 3i
  Int num;
  num.val = (l.val ^= r.val);
  num.u = (l.u ^=  r.u);
  return num;
}

// **********************************************************************************************************
Int operator <<= (Int& l , UnsignedInt& r) { // 3i
  Int num;
  num.val = (l.val <<= r.val);
  num.u = (l.u <<= r.u);
  return num;
}

// **********************************************************************************************************
Int operator >>= (Int& l , UnsignedInt& r) { // 3i
  Int num;
  num.val = (l.val >>= r.val);
  num.u = (l.u >>= r.u);
  return num;
}

// **********************************************************************************************************
Int operator %   (Int& l , unsigned int& r) { // 6i
  Int num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator %   (int& l , UnsignedInt& r) { // 8i
  Int num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator &   (Int& l , unsigned int& r) { // 6i
  Int num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator &   (int& l , UnsignedInt& r) { // 8i
  Int num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator ^   (Int& l , unsigned int& r) { // 6i
  Int num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator ^   (int& l , UnsignedInt& r) { // 8i
  Int num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator |   (Int& l , unsigned int& r) { // 6i
  Int num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator |   (int& l , UnsignedInt& r) { // 8i
  Int num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator <<  (Int& l , unsigned int& r) { // 6i
  Int num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator <<  (int& l , UnsignedInt& r) { // 8i
  Int num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator >>  (Int& l , unsigned int& r) { // 6i
  Int num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator >>  (int& l , UnsignedInt& r) { // 8i
  Int num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator %=  (Int& l , unsigned int& r) { // 6i
  Int num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator %=  (int& l , UnsignedInt& r) { // 8i
  Int num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator &=  (Int& l , unsigned int& r) { // 6i
  Int num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator &=  (int& l , UnsignedInt& r) { // 8i
  Int num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator |=  (Int& l , unsigned int& r) { // 6i
  Int num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator |=  (int& l , UnsignedInt& r) { // 8i
  Int num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator ^=  (Int& l , unsigned int& r) { // 6i
  Int num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator ^=  (int& l , UnsignedInt& r) { // 8i
  Int num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator <<= (Int& l , unsigned int& r) { // 6i
  Int num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator <<= (int& l , UnsignedInt& r) { // 8i
  Int num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator >>= (Int& l , unsigned int& r) { // 6i
  Int num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator >>= (int& l , UnsignedInt& r) { // 8i
  Int num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int Int::operator %   (Int& r) { // 1i
  Int num;
  num.val = (val % r.val);
  num.u = (u %   r.u);
  return num;
}

// **********************************************************************************************************
Int Int::operator &   (Int& r) { // 1i
  Int num;
  num.val = (val & r.val);
  num.u = (u &   r.u);
  return num;
}

// **********************************************************************************************************
Int Int::operator ^   (Int& r) { // 1i
  Int num;
  num.val = (val ^ r.val);
  num.u = (u ^   r.u);
  return num;
}

// **********************************************************************************************************
Int Int::operator |   (Int& r) { // 1i
  Int num;
  num.val = (val | r.val);
  num.u = (u |   r.u);
  return num;
}

// **********************************************************************************************************
Int Int::operator <<  (Int& r) { // 1i
  Int num;
  num.val = (val << r.val);
  num.u = (u <<  r.u);
  return num;
}

// **********************************************************************************************************
Int Int::operator >>  (Int& r) { // 1i
  Int num;
  num.val = (val >> r.val);
  num.u = (u >>  r.u);
  return num;
}

// **********************************************************************************************************
Int Int::operator %=  (Int& r) { // 1i
  Int num;
  num.val = (val %= r.val);
  num.u = (u %=  r.u);
  return num;
}

// **********************************************************************************************************
Int Int::operator &=  (Int& r) { // 1i
  Int num;
  num.val = (val &= r.val);
  num.u = (u &=  r.u);
  return num;
}

// **********************************************************************************************************
Int Int::operator |=  (Int& r) { // 1i
  Int num;
  num.val = (val |= r.val);
  num.u = (u |=  r.u);
  return num;
}

// **********************************************************************************************************
Int Int::operator ^=  (Int& r) { // 1i
  Int num;
  num.val = (val ^= r.val);
  num.u = (u ^=  r.u);
  return num;
}

// **********************************************************************************************************
Int Int::operator <<= (Int& r) { // 1i
  Int num;
  num.val = (val <<= r.val);
  num.u = (u <<= r.u);
  return num;
}

// **********************************************************************************************************
Int Int::operator >>= (Int& r) { // 1i
  Int num;
  num.val = (val >>= r.val);
  num.u = (u >>= r.u);
  return num;
}

// **********************************************************************************************************
Int operator %   (Int& l , int& r) { // 6i
  Int num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator %   (int& l , Int& r) { // 8i
  Int num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator &   (Int& l , int& r) { // 6i
  Int num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator &   (int& l , Int& r) { // 8i
  Int num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator ^   (Int& l , int& r) { // 6i
  Int num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator ^   (int& l , Int& r) { // 8i
  Int num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator |   (Int& l , int& r) { // 6i
  Int num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator |   (int& l , Int& r) { // 8i
  Int num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator <<  (Int& l , int& r) { // 6i
  Int num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator <<  (int& l , Int& r) { // 8i
  Int num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator >>  (Int& l , int& r) { // 6i
  Int num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator >>  (int& l , Int& r) { // 8i
  Int num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator %=  (Int& l , int& r) { // 6i
  Int num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator %=  (int& l , Int& r) { // 8i
  Int num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator &=  (Int& l , int& r) { // 6i
  Int num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator &=  (int& l , Int& r) { // 8i
  Int num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator |=  (Int& l , int& r) { // 6i
  Int num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator |=  (int& l , Int& r) { // 8i
  Int num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator ^=  (Int& l , int& r) { // 6i
  Int num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator ^=  (int& l , Int& r) { // 8i
  Int num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator <<= (Int& l , int& r) { // 6i
  Int num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator <<= (int& l , Int& r) { // 8i
  Int num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int operator >>= (Int& l , int& r) { // 6i
  Int num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Int operator >>= (int& l , Int& r) { // 8i
  Int num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %   (Int& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val % r.val);
  num.u = (l.u %   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &   (Int& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val & r.val);
  num.u = (l.u &   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^   (Int& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val ^ r.val);
  num.u = (l.u ^   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |   (Int& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val | r.val);
  num.u = (l.u |   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<  (Int& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val << r.val);
  num.u = (l.u <<  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>  (Int& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val >> r.val);
  num.u = (l.u >>  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %=  (Int& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val %= r.val);
  num.u = (l.u %=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &=  (Int& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val &= r.val);
  num.u = (l.u &=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |=  (Int& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val |= r.val);
  num.u = (l.u |=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^=  (Int& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val ^= r.val);
  num.u = (l.u ^=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<= (Int& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val <<= r.val);
  num.u = (l.u <<= r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>= (Int& l , UnsignedLong& r) { // 3i
  UnsignedLong num;
  num.val = (l.val >>= r.val);
  num.u = (l.u >>= r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %   (Int& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %   (int& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &   (Int& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &   (int& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^   (Int& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^   (int& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |   (Int& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |   (int& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<  (Int& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<  (int& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>  (Int& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>  (int& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %=  (Int& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %=  (int& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &=  (Int& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &=  (int& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |=  (Int& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |=  (int& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^=  (Int& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^=  (int& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<= (Int& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<= (int& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>= (Int& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>= (int& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator %   (Int& l , Long& r) { // 3i
  Long num;
  num.val = (l.val % r.val);
  num.u = (l.u %   r.u);
  return num;
}

// **********************************************************************************************************
Long operator &   (Int& l , Long& r) { // 3i
  Long num;
  num.val = (l.val & r.val);
  num.u = (l.u &   r.u);
  return num;
}

// **********************************************************************************************************
Long operator ^   (Int& l , Long& r) { // 3i
  Long num;
  num.val = (l.val ^ r.val);
  num.u = (l.u ^   r.u);
  return num;
}

// **********************************************************************************************************
Long operator |   (Int& l , Long& r) { // 3i
  Long num;
  num.val = (l.val | r.val);
  num.u = (l.u |   r.u);
  return num;
}

// **********************************************************************************************************
Long operator <<  (Int& l , Long& r) { // 3i
  Long num;
  num.val = (l.val << r.val);
  num.u = (l.u <<  r.u);
  return num;
}

// **********************************************************************************************************
Long operator >>  (Int& l , Long& r) { // 3i
  Long num;
  num.val = (l.val >> r.val);
  num.u = (l.u >>  r.u);
  return num;
}

// **********************************************************************************************************
Long operator %=  (Int& l , Long& r) { // 3i
  Long num;
  num.val = (l.val %= r.val);
  num.u = (l.u %=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator &=  (Int& l , Long& r) { // 3i
  Long num;
  num.val = (l.val &= r.val);
  num.u = (l.u &=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator |=  (Int& l , Long& r) { // 3i
  Long num;
  num.val = (l.val |= r.val);
  num.u = (l.u |=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator ^=  (Int& l , Long& r) { // 3i
  Long num;
  num.val = (l.val ^= r.val);
  num.u = (l.u ^=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator <<= (Int& l , Long& r) { // 3i
  Long num;
  num.val = (l.val <<= r.val);
  num.u = (l.u <<= r.u);
  return num;
}

// **********************************************************************************************************
Long operator >>= (Int& l , Long& r) { // 3i
  Long num;
  num.val = (l.val >>= r.val);
  num.u = (l.u >>= r.u);
  return num;
}

// **********************************************************************************************************
Long operator %   (Int& l , long& r) { // 6i
  Long num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator %   (int& l , Long& r) { // 8i
  Long num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator &   (Int& l , long& r) { // 6i
  Long num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator &   (int& l , Long& r) { // 8i
  Long num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator ^   (Int& l , long& r) { // 6i
  Long num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator ^   (int& l , Long& r) { // 8i
  Long num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator |   (Int& l , long& r) { // 6i
  Long num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator |   (int& l , Long& r) { // 8i
  Long num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator <<  (Int& l , long& r) { // 6i
  Long num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator <<  (int& l , Long& r) { // 8i
  Long num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator >>  (Int& l , long& r) { // 6i
  Long num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator >>  (int& l , Long& r) { // 8i
  Long num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator %=  (Int& l , long& r) { // 6i
  Long num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator %=  (int& l , Long& r) { // 8i
  Long num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator &=  (Int& l , long& r) { // 6i
  Long num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator &=  (int& l , Long& r) { // 8i
  Long num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator |=  (Int& l , long& r) { // 6i
  Long num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator |=  (int& l , Long& r) { // 8i
  Long num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator ^=  (Int& l , long& r) { // 6i
  Long num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator ^=  (int& l , Long& r) { // 8i
  Long num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator <<= (Int& l , long& r) { // 6i
  Long num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator <<= (int& l , Long& r) { // 8i
  Long num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator >>= (Int& l , long& r) { // 6i
  Long num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator >>= (int& l , Long& r) { // 8i
  Long num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Int Int::operator ++(void) { // 1p, Prefix operator
   ++val;
  return *this;
}

// **********************************************************************************************************
Int Int::operator --(void) { // 1p, Prefix operator
   --val;
  return *this;
}

// **********************************************************************************************************
Int Int::operator ++(int) { // 1p, Postfix operator
   val++;
  return *this;
}

// **********************************************************************************************************
Int Int::operator --(int) { // 1p, Postfix operator
   val--;
  return *this;
}

// *********************************************************************************************************
// First class UnsignedLong constructor
// *********************************************************************************************************
UnsignedLong::UnsignedLong() {
  val=0;
  state=UNDEF;
  u.init();
}
// *********************************************************************************************************
// Second class UnsignedLong constructor
// *********************************************************************************************************
UnsignedLong::UnsignedLong(char* str) {
  val=0;
  state=UNDEF;
  u.init(str);
}
// *********************************************************************************************************
// First class UnsignedLong destructor
// *********************************************************************************************************
UnsignedLong::~UnsignedLong() {
  val=0;
  state=UNDEF;
  u.init();
}
// **********************************************************************************************************
UnsignedLong operator +   (UnsignedLong& l , UnsignedChar& r) { // 3a
  UnsignedLong num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -   (UnsignedLong& l , UnsignedChar& r) { // 3a
  UnsignedLong num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *   (UnsignedLong& l , UnsignedChar& r) { // 3a
  UnsignedLong num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /   (UnsignedLong& l , UnsignedChar& r) { // 3a
  UnsignedLong num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +=  (UnsignedLong& l , UnsignedChar& r) { // 3a
  UnsignedLong num;
  num.val = (unsigned long)(l.val += (unsigned long)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -=  (UnsignedLong& l , UnsignedChar& r) { // 3a
  UnsignedLong num;
  num.val = (unsigned long)(l.val -= (unsigned long)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *=  (UnsignedLong& l , UnsignedChar& r) { // 3a
  UnsignedLong num;
  num.val = (unsigned long)(l.val *= (unsigned long)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /=  (UnsignedLong& l , UnsignedChar& r) { // 3a
  UnsignedLong num;
  num.val = (unsigned long)(l.val /= (unsigned long)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +   (UnsignedLong& l , unsigned char& r) {   // 6a
  UnsignedLong num;
  num.val = (l.val + (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +   (unsigned long& l , UnsignedChar& r) {   // 8a
  UnsignedLong num;
  num.val = (l + (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -   (UnsignedLong& l , unsigned char& r) {   // 6a
  UnsignedLong num;
  num.val = (l.val - (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -   (unsigned long& l , UnsignedChar& r) {   // 8a
  UnsignedLong num;
  num.val = (l - (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *   (UnsignedLong& l , unsigned char& r) {   // 6a
  UnsignedLong num;
  num.val = (l.val * (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *   (unsigned long& l , UnsignedChar& r) {   // 8a
  UnsignedLong num;
  num.val = (l * (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /   (UnsignedLong& l , unsigned char& r) {   // 6a
  UnsignedLong num;
  num.val = (l.val / (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /   (unsigned long& l , UnsignedChar& r) {   // 8a
  UnsignedLong num;
  num.val = (l / (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +=  (UnsignedLong& l , unsigned char& r) {   // 6a
  UnsignedLong num;
  num.val = (unsigned long)(l.val += (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +=  (unsigned long& l , UnsignedChar& r) {   // 8a
  UnsignedLong num;
  num.val = (unsigned long)(l += (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -=  (UnsignedLong& l , unsigned char& r) {   // 6a
  UnsignedLong num;
  num.val = (unsigned long)(l.val -= (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -=  (unsigned long& l , UnsignedChar& r) {   // 8a
  UnsignedLong num;
  num.val = (unsigned long)(l -= (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *=  (UnsignedLong& l , unsigned char& r) {   // 6a
  UnsignedLong num;
  num.val = (unsigned long)(l.val *= (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *=  (unsigned long& l , UnsignedChar& r) {   // 8a
  UnsignedLong num;
  num.val = (unsigned long)(l *= (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /=  (UnsignedLong& l , unsigned char& r) {   // 6a
  UnsignedLong num;
  num.val = (unsigned long)(l.val /= (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /=  (unsigned long& l , UnsignedChar& r) {   // 8a
  UnsignedLong num;
  num.val = (unsigned long)(l /= (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +   (UnsignedLong& l , Char& r) { // 3a
  UnsignedLong num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -   (UnsignedLong& l , Char& r) { // 3a
  UnsignedLong num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *   (UnsignedLong& l , Char& r) { // 3a
  UnsignedLong num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /   (UnsignedLong& l , Char& r) { // 3a
  UnsignedLong num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +=  (UnsignedLong& l , Char& r) { // 3a
  UnsignedLong num;
  num.val = (unsigned long)(l.val += (unsigned long)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -=  (UnsignedLong& l , Char& r) { // 3a
  UnsignedLong num;
  num.val = (unsigned long)(l.val -= (unsigned long)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *=  (UnsignedLong& l , Char& r) { // 3a
  UnsignedLong num;
  num.val = (unsigned long)(l.val *= (unsigned long)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /=  (UnsignedLong& l , Char& r) { // 3a
  UnsignedLong num;
  num.val = (unsigned long)(l.val /= (unsigned long)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +   (UnsignedLong& l , char& r) {   // 6a
  UnsignedLong num;
  num.val = (l.val + (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +   (unsigned long& l , Char& r) {   // 8a
  UnsignedLong num;
  num.val = (l + (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -   (UnsignedLong& l , char& r) {   // 6a
  UnsignedLong num;
  num.val = (l.val - (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -   (unsigned long& l , Char& r) {   // 8a
  UnsignedLong num;
  num.val = (l - (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *   (UnsignedLong& l , char& r) {   // 6a
  UnsignedLong num;
  num.val = (l.val * (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *   (unsigned long& l , Char& r) {   // 8a
  UnsignedLong num;
  num.val = (l * (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /   (UnsignedLong& l , char& r) {   // 6a
  UnsignedLong num;
  num.val = (l.val / (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /   (unsigned long& l , Char& r) {   // 8a
  UnsignedLong num;
  num.val = (l / (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +=  (UnsignedLong& l , char& r) {   // 6a
  UnsignedLong num;
  num.val = (unsigned long)(l.val += (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +=  (unsigned long& l , Char& r) {   // 8a
  UnsignedLong num;
  num.val = (unsigned long)(l += (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -=  (UnsignedLong& l , char& r) {   // 6a
  UnsignedLong num;
  num.val = (unsigned long)(l.val -= (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -=  (unsigned long& l , Char& r) {   // 8a
  UnsignedLong num;
  num.val = (unsigned long)(l -= (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *=  (UnsignedLong& l , char& r) {   // 6a
  UnsignedLong num;
  num.val = (unsigned long)(l.val *= (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *=  (unsigned long& l , Char& r) {   // 8a
  UnsignedLong num;
  num.val = (unsigned long)(l *= (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /=  (UnsignedLong& l , char& r) {   // 6a
  UnsignedLong num;
  num.val = (unsigned long)(l.val /= (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /=  (unsigned long& l , Char& r) {   // 8a
  UnsignedLong num;
  num.val = (unsigned long)(l /= (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +   (UnsignedLong& l , UnsignedShort& r) { // 3a
  UnsignedLong num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -   (UnsignedLong& l , UnsignedShort& r) { // 3a
  UnsignedLong num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *   (UnsignedLong& l , UnsignedShort& r) { // 3a
  UnsignedLong num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /   (UnsignedLong& l , UnsignedShort& r) { // 3a
  UnsignedLong num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +=  (UnsignedLong& l , UnsignedShort& r) { // 3a
  UnsignedLong num;
  num.val = (unsigned long)(l.val += (unsigned long)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -=  (UnsignedLong& l , UnsignedShort& r) { // 3a
  UnsignedLong num;
  num.val = (unsigned long)(l.val -= (unsigned long)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *=  (UnsignedLong& l , UnsignedShort& r) { // 3a
  UnsignedLong num;
  num.val = (unsigned long)(l.val *= (unsigned long)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /=  (UnsignedLong& l , UnsignedShort& r) { // 3a
  UnsignedLong num;
  num.val = (unsigned long)(l.val /= (unsigned long)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +   (UnsignedLong& l , unsigned short& r) {   // 6a
  UnsignedLong num;
  num.val = (l.val + (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +   (unsigned long& l , UnsignedShort& r) {   // 8a
  UnsignedLong num;
  num.val = (l + (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -   (UnsignedLong& l , unsigned short& r) {   // 6a
  UnsignedLong num;
  num.val = (l.val - (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -   (unsigned long& l , UnsignedShort& r) {   // 8a
  UnsignedLong num;
  num.val = (l - (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *   (UnsignedLong& l , unsigned short& r) {   // 6a
  UnsignedLong num;
  num.val = (l.val * (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *   (unsigned long& l , UnsignedShort& r) {   // 8a
  UnsignedLong num;
  num.val = (l * (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /   (UnsignedLong& l , unsigned short& r) {   // 6a
  UnsignedLong num;
  num.val = (l.val / (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /   (unsigned long& l , UnsignedShort& r) {   // 8a
  UnsignedLong num;
  num.val = (l / (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +=  (UnsignedLong& l , unsigned short& r) {   // 6a
  UnsignedLong num;
  num.val = (unsigned long)(l.val += (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +=  (unsigned long& l , UnsignedShort& r) {   // 8a
  UnsignedLong num;
  num.val = (unsigned long)(l += (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -=  (UnsignedLong& l , unsigned short& r) {   // 6a
  UnsignedLong num;
  num.val = (unsigned long)(l.val -= (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -=  (unsigned long& l , UnsignedShort& r) {   // 8a
  UnsignedLong num;
  num.val = (unsigned long)(l -= (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *=  (UnsignedLong& l , unsigned short& r) {   // 6a
  UnsignedLong num;
  num.val = (unsigned long)(l.val *= (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *=  (unsigned long& l , UnsignedShort& r) {   // 8a
  UnsignedLong num;
  num.val = (unsigned long)(l *= (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /=  (UnsignedLong& l , unsigned short& r) {   // 6a
  UnsignedLong num;
  num.val = (unsigned long)(l.val /= (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /=  (unsigned long& l , UnsignedShort& r) {   // 8a
  UnsignedLong num;
  num.val = (unsigned long)(l /= (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +   (UnsignedLong& l , Short& r) { // 3a
  UnsignedLong num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -   (UnsignedLong& l , Short& r) { // 3a
  UnsignedLong num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *   (UnsignedLong& l , Short& r) { // 3a
  UnsignedLong num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /   (UnsignedLong& l , Short& r) { // 3a
  UnsignedLong num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +=  (UnsignedLong& l , Short& r) { // 3a
  UnsignedLong num;
  num.val = (unsigned long)(l.val += (unsigned long)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -=  (UnsignedLong& l , Short& r) { // 3a
  UnsignedLong num;
  num.val = (unsigned long)(l.val -= (unsigned long)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *=  (UnsignedLong& l , Short& r) { // 3a
  UnsignedLong num;
  num.val = (unsigned long)(l.val *= (unsigned long)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /=  (UnsignedLong& l , Short& r) { // 3a
  UnsignedLong num;
  num.val = (unsigned long)(l.val /= (unsigned long)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +   (UnsignedLong& l , short& r) {   // 6a
  UnsignedLong num;
  num.val = (l.val + (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +   (unsigned long& l , Short& r) {   // 8a
  UnsignedLong num;
  num.val = (l + (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -   (UnsignedLong& l , short& r) {   // 6a
  UnsignedLong num;
  num.val = (l.val - (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -   (unsigned long& l , Short& r) {   // 8a
  UnsignedLong num;
  num.val = (l - (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *   (UnsignedLong& l , short& r) {   // 6a
  UnsignedLong num;
  num.val = (l.val * (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *   (unsigned long& l , Short& r) {   // 8a
  UnsignedLong num;
  num.val = (l * (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /   (UnsignedLong& l , short& r) {   // 6a
  UnsignedLong num;
  num.val = (l.val / (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /   (unsigned long& l , Short& r) {   // 8a
  UnsignedLong num;
  num.val = (l / (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +=  (UnsignedLong& l , short& r) {   // 6a
  UnsignedLong num;
  num.val = (unsigned long)(l.val += (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +=  (unsigned long& l , Short& r) {   // 8a
  UnsignedLong num;
  num.val = (unsigned long)(l += (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -=  (UnsignedLong& l , short& r) {   // 6a
  UnsignedLong num;
  num.val = (unsigned long)(l.val -= (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -=  (unsigned long& l , Short& r) {   // 8a
  UnsignedLong num;
  num.val = (unsigned long)(l -= (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *=  (UnsignedLong& l , short& r) {   // 6a
  UnsignedLong num;
  num.val = (unsigned long)(l.val *= (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *=  (unsigned long& l , Short& r) {   // 8a
  UnsignedLong num;
  num.val = (unsigned long)(l *= (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /=  (UnsignedLong& l , short& r) {   // 6a
  UnsignedLong num;
  num.val = (unsigned long)(l.val /= (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /=  (unsigned long& l , Short& r) {   // 8a
  UnsignedLong num;
  num.val = (unsigned long)(l /= (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +   (UnsignedLong& l , UnsignedInt& r) { // 3a
  UnsignedLong num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -   (UnsignedLong& l , UnsignedInt& r) { // 3a
  UnsignedLong num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *   (UnsignedLong& l , UnsignedInt& r) { // 3a
  UnsignedLong num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /   (UnsignedLong& l , UnsignedInt& r) { // 3a
  UnsignedLong num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +=  (UnsignedLong& l , UnsignedInt& r) { // 3a
  UnsignedLong num;
  num.val = (unsigned long)(l.val += (unsigned long)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -=  (UnsignedLong& l , UnsignedInt& r) { // 3a
  UnsignedLong num;
  num.val = (unsigned long)(l.val -= (unsigned long)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *=  (UnsignedLong& l , UnsignedInt& r) { // 3a
  UnsignedLong num;
  num.val = (unsigned long)(l.val *= (unsigned long)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /=  (UnsignedLong& l , UnsignedInt& r) { // 3a
  UnsignedLong num;
  num.val = (unsigned long)(l.val /= (unsigned long)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +   (UnsignedLong& l , unsigned int& r) {   // 6a
  UnsignedLong num;
  num.val = (l.val + (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +   (unsigned long& l , UnsignedInt& r) {   // 8a
  UnsignedLong num;
  num.val = (l + (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -   (UnsignedLong& l , unsigned int& r) {   // 6a
  UnsignedLong num;
  num.val = (l.val - (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -   (unsigned long& l , UnsignedInt& r) {   // 8a
  UnsignedLong num;
  num.val = (l - (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *   (UnsignedLong& l , unsigned int& r) {   // 6a
  UnsignedLong num;
  num.val = (l.val * (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *   (unsigned long& l , UnsignedInt& r) {   // 8a
  UnsignedLong num;
  num.val = (l * (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /   (UnsignedLong& l , unsigned int& r) {   // 6a
  UnsignedLong num;
  num.val = (l.val / (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /   (unsigned long& l , UnsignedInt& r) {   // 8a
  UnsignedLong num;
  num.val = (l / (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +=  (UnsignedLong& l , unsigned int& r) {   // 6a
  UnsignedLong num;
  num.val = (unsigned long)(l.val += (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +=  (unsigned long& l , UnsignedInt& r) {   // 8a
  UnsignedLong num;
  num.val = (unsigned long)(l += (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -=  (UnsignedLong& l , unsigned int& r) {   // 6a
  UnsignedLong num;
  num.val = (unsigned long)(l.val -= (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -=  (unsigned long& l , UnsignedInt& r) {   // 8a
  UnsignedLong num;
  num.val = (unsigned long)(l -= (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *=  (UnsignedLong& l , unsigned int& r) {   // 6a
  UnsignedLong num;
  num.val = (unsigned long)(l.val *= (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *=  (unsigned long& l , UnsignedInt& r) {   // 8a
  UnsignedLong num;
  num.val = (unsigned long)(l *= (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /=  (UnsignedLong& l , unsigned int& r) {   // 6a
  UnsignedLong num;
  num.val = (unsigned long)(l.val /= (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /=  (unsigned long& l , UnsignedInt& r) {   // 8a
  UnsignedLong num;
  num.val = (unsigned long)(l /= (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +   (UnsignedLong& l , Int& r) { // 3a
  UnsignedLong num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -   (UnsignedLong& l , Int& r) { // 3a
  UnsignedLong num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *   (UnsignedLong& l , Int& r) { // 3a
  UnsignedLong num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /   (UnsignedLong& l , Int& r) { // 3a
  UnsignedLong num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +=  (UnsignedLong& l , Int& r) { // 3a
  UnsignedLong num;
  num.val = (unsigned long)(l.val += (unsigned long)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -=  (UnsignedLong& l , Int& r) { // 3a
  UnsignedLong num;
  num.val = (unsigned long)(l.val -= (unsigned long)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *=  (UnsignedLong& l , Int& r) { // 3a
  UnsignedLong num;
  num.val = (unsigned long)(l.val *= (unsigned long)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /=  (UnsignedLong& l , Int& r) { // 3a
  UnsignedLong num;
  num.val = (unsigned long)(l.val /= (unsigned long)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +   (UnsignedLong& l , int& r) {   // 6a
  UnsignedLong num;
  num.val = (l.val + (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +   (unsigned long& l , Int& r) {   // 8a
  UnsignedLong num;
  num.val = (l + (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -   (UnsignedLong& l , int& r) {   // 6a
  UnsignedLong num;
  num.val = (l.val - (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -   (unsigned long& l , Int& r) {   // 8a
  UnsignedLong num;
  num.val = (l - (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *   (UnsignedLong& l , int& r) {   // 6a
  UnsignedLong num;
  num.val = (l.val * (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *   (unsigned long& l , Int& r) {   // 8a
  UnsignedLong num;
  num.val = (l * (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /   (UnsignedLong& l , int& r) {   // 6a
  UnsignedLong num;
  num.val = (l.val / (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /   (unsigned long& l , Int& r) {   // 8a
  UnsignedLong num;
  num.val = (l / (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +=  (UnsignedLong& l , int& r) {   // 6a
  UnsignedLong num;
  num.val = (unsigned long)(l.val += (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +=  (unsigned long& l , Int& r) {   // 8a
  UnsignedLong num;
  num.val = (unsigned long)(l += (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -=  (UnsignedLong& l , int& r) {   // 6a
  UnsignedLong num;
  num.val = (unsigned long)(l.val -= (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -=  (unsigned long& l , Int& r) {   // 8a
  UnsignedLong num;
  num.val = (unsigned long)(l -= (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *=  (UnsignedLong& l , int& r) {   // 6a
  UnsignedLong num;
  num.val = (unsigned long)(l.val *= (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *=  (unsigned long& l , Int& r) {   // 8a
  UnsignedLong num;
  num.val = (unsigned long)(l *= (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /=  (UnsignedLong& l , int& r) {   // 6a
  UnsignedLong num;
  num.val = (unsigned long)(l.val /= (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /=  (unsigned long& l , Int& r) {   // 8a
  UnsignedLong num;
  num.val = (unsigned long)(l /= (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong UnsignedLong::operator +   (UnsignedLong& r) { // 1a
  UnsignedLong num;
  num.val = (val + r.val);
  num.u = (u +   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong UnsignedLong::operator -   (UnsignedLong& r) { // 1a
  UnsignedLong num;
  num.val = (val - r.val);
  num.u = (u -   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong UnsignedLong::operator *   (UnsignedLong& r) { // 1a
  UnsignedLong num;
  num.val = (val * r.val);
  num.u = (u *   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong UnsignedLong::operator /   (UnsignedLong& r) { // 1a
  UnsignedLong num;
  num.val = (val / r.val);
  num.u = (u /   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong UnsignedLong::operator +=  (UnsignedLong& r) { // 1a
  UnsignedLong num;
  num.val = (val += r.val);
  num.u = (u +=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong UnsignedLong::operator -=  (UnsignedLong& r) { // 1a
  UnsignedLong num;
  num.val = (val -= r.val);
  num.u = (u -=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong UnsignedLong::operator *=  (UnsignedLong& r) { // 1a
  UnsignedLong num;
  num.val = (val *= r.val);
  num.u = (u *=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong UnsignedLong::operator /=  (UnsignedLong& r) { // 1a
  UnsignedLong num;
  num.val = (val /= r.val);
  num.u = (u /=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +   (UnsignedLong& l , unsigned long& r) {   // 6a
  UnsignedLong num;
  num.val = (l.val + r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +   (unsigned long& l , UnsignedLong& r) {   // 8a
  UnsignedLong num;
  num.val = (l + r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -   (UnsignedLong& l , unsigned long& r) {   // 6a
  UnsignedLong num;
  num.val = (l.val - r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -   (unsigned long& l , UnsignedLong& r) {   // 8a
  UnsignedLong num;
  num.val = (l - r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *   (UnsignedLong& l , unsigned long& r) {   // 6a
  UnsignedLong num;
  num.val = (l.val * r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *   (unsigned long& l , UnsignedLong& r) {   // 8a
  UnsignedLong num;
  num.val = (l * r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /   (UnsignedLong& l , unsigned long& r) {   // 6a
  UnsignedLong num;
  num.val = (l.val / r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /   (unsigned long& l , UnsignedLong& r) {   // 8a
  UnsignedLong num;
  num.val = (l / r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +=  (UnsignedLong& l , unsigned long& r) {   // 6a
  UnsignedLong num;
  num.val = (unsigned long)(l.val += (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator +=  (unsigned long& l , UnsignedLong& r) {   // 8a
  UnsignedLong num;
  num.val = (unsigned long)(l += (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -=  (UnsignedLong& l , unsigned long& r) {   // 6a
  UnsignedLong num;
  num.val = (unsigned long)(l.val -= (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator -=  (unsigned long& l , UnsignedLong& r) {   // 8a
  UnsignedLong num;
  num.val = (unsigned long)(l -= (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *=  (UnsignedLong& l , unsigned long& r) {   // 6a
  UnsignedLong num;
  num.val = (unsigned long)(l.val *= (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator *=  (unsigned long& l , UnsignedLong& r) {   // 8a
  UnsignedLong num;
  num.val = (unsigned long)(l *= (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /=  (UnsignedLong& l , unsigned long& r) {   // 6a
  UnsignedLong num;
  num.val = (unsigned long)(l.val /= (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator /=  (unsigned long& l , UnsignedLong& r) {   // 8a
  UnsignedLong num;
  num.val = (unsigned long)(l /= (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator +   (UnsignedLong& l , Long& r) { // 3a
  Long num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
Long operator -   (UnsignedLong& l , Long& r) { // 3a
  Long num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
Long operator *   (UnsignedLong& l , Long& r) { // 3a
  Long num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
Long operator /   (UnsignedLong& l , Long& r) { // 3a
  Long num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
Long operator +=  (UnsignedLong& l , Long& r) { // 3a
  Long num;
  num.val = (long)(l.val += (unsigned long)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator -=  (UnsignedLong& l , Long& r) { // 3a
  Long num;
  num.val = (long)(l.val -= (unsigned long)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator *=  (UnsignedLong& l , Long& r) { // 3a
  Long num;
  num.val = (long)(l.val *= (unsigned long)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator /=  (UnsignedLong& l , Long& r) { // 3a
  Long num;
  num.val = (long)(l.val /= (unsigned long)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator +   (UnsignedLong& l , long& r) {   // 6a
  Long num;
  num.val = ((long)l.val + r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator +   (unsigned long& l , Long& r) {   // 8a
  Long num;
  num.val = ((long)l + r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator -   (UnsignedLong& l , long& r) {   // 6a
  Long num;
  num.val = ((long)l.val - r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator -   (unsigned long& l , Long& r) {   // 8a
  Long num;
  num.val = ((long)l - r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator *   (UnsignedLong& l , long& r) {   // 6a
  Long num;
  num.val = ((long)l.val * r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator *   (unsigned long& l , Long& r) {   // 8a
  Long num;
  num.val = ((long)l * r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator /   (UnsignedLong& l , long& r) {   // 6a
  Long num;
  num.val = ((long)l.val / r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator /   (unsigned long& l , Long& r) {   // 8a
  Long num;
  num.val = ((long)l / r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator +=  (UnsignedLong& l , long& r) {   // 6a
  Long num;
  num.val = (long)(l.val += (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator +=  (unsigned long& l , Long& r) {   // 8a
  Long num;
  num.val = (long)(l += (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator -=  (UnsignedLong& l , long& r) {   // 6a
  Long num;
  num.val = (long)(l.val -= (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator -=  (unsigned long& l , Long& r) {   // 8a
  Long num;
  num.val = (long)(l -= (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator *=  (UnsignedLong& l , long& r) {   // 6a
  Long num;
  num.val = (long)(l.val *= (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator *=  (unsigned long& l , Long& r) {   // 8a
  Long num;
  num.val = (long)(l *= (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator /=  (UnsignedLong& l , long& r) {   // 6a
  Long num;
  num.val = (long)(l.val /= (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator /=  (unsigned long& l , Long& r) {   // 8a
  Long num;
  num.val = (long)(l /= (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator +   (UnsignedLong& l , Float& r) { // 3a
  Float num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
Float operator -   (UnsignedLong& l , Float& r) { // 3a
  Float num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
Float operator *   (UnsignedLong& l , Float& r) { // 3a
  Float num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
Float operator /   (UnsignedLong& l , Float& r) { // 3a
  Float num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
Float operator +=  (UnsignedLong& l , Float& r) { // 3a
  Float num;
  num.val = (float)(l.val += (unsigned long)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
Float operator -=  (UnsignedLong& l , Float& r) { // 3a
  Float num;
  num.val = (float)(l.val -= (unsigned long)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
Float operator *=  (UnsignedLong& l , Float& r) { // 3a
  Float num;
  num.val = (float)(l.val *= (unsigned long)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
Float operator /=  (UnsignedLong& l , Float& r) { // 3a
  Float num;
  num.val = (float)(l.val /= (unsigned long)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
Float operator +   (UnsignedLong& l , float& r) {   // 6a
  Float num;
  num.val = ((float)l.val + r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator +   (unsigned long& l , Float& r) {   // 8a
  Float num;
  num.val = ((float)l + r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator -   (UnsignedLong& l , float& r) {   // 6a
  Float num;
  num.val = ((float)l.val - r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator -   (unsigned long& l , Float& r) {   // 8a
  Float num;
  num.val = ((float)l - r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator *   (UnsignedLong& l , float& r) {   // 6a
  Float num;
  num.val = ((float)l.val * r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator *   (unsigned long& l , Float& r) {   // 8a
  Float num;
  num.val = ((float)l * r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator /   (UnsignedLong& l , float& r) {   // 6a
  Float num;
  num.val = ((float)l.val / r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator /   (unsigned long& l , Float& r) {   // 8a
  Float num;
  num.val = ((float)l / r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator +=  (UnsignedLong& l , float& r) {   // 6a
  Float num;
  num.val = (float)(l.val += (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator +=  (unsigned long& l , Float& r) {   // 8a
  Float num;
  num.val = (float)(l += (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator -=  (UnsignedLong& l , float& r) {   // 6a
  Float num;
  num.val = (float)(l.val -= (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator -=  (unsigned long& l , Float& r) {   // 8a
  Float num;
  num.val = (float)(l -= (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator *=  (UnsignedLong& l , float& r) {   // 6a
  Float num;
  num.val = (float)(l.val *= (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator *=  (unsigned long& l , Float& r) {   // 8a
  Float num;
  num.val = (float)(l *= (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator /=  (UnsignedLong& l , float& r) {   // 6a
  Float num;
  num.val = (float)(l.val /= (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator /=  (unsigned long& l , Float& r) {   // 8a
  Float num;
  num.val = (float)(l /= (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator +   (UnsignedLong& l , Double& r) { // 3a
  Double num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
Double operator -   (UnsignedLong& l , Double& r) { // 3a
  Double num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
Double operator *   (UnsignedLong& l , Double& r) { // 3a
  Double num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
Double operator /   (UnsignedLong& l , Double& r) { // 3a
  Double num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
Double operator +=  (UnsignedLong& l , Double& r) { // 3a
  Double num;
  num.val = (double)(l.val += (unsigned long)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
Double operator -=  (UnsignedLong& l , Double& r) { // 3a
  Double num;
  num.val = (double)(l.val -= (unsigned long)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
Double operator *=  (UnsignedLong& l , Double& r) { // 3a
  Double num;
  num.val = (double)(l.val *= (unsigned long)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
Double operator /=  (UnsignedLong& l , Double& r) { // 3a
  Double num;
  num.val = (double)(l.val /= (unsigned long)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
Double operator +   (UnsignedLong& l , double& r) {   // 6a
  Double num;
  num.val = ((double)l.val + r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator +   (unsigned long& l , Double& r) {   // 8a
  Double num;
  num.val = ((double)l + r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator -   (UnsignedLong& l , double& r) {   // 6a
  Double num;
  num.val = ((double)l.val - r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator -   (unsigned long& l , Double& r) {   // 8a
  Double num;
  num.val = ((double)l - r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator *   (UnsignedLong& l , double& r) {   // 6a
  Double num;
  num.val = ((double)l.val * r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator *   (unsigned long& l , Double& r) {   // 8a
  Double num;
  num.val = ((double)l * r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator /   (UnsignedLong& l , double& r) {   // 6a
  Double num;
  num.val = ((double)l.val / r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator /   (unsigned long& l , Double& r) {   // 8a
  Double num;
  num.val = ((double)l / r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator +=  (UnsignedLong& l , double& r) {   // 6a
  Double num;
  num.val = (double)(l.val += (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator +=  (unsigned long& l , Double& r) {   // 8a
  Double num;
  num.val = (double)(l += (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator -=  (UnsignedLong& l , double& r) {   // 6a
  Double num;
  num.val = (double)(l.val -= (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator -=  (unsigned long& l , Double& r) {   // 8a
  Double num;
  num.val = (double)(l -= (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator *=  (UnsignedLong& l , double& r) {   // 6a
  Double num;
  num.val = (double)(l.val *= (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator *=  (unsigned long& l , Double& r) {   // 8a
  Double num;
  num.val = (double)(l *= (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator /=  (UnsignedLong& l , double& r) {   // 6a
  Double num;
  num.val = (double)(l.val /= (unsigned long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator /=  (unsigned long& l , Double& r) {   // 8a
  Double num;
  num.val = (double)(l /= (unsigned long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %   (UnsignedLong& l , UnsignedChar& r) { // 3i
  UnsignedLong num;
  num.val = (l.val % r.val);
  num.u = (l.u %   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &   (UnsignedLong& l , UnsignedChar& r) { // 3i
  UnsignedLong num;
  num.val = (l.val & r.val);
  num.u = (l.u &   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^   (UnsignedLong& l , UnsignedChar& r) { // 3i
  UnsignedLong num;
  num.val = (l.val ^ r.val);
  num.u = (l.u ^   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |   (UnsignedLong& l , UnsignedChar& r) { // 3i
  UnsignedLong num;
  num.val = (l.val | r.val);
  num.u = (l.u |   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<  (UnsignedLong& l , UnsignedChar& r) { // 3i
  UnsignedLong num;
  num.val = (l.val << r.val);
  num.u = (l.u <<  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>  (UnsignedLong& l , UnsignedChar& r) { // 3i
  UnsignedLong num;
  num.val = (l.val >> r.val);
  num.u = (l.u >>  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %=  (UnsignedLong& l , UnsignedChar& r) { // 3i
  UnsignedLong num;
  num.val = (l.val %= r.val);
  num.u = (l.u %=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &=  (UnsignedLong& l , UnsignedChar& r) { // 3i
  UnsignedLong num;
  num.val = (l.val &= r.val);
  num.u = (l.u &=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |=  (UnsignedLong& l , UnsignedChar& r) { // 3i
  UnsignedLong num;
  num.val = (l.val |= r.val);
  num.u = (l.u |=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^=  (UnsignedLong& l , UnsignedChar& r) { // 3i
  UnsignedLong num;
  num.val = (l.val ^= r.val);
  num.u = (l.u ^=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<= (UnsignedLong& l , UnsignedChar& r) { // 3i
  UnsignedLong num;
  num.val = (l.val <<= r.val);
  num.u = (l.u <<= r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>= (UnsignedLong& l , UnsignedChar& r) { // 3i
  UnsignedLong num;
  num.val = (l.val >>= r.val);
  num.u = (l.u >>= r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %   (UnsignedLong& l , unsigned char& r) { // 6i
  UnsignedLong num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %   (unsigned long& l , UnsignedChar& r) { // 8i
  UnsignedLong num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &   (UnsignedLong& l , unsigned char& r) { // 6i
  UnsignedLong num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &   (unsigned long& l , UnsignedChar& r) { // 8i
  UnsignedLong num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^   (UnsignedLong& l , unsigned char& r) { // 6i
  UnsignedLong num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^   (unsigned long& l , UnsignedChar& r) { // 8i
  UnsignedLong num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |   (UnsignedLong& l , unsigned char& r) { // 6i
  UnsignedLong num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |   (unsigned long& l , UnsignedChar& r) { // 8i
  UnsignedLong num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<  (UnsignedLong& l , unsigned char& r) { // 6i
  UnsignedLong num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<  (unsigned long& l , UnsignedChar& r) { // 8i
  UnsignedLong num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>  (UnsignedLong& l , unsigned char& r) { // 6i
  UnsignedLong num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>  (unsigned long& l , UnsignedChar& r) { // 8i
  UnsignedLong num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %=  (UnsignedLong& l , unsigned char& r) { // 6i
  UnsignedLong num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %=  (unsigned long& l , UnsignedChar& r) { // 8i
  UnsignedLong num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &=  (UnsignedLong& l , unsigned char& r) { // 6i
  UnsignedLong num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &=  (unsigned long& l , UnsignedChar& r) { // 8i
  UnsignedLong num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |=  (UnsignedLong& l , unsigned char& r) { // 6i
  UnsignedLong num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |=  (unsigned long& l , UnsignedChar& r) { // 8i
  UnsignedLong num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^=  (UnsignedLong& l , unsigned char& r) { // 6i
  UnsignedLong num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^=  (unsigned long& l , UnsignedChar& r) { // 8i
  UnsignedLong num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<= (UnsignedLong& l , unsigned char& r) { // 6i
  UnsignedLong num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<= (unsigned long& l , UnsignedChar& r) { // 8i
  UnsignedLong num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>= (UnsignedLong& l , unsigned char& r) { // 6i
  UnsignedLong num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>= (unsigned long& l , UnsignedChar& r) { // 8i
  UnsignedLong num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %   (UnsignedLong& l , Char& r) { // 3i
  UnsignedLong num;
  num.val = (l.val % r.val);
  num.u = (l.u %   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &   (UnsignedLong& l , Char& r) { // 3i
  UnsignedLong num;
  num.val = (l.val & r.val);
  num.u = (l.u &   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^   (UnsignedLong& l , Char& r) { // 3i
  UnsignedLong num;
  num.val = (l.val ^ r.val);
  num.u = (l.u ^   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |   (UnsignedLong& l , Char& r) { // 3i
  UnsignedLong num;
  num.val = (l.val | r.val);
  num.u = (l.u |   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<  (UnsignedLong& l , Char& r) { // 3i
  UnsignedLong num;
  num.val = (l.val << r.val);
  num.u = (l.u <<  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>  (UnsignedLong& l , Char& r) { // 3i
  UnsignedLong num;
  num.val = (l.val >> r.val);
  num.u = (l.u >>  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %=  (UnsignedLong& l , Char& r) { // 3i
  UnsignedLong num;
  num.val = (l.val %= r.val);
  num.u = (l.u %=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &=  (UnsignedLong& l , Char& r) { // 3i
  UnsignedLong num;
  num.val = (l.val &= r.val);
  num.u = (l.u &=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |=  (UnsignedLong& l , Char& r) { // 3i
  UnsignedLong num;
  num.val = (l.val |= r.val);
  num.u = (l.u |=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^=  (UnsignedLong& l , Char& r) { // 3i
  UnsignedLong num;
  num.val = (l.val ^= r.val);
  num.u = (l.u ^=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<= (UnsignedLong& l , Char& r) { // 3i
  UnsignedLong num;
  num.val = (l.val <<= r.val);
  num.u = (l.u <<= r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>= (UnsignedLong& l , Char& r) { // 3i
  UnsignedLong num;
  num.val = (l.val >>= r.val);
  num.u = (l.u >>= r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %   (UnsignedLong& l , char& r) { // 6i
  UnsignedLong num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %   (unsigned long& l , Char& r) { // 8i
  UnsignedLong num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &   (UnsignedLong& l , char& r) { // 6i
  UnsignedLong num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &   (unsigned long& l , Char& r) { // 8i
  UnsignedLong num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^   (UnsignedLong& l , char& r) { // 6i
  UnsignedLong num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^   (unsigned long& l , Char& r) { // 8i
  UnsignedLong num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |   (UnsignedLong& l , char& r) { // 6i
  UnsignedLong num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |   (unsigned long& l , Char& r) { // 8i
  UnsignedLong num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<  (UnsignedLong& l , char& r) { // 6i
  UnsignedLong num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<  (unsigned long& l , Char& r) { // 8i
  UnsignedLong num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>  (UnsignedLong& l , char& r) { // 6i
  UnsignedLong num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>  (unsigned long& l , Char& r) { // 8i
  UnsignedLong num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %=  (UnsignedLong& l , char& r) { // 6i
  UnsignedLong num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %=  (unsigned long& l , Char& r) { // 8i
  UnsignedLong num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &=  (UnsignedLong& l , char& r) { // 6i
  UnsignedLong num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &=  (unsigned long& l , Char& r) { // 8i
  UnsignedLong num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |=  (UnsignedLong& l , char& r) { // 6i
  UnsignedLong num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |=  (unsigned long& l , Char& r) { // 8i
  UnsignedLong num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^=  (UnsignedLong& l , char& r) { // 6i
  UnsignedLong num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^=  (unsigned long& l , Char& r) { // 8i
  UnsignedLong num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<= (UnsignedLong& l , char& r) { // 6i
  UnsignedLong num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<= (unsigned long& l , Char& r) { // 8i
  UnsignedLong num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>= (UnsignedLong& l , char& r) { // 6i
  UnsignedLong num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>= (unsigned long& l , Char& r) { // 8i
  UnsignedLong num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %   (UnsignedLong& l , UnsignedShort& r) { // 3i
  UnsignedLong num;
  num.val = (l.val % r.val);
  num.u = (l.u %   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &   (UnsignedLong& l , UnsignedShort& r) { // 3i
  UnsignedLong num;
  num.val = (l.val & r.val);
  num.u = (l.u &   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^   (UnsignedLong& l , UnsignedShort& r) { // 3i
  UnsignedLong num;
  num.val = (l.val ^ r.val);
  num.u = (l.u ^   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |   (UnsignedLong& l , UnsignedShort& r) { // 3i
  UnsignedLong num;
  num.val = (l.val | r.val);
  num.u = (l.u |   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<  (UnsignedLong& l , UnsignedShort& r) { // 3i
  UnsignedLong num;
  num.val = (l.val << r.val);
  num.u = (l.u <<  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>  (UnsignedLong& l , UnsignedShort& r) { // 3i
  UnsignedLong num;
  num.val = (l.val >> r.val);
  num.u = (l.u >>  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %=  (UnsignedLong& l , UnsignedShort& r) { // 3i
  UnsignedLong num;
  num.val = (l.val %= r.val);
  num.u = (l.u %=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &=  (UnsignedLong& l , UnsignedShort& r) { // 3i
  UnsignedLong num;
  num.val = (l.val &= r.val);
  num.u = (l.u &=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |=  (UnsignedLong& l , UnsignedShort& r) { // 3i
  UnsignedLong num;
  num.val = (l.val |= r.val);
  num.u = (l.u |=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^=  (UnsignedLong& l , UnsignedShort& r) { // 3i
  UnsignedLong num;
  num.val = (l.val ^= r.val);
  num.u = (l.u ^=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<= (UnsignedLong& l , UnsignedShort& r) { // 3i
  UnsignedLong num;
  num.val = (l.val <<= r.val);
  num.u = (l.u <<= r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>= (UnsignedLong& l , UnsignedShort& r) { // 3i
  UnsignedLong num;
  num.val = (l.val >>= r.val);
  num.u = (l.u >>= r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %   (UnsignedLong& l , unsigned short& r) { // 6i
  UnsignedLong num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %   (unsigned long& l , UnsignedShort& r) { // 8i
  UnsignedLong num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &   (UnsignedLong& l , unsigned short& r) { // 6i
  UnsignedLong num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &   (unsigned long& l , UnsignedShort& r) { // 8i
  UnsignedLong num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^   (UnsignedLong& l , unsigned short& r) { // 6i
  UnsignedLong num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^   (unsigned long& l , UnsignedShort& r) { // 8i
  UnsignedLong num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |   (UnsignedLong& l , unsigned short& r) { // 6i
  UnsignedLong num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |   (unsigned long& l , UnsignedShort& r) { // 8i
  UnsignedLong num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<  (UnsignedLong& l , unsigned short& r) { // 6i
  UnsignedLong num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<  (unsigned long& l , UnsignedShort& r) { // 8i
  UnsignedLong num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>  (UnsignedLong& l , unsigned short& r) { // 6i
  UnsignedLong num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>  (unsigned long& l , UnsignedShort& r) { // 8i
  UnsignedLong num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %=  (UnsignedLong& l , unsigned short& r) { // 6i
  UnsignedLong num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %=  (unsigned long& l , UnsignedShort& r) { // 8i
  UnsignedLong num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &=  (UnsignedLong& l , unsigned short& r) { // 6i
  UnsignedLong num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &=  (unsigned long& l , UnsignedShort& r) { // 8i
  UnsignedLong num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |=  (UnsignedLong& l , unsigned short& r) { // 6i
  UnsignedLong num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |=  (unsigned long& l , UnsignedShort& r) { // 8i
  UnsignedLong num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^=  (UnsignedLong& l , unsigned short& r) { // 6i
  UnsignedLong num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^=  (unsigned long& l , UnsignedShort& r) { // 8i
  UnsignedLong num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<= (UnsignedLong& l , unsigned short& r) { // 6i
  UnsignedLong num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<= (unsigned long& l , UnsignedShort& r) { // 8i
  UnsignedLong num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>= (UnsignedLong& l , unsigned short& r) { // 6i
  UnsignedLong num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>= (unsigned long& l , UnsignedShort& r) { // 8i
  UnsignedLong num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %   (UnsignedLong& l , Short& r) { // 3i
  UnsignedLong num;
  num.val = (l.val % r.val);
  num.u = (l.u %   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &   (UnsignedLong& l , Short& r) { // 3i
  UnsignedLong num;
  num.val = (l.val & r.val);
  num.u = (l.u &   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^   (UnsignedLong& l , Short& r) { // 3i
  UnsignedLong num;
  num.val = (l.val ^ r.val);
  num.u = (l.u ^   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |   (UnsignedLong& l , Short& r) { // 3i
  UnsignedLong num;
  num.val = (l.val | r.val);
  num.u = (l.u |   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<  (UnsignedLong& l , Short& r) { // 3i
  UnsignedLong num;
  num.val = (l.val << r.val);
  num.u = (l.u <<  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>  (UnsignedLong& l , Short& r) { // 3i
  UnsignedLong num;
  num.val = (l.val >> r.val);
  num.u = (l.u >>  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %=  (UnsignedLong& l , Short& r) { // 3i
  UnsignedLong num;
  num.val = (l.val %= r.val);
  num.u = (l.u %=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &=  (UnsignedLong& l , Short& r) { // 3i
  UnsignedLong num;
  num.val = (l.val &= r.val);
  num.u = (l.u &=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |=  (UnsignedLong& l , Short& r) { // 3i
  UnsignedLong num;
  num.val = (l.val |= r.val);
  num.u = (l.u |=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^=  (UnsignedLong& l , Short& r) { // 3i
  UnsignedLong num;
  num.val = (l.val ^= r.val);
  num.u = (l.u ^=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<= (UnsignedLong& l , Short& r) { // 3i
  UnsignedLong num;
  num.val = (l.val <<= r.val);
  num.u = (l.u <<= r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>= (UnsignedLong& l , Short& r) { // 3i
  UnsignedLong num;
  num.val = (l.val >>= r.val);
  num.u = (l.u >>= r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %   (UnsignedLong& l , short& r) { // 6i
  UnsignedLong num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %   (unsigned long& l , Short& r) { // 8i
  UnsignedLong num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &   (UnsignedLong& l , short& r) { // 6i
  UnsignedLong num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &   (unsigned long& l , Short& r) { // 8i
  UnsignedLong num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^   (UnsignedLong& l , short& r) { // 6i
  UnsignedLong num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^   (unsigned long& l , Short& r) { // 8i
  UnsignedLong num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |   (UnsignedLong& l , short& r) { // 6i
  UnsignedLong num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |   (unsigned long& l , Short& r) { // 8i
  UnsignedLong num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<  (UnsignedLong& l , short& r) { // 6i
  UnsignedLong num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<  (unsigned long& l , Short& r) { // 8i
  UnsignedLong num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>  (UnsignedLong& l , short& r) { // 6i
  UnsignedLong num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>  (unsigned long& l , Short& r) { // 8i
  UnsignedLong num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %=  (UnsignedLong& l , short& r) { // 6i
  UnsignedLong num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %=  (unsigned long& l , Short& r) { // 8i
  UnsignedLong num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &=  (UnsignedLong& l , short& r) { // 6i
  UnsignedLong num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &=  (unsigned long& l , Short& r) { // 8i
  UnsignedLong num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |=  (UnsignedLong& l , short& r) { // 6i
  UnsignedLong num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |=  (unsigned long& l , Short& r) { // 8i
  UnsignedLong num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^=  (UnsignedLong& l , short& r) { // 6i
  UnsignedLong num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^=  (unsigned long& l , Short& r) { // 8i
  UnsignedLong num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<= (UnsignedLong& l , short& r) { // 6i
  UnsignedLong num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<= (unsigned long& l , Short& r) { // 8i
  UnsignedLong num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>= (UnsignedLong& l , short& r) { // 6i
  UnsignedLong num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>= (unsigned long& l , Short& r) { // 8i
  UnsignedLong num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %   (UnsignedLong& l , UnsignedInt& r) { // 3i
  UnsignedLong num;
  num.val = (l.val % r.val);
  num.u = (l.u %   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &   (UnsignedLong& l , UnsignedInt& r) { // 3i
  UnsignedLong num;
  num.val = (l.val & r.val);
  num.u = (l.u &   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^   (UnsignedLong& l , UnsignedInt& r) { // 3i
  UnsignedLong num;
  num.val = (l.val ^ r.val);
  num.u = (l.u ^   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |   (UnsignedLong& l , UnsignedInt& r) { // 3i
  UnsignedLong num;
  num.val = (l.val | r.val);
  num.u = (l.u |   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<  (UnsignedLong& l , UnsignedInt& r) { // 3i
  UnsignedLong num;
  num.val = (l.val << r.val);
  num.u = (l.u <<  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>  (UnsignedLong& l , UnsignedInt& r) { // 3i
  UnsignedLong num;
  num.val = (l.val >> r.val);
  num.u = (l.u >>  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %=  (UnsignedLong& l , UnsignedInt& r) { // 3i
  UnsignedLong num;
  num.val = (l.val %= r.val);
  num.u = (l.u %=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &=  (UnsignedLong& l , UnsignedInt& r) { // 3i
  UnsignedLong num;
  num.val = (l.val &= r.val);
  num.u = (l.u &=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |=  (UnsignedLong& l , UnsignedInt& r) { // 3i
  UnsignedLong num;
  num.val = (l.val |= r.val);
  num.u = (l.u |=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^=  (UnsignedLong& l , UnsignedInt& r) { // 3i
  UnsignedLong num;
  num.val = (l.val ^= r.val);
  num.u = (l.u ^=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<= (UnsignedLong& l , UnsignedInt& r) { // 3i
  UnsignedLong num;
  num.val = (l.val <<= r.val);
  num.u = (l.u <<= r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>= (UnsignedLong& l , UnsignedInt& r) { // 3i
  UnsignedLong num;
  num.val = (l.val >>= r.val);
  num.u = (l.u >>= r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %   (UnsignedLong& l , unsigned int& r) { // 6i
  UnsignedLong num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %   (unsigned long& l , UnsignedInt& r) { // 8i
  UnsignedLong num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &   (UnsignedLong& l , unsigned int& r) { // 6i
  UnsignedLong num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &   (unsigned long& l , UnsignedInt& r) { // 8i
  UnsignedLong num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^   (UnsignedLong& l , unsigned int& r) { // 6i
  UnsignedLong num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^   (unsigned long& l , UnsignedInt& r) { // 8i
  UnsignedLong num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |   (UnsignedLong& l , unsigned int& r) { // 6i
  UnsignedLong num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |   (unsigned long& l , UnsignedInt& r) { // 8i
  UnsignedLong num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<  (UnsignedLong& l , unsigned int& r) { // 6i
  UnsignedLong num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<  (unsigned long& l , UnsignedInt& r) { // 8i
  UnsignedLong num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>  (UnsignedLong& l , unsigned int& r) { // 6i
  UnsignedLong num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>  (unsigned long& l , UnsignedInt& r) { // 8i
  UnsignedLong num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %=  (UnsignedLong& l , unsigned int& r) { // 6i
  UnsignedLong num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %=  (unsigned long& l , UnsignedInt& r) { // 8i
  UnsignedLong num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &=  (UnsignedLong& l , unsigned int& r) { // 6i
  UnsignedLong num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &=  (unsigned long& l , UnsignedInt& r) { // 8i
  UnsignedLong num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |=  (UnsignedLong& l , unsigned int& r) { // 6i
  UnsignedLong num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |=  (unsigned long& l , UnsignedInt& r) { // 8i
  UnsignedLong num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^=  (UnsignedLong& l , unsigned int& r) { // 6i
  UnsignedLong num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^=  (unsigned long& l , UnsignedInt& r) { // 8i
  UnsignedLong num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<= (UnsignedLong& l , unsigned int& r) { // 6i
  UnsignedLong num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<= (unsigned long& l , UnsignedInt& r) { // 8i
  UnsignedLong num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>= (UnsignedLong& l , unsigned int& r) { // 6i
  UnsignedLong num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>= (unsigned long& l , UnsignedInt& r) { // 8i
  UnsignedLong num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %   (UnsignedLong& l , Int& r) { // 3i
  UnsignedLong num;
  num.val = (l.val % r.val);
  num.u = (l.u %   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &   (UnsignedLong& l , Int& r) { // 3i
  UnsignedLong num;
  num.val = (l.val & r.val);
  num.u = (l.u &   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^   (UnsignedLong& l , Int& r) { // 3i
  UnsignedLong num;
  num.val = (l.val ^ r.val);
  num.u = (l.u ^   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |   (UnsignedLong& l , Int& r) { // 3i
  UnsignedLong num;
  num.val = (l.val | r.val);
  num.u = (l.u |   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<  (UnsignedLong& l , Int& r) { // 3i
  UnsignedLong num;
  num.val = (l.val << r.val);
  num.u = (l.u <<  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>  (UnsignedLong& l , Int& r) { // 3i
  UnsignedLong num;
  num.val = (l.val >> r.val);
  num.u = (l.u >>  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %=  (UnsignedLong& l , Int& r) { // 3i
  UnsignedLong num;
  num.val = (l.val %= r.val);
  num.u = (l.u %=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &=  (UnsignedLong& l , Int& r) { // 3i
  UnsignedLong num;
  num.val = (l.val &= r.val);
  num.u = (l.u &=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |=  (UnsignedLong& l , Int& r) { // 3i
  UnsignedLong num;
  num.val = (l.val |= r.val);
  num.u = (l.u |=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^=  (UnsignedLong& l , Int& r) { // 3i
  UnsignedLong num;
  num.val = (l.val ^= r.val);
  num.u = (l.u ^=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<= (UnsignedLong& l , Int& r) { // 3i
  UnsignedLong num;
  num.val = (l.val <<= r.val);
  num.u = (l.u <<= r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>= (UnsignedLong& l , Int& r) { // 3i
  UnsignedLong num;
  num.val = (l.val >>= r.val);
  num.u = (l.u >>= r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %   (UnsignedLong& l , int& r) { // 6i
  UnsignedLong num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %   (unsigned long& l , Int& r) { // 8i
  UnsignedLong num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &   (UnsignedLong& l , int& r) { // 6i
  UnsignedLong num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &   (unsigned long& l , Int& r) { // 8i
  UnsignedLong num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^   (UnsignedLong& l , int& r) { // 6i
  UnsignedLong num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^   (unsigned long& l , Int& r) { // 8i
  UnsignedLong num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |   (UnsignedLong& l , int& r) { // 6i
  UnsignedLong num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |   (unsigned long& l , Int& r) { // 8i
  UnsignedLong num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<  (UnsignedLong& l , int& r) { // 6i
  UnsignedLong num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<  (unsigned long& l , Int& r) { // 8i
  UnsignedLong num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>  (UnsignedLong& l , int& r) { // 6i
  UnsignedLong num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>  (unsigned long& l , Int& r) { // 8i
  UnsignedLong num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %=  (UnsignedLong& l , int& r) { // 6i
  UnsignedLong num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %=  (unsigned long& l , Int& r) { // 8i
  UnsignedLong num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &=  (UnsignedLong& l , int& r) { // 6i
  UnsignedLong num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &=  (unsigned long& l , Int& r) { // 8i
  UnsignedLong num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |=  (UnsignedLong& l , int& r) { // 6i
  UnsignedLong num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |=  (unsigned long& l , Int& r) { // 8i
  UnsignedLong num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^=  (UnsignedLong& l , int& r) { // 6i
  UnsignedLong num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^=  (unsigned long& l , Int& r) { // 8i
  UnsignedLong num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<= (UnsignedLong& l , int& r) { // 6i
  UnsignedLong num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<= (unsigned long& l , Int& r) { // 8i
  UnsignedLong num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>= (UnsignedLong& l , int& r) { // 6i
  UnsignedLong num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>= (unsigned long& l , Int& r) { // 8i
  UnsignedLong num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong UnsignedLong::operator %   (UnsignedLong& r) { // 1i
  UnsignedLong num;
  num.val = (val % r.val);
  num.u = (u %   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong UnsignedLong::operator &   (UnsignedLong& r) { // 1i
  UnsignedLong num;
  num.val = (val & r.val);
  num.u = (u &   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong UnsignedLong::operator ^   (UnsignedLong& r) { // 1i
  UnsignedLong num;
  num.val = (val ^ r.val);
  num.u = (u ^   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong UnsignedLong::operator |   (UnsignedLong& r) { // 1i
  UnsignedLong num;
  num.val = (val | r.val);
  num.u = (u |   r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong UnsignedLong::operator <<  (UnsignedLong& r) { // 1i
  UnsignedLong num;
  num.val = (val << r.val);
  num.u = (u <<  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong UnsignedLong::operator >>  (UnsignedLong& r) { // 1i
  UnsignedLong num;
  num.val = (val >> r.val);
  num.u = (u >>  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong UnsignedLong::operator %=  (UnsignedLong& r) { // 1i
  UnsignedLong num;
  num.val = (val %= r.val);
  num.u = (u %=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong UnsignedLong::operator &=  (UnsignedLong& r) { // 1i
  UnsignedLong num;
  num.val = (val &= r.val);
  num.u = (u &=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong UnsignedLong::operator |=  (UnsignedLong& r) { // 1i
  UnsignedLong num;
  num.val = (val |= r.val);
  num.u = (u |=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong UnsignedLong::operator ^=  (UnsignedLong& r) { // 1i
  UnsignedLong num;
  num.val = (val ^= r.val);
  num.u = (u ^=  r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong UnsignedLong::operator <<= (UnsignedLong& r) { // 1i
  UnsignedLong num;
  num.val = (val <<= r.val);
  num.u = (u <<= r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong UnsignedLong::operator >>= (UnsignedLong& r) { // 1i
  UnsignedLong num;
  num.val = (val >>= r.val);
  num.u = (u >>= r.u);
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %   (UnsignedLong& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %   (unsigned long& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &   (UnsignedLong& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &   (unsigned long& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^   (UnsignedLong& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^   (unsigned long& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |   (UnsignedLong& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |   (unsigned long& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<  (UnsignedLong& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<  (unsigned long& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>  (UnsignedLong& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>  (unsigned long& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %=  (UnsignedLong& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator %=  (unsigned long& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &=  (UnsignedLong& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator &=  (unsigned long& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |=  (UnsignedLong& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator |=  (unsigned long& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^=  (UnsignedLong& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator ^=  (unsigned long& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<= (UnsignedLong& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator <<= (unsigned long& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>= (UnsignedLong& l , unsigned long& r) { // 6i
  UnsignedLong num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong operator >>= (unsigned long& l , UnsignedLong& r) { // 8i
  UnsignedLong num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator %   (UnsignedLong& l , Long& r) { // 3i
  Long num;
  num.val = (l.val % r.val);
  num.u = (l.u %   r.u);
  return num;
}

// **********************************************************************************************************
Long operator &   (UnsignedLong& l , Long& r) { // 3i
  Long num;
  num.val = (l.val & r.val);
  num.u = (l.u &   r.u);
  return num;
}

// **********************************************************************************************************
Long operator ^   (UnsignedLong& l , Long& r) { // 3i
  Long num;
  num.val = (l.val ^ r.val);
  num.u = (l.u ^   r.u);
  return num;
}

// **********************************************************************************************************
Long operator |   (UnsignedLong& l , Long& r) { // 3i
  Long num;
  num.val = (l.val | r.val);
  num.u = (l.u |   r.u);
  return num;
}

// **********************************************************************************************************
Long operator <<  (UnsignedLong& l , Long& r) { // 3i
  Long num;
  num.val = (l.val << r.val);
  num.u = (l.u <<  r.u);
  return num;
}

// **********************************************************************************************************
Long operator >>  (UnsignedLong& l , Long& r) { // 3i
  Long num;
  num.val = (l.val >> r.val);
  num.u = (l.u >>  r.u);
  return num;
}

// **********************************************************************************************************
Long operator %=  (UnsignedLong& l , Long& r) { // 3i
  Long num;
  num.val = (l.val %= r.val);
  num.u = (l.u %=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator &=  (UnsignedLong& l , Long& r) { // 3i
  Long num;
  num.val = (l.val &= r.val);
  num.u = (l.u &=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator |=  (UnsignedLong& l , Long& r) { // 3i
  Long num;
  num.val = (l.val |= r.val);
  num.u = (l.u |=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator ^=  (UnsignedLong& l , Long& r) { // 3i
  Long num;
  num.val = (l.val ^= r.val);
  num.u = (l.u ^=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator <<= (UnsignedLong& l , Long& r) { // 3i
  Long num;
  num.val = (l.val <<= r.val);
  num.u = (l.u <<= r.u);
  return num;
}

// **********************************************************************************************************
Long operator >>= (UnsignedLong& l , Long& r) { // 3i
  Long num;
  num.val = (l.val >>= r.val);
  num.u = (l.u >>= r.u);
  return num;
}

// **********************************************************************************************************
Long operator %   (UnsignedLong& l , long& r) { // 6i
  Long num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator %   (unsigned long& l , Long& r) { // 8i
  Long num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator &   (UnsignedLong& l , long& r) { // 6i
  Long num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator &   (unsigned long& l , Long& r) { // 8i
  Long num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator ^   (UnsignedLong& l , long& r) { // 6i
  Long num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator ^   (unsigned long& l , Long& r) { // 8i
  Long num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator |   (UnsignedLong& l , long& r) { // 6i
  Long num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator |   (unsigned long& l , Long& r) { // 8i
  Long num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator <<  (UnsignedLong& l , long& r) { // 6i
  Long num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator <<  (unsigned long& l , Long& r) { // 8i
  Long num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator >>  (UnsignedLong& l , long& r) { // 6i
  Long num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator >>  (unsigned long& l , Long& r) { // 8i
  Long num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator %=  (UnsignedLong& l , long& r) { // 6i
  Long num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator %=  (unsigned long& l , Long& r) { // 8i
  Long num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator &=  (UnsignedLong& l , long& r) { // 6i
  Long num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator &=  (unsigned long& l , Long& r) { // 8i
  Long num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator |=  (UnsignedLong& l , long& r) { // 6i
  Long num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator |=  (unsigned long& l , Long& r) { // 8i
  Long num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator ^=  (UnsignedLong& l , long& r) { // 6i
  Long num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator ^=  (unsigned long& l , Long& r) { // 8i
  Long num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator <<= (UnsignedLong& l , long& r) { // 6i
  Long num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator <<= (unsigned long& l , Long& r) { // 8i
  Long num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator >>= (UnsignedLong& l , long& r) { // 6i
  Long num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator >>= (unsigned long& l , Long& r) { // 8i
  Long num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
UnsignedLong UnsignedLong::operator ++(void) { // 1p, Prefix operator
   ++val;
  return *this;
}

// **********************************************************************************************************
UnsignedLong UnsignedLong::operator --(void) { // 1p, Prefix operator
   --val;
  assert(val>=1);
  return *this;
}

// **********************************************************************************************************
UnsignedLong UnsignedLong::operator ++(int) { // 1p, Postfix operator
   val++;
  return *this;
}

// **********************************************************************************************************
UnsignedLong UnsignedLong::operator --(int) { // 1p, Postfix operator
  assert(val>=1);
   val--;
  return *this;
}

// *********************************************************************************************************
// First class Long constructor
// *********************************************************************************************************
Long::Long() {
  val=0;
  state=UNDEF;
  u.init();
}
// *********************************************************************************************************
// Second class Long constructor
// *********************************************************************************************************
Long::Long(char* str) {
  val=0;
  state=UNDEF;
  u.init(str);
}
// *********************************************************************************************************
// First class Long destructor
// *********************************************************************************************************
Long::~Long() {
  val=0;
  state=UNDEF;
  u.init();
}
// **********************************************************************************************************
Long operator +   (Long& l , UnsignedChar& r) { // 3a
  Long num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
Long operator -   (Long& l , UnsignedChar& r) { // 3a
  Long num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
Long operator *   (Long& l , UnsignedChar& r) { // 3a
  Long num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
Long operator /   (Long& l , UnsignedChar& r) { // 3a
  Long num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
Long operator +=  (Long& l , UnsignedChar& r) { // 3a
  Long num;
  num.val = (long)(l.val += (long)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator -=  (Long& l , UnsignedChar& r) { // 3a
  Long num;
  num.val = (long)(l.val -= (long)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator *=  (Long& l , UnsignedChar& r) { // 3a
  Long num;
  num.val = (long)(l.val *= (long)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator /=  (Long& l , UnsignedChar& r) { // 3a
  Long num;
  num.val = (long)(l.val /= (long)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator +   (Long& l , unsigned char& r) {   // 6a
  Long num;
  num.val = (l.val + (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator +   (long& l , UnsignedChar& r) {   // 8a
  Long num;
  num.val = (l + (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator -   (Long& l , unsigned char& r) {   // 6a
  Long num;
  num.val = (l.val - (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator -   (long& l , UnsignedChar& r) {   // 8a
  Long num;
  num.val = (l - (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator *   (Long& l , unsigned char& r) {   // 6a
  Long num;
  num.val = (l.val * (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator *   (long& l , UnsignedChar& r) {   // 8a
  Long num;
  num.val = (l * (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator /   (Long& l , unsigned char& r) {   // 6a
  Long num;
  num.val = (l.val / (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator /   (long& l , UnsignedChar& r) {   // 8a
  Long num;
  num.val = (l / (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator +=  (Long& l , unsigned char& r) {   // 6a
  Long num;
  num.val = (long)(l.val += (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator +=  (long& l , UnsignedChar& r) {   // 8a
  Long num;
  num.val = (long)(l += (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator -=  (Long& l , unsigned char& r) {   // 6a
  Long num;
  num.val = (long)(l.val -= (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator -=  (long& l , UnsignedChar& r) {   // 8a
  Long num;
  num.val = (long)(l -= (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator *=  (Long& l , unsigned char& r) {   // 6a
  Long num;
  num.val = (long)(l.val *= (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator *=  (long& l , UnsignedChar& r) {   // 8a
  Long num;
  num.val = (long)(l *= (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator /=  (Long& l , unsigned char& r) {   // 6a
  Long num;
  num.val = (long)(l.val /= (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator /=  (long& l , UnsignedChar& r) {   // 8a
  Long num;
  num.val = (long)(l /= (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator +   (Long& l , Char& r) { // 3a
  Long num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
Long operator -   (Long& l , Char& r) { // 3a
  Long num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
Long operator *   (Long& l , Char& r) { // 3a
  Long num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
Long operator /   (Long& l , Char& r) { // 3a
  Long num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
Long operator +=  (Long& l , Char& r) { // 3a
  Long num;
  num.val = (long)(l.val += (long)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator -=  (Long& l , Char& r) { // 3a
  Long num;
  num.val = (long)(l.val -= (long)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator *=  (Long& l , Char& r) { // 3a
  Long num;
  num.val = (long)(l.val *= (long)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator /=  (Long& l , Char& r) { // 3a
  Long num;
  num.val = (long)(l.val /= (long)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator +   (Long& l , char& r) {   // 6a
  Long num;
  num.val = (l.val + (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator +   (long& l , Char& r) {   // 8a
  Long num;
  num.val = (l + (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator -   (Long& l , char& r) {   // 6a
  Long num;
  num.val = (l.val - (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator -   (long& l , Char& r) {   // 8a
  Long num;
  num.val = (l - (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator *   (Long& l , char& r) {   // 6a
  Long num;
  num.val = (l.val * (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator *   (long& l , Char& r) {   // 8a
  Long num;
  num.val = (l * (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator /   (Long& l , char& r) {   // 6a
  Long num;
  num.val = (l.val / (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator /   (long& l , Char& r) {   // 8a
  Long num;
  num.val = (l / (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator +=  (Long& l , char& r) {   // 6a
  Long num;
  num.val = (long)(l.val += (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator +=  (long& l , Char& r) {   // 8a
  Long num;
  num.val = (long)(l += (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator -=  (Long& l , char& r) {   // 6a
  Long num;
  num.val = (long)(l.val -= (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator -=  (long& l , Char& r) {   // 8a
  Long num;
  num.val = (long)(l -= (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator *=  (Long& l , char& r) {   // 6a
  Long num;
  num.val = (long)(l.val *= (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator *=  (long& l , Char& r) {   // 8a
  Long num;
  num.val = (long)(l *= (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator /=  (Long& l , char& r) {   // 6a
  Long num;
  num.val = (long)(l.val /= (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator /=  (long& l , Char& r) {   // 8a
  Long num;
  num.val = (long)(l /= (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator +   (Long& l , UnsignedShort& r) { // 3a
  Long num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
Long operator -   (Long& l , UnsignedShort& r) { // 3a
  Long num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
Long operator *   (Long& l , UnsignedShort& r) { // 3a
  Long num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
Long operator /   (Long& l , UnsignedShort& r) { // 3a
  Long num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
Long operator +=  (Long& l , UnsignedShort& r) { // 3a
  Long num;
  num.val = (long)(l.val += (long)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator -=  (Long& l , UnsignedShort& r) { // 3a
  Long num;
  num.val = (long)(l.val -= (long)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator *=  (Long& l , UnsignedShort& r) { // 3a
  Long num;
  num.val = (long)(l.val *= (long)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator /=  (Long& l , UnsignedShort& r) { // 3a
  Long num;
  num.val = (long)(l.val /= (long)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator +   (Long& l , unsigned short& r) {   // 6a
  Long num;
  num.val = (l.val + (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator +   (long& l , UnsignedShort& r) {   // 8a
  Long num;
  num.val = (l + (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator -   (Long& l , unsigned short& r) {   // 6a
  Long num;
  num.val = (l.val - (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator -   (long& l , UnsignedShort& r) {   // 8a
  Long num;
  num.val = (l - (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator *   (Long& l , unsigned short& r) {   // 6a
  Long num;
  num.val = (l.val * (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator *   (long& l , UnsignedShort& r) {   // 8a
  Long num;
  num.val = (l * (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator /   (Long& l , unsigned short& r) {   // 6a
  Long num;
  num.val = (l.val / (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator /   (long& l , UnsignedShort& r) {   // 8a
  Long num;
  num.val = (l / (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator +=  (Long& l , unsigned short& r) {   // 6a
  Long num;
  num.val = (long)(l.val += (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator +=  (long& l , UnsignedShort& r) {   // 8a
  Long num;
  num.val = (long)(l += (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator -=  (Long& l , unsigned short& r) {   // 6a
  Long num;
  num.val = (long)(l.val -= (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator -=  (long& l , UnsignedShort& r) {   // 8a
  Long num;
  num.val = (long)(l -= (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator *=  (Long& l , unsigned short& r) {   // 6a
  Long num;
  num.val = (long)(l.val *= (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator *=  (long& l , UnsignedShort& r) {   // 8a
  Long num;
  num.val = (long)(l *= (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator /=  (Long& l , unsigned short& r) {   // 6a
  Long num;
  num.val = (long)(l.val /= (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator /=  (long& l , UnsignedShort& r) {   // 8a
  Long num;
  num.val = (long)(l /= (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator +   (Long& l , Short& r) { // 3a
  Long num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
Long operator -   (Long& l , Short& r) { // 3a
  Long num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
Long operator *   (Long& l , Short& r) { // 3a
  Long num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
Long operator /   (Long& l , Short& r) { // 3a
  Long num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
Long operator +=  (Long& l , Short& r) { // 3a
  Long num;
  num.val = (long)(l.val += (long)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator -=  (Long& l , Short& r) { // 3a
  Long num;
  num.val = (long)(l.val -= (long)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator *=  (Long& l , Short& r) { // 3a
  Long num;
  num.val = (long)(l.val *= (long)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator /=  (Long& l , Short& r) { // 3a
  Long num;
  num.val = (long)(l.val /= (long)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator +   (Long& l , short& r) {   // 6a
  Long num;
  num.val = (l.val + (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator +   (long& l , Short& r) {   // 8a
  Long num;
  num.val = (l + (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator -   (Long& l , short& r) {   // 6a
  Long num;
  num.val = (l.val - (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator -   (long& l , Short& r) {   // 8a
  Long num;
  num.val = (l - (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator *   (Long& l , short& r) {   // 6a
  Long num;
  num.val = (l.val * (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator *   (long& l , Short& r) {   // 8a
  Long num;
  num.val = (l * (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator /   (Long& l , short& r) {   // 6a
  Long num;
  num.val = (l.val / (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator /   (long& l , Short& r) {   // 8a
  Long num;
  num.val = (l / (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator +=  (Long& l , short& r) {   // 6a
  Long num;
  num.val = (long)(l.val += (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator +=  (long& l , Short& r) {   // 8a
  Long num;
  num.val = (long)(l += (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator -=  (Long& l , short& r) {   // 6a
  Long num;
  num.val = (long)(l.val -= (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator -=  (long& l , Short& r) {   // 8a
  Long num;
  num.val = (long)(l -= (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator *=  (Long& l , short& r) {   // 6a
  Long num;
  num.val = (long)(l.val *= (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator *=  (long& l , Short& r) {   // 8a
  Long num;
  num.val = (long)(l *= (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator /=  (Long& l , short& r) {   // 6a
  Long num;
  num.val = (long)(l.val /= (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator /=  (long& l , Short& r) {   // 8a
  Long num;
  num.val = (long)(l /= (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator +   (Long& l , UnsignedInt& r) { // 3a
  Long num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
Long operator -   (Long& l , UnsignedInt& r) { // 3a
  Long num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
Long operator *   (Long& l , UnsignedInt& r) { // 3a
  Long num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
Long operator /   (Long& l , UnsignedInt& r) { // 3a
  Long num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
Long operator +=  (Long& l , UnsignedInt& r) { // 3a
  Long num;
  num.val = (long)(l.val += (long)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator -=  (Long& l , UnsignedInt& r) { // 3a
  Long num;
  num.val = (long)(l.val -= (long)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator *=  (Long& l , UnsignedInt& r) { // 3a
  Long num;
  num.val = (long)(l.val *= (long)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator /=  (Long& l , UnsignedInt& r) { // 3a
  Long num;
  num.val = (long)(l.val /= (long)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator +   (Long& l , unsigned int& r) {   // 6a
  Long num;
  num.val = (l.val + (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator +   (long& l , UnsignedInt& r) {   // 8a
  Long num;
  num.val = (l + (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator -   (Long& l , unsigned int& r) {   // 6a
  Long num;
  num.val = (l.val - (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator -   (long& l , UnsignedInt& r) {   // 8a
  Long num;
  num.val = (l - (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator *   (Long& l , unsigned int& r) {   // 6a
  Long num;
  num.val = (l.val * (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator *   (long& l , UnsignedInt& r) {   // 8a
  Long num;
  num.val = (l * (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator /   (Long& l , unsigned int& r) {   // 6a
  Long num;
  num.val = (l.val / (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator /   (long& l , UnsignedInt& r) {   // 8a
  Long num;
  num.val = (l / (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator +=  (Long& l , unsigned int& r) {   // 6a
  Long num;
  num.val = (long)(l.val += (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator +=  (long& l , UnsignedInt& r) {   // 8a
  Long num;
  num.val = (long)(l += (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator -=  (Long& l , unsigned int& r) {   // 6a
  Long num;
  num.val = (long)(l.val -= (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator -=  (long& l , UnsignedInt& r) {   // 8a
  Long num;
  num.val = (long)(l -= (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator *=  (Long& l , unsigned int& r) {   // 6a
  Long num;
  num.val = (long)(l.val *= (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator *=  (long& l , UnsignedInt& r) {   // 8a
  Long num;
  num.val = (long)(l *= (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator /=  (Long& l , unsigned int& r) {   // 6a
  Long num;
  num.val = (long)(l.val /= (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator /=  (long& l , UnsignedInt& r) {   // 8a
  Long num;
  num.val = (long)(l /= (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator +   (Long& l , Int& r) { // 3a
  Long num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
Long operator -   (Long& l , Int& r) { // 3a
  Long num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
Long operator *   (Long& l , Int& r) { // 3a
  Long num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
Long operator /   (Long& l , Int& r) { // 3a
  Long num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
Long operator +=  (Long& l , Int& r) { // 3a
  Long num;
  num.val = (long)(l.val += (long)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator -=  (Long& l , Int& r) { // 3a
  Long num;
  num.val = (long)(l.val -= (long)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator *=  (Long& l , Int& r) { // 3a
  Long num;
  num.val = (long)(l.val *= (long)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator /=  (Long& l , Int& r) { // 3a
  Long num;
  num.val = (long)(l.val /= (long)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator +   (Long& l , int& r) {   // 6a
  Long num;
  num.val = (l.val + (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator +   (long& l , Int& r) {   // 8a
  Long num;
  num.val = (l + (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator -   (Long& l , int& r) {   // 6a
  Long num;
  num.val = (l.val - (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator -   (long& l , Int& r) {   // 8a
  Long num;
  num.val = (l - (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator *   (Long& l , int& r) {   // 6a
  Long num;
  num.val = (l.val * (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator *   (long& l , Int& r) {   // 8a
  Long num;
  num.val = (l * (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator /   (Long& l , int& r) {   // 6a
  Long num;
  num.val = (l.val / (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator /   (long& l , Int& r) {   // 8a
  Long num;
  num.val = (l / (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator +=  (Long& l , int& r) {   // 6a
  Long num;
  num.val = (long)(l.val += (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator +=  (long& l , Int& r) {   // 8a
  Long num;
  num.val = (long)(l += (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator -=  (Long& l , int& r) {   // 6a
  Long num;
  num.val = (long)(l.val -= (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator -=  (long& l , Int& r) {   // 8a
  Long num;
  num.val = (long)(l -= (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator *=  (Long& l , int& r) {   // 6a
  Long num;
  num.val = (long)(l.val *= (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator *=  (long& l , Int& r) {   // 8a
  Long num;
  num.val = (long)(l *= (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator /=  (Long& l , int& r) {   // 6a
  Long num;
  num.val = (long)(l.val /= (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator /=  (long& l , Int& r) {   // 8a
  Long num;
  num.val = (long)(l /= (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator +   (Long& l , UnsignedLong& r) { // 3a
  Long num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
Long operator -   (Long& l , UnsignedLong& r) { // 3a
  Long num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
Long operator *   (Long& l , UnsignedLong& r) { // 3a
  Long num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
Long operator /   (Long& l , UnsignedLong& r) { // 3a
  Long num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
Long operator +=  (Long& l , UnsignedLong& r) { // 3a
  Long num;
  num.val = (long)(l.val += (long)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator -=  (Long& l , UnsignedLong& r) { // 3a
  Long num;
  num.val = (long)(l.val -= (long)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator *=  (Long& l , UnsignedLong& r) { // 3a
  Long num;
  num.val = (long)(l.val *= (long)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator /=  (Long& l , UnsignedLong& r) { // 3a
  Long num;
  num.val = (long)(l.val /= (long)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator +   (Long& l , unsigned long& r) {   // 6a
  Long num;
  num.val = (l.val + (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator +   (long& l , UnsignedLong& r) {   // 8a
  Long num;
  num.val = (l + (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator -   (Long& l , unsigned long& r) {   // 6a
  Long num;
  num.val = (l.val - (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator -   (long& l , UnsignedLong& r) {   // 8a
  Long num;
  num.val = (l - (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator *   (Long& l , unsigned long& r) {   // 6a
  Long num;
  num.val = (l.val * (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator *   (long& l , UnsignedLong& r) {   // 8a
  Long num;
  num.val = (l * (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator /   (Long& l , unsigned long& r) {   // 6a
  Long num;
  num.val = (l.val / (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator /   (long& l , UnsignedLong& r) {   // 8a
  Long num;
  num.val = (l / (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator +=  (Long& l , unsigned long& r) {   // 6a
  Long num;
  num.val = (long)(l.val += (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator +=  (long& l , UnsignedLong& r) {   // 8a
  Long num;
  num.val = (long)(l += (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator -=  (Long& l , unsigned long& r) {   // 6a
  Long num;
  num.val = (long)(l.val -= (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator -=  (long& l , UnsignedLong& r) {   // 8a
  Long num;
  num.val = (long)(l -= (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator *=  (Long& l , unsigned long& r) {   // 6a
  Long num;
  num.val = (long)(l.val *= (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator *=  (long& l , UnsignedLong& r) {   // 8a
  Long num;
  num.val = (long)(l *= (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator /=  (Long& l , unsigned long& r) {   // 6a
  Long num;
  num.val = (long)(l.val /= (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator /=  (long& l , UnsignedLong& r) {   // 8a
  Long num;
  num.val = (long)(l /= (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long Long::operator +   (Long& r) { // 1a
  Long num;
  num.val = (val + r.val);
  num.u = (u +   r.u);
  return num;
}

// **********************************************************************************************************
Long Long::operator -   (Long& r) { // 1a
  Long num;
  num.val = (val - r.val);
  num.u = (u -   r.u);
  return num;
}

// **********************************************************************************************************
Long Long::operator *   (Long& r) { // 1a
  Long num;
  num.val = (val * r.val);
  num.u = (u *   r.u);
  return num;
}

// **********************************************************************************************************
Long Long::operator /   (Long& r) { // 1a
  Long num;
  num.val = (val / r.val);
  num.u = (u /   r.u);
  return num;
}

// **********************************************************************************************************
Long Long::operator +=  (Long& r) { // 1a
  Long num;
  num.val = (val += r.val);
  num.u = (u +=  r.u);
  return num;
}

// **********************************************************************************************************
Long Long::operator -=  (Long& r) { // 1a
  Long num;
  num.val = (val -= r.val);
  num.u = (u -=  r.u);
  return num;
}

// **********************************************************************************************************
Long Long::operator *=  (Long& r) { // 1a
  Long num;
  num.val = (val *= r.val);
  num.u = (u *=  r.u);
  return num;
}

// **********************************************************************************************************
Long Long::operator /=  (Long& r) { // 1a
  Long num;
  num.val = (val /= r.val);
  num.u = (u /=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator +   (Long& l , long& r) {   // 6a
  Long num;
  num.val = (l.val + r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator +   (long& l , Long& r) {   // 8a
  Long num;
  num.val = (l + r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator -   (Long& l , long& r) {   // 6a
  Long num;
  num.val = (l.val - r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator -   (long& l , Long& r) {   // 8a
  Long num;
  num.val = (l - r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator *   (Long& l , long& r) {   // 6a
  Long num;
  num.val = (l.val * r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator *   (long& l , Long& r) {   // 8a
  Long num;
  num.val = (l * r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator /   (Long& l , long& r) {   // 6a
  Long num;
  num.val = (l.val / r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator /   (long& l , Long& r) {   // 8a
  Long num;
  num.val = (l / r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator +=  (Long& l , long& r) {   // 6a
  Long num;
  num.val = (long)(l.val += (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator +=  (long& l , Long& r) {   // 8a
  Long num;
  num.val = (long)(l += (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator -=  (Long& l , long& r) {   // 6a
  Long num;
  num.val = (long)(l.val -= (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator -=  (long& l , Long& r) {   // 8a
  Long num;
  num.val = (long)(l -= (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator *=  (Long& l , long& r) {   // 6a
  Long num;
  num.val = (long)(l.val *= (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator *=  (long& l , Long& r) {   // 8a
  Long num;
  num.val = (long)(l *= (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator /=  (Long& l , long& r) {   // 6a
  Long num;
  num.val = (long)(l.val /= (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator /=  (long& l , Long& r) {   // 8a
  Long num;
  num.val = (long)(l /= (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator +   (Long& l , Float& r) { // 3a
  Float num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
Float operator -   (Long& l , Float& r) { // 3a
  Float num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
Float operator *   (Long& l , Float& r) { // 3a
  Float num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
Float operator /   (Long& l , Float& r) { // 3a
  Float num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
Float operator +=  (Long& l , Float& r) { // 3a
  Float num;
  num.val = (float)(l.val += (long)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
Float operator -=  (Long& l , Float& r) { // 3a
  Float num;
  num.val = (float)(l.val -= (long)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
Float operator *=  (Long& l , Float& r) { // 3a
  Float num;
  num.val = (float)(l.val *= (long)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
Float operator /=  (Long& l , Float& r) { // 3a
  Float num;
  num.val = (float)(l.val /= (long)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
Float operator +   (Long& l , float& r) {   // 6a
  Float num;
  num.val = ((float)l.val + r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator +   (long& l , Float& r) {   // 8a
  Float num;
  num.val = ((float)l + r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator -   (Long& l , float& r) {   // 6a
  Float num;
  num.val = ((float)l.val - r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator -   (long& l , Float& r) {   // 8a
  Float num;
  num.val = ((float)l - r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator *   (Long& l , float& r) {   // 6a
  Float num;
  num.val = ((float)l.val * r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator *   (long& l , Float& r) {   // 8a
  Float num;
  num.val = ((float)l * r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator /   (Long& l , float& r) {   // 6a
  Float num;
  num.val = ((float)l.val / r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator /   (long& l , Float& r) {   // 8a
  Float num;
  num.val = ((float)l / r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator +=  (Long& l , float& r) {   // 6a
  Float num;
  num.val = (float)(l.val += (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator +=  (long& l , Float& r) {   // 8a
  Float num;
  num.val = (float)(l += (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator -=  (Long& l , float& r) {   // 6a
  Float num;
  num.val = (float)(l.val -= (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator -=  (long& l , Float& r) {   // 8a
  Float num;
  num.val = (float)(l -= (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator *=  (Long& l , float& r) {   // 6a
  Float num;
  num.val = (float)(l.val *= (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator *=  (long& l , Float& r) {   // 8a
  Float num;
  num.val = (float)(l *= (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Float operator /=  (Long& l , float& r) {   // 6a
  Float num;
  num.val = (float)(l.val /= (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Float operator /=  (long& l , Float& r) {   // 8a
  Float num;
  num.val = (float)(l /= (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator +   (Long& l , Double& r) { // 3a
  Double num;
  num.val = (l.val + r.val);
  num.u = (l.u +   r.u);
  return num;
}

// **********************************************************************************************************
Double operator -   (Long& l , Double& r) { // 3a
  Double num;
  num.val = (l.val - r.val);
  num.u = (l.u -   r.u);
  return num;
}

// **********************************************************************************************************
Double operator *   (Long& l , Double& r) { // 3a
  Double num;
  num.val = (l.val * r.val);
  num.u = (l.u *   r.u);
  return num;
}

// **********************************************************************************************************
Double operator /   (Long& l , Double& r) { // 3a
  Double num;
  num.val = (l.val / r.val);
  num.u = (l.u /   r.u);
  return num;
}

// **********************************************************************************************************
Double operator +=  (Long& l , Double& r) { // 3a
  Double num;
  num.val = (double)(l.val += (long)r.val);
  num.u = (l.u +=  r.u);
  return num;
}

// **********************************************************************************************************
Double operator -=  (Long& l , Double& r) { // 3a
  Double num;
  num.val = (double)(l.val -= (long)r.val);
  num.u = (l.u -=  r.u);
  return num;
}

// **********************************************************************************************************
Double operator *=  (Long& l , Double& r) { // 3a
  Double num;
  num.val = (double)(l.val *= (long)r.val);
  num.u = (l.u *=  r.u);
  return num;
}

// **********************************************************************************************************
Double operator /=  (Long& l , Double& r) { // 3a
  Double num;
  num.val = (double)(l.val /= (long)r.val);
  num.u = (l.u /=  r.u);
  return num;
}

// **********************************************************************************************************
Double operator +   (Long& l , double& r) {   // 6a
  Double num;
  num.val = ((double)l.val + r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator +   (long& l , Double& r) {   // 8a
  Double num;
  num.val = ((double)l + r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator -   (Long& l , double& r) {   // 6a
  Double num;
  num.val = ((double)l.val - r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator -   (long& l , Double& r) {   // 8a
  Double num;
  num.val = ((double)l - r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator *   (Long& l , double& r) {   // 6a
  Double num;
  num.val = ((double)l.val * r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator *   (long& l , Double& r) {   // 8a
  Double num;
  num.val = ((double)l * r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator /   (Long& l , double& r) {   // 6a
  Double num;
  num.val = ((double)l.val / r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator /   (long& l , Double& r) {   // 8a
  Double num;
  num.val = ((double)l / r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator +=  (Long& l , double& r) {   // 6a
  Double num;
  num.val = (double)(l.val += (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator +=  (long& l , Double& r) {   // 8a
  Double num;
  num.val = (double)(l += (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator -=  (Long& l , double& r) {   // 6a
  Double num;
  num.val = (double)(l.val -= (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator -=  (long& l , Double& r) {   // 8a
  Double num;
  num.val = (double)(l -= (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator *=  (Long& l , double& r) {   // 6a
  Double num;
  num.val = (double)(l.val *= (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator *=  (long& l , Double& r) {   // 8a
  Double num;
  num.val = (double)(l *= (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Double operator /=  (Long& l , double& r) {   // 6a
  Double num;
  num.val = (double)(l.val /= (long)r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Double operator /=  (long& l , Double& r) {   // 8a
  Double num;
  num.val = (double)(l /= (long)r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator %   (Long& l , UnsignedChar& r) { // 3i
  Long num;
  num.val = (l.val % r.val);
  num.u = (l.u %   r.u);
  return num;
}

// **********************************************************************************************************
Long operator &   (Long& l , UnsignedChar& r) { // 3i
  Long num;
  num.val = (l.val & r.val);
  num.u = (l.u &   r.u);
  return num;
}

// **********************************************************************************************************
Long operator ^   (Long& l , UnsignedChar& r) { // 3i
  Long num;
  num.val = (l.val ^ r.val);
  num.u = (l.u ^   r.u);
  return num;
}

// **********************************************************************************************************
Long operator |   (Long& l , UnsignedChar& r) { // 3i
  Long num;
  num.val = (l.val | r.val);
  num.u = (l.u |   r.u);
  return num;
}

// **********************************************************************************************************
Long operator <<  (Long& l , UnsignedChar& r) { // 3i
  Long num;
  num.val = (l.val << r.val);
  num.u = (l.u <<  r.u);
  return num;
}

// **********************************************************************************************************
Long operator >>  (Long& l , UnsignedChar& r) { // 3i
  Long num;
  num.val = (l.val >> r.val);
  num.u = (l.u >>  r.u);
  return num;
}

// **********************************************************************************************************
Long operator %=  (Long& l , UnsignedChar& r) { // 3i
  Long num;
  num.val = (l.val %= r.val);
  num.u = (l.u %=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator &=  (Long& l , UnsignedChar& r) { // 3i
  Long num;
  num.val = (l.val &= r.val);
  num.u = (l.u &=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator |=  (Long& l , UnsignedChar& r) { // 3i
  Long num;
  num.val = (l.val |= r.val);
  num.u = (l.u |=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator ^=  (Long& l , UnsignedChar& r) { // 3i
  Long num;
  num.val = (l.val ^= r.val);
  num.u = (l.u ^=  r.u);
  return num;
}

// **********************************************************************************************************
Long operator <<= (Long& l , UnsignedChar& r) { // 3i
  Long num;
  num.val = (l.val <<= r.val);
  num.u = (l.u <<= r.u);
  return num;
}

// **********************************************************************************************************
Long operator >>= (Long& l , UnsignedChar& r) { // 3i
  Long num;
  num.val = (l.val >>= r.val);
  num.u = (l.u >>= r.u);
  return num;
}

// **********************************************************************************************************
Long operator %   (Long& l , unsigned char& r) { // 6i
  Long num;
  num.val = (l.val % r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator %   (long& l , UnsignedChar& r) { // 8i
  Long num;
  num.val = (l % r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator &   (Long& l , unsigned char& r) { // 6i
  Long num;
  num.val = (l.val & r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator &   (long& l , UnsignedChar& r) { // 8i
  Long num;
  num.val = (l & r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator ^   (Long& l , unsigned char& r) { // 6i
  Long num;
  num.val = (l.val ^ r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator ^   (long& l , UnsignedChar& r) { // 8i
  Long num;
  num.val = (l ^ r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator |   (Long& l , unsigned char& r) { // 6i
  Long num;
  num.val = (l.val | r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator |   (long& l , UnsignedChar& r) { // 8i
  Long num;
  num.val = (l | r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator <<  (Long& l , unsigned char& r) { // 6i
  Long num;
  num.val = (l.val << r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator <<  (long& l , UnsignedChar& r) { // 8i
  Long num;
  num.val = (l << r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator >>  (Long& l , unsigned char& r) { // 6i
  Long num;
  num.val = (l.val >> r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator >>  (long& l , UnsignedChar& r) { // 8i
  Long num;
  num.val = (l >> r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator %=  (Long& l , unsigned char& r) { // 6i
  Long num;
  num.val = (l.val %= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator %=  (long& l , UnsignedChar& r) { // 8i
  Long num;
  num.val = (l %= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator &=  (Long& l , unsigned char& r) { // 6i
  Long num;
  num.val = (l.val &= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator &=  (long& l , UnsignedChar& r) { // 8i
  Long num;
  num.val = (l &= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator |=  (Long& l , unsigned char& r) { // 6i
  Long num;
  num.val = (l.val |= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator |=  (long& l , UnsignedChar& r) { // 8i
  Long num;
  num.val = (l |= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator ^=  (Long& l , unsigned char& r) { // 6i
  Long num;
  num.val = (l.val ^= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator ^=  (long& l , UnsignedChar& r) { // 8i
  Long num;
  num.val = (l ^= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator <<= (Long& l , unsigned char& r) { // 6i
  Long num;
  num.val = (l.val <<= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator <<= (long& l , UnsignedChar& r) { // 8i
  Long num;
  num.val = (l <<= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator >>= (Long& l , unsigned char& r) { // 6i
  Long num;
  num.val = (l.val >>= r);
  num.u = l.u;
  return num;
}

// **********************************************************************************************************
Long operator >>= (long& l , UnsignedChar& r) { // 8i
  Long num;
  num.val = (l >>= r.val);
  num.u = r.u;
  return num;
}

// **********************************************************************************************************
Long operator %   (Long& l , Char& r) { // 3i
  Long num;
  num.val = (l.val % r.val);
  num.u = (l.u %   r.u);
  return num;
}

// **********************************************************************************************************
Long operator &   (Long& l , Char& r) { // 3i
  Long num;
  num.val = (l.val & r.val);
  num.u = (l.u &   r.u);
  return num;
}

// **********************************************************************************************************
Long operator ^   (Long& l , Char& r) { // 3i
  Long num;
  num.val = (l.val ^ r.val);
  num.u = (l.u ^   r.u);
  return num;
}

// **********************************************************************************************************
Long operator |   (Long& l , Char& r) { // 3i
  Long num;
  num.val = (l.val | r.val);
  num.u = (l.u |   r.u);
  return num;
}

// **********************************************************************************************************
Long operator <<  (L