/*

  Testing ** to see if I can fix the blow up....

  Note: it does not work to add constraints in the definition
  of
    eval('pow'(X,Y)) 
  since the program just stops when these constraints are satisfied.

  Ah, Picat has pow_mod(X,Y,Modulo) which seems to solve this, 
  though in some case it might give some unexpected results.
  Also, it requires a modulo constant which is transmitted 
  via parameter pow_mod_constant.

  Also, we can use pow_mod_mod/3 directly,
    
  * Using pow_mod2/2.
    [program = 1 * 1 + N * N,res = 101,count = 9]
    [program = 1 + pow_mod2(N * N,1),res = 101,count = 9]
    [program = 1 + N * N,res = 101,count = 9]
    [program = N * N + 1,res = 101,count = 7]
    [program = 1 + pow_mod2(N,2),res = 101,count = 7]
    [program = pow_mod2(N,2) + 1,res = 101,count = 6]
    [program = 1 + pow_mod2(N,1) * N,res = 101,count = 6]
    [program = pow_mod2(pow_mod2(1,pow_mod2(2 - N,2)) * N,2) + 1,res = 101,count = 5]
    [program = 1 + pow_mod2(pow_mod2(1,pow_mod2(2 - N,2)) * N,2),res = 101,count = 4]
    [program = 1 + 1 * (pow_mod2(N,1) * N),res = 101,count = 4]
    [program = pow_mod2(1,N) + N * N,res = 101,count = 2]
    [program = N * N + pow_mod2(1,1),res = 101,count = 2]
    [program = pow_mod2(pow_mod2(N,2) + 1,pow_mod2(pow_mod2(1,2),2 * (((1 + (pow_mod2(2,1) + N + 2)) * 2 - N) * 2))),res = 101,count = 1]
    [program = pow_mod2(pow_mod2(N,2) + 1,pow_mod2(1,1)),res = 101,count = 1]
    [program = pow_mod2(pow_mod2(N,2) + 1,1),res = 101,count = 1]
    [program = pow_mod2(N,2) - (N - N - 1),res = 101,count = 1]
    [program = N * N - (N - N - 1),res = 101,count = 1]
    [program = pow_mod2(pow_mod2(1,2),2 * (((1 + (pow_mod2(2,1) + N + 2)) * 2 - N) * 2)) + pow_mod2(N,2),res = 101,count = 1]
    [program = pow_mod2(pow_mod2(1,pow_mod2(2 - N,2)) * N,2) + pow_mod2(1,2),res = 101,count = 1]
    [program = pow_mod2(1,2) + pow_mod2(N,2),res = 101,count = 1]
    [program = (pow_mod2(N,2) + 1) * (2 - 1),res = 101,count = 1]

    resultMap = [101 = 21]


  * Using pow_mod/3:
    [program = 1 + N * N,res = 101,count = 11]
    [program = N * N + 1,res = 101,count = 9]
    [program = pow_mod(N,2,2 + (pow_mod(N,N,2) + N + N * N) + N) + 1,res = 101,count = 4]
    [program = N * N + pow_mod(1,1,2),res = 101,count = 4]
    [program = (N - 1) * N + (1 + N),res = 101,count = 2]

    resultMap = [101 = 5]



  Using power_restricted works with pow_mod_constant=10**6

    If either X or Y are > 10 then the value is 1 else it's X**Y
    [program = 1 + N * N,res = 101,count = 10]
    [program = N * N + 1,res = 101,count = 9]
    [program = N * N + pow_restricted(pow_restricted(1,N + pow_restricted(2,pow_restricted(1,2))),N),res = 101,count = 7]
    [program = pow_restricted(N,2) + 1,res = 101,count = 5]
    [program = (2 - 1) * pow_restricted(N,2) + 1,res = 101,count = 5]
    [program = N * N + pow_restricted(N - 1 * (N * 2) + 2 + 2 + 2,pow_restricted(N - N,N)),res = 101,count = 5]
    [program = 1 * 1 + pow_restricted(N,1 + 1),res = 101,count = 4]
    [program = 1 + pow_restricted(N,2),res = 101,count = 3]
    [program = pow_restricted(N - 1 * (N * 2) + 2 + 2 + 2,pow_restricted(N - N,N)) + pow_restricted(N,2),res = 101,count = 2]
    [program = pow_restricted(N,2) + pow_restricted(1,N),res = 101,count = 2]
    [program = 1 - N * (N * (1 - 2)),res = 101,count = 1]
    [program = pow_restricted(N,2 * 1) + 1,res = 101,count = 1]
    [program = N * N + 1 * 1,res = 101,count = 1]
    [program = 1 + pow_restricted(N,2 * 1),res = 101,count = 1]

    resultMap = [101 = 14]


    Another expression: 1+N**N-N

    [program = pow_restricted(N,N) - N + 1,res = 9999999991,count = 8]
    [program = pow_restricted(N,N) - (N - pow_restricted(1,1)),res = 9999999991,count = 5]
    [program = pow_restricted(1,N) + (pow_restricted(N,N) - N),res = 9999999991,count = 3]
    [program = pow_restricted(N,N) + (1 - N),res = 9999999991,count = 1]

 

*/
data(power,Data,Vars,Unknown,Ops,Constants,MaxSize,Params) :-
  % Data =  [ [[N],1+N**2] : N in 1..9],
  Data =  [ [[N],1+N**N-N] : N in 1..9],
  println(data=Data),
  Unknown = [10], 
  Vars = ['N'],
  % Ops = [+,-,*,pow_mod2],
  Ops = [+,-,*,pow_restricted],
  % Ops = [+,-,*,pow_mod],  
  Constants = 1..2,
  MaxSize = 21,
  Params = new_map([debug=false,pow_mod_constant=10**6]).