anchor.diff:      for (int nDigits = minNDigits; nDigits <= maxNDigits; nDigits++) {
         stopWatch.start();
   
  -      int maxValue = ((pow(base, nDigits)) / 2.0).ceil();
  -      //int maxValue = pow(base, nDigits) - 1;
  -      TedNumber tedNumber = new TedNumber(base, nDigits, minValue);
  +      int maxValue = ((pow(base, nDigits)) / 2.0).ceil(); // Only need to go half way
  +      TedNumbers tedNumber = new TedNumbers(base, nDigits, minValue);
         for (int value = minValue; value <= maxValue; value++) {
  -        //print("Base $base, digits $nDigits: ${tedNumber.toDigitsStringNDigits()}:${tedNumber.toReversedDigitsStringNDigits()}");
           tedNumber.increment();
  -        //Solution solution = tedNumber.getSolution();
  -        //bool hasSolution = tedNumber.hasSolution();
  -//        if (solution != null) {
  -//          print(
  -//              "Base $base, digits:${nDigits}, "
  -//                  "n: ${solution.forwardNumber.toRadixString(base)}, "
  -//                  "m: ${solution.reversedNumber.toRadixString(base)},  "
  -//                  "${solution.multiple.toRadixString(base)} * "
  -//                  "${solution.forwardNumber.toRadixString(base)} == ${solution
  -//                  .reversedNumber.toRadixString(base)}");
  -//        }
           if (tedNumber.hasSolution()) {
             print(
                 "Base $base, digits:${nDigits}, "
  
positive.code:    * represented in the specified base) are the right number of digits (no leading 0's).
     * If so, then there's a solution, and return it.
     */
    //Solution getSolution() {
    bool hasSolution() {
      //print("In getSolution");
      if (digits[0] == "0" || digits[nDigits - 1] == "0") {
        //print("Skipping values not the right length.");
        return false;
      }
      //List<String> reversedDigits = new List<String>.from(digits.reversed);
      //int reversedValue = reversedDigits.................................
  //    if (digits == reversedDigits) { // does this work? No, fix this later
  //      print("Skipping values that are the same back and forward.");
  //      return null;
  //    }
      //int reversedValue = getReversedValue();
      reversedValue = getReversedValue();
      int mDivNRemainder = reversedValue % value;
      if (mDivNRemainder == 0) {
        //int wholeNumberMultiple = reversedValue ~/ value;
        multiple = reversedValue ~/ value;
        if (multiple != 1) {
          return true;
        }
        // This slows things down.  Maybe just update the values in this class
        // and return true or false
        //return new Solution(value, reversedValue, wholeNumberMultiple);
        //return true;
      }
      return false;
    }
  
    //
    // This reverses "digits" and calls a method to get a String representation
    // and then returns that.
    //
    String reverseDigitsAsString() {
      //print("In toReversedDigitsStringNDigits()");
      //List<String> digits = toDigitsList();
      Iterable digitsReversedIterable = digits.reversed;
      List<String> reversedDigits = new List<String>.from(digitsReversedIterable);
      String reversedStringNDigits = digitsToString(reversedDigits);
      return reversedStringNDigits;
    }
  
    //
    // Loops through provided "digits" and converts to a string of equal length.
    // Thus there can be leading 0's.
    // Only called by reverseDigitsAsString.
    //
    String digitsToString(List<String> digits) {
      //print("In digitsToStringNDigits(digits)");
  
      StringBuffer resultStringBuffer = new StringBuffer();
      for (int ctr = 0; ctr < digits.length; ctr++) {
        String digit = digits.elementAt(ctr);
  
negative.code: 
      }
    }
    print("Finished at " + (new DateTime.now()).toString());
  }
  /**
   * This class holds the number to be used to compare against its (in base) reversed form,
   * plus methods to reverse and print them.
   *
   * To compare the two numbers, the forward version has to be able to be reversed,
   * and the two numbers have to be integers in order to do the division.  The numbers,
   * forward and reversed, need to be the specified number of digits, so neither
   * of them can start with a 0 digit.
   *
   * I think that digits are most easily stored as an array of integers or characters,
   * as in List<int>, or as List<String> where each element represents a single digit,
   * in the specified base, like like 15 or "f" in base 16.
   */
  class TedNumbers {
    int base;
    int nDigits;
    int value;
    int reversedValue;
    int multiple;
    List<String> digits;
  
    TedNumbers(int base, int nDigits, int value) {
      this.base = base;
      this.nDigits = nDigits;
      this.value = value;
      this.digits = new List<String>.filled(this.nDigits, '0');
      updateDigits();
    }
  
    /**
     * Increment "value", and update the digits.
     */
    increment() {
      value++;
      updateDigits();
    }
  
    /**
     * Update the digits list by converting "value" to a string in the base,
     * then map those characters into "digits" list.
     */
    updateDigits() {
      String digitsStringValue = value.toRadixString(base);
      if (digitsStringValue.length > nDigits) {
        return; // not sure this is best
      }
      digits.fillRange(0, nDigits, "0"); // why not nDigits-1 ?
      int nCharsForValueInBase = digitsStringValue.length;
      for (int ctr = 0; ctr < nCharsForValueInBase; ctr++) {
        digits[nDigits - nCharsForValueInBase + ctr] = digitsStringValue[ctr];
      }
    }
  
    /**
  