Project Euler 251(unsolved)

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

package {
    import flash.display.Sprite;
    import flash.text.TextField;
    import flash.utils.getTimer;
    import flash.events.*;
    import com.bit101.components.*;
    // @see http://projecteuler.net/index.php?section=problems&id=251
    public class Euler251 extends Sprite {
        private var _tf : TextField;
        private var _primes : Array;
  
        public function Euler251() {
            _tf = new TextField();
            _tf.width = 465;
            _tf.height = 465;
            addChild(_tf);
            
            var pb : PushButton = new PushButton(this, 350, 10);
            pb.label = "stop";
            pb.width = 100;
            pb.addEventListener(MouseEvent.CLICK, function(e : MouseEvent) : void
            {
                removeEventListener(Event.ENTER_FRAME, onEnterFrame);
            });
            
            _s = getTimer();
            solve();
            tr((getTimer() - _s) + " ms");
        }
        
        private var _s : int;
        
//        private static const N : int = 110000000;
        private static const N : int = 1000;
        
        private var ct : Number;
        private var m : uint;
        private var M : int;
        
        // b^2 c = a^2 - ((1-2a)/3)^3
        // -> a = 2(mod 3)
        // a = 3m - 1として
        // 右辺=(8m-3)m^2
        private function solve() : void
        {
            var start : int = 0;
            var end : int = N;
            do{
                var mid : int = (start + end) >> 1;
                if(mid * mid * (8 * mid - 3) - 4 / 27 * Math.pow(N - (3 * mid - 1), 3) > 0){
                    end = mid;
                }else{
                    start = mid;
                }
            }while(end - start > 1);
            M = start + 1;
            tr("M : " + M);
//            M += 100;
            
            _primes = doEratosthenes(Math.sqrt(8 * M - 3));
            _primes.shift();
            
            _ccs = new Array(M);
            var i : uint;
            for(i = 0;i < M;i++){
                _ccs[i] = 8 * i + 5;
            }
            
            for each(var p : uint in _primes){
                var pp : uint = p * p;
                var inv8 : uint = exmod(8, totient(pp) - 1, pp);
                var cor : uint = (inv8 * (pp - 5)) % pp;
                for(i = cor;i < M;i += pp){
                    while(_ccs[i] % pp == 0){
                        _ccs[i] /= pp;
                    }
                }
                
//                tr(p, inv8, cor);
            } 
            
            addEventListener(Event.ENTER_FRAME, onEnterFrame);
            /*
            for(i = M-100;i < M;i++){
                tr(i, _ccs[i]);
            }
            
            var xxx : Number = 16224756;
            tr(Math.sqrt((8 * xxx - 3) / _ccs[xxx-1]));
            */
            
            m = 16000001;
//            m = 1;
            ct = 0;
        }
        
        private var _ccs : Array;
        
        private function exmod(a : uint, b : uint, m : uint) : uint
        {
            var i : uint;
            var ret : Number = 1;
            var mul : Number = a;
            for(i = b;i;i >>>= 1){
                if(i & 1){
                    ret = (ret * mul) % m;
                }
                mul = (mul * mul) % m;
            }
            return ret;
        }
        
        private function onEnterFrame(e : Event) : void
        {
            var goal : int = m + 200000;
            var i : int, j : uint, k : uint, p : int;
            for(;m < goal && m <= M;m++){
                /*
                var cc : int = 8 * m - 3;
                var sc : Number = Math.sqrt(cc);
                var bb : int = m;
                for each(p in _primes){
                    if(p > sc)break;
                    while(cc % (p * p) == 0){
                        cc /= (p * p);
                        sc /= p;
                        bb *= p;
                    } 
                }
                */
                var cc : Number = _ccs[m-1];
                var X : Number = m * m * (8 * m - 3);
                var bb : Number = Math.sqrt((8 * m - 3) / _ccs[m-1]) * m;
                
                var f : Object = factor(bb);
                var divs : Array = [1];
                for(var keystr : String in f){
                    var key : uint = uint(keystr);
                    var val : uint = f[keystr];
                    var lim : uint = divs.length;
                    for(i = 0, j = key;i < val;i++, j *= key){
                        for(k = 0;k < lim;k++){
                            divs.push(divs[k] * j);
                        }
                    }
                }
                if(m > 16224700){
                    tr(m, bb, divs); 
                }
                
                var a : uint = 3 * m - 1;
                var c : Number;
                for each(var b : Number in divs){
                    c = cc * (bb / b) * (bb / b);
                    if(a + b + c <= N){
//                        if(m > 16200000){
//                            tr(a,b,c,m);
//                        }
                        ct++;
                    }
                }
            }
            if(m > M){ 
                tr("solved! " + (getTimer() - _s) + "ms");
                tr(ct);
                removeEventListener(Event.ENTER_FRAME, onEnterFrame);
            }
            if(m % 200000 == 1)tr(m, ct, (getTimer() - _s) + "ms");
        }
        
        private var _ps : Array = doEratosthenes(Math.sqrt(16224756));
        
        private function factor(n : int) : Object
        {
            var ret : Object = {};
            for each(var i : uint in _ps){ 
                if(i * i > n)break;
                var ct : int = 0;
                while(n % i == 0){
                    n /= i;
                    ct++;
                }
                if(ct > 0){
                    ret[i] = ct;
                }
            }
            if(n != 1){
                ret[n] = 1;
            }
            return ret;
        }
                
        private function doEratosthenes(n : int) : Array
        {
            var nn : uint = ((n / 2 - 1) >>> 5) + 1;
            var ar : Vector.<uint> = new Vector.<uint>(nn);
            var i : uint, j : uint;
            for(i = 0;i < nn - 1;i++)ar[i] = 0xffffffff;
            ar[nn - 1] = (1 << ((n / 2 - 1) & 31)) - 1;
            
            var sq : uint = (Math.sqrt(n) - 3) >>> 1;
            for(var p : uint = 0;p <= sq;p++){
                if(ar[p >>> 5] & (1 << (p & 31))){
                    var m : uint = (p << 1) + 3;
                    var m2 : uint = m << 1;
                    for(var mm : uint = m * m;mm <= n;mm += m2){
                        var ind : uint = (mm - 3) >>> 1;
                        ar[ind >>> 5] &= ~(1 << (ind & 31));
                    }
                }
            }
            
            var ret : Array = [2];
            for(i = 0;i < nn;i++){
                for(j = 0;j <= 31;j++){
                    if(ar[i] & (1 << j))ret.push((((i << 5) | j) << 1) + 3);
                }
            }
            return ret;
        }
        
        private function totient(n : uint) : uint
        {
            if(n == 0)return 0;
            var ret : uint = n;
            for(var x : uint = 2;x * x <= n;++x){
                if(n % x == 0){
                    ret -= ret / x;
                    do{n /= x;}while(n % x == 0);
                }
            }
            if(n > 1)ret -= ret / n;
            return ret;
        }
        
        private function carmichaelLambda(n : uint) : uint
        {
            var ret : uint = 1;
            if(n % 8 == 0)n /= 2;
            for(var d : uint = 2;d <= n;d++){
                if(n % d == 0){
                    var y : uint = d - 1;
                    n /= d;
                    while(n % d == 0){
                        n /= d;
                        y *= d;
                    }
                    ret = ret * y / GCD(ret, y);
                }
            }
            return ret;
        }
        
        private function GCD(a : uint, b : uint) : uint
        {
            while(b > 0){
                var c : uint = a;
                a = b;
                b = c % b;
            }
            return a;
        }
        
        private function tr(...o : Array) : void
        {
            _tf.appendText(o + "\n");
            _tf.scrollV = _tf.maxScrollV;
        }
    }
}