createTermynals();
    loadVisibleTermynals();
}

function shuffle(array) {
    var currentIndex = array.length, temporaryValue, randomIndex;
    while (0 !== currentIndex) {
        randomIndex = Math.floor(Math.random() * currentIndex);
        currentIndex -= 1;
        temporaryValue = array[currentIndex];
        array[currentIndex] = array[randomIndex];
        array[randomIndex] = temporaryValue;
    }

		return 0, fmt.Errorf("invalid value for IntOrString: %v", err)
	}
	if isPercent {
		if roundUp {
			value = int(math.Ceil(float64(value) * (float64(total)) / 100))
		} else {
			value = int(math.Floor(float64(value) * (float64(total)) / 100))
		}
	}
	return value, nil
}

// GetValueFromIntOrPercent was deprecated in favor of

	c := math.Sqrt(a*a + b*b)
	fmt.Printf("%.1f", c)
	// Output: 5.0
}

func ExampleCeil() {
	c := math.Ceil(1.49)
	fmt.Printf("%.1f", c)
	// Output: 2.0
}

func ExampleFloor() {
	c := math.Floor(1.51)
	fmt.Printf("%.1f", c)
	// Output: 1.0
}

func ExamplePow() {
	c := math.Pow(2, 3)
	fmt.Printf("%.1f", c)
	// Output: 8.0
}

func ExamplePow10() {
	c := math.Pow10(2)

    @Override
    @CheckForNull
    public E lower(@ParametricNullness E e) {
      return getElementOrNull(multiset().headMultiset(e, OPEN).lastEntry());
    }

    @Override
    @CheckForNull
    public E floor(@ParametricNullness E e) {
      return getElementOrNull(multiset().headMultiset(e, CLOSED).lastEntry());
    }

    @Override
    @CheckForNull
    public E ceiling(@ParametricNullness E e) {

        "wealth",
        "cabbage",
        "playground",
        "wren",
        "flowers",
        "cobweb",
        "shame",
        "plate",
        "authority",
        "cave",
        "floor",
        "shelf",
        "snakes",
        "ants",
        "comparison",
        "quicksand",
        "eyes",
        "thumb",
        "church",
        "needle",
        "celery",

    @Override
    @CheckForNull
    public E lower(@ParametricNullness E e) {
      return getElementOrNull(multiset().headMultiset(e, OPEN).lastEntry());
    }

    @Override
    @CheckForNull
    public E floor(@ParametricNullness E e) {
      return getElementOrNull(multiset().headMultiset(e, CLOSED).lastEntry());
    }

    @Override
    @CheckForNull
    public E ceiling(@ParametricNullness E e) {

  // CHECK:  %[[MASK:.*]] = "tf.Less"(%[[XDIVY]], %[[ZERO]])
  // CHECK:  %[[CEIL:.*]] = "tf.Ceil"(%[[XDIVY]])
  // CHECK:  %[[FLOOR:.*]] = "tf.Floor"(%[[XDIVY]])
  // CHECK:  %[[RESULT:.*]] = "tf.SelectV2"(%[[MASK]], %[[CEIL]], %[[FLOOR]])
  %0 = "tf.TruncateDiv"(%arg0, %arg1)
      : (tensor<*xf32>, tensor<*xf32>) -> tensor<*xf32>

  // CHECK: return %[[RESULT]]
  func.return %0 : tensor<*xf32>

      return standardSubSet(fromElement, toElement);
    }

    @Override
    public @Nullable T lower(T e) {
      return standardLower(e);
    }

    @Override
    public @Nullable T floor(T e) {
      return standardFloor(e);
    }

    @Override
    public @Nullable T ceiling(T e) {
      return standardCeiling(e);
    }

    @Override
    public @Nullable T higher(T e) {

		dl++
	}
	// We need to remember whether the trimmed digits of 'dc' are zero.
	c0 := dc0 && fracc == 0
	// render digits
	ryuDigits(d, dl, dc, du, c0, cup)
	d.dp -= q
}

// mulByLog2Log10 returns math.Floor(x * log(2)/log(10)) for an integer x in
// the range -1600 <= x && x <= +1600.
//
// The range restriction lets us work in faster integer arithmetic instead of

		z1, z0 := mulAddWWW_g(x[i], y, z[i])
		lo, cc := bits.Add(uint(z0), uint(c), 0)
		c, z[i] = Word(cc), Word(lo)
		c += z1
	}
	return
}

// q = ( x1 << _W + x0 - r)/y. m = floor(( _B^2 - 1 ) / d - _B). Requiring x1<y.
// An approximate reciprocal with a reference to "Improved Division by Invariant Integers
// (IEEE Transactions on Computers, 11 Jun. 2010)"
func divWW(x1, x0, y, m Word) (q, r Word) {