int BitAnd(int a, int b) {
     int p = 1;
     int result = 0;
     for (int i = 0) {
         int x = a / 2;
         int y = b / 2;
         if a - x - x == 1 && b - y - y == 1 {
             result += p;
         }
         exitwhen i == 31;
         i++;
         p += p;
         a = x;
         b = y;
     }
     return result;
}

function BitwiseXOR takes integer Value1, integer Value2 returns integer

  local integer Index
  local integer ResultValue
  local integer array Byte1
  local integer array Byte2
  local integer array ResultByte

  //Convert Value1 to a Byte
  set Index = 8
  loop

    set Index = Index - 1
    set Byte1[Index] = ModuloInteger(Value1, 2)
    set Value1 = Value1 / 2
    exitwhen Index <= 0

  endloop

  //Convert Value2 to a Byte
  set Index = 8
  loop

    set Index = Index - 1
    set Byte2[Index] = ModuloInteger(Value2, 2)
    set Value2 = Value2 / 2
    exitwhen Index <= 0

  endloop

  //Makes a bitwise XOR on the Bytes
  set Index = 0
  loop
    if (Byte1[Index] == Byte2[Index]) then
      set ResultByte[Index] = 0
    else
      set ResultByte[Index] = 1
    endif
    set Index = Index + 1
    exitwhen Index >= 8

  endloop

  //Convert the resulting Byte back to an integer
  set Index = 0
  set ResultValue = 0
  loop

    set ResultValue = ResultValue * 2
    set ResultValue = ResultValue + ResultByte[Index]
    set Index = Index + 1
    exitwhen Index >= 8

  endloop

  return ResultValue

endfunction

library BitOperations initializer Init
      globals
          // Warcraft 3 uses 32-bit signed integers.
          private constant integer       BITS_IN_INTEGER = 32
            
          private          integer array Pow2[BITS_IN_INTEGER]
      endglobals

      // BitwiseNot(a) = ~a in C++
      function BitwiseNot takes integer a returns integer
          return -1-x
      endfunction
        
      // LeftShift(a,bitCount) = a << bitCount in C++
      function LeftShift takes integer a, integer bitCount returns integer
          return a*Pow2[bitCount]
      endfunction
        
      // RightShift(a,bitCount) = a >> bitCount in C++
      function RightShift takes integer a, integer bitCount returns integer
          return a/Pow2[bitCount]
      endfunction
        
      // BitwiseAnd(a,b) = a&b in C++
      function BitwiseAnd takes integer a, integer b returns integer
          local integer aBit     // Bit of a;
          local integer bBit     // Bit of b;
          local integer rBit     // Bit of result
          local integer r    = 0 // result
            
          loop
              exitwhen i==BITS_IN_INTEGER
              set aBit = ModuloInteger(a, 2)
        set bBit = ModuloInteger(b, 2)
          
        if aBit == 1 and bBit == 1 then
                  set rBit = 1
              else
                  set Bit = 0
              endif   
                
              set r = r + LeftShift(rBit,i)
          
        set a = a / 2
        set b = b / 2
              set i = i + 1
          endloop
            
          return r
      endfunction
        
      // BitwiseOr(a,b) = a|b in C++
      function BitwiseOr takes integer a, integer b returns integer
          local integer aBit     // Bit of a
          local integer bBit     // Bit of b
          local integer rBit     // Bit of result
          local integer r    = 0 // result
            
          loop
              exitwhen i==BITS_IN_INTEGER
              set aBit = ModuloInteger(a, 2)
        set bBit = ModuloInteger(b, 2)
          
        if aBit == 1 or bBit == 1 then
         set rBit = 1
        else
               set rBit = 0
        endif
          
        set r = r + LeftShift(rBit,i)
          
        set a = a / 2
        set b = b / 2
              set i = i + 1
          endloop
            
          return r
      endfunction
        
      // BitwiseXor(a,b) = a^b in C++
      function BitwiseXor takes integer a, integer b returns integer
          local integer aBit     // Bit of a
          local integer bBit     // Bit of b
          local integer rBit     // Bit of result
          local integer r    = 0 // result
            
          loop
              exitwhen i==BITS_IN_INTEGER
              set aBit = ModuloInteger(a, 2)
        set bBit = ModuloInteger(b, 2)
          
        if aBit != bBit then
            set rBit = 1
        else
         set rBit = 0
        endif
          
        set r = r + LeftShift(rBit,i)
          
        set a = a / 2
        set b = b / 2
              set i = i + 1
          endloop
            
          return r
      endfunction

      private function Init takes nothing returns nothing
          local integer i = 1
            
          // Pre-init the power of two array to speed up the system.
          set Pow2[0] = 1
          loop
              exitwhen i > BITS_IN_INTEGER-1
              set Pow2[i] = Pow2[i-1]*2
              set i = i + 1
          endloop      
      endfunction
endlibrary

library Binary initializer InitBinary

globals
   private integer array bintable
   // Offsets:
   // 0x000 = powers of 2 (up to 32)
   // 0x100 = AND
   // 0x200 = OR
   // 0x300 = XOR
endglobals

// just hope it gets inlined in future
function NOT takes integer a returns integer
   return -1 - a
endfunction
// binary operations use lookup tables for 4-bit blocks
function AND takes integer a, integer b returns integer
   local integer ta = a / 16
   local integer tb = b / 16
   local integer x = bintable[0x100 + (a - ta * 16) + (b - tb * 16) * 16]
   set a = ta / 16
   set b = tb / 16
   set x = x + bintable[0x100 + (ta - a * 16) + (tb - b * 16) * 16] * 0x00000010
   set ta = a / 16
   set tb = b / 16
   set x = x + bintable[0x100 + (a - ta * 16) + (b - tb * 16) * 16] * 0x00000100
   set a = ta / 16
   set b = tb / 16
   set x = x + bintable[0x100 + (ta - a * 16) + (tb - b * 16) * 16] * 0x00001000
   set ta = a / 16
   set tb = b / 16
   set x = x + bintable[0x100 + (a - ta * 16) + (b - tb * 16) * 16] * 0x00010000
   set a = ta / 16
   set b = tb / 16
   set x = x + bintable[0x100 + (ta - a * 16) + (tb - b * 16) * 16] * 0x00100000
   set ta = a / 16
   set tb = b / 16
   set x = x + bintable[0x100 + (a - ta * 16) + (b - tb * 16) * 16] * 0x01000000
   set a = ta / 16
   set b = tb / 16
   return x + bintable[0x100 + (ta - a * 16) + (tb - b * 16) * 16] * 0x10000000
endfunction
function OR takes integer a, integer b returns integer
   local integer ta = a / 16
   local integer tb = b / 16
   local integer x = bintable[0x200 + (a - ta * 16) + (b - tb * 16) * 16]
   set a = ta / 16
   set b = tb / 16
   set x = x + bintable[0x200 + (ta - a * 16) + (tb - b * 16) * 16] * 0x00000010
   set ta = a / 16
   set tb = b / 16
   set x = x + bintable[0x200 + (a - ta * 16) + (b - tb * 16) * 16] * 0x00000100
   set a = ta / 16
   set b = tb / 16
   set x = x + bintable[0x200 + (ta - a * 16) + (tb - b * 16) * 16] * 0x00001000
   set ta = a / 16
   set tb = b / 16
   set x = x + bintable[0x200 + (a - ta * 16) + (b - tb * 16) * 16] * 0x00010000
   set a = ta / 16
   set b = tb / 16
   set x = x + bintable[0x200 + (ta - a * 16) + (tb - b * 16) * 16] * 0x00100000
   set ta = a / 16
   set tb = b / 16
   set x = x + bintable[0x200 + (a - ta * 16) + (b - tb * 16) * 16] * 0x01000000
   set a = ta / 16
   set b = tb / 16
   return x + bintable[0x200 + (ta - a * 16) + (tb - b * 16) * 16] * 0x10000000
endfunction
function XOR takes integer a, integer b returns integer
   local integer ta = a / 16
   local integer tb = b / 16
   local integer x = bintable[0x300 + (a - ta * 16) + (b - tb * 16) * 16]
   set a = ta / 16
   set b = tb / 16
   set x = x + bintable[0x300 + (ta - a * 16) + (tb - b * 16) * 16] * 0x00000010
   set ta = a / 16
   set tb = b / 16
   set x = x + bintable[0x300 + (a - ta * 16) + (b - tb * 16) * 16] * 0x00000100
   set a = ta / 16
   set b = tb / 16
   set x = x + bintable[0x300 + (ta - a * 16) + (tb - b * 16) * 16] * 0x00001000
   set ta = a / 16
   set tb = b / 16
   set x = x + bintable[0x300 + (a - ta * 16) + (b - tb * 16) * 16] * 0x00010000
   set a = ta / 16
   set b = tb / 16
   set x = x + bintable[0x300 + (ta - a * 16) + (tb - b * 16) * 16] * 0x00100000
   set ta = a / 16
   set tb = b / 16
   set x = x + bintable[0x300 + (a - ta * 16) + (b - tb * 16) * 16] * 0x01000000
   set a = ta / 16
   set b = tb / 16
   return x + bintable[0x300 + (ta - a * 16) + (tb - b * 16) * 16] * 0x10000000
endfunction
// shift left/right. DO NOT use negative values, this should get inlined as well
function SHL takes integer a, integer b returns integer
   return a * bintable[b]
endfunction
function SHR takes integer a, integer b returns integer
   return a / bintable[b]
endfunction

private function InitBinary takes nothing returns nothing
   local integer i = 0
   local integer a
   local integer b
   local integer ta
   local integer tb
   loop
     exitwhen i >= 256
     set a = i / 16
     set b = i - a * 16
     set ta = a - (a / 2) * 2
     set tb = b - (b / 2) * 2
     set bintable[0x100 + i] = ta * tb
     set bintable[0x200 + i] = ta + tb - ta * tb
     set bintable[0x300 + i] = ta + tb - 2 * ta * tb
     set a = a / 2
     set b = b / 2
     set ta = a - (a / 2) * 2
     set tb = b - (b / 2) * 2
     set bintable[0x100 + i] = bintable[0x100 + i] + 2 * (ta * tb)
     set bintable[0x200 + i] = bintable[0x200 + i] + 2 * (ta + tb - ta * tb)
     set bintable[0x300 + i] = bintable[0x300 + i] + 2 * (ta + tb - 2 * ta * tb)
     set a = a / 2
     set b = b / 2
     set ta = a - (a / 2) * 2
     set tb = b - (b / 2) * 2
     set bintable[0x100 + i] = bintable[0x100 + i] + 4 * (ta * tb)
     set bintable[0x200 + i] = bintable[0x200 + i] + 4 * (ta + tb - ta * tb)
     set bintable[0x300 + i] = bintable[0x300 + i] + 4 * (ta + tb - 2 * ta * tb)
     set ta = a / 2
     set tb = b / 2
     set bintable[0x100 + i] = bintable[0x100 + i] + 8 * (ta * tb)
     set bintable[0x200 + i] = bintable[0x200 + i] + 8 * (ta + tb - ta * tb)
     set bintable[0x300 + i] = bintable[0x300 + i] + 8 * (ta + tb - 2 * ta * tb)
     set i = i + 1
   endloop
   set i = 1
   set bintable[0] = 1
   loop
     exitwhen i > 31
     set bintable[i] = bintable[i - 1] * 2
     set i = i + 1
   endloop
endfunction
endlibrary