laumann/ani - Change YFBKBUKBX3JB7OCB4D3ZKSLWTP6QWZ36HEE5GZROJE55RK33MZCAC

change: rename binstat -> bc

The variable "binstat" didn't make a lot of sense, it was a leftover from when the bincode struct was named something like "bincode state".

Created by laumann on July 17, 2023

YFBKBUKBX3JB7OCB4D3ZKSLWTP6QWZ36HEE5GZROJE55RK33MZCAC

Dependencies

In channels

main

Change contents

Replacement in change.c at line 43 [6.1047]
B:BD[6.1587] → [7.2449:2474]
```
	struct bincode binstat;
```
[6.1587]
[6.1603]
```
	struct bincode bc;
```

Replacement in change.c at line 57 [6.1047]

B:BD[8.33] → [8.33:84]

	binstat.buf = buf;
	binstat.avail = OFFSETS_SIZE;

[8.33]

[9.727]

	bc.buf = buf;
	bc.avail = OFFSETS_SIZE;

Replacement in change.c at line 60 [6.1047]

B:BD[9.728] → [8.85:400]

	off->version = bincode_getu64(&binstat);
	off->hashed_len = bincode_getu64(&binstat);
	off->unhashed_off = bincode_getu64(&binstat);
	off->unhashed_len = bincode_getu64(&binstat);
	off->contents_off = bincode_getu64(&binstat);
	off->contents_len = bincode_getu64(&binstat);
	off->total = bincode_getu64(&binstat);

[9.728]

[6.2183]

	off->version = bincode_getu64(&bc);
	off->hashed_len = bincode_getu64(&bc);
	off->unhashed_off = bincode_getu64(&bc);
	off->unhashed_len = bincode_getu64(&bc);
	off->contents_off = bincode_getu64(&bc);
	off->contents_len = bincode_getu64(&bc);
	off->total = bincode_getu64(&bc);

Replacement in change.c at line 118 [6.1047]

B:BD[10.15] → [7.2475:2548]

change_readhash(struct bincode *binstat, uint8_t *dest, uint8_t variant)

[10.15]

[10.81]

change_readhash(struct bincode *bc, uint8_t *dest, uint8_t variant)

Replacement in change.c at line 122 [6.1047]

B:BD[10.122] → [10.122:171]

		bincode_getbytes(binstat, dest, BLAKE3_BYTES);

[10.122]

[10.171]

		bincode_getbytes(bc, dest, BLAKE3_BYTES);

Replacement in change.c at line 133 [6.1047]

B:BD[11.988] → [7.2549:2622]

change_decode_hashlist(struct bincode *binstat, struct hashlist *target)

[11.988]

[12.86]

change_decode_hashlist(struct bincode *bc, struct hashlist *target)

Replacement in change.c at line 138 [6.1047]
B:BD[12.110] → [12.110:142]
```
	len = bincode_getu64(binstat);
```
[12.110]
[12.142]
```
	len = bincode_getu64(bc);
```

Replacement in change.c at line 143 [6.1047]

B:BD[12.255] → [13.64:129]

		target->entries[i].variant = (uint8_t)bincode_getu32(binstat);

[12.255]

[10.305]

		target->entries[i].variant = (uint8_t)bincode_getu32(bc);

Replacement in change.c at line 145 [6.1047]

B:BD[10.324] → [10.324:392]

			binstat, target->entries[i].bytes,
			target->entries[i].variant

[10.324]

[10.392]

			bc, target->entries[i].bytes, target->entries[i].variant

Replacement in change.c at line 151 [6.1047]

B:BD[11.1081] → [7.2679:2749]

change_decode_position(struct bincode *binstat, struct position *pos)

[11.1081]

[14.2311]

change_decode_position(struct bincode *bc, struct position *pos)

Replacement in change.c at line 153 [6.1047]

B:BD[14.2381] → [14.2381:2412]

B:BD[14.2412] → [11.1138:1196]

	if (bincode_getu8(binstat)) {
		pos->change.variant = (uint8_t)bincode_getu32(binstat);

[14.2313]

[10.398]

	if (bincode_getu8(bc)) {
		pos->change.variant = (uint8_t)bincode_getu32(bc);

Replacement in change.c at line 156 [6.1047]

B:BD[10.417] → [10.417:483]

			binstat, (uint8_t *)&pos->change.bytes,
			pos->change.variant

[10.417]

[10.483]

			bc, (uint8_t *)&pos->change.bytes, pos->change.variant

Replacement in change.c at line 159 [6.1047]
B:BD[11.1378] → [11.1378:1415]
```
	pos->pos = bincode_getu64(binstat);
```
[11.1378]
[11.1415]
```
	pos->pos = bincode_getu64(bc);
```

Replacement in change.c at line 163 [6.1047]

B:BD[11.1430] → [7.2750:2814]

change_decode_vertex(struct bincode *binstat, struct vertex *v)

[11.1430]

[11.1480]

change_decode_vertex(struct bincode *bc, struct vertex *v)

Replacement in change.c at line 169 [6.1047]
B:BD[11.1517] → [11.1517:1559]
```
	uint8_t ishash = bincode_getu8(binstat);
```
[11.1517]
[11.1559]
```
	uint8_t ishash = bincode_getu8(bc);
```

Replacement in change.c at line 171 [6.1047]

B:BD[11.1574] → [11.1574:1626]

B:BD[11.1626] → [10.489:556]

		hash->variant = (uint8_t)bincode_getu32(binstat);
		change_readhash(binstat, (uint8_t *)hash->bytes, hash->variant);

[11.1574]

[11.1734]

		hash->variant = (uint8_t)bincode_getu32(bc);
		change_readhash(bc, (uint8_t *)hash->bytes, hash->variant);

Replacement in change.c at line 174 [6.1047]

B:BD[11.1737] → [11.1737:1809]

	v->start = bincode_getu64(binstat);
	v->end = bincode_getu64(binstat);

[11.1737]

[14.2789]

	v->start = bincode_getu64(bc);
	v->end = bincode_getu64(bc);

Replacement in change.c at line 179 [6.1047]

B:BD[11.1955] → [7.2836:2907]

change_decode_introducedby(struct bincode *binstat, struct hash *hash)

[11.1955]

[14.2850]

change_decode_introducedby(struct bincode *bc, struct hash *hash)

Replacement in change.c at line 183 [6.1047]
B:BD[14.2878] → [11.2031:2065]
```
	ishash = bincode_getu8(binstat);
```
[14.2878]
[11.2065]
```
	ishash = bincode_getu8(bc);
```

Replacement in change.c at line 185 [6.1047]

B:BD[11.2080] → [11.2080:2132]

B:BD[11.2132] → [10.557:624]

		hash->variant = (uint8_t)bincode_getu32(binstat);
		change_readhash(binstat, (uint8_t *)hash->bytes, hash->variant);

[11.2080]

[11.2460]

		hash->variant = (uint8_t)bincode_getu32(bc);
		change_readhash(bc, (uint8_t *)hash->bytes, hash->variant);

Replacement in change.c at line 191 [6.1047]

B:BD[11.2477] → [7.2908:2974]

change_decode_newedge(struct bincode *binstat, struct edge *edge)

[11.2477]

[11.2529]

change_decode_newedge(struct bincode *bc, struct edge *edge)

Replacement in change.c at line 193 [6.1047]

B:BD[11.2531] → [11.2531:2611]

	edge->previous = bincode_getu8(binstat);
	edge->flag = bincode_getu8(binstat);

[11.2531]

[11.2679]

	edge->previous = bincode_getu8(bc);
	edge->flag = bincode_getu8(bc);

Replacement in change.c at line 196 [6.1047]

B:BD[11.2680] → [11.2680:2727]

B:BD[11.2728] → [11.2728:2771]

B:BD[11.2772] → [11.2772:2831]

	change_decode_position(binstat, &edge->from);
	change_decode_vertex(binstat, &edge->to);
	change_decode_introducedby(binstat, &edge->introducedby);

[11.2680]

[11.2831]

	change_decode_position(bc, &edge->from);
	change_decode_vertex(bc, &edge->to);
	change_decode_introducedby(bc, &edge->introducedby);

Replacement in change.c at line 202 [6.1047]

B:BD[11.2846] → [7.2975:3057]

change_decode_positionlist(struct bincode *binstat, struct positionlist *poslist)

[11.2846]

[11.2914]

change_decode_positionlist(struct bincode *bc, struct positionlist *poslist)

Replacement in change.c at line 207 [6.1047]
B:BD[14.3193] → [11.2938:2985]
```
	poslist->len = len = bincode_getu64(binstat);
```
[14.3193]
[11.2985]
```
	poslist->len = len = bincode_getu64(bc);
```

Replacement in change.c at line 211 [6.1047]

B:BD[11.3075] → [11.3075:3127]

		change_decode_position(binstat, &poslist->first);

[11.3075]

[11.3127]

		change_decode_position(bc, &poslist->first);

Replacement in change.c at line 213 [6.1047]

B:BD[11.3159] → [11.3159:3217]

			change_decode_position(binstat, &poslist->entries[i]);

[11.3159]

[11.3217]

			change_decode_position(bc, &poslist->entries[i]);

Replacement in change.c at line 218 [6.1047]

B:BD[11.3233] → [7.3126:3204]

change_decode_newvertex(struct bincode *binstat, struct newvertex *newvertex)

[11.3233]

[14.3319]

change_decode_newvertex(struct bincode *bc, struct newvertex *newvertex)

Replacement in change.c at line 222 [6.1047]

B:BD[11.3451] → [11.3451:3575]

	change_decode_positionlist(binstat, &newvertex->upcontext);
	change_decode_positionlist(binstat, &newvertex->downcontext);

[11.3418]

[11.3575]

	change_decode_positionlist(bc, &newvertex->upcontext);
	change_decode_positionlist(bc, &newvertex->downcontext);

Replacement in change.c at line 225 [6.1047]

B:BD[11.3576] → [11.3576:3707]

	newvertex->flag = bincode_getu8(binstat);
	newvertex->start = bincode_getu64(binstat);
	newvertex->end = bincode_getu64(binstat);

[11.3576]

[11.3707]

	newvertex->flag = bincode_getu8(bc);
	newvertex->start = bincode_getu64(bc);
	newvertex->end = bincode_getu64(bc);

Replacement in change.c at line 229 [6.1047]

B:BD[11.3708] → [11.3708:3761]

	change_decode_position(binstat, &newvertex->inode);

[11.3708]

[11.3761]

	change_decode_position(bc, &newvertex->inode);

Replacement in change.c at line 233 [6.1047]

B:BD[11.3776] → [7.3205:3277]

change_decode_edgemap(struct bincode *binstat, struct edgemap *edgemap)

[11.3776]

[11.3825]

change_decode_edgemap(struct bincode *bc, struct edgemap *edgemap)

Replacement in change.c at line 237 [6.1047]

B:BD[15.72] → [15.72:125]

	edgemap->edges.len = len = bincode_getu64(binstat);

[15.72]

[7.3278]

	edgemap->edges.len = len = bincode_getu64(bc);

Replacement in change.c at line 240 [6.1047]

B:BD[15.209] → [15.209:271]

		change_decode_newedge(binstat, &edgemap->edges.entries[i]);

[15.209]

[15.271]

		change_decode_newedge(bc, &edgemap->edges.entries[i]);

Replacement in change.c at line 243 [6.1047]

B:BD[15.287] → [15.287:338]

	change_decode_position(binstat, &edgemap->inode);

[15.287]

[15.338]

	change_decode_position(bc, &edgemap->inode);

Replacement in change.c at line 247 [6.1047]

B:BD[15.353] → [7.3341:3404]

change_decode_atom(struct bincode *binstat, struct atom *atom)

[15.353]

[15.402]

change_decode_atom(struct bincode *bc, struct atom *atom)

Replacement in change.c at line 251 [6.1047]
B:BD[2.14] → [2.14:44]
```
	x = bincode_getu32(binstat);
```
[2.14]
[2.44]
```
	x = bincode_getu32(bc);
```

Replacement in change.c at line 255 [6.1047]

B:BD[11.3868] → [11.3868:3922]

		change_decode_newvertex(binstat, &atom->newvertex);

[11.3868]

[14.3439]

		change_decode_newvertex(bc, &atom->newvertex);

Replacement in change.c at line 260 [6.1047]

B:BD[11.3952] → [15.405:455]

		change_decode_edgemap(binstat, &atom->edgemap);

[11.3952]

[14.3721]

		change_decode_edgemap(bc, &atom->edgemap);

Replacement in change.c at line 268 [6.1047]

B:BD[11.4370] → [7.3405:3471]

change_decode_local(struct bincode *binstat, struct local *local)

[11.4370]

[11.4422]

change_decode_local(struct bincode *bc, struct local *local)

Replacement in change.c at line 272 [6.1047]

B:BD[11.4440] → [11.4440:4557]

	len = bincode_getu64(binstat);
	local->path = bincode_getstr(binstat, len);
	local->line = bincode_getu64(binstat);

[11.4440]

[11.4557]

	len = bincode_getu64(bc);
	local->path = bincode_getstr(bc, len);
	local->line = bincode_getu64(bc);

Replacement in change.c at line 278 [6.1047]

B:BD[11.4572] → [7.3472:3537]

change_decode_encoding(struct bincode *binstat, char **encoding)

[11.4572]

[11.4630]

change_decode_encoding(struct bincode *bc, char **encoding)

Replacement in change.c at line 281 [6.1047]

B:BD[11.4700] → [11.4700:4817]

	if (bincode_getu8(binstat)) {
		uint64_t len = bincode_getu64(binstat);
		*encoding = bincode_getstr(binstat, len);

[11.4700]

[14.3751]

	if (bincode_getu8(bc)) {
		uint64_t len = bincode_getu64(bc);
		*encoding = bincode_getstr(bc, len);

Replacement in change.c at line 291 [6.1047]

B:BD[11.4830] → [7.3538:3606]

change_decode_hunks(struct bincode *binstat, struct hashed *hashed)

[11.4830]

[14.3853]

change_decode_hunks(struct bincode *bc, struct hashed *hashed)

Replacement in change.c at line 296 [6.1047]
B:BD[14.3879] → [14.3879:3911]
```
	len = bincode_getu64(binstat);
```
[14.3879]
[11.4885]
```
	len = bincode_getu64(bc);
```
Replacement in change.c at line 301 [6.1047]
∅:D[7.3683] → [11.4975:5020]
B:BD[11.4975] → [11.4975:5020]
```
		bhunk->hunktype = bincode_getu32(binstat);
```
[7.3683]
[14.4062]
```
		bhunk->hunktype = bincode_getu32(bc);
```
Replacement in change.c at line 307 [6.1047]
B:BD[11.5212] → [11.5212:5245]
```
				binstat, &bhunk->edit.change
```
[11.5212]
[11.5245]
```
				bc, &bhunk->edit.change
```

Replacement in change.c at line 309 [6.1047]

B:BD[11.5274] → [11.5274:5386]

			change_decode_local(binstat, &bhunk->edit.local);
			change_decode_encoding(binstat, &bhunk->edit.encoding);

[11.5274]

[14.4305]

			change_decode_local(bc, &bhunk->edit.local);
			change_decode_encoding(bc, &bhunk->edit.encoding);

Replacement in change.c at line 313 [6.1047]

B:BD[14.4335] → [16.250:513]

∅:D[16.513] → [14.4436:4442]

B:BD[14.4436] → [14.4436:4442]

			change_decode_atom(binstat, &bhunk->replacement.change);
			change_decode_atom(
				binstat, &bhunk->replacement.replacement
			);
			change_decode_local(binstat, &bhunk->replacement.local);
			change_decode_encoding(
				binstat, &bhunk->replacement.encoding
			);

[14.4335]

[17.0]

			change_decode_atom(bc, &bhunk->replacement.change);
			change_decode_atom(bc, &bhunk->replacement.replacement);
			change_decode_local(bc, &bhunk->replacement.local);
			change_decode_encoding(bc, &bhunk->replacement.encoding);

Replacement in change.c at line 319 [6.1047]

B:BD[17.27] → [17.27:334]

B:BD[17.334] → [4.0:71]

			change_decode_atom(binstat, &bhunk->fileadd.addname);
			change_decode_atom(binstat, &bhunk->fileadd.addinode);
			if (bincode_getu8(binstat))
				change_decode_atom(
					binstat, &bhunk->fileadd.contents
				);
			slen = bincode_getu64(binstat);
			bhunk->fileadd.path = bincode_getstr(binstat, slen);
			change_decode_encoding(
				binstat, &bhunk->fileadd.encoding
			);

[17.27]

[12.583]

			change_decode_atom(bc, &bhunk->fileadd.addname);
			change_decode_atom(bc, &bhunk->fileadd.addinode);
			if (bincode_getu8(bc))
				change_decode_atom(bc, &bhunk->fileadd.contents);
			slen = bincode_getu64(bc);
			bhunk->fileadd.path = bincode_getstr(bc, slen);
			change_decode_encoding(bc, &bhunk->fileadd.encoding);

Replacement in change.c at line 328 [6.1047]

B:BD[18.242] → [18.242:442]

			change_decode_atom(binstat, &bhunk->filemove.del);
			change_decode_atom(binstat, &bhunk->filemove.add);
			slen = bincode_getu64(binstat);
			bhunk->filemove.path = bincode_getstr(binstat, slen);

[18.242]

[19.0]

			change_decode_atom(bc, &bhunk->filemove.del);
			change_decode_atom(bc, &bhunk->filemove.add);
			slen = bincode_getu64(bc);
			bhunk->filemove.path = bincode_getstr(bc, slen);

Replacement in change.c at line 334 [6.1047]

B:BD[19.27] → [19.27:183]

			change_decode_atom(binstat, &bhunk->filedel.del);
			if (bincode_getu8(binstat)) {
				change_decode_atom(
					binstat, &bhunk->filedel.contents
				);

[19.27]

[19.183]

			change_decode_atom(bc, &bhunk->filedel.del);
			if (bincode_getu8(bc)) {
				change_decode_atom(bc, &bhunk->filedel.contents);

Replacement in change.c at line 338 [6.1047]

B:BD[19.188] → [19.188:344]

B:BD[19.344] → [20.52:58]

			slen = bincode_getu64(binstat);
			bhunk->filedel.path = bincode_getstr(binstat, slen);
			change_decode_encoding(
				binstat, &bhunk->filedel.encoding
			);

[19.188]

[20.58]

			slen = bincode_getu64(bc);
			bhunk->filedel.path = bincode_getstr(bc, slen);
			change_decode_encoding(bc, &bhunk->filedel.encoding);

Replacement in change.c at line 343 [6.1047]

B:BD[20.87] → [20.87:175]

			change_decode_atom(binstat, &bhunk->fileundel.undel);
			if (bincode_getu8(binstat))

[20.87]

[20.175]

			change_decode_atom(bc, &bhunk->fileundel.undel);
			if (bincode_getu8(bc))

Replacement in change.c at line 346 [6.1047]
B:BD[20.199] → [20.199:240]
```
					binstat, &bhunk->fileundel.contents
```
[20.199]
[20.240]
```
					bc, &bhunk->fileundel.contents
```

Replacement in change.c at line 348 [6.1047]

B:BD[20.247] → [20.247:407]

B:BD[20.407] → [21.252:258]

			slen = bincode_getu64(binstat);
			bhunk->fileundel.path = bincode_getstr(binstat, slen);
			change_decode_encoding(
				binstat, &bhunk->fileundel.encoding
			);

[20.247]

[21.258]

			slen = bincode_getu64(bc);
			bhunk->fileundel.path = bincode_getstr(bc, slen);
			change_decode_encoding(bc, &bhunk->fileundel.encoding);

Replacement in change.c at line 354 [6.1047]

B:BD[21.320] → [21.320:367]

				binstat, &bhunk->solveorderconflict.change

[21.320]

[21.367]

				bc, &bhunk->solveorderconflict.change

Replacement in change.c at line 357 [6.1047]

B:BD[21.397] → [21.397:443]

				binstat, &bhunk->solveorderconflict.local

[21.397]

[21.443]

				bc, &bhunk->solveorderconflict.local

Replacement in change.c at line 362 [6.1047]

B:BD[21.513] → [21.513:562]

				binstat, &bhunk->unsolveorderconflict.change

[21.513]

[21.562]

				bc, &bhunk->unsolveorderconflict.change

Replacement in change.c at line 365 [6.1047]

B:BD[21.592] → [21.592:640]

				binstat, &bhunk->unsolveorderconflict.local

[21.592]

[22.222]

				bc, &bhunk->unsolveorderconflict.local

Replacement in change.c at line 369 [6.1047]

B:BD[22.266] → [22.266:374]

			change_decode_atom(
				binstat, &bhunk->solvenameconflict.name
			);
			slen = bincode_getu64(binstat);

[22.266]

[22.374]

			change_decode_atom(bc, &bhunk->solvenameconflict.name);
			slen = bincode_getu64(bc);

Replacement in change.c at line 372 [6.1047]
B:BD[22.409] → [22.409:444]
```
				bincode_getstr(binstat, slen);
```
[22.409]
[22.444]
```
				bincode_getstr(bc, slen);
```
Replacement in change.c at line 375 [6.1047]
B:BD[22.484] → [22.484:553]
∅:D[20.407] → [19.344:350]
∅:D[22.553] → [19.344:350]
∅:D[21.640] → [19.344:350]
B:BD[19.344] → [19.344:350]
B:BD[19.350] → [22.554:589]
```
			change_decode_atom(
				binstat, &bhunk->unsolvenameconflict.name
			);
			slen = bincode_getu64(binstat);
```
[22.484]
[22.589]
```
			change_decode_atom(bc, &bhunk->unsolvenameconflict.name);
			slen = bincode_getu64(bc);
```
Replacement in change.c at line 378 [6.1047]
B:BD[22.626] → [22.626:661]
```
				bincode_getstr(binstat, slen);
```
[22.626]
[5.306]
```
				bincode_getstr(bc, slen);
```

Replacement in change.c at line 381 [6.1047]

B:BD[5.342] → [5.342:490]

			change_decode_atom(
				binstat, &bhunk->resurrectzombies.change
			);
			change_decode_local(
				binstat, &bhunk->resurrectzombies.local
			);

[5.342]

[5.490]

			change_decode_atom(bc, &bhunk->resurrectzombies.change);
			change_decode_local(bc, &bhunk->resurrectzombies.local);

Replacement in change.c at line 384 [6.1047]

B:BD[5.517] → [5.517:564]

				binstat, &bhunk->resurrectzombies.encoding

[5.517]

[5.564]

				bc, &bhunk->resurrectzombies.encoding

Replacement in change.c at line 388 [6.1047]

B:BD[5.597] → [5.597:706]

			change_decode_atom(binstat, &bhunk->addroot.name);
			change_decode_atom(binstat, &bhunk->addroot.inode);

[5.597]

[5.706]

			change_decode_atom(bc, &bhunk->addroot.name);
			change_decode_atom(bc, &bhunk->addroot.inode);

Replacement in change.c at line 392 [6.1047]

B:BD[5.733] → [5.733:842]

			change_decode_atom(binstat, &bhunk->delroot.name);
			change_decode_atom(binstat, &bhunk->delroot.inode);

[5.733]

[18.442]

			change_decode_atom(bc, &bhunk->delroot.name);
			change_decode_atom(bc, &bhunk->delroot.inode);

Replacement in change.c at line 416 [6.1047]
B:BD[23.648] → [7.3802:3827]
```
	struct bincode binstat;
```
[23.648]
[24.2591]
```
	struct bincode bc;
```

Replacement in change.c at line 441 [6.1047]

B:BD[23.650] → [25.32:81]

	binstat.avail = hashed_len;
	binstat.buf = buf;

[23.650]

[23.696]

	bc.avail = hashed_len;
	bc.buf = buf;

Replacement in change.c at line 444 [6.1047]
B:BD[23.697] → [26.93:138]
```
	hashed->version = bincode_getu64(&binstat);
```
[23.697]
[23.802]
```
	hashed->version = bincode_getu64(&bc);
```

Replacement in change.c at line 446 [6.1047]

B:BD[23.803] → [25.165:198]

B:BD[25.198] → [26.139:196]

	len = bincode_getu64(&binstat);
	hashed->header.message = bincode_getstr(&binstat, len);

[23.803]

[23.853]

	len = bincode_getu64(&bc);
	hashed->header.message = bincode_getstr(&bc, len);

Replacement in change.c at line 454 [6.1047]

B:BD[23.1130] → [25.256:322]

B:BD[25.322] → [26.197:259]

	if (bincode_getu8(&binstat)) {
		len = bincode_getu64(&binstat);
		hashed->header.description = bincode_getstr(&binstat, len);

[23.1130]

[26.259]

	if (bincode_getu8(&bc)) {
		len = bincode_getu64(&bc);
		hashed->header.description = bincode_getstr(&bc, len);

Replacement in change.c at line 459 [6.1047]
B:BD[23.1368] → [25.384:417]
```
	len = bincode_getu64(&binstat);
```
[23.1368]
[27.1399]
```
	len = bincode_getu64(&bc);
```

Replacement in change.c at line 464 [6.1047]

B:BD[9.1248] → [26.263:322]

	hashed->header.timestamp = bincode_getstr(&binstat, len);

[9.1248]

[28.354]

	hashed->header.timestamp = bincode_getstr(&bc, len);

Replacement in change.c at line 466 [6.1047]

B:BD[28.355] → [28.355:412]

	len = bincode_getu64(&binstat); /* arrays of authors */

[28.355]

[26.323]

	len = bincode_getu64(&bc); /* arrays of authors */

Replacement in change.c at line 472 [6.1047]
∅:D[29.502] → [28.600:634]
B:BD[28.600] → [28.600:634]
```
		len = bincode_getu64(&binstat);
```
[29.502]
[26.480]
```
		len = bincode_getu64(&bc);
```
Replacement in change.c at line 481 [6.1047]
∅:D[3.265] → [28.814:849]
∅:D[26.626] → [28.814:849]
B:BD[28.814] → [28.814:849]
```
			len = bincode_getu64(&binstat);
```
[3.265]
[26.627]
```
			len = bincode_getu64(&bc);
```
Replacement in change.c at line 483 [6.1047]
∅:D[26.677] → [9.1381:1416]
B:BD[9.1381] → [9.1381:1416]
∅:D[9.1416] → [28.929:964]
B:BD[28.929] → [28.929:964]
```
				bincode_getstr(&binstat, len);
			len = bincode_getu64(&binstat);
```
[26.677]
[26.678]
```
				bincode_getstr(&bc, len);
			len = bincode_getu64(&bc);
```
Replacement in change.c at line 486 [6.1047]
∅:D[26.730] → [9.1468:1503]
B:BD[9.1468] → [9.1468:1503]
```
				bincode_getstr(&binstat, len);
```
[26.730]
[28.1172]
```
				bincode_getstr(&bc, len);
```

Replacement in change.c at line 491 [6.1047]

B:BD[30.881] → [26.731:789]

	change_decode_hashlist(&binstat, &hashed->dependencies);

[30.881]

[28.1176]

	change_decode_hashlist(&bc, &hashed->dependencies);

Replacement in change.c at line 494 [6.1047]

B:BD[30.1575] → [31.3170:3226]

	change_decode_hashlist(&binstat, &hashed->extraknown);

[30.1575]

[32.226]

	change_decode_hashlist(&bc, &hashed->extraknown);

Replacement in change.c at line 497 [6.1047]
B:BD[33.27] → [33.27:60]
```
	len = bincode_getu64(&binstat);
```
[33.27]
[33.60]
```
	len = bincode_getu64(&bc);
```

Replacement in change.c at line 500 [6.1047]

B:BD[11.5580] → [11.5580:5633]

		bincode_getbytes(&binstat, hashed->metadata, len);

[11.5580]

[33.179]

		bincode_getbytes(&bc, hashed->metadata, len);

Replacement in change.c at line 504 [6.1047]
B:BD[33.278] → [11.5634:5674]
```
	change_decode_hunks(&binstat, hashed);
```
[33.278]
[33.278]
```
	change_decode_hunks(&bc, hashed);
```