1// Copyright 2009 The Go Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style
3// license that can be found in the LICENSE file.
4
5package big
6
7import (
8	"fmt"
9	"runtime"
10	"strings"
11	"testing"
12)
13
14var cmpTests = []struct {
15	x, y nat
16	r    int
17}{
18	{nil, nil, 0},
19	{nil, nat(nil), 0},
20	{nat(nil), nil, 0},
21	{nat(nil), nat(nil), 0},
22	{nat{0}, nat{0}, 0},
23	{nat{0}, nat{1}, -1},
24	{nat{1}, nat{0}, 1},
25	{nat{1}, nat{1}, 0},
26	{nat{0, _M}, nat{1}, 1},
27	{nat{1}, nat{0, _M}, -1},
28	{nat{1, _M}, nat{0, _M}, 1},
29	{nat{0, _M}, nat{1, _M}, -1},
30	{nat{16, 571956, 8794, 68}, nat{837, 9146, 1, 754489}, -1},
31	{nat{34986, 41, 105, 1957}, nat{56, 7458, 104, 1957}, 1},
32}
33
34func TestCmp(t *testing.T) {
35	for i, a := range cmpTests {
36		r := a.x.cmp(a.y)
37		if r != a.r {
38			t.Errorf("#%d got r = %v; want %v", i, r, a.r)
39		}
40	}
41}
42
43type funNN func(z, x, y nat) nat
44type argNN struct {
45	z, x, y nat
46}
47
48var sumNN = []argNN{
49	{},
50	{nat{1}, nil, nat{1}},
51	{nat{1111111110}, nat{123456789}, nat{987654321}},
52	{nat{0, 0, 0, 1}, nil, nat{0, 0, 0, 1}},
53	{nat{0, 0, 0, 1111111110}, nat{0, 0, 0, 123456789}, nat{0, 0, 0, 987654321}},
54	{nat{0, 0, 0, 1}, nat{0, 0, _M}, nat{0, 0, 1}},
55}
56
57var prodNN = []argNN{
58	{},
59	{nil, nil, nil},
60	{nil, nat{991}, nil},
61	{nat{991}, nat{991}, nat{1}},
62	{nat{991 * 991}, nat{991}, nat{991}},
63	{nat{0, 0, 991 * 991}, nat{0, 991}, nat{0, 991}},
64	{nat{1 * 991, 2 * 991, 3 * 991, 4 * 991}, nat{1, 2, 3, 4}, nat{991}},
65	{nat{4, 11, 20, 30, 20, 11, 4}, nat{1, 2, 3, 4}, nat{4, 3, 2, 1}},
66	// 3^100 * 3^28 = 3^128
67	{
68		natFromString("11790184577738583171520872861412518665678211592275841109096961"),
69		natFromString("515377520732011331036461129765621272702107522001"),
70		natFromString("22876792454961"),
71	},
72	// z = 111....1 (70000 digits)
73	// x = 10^(99*700) + ... + 10^1400 + 10^700 + 1
74	// y = 111....1 (700 digits, larger than Karatsuba threshold on 32-bit and 64-bit)
75	{
76		natFromString(strings.Repeat("1", 70000)),
77		natFromString("1" + strings.Repeat(strings.Repeat("0", 699)+"1", 99)),
78		natFromString(strings.Repeat("1", 700)),
79	},
80	// z = 111....1 (20000 digits)
81	// x = 10^10000 + 1
82	// y = 111....1 (10000 digits)
83	{
84		natFromString(strings.Repeat("1", 20000)),
85		natFromString("1" + strings.Repeat("0", 9999) + "1"),
86		natFromString(strings.Repeat("1", 10000)),
87	},
88}
89
90func natFromString(s string) nat {
91	x, _, _, err := nat(nil).scan(strings.NewReader(s), 0, false)
92	if err != nil {
93		panic(err)
94	}
95	return x
96}
97
98func TestSet(t *testing.T) {
99	for _, a := range sumNN {
100		z := nat(nil).set(a.z)
101		if z.cmp(a.z) != 0 {
102			t.Errorf("got z = %v; want %v", z, a.z)
103		}
104	}
105}
106
107func testFunNN(t *testing.T, msg string, f funNN, a argNN) {
108	z := f(nil, a.x, a.y)
109	if z.cmp(a.z) != 0 {
110		t.Errorf("%s%+v\n\tgot z = %v; want %v", msg, a, z, a.z)
111	}
112}
113
114func TestFunNN(t *testing.T) {
115	for _, a := range sumNN {
116		arg := a
117		testFunNN(t, "add", nat.add, arg)
118
119		arg = argNN{a.z, a.y, a.x}
120		testFunNN(t, "add symmetric", nat.add, arg)
121
122		arg = argNN{a.x, a.z, a.y}
123		testFunNN(t, "sub", nat.sub, arg)
124
125		arg = argNN{a.y, a.z, a.x}
126		testFunNN(t, "sub symmetric", nat.sub, arg)
127	}
128
129	for _, a := range prodNN {
130		arg := a
131		testFunNN(t, "mul", nat.mul, arg)
132
133		arg = argNN{a.z, a.y, a.x}
134		testFunNN(t, "mul symmetric", nat.mul, arg)
135	}
136}
137
138var mulRangesN = []struct {
139	a, b uint64
140	prod string
141}{
142	{0, 0, "0"},
143	{1, 1, "1"},
144	{1, 2, "2"},
145	{1, 3, "6"},
146	{10, 10, "10"},
147	{0, 100, "0"},
148	{0, 1e9, "0"},
149	{1, 0, "1"},                    // empty range
150	{100, 1, "1"},                  // empty range
151	{1, 10, "3628800"},             // 10!
152	{1, 20, "2432902008176640000"}, // 20!
153	{1, 100,
154		"933262154439441526816992388562667004907159682643816214685929" +
155			"638952175999932299156089414639761565182862536979208272237582" +
156			"51185210916864000000000000000000000000", // 100!
157	},
158}
159
160func TestMulRangeN(t *testing.T) {
161	for i, r := range mulRangesN {
162		prod := string(nat(nil).mulRange(r.a, r.b).utoa(10))
163		if prod != r.prod {
164			t.Errorf("#%d: got %s; want %s", i, prod, r.prod)
165		}
166	}
167}
168
169// allocBytes returns the number of bytes allocated by invoking f.
170func allocBytes(f func()) uint64 {
171	var stats runtime.MemStats
172	runtime.ReadMemStats(&stats)
173	t := stats.TotalAlloc
174	f()
175	runtime.ReadMemStats(&stats)
176	return stats.TotalAlloc - t
177}
178
179// TestMulUnbalanced tests that multiplying numbers of different lengths
180// does not cause deep recursion and in turn allocate too much memory.
181// Test case for issue 3807.
182func TestMulUnbalanced(t *testing.T) {
183	defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(1))
184	x := rndNat(50000)
185	y := rndNat(40)
186	allocSize := allocBytes(func() {
187		nat(nil).mul(x, y)
188	})
189	inputSize := uint64(len(x)+len(y)) * _S
190	if ratio := allocSize / uint64(inputSize); ratio > 10 {
191		t.Errorf("multiplication uses too much memory (%d > %d times the size of inputs)", allocSize, ratio)
192	}
193}
194
195func rndNat(n int) nat {
196	return nat(rndV(n)).norm()
197}
198
199func BenchmarkMul(b *testing.B) {
200	mulx := rndNat(1e4)
201	muly := rndNat(1e4)
202	b.ResetTimer()
203	for i := 0; i < b.N; i++ {
204		var z nat
205		z.mul(mulx, muly)
206	}
207}
208
209func TestNLZ(t *testing.T) {
210	var x Word = _B >> 1
211	for i := 0; i <= _W; i++ {
212		if int(nlz(x)) != i {
213			t.Errorf("failed at %x: got %d want %d", x, nlz(x), i)
214		}
215		x >>= 1
216	}
217}
218
219type shiftTest struct {
220	in    nat
221	shift uint
222	out   nat
223}
224
225var leftShiftTests = []shiftTest{
226	{nil, 0, nil},
227	{nil, 1, nil},
228	{natOne, 0, natOne},
229	{natOne, 1, natTwo},
230	{nat{1 << (_W - 1)}, 1, nat{0}},
231	{nat{1 << (_W - 1), 0}, 1, nat{0, 1}},
232}
233
234func TestShiftLeft(t *testing.T) {
235	for i, test := range leftShiftTests {
236		var z nat
237		z = z.shl(test.in, test.shift)
238		for j, d := range test.out {
239			if j >= len(z) || z[j] != d {
240				t.Errorf("#%d: got: %v want: %v", i, z, test.out)
241				break
242			}
243		}
244	}
245}
246
247var rightShiftTests = []shiftTest{
248	{nil, 0, nil},
249	{nil, 1, nil},
250	{natOne, 0, natOne},
251	{natOne, 1, nil},
252	{natTwo, 1, natOne},
253	{nat{0, 1}, 1, nat{1 << (_W - 1)}},
254	{nat{2, 1, 1}, 1, nat{1<<(_W-1) + 1, 1 << (_W - 1)}},
255}
256
257func TestShiftRight(t *testing.T) {
258	for i, test := range rightShiftTests {
259		var z nat
260		z = z.shr(test.in, test.shift)
261		for j, d := range test.out {
262			if j >= len(z) || z[j] != d {
263				t.Errorf("#%d: got: %v want: %v", i, z, test.out)
264				break
265			}
266		}
267	}
268}
269
270func BenchmarkZeroShifts(b *testing.B) {
271	x := rndNat(800)
272
273	b.Run("Shl", func(b *testing.B) {
274		for i := 0; i < b.N; i++ {
275			var z nat
276			z.shl(x, 0)
277		}
278	})
279	b.Run("ShlSame", func(b *testing.B) {
280		for i := 0; i < b.N; i++ {
281			x.shl(x, 0)
282		}
283	})
284
285	b.Run("Shr", func(b *testing.B) {
286		for i := 0; i < b.N; i++ {
287			var z nat
288			z.shr(x, 0)
289		}
290	})
291	b.Run("ShrSame", func(b *testing.B) {
292		for i := 0; i < b.N; i++ {
293			x.shr(x, 0)
294		}
295	})
296}
297
298type modWTest struct {
299	in       string
300	dividend string
301	out      string
302}
303
304var modWTests32 = []modWTest{
305	{"23492635982634928349238759823742", "252341", "220170"},
306}
307
308var modWTests64 = []modWTest{
309	{"6527895462947293856291561095690465243862946", "524326975699234", "375066989628668"},
310}
311
312func runModWTests(t *testing.T, tests []modWTest) {
313	for i, test := range tests {
314		in, _ := new(Int).SetString(test.in, 10)
315		d, _ := new(Int).SetString(test.dividend, 10)
316		out, _ := new(Int).SetString(test.out, 10)
317
318		r := in.abs.modW(d.abs[0])
319		if r != out.abs[0] {
320			t.Errorf("#%d failed: got %d want %s", i, r, out)
321		}
322	}
323}
324
325func TestModW(t *testing.T) {
326	if _W >= 32 {
327		runModWTests(t, modWTests32)
328	}
329	if _W >= 64 {
330		runModWTests(t, modWTests64)
331	}
332}
333
334var montgomeryTests = []struct {
335	x, y, m      string
336	k0           uint64
337	out32, out64 string
338}{
339	{
340		"0xffffffffffffffffffffffffffffffffffffffffffffffffe",
341		"0xffffffffffffffffffffffffffffffffffffffffffffffffe",
342		"0xfffffffffffffffffffffffffffffffffffffffffffffffff",
343		1,
344		"0x1000000000000000000000000000000000000000000",
345		"0x10000000000000000000000000000000000",
346	},
347	{
348		"0x000000000ffffff5",
349		"0x000000000ffffff0",
350		"0x0000000010000001",
351		0xff0000000fffffff,
352		"0x000000000bfffff4",
353		"0x0000000003400001",
354	},
355	{
356		"0x0000000080000000",
357		"0x00000000ffffffff",
358		"0x1000000000000001",
359		0xfffffffffffffff,
360		"0x0800000008000001",
361		"0x0800000008000001",
362	},
363	{
364		"0x0000000080000000",
365		"0x0000000080000000",
366		"0xffffffff00000001",
367		0xfffffffeffffffff,
368		"0xbfffffff40000001",
369		"0xbfffffff40000001",
370	},
371	{
372		"0x0000000080000000",
373		"0x0000000080000000",
374		"0x00ffffff00000001",
375		0xfffffeffffffff,
376		"0xbfffff40000001",
377		"0xbfffff40000001",
378	},
379	{
380		"0x0000000080000000",
381		"0x0000000080000000",
382		"0x0000ffff00000001",
383		0xfffeffffffff,
384		"0xbfff40000001",
385		"0xbfff40000001",
386	},
387	{
388		"0x3321ffffffffffffffffffffffffffff00000000000022222623333333332bbbb888c0",
389		"0x3321ffffffffffffffffffffffffffff00000000000022222623333333332bbbb888c0",
390		"0x33377fffffffffffffffffffffffffffffffffffffffffffff0000000000022222eee1",
391		0xdecc8f1249812adf,
392		"0x04eb0e11d72329dc0915f86784820fc403275bf2f6620a20e0dd344c5cd0875e50deb5",
393		"0x0d7144739a7d8e11d72329dc0915f86784820fc403275bf2f61ed96f35dd34dbb3d6a0",
394	},
395	{
396		"0x10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffffffffffff00000000000022222223333333333444444444",
397		"0x10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffffffffffff999999999999999aaabbbbbbbbcccccccccccc",
398		"0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff33377fffffffffffffffffffffffffffffffffffffffffffff0000000000022222eee1",
399		0xdecc8f1249812adf,
400		"0x5c0d52f451aec609b15da8e5e5626c4eaa88723bdeac9d25ca9b961269400410ca208a16af9c2fb07d7a11c7772cba02c22f9711078d51a3797eb18e691295293284d988e349fa6deba46b25a4ecd9f715",
401		"0x92fcad4b5c0d52f451aec609b15da8e5e5626c4eaa88723bdeac9d25ca9b961269400410ca208a16af9c2fb07d799c32fe2f3cc5422f9711078d51a3797eb18e691295293284d8f5e69caf6decddfe1df6",
402	},
403}
404
405func TestMontgomery(t *testing.T) {
406	one := NewInt(1)
407	_B := new(Int).Lsh(one, _W)
408	for i, test := range montgomeryTests {
409		x := natFromString(test.x)
410		y := natFromString(test.y)
411		m := natFromString(test.m)
412		for len(x) < len(m) {
413			x = append(x, 0)
414		}
415		for len(y) < len(m) {
416			y = append(y, 0)
417		}
418
419		if x.cmp(m) > 0 {
420			_, r := nat(nil).div(nil, x, m)
421			t.Errorf("#%d: x > m (0x%s > 0x%s; use 0x%s)", i, x.utoa(16), m.utoa(16), r.utoa(16))
422		}
423		if y.cmp(m) > 0 {
424			_, r := nat(nil).div(nil, x, m)
425			t.Errorf("#%d: y > m (0x%s > 0x%s; use 0x%s)", i, y.utoa(16), m.utoa(16), r.utoa(16))
426		}
427
428		var out nat
429		if _W == 32 {
430			out = natFromString(test.out32)
431		} else {
432			out = natFromString(test.out64)
433		}
434
435		// t.Logf("#%d: len=%d\n", i, len(m))
436
437		// check output in table
438		xi := &Int{abs: x}
439		yi := &Int{abs: y}
440		mi := &Int{abs: m}
441		p := new(Int).Mod(new(Int).Mul(xi, new(Int).Mul(yi, new(Int).ModInverse(new(Int).Lsh(one, uint(len(m))*_W), mi))), mi)
442		if out.cmp(p.abs.norm()) != 0 {
443			t.Errorf("#%d: out in table=0x%s, computed=0x%s", i, out.utoa(16), p.abs.norm().utoa(16))
444		}
445
446		// check k0 in table
447		k := new(Int).Mod(&Int{abs: m}, _B)
448		k = new(Int).Sub(_B, k)
449		k = new(Int).Mod(k, _B)
450		k0 := Word(new(Int).ModInverse(k, _B).Uint64())
451		if k0 != Word(test.k0) {
452			t.Errorf("#%d: k0 in table=%#x, computed=%#x\n", i, test.k0, k0)
453		}
454
455		// check montgomery with correct k0 produces correct output
456		z := nat(nil).montgomery(x, y, m, k0, len(m))
457		z = z.norm()
458		if z.cmp(out) != 0 {
459			t.Errorf("#%d: got 0x%s want 0x%s", i, z.utoa(16), out.utoa(16))
460		}
461	}
462}
463
464var expNNTests = []struct {
465	x, y, m string
466	out     string
467}{
468	{"0", "0", "0", "1"},
469	{"0", "0", "1", "0"},
470	{"1", "1", "1", "0"},
471	{"2", "1", "1", "0"},
472	{"2", "2", "1", "0"},
473	{"10", "100000000000", "1", "0"},
474	{"0x8000000000000000", "2", "", "0x40000000000000000000000000000000"},
475	{"0x8000000000000000", "2", "6719", "4944"},
476	{"0x8000000000000000", "3", "6719", "5447"},
477	{"0x8000000000000000", "1000", "6719", "1603"},
478	{"0x8000000000000000", "1000000", "6719", "3199"},
479	{
480		"2938462938472983472983659726349017249287491026512746239764525612965293865296239471239874193284792387498274256129746192347",
481		"298472983472983471903246121093472394872319615612417471234712061",
482		"29834729834729834729347290846729561262544958723956495615629569234729836259263598127342374289365912465901365498236492183464",
483		"23537740700184054162508175125554701713153216681790245129157191391322321508055833908509185839069455749219131480588829346291",
484	},
485	{
486		"11521922904531591643048817447554701904414021819823889996244743037378330903763518501116638828335352811871131385129455853417360623007349090150042001944696604737499160174391019030572483602867266711107136838523916077674888297896995042968746762200926853379",
487		"426343618817810911523",
488		"444747819283133684179",
489		"42",
490	},
491}
492
493func TestExpNN(t *testing.T) {
494	for i, test := range expNNTests {
495		x := natFromString(test.x)
496		y := natFromString(test.y)
497		out := natFromString(test.out)
498
499		var m nat
500		if len(test.m) > 0 {
501			m = natFromString(test.m)
502		}
503
504		z := nat(nil).expNN(x, y, m)
505		if z.cmp(out) != 0 {
506			t.Errorf("#%d got %s want %s", i, z.utoa(10), out.utoa(10))
507		}
508	}
509}
510
511func BenchmarkExp3Power(b *testing.B) {
512	const x = 3
513	for _, y := range []Word{
514		0x10, 0x40, 0x100, 0x400, 0x1000, 0x4000, 0x10000, 0x40000, 0x100000, 0x400000,
515	} {
516		b.Run(fmt.Sprintf("%#x", y), func(b *testing.B) {
517			var z nat
518			for i := 0; i < b.N; i++ {
519				z.expWW(x, y)
520			}
521		})
522	}
523}
524
525func fibo(n int) nat {
526	switch n {
527	case 0:
528		return nil
529	case 1:
530		return nat{1}
531	}
532	f0 := fibo(0)
533	f1 := fibo(1)
534	var f2 nat
535	for i := 1; i < n; i++ {
536		f2 = f2.add(f0, f1)
537		f0, f1, f2 = f1, f2, f0
538	}
539	return f1
540}
541
542var fiboNums = []string{
543	"0",
544	"55",
545	"6765",
546	"832040",
547	"102334155",
548	"12586269025",
549	"1548008755920",
550	"190392490709135",
551	"23416728348467685",
552	"2880067194370816120",
553	"354224848179261915075",
554}
555
556func TestFibo(t *testing.T) {
557	for i, want := range fiboNums {
558		n := i * 10
559		got := string(fibo(n).utoa(10))
560		if got != want {
561			t.Errorf("fibo(%d) failed: got %s want %s", n, got, want)
562		}
563	}
564}
565
566func BenchmarkFibo(b *testing.B) {
567	for i := 0; i < b.N; i++ {
568		fibo(1e0)
569		fibo(1e1)
570		fibo(1e2)
571		fibo(1e3)
572		fibo(1e4)
573		fibo(1e5)
574	}
575}
576
577var bitTests = []struct {
578	x    string
579	i    uint
580	want uint
581}{
582	{"0", 0, 0},
583	{"0", 1, 0},
584	{"0", 1000, 0},
585
586	{"0x1", 0, 1},
587	{"0x10", 0, 0},
588	{"0x10", 3, 0},
589	{"0x10", 4, 1},
590	{"0x10", 5, 0},
591
592	{"0x8000000000000000", 62, 0},
593	{"0x8000000000000000", 63, 1},
594	{"0x8000000000000000", 64, 0},
595
596	{"0x3" + strings.Repeat("0", 32), 127, 0},
597	{"0x3" + strings.Repeat("0", 32), 128, 1},
598	{"0x3" + strings.Repeat("0", 32), 129, 1},
599	{"0x3" + strings.Repeat("0", 32), 130, 0},
600}
601
602func TestBit(t *testing.T) {
603	for i, test := range bitTests {
604		x := natFromString(test.x)
605		if got := x.bit(test.i); got != test.want {
606			t.Errorf("#%d: %s.bit(%d) = %v; want %v", i, test.x, test.i, got, test.want)
607		}
608	}
609}
610
611var stickyTests = []struct {
612	x    string
613	i    uint
614	want uint
615}{
616	{"0", 0, 0},
617	{"0", 1, 0},
618	{"0", 1000, 0},
619
620	{"0x1", 0, 0},
621	{"0x1", 1, 1},
622
623	{"0x1350", 0, 0},
624	{"0x1350", 4, 0},
625	{"0x1350", 5, 1},
626
627	{"0x8000000000000000", 63, 0},
628	{"0x8000000000000000", 64, 1},
629
630	{"0x1" + strings.Repeat("0", 100), 400, 0},
631	{"0x1" + strings.Repeat("0", 100), 401, 1},
632}
633
634func TestSticky(t *testing.T) {
635	for i, test := range stickyTests {
636		x := natFromString(test.x)
637		if got := x.sticky(test.i); got != test.want {
638			t.Errorf("#%d: %s.sticky(%d) = %v; want %v", i, test.x, test.i, got, test.want)
639		}
640		if test.want == 1 {
641			// all subsequent i's should also return 1
642			for d := uint(1); d <= 3; d++ {
643				if got := x.sticky(test.i + d); got != 1 {
644					t.Errorf("#%d: %s.sticky(%d) = %v; want %v", i, test.x, test.i+d, got, 1)
645				}
646			}
647		}
648	}
649}
650
651func testSqr(t *testing.T, x nat) {
652	got := make(nat, 2*len(x))
653	want := make(nat, 2*len(x))
654	got = got.sqr(x)
655	want = want.mul(x, x)
656	if got.cmp(want) != 0 {
657		t.Errorf("basicSqr(%v), got %v, want %v", x, got, want)
658	}
659}
660
661func TestSqr(t *testing.T) {
662	for _, a := range prodNN {
663		if a.x != nil {
664			testSqr(t, a.x)
665		}
666		if a.y != nil {
667			testSqr(t, a.y)
668		}
669		if a.z != nil {
670			testSqr(t, a.z)
671		}
672	}
673}
674
675func benchmarkNatSqr(b *testing.B, nwords int) {
676	x := rndNat(nwords)
677	var z nat
678	b.ResetTimer()
679	for i := 0; i < b.N; i++ {
680		z.sqr(x)
681	}
682}
683
684var sqrBenchSizes = []int{1, 2, 3, 5, 8, 10, 20, 30, 50, 80, 100, 200, 300, 500, 800, 1000}
685
686func BenchmarkNatSqr(b *testing.B) {
687	for _, n := range sqrBenchSizes {
688		if isRaceBuilder && n > 1e3 {
689			continue
690		}
691		b.Run(fmt.Sprintf("%d", n), func(b *testing.B) {
692			benchmarkNatSqr(b, n)
693		})
694	}
695}
696
697func BenchmarkNatSetBytes(b *testing.B) {
698	const maxLength = 128
699	lengths := []int{
700		// No remainder:
701		8, 24, maxLength,
702		// With remainder:
703		7, 23, maxLength - 1,
704	}
705	n := make(nat, maxLength/_W) // ensure n doesn't need to grow during the test
706	buf := make([]byte, maxLength)
707	for _, l := range lengths {
708		b.Run(fmt.Sprint(l), func(b *testing.B) {
709			for i := 0; i < b.N; i++ {
710				n.setBytes(buf[:l])
711			}
712		})
713	}
714}
715