public static Cons walkSlotOnAbstractTypeTree(Cons tree, Surrogate abstracttype, Object [] MV_returnarray) {
    { Stella_Object methodname = tree.value;
      MethodSlot prototypemethod = Symbol.findPrototypeMethod(((Symbol)(methodname)), abstracttype);
      boolean undefinedmethodP = true;
      Stella_Object otree = null;
      StandardObject otype = null;

      if (prototypemethod != null) {
        undefinedmethodP = false;
        if (Stella.warnAboutMissingMethodsP()) {
          { int nofsubs = Stella.NULL_INTEGER;
            int nofmethods = Stella.NULL_INTEGER;
            boolean compatibleP = false;

            { Object [] caller_MV_returnarray = new Object[2];

              nofsubs = MethodSlot.compatibleRealMethods(prototypemethod, abstracttype, caller_MV_returnarray);
              nofmethods = ((int)(((IntegerWrapper)(caller_MV_returnarray[0])).wrapperValue));
              compatibleP = ((boolean)(((BooleanWrapper)(caller_MV_returnarray[1])).wrapperValue));
            }
            if ((nofsubs == nofmethods) &&
                compatibleP) {
              { Object old$PrintreadablyP$000 = Stella.$PRINTREADABLYp$.get();

                try {
                  Native.setBooleanSpecial(Stella.$PRINTREADABLYp$, true);
                  Stella.signalTranslationNote();
                  if (!(Stella.suppressWarningsP())) {
                    Stella.printErrorContext(">> NOTE: ", Stella.STANDARD_OUTPUT);
                    {
                      System.out.println();
                      System.out.println(" Inferred the method `" + Stella_Object.deUglifyParseTree(methodname) + "' on the abstract");
                      System.out.println("   type `" + Stella_Object.deUglifyParseTree(abstracttype) + "', since `" + Stella_Object.deUglifyParseTree(methodname) + "' is implemented");
                      System.out.println("   on all non-abstract subtypes of `" + Stella_Object.deUglifyParseTree(abstracttype) + "'.");
                    }
;
                  }

                } finally {
                  Stella.$PRINTREADABLYp$.set(old$PrintreadablyP$000);
                }
              }
              tree.secondSetter(Stella_Object.sysTree(tree.rest.value, prototypemethod.slotOwner, new Object[1]));
              { Object [] caller_MV_returnarray = new Object[1];

                otree = Cons.walkCallSlotTree(tree, caller_MV_returnarray);
                otype = ((StandardObject)(caller_MV_returnarray[0]));
              }
            }
            else if (nofsubs == nofmethods) {
              { Object old$PrintreadablyP$001 = Stella.$PRINTREADABLYp$.get();

                try {
                  Native.setBooleanSpecial(Stella.$PRINTREADABLYp$, true);
                  Stella.signalTranslationWarning();
                  if (!(Stella.suppressWarningsP())) {
                    Stella.printErrorContext(">> WARNING: ", Stella.STANDARD_WARNING);
                    {
                      Stella.STANDARD_WARNING.nativeStream.println();
                      Stella.STANDARD_WARNING.nativeStream.println(" Could not infer `" + Stella_Object.deUglifyParseTree(methodname) + "' on abstract type `" + Stella_Object.deUglifyParseTree(abstracttype) + "',");
                      Stella.STANDARD_WARNING.nativeStream.println("   since the implementations of `" + Stella_Object.deUglifyParseTree(methodname) + "' on the non-abstract");
                      Stella.STANDARD_WARNING.nativeStream.println("   subtypes of `" + Stella_Object.deUglifyParseTree(abstracttype) + "' are not all compatible.");
                    }
;
                  }

                } finally {
                  Stella.$PRINTREADABLYp$.set(old$PrintreadablyP$001);
                }
              }
            }
            else {
              { Object old$PrintreadablyP$002 = Stella.$PRINTREADABLYp$.get();

                try {
                  Native.setBooleanSpecial(Stella.$PRINTREADABLYp$, true);
                  Stella.signalTranslationWarning();
                  if (!(Stella.suppressWarningsP())) {
                    Stella.printErrorContext(">> WARNING: ", Stella.STANDARD_WARNING);
                    {
                      Stella.STANDARD_WARNING.nativeStream.println();
                      Stella.STANDARD_WARNING.nativeStream.println(" Could not infer `" + Stella_Object.deUglifyParseTree(methodname) + "' on abstract type `" + Stella_Object.deUglifyParseTree(abstracttype) + "',");
                      Stella.STANDARD_WARNING.nativeStream.println("   since `" + Stella_Object.deUglifyParseTree(methodname) + "' is only implemented on `" + Stella_Object.deUglifyParseTree(IntegerWrapper.wrapInteger(nofmethods)) + "' of the `" + Stella_Object.deUglifyParseTree(IntegerWrapper.wrapInteger(nofsubs)) + "'");
                      Stella.STANDARD_WARNING.nativeStream.println("   non-abstract subtypes of `" + Stella_Object.deUglifyParseTree(abstracttype) + "'.");
                    }
;
                  }

                } finally {
                  Stella.$PRINTREADABLYp$.set(old$PrintreadablyP$002);
                }
              }
              if (!(compatibleP)) {
                System.out.println(" Additionally, the method signatures are not compatible.");
              }
            }
          }
        }
      }
      if (undefinedmethodP) {
        { Cons value000 = null;
          Surrogate value001 = null;

          { Object [] caller_MV_returnarray = new Object[1];

            value000 = Cons.walkUndefinedSlotTree(tree, abstracttype, Stella.warnAboutUndefinedMethodsP(), caller_MV_returnarray);
            value001 = ((Surrogate)(caller_MV_returnarray[0]));
          }
          {
            otree = value000;
            otype = value001;
          }
        }
      }
      else {
        { Cons value002 = null;
          Surrogate value003 = null;

          { Object [] caller_MV_returnarray = new Object[1];

            value002 = Cons.walkUndefinedSlotTree(tree, abstracttype, false, caller_MV_returnarray);
            value003 = ((Surrogate)(caller_MV_returnarray[0]));
          }
          {
            otree = value002;
            otype = value003;
          }
        }
      }
      { Cons _return_temp = ((Cons)(otree));

        MV_returnarray[0] = otype;
        return (_return_temp);
      }
    }
  }