}
	// sync file, to ensure it's written in case a hard reset happens
	return tmpPath, tmpFile.Sync()
}

// ReplaceFile replaces the contents of the file at `path` with `data` by writing to a tmp file in the same
// dir as `path` and renaming the tmp file over `path`. The file does not have to exist to use ReplaceFile,
// but the parent directory must exist.
// Note ReplaceFile calls fsync.

  %tmp0, %ctl0 = tfl.control_node controls "tfl.neg"(%arg0): (tensor<1xf32>) -> tensor<1xf32>
  %tmp1, %ctl1 = tfl.control_node controls "tfl.neg"(%tmp0): (tensor<1xf32>) -> tensor<1xf32>
  %tmp2, %ctl2 = tfl.control_node controls "tfl.neg"(%tmp1): (tensor<1xf32>) -> tensor<1xf32>
  %tmp3, %ctl3 = tfl.control_node controls "tfl.neg"(%tmp2): (tensor<1xf32>) -> tensor<1xf32>

// CHECK-NEXT: %[[CONST:.*]] = "tfl.pseudo_const"()
// CHECK-NEXT: %[[TMP1:.*]] = tfl.add %[[CONST]], %[[CONST]]
// CHECK-NEXT: %[[TMP2:.*]], %[[SEQ1:.*]] = tfl.control_node(%[[SEQ0]]) controls "tfl.add"(%[[VAR]], %[[TMP1]])
// CHECK-NEXT: %[[TMP3:.*]] = tfl.add %[[TMP2]], %[[TMP1]]
// CHECK-NEXT: %[[TMP4:.*]], %[[SEQ2:.*]] = tfl.control_node(%[[SEQ1]]) controls "tfl.while"(%[[TMP3]]) ({
// CHECK-NEXT:   ^bb0(%[[ARG_COND:.*]]: tensor<1xf32>):

# external linker.

mkdir tmp1
mkdir tmp2
mkdir tmp3
mkdir tmp4
mkdir tmp5

# First build: no external linking expected
go build -ldflags=-tmpdir=tmp1 -o $devnull ./noUseOfCgo &

# Second build: using only "runtime/cgo", expect internal linking.
go build -ldflags=-tmpdir=tmp2 -o $devnull ./usesInternalCgo &

	accP3.fromP1xP1(&accP1xP1)
	accP1xP1.AddAffine(accP3, &tmp2)
	accP3.fromP1xP1(&accP1xP1)
	accP1xP1.AddAffine(accP3, &tmp3)
	accP3.fromP1xP1(&accP1xP1)

	if accP3.Equal(I) != 1 {
		t.Errorf("Consistency check on ProjLookupTable.SelectInto failed!  %x %x %x", tmp1, tmp2, tmp3)
	}
}

func TestNafLookupTable5(t *testing.T) {
	var table nafLookupTable5
	table.FromP3(B)

	var tmp1, tmp2, tmp3, tmp4 projCached

		x3 := s[3]
		x4 := s[4]
		x5 := s[5]
		x6 := s[6]
		x7 := s[7]

		tmp0 := x0 + x7
		tmp1 := x1 + x6
		tmp2 := x2 + x5
		tmp3 := x3 + x4

		tmp10 := tmp0 + tmp3
		tmp12 := tmp0 - tmp3
		tmp11 := tmp1 + tmp2
		tmp13 := tmp1 - tmp2

		tmp0 = x0 - x7
		tmp1 = x1 - x6
		tmp2 = x2 - x5
		tmp3 = x3 - x4

		s[0] = (tmp10 + tmp11 - 8*centerJSample) << pass1Bits

}
// CHECK-NEXT: %[[CONST:.*]] = "tfl.pseudo_const"()
// CHECK-NEXT: %[[TMP1:.*]] = tfl.add %[[CONST]], %[[CONST]]
// CHECK-NEXT: %[[TMP2:.*]] = "tf.AddV2"(%[[TMP1]], %[[TMP1]])
// CHECK-NEXT: %[[TMP3:.*]] = tfl.add %[[CONST]], %[[TMP2]]
// CHECK-NEXT: %[[TMP4:.*]] = "tf.AddV2"(%[[TMP2]], %[[TMP3]])
// CHECK-NEXT: %[[RESULT:.*]] = tfl.add %[[TMP3]], %[[TMP4]]
// CHECK-NEXT: return %[[RESULT]]

	// carried out one at a time. The operands of an index
	// expression include both the array and the index. So this
	// evaluates as
	//   tmp1 := arr
	//   tmp2 := len(arr) - 1
	//   tmp3 := len(arr)
	//   arr = arr[:tmp3-1]
	//   tmp1[tmp2] = 3
	arr, arr[len(arr)-1] = arr[:len(arr)-1], 3

	if len(arr) != 1 || arr[0] != 1 || arr[:2][1] != 3 {
		panic(arr)
	}

		}

		// Set p = (16^2)*p = 256*p = 2^8*p
		tmp2.FromP3(tmp3)
		for j := 0; j < 7; j++ {
			tmp1.Double(tmp2)
			tmp2.FromP1xP1(tmp1)
		}
		tmp1.Double(tmp2)
		tmp3.fromP1xP1(tmp1)
		checkOnCurve(t, tmp3)
	}
}

func TestScalarMultMatchesBaseMult(t *testing.T) {
	scalarMultMatchesBaseMult := func(x Scalar) bool {
		var p, q Point
		p.ScalarMult(&x, B)
		q.ScalarBaseMult(&x)

					$.each(li_attr, function (i, v) {
						tmp2 = li.attr(v);
						if(tmp2 && tmp2.length && tmp2.replace(/jstree[^ ]*/ig,'').length) {
							tmp1.attr[v] = (" " + tmp2).replace(/ jstree[^ ]*/ig,'').replace(/\s+$/ig," ").replace(/^ /,"").replace(/ $/,"");
						}
					});
					if(li.hasClass("jstree-open")) { tmp1.state = "open"; }
					if(li.hasClass("jstree-closed")) { tmp1.state = "closed"; }