public static ParametricTypeSpecifier yieldParametricTypeSpecifier(Cons typespectree) {
    { ParametricTypeSpecifier typespec = ParametricTypeSpecifier.newParametricTypeSpecifier();
      StandardObject parametertypespec = null;
      Cons cursor = typespectree;

      { Stella_Object head000 = cursor.value;

        cursor = cursor.rest;
        { Surrogate basetype = Stella_Object.typify(head000);
          StandardObject realbasetypespec = Surrogate.realTypeSpecifier(basetype);
          boolean definedbasetypeP = !(basetype == realbasetypespec);

          { Stella_Object head001 = cursor.value;

            cursor = cursor.rest;
            { Stella_Object operator = head001;
              boolean arraytypeP = false;

              if (definedbasetypeP) {
                basetype = StandardObject.typeSpecToBaseType(realbasetypespec);
              }
              typespec.specifierBaseType = Surrogate.verifyType(basetype);
              if (StandardObject.arrayTypeSpecifierP(typespec)) {
                if (operator == Stella.SYM_STELLA_SIZE) {
                  { Stella_Object head002 = cursor.value;

                    cursor = cursor.rest;
                    operator = head002;
                  }
                }
                arraytypeP = true;
                typespec.specifierDimensions = Stella_Object.parseArrayDimensionsSpec(operator);
                { Stella_Object head003 = cursor.value;

                  cursor = cursor.rest;
                  operator = head003;
                }
              }
              if (arraytypeP &&
                  (typespec.specifierDimensions == null)) {
                { 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 array type specifier dimensions: `" + Stella_Object.deUglifyParseTree(typespectree) + "'.");
                      }
;
                    }

                  } finally {
                    Stella.$PRINTREADABLYp$.set(old$PrintreadablyP$000);
                  }
                }
                return (Cons.yieldParametricTypeSpecifier(Cons.list$(Cons.cons(Stella.SYM_STELLA_UNKNOWN, Cons.cons(Stella.SYM_STELLA_OF, Cons.cons(Stella.NIL, Stella.NIL))))));
              }
              if (!(operator == Stella.SYM_STELLA_OF)) {
                { 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(" Bad type specifier `" + Stella_Object.deUglifyParseTree(typespectree) + "'.");
                      }
;
                    }

                  } finally {
                    Stella.$PRINTREADABLYp$.set(old$PrintreadablyP$001);
                  }
                }
                return (Cons.yieldParametricTypeSpecifier(Cons.list$(Cons.cons(Stella.SYM_STELLA_UNKNOWN, Cons.cons(Stella.SYM_STELLA_OF, Cons.cons(Stella.NIL, Stella.NIL))))));
              }
              { Stella_Object p = null;
                Cons iter000 = cursor;
                List into000 = typespec.specifierParameterTypes;
                Cons collect000 = null;

                for (;!(iter000 == Stella.NIL); iter000 = iter000.rest) {
                  p = iter000.value;
                  parametertypespec = p.yieldTypeSpecifier();
                  if (StandardObject.arrayTypeSpecifierP(parametertypespec)) {
                    { 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 nested array type specifier: ");
                            Stella.STANDARD_ERROR.nativeStream.println("   `" + Stella_Object.deUglifyParseTree(typespectree) + "'");
                            Stella.STANDARD_ERROR.nativeStream.println("   Use multi-dimensional arrays instead.");
                          }
;
                        }

                      } finally {
                        Stella.$PRINTREADABLYp$.set(old$PrintreadablyP$002);
                      }
                    }
                    return (Cons.yieldParametricTypeSpecifier(Cons.list$(Cons.cons(Stella.SYM_STELLA_UNKNOWN, Cons.cons(Stella.SYM_STELLA_OF, Cons.cons(Stella.NIL, Stella.NIL))))));
                  }
                  if (collect000 == null) {
                    {
                      collect000 = Cons.cons(parametertypespec, Stella.NIL);
                      if (into000.theConsList == Stella.NIL) {
                        into000.theConsList = collect000;
                      }
                      else {
                        Cons.addConsToEndOfConsList(into000.theConsList, collect000);
                      }
                    }
                  }
                  else {
                    {
                      collect000.rest = Cons.cons(parametertypespec, Stella.NIL);
                      collect000 = collect000.rest;
                    }
                  }
                }
              }
              if (definedbasetypeP) {
                if (Surrogate.subtypeOfParametricTypeSpecifierP(Stella_Object.safePrimaryType(realbasetypespec))) {
                  { ParametricTypeSpecifier realbasetypespec000 = ((ParametricTypeSpecifier)(realbasetypespec));

                    { boolean testValue000 = false;

                      testValue000 = realbasetypespec000.specifierParameterTypes.length() == typespec.specifierParameterTypes.length();
                      if (testValue000) {
                        { boolean alwaysP000 = true;

                          { StandardObject partype = null;
                            Cons iter001 = typespec.specifierParameterTypes.theConsList;
                            StandardObject rpartype = null;
                            Cons iter002 = realbasetypespec000.specifierParameterTypes.theConsList;

                            loop001 : for (;(!(iter001 == Stella.NIL)) &&
                                      (!(iter002 == Stella.NIL)); iter001 = iter001.rest, iter002 = iter002.rest) {
                              partype = ((StandardObject)(iter001.value));
                              rpartype = ((StandardObject)(iter002.value));
                              if (!Surrogate.optimisticSubtypeOfP(StandardObject.typeSpecToBaseType(partype), StandardObject.typeSpecToBaseType(rpartype))) {
                                alwaysP000 = false;
                                break loop001;
                              }
                            }
                          }
                          testValue000 = alwaysP000;
                        }
                      }
                      if (!(testValue000)) {
                        { 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(" Parameter types of `" + Stella_Object.deUglifyParseTree(typespectree) + "' are incompatible ");
                                Stella.STANDARD_ERROR.nativeStream.println(" with parameter types of defined type `" + typespectree.value + "'.");
                              }
;
                            }

                          } finally {
                            Stella.$PRINTREADABLYp$.set(old$PrintreadablyP$003);
                          }
                        }
                        return (Cons.yieldParametricTypeSpecifier(Cons.list$(Cons.cons(Stella.SYM_STELLA_UNKNOWN, Cons.cons(Stella.SYM_STELLA_OF, Cons.cons(Stella.NIL, Stella.NIL))))));
                      }
                    }
                  }
                }
                else {
                }
              }
              return (typespec);
            }
          }
        }
      }
    }
  }