syj a écrit 630 commentaires

  • # J'ai aussi utilisé le Z3 theorem prover.

    Posté par  . En réponse au message Advent of Code 2023, jour 24. Évalué à 1. Dernière modification le 31 décembre 2023 à 11:07.

    J'ai aussi utilisé le Z3 theorem prover.

    En gros, je pose pour chaque axe & chaque grelon

    rock.x + t1 * rock.vx = grelon.x + t1 * grelon.vx
    rock.y + t1 * rock.vy = grelon.y + t1 * grelon.vy
    rock.z + t1 * rock.vz = grelon.z + t1 * grelon.vz

    Le solve du z3 se charge de trouver la solution des systèmes d'équation.
    Vu que je suis plus habitué à Java pour le parsing du input , j'ai écrit un petit programme qui me génère le code typescript attendu par le solver Z3.
    La première version pouvait directement s'éxecuter dans la sandbox https://microsoft.github.io/z3guide/programming/Z3%20JavaScript%20Examples/

    On peut aussi l'éxecuter en locale de cette manière:
    Via package.json

    {
  "dependencies": {
    "z3-solver": "4.12.4"
  },
  "devDependencies": {
    "@types/node": "^20.10.5",
    "typescript": "^5.3.3"
  }
}

    Code typescript

    const { init } = require('z3-solver');


async function execute() {
    const { Context } = await init();
    const Z3 = Context('main');

    // Z3 https://microsoft.github.io/z3guide/programming/Z3 JavaScript Examples
const x = Z3.Int.const('x');
const y = Z3.Int.const('y');
const z = Z3.Int.const('z');
const vx = Z3.Int.const('vx');
const vy = Z3.Int.const('vy');
const vz = Z3.Int.const('vz');


const t0 = Z3.Int.const('t0') 
const t1 = Z3.Int.const('t1') 
const t2 = Z3.Int.const('t2') 
const t3 = Z3.Int.const('t3') 
const t4 = Z3.Int.const('t4') 
const t5 = Z3.Int.const('t5') 
const t6 = Z3.Int.const('t6') 
const t7 = Z3.Int.const('t7') 
const t8 = Z3.Int.const('t8') 
const t9 = Z3.Int.const('t9') 
const t10 = Z3.Int.const('t10') 
const t11 = Z3.Int.const('t11') 
const t12 = Z3.Int.const('t12') 
const t13 = Z3.Int.const('t13') 
const t14 = Z3.Int.const('t14') 
const t15 = Z3.Int.const('t15') 
const t16 = Z3.Int.const('t16') 
const t17 = Z3.Int.const('t17') 
const t18 = Z3.Int.const('t18') 
const t19 = Z3.Int.const('t19') 
const t20 = Z3.Int.const('t20') 
const t21 = Z3.Int.const('t21') 
const t22 = Z3.Int.const('t22') 
const t23 = Z3.Int.const('t23') 
const t24 = Z3.Int.const('t24') 
const t25 = Z3.Int.const('t25') 
const t26 = Z3.Int.const('t26') 
const t27 = Z3.Int.const('t27') 
const t28 = Z3.Int.const('t28') 
const t29 = Z3.Int.const('t29') 
const t30 = Z3.Int.const('t30') 
const t31 = Z3.Int.const('t31') 
const t32 = Z3.Int.const('t32') 
const t33 = Z3.Int.const('t33') 
const t34 = Z3.Int.const('t34') 
const t35 = Z3.Int.const('t35') 
const t36 = Z3.Int.const('t36') 
const t37 = Z3.Int.const('t37') 
const t38 = Z3.Int.const('t38') 
const t39 = Z3.Int.const('t39') 
const t40 = Z3.Int.const('t40') 
const t41 = Z3.Int.const('t41') 
const t42 = Z3.Int.const('t42') 
const t43 = Z3.Int.const('t43') 
const t44 = Z3.Int.const('t44') 
const t45 = Z3.Int.const('t45') 
const t46 = Z3.Int.const('t46') 
const t47 = Z3.Int.const('t47') 
const t48 = Z3.Int.const('t48') 
const t49 = Z3.Int.const('t49') 
const t50 = Z3.Int.const('t50') 
const t51 = Z3.Int.const('t51') 
const t52 = Z3.Int.const('t52') 
const t53 = Z3.Int.const('t53') 
const t54 = Z3.Int.const('t54') 
const t55 = Z3.Int.const('t55') 
const t56 = Z3.Int.const('t56') 
const t57 = Z3.Int.const('t57') 
const t58 = Z3.Int.const('t58') 
const t59 = Z3.Int.const('t59') 
const t60 = Z3.Int.const('t60') 
const t61 = Z3.Int.const('t61') 
const t62 = Z3.Int.const('t62') 
const t63 = Z3.Int.const('t63') 
const t64 = Z3.Int.const('t64') 
const t65 = Z3.Int.const('t65') 
const t66 = Z3.Int.const('t66') 
const t67 = Z3.Int.const('t67') 
const t68 = Z3.Int.const('t68') 
const t69 = Z3.Int.const('t69') 
const t70 = Z3.Int.const('t70') 
const t71 = Z3.Int.const('t71') 
const t72 = Z3.Int.const('t72') 
const t73 = Z3.Int.const('t73') 
const t74 = Z3.Int.const('t74') 
const t75 = Z3.Int.const('t75') 
const t76 = Z3.Int.const('t76') 
const t77 = Z3.Int.const('t77') 
const t78 = Z3.Int.const('t78') 
const t79 = Z3.Int.const('t79') 
const t80 = Z3.Int.const('t80') 
const t81 = Z3.Int.const('t81') 
const t82 = Z3.Int.const('t82') 
const t83 = Z3.Int.const('t83') 
const t84 = Z3.Int.const('t84') 
const t85 = Z3.Int.const('t85') 
const t86 = Z3.Int.const('t86') 
const t87 = Z3.Int.const('t87') 
const t88 = Z3.Int.const('t88') 
const t89 = Z3.Int.const('t89') 
const t90 = Z3.Int.const('t90') 
const t91 = Z3.Int.const('t91') 
const t92 = Z3.Int.const('t92') 
const t93 = Z3.Int.const('t93') 
const t94 = Z3.Int.const('t94') 
const t95 = Z3.Int.const('t95') 
const t96 = Z3.Int.const('t96') 
const t97 = Z3.Int.const('t97') 
const t98 = Z3.Int.const('t98') 
const t99 = Z3.Int.const('t99') 
const t100 = Z3.Int.const('t100') 
const t101 = Z3.Int.const('t101') 
const t102 = Z3.Int.const('t102') 
const t103 = Z3.Int.const('t103') 
const t104 = Z3.Int.const('t104') 
const t105 = Z3.Int.const('t105') 
const t106 = Z3.Int.const('t106') 
const t107 = Z3.Int.const('t107') 
const t108 = Z3.Int.const('t108') 
const t109 = Z3.Int.const('t109') 
const t110 = Z3.Int.const('t110') 
const t111 = Z3.Int.const('t111') 
const t112 = Z3.Int.const('t112') 
const t113 = Z3.Int.const('t113') 
const t114 = Z3.Int.const('t114') 
const t115 = Z3.Int.const('t115') 
const t116 = Z3.Int.const('t116') 
const t117 = Z3.Int.const('t117') 
const t118 = Z3.Int.const('t118') 
const t119 = Z3.Int.const('t119') 
const t120 = Z3.Int.const('t120') 
const t121 = Z3.Int.const('t121') 
const t122 = Z3.Int.const('t122') 
const t123 = Z3.Int.const('t123') 
const t124 = Z3.Int.const('t124') 
const t125 = Z3.Int.const('t125') 
const t126 = Z3.Int.const('t126') 
const t127 = Z3.Int.const('t127') 
const t128 = Z3.Int.const('t128') 
const t129 = Z3.Int.const('t129') 
const t130 = Z3.Int.const('t130') 
const t131 = Z3.Int.const('t131') 
const t132 = Z3.Int.const('t132') 
const t133 = Z3.Int.const('t133') 
const t134 = Z3.Int.const('t134') 
const t135 = Z3.Int.const('t135') 
const t136 = Z3.Int.const('t136') 
const t137 = Z3.Int.const('t137') 
const t138 = Z3.Int.const('t138') 
const t139 = Z3.Int.const('t139') 
const t140 = Z3.Int.const('t140') 
const t141 = Z3.Int.const('t141') 
const t142 = Z3.Int.const('t142') 
const t143 = Z3.Int.const('t143') 
const t144 = Z3.Int.const('t144') 
const t145 = Z3.Int.const('t145') 
const t146 = Z3.Int.const('t146') 
const t147 = Z3.Int.const('t147') 
const t148 = Z3.Int.const('t148') 
const t149 = Z3.Int.const('t149') 
const t150 = Z3.Int.const('t150') 
const t151 = Z3.Int.const('t151') 
const t152 = Z3.Int.const('t152') 
const t153 = Z3.Int.const('t153') 
const t154 = Z3.Int.const('t154') 
const t155 = Z3.Int.const('t155') 
const t156 = Z3.Int.const('t156') 
const t157 = Z3.Int.const('t157') 
const t158 = Z3.Int.const('t158') 
const t159 = Z3.Int.const('t159') 
const t160 = Z3.Int.const('t160') 
const t161 = Z3.Int.const('t161') 
const t162 = Z3.Int.const('t162') 
const t163 = Z3.Int.const('t163') 
const t164 = Z3.Int.const('t164') 
const t165 = Z3.Int.const('t165') 
const t166 = Z3.Int.const('t166') 
const t167 = Z3.Int.const('t167') 
const t168 = Z3.Int.const('t168') 
const t169 = Z3.Int.const('t169') 
const t170 = Z3.Int.const('t170') 
const t171 = Z3.Int.const('t171') 
const t172 = Z3.Int.const('t172') 
const t173 = Z3.Int.const('t173') 
const t174 = Z3.Int.const('t174') 
const t175 = Z3.Int.const('t175') 
const t176 = Z3.Int.const('t176') 
const t177 = Z3.Int.const('t177') 
const t178 = Z3.Int.const('t178') 
const t179 = Z3.Int.const('t179') 
const t180 = Z3.Int.const('t180') 
const t181 = Z3.Int.const('t181') 
const t182 = Z3.Int.const('t182') 
const t183 = Z3.Int.const('t183') 
const t184 = Z3.Int.const('t184') 
const t185 = Z3.Int.const('t185') 
const t186 = Z3.Int.const('t186') 
const t187 = Z3.Int.const('t187') 
const t188 = Z3.Int.const('t188') 
const t189 = Z3.Int.const('t189') 
const t190 = Z3.Int.const('t190') 
const t191 = Z3.Int.const('t191') 
const t192 = Z3.Int.const('t192') 
const t193 = Z3.Int.const('t193') 
const t194 = Z3.Int.const('t194') 
const t195 = Z3.Int.const('t195') 
const t196 = Z3.Int.const('t196') 
const t197 = Z3.Int.const('t197') 
const t198 = Z3.Int.const('t198') 
const t199 = Z3.Int.const('t199') 
const t200 = Z3.Int.const('t200') 
const t201 = Z3.Int.const('t201') 
const t202 = Z3.Int.const('t202') 
const t203 = Z3.Int.const('t203') 
const t204 = Z3.Int.const('t204') 
const t205 = Z3.Int.const('t205') 
const t206 = Z3.Int.const('t206') 
const t207 = Z3.Int.const('t207') 
const t208 = Z3.Int.const('t208') 
const t209 = Z3.Int.const('t209') 
const t210 = Z3.Int.const('t210') 
const t211 = Z3.Int.const('t211') 
const t212 = Z3.Int.const('t212') 
const t213 = Z3.Int.const('t213') 
const t214 = Z3.Int.const('t214') 
const t215 = Z3.Int.const('t215') 
const t216 = Z3.Int.const('t216') 
const t217 = Z3.Int.const('t217') 
const t218 = Z3.Int.const('t218') 
const t219 = Z3.Int.const('t219') 
const t220 = Z3.Int.const('t220') 
const t221 = Z3.Int.const('t221') 
const t222 = Z3.Int.const('t222') 
const t223 = Z3.Int.const('t223') 
const t224 = Z3.Int.const('t224') 
const t225 = Z3.Int.const('t225') 
const t226 = Z3.Int.const('t226') 
const t227 = Z3.Int.const('t227') 
const t228 = Z3.Int.const('t228') 
const t229 = Z3.Int.const('t229') 
const t230 = Z3.Int.const('t230') 
const t231 = Z3.Int.const('t231') 
const t232 = Z3.Int.const('t232') 
const t233 = Z3.Int.const('t233') 
const t234 = Z3.Int.const('t234') 
const t235 = Z3.Int.const('t235') 
const t236 = Z3.Int.const('t236') 
const t237 = Z3.Int.const('t237') 
const t238 = Z3.Int.const('t238') 
const t239 = Z3.Int.const('t239') 
const t240 = Z3.Int.const('t240') 
const t241 = Z3.Int.const('t241') 
const t242 = Z3.Int.const('t242') 
const t243 = Z3.Int.const('t243') 
const t244 = Z3.Int.const('t244') 
const t245 = Z3.Int.const('t245') 
const t246 = Z3.Int.const('t246') 
const t247 = Z3.Int.const('t247') 
const t248 = Z3.Int.const('t248') 
const t249 = Z3.Int.const('t249') 
const t250 = Z3.Int.const('t250') 
const t251 = Z3.Int.const('t251') 
const t252 = Z3.Int.const('t252') 
const t253 = Z3.Int.const('t253') 
const t254 = Z3.Int.const('t254') 
const t255 = Z3.Int.const('t255') 
const t256 = Z3.Int.const('t256') 
const t257 = Z3.Int.const('t257') 
const t258 = Z3.Int.const('t258') 
const t259 = Z3.Int.const('t259') 
const t260 = Z3.Int.const('t260') 
const t261 = Z3.Int.const('t261') 
const t262 = Z3.Int.const('t262') 
const t263 = Z3.Int.const('t263') 
const t264 = Z3.Int.const('t264') 
const t265 = Z3.Int.const('t265') 
const t266 = Z3.Int.const('t266') 
const t267 = Z3.Int.const('t267') 
const t268 = Z3.Int.const('t268') 
const t269 = Z3.Int.const('t269') 
const t270 = Z3.Int.const('t270') 
const t271 = Z3.Int.const('t271') 
const t272 = Z3.Int.const('t272') 
const t273 = Z3.Int.const('t273') 
const t274 = Z3.Int.const('t274') 
const t275 = Z3.Int.const('t275') 
const t276 = Z3.Int.const('t276') 
const t277 = Z3.Int.const('t277') 
const t278 = Z3.Int.const('t278') 
const t279 = Z3.Int.const('t279') 
const t280 = Z3.Int.const('t280') 
const t281 = Z3.Int.const('t281') 
const t282 = Z3.Int.const('t282') 
const t283 = Z3.Int.const('t283') 
const t284 = Z3.Int.const('t284') 
const t285 = Z3.Int.const('t285') 
const t286 = Z3.Int.const('t286') 
const t287 = Z3.Int.const('t287') 
const t288 = Z3.Int.const('t288') 
const t289 = Z3.Int.const('t289') 
const t290 = Z3.Int.const('t290') 
const t291 = Z3.Int.const('t291') 
const t292 = Z3.Int.const('t292') 
const t293 = Z3.Int.const('t293') 
const t294 = Z3.Int.const('t294') 
const t295 = Z3.Int.const('t295') 
const t296 = Z3.Int.const('t296') 
const t297 = Z3.Int.const('t297') 
const t298 = Z3.Int.const('t298') 
const t299 = Z3.Int.const('t299') 
const eqs = [];
let px, py, pz, vpx, vpy, vpz;
px = 246694783951603;
py = 201349632539530;
pz = 307741668306846;
vpx = 54;
vpy = -21;
vpz = 12;


eqs.push(x.add(t0.mul(vx)).eq(t0.mul(vpx).add(px)));
eqs.push(y.add(t0.mul(vy)).eq(t0.mul(vpy).add(py)));
eqs.push(z.add(t0.mul(vz)).eq(t0.mul(vpz).add(pz)));
px = 220339749104883;
py = 131993821472398;
pz = 381979584524072;
vpx = 77;
vpy = 7;
vpz = -58;


eqs.push(x.add(t1.mul(vx)).eq(t1.mul(vpx).add(px)));
eqs.push(y.add(t1.mul(vy)).eq(t1.mul(vpy).add(py)));
eqs.push(z.add(t1.mul(vz)).eq(t1.mul(vpz).add(pz)));
px = 148729713759711;
py = 225554040514665;
pz = 96860758795727;
vpx = 238;
vpy = 84;
vpz = 360;


eqs.push(x.add(t2.mul(vx)).eq(t2.mul(vpx).add(px)));
eqs.push(y.add(t2.mul(vy)).eq(t2.mul(vpy).add(py)));
eqs.push(z.add(t2.mul(vz)).eq(t2.mul(vpz).add(pz)));
px = 243519011458151;
py = 277335413285770;
pz = 177685287085848;
vpx = 57;
vpy = -116;
vpz = 163;


eqs.push(x.add(t3.mul(vx)).eq(t3.mul(vpx).add(px)));
eqs.push(y.add(t3.mul(vy)).eq(t3.mul(vpy).add(py)));
eqs.push(z.add(t3.mul(vz)).eq(t3.mul(vpz).add(pz)));
px = 143332267182217;
py = 225367189590686;
pz = 145981889711118;
vpx = 171;
vpy = -59;
vpz = 198;


eqs.push(x.add(t4.mul(vx)).eq(t4.mul(vpx).add(px)));
eqs.push(y.add(t4.mul(vy)).eq(t4.mul(vpy).add(py)));
eqs.push(z.add(t4.mul(vz)).eq(t4.mul(vpz).add(pz)));
px = 254741732348622;
py = 413864429531780;
pz = 57992504228203;
vpx = 53;
vpy = -245;
vpz = 424;


eqs.push(x.add(t5.mul(vx)).eq(t5.mul(vpx).add(px)));
eqs.push(y.add(t5.mul(vy)).eq(t5.mul(vpy).add(py)));
eqs.push(z.add(t5.mul(vz)).eq(t5.mul(vpz).add(pz)));
px = 287588175352717;
py = 369004130634898;
pz = 288915032357048;
vpx = -39;
vpy = 27;
vpz = -7;


eqs.push(x.add(t6.mul(vx)).eq(t6.mul(vpx).add(px)));
eqs.push(y.add(t6.mul(vy)).eq(t6.mul(vpy).add(py)));
eqs.push(z.add(t6.mul(vz)).eq(t6.mul(vpz).add(pz)));
px = 447514372965507;
py = 419011885432650;
pz = 289910622198608;
vpx = -184;
vpy = -278;
vpz = 33;


eqs.push(x.add(t7.mul(vx)).eq(t7.mul(vpx).add(px)));
eqs.push(y.add(t7.mul(vy)).eq(t7.mul(vpy).add(py)));
eqs.push(z.add(t7.mul(vz)).eq(t7.mul(vpz).add(pz)));
px = 423849084726710;
py = 199213120137139;
pz = 503612707855311;
vpx = -173;
vpy = 12;
vpz = -246;


eqs.push(x.add(t8.mul(vx)).eq(t8.mul(vpx).add(px)));
eqs.push(y.add(t8.mul(vy)).eq(t8.mul(vpy).add(py)));
eqs.push(z.add(t8.mul(vz)).eq(t8.mul(vpz).add(pz)));
px = 144839738540189;
py = 369107692234507;
pz = 296030329229962;
vpx = 168;
vpy = -224;
vpz = 27;


eqs.push(x.add(t9.mul(vx)).eq(t9.mul(vpx).add(px)));
eqs.push(y.add(t9.mul(vy)).eq(t9.mul(vpy).add(py)));
eqs.push(z.add(t9.mul(vz)).eq(t9.mul(vpz).add(pz)));
px = 360925037945229;
py = 286810941619090;
pz = 174184175152638;
vpx = -61;
vpy = -161;
vpz = 148;


eqs.push(x.add(t10.mul(vx)).eq(t10.mul(vpx).add(px)));
eqs.push(y.add(t10.mul(vy)).eq(t10.mul(vpy).add(py)));
eqs.push(z.add(t10.mul(vz)).eq(t10.mul(vpz).add(pz)));
px = 251557757123447;
py = 3211438473033;
pz = 459503063519822;
vpx = 46;
vpy = 158;
vpz = -145;


eqs.push(x.add(t11.mul(vx)).eq(t11.mul(vpx).add(px)));
eqs.push(y.add(t11.mul(vy)).eq(t11.mul(vpy).add(py)));
eqs.push(z.add(t11.mul(vz)).eq(t11.mul(vpz).add(pz)));
px = 316625519187704;
py = 218442590671631;
pz = 340432751592346;
vpx = -33;
vpy = -18;
vpz = -33;


eqs.push(x.add(t12.mul(vx)).eq(t12.mul(vpx).add(px)));
eqs.push(y.add(t12.mul(vy)).eq(t12.mul(vpy).add(py)));
eqs.push(z.add(t12.mul(vz)).eq(t12.mul(vpz).add(pz)));
px = 274401356328157;
py = 323394494374360;
pz = 297096642831308;
vpx = 16;
vpy = 19;
vpz = -7;


eqs.push(x.add(t13.mul(vx)).eq(t13.mul(vpx).add(px)));
eqs.push(y.add(t13.mul(vy)).eq(t13.mul(vpy).add(py)));
eqs.push(z.add(t13.mul(vz)).eq(t13.mul(vpz).add(pz)));
px = 304828109276462;
py = 349810827812905;
pz = 428798006192786;
vpx = -39;
vpy = -116;
vpz = -241;


eqs.push(x.add(t14.mul(vx)).eq(t14.mul(vpx).add(px)));
eqs.push(y.add(t14.mul(vy)).eq(t14.mul(vpy).add(py)));
eqs.push(z.add(t14.mul(vz)).eq(t14.mul(vpz).add(pz)));
px = 303443040396668;
py = 402514782738987;
pz = 345785270737548;
vpx = -183;
vpy = 56;
vpz = -407;


eqs.push(x.add(t15.mul(vx)).eq(t15.mul(vpx).add(px)));
eqs.push(y.add(t15.mul(vy)).eq(t15.mul(vpy).add(py)));
eqs.push(z.add(t15.mul(vz)).eq(t15.mul(vpz).add(pz)));
px = 323340955971369;
py = 92034804687714;
pz = 417353097216926;
vpx = -25;
vpy = 27;
vpz = -86;


eqs.push(x.add(t16.mul(vx)).eq(t16.mul(vpx).add(px)));
eqs.push(y.add(t16.mul(vy)).eq(t16.mul(vpy).add(py)));
eqs.push(z.add(t16.mul(vz)).eq(t16.mul(vpz).add(pz)));
px = 307765512354748;
py = 188583122359672;
pz = 325523485683806;
vpx = -21;
vpy = 15;
vpz = -13;


eqs.push(x.add(t17.mul(vx)).eq(t17.mul(vpx).add(px)));
eqs.push(y.add(t17.mul(vy)).eq(t17.mul(vpy).add(py)));
eqs.push(z.add(t17.mul(vz)).eq(t17.mul(vpz).add(pz)));
px = 263488210563664;
py = 385897724824405;
pz = 270935537020622;
vpx = 85;
vpy = 334;
vpz = 71;


eqs.push(x.add(t18.mul(vx)).eq(t18.mul(vpx).add(px)));
eqs.push(y.add(t18.mul(vy)).eq(t18.mul(vpy).add(py)));
eqs.push(z.add(t18.mul(vz)).eq(t18.mul(vpz).add(pz)));
px = 210178816788935;
py = 189082262652706;
pz = 228983255761448;
vpx = 108;
vpy = 43;
vpz = 113;


eqs.push(x.add(t19.mul(vx)).eq(t19.mul(vpx).add(px)));
eqs.push(y.add(t19.mul(vy)).eq(t19.mul(vpy).add(py)));
eqs.push(z.add(t19.mul(vz)).eq(t19.mul(vpz).add(pz)));
px = 283985882559237;
py = 367640038537875;
pz = 230423888034968;
vpx = -48;
vpy = 192;
vpz = 285;


eqs.push(x.add(t20.mul(vx)).eq(t20.mul(vpx).add(px)));
eqs.push(y.add(t20.mul(vy)).eq(t20.mul(vpy).add(py)));
eqs.push(z.add(t20.mul(vz)).eq(t20.mul(vpz).add(pz)));
px = 333130789363343;
py = 379047533938042;
pz = 237713333264712;
vpx = -180;
vpy = -53;
vpz = 169;


eqs.push(x.add(t21.mul(vx)).eq(t21.mul(vpx).add(px)));
eqs.push(y.add(t21.mul(vy)).eq(t21.mul(vpy).add(py)));
eqs.push(z.add(t21.mul(vz)).eq(t21.mul(vpz).add(pz)));
px = 289287446432941;
py = 397451442710462;
pz = 326233192718027;
vpx = -120;
vpy = 181;
vpz = -358;


eqs.push(x.add(t22.mul(vx)).eq(t22.mul(vpx).add(px)));
eqs.push(y.add(t22.mul(vy)).eq(t22.mul(vpy).add(py)));
eqs.push(z.add(t22.mul(vz)).eq(t22.mul(vpz).add(pz)));
px = 265072410973990;
py = 426345702753054;
pz = 330651523533836;
vpx = 67;
vpy = -43;
vpz = -391;


eqs.push(x.add(t23.mul(vx)).eq(t23.mul(vpx).add(px)));
eqs.push(y.add(t23.mul(vy)).eq(t23.mul(vpy).add(py)));
eqs.push(z.add(t23.mul(vz)).eq(t23.mul(vpz).add(pz)));
px = 357521545644523;
py = 129199780517120;
pz = 329831493509697;
vpx = -86;
vpy = 99;
vpz = -20;


eqs.push(x.add(t24.mul(vx)).eq(t24.mul(vpx).add(px)));
eqs.push(y.add(t24.mul(vy)).eq(t24.mul(vpy).add(py)));
eqs.push(z.add(t24.mul(vz)).eq(t24.mul(vpz).add(pz)));
px = 283408270669227;
py = 202525462999982;
pz = 260893535402016;
vpx = 11;
vpy = -30;
vpz = 67;


eqs.push(x.add(t25.mul(vx)).eq(t25.mul(vpx).add(px)));
eqs.push(y.add(t25.mul(vy)).eq(t25.mul(vpy).add(py)));
eqs.push(z.add(t25.mul(vz)).eq(t25.mul(vpz).add(pz)));
px = 360621125237679;
py = 176142496411170;
pz = 311032962569312;
vpx = -145;
vpy = 214;
vpz = -19;


eqs.push(x.add(t26.mul(vx)).eq(t26.mul(vpx).add(px)));
eqs.push(y.add(t26.mul(vy)).eq(t26.mul(vpy).add(py)));
eqs.push(z.add(t26.mul(vz)).eq(t26.mul(vpz).add(pz)));
px = 330191571870402;
py = 459937341246504;
pz = 289198161226967;
vpx = -259;
vpy = -313;
vpz = -24;


eqs.push(x.add(t27.mul(vx)).eq(t27.mul(vpx).add(px)));
eqs.push(y.add(t27.mul(vy)).eq(t27.mul(vpy).add(py)));
eqs.push(z.add(t27.mul(vz)).eq(t27.mul(vpz).add(pz)));
px = 279219984868398;
py = 482578947238962;
pz = 271832563687538;
vpx = -47;
vpy = -487;
vpz = 63;


eqs.push(x.add(t28.mul(vx)).eq(t28.mul(vpx).add(px)));
eqs.push(y.add(t28.mul(vy)).eq(t28.mul(vpy).add(py)));
eqs.push(z.add(t28.mul(vz)).eq(t28.mul(vpz).add(pz)));
px = 268772677767959;
py = 372556851973094;
pz = 290625485800272;
vpx = 33;
vpy = 63;
vpz = -23;


eqs.push(x.add(t29.mul(vx)).eq(t29.mul(vpx).add(px)));
eqs.push(y.add(t29.mul(vy)).eq(t29.mul(vpy).add(py)));
eqs.push(z.add(t29.mul(vz)).eq(t29.mul(vpz).add(pz)));
px = 276393131794075;
py = 291938143229626;
pz = 238911680329090;
vpx = 10;
vpy = 127;
vpz = 144;


eqs.push(x.add(t30.mul(vx)).eq(t30.mul(vpx).add(px)));
eqs.push(y.add(t30.mul(vy)).eq(t30.mul(vpy).add(py)));
eqs.push(z.add(t30.mul(vz)).eq(t30.mul(vpz).add(pz)));
px = 235700158714295;
py = 318767843977690;
pz = 173717989251612;
vpx = 99;
vpy = -26;
vpz = 262;


eqs.push(x.add(t31.mul(vx)).eq(t31.mul(vpx).add(px)));
eqs.push(y.add(t31.mul(vy)).eq(t31.mul(vpy).add(py)));
eqs.push(z.add(t31.mul(vz)).eq(t31.mul(vpz).add(pz)));
px = 307035460762787;
py = 433352602775398;
pz = 329838863767902;
vpx = -114;
vpy = -215;
vpz = -164;


eqs.push(x.add(t32.mul(vx)).eq(t32.mul(vpx).add(px)));
eqs.push(y.add(t32.mul(vy)).eq(t32.mul(vpy).add(py)));
eqs.push(z.add(t32.mul(vz)).eq(t32.mul(vpz).add(pz)));
px = 483366892313104;
py = 262936260613156;
pz = 342469711655622;
vpx = -201;
vpy = -117;
vpz = -21;


eqs.push(x.add(t33.mul(vx)).eq(t33.mul(vpx).add(px)));
eqs.push(y.add(t33.mul(vy)).eq(t33.mul(vpy).add(py)));
eqs.push(z.add(t33.mul(vz)).eq(t33.mul(vpz).add(pz)));
px = 252037178725326;
py = 239083355734533;
pz = 100854044768291;
vpx = 47;
vpy = -74;
vpz = 250;


eqs.push(x.add(t34.mul(vx)).eq(t34.mul(vpx).add(px)));
eqs.push(y.add(t34.mul(vy)).eq(t34.mul(vpy).add(py)));
eqs.push(z.add(t34.mul(vz)).eq(t34.mul(vpz).add(pz)));
px = 338759779357023;
py = 411820696207434;
pz = 365708713895558;
vpx = -306;
vpy = -79;
vpz = -397;


eqs.push(x.add(t35.mul(vx)).eq(t35.mul(vpx).add(px)));
eqs.push(y.add(t35.mul(vy)).eq(t35.mul(vpy).add(py)));
eqs.push(z.add(t35.mul(vz)).eq(t35.mul(vpz).add(pz)));
px = 275725852568965;
py = 437253800744482;
pz = 228918187676310;
vpx = -51;
vpy = 51;
vpz = 690;


eqs.push(x.add(t36.mul(vx)).eq(t36.mul(vpx).add(px)));
eqs.push(y.add(t36.mul(vy)).eq(t36.mul(vpy).add(py)));
eqs.push(z.add(t36.mul(vz)).eq(t36.mul(vpz).add(pz)));
px = 218291728169979;
py = 225148716056766;
pz = 301148692245056;
vpx = 102;
vpy = 17;
vpz = 12;


eqs.push(x.add(t37.mul(vx)).eq(t37.mul(vpx).add(px)));
eqs.push(y.add(t37.mul(vy)).eq(t37.mul(vpy).add(py)));
eqs.push(z.add(t37.mul(vz)).eq(t37.mul(vpz).add(pz)));
px = 335796419585965;
py = 273216483788310;
pz = 218432517319212;
vpx = -180;
vpy = 269;
vpz = 225;


eqs.push(x.add(t38.mul(vx)).eq(t38.mul(vpx).add(px)));
eqs.push(y.add(t38.mul(vy)).eq(t38.mul(vpy).add(py)));
eqs.push(z.add(t38.mul(vz)).eq(t38.mul(vpz).add(pz)));
px = 288650438469807;
py = 393217145633735;
pz = 393241761060833;
vpx = -10;
vpy = -192;
vpz = -184;


eqs.push(x.add(t39.mul(vx)).eq(t39.mul(vpx).add(px)));
eqs.push(y.add(t39.mul(vy)).eq(t39.mul(vpy).add(py)));
eqs.push(z.add(t39.mul(vz)).eq(t39.mul(vpz).add(pz)));
px = 297535201134031;
py = 320994614809658;
pz = 200806502447378;
vpx = -36;
vpy = -5;
vpz = 218;


eqs.push(x.add(t40.mul(vx)).eq(t40.mul(vpx).add(px)));
eqs.push(y.add(t40.mul(vy)).eq(t40.mul(vpy).add(py)));
eqs.push(z.add(t40.mul(vz)).eq(t40.mul(vpz).add(pz)));
px = 305894885039157;
py = 266792713041662;
pz = 262627732020492;
vpx = -49;
vpy = 85;
vpz = 75;


eqs.push(x.add(t41.mul(vx)).eq(t41.mul(vpx).add(px)));
eqs.push(y.add(t41.mul(vy)).eq(t41.mul(vpy).add(py)));
eqs.push(z.add(t41.mul(vz)).eq(t41.mul(vpz).add(pz)));
px = 354668455172970;
py = 352774244046983;
pz = 536345552823415;
vpx = -151;
vpy = -98;
vpz = -500;


eqs.push(x.add(t42.mul(vx)).eq(t42.mul(vpx).add(px)));
eqs.push(y.add(t42.mul(vy)).eq(t42.mul(vpy).add(py)));
eqs.push(z.add(t42.mul(vz)).eq(t42.mul(vpz).add(pz)));
px = 365871847999148;
py = 287112731527968;
pz = 359906767568725;
vpx = -107;
vpy = -85;
vpz = -68;


eqs.push(x.add(t43.mul(vx)).eq(t43.mul(vpx).add(px)));
eqs.push(y.add(t43.mul(vy)).eq(t43.mul(vpy).add(py)));
eqs.push(z.add(t43.mul(vz)).eq(t43.mul(vpz).add(pz)));
px = 188863864270103;
py = 133490031564998;
pz = 361421327952572;
vpx = 145;
vpy = 151;
vpz = -76;


eqs.push(x.add(t44.mul(vx)).eq(t44.mul(vpx).add(px)));
eqs.push(y.add(t44.mul(vy)).eq(t44.mul(vpy).add(py)));
eqs.push(z.add(t44.mul(vz)).eq(t44.mul(vpz).add(pz)));
px = 266041565973615;
py = 80493722144573;
pz = 323436962795307;
vpx = 38;
vpy = 726;
vpz = -86;


eqs.push(x.add(t45.mul(vx)).eq(t45.mul(vpx).add(px)));
eqs.push(y.add(t45.mul(vy)).eq(t45.mul(vpy).add(py)));
eqs.push(z.add(t45.mul(vz)).eq(t45.mul(vpz).add(pz)));
px = 210524009414594;
py = 307434778066041;
pz = 336020097277997;
vpx = 103;
vpy = -130;
vpz = -28;


eqs.push(x.add(t46.mul(vx)).eq(t46.mul(vpx).add(px)));
eqs.push(y.add(t46.mul(vy)).eq(t46.mul(vpy).add(py)));
eqs.push(z.add(t46.mul(vz)).eq(t46.mul(vpz).add(pz)));
px = 387419474737982;
py = 246377818528285;
pz = 469298726964458;
vpx = -135;
vpy = -32;
vpz = -217;


eqs.push(x.add(t47.mul(vx)).eq(t47.mul(vpx).add(px)));
eqs.push(y.add(t47.mul(vy)).eq(t47.mul(vpy).add(py)));
eqs.push(z.add(t47.mul(vz)).eq(t47.mul(vpz).add(pz)));
px = 286379423522892;
py = 415752542225355;
pz = 261516190255763;
vpx = -189;
vpy = 314;
vpz = 208;


eqs.push(x.add(t48.mul(vx)).eq(t48.mul(vpx).add(px)));
eqs.push(y.add(t48.mul(vy)).eq(t48.mul(vpy).add(py)));
eqs.push(z.add(t48.mul(vz)).eq(t48.mul(vpz).add(pz)));
px = 358423439654491;
py = 474986432063286;
pz = 379323436257296;
vpx = -138;
vpy = -352;
vpz = -145;


eqs.push(x.add(t49.mul(vx)).eq(t49.mul(vpx).add(px)));
eqs.push(y.add(t49.mul(vy)).eq(t49.mul(vpy).add(py)));
eqs.push(z.add(t49.mul(vz)).eq(t49.mul(vpz).add(pz)));
px = 316468823323255;
py = 178336491882174;
pz = 353304310212440;
vpx = -36;
vpy = 53;
vpz = -55;


eqs.push(x.add(t50.mul(vx)).eq(t50.mul(vpx).add(px)));
eqs.push(y.add(t50.mul(vy)).eq(t50.mul(vpy).add(py)));
eqs.push(z.add(t50.mul(vz)).eq(t50.mul(vpz).add(pz)));
px = 370513619404125;
py = 438286486099934;
pz = 516988421715709;
vpx = -100;
vpy = -299;
vpz = -254;


eqs.push(x.add(t51.mul(vx)).eq(t51.mul(vpx).add(px)));
eqs.push(y.add(t51.mul(vy)).eq(t51.mul(vpy).add(py)));
eqs.push(z.add(t51.mul(vz)).eq(t51.mul(vpz).add(pz)));
px = 375291925637577;
py = 465656729270115;
pz = 409022941382558;
vpx = -244;
vpy = -336;
vpz = -297;


eqs.push(x.add(t52.mul(vx)).eq(t52.mul(vpx).add(px)));
eqs.push(y.add(t52.mul(vy)).eq(t52.mul(vpy).add(py)));
eqs.push(z.add(t52.mul(vz)).eq(t52.mul(vpz).add(pz)));
px = 139537859245179;
py = 292990088786943;
pz = 222949159733159;
vpx = 154;
vpy = -164;
vpz = 102;


eqs.push(x.add(t53.mul(vx)).eq(t53.mul(vpx).add(px)));
eqs.push(y.add(t53.mul(vy)).eq(t53.mul(vpy).add(py)));
eqs.push(z.add(t53.mul(vz)).eq(t53.mul(vpz).add(pz)));
px = 281771608749457;
py = 286998983543310;
pz = 331946898945808;
vpx = 9;
vpy = -67;
vpz = -35;


eqs.push(x.add(t54.mul(vx)).eq(t54.mul(vpx).add(px)));
eqs.push(y.add(t54.mul(vy)).eq(t54.mul(vpy).add(py)));
eqs.push(z.add(t54.mul(vz)).eq(t54.mul(vpz).add(pz)));
px = 324649828198072;
py = 422398718458555;
pz = 467174560000358;
vpx = -83;
vpy = -248;
vpz = -337;


eqs.push(x.add(t55.mul(vx)).eq(t55.mul(vpx).add(px)));
eqs.push(y.add(t55.mul(vy)).eq(t55.mul(vpy).add(py)));
eqs.push(z.add(t55.mul(vz)).eq(t55.mul(vpz).add(pz)));
px = 233274360798549;
py = 207145055922274;
pz = 267181130893562;
vpx = 83;
vpy = 63;
vpz = 62;


eqs.push(x.add(t56.mul(vx)).eq(t56.mul(vpx).add(px)));
eqs.push(y.add(t56.mul(vy)).eq(t56.mul(vpy).add(py)));
eqs.push(z.add(t56.mul(vz)).eq(t56.mul(vpz).add(pz)));
px = 304178874538143;
py = 53305704988308;
pz = 529422903687140;
vpx = -8;
vpy = 82;
vpz = -205;


eqs.push(x.add(t57.mul(vx)).eq(t57.mul(vpx).add(px)));
eqs.push(y.add(t57.mul(vy)).eq(t57.mul(vpy).add(py)));
eqs.push(z.add(t57.mul(vz)).eq(t57.mul(vpz).add(pz)));
px = 316304122802127;
py = 392295632220390;
pz = 357213661388378;
vpx = -64;
vpy = -191;
vpz = -112;


eqs.push(x.add(t58.mul(vx)).eq(t58.mul(vpx).add(px)));
eqs.push(y.add(t58.mul(vy)).eq(t58.mul(vpy).add(py)));
eqs.push(z.add(t58.mul(vz)).eq(t58.mul(vpz).add(pz)));
px = 319638806555470;
py = 420539055708926;
pz = 216374545050404;
vpx = -47;
vpy = -267;
vpz = 137;


eqs.push(x.add(t59.mul(vx)).eq(t59.mul(vpx).add(px)));
eqs.push(y.add(t59.mul(vy)).eq(t59.mul(vpy).add(py)));
eqs.push(z.add(t59.mul(vz)).eq(t59.mul(vpz).add(pz)));
px = 247237743462387;
py = 360290797877334;
pz = 387013342411292;
vpx = 116;
vpy = 71;
vpz = -390;


eqs.push(x.add(t60.mul(vx)).eq(t60.mul(vpx).add(px)));
eqs.push(y.add(t60.mul(vy)).eq(t60.mul(vpy).add(py)));
eqs.push(z.add(t60.mul(vz)).eq(t60.mul(vpz).add(pz)));
px = 306702826165702;
py = 106832790607142;
pz = 342550713958507;
vpx = -9;
vpy = 13;
vpz = -14;


eqs.push(x.add(t61.mul(vx)).eq(t61.mul(vpx).add(px)));
eqs.push(y.add(t61.mul(vy)).eq(t61.mul(vpy).add(py)));
eqs.push(z.add(t61.mul(vz)).eq(t61.mul(vpz).add(pz)));
px = 261417334297627;
py = 325052103502854;
pz = 344840959947648;
vpx = 46;
vpy = -22;
vpz = -107;


eqs.push(x.add(t62.mul(vx)).eq(t62.mul(vpx).add(px)));
eqs.push(y.add(t62.mul(vy)).eq(t62.mul(vpy).add(py)));
eqs.push(z.add(t62.mul(vz)).eq(t62.mul(vpz).add(pz)));
px = 301336648580432;
py = 378307529064045;
pz = 144808148666922;
vpx = -99;
vpy = 14;
vpz = 571;


eqs.push(x.add(t63.mul(vx)).eq(t63.mul(vpx).add(px)));
eqs.push(y.add(t63.mul(vy)).eq(t63.mul(vpy).add(py)));
eqs.push(z.add(t63.mul(vz)).eq(t63.mul(vpz).add(pz)));
px = 269012554705770;
py = 387372467070396;
pz = 393532923667106;
vpx = 29;
vpy = -165;
vpz = -209;


eqs.push(x.add(t64.mul(vx)).eq(t64.mul(vpx).add(px)));
eqs.push(y.add(t64.mul(vy)).eq(t64.mul(vpy).add(py)));
eqs.push(z.add(t64.mul(vz)).eq(t64.mul(vpz).add(pz)));
px = 269312570033932;
py = 434661648029110;
pz = 307394457405958;
vpx = 37;
vpy = -35;
vpz = -297;


eqs.push(x.add(t65.mul(vx)).eq(t65.mul(vpx).add(px)));
eqs.push(y.add(t65.mul(vy)).eq(t65.mul(vpy).add(py)));
eqs.push(z.add(t65.mul(vz)).eq(t65.mul(vpz).add(pz)));
px = 268744271151861;
py = 289031189760834;
pz = 291169322258114;
vpx = 29;
vpy = -13;
vpz = 20;


eqs.push(x.add(t66.mul(vx)).eq(t66.mul(vpx).add(px)));
eqs.push(y.add(t66.mul(vy)).eq(t66.mul(vpy).add(py)));
eqs.push(z.add(t66.mul(vz)).eq(t66.mul(vpz).add(pz)));
px = 256196973903807;
py = 290532096714210;
pz = 200646072951758;
vpx = 76;
vpy = 279;
vpz = 308;


eqs.push(x.add(t67.mul(vx)).eq(t67.mul(vpx).add(px)));
eqs.push(y.add(t67.mul(vy)).eq(t67.mul(vpy).add(py)));
eqs.push(z.add(t67.mul(vz)).eq(t67.mul(vpz).add(pz)));
px = 273118846488495;
py = 445371405950118;
pz = 389543008692968;
vpx = 15;
vpy = -257;
vpz = -417;


eqs.push(x.add(t68.mul(vx)).eq(t68.mul(vpx).add(px)));
eqs.push(y.add(t68.mul(vy)).eq(t68.mul(vpy).add(py)));
eqs.push(z.add(t68.mul(vz)).eq(t68.mul(vpz).add(pz)));
px = 231693759411627;
py = 45770729679966;
pz = 206286995452310;
vpx = 66;
vpy = 101;
vpz = 122;


eqs.push(x.add(t69.mul(vx)).eq(t69.mul(vpx).add(px)));
eqs.push(y.add(t69.mul(vy)).eq(t69.mul(vpy).add(py)));
eqs.push(z.add(t69.mul(vz)).eq(t69.mul(vpz).add(pz)));
px = 397593077056783;
py = 303468227079126;
pz = 340489985475012;
vpx = -255;
vpy = 23;
vpz = -96;


eqs.push(x.add(t70.mul(vx)).eq(t70.mul(vpx).add(px)));
eqs.push(y.add(t70.mul(vy)).eq(t70.mul(vpy).add(py)));
eqs.push(z.add(t70.mul(vz)).eq(t70.mul(vpz).add(pz)));
px = 147291213144669;
py = 127398963485282;
pz = 289938063174374;
vpx = 179;
vpy = 87;
vpz = 32;


eqs.push(x.add(t71.mul(vx)).eq(t71.mul(vpx).add(px)));
eqs.push(y.add(t71.mul(vy)).eq(t71.mul(vpy).add(py)));
eqs.push(z.add(t71.mul(vz)).eq(t71.mul(vpz).add(pz)));
px = 279062146022054;
py = 218288644051118;
pz = 283712519894512;
vpx = 13;
vpy = 37;
vpz = 37;


eqs.push(x.add(t72.mul(vx)).eq(t72.mul(vpx).add(px)));
eqs.push(y.add(t72.mul(vy)).eq(t72.mul(vpy).add(py)));
eqs.push(z.add(t72.mul(vz)).eq(t72.mul(vpz).add(pz)));
px = 281974048517427;
py = 162586692606990;
pz = 317438841834668;
vpx = 14;
vpy = -19;
vpz = 7;


eqs.push(x.add(t73.mul(vx)).eq(t73.mul(vpx).add(px)));
eqs.push(y.add(t73.mul(vy)).eq(t73.mul(vpy).add(py)));
eqs.push(z.add(t73.mul(vz)).eq(t73.mul(vpz).add(pz)));
px = 315097282844553;
py = 236030235469392;
pz = 104618134238444;
vpx = -17;
vpy = -112;
vpz = 215;


eqs.push(x.add(t74.mul(vx)).eq(t74.mul(vpx).add(px)));
eqs.push(y.add(t74.mul(vy)).eq(t74.mul(vpy).add(py)));
eqs.push(z.add(t74.mul(vz)).eq(t74.mul(vpz).add(pz)));
px = 231684036933203;
py = 310263831029412;
pz = 364282571619596;
vpx = 82;
vpy = -109;
vpz = -79;


eqs.push(x.add(t75.mul(vx)).eq(t75.mul(vpx).add(px)));
eqs.push(y.add(t75.mul(vy)).eq(t75.mul(vpy).add(py)));
eqs.push(z.add(t75.mul(vz)).eq(t75.mul(vpz).add(pz)));
px = 273377967027768;
py = 236797636615074;
pz = 204369745689605;
vpx = 23;
vpy = -103;
vpz = 122;


eqs.push(x.add(t76.mul(vx)).eq(t76.mul(vpx).add(px)));
eqs.push(y.add(t76.mul(vy)).eq(t76.mul(vpy).add(py)));
eqs.push(z.add(t76.mul(vz)).eq(t76.mul(vpz).add(pz)));
px = 265666680959117;
py = 435600154727410;
pz = 232785008689678;
vpx = 105;
vpy = 139;
vpz = 726;


eqs.push(x.add(t77.mul(vx)).eq(t77.mul(vpx).add(px)));
eqs.push(y.add(t77.mul(vy)).eq(t77.mul(vpy).add(py)));
eqs.push(z.add(t77.mul(vz)).eq(t77.mul(vpz).add(pz)));
px = 98536893585797;
py = 312295662294412;
pz = 62170711477966;
vpx = 211;
vpy = -168;
vpz = 280;


eqs.push(x.add(t78.mul(vx)).eq(t78.mul(vpx).add(px)));
eqs.push(y.add(t78.mul(vy)).eq(t78.mul(vpy).add(py)));
eqs.push(z.add(t78.mul(vz)).eq(t78.mul(vpz).add(pz)));
px = 286415700563907;
py = 459868507706766;
pz = 268341626133232;
vpx = -49;
vpy = -313;
vpz = 75;


eqs.push(x.add(t79.mul(vx)).eq(t79.mul(vpx).add(px)));
eqs.push(y.add(t79.mul(vy)).eq(t79.mul(vpy).add(py)));
eqs.push(z.add(t79.mul(vz)).eq(t79.mul(vpz).add(pz)));
px = 249907840686301;
py = 301499975324576;
pz = 422522477648468;
vpx = 63;
vpy = -38;
vpz = -217;


eqs.push(x.add(t80.mul(vx)).eq(t80.mul(vpx).add(px)));
eqs.push(y.add(t80.mul(vy)).eq(t80.mul(vpy).add(py)));
eqs.push(z.add(t80.mul(vz)).eq(t80.mul(vpz).add(pz)));
px = 332999276737947;
py = 434926077550905;
pz = 317481674006573;
vpx = -198;
vpy = -228;
vpz = -106;


eqs.push(x.add(t81.mul(vx)).eq(t81.mul(vpx).add(px)));
eqs.push(y.add(t81.mul(vy)).eq(t81.mul(vpy).add(py)));
eqs.push(z.add(t81.mul(vz)).eq(t81.mul(vpz).add(pz)));
px = 265638990566034;
py = 251855758509942;
pz = 298845110741690;
vpx = 33;
vpy = -19;
vpz = 15;


eqs.push(x.add(t82.mul(vx)).eq(t82.mul(vpx).add(px)));
eqs.push(y.add(t82.mul(vy)).eq(t82.mul(vpy).add(py)));
eqs.push(z.add(t82.mul(vz)).eq(t82.mul(vpz).add(pz)));
px = 330149687686095;
py = 254832195425806;
pz = 276810334792564;
vpx = -85;
vpy = 57;
vpz = 46;


eqs.push(x.add(t83.mul(vx)).eq(t83.mul(vpx).add(px)));
eqs.push(y.add(t83.mul(vy)).eq(t83.mul(vpy).add(py)));
eqs.push(z.add(t83.mul(vz)).eq(t83.mul(vpz).add(pz)));
px = 271216279199148;
py = 299452379469804;
pz = 279084920945042;
vpx = 23;
vpy = 267;
vpz = 31;


eqs.push(x.add(t84.mul(vx)).eq(t84.mul(vpx).add(px)));
eqs.push(y.add(t84.mul(vy)).eq(t84.mul(vpy).add(py)));
eqs.push(z.add(t84.mul(vz)).eq(t84.mul(vpz).add(pz)));
px = 330849958763937;
py = 301123922204940;
pz = 203779586283428;
vpx = -77;
vpy = -54;
vpz = 171;


eqs.push(x.add(t85.mul(vx)).eq(t85.mul(vpx).add(px)));
eqs.push(y.add(t85.mul(vy)).eq(t85.mul(vpy).add(py)));
eqs.push(z.add(t85.mul(vz)).eq(t85.mul(vpz).add(pz)));
px = 277661292234039;
py = 274718355975078;
pz = 308175678115746;
vpx = 14;
vpy = -19;
vpz = -5;


eqs.push(x.add(t86.mul(vx)).eq(t86.mul(vpx).add(px)));
eqs.push(y.add(t86.mul(vy)).eq(t86.mul(vpy).add(py)));
eqs.push(z.add(t86.mul(vz)).eq(t86.mul(vpz).add(pz)));
px = 308881913543876;
py = 406703097591989;
pz = 328605909836864;
vpx = -107;
vpy = -134;
vpz = -139;


eqs.push(x.add(t87.mul(vx)).eq(t87.mul(vpx).add(px)));
eqs.push(y.add(t87.mul(vy)).eq(t87.mul(vpy).add(py)));
eqs.push(z.add(t87.mul(vz)).eq(t87.mul(vpz).add(pz)));
px = 244806518069345;
py = 323928824537342;
pz = 355727357622573;
vpx = 108;
vpy = 117;
vpz = -212;


eqs.push(x.add(t88.mul(vx)).eq(t88.mul(vpx).add(px)));
eqs.push(y.add(t88.mul(vy)).eq(t88.mul(vpy).add(py)));
eqs.push(z.add(t88.mul(vz)).eq(t88.mul(vpz).add(pz)));
px = 282765808815827;
py = 428682433212430;
pz = 331695854219608;
vpx = -51;
vpy = -113;
vpz = -312;


eqs.push(x.add(t89.mul(vx)).eq(t89.mul(vpx).add(px)));
eqs.push(y.add(t89.mul(vy)).eq(t89.mul(vpy).add(py)));
eqs.push(z.add(t89.mul(vz)).eq(t89.mul(vpz).add(pz)));
px = 114042058484541;
py = 57585054933291;
pz = 155461437387323;
vpx = 272;
vpy = 308;
vpz = 238;


eqs.push(x.add(t90.mul(vx)).eq(t90.mul(vpx).add(px)));
eqs.push(y.add(t90.mul(vy)).eq(t90.mul(vpy).add(py)));
eqs.push(z.add(t90.mul(vz)).eq(t90.mul(vpz).add(pz)));
px = 316947363623629;
py = 366249784163292;
pz = 234525003541438;
vpx = -113;
vpy = -40;
vpz = 168;


eqs.push(x.add(t91.mul(vx)).eq(t91.mul(vpx).add(px)));
eqs.push(y.add(t91.mul(vy)).eq(t91.mul(vpy).add(py)));
eqs.push(z.add(t91.mul(vz)).eq(t91.mul(vpz).add(pz)));
px = 257454091974513;
py = 358306423318053;
pz = 272661312781067;
vpx = 60;
vpy = -54;
vpz = 54;


eqs.push(x.add(t92.mul(vx)).eq(t92.mul(vpx).add(px)));
eqs.push(y.add(t92.mul(vy)).eq(t92.mul(vpy).add(py)));
eqs.push(z.add(t92.mul(vz)).eq(t92.mul(vpz).add(pz)));
px = 327941728613805;
py = 516313152213920;
pz = 403920559229147;
vpx = -160;
vpy = -501;
vpz = -370;


eqs.push(x.add(t93.mul(vx)).eq(t93.mul(vpx).add(px)));
eqs.push(y.add(t93.mul(vy)).eq(t93.mul(vpy).add(py)));
eqs.push(z.add(t93.mul(vz)).eq(t93.mul(vpz).add(pz)));
px = 266268656989236;
py = 320340905431026;
pz = 161388351945824;
vpx = 39;
vpy = 121;
vpz = 405;


eqs.push(x.add(t94.mul(vx)).eq(t94.mul(vpx).add(px)));
eqs.push(y.add(t94.mul(vy)).eq(t94.mul(vpy).add(py)));
eqs.push(z.add(t94.mul(vz)).eq(t94.mul(vpz).add(pz)));
px = 334169171100818;
py = 344369161102431;
pz = 299562952971470;
vpx = -75;
vpy = -142;
vpz = 11;


eqs.push(x.add(t95.mul(vx)).eq(t95.mul(vpx).add(px)));
eqs.push(y.add(t95.mul(vy)).eq(t95.mul(vpy).add(py)));
eqs.push(z.add(t95.mul(vz)).eq(t95.mul(vpz).add(pz)));
px = 439234520585447;
py = 423874948507650;
pz = 301498412981108;
vpx = -152;
vpy = -289;
vpz = 23;


eqs.push(x.add(t96.mul(vx)).eq(t96.mul(vpx).add(px)));
eqs.push(y.add(t96.mul(vy)).eq(t96.mul(vpy).add(py)));
eqs.push(z.add(t96.mul(vz)).eq(t96.mul(vpz).add(pz)));
px = 318895708853607;
py = 486025745441448;
pz = 536900806204640;
vpx = -74;
vpy = -377;
vpz = -491;


eqs.push(x.add(t97.mul(vx)).eq(t97.mul(vpx).add(px)));
eqs.push(y.add(t97.mul(vy)).eq(t97.mul(vpy).add(py)));
eqs.push(z.add(t97.mul(vz)).eq(t97.mul(vpz).add(pz)));
px = 277309303017633;
py = 342141230045350;
pz = 269059285146990;
vpx = -7;
vpy = 249;
vpz = 72;


eqs.push(x.add(t98.mul(vx)).eq(t98.mul(vpx).add(px)));
eqs.push(y.add(t98.mul(vy)).eq(t98.mul(vpy).add(py)));
eqs.push(z.add(t98.mul(vz)).eq(t98.mul(vpz).add(pz)));
px = 307111474143542;
py = 146142245024510;
pz = 344495522925368;
vpx = -11;
vpy = -11;
vpz = -19;


eqs.push(x.add(t99.mul(vx)).eq(t99.mul(vpx).add(px)));
eqs.push(y.add(t99.mul(vy)).eq(t99.mul(vpy).add(py)));
eqs.push(z.add(t99.mul(vz)).eq(t99.mul(vpz).add(pz)));
px = 292035489628817;
py = 378205500734800;
pz = 312425494203218;
vpx = -35;
vpy = -90;
vpz = -58;


eqs.push(x.add(t100.mul(vx)).eq(t100.mul(vpx).add(px)));
eqs.push(y.add(t100.mul(vy)).eq(t100.mul(vpy).add(py)));
eqs.push(z.add(t100.mul(vz)).eq(t100.mul(vpz).add(pz)));
px = 288046802811951;
py = 481903708723622;
pz = 335902848039198;
vpx = -40;
vpy = -399;
vpz = -182;


eqs.push(x.add(t101.mul(vx)).eq(t101.mul(vpx).add(px)));
eqs.push(y.add(t101.mul(vy)).eq(t101.mul(vpy).add(py)));
eqs.push(z.add(t101.mul(vz)).eq(t101.mul(vpz).add(pz)));
px = 299077518805092;
py = 451002619191319;
pz = 299364822899846;
vpx = -229;
vpy = -218;
vpz = -181;


eqs.push(x.add(t102.mul(vx)).eq(t102.mul(vpx).add(px)));
eqs.push(y.add(t102.mul(vy)).eq(t102.mul(vpy).add(py)));
eqs.push(z.add(t102.mul(vz)).eq(t102.mul(vpz).add(pz)));
px = 338578952775771;
py = 260371574631762;
pz = 259648024246724;
vpx = -142;
vpy = 170;
vpz = 86;


eqs.push(x.add(t103.mul(vx)).eq(t103.mul(vpx).add(px)));
eqs.push(y.add(t103.mul(vy)).eq(t103.mul(vpy).add(py)));
eqs.push(z.add(t103.mul(vz)).eq(t103.mul(vpz).add(pz)));
px = 180222081436251;
py = 287435576112478;
pz = 242578960218608;
vpx = 248;
vpy = 103;
vpz = 128;


eqs.push(x.add(t104.mul(vx)).eq(t104.mul(vpx).add(px)));
eqs.push(y.add(t104.mul(vy)).eq(t104.mul(vpy).add(py)));
eqs.push(z.add(t104.mul(vz)).eq(t104.mul(vpz).add(pz)));
px = 362547459087383;
py = 295292504802178;
pz = 497868843146721;
vpx = -90;
vpy = -119;
vpz = -230;


eqs.push(x.add(t105.mul(vx)).eq(t105.mul(vpx).add(px)));
eqs.push(y.add(t105.mul(vy)).eq(t105.mul(vpy).add(py)));
eqs.push(z.add(t105.mul(vz)).eq(t105.mul(vpz).add(pz)));
px = 288808115934893;
py = 346012569018756;
pz = 280648410315037;
vpx = -20;
vpy = -37;
vpz = 34;


eqs.push(x.add(t106.mul(vx)).eq(t106.mul(vpx).add(px)));
eqs.push(y.add(t106.mul(vy)).eq(t106.mul(vpy).add(py)));
eqs.push(z.add(t106.mul(vz)).eq(t106.mul(vpz).add(pz)));
px = 272807874105531;
py = 390439408169982;
pz = 264788373273776;
vpx = 14;
vpy = 33;
vpz = 94;


eqs.push(x.add(t107.mul(vx)).eq(t107.mul(vpx).add(px)));
eqs.push(y.add(t107.mul(vy)).eq(t107.mul(vpy).add(py)));
eqs.push(z.add(t107.mul(vz)).eq(t107.mul(vpz).add(pz)));
px = 302511531241630;
py = 184207826179129;
pz = 224521189736869;
vpx = -21;
vpy = 78;
vpz = 124;


eqs.push(x.add(t108.mul(vx)).eq(t108.mul(vpx).add(px)));
eqs.push(y.add(t108.mul(vy)).eq(t108.mul(vpy).add(py)));
eqs.push(z.add(t108.mul(vz)).eq(t108.mul(vpz).add(pz)));
px = 225296060369532;
py = 273107692555221;
pz = 308517494417711;
vpx = 101;
vpy = -14;
vpz = -6;


eqs.push(x.add(t109.mul(vx)).eq(t109.mul(vpx).add(px)));
eqs.push(y.add(t109.mul(vy)).eq(t109.mul(vpy).add(py)));
eqs.push(z.add(t109.mul(vz)).eq(t109.mul(vpz).add(pz)));
px = 271285620465063;
py = 104568575628198;
pz = 270361655266940;
vpx = 25;
vpy = 71;
vpz = 56;


eqs.push(x.add(t110.mul(vx)).eq(t110.mul(vpx).add(px)));
eqs.push(y.add(t110.mul(vy)).eq(t110.mul(vpy).add(py)));
eqs.push(z.add(t110.mul(vz)).eq(t110.mul(vpz).add(pz)));
px = 205779393651525;
py = 158598001085695;
pz = 168943397919337;
vpx = 152;
vpy = 264;
vpz = 256;


eqs.push(x.add(t111.mul(vx)).eq(t111.mul(vpx).add(px)));
eqs.push(y.add(t111.mul(vy)).eq(t111.mul(vpy).add(py)));
eqs.push(z.add(t111.mul(vz)).eq(t111.mul(vpz).add(pz)));
px = 201750236796640;
py = 12985344330332;
pz = 2118606375894;
vpx = 139;
vpy = 411;
vpz = 499;


eqs.push(x.add(t112.mul(vx)).eq(t112.mul(vpx).add(px)));
eqs.push(y.add(t112.mul(vy)).eq(t112.mul(vpy).add(py)));
eqs.push(z.add(t112.mul(vz)).eq(t112.mul(vpz).add(pz)));
px = 292284953515732;
py = 350387069343910;
pz = 274587215237438;
vpx = -59;
vpy = 109;
vpz = 47;


eqs.push(x.add(t113.mul(vx)).eq(t113.mul(vpx).add(px)));
eqs.push(y.add(t113.mul(vy)).eq(t113.mul(vpy).add(py)));
eqs.push(z.add(t113.mul(vz)).eq(t113.mul(vpz).add(pz)));
px = 279339603973190;
py = 396504749587547;
pz = 287191191874116;
vpx = -17;
vpy = -8;
vpz = -15;


eqs.push(x.add(t114.mul(vx)).eq(t114.mul(vpx).add(px)));
eqs.push(y.add(t114.mul(vy)).eq(t114.mul(vpy).add(py)));
eqs.push(z.add(t114.mul(vz)).eq(t114.mul(vpz).add(pz)));
px = 288204432689707;
py = 392989194073110;
pz = 280376285126608;
vpx = -42;
vpy = -61;
vpz = 25;


eqs.push(x.add(t115.mul(vx)).eq(t115.mul(vpx).add(px)));
eqs.push(y.add(t115.mul(vy)).eq(t115.mul(vpy).add(py)));
eqs.push(z.add(t115.mul(vz)).eq(t115.mul(vpz).add(pz)));
px = 167132397590417;
py = 213225790229422;
pz = 62525039623800;
vpx = 181;
vpy = 45;
vpz = 369;


eqs.push(x.add(t116.mul(vx)).eq(t116.mul(vpx).add(px)));
eqs.push(y.add(t116.mul(vy)).eq(t116.mul(vpy).add(py)));
eqs.push(z.add(t116.mul(vz)).eq(t116.mul(vpz).add(pz)));
px = 245654091693687;
py = 334202746092570;
pz = 156918144838580;
vpx = 111;
vpy = 114;
vpz = 452;


eqs.push(x.add(t117.mul(vx)).eq(t117.mul(vpx).add(px)));
eqs.push(y.add(t117.mul(vy)).eq(t117.mul(vpy).add(py)));
eqs.push(z.add(t117.mul(vz)).eq(t117.mul(vpz).add(pz)));
px = 312867158510437;
py = 261732270547545;
pz = 387814542702538;
vpx = -68;
vpy = 116;
vpz = -201;


eqs.push(x.add(t118.mul(vx)).eq(t118.mul(vpx).add(px)));
eqs.push(y.add(t118.mul(vy)).eq(t118.mul(vpy).add(py)));
eqs.push(z.add(t118.mul(vz)).eq(t118.mul(vpz).add(pz)));
px = 251443737700485;
py = 299042777218395;
pz = 331691921259038;
vpx = 68;
vpy = 34;
vpz = -77;


eqs.push(x.add(t119.mul(vx)).eq(t119.mul(vpx).add(px)));
eqs.push(y.add(t119.mul(vy)).eq(t119.mul(vpy).add(py)));
eqs.push(z.add(t119.mul(vz)).eq(t119.mul(vpz).add(pz)));
px = 249071808318983;
py = 339880497661598;
pz = 318019160349960;
vpx = 99;
vpy = 93;
vpz = -101;


eqs.push(x.add(t120.mul(vx)).eq(t120.mul(vpx).add(px)));
eqs.push(y.add(t120.mul(vy)).eq(t120.mul(vpy).add(py)));
eqs.push(z.add(t120.mul(vz)).eq(t120.mul(vpz).add(pz)));
px = 345158773413630;
py = 462131781350082;
pz = 309436145474852;
vpx = -163;
vpy = -327;
vpz = -39;


eqs.push(x.add(t121.mul(vx)).eq(t121.mul(vpx).add(px)));
eqs.push(y.add(t121.mul(vy)).eq(t121.mul(vpy).add(py)));
eqs.push(z.add(t121.mul(vz)).eq(t121.mul(vpz).add(pz)));
px = 202130071322571;
py = 279871754990196;
pz = 257527720559768;
vpx = 114;
vpy = -94;
vpz = 73;


eqs.push(x.add(t122.mul(vx)).eq(t122.mul(vpx).add(px)));
eqs.push(y.add(t122.mul(vy)).eq(t122.mul(vpy).add(py)));
eqs.push(z.add(t122.mul(vz)).eq(t122.mul(vpz).add(pz)));
px = 285698456170628;
py = 389258400382057;
pz = 283159525263149;
vpx = -33;
vpy = -44;
vpz = 14;


eqs.push(x.add(t123.mul(vx)).eq(t123.mul(vpx).add(px)));
eqs.push(y.add(t123.mul(vy)).eq(t123.mul(vpy).add(py)));
eqs.push(z.add(t123.mul(vz)).eq(t123.mul(vpz).add(pz)));
px = 299827810110366;
py = 263703105196145;
pz = 180961293180126;
vpx = -13;
vpy = -66;
vpz = 175;


eqs.push(x.add(t124.mul(vx)).eq(t124.mul(vpx).add(px)));
eqs.push(y.add(t124.mul(vy)).eq(t124.mul(vpy).add(py)));
eqs.push(z.add(t124.mul(vz)).eq(t124.mul(vpz).add(pz)));
px = 224485850365387;
py = 70640821943795;
pz = 141634852869037;
vpx = 106;
vpy = 354;
vpz = 282;


eqs.push(x.add(t125.mul(vx)).eq(t125.mul(vpx).add(px)));
eqs.push(y.add(t125.mul(vy)).eq(t125.mul(vpy).add(py)));
eqs.push(z.add(t125.mul(vz)).eq(t125.mul(vpz).add(pz)));
px = 313614170820024;
py = 195171223806147;
pz = 341771827813217;
vpx = -35;
vpy = 48;
vpz = -44;


eqs.push(x.add(t126.mul(vx)).eq(t126.mul(vpx).add(px)));
eqs.push(y.add(t126.mul(vy)).eq(t126.mul(vpy).add(py)));
eqs.push(z.add(t126.mul(vz)).eq(t126.mul(vpz).add(pz)));
px = 234803600210211;
py = 72733572075097;
pz = 404522037783646;
vpx = 98;
vpy = 460;
vpz = -213;


eqs.push(x.add(t127.mul(vx)).eq(t127.mul(vpx).add(px)));
eqs.push(y.add(t127.mul(vy)).eq(t127.mul(vpy).add(py)));
eqs.push(z.add(t127.mul(vz)).eq(t127.mul(vpz).add(pz)));
px = 300197381692515;
py = 549817932431822;
pz = 349210583580184;
vpx = -10;
vpy = -435;
vpz = -39;


eqs.push(x.add(t128.mul(vx)).eq(t128.mul(vpx).add(px)));
eqs.push(y.add(t128.mul(vy)).eq(t128.mul(vpy).add(py)));
eqs.push(z.add(t128.mul(vz)).eq(t128.mul(vpz).add(pz)));
px = 254308938013475;
py = 228010819920710;
pz = 270823461852576;
vpx = 55;
vpy = 94;
vpz = 57;


eqs.push(x.add(t129.mul(vx)).eq(t129.mul(vpx).add(px)));
eqs.push(y.add(t129.mul(vy)).eq(t129.mul(vpy).add(py)));
eqs.push(z.add(t129.mul(vz)).eq(t129.mul(vpz).add(pz)));
px = 276569191946117;
py = 456319180009760;
pz = 277217824707488;
vpx = -45;
vpy = -246;
vpz = 5;


eqs.push(x.add(t130.mul(vx)).eq(t130.mul(vpx).add(px)));
eqs.push(y.add(t130.mul(vy)).eq(t130.mul(vpy).add(py)));
eqs.push(z.add(t130.mul(vz)).eq(t130.mul(vpz).add(pz)));
px = 365061136404707;
py = 490762403014510;
pz = 227059802667528;
vpx = -149;
vpy = -381;
vpz = 138;


eqs.push(x.add(t131.mul(vx)).eq(t131.mul(vpx).add(px)));
eqs.push(y.add(t131.mul(vy)).eq(t131.mul(vpy).add(py)));
eqs.push(z.add(t131.mul(vz)).eq(t131.mul(vpz).add(pz)));
px = 215364734017875;
py = 180715624686174;
pz = 309399294492047;
vpx = 82;
vpy = -43;
vpz = 16;


eqs.push(x.add(t132.mul(vx)).eq(t132.mul(vpx).add(px)));
eqs.push(y.add(t132.mul(vy)).eq(t132.mul(vpy).add(py)));
eqs.push(z.add(t132.mul(vz)).eq(t132.mul(vpz).add(pz)));
px = 256910072363323;
py = 125697352146654;
pz = 366453893454240;
vpx = 40;
vpy = 20;
vpz = -44;


eqs.push(x.add(t133.mul(vx)).eq(t133.mul(vpx).add(px)));
eqs.push(y.add(t133.mul(vy)).eq(t133.mul(vpy).add(py)));
eqs.push(z.add(t133.mul(vz)).eq(t133.mul(vpz).add(pz)));
px = 262846559729706;
py = 375681397818765;
pz = 273041846062208;
vpx = 59;
vpy = 54;
vpz = 53;


eqs.push(x.add(t134.mul(vx)).eq(t134.mul(vpx).add(px)));
eqs.push(y.add(t134.mul(vy)).eq(t134.mul(vpy).add(py)));
eqs.push(z.add(t134.mul(vz)).eq(t134.mul(vpz).add(pz)));
px = 249059367699955;
py = 319717365318984;
pz = 316469445437246;
vpx = 82;
vpy = 47;
vpz = -61;


eqs.push(x.add(t135.mul(vx)).eq(t135.mul(vpx).add(px)));
eqs.push(y.add(t135.mul(vy)).eq(t135.mul(vpy).add(py)));
eqs.push(z.add(t135.mul(vz)).eq(t135.mul(vpz).add(pz)));
px = 351641125870887;
py = 373169814589095;
pz = 279927346260308;
vpx = -210;
vpy = -68;
vpz = 33;


eqs.push(x.add(t136.mul(vx)).eq(t136.mul(vpx).add(px)));
eqs.push(y.add(t136.mul(vy)).eq(t136.mul(vpy).add(py)));
eqs.push(z.add(t136.mul(vz)).eq(t136.mul(vpz).add(pz)));
px = 372162402226347;
py = 397883781850710;
pz = 390113135537768;
vpx = -260;
vpy = -146;
vpz = -276;


eqs.push(x.add(t137.mul(vx)).eq(t137.mul(vpx).add(px)));
eqs.push(y.add(t137.mul(vy)).eq(t137.mul(vpy).add(py)));
eqs.push(z.add(t137.mul(vz)).eq(t137.mul(vpz).add(pz)));
px = 337578787443909;
py = 271222575652692;
pz = 273454033570862;
vpx = -137;
vpy = 136;
vpz = 52;


eqs.push(x.add(t138.mul(vx)).eq(t138.mul(vpx).add(px)));
eqs.push(y.add(t138.mul(vy)).eq(t138.mul(vpy).add(py)));
eqs.push(z.add(t138.mul(vz)).eq(t138.mul(vpz).add(pz)));
px = 399858185929617;
py = 297153999560655;
pz = 206854191129263;
vpx = -152;
vpy = -102;
vpz = 144;


eqs.push(x.add(t139.mul(vx)).eq(t139.mul(vpx).add(px)));
eqs.push(y.add(t139.mul(vy)).eq(t139.mul(vpy).add(py)));
eqs.push(z.add(t139.mul(vz)).eq(t139.mul(vpz).add(pz)));
px = 256793953778627;
py = 450638882814610;
pz = 135490117389868;
vpx = 78;
vpy = -281;
vpz = 579;


eqs.push(x.add(t140.mul(vx)).eq(t140.mul(vpx).add(px)));
eqs.push(y.add(t140.mul(vy)).eq(t140.mul(vpy).add(py)));
eqs.push(z.add(t140.mul(vz)).eq(t140.mul(vpz).add(pz)));
px = 247177305739257;
py = 208350046459560;
pz = 104164698972158;
vpx = 77;
vpy = 230;
vpz = 424;


eqs.push(x.add(t141.mul(vx)).eq(t141.mul(vpx).add(px)));
eqs.push(y.add(t141.mul(vy)).eq(t141.mul(vpy).add(py)));
eqs.push(z.add(t141.mul(vz)).eq(t141.mul(vpz).add(pz)));
px = 37127457323232;
py = 142872779547270;
pz = 37321661260448;
vpx = 311;
vpy = 61;
vpz = 341;


eqs.push(x.add(t142.mul(vx)).eq(t142.mul(vpx).add(px)));
eqs.push(y.add(t142.mul(vy)).eq(t142.mul(vpy).add(py)));
eqs.push(z.add(t142.mul(vz)).eq(t142.mul(vpz).add(pz)));
px = 295888104359025;
py = 343758112735404;
pz = 317764128822074;
vpx = -35;
vpy = -44;
vpz = -54;


eqs.push(x.add(t143.mul(vx)).eq(t143.mul(vpx).add(px)));
eqs.push(y.add(t143.mul(vy)).eq(t143.mul(vpy).add(py)));
eqs.push(z.add(t143.mul(vz)).eq(t143.mul(vpz).add(pz)));
px = 172249909503397;
py = 363737392387940;
pz = 180402839361078;
vpx = 133;
vpy = -222;
vpz = 154;


eqs.push(x.add(t144.mul(vx)).eq(t144.mul(vpx).add(px)));
eqs.push(y.add(t144.mul(vy)).eq(t144.mul(vpy).add(py)));
eqs.push(z.add(t144.mul(vz)).eq(t144.mul(vpz).add(pz)));
px = 266945241349051;
py = 252155610635398;
pz = 284675410934072;
vpx = 34;
vpy = 160;
vpz = 26;


eqs.push(x.add(t145.mul(vx)).eq(t145.mul(vpx).add(px)));
eqs.push(y.add(t145.mul(vy)).eq(t145.mul(vpy).add(py)));
eqs.push(z.add(t145.mul(vz)).eq(t145.mul(vpz).add(pz)));
px = 363630573951458;
py = 250073512495827;
pz = 350128671211073;
vpx = -101;
vpy = -40;
vpz = -52;


eqs.push(x.add(t146.mul(vx)).eq(t146.mul(vpx).add(px)));
eqs.push(y.add(t146.mul(vy)).eq(t146.mul(vpy).add(py)));
eqs.push(z.add(t146.mul(vz)).eq(t146.mul(vpz).add(pz)));
px = 258823670942991;
py = 155219406452350;
pz = 365590266784736;
vpx = 38;
vpy = -11;
vpz = -43;


eqs.push(x.add(t147.mul(vx)).eq(t147.mul(vpx).add(px)));
eqs.push(y.add(t147.mul(vy)).eq(t147.mul(vpy).add(py)));
eqs.push(z.add(t147.mul(vz)).eq(t147.mul(vpz).add(pz)));
px = 342703092464223;
py = 215373784249550;
pz = 286919689594404;
vpx = -73;
vpy = 9;
vpz = 34;


eqs.push(x.add(t148.mul(vx)).eq(t148.mul(vpx).add(px)));
eqs.push(y.add(t148.mul(vy)).eq(t148.mul(vpy).add(py)));
eqs.push(z.add(t148.mul(vz)).eq(t148.mul(vpz).add(pz)));
px = 260407037303904;
py = 414839283281769;
pz = 219962698211171;
vpx = 83;
vpy = -52;
vpz = 356;


eqs.push(x.add(t149.mul(vx)).eq(t149.mul(vpx).add(px)));
eqs.push(y.add(t149.mul(vy)).eq(t149.mul(vpy).add(py)));
eqs.push(z.add(t149.mul(vz)).eq(t149.mul(vpz).add(pz)));
px = 310782605378913;
py = 113664166198858;
pz = 274077496878762;
vpx = -13;
vpy = 7;
vpz = 52;


eqs.push(x.add(t150.mul(vx)).eq(t150.mul(vpx).add(px)));
eqs.push(y.add(t150.mul(vy)).eq(t150.mul(vpy).add(py)));
eqs.push(z.add(t150.mul(vz)).eq(t150.mul(vpz).add(pz)));
px = 291127144241187;
py = 318569697238950;
pz = 259564147602086;
vpx = 6;
vpy = -191;
vpz = 66;


eqs.push(x.add(t151.mul(vx)).eq(t151.mul(vpx).add(px)));
eqs.push(y.add(t151.mul(vy)).eq(t151.mul(vpy).add(py)));
eqs.push(z.add(t151.mul(vz)).eq(t151.mul(vpz).add(pz)));
px = 274748127176803;
py = 292552751967326;
pz = 223845757853312;
vpx = 9;
vpy = 337;
vpz = 245;


eqs.push(x.add(t152.mul(vx)).eq(t152.mul(vpx).add(px)));
eqs.push(y.add(t152.mul(vy)).eq(t152.mul(vpy).add(py)));
eqs.push(z.add(t152.mul(vz)).eq(t152.mul(vpz).add(pz)));
px = 293125400088063;
py = 476133192349023;
pz = 361869628526162;
vpx = -82;
vpy = -390;
vpz = -369;


eqs.push(x.add(t153.mul(vx)).eq(t153.mul(vpx).add(px)));
eqs.push(y.add(t153.mul(vy)).eq(t153.mul(vpy).add(py)));
eqs.push(z.add(t153.mul(vz)).eq(t153.mul(vpz).add(pz)));
px = 282164981148321;
py = 279274272892224;
pz = 276609348369788;
vpx = -7;
vpy = 186;
vpz = 43;


eqs.push(x.add(t154.mul(vx)).eq(t154.mul(vpx).add(px)));
eqs.push(y.add(t154.mul(vy)).eq(t154.mul(vpy).add(py)));
eqs.push(z.add(t154.mul(vz)).eq(t154.mul(vpz).add(pz)));
px = 174918204232227;
py = 112847121262641;
pz = 27991863189436;
vpx = 146;
vpy = 110;
vpz = 361;


eqs.push(x.add(t155.mul(vx)).eq(t155.mul(vpx).add(px)));
eqs.push(y.add(t155.mul(vy)).eq(t155.mul(vpy).add(py)));
eqs.push(z.add(t155.mul(vz)).eq(t155.mul(vpz).add(pz)));
px = 249955668205419;
py = 17029432884558;
pz = 46779983503448;
vpx = 54;
vpy = 281;
vpz = 363;


eqs.push(x.add(t156.mul(vx)).eq(t156.mul(vpx).add(px)));
eqs.push(y.add(t156.mul(vy)).eq(t156.mul(vpy).add(py)));
eqs.push(z.add(t156.mul(vz)).eq(t156.mul(vpz).add(pz)));
px = 325400633182867;
py = 521617731298910;
pz = 409839075322298;
vpx = -50;
vpy = -411;
vpz = -136;


eqs.push(x.add(t157.mul(vx)).eq(t157.mul(vpx).add(px)));
eqs.push(y.add(t157.mul(vy)).eq(t157.mul(vpy).add(py)));
eqs.push(z.add(t157.mul(vz)).eq(t157.mul(vpz).add(pz)));
px = 277793703195657;
py = 422561915271444;
pz = 188813007504665;
vpx = -24;
vpy = -53;
vpz = 622;


eqs.push(x.add(t158.mul(vx)).eq(t158.mul(vpx).add(px)));
eqs.push(y.add(t158.mul(vy)).eq(t158.mul(vpy).add(py)));
eqs.push(z.add(t158.mul(vz)).eq(t158.mul(vpz).add(pz)));
px = 318315084458607;
py = 323300159682981;
pz = 286939475730545;
vpx = -74;
vpy = -38;
vpz = 24;


eqs.push(x.add(t159.mul(vx)).eq(t159.mul(vpx).add(px)));
eqs.push(y.add(t159.mul(vy)).eq(t159.mul(vpy).add(py)));
eqs.push(z.add(t159.mul(vz)).eq(t159.mul(vpz).add(pz)));
px = 255642309986097;
py = 153965957702700;
pz = 396941119858772;
vpx = 41;
vpy = -16;
vpz = -73;


eqs.push(x.add(t160.mul(vx)).eq(t160.mul(vpx).add(px)));
eqs.push(y.add(t160.mul(vy)).eq(t160.mul(vpy).add(py)));
eqs.push(z.add(t160.mul(vz)).eq(t160.mul(vpz).add(pz)));
px = 311855158178637;
py = 285884222493028;
pz = 276266740979067;
vpx = -64;
vpy = 55;
vpz = 46;


eqs.push(x.add(t161.mul(vx)).eq(t161.mul(vpx).add(px)));
eqs.push(y.add(t161.mul(vy)).eq(t161.mul(vpy).add(py)));
eqs.push(z.add(t161.mul(vz)).eq(t161.mul(vpz).add(pz)));
px = 252905927924047;
py = 229397781030026;
pz = 369216471913138;
vpx = 46;
vpy = -63;
vpz = -57;


eqs.push(x.add(t162.mul(vx)).eq(t162.mul(vpx).add(px)));
eqs.push(y.add(t162.mul(vy)).eq(t162.mul(vpy).add(py)));
eqs.push(z.add(t162.mul(vz)).eq(t162.mul(vpz).add(pz)));
px = 295981809556490;
py = 246548466213584;
pz = 395456892713651;
vpx = -11;
vpy = -17;
vpz = -124;


eqs.push(x.add(t163.mul(vx)).eq(t163.mul(vpx).add(px)));
eqs.push(y.add(t163.mul(vy)).eq(t163.mul(vpy).add(py)));
eqs.push(z.add(t163.mul(vz)).eq(t163.mul(vpz).add(pz)));
px = 279043571254974;
py = 200328667112248;
pz = 359555323278878;
vpx = 17;
vpy = -57;
vpz = -37;


eqs.push(x.add(t164.mul(vx)).eq(t164.mul(vpx).add(px)));
eqs.push(y.add(t164.mul(vy)).eq(t164.mul(vpy).add(py)));
eqs.push(z.add(t164.mul(vz)).eq(t164.mul(vpz).add(pz)));
px = 217695580278467;
py = 167295523885635;
pz = 369314559700858;
vpx = 130;
vpy = 254;
vpz = -137;


eqs.push(x.add(t165.mul(vx)).eq(t165.mul(vpx).add(px)));
eqs.push(y.add(t165.mul(vy)).eq(t165.mul(vpy).add(py)));
eqs.push(z.add(t165.mul(vz)).eq(t165.mul(vpz).add(pz)));
px = 174106338139371;
py = 39732596425854;
pz = 161382584008736;
vpx = 145;
vpy = 193;
vpz = 191;


eqs.push(x.add(t166.mul(vx)).eq(t166.mul(vpx).add(px)));
eqs.push(y.add(t166.mul(vy)).eq(t166.mul(vpy).add(py)));
eqs.push(z.add(t166.mul(vz)).eq(t166.mul(vpz).add(pz)));
px = 346210458355071;
py = 309591828785934;
pz = 307843658767280;
vpx = -157;
vpy = 41;
vpz = -31;


eqs.push(x.add(t167.mul(vx)).eq(t167.mul(vpx).add(px)));
eqs.push(y.add(t167.mul(vy)).eq(t167.mul(vpy).add(py)));
eqs.push(z.add(t167.mul(vz)).eq(t167.mul(vpz).add(pz)));
px = 268115431092279;
py = 437278052184396;
pz = 275571615441128;
vpx = 44;
vpy = -122;
vpz = 33;


eqs.push(x.add(t168.mul(vx)).eq(t168.mul(vpx).add(px)));
eqs.push(y.add(t168.mul(vy)).eq(t168.mul(vpy).add(py)));
eqs.push(z.add(t168.mul(vz)).eq(t168.mul(vpz).add(pz)));
px = 282893044906941;
py = 149804627700634;
pz = 292487568198972;
vpx = 8;
vpy = 121;
vpz = 25;


eqs.push(x.add(t169.mul(vx)).eq(t169.mul(vpx).add(px)));
eqs.push(y.add(t169.mul(vy)).eq(t169.mul(vpy).add(py)));
eqs.push(z.add(t169.mul(vz)).eq(t169.mul(vpz).add(pz)));
px = 267897589339695;
py = 437936255526786;
pz = 277577544596048;
vpx = 59;
vpy = 10;
vpz = -7;


eqs.push(x.add(t170.mul(vx)).eq(t170.mul(vpx).add(px)));
eqs.push(y.add(t170.mul(vy)).eq(t170.mul(vpy).add(py)));
eqs.push(z.add(t170.mul(vz)).eq(t170.mul(vpz).add(pz)));
px = 346296387214107;
py = 194796533724990;
pz = 320753034661568;
vpx = -79;
vpy = 41;
vpz = -13;


eqs.push(x.add(t171.mul(vx)).eq(t171.mul(vpx).add(px)));
eqs.push(y.add(t171.mul(vy)).eq(t171.mul(vpy).add(py)));
eqs.push(z.add(t171.mul(vz)).eq(t171.mul(vpz).add(pz)));
px = 315255524851362;
py = 229609278952623;
pz = 335034771519884;
vpx = -29;
vpy = -44;
vpz = -23;


eqs.push(x.add(t172.mul(vx)).eq(t172.mul(vpx).add(px)));
eqs.push(y.add(t172.mul(vy)).eq(t172.mul(vpy).add(py)));
eqs.push(z.add(t172.mul(vz)).eq(t172.mul(vpz).add(pz)));
px = 286757602361455;
py = 297841319495254;
pz = 420052876213368;
vpx = -33;
vpy = 267;
vpz = -477;


eqs.push(x.add(t173.mul(vx)).eq(t173.mul(vpx).add(px)));
eqs.push(y.add(t173.mul(vy)).eq(t173.mul(vpy).add(py)));
eqs.push(z.add(t173.mul(vz)).eq(t173.mul(vpz).add(pz)));
px = 279149085394077;
py = 286241741815838;
pz = 295809686900210;
vpx = 11;
vpy = -27;
vpz = 14;


eqs.push(x.add(t174.mul(vx)).eq(t174.mul(vpx).add(px)));
eqs.push(y.add(t174.mul(vy)).eq(t174.mul(vpy).add(py)));
eqs.push(z.add(t174.mul(vz)).eq(t174.mul(vpz).add(pz)));
px = 249787414488866;
py = 224616754074458;
pz = 353421002136562;
vpx = 127;
vpy = 841;
vpz = -341;


eqs.push(x.add(t175.mul(vx)).eq(t175.mul(vpx).add(px)));
eqs.push(y.add(t175.mul(vy)).eq(t175.mul(vpy).add(py)));
eqs.push(z.add(t175.mul(vz)).eq(t175.mul(vpz).add(pz)));
px = 254897534574362;
py = 284861161068002;
pz = 291192767414115;
vpx = 61;
vpy = 73;
vpz = 12;


eqs.push(x.add(t176.mul(vx)).eq(t176.mul(vpx).add(px)));
eqs.push(y.add(t176.mul(vy)).eq(t176.mul(vpy).add(py)));
eqs.push(z.add(t176.mul(vz)).eq(t176.mul(vpz).add(pz)));
px = 327689466751032;
py = 312558557705445;
pz = 390910460681528;
vpx = -79;
vpy = -54;
vpz = -163;


eqs.push(x.add(t177.mul(vx)).eq(t177.mul(vpx).add(px)));
eqs.push(y.add(t177.mul(vy)).eq(t177.mul(vpy).add(py)));
eqs.push(z.add(t177.mul(vz)).eq(t177.mul(vpz).add(pz)));
px = 349426050024227;
py = 325969473167078;
pz = 411633306087357;
vpx = -254;
vpy = 157;
vpz = -438;


eqs.push(x.add(t178.mul(vx)).eq(t178.mul(vpx).add(px)));
eqs.push(y.add(t178.mul(vy)).eq(t178.mul(vpy).add(py)));
eqs.push(z.add(t178.mul(vz)).eq(t178.mul(vpz).add(pz)));
px = 286724659720566;
py = 160122975419178;
pz = 286492087628186;
vpx = 9;
vpy = -15;
vpz = 39;


eqs.push(x.add(t179.mul(vx)).eq(t179.mul(vpx).add(px)));
eqs.push(y.add(t179.mul(vy)).eq(t179.mul(vpy).add(py)));
eqs.push(z.add(t179.mul(vz)).eq(t179.mul(vpz).add(pz)));
px = 262042638250419;
py = 379072267855814;
pz = 314462337759672;
vpx = 77;
vpy = 186;
vpz = -200;


eqs.push(x.add(t180.mul(vx)).eq(t180.mul(vpx).add(px)));
eqs.push(y.add(t180.mul(vy)).eq(t180.mul(vpy).add(py)));
eqs.push(z.add(t180.mul(vz)).eq(t180.mul(vpz).add(pz)));
px = 290089021697532;
py = 396557439881800;
pz = 284672336406798;
vpx = -79;
vpy = 27;
vpz = -9;


eqs.push(x.add(t181.mul(vx)).eq(t181.mul(vpx).add(px)));
eqs.push(y.add(t181.mul(vy)).eq(t181.mul(vpy).add(py)));
eqs.push(z.add(t181.mul(vz)).eq(t181.mul(vpz).add(pz)));
px = 199041215073927;
py = 175260919960890;
pz = 160221875421308;
vpx = 260;
vpy = 615;
vpz = 423;


eqs.push(x.add(t182.mul(vx)).eq(t182.mul(vpx).add(px)));
eqs.push(y.add(t182.mul(vy)).eq(t182.mul(vpy).add(py)));
eqs.push(z.add(t182.mul(vz)).eq(t182.mul(vpz).add(pz)));
px = 299001970398348;
py = 410805706210815;
pz = 309881794080206;
vpx = -193;
vpy = 74;
vpz = -229;


eqs.push(x.add(t183.mul(vx)).eq(t183.mul(vpx).add(px)));
eqs.push(y.add(t183.mul(vy)).eq(t183.mul(vpy).add(py)));
eqs.push(z.add(t183.mul(vz)).eq(t183.mul(vpz).add(pz)));
px = 331984959199482;
py = 407400783870750;
pz = 286064310174485;
vpx = -149;
vpy = -171;
vpz = 16;


eqs.push(x.add(t184.mul(vx)).eq(t184.mul(vpx).add(px)));
eqs.push(y.add(t184.mul(vy)).eq(t184.mul(vpy).add(py)));
eqs.push(z.add(t184.mul(vz)).eq(t184.mul(vpz).add(pz)));
px = 340834762010483;
py = 451723922878846;
pz = 270793679940596;
vpx = -68;
vpy = -315;
vpz = 56;


eqs.push(x.add(t185.mul(vx)).eq(t185.mul(vpx).add(px)));
eqs.push(y.add(t185.mul(vy)).eq(t185.mul(vpy).add(py)));
eqs.push(z.add(t185.mul(vz)).eq(t185.mul(vpz).add(pz)));
px = 280650616915145;
py = 300312590469119;
pz = 236404726841358;
vpx = 12;
vpy = -108;
vpz = 103;


eqs.push(x.add(t186.mul(vx)).eq(t186.mul(vpx).add(px)));
eqs.push(y.add(t186.mul(vy)).eq(t186.mul(vpy).add(py)));
eqs.push(z.add(t186.mul(vz)).eq(t186.mul(vpz).add(pz)));
px = 377338176867579;
py = 289926968025918;
pz = 270071125136256;
vpx = -118;
vpy = -97;
vpz = 57;


eqs.push(x.add(t187.mul(vx)).eq(t187.mul(vpx).add(px)));
eqs.push(y.add(t187.mul(vy)).eq(t187.mul(vpy).add(py)));
eqs.push(z.add(t187.mul(vz)).eq(t187.mul(vpz).add(pz)));
px = 268907170557389;
py = 477079618977372;
pz = 213639727025488;
vpx = 28;
vpy = -349;
vpz = 133;


eqs.push(x.add(t188.mul(vx)).eq(t188.mul(vpx).add(px)));
eqs.push(y.add(t188.mul(vy)).eq(t188.mul(vpy).add(py)));
eqs.push(z.add(t188.mul(vz)).eq(t188.mul(vpz).add(pz)));
px = 225234660515415;
py = 245452587607632;
pz = 302310636907138;
vpx = 80;
vpy = -70;
vpz = 18;


eqs.push(x.add(t189.mul(vx)).eq(t189.mul(vpx).add(px)));
eqs.push(y.add(t189.mul(vy)).eq(t189.mul(vpy).add(py)));
eqs.push(z.add(t189.mul(vz)).eq(t189.mul(vpz).add(pz)));
px = 239124996839450;
py = 329796020316647;
pz = 217586764756122;
vpx = 79;
vpy = -104;
vpz = 147;


eqs.push(x.add(t190.mul(vx)).eq(t190.mul(vpx).add(px)));
eqs.push(y.add(t190.mul(vy)).eq(t190.mul(vpy).add(py)));
eqs.push(z.add(t190.mul(vz)).eq(t190.mul(vpz).add(pz)));
px = 239554809832227;
py = 129642160432410;
pz = 315186311453684;
vpx = 56;
vpy = -6;
vpz = 12;


eqs.push(x.add(t191.mul(vx)).eq(t191.mul(vpx).add(px)));
eqs.push(y.add(t191.mul(vy)).eq(t191.mul(vpy).add(py)));
eqs.push(z.add(t191.mul(vz)).eq(t191.mul(vpz).add(pz)));
px = 253320335853005;
py = 413624098121136;
pz = 266850941738582;
vpx = 117;
vpy = -64;
vpz = 86;


eqs.push(x.add(t192.mul(vx)).eq(t192.mul(vpx).add(px)));
eqs.push(y.add(t192.mul(vy)).eq(t192.mul(vpy).add(py)));
eqs.push(z.add(t192.mul(vz)).eq(t192.mul(vpz).add(pz)));
px = 110151001176190;
py = 232349810448540;
pz = 176211588702025;
vpx = 213;
vpy = -61;
vpz = 166;


eqs.push(x.add(t193.mul(vx)).eq(t193.mul(vpx).add(px)));
eqs.push(y.add(t193.mul(vy)).eq(t193.mul(vpy).add(py)));
eqs.push(z.add(t193.mul(vz)).eq(t193.mul(vpz).add(pz)));
px = 343059121083093;
py = 337995951341106;
pz = 558359726012288;
vpx = -137;
vpy = -49;
vpz = -587;


eqs.push(x.add(t194.mul(vx)).eq(t194.mul(vpx).add(px)));
eqs.push(y.add(t194.mul(vy)).eq(t194.mul(vpy).add(py)));
eqs.push(z.add(t194.mul(vz)).eq(t194.mul(vpz).add(pz)));
px = 428022104051019;
py = 368959101658182;
pz = 365140203218624;
vpx = -152;
vpy = -224;
vpz = -51;


eqs.push(x.add(t195.mul(vx)).eq(t195.mul(vpx).add(px)));
eqs.push(y.add(t195.mul(vy)).eq(t195.mul(vpy).add(py)));
eqs.push(z.add(t195.mul(vz)).eq(t195.mul(vpz).add(pz)));
px = 391393694476735;
py = 271335399064952;
pz = 241092019464786;
vpx = -152;
vpy = -48;
vpz = 100;


eqs.push(x.add(t196.mul(vx)).eq(t196.mul(vpx).add(px)));
eqs.push(y.add(t196.mul(vy)).eq(t196.mul(vpy).add(py)));
eqs.push(z.add(t196.mul(vz)).eq(t196.mul(vpz).add(pz)));
px = 452639727139518;
py = 425511057245729;
pz = 406439503340981;
vpx = -265;
vpy = -270;
vpz = -160;


eqs.push(x.add(t197.mul(vx)).eq(t197.mul(vpx).add(px)));
eqs.push(y.add(t197.mul(vy)).eq(t197.mul(vpy).add(py)));
eqs.push(z.add(t197.mul(vz)).eq(t197.mul(vpz).add(pz)));
px = 218921039491667;
py = 108271625982030;
pz = 352676508164368;
vpx = 79;
vpy = 35;
vpz = -29;


eqs.push(x.add(t198.mul(vx)).eq(t198.mul(vpx).add(px)));
eqs.push(y.add(t198.mul(vy)).eq(t198.mul(vpy).add(py)));
eqs.push(z.add(t198.mul(vz)).eq(t198.mul(vpz).add(pz)));
px = 221949088556126;
py = 205077065621025;
pz = 338727452810928;
vpx = 85;
vpy = -16;
vpz = -27;


eqs.push(x.add(t199.mul(vx)).eq(t199.mul(vpx).add(px)));
eqs.push(y.add(t199.mul(vy)).eq(t199.mul(vpy).add(py)));
eqs.push(z.add(t199.mul(vz)).eq(t199.mul(vpz).add(pz)));
px = 280534348923077;
py = 134095067026585;
pz = 348093573946506;
vpx = 16;
vpy = -6;
vpz = -21;


eqs.push(x.add(t200.mul(vx)).eq(t200.mul(vpx).add(px)));
eqs.push(y.add(t200.mul(vy)).eq(t200.mul(vpy).add(py)));
eqs.push(z.add(t200.mul(vz)).eq(t200.mul(vpz).add(pz)));
px = 125204260705579;
py = 234160200966486;
pz = 267155847569192;
vpx = 174;
vpy = -97;
vpz = 59;


eqs.push(x.add(t201.mul(vx)).eq(t201.mul(vpx).add(px)));
eqs.push(y.add(t201.mul(vy)).eq(t201.mul(vpy).add(py)));
eqs.push(z.add(t201.mul(vz)).eq(t201.mul(vpz).add(pz)));
px = 290559272158077;
py = 442249798043770;
pz = 274221205630908;
vpx = -145;
vpy = -149;
vpz = 43;


eqs.push(x.add(t202.mul(vx)).eq(t202.mul(vpx).add(px)));
eqs.push(y.add(t202.mul(vy)).eq(t202.mul(vpy).add(py)));
eqs.push(z.add(t202.mul(vz)).eq(t202.mul(vpz).add(pz)));
px = 243475915019523;
py = 329912782480662;
pz = 192292920520856;
vpx = 95;
vpy = 12;
vpz = 260;


eqs.push(x.add(t203.mul(vx)).eq(t203.mul(vpx).add(px)));
eqs.push(y.add(t203.mul(vy)).eq(t203.mul(vpy).add(py)));
eqs.push(z.add(t203.mul(vz)).eq(t203.mul(vpz).add(pz)));
px = 521918265103796;
py = 310256015748577;
pz = 518211633874598;
vpx = -251;
vpy = -162;
vpz = -217;


eqs.push(x.add(t204.mul(vx)).eq(t204.mul(vpx).add(px)));
eqs.push(y.add(t204.mul(vy)).eq(t204.mul(vpy).add(py)));
eqs.push(z.add(t204.mul(vz)).eq(t204.mul(vpz).add(pz)));
px = 312727502788511;
py = 201561066806116;
pz = 321076105217151;
vpx = -26;
vpy = -9;
vpz = -6;


eqs.push(x.add(t205.mul(vx)).eq(t205.mul(vpx).add(px)));
eqs.push(y.add(t205.mul(vy)).eq(t205.mul(vpy).add(py)));
eqs.push(z.add(t205.mul(vz)).eq(t205.mul(vpz).add(pz)));
px = 494755918231443;
py = 397724820224070;
pz = 553863071779156;
vpx = -280;
vpy = -241;
vpz = -330;


eqs.push(x.add(t206.mul(vx)).eq(t206.mul(vpx).add(px)));
eqs.push(y.add(t206.mul(vy)).eq(t206.mul(vpy).add(py)));
eqs.push(z.add(t206.mul(vz)).eq(t206.mul(vpz).add(pz)));
px = 293481938243707;
py = 113760653614610;
pz = 275206506816308;
vpx = -6;
vpy = 154;
vpz = 50;


eqs.push(x.add(t207.mul(vx)).eq(t207.mul(vpx).add(px)));
eqs.push(y.add(t207.mul(vy)).eq(t207.mul(vpy).add(py)));
eqs.push(z.add(t207.mul(vz)).eq(t207.mul(vpz).add(pz)));
px = 286912142714032;
py = 364865445456985;
pz = 315289508229308;
vpx = -35;
vpy = 34;
vpz = -103;


eqs.push(x.add(t208.mul(vx)).eq(t208.mul(vpx).add(px)));
eqs.push(y.add(t208.mul(vy)).eq(t208.mul(vpy).add(py)));
eqs.push(z.add(t208.mul(vz)).eq(t208.mul(vpz).add(pz)));
px = 187420037282402;
py = 262416403376697;
pz = 270877354246967;
vpx = 141;
vpy = -52;
vpz = 56;


eqs.push(x.add(t209.mul(vx)).eq(t209.mul(vpx).add(px)));
eqs.push(y.add(t209.mul(vy)).eq(t209.mul(vpy).add(py)));
eqs.push(z.add(t209.mul(vz)).eq(t209.mul(vpz).add(pz)));
px = 269265569314367;
py = 311334159082475;
pz = 281210089149523;
vpx = 30;
vpy = 210;
vpz = 24;


eqs.push(x.add(t210.mul(vx)).eq(t210.mul(vpx).add(px)));
eqs.push(y.add(t210.mul(vy)).eq(t210.mul(vpy).add(py)));
eqs.push(z.add(t210.mul(vz)).eq(t210.mul(vpz).add(pz)));
px = 262429174710483;
py = 108363088475589;
pz = 352672334290448;
vpx = 34;
vpy = 26;
vpz = -27;


eqs.push(x.add(t211.mul(vx)).eq(t211.mul(vpx).add(px)));
eqs.push(y.add(t211.mul(vy)).eq(t211.mul(vpy).add(py)));
eqs.push(z.add(t211.mul(vz)).eq(t211.mul(vpz).add(pz)));
px = 266123105107587;
py = 231758707729990;
pz = 314309990844168;
vpx = 32;
vpy = -5;
vpz = -5;


eqs.push(x.add(t212.mul(vx)).eq(t212.mul(vpx).add(px)));
eqs.push(y.add(t212.mul(vy)).eq(t212.mul(vpy).add(py)));
eqs.push(z.add(t212.mul(vz)).eq(t212.mul(vpz).add(pz)));
px = 267316984179419;
py = 474832315242782;
pz = 311127502675744;
vpx = 52;
vpy = -425;
vpz = -269;


eqs.push(x.add(t213.mul(vx)).eq(t213.mul(vpx).add(px)));
eqs.push(y.add(t213.mul(vy)).eq(t213.mul(vpy).add(py)));
eqs.push(z.add(t213.mul(vz)).eq(t213.mul(vpz).add(pz)));
px = 345898863591507;
py = 388497912289980;
pz = 265200771902318;
vpx = -234;
vpy = -72;
vpz = 80;


eqs.push(x.add(t214.mul(vx)).eq(t214.mul(vpx).add(px)));
eqs.push(y.add(t214.mul(vy)).eq(t214.mul(vpy).add(py)));
eqs.push(z.add(t214.mul(vz)).eq(t214.mul(vpz).add(pz)));
px = 217520406141762;
py = 130932703317915;
pz = 337317388773498;
vpx = 77;
vpy = -10;
vpz = -9;


eqs.push(x.add(t215.mul(vx)).eq(t215.mul(vpx).add(px)));
eqs.push(y.add(t215.mul(vy)).eq(t215.mul(vpy).add(py)));
eqs.push(z.add(t215.mul(vz)).eq(t215.mul(vpz).add(pz)));
px = 355913193078057;
py = 207151233559860;
pz = 210098412477272;
vpx = -99;
vpy = 44;
vpz = 145;


eqs.push(x.add(t216.mul(vx)).eq(t216.mul(vpx).add(px)));
eqs.push(y.add(t216.mul(vy)).eq(t216.mul(vpy).add(py)));
eqs.push(z.add(t216.mul(vz)).eq(t216.mul(vpz).add(pz)));
px = 272808363486333;
py = 375927723900832;
pz = 296397865608126;
vpx = 20;
vpy = -113;
vpz = -5;


eqs.push(x.add(t217.mul(vx)).eq(t217.mul(vpx).add(px)));
eqs.push(y.add(t217.mul(vy)).eq(t217.mul(vpy).add(py)));
eqs.push(z.add(t217.mul(vz)).eq(t217.mul(vpz).add(pz)));
px = 291898203879003;
py = 420126128457744;
pz = 308181081805622;
vpx = -86;
vpy = -104;
vpz = -130;


eqs.push(x.add(t218.mul(vx)).eq(t218.mul(vpx).add(px)));
eqs.push(y.add(t218.mul(vy)).eq(t218.mul(vpy).add(py)));
eqs.push(z.add(t218.mul(vz)).eq(t218.mul(vpz).add(pz)));
px = 271920842740797;
py = 434415607383885;
pz = 274825235137613;
vpx = 8;
vpy = 14;
vpz = 32;


eqs.push(x.add(t219.mul(vx)).eq(t219.mul(vpx).add(px)));
eqs.push(y.add(t219.mul(vy)).eq(t219.mul(vpy).add(py)));
eqs.push(z.add(t219.mul(vz)).eq(t219.mul(vpz).add(pz)));
px = 467787726572007;
py = 345276840370890;
pz = 452671753827425;
vpx = -274;
vpy = -151;
vpz = -220;


eqs.push(x.add(t220.mul(vx)).eq(t220.mul(vpx).add(px)));
eqs.push(y.add(t220.mul(vy)).eq(t220.mul(vpy).add(py)));
eqs.push(z.add(t220.mul(vz)).eq(t220.mul(vpz).add(pz)));
px = 363813198582635;
py = 426066883592142;
pz = 467552682172376;
vpx = -108;
vpy = -277;
vpz = -226;


eqs.push(x.add(t221.mul(vx)).eq(t221.mul(vpx).add(px)));
eqs.push(y.add(t221.mul(vy)).eq(t221.mul(vpy).add(py)));
eqs.push(z.add(t221.mul(vz)).eq(t221.mul(vpz).add(pz)));
px = 273480967034017;
py = 426649220185590;
pz = 335257965147938;
vpx = 19;
vpy = -247;
vpz = -88;


eqs.push(x.add(t222.mul(vx)).eq(t222.mul(vpx).add(px)));
eqs.push(y.add(t222.mul(vy)).eq(t222.mul(vpy).add(py)));
eqs.push(z.add(t222.mul(vz)).eq(t222.mul(vpz).add(pz)));
px = 213281352574307;
py = 221262331519110;
pz = 241523110674458;
vpx = 238;
vpy = 569;
vpz = 170;


eqs.push(x.add(t223.mul(vx)).eq(t223.mul(vpx).add(px)));
eqs.push(y.add(t223.mul(vy)).eq(t223.mul(vpy).add(py)));
eqs.push(z.add(t223.mul(vz)).eq(t223.mul(vpz).add(pz)));
px = 263573435700703;
py = 441088164385924;
pz = 175409202095378;
vpx = 48;
vpy = -258;
vpz = 368;


eqs.push(x.add(t224.mul(vx)).eq(t224.mul(vpx).add(px)));
eqs.push(y.add(t224.mul(vy)).eq(t224.mul(vpy).add(py)));
eqs.push(z.add(t224.mul(vz)).eq(t224.mul(vpz).add(pz)));
px = 289945459220307;
py = 377054201629326;
pz = 372841561008656;
vpx = -99;
vpy = 223;
vpz = -585;


eqs.push(x.add(t225.mul(vx)).eq(t225.mul(vpx).add(px)));
eqs.push(y.add(t225.mul(vy)).eq(t225.mul(vpy).add(py)));
eqs.push(z.add(t225.mul(vz)).eq(t225.mul(vpz).add(pz)));
px = 374047749163227;
py = 125420199456462;
pz = 169386320432288;
vpx = -84;
vpy = 28;
vpz = 163;


eqs.push(x.add(t226.mul(vx)).eq(t226.mul(vpx).add(px)));
eqs.push(y.add(t226.mul(vy)).eq(t226.mul(vpy).add(py)));
eqs.push(z.add(t226.mul(vz)).eq(t226.mul(vpz).add(pz)));
px = 263769412974873;
py = 408366368241483;
pz = 273672589924916;
vpx = 68;
vpy = 20;
vpz = 49;


eqs.push(x.add(t227.mul(vx)).eq(t227.mul(vpx).add(px)));
eqs.push(y.add(t227.mul(vy)).eq(t227.mul(vpy).add(py)));
eqs.push(z.add(t227.mul(vz)).eq(t227.mul(vpz).add(pz)));
px = 258388105998642;
py = 392013872595165;
pz = 296941935928523;
vpx = 137;
vpy = 332;
vpz = -168;


eqs.push(x.add(t228.mul(vx)).eq(t228.mul(vpx).add(px)));
eqs.push(y.add(t228.mul(vy)).eq(t228.mul(vpy).add(py)));
eqs.push(z.add(t228.mul(vz)).eq(t228.mul(vpz).add(pz)));
px = 337052359836476;
py = 219012376017920;
pz = 195412320240796;
vpx = -53;
vpy = -41;
vpz = 145;


eqs.push(x.add(t229.mul(vx)).eq(t229.mul(vpx).add(px)));
eqs.push(y.add(t229.mul(vy)).eq(t229.mul(vpy).add(py)));
eqs.push(z.add(t229.mul(vz)).eq(t229.mul(vpz).add(pz)));
px = 324272597155987;
py = 281255604244580;
pz = 91195585085663;
vpx = -62;
vpy = -33;
vpz = 350;


eqs.push(x.add(t230.mul(vx)).eq(t230.mul(vpx).add(px)));
eqs.push(y.add(t230.mul(vy)).eq(t230.mul(vpy).add(py)));
eqs.push(z.add(t230.mul(vz)).eq(t230.mul(vpz).add(pz)));
px = 262437337440531;
py = 287570235854070;
pz = 346908645495128;
vpx = 40;
vpy = -21;
vpz = -77;


eqs.push(x.add(t231.mul(vx)).eq(t231.mul(vpx).add(px)));
eqs.push(y.add(t231.mul(vy)).eq(t231.mul(vpy).add(py)));
eqs.push(z.add(t231.mul(vz)).eq(t231.mul(vpz).add(pz)));
px = 345825800459582;
py = 209207813086330;
pz = 293376114624943;
vpx = -89;
vpy = 57;
vpz = 22;


eqs.push(x.add(t232.mul(vx)).eq(t232.mul(vpx).add(px)));
eqs.push(y.add(t232.mul(vy)).eq(t232.mul(vpy).add(py)));
eqs.push(z.add(t232.mul(vz)).eq(t232.mul(vpz).add(pz)));
px = 289000029711828;
py = 197888339643810;
pz = 351017414810296;
vpx = 5;
vpy = -31;
vpz = -35;


eqs.push(x.add(t233.mul(vx)).eq(t233.mul(vpx).add(px)));
eqs.push(y.add(t233.mul(vy)).eq(t233.mul(vpy).add(py)));
eqs.push(z.add(t233.mul(vz)).eq(t233.mul(vpz).add(pz)));
px = 268158708478464;
py = 197181345649512;
pz = 322923682287035;
vpx = 29;
vpy = 27;
vpz = -14;


eqs.push(x.add(t234.mul(vx)).eq(t234.mul(vpx).add(px)));
eqs.push(y.add(t234.mul(vy)).eq(t234.mul(vpy).add(py)));
eqs.push(z.add(t234.mul(vz)).eq(t234.mul(vpz).add(pz)));
px = 306374642927877;
py = 236479711835674;
pz = 294849372968008;
vpx = -139;
vpy = 711;
vpz = -47;


eqs.push(x.add(t235.mul(vx)).eq(t235.mul(vpx).add(px)));
eqs.push(y.add(t235.mul(vy)).eq(t235.mul(vpy).add(py)));
eqs.push(z.add(t235.mul(vz)).eq(t235.mul(vpz).add(pz)));
px = 328253125942587;
py = 134059263993870;
pz = 322528144175408;
vpx = -50;
vpy = 102;
vpz = -12;


eqs.push(x.add(t236.mul(vx)).eq(t236.mul(vpx).add(px)));
eqs.push(y.add(t236.mul(vy)).eq(t236.mul(vpy).add(py)));
eqs.push(z.add(t236.mul(vz)).eq(t236.mul(vpz).add(pz)));
px = 431481134597703;
py = 353764567975554;
pz = 364240330103956;
vpx = -163;
vpy = -202;
vpz = -54;


eqs.push(x.add(t237.mul(vx)).eq(t237.mul(vpx).add(px)));
eqs.push(y.add(t237.mul(vy)).eq(t237.mul(vpy).add(py)));
eqs.push(z.add(t237.mul(vz)).eq(t237.mul(vpz).add(pz)));
px = 283117766261329;
py = 340540492770048;
pz = 303295023113732;
vpx = -27;
vpy = 182;
vpz = -73;


eqs.push(x.add(t238.mul(vx)).eq(t238.mul(vpx).add(px)));
eqs.push(y.add(t238.mul(vy)).eq(t238.mul(vpy).add(py)));
eqs.push(z.add(t238.mul(vz)).eq(t238.mul(vpz).add(pz)));
px = 323910413067526;
py = 211269851938360;
pz = 527505690640004;
vpx = -27;
vpy = -81;
vpz = -199;


eqs.push(x.add(t239.mul(vx)).eq(t239.mul(vpx).add(px)));
eqs.push(y.add(t239.mul(vy)).eq(t239.mul(vpy).add(py)));
eqs.push(z.add(t239.mul(vz)).eq(t239.mul(vpz).add(pz)));
px = 320624628251168;
py = 104627051042668;
pz = 352617932743968;
vpx = -75;
vpy = 391;
vpz = -107;


eqs.push(x.add(t240.mul(vx)).eq(t240.mul(vpx).add(px)));
eqs.push(y.add(t240.mul(vy)).eq(t240.mul(vpy).add(py)));
eqs.push(z.add(t240.mul(vz)).eq(t240.mul(vpz).add(pz)));
px = 347175059335577;
py = 146883914462638;
pz = 322344509051034;
vpx = -69;
vpy = 61;
vpz = -8;


eqs.push(x.add(t241.mul(vx)).eq(t241.mul(vpx).add(px)));
eqs.push(y.add(t241.mul(vy)).eq(t241.mul(vpy).add(py)));
eqs.push(z.add(t241.mul(vz)).eq(t241.mul(vpz).add(pz)));
px = 356532922902485;
py = 428448486747668;
pz = 367854427918216;
vpx = -123;
vpy = -270;
vpz = -111;


eqs.push(x.add(t242.mul(vx)).eq(t242.mul(vpx).add(px)));
eqs.push(y.add(t242.mul(vy)).eq(t242.mul(vpy).add(py)));
eqs.push(z.add(t242.mul(vz)).eq(t242.mul(vpz).add(pz)));
px = 249748070667087;
py = 318842894010110;
pz = 282096299073708;
vpx = 83;
vpy = 69;
vpz = 28;


eqs.push(x.add(t243.mul(vx)).eq(t243.mul(vpx).add(px)));
eqs.push(y.add(t243.mul(vy)).eq(t243.mul(vpy).add(py)));
eqs.push(z.add(t243.mul(vz)).eq(t243.mul(vpz).add(pz)));
px = 255019298626401;
py = 274602764371060;
pz = 289390829693362;
vpx = 89;
vpy = 444;
vpz = -14;


eqs.push(x.add(t244.mul(vx)).eq(t244.mul(vpx).add(px)));
eqs.push(y.add(t244.mul(vy)).eq(t244.mul(vpy).add(py)));
eqs.push(z.add(t244.mul(vz)).eq(t244.mul(vpz).add(pz)));
px = 272016051241871;
py = 250992712372226;
pz = 253555913559440;
vpx = 24;
vpy = -69;
vpz = 77;


eqs.push(x.add(t245.mul(vx)).eq(t245.mul(vpx).add(px)));
eqs.push(y.add(t245.mul(vy)).eq(t245.mul(vpy).add(py)));
eqs.push(z.add(t245.mul(vz)).eq(t245.mul(vpz).add(pz)));
px = 514434578625654;
py = 249800472915633;
pz = 557255782239715;
vpx = -217;
vpy = -118;
vpz = -230;


eqs.push(x.add(t246.mul(vx)).eq(t246.mul(vpx).add(px)));
eqs.push(y.add(t246.mul(vy)).eq(t246.mul(vpy).add(py)));
eqs.push(z.add(t246.mul(vz)).eq(t246.mul(vpz).add(pz)));
px = 268165768443117;
py = 406494246376227;
pz = 482328624540068;
vpx = 36;
vpy = -74;
vpz = -887;


eqs.push(x.add(t247.mul(vx)).eq(t247.mul(vpx).add(px)));
eqs.push(y.add(t247.mul(vy)).eq(t247.mul(vpy).add(py)));
eqs.push(z.add(t247.mul(vz)).eq(t247.mul(vpz).add(pz)));
px = 339850866338441;
py = 442648816097471;
pz = 122168564559253;
vpx = -96;
vpy = -294;
vpz = 318;


eqs.push(x.add(t248.mul(vx)).eq(t248.mul(vpx).add(px)));
eqs.push(y.add(t248.mul(vy)).eq(t248.mul(vpy).add(py)));
eqs.push(z.add(t248.mul(vz)).eq(t248.mul(vpz).add(pz)));
px = 264492045152224;
py = 92845786811750;
pz = 257027076170697;
vpx = 33;
vpy = 109;
vpz = 72;


eqs.push(x.add(t249.mul(vx)).eq(t249.mul(vpx).add(px)));
eqs.push(y.add(t249.mul(vy)).eq(t249.mul(vpy).add(py)));
eqs.push(z.add(t249.mul(vz)).eq(t249.mul(vpz).add(pz)));
px = 226970821111617;
py = 357041090575470;
pz = 293897795256878;
vpx = 153;
vpy = -19;
vpz = -8;


eqs.push(x.add(t250.mul(vx)).eq(t250.mul(vpx).add(px)));
eqs.push(y.add(t250.mul(vy)).eq(t250.mul(vpy).add(py)));
eqs.push(z.add(t250.mul(vz)).eq(t250.mul(vpz).add(pz)));
px = 342089927413667;
py = 411997765624670;
pz = 342682648601738;
vpx = -218;
vpy = -155;
vpz = -184;


eqs.push(x.add(t251.mul(vx)).eq(t251.mul(vpx).add(px)));
eqs.push(y.add(t251.mul(vy)).eq(t251.mul(vpy).add(py)));
eqs.push(z.add(t251.mul(vz)).eq(t251.mul(vpz).add(pz)));
px = 250668161400931;
py = 243931735576206;
pz = 92707563709056;
vpx = 82;
vpy = 293;
vpz = 565;


eqs.push(x.add(t252.mul(vx)).eq(t252.mul(vpx).add(px)));
eqs.push(y.add(t252.mul(vy)).eq(t252.mul(vpy).add(py)));
eqs.push(z.add(t252.mul(vz)).eq(t252.mul(vpz).add(pz)));
px = 351411042914937;
py = 361276554470210;
pz = 440666989610408;
vpx = -148;
vpy = -111;
vpz = -307;


eqs.push(x.add(t253.mul(vx)).eq(t253.mul(vpx).add(px)));
eqs.push(y.add(t253.mul(vy)).eq(t253.mul(vpy).add(py)));
eqs.push(z.add(t253.mul(vz)).eq(t253.mul(vpz).add(pz)));
px = 333282548167675;
py = 191427623038494;
pz = 368806658573632;
vpx = -62;
vpy = 50;
vpz = -81;


eqs.push(x.add(t254.mul(vx)).eq(t254.mul(vpx).add(px)));
eqs.push(y.add(t254.mul(vy)).eq(t254.mul(vpy).add(py)));
eqs.push(z.add(t254.mul(vz)).eq(t254.mul(vpz).add(pz)));
px = 328331873426359;
py = 328640111768590;
pz = 542478990963640;
vpx = -137;
vpy = 49;
vpz = -705;


eqs.push(x.add(t255.mul(vx)).eq(t255.mul(vpx).add(px)));
eqs.push(y.add(t255.mul(vy)).eq(t255.mul(vpy).add(py)));
eqs.push(z.add(t255.mul(vz)).eq(t255.mul(vpz).add(pz)));
px = 338578447617845;
py = 517862026025949;
pz = 243246185117704;
vpx = -212;
vpy = -520;
vpz = 157;


eqs.push(x.add(t256.mul(vx)).eq(t256.mul(vpx).add(px)));
eqs.push(y.add(t256.mul(vy)).eq(t256.mul(vpy).add(py)));
eqs.push(z.add(t256.mul(vz)).eq(t256.mul(vpz).add(pz)));
px = 286592031513947;
py = 354871682324185;
pz = 553501021727038;
vpx = -6;
vpy = -116;
vpz = -501;


eqs.push(x.add(t257.mul(vx)).eq(t257.mul(vpx).add(px)));
eqs.push(y.add(t257.mul(vy)).eq(t257.mul(vpy).add(py)));
eqs.push(z.add(t257.mul(vz)).eq(t257.mul(vpz).add(pz)));
px = 309625408577591;
py = 132907059207079;
pz = 412141320310124;
vpx = -18;
vpy = 40;
vpz = -103;


eqs.push(x.add(t258.mul(vx)).eq(t258.mul(vpx).add(px)));
eqs.push(y.add(t258.mul(vy)).eq(t258.mul(vpy).add(py)));
eqs.push(z.add(t258.mul(vz)).eq(t258.mul(vpz).add(pz)));
px = 270392223533307;
py = 270952402587212;
pz = 225477260964402;
vpx = 26;
vpy = 208;
vpz = 186;


eqs.push(x.add(t259.mul(vx)).eq(t259.mul(vpx).add(px)));
eqs.push(y.add(t259.mul(vy)).eq(t259.mul(vpy).add(py)));
eqs.push(z.add(t259.mul(vz)).eq(t259.mul(vpz).add(pz)));
px = 341270768940030;
py = 247637799886236;
pz = 298503071111225;
vpx = -77;
vpy = -17;
vpz = 16;


eqs.push(x.add(t260.mul(vx)).eq(t260.mul(vpx).add(px)));
eqs.push(y.add(t260.mul(vy)).eq(t260.mul(vpy).add(py)));
eqs.push(z.add(t260.mul(vz)).eq(t260.mul(vpz).add(pz)));
px = 221649641193999;
py = 329672040761013;
pz = 359278722508676;
vpx = 78;
vpy = -188;
vpz = -39;


eqs.push(x.add(t261.mul(vx)).eq(t261.mul(vpx).add(px)));
eqs.push(y.add(t261.mul(vy)).eq(t261.mul(vpy).add(py)));
eqs.push(z.add(t261.mul(vz)).eq(t261.mul(vpz).add(pz)));
px = 272098601220282;
py = 429324068810460;
pz = 278292238945208;
vpx = 13;
vpy = -69;
vpz = 13;


eqs.push(x.add(t262.mul(vx)).eq(t262.mul(vpx).add(px)));
eqs.push(y.add(t262.mul(vy)).eq(t262.mul(vpy).add(py)));
eqs.push(z.add(t262.mul(vz)).eq(t262.mul(vpz).add(pz)));
px = 313181380730475;
py = 334213182994734;
pz = 337934011612880;
vpx = -125;
vpy = 126;
vpz = -176;


eqs.push(x.add(t263.mul(vx)).eq(t263.mul(vpx).add(px)));
eqs.push(y.add(t263.mul(vy)).eq(t263.mul(vpy).add(py)));
eqs.push(z.add(t263.mul(vz)).eq(t263.mul(vpz).add(pz)));
px = 280003362379015;
py = 347368777219750;
pz = 416197229921964;
vpx = 7;
vpy = -101;
vpz = -230;


eqs.push(x.add(t264.mul(vx)).eq(t264.mul(vpx).add(px)));
eqs.push(y.add(t264.mul(vy)).eq(t264.mul(vpy).add(py)));
eqs.push(z.add(t264.mul(vz)).eq(t264.mul(vpz).add(pz)));
px = 241813862847152;
py = 159150469738801;
pz = 361226501893772;
vpx = 61;
vpy = 42;
vpz = -55;


eqs.push(x.add(t265.mul(vx)).eq(t265.mul(vpx).add(px)));
eqs.push(y.add(t265.mul(vy)).eq(t265.mul(vpy).add(py)));
eqs.push(z.add(t265.mul(vz)).eq(t265.mul(vpz).add(pz)));
px = 347694566155717;
py = 421001322372236;
pz = 370259368478866;
vpx = -269;
vpy = -168;
vpz = -318;


eqs.push(x.add(t266.mul(vx)).eq(t266.mul(vpx).add(px)));
eqs.push(y.add(t266.mul(vy)).eq(t266.mul(vpy).add(py)));
eqs.push(z.add(t266.mul(vz)).eq(t266.mul(vpz).add(pz)));
px = 284902985674235;
py = 243491987349438;
pz = 349863527984768;
vpx = 9;
vpy = -73;
vpz = -37;


eqs.push(x.add(t267.mul(vx)).eq(t267.mul(vpx).add(px)));
eqs.push(y.add(t267.mul(vy)).eq(t267.mul(vpy).add(py)));
eqs.push(z.add(t267.mul(vz)).eq(t267.mul(vpz).add(pz)));
px = 240539819926125;
py = 53434954156942;
pz = 140619645445734;
vpx = 65;
vpy = 205;
vpz = 226;


eqs.push(x.add(t268.mul(vx)).eq(t268.mul(vpx).add(px)));
eqs.push(y.add(t268.mul(vy)).eq(t268.mul(vpy).add(py)));
eqs.push(z.add(t268.mul(vz)).eq(t268.mul(vpz).add(pz)));
px = 379018120747357;
py = 234456327547615;
pz = 333071947154183;
vpx = -164;
vpy = 70;
vpz = -52;


eqs.push(x.add(t269.mul(vx)).eq(t269.mul(vpx).add(px)));
eqs.push(y.add(t269.mul(vy)).eq(t269.mul(vpy).add(py)));
eqs.push(z.add(t269.mul(vz)).eq(t269.mul(vpz).add(pz)));
px = 317771834387082;
py = 438103541732610;
pz = 439083905720933;
vpx = -85;
vpy = -271;
vpz = -336;


eqs.push(x.add(t270.mul(vx)).eq(t270.mul(vpx).add(px)));
eqs.push(y.add(t270.mul(vy)).eq(t270.mul(vpy).add(py)));
eqs.push(z.add(t270.mul(vz)).eq(t270.mul(vpz).add(pz)));
px = 269556676003839;
py = 348826356892260;
pz = 305628199711460;
vpx = 28;
vpy = -56;
vpz = -25;


eqs.push(x.add(t271.mul(vx)).eq(t271.mul(vpx).add(px)));
eqs.push(y.add(t271.mul(vy)).eq(t271.mul(vpy).add(py)));
eqs.push(z.add(t271.mul(vz)).eq(t271.mul(vpz).add(pz)));
px = 331741677987807;
py = 537333487539510;
pz = 435437460794708;
vpx = -144;
vpy = -535;
vpz = -397;


eqs.push(x.add(t272.mul(vx)).eq(t272.mul(vpx).add(px)));
eqs.push(y.add(t272.mul(vy)).eq(t272.mul(vpy).add(py)));
eqs.push(z.add(t272.mul(vz)).eq(t272.mul(vpz).add(pz)));
px = 376406942380642;
py = 278311657140166;
pz = 259235278026276;
vpx = -189;
vpy = 45;
vpz = 81;


eqs.push(x.add(t273.mul(vx)).eq(t273.mul(vpx).add(px)));
eqs.push(y.add(t273.mul(vy)).eq(t273.mul(vpy).add(py)));
eqs.push(z.add(t273.mul(vz)).eq(t273.mul(vpz).add(pz)));
px = 304404468922375;
py = 260140849938953;
pz = 402588486588217;
vpx = -42;
vpy = 76;
vpz = -206;


eqs.push(x.add(t274.mul(vx)).eq(t274.mul(vpx).add(px)));
eqs.push(y.add(t274.mul(vy)).eq(t274.mul(vpy).add(py)));
eqs.push(z.add(t274.mul(vz)).eq(t274.mul(vpz).add(pz)));
px = 279180801330347;
py = 349023201942738;
pz = 119900877948786;
vpx = -14;
vpy = 191;
vpz = 750;


eqs.push(x.add(t275.mul(vx)).eq(t275.mul(vpx).add(px)));
eqs.push(y.add(t275.mul(vy)).eq(t275.mul(vpy).add(py)));
eqs.push(z.add(t275.mul(vz)).eq(t275.mul(vpz).add(pz)));
px = 188333061901926;
py = 318660068603285;
pz = 244031031344043;
vpx = 125;
vpy = -156;
vpz = 88;


eqs.push(x.add(t276.mul(vx)).eq(t276.mul(vpx).add(px)));
eqs.push(y.add(t276.mul(vy)).eq(t276.mul(vpy).add(py)));
eqs.push(z.add(t276.mul(vz)).eq(t276.mul(vpz).add(pz)));
px = 288725944455068;
py = 467163692472072;
pz = 295016758944040;
vpx = -261;
vpy = -385;
vpz = -291;


eqs.push(x.add(t277.mul(vx)).eq(t277.mul(vpx).add(px)));
eqs.push(y.add(t277.mul(vy)).eq(t277.mul(vpy).add(py)));
eqs.push(z.add(t277.mul(vz)).eq(t277.mul(vpz).add(pz)));
px = 146106098497872;
py = 69764788293913;
pz = 174366195276499;
vpx = 191;
vpy = 192;
vpz = 184;


eqs.push(x.add(t278.mul(vx)).eq(t278.mul(vpx).add(px)));
eqs.push(y.add(t278.mul(vy)).eq(t278.mul(vpy).add(py)));
eqs.push(z.add(t278.mul(vz)).eq(t278.mul(vpz).add(pz)));
px = 223140068566361;
py = 239780016481192;
pz = 175455873847863;
vpx = 72;
vpy = -113;
vpz = 148;


eqs.push(x.add(t279.mul(vx)).eq(t279.mul(vpx).add(px)));
eqs.push(y.add(t279.mul(vy)).eq(t279.mul(vpy).add(py)));
eqs.push(z.add(t279.mul(vz)).eq(t279.mul(vpz).add(pz)));
px = 271599283420167;
py = 328121081570170;
pz = 313880705567638;
vpx = 20;
vpy = 343;
vpz = -150;


eqs.push(x.add(t280.mul(vx)).eq(t280.mul(vpx).add(px)));
eqs.push(y.add(t280.mul(vy)).eq(t280.mul(vpy).add(py)));
eqs.push(z.add(t280.mul(vz)).eq(t280.mul(vpz).add(pz)));
px = 299714040995601;
py = 312916223816598;
pz = 194152194318417;
vpx = -16;
vpy = -115;
vpz = 166;


eqs.push(x.add(t281.mul(vx)).eq(t281.mul(vpx).add(px)));
eqs.push(y.add(t281.mul(vy)).eq(t281.mul(vpy).add(py)));
eqs.push(z.add(t281.mul(vz)).eq(t281.mul(vpz).add(pz)));
px = 278675764379679;
py = 171531065067534;
pz = 395035811254232;
vpx = 15;
vpy = 57;
vpz = -109;


eqs.push(x.add(t282.mul(vx)).eq(t282.mul(vpx).add(px)));
eqs.push(y.add(t282.mul(vy)).eq(t282.mul(vpy).add(py)));
eqs.push(z.add(t282.mul(vz)).eq(t282.mul(vpz).add(pz)));
px = 215107541859009;
py = 109571688570346;
pz = 196925255351218;
vpx = 95;
vpy = 111;
vpz = 148;


eqs.push(x.add(t283.mul(vx)).eq(t283.mul(vpx).add(px)));
eqs.push(y.add(t283.mul(vy)).eq(t283.mul(vpy).add(py)));
eqs.push(z.add(t283.mul(vz)).eq(t283.mul(vpz).add(pz)));
px = 216241220884565;
py = 173439581483993;
pz = 339156442319393;
vpx = 112;
vpy = 130;
vpz = -52;


eqs.push(x.add(t284.mul(vx)).eq(t284.mul(vpx).add(px)));
eqs.push(y.add(t284.mul(vy)).eq(t284.mul(vpy).add(py)));
eqs.push(z.add(t284.mul(vz)).eq(t284.mul(vpz).add(pz)));
px = 304209814619857;
py = 196446083606860;
pz = 264860170799333;
vpx = -36;
vpy = 159;
vpz = 68;


eqs.push(x.add(t285.mul(vx)).eq(t285.mul(vpx).add(px)));
eqs.push(y.add(t285.mul(vy)).eq(t285.mul(vpy).add(py)));
eqs.push(z.add(t285.mul(vz)).eq(t285.mul(vpz).add(pz)));
px = 267658514050651;
py = 431763912615568;
pz = 268257854467560;
vpx = 58;
vpy = 43;
vpz = 109;


eqs.push(x.add(t286.mul(vx)).eq(t286.mul(vpx).add(px)));
eqs.push(y.add(t286.mul(vy)).eq(t286.mul(vpy).add(py)));
eqs.push(z.add(t286.mul(vz)).eq(t286.mul(vpz).add(pz)));
px = 315708192092025;
py = 260523186398568;
pz = 509854326917444;
vpx = -67;
vpy = 86;
vpz = -433;


eqs.push(x.add(t287.mul(vx)).eq(t287.mul(vpx).add(px)));
eqs.push(y.add(t287.mul(vy)).eq(t287.mul(vpy).add(py)));
eqs.push(z.add(t287.mul(vz)).eq(t287.mul(vpz).add(pz)));
px = 331751357074977;
py = 515528521629298;
pz = 145551201925627;
vpx = -64;
vpy = -407;
vpz = 240;


eqs.push(x.add(t288.mul(vx)).eq(t288.mul(vpx).add(px)));
eqs.push(y.add(t288.mul(vy)).eq(t288.mul(vpy).add(py)));
eqs.push(z.add(t288.mul(vz)).eq(t288.mul(vpz).add(pz)));
px = 400296648324294;
py = 388920685496269;
pz = 371454289085683;
vpx = -205;
vpy = -198;
vpz = -122;


eqs.push(x.add(t289.mul(vx)).eq(t289.mul(vpx).add(px)));
eqs.push(y.add(t289.mul(vy)).eq(t289.mul(vpy).add(py)));
eqs.push(z.add(t289.mul(vz)).eq(t289.mul(vpz).add(pz)));
px = 162546432374355;
py = 299744520942234;
pz = 221870118624542;
vpx = 222;
vpy = -33;
vpz = 146;


eqs.push(x.add(t290.mul(vx)).eq(t290.mul(vpx).add(px)));
eqs.push(y.add(t290.mul(vy)).eq(t290.mul(vpy).add(py)));
eqs.push(z.add(t290.mul(vz)).eq(t290.mul(vpz).add(pz)));
px = 318167909934022;
py = 328472199152086;
pz = 112074533419799;
vpx = -39;
vpy = -147;
vpz = 272;


eqs.push(x.add(t291.mul(vx)).eq(t291.mul(vpx).add(px)));
eqs.push(y.add(t291.mul(vy)).eq(t291.mul(vpy).add(py)));
eqs.push(z.add(t291.mul(vz)).eq(t291.mul(vpz).add(pz)));
px = 204650693234927;
py = 198152960594075;
pz = 188269872782718;
vpx = 102;
vpy = -24;
vpz = 151;


eqs.push(x.add(t292.mul(vx)).eq(t292.mul(vpx).add(px)));
eqs.push(y.add(t292.mul(vy)).eq(t292.mul(vpy).add(py)));
eqs.push(z.add(t292.mul(vz)).eq(t292.mul(vpz).add(pz)));
px = 234473437726867;
py = 324086186101470;
pz = 313007819001768;
vpx = 97;
vpy = -55;
vpz = -26;


eqs.push(x.add(t293.mul(vx)).eq(t293.mul(vpx).add(px)));
eqs.push(y.add(t293.mul(vy)).eq(t293.mul(vpy).add(py)));
eqs.push(z.add(t293.mul(vz)).eq(t293.mul(vpz).add(pz)));
px = 208245832758657;
py = 180504161378205;
pz = 257061345577298;
vpx = 96;
vpy = -12;
vpz = 71;


eqs.push(x.add(t294.mul(vx)).eq(t294.mul(vpx).add(px)));
eqs.push(y.add(t294.mul(vy)).eq(t294.mul(vpy).add(py)));
eqs.push(z.add(t294.mul(vz)).eq(t294.mul(vpz).add(pz)));
px = 293473224944187;
py = 376336065424350;
pz = 272052660287456;
vpx = -44;
vpy = -66;
vpz = 56;


eqs.push(x.add(t295.mul(vx)).eq(t295.mul(vpx).add(px)));
eqs.push(y.add(t295.mul(vy)).eq(t295.mul(vpy).add(py)));
eqs.push(z.add(t295.mul(vz)).eq(t295.mul(vpz).add(pz)));
px = 288576903408210;
py = 474350464385091;
pz = 241933462879984;
vpx = -133;
vpy = -424;
vpz = 325;


eqs.push(x.add(t296.mul(vx)).eq(t296.mul(vpx).add(px)));
eqs.push(y.add(t296.mul(vy)).eq(t296.mul(vpy).add(py)));
eqs.push(z.add(t296.mul(vz)).eq(t296.mul(vpz).add(pz)));
px = 335647092276321;
py = 359684641299450;
pz = 379435653795383;
vpx = -112;
vpy = -111;
vpz = -172;


eqs.push(x.add(t297.mul(vx)).eq(t297.mul(vpx).add(px)));
eqs.push(y.add(t297.mul(vy)).eq(t297.mul(vpy).add(py)));
eqs.push(z.add(t297.mul(vz)).eq(t297.mul(vpz).add(pz)));
px = 343665260864859;
py = 292743721753822;
pz = 358527056282352;
vpx = -70;
vpy = -107;
vpz = -59;


eqs.push(x.add(t298.mul(vx)).eq(t298.mul(vpx).add(px)));
eqs.push(y.add(t298.mul(vy)).eq(t298.mul(vpy).add(py)));
eqs.push(z.add(t298.mul(vz)).eq(t298.mul(vpz).add(pz)));
px = 401753783270176;
py = 450367245750257;
pz = 441634222195088;
vpx = -161;
vpy = -312;
vpz = -187;


eqs.push(x.add(t299.mul(vx)).eq(t299.mul(vpx).add(px)));
eqs.push(y.add(t299.mul(vy)).eq(t299.mul(vpy).add(py)));
eqs.push(z.add(t299.mul(vz)).eq(t299.mul(vpz).add(pz)));

const model = await Z3.solve(...eqs);

console.log(model.eval(x).toString());
console.log(model.eval(y).toString());
console.log(model.eval(z).toString());

console.log(model.eval(x.add(y).add(z)).toString());
}

execute();

  • # Enfin...

    Posté par  . En réponse au message Advent of Code 2023, jour 20. Évalué à 1.

    J'ai enfin ma solution pour le jour 20.
    1) J'ai exploré plusieurs solutions comme laisser mon PC calculé à l'aveugle pendant 1j de travail. Je chauffe en partie à l'électrique. Donc, cela ne me coutait pas de laisser mon PC cramer des Watt :).
    2) J’ai tenté de simplifier les cycles des flip-flop sans grand succès. Car je pensais que les conjuctions serait beaucoup plus complexe avec leurs multiples false, true qu’elles crachent
    3) Via récursivité de trouver une méthode pour factoriser les circuits. Je n’ai pas vu la solution suivante toute suite, car ma fonction recursive allé jusqu’au flip / flop. Mais au final,c’était trop complexe pour trouver une simplification évidente.
    4) Finalement, j’ai tenté juste de regarder les cycles des trues sur les 4 conjonctions qui sont avant RX { "hz", "pv", "qh", "xm" }
    Et là, c’était évident. J’avais des cycles réguliers pour ces 4 conjonctions. Il ne me reste plus qu’à trouver quand elles sont à true toutes les 4 en même temps. Ce qui revient à trouver le PPCM des 4 cycles.
    J’ai demandé à chatgpt de me fournir le calcul d’un PPCM (çà se reconnait au style).
    En prenant, le problème dans le bon sens, j’aurai pu le résoudre en 1h partie 1 et partie 2…. J’ai mis encore bien 5h cumulé. 

    public class Aoc2023s20v3 { 
    public record Message(String sourceName, boolean hight, Component component) {  
    }


    // Hard coded main conjunction
    protected static final String[] CHECK_MAIN_RX_CONJUNCTION = new String[] {
        "hz", "pv", "qh", "xm"
    };


      // Function to find the GCD (Greatest Common Divisor) of two numbers
    private static long findGCD(long a, long b) {
        while (b != 0) {
            long temp = b;
            b = a % b;
            a = temp;
        }
        return a;
    }

    // Function to find the LCM (Lowest Common Multiple) of two numbers
    private static long findLCM(long a, long b) {
        return (a * b) / findGCD(a, b);
    }

    // Function to find the LCM of an array of numbers
    public static long findLCMOfArray(Long[] numbers) {
        if (numbers.length == 0) {
            throw new IllegalArgumentException("Array should not be empty");
        }

        long lcm = numbers[0];
        for (int i = 1; i < numbers.length; i++) {
            lcm = findLCM(lcm, numbers[i]);
        }

        return lcm;
    }


    public static abstract class Component {
        String name;
        String[] targetNames = new String[0] ;

        public Map<String, Message> getMessageHight = new HashMap<>();
        public Map<String, Message> getMessageLow = new HashMap<>();

        private Message[] sendTrue;
        private Message[] sendFalse;


        public HashMap<Long, List<Boolean>> signalHistory = new LinkedHashMap<>();

        public Component(String name) {
            this.name = name;
        }

        public void registerInput(String name) {

        }

        public void clear() {
        }

        public void process(Circuit circuit, Message message) {

        }

        public final void send(Circuit circuit, boolean sendSignalHight) {          
            Message[] toSend;


            if(sendSignalHight) {
                if(sendTrue == null) {
                    sendTrue = Arrays.stream(targetNames).map(target  -> new Message(this.name, sendSignalHight, circuit.elementsByName.get(target))).toArray(k-> new Message[k]);
                }
                toSend = sendTrue;
            } else {
                if(sendFalse == null) {
                    sendFalse = Arrays.stream(targetNames).map(target  -> new Message(this.name, sendSignalHight, circuit.elementsByName.get(target))).toArray(k-> new Message[k]);
                }
                toSend = sendFalse;
            }


            if(this instanceof Conjuction && sendSignalHight)
                signalHistory.computeIfAbsent((long)circuit.circuitIndex, (k)->new ArrayList<Boolean>()).add(sendSignalHight);

            ArrayDeque<Message> messages = circuit.messages; 
            for (Message target : toSend) {             
                messages.add(target);
            }       
        }

        public String expr(Circuit circuit) {
            return this.name;
        }
    }

    public static class FlipFlop extends Component {
        boolean state;

        public FlipFlop(String name) {
            super(name);
        }

        @Override
        public void clear() {
            state = false;
        }

        @Override
        public void process(Circuit circuit, Message message) {
            if (message.hight) {
                // do nothing
                return;
            }

            this.state = !state;
            send(circuit, this.state);

        }

        @Override
        public String toString() {
            return "FlipFlop [state=" + state + ", name=" + name + ", targetNames=" + targetNames + "]";
        }

        public String expr(Circuit circuit) {

            return "%" + this.name;
        }

    }

    public static class Conjuction extends Component {

        private long state= 0;
        private long allUp = 0;
        private Map<String, Long> inputMask = new HashMap<>();
        private Map<String, Long> notInputMask = new HashMap<>();



        public Conjuction(String name) {
            super(name);
        }

        @Override
        public void registerInput(String name) {
            int  nextId = inputMask.size();
            long mask = 1L << nextId;
            inputMask.put(name,  mask);
            notInputMask.put(name, ~mask);
            allUp = (1L << (nextId+1))-1;
        }

        @Override
        public void process(Circuit circuit, Message message) {
            if(message.hight) {
                long mask = inputMask.get(message.sourceName);
                state = state | mask;
            } else {
                long notMask = notInputMask.get(message.sourceName);
                state = state & notMask;
            }

            var notAllTrue = state != allUp;

            send(circuit, notAllTrue);          
        }

        @Override
        public String toString() {
            return "Conjuction [name=" + name + ", targetNames=" + targetNames + "]";
        }

        public String expr(Circuit circuit) {
            return "/*" + this.name + "*/(" + this.inputMask.keySet().stream().map(n->circuit.elementsByName.get(n).expr(circuit)).collect(Collectors.joining(" & "))  + ") \n";
        }
    }



    public static class Output extends Component {
        private long countHight;
        private long countSmall;

        public Output(String name) {
            super(name);
        }

        @Override
        public void clear() {
            this.countHight = 0;
            this.countSmall = 0;
        }

        @Override
        public void process(Circuit circuit, Message message) {
            if (message.hight)
                countHight++;
            else
                countSmall++;
        }

        @Override
        public String toString() {
            return "Output [countHight=" + countHight + ", countSmall=" + countSmall + ", name=" + name
                    + ", targetNames=" + targetNames + "]";
        }
    }

    public static class Circuit {
        Map<String, Component> elementsByName = new HashMap<>();
        String[] broadcastList = new String[0];     
        ArrayDeque<Message> messages = new ArrayDeque<>();

        long countHight;
        long countLow;

        long circuitIndex = 0;

        void parse(Scanner in) {
            while (in.hasNext()) {
                String row = in.nextLine();
                String[] part = row.split("->");
                String typeName = part[0].trim();
                String[] targetNames = Arrays.stream(part[1].trim().split(",")).map(String::trim).toArray(k ->new String[k]);

                if ("broadcaster".equals(typeName)) {
                    broadcastList = targetNames;
                } else if (typeName.startsWith("%")) {
                    FlipFlop flipFlop = new FlipFlop(typeName.substring(1));
                    flipFlop.targetNames = targetNames;
                    elementsByName.put(flipFlop.name, flipFlop);
                } else if (typeName.startsWith("&")) {
                    Conjuction c = new Conjuction(typeName.substring(1));
                    c.targetNames = targetNames;
                    elementsByName.put(c.name, c);
                }
            }

            elementsByName.put("output", new Output("output"));
            elementsByName.put("rx", new Output("rx"));



            for (Component source : elementsByName.values()) {
                for (String target : source.targetNames) {
                    Component rx= elementsByName.get(target);
                    if(rx != null) {
                        rx.registerInput(source.name);
                    }
                }
            }

            for (String target : broadcastList) {
                elementsByName.get(target).registerInput("broadcast");
            }


        }

        public long experienceToFindWhereRxIsUp(long count) {
            messages.clear();
            elementsByName.values().forEach(Component::clear);

            countHight = 0;
            countLow = 0;


            long  s = System.currentTimeMillis();
            int x=0;
            while(true) {
                circuitIndex = x;
                countLow++;

                for (String initial : broadcastList) {
                    messages.add(new Message("broadcast", false, elementsByName.get(initial)));
                }

                processMessages();                      

                if(x > count) {
                    System.out.println("seek " + x + "   " + (System.currentTimeMillis() -s) + "ms");
                    s = System.currentTimeMillis();
                    return tryToFindLcmInMainConjuction();
                }
                x++;
            }
        }

        private long tryToFindLcmInMainConjuction() {           
            List<Long> toComputeLcm = new ArrayList<>();

            for(String name: CHECK_MAIN_RX_CONJUNCTION) {
                Component c= elementsByName.get(name);
                System.out.println(c.name + " => " +  c.signalHistory.keySet());

                Long previous = null;
                Long previousDiff= null;

                for(Long l: c.signalHistory.keySet()) {
                    if(previous !=null) {
                        long diff= l-previous;
                        System.out.print((l-previous) + ",");

                        if(previousDiff != null) {
                            if(diff == previousDiff) {
                                toComputeLcm.add(diff);
                            } else {
                                System.out.println("Can't compute LCM");
                            }
                        }
                        previousDiff = diff;
                    }
                    previous = l;
                }
                System.out.println();
            }

            return findLCMOfArray(toComputeLcm.toArray(new Long[toComputeLcm.size()]));
        }

        private void processMessages() {
            while (!messages.isEmpty()) {
                Message message = messages.pollFirst();
                if(message.hight) {
                    countHight++;
                } else {
                    countLow++;
                }

                message.component.process(this, message);
            }
        }
    }

    public static void main(String[] args) {

        try (Scanner in = new Scanner(Aoc2023s18v2.class.getResourceAsStream("res/t20.txt"))) {
            Circuit circuit = new Circuit();
            circuit.parse(in);
            long result = circuit.experienceToFindWhereRxIsUp(20000);
            System.out.println(result);
        }

    }
}

  • # Brut force pour la partie 2

    Posté par  . En réponse au message Advent of Code 2023, jour 23. Évalué à 1.

    Pour la partie 1 , j'ai appliqué un bête parcours en profondeur.
    Pour la partie 2, j'ai laissé tourner ma solution de partie 1 pour trouver la max de la partie 2.
    Environ 1h de calcul.

    J'aurai bien essayé de faire un truc plus intelligent mais je n'avais pas le temps.

    Il faut quand même lancer ce code -Xss1g pour avoir une stack conséquence qui permet une récursivité aussi profonde.

    package aoc2023;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Aoc2023s23 {
    public static Point[] DIRECTIONS = new Point[] { new Point(1, 0), new Point(-1, 0), new Point(0, -1),
            new Point(0, 1) };

    public record Point(int x, int y) {
    }

    public static class Path {
        boolean[][] walked;
        int[] pathX;
        int[] pathY;
        int step = -1;

        public Path(World world) {
            walked = new boolean[world.height][world.width];
            this.pathX = new int[world.width * world.height];
            this.pathY = new int[world.width * world.height];
        }

        public void move(int x, int y) {
            walked[y][x] = true;
            step++;
            this.pathX[step] = x;
            this.pathY[step] = y;

        }

        public void back() {

            if (step >= 0) {
                int x = getX();
                int y = getY();
                walked[y][x] = false;
            }
            step--;
        }

        private int getY() {
            return this.pathY[step];
        }

        private int getX() {
            return this.pathX[step];
        }

    }

    public static class World {
        List<String> rows;
        int width;
        int height;

        int endx;
        int endy;

        int maxPath =0;


        public World(List<String> rows) {
            this.rows = rows;
            this.height = rows.size();
            this.width = rows.get(0).length();
            this.endx = width - 2;
            this.endy = height - 1;
        }

        public final char cell(int x, int y) {
            return rows.get(y).charAt(x);
        }

        public boolean canWalkFrom(int sx, int sy, int dx, int dy) {
            if (dx < 0 || dx >= width || dy < 0 || dy >= height) {
                return false;
            }
            char dest = cell(dx, dy);
            if (dest == '#') {
                return false;
            }

            char start = cell(sx, sy);
            return true;
            /*
            if (start == '.') {
                return true;
            } else if (start == '>') {
                return dx > sx;
            } else if (start == '<') {
                return dx < sx;
            } else if (start == '^') {
                return dy < sy;
            } else if (start == 'v') {
                return dy > sy;
            }
            throw new RuntimeException("Unsupported " + start);
            */
        }

        public void explore(Path path) {
            int sx = path.getX();
            int sy = path.getY();

            if(sx == endx && sy == endy) {
                System.out.println("Size:" + path.step);
                if(path.step > maxPath ) {
                    maxPath = path.step;
                }
                return ;
            }

            for (int i = 0; i < DIRECTIONS.length; i++) {
                Point p = DIRECTIONS[i];

                int dx = sx + p.x;
                int dy = sy + p.y;

                if (canWalkFrom(sx, sy, dx, dy) && !path.walked[dy][dx]) {
                    path.move(dx, dy);
                    explore(path);
                    path.back();
                }
            }
        }
    }

    public static void main(String[] args) {

        try (Scanner in = new Scanner(Aoc2023s23.class.getResourceAsStream("res/t23.txt"))) {
            List<String> rows = new ArrayList<>();  
            while (in.hasNext()) {
                String row = in.nextLine();
                rows.add(row);
            }           
            World world = new World(rows);

            Path path = new Path(world);
            path.move(1, 0);
            world.explore(path);

            System.out.println("max=" +  world.maxPath);
        }

    }
}

  • # Méthode de Guillaume

    Posté par  . En réponse au message Advent of Code 2023, jour 21. Évalué à 1. Dernière modification le 23 décembre 2023 à 02:37.

    J'ai implémenté la méthode avec séquence quadratique de Guillaume B.
    Je suis un peu décu de ne pas avoir trouvé par moi-même

    Mais je suis très heureux d'avoir découvert ce point des maths que je ne connaissais pas.

    package aoc2023;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Scanner;
import java.util.Set;

public class Aoc2023s21s3 {
    public static Point[] DIRECTIONS = new Point[] { new Point(1, 0), new Point(-1, 0), new Point(0, -1),
            new Point(0, 1) };

    public record Point(int x, int y) {     
    }

    public static class State {     
        Set<Point> current = new HashSet<>();;
        Set<Point> next = new HashSet<>();;

        char[][] map;
        int width;
        int height;

        List<Long> quadraticsSeries = new ArrayList<>();

        public void propagate(Point p) {
            for (Point move : DIRECTIONS) {
                int dx = p.x + move.x;
                int dy = p.y + move.y;

                int rx = dx % width;
                if (rx < 0) {
                    rx += width;
                }
                int ry = dy % height;
                if (ry < 0) {
                    ry += height;
                }

                Point np = new Point(dx, dy);               
                if (map[ry][rx] == '.') {
                    next.add(np);
                }
            }

        }

        public long propagate(World world, int step) {
            map = world.map;
            width = world.width;
            height = world.height;

            // gridSize d'une taille arbitaire suffisant propage au moins une grille complète (à priori)
            int gridSize = width * 2;

            // étape pour lesquels on va récupérer les valeurs de  u(n) pour la séquence quadratique.
            int same = (step-1) % gridSize;
            int end = same + gridSize*2+1;                              

            // Boucle de propagation (très inefficace)         
            System.out.println("Propagation maximum à calculer :" + end);
            for (int i = 0; i < end; i++) {
                next.clear();


                current.forEach(p -> propagate(p));
                // switch
                Set<Point> tmp = next;
                next = current;
                current = tmp;

                if(i >= 0 && (i % (gridSize)) == same) {                    
                    System.out.println("u(" + current.size() + ") = " + current.size());
                    quadraticsSeries.add((long)current.size());
                }                               
            }

            long d1 = quadraticsSeries.get(1) - quadraticsSeries.get(0);  
            long d2 = quadraticsSeries.get(2) - quadraticsSeries.get(1);        
            //long d3 = quadraticsSeries.get(3) - quadraticsSeries.get(2);

            System.out.println("dp:" + (d2-d1));
            //System.out.println("dp:" + (d3-d2)); // si la séquence est quadratique d2-d1 == d3-d2 == d4-d3 ...

            long a = (d2-d1)/2;

            long c = quadraticsSeries.get(0);
            // a n^2 + b n + c = u(n)           
            // b = (u(n) - a n^2 - c)/n
            int n = 2;
            double b = (quadraticsSeries.get(n) - a * n * n - c)/n;


            System.out.println(quadraticsSeries);
            System.out.println(a + "," + b + "," + c);

            /*
            // Vérifie via la propagation jusqu'à u(3) que la formule u(n) = a*x^2 + bx+c  est bien paramétré.
            n = 3;          
            long control3 = (long)(a * n * n + n * b + c);
            System.out.println("Control3:" + control3);
            if(control3 != quadraticsSeries.get(3)) {
                throw new RuntimeException("Failed to compute u(n) = a*x^2 + bx+c ");
            }*/

            n = ((step)/gridSize);

            return (long)(a * n * n + n * b + c);       
        }       

        public boolean match(int x, int y) {
            return current.contains(new Point(x, y));
        }
    }

    public static class World {
        final int width;
        final int height;

        char[][] map;

        State state = new State();

        public World(List<String> rows) {
            height = rows.size();
            width = rows.get(0).length();
            map = new char[height][width];

            for (int y = 0; y < height; y++) {
                String row = rows.get(y);
                for (int x = 0; x < width; x++) {
                    if (row.charAt(x) == 'S') {
                        state.current.add(new Point(x, y));
                        map[y][x] = '.';
                    } else {
                        map[y][x] = row.charAt(x);
                    }
                }
            }
        }
    }

    public static void main(String[] args) {
        try (Scanner in = new Scanner(Aoc2023s21s3.class.getResourceAsStream("res/t21.txt"))) {
            List<String> rows = new ArrayList<>();
            while (in.hasNext()) {
                rows.add(in.nextLine());
            }
            World world = new World(rows);          
            System.out.println(world.state.propagate(world, 26501365));                     
        }           
    }
}

  • [^] # Re: Solution en Haskell.

    Posté par  . En réponse au message Advent of Code, jour 19. Évalué à 1.

    600 microsecondes ?

    Tu es sur que ce n'est pas des millisecondes ?

  • # Encore des problèmes de tests au borne

    Posté par  . En réponse au message Advent of Code, jour 19. Évalué à 1.

    Je fatigue , il est temps que la saison se termine. J'ai encore perdu du temps sur des tests bête aux borne
    Environ ~3h00 au total.

    Encore obligé d'en arriver à écrire T.U. pour débuguer. Demain, je TDD, je vais probablement gagner du temps.

    Pour la partie 1, j'ai utilisé un evaluator JEXL pour les expressions.
    Pour la partie 2, je n'avais pas le choix. J'ai écris le "parseur" (En fait, c'est plutôt un split de l'expression) car il faut plus travailler sur des lots de pieces.

    Mon objet Piece a maintenant une propriété Range que je vais split à chaque expression en 0, 1 ou 2.

    Temps d'éxecution:123ms

    package aoc2023;

import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Scanner;
import java.util.Stack;

import org.apache.commons.jexl3.JexlBuilder;
import org.apache.commons.jexl3.JexlContext;
import org.apache.commons.jexl3.JexlEngine;
import org.apache.commons.jexl3.JexlExpression;
import org.apache.commons.jexl3.MapContext;

public class Aoc2023s19v2 {

    public static Random RANDOM = new Random(0L);
    public static JexlEngine jexl = new JexlBuilder().create();

    public static record Range(int start, int end) {

        public long count() {
            return end - start;
        }

        public Range[] split(int to) {          
            if(start >= to || to >= end) {
                return null;
            }
            return new Range[] { new Range(start, to), new Range(to, end) };
        }

        public Range random() {
            int i = start  + RANDOM.nextInt((int)count());
            return new Range(i, i+1);
        }
    }

    public static class Piece {
        public Range x;
        public Range m;
        public Range a;
        public Range s;

        Piece(Range x, Range m, Range a, Range s) {
            this.x = x;
            this.m = m;
            this.a = a;
            this.s = s;
        }

        public long prod() {
            return x.count() * m.count() * a.count() * s.count();
        }

        @Override
        public String toString() {
            return "Piece [x=" + x + ", m=" + m + ", a=" + a + ", s=" + s + "]";
        }

        public Range get(String key) {
            return switch (key) {
            case "x" -> x;
            case "m" -> m;
            case "a" -> a;
            case "s" -> s;
            default -> throw new RuntimeException();
            };
        }

        public Piece substitute(String key, Range r) {
            return switch (key) {
            case "x" -> new Piece(r, m, a, s);
            case "m" -> new Piece(x, r, a, s);
            case "a" -> new Piece(x, m, r, s);
            case "s" -> new Piece(x, m, a, r);
            default -> throw new RuntimeException();
            };
        }
    }

    static class Rule {
        String condition;
        String destination;

        String attributTest;
        boolean attributeGreaterThan;
        int valueTest;

        Rule(String condition, String destination) {
            this.condition = condition;
            this.destination = destination;

            if(! this.condition.equals("true")) {
                attributTest = "" + this.condition.charAt(0);
                attributeGreaterThan = this.condition.charAt(1) == '>';
                valueTest = Integer.parseInt(this.condition.substring(2));
            }

        }

        public boolean match(Piece piece) {
            // Create a JEXL expression object
            JexlExpression jexlExpression = jexl.createExpression(condition);

            // Create a JexlContext and add the 'part' variable to it
            JexlContext context = new MapContext();
            context.set("x", piece.x.start);
            context.set("m", piece.m.start);
            context.set("s", piece.s.start);
            context.set("a", piece.a.start);

            // Evaluate the expression
            boolean result = (boolean) jexlExpression.evaluate(context);

            //System.out.println("Evaluation result: " + result);
            return result;
        }

        public String toString() {
            return condition + "," + destination;
        }

        public boolean process(Piece piece, Workflow workflow, Map<String, Workflow> workflows, List<Piece> accepts) {
            if(condition.equals("true")) {
                System.out.println("Default move to " + destination);
                getDestination(workflows, accepts).add(piece);              
                return true;
            }

            Range range = piece.get(attributTest);  

            System.out.println(this.condition);
            System.out.println(range);

            Range split[] = range.split(attributeGreaterThan ? valueTest +1: valueTest);
            if(split != null) {

                System.out.println("Splited to "  + workflow.name + " & " + destination);
                System.out.println(split[0] + " <-> " + split[1]);
                if(attributeGreaterThan) {
                    getDestination(workflows, accepts).add(piece.substitute(attributTest, split[1]));
                    workflow.pieces.add(piece.substitute(attributTest, split[0]));
                } else {
                    getDestination(workflows, accepts).add(piece.substitute(attributTest, split[0]));
                    workflow.pieces.add(piece.substitute(attributTest, split[1]));                  
                }
                return true;
            } else {
                if(attributeGreaterThan) {
                    if(range.start > valueTest) {               
                        System.out.println("Greater move to ");
                        getDestination(workflows, accepts).add(piece.substitute(attributTest, range));
                        return true;
                    }
                } else {
                    if((range.end-1) < valueTest) {
                        System.out.println("Lower move to ");
                        getDestination(workflows, accepts).add(piece.substitute(attributTest, range));
                        return true;
                    }
                }
            }
            return false;
        }

        private Collection<Piece> getDestination(Map<String, Workflow> workflows, List<Piece> accepts) {        
            if("A".equals(destination)) {
                return accepts;
            }
            if("R".equals(destination)) {
                return new ArrayList();
            }

            return workflows.get(destination).pieces;
        }
    }

    static class Workflow {
        String name;
        List<Rule> rules;
        Stack<Piece> pieces = new Stack();

        Workflow(String name) {
            this.name = name;
            this.rules = new ArrayList<>();
        }

        void addRule(Rule rule) {
            this.rules.add(rule);
        }

        public String toString() {
            StringBuilder sb = new StringBuilder();
            for (Rule rule : this.rules) {
                sb.append(rule.toString());
            }
            return sb.toString();
        }
    }

    static Map<String, Workflow> parseInput(Scanner in) {
        Map<String, Workflow> workflows = new HashMap<>();
        while (in.hasNext()) {
            String line = in.nextLine();
            line = line.trim();
            if (line.isEmpty()) {
                break;
            }

            String name = line.substring(0, line.indexOf('{')).trim();
            Workflow current = new Workflow(name);
            workflows.put(name, current);

            String[] parts = line.substring(line.indexOf('{') + 1, line.length() - 1).split(",");

            for (String part : parts) {
                String[] s = part.split(":");
                if (s.length == 1) {
                    current.addRule(new Rule("true", s[0]));
                } else {
                    current.addRule(new Rule(s[0], s[1]));
                }
            }

        }

        Range range = new Range(1, 4001);
        Piece base = new Piece(range, range, range, range);
        workflows.get("in").pieces.add(base);

        List<Piece> accepts = new ArrayList<>();

        computeAccepts(workflows, accepts);

        BigInteger sum = BigInteger.ZERO;
        for(Piece piece :accepts) {

            // uncomment to checkIndividual(piece, workflows);
            sum = sum.add(BigInteger.valueOf(piece.prod()));
        }
        System.out.println(sum);
        return workflows;
    }

    private static void checkIndividual(Piece rangePiece, Map<String, Workflow> workflows) {            
        for(int i=0;i < 1000;i++) {
            String currentName = "in";

            Piece piece = new Piece(
                    rangePiece.x.random(),
                    rangePiece.m.random(),
                    rangePiece.a.random(),
                    rangePiece.s.random()
                    );              
            //System.out.println("Piece:" + piece);             
            while(! currentName.equals("R") && !currentName.equals("A")) {
                //System.out.println("Current workflow:" + currentName);
                Workflow workflow = workflows.get(currentName);
                for(Rule rule : workflow.rules) {
                    //System.out.println("Match:" + rule.condition);
                    if(rule.match(piece)) {
                        currentName = rule.destination;                     
                        //System.out.println("=>:" + rule.destination);
                        break;
                    }
                }
            }

            if(! currentName.equals("A")) {
                System.err.println(rangePiece);
                throw new RuntimeException(piece.toString());
            }

        }

    }

    private static void computeAccepts(Map<String, Workflow> workflows, List<Piece> accepts) {
        while (workflows.values().stream().filter(w -> !w.pieces.isEmpty()).count() > 0) {
            Workflow workflow = workflows.values().stream().filter(w -> !w.pieces.isEmpty()).findFirst().orElse(null);
            System.out.println("Workflow:" + workflow.name);

            Piece piece = workflow.pieces.pop();
            for (Rule rule : workflow.rules) {
                if (rule.process(piece, workflow, workflows, accepts)) {
                    break;
                }
            }
        }
    }

    public static void main(String[] args) {
        long  s = System.currentTimeMillis();
        try (Scanner in = new Scanner(Aoc2023s18v2.class.getResourceAsStream("res/t19.txt"))) {
            parseInput(in);
        }
        System.out.println("Durée:" + (System.currentTimeMillis() - s) + "ms");
    }
}

  • # Bof , bof, je n'ai pas vraiment trouvé par moi-même.

    Posté par  . En réponse au message Advent of Code, jour 18. Évalué à 1.

    Pour la première partie, j'ai utilisé un bête algo de remplissage de forme par propagation.

    Pour la deuxième partie, je connaissais l'algorithme du lacets(Shoelace) pour en avoir entendu parlé récemment.
    Je me doutais qu'il fallait retirer le périmètre du polygone.

    Par contre, je ne trouvais pas malgré toutes mes investigations ,c'est en lisant le CR de Guillaume que j'ai découvert le théorème de Pick et son usage.

    Mon implémtentation en Java.

    package aoc2023;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Scanner;

public class Aoc2023s18v2 {
    public static record Point(long x, long y) {
        public Point createRelative(Point dir, long factor) {
            return new Point(x + dir.x * factor, y + dir.y * factor);
        }

        public double dist(Point p) {
            long dx = p.x - x;
            long dy = p.y - y;

            return Math.sqrt(dx * dx + dy * dy);
        }
    }

    public static List<String> ORDERS = Arrays.asList("R", "D", "L", "U");

    public static Map<String, Point> DIRECTIONS = Map.of("U", new Point(0, -1), "R", new Point(1, 0), "D",
            new Point(0, 1), "L", new Point(-1, 0));

    public static Map<String, String> DIRECTIONS_TRAD = Map.of("3", "U", "0", "R", "1", "D", "2", "L");

    public static long calculateArea2(List<Point> listPoints) {
        Point[] points = listPoints.toArray(new Point[listPoints.size()]);
        double sum = 0.0;

        for (int i = 0; i < points.length - 1; ++i) {
            sum += (points[i].x * points[i + 1].y) - (points[i + 1].x * points[i].y);
        }
        long perimeter = dist(listPoints);
        long s1 = (long) (Math.abs(sum) - perimeter);
        s1 = s1 / 2;
        s1 += 1;
        return s1 + perimeter;
    }

    public static long dist(List<Point> poly) {
        double sum = 0;
        for (int x = 1; x < (poly.size()); x++) {
            sum += poly.get(x - 1).dist(poly.get(x));
        }

        sum += poly.get(poly.size() - 1).dist(poly.get(0));
        return (long) sum;
    }

    public static void main(String[] args) {
        try (Scanner in = new Scanner(Aoc2023s18v2.class.getResourceAsStream("res/t18.txt"))) {
            List<String> rows = new ArrayList<>();

            while (in.hasNext()) {
                String row = in.nextLine();
                rows.add(row);
            }
            List<Point> polyPoints = polygons2(rows);

            System.out.println("found=" + calculateArea2(polyPoints));

        }
    }

    private static List<Point> polygons2(List<String> rows) {
        List<Point> points = new ArrayList<>();
        Point p = new Point(0, 0);
        points.add(p);
        for (String row : rows) {
            String dirKey = row.split(" ")[2];
            long factor = Long.valueOf(dirKey.substring(2, 7), 16);
            String dir = "" + dirKey.charAt(dirKey.length() - 2);
            System.out.println(factor + " " + dir);
            Point np = p.createRelative(DIRECTIONS.get(DIRECTIONS_TRAD.get(dir)), factor);
            points.add(np);
            p = np;
        }
        return points;
    }
}

  • # J'étais fatigué, j'ai fait un algo moisie, j'ai du corrigé des bug moisie

    Posté par  . En réponse au message Advent of Code, jour 17. Évalué à 1.

    Mauvais cocktail pour coder :)
    - S'être couché à 3h
    - Être fatigué, limite reste de gueule bois
    - Regarder les conneries à la télé en même temps qu'on code.

    Conséquences:
    - çà donne un code très long à déboguer
    - un problème pris de travers.

    Mon code est tellement moche que je ne vais pas le partager :)

    Honnêtement , je ne voyais pas comment appliquer un algo traditionnel de pathfinding avec les règles de déplacement.
    Je suis donc partie sur une fonction récursive dans un premier temps. Mauvaise pioche entre les bogues, je suis arrivé après 3h à me dire que çà ne pouvait pas marcher.
    Je change de stratégie. Je pars de l'arrivé et je remonte progressivement en mettant à jour les noeuds adjacents, j'y ai passé encore bien 3h au total sur la journée.

    3min pour donner la réponse de la partie 2.

  • # Solution en Java 403ms

    Posté par  . En réponse au message Advent of Code, jour 14. Évalué à 1.

    Ci-dessous ma soluce en Java pour la partie 2. Elle met 403ms une fois Java lancé (c'est comme un bon diesel Java). Et encore, j'ai une vilaine boucle qui compte jusqu'à avant le milliard.
    J'optimise en utilisant des objets mutable & un bon vieux cache basé sur un Record.

    package aoc2023;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Aoc2023s14v2 {     
    enum Type {
        SPHERE,
        ROCK;
    }

    public static class Point {
        int x;
        int y;
        Type type;

        public Point(int x, int y, Type type) {
            this.x= x;
            this.y=y;
            this.type = type;
        }
    }

    public static class World {
        int width;
        int height;

        Point[][] map;
        List<Point> spheres = new ArrayList<>();


        public World(List<String> rows) {
            map = new Point[rows.size()][rows.get(0).length()];
            for(int y=0;y < rows.size();y++) {
                addRow(rows.get(y), y);
            }
            this.height = rows.size();
        }

        public void addRow(String row, int y) {
            this.width = row.length();

            for(int x=0;x < row.length();x++) {
                Point p = null;
                if(row.charAt(x) == 'O') {
                    p =new Point(x, y, Type.SPHERE);
                    spheres.add(p);
                } else if(row.charAt(x) == '#') {
                    p = new Point(x, y, Type.ROCK);
                }

                map[y][x] =p;
            }
        }

        public boolean isFree(int x, int y) {
            if(x < 0 || x >= width || y < 0 || y >= height ) {
                return false;
            }

            return this.map[y][x] == null;          
        }

        public Point find(int x, int y) {
            if(x < 0 || x >= width || y < 0 || y >= height ) {
                return null;
            }
            return this.map[y][x];      
        }

        public void move(int dx, int dy) {
            boolean change = false;
            do {
                change =false;
                for(Point p : spheres) {
                    if(isFree(p.x + dx, p.y +dy)) {
                        map[p.y][p.x] = null;
                        p.x += dx;
                        p.y += dy;
                        map[p.y][p.x] = p;
                        change =true;
                    }
                }               
            } while(change);            
        }

        public int computeWeight() {
            int sum = 0;
            for(Point sphere :spheres) {
                sum += (height-sphere.y);
            }
            return sum;
        }


        public List<String> toRows() {
            List<String> rows = new ArrayList<>();
            StringBuilder sb = new StringBuilder();
            for(int y=0;y < height;y++) {
                sb.setLength(0);
                for(int x=0;x < width;x++) {
                    Point p = find(x, y);
                    if(p == null) {
                        sb.append('.');
                    } else if(p.type == Type.ROCK) {
                        sb.append('#');
                    } else {
                        sb.append('O');
                    }
                }
                rows.add(sb.toString());
            }
            return rows;
        }
    }

    public static void main(String[] args) {        
        long startMs = System.currentTimeMillis();          
        try (Scanner in = new Scanner(Aoc2023s14v2.class.getResourceAsStream("res/t14.txt"))) {
            List<String> rows = new ArrayList<>();
            while (in.hasNext()) {
                rows.add(in.nextLine());
            }

            Integer startCycle = null;
            Integer cycleCount = null;
            World world = null;
            final long LOOPS = 1_000_000_000L;
            for(long x = 0 ;x < LOOPS;x++) {
                CacheKey current = new CacheKey(rows);
                if(keys[current.cacheIndex()] != null && keys[current.cacheIndex()].equals(current)) {
                    if(startCycle == null) {
                        startCycle = current.cacheIndex();
                        cycleCount = 0;
                    } else if(startCycle == current.cacheIndex()) {
                        System.out.println("Make cycle: " + cycleCount);
                        // Could be more elegant :)
                        while(x < (LOOPS-cycleCount)) {
                            x += (cycleCount+1);
                        }
                    } else {
                        cycleCount++;
                    }
                    world = cache_worlds[current.cacheIndex()];
                } else {
                    world = computeWorld(rows);
                    keys[current.cacheIndex()] = current;
                    cache_worlds[current.cacheIndex()] = world;
                    System.out.println("miss " + x);

                    startCycle = null;
                    cycleCount = null;
                }
                rows = world.toRows();              
            }

            System.out.println(world.computeWeight());
        }   
        System.out.println((System.currentTimeMillis() - startMs) + "ms");
    }

    private static World computeWorld(List<String> rows) {
        World world;
        world = new World(rows);
        world.move(0, -1);
        world.move(-1, 0);
        world.move(0, 1);
        world.move(1, 0);
        return world;
    }

    public static record CacheKey(List<String> rows) {

        public int cacheIndex() {
            return Math.abs(this.hashCode()) % CACHE_SIZE;
        }
    }

    public static final int CACHE_SIZE = 1_000_000;
    public static  CacheKey[] keys = new CacheKey[CACHE_SIZE];
    public static  World[] cache_worlds = new World[CACHE_SIZE];

}

  • # J'en ai bavé.

    Posté par  . En réponse au message Advent of Code 2023, jour 12. Évalué à 1.

    6h au total ! J'ai commencé par prendre le problème de travers.

    J'ai fait substitution récursive des '?' ,c'était mon erreur.

    C'est après que j'ai compris qu'il fallait distribuer les espaces restant entre les groupes.

    çà permet d'exprimer le problème avec une fonction recursive pour lequel on peut mettre en place un cache des valeurs par rapport au reste à évaluer.

    Environ 414ms sur ma machine (après avoir commenté les println)

    package aoc2023;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
import java.util.concurrent.atomic.AtomicLong;

public class Aoc2023s12v4 { 
    public static record Evaluation(List<Integer> groupes, int totalDot, String dstSpring) {                    
    }

    public static Evaluation[] cache = new Evaluation[1_000_000];
    public static long[] cacheValue = new long[1_000_000];

    public static void main(String[] args) {                        
        assert (countExpandedPossibility("??# 2") == 16L);

        assert (countExpandedPossibility("???.### 1,1,3") == 1L); 
        assert (countExpandedPossibility(".??..??...?##. 1,1,3") == 16384L);
        assert (countExpandedPossibility("????.#...#... 4,1,1") == 16L);
        assert (countExpandedPossibility("????.######..#####. 1,6,5") == 2500L);
        assert (countExpandedPossibility("?###???????? 3,2,1") == 506250L);
        //assert (countExpandedPossibility("???.?#?????##?#????? 1,2,7,1") == 506250L);

        System.out.println("-----------          -----------");
        System.out.println("----------- END TEST -----------");
        System.out.println("-----------          -----------");


        try (Scanner in = new Scanner(Aoc2023s12v4.class.getResourceAsStream("res/t12.txt"))) {
            List<String> map = new ArrayList<>();

            while (in.hasNext()) {
                String row = in.nextLine();
                map.add(row);
            }

            long count = 0;

            for (String row : map) {
                count += countExpandedPossibility(row);
            }
            System.out.println(count);
        }
    }
        private static long countExpandedPossibility(String row) {
        String srcSprings = row.split(" ")[0];
        int[] srcRules = Arrays.stream(row.split(" ")[1].split(",")).mapToInt(s -> Integer.parseInt(s)).toArray();

        long r = countExpanded(srcSprings, srcRules, 5);
        System.out.println(r);
        return r;
    }
        private static long countExpanded(String srcSprings, int[] srcRules, int i) {
        int[] dstRules = new int[srcRules.length * 5];
        for (int x = 0; x < i; x++) {
            for (int y = 0; y < srcRules.length; y++) {
                dstRules[x * srcRules.length + y] = srcRules[y];
            }
        }

        String dstSpring = srcSprings;
        for(int x=0;x < i-1;x++) {
            dstSpring += '?' + srcSprings;
        }               
        System.out.println("Pattern:");
        System.out.println(dstSpring);

        int total = Arrays.stream(dstRules).sum();
        int totalDot = dstSpring.length() - total;

        System.out.println(total + " + " + totalDot + " => " + dstSpring.length());


        return distributeDotBetweenGroup(
                Arrays.stream(dstRules).mapToObj(Integer::valueOf).toList(),
                true,
                totalDot,               
                dstSpring);             
    }
        private static long distributeDotBetweenGroup(List<Integer> groupes, boolean first, int totalDot, String dstSpring) {           
        if(0 == groupes.size() ) {
            String current = "";
            for(int j=0;j < totalDot;j++) {
                current += '.';
            }
            //System.out.println(sb);
            if(match(current, dstSpring)) {             
                return 1;           
            }
            return 0;
        }

        int size = groupes.get(0);

        StringBuilder sb = new StringBuilder();
        long sum  = 0;
        for(int ud=(first? 0:1);ud <= totalDot;ud++) {
            sb.setLength(0);            
            for(int j=0;j < ud;j++) {
                sb.append('.');             
            }           
            for(int j=0;j < size;j++) {
                sb.append('#');
            }


            if(! match(sb, dstSpring, sb.length())) {
                continue;
            }

            Evaluation eva= new Evaluation(groupes.subList(1, groupes.size()), totalDot-ud, dstSpring.substring(sb.length()));

            int indexCache =Math.abs(eva.hashCode())% cache.length;
            if(cache[indexCache] !=null && cache[indexCache].equals(eva)) {
                sum += cacheValue[indexCache];
            } else {
                long i= distributeDotBetweenGroup(eva.groupes, false, eva.totalDot, eva.dstSpring);
                cache[indexCache] = eva;
                cacheValue[indexCache] = i;
                sum += i;
            }           

        }
        return sum;

    }
        private static boolean match(String test, String refPattern) {
        if(test.length() != refPattern.length()) {
            return false;
        }
        for (int x = 0; x < test.length(); x++) {
            char c = refPattern.charAt(x);
            if (c != '?') {
                if (test.charAt(x) != c) {
                    return false;
                }
            }
        }
        return true;
    }
        private static boolean match(StringBuilder test, String refPattern, int wi) {       
        for (int x = 0; x < wi; x++) {
            char c = refPattern.charAt(x);
            if (c != '?') {
                if (test.charAt(x) != c) {
                    return false;
                }
            }
        }
        return true;
    }
}

  • # Ma solution

    Posté par  . En réponse au message Advent of Code 2023 : Jour 10. Évalué à 1.

    Pour la deuxième partie, j'ai opté pour une solution où je remplace les tuiles de base par des tuiles de 3x3
    Je remplie ensuite en faisant les cellules en bordure de la map.

    Note: Ce code doit être utilisée --Xms2G pour avoir une stack plus grande que celle par défaut.

    package aoc;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;
import java.util.Stack;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

import aoc.Aoc2023s10p1.Direction;
import aoc.Aoc2023s10p1.Maze;
import aoc.Aoc2023s10p1.Pipe;

public class Aoc2023s10p2 {
    public enum Direction {
        N(0, -1), S(0, 1), E(1, 0), W(-1, 0);

        int dx;
        int dy;

        Direction(int dx, int dy) {
            this.dx = dx;
            this.dy = dy;
        }

        Direction comeFrom() {
            if (this == N) {
                return S;
            } else if (this == E) {
                return W;
            } else if (this == W) {
                return E;
            } else if (this == S) {
                return N;
            }
            throw new RuntimeException();
        }
    }
        public enum Pipe {

        V('|', Arrays.asList(Direction.N, Direction.S),
                new int[][] {new int[]{0, 1, 0}, new int[]{0, 1, 0}, new int[]{0, 1, 0}}
                ), // is a vertical pipe connecting north and south.
        H('-', Arrays.asList(Direction.E, Direction.W),
                new int[][] {new int[]{0, 0, 0}, new int[]{1, 1, 1}, new int[]{0, 0, 0}}
                ), // is a horizontal pipe connecting east and west.
        L('L', Arrays.asList(Direction.N, Direction.E),
                new int[][] {new int[]{0, 1, 0}, new int[]{0, 1, 1}, new int[]{0, 0, 0}}
                ), // , is a 90-degree bend connecting north and east.
        J('J', Arrays.asList(Direction.N, Direction.W),
                new int[][] {new int[]{0, 1, 0}, new int[]{1, 1, 0}, new int[]{0, 0, 0}}
                ), // is a 90-degree bend connecting north and west.
        _7('7', Arrays.asList(Direction.S, Direction.W),
                new int[][] {new int[]{0, 0, 0}, new int[]{1, 1, 0}, new int[]{0, 1, 0}}
                ), // is a 90-degree bend connecting south and west.
        F('F', Arrays.asList(Direction.S, Direction.E),
                new int[][] {new int[]{0, 0, 0}, new int[]{0, 1, 1}, new int[]{0, 1, 0}}
                ), // is a 90-degree bend connecting south and east.
        D('.', Collections.emptyList(),
                new int[][] {new int[]{0, 0, 0}, new int[]{0, 0, 0}, new int[]{0, 0, 0}}
                ), // is ground; there is no pipe in this tile.
        S('S', Arrays.asList(Direction.N, Direction.S, Direction.E, Direction.W),
                new int[][] {new int[]{0, 1, 0}, new int[]{1, 1, 1}, new int[]{0, 1, 0}}
                ),// is the starting position of the
                                                                                    // animal; there is a pipe on this
                                                                                    // tile, but your sketch doesn't
                                                                                    // show what shape the pipe has.
        ;

        char c;
        List<Direction> directions;
        int[][] matrix;

        Pipe(char c, List<Direction> directions, int[][] matrix) {
            this.c = c;
            this.directions = directions;
            this.matrix = matrix;
        }

        boolean acceptFrom(Direction d) {
            return directions.contains(d);
        }
    }
        public static class Maze2 {
        List<List<Pipe>> maze;
        final int heightMap;
        final int widthMap;
        final int[][] map;
        final int[][] weights;

        final int[][] externs;

        Maze2(List<List<Pipe>> maze) {
            this.maze = maze;

            int height = maze.size();
            int width = maze.get(0).size();     
            weights = new int[height][width];
            computeWeight();

            heightMap = height*3;
            widthMap = width*3;
            map = new int[heightMap][widthMap];
            externs = new int[heightMap][widthMap];
            for (int x = 0; x < width; x++) {
                for (int y = 0; y < height; y++) {

                    if(weights[y][x] != Integer.MAX_VALUE) {
                        writeMatrix(maze, x, y);
                    }
                }
            }

            for (int x = 0; x < widthMap; x++) {
                for (int y = 0; y < heightMap; y++) {
                    externs[y][x] = -1;
                    if (map[y][x] == 1) {
                        externs[y][x] = 0;
                    }

                }
            }

            for (int x = 0; x < widthMap; x++) {
                fillEnclosed(x, 0);
                fillEnclosed(x, heightMap - 1);
            }

            for (int y = 0; y < heightMap; y++) {
                fillEnclosed(0, y);
                fillEnclosed(widthMap - 1, y);
            }

        }

        private void writeMatrix(List<List<Pipe>> maze, int x, int y) {
            Pipe p = maze.get(y).get(x);
            for (int dy = 0; dy < 3; dy++) {
                for (int dx = 0; dx < 3; dx++) {
                    int m = p.matrix[dy][dx];
                    map[y*3 +dy][x*3 + dx] = m;
                }
            }
        }

        private void fillEnclosed(int x, int y) {
            if (x < 0 
                    || x >= widthMap 
                    || y < 0 
                    || y >= heightMap) {
                return;
            }
            if (map[y][x] == 1) {
                return;
            }

            if (externs[y][x] < 0) {
                externs[y][x] = 1;

                for (Direction d : Direction.values()) {
                    fillEnclosed(x + d.dx, y + d.dy);
                }               
            }
        }

        public void print() {
            for(int y=0;y < heightMap;y++) {
                for(int x=0;x < widthMap;x++) {
                    System.out.print(map[y][x]);
                }
                System.out.println();
            }

            for(int y=0;y < heightMap;y++) {
                for(int x=0;x < widthMap;x++) {
                    int i = externs[y][x];
                    if(i < 0) {
                        System.out.print("I");
                    } else if(i == 0) {
                        System.out.print("#");
                    } else {
                        System.out.print(".");
                    }

                }
                System.out.println();
            }
        }

        public int countEnclosed() {
            int max = 0;
            int height = maze.size();
            int  width= maze.get(0).size(); 
            for (int y = 0; y < height; y++) {
                for (int x = 0; x < width; x++) {

                    if(emptyTile(x, y)) {
                        max++;
                    }       
                }
            }
            return max;
        }

        public boolean emptyTile(int x, int y) {
            for (int dy = 0; dy < 3; dy++) {
                for (int dx = 0; dx < 3; dx++) {

                    if(externs[y*3+dy][x*3+dx] >= 0) {
                        return false;
                    }
                }
            }
            return true;
        }

        public void computeWeight() {
            int height = maze.size();
            int width = maze.get(0).size(); 

            int sx = 0;
            int sy = 0;
            for(int x=0;x < width;x++) {
                for(int y=0;y < height;y++) {
                    weights[y][x] = Integer.MAX_VALUE;
                    if(maze.get(y).get(x) == Pipe.S) {
                        weights[y][x] = 0;
                        sx = x;
                        sy = y;
                    }
                }
            }

            fillWeightFrom(sx, sy);
        }

        private void fillWeightFrom(int cx, int cy) {
            int w = weights[cy][cx];
            Pipe currentPipe = this.maze.get(cy).get(cx);

            for(Direction d : Direction.values()) {

                if(currentPipe.directions.contains(d)) {
                    int dx = cx+ d.dx;
                    int dy = cy+ d.dy;
                    Pipe nextPipe = next(dx, dy);
                    if(nextPipe != null) {
                        if(nextPipe.acceptFrom(d.comeFrom())) {
                            int wn = weights[dy][dx];
                            if(wn > (w+1)) {
                                weights[dy][dx] = w+1;
                                fillWeightFrom(dx, dy);
                            }
                        }
                    }
                }               
            }       
        }

        public Pipe next(int cx, int cy) {
            int height = maze.size();
            int width = maze.get(0).size(); 
            if(cx < 0 || cx >= width) {
                return null;
            }
            if(cy < 0 || cy >= height) {
                return null;
            }

            return this.maze.get(cy).get(cx);
        }
    }
        public static Map<String, Pipe> pipeBySymbol = Arrays.stream(Pipe.values())
            .collect(Collectors.toMap(p -> "" + p.c, p -> p));
        public static void main(String[] args) {

        try (Scanner in = new Scanner(Aoc2023s10p2.class.getResourceAsStream("res/Aoc2023s10p1.txt"))) {
            String row;
                List<List<Pipe>> maze = new ArrayList<>();
            while (in.hasNext()) {
                row = in.nextLine();

                maze.add(row.chars().mapToObj(i -> pipeBySymbol.get(String.valueOf((char) i))).toList());

            }

            Maze2 mazeSolve = new Maze2(maze);
            mazeSolve.print();
            System.out.println(mazeSolve.countEnclosed());
            }
    }

}

  • # Je me lance ma soluce en Java

    Posté par  . En réponse au message Advent of Code 2023 : Day 3. Évalué à 1.

    Un peu long à coder, j'ai passé plus de temps sur la première partie que sur la deuxième partie.

    Partie 1 :

    public class Aoc2023s3p1 {
    public static void main(String[] args) {
        try(Scanner in = new Scanner(Aoc2023s3p1.class.getResourceAsStream("res/Aoc2023s3p1.txt"))) {
                String row;
                int sum =0;

                List<String> rows = new ArrayList<>();

                while(in.hasNext()) {
                    row = in.nextLine();
                    rows.add(row);
                }

                for(int x=0;x < rows.size();x++) {
                    sum += check(x, rows);
                }


                System.out.println(sum);
        }
    }

    public static record Num(int start, int end, String data) {
    }


    public static int check(int rowIndex, List<String> rows) {

        String row = rows.get(rowIndex);

        List<Num> list = new ArrayList<>();
        Integer start = null;
        for(int x=0;x < row.length();x++) {
            int c = row.charAt(x) - '0';
            if(Character.isDigit(row.charAt(x))) {
                if(start == null) {
                    start = x;
                }
            } else {
                if(start != null) {
                list.add(new Num(start, x, row.substring(start, x)));
                start = null;
                }
            }
        }

        if(start !=null) {
            list.add(new Num(start, row.length(), row.substring(start)));
        }

        int sum = 0;
        for(Num num : list) {
            System.out.println(num);
            if(checkNum(num, rowIndex, rows)) {
                System.out.println("OK");
                sum += Integer.parseInt(num.data());
            }
        }

        return sum;
    }


    private static boolean checkNum(Num num, int rowIndex, List<String> rows) {
        int before = num.start-1;
        if(checkCharacter(rowIndex, before, rows)) {
            return true; 
        }

        if(checkCharacter(rowIndex, num.end, rows)) {
            return true; 
        }


        for(int x = num.start-1;x < num.end+1;x++) {
            if(checkCharacter(rowIndex - 1, x, rows)
                    || checkCharacter(rowIndex + 1, x, rows)) {
                return true;
            }
        }
        return false;
    }

    private static boolean checkCharacter(int rowIndex, int colIndex, List<String> rows) {
        if(rowIndex < 0 || rowIndex >= rows.size()) {
            return false;
        }
        String row = rows.get(rowIndex);

        if(colIndex < 0 || colIndex >= row.length()) {
            return false;
        }

        char c = row.charAt(colIndex);
        if(Character.isDigit(c) || c == '.') {
            return false;
        }

        return true;
    }

}

    Pour la partie 2, l'idée est assez simple. J'identifie les engrenages '*' par leurs coordonnées et je stocke sur chaque coordonnée la liste des nombres associés (numsById)

    public class Aoc2023s3p2 {
    public static Map<Coord, List<Num>> numsById = new HashMap<>();

    public static void main(String[] args) {

        try(Scanner in = new Scanner(Aoc2023s3p2.class.getResourceAsStream("res/Aoc2023s3p1.txt"))) {
                String row;


                List<String> rows = new ArrayList<>();

                while(in.hasNext()) {
                    row = in.nextLine();
                    rows.add(row);
                }

                for(int x=0;x < rows.size();x++) {
                    check(x, rows);
                }


                int sum =0;
                for(List<Num> nums: numsById.values()) {

                    if(nums.size() <= 1) {
                        continue;
                    }
                    System.out.println("=====");
                    int prod = 1;
                    for(Num num : nums) {
                        prod *= Integer.parseInt(num.data);
                        System.out.println(num.data);
                    }
                    System.out.println("=>" + prod);
                    sum += prod;
                }

                System.out.println(sum);
        }
    }

    public static record Num(int start, int end, String data) {
    }


    public static void check(int rowIndex, List<String> rows) {
        String row = rows.get(rowIndex);

        List<Num> list = new ArrayList<>();
        Integer start = null;
        for(int x=0;x < row.length();x++) {
            int c = row.charAt(x) - '0';
            if(Character.isDigit(row.charAt(x))) {
                if(start == null) {
                    start = x;
                }
            } else {
                if(start != null) {
                list.add(new Num(start, x, row.substring(start, x)));
                start = null;
                }
            }
        }

        if(start !=null) {
            list.add(new Num(start, row.length(), row.substring(start)));
        }

        for(Num num : list) {
            System.out.println(num);
            if(isGearPart(num, rowIndex, rows)) {
                System.out.println("OK");
            }
        }


    }


    private static boolean isGearPart(Num num, int rowIndex, List<String> rows) {


        int before = num.start-1;
        checkGear(num, rowIndex, before, rows);
        checkGear(num, rowIndex, num.end, rows);


        for(int x = num.start-1;x < num.end+1;x++) {
            checkGear(num, rowIndex - 1, x, rows);
            checkGear(num, rowIndex + 1, x, rows);
        }



        return false;
    }


    public static record Coord(int rowIndex, int colIndex) {

    }

    private static boolean checkGear(Num num, int rowIndex, int colIndex, List<String> rows) {
        if(rowIndex < 0 || rowIndex >= rows.size()) {
            return false;
        }
        String row = rows.get(rowIndex);

        if(colIndex < 0 || colIndex >= row.length()) {
            return false;
        }

        char c = row.charAt(colIndex);
        if(c == '*') {
            numsById.computeIfAbsent(new Coord(rowIndex, colIndex),k->new ArrayList<>()).add(num);

        }

        return false;
    }

}

  • [^] # Re: Plusieurs leaderboards privés ?

    Posté par  . En réponse au journal Advent of code 2023. Évalué à 3.

    Je confirme. On a un leadboard interne à ma boite. Plus celui-ci.

  • [^] # Re: J'y retourne !

    Posté par  . En réponse au journal Advent of code 2023. Évalué à 4.

    J'aurai du te laisser faire la news :-p

  • # Personnellement, je préfère les tomates aux pattates

    Posté par  . En réponse au journal Il est temps que la communauté internationale fasse un choix. Évalué à 2.

    Alors pour moi, une bonne raclette:
    - Bcp de fromages
    - Des Tomates
    - De l'oignon coupé finement.
    - Un gouse d'ail cuite en même que les patates
    - Un peu de patates (pas plus d'une pour moi)
    - Un peu de jambon fumé et du bacon

    Et sinon pour la problématique de l'appareil à Raclette , il y a ceux de GIFI qui se branche les un les autres. Donc tout le monde peut venir avec ses appareils à raclette.

  • # J'adore

    Posté par  . En réponse au journal Grandbrothers. Évalué à 2.

    J'adore :) Merci pour cette belle découverte.

  • # Ça dépend

    Posté par  . En réponse à la dépêche Pétition de Mozilla pour protéger Firefox. Évalué à 1.

    Si, c'est comme dans l'article, c'est à dire:
    - le navigateur récupère une black list du gouvernement , çà me va.

    Par contre, si le système est du type. Quand on consulte un site, on vient demander au site du gouvernement si on a le droit d'y accéder, c'est plus ennuyeux.
    Pour 3 raisons:
    - le gouvernement connaitra ton historique de navigation
    - ça risque de tuer les perf de navigation
    - une ddos sur site , on ne navigue plus

    Après, c'est le genre de feature qui pourra se désactiver. Vu qu'elle ne sera pas appliquable dans tous les pays.

    Après pour l histoiriques de navigation, les antivirus, google, ils ont déjà cette historique avec l antiphishing d activés donc c est plutôt le risque 2 et 3 qui gène

  • # embrace - extend - extinguish

    Posté par  . En réponse au journal Wayland dans windows 10 et 11. Évalué à 2.

    J'ai découvert moi aussi WSL 2 sur Windows. çà me permet de faire tourner un Linux & plein d'instance docker pour mes dev.

    Je n'ai pas encore essayé de faire tourner des apps graphique mais je ne suis pas surpris que çà marche.

    Ce qui me terrifie, c'est la stratégie historique de Microsoft: Embrace - Extend - Extinguish.

    Avec, ils ont réussi à bouffer : OS/2 , Netscape, …

  • [^] # Re: Mailcow ?

    Posté par  . En réponse au message Serveur smtp/map. Évalué à 1.

    Merci pour l'info.

    Au final, je pense que je vais partir avec une image docker de postfix maison ou de sendmail maison.

  • [^] # Re: Mailcow ?

    Posté par  . En réponse au message Serveur smtp/map. Évalué à 1.

    Merci pour le lien.
    J'aurai préféré un témoignage genre çà marche chez moi :)

    çà a l'air de faire trop de truc pour moi. Mon besoin est beaucoup plus simple.

  • # Perso, j'y connais rien Ruby mais ...

    Posté par  . En réponse au lien OneTimeSecret. Évalué à 0.

    Je trouve que l'idée est bonne.

    Par contre, ce qui me gène, c'est que je n'y connais rien Ruby & que pour utiliser ce genre de service.
    il faut que je sois sur que cela soit Safe. il faut donc que je l'audit.

    Il faudrait le même service dans un code qui tient en quelques fichiers facilement auditable sans dépendance tiers.
    - 1 fichier sources serveur
    - 1 form HTML
    - 1 JS
    - 1 form CSS
    - 1 Dockerfile

  • [^] # Re: J'ai galéré :)

    Posté par  . En réponse au message Avent du code jour 25. Évalué à 2.

    Yes bien joué Yth

    Bien joué tt le monde.

    Je trouve qu il etait vraiment plus simple que l'an dernier.

    Le prochain challenge sympa dans ce genre, c est ctf de l Ansi en mai.

  • # J'ai galéré :)

    Posté par  . En réponse au message Avent du code jour 25. Évalué à 2. Dernière modification le 25 décembre 2022 à 11:52.

    Environ 2h40 pour faire ce fichu dernier problème. Je genre d'éxercice, ce n'est vraiment pas mon truc.

    J'y suis allé à la méthode ajustement test unitaire.

    Le parsing est assez simple à réaliser. En gros, c'est comme une conversion d'une base 5 avec des -1 , et -2 :)

    Le problème, c'est l'opération inverse. Mon algo est tellement tordu que je n'arrive pas à l'expliquer :)
    Je n'ai même pas l'excuse de l'alcool car je suis sous antibiotique. Résultat, c'est mon premier noël sans une goutte d'alcool.

    Joyeux noël à tous.

        static String toSnafu(long v) {
        String s  =Long.toString(v, 5);
        if(s.indexOf("3") < 0 && s.indexOf("4") < 0) {
            return s;
        }
        long[] seek = prepareSeek(v);
        long seekValue = seek[0] * ((long)Math.pow(5, seek.length-1));

        for(int x=1;x < seek.length;x++) {
            long lowestGreater = 2;
            for(int e=VALUES.length-1;e >= 0;e--) {


                long add = VALUES[e] * ((long)Math.pow(5, seek.length-1-x));

                long s1 = seekValue + add + maxWithOnly2(seek.length-1-x) ;
                long s2 = v;


                if(s1 < s2) {                   
                    break;
                }

                lowestGreater = VALUES[e];

            }



            seek[x] = lowestGreater;
            //System.out.println(Arrays.stream(seek).mapToObj(i->Long.toString(i)).collect(Collectors.joining(",")));
            long add = lowestGreater * ((long)Math.pow(5, seek.length-1-x));
            seekValue += add;
        }




        return seekToString(seek);
    }


    private static String seekToString(long[] seek) {
        StringBuilder sb = new StringBuilder();
        for(int x=0;x < seek.length;x++) {
            if(seek[x] == 0 && x == 0) {
                continue;
            }

            if(seek[x] == -2) {
                sb.append('=');
            } else if(seek[x] == -1) {
                sb.append('-');
            } else {
                sb.append(Long.valueOf(seek[x]));
            }

        }

        return sb.toString();
    }

    static long[] prepareSeek(long v) {
        if(v == 0) {
            return new long[] {0};
        }
        long power = 0;
        boolean greater = false;
        long greaterNb = 0;
        while(! greater) {
            long max = maxWithOnly2(power);

            for(long x=1; x <= 2;x++) {
                long l = (x* ((long)Math.pow(5, power))) +max ;
                if(l >= v) {
                    greater =true;
                    greaterNb = x;
                    break;
                }
            }
            power += 1;
        }

        long[] mask = new long[(int)power];
        mask[0]=greaterNb;
        return mask;
    }


    private static long maxWithOnly2(long power) {
        long max = 0;
        for(int j=0; j < power;j++) {
            max += 2* Math.pow(5, j);
        }
        return max;
    }

  • # Parcours en largeur.

    Posté par  . En réponse au message Avent du Code, jour 24. Évalué à 5.

    On est dans le cas typique d'un parcours en largeur d'un arbre des possibles.

    A chaque round, on regarde l'ensemble des actions possibles et on calcule les états suivants en fonction de ses possibilités
    il y a des branches qui s'élimine d'elle-même car il n'y a plus d'action possible pour le joueur.
    il y aussi des branches qui se rejoingne car il y a plusieurs chemin pour arriver à un même état.
    J'utilise le hashCode/equals de mon State pour les dédupliquer sinon çà explose grave.

    Au total,j'ai mis 1h50 pour debug les différentes conneries que j'ai fait à mon réveille.

    Je mets 40s pour calculer la solution de la 2ème étoiles

    Maintenant, je vais aller braver les magasins car j'ai plein de cadeau à acheter :-).
    Joyeux Noël à tous.

    import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Objects;
import java.util.Scanner;
import java.util.Set;
import java.util.stream.Collectors;

public class A2022D24 {
    public enum Move {
        EAST(1, 0, '>'),

        SOUTH(0, 1, 'v'), WEST(-1, 0, '<'), WAIT(0, 0, 'W'), NORTH(0, -1, '^');

        int dx;
        int dy;
        char d;

        private Move(int dx, int dy, char d) {
            this.dx = dx;
            this.dy = dy;
            this.d = d;
        };

    }

    public static class Point {
        int x;
        int y;

        public Point() {
        }

        public Point(int x, int y) {
            this.x = x;
            this.y = y;
        }

        public String toString() {
            return x + "," + y;
        }

        public void copyInto(Point p) {
            p.x = this.x;
            p.y = this.y;
        }

        @Override
        public int hashCode() {
            return Objects.hash(x, y);
        }

        @Override
        public boolean equals(Object obj) {
            if (this == obj)
                return true;
            if (obj == null)
                return false;
            if (getClass() != obj.getClass())
                return false;
            Point other = (Point) obj;
            return x == other.x && y == other.y;
        }


    }

    public static class Wind extends Point {
        Move m;

        public Wind(int x, int y) {
            this.x = x;
            this.y = y;
        }

        public void copyInto(Wind wind) {
            super.copyInto(wind);
            wind.m = m;

        }

    }

    public static class State {
        List<Wind> winds = new ArrayList<>();
        Point pos = new Point(1, 0);
        int round = 0;

        public void copyInto(State state) {
            state.winds.clear();
            for (Wind w : this.winds) {
                Wind newWind = new Wind(0, 0);
                w.copyInto(newWind);
                state.winds.add(newWind);
            }

            this.pos.copyInto(state.pos);
            state.round = this.round;

        }

        public char count(int x, int y) {
            char c = '.';
            int count = 0;
            for (Wind wind : this.winds) {
                if (wind.x == x && wind.y == y) {
                    count++;
                    c = wind.m.d;
                }
            }
            if(count > 1) {
                c = ("" + count).charAt(0);
            }
            return c;

        }

        public boolean isFree(int x, int y) {
            if ((x == WIDTH - 2) && (y == HEIGHT - 1)) {
                return true;
            }

            if ((x == 1) && (y == 0)) {
                return true;
            }

            if (y <= 0 || x <= 0 || x >= (WIDTH - 1) || y >= (HEIGHT - 1)) {
                return false;
            }

            for (Wind wind : this.winds) {
                if (wind.x == x && wind.y == y) {
                    return false;
                }
            }
            return true;

        }

        public List<A2022D24.Move> getAvailables() {
            return Arrays.stream(Move.values()).filter(m -> isFree(pos.x + m.dx, pos.y + m.dy))
                    .collect(Collectors.toList());
        }

        public void moveWind() {
            for (Wind wind : winds) {
                wind.x = wind.x + wind.m.dx;
                wind.y = wind.y + wind.m.dy;

                if (wind.x == 0) {
                    wind.x = WIDTH - 2;
                } else if (wind.x == WIDTH - 1) {
                    wind.x = 1;
                }

                if (wind.y == 0) {
                    wind.y = HEIGHT - 2;
                } else if (wind.y == HEIGHT - 1) {
                    wind.y = 1;
                }
            }
        }

        public void print() {
            for (int y = 0; y < HEIGHT; y++) {
                for (int x = 0; x < WIDTH; x++) {

                    if (x == pos.x && y == pos.y) {
                        System.out.print("E");
                    } else if (isFree(x, y)) {
                        System.out.print(".");
                    } else if(x == 0 || x == (WIDTH-1) || y == 0 || y == HEIGHT-1) {
                        System.out.print("#");
                    } else {
                        System.out.print(count(x, y));
                    }

                }
                System.out.println();
            }
        }

        @Override
        public int hashCode() {
            return Objects.hash(pos, round);
        }

        @Override
        public boolean equals(Object obj) {
            if (this == obj)
                return true;
            if (obj == null)
                return false;
            if (getClass() != obj.getClass())
                return false;
            State other = (State) obj;
            return Objects.equals(pos, other.pos) && round == other.round;
        }
    }

    public static void main(String[] args) {
        step1();
    }

    public static int WIDTH = 0;
    public static int HEIGHT = 0;

    private static void step1() {
        List<Wind> winds = new ArrayList<>();

        try (Scanner in = new Scanner(A2022D24.class.getResourceAsStream("/res/i24.txt"))) {
            int y = 0;
            while (in.hasNext()) {
                String row = in.nextLine();

                for (int x = 0; x < row.length(); x++) {
                    final char d = row.charAt(x);

                    Move blizzard = Arrays.stream(Move.values()).filter(c -> {
                        return c.d == d;
                    }).findAny().orElse(null);

                    if(blizzard != null) {
                        Wind wind = new Wind(x, y);
                        wind.m = blizzard;
                        winds.add(wind);
                    }

                }
                WIDTH = row.length();
                y++;
            }

            HEIGHT = y;



            State state = new State();
            state.pos = new Point(1, 0);
            state.winds = winds;


            int round = 0;
            int targetX = WIDTH-2;
            int targetY = HEIGHT-1;
            state = foundSolution(state, targetX, targetY);

            state = foundSolution(state, 1, 0);
            state = foundSolution(state, targetX, targetY);
            System.out.println(state.round);
        }
    }

    private static State foundSolution(State start, int targetX, int targetY) {
        Set<State> previous = new HashSet<>();

        previous.add(start);
        Set<State> next = new HashSet<>(); 

        Set<State> tmp;
        State state;
        while(true) {
            System.out.println("States stack:" + previous.size() + " round:" + previous.iterator().next().round);
            next.clear();
            for(State s :previous) {
                if(s.pos.x == targetX && s.pos.y == targetY)  {
                    return s;

                }


                explore(next, s);
            }

            tmp = previous;
            previous = next;
            next = tmp;
        }
    }

    private static void explore(Set<State> next,  A2022D24.State state) {

        //state.print();
        state.moveWind();
        List<Move> moves = state.getAvailables();
        if(moves.size() == 0) {
            //System.out.println("empty");
        }

        for (Move move : moves) {
            State newState = new State();
            state.copyInto(newState);
            newState.pos.x += move.dx;
            newState.pos.y += move.dy;
            newState.round++;

            if (!newState.isFree(newState.pos.x, newState.pos.y)) {
                throw new RuntimeException(); 
            }

            next.add(newState);
        }

    }
}

  • # Dans l'ensemble, c'est plus simple que l'an dernier

    Posté par  . En réponse au message Avent du Code, jour 23. Évalué à 2.

    Dans l'ensemble, ils sont tous beaucoup plus simple que l'an dernier.

    Environ 1h40 après 12h de voiture + ma crève qui ne me lâche pas, on va dire que çà aurait pu être pire.

    Dans l'ensemble , il n'y a rien de compliqué aujourd'hui. Il faut juste conserver à l'esprit toutes les petites règles qui ne sont pas flag en gras dans la description.

    Résultat, j'ai perdu 30min à comprendre que quand il n'y a pas d'Elf autour. Il ne bouge pas.

    La deuxième partie, elle ne rajoute rien de dur, je m'attendais à une règle genre distance, ou un truc qui faisait exploser la volumétrie.

    Mais non rien, j'ai juste lancé mon programme pas du tout optimisé en me disant il va falloir que je trouve une opti.
    Je n'ai pas eu le temps de finir d'écrire la première opti que j'avais déjà la solution.

    1min20 pour 1014 round