var RTL$ = {
    extend: function (cons, base){
        function Type(){}
        Type.prototype = base.prototype;
        cons.prototype = new Type();
        cons.prototype.constructor = cons;
    },
    typeGuard: function (from, to){
        if (!from)
            return from;
        if (!(from instanceof to)){
            var fromStr;
            var toStr;
            
            if (from && from.constructor && from.constructor.name)
                fromStr = "" + from.constructor.name;
            else
                fromStr = "" + from;
            
            if (to.name)
                toStr = "" + to.name;
            else
                toStr = "" + to;
            
            var msg = "typeguard assertion failed";
            if (fromStr || toStr)               
                msg += ": '" + fromStr + "' is not an extension of '" + toStr + "'";
            throw new Error(msg);
        }
        return from;
    },
    makeRef: function (obj, prop){
        return {set: function(v){ obj[prop] = v; },
                get: function(){ return obj[prop]; }};
    },
    makeArray: function (/*dimensions, initializer*/){
        var forward = Array.prototype.slice.call(arguments);
        var result = new Array(forward.shift());
        var i;
        if (forward.length == 1){
            var init = forward[0];
            if (typeof init == "function")
                for(i = 0; i < result.length; ++i)
                    result[i] = init();
            else
                for(i = 0; i < result.length; ++i)
                    result[i] = init;
        }
        else
            for(i = 0; i < result.length; ++i)
                result[i] = this.makeArray.apply(this, forward);
        return result;
    }
};
var m1 = function (){
var ci = 123;
function Base(){
	this.i = 0;
}
RTL$.extend(T, Base);
function T(){
	Base.call(this);
}
function TPA(){
}
RTL$.extend(TPB, Base);
function TPB(){
	Base.call(this);
}
var i = 0;
function anonymous$1(){
	this.i = 0;
}
var pr = null;
var pr2 = null;

function p(){
}

function makeTPA(){
	var result = null;
	result = new TPA();
	return result;
}

function makeTPB(){
	var result = null;
	result = new TPB();
	return result;
}
pr = new anonymous$1();
return {
	ci: ci,
	Base: Base,
	T: T,
	TPA: TPA,
	TPB: TPB,
	i: function(){return i;},
	pr: function(){return pr;},
	pr2: function(){return pr2;},
	p: p,
	makeTPA: makeTPA,
	makeTPB: makeTPB
}
}();
var m2 = function (m1){
RTL$.extend(T, m1.T);
function T(){
	m1.T.call(this);
	this.i2 = 0;
}
var r = new m1.T();
var r2 = new T();
var pb = null;
var ptr = null;
var ptr2 = null;
var ptrA = null;

function p(i/*INTEGER*/){
}

function ref(i/*VAR INTEGER*/){
}
ptr = new m1.T();
pb = ptr;
RTL$.typeGuard(pb, m1.T).i = 123;
ptr2 = new T();
ptr2.i = 1;
ptr2.i2 = 2;
ptrA = m1.makeTPA();
m1.p();
p(m1.i());
p(m1.ci);
ref(RTL$.makeRef(m1.pr2(), "i"));
}(m1);
var m3 = function (m1, m2){
RTL$.extend(T, m2.T);
function T(){
	m2.T.call(this);
}
var r = new m2.T();
var r2 = new T();
var a = RTL$.makeArray(3, function(){return new m2.Base();});
var ptr = null;
var pb = null;
var pTPB = null;
ptr = new m2.T();
pb = ptr;
RTL$.typeGuard(pb, m2.T).i = 123;
pb = m2.makeTPB();
pTPB = RTL$.typeGuard(pb, m2.TPB);
m2.p();
}(m2, m1);