* @param t2
   * @return TimeDuration
   */
  public static TimeDuration timeMultiply(Stella_Object t1, Stella_Object t2) {
    { Surrogate testValue000 = Stella_Object.safePrimaryType(t1);

      if (Surrogate.subtypeOfP(testValue000, Stella.SGT_STELLA_CALENDAR_DATE)) {
        { CalendarDate t1000 = ((CalendarDate)(t1));

          { OutputStringStream stream000 = OutputStringStream.newOutputStringStream();

            stream000.nativeStream.print("Calendar dates cannot be involved in multiplication:  `" + t1000 + "'  `" + t2 + "'");
            throw ((StellaException)(StellaException.newStellaException(stream000.theStringReader()).fillInStackTrace()));
          }
        }
      }
      else if (Surrogate.subtypeOfP(testValue000, Stella.SGT_STELLA_TIME_DURATION)) {
        { TimeDuration t1000 = ((TimeDuration)(t1));

          { Surrogate testValue001 = Stella_Object.safePrimaryType(t2);

            if (Surrogate.subtypeOfP(testValue001, Stella.SGT_STELLA_CALENDAR_DATE)) {
              { CalendarDate t2000 = ((CalendarDate)(t2));

                { OutputStringStream stream001 = OutputStringStream.newOutputStringStream();

                  stream001.nativeStream.print("Calendar dates cannot be involved in multiplication:  `" + t1000 + "'  `" + t2000 + "'");
                  throw ((StellaException)(StellaException.newStellaException(stream001.theStringReader()).fillInStackTrace()));
                }
              }
            }
            else if (Surrogate.subtypeOfP(testValue001, Stella.SGT_STELLA_TIME_DURATION)) {
              { TimeDuration t2000 = ((TimeDuration)(t2));

                { OutputStringStream stream002 = OutputStringStream.newOutputStringStream();

                  stream002.nativeStream.print("You can't multiply two relative dates: `" + t1000 + "'  `" + t2000 + "'");
                  throw ((StellaException)(StellaException.newStellaException(stream002.theStringReader()).fillInStackTrace()));
                }
              }
            }
            else if (Surrogate.subtypeOfIntegerP(testValue001)) {
              { IntegerWrapper t2000 = ((IntegerWrapper)(t2));

                return (TimeDuration.makeTimeDuration(t1000.days * t2000.wrapperValue, t1000.millis * t2000.wrapperValue));
              }
            }
            else if (Surrogate.subtypeOfFloatP(testValue001)) {
              { FloatWrapper t2000 = ((FloatWrapper)(t2));

                return (TimeDuration.makeTimeDuration(Native.round(t1000.days * t2000.wrapperValue), Native.round(t1000.millis * t2000.wrapperValue)));
              }
            }
            else {
              { OutputStringStream stream003 = OutputStringStream.newOutputStringStream();

                stream003.nativeStream.print("`" + testValue001 + "' is not a valid case option");
                throw ((StellaException)(StellaException.newStellaException(stream003.theStringReader()).fillInStackTrace()));
              }
            }
          }
        }
      }
      else if (Surrogate.subtypeOfIntegerP(testValue000)) {
        { IntegerWrapper t1000 = ((IntegerWrapper)(t1));

          { Surrogate testValue002 = Stella_Object.safePrimaryType(t2);

            if (Surrogate.subtypeOfP(testValue002, Stella.SGT_STELLA_CALENDAR_DATE)) {
              { CalendarDate t2000 = ((CalendarDate)(t2));

                { OutputStringStream stream004 = OutputStringStream.newOutputStringStream();

                  stream004.nativeStream.print("Calendar dates cannot be involved in multiplication:  `" + t1000 + "'  `" + t2000 + "'");
                  throw ((StellaException)(StellaException.newStellaException(stream004.theStringReader()).fillInStackTrace()));
                }
              }
            }
            else if (Surrogate.subtypeOfP(testValue002, Stella.SGT_STELLA_TIME_DURATION)) {
              { TimeDuration t2000 = ((TimeDuration)(t2));

                return (TimeDuration.makeTimeDuration(t1000.wrapperValue * t2000.days, t1000.wrapperValue * t2000.millis));
              }
            }
            else if (Surrogate.subtypeOfP(testValue002, Stella.SGT_STELLA_NUMBER_WRAPPER)) {
              { NumberWrapper t2000 = ((NumberWrapper)(t2));

                { OutputStringStream stream005 = OutputStringStream.newOutputStringStream();

                  stream005.nativeStream.print("One argument must be a relative date:  `" + t1000 + "'  `" + t2000 + "'");
                  throw ((StellaException)(StellaException.newStellaException(stream005.theStringReader()).fillInStackTrace()));
                }
              }
            }
            else {
              { OutputStringStream stream006 = OutputStringStream.newOutputStringStream();

                stream006.nativeStream.print("`" + testValue002 + "' is not a valid case option");
                throw ((StellaException)(StellaException.newStellaException(stream006.theStringReader()).fillInStackTrace()));
              }
            }
          }
        }
      }
      else if (Surrogate.subtypeOfFloatP(testValue000)) {
        { FloatWrapper t1000 = ((FloatWrapper)(t1));

          { Surrogate testValue003 = Stella_Object.safePrimaryType(t2);

            if (Surrogate.subtypeOfP(testValue003, Stella.SGT_STELLA_CALENDAR_DATE)) {
              { CalendarDate t2000 = ((CalendarDate)(t2));

                { OutputStringStream stream007 = OutputStringStream.newOutputStringStream();

                  stream007.nativeStream.print("Calendar dates cannot be involved in multiplication:  `" + t1000 + "'  `" + t2000 + "'");
                  throw ((StellaException)(StellaException.newStellaException(stream007.theStringReader()).fillInStackTrace()));
                }
              }
            }
            else if (Surrogate.subtypeOfP(testValue003, Stella.SGT_STELLA_TIME_DURATION)) {
              { TimeDuration t2000 = ((TimeDuration)(t2));

                return (TimeDuration.makeTimeDuration(Native.round(t1000.wrapperValue * t2000.days), Native.round(t1000.wrapperValue * t2000.millis)));
              }
            }
            else if (Surrogate.subtypeOfP(testValue003, Stella.SGT_STELLA_NUMBER_WRAPPER)) {
              { NumberWrapper t2000 = ((NumberWrapper)(t2));

                { OutputStringStream stream008 = OutputStringStream.newOutputStringStream();

                  stream008.nativeStream.print("One argument must be a relative date:  `" + t1000 + "'  `" + t2000 + "'");
                  throw ((StellaException)(StellaException.newStellaException(stream008.theStringReader()).fillInStackTrace()));
                }
              }
            }
            else {
              { OutputStringStream stream009 = OutputStringStream.newOutputStringStream();

                stream009.nativeStream.print("`" + testValue003 + "' is not a valid case option");
                throw ((StellaException)(StellaException.newStellaException(stream009.theStringReader()).fillInStackTrace()));
              }
            }
          }
        }
      }
      else {
        { OutputStringStream stream010 = OutputStringStream.newOutputStringStream();

          stream010.nativeStream.print("`" + testValue000 + "' is not a valid case option");
          throw ((StellaException)(StellaException.newStellaException(stream010.theStringReader()).fillInStackTrace()));
        }
      }
    }
  }