public static NumberWrapper divideComputation(NumberWrapper x, NumberWrapper y) {
    try {
      { double floatresult = Stella.NULL_FLOAT;

        { Surrogate testValue000 = Stella_Object.safePrimaryType(x);

          if (Surrogate.subtypeOfIntegerP(testValue000)) {
            { IntegerWrapper x000 = ((IntegerWrapper)(x));

              { Surrogate testValue001 = Stella_Object.safePrimaryType(y);

                if (Surrogate.subtypeOfIntegerP(testValue001)) {
                  { IntegerWrapper y000 = ((IntegerWrapper)(y));

                    if (((x000.wrapperValue) % (y000.wrapperValue)) == 0) {
                      return (IntegerWrapper.wrapInteger(((x000.wrapperValue) / (y000.wrapperValue))));
                    }
                    else {
                      floatresult = ((double)(x000.wrapperValue)) / ((double)(y000.wrapperValue));
                    }
                  }
                }
                else if (Surrogate.subtypeOfFloatP(testValue001)) {
                  { FloatWrapper y000 = ((FloatWrapper)(y));

                    floatresult = x000.wrapperValue / y000.wrapperValue;
                  }
                }
                else {
                  { OutputStringStream stream000 = OutputStringStream.newOutputStringStream();

                    stream000.nativeStream.print("`" + testValue001 + "' is not a valid case option");
                    throw ((StellaException)(StellaException.newStellaException(stream000.theStringReader()).fillInStackTrace()));
                  }
                }
              }
            }
          }
          else if (Surrogate.subtypeOfFloatP(testValue000)) {
            { FloatWrapper x000 = ((FloatWrapper)(x));

              { Surrogate testValue002 = Stella_Object.safePrimaryType(y);

                if (Surrogate.subtypeOfIntegerP(testValue002)) {
                  { IntegerWrapper y000 = ((IntegerWrapper)(y));

                    floatresult = x000.wrapperValue / y000.wrapperValue;
                  }
                }
                else if (Surrogate.subtypeOfFloatP(testValue002)) {
                  { FloatWrapper y000 = ((FloatWrapper)(y));

                    floatresult = x000.wrapperValue / y000.wrapperValue;
                  }
                }
                else {
                  { OutputStringStream stream001 = OutputStringStream.newOutputStringStream();

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

              stream002.nativeStream.print("`" + testValue000 + "' is not a valid case option");
              throw ((StellaException)(StellaException.newStellaException(stream002.theStringReader()).fillInStackTrace()));
            }
          }
        }
        return (FloatWrapper.wrapFloat(floatresult));
      }
    } catch (java.lang.Exception e000) {
      return (null);
    }
  }