anchor.diff:  import 'dart:math';
  -
  -// Obviously wrong if you look at how this counts.
   
   main(List<String> arguments) {
     int minBase = 10;
  -  int maxBase = 11;
  +  int maxBase = 10;
     int minNDigits = 4;
  -  int maxNDigits = 6;
  -  int minValue = 1;
  +  int maxNDigits = 4;
  +  int minValue = 100;
   
     print("Starting at " + (new DateTime.now()).toString());
     Stopwatch stopWatch = new Stopwatch();
  
positive.code: 
      }
    }
    print("Done");
  }
  
  /**
   * This class merely holds the solution found so it can be returned by some function.
   */
  //class Solution {
  //  int multiple;
  //  int forwardNumber;
  //  int reversedNumber;
  //  Solution(this.forwardNumber, this.reversedNumber, this.multiple);
  //}
  
  // This class holds the number to be used to compare against its (in base) reversed form,
  // and methods to reverse and print them.  When printed, they need to be in the
  // specified base.
  //
  // 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, which means the series of digits for the
  // forward version cannot start or end with a zero.
  //
  // So, you have to be able to convert an integer to a series or list of digits
  // for checking length and for checking for 0 digits.
  //
  // You also need to print both the forward and reversed numbers, and they need
  // to be strings, or easily converted to strings.
  //
  // I think that digits are most easily stored as an array of integers, as in
  // List<int>, or as List<String> where each element is a single digit, like "f"
  // in base 16.  Strings themselves are immutable, so you cannot do something like
  // forwardString[2] = "1";  You'd have to do multi-step operations where a new
  // String would be created.
  //
  // Therefore a forward and reversed digits will be of type List<String>.  That
  // way I can reverse them easily.  Creating a single string can be done with
  // a StringBuffer.  So, forward[2] would be "1", or "a".
  //
  // The number has to be easily incremented, or set, or maybe decremented.
  // So, operators "++", "--", and "=", and "==" overloaded would be good.
  //
  class TedNumber {
    int base;
    int nDigits;
    int value;
    int reversedValue;
    int multiple;
    List<String> digits; // do we want to store this and update it every time the number changes?
  
    TedNumber(int base, int nDigits, int value) {
      //print("In constructor");
      this.base = base;
      this.nDigits = nDigits;
      this.value = value;
      this.digits = new List<String>.filled(this.nDigits, '0'); // want this?
      updateDigits(); // update "digits" with "value"
    }
  
    /**
     * Increment "value", and update the digits.
     */
    increment() {
      //print("In increment()");
      value++;
      updateDigits();
    }
    /**
     * Update the digits list by converting "value" to a string in the base,
     * then transfer those characters into "digits" list.
     */
    updateDigits() {
      //print("In updateDigits()");
      String digitsStringValue = value.toRadixString(base);
      if (digitsStringValue.length > nDigits) {
        return; // not sure this is best
      }
      int nCharsValueInBase = digitsStringValue.length;
      for (int ctr = 0; ctr < nCharsValueInBase; ctr++) {
        digits[nDigits - nCharsValueInBase + ctr] = digitsStringValue[ctr];
      }
      //look for solution
      //return;
    }
  
    /**
  
negative.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.
     */
    bool hasSolution() {
      if (digits[0] == "0" || digits[nDigits - 1] == "0") {
        return false;
      }
      reversedValue = getReversedValue();
      if (value == reversedValue) {
        return false; // Don't want multiple of 1
      }
      int mDivNRemainder = reversedValue % value;
      if (mDivNRemainder == 0) {
        multiple = reversedValue ~/ value;
        return true;
      }
      return false;
    }
  
    /**
     * This reverses "digits" and calls a method to get a String representation
     * and then returns that.
     */
    String reverseDigitsAsString() {
      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.
     */
    String digitsToString(List<String> digits) {
      StringBuffer resultStringBuffer = new StringBuffer();
      for (int ctr = 0; ctr < digits.length; ctr++) {
        String digit = digits.elementAt(ctr);
  