public boolean conformingSignaturesP(Slot superslot) {
    { MethodSlot self = this;

      if (StandardObject.conformingTypeSpecP(self.slotBaseType, superslot.type()) &&
          (StandardObject.conformingTypeSpecP(((CompoundTypeSpecifier)(KeyValueList.dynamicSlotValue(self.dynamicSlots, Stella.SYM_STELLA_SLOT_TYPE_SPECIFIER, null))), ((CompoundTypeSpecifier)(KeyValueList.dynamicSlotValue(superslot.dynamicSlots, Stella.SYM_STELLA_SLOT_TYPE_SPECIFIER, null)))) &&
           (self.methodArgumentCount() == superslot.methodArgumentCount()))) {
        { Surrogate testValue000 = Stella_Object.safePrimaryType(superslot);

          if (Surrogate.subtypeOfStorageSlotP(testValue000)) {
            { StorageSlot superslot000 = ((StorageSlot)(superslot));

              return (self.methodReturnTypeSpecifiers().length() == 1);
            }
          }
          else if (Surrogate.subtypeOfMethodSlotP(testValue000)) {
            { MethodSlot superslot000 = ((MethodSlot)(superslot));

              { boolean testValue001 = false;

                { boolean alwaysP000 = true;

                  { StandardObject ts1 = null;
                    Cons iter000 = self.methodParameterTypeSpecifiers().rest();
                    StandardObject ts2 = null;
                    Cons iter001 = superslot000.methodParameterTypeSpecifiers().rest();

                    loop000 : for (;(!(iter000 == Stella.NIL)) &&
                              (!(iter001 == Stella.NIL)); iter000 = iter000.rest, iter001 = iter001.rest) {
                      ts1 = ((StandardObject)(iter000.value));
                      ts2 = ((StandardObject)(iter001.value));
                      if (!StandardObject.conformingTypeSpecP(ts2, ts1)) {
                        alwaysP000 = false;
                        break loop000;
                      }
                    }
                  }
                  testValue001 = alwaysP000;
                }
                if (testValue001) {
                  { boolean alwaysP001 = true;

                    { StandardObject ts1 = null;
                      Cons iter002 = self.methodReturnTypeSpecifiers().theConsList;
                      StandardObject ts2 = null;
                      Cons iter003 = superslot000.methodReturnTypeSpecifiers().theConsList;

                      loop001 : for (;(!(iter002 == Stella.NIL)) &&
                                (!(iter003 == Stella.NIL)); iter002 = iter002.rest, iter003 = iter003.rest) {
                        ts1 = ((StandardObject)(iter002.value));
                        ts2 = ((StandardObject)(iter003.value));
                        if (!StandardObject.conformingTypeSpecP(ts1, ts2)) {
                          alwaysP001 = false;
                          break loop001;
                        }
                      }
                    }
                    testValue001 = alwaysP001;
                  }
                }
                { boolean value000 = testValue001;

                  return (value000);
                }
              }
            }
          }
          else {
          }
        }
      }
      return (false);
    }
  }