public static Stella_Object coerceMvTree(Stella_Object tree, Symbol operator, List sourcetypes, List targettypes, Object [] MV_returnarray) {
    { boolean valuestreeP = Stella_Object.valuesTreeP(tree);
      Cons valuestree = Stella.NIL;
      boolean needtemporariesP = false;
      boolean successP = false;
      Stella_Object otree = null;
      StandardObject otype = null;
      List returntypes = List.newList();

      if (valuestreeP) {
        valuestree = ((Cons)(tree));
      }
      else {
        valuestree = Cons.cons(Stella.SYM_STELLA_VALUES, Stella.NIL);
        { StandardObject type = null;
          Cons iter000 = sourcetypes.theConsList;
          Cons collect000 = null;

          for (;!(iter000 == Stella.NIL); iter000 = iter000.rest) {
            type = ((StandardObject)(iter000.value));
            if (collect000 == null) {
              {
                collect000 = Cons.cons(Stella_Object.sysTree(null, type, new Object[1]), Stella.NIL);
                if (valuestree == Stella.NIL) {
                  valuestree = collect000;
                }
                else {
                  Cons.addConsToEndOfConsList(valuestree, collect000);
                }
              }
            }
            else {
              {
                collect000.rest = Cons.cons(Stella_Object.sysTree(null, type, new Object[1]), Stella.NIL);
                collect000 = collect000.rest;
              }
            }
          }
        }
      }
      { StandardObject tgtts = null;
        Cons iter001 = targettypes.theConsList;
        StandardObject srcts = null;
        Cons iter002 = sourcetypes.theConsList;
        int i = Stella.NULL_INTEGER;
        int iter003 = 1;
        ConsIterator it = valuestree.rest.allocateIterator();
        Cons collect001 = null;

        for (;(!(iter001 == Stella.NIL)) &&
                  ((!(iter002 == Stella.NIL)) &&
                   it.nextP()); 
              iter001 = iter001.rest,
              iter002 = iter002.rest,
              iter003 = iter003 + 1) {
          tgtts = ((StandardObject)(iter001.value));
          srcts = ((StandardObject)(iter002.value));
          i = iter003;
          { Object [] caller_MV_returnarray = new Object[2];

            otree = Stella_Object.helpCoerceATree(it.value, srcts, tgtts, false, caller_MV_returnarray);
            otype = ((StandardObject)(caller_MV_returnarray[0]));
            successP = ((boolean)(((BooleanWrapper)(caller_MV_returnarray[1])).wrapperValue));
          }
          if (!(successP)) {
            { Object old$PrintreadablyP$000 = Stella.$PRINTREADABLYp$.get();

              try {
                Native.setBooleanSpecial(Stella.$PRINTREADABLYp$, true);
                Stella.signalTranslationError();
                if (!(Stella.suppressWarningsP())) {
                  Stella.printErrorContext(">> ERROR: ", Stella.STANDARD_ERROR);
                  {
                    Stella.STANDARD_ERROR.nativeStream.println();
                    Stella.STANDARD_ERROR.nativeStream.println(" Type clash on argument `" + Stella_Object.deUglifyParseTree(IntegerWrapper.wrapInteger(i)) + "' of `" + Stella_Object.deUglifyParseTree(operator) + "' operator.");
                    Stella.STANDARD_ERROR.nativeStream.println(" `" + Stella_Object.deUglifyParseTree(srcts) + "' found where `" + Stella_Object.deUglifyParseTree(tgtts) + "' expected.");
                  }
;
                }

              } finally {
                Stella.$PRINTREADABLYp$.set(old$PrintreadablyP$000);
              }
            }
            { Stella_Object _return_temp = tree;

              MV_returnarray[0] = ((Cons)((valuestreeP ? tree : ((Stella_Object)(null)))));
              MV_returnarray[1] = targettypes.copy();
              return (_return_temp);
            }
          }
          if ((!Stella_Object.eqlP(otree, it.value)) ||
              ((i > 1) &&
               ((!valuestreeP) &&
                ((!(((Keyword)(Stella.$TRANSLATOROUTPUTLANGUAGE$.get())) == Stella.KWD_COMMON_LISP)) &&
                 ((!(StandardObject.typeSpecToBaseType(tgtts) == Stella.SGT_STELLA_UNKNOWN)) &&
                  (!(StandardObject.typeSpecToBaseType(srcts) == StandardObject.typeSpecToBaseType(tgtts)))))))) {
            needtemporariesP = true;
          }
          it.valueSetter(otree);
          if (collect001 == null) {
            {
              collect001 = Cons.cons(otype, Stella.NIL);
              if (returntypes.theConsList == Stella.NIL) {
                returntypes.theConsList = collect001;
              }
              else {
                Cons.addConsToEndOfConsList(returntypes.theConsList, collect001);
              }
            }
          }
          else {
            {
              collect001.rest = Cons.cons(otype, Stella.NIL);
              collect001 = collect001.rest;
            }
          }
        }
      }
      if (valuestreeP) {
        { Stella_Object _return_temp = tree;

          MV_returnarray[0] = ((Cons)(tree));
          MV_returnarray[1] = returntypes;
          return (_return_temp);
        }
      }
      if (!needtemporariesP) {
        { Stella_Object _return_temp = tree;

          MV_returnarray[0] = null;
          MV_returnarray[1] = returntypes;
          return (_return_temp);
        }
      }
      valuestree = Cons.cons(Stella.SYM_STELLA_VALUES, Stella.NIL);
      { int i = Stella.NULL_INTEGER;
        int iter004 = 1;
        int upperBound000 = targettypes.length();
        Cons collect002 = null;

        for (;iter004 <= upperBound000; iter004 = iter004 + 1) {
          i = iter004;
          i = i;
          if (collect002 == null) {
            {
              collect002 = Cons.cons(Stella.localGensym("VALUE"), Stella.NIL);
              if (valuestree == Stella.NIL) {
                valuestree = collect002;
              }
              else {
                Cons.addConsToEndOfConsList(valuestree, collect002);
              }
            }
          }
          else {
            {
              collect002.rest = Cons.cons(Stella.localGensym("VALUE"), Stella.NIL);
              collect002 = collect002.rest;
            }
          }
        }
      }
      otree = Stella_Object.walkWithoutTypeTree(Cons.list$(Cons.cons(Stella.SYM_STELLA_MV_BIND, Cons.cons(Cons.copyConsList(valuestree.rest), Cons.cons(Cons.cons(tree, Cons.cons(valuestree, Stella.NIL)), Stella.NIL)))));
      valuestree.firstSetter(Stella.getQuotedTree("((VALUES) \"/STELLA\")", "/STELLA"));
      { ConsIterator it = valuestree.rest.allocateIterator();
        StandardObject srcts = null;
        Cons iter005 = sourcetypes.theConsList;
        StandardObject tgtts = null;
        Cons iter006 = targettypes.theConsList;

        for (;it.nextP() &&
                  ((!(iter005 == Stella.NIL)) &&
                   (!(iter006 == Stella.NIL))); iter005 = iter005.rest, iter006 = iter006.rest) {
          srcts = ((StandardObject)(iter005.value));
          tgtts = ((StandardObject)(iter006.value));
          it.valueSetter(Stella_Object.coerceATree(it.value, srcts, tgtts, new Object[1]));
        }
      }
      { Stella_Object _return_temp = otree;

        MV_returnarray[0] = valuestree;
        MV_returnarray[1] = returntypes;
        return (_return_temp);
      }
    }
  }