Bitwise And operation

/**
 * Copyright aobyrne ( http://wonderfl.net/user/aobyrne )
 * MIT License ( http://www.opensource.org/licenses/mit-license.php )
 * Downloaded from: http://wonderfl.net/c/mkNh
 */

package {
    import flash.display.Graphics;
    import flash.display.Sprite;
    import flash.display.StageAlign;
    import flash.display.StageScaleMode;
    import flash.events.Event;
    import flash.events.MouseEvent;
    import flash.filters.DropShadowFilter;
    import flash.text.TextField;
    import flash.text.TextFormat;
    import frocessing.color.ColorHSV;
    public class IntegerBitAnd extends Sprite {
        public static var textField:TextField;
        public const DIMENSION:Number=10;
        public var maxPower:uint;
        
        public var max:Number;
        private var highlight:Highlight;
        private var matrix:Sprite;
        
        public function IntegerBitAnd() {
            matrix = Sprite(addChild(new Sprite));
            stage.align = StageAlign.TOP_LEFT;
            stage.addEventListener(Event.RESIZE, onResize);
            stage.scaleMode = StageScaleMode.NO_SCALE;
            textField = TextField(addChild(new TextField));
            textField.backgroundColor = 0xffffff;
            textField.background = true;
            textField.defaultTextFormat = new TextFormat("Lucida Console",11);
            textField.width = 150;
            textField.height = 50;
            textField.wordWrap = true;
            textField.filters = [new DropShadowFilter()];
            textField.border = true;
            textField.x = 800;
            
            cTrace( "maxPower : " + maxPower );
            addEventListener(MouseEvent.CLICK, onClick);
            paint();
            highlight = new Highlight(this as Sprite);
            
        }
        
        private function paint():void 
        {
            max = Math.round(stage.stageHeight / 10);
            maxPower =  Math.floor(Math.log(max) / Math.log(2)) + 1;
            var r1:Array = [];
            r1.length = 0;
            for (var o:int = 0; o <max; o++) 
            {
                r1[o]=r1.length;
                
            }
            
            var g:Graphics = matrix.graphics;
            g.clear();
            for (var k:int = 0; k < r1.length; k++) 
            {
                var item:int = r1[k];
                
                var colorHSV:ColorHSV = new ColorHSV();
                var n:int
                for (n = 0; n < r1.length; n++) 
                {
                    var itemInner:int = r1[n];
                    var sco:int = addOperation(item, itemInner);
                    var ratio:Number = sco / max;
                    colorHSV.h = 300*ratio;
                    var sc:Boolean = Boolean(sco);
                    g.beginFill(sc?colorHSV.value:0);
                    g.drawRect(k * DIMENSION, n * DIMENSION, DIMENSION, DIMENSION);
                }
            }
        }
        
        
        private function onResize(e:Event):void 
        {
            paint();
        }
        
        private function onClick(e:MouseEvent):void 
        {
            textField.text = "";
            var m:Number = Math.floor(stage.mouseX / DIMENSION);
            var n:Number = Math.floor(stage.mouseY / DIMENSION);
            multiplcationConsole(String(m), String(n), maxPower);
            highlight.shape.x = m*DIMENSION;
            highlight.shape.y = n * DIMENSION;
            textField.x = highlight.shape.x + DIMENSION;
            textField.y = highlight.shape.y + DIMENSION;
        }
        
        public static function pad(item:int,maxPowerArg:int):String 
        {
            var numberPure:String = item.toString(2);
            var zeros:String = "";
            if (numberPure.length<maxPowerArg) 
            {
                var l:int = maxPowerArg - numberPure.length;
                for (var m:int = 0; m < l; m++) 
                {
                    zeros += "0";
                    
                }
                numberPure = zeros + numberPure;
            }
            return numberPure;
        }
        
        private function addOperation(n:int, m:int) : int{
            var m1:int = n & m;
            return m1;
        }
        
        public static function ctrace(msg:String):void 
        {
            textField.appendText("\n"+msg);
        }
        private function cTrace(msg:String):void 
        {
            ctrace(msg);
        }
         private function multiplcationConsole(p:String,q:String,maxPowerArg:int):void 
        {
            var pi:int = parseInt(p, 10);
            var qi:int = parseInt(q, 10);
            var ri:int = int(pi & qi);
            cTrace( "p     : " + pad(pi,maxPowerArg)+","+pi );
            cTrace( "q     : " + pad(qi,maxPowerArg)+","+qi );
            cTrace( "(p&q) : " + pad(ri,maxPowerArg)+","+ri );
        }
   }
}
import flash.display.Graphics;
import flash.display.Shape;
import flash.display.Sprite;
import flash.display.Stage;
import flash.events.KeyboardEvent;
import flash.ui.Keyboard;
class Highlight
{
    private var root:Sprite;
    public var shape:Shape;
    private var d:Number;
    private var main:IntegerBitAnd;
    private var pad:Function;
    public function Highlight(roota:Sprite)
    {
        root = roota;
        shape = root.addChild(new Shape) as Shape;
        var g:Graphics = shape.graphics;
        g.lineStyle(0);
        g.beginFill(0xffffff);
        shape.alpha = 0.5;
        main = (root as IntegerBitAnd);
        
        d = main.DIMENSION;
        g.drawRect(0, 0, d, d);
        
        var s:Stage = root.stage;
        s.addEventListener(KeyboardEvent.KEY_DOWN, onKeyDown);
        pad = IntegerBitAnd.pad;
    }
    
    private function onKeyDown(e:KeyboardEvent):void 
    {
        switch (e.keyCode) 
        {
            case Keyboard.DOWN:
                shape.y += d;
            break;
            case Keyboard.UP:
                shape.y -= d;
            break;
            case Keyboard.RIGHT:
                shape.x += d;
            break;
            case Keyboard.LEFT:
                shape.x -= d;
            break;
            default:
                
            break;
        }
        if (shape.y<0) 
        {
            shape.y = 0;
        }
        if (shape.y>=main.max*d) 
        {
            shape.y = (main.max-1)*d
        }
        if (shape.x<0) 
        {
            shape.x = 0;
        }
        if (shape.x>=main.max*d) 
        {
            shape.x = (main.max-1)*d
        }
        var x1:Number = shape.x;
        var y1:Number = shape.y;
        multiply(x1, y1);
        IntegerBitAnd.textField.x = x1+d;
        IntegerBitAnd.textField.y = y1+d;
    }
    private function multiply(xa:Number,ya:Number):void 
    {
        IntegerBitAnd.textField.text = "";
        var m:Number = Math.floor(xa / d);
        var n:Number = Math.floor(ya / d);
        multiplcationConsole(String(m), String(n), main.maxPower);
    }
         private function multiplcationConsole(p:String,q:String,maxPowerArg:int):void 
        {
            var pi:int = parseInt(p, 10);
            var qi:int = parseInt(q, 10);
            var ri:int = int(pi & qi);
            cTrace( "  p   : " + pad(pi,maxPowerArg)+","+pi );
            cTrace( "  q   : " + pad(qi,maxPowerArg)+","+qi );
            cTrace( "p & q : " + pad(ri,maxPowerArg)+","+ri );
        }
        
        private function cTrace(msg:String):void 
        {
            IntegerBitAnd.ctrace(msg);
        }
    
}