public static void incorporateInputParameters(MethodSlot method, Cons parameters) {
    if (parameters == Stella.NIL) {
      return;
    }
    { Symbol name = null;
      StandardObject ts = null;
      Symbol direction = null;
      boolean variableargsP = false;

      method.methodParameterNames = List.newList();
      method.methodParameterTypeSpecifiers = List.newList();
      { Stella_Object p = null;
        Cons iter000 = parameters;

        loop000 : for (;!(iter000 == Stella.NIL); iter000 = iter000.rest) {
          p = iter000.value;
          { Surrogate testValue000 = Stella_Object.safePrimaryType(p);

            if (testValue000 == Stella.SGT_STELLA_CONS) {
              { Cons p000 = ((Cons)(p));

                switch (p000.length()) {
                  case 2: 
                    direction = Stella.SYM_STELLA_IN;
                  break;
                  case 3: 
                    if ((p000.value == Stella.SYM_STELLA_IN) ||
                        ((p000.value == Stella.SYM_STELLA_OUT) ||
                         (p000.value == Stella.SYM_STELLA_INOUT))) {
                      direction = ((Symbol)(p000.value));
                      if (List.nullListP(method.methodParameterDirections())) {
                        KeyValueList.setDynamicSlotValue(method.dynamicSlots, Stella.SYM_STELLA_METHOD_PARAMETER_DIRECTIONS, List.newList(), null);
                        { Stella_Object par = null;
                          Cons iter001 = parameters;

                          loop001 : for (;!(iter001 == Stella.NIL); iter001 = iter001.rest) {
                            par = iter001.value;
                            if (par == p000) {
                              break loop001;
                            }
                            else {
                              method.methodParameterDirections().insert(Stella.SYM_STELLA_IN);
                            }
                          }
                        }
                      }
                    }
                    else {
                      { 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 direction for method parameter: `" + Stella_Object.deUglifyParseTree(p000) + "'.");
                            }
;
                          }

                        } finally {
                          Stella.$PRINTREADABLYp$.set(old$PrintreadablyP$000);
                        }
                      }
                      direction = Stella.SYM_STELLA_IN;
                    }
                    p000 = p000.rest;
                  break;
                  default:
                    { 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 method parameter: `" + Stella_Object.deUglifyParseTree(p000) + "'.");
                          }
;
                        }

                      } finally {
                        Stella.$PRINTREADABLYp$.set(old$PrintreadablyP$001);
                      }
                    }
                    continue loop000;
                }
                if (variableargsP) {
                  { Cons varargtype = Cons.list$(Cons.cons(Stella.SYM_STELLA_ARGUMENT_LIST, Cons.cons(Stella.SYM_STELLA_OF, Cons.cons(p000.rest.value, Cons.cons(Stella.NIL, Stella.NIL)))));

                    name = ((Symbol)(p000.value));
                    ts = varargtype.yieldTypeSpecifier();
                  }
                }
                else {
                  {
                    if (!(Stella_Object.symbolP(p000.value) &&
                        (Stella_Object.symbolP(p000.rest.value) ||
                         (Stella_Object.surrogateP(p000.rest.value) ||
                          Stella_Object.consP(p000.rest.value))))) {
                      { 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 method parameter: `" + Stella_Object.deUglifyParseTree(p000) + "'.");
                            }
;
                          }

                        } finally {
                          Stella.$PRINTREADABLYp$.set(old$PrintreadablyP$002);
                        }
                      }
                      continue loop000;
                    }
                    name = ((Symbol)(p000.value));
                    ts = p000.rest.value.yieldTypeSpecifier();
                  }
                }
              }
            }
            else if (Surrogate.subtypeOfSymbolP(testValue000)) {
              { Symbol p000 = ((Symbol)(p));

                if (p000 == Stella.SYM_STELLA_aREST) {
                  KeyValueList.setDynamicSlotValue(method.dynamicSlots, Stella.SYM_STELLA_METHOD_VARIABLE_ARGUMENTSp, Stella.TRUE_WRAPPER, Stella.FALSE_WRAPPER);
                  variableargsP = true;
                  continue loop000;
                }
                else if (p000 == Stella.SYM_STELLA_aBODY) {
                  KeyValueList.setDynamicSlotValue(method.dynamicSlots, Stella.SYM_STELLA_METHOD_BODY_ARGUMENTp, Stella.TRUE_WRAPPER, Stella.FALSE_WRAPPER);
                  continue loop000;
                }
                else {
                  { Object old$PrintreadablyP$003 = 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(" Untyped parameter in parameter list: `" + Stella_Object.deUglifyParseTree(parameters) + "'.");
                        }
;
                      }

                    } finally {
                      Stella.$PRINTREADABLYp$.set(old$PrintreadablyP$003);
                    }
                  }
                  name = p000;
                  ts = Stella.SGT_STELLA_UNKNOWN;
                }
              }
            }
            else {
              { Object old$PrintreadablyP$004 = 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 parameter list: `" + Stella_Object.deUglifyParseTree(parameters) + "'.");
                    }
;
                  }

                } finally {
                  Stella.$PRINTREADABLYp$.set(old$PrintreadablyP$004);
                }
              }
              continue loop000;
            }
          }
          method.methodParameterTypeSpecifiers().insert(ts);
          method.methodParameterNames().insert(((Symbol)(name.permanentify())));
          if (List.definedListP(method.methodParameterDirections())) {
            method.methodParameterDirections().insert(direction);
          }
        }
      }
      method.methodParameterNames().reverse();
      method.methodParameterTypeSpecifiers().reverse();
      method.methodParameterDirections().reverse();
    }
  }