// form. So we'll invert and subtract 1. If the
		// most-significant-bit isn't set then we'll need to pad the
		// beginning with 0xff in order to keep the number negative.
		nMinus1 := new(big.Int).Neg(n)
		nMinus1.Sub(nMinus1, bigOne)
		bytes := nMinus1.Bytes()
		for i := range bytes {
			bytes[i] ^= 0xff
		}
		if len(bytes) == 0 || bytes[0]&0x80 == 0 {
			return multiEncoder([]encoder{byteFFEncoder, bytesEncoder(bytes)}), nil

              return roundCeilingAsDouble;
            }
            roundFloor = toX(roundFloorAsDouble, RoundingMode.FLOOR);
          }

          X deltaToFloor = minus(x, roundFloor);
          X deltaToCeiling = minus(roundCeiling, x);
          int diff = deltaToFloor.compareTo(deltaToCeiling);
          if (diff < 0) { // closer to floor
            return roundFloorAsDouble;

      this.arithmetic = arithmetic;
    }

    @Override
    public int add(int a, int b) {
      return arithmetic.add(a, b);
    }

    @Override
    public int minus(int a, int b) {
      return arithmetic.minus(a, b);
    }

    @Override
    public String toString() {
      return arithmetic.toString();
    }
  }

  private static class FailsToForwardParameters implements Adder {

int plus(int a, int b);

      this.arithmetic = arithmetic;
    }

    @Override
    public int add(int a, int b) {
      return arithmetic.add(a, b);
    }

    @Override
    public int minus(int a, int b) {
      return arithmetic.minus(a, b);
    }

    @Override
    public String toString() {
      return arithmetic.toString();
    }
  }

  private static class FailsToForwardParameters implements Adder {

    TF_RETURN_IF_ERROR(
        RunAndMaybeSum(ctx, forward, theta_inputs, f_outputs, use_function));
    AbstractTensorHandlePtr fMinus(f_outputs[0]);

    // Take Difference of both estimates: (f(theta + eps) - f(theta - eps)).
    TF_RETURN_IF_ERROR(
        ops::Sub(ctx, fPlus.get(), fMinus.get(), f_outputs, "sub_top"));
    AbstractTensorHandlePtr fDiff(f_outputs[0]);

    // Calculate using the difference quotient definition:

	"*":                          "\u002a",
	"⫰":                          "\u2af0",
	"·":                          "\u00b7",
	"−":                           "\u2212",
	"⊟":                          "\u229f",
	"∸":                          "\u2238",
	"⨪":                         "\u2a2a",
	"⫛":                            "\u2adb",

		"midast;":                          '\U0000002A',
		"midcir;":                          '\U00002AF0',
		"middot;":                          '\U000000B7',
		"minus;":                           '\U00002212',
		"minusb;":                          '\U0000229F',
		"minusd;":                          '\U00002238',
		"minusdu;":                         '\U00002A2A',
		"mlcp;":                            '\U00002ADB',

	VMINPS Z15, Z8, K1, Z2                             // 62d13c495dd7
	VMINPS Z12, Z8, K1, Z2                             // 62d13c495dd4
	VMINPS Z13, Z11, K1, Z14                           // 625124495df5
	VMINPS Z14, Z11, K1, Z14                           // 625124495df6
	VMINPS 99(R15)(R15*8), Z11, K1, Z14                // 621124495db4ff63000000
	VMINPS 7(AX)(CX*8), Z11, K1, Z14                   // 627124495db4c807000000

  protected Map<String, Integer> makePopulatedMap() {
    return SerializableTester.reserialize(ImmutableMap.of("one", 1, "two", 2, "three", 3));
  }

  @Override
  protected String getKeyNotInPopulatedMap() {
    return "minus one";
  }

  @Override
  protected Integer getValueNotInPopulatedMap() {
    return -1;
  }