Opublikowane źródło

CH-J Tools

Przeglądaj katalogi i pliki dla konkretnego wydania aplikacji.

Pobierz źródło ZIP

CH-J / Server Manager 1704 pliki

0.1.2-beta Dodano: 8 lis 2026, 02:53 · Built: 7 lis 2026, 19:32

city.rs Dodano: Data niezanotowana 19,3 KB · 539 linie

Kod Pobierz plik PDF

1//! CityHash v1.1 (32/64/128) and FarmHash fingerprints (farmhashmk::Hash32,

2//! farmhashna::Hash64) over a random-access view, ported from the 0.1.0 code

3//! (`hashing/cityHash.js`, google/cityhash, MIT) and farmhashjs (Apache-2.0).

4//! The view reads the file lazily so arbitrarily large files never sit in memory.

6const K0: u64 = 0xc3a5c85c97cb3127;

7const K1: u64 = 0xb492b66fbe98f273;

8const K2: u64 = 0x9ae16a3b2f90404f;

9const C1: u32 = 0xcc9e2d51;

10const C2: u32 = 0x1b873593;

12/// Little-endian random access to the hashed input.

13pub trait View {

14 fn len(&self) -> usize;

15 fn byte(&mut self, offset: usize) -> u8;

16 fn u32(&mut self, offset: usize) -> u32;

17 fn u64(&mut self, offset: usize) -> u64;

18}

20pub struct SliceView<'a>(pub &'a [u8]);

22impl View for SliceView<'_> {

23 fn len(&self) -> usize {

24 self.0.len()

25 }

26 fn byte(&mut self, offset: usize) -> u8 {

27 self.0[offset]

28 }

29 fn u32(&mut self, offset: usize) -> u32 {

30 u32::from_le_bytes(self.0[offset..offset + 4].try_into().unwrap())

31 }

32 fn u64(&mut self, offset: usize) -> u64 {

33 u64::from_le_bytes(self.0[offset..offset + 8].try_into().unwrap())

34 }

35}

37#[inline]

38fn rot32(v: u32, s: u32) -> u32 {

39 v.rotate_right(s)

40}

41#[inline]

42fn rot64(v: u64, s: u32) -> u64 {

43 v.rotate_right(s)

44}

45#[inline]

46fn fmix(mut h: u32) -> u32 {

47 h ^= h >> 16;

48 h = h.wrapping_mul(0x85ebca6b);

49 h ^= h >> 13;

50 h = h.wrapping_mul(0xc2b2ae35);

51 h ^ (h >> 16)

52}

53#[inline]

54fn mur(mut a: u32, mut h: u32) -> u32 {

55 a = a.wrapping_mul(C1);

56 a = rot32(a, 17);

57 a = a.wrapping_mul(C2);

58 h ^= a;

59 h = rot32(h, 19);

60 h.wrapping_mul(5).wrapping_add(0xe6546b64)

61}

62#[inline]

63fn shift_mix(v: u64) -> u64 {

64 v ^ (v >> 47)

65}

66#[inline]

67fn hash_len16(u: u64, v: u64, mul: u64) -> u64 {

68 let mut a = (u ^ v).wrapping_mul(mul);

69 a ^= a >> 47;

70 let mut b = (v ^ a).wrapping_mul(mul);

71 b ^= b >> 47;

72 b.wrapping_mul(mul)

73}

74const KMUL: u64 = 0x9ddfea08eb382d69;

76fn weak_hash(view: &mut dyn View, offset: usize, mut a: u64, mut b: u64) -> (u64, u64) {

77 let w = view.u64(offset);

78 let x = view.u64(offset + 8);

79 let y = view.u64(offset + 16);

80 let z = view.u64(offset + 24);

81 a = a.wrapping_add(w);

82 b = rot64(b.wrapping_add(a).wrapping_add(z), 21);

83 let c = a;

84 a = a.wrapping_add(x).wrapping_add(y);

85 b = b.wrapping_add(rot64(a, 44));

86 (a.wrapping_add(z), b.wrapping_add(c))

87}

89#[inline]

90fn mix20(v: u32) -> u32 {

91 rot32(v.wrapping_mul(C1), 17).wrapping_mul(C2)

92}

94pub fn city32(view: &mut dyn View) -> u32 {

95 let len = view.len();

96 let l32 = len as u32;

97 if len <= 4 {

98 let (mut b, mut c) = (0u32, 9u32);

99 for i in 0..len {

100 let signed = view.byte(i) as i8 as i32 as u32;

101 b = b.wrapping_mul(C1).wrapping_add(signed);

102 c ^= b;

103 }

104 return fmix(mur(b, mur(l32, c)));

105 }

106 if len <= 12 {

107 let mut a = l32;

108 let mut b = l32.wrapping_mul(5);

109 let c = 9u32.wrapping_add(view.u32((len >> 1) & 4));

110 let d = b;

111 a = a.wrapping_add(view.u32(0));

112 b = b.wrapping_add(view.u32(len - 4));

113 return fmix(mur(c, mur(b, mur(a, d))));

114 }

115 if len <= 24 {

116 let a = view.u32((len >> 1) - 4);

117 let b = view.u32(4);

118 let c = view.u32(len - 8);

119 let d = view.u32(len >> 1);

120 let e = view.u32(0);

121 let f = view.u32(len - 4);

122 return fmix(mur(f, mur(e, mur(d, mur(c, mur(b, mur(a, l32)))))));

123 }

124 let mut h = l32;

125 let mut g = C1.wrapping_mul(h);

126 let mut f = g;

127 let t: Vec<u32> = [len - 4, len - 8, len - 16, len - 12, len - 20].iter().map(|o| mix20(view.u32(*o))).collect();

128 let step = |x: u32| rot32(x, 19).wrapping_mul(5).wrapping_add(0xe6546b64);

129 h ^= t[0];

130 h = step(h);

131 h ^= t[2];

132 h = step(h);

133 g ^= t[1];

134 g = step(g);

135 g ^= t[3];

136 g = step(g);

137 f = f.wrapping_add(t[4]);

138 f = step(f);

139 let mut offset = 0;

140 let mut iterations = (len - 1) / 20;

141 loop {

142 let a0 = mix20(view.u32(offset));

143 let a1 = view.u32(offset + 4);

144 let a2 = mix20(view.u32(offset + 8));

145 let a3 = mix20(view.u32(offset + 12));

146 let a4 = view.u32(offset + 16);

147 h ^= a0;

148 h = rot32(h, 18).wrapping_mul(5).wrapping_add(0xe6546b64);

149 f = f.wrapping_add(a1);

150 f = rot32(f, 19).wrapping_mul(C1);

151 g = g.wrapping_add(a2);

152 g = rot32(g, 18).wrapping_mul(5).wrapping_add(0xe6546b64);

153 h ^= a3.wrapping_add(a1);

154 h = rot32(h, 19).wrapping_mul(5).wrapping_add(0xe6546b64);

155 g ^= a4;

156 g = g.swap_bytes().wrapping_mul(5);

157 h = h.wrapping_add(a4.wrapping_mul(5)).swap_bytes();

158 f = f.wrapping_add(a0);

159 let old_f = f;

160 f = g;

161 g = h;

162 h = old_f;

163 offset += 20;

164 iterations -= 1;

165 if iterations == 0 {

166 break;

167 }

168 }

169 g = rot32(rot32(g, 11).wrapping_mul(C1), 17).wrapping_mul(C1);

170 f = rot32(rot32(f, 11).wrapping_mul(C1), 17).wrapping_mul(C1);

171 h = rot32(h.wrapping_add(g), 19);

172 h = h.wrapping_mul(5).wrapping_add(0xe6546b64);

173 h = rot32(h, 17).wrapping_mul(C1);

174 h = rot32(h.wrapping_add(f), 19);

175 h = h.wrapping_mul(5).wrapping_add(0xe6546b64);

176 rot32(h, 17).wrapping_mul(C1)

177}

178

179fn hash0to16(view: &mut dyn View, offset: usize, len: usize) -> u64 {

180 if len >= 8 {

181 let mul = K2.wrapping_add(len as u64 * 2);

182 let a = view.u64(offset).wrapping_add(K2);

183 let b = view.u64(offset + len - 8);

184 let c = rot64(b, 37).wrapping_mul(mul).wrapping_add(a);

185 let d = rot64(a, 25).wrapping_add(b).wrapping_mul(mul);

186 return hash_len16(c, d, mul);

187 }

188 if len >= 4 {

189 let mul = K2.wrapping_add(len as u64 * 2);

190 let a = view.u32(offset) as u64;

191 return hash_len16((len as u64).wrapping_add(a << 3), view.u32(offset + len - 4) as u64, mul);

192 }

193 if len > 0 {

194 let a = view.byte(offset) as u64;

195 let b = view.byte(offset + (len >> 1)) as u64;

196 let c = view.byte(offset + len - 1) as u64;

197 let y = a.wrapping_add(b << 8);

198 let z = (len as u64).wrapping_add(c << 2);

199 return shift_mix(y.wrapping_mul(K2) ^ z.wrapping_mul(K0)).wrapping_mul(K2);

200 }

201 K2

202}

203

204fn hash17to32(view: &mut dyn View, offset: usize, len: usize) -> u64 {

205 let mul = K2.wrapping_add(len as u64 * 2);

206 let a = view.u64(offset).wrapping_mul(K1);

207 let b = view.u64(offset + 8);

208 let c = view.u64(offset + len - 8).wrapping_mul(mul);

209 let d = view.u64(offset + len - 16).wrapping_mul(K2);

210 hash_len16(

211 rot64(a.wrapping_add(b), 43).wrapping_add(rot64(c, 30)).wrapping_add(d),

212 a.wrapping_add(rot64(b.wrapping_add(K2), 18)).wrapping_add(c),

213 mul,

214 )

215}

216

217fn city_hash33to64(view: &mut dyn View, offset: usize, len: usize) -> u64 {

218 let mul = K2.wrapping_add(len as u64 * 2);

219 let mut a = view.u64(offset).wrapping_mul(K2);

220 let mut b = view.u64(offset + 8);

221 let c = view.u64(offset + len - 24);

222 let d = view.u64(offset + len - 32);

223 let e = view.u64(offset + 16).wrapping_mul(K2);

224 let f = view.u64(offset + 24).wrapping_mul(9);

225 let g = view.u64(offset + len - 8);

226 let h = view.u64(offset + len - 16).wrapping_mul(mul);

227 let u = rot64(a.wrapping_add(g), 43).wrapping_add(rot64(b, 30).wrapping_add(c).wrapping_mul(9));

228 let v = (a.wrapping_add(g) ^ d).wrapping_add(f).wrapping_add(1);

229 let w = u.wrapping_add(v).wrapping_mul(mul).swap_bytes().wrapping_add(h);

230 let x = rot64(e.wrapping_add(f), 42).wrapping_add(c);

231 let y = v.wrapping_add(w).wrapping_mul(mul).swap_bytes().wrapping_add(g).wrapping_mul(mul);

232 let z = e.wrapping_add(f).wrapping_add(c);

233 a = x.wrapping_add(z).wrapping_mul(mul).wrapping_add(y).swap_bytes().wrapping_add(b);

234 b = shift_mix(z.wrapping_add(a).wrapping_mul(mul).wrapping_add(d).wrapping_add(h)).wrapping_mul(mul);

235 b.wrapping_add(x)

236}

237

238pub fn city64(view: &mut dyn View) -> u64 {

239 let len = view.len();

240 if len <= 16 {

241 return hash0to16(view, 0, len);

242 }

243 if len <= 32 {

244 return hash17to32(view, 0, len);

245 }

246 if len <= 64 {

247 return city_hash33to64(view, 0, len);

248 }

249 let l = len as u64;

250 let mut x = view.u64(len - 40);

251 let mut y = view.u64(len - 16).wrapping_add(view.u64(len - 56));

252 let mut z = hash_len16(view.u64(len - 48).wrapping_add(l), view.u64(len - 24), KMUL);

253 let mut v = weak_hash(view, len - 64, l, z);

254 let mut w = weak_hash(view, len - 32, y.wrapping_add(K1), x);

255 x = x.wrapping_mul(K1).wrapping_add(view.u64(0));

256 let mut remaining = (len - 1) & !63usize;

257 let mut offset = 0usize;

258 loop {

259 x = rot64(x.wrapping_add(y).wrapping_add(v.0).wrapping_add(view.u64(offset + 8)), 37).wrapping_mul(K1);

260 y = rot64(y.wrapping_add(v.1).wrapping_add(view.u64(offset + 48)), 42).wrapping_mul(K1);

261 x ^= w.1;

262 y = y.wrapping_add(v.0).wrapping_add(view.u64(offset + 40));

263 z = rot64(z.wrapping_add(w.0), 33).wrapping_mul(K1);

264 v = weak_hash(view, offset, v.1.wrapping_mul(K1), x.wrapping_add(w.0));

265 let seed_b = y.wrapping_add(view.u64(offset + 16));

266 w = weak_hash(view, offset + 32, z.wrapping_add(w.1), seed_b);

267 std::mem::swap(&mut z, &mut x);

268 offset += 64;

269 remaining -= 64;

270 if remaining == 0 {

271 break;

272 }

273 }

274 hash_len16(

275 hash_len16(v.0, w.0, KMUL).wrapping_add(shift_mix(y).wrapping_mul(K1)).wrapping_add(z),

276 hash_len16(v.1, w.1, KMUL).wrapping_add(x),

277 KMUL,

278 )

279}

280

281fn city_murmur(view: &mut dyn View, offset: usize, len: usize, seed: (u64, u64)) -> (u64, u64) {

282 let (mut a, mut b) = seed;

283 let mut c;

284 let mut d;

285 let mut position = offset;

286 let mut remaining = len as i64;

287 if len <= 16 {

288 a = shift_mix(a.wrapping_mul(K1)).wrapping_mul(K1);

289 c = b.wrapping_mul(K1).wrapping_add(hash0to16(view, position, len));

290 d = shift_mix(a.wrapping_add(if len >= 8 { view.u64(position) } else { c }));

291 } else {

292 c = hash_len16(view.u64(position + len - 8).wrapping_add(K1), a, KMUL);

293 d = hash_len16(b.wrapping_add(len as u64), c.wrapping_add(view.u64(position + len - 16)), KMUL);

294 a = a.wrapping_add(d);

295 loop {

296 a ^= shift_mix(view.u64(position).wrapping_mul(K1)).wrapping_mul(K1);

297 a = a.wrapping_mul(K1);

298 b ^= a;

299 c ^= shift_mix(view.u64(position + 8).wrapping_mul(K1)).wrapping_mul(K1);

300 c = c.wrapping_mul(K1);

301 d ^= c;

302 position += 16;

303 remaining -= 16;

304 if remaining <= 16 {

305 break;

306 }

307 }

308 }

309 a = hash_len16(a, c, KMUL);

310 b = hash_len16(d, b, KMUL);

311 (a ^ b, hash_len16(b, a, KMUL))

312}

313

314fn city128_with_seed(view: &mut dyn View, base: usize, len: usize, seed: (u64, u64)) -> (u64, u64) {

315 if len < 128 {

316 return city_murmur(view, base, len, seed);

317 }

318 let (mut x, mut y) = seed;

319 let mut z = (len as u64).wrapping_mul(K1);

320 let mut offset = base;

321 let mut remaining = len;

322 let mut v = (0u64, 0u64);

323 v.0 = rot64(y ^ K1, 49).wrapping_mul(K1).wrapping_add(view.u64(offset));

324 v.1 = rot64(v.0, 42).wrapping_mul(K1).wrapping_add(view.u64(offset + 8));

325

    let mut w = (rot64(y.wrapping_add(z), 35).wrapping_mul(K1).wrapping_add(x), rot64(x.wrapping_add(view.u64(offset + 88)), 53).wrapping_mul(K1));

326 loop {

327 for _ in 0..2 {

328 x = rot64(x.wrapping_add(y).wrapping_add(v.0).wrapping_add(view.u64(offset + 8)), 37).wrapping_mul(K1);

329 y = rot64(y.wrapping_add(v.1).wrapping_add(view.u64(offset + 48)), 42).wrapping_mul(K1);

330 x ^= w.1;

331 y = y.wrapping_add(v.0).wrapping_add(view.u64(offset + 40));

332 z = rot64(z.wrapping_add(w.0), 33).wrapping_mul(K1);

333 v = weak_hash(view, offset, v.1.wrapping_mul(K1), x.wrapping_add(w.0));

334 let seed_b = y.wrapping_add(view.u64(offset + 16));

335 w = weak_hash(view, offset + 32, z.wrapping_add(w.1), seed_b);

336 std::mem::swap(&mut z, &mut x);

337 offset += 64;

338 }

339 remaining -= 128;

340 if remaining < 128 {

341 break;

342 }

343 }

344 x = x.wrapping_add(rot64(v.0.wrapping_add(z), 49).wrapping_mul(K0));

345 y = y.wrapping_mul(K0).wrapping_add(rot64(w.1, 37));

346 z = z.wrapping_mul(K0).wrapping_add(rot64(w.0, 27));

347 w.0 = w.0.wrapping_mul(9);

348 v.0 = v.0.wrapping_mul(K0);

349 let mut done = 0;

350 while done < remaining {

351 done += 32;

352 y = rot64(x.wrapping_add(y), 42).wrapping_mul(K0).wrapping_add(v.1);

353 w.0 = w.0.wrapping_add(view.u64(offset + remaining - done + 16));

354 x = x.wrapping_mul(K0).wrapping_add(w.0);

355 z = z.wrapping_add(w.1).wrapping_add(view.u64(offset + remaining - done));

356 w.1 = w.1.wrapping_add(v.0);

357 v = weak_hash(view, offset + remaining - done, v.0.wrapping_add(z), v.1);

358 v.0 = v.0.wrapping_mul(K0);

359 }

360 x = hash_len16(x, v.0, KMUL);

361 y = hash_len16(y.wrapping_add(z), w.0, KMUL);

362

    (hash_len16(x.wrapping_add(v.1), w.1, KMUL).wrapping_add(y), hash_len16(x.wrapping_add(w.1), y.wrapping_add(v.1), KMUL))

363}

364

365pub fn city128(view: &mut dyn View) -> (u64, u64) {

366 let len = view.len();

367 if len >= 16 {

368 let seed = (view.u64(0), view.u64(8).wrapping_add(K0));

369 city128_with_seed(view, 16, len - 16, seed)

370 } else {

371 city128_with_seed(view, 0, len, (K0, K1))

372 }

373}

374

375/// 0.1.0 digest layout: high (second) word first, both big-endian.

376pub fn digest128(value: (u64, u64)) -> Vec<u8> {

377 [value.1.to_be_bytes(), value.0.to_be_bytes()].concat()

378}

379

380// --- FarmHash fingerprints ----------------------------------------------------------------------

381

382fn farm_mk_hash32(view: &mut dyn View) -> u32 {

383 let len = view.len();

384 let l32 = len as u32;

385 if len <= 4 {

386 return city32(view); // identical algorithm for 0..4 bytes (seed 0)

387 }

388 if len <= 12 {

389 let mut a = l32;

390 let mut b = l32.wrapping_mul(5);

391 let mut c = 9u32;

392 let d = b;

393 a = a.wrapping_add(view.u32(0));

394 b = b.wrapping_add(view.u32(len - 4));

395 c = c.wrapping_add(view.u32((len >> 1) & 4));

396 return fmix(mur(c, mur(b, mur(a, d))));

397 }

398 if len <= 24 {

399 let a = view.u32((len >> 1) - 4);

400 let b = view.u32(4);

401 let c = view.u32(len - 8);

402 let d = view.u32(len >> 1);

403 let e = view.u32(0);

404 let f = view.u32(len - 4);

405 let mut h = d.wrapping_mul(C1).wrapping_add(l32);

406 let mut a2 = rot32(a, 12).wrapping_add(f);

407 h = mur(c, h).wrapping_add(a2);

408 a2 = rot32(a2, 3).wrapping_add(c);

409 h = mur(e, h).wrapping_add(a2);

410 a2 = rot32(a2.wrapping_add(f), 12).wrapping_add(d);

411 h = mur(b, h).wrapping_add(a2);

412 return fmix(h);

413 }

414 let mut h = l32;

415 let mut g = C1.wrapping_mul(l32);

416 let mut f = g;

417 let a0 = mix20(view.u32(len - 4));

418 let a1 = mix20(view.u32(len - 8));

419 let a2 = mix20(view.u32(len - 16));

420 let a3 = mix20(view.u32(len - 12));

421 let a4 = mix20(view.u32(len - 20));

422 let step = |x: u32| rot32(x, 19).wrapping_mul(5).wrapping_add(0xe6546b64);

423 h ^= a0;

424 h = step(h);

425 h ^= a2;

426 h = step(h);

427 g ^= a1;

428 g = step(g);

429 g ^= a3;

430 g = step(g);

431 f = f.wrapping_add(a4);

432 f = rot32(f, 19).wrapping_add(113);

433 let mut iterations = (len - 1) / 20;

434 let mut offset = 0;

435 loop {

436 let a = view.u32(offset);

437 let b = view.u32(offset + 4);

438 let c = view.u32(offset + 8);

439 let d = view.u32(offset + 12);

440 let e = view.u32(offset + 16);

441 h = h.wrapping_add(a);

442 g = g.wrapping_add(b);

443 f = f.wrapping_add(c);

444 h = mur(d, h).wrapping_add(e);

445 g = mur(c, g).wrapping_add(a);

446 f = mur(b.wrapping_add(e.wrapping_mul(C1)), f).wrapping_add(d);

447 f = f.wrapping_add(g);

448 g = g.wrapping_add(f);

449 offset += 20;

450 iterations -= 1;

451 if iterations == 0 {

452 break;

453 }

454 }

455 g = rot32(rot32(g, 11).wrapping_mul(C1), 17).wrapping_mul(C1);

456 f = rot32(rot32(f, 11).wrapping_mul(C1), 17).wrapping_mul(C1);

457 h = rot32(h.wrapping_add(g), 19);

458 h = h.wrapping_mul(5).wrapping_add(0xe6546b64);

459 h = rot32(h, 17).wrapping_mul(C1);

460 h = rot32(h.wrapping_add(f), 19);

461 h = h.wrapping_mul(5).wrapping_add(0xe6546b64);

462 rot32(h, 17).wrapping_mul(C1)

463}

464

465pub fn farm32(view: &mut dyn View) -> u32 {

466 farm_mk_hash32(view)

467}

468

469fn na_hash33to64(view: &mut dyn View, len: usize) -> u64 {

470 let mul = K2.wrapping_add(len as u64 * 2);

471 let a = view.u64(0).wrapping_mul(K2);

472 let b = view.u64(8);

473 let c = view.u64(len - 8).wrapping_mul(mul);

474 let d = view.u64(len - 16).wrapping_mul(K2);

475 let y = rot64(a.wrapping_add(b), 43).wrapping_add(rot64(c, 30)).wrapping_add(d);

476 let z = hash_len16(y, a.wrapping_add(rot64(b.wrapping_add(K2), 18)).wrapping_add(c), mul);

477 let e = view.u64(16).wrapping_mul(mul);

478 let f = view.u64(24);

479 let g = y.wrapping_add(view.u64(len - 32)).wrapping_mul(mul);

480 let h = z.wrapping_add(view.u64(len - 24)).wrapping_mul(mul);

481

    hash_len16(rot64(e.wrapping_add(f), 43).wrapping_add(rot64(g, 30)).wrapping_add(h), e.wrapping_add(rot64(f.wrapping_add(a), 18)).wrapping_add(g), mul)

482}

483

484pub fn farm64(view: &mut dyn View) -> u64 {

485 let len = view.len();

486 if len <= 16 {

487 return hash0to16(view, 0, len);

488 }

489 if len <= 32 {

490 return hash17to32(view, 0, len);

491 }

492 if len <= 64 {

493 return na_hash33to64(view, len);

494 }

495 let seed = 81u64;

496 let mut x = seed;

497 let mut y = seed.wrapping_mul(K1).wrapping_add(113);

498 let mut z = shift_mix(y.wrapping_mul(K2).wrapping_add(113)).wrapping_mul(K2);

499 let mut v = (0u64, 0u64);

500 let mut w = (0u64, 0u64);

501 x = x.wrapping_mul(K2).wrapping_add(view.u64(0));

502 let end = ((len - 1) / 64) * 64;

503 let last64 = end + ((len - 1) & 63) - 63;

504 let mut idx = 0;

505 loop {

506 x = rot64(x.wrapping_add(y).wrapping_add(v.0).wrapping_add(view.u64(idx + 8)), 37).wrapping_mul(K1);

507 y = rot64(y.wrapping_add(v.1).wrapping_add(view.u64(idx + 48)), 42).wrapping_mul(K1);

508 x ^= w.1;

509 y = y.wrapping_add(v.0).wrapping_add(view.u64(idx + 40));

510 z = rot64(z.wrapping_add(w.0), 33).wrapping_mul(K1);

511 v = weak_hash(view, idx, v.1.wrapping_mul(K1), x.wrapping_add(w.0));

512 let seed_b = y.wrapping_add(view.u64(idx + 16));

513 w = weak_hash(view, idx + 32, z.wrapping_add(w.1), seed_b);

514 std::mem::swap(&mut z, &mut x);

515 idx += 64;

516 if idx == end {

517 break;

518 }

519 }

520 let mul = K1.wrapping_add((z & 0xff) << 1);

521 idx = last64;

522 w.0 = w.0.wrapping_add(((len - 1) & 63) as u64);

523 v.0 = v.0.wrapping_add(w.0);

524 w.0 = w.0.wrapping_add(v.0);

525 x = rot64(x.wrapping_add(y).wrapping_add(v.0).wrapping_add(view.u64(idx + 8)), 37).wrapping_mul(mul);

526 y = rot64(y.wrapping_add(v.1).wrapping_add(view.u64(idx + 48)), 42).wrapping_mul(mul);

527 x ^= w.1.wrapping_mul(9);

528 y = y.wrapping_add(v.0.wrapping_mul(9)).wrapping_add(view.u64(idx + 40));

529 z = rot64(z.wrapping_add(w.0), 33).wrapping_mul(mul);

530 v = weak_hash(view, idx, v.1.wrapping_mul(mul), x.wrapping_add(w.0));

531 let seed_b = y.wrapping_add(view.u64(idx + 16));

532 w = weak_hash(view, idx + 32, z.wrapping_add(w.1), seed_b);

533 std::mem::swap(&mut z, &mut x);

534 hash_len16(

535 hash_len16(v.0, w.0, mul).wrapping_add(shift_mix(y).wrapping_mul(K0)).wrapping_add(z),

536 hash_len16(v.1, w.1, mul).wrapping_add(x),

537 mul,

538 )

539}

540

SHA-256

5985237d7a7e4c80903814941ee3515edb19dae615a8c4bc3a49afb5396a007c

CH-J Proprietary Software License 1.14 · Źródło jest dostarczane pod CH-J Proprietary Software License 1.14. Jego dostępność nie zmienia warunków licencji ani nie przyznaje dodatkowych praw.

SHA-256

ac8fe790f4ba60fc098f8c985fc2656cfcc6cdc21fb34b30e308a2b54e62258f