+98004,50283

+98004,51502

+98073,51502

+98073,52727

+98144,52727

+98144,53937

+97953,53937

+97953,55168

+98003,55168

+98003,56406

+98033,56406

+98033,57473

+96926,57473

+96926,58748

+97199,58748

+97199,59926

+96895,59926

+96895,61220

+97084,61220

+97084,62314

+96426,62314

+96426,63395

+95789,63395

+95789,64490

+95244,64490

+95244,65829

+95432,65829

+95432,66934

+94907,66934

+94907,68050

+94423,68050

+94423,69341

+94345,69341

+94345,70156

+93192,70156

+93192,71485

+93153,71485

+93153,72568

+92590,72568

+92590,73702

+92113,73702

+92113,74741

+91467,74741

+91467,75567

+90483,75567

+90483,76688

+89978,76688

+89978,77537

+89068,77537

+89068,78372

+88163,78372

+88163,79469

+87609,79469

+87609,80612

+87093,80612

+87093,81578

+86346,81578

+86346,82422

+85463,82422

+85463,82939

+84244,82939

+84244,84206

+83804,84206

+83804,84848

+82735,84848

+82735,85434

+81634,85434

+81634,86745

+81168,86745

+81168,87730

+80395,87730

+80395,87950

+79018,87950

+79018,88564

+77968,88564

+77968,89681

+77272,89681

+77272,90032

+76045,90032

+76045,90883

+75148,90883

+75148,91125

+73882,91125

+73882,91934

+72952,91934

+72952,92557

+71910,92557

+71910,92993

+70774,92993

+70774,93784

+69804,93784

+69804,94065

+68601,94065

+68601,94737

+67564,94737

+67564,94644

+66234,94644

+66234,95260

+65172,95260

+65172,96308

+64228,96308

+64228,96569

+63027,96569

+63027,96815

+61826,96815

+61826,96343

+60465,96343

+60465,96835

+59336,96835

+59336,97723

+58262,97723

+58262,97006

+56916,97006

+56916,97227

+55731,97227

+55731,97435

+54540,97435

+54540,98266

+53388,98266

+53388,98391

+52167,98391

+52167,98195

+50936,98195

+50936,98172

+49715,98172

+49715,97959

+48500,97959

+48500,98135

+47273,98135

+47273,98219

+46040,98219

+46040,97295

+44907,97295

+44907,97942

+43605,97942

+43605,96967

+42520,96967

+42520,96937

+41300,96937

+41300,96652

+40124,96652

+40124,96994

+38801,96994

+38801,96419

+37687,96419

+37687,95965

+36552,95965

+36552,95897

+35300,95897

+35300,95312

+34211,95312

+34211,94929

+33056,94929

+33056,94007

+32118,94007

+32118,93804

+30894,93804

+30894,93729

+29593,93729

+29593,93046

+28568,93046

+28568,92453

+27503,92453

+27503,91601

+26586,91601

+26586,90840

+25632,90840

+25632,90635

+24336,90635

+24336,89546

+23599,89546

+23599,89479

+22173,89479

+22173,88691

+21234,88691

+21234,87455

+20651,87455

+20651,87191

+19306,87191

+19306,86273

+18485,86273

+18485,85089

+17918,85089

+17918,84736

+16587,84736

+16587,83568

+16032,83568

+16032,83102

+14760,83102

+14760,82116

+14026,82116

+14026,81313

+13084,81313

+13084,79817

+12987,79817

+12987,79115

+11922,79115

+11922,78148

+11187,78148

+11187,77151

+10493,77151

+10493,75950

+10112,75950

+10112,74905

+9511,74905

+9511,74201

+8326,74201

+8326,72904

+8152,72904

+8152,71838

+7581,71838

+7581,70676

+7210,70676

+7210,69798

+6230,69798

+6230,68607

+5921,68607

+5921,67692

+4935,67692

+4935,66370

+4983,66370

+4983,65240

+4534,65240

+4534,64208

+3759,64208

+3759,62870

+3992,62870

+3992,61715

+3622,61715

+3622,60663

+2780,60663

+2780,59343

+3127,59343

+3127,58209

+2581,58209

+2581,57040

+2155,57040

+2155,55761

+2518,55761

+2518,54592

+2022,54592

+2022,53344

+2362,53344

+2362,52146

+2079,52146

+2079,50925

+2365,50925

+2365,50265

+94901,50265

+94901,48488

+1659,48488

+1659,47308

+2494,47308

+2494,46043

+1812,46043

+1812,44875

+2401,44875

+2401,43591

+1950,43591

+1950,42377

+2134,42377

+2134,41191

+2472,41191

+2472,40153

+3483,40153

+3483,38963

+3684,38963

+3684,37617

+3317,37617

+3317,36454

+3697,36454

+3697,35377

+4342,35377

+4342,34263

+4837,34263

+4837,32955

+4800,32955

+4800,31869

+5379,31869

+5379,30923

+6262,30923

+6262,29782

+6675,29782

+6675,28650

+7119,28650

+7119,27415

+7379,27415

+7379,26415

+8095,26415

+8095,25406

+8781,25406

+8781,24145

+9061,24145

+9061,23300

+10005,23300

+10005,22154

+10494,22154

+10494,21597

+11796,21597

+11796,20131

+11881,20131

+11881,19735

+13328,19735

+13328,18722

+13998,18722

+13998,17795

+14776,17795

+14776,16811

+15496,16811

+15496,15841

+16243,15841

+16243,14681

+16822,14681

+16822,14162

+18004,14162

+18004,13340

+18903,13340

+18903,12715

+19963,12715

+19963,11815

+20802,11815

+20802,11108

+21793,11108

+21793,10828

+23078,10828

+23078,10062

+24016,10062

+24016,9070

+24823,9070

+24823,8392

+25837,8392

+25837,7547

+26764,7547

+26764,7731

+28238,7731

+28238,6379

+28922,6379

+28922,5921

+30062,5921

+30062,5661

+31282,5661

+31282,5137

+32386,5137

+32386,5118

+33678,5118

+33678,4277

+34673,4277

+34673,4403

+35989,4403

+35989,4090

+37156,4090

+37156,3656

+38292,3656

+38292,3559

+39512,3559

+39512,2594

+40549,2594

+40549,2472

+41771,2472

+41771,2323

+42984,2323

+42984,2689

+44258,2689

+44258,2443

+45448,2443

+45448,2139

+46639,2139

+46639,1555

+47830,1555

+47830,1845

+49064,1845

+49064,1634

+50286,1634

+50286,2188

+51494,2188

+51494,2386

+52697,2386

+52697,2595

+53892,2595

+53892,2621

+55101,2621

+55101,2661

+56313,2661

+56313,2728

+57528,2728

+57528,2364

+58828,2364

+58828,2818

+59987,2818

+59987,2845

+61236,2845

+61236,3836

+62244,3836

+62244,3791

+63518,3791

+63518,4250

+64651,4250

+64651,4284

+65928,4284

+65928,5346

+66839,5346

+66839,5849

+67939,5849

+67939,5650

+69343,5650

+69343,6127

+70473,6127

+70473,7026

+71396,7026

+71396,7311

+72621,7311

+72621,7898

+73695,7898

+73695,8360

+74844,8360

+74844,9323

+75689,9323

+75689,9834

+76813,9834

+76813,10909

+77552,10909

+77552,11764

+78426,11764

+78426,12198

+79619,12198

+79619,12720

+80766,12720

+80766,13911

+81353,13911

+81353,14300

+82639,14300

+82639,15444

+83238,15444

+83238,15925

+84480,15925

+84480,17167

+84951,17167

+84951,18280

+85528,18280

+85528,19271

+86225,19271

+86225,20163

+87036,20163

+87036,20724

+88286,20724

+88286,21775

+88917,21775

+88917,22924

+89395,22924

+89395,24077

+89844,24077

+89844,24888

+90823,24888

+90823,25962

+91392,25962

+91392,27042

+91944,27042

+91944,28174

+92391,28174

+92391,28956

+93550,28956

+93550,30107

+93978,30107

+93978,31501

+93820,31501

+93820,32387

+94861,32387

+94861,33531

+95288,33531

+95288,34727

+95560,34727

+95560,35758

+96349,35758

+96349,37174

+95847,37174

+95847,38217

+96640,38217

+96640,39523

+96391,39523

+96391,40646

+96922,40646

+96922,41796

+97381,41796

+97381,43019

+97440,43019

+97440,44222

+97609,44222

+97609,45404

+98016,45404

+98016,46605

+98352,46605

+98352,47838

+98266,47838

+98266,49062

+98278,49062

+98278,50283

+ let p = util::uints::<i64>(x)

+ .array_chunks::<2>()

+ .collect::<Vec<_>>();

+ let mut i = fimg::Image::<_, 1>::alloc(

+ p.iter().map(|[x, _]| *x).max().unwrap() as u32 / 12,

+ p.iter().map(|[_, x]| *x).max().unwrap() as u32 / 12,

+ );

+ i.points(

+ &p.iter()

+ .map(|[a, b]| (*a as i32 / 12, *b as i32 / 12))

+ .collect::<Vec<_>>(),

+ [255],

+ );

+ i.points(

+ &[

+ (98278 / 12, 50283 / 12),

+ (98278 / 12, 4250 / 12),

+ (63518 / 12, 4250 / 12),

+ (63518 / 12, 50283 / 12),

+ (98278 / 12, 50283 / 12),

+ ],

+ [129],

+ );

+ i.save("hm.png");

+ i.show();

+ return p

+ .into_iter()

+ .array_combinations()

+ .map_w(|z @ [[x1, y1], [x2, y2]]| {

+ // dbg!(z);

+ ((x2 - x1 - 1).abs() * (y2 - y1 - 1).abs())

+ })

+ .max_by_key(|x| x.1)

+ .unwrap();

+pub(crate) fn sq(p1: [i64; 3], p2: [i64; 3]) -> i64 {

+ (p1[0] - p2[0]).pow(2) + (p1[1] - p2[1]).pow(2) + (p1[2] - p2[2]).pow(2)

+}

+#[unsafe(no_mangle)]

+pub(crate) unsafe fn p2(x: &[u8]) -> i64 {

+ (281..955)

+ // let former = from_fn(|j| points[j][i] as i64);

+ // let (_dist, _retval) = (0..1000)

+ // .filter(|j| i != *j)

+ // .filter_map(|j| {

+ // let with: [i64; 3] = from_fn(|i| points[i][j] as i64);

+ // let d = sq(former, from_fn(|i| points[i][j] as i64)) as i64;

+ // // println!("{former:?} <-> {with:?}: {d}");

+ // Some((d, points[0][i] as i64 * points[0][j] as i64))

+ // })

+ // .min_by_key(|&(d, _)| d)

+ // .unwrap_or((i64::MAX, 0));

+ // dbg!(_dist);

+

+ let [_x, _y, _z] = from_fn(|j| points[j][i]);

+ let x = i32x8::splat(_x);

+ let y = i32x8::splat(_y);

+ let z = i32x8::splat(_z);

+ // result of min distance

+ let mut dist = i64x8::splat(i64::MAX);

+ // result of the multiply

+ let mut retval = Simd::splat(0);

+ let [(x_, xrest), (y_, yrest), (z_, zrest)] = {

+ [

+ points[0][25..905].as_chunks::<8>(),

+ points[1][25..905].as_chunks::<8>(),

+ points[2][25..905].as_chunks::<8>(),

+ ]

+ };

+ // let mut rmin = [i64::MAX; 16];

+ // let mut reduced = i64::MAX;

+ for (x_, y_, z_) in izip!(x_, y_, z_) {

+ let x_ = Simd::from_slice(x_);

+ let y_ = Simd::from_slice(y_);

+ let z_ = Simd::from_slice(z_);

+ let one = (x - x_).cast::<i64>();

+ let two = (y - y_).cast::<i64>();

+ let thr = (z - z_).cast::<i64>();

+ let d = one * one + two * two + thr * thr;

+ // let min = izip!(x_.to_array(), y_.to_array(), z_.to_array())

+ // .map(|(x, y, z)| {

+ // sq(

+ // [x as i64, y as i64, z as i64],

+ // [_x as i64, _y as i64, _z as i64],

+ // )

+ // })

+ // .collect_array::<16>()

+ // .unwrap();

+ // rmin = min

+ // .zip(rmin)

+ // .map(|(x, y)| if x.min(y) == 0 { y } else { x.min(y) });

+

+ // dbg!(d);

+ let m = d.simd_lt(dist) & d.simd_ne(Simd::splat(0));

+ // dbg!(d);

+ // reduced = reduced.min(m.select(d, Simd::splat(i64::MAX)).reduce_min());

+ // min_by_key ( distance )

+ dist = m.select(d, dist);

+ // println!("{rmin:?} {dist:?}");

+ // assert_eq!(rmin, dist.to_array());

+ // dbg!(dist);

+

+ // points[0][1] * points[1][0]

+ retval = m.select(x.cast::<i64>() * x_.cast::<i64>(), retval);

+ }

+ // dbg!(rmin, reduced);

+

+ // let (dist_, retval_) = izip!(xrest, yrest, zrest)

+ // .filter_map(|t| {

+ // let d = sq(

+ // [_x as i64, _y as i64, _z as i64],

+ // <[_; 3]>::from(t).map(|x| *x as i64),

+ // );

+ // Some((d, _x as i64 * *t.0 as i64))

+ // })

+ // // .chain(izip!(dist.to_array(), retval.to_array()))

+ // .min_by_key(|&(d, _)| d)

+ // .unwrap();

+ // dbg!(dist, retval, dist_, _retval);

+

+ // todo x8?

+ // let dist = dist

+ // .to_array()

+ // .into_iter()

+ // .zip(retval.to_array())

+ // .min_by_key(|x| x.0)

+ // .unwrap();

+ // let rest = retval;

+ // let (dist, retval) = izip!(xrest, yrest, zrest)

+ // .filter_map(|t| {

+ // let d = sq(

+ // [_x as i64, _y as i64, _z as i64],

+ // <[_; 3]>::from(t).map(|x| *x as i64),

+ // ) as i64;

+ // Some((d, _x as i64 * *t.0 as i64))

+ // })

+ // .chain(izip!(dist.to_array(), retval.to_array()))

+ // .filter(|(d, _)| *d != 0)

+ // .min_by_key(|&(d, _)| d)

+ // .unwrap();

+ // println!("{i}");

+ // assert_eq!(dist, _dist);

+ // assert_eq!(retval, _retval);

+ // println!("pass");

+ // (dist, retval)

+ .fold((-1, 0), |(_scdist, _scretval), (dist, retval)| {

+ // we do a lil maxxing

+ // eprintln!("dist = {dist:?}\nretval = {retval:?}\n_dist = {_dist:?}\n_retval = {_retval:?}");

+ let (scdist, scretval) = dist

+ .to_array()

+ .into_iter()

+ .zip(retval.to_array())

+ .min_by_key(|x| x.0)

+ .unwrap();

+ // eprintln!("min of new {scdist} {scretval}");

+ // let m = Simd::splat(dbg!(dist.reduce_min().max(scdist))).simd_ge(_dist);

+ // eprintln!("{} >= {_dist:?} {m:?}", dist.reduce_min());

+ // eprintln!("dmatched = {:?}",m.select(dist, Simd::splat(0)));

+ // eprintln!("rmatched = {:?}",m.select(retval, Simd::splat(0)));

+ // dbg!(real);

+

+ if scdist > _scdist {

+ (scdist, scretval)

+ } else {

+ (_scdist, _scretval)

+ }

+ // m.select(dist, _dist),

+ // m.select(retval, _retval),

+

+ // if dist > mxd {}

+ .1

+

+ // .reduce_min()

+

+pub(crate) const ISIZE: usize = include_bytes!("inp.txt").len();

+

+pub(crate) fn main() {

+ // dbg!(sq([75262, 24842, 97390], [69492, 23068, 98918]));

+ unsafe { println!("{:?}", p1(include_bytes!("../input_day_9"))) };

+

+ // unsafe { println!("{:?}", p2(include_bytes!("inp.txt"))) };

+ // unsafe { println!("{:?}", p2(include_bytes!("../1"))) }; // 3200955921

+ // unsafe { println!("{:?}", p2(include_bytes!("../2"))) }; // 8141888143

+ // unsafe { println!("{:?}", p2(include_bytes!("../3"))) }; // 8465902405

+pub(crate) fn benc(b: &mut test::Bencher) {