code guessing, round #17 (completed)

[0][0]#{ FALSE Polyglot because why not (Tested on TIO)
# All the [0][0]#{ are to create comments in FALSE
import sys

code = r'''
{ Get integer from stdin }
0^[$1_>]['0-\10*+^]#%
{ Store in a }
a:
{ Flag for primality }
a;1=b:
{ Loop from a to 2, if divisible then set flag }
a;[1-$1>][$$a;\/*a;=b;|b:]#
%
{ Print result (add one; -1 (not prime) => 0; 0 (prime) => 1) }
1b;+.
''' 
[0][0]#{

class Interpreter:
    class Variable:
        def __init__(self, name):
            self.name = name
    class Lambda:
        def __init__(self, code):
            self.code = code

    def __init__(self, code, vars = None, stack = None):
        self.code = code
        self.pos = 0

        self.vars = vars or dict()
        self.stack = stack or list()

        self.input = sys.stdin
        self.output = sys.stdout

    def set_input(self, inp):
        self.input = inp

    def set_output(self, out):
        self.output = out

    def run(self):
        while True:
            self.skip_whitespace()
            if self.current_char() == None:
                return
            elif self.current_char() == '{':
                self.skip_comment()
            elif self.current_char() == '\'':
                self.advance()
                self.stack.append(ord(self.current_char()))
                self.advance()
            elif self.current_char() == '$':
                self.stack.append(self.stack[-1])
                self.advance()
            elif self.current_char() == '%':
                self.stack.pop()
                self.advance()
            elif self.current_char() == '\\':
                self.swap()
                self.advance()
            elif self.current_char() == '@':
                self.rotate()
                self.advance()
            elif self.current_char() == 'ø':
                self.pick()
                self.advance()
            elif self.current_char() == '+':
                self.stack.append(self.stack.pop() + self.stack.pop())
                self.advance()
            elif self.current_char() == '-':
                a = self.stack.pop()
                self.stack.append(self.stack.pop() - a)
                self.advance()
            elif self.current_char() == '*':
                self.stack.append(self.stack.pop() * self.stack.pop())
                self.advance()
            elif self.current_char() == '/':
                q = self.stack.pop()
                self.stack.append(self.stack.pop() // q)
                self.advance()
            elif self.current_char() == '_':
                self.stack.append(-self.stack.pop())
                self.advance()
            elif self.current_char() == '&':            
                self.stack.append(self.stack.pop() & self.stack.pop()) 
                self.advance()
            elif self.current_char() == '|':            
                self.stack.append(self.stack.pop() | self.stack.pop()) 
                self.advance()
            elif self.current_char() == '~':            
                self.stack.append(~self.stack.pop())
                self.advance()
            elif self.current_char() == '>':         
                b = self.stack.pop()
                self.stack.append(-1 if self.stack.pop() > b else 0) 
                self.advance()
            elif self.current_char() == '=':         
                b = self.stack.pop()
                self.stack.append(-1 if self.stack.pop() == b else 0) 
                self.advance()
            elif self.current_char() == '[':         
                self.push_lambda()
            elif self.current_char() == '#':
                self.advance()
                self.while_loop()
            elif self.current_char().isdigit():
                self.push_num()
            elif self.current_char().isalpha():
                self.stack.append(__class__.Variable(self.current_char()))
                self.advance()
            elif self.current_char() == ':':
                var = self.stack.pop()
                self.vars[var.name] = self.stack.pop()
                self.advance()
            elif self.current_char() == ';':
                var = self.stack.pop()
                self.stack.append(self.vars[var.name])
                self.advance()
            elif self.current_char() == '^':
                ch = self.input.read(1)
                self.stack.append(ord(ch) if ch else -1)
                self.advance()
            elif self.current_char() == '.':
                self.output.write(str(self.stack.pop()))
                self.advance()
            else:
                raise Exception("Invalid character " + self.current_char())
    def push_lambda(self):
        self.advance()
        res = ''
        while self.current_char() != ']':
            res += self.current_char()
            self.advance()
        self.advance()
        self.stack.append(__class__.Lambda(res))

    def run_lambda(self, l):
        lambda_runner = Interpreter(l.code, self.vars, self.stack)
        lambda_runner.set_input(self.input)
        lambda_runner.set_output(self.output)
        lambda_runner.run()

    def while_loop(self):
        body = self.stack.pop()
        cond = self.stack.pop()
        while True:
            self.run_lambda(cond)
            if self.stack.pop() == 0:
                break
            else:
                self.run_lambda(body)

    def pick(self):
        i = self.stack.pop() + 1
        val = self.stack.pop(-i)
        self.stack.append(val)
    def rotate(self):
        a = self.stack.pop(0)
        self.stack.append(a)

    def swap(self):
        a = self.stack.pop()
        b = self.stack.pop()
        self.stack.append(a)
        self.stack.append(b)

    def push_num(self):
        res = 0

        while self.current_char() and self.current_char().isdigit():
            res = res * 10 + int(self.current_char())
            self.advance()

        self.stack.append(res)

    def skip_whitespace(self):
        while self.current_char() and self.current_char().isspace():
            self.advance()

    def skip_comment(self):
        while self.current_char() != '}':
            [0][0]#{
            self.advance()
        self.advance()

    def current_char(self):
        try:
            return self.code[self.pos]
        except:
            return None

    def advance(self):
        self.pos += 1

from io import StringIO

def entry(n):
    interpreter = Interpreter(code)
    inp = StringIO(str(n))
    out = StringIO()
    interpreter.set_input(inp)
    interpreter.set_output(out)
    interpreter.run()
    return out.getvalue() == '1'

[0][0]# If you're reading this you're a cool person :) }

1m:[[^$1_=~][48-\10*+]#%]y:[$$3ø$@/@*-]r:
47 ^$z:$$3ø>\58\>&$p:[48-y;!$h: $1=[0m:]?
2[$2ø>~m;0=~&][r;!0=$[0m:]?~[\]?]# h;2=$[
1.]?~[m;.]?]?p;~[z;'X=$[^^^^^'*=$["DWN"]?
~["RGT"]?%%%%]?~[^^^^^'*=$["UPP"]?~["LFT"
]?]?]?

const PRIMES: &[u8] = include_bytes!("primes.32b"); // http://www.umopit.ru/CompLab/primes32.htm
const NUM_PRIMES: usize = PRIMES.len() / 4;
const LAST: u32 = prime_at(NUM_PRIMES - 1);

const fn prime_at(index: usize) -> u32 {
    u32::from_le_bytes([
        PRIMES[index * 4],
        PRIMES[index * 4 + 1],
        PRIMES[index * 4 + 2],
        PRIMES[index * 4 + 3],
    ])
}

pub fn entry(num: u32) -> bool {
    if num < 2 {
        false
    } else if num == 2 {
        true
    } else if num > LAST {
        false
    } else {
        let mut lo = 0;
        let mut hi = NUM_PRIMES - 1;
        let mut isp = false;
        while lo <= hi {
            let guess = lo + (hi - lo) / 2;
            let p = prime_at(guess);
            use std::cmp::Ordering::*;
            match num.cmp(&p) {
                Equal => {
                    isp = true;
                    break;
                }
                Less => hi = guess - 1,
                Greater => lo = guess + 1,
            }
        }
        isp
    }
}

{Code by SoundOfSpouting#6980 (UID: 151149148639330304)}
{This prime tester may randomly call some primes composite for large inputs depending on the FALSE interpreter you use.
This is due to integer overflow. In theory, it should correctly label all numbers below 2^16.}
[$@$@/@*-]m:
0^[$1+][48-\10*+^]#%$1-[$1&1-$[%2=$["1"]?~["0"]?1_$]?~[
	$n:0\1-[$1&1-][\1+\2/]#d:r:
	1 0 61 7 2
	[$][a:1
		d;
		[$][1-\a;*n;m;!\]#
		%$$$1=\n;1-=|~&
		$[
			%0\r;
			[1-$][
				\$*n;m;!
				$n;1-=[@%1_@@]?
				\
			]#
			%%$~["0"1_0 0 1_]?
		]?~[%]?
	]#
	%["1"1_]?
]?
]?~["0"]?

// Code by SoundOfSpouting#6980 (UID: 151149148639330304)
int entry(int N)
{
   int M=1;
   for(int L=2;L<N;++L)
   {
      M*=L;
   }
   return 1-(M+1)%N;
}

enum Space (Gap => '.', Star => '*', Strudel => '@', Cross => 'X', Naught => 'O');

sub postfix:<space>($_) {
   Space($_)
}

sub swap($_) { # swap sides
   when Strudel { Star }
   when Star { Strudel }
   when Cross { Naught }
   when Naught { Cross }
   default { Gap }
}

sub back($_) {
   when 'd' { 'u' }
   when 'u' { 'd' }
   when 'r' { 'l' }
   when 'l' { 'r' }
   'n'
}

sub infix:<taxi>(@a, @b) { # taxicab distance
   [+] (@a Z- @b)>>.abs
}

sub honcho($_) {
   when Naught { Strudel }
   when Cross { Star }
   $_
}

class GameBoard {
   has @.grid is rw;
   has $.ally is rw;

   method to-string {
      "{ $!ally.value }\n" ~ @!grid.deepmap({.value}).map(*.join).join("\n")
   }

   method score {
      my $otal = 0;
      for @!grid {
         for @$_ {
            when Star | Cross {
               $otal++;
            }
            when Strudel | Naught {
               $otal--;
            }
         }
      }
      given $!ally {
         when Naught { $otal }
         default { -$otal }
      }
   }

   method ally-pos {
      self.nearest(0, 0){honcho($!ally)}
   }

   method enemy-pos {
      self.nearest(0, 0){honcho(swap($!ally))}
   }

   method get($x, $y) {
      @!grid[$x][$y]
   }

   method nearest($x, $y) {
      my %ashmap;
      for ^@!grid -> $i {
         for ^@!grid[$i] -> $j {
            given %ashmap{ self.get($i, $j) } //= ($i, $j) { # insert into hasmap if unset
               when (* taxi ($x, $y)) < (($i, $j) taxi ($x, $y)) { # compare distance
                  %ashmap{ self.get($i, $j) } = ($i, $j);
               }
            }
         }
      }
      %ashmap
   }

   method pathfind($a, $b) {
      my ($c, $d) = self.ally-pos;
      when $b > $d {
         # does horizontal first so more likely to complete boxes as an accident
         'r'
      }
      when $b < $d {
         'l'
      }
      when $a > $c {
         'd'
      }
      when $a < $c {
         'u'
      }
      'n'
   }

   method pathfind2($a, $b) {
      my ($c, $d) = self.ally-pos;
      when $a > $c {
         'd'
      }
      when $a < $c {
         'u'
      }
      when $b > $d {
         'r'
      }
      when $b < $d {
         'l'
      }
      'n'
   }

   method flow($a, $b) {
      <
         rrrrrrrrrrrrrrrrdddddddddddddddd
         uuuuuuuuuuuuuuuudddddddddddddddd
         uuuuuuuuuuuuuuuudddddddddddddddd
         uuuuuuuuuuuuuuuudddddddddddddddd
         uuuuuuuuuuuuuuuudddddddddddddddd
         uuuuuuuuuuuuuuuudddddddddddddddd
         uuuuuuuuuuuuuuuudddddddddddddddd
         rrrrrrrrrrrrrrrurrrrrrrrrrrrrrrd
         ullllllllllllllldlllllllllllllll
         uuuuuuuuuuuuuuuudddddddddddddddd
         uuuuuuuuuuuuuuuudddddddddddddddd
         uuuuuuuuuuuuuuuudddddddddddddddd
         uuuuuuuuuuuuuuuudddddddddddddddd
         uuuuuuuuuuuuuuuudddddddddddddddd
         uuuuuuuuuuuuuuuudddddddddddddddd
         uuuuuuuuuuuuuuuullllllllllllllll
      >>>.comb[$a][$b]
   }

   method go {
      if self.score > 1 { # winning
         when (self.enemy-pos taxi self.ally-pos) %% 2 {
            'n' # wait
         }
         # go to enemy
         self.pathfind(|self.enemy-pos)
      } else {
         given self.ally-pos {
            # avoid enemy
            when (self.enemy-pos taxi *) == 2 {
               if (self.pathfind(|self.enemy-pos) | self.pathfind2(|self.enemy-pos)) ~~ self.flow(|self.ally-pos) {
                  back(self.flow(|self.ally-pos))
               } else {
                  self.flow(|self.ally-pos)
               }
            }
            # get more score
            # go to good spot
            self.flow(|$_)
         }
      }
   }
}
=my plan was
look for bits where enemy is making 1-wide path with nothing on either side
to ruin all its borders and not get stuck
but that was too hard so its only this instead

sub MAIN {
   my $type = (get)space;
   my @big = lines>>.comb()>>space;
   my $oard = GameBoard.new(grid => @big, ally => $type);
   say $oard.go;
}

# prime time
our proto entry(|) {*}

subset Tiny of Int where * < 10;
multi entry(Tiny $nput) { # known primes <10
   $nput ~~ one(2, 3, 5, 7)
}

subset Small of Int where * < 100;
multi entry(Small $nput) {
   given $nput.comb.tail {
      when any(0,2...^10) { False } # even numbers
      when 5 { False } # ends in 5
      when $nput.comb.sum ~~ one(1..5) * 3 { False } # multiple of 3 <99
      when 1 ^ $nput.comb.head ^ 1 { False } # multiple of 11 >11
      when seven($nput) { False }
      default { True } # no prime factor <sqrt(100)
   } # <3
}

subset Medium of Int where * < 1000000;
multi entry(Medium $nput) {
   when proven-composite($nput) { False }
   when (given $nput - 1 { factorial($_, $nput) ~~ $_ }) { True } # wilson's theorem
}

multi entry(Int $_) {
   when proven-composite($_) { False }
   default { hard-prime($_) }
}

our sub proven-composite(Int $_) { # finds easy composite numbers
   when 1..^100 { !entry($_) }
   when * % 6 == none(1, 5) { True } # != 1 or -1 mod 6
   when !($_ * $_ % 24 ~~ 1) { True } # != 1 mod 24
   when * %% (7 | 5) { True }
}

sub seven(int $nput) { # 7
   given -$nput.comb.head(*-1).join + 2 * ($nput % 10) { # double last digit - other digits
      when 0|7 { True }
      when -6..13 { False }
      default { seven(abs($_)) }
   }
}

sub factorial(Int $nput is copy, Int $odulus) {
   my $otal = 1;
   loop (;$nput > 0;) {
      $otal %= $odulus;
      $otal *= $nput--;
      if !$otal { last; }
   }
   $otal % $odulus
}

our sub hard-prime(int $_) { # trial division
   $_ <= 1 !|| $_ %% any(2..$_.sqrt)
}

#include <stdio.h>
#include <stdbool.h>

// Multiply a and b via long multiplication
#define M(a, b) ((long)a * b) % i

int entry(int);
bool is_multiple_of(int, int, int, int);

int main(void) {
    int i;
    while (scanf("%d", &i) != -1)
        printf("%s\n", entry(i) ? "prime" : "composite");
}

// returns 1 if i is prime, 0 if it is composite
int entry(int i) {
    // the smallest prime number is 2
    if (i < 2) return false;
    // here are some prime numbers
    if (i == 2 || i == 3 || i == 5 || i == 7) return true;

    int am = 0;
    int logos = i - 1;
    while ((logos & 1) == 0) {
        logos >>= 1;
        am++;
    }

    // Check for composite numbers that are multiples of the primes discovered so far
    // This is valid up until at least 121, a very big number
    return (
        !is_multiple_of(i, am, logos, 2) &&
        !is_multiple_of(i, am, logos, 3) &&
        !is_multiple_of(i, am, logos, 5) &&
        !is_multiple_of(i, am, logos, 7));
}

int squizzle(int lo, int i, int hi) {
    int r = 1;
    lo %= i;
    while (hi) {
        if (hi & 1) r = M(r, lo);
        lo = M(lo, lo);
        hi >>= 1;
    }
    return r;
}

bool is_multiple_of(int i, int really, int didnt_obfuscate_this, int be_happy) {
    int l = i - 1;
    int o = squizzle(be_happy, i, didnt_obfuscate_this);
    if (1 == o || o == l) return false;
    for (int nearly = 1; nearly < really; nearly++) {
        o = M(o , o);
        if (l == o || o == l) return false;
    }
    return true;
}

my&entry=&is-prime;

static mut RAIL: Vec<usize> = Vec::new();
static mut TOP: usize = 0;

fn raw_brute_prime(p: i32) -> bool {
    for i in 2..f64::sqrt(p as f64).round() as i32 + 1 {
        //TST[4] += 1;
        if p % i == 0 {
            return false;
        }
    }
    return true;
}
fn brute_prime(p: usize, lock: usize) -> bool {
    for i in 2..lock {
        if p % i == 0 {
            return false;
        }
    }
    return true;
}

unsafe fn primeband(n: usize, lock: usize) -> bool {
    let mut prime_count: usize = 0;
    let mut e: usize; let mut j: usize;
    let mut v: Vec<usize> = (2..n+1).collect();
    //Lock is TOP bound, sqrt n as usize + 1
    //Pass through the band
    for i in 0..lock { //Early exit with square root.
        //e not prime = there exits a and b whith axb = e, then a or b are <= sqrt(e).
        e = v[i];
        if e != 0 {
            prime_count += 1;
            j = e + i;
            while j < n - 1 { //bounce from value to value.
                v[j] = 0;
                j += e;
            }
        }
    }
    //railh.reserve(prime_count);
    RAIL.reserve(prime_count * 2); //By all means not the right amount.
    for i in 0..n-1 { //All != 0 are primes. 
        e = v[i]; 
        if e != 0 {
            RAIL.push(e);
        }
    }
    TOP = n;
    return RAIL.last().unwrap() == &n;
    //return railh.contains(&n);
}
unsafe fn extendedprimeband(n: usize, lock: usize) -> bool {
    //Primeband, but takes in account the already existing prime list.
    //let bottom;
    match RAIL.last() { //Nothing to process?
        Some(i) => {if i >= &n { return false; }}, // else { bottom = *i; }
        None => return primeband(n, lock),
    }
    let mut prime_count: usize = 0;
    let mut e: usize; let mut j: usize;
    let mut v: Vec<usize> = (TOP+1..n+1).collect(); //fill the band. values from TOP+1 to n incuded.
    //let lock = f64::sqrt(n as f64).round() as usize + 1; //TOP bound for calculations; cf primeband.
    //First pass: the original band.
    let mut g = 0; e = RAIL[0];
    while g < RAIL.len() - 1 && e <= lock {
        e = RAIL[g];
        j = e - (TOP + 1) % e; //sets staring point.
        //option 2 for setting starting point: (should by all means be slower)
        /*j = 0;
        while j < v.len() && (v[j] == 0 || v[j] % e != 0) {
            j += 1;
        }*/
        while j < v.len() {
            v[j] = 0;
            j += e;
        }
        g += 1;
    }
    //Second pass: extending the band using an adaptation of erathosthene's method
    //Not exacty sure of how that part works, not going to question it.
    //g = 0; while g < v.len() && v[g] <= lock //the other option, slower apparently. Again not sure why or how but hey.
    for i in 0..f64::sqrt(v.len() as f64).round() as usize + 1 {
        e = v[i];
        if e != 0 {
            prime_count += 1;
            j = e + i;
            while j < v.len() {
                v[j] = 0;
                j += e;
            }
        }
    }
    RAIL.reserve(prime_count * 2); //Not enough, but a start. 
    for i in 0..v.len() { //All != 0 are primes. 
        e = v[i]; 
        if e != 0 { 
            RAIL.push(e);
        }
    }
    TOP = n;
    return RAIL.last().unwrap() == &n;
}

unsafe fn resolve_band(p: usize, lock: usize) -> bool { 
    //where TOP < p <= TOP * TOP, RAIL not empty.
    let mut i: usize = 0; let mut e = RAIL[0];
    while i < RAIL.len() && e <= lock {
        e = RAIL[i];
        if p == RAIL[i] { return true; } //doubles as a fastcheck.
        if p % e == 0 {
            return false;
        }
        i += 1;
    }
    return true;
}
/* Not a good tradeoff.
unsafe fn fastcheck(p: usize) -> bool {
    for i in 0..RAIL.len() {
        if p == RAIL[i] { return true; }
        if p < RAIL[i] { return false; }
    }
    return false;
}*/


unsafe fn resolve(p: usize) -> bool { //Damn you and your I32 >:(
    //assumed that p > 1.
    let lock = f64::sqrt(p as f64) as usize;
    if TOP == 0 {
        return primeband(p, lock);
    } else if TOP >= lock { 
        return resolve_band(p, lock);
    } else if TOP <= p * p {
        return extendedprimeband(lock * 2, f64::sqrt(lock as f64) as usize);
    } else { //Outside of the scope of this project.
        return brute_prime(p, lock);
    }
}
fn entry(p: i32) -> bool {
    if p < 2 { return false; }
    unsafe {
        return resolve(p as usize);
    }
}

use std::time;
extern crate rand;
use rand::Rng;
use std::env;

static mut RAIL: Vec<usize> = Vec::new();
static mut TOP: usize = 0;

fn raw_brute_prime(p: i32) -> bool {
    for i in 2..f64::sqrt(p as f64).round() as i32 + 1 {
        //TST[4] += 1;
        if p % i == 0 {
            return false;
        }
    }
    return true;
}
fn brute_prime(p: usize, lock: usize) -> bool {
    for i in 2..lock {
        if p % i == 0 {
            return false;
        }
    }
    return true;
}

unsafe fn primeband(n: usize, lock: usize) -> bool {
    let mut prime_count: usize = 0;
    let mut e: usize; let mut j: usize;
    let mut v: Vec<usize> = (2..n+1).collect();
    //Lock is TOP bound, sqrt n as usize + 1
    //Pass through the band
    for i in 0..lock { //Early exit with square root.
        //e not prime = there exits a and b whith axb = e, then a or b are <= sqrt(e).
        e = v[i];
        if e != 0 {
            prime_count += 1;
            j = e + i;
            while j < n - 1 { //bounce from value to value.
                v[j] = 0;
                j += e;
            }
        }
    }
    //railh.reserve(prime_count);
    RAIL.reserve(prime_count * 2); //By all means not the right amount.
    for i in 0..n-1 { //All != 0 are primes. 
        e = v[i]; 
        if e != 0 {
            RAIL.push(e);
        }
    }
    TOP = n;
    return RAIL.last().unwrap() == &n;
    //return railh.contains(&n);
}
unsafe fn extendedprimeband(n: usize, lock: usize) -> bool {
    //Primeband, but takes in account the already existing prime list.
    //let bottom;
    match RAIL.last() { //Nothing to process?
        Some(i) => {if i >= &n { return false; }}, // else { bottom = *i; }
        None => return primeband(n, lock),
    }
    let mut prime_count: usize = 0;
    let mut e: usize; let mut j: usize;
    let mut v: Vec<usize> = (TOP+1..n+1).collect(); //fill the band. values from TOP+1 to n incuded.
    //let lock = f64::sqrt(n as f64).round() as usize + 1; //TOP bound for calculations; cf primeband.
    //First pass: the original band.
    let mut g = 0; e = RAIL[0];
    while g < RAIL.len() - 1 && e <= lock {
        e = RAIL[g];
        j = e - (TOP + 1) % e; //sets staring point.
        //option 2 for setting starting point: (should by all means be slower)
        /*j = 0;
        while j < v.len() && (v[j] == 0 || v[j] % e != 0) {
            j += 1;
        }*/
        while j < v.len() {
            v[j] = 0;
            j += e;
        }
        g += 1;
    }
    //Second pass: extending the band using an adaptation of erathosthene's method
    //Not exacty sure of how that part works, not going to question it.
    //g = 0; while g < v.len() && v[g] <= lock //the other option, slower apparently. Again not sure why or how but hey.
    for i in 0..f64::sqrt(v.len() as f64).round() as usize + 1 {
        e = v[i];
        if e != 0 {
            prime_count += 1;
            j = e + i;
            while j < v.len() {
                v[j] = 0;
                j += e;
            }
        }
    }
    RAIL.reserve(prime_count * 2); //Not enough, but a start. 
    for i in 0..v.len() { //All != 0 are primes. 
        e = v[i]; 
        if e != 0 { 
            RAIL.push(e);
        }
    }
    TOP = n;
    return RAIL.last().unwrap() == &n;
}

unsafe fn resolve_band(p: usize, lock: usize) -> bool { 
    //where TOP < p <= TOP * TOP, RAIL not empty.
    let mut i: usize = 0; let mut e = RAIL[0];
    while i < RAIL.len() && e <= lock {
        e = RAIL[i];
        if p == RAIL[i] { return true; } //doubles as a fastcheck.
        if p % e == 0 {
            return false;
        }
        i += 1;
    }
    return true;
}
/* Not a good tradeoff.
unsafe fn fastcheck(p: usize) -> bool {
    for i in 0..RAIL.len() {
        if p == RAIL[i] { return true; }
        if p < RAIL[i] { return false; }
    }
    return false;
}*/


unsafe fn resolve(p: usize) -> bool { //Damn you and your I32 >:(
    //assumed that p > 1.
    let lock = f64::sqrt(p as f64) as usize;
    if TOP == 0 {
        return primeband(p, lock);
    } else if TOP >= lock { 
        return resolve_band(p, lock);
    } else if TOP <= p * p {
        return extendedprimeband(lock * 2, f64::sqrt(lock as f64) as usize);
    } else { //Outside of the scope of this project.
        return brute_prime(p, lock);
    }
}
fn entry(p: i32) -> bool {
    if p < 2 { return false; }
    unsafe {
        return resolve(p as usize);
    }
}

fn test_compare(r: i32) {
    let mut cha: Vec<i32> = Vec::new();
    let mut chb: Vec<i32> = Vec::new();
    /*for i in 2..r {
        //assert_eq!(entry(i), raw_brute_prime(i));
        if entry(i) != raw_brute_prime(i) {
            println!("ono {}", i);
        }
    }*/
    let mut t = time::Instant::now();
    for i in 2..r {
        if entry(i) {
            cha.push(i);
        }
    }
    let da = time::Instant::now() - t;
    t = time::Instant::now();
    for i in 2..r {
        if raw_brute_prime(i) {
            chb.push(i);
        }
    }
    let db = time::Instant::now() - t;
    for i in 0..cha.len() {
        if cha[i] != chb[i] {
            println!("{} {}", cha[i], chb[i]);
        }
    }
    println!("Brute time: {:?} Optimised time: {:?}", db, da);
    if db<da {
        println!("Optimised is slower than Brute.");
        //println!("Optimised is {:?} times slower than Brute.", da / db);
    }
}
fn test_self(r: i32) {
    let t = time::Instant::now();
    for i in 2..r {
        entry(i);
    }
    let da = time::Instant::now() - t;
    println!("Optimised time: {:?}", da);
}
fn test_actual_compare(r: i32, mx: i32) {
    let mut cha: Vec<i32> = Vec::new();
    let mut chb: Vec<i32> = Vec::new();
    let mut rcx: Vec<i32> = Vec::with_capacity(r as usize);
    let mut rng = rand::thread_rng();
    for _ in 2..r { //That way the set is the same
        rcx.push(rng.gen_range(2, mx));
    }
    let mut t = time::Instant::now();
    for i in &rcx {
        if entry(*i) {
            cha.push(*i);
        }
    }
    let da = time::Instant::now() - t;
    t = time::Instant::now();
    for i in &rcx {
        if raw_brute_prime(*i) {
            chb.push(*i);
        }
    }
    let db = time::Instant::now() - t;
    println!("Brute time: {:?} Optimised time: {:?}", db, da);
    if db<da {
        println!("Optimised is slower than Brute.");
    }
}
fn test_actual_self(r: i32, mx: i32) {
    let mut rng = rand::thread_rng();
    let mut rcx: Vec<i32> = Vec::with_capacity(r as usize);
    for _ in 2..r { //Generate before timing.
        rcx.push(rng.gen_range(2, mx));
    }
    let t = time::Instant::now();
    for i in rcx {
        entry(i);
    }
    let da = time::Instant::now() - t;
    println!("Optimised time: {:?}", da);
}
fn test_compare_r(r: i32) {
    let mut cha: Vec<i32> = Vec::new();
    let mut chb: Vec<i32> = Vec::new();
    let mut t = time::Instant::now();
    for i in 2..r {
        if entry(r-i+2) {
            cha.push(r-i+2);
        }
    }
    let da = time::Instant::now() - t;
    t = time::Instant::now();
    for i in 2..r {
        if raw_brute_prime(r-i+2) {
            chb.push(r-i+2);
        }
    }
    let db = time::Instant::now() - t;
    for i in 0..cha.len() {
        if cha[i] != chb[i] {
            println!("{} {}", cha[i], chb[i]);
        }
    }
    println!("Brute time: {:?} Optimised time: {:?}", db, da);
}
fn test_self_r(r: i32) {
    //let mut cha: Vec<i32> = Vec::new();
    let t = time::Instant::now();
    for i in 2..r {
        entry(r-i+2);
    }
    let da = time::Instant::now() - t;
    println!("Optimised time: {:?}", da);
}

fn main() {
    let args: Vec<String> = env::args().collect();
    if args.len() < 3 {
        println!("This program needs test_mode and range arguments. (int)");
        return;
    }
    let mode: i32 = args[1].parse().unwrap();
    let r: i32 = args[2].parse().unwrap();
    if mode == 0 {
        test_compare(r); 
    } else if mode == 1 {
        test_self(r); //Should run in under 500 seconds.
    } else if mode == 2 {
        if args.len() < 4 {
            println!("This program needs a max_value argument. (int)");
            return;
        }
        test_actual_compare(r, args[3].parse().unwrap());
    } else if mode == 3 {
        if args.len() < 4 {
            println!("This program needs a max_value argument. (int)");
            return;
        }
        test_actual_self(r, args[3].parse().unwrap());
    } else if mode == 4 {
        test_compare_r(r); 
    } else if mode == 5 {
        test_self_r(r); 
    } 
}