;(function () {
	print(function (n) {

		for (var i = 1; i <= 4; i++) {
			var l = readline().split(' ').map(Number),
				x = Math.min(l[0], l[1]),
				y = Math.min(l[2], l[3]);

			if (x + y <= n) {
				return [i, x, n - x].join(' ');
			}
		}

		return -1;

	}(+readline()));
}.call(this));


print(function(n) {

	for (var i = 0; i < 4; i++) {
		var a = readline().split(' ').map(Number);
		for (var x = 0; x <= 1; x++) for (var y = 2; y <= 3; y++)
				if (a[x] + a[y] <= n)
					return [i + 1, a[x], n - a[x]].join(' ');
	}

	return -1;

}(+readline()));


print(function(n) {

	for (var i = 0; i < 4; i++) {
		var a = readline().split(' ').map(Number);
		for (var x = 0; x <= 1; x++)
			for (var y = 2; y <= 3; y++)
				if (a[x] + a[y] <= n) return [i + 1, a[x], n - a[x]].join(' ');
	}

	return -1;

}(+readline()));


print(function(n) {

	for (var i = 0; i < 4; i++) {
		var a = readline().split(' ').map(Number);
		for (var x = 0; x <= 1; x++)
			for (var y = 2; y <= 3; y++)
				if (a[x] + a[y] <= n) return [i + 1, a[x], n - a[y]].join(' ');
	}

	return -1;

}(+readline()));


function Stack(){this.a=[]}function Queue(){this.l=new Stack,this.r=new Stack}function Reader(){this.b=[],this.c=0}function Writer(){this.l=[""],this.c=0}Array.prototype.back=function(){return this[this.length-1]},Math.gcd=function(t,i){return i?gcd(i,t%i):t},Math.lcm=function(t,i){return t/gcd(t,i)*i},Math.sign=function(t){return(t>0)-(0>t)},Math.cmp=function(t,i){return(+t>+i)-(+i>+t)},Math.icmp=function(t,i){return(+i>+t)-(+t>+i)},Stack.prototype.empty=function(){return 0==this.a.length},Stack.prototype.push=function(t){this.a.push(t)},Stack.prototype.pop=function(){return this.empty()?void 0:this.a.pop()},Stack.prototype.top=function(){return this.empty()?void 0:this.a[this.a.length-1]},Stack.prototype.clear=function(){this.a=[]},Stack.prototype.size=function(){return this.a.length},Queue.prototype.push=function(t){this.l.push(t)},Queue.prototype.empty=function(){return this.r.empty()&&this.l.empty()},Queue.prototype.pop=function(){if(this.r.empty())for(;!this.l.empty();)this.r.push(this.l.pop());return this.r.empty()?void 0:this.r.pop()},Queue.prototype.front=function(){if(this.r.empty())for(;!this.l.empty();)this.r.push(this.l.pop());return this.r.empty()?void 0:this.r.top()},Queue.prototype.size=function(){return l.size()+r.size()},Queue.prototype.clear=function(){l.clear(),r.clear()},Reader.prototype.next=function(){return this.c==this.b.length&&(this.c=0,this.b=readline().split(" ")),this.b[this.c++]},Writer.prototype.print=function(t){this.l[this.c]+=t},Writer.prototype.println=function(t){this.l[this.c]+=t,this.l.push(""),++this.c},Writer.prototype.flush=function(){print(this.l.join("\n")),this.l=[]};

function main(cin, cout)
{
    var n = +cin.next();
    var k1 = +cin.next();
    var q1 = new Queue();
    var q2 = new Queue();
    var t;
    for(var i = 0; i < k1; ++i)
    {
        t = +cin.next();
        q1.push(t);
    }
    var k2 = +cin.next();
    for(var i = 0; i < k2; ++i)
    {
        t = +cin.next();
        q2.push(t);
    }
    var iter = 0;
    var c1, c2;

    while(!q1.empty() && !q2.empty())
    {
        c1 = q1.front();
        q1.pop();
        c2 = q2.front();
        q2.pop();
        if (c1 > c2)
        {
            q1.push(c2);
            q1.push(c1);
        } else
        {
            q2.push(c1);
            q2.push(c2);
        }
        iter++;
        if (iter == 10000000)
            break;
    }
    if (iter == 10000000)
        cout.print("-1");
    else
        cout.print(iter + " " + (q1.empty() ? 2 : 1));
}

var cin = new Reader();
var cout = new Writer();

main(cin, cout);

cout.flush();


function ProblemSolver() {
    this.HAS_TEST_CASES = false;
    this.INPUT_FILE_NAME = "test.in";
    this.OUTPUT_FILE_NAME = "out.txt";
    this.DO_OUTPUT_TO_FILE = false;
    this.CLEAR_ARRAY_PER_CASE = false;

    this.rec = function( arr , brr , firstFlag ) {
    	var res , r1 , newArr , newBrr , fl , sz , i , sz1 , sz2 ;
    	if( firstFlag == false && arr.length == this.baseCaseArr.length && brr.length == this.baseCaseBrr.length ) {
    		fl = 1 ;
    		sz = arr.length ;
    		for( i = 0 ; i < sz ; i++ ) {
    			if( arr[ i ] != this.baseCaseArr[ i ] ) {
    				fl = 0 ;
    				break ;
    			}
    		}
    		sz = brr.length ;
    		for( i = 0 ; i < sz ; i++ ) {
    			if( brr[ i ] != this.baseCaseBrr[ i ] ) {
    				fl = 0 ;
    				break ;
    			}
    		}
    		if( fl == 1 ) {
    			return -1 ;
    		}
    	}
    	if( arr.length == 0 ) {
    		this.winner = 2 ;
    		return 0 ;
    	}
    	if( brr.length == 0 ) {
    		this.winner = 1 ;
    		return 0 ;
    	}
    	newArr = [] ;
    	newBrr = [] ;
    	sz1 = arr.length ;
    	sz2 = brr.length ;
    	for( i = 1 ; i < sz1 ; i++ ) {
			newArr.push( arr[ i ] ) ;
		}
		for( i = 1 ; i < sz2 ; i++ ) {
			newBrr.push( brr[ i ] ) ;
		}
    	if( arr[ 0 ] > brr[ 0 ] ) {
    		newArr.push( brr[ 0 ] ) ;
    		newArr.push( arr[ 0 ] ) ;
    	}
    	else {
    		newBrr.push( arr[ 0 ] ) ;
    		newBrr.push( brr[ 0 ] ) ;
    	}
    	r1 = this.rec( newArr , newBrr , false ) ;
    	if( r1 == -1 ) {
    		res = -1 ;
    	}
    	else {
    		res = r1 + 1 ;
    	}
    	return res ;
    } ;

    this.solveCase = function() {
        var res , i , j , fl , cn , temp ;
        res = 0 ;
        this.baseCaseArr = [] ;
        for( i = 0 ; i < this.k1 ; i++ ) {
        	this.baseCaseArr.push( this.arr[ i ] ) ;
        }
        this.baseCaseBrr = [] ;
        for( i = 0 ; i < this.k2 ; i++ ) {
        	this.baseCaseBrr.push( this.brr[ i ] ) ;
        }
        this.winner = -1 ;
        res = this.rec( this.arr , this.brr , true ) ;
        if( res == -1 ) {
        	print( res );
        }
        else {
        	print( res + ' ' + this.winner );
        }
    };

    this.init = function() {
        this.lim1 = 100010;
        this.lim2 = 110;
        this.cc = 1;
        this.ind = 1;
        this.n = 0;
        this.cn = 0;
        this.declareAndFillArrays();
    };

    this.getInput = function( irObj ) {
        var hasMoreInput , i;
        hasMoreInput = true;
        try {
            this.n = irObj.nextInt();
            this.k1 = irObj.nextInt();
            this.arr = [] ;
            for( i = 0 ; i < this.k1 ; i++ ) {
                this.arr.push( irObj.nextInt() ) ;
            }
            this.brr = [] ;
            this.k2 = irObj.nextInt();
            for( i = 0 ; i < this.k2 ; i++ ) {
                this.brr.push( irObj.nextInt() ) ;
            }
        }
        catch( ex ) {
            hasMoreInput = false;
        }
        return hasMoreInput;
    };

    this.clearArraysPerCase = function() {
        var i;
        this.arr = new Array();
        this.adj_list = new Array();
        for( i = 0 ; i < this.lim1 ; i++ ) {
            this.arr.push( 0 );
            this.adj_list.push( new Array() );
        }
    };

    this.clearPerCase = function() {
        this.cn = 0;
        this.cc++;
        if( this.CLEAR_ARRAY_PER_CASE == true ) {
            this.clearArraysPerCase() ;
        }
    };

    this.declareAndFillArrays = function() {
        var i , j;
        this.srr = new Array();
        this.vis = new Array();
        this.arr = new Array();
        this.brr = new Array();
        this.memo = new Array();
        this.done = new Array();
        this.adj_list = new Array();
        for( i = 0 ; i < this.lim1 ; i++ ) {
            this.srr.push( "" );
            this.vis.push( 0 );
            this.arr.push( 0 );
            this.brr.push( 0 );
            this.adj_list.push( new Array() );
        }
        for( i = 0 ; i < this.lim2 ; i++ ) {
            this.memo.push( new Array() );
            this.done.push( new Array() );
            for( j = 0 ; j < this.lim2 ; j++ ) {
                this.memo[ i ].push( -1 );
                this.done[ i ].push( 0 );
            }
        }
    };

    this.init();
}

function InputReader() {
    var self = this ;
    this.allLines = new Array();
    this.currrentLineNumber = 0;
    this.currrentCharacterIndex = 0;
    this.callBackFunction = null ;
    this.parentContext = null ;

    this.readAllLines = function() {
        var singleLine;
        while( true ) {
            try {
                singleLine = readline();
                if( singleLine == null ) {
                    break;
                }
            }
            catch( ex ) {
                break;
            }
            this.allLines.push( singleLine );
        }
    };

    this.readAllLinesFromRhino = function() {
        var brObj , line ;
        importPackage( java.io ) ;
        importPackage( java.lang ) ;
        brObj = new BufferedReader( new InputStreamReader( System[ 'in' ] ) ) ;
        this.allLines = [] ;
        while( true ) {
            line = brObj.readLine() ;
            if( line == null ) {
                break;
            }
            this.allLines.push( line ) ;
        }
    };

    this.readSingleLinesFromNodeJsJudgeServer = function( chunk ) {
        self.chunkData += chunk ;
    };

    this.readEndFromNodeJsJudgeServer = function() {
        self.parseRawData( self.chunkData ) ;
        self.parentContext.runCases() ;
    };

    this.readAllLinesFromNodeJsJudgeServer = function( parentContext ) {
        this.parentContext = parentContext ;
        process.stdin.resume() ;
        process.stdin.setEncoding( 'utf8' ) ;
        this.chunkData = '' ;
        process.stdin.on( 'data' , this.readSingleLinesFromNodeJsJudgeServer ) ;
        process.stdin.on( 'end' , this.readEndFromNodeJsJudgeServer ) ;
    };

    this.parseRawData = function( data ) {
        var len , i , currentString;
        len = data.length;
        currentString = "";
        this.allLines = [] ;
        for( i = 0 ; i < len ; i++ ) {
            if( data[ i ] == '\r' ) {
            }
            else if( data[ i ] == '\n' ) {
                this.allLines.push( currentString );
                currentString = "";
            }
            else {
                currentString += data[ i ];
            }
        }
        if( currentString != "" ) {
            this.allLines.push( currentString );
        }
    };

    this.readAllLinesFromFile = function( inputFileName ) {
        var currentDirectory , fsObj , inputFilePath , rawData;
        fsObj = require( 'fs' );
        currentDirectory = __dirname;
        inputFilePath = currentDirectory + "\\" + inputFileName;
        rawData = fsObj.readFileSync( inputFilePath , "utf8" );
        this.parseRawData( rawData );
    };

    this.next = function( flag ) {
        var len , i , startIdx , res , endIdx;
        if( flag == 0 ) {
            if( this.currrentCharacterIndex != 0 ) {
                this.currrentLineNumber++;
                this.currrentCharacterIndex = 0;
            }
            res = "";
            len = this.allLines[ this.currrentLineNumber ].length;
            if( typeof( len ) == 'function' ) {
                len = this.allLines[ this.currrentLineNumber ].length() ;
            }
            for( i = this.currrentCharacterIndex ; i < len ; i++ ) {
                res += '' + this.allLines[ this.currrentLineNumber ].charAt( i ) ;
            }
            this.currrentLineNumber++;
            this.currrentCharacterIndex = 0;
            return res;
        }
        while( true ) {
            if( this.currrentLineNumber >= this.allLines.length ) {
                throw new Error( "No more tokens available!" );
            }
            startIdx = -1;
            len = this.allLines[ this.currrentLineNumber ].length;
            if( typeof( len ) == 'function' ) {
                len = this.allLines[ this.currrentLineNumber ].length() ;
            }
            for( i = this.currrentCharacterIndex ; i < len ; i++ ) {
                if( this.allLines[ this.currrentLineNumber ].charCodeAt( i ) != ' '.charCodeAt( 0 ) ) {
                    startIdx = i;
                    break;
                }
            }
            if( startIdx == -1 ) {
                this.currrentLineNumber++;
                this.currrentCharacterIndex = 0;
                continue;
            }
            res = "";
            endIdx = len - 1 ;
            for( i = startIdx ; i < len ; i++ ) {
                if( this.allLines[ this.currrentLineNumber ].charCodeAt( i ) == ' '.charCodeAt( 0 ) ) {
                    endIdx = i;
                    break;
                }
                if( this.allLines[ this.currrentLineNumber ].charCodeAt( i ) >= 48 && this.allLines[ this.currrentLineNumber ].charCodeAt( i ) <= 57 ) {
                    res += '' + ( this.allLines[ this.currrentLineNumber ].charCodeAt( i ) - 48 ) ;
                }
                else {
                    res += '' + this.allLines[ this.currrentLineNumber ].charAt( i );
                }
            }
            this.currrentCharacterIndex = endIdx;
            if( endIdx == len - 1 ) {
                this.currrentLineNumber++;
                this.currrentCharacterIndex = 0;
            }
            return res;
        }
    };

    this.nextInt = function() {
        return parseInt( this.next( 1 ) );
    };

    this.nextDouble = function() {
        return parseFloat( this.next( 1 ) );
    };

    this.nextString = function() {
        return this.next( 1 );
    };

    this.nextLine = function() {
        return this.next( 0 );
    };
}

function FileOutputHandler() {
    this.resultantStringArray = new Array();

    this.addNewLine = function( newString ) {
        this.resultantStringArray.push( newString );
    };

    this.clearPercase = function() {
        this.resultantStringArray = new Array();
    };

    this.flushOutOutputToFile = function( outputFileName ) {
        var i , sz , res , currentDirectory , fsObj , outputFilePath;
        res = "";
        sz = this.resultantStringArray.length;
        for( i = 0 ; i < sz ; i++ ) {
            if( i != 0 ) {
                res += "\n";
            }
            res += this.resultantStringArray[ i ];
        }
        fsObj = require( 'fs' );
        currentDirectory = __dirname;
        outputFilePath = currentDirectory + "\\" + outputFileName;
        fsObj.writeFileSync( outputFilePath , res );
        this.clearPercase();
    };
}

function CodeExecutioner() {
    this.irObj = new InputReader();
    this.psObj = new ProblemSolver();
    this.fohObj = new FileOutputHandler();

    this.runCases = function() {
        if( this.psObj.HAS_TEST_CASES == true ) {
            testCases = this.irObj.nextInt();
            for( i = 0 ; i < testCases ; i++ ) {
                this.psObj.clearPerCase();
                this.psObj.getInput( this.irObj );
                this.psObj.solveCase();
            }
        }
        else {
            while( true ) {
                this.psObj.clearPerCase();
                hasMoreTestCases = this.psObj.getInput( this.irObj );
                if( hasMoreTestCases == false ) {
                    break;
                }
                this.psObj.solveCase();
            }
        }
        if( this.psObj.DO_OUTPUT_TO_FILE == true ) {
            this.fohObj.flushOutOutputToFile( this.psObj.OUTPUT_FILE_NAME );
        }
    };

    this.detectEnvironmentType = function() {
        var environmentType = null ;
        try {
            if( importPackage != null ) {
                environmentType = 'rhino' ;
            }
        }
        catch( ex1 ) {
            try {
                //for nodejs local server check
                if( __dirname != null && readline != null && typeof( readline ) != 'function' ) {
                    environmentType = 'local-node-js' ;
                }
            }
            catch( ex2 ) {
                try {
                    if( readline == null || typeof( readline ) != 'function' ) {
                        environmentType = 'server-node-js' ;
                    }
                    else {
                        try {
                            if( Map != null ) {
                                environmentType = 'spider-monkey' ;
                            }
                            else {
                                environmentType = 'javascript-v8' ;
                            }
                        }
                        catch( ex3 ) {
                            environmentType = 'javascript-v8' ;
                        }
                    }
                }
                catch( ex3 ) {
                    environmentType = 'server-node-js' ;
                }
            }
        }
        return environmentType ;
    };

    this.configureStreamsAndReadInput = function() {
        var testCases , i , hasMoreTestCases , isLocal , localContext , isNodeJsJudgeServer , environmentType ;
        isNodeJsJudgeServer = false ;
        environmentType = this.detectEnvironmentType() ;
        if( environmentType == 'local-node-js' ) {
            try {
                if( print == null || typeof( print ) != 'function' ) {
                    print = console.log;
                }
            }
            catch( ex ) {
                print = console.log;
            }
            if( this.psObj.DO_OUTPUT_TO_FILE == true ) {
                localContext = this.fohObj;
                print = function() {
                    localContext.addNewLine.apply( localContext , arguments );
                }
            }
            this.irObj.readAllLinesFromFile( this.psObj.INPUT_FILE_NAME );
            this.runCases() ;
        }
        else if( environmentType == 'server-node-js' ) {
            try {
                if( print == null || typeof( print ) != 'function' ) {
                    print = console.log;
                }
            }
            catch( ex ) {
                print = console.log;
            }
            this.irObj.readAllLinesFromNodeJsJudgeServer( this ) ;
        }
        else if( environmentType == 'javascript-v8' ) {
            this.irObj.readAllLines();
            this.runCases() ;
        }
        else if( environmentType == 'rhino' ) {
            this.irObj.readAllLinesFromRhino();
            this.runCases() ;
        }
        else if( environmentType == 'spider-monkey' ) {
            this.irObj.readAllLines();
            this.runCases() ;
        }
    };

    this.configureStreamsAndReadInput();
}

new CodeExecutioner();


(function () {
	var lines = readline().split(' ').map(function (e) {
		return parseInt(e);
	});
	var n = lines[0],
		t = lines[1];
	var a = [{
		x: t,
		y: 1
	}];
	var cnt = 0,nxt;
	for(var i=0;i<n;++i) {
		nxt = [];
		for(var j=0;j<=i;++j) {
			var tmp = {
				x: a[j].x - a[j].y,
				y: a[j].y*2
			};
			if(a[j].x>=a[j].y) {
				++cnt;
			} else {
				tmp.x = 0;
			}
			if(j) {
				nxt[j].x += tmp.x;
			} else {
				nxt.push({
					x: tmp.x,
					y: tmp.y
				});
			}
			nxt.push(tmp);
		}
		a = nxt;
	}
	print(cnt);
})()


function main() {
  var input = readline().split(' ').map(Number);
  var n = input[0];
  var t = input[1];

  var count = 0;

  function isBigEnough(element, index, array) {
    return element >= 1;
  }

  var array = [t];
  count += array.filter(isBigEnough).length;
  for (var i = 2; i <= n; ++i) {
    var next_array = [];
    for (var j = 0; j < i; ++j) {
      var value = 0;
      if (j - 1 >= 0) {
        value += Math.max(0, array[j - 1] - 1);
      }
      if (j < array.length) {
        value += Math.max(0, array[j] - 1);
      }
      value /= 2;
      next_array.push(value);
    }
    array = next_array;
    count += array.filter(isBigEnough).length;
  }

  print(count);
}

main();


var data = readline().split(" "),

    height = +data[0],
    time = +data[1],

    swap = [],
    level,
    gid = 1;

function Glass(level, left, right) {
    this.value = 0;
    this.level = level;
    this.left = left;
    this.right = right;
    this.id = gid++;
};

Glass.prototype.toString = function() {
    return "{ level = " + this.level + ", inner = [ " + this.left + " , " + this.right + " ] }"
};

Glass.prototype.add = function(v) {
    if (this.value < 1) {
        this.value += v;
    } else {
        if (this.getLeft()) {
            this.getLeft().add(v / 2);
        };
        if (this.getRight()) {
            this.getRight().add(v / 2);
        };
    };
    return this;
};

Glass.prototype.getLeft = function() {
    if (!swap[this.level + 1]) {
        return;
    };
    return swap[this.level + 1][this.left];
}

Glass.prototype.getRight = function() {
    if (!swap[this.level + 1]) {
        return;
    };
    return swap[this.level + 1][this.right];
}

for (var i = 1; i <= height; ++i) {
    level = [];
    for (var j = 0; j < i; ++j) {
        level.push(new Glass(i - 1, j, j + 1));
    };
    swap.push(level);
}

for (var i = 0; i < time; ++i) {
    swap[0][0].add(1);
};

var result = 0;

for (var i = 0; i < swap.length; ++i) {
    for (var j = 0; j < swap[i].length; ++j) {
        if (swap[i][j].value == 1) {
            result++;
        };
    };
};

print(result);


var data = readline().split(" "),

    height = +data[0],
    time = +data[1],

    swap = [],
    level,
    gid = 1;

function Glass(level, left, right) {
    this.value = 0;
    this.level = level;
    this.left = left;
    this.right = right;
    this.id = gid++;
};

Glass.prototype.toString = function() {
    return "{ level = " + this.level + ", inner = [ " + this.left + " , " + this.right + " ] }"
};

Glass.prototype.add = function(v) {
    if (this.value < 1) {
        this.value += v;
    } else {
        this.getLeft().add(v / 2);
        this.getRight().add(v / 2);
    };
    return this;
};

Glass.prototype.getLeft = function() {
    if (!swap[this.level + 1]) {
        return;
    };
    return swap[this.level + 1][this.left];
}

Glass.prototype.getRight = function() {
    if (!swap[this.level + 1]) {
        return;
    };
    return swap[this.level + 1][this.right];
}

for (var i = 1; i <= height; ++i) {
    level = [];
    for (var j = 0; j < i; ++j) {
        level.push(new Glass(i - 1, j, j + 1));
    };
    swap.push(level);
}

for (var i = 0; i < time; ++i) {
    swap[0][0].add(1);
};

var result = 0;

for (var i = 0; i < swap.length; ++i) {
    for (var j = 0; j < swap[i].length; ++j) {
        if (swap[i][j].value == 1) {
            result++;
        };
    };
};

print(result);


function substract(a, b) {
  if (a === 0 || b === 0) {
    return { a, b };
  } else if (a >= 2 * b) {
    a = a - 2 * b;
    return substract(a, b);
  } else if (b >= 2 * a) {
    b = b - 2 * a;
    return substract(a, b);
  } else {
    return { a, b };
  }
}

const nd = readline().split(' ');

const result = substract(nd[0], nd[1]);

print(result.a + ' ' + result.b + '\n');


var bigInt = (function(undefined) {
  'use strict';
  var BASE = 1e7,
    LOG_BASE = 7,
    MAX_INT = 9007199254740992,
    MAX_INT_ARR = smallToArray(MAX_INT),
    LOG_MAX_INT = Math.log(MAX_INT);
  function Integer(v, radix) {
    if (typeof v === 'undefined') return Integer[0];
    if (typeof radix !== 'undefined')
      return +radix === 10 ? parseValue(v) : parseBase(v, radix);
    return parseValue(v);
  }
  function BigInteger(value, sign) {
    this.value = value;
    this.sign = sign;
    this.isSmall = false;
  }
  BigInteger.prototype = Object.create(Integer.prototype);
  function SmallInteger(value) {
    this.value = value;
    this.sign = value < 0;
    this.isSmall = true;
  }
  SmallInteger.prototype = Object.create(Integer.prototype);
  function isPrecise(n) {
    return -MAX_INT < n && n < MAX_INT;
  }
  function smallToArray(n) {
    if (n < 1e7) return [n];
    if (n < 1e14) return [n % 1e7, Math.floor(n / 1e7)];
    return [n % 1e7, Math.floor(n / 1e7) % 1e7, Math.floor(n / 1e14)];
  }
  function arrayToSmall(arr) {
    trim(arr);
    var length = arr.length;
    if (length < 4 && compareAbs(arr, MAX_INT_ARR) < 0) {
      switch (length) {
        case 0:
          return 0;
        case 1:
          return arr[0];
        case 2:
          return arr[0] + arr[1] * BASE;
        default:
          return arr[0] + (arr[1] + arr[2] * BASE) * BASE;
      }
    }
    return arr;
  }
  function trim(v) {
    var i = v.length;
    while (v[--i] === 0);
    v.length = i + 1;
  }
  function createArray(length) {
    var x = new Array(length);
    var i = -1;
    while (++i < length) {
      x[i] = 0;
    }
    return x;
  }
  function truncate(n) {
    if (n > 0) return Math.floor(n);
    return Math.ceil(n);
  }
  function add(a, b) {
    var l_a = a.length,
      l_b = b.length,
      r = new Array(l_a),
      carry = 0,
      base = BASE,
      sum,
      i;
    for (i = 0; i < l_b; i++) {
      sum = a[i] + b[i] + carry;
      carry = sum >= base ? 1 : 0;
      r[i] = sum - carry * base;
    }
    while (i < l_a) {
      sum = a[i] + carry;
      carry = sum === base ? 1 : 0;
      r[i++] = sum - carry * base;
    }
    if (carry > 0) r.push(carry);
    return r;
  }
  function addAny(a, b) {
    if (a.length >= b.length) return add(a, b);
    return add(b, a);
  }
  function addSmall(a, carry) {
    var l = a.length,
      r = new Array(l),
      base = BASE,
      sum,
      i;
    for (i = 0; i < l; i++) {
      sum = a[i] - base + carry;
      carry = Math.floor(sum / base);
      r[i] = sum - carry * base;
      carry += 1;
    }
    while (carry > 0) {
      r[i++] = carry % base;
      carry = Math.floor(carry / base);
    }
    return r;
  }
  BigInteger.prototype.add = function(v) {
    var n = parseValue(v);
    if (this.sign !== n.sign) {
      return this.subtract(n.negate());
    }
    var a = this.value,
      b = n.value;
    if (n.isSmall) {
      return new BigInteger(addSmall(a, Math.abs(b)), this.sign);
    }
    return new BigInteger(addAny(a, b), this.sign);
  };
  BigInteger.prototype.plus = BigInteger.prototype.add;
  SmallInteger.prototype.add = function(v) {
    var n = parseValue(v);
    var a = this.value;
    if (a < 0 !== n.sign) {
      return this.subtract(n.negate());
    }
    var b = n.value;
    if (n.isSmall) {
      if (isPrecise(a + b)) return new SmallInteger(a + b);
      b = smallToArray(Math.abs(b));
    }
    return new BigInteger(addSmall(b, Math.abs(a)), a < 0);
  };
  SmallInteger.prototype.plus = SmallInteger.prototype.add;
  function subtract(a, b) {
    var a_l = a.length,
      b_l = b.length,
      r = new Array(a_l),
      borrow = 0,
      base = BASE,
      i,
      difference;
    for (i = 0; i < b_l; i++) {
      difference = a[i] - borrow - b[i];
      if (difference < 0) {
        difference += base;
        borrow = 1;
      } else borrow = 0;
      r[i] = difference;
    }
    for (i = b_l; i < a_l; i++) {
      difference = a[i] - borrow;
      if (difference < 0) difference += base;
      else {
        r[i++] = difference;
        break;
      }
      r[i] = difference;
    }
    for (; i < a_l; i++) {
      r[i] = a[i];
    }
    trim(r);
    return r;
  }
  function subtractAny(a, b, sign) {
    var value;
    if (compareAbs(a, b) >= 0) {
      value = subtract(a, b);
    } else {
      value = subtract(b, a);
      sign = !sign;
    }
    value = arrayToSmall(value);
    if (typeof value === 'number') {
      if (sign) value = -value;
      return new SmallInteger(value);
    }
    return new BigInteger(value, sign);
  }
  function subtractSmall(a, b, sign) {
    var l = a.length,
      r = new Array(l),
      carry = -b,
      base = BASE,
      i,
      difference;
    for (i = 0; i < l; i++) {
      difference = a[i] + carry;
      carry = Math.floor(difference / base);
      difference %= base;
      r[i] = difference < 0 ? difference + base : difference;
    }
    r = arrayToSmall(r);
    if (typeof r === 'number') {
      if (sign) r = -r;
      return new SmallInteger(r);
    }
    return new BigInteger(r, sign);
  }
  BigInteger.prototype.subtract = function(v) {
    var n = parseValue(v);
    if (this.sign !== n.sign) {
      return this.add(n.negate());
    }
    var a = this.value,
      b = n.value;
    if (n.isSmall) return subtractSmall(a, Math.abs(b), this.sign);
    return subtractAny(a, b, this.sign);
  };
  BigInteger.prototype.minus = BigInteger.prototype.subtract;
  SmallInteger.prototype.subtract = function(v) {
    var n = parseValue(v);
    var a = this.value;
    if (a < 0 !== n.sign) {
      return this.add(n.negate());
    }
    var b = n.value;
    if (n.isSmall) {
      return new SmallInteger(a - b);
    }
    return subtractSmall(b, Math.abs(a), a >= 0);
  };
  SmallInteger.prototype.minus = SmallInteger.prototype.subtract;
  BigInteger.prototype.negate = function() {
    return new BigInteger(this.value, !this.sign);
  };
  SmallInteger.prototype.negate = function() {
    var sign = this.sign;
    var small = new SmallInteger(-this.value);
    small.sign = !sign;
    return small;
  };
  BigInteger.prototype.abs = function() {
    return new BigInteger(this.value, false);
  };
  SmallInteger.prototype.abs = function() {
    return new SmallInteger(Math.abs(this.value));
  };
  function multiplyLong(a, b) {
    var a_l = a.length,
      b_l = b.length,
      l = a_l + b_l,
      r = createArray(l),
      base = BASE,
      product,
      carry,
      i,
      a_i,
      b_j;
    for (i = 0; i < a_l; ++i) {
      a_i = a[i];
      for (var j = 0; j < b_l; ++j) {
        b_j = b[j];
        product = a_i * b_j + r[i + j];
        carry = Math.floor(product / base);
        r[i + j] = product - carry * base;
        r[i + j + 1] += carry;
      }
    }
    trim(r);
    return r;
  }
  function multiplySmall(a, b) {
    var l = a.length,
      r = new Array(l),
      base = BASE,
      carry = 0,
      product,
      i;
    for (i = 0; i < l; i++) {
      product = a[i] * b + carry;
      carry = Math.floor(product / base);
      r[i] = product - carry * base;
    }
    while (carry > 0) {
      r[i++] = carry % base;
      carry = Math.floor(carry / base);
    }
    return r;
  }
  function shiftLeft(x, n) {
    var r = [];
    while (n-- > 0) r.push(0);
    return r.concat(x);
  }
  function multiplyKaratsuba(x, y) {
    var n = Math.max(x.length, y.length);
    if (n <= 30) return multiplyLong(x, y);
    n = Math.ceil(n / 2);
    var b = x.slice(n),
      a = x.slice(0, n),
      d = y.slice(n),
      c = y.slice(0, n);
    var ac = multiplyKaratsuba(a, c),
      bd = multiplyKaratsuba(b, d),
      abcd = multiplyKaratsuba(addAny(a, b), addAny(c, d));
    var product = addAny(
      addAny(ac, shiftLeft(subtract(subtract(abcd, ac), bd), n)),
      shiftLeft(bd, 2 * n)
    );
    trim(product);
    return product;
  }
  function useKaratsuba(l1, l2) {
    return -0.012 * l1 - 0.012 * l2 + 15e-6 * l1 * l2 > 0;
  }
  BigInteger.prototype.multiply = function(v) {
    var n = parseValue(v),
      a = this.value,
      b = n.value,
      sign = this.sign !== n.sign,
      abs;
    if (n.isSmall) {
      if (b === 0) return Integer[0];
      if (b === 1) return this;
      if (b === -1) return this.negate();
      abs = Math.abs(b);
      if (abs < BASE) {
        return new BigInteger(multiplySmall(a, abs), sign);
      }
      b = smallToArray(abs);
    }
    if (useKaratsuba(a.length, b.length))
      return new BigInteger(multiplyKaratsuba(a, b), sign);
    return new BigInteger(multiplyLong(a, b), sign);
  };
  BigInteger.prototype.times = BigInteger.prototype.multiply;
  function multiplySmallAndArray(a, b, sign) {
    if (a < BASE) {
      return new BigInteger(multiplySmall(b, a), sign);
    }
    return new BigInteger(multiplyLong(b, smallToArray(a)), sign);
  }
  SmallInteger.prototype._multiplyBySmall = function(a) {
    if (isPrecise(a.value * this.value)) {
      return new SmallInteger(a.value * this.value);
    }
    return multiplySmallAndArray(
      Math.abs(a.value),
      smallToArray(Math.abs(this.value)),
      this.sign !== a.sign
    );
  };
  BigInteger.prototype._multiplyBySmall = function(a) {
    if (a.value === 0) return Integer[0];
    if (a.value === 1) return this;
    if (a.value === -1) return this.negate();
    return multiplySmallAndArray(
      Math.abs(a.value),
      this.value,
      this.sign !== a.sign
    );
  };
  SmallInteger.prototype.multiply = function(v) {
    return parseValue(v)._multiplyBySmall(this);
  };
  SmallInteger.prototype.times = SmallInteger.prototype.multiply;
  function square(a) {
    var l = a.length,
      r = createArray(l + l),
      base = BASE,
      product,
      carry,
      i,
      a_i,
      a_j;
    for (i = 0; i < l; i++) {
      a_i = a[i];
      carry = 0 - a_i * a_i;
      for (var j = i; j < l; j++) {
        a_j = a[j];
        product = 2 * (a_i * a_j) + r[i + j] + carry;
        carry = Math.floor(product / base);
        r[i + j] = product - carry * base;
      }
      r[i + l] = carry;
    }
    trim(r);
    return r;
  }
  BigInteger.prototype.square = function() {
    return new BigInteger(square(this.value), false);
  };
  SmallInteger.prototype.square = function() {
    var value = this.value * this.value;
    if (isPrecise(value)) return new SmallInteger(value);
    return new BigInteger(square(smallToArray(Math.abs(this.value))), false);
  };
  function divMod1(a, b) {
    var a_l = a.length,
      b_l = b.length,
      base = BASE,
      result = createArray(b.length),
      divisorMostSignificantDigit = b[b_l - 1],
      lambda = Math.ceil(base / (2 * divisorMostSignificantDigit)),
      remainder = multiplySmall(a, lambda),
      divisor = multiplySmall(b, lambda),
      quotientDigit,
      shift,
      carry,
      borrow,
      i,
      l,
      q;
    if (remainder.length <= a_l) remainder.push(0);
    divisor.push(0);
    divisorMostSignificantDigit = divisor[b_l - 1];
    for (shift = a_l - b_l; shift >= 0; shift--) {
      quotientDigit = base - 1;
      if (remainder[shift + b_l] !== divisorMostSignificantDigit) {
        quotientDigit = Math.floor(
          (remainder[shift + b_l] * base + remainder[shift + b_l - 1]) /
            divisorMostSignificantDigit
        );
      }
      carry = 0;
      borrow = 0;
      l = divisor.length;
      for (i = 0; i < l; i++) {
        carry += quotientDigit * divisor[i];
        q = Math.floor(carry / base);
        borrow += remainder[shift + i] - (carry - q * base);
        carry = q;
        if (borrow < 0) {
          remainder[shift + i] = borrow + base;
          borrow = -1;
        } else {
          remainder[shift + i] = borrow;
          borrow = 0;
        }
      }
      while (borrow !== 0) {
        quotientDigit -= 1;
        carry = 0;
        for (i = 0; i < l; i++) {
          carry += remainder[shift + i] - base + divisor[i];
          if (carry < 0) {
            remainder[shift + i] = carry + base;
            carry = 0;
          } else {
            remainder[shift + i] = carry;
            carry = 1;
          }
        }
        borrow += carry;
      }
      result[shift] = quotientDigit;
    }
    remainder = divModSmall(remainder, lambda)[0];
    return [arrayToSmall(result), arrayToSmall(remainder)];
  }
  function divMod2(a, b) {
    var a_l = a.length,
      b_l = b.length,
      result = [],
      part = [],
      base = BASE,
      guess,
      xlen,
      highx,
      highy,
      check;
    while (a_l) {
      part.unshift(a[--a_l]);
      trim(part);
      if (compareAbs(part, b) < 0) {
        result.push(0);
        continue;
      }
      xlen = part.length;
      highx = part[xlen - 1] * base + part[xlen - 2];
      highy = b[b_l - 1] * base + b[b_l - 2];
      if (xlen > b_l) {
        highx = (highx + 1) * base;
      }
      guess = Math.ceil(highx / highy);
      do {
        check = multiplySmall(b, guess);
        if (compareAbs(check, part) <= 0) break;
        guess--;
      } while (guess);
      result.push(guess);
      part = subtract(part, check);
    }
    result.reverse();
    return [arrayToSmall(result), arrayToSmall(part)];
  }
  function divModSmall(value, lambda) {
    var length = value.length,
      quotient = createArray(length),
      base = BASE,
      i,
      q,
      remainder,
      divisor;
    remainder = 0;
    for (i = length - 1; i >= 0; --i) {
      divisor = remainder * base + value[i];
      q = truncate(divisor / lambda);
      remainder = divisor - q * lambda;
      quotient[i] = q | 0;
    }
    return [quotient, remainder | 0];
  }
  function divModAny(self, v) {
    var value,
      n = parseValue(v);
    var a = self.value,
      b = n.value;
    var quotient;
    if (b === 0) throw new Error('Cannot divide by zero');
    if (self.isSmall) {
      if (n.isSmall) {
        return [new SmallInteger(truncate(a / b)), new SmallInteger(a % b)];
      }
      return [Integer[0], self];
    }
    if (n.isSmall) {
      if (b === 1) return [self, Integer[0]];
      if (b == -1) return [self.negate(), Integer[0]];
      var abs = Math.abs(b);
      if (abs < BASE) {
        value = divModSmall(a, abs);
        quotient = arrayToSmall(value[0]);
        var remainder = value[1];
        if (self.sign) remainder = -remainder;
        if (typeof quotient === 'number') {
          if (self.sign !== n.sign) quotient = -quotient;
          return [new SmallInteger(quotient), new SmallInteger(remainder)];
        }
        return [
          new BigInteger(quotient, self.sign !== n.sign),
          new SmallInteger(remainder)
        ];
      }
      b = smallToArray(abs);
    }
    var comparison = compareAbs(a, b);
    if (comparison === -1) return [Integer[0], self];
    if (comparison === 0)
      return [Integer[self.sign === n.sign ? 1 : -1], Integer[0]];
    if (a.length + b.length <= 200) value = divMod1(a, b);
    else value = divMod2(a, b);
    quotient = value[0];
    var qSign = self.sign !== n.sign,
      mod = value[1],
      mSign = self.sign;
    if (typeof quotient === 'number') {
      if (qSign) quotient = -quotient;
      quotient = new SmallInteger(quotient);
    } else quotient = new BigInteger(quotient, qSign);
    if (typeof mod === 'number') {
      if (mSign) mod = -mod;
      mod = new SmallInteger(mod);
    } else mod = new BigInteger(mod, mSign);
    return [quotient, mod];
  }
  BigInteger.prototype.divmod = function(v) {
    var result = divModAny(this, v);
    return { quotient: result[0], remainder: result[1] };
  };
  SmallInteger.prototype.divmod = BigInteger.prototype.divmod;
  BigInteger.prototype.divide = function(v) {
    return divModAny(this, v)[0];
  };
  SmallInteger.prototype.over = SmallInteger.prototype.divide = BigInteger.prototype.over =
    BigInteger.prototype.divide;
  BigInteger.prototype.mod = function(v) {
    return divModAny(this, v)[1];
  };
  SmallInteger.prototype.remainder = SmallInteger.prototype.mod = BigInteger.prototype.remainder =
    BigInteger.prototype.mod;
  BigInteger.prototype.pow = function(v) {
    var n = parseValue(v),
      a = this.value,
      b = n.value,
      value,
      x,
      y;
    if (b === 0) return Integer[1];
    if (a === 0) return Integer[0];
    if (a === 1) return Integer[1];
    if (a === -1) return n.isEven() ? Integer[1] : Integer[-1];
    if (n.sign) {
      return Integer[0];
    }
    if (!n.isSmall)
      throw new Error('The exponent ' + n.toString() + ' is too large.');
    if (this.isSmall) {
      if (isPrecise((value = Math.pow(a, b))))
        return new SmallInteger(truncate(value));
    }
    x = this;
    y = Integer[1];
    while (true) {
      if (b & (1 === 1)) {
        y = y.times(x);
        --b;
      }
      if (b === 0) break;
      b /= 2;
      x = x.square();
    }
    return y;
  };
  SmallInteger.prototype.pow = BigInteger.prototype.pow;
  BigInteger.prototype.modPow = function(exp, mod) {
    exp = parseValue(exp);
    mod = parseValue(mod);
    if (mod.isZero()) throw new Error('Cannot take modPow with modulus 0');
    var r = Integer[1],
      base = this.mod(mod);
    while (exp.isPositive()) {
      if (base.isZero()) return Integer[0];
      if (exp.isOdd()) r = r.multiply(base).mod(mod);
      exp = exp.divide(2);
      base = base.square().mod(mod);
    }
    return r;
  };
  SmallInteger.prototype.modPow = BigInteger.prototype.modPow;
  function compareAbs(a, b) {
    if (a.length !== b.length) {
      return a.length > b.length ? 1 : -1;
    }
    for (var i = a.length - 1; i >= 0; i--) {
      if (a[i] !== b[i]) return a[i] > b[i] ? 1 : -1;
    }
    return 0;
  }
  BigInteger.prototype.compareAbs = function(v) {
    var n = parseValue(v),
      a = this.value,
      b = n.value;
    if (n.isSmall) return 1;
    return compareAbs(a, b);
  };
  SmallInteger.prototype.compareAbs = function(v) {
    var n = parseValue(v),
      a = Math.abs(this.value),
      b = n.value;
    if (n.isSmall) {
      b = Math.abs(b);
      return a === b ? 0 : a > b ? 1 : -1;
    }
    return -1;
  };
  BigInteger.prototype.compare = function(v) {
    if (v === Infinity) {
      return -1;
    }
    if (v === -Infinity) {
      return 1;
    }
    var n = parseValue(v),
      a = this.value,
      b = n.value;
    if (this.sign !== n.sign) {
      return n.sign ? 1 : -1;
    }
    if (n.isSmall) {
      return this.sign ? -1 : 1;
    }
    return compareAbs(a, b) * (this.sign ? -1 : 1);
  };
  BigInteger.prototype.compareTo = BigInteger.prototype.compare;
  SmallInteger.prototype.compare = function(v) {
    if (v === Infinity) {
      return -1;
    }
    if (v === -Infinity) {
      return 1;
    }
    var n = parseValue(v),
      a = this.value,
      b = n.value;
    if (n.isSmall) {
      return a == b ? 0 : a > b ? 1 : -1;
    }
    if (a < 0 !== n.sign) {
      return a < 0 ? -1 : 1;
    }
    return a < 0 ? 1 : -1;
  };
  SmallInteger.prototype.compareTo = SmallInteger.prototype.compare;
  BigInteger.prototype.equals = function(v) {
    return this.compare(v) === 0;
  };
  SmallInteger.prototype.eq = SmallInteger.prototype.equals = BigInteger.prototype.eq =
    BigInteger.prototype.equals;
  BigInteger.prototype.notEquals = function(v) {
    return this.compare(v) !== 0;
  };
  SmallInteger.prototype.neq = SmallInteger.prototype.notEquals = BigInteger.prototype.neq =
    BigInteger.prototype.notEquals;
  BigInteger.prototype.greater = function(v) {
    return this.compare(v) > 0;
  };
  SmallInteger.prototype.gt = SmallInteger.prototype.greater = BigInteger.prototype.gt =
    BigInteger.prototype.greater;
  BigInteger.prototype.lesser = function(v) {
    return this.compare(v) < 0;
  };
  SmallInteger.prototype.lt = SmallInteger.prototype.lesser = BigInteger.prototype.lt =
    BigInteger.prototype.lesser;
  BigInteger.prototype.greaterOrEquals = function(v) {
    return this.compare(v) >= 0;
  };
  SmallInteger.prototype.geq = SmallInteger.prototype.greaterOrEquals = BigInteger.prototype.geq =
    BigInteger.prototype.greaterOrEquals;
  BigInteger.prototype.lesserOrEquals = function(v) {
    return this.compare(v) <= 0;
  };
  SmallInteger.prototype.leq = SmallInteger.prototype.lesserOrEquals = BigInteger.prototype.leq =
    BigInteger.prototype.lesserOrEquals;
  BigInteger.prototype.isEven = function() {
    return (this.value[0] & 1) === 0;
  };
  SmallInteger.prototype.isEven = function() {
    return (this.value & 1) === 0;
  };
  BigInteger.prototype.isOdd = function() {
    return (this.value[0] & 1) === 1;
  };
  SmallInteger.prototype.isOdd = function() {
    return (this.value & 1) === 1;
  };
  BigInteger.prototype.isPositive = function() {
    return !this.sign;
  };
  SmallInteger.prototype.isPositive = function() {
    return this.value > 0;
  };
  BigInteger.prototype.isNegative = function() {
    return this.sign;
  };
  SmallInteger.prototype.isNegative = function() {
    return this.value < 0;
  };
  BigInteger.prototype.isUnit = function() {
    return false;
  };
  SmallInteger.prototype.isUnit = function() {
    return Math.abs(this.value) === 1;
  };
  BigInteger.prototype.isZero = function() {
    return false;
  };
  SmallInteger.prototype.isZero = function() {
    return this.value === 0;
  };
  BigInteger.prototype.isDivisibleBy = function(v) {
    var n = parseValue(v);
    var value = n.value;
    if (value === 0) return false;
    if (value === 1) return true;
    if (value === 2) return this.isEven();
    return this.mod(n).equals(Integer[0]);
  };
  SmallInteger.prototype.isDivisibleBy = BigInteger.prototype.isDivisibleBy;
  function isBasicPrime(v) {
    var n = v.abs();
    if (n.isUnit()) return false;
    if (n.equals(2) || n.equals(3) || n.equals(5)) return true;
    if (n.isEven() || n.isDivisibleBy(3) || n.isDivisibleBy(5)) return false;
    if (n.lesser(49)) return true;
  }
  function millerRabinTest(n, a) {
    var nPrev = n.prev(),
      b = nPrev,
      r = 0,
      d,
      t,
      i,
      x;
    while (b.isEven()) (b = b.divide(2)), r++;
    next: for (i = 0; i < a.length; i++) {
      if (n.lesser(a[i])) continue;
      x = bigInt(a[i]).modPow(b, n);
      if (x.equals(Integer[1]) || x.equals(nPrev)) continue;
      for (d = r - 1; d != 0; d--) {
        x = x.square().mod(n);
        if (x.isUnit()) return false;
        if (x.equals(nPrev)) continue next;
      }
      return false;
    }
    return true;
  }
  BigInteger.prototype.isPrime = function(strict) {
    var isPrime = isBasicPrime(this);
    if (isPrime !== undefined) return isPrime;
    var n = this.abs();
    var bits = n.bitLength();
    if (bits <= 64)
      return millerRabinTest(n, [
        2,
        325,
        9375,
        28178,
        450775,
        9780504,
        1795265022
      ]);
    var logN = Math.log(2) * bits;
    var t = Math.ceil(strict === true ? 2 * Math.pow(logN, 2) : logN);
    for (var a = [], i = 0; i < t; i++) {
      a.push(bigInt(i + 2));
    }
    return millerRabinTest(n, a);
  };
  SmallInteger.prototype.isPrime = BigInteger.prototype.isPrime;
  BigInteger.prototype.isProbablePrime = function(iterations) {
    var isPrime = isBasicPrime(this);
    if (isPrime !== undefined) return isPrime;
    var n = this.abs();
    var t = iterations === undefined ? 5 : iterations;
    for (var a = [], i = 0; i < t; i++) {
      a.push(bigInt.randBetween(2, n.minus(2)));
    }
    return millerRabinTest(n, a);
  };
  SmallInteger.prototype.isProbablePrime = BigInteger.prototype.isProbablePrime;
  BigInteger.prototype.modInv = function(n) {
    var t = bigInt.zero,
      newT = bigInt.one,
      r = parseValue(n),
      newR = this.abs(),
      q,
      lastT,
      lastR;
    while (!newR.equals(bigInt.zero)) {
      q = r.divide(newR);
      lastT = t;
      lastR = r;
      t = newT;
      r = newR;
      newT = lastT.subtract(q.multiply(newT));
      newR = lastR.subtract(q.multiply(newR));
    }
    if (!r.equals(1))
      throw new Error(
        this.toString() + ' and ' + n.toString() + ' are not co-prime'
      );
    if (t.compare(0) === -1) {
      t = t.add(n);
    }
    if (this.isNegative()) {
      return t.negate();
    }
    return t;
  };
  SmallInteger.prototype.modInv = BigInteger.prototype.modInv;
  BigInteger.prototype.next = function() {
    var value = this.value;
    if (this.sign) {
      return subtractSmall(value, 1, this.sign);
    }
    return new BigInteger(addSmall(value, 1), this.sign);
  };
  SmallInteger.prototype.next = function() {
    var value = this.value;
    if (value + 1 < MAX_INT) return new SmallInteger(value + 1);
    return new BigInteger(MAX_INT_ARR, false);
  };
  BigInteger.prototype.prev = function() {
    var value = this.value;
    if (this.sign) {
      return new BigInteger(addSmall(value, 1), true);
    }
    return subtractSmall(value, 1, this.sign);
  };
  SmallInteger.prototype.prev = function() {
    var value = this.value;
    if (value - 1 > -MAX_INT) return new SmallInteger(value - 1);
    return new BigInteger(MAX_INT_ARR, true);
  };
  var powersOfTwo = [1];
  while (2 * powersOfTwo[powersOfTwo.length - 1] <= BASE)
    powersOfTwo.push(2 * powersOfTwo[powersOfTwo.length - 1]);
  var powers2Length = powersOfTwo.length,
    highestPower2 = powersOfTwo[powers2Length - 1];
  function shift_isSmall(n) {
    return (
      ((typeof n === 'number' || typeof n === 'string') &&
        +Math.abs(n) <= BASE) ||
      (n instanceof BigInteger && n.value.length <= 1)
    );
  }
  BigInteger.prototype.shiftLeft = function(n) {
    if (!shift_isSmall(n)) {
      throw new Error(String(n) + ' is too large for shifting.');
    }
    n = +n;
    if (n < 0) return this.shiftRight(-n);
    var result = this;
    if (result.isZero()) return result;
    while (n >= powers2Length) {
      result = result.multiply(highestPower2);
      n -= powers2Length - 1;
    }
    return result.multiply(powersOfTwo[n]);
  };
  SmallInteger.prototype.shiftLeft = BigInteger.prototype.shiftLeft;
  BigInteger.prototype.shiftRight = function(n) {
    var remQuo;
    if (!shift_isSmall(n)) {
      throw new Error(String(n) + ' is too large for shifting.');
    }
    n = +n;
    if (n < 0) return this.shiftLeft(-n);
    var result = this;
    while (n >= powers2Length) {
      if (result.isZero() || (result.isNegative() && result.isUnit()))
        return result;
      remQuo = divModAny(result, highestPower2);
      result = remQuo[1].isNegative() ? remQuo[0].prev() : remQuo[0];
      n -= powers2Length - 1;
    }
    remQuo = divModAny(result, powersOfTwo[n]);
    return remQuo[1].isNegative() ? remQuo[0].prev() : remQuo[0];
  };
  SmallInteger.prototype.shiftRight = BigInteger.prototype.shiftRight;
  function bitwise(x, y, fn) {
    y = parseValue(y);
    var xSign = x.isNegative(),
      ySign = y.isNegative();
    var xRem = xSign ? x.not() : x,
      yRem = ySign ? y.not() : y;
    var xDigit = 0,
      yDigit = 0;
    var xDivMod = null,
      yDivMod = null;
    var result = [];
    while (!xRem.isZero() || !yRem.isZero()) {
      xDivMod = divModAny(xRem, highestPower2);
      xDigit = xDivMod[1].toJSNumber();
      if (xSign) {
        xDigit = highestPower2 - 1 - xDigit;
      }
      yDivMod = divModAny(yRem, highestPower2);
      yDigit = yDivMod[1].toJSNumber();
      if (ySign) {
        yDigit = highestPower2 - 1 - yDigit;
      }
      xRem = xDivMod[0];
      yRem = yDivMod[0];
      result.push(fn(xDigit, yDigit));
    }
    var sum = fn(xSign ? 1 : 0, ySign ? 1 : 0) !== 0 ? bigInt(-1) : bigInt(0);
    for (var i = result.length - 1; i >= 0; i -= 1) {
      sum = sum.multiply(highestPower2).add(bigInt(result[i]));
    }
    return sum;
  }
  BigInteger.prototype.not = function() {
    return this.negate().prev();
  };
  SmallInteger.prototype.not = BigInteger.prototype.not;
  BigInteger.prototype.and = function(n) {
    return bitwise(this, n, function(a, b) {
      return a & b;
    });
  };
  SmallInteger.prototype.and = BigInteger.prototype.and;
  BigInteger.prototype.or = function(n) {
    return bitwise(this, n, function(a, b) {
      return a | b;
    });
  };
  SmallInteger.prototype.or = BigInteger.prototype.or;
  BigInteger.prototype.xor = function(n) {
    return bitwise(this, n, function(a, b) {
      return a ^ b;
    });
  };
  SmallInteger.prototype.xor = BigInteger.prototype.xor;
  var LOBMASK_I = 1 << 30,
    LOBMASK_BI = ((BASE & -BASE) * (BASE & -BASE)) | LOBMASK_I;
  function roughLOB(n) {
    var v = n.value,
      x =
        typeof v === 'number'
          ? v | LOBMASK_I
          : (v[0] + v[1] * BASE) | LOBMASK_BI;
    return x & -x;
  }
  function integerLogarithm(value, base) {
    if (base.compareTo(value) <= 0) {
      var tmp = integerLogarithm(value, base.square(base));
      var p = tmp.p;
      var e = tmp.e;
      var t = p.multiply(base);
      return t.compareTo(value) <= 0
        ? { p: t, e: e * 2 + 1 }
        : { p: p, e: e * 2 };
    }
    return { p: bigInt(1), e: 0 };
  }
  BigInteger.prototype.bitLength = function() {
    var n = this;
    if (n.compareTo(bigInt(0)) < 0) {
      n = n.negate().subtract(bigInt(1));
    }
    if (n.compareTo(bigInt(0)) === 0) {
      return bigInt(0);
    }
    return bigInt(integerLogarithm(n, bigInt(2)).e).add(bigInt(1));
  };
  SmallInteger.prototype.bitLength = BigInteger.prototype.bitLength;
  function max(a, b) {
    a = parseValue(a);
    b = parseValue(b);
    return a.greater(b) ? a : b;
  }
  function min(a, b) {
    a = parseValue(a);
    b = parseValue(b);
    return a.lesser(b) ? a : b;
  }
  function gcd(a, b) {
    a = parseValue(a).abs();
    b = parseValue(b).abs();
    if (a.equals(b)) return a;
    if (a.isZero()) return b;
    if (b.isZero()) return a;
    var c = Integer[1],
      d,
      t;
    while (a.isEven() && b.isEven()) {
      d = Math.min(roughLOB(a), roughLOB(b));
      a = a.divide(d);
      b = b.divide(d);
      c = c.multiply(d);
    }
    while (a.isEven()) {
      a = a.divide(roughLOB(a));
    }
    do {
      while (b.isEven()) {
        b = b.divide(roughLOB(b));
      }
      if (a.greater(b)) {
        t = b;
        b = a;
        a = t;
      }
      b = b.subtract(a);
    } while (!b.isZero());
    return c.isUnit() ? a : a.multiply(c);
  }
  function lcm(a, b) {
    a = parseValue(a).abs();
    b = parseValue(b).abs();
    return a.divide(gcd(a, b)).multiply(b);
  }
  function randBetween(a, b) {
    a = parseValue(a);
    b = parseValue(b);
    var low = min(a, b),
      high = max(a, b);
    var range = high.subtract(low).add(1);
    if (range.isSmall) return low.add(Math.floor(Math.random() * range));
    var length = range.value.length - 1;
    var result = [],
      restricted = true;
    for (var i = length; i >= 0; i--) {
      var top = restricted ? range.value[i] : BASE;
      var digit = truncate(Math.random() * top);
      result.unshift(digit);
      if (digit < top) restricted = false;
    }
    result = arrayToSmall(result);
    return low.add(
      typeof result === 'number'
        ? new SmallInteger(result)
        : new BigInteger(result, false)
    );
  }
  var parseBase = function(text, base) {
    var length = text.length;
    var i;
    var absBase = Math.abs(base);
    for (var i = 0; i < length; i++) {
      var c = text[i].toLowerCase();
      if (c === '-') continue;
      if (/[a-z0-9]/.test(c)) {
        if (/[0-9]/.test(c) && +c >= absBase) {
          if (c === '1' && absBase === 1) continue;
          throw new Error(c + ' is not a valid digit in base ' + base + '.');
        } else if (c.charCodeAt(0) - 87 >= absBase) {
          throw new Error(c + ' is not a valid digit in base ' + base + '.');
        }
      }
    }
    if (2 <= base && base <= 36) {
      if (length <= LOG_MAX_INT / Math.log(base)) {
        var result = parseInt(text, base);
        if (isNaN(result)) {
          throw new Error(c + ' is not a valid digit in base ' + base + '.');
        }
        return new SmallInteger(parseInt(text, base));
      }
    }
    base = parseValue(base);
    var digits = [];
    var isNegative = text[0] === '-';
    for (i = isNegative ? 1 : 0; i < text.length; i++) {
      var c = text[i].toLowerCase(),
        charCode = c.charCodeAt(0);
      if (48 <= charCode && charCode <= 57) digits.push(parseValue(c));
      else if (97 <= charCode && charCode <= 122)
        digits.push(parseValue(c.charCodeAt(0) - 87));
      else if (c === '<') {
        var start = i;
        do {
          i++;
        } while (text[i] !== '>');
        digits.push(parseValue(text.slice(start + 1, i)));
      } else throw new Error(c + ' is not a valid character');
    }
    return parseBaseFromArray(digits, base, isNegative);
  };
  function parseBaseFromArray(digits, base, isNegative) {
    var val = Integer[0],
      pow = Integer[1],
      i;
    for (i = digits.length - 1; i >= 0; i--) {
      val = val.add(digits[i].times(pow));
      pow = pow.times(base);
    }
    return isNegative ? val.negate() : val;
  }
  function stringify(digit) {
    if (digit <= 35) {
      return '0123456789abcdefghijklmnopqrstuvwxyz'.charAt(digit);
    }
    return '<' + digit + '>';
  }
  function toBase(n, base) {
    base = bigInt(base);
    if (base.isZero()) {
      if (n.isZero()) return { value: [0], isNegative: false };
      throw new Error('Cannot convert nonzero numbers to base 0.');
    }
    if (base.equals(-1)) {
      if (n.isZero()) return { value: [0], isNegative: false };
      if (n.isNegative())
        return {
          value: [].concat.apply(
            [],
            Array.apply(null, Array(-n)).map(Array.prototype.valueOf, [1, 0])
          ),
          isNegative: false
        };
      var arr = Array.apply(null, Array(+n - 1)).map(Array.prototype.valueOf, [
        0,
        1
      ]);
      arr.unshift([1]);
      return { value: [].concat.apply([], arr), isNegative: false };
    }
    var neg = false;
    if (n.isNegative() && base.isPositive()) {
      neg = true;
      n = n.abs();
    }
    if (base.equals(1)) {
      if (n.isZero()) return { value: [0], isNegative: false };
      return {
        value: Array.apply(null, Array(+n)).map(Number.prototype.valueOf, 1),
        isNegative: neg
      };
    }
    var out = [];
    var left = n,
      divmod;
    while (left.isNegative() || left.compareAbs(base) >= 0) {
      divmod = left.divmod(base);
      left = divmod.quotient;
      var digit = divmod.remainder;
      if (digit.isNegative()) {
        digit = base.minus(digit).abs();
        left = left.next();
      }
      out.push(digit.toJSNumber());
    }
    out.push(left.toJSNumber());
    return { value: out.reverse(), isNegative: neg };
  }
  function toBaseString(n, base) {
    var arr = toBase(n, base);
    return (arr.isNegative ? '-' : '') + arr.value.map(stringify).join('');
  }
  BigInteger.prototype.toArray = function(radix) {
    return toBase(this, radix);
  };
  SmallInteger.prototype.toArray = function(radix) {
    return toBase(this, radix);
  };
  BigInteger.prototype.toString = function(radix) {
    if (radix === undefined) radix = 10;
    if (radix !== 10) return toBaseString(this, radix);
    var v = this.value,
      l = v.length,
      str = String(v[--l]),
      zeros = '0000000',
      digit;
    while (--l >= 0) {
      digit = String(v[l]);
      str += zeros.slice(digit.length) + digit;
    }
    var sign = this.sign ? '-' : '';
    return sign + str;
  };
  SmallInteger.prototype.toString = function(radix) {
    if (radix === undefined) radix = 10;
    if (radix != 10) return toBaseString(this, radix);
    return String(this.value);
  };
  BigInteger.prototype.toJSON = SmallInteger.prototype.toJSON = function() {
    return this.toString();
  };
  BigInteger.prototype.valueOf = function() {
    return parseInt(this.toString(), 10);
  };
  BigInteger.prototype.toJSNumber = BigInteger.prototype.valueOf;
  SmallInteger.prototype.valueOf = function() {
    return this.value;
  };
  SmallInteger.prototype.toJSNumber = SmallInteger.prototype.valueOf;
  function parseStringValue(v) {
    if (isPrecise(+v)) {
      var x = +v;
      if (x === truncate(x)) return new SmallInteger(x);
      throw new Error('Invalid integer: ' + v);
    }
    var sign = v[0] === '-';
    if (sign) v = v.slice(1);
    var split = v.split(/e/i);
    if (split.length > 2)
      throw new Error('Invalid integer: ' + split.join('e'));
    if (split.length === 2) {
      var exp = split[1];
      if (exp[0] === '+') exp = exp.slice(1);
      exp = +exp;
      if (exp !== truncate(exp) || !isPrecise(exp))
        throw new Error(
          'Invalid integer: ' + exp + ' is not a valid exponent.'
        );
      var text = split[0];
      var decimalPlace = text.indexOf('.');
      if (decimalPlace >= 0) {
        exp -= text.length - decimalPlace - 1;
        text = text.slice(0, decimalPlace) + text.slice(decimalPlace + 1);
      }
      if (exp < 0)
        throw new Error('Cannot include negative exponent part for integers');
      text += new Array(exp + 1).join('0');
      v = text;
    }
    var isValid = /^([0-9][0-9]*)$/.test(v);
    if (!isValid) throw new Error('Invalid integer: ' + v);
    var r = [],
      max = v.length,
      l = LOG_BASE,
      min = max - l;
    while (max > 0) {
      r.push(+v.slice(min, max));
      min -= l;
      if (min < 0) min = 0;
      max -= l;
    }
    trim(r);
    return new BigInteger(r, sign);
  }
  function parseNumberValue(v) {
    if (isPrecise(v)) {
      if (v !== truncate(v)) throw new Error(v + ' is not an integer.');
      return new SmallInteger(v);
    }
    return parseStringValue(v.toString());
  }
  function parseValue(v) {
    if (typeof v === 'number') {
      return parseNumberValue(v);
    }
    if (typeof v === 'string') {
      return parseStringValue(v);
    }
    return v;
  }
  for (var i = 0; i < 1e3; i++) {
    Integer[i] = new SmallInteger(i);
    if (i > 0) Integer[-i] = new SmallInteger(-i);
  }
  Integer.one = Integer[1];
  Integer.zero = Integer[0];
  Integer.minusOne = Integer[-1];
  Integer.max = max;
  Integer.min = min;
  Integer.gcd = gcd;
  Integer.lcm = lcm;
  Integer.isInstance = function(x) {
    return x instanceof BigInteger || x instanceof SmallInteger;
  };
  Integer.randBetween = randBetween;
  Integer.fromArray = function(digits, base, isNegative) {
    return parseBaseFromArray(
      digits.map(parseValue),
      parseValue(base || 10),
      isNegative
    );
  };
  return Integer;
})();
if (typeof module !== 'undefined' && module.hasOwnProperty('exports')) {
  module.exports = bigInt;
}
if (typeof define === 'function' && define.amd) {
  define('big-integer', [], function() {
    return bigInt;
  });
}

function substract(a, b) {
  if (a.eq(0) || b.eq(0)) {
    return { a, b };
  } else if (a.greaterOrEquals(b.multiply(2))) {
    a = a.mod(2 * b);
    return substract(a, b);
  } else if (b.greaterOrEquals(a.multiply(2))) {
    b = b.mod(2 * a);
    return substract(a, b);
  } else {
    return { a, b };
  }
}

const nd = readline().split(' ');

const result = substract(nd[0], nd[1]);

print(result.a.toJSNumber() + ' ' + result.b.toJSNumber() + '\n');