public static String normalizeFetchQueryArguments(Proposition proposition, Stella_Object arguments, Object [] MV_returnarray) {
    if (!(Stella_Object.stringP(arguments))) {
      { OutputStringStream stream000 = OutputStringStream.newOutputStringStream();

        { Object old$PrintreadablyP$000 = Stella.$PRINTREADABLYp$.get();

          try {
            Native.setBooleanSpecial(Stella.$PRINTREADABLYp$, true);
            stream000.nativeStream.println("PARSING ERROR: Fetch-EDB-query: illegal pattern arguments: `" + arguments + "'.");
            Logic.helpSignalPropositionError(stream000, RDBMS.KWD_ERROR);

          } finally {
            Stella.$PRINTREADABLYp$.set(old$PrintreadablyP$000);
          }
        }
        throw ((ParsingError)(ParsingError.newParsingError(stream000.theStringReader()).fillInStackTrace()));
      }
    }
    { Stella_Object args = Stella.readSExpressionFromString(((StringWrapper)(arguments)).wrapperValue);
      Cons cursor = null;
      String queryid = null;
      Cons outputargs = Stella.NIL;
      Cons parameters = Stella.NIL;
      Stella_Object parametervalue = null;

      if (Stella_Object.safePrimaryType(args) == RDBMS.SGT_STELLA_CONS) {
        { Cons args000 = ((Cons)(args));

          { boolean testValue000 = false;

            testValue000 = (Stella_Object.consP(args000.value) &&
                (((args000.length()) % 2) == 0)) ||
                ((!Stella_Object.consP(args000.value)) &&
                 (((args000.length()) % 2) == 1));
            if (testValue000) {
              { boolean alwaysP000 = true;

                { Stella_Object arg = null;
                  Cons iter000 = args000.rest;

                  loop000 : for (;!(iter000 == Stella.NIL); iter000 = iter000.rest) {
                    arg = iter000.value;
                    if (!(!Stella_Object.consP(arg))) {
                      alwaysP000 = false;
                      break loop000;
                    }
                  }
                }
                testValue000 = alwaysP000;
              }
            }
            if (!(testValue000)) {
              { OutputStringStream stream001 = OutputStringStream.newOutputStringStream();

                { Object old$PrintreadablyP$001 = Stella.$PRINTREADABLYp$.get();

                  try {
                    Native.setBooleanSpecial(Stella.$PRINTREADABLYp$, true);
                    stream001.nativeStream.println("PARSING ERROR: Fetch-EDB-query: illegal pattern arguments: `" + arguments + "'.");
                    Logic.helpSignalPropositionError(stream001, RDBMS.KWD_ERROR);

                  } finally {
                    Stella.$PRINTREADABLYp$.set(old$PrintreadablyP$001);
                  }
                }
                throw ((ParsingError)(ParsingError.newParsingError(stream001.theStringReader()).fillInStackTrace()));
              }
            }
          }
          cursor = args000;
          if (Stella_Object.consP(cursor.value)) {
            { Stella_Object outarg = null;
              Cons iter001 = ((Cons)(cursor.value));
              Cons collect000 = null;

              for (;!(iter001 == Stella.NIL); iter001 = iter001.rest) {
                outarg = iter001.value;
                if (collect000 == null) {
                  {
                    collect000 = Cons.cons(StringWrapper.wrapString(Stella_Object.coerceToString(outarg)), Stella.NIL);
                    if (outputargs == Stella.NIL) {
                      outputargs = collect000;
                    }
                    else {
                      Cons.addConsToEndOfConsList(outputargs, collect000);
                    }
                  }
                }
                else {
                  {
                    collect000.rest = Cons.cons(StringWrapper.wrapString(Stella_Object.coerceToString(outarg)), Stella.NIL);
                    collect000 = collect000.rest;
                  }
                }
              }
            }
            cursor = cursor.rest;
          }
          else {
            outputargs = RDBMS.getTableColumnNames(Logic.getDescription(((Surrogate)(proposition.operator))));
            if (outputargs == null) {
              { OutputStringStream stream002 = OutputStringStream.newOutputStringStream();

                { Object old$PrintreadablyP$002 = Stella.$PRINTREADABLYp$.get();

                  try {
                    Native.setBooleanSpecial(Stella.$PRINTREADABLYp$, true);
                    stream002.nativeStream.println("PARSING ERROR: Fetch-EDB-query: missing output arg/column specifications for: `" + Logic.getDescription(((Surrogate)(proposition.operator))) + "'.");
                    Logic.helpSignalPropositionError(stream002, RDBMS.KWD_ERROR);

                  } finally {
                    Stella.$PRINTREADABLYp$.set(old$PrintreadablyP$002);
                  }
                }
                throw ((ParsingError)(ParsingError.newParsingError(stream002.theStringReader()).fillInStackTrace()));
              }
            }
          }
          queryid = Stella_Object.coerceToString(cursor.value);
          cursor = cursor.rest;
          parameters = cursor;
          while (!(cursor == Stella.NIL)) {
            cursor.firstSetter(StringWrapper.wrapString(Stella_Object.coerceToString(cursor.value)));
            parametervalue = cursor.rest.value;
            if (Logic.questionMarkSymbolP(parametervalue)) {
              { Stella_Object value000 = null;

                { Stella_Object arg = null;
                  Vector vector000 = proposition.arguments;
                  int index000 = 0;
                  int length000 = vector000.length();
                  Symbol var = null;
                  Cons iter002 = Logic.getDescription(((Surrogate)(proposition.operator))).ioVariableNames.theConsList;

                  loop003 : for (;(index000 < length000) &&
                            (!(iter002 == Stella.NIL)); index000 = index000 + 1, iter002 = iter002.rest) {
                    arg = (vector000.theArray)[index000];
                    var = ((Symbol)(iter002.value));
                    if (var == parametervalue) {
                      value000 = arg;
                      break loop003;
                    }
                  }
                }
                parametervalue = value000;
              }
              if (parametervalue == null) {
                { OutputStringStream stream003 = OutputStringStream.newOutputStringStream();

                  { Object old$PrintreadablyP$003 = Stella.$PRINTREADABLYp$.get();

                    try {
                      Native.setBooleanSpecial(Stella.$PRINTREADABLYp$, true);
                      stream003.nativeStream.println("PARSING ERROR: Fetch-EDB-query: non-existent input variable: `" + cursor.rest.value + "'.");
                      Logic.helpSignalPropositionError(stream003, RDBMS.KWD_ERROR);

                    } finally {
                      Stella.$PRINTREADABLYp$.set(old$PrintreadablyP$003);
                    }
                  }
                  throw ((ParsingError)(ParsingError.newParsingError(stream003.theStringReader()).fillInStackTrace()));
                }
              }
              cursor.rest.firstSetter(parametervalue);
            }
            else {
              cursor.rest.firstSetter(StringWrapper.wrapString(Stella_Object.coerceToString(parametervalue)));
            }
            cursor = cursor.rest.rest;
          }
        }
      }
      else {
        { OutputStringStream stream004 = OutputStringStream.newOutputStringStream();

          { Object old$PrintreadablyP$004 = Stella.$PRINTREADABLYp$.get();

            try {
              Native.setBooleanSpecial(Stella.$PRINTREADABLYp$, true);
              stream004.nativeStream.println("PARSING ERROR: Fetch-EDB-query: illegal pattern arguments: `" + arguments + "'.");
              Logic.helpSignalPropositionError(stream004, RDBMS.KWD_ERROR);

            } finally {
              Stella.$PRINTREADABLYp$.set(old$PrintreadablyP$004);
            }
          }
          throw ((ParsingError)(ParsingError.newParsingError(stream004.theStringReader()).fillInStackTrace()));
        }
      }
      { PropertyList self010 = PropertyList.newPropertyList();

        self010.thePlist = parameters;
        { PropertyList value001 = self010;

          { String _return_temp = queryid;

            MV_returnarray[0] = outputargs;
            MV_returnarray[1] = value001;
            return (_return_temp);
          }
        }
      }
    }
  }