public static Cons walkMvBindTree(Cons tree, Object [] MV_returnarray) {
    if ((tree.length() < 3) ||
        (!Stella_Object.consP(tree.rest.value))) {
      { 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-bind' expression: `" + Stella_Object.deUglifyParseTree(tree) + "'.");
            }
;
          }

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

      { ConsIterator it = declarations.allocateIterator();

        while (it.nextP()) {
          decl = it.value;
          { Surrogate testValue000 = Stella_Object.safePrimaryType(decl);

            if (testValue000 == Stella.SGT_STELLA_CONS) {
              { Cons decl000 = ((Cons)(decl));

                if (!(Stella_Object.symbolP(decl000.value) &&
                    (decl000.length() == 2))) {
                  { Object old$PrintreadablyP$001 = 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 variable declaration `" + Stella_Object.deUglifyParseTree(decl000) + "' in 'mv-bind' expression: `" + Stella_Object.deUglifyParseTree(tree) + "'.");
                        }
;
                      }

                    } finally {
                      Stella.$PRINTREADABLYp$.set(old$PrintreadablyP$001);
                    }
                  }
                  return (Stella_Object.walkDontCallMeTree(tree, Stella.SGT_STELLA_VOID, MV_returnarray));
                }
                targettypes.push(decl000.rest.value.yieldTypeSpecifier());
                decl000.rest.rest = Cons.cons(Stella.SYM_STELLA_NULL, Stella.NIL);
                variables = Cons.cons(decl000.value, variables);
              }
            }
            else if (Surrogate.subtypeOfSymbolP(testValue000)) {
              { Symbol decl000 = ((Symbol)(decl));

                targettypes.push(Stella.SGT_STELLA_UNKNOWN);
                it.valueSetter(Cons.cons(decl000, Cons.list$(Cons.cons(Stella.SGT_STELLA_UNKNOWN, Cons.cons(Stella.SYM_STELLA_NULL, Cons.cons(Stella.NIL, Stella.NIL))))));
                variables = Cons.cons(decl000, variables);
              }
            }
            else {
              { Object old$PrintreadablyP$002 = 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 variable `" + Stella_Object.deUglifyParseTree(decl) + "' in 'mv-bind' expression: `" + Stella_Object.deUglifyParseTree(tree) + "'.");
                    }
;
                  }

                } finally {
                  Stella.$PRINTREADABLYp$.set(old$PrintreadablyP$002);
                }
              }
              return (Stella_Object.walkDontCallMeTree(tree, Stella.SGT_STELLA_VOID, MV_returnarray));
            }
          }
        }
      }
      variables = variables.reverse();
      { Stella_Object variable = null;
        Cons iter000 = variables;

        for (;!(iter000 == Stella.NIL); iter000 = iter000.rest) {
          variable = iter000.value;
          Symbol.pushVariableBinding(((Symbol)(variable)), Stella.SGT_STELLA_UNINITIALIZED);
        }
      }
      { Stella_Object omvtree = null;
        Cons valuestree = null;
        List variabletypes = null;

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

          omvtree = Stella_Object.walkMvExpressionTree(mvtree, targettypes.reverse(), Stella.SYM_STELLA_MV_BIND, caller_MV_returnarray);
          valuestree = ((Cons)(caller_MV_returnarray[0]));
          variabletypes = ((List)(caller_MV_returnarray[1]));
        }
        { Stella_Object variable = null;
          Cons iter001 = variables;

          for (;!(iter001 == Stella.NIL); iter001 = iter001.rest) {
            variable = iter001.value;
            variable = variable;
            Stella.popVariableBinding();
          }
        }
        targettypes.free();
        tree.rest.rest.rest = Stella.NIL;
        { Cons decl000 = null;
          Cons iter002 = ((Cons)(declarations));
          StandardObject type = null;
          Cons iter003 = variabletypes.theConsList;

          for (;(!(iter002 == Stella.NIL)) &&
                    (!(iter003 == Stella.NIL)); iter002 = iter002.rest, iter003 = iter003.rest) {
            decl000 = ((Cons)(iter002.value));
            type = ((StandardObject)(iter003.value));
            if (Stella.SGT_STELLA_UNKNOWN == decl000.rest.value) {
              decl000.secondSetter(type);
            }
          }
        }
        variabletypes.free();
        if (valuestree != null) {
          valuestree.firstSetter(Stella.SYM_STELLA_PROGN);
          { ConsIterator it = valuestree.rest.allocateIterator();
            Stella_Object var = null;
            Cons iter004 = variables;

            for (;it.nextP() &&
                      (!(iter004 == Stella.NIL)); iter004 = iter004.rest) {
              var = iter004.value;
              it.valueSetter(Cons.list$(Cons.cons(Stella.SYM_STELLA_SETQ, Cons.cons(var, Cons.cons(Cons.cons(it.value, Stella.NIL), Stella.NIL)))));
            }
          }
          valuestree = ((Cons)(omvtree));
        }
        else {
          valuestree = Cons.list$(Cons.cons(Stella.SYM_STELLA_MV_SETQ, Cons.cons(variables, Cons.cons(Cons.cons(omvtree, Stella.NIL), Stella.NIL))));
        }
        return (Cons.walkAConsTree(Cons.list$(Cons.cons(Stella.SYM_STELLA_LET, Cons.cons(declarations, Cons.cons(Cons.cons(valuestree, body.concatenate(Stella.NIL, Stella.NIL)), Stella.NIL)))), MV_returnarray));
      }
    }
  }