anchor.diff:     * 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();
  +    if (value == reversedValue) {
  +      return false; // Don't want multiple of 1
  +    }
       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 true;
       }
       return false;
     }
   
  -  //
  -  // This reverses "digits" and calls a method to get a String representation
  -  // and then returns that.
  -  //
  +  /**
  +   * 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);
  +    List<String> reversedDigits = digits.reversed.toList(growable:false);
       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.
  -  //
  +  /**
  +   * 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);
  
positive.code: import 'dart:math';
  
  // Obviously wrong if you look at how this counts.
  
  main(List<String> arguments) {
    int minBase = 10;
    int maxBase = 11;
    int minNDigits = 4;
    int maxNDigits = 6;
    int minValue = 1;
  
    print("Starting at " + (new DateTime.now()).toString());
    Stopwatch stopWatch = new Stopwatch();
  
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];
      }
    }
  
    /**
  