public static Cons walkMvSetqTree(Cons tree, Object [] MV_returnarray) {
    { boolean testValue000 = false;

      if (Cons.badArgumentCountP(tree, 2)) {
        testValue000 = true;
      }
      else {
        if (!Stella_Object.consP(tree.rest.value)) {
          testValue000 = true;
        }
        else {
          {
            { boolean alwaysP000 = true;

              { Stella_Object v = null;
                Cons iter000 = ((Cons)(tree.rest.value));

                loop000 : for (;!(iter000 == Stella.NIL); iter000 = iter000.rest) {
                  v = iter000.value;
                  if (!Stella_Object.symbolP(v)) {
                    alwaysP000 = false;
                    break loop000;
                  }
                }
              }
              testValue000 = alwaysP000;
            }
            testValue000 = !testValue000;
          }
        }
      }
      if (testValue000) {
        { 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(" Illegal 'mv-setq' expression: `" + Stella_Object.deUglifyParseTree(tree) + "'.");
              }
;
            }

          } finally {
            Stella.$PRINTREADABLYp$.set(old$PrintreadablyP$000);
          }
        }
        return (Stella_Object.walkDontCallMeTree(tree, Stella.SGT_STELLA_VOID, MV_returnarray));
      }
    }
    { Cons variables = ((Cons)(tree.rest.value));
      List targettypes = List.newList();

      { ConsIterator it = variables.allocateIterator();
        Cons collect000 = null;

        while (it.nextP()) {
          it.valueSetter(Symbol.trueVariableName(((Symbol)(it.value))));
          if (collect000 == null) {
            {
              collect000 = Cons.cons(Symbol.lookupVariableType(((Symbol)(it.value))), Stella.NIL);
              if (targettypes.theConsList == Stella.NIL) {
                targettypes.theConsList = collect000;
              }
              else {
                Cons.addConsToEndOfConsList(targettypes.theConsList, collect000);
              }
            }
          }
          else {
            {
              collect000.rest = Cons.cons(Symbol.lookupVariableType(((Symbol)(it.value))), Stella.NIL);
              collect000 = collect000.rest;
            }
          }
        }
      }
      { Stella_Object otree = null;
        Cons valuestree = null;
        List valuetypes = null;

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

          otree = Stella_Object.walkMvExpressionTree(tree.rest.rest.value, targettypes, Stella.SYM_STELLA_MV_SETQ, caller_MV_returnarray);
          valuestree = ((Cons)(caller_MV_returnarray[0]));
          valuetypes = ((List)(caller_MV_returnarray[1]));
        }
        valuetypes.free();
        targettypes.free();
        if (valuestree != null) {
          valuestree.firstSetter(Stella.SYM_STELLA_PROGN);
          { ConsIterator it = valuestree.rest.allocateIterator();
            Stella_Object var = null;
            Cons iter001 = variables;

            for (;it.nextP() &&
                      (!(iter001 == Stella.NIL)); iter001 = iter001.rest) {
              var = iter001.value;
              it.valueSetter(Cons.list$(Cons.cons(Stella.SYM_STELLA_SETQ, Cons.cons(var, Cons.cons(Cons.cons(it.value, Stella.NIL), Stella.NIL)))));
            }
          }
          tree.rest.rest = Stella.NIL;
          return (Stella_Object.sysTree(otree, Stella.SGT_STELLA_VOID, MV_returnarray));
        }
        tree.thirdSetter(otree);
        return (Stella_Object.sysTree(tree, Stella.SGT_STELLA_VOID, MV_returnarray));
      }
    }
  }