<?
set_time_limit(60*60*5);
define('_N', 64);
define('_V', _N/2);
define('_V2', _V/2);

ini_set("memory_limit", "13000M");
// echo ini_get('memory_limit');exit;

// echo PHP_INT_SIZE;

list($k1, $k2, $Lamd) = getK(_N);

define('_K1', $k1);
define('_K2', $k2);
define('_La', $Lamd);

define('_Z1', _V-_K1);
define('_Z2', _V-_K2);

echo '<pre>';
$microtime = microtime(true);

// $select_combine_1 = 9;
// $select_combine_z_1 = 3;
$combine_mas = getNumComp(_K1-1);

// foreach($combine_mas as $row){
    // echo implode(',',$row)."\r\n";

// }
// var_dump('N', _N,'k1',$k1,'k2',$k2,'Lamd',$Lamd);
// exit;

$combine_mas_1_allow = array();
$combine_mas_2_allow = array();

if(file_exists(_N."-task.dat")){

    $dat = json_decode(file_get_contents(_N."-task.dat"), true);
    $combine_mas_1_allow = $dat['combine_mas_1_allow'];
    $combine_mas_2_allow = $dat['combine_mas_2_allow'];

}else{


foreach($combine_mas as $row){
    $rows_z = getNumComp(_Z1-1, count($row));
    $ccounts_k = array_count_values($row);

    foreach($rows_z as $row_z){

        $ccounts_z = array_count_values($row_z);

        // var_dump($row,$ccounts_k, $ccounts_z);exit;

        $lam1 = array_sum($row) - count($row);

        $lam2 = 0;
        foreach($ccounts_k as $k=>$v) if($k>1) $lam2 += ($k-2)*$v;
        foreach($ccounts_z as $k=>$v) if($k==1) $lam2 +=$v;
        $combine_mas_1_allow[$lam1.'.'.$lam2.''][implode(',',$row)][] = $row_z;
    }
}

$combine_mas = getNumComp(_K2-1);
foreach($combine_mas as $row){
    $rows_z = getNumComp(_Z2-1, count($row));
    $ccounts_k = array_count_values($row);

    foreach($rows_z as $row_z){

        $ccounts_z = array_count_values($row_z);

        // var_dump($row,$ccounts_k, $ccounts_z);exit;

        $lam1 = array_sum($row) - count($row);

        $lam2 = 0;
        foreach($ccounts_k as $k=>$v) if($k>1) $lam2 += ($k-2)*$v;
        foreach($ccounts_z as $k=>$v) if($k==1) $lam2 +=$v;

        $combine_mas_2_allow[convertLa2b($lam1).'.'.convertLa2b($lam2).''][implode(',',$row)][] = $row_z;

    }
}

// $combine_mas = getNumComp(_K2-1);
// $combine_mas_2_allow = array();
// foreach($combine_mas as $row){
    // $lam1 = convertLa2b(array_sum($row) - count($row));
    // $combine_mas_2_allow[$lam1][] = $row;
// }



foreach($combine_mas_1_allow as $key=>$row){
    if(!isset( $combine_mas_2_allow[$key] )) {
        unset($combine_mas_1_allow[$key]);
    }
}
foreach($combine_mas_2_allow as $key=>$row){
    if(!isset( $combine_mas_1_allow[$key] )) {
        unset($combine_mas_2_allow[$key]);
    }
}


ksort($combine_mas_1_allow);

file_put_contents(_N."-task.dat", json_encode(array('combine_mas_1_allow'=>$combine_mas_1_allow, 'combine_mas_2_allow'=>$combine_mas_2_allow)));

}


// var_dump(array_keys($combine_mas_1_allow));exit;

// exit;



echo "N="._N.";"."V="._V.";"."K1="._K1.";"."K2="._K2.";"."La="._La.";"."Z1="._Z1.";"."Z2="._Z2.";"."\r\n";
if(!_K1 || !_K2) exit;

file_put_contents(_N.'res.txt', "start ".date('Y-m-d H:i:s')."\r\n");


// var_dump(array_keys($combine_mas_1_allow));
// exit;

$i=0;

$vector_list = array();
$result_list = array();
foreach($combine_mas_1_allow as $keyv=>$combine_mas_1){



    // var_dump($combine_mas_1);
echo "<h2>Генерация векторов A  - ".$keyv."</h2>";



file_put_contents(_N.'res.txt', "Генерация векторов A  - ".$keyv."\r\n", FILE_APPEND);

if($keyv<='9.9') continue;

// break;
//Генерация векторов А

//11111010011000100000  11001000101001010000
//combine 2,1,1,1,1,1 vs 4,3,2,2,1,1
// var_dump($combine_mas_1);exit;
foreach($combine_mas_1 as $key1 => $combine_mas_z_1){
    // echo $key1."\r\n";
    $combine_1 = explode(',',$key1);
    $glen = count($combine_1);

    // $combine_mas_z_1 = getNumComp(_Z1-1, $glen);

    // echo implode(',',$combine_1)." combine_1\r\n";
    foreach($combine_mas_z_1  as $combine_z_1){
        // $tt = array();
        // echo "combine ".implode(',',$combine_1)." vs ".implode(',',$combine_z_1)."\r\n";
        // exit;
        $temp_combine_z_1 = $combine_z_1;
        do{

            $combine_z_1 = $temp_combine_z_1;
            do{
                $v = getVector($combine_1, $combine_z_1);
                $key = getLamdKey($v);
                $vector_list[implode('',getInverseLamdKey($key))] = $v;


            }while(NextSet($combine_z_1, $glen));

        }while(NextSet($combine_1, $glen));

        // echo implode(',',$combine_z_1)." combine_z ";
        // foreach($tt as $ii=>$vv) echo "[".implode(',',array_keys($vv))."],";
        // echo "\r\n";



    }
}
// echo 'step1';exit;
// echo "<h2>Генерация векторов Б - ".$keyv."</h2>";
//Генерация векторов Б
$combine_mas_1 = $combine_mas_2_allow[$keyv];
foreach($combine_mas_1 as $key1 => $combine_mas_z_1){
    // echo $key1."\r\n";
    $combine_1 = explode(',',$key1);
    $glen = count($combine_1);
    // $combine_mas_z_1 = getNumComp(_Z2-1, $glen);
    foreach($combine_mas_z_1  as $combine_z_1){
        // echo "combine ".implode(',',$combine_1)." vs ".implode(',',$combine_z_1)."\r\n";
        $temp_combine_z_1 = $combine_z_1;
        do{

            $combine_z_1 = $temp_combine_z_1;

            do{

                $v = getVector($combine_1, $combine_z_1);
                $key = getLamdKey($v);
                $key_str = implode('',$key);
                if(isset($vector_list[$key_str]))  {
                    $result_list[$vector_list[$key_str]] = $v;
                    file_put_contents(_N.'res.txt', showVector($vector_list[$key_str], true)."\t".showVector($v, true)."\t[".implode(',',getKey($v))."]\r\n", FILE_APPEND);
                    break 2;
                }


            }while(NextSet($combine_z_1, $glen));


        }while(NextSet($combine_1, $glen));



    }
}

$size = memory_get_usage();
echo "list size = $size byte\r\n";



    // break;

}
var_dump('count result ' .count($result_list));
// var_dump($result_list);

$size = memory_get_usage();
echo "list size = $size byte\r\n";


echo "\r\n"._N."\tTime: ".(microtime(true)-$microtime). "";
echo "END\r\n";
file_put_contents(_N.'res.txt', "end ".date('Y-m-d H:i:s')."\r\n", FILE_APPEND);
// showKey(getKey($v));




// exit;

function convertEa($l){
    $e = _V - 4*(_K1 - $l);
    return $e;
}
function convertEb($l){
    $e = _V - 4*(_K2 - $l);
    return $e;
}

function convertLa2b($l){
    $e = _V - 4*(_K1 - $l);
    $l2 = - ((-$e - _V)/-4 - _K2);
    return $l2;
}

function convertLb2a($l){
    $e = _V - 4*(_K2 - $l);
    $l2 = - ((-$e - _V)/-4 - _K1);
    return $l2;
}

//Циклический сдвиг вектора
function ROL($value, $shift)
{
    // showVector(((1<<_V)-1)); echo "\r\n";
    return ( ($value << $shift) | ($value >> (_V-$shift)) ) & ((1<<_V)-1);
}

//Возвращает количество единиц в бинарном представлении числа
function EC($xor){
    $xor -= ($xor >> 1) & 0x5555555555555555;
    $xor = (($xor >> 2) & 0x3333333333333333) + ($xor & 0x3333333333333333);
    $xor = (((($xor >> 4) + $xor) & 0x0F0F0F0F0F0F0F0F) * 0x0101010101010101) >> 56;
    return $xor;
}

//Выводит ключ вектора на экран
function showKey($key){
    echo "[".implode(',',$key)."]";
}

//На основании бинарного представления вектора
//вычисляет его ключ из лямбда
function getLamdKey($vector){
    $key = array();
    for($i=1; $i<=_V2; $i++){
        $e = EC($vector & ROL($vector,$i));
        $key[] = $e;
        // showVector($xor);
        // echo " - $i - $e\r\n";
    }
    return $key;
}
function getInverseLamdKey($key){
    $ret = array();
    foreach($key as $k=>$e) $ret[$k] = convertLa2b($e);
    return $ret;
}
function getInverseKey($key){
    $ret = array();
    foreach($key as $k=>$e) $ret[$k] = -$e;
    return $ret;
}
//На основании бинарного представления вектора
//вычисляет его ключ

function getKey($vector){
    $key = array();
    for($i=1; $i<=_V2; $i++){
        $xor = $vector ^ ROL($vector,$i);
        $e = _V - EC($xor)*2;
        $key[] = $e;
        // showVector($xor);
        // echo " - $i - $e\r\n";
    }
    return $key;
}

//Из массивов груп единиц и нулей делает бинарное представление вектора
//[3,1,1] [2,2,1] = 1110010010
function getVector($ar_k, $ar_z){
    // var_dump($ar_k, $ar_z);
    $vector = 0;
    // var_dump($ar_k,$ar_z);
    foreach($ar_k as $k=>$v){
        $vector = $vector<<$v;
        // $vector |= pow(2,$v)-1;
        $vector |= (1<<$v)-1;
        $vector = $vector<<$ar_z[$k];
    }
    return $vector;
}

//Переводит бинарное представление вектора в строку
function showVector($vector, $ret=false){
    $str = decbin($vector);
    if($ret) return $str;
    echo $str;
}

//Вычисляет переменные К для N сложности
function getK($N){
    $V=$N/2;
    $k1=$k2=0;
    for ($x=0;$x<$V;$x++)
    for ($y=0;$y<$V;$y++)
        if ($x*$x+$y*$y==$N) { $k1=($V-$x)/2; $k2=($V-$y)/2; }
    $lambda=$k1+$k2-$N/4;
    return array($k1,$k2,$lambda);
}


//Раскладывает число на слагаемые: 5 = 5 = 4+1 = 3+2 = 3+1+1 = 2+1+1+1 = 1+1+1+1+1
function getNumComp($left, $mas_len = false, &$sums=array(), &$sum=array(),$min = 1, $i = 0){


    if ($left < 0) return;
    $sum[$i] = $min;
    if ($min != 0)
    {
      getNumComp($left - $min, $mas_len,$sums, $sum, $min, $i + 1);
    }
    getNumComp($left - 1, $mas_len,$sums, $sum, $min + 1, $i);
    if ($left == 0)
    {
        $ar = array();
        for ($j = 0; $j <= $i; ++$j){
            $ar[] = $sum[$j];
        }
        if(!$mas_len || count($ar)==$mas_len) $sums[] = $ar;
    }
     return $sums;
}


//Возвращает следущую комбинацию чисел
function NextSet(&$a, &$n)
{
    static $s;
    //https://prog-cpp.ru/permutation/
  $j = $n - 2;
  while ($j != -1 && $a[$j] >= $a[$j + 1]) $j--;
  if ($j == -1)
    return false; // больше перестановок нет
  $k = $n - 1;
  while ($a[$j] >= $a[$k]) $k--;

    $s = $a[$j];  $a[$j] = $a[$k];  $a[$k] = $s;

  $l = $j + 1;
  $r = $n - 1; // сортируем оставшуюся часть последовательности
  while ($l<$r)
  {
    $s = $a[$l];  $a[$l] = $a[$r];  $a[$r] = $s; ++$l; --$r;
  }
  return true;
}