[No Subject]

{3COM/PDD/PeteW}@pdd.3mail.3com.com Wed, 28 April 1993 10:08 UTC

Received: from ietf.nri.reston.va.us by IETF.CNRI.Reston.VA.US id aa01614; 28 Apr 93 6:08 EDT
Received: from CS.UTK.EDU by IETF.CNRI.Reston.VA.US id aa01610; 28 Apr 93 6:08 EDT
Received: from localhost by CS.UTK.EDU with SMTP (5.61+IDA+UTK-930125/2.8s-UTK) id AA04714; Wed, 28 Apr 93 05:23:57 -0400
X-Resent-To: chassismib@CS.UTK.EDU ; Wed, 28 Apr 1993 05:23:53 EDT
Errors-To: owner-chassismib@CS.UTK.EDU
Received: from gatekeeper.3Com.COM by CS.UTK.EDU with SMTP (5.61+IDA+UTK-930125/2.8s-UTK) id AA04571; Wed, 28 Apr 93 05:23:38 -0400
Received: from gw.3Com.COM by gatekeeper.3Com.COM with SMTP id AA05893 (5.65c/IDA-1.4.4-910725 for <chassismib@cs.utk.edu>); Wed, 28 Apr 1993 02:23:28 -0700
Received: by gw.3Com.COM id AA16450 (5.65c/IDA-1.4.4 for chassismib@cs.utk.edu); Wed, 28 Apr 1993 02:23:21 -0700
Date: Wed, 28 Apr 93 10:15 PDT
Sender: ietf-archive-request@IETF.CNRI.Reston.VA.US
From: {3COM/PDD/PeteW}@pdd.3mail.3com.com
Subject: [No Subject]
To: chassismib@cs.utk.edu
Message-Id: <930428.022510@3Mail.3Com.COM>
Msg-Date: 1993-04-28
Msg-Time: 10:15

Microsoft Mail v3.0 IPM.Microsoft Mail.Note
From: Wilson, Peter
To:  Chassis MIB
Date: 1993-04-28 10:09
Priority: 
Message ID: 69910251
Conversation ID: 69910251
Attachments:
     740-020.TXT

------------------------------------------------------------------------------

[[ 740-020.TXT : 2607 in 740-020.TXT ]]

---------------------------------------
Attachment: L:\MAILEXE2\MFFGET\740-020.TXT
---------------------------------------
I've modified the Chassis MIB sent around by Dave a couple of days ago
(the one that uses the full indices) to more accurately reflect my
thoughts on the chassis MIB. It was basically correct I wanted to
clarify a few points. Some of the changes are to the descriptions to
make things clearer, some are typos or ommisions. Dave: you should be
able to do some diffs between this and the one you sent to find the
descriptive differences. I removed the header and footers but ignoring
those I've not needlessly changed spacing etc. 

I started writing these as comments but soon found it easier this way.
I've included some comments in the MIB by using '-- &&'. These are
meant to be comments to the group, not a part of the eventual MIB!

I'm working on a couple of more complex examples at the moment which
I'll send shortly. Has anyone had the opportunity to try the model on
their device? Any comments? has anyone found the first two examples
useful, confusing, or whatever? Has anyone had a chance to consider
the indices on tables?

Summary:
1) Added OBJECT IDENTIFIERS for common types.
2) chasPhyLocationTable is a dense table with a single row for each
type of location. Your comments suggested this but then had an extra
index so that instances of location types could be enumerated. This
removed the chasPhyLocationIndex is removed.
3) I've renamed chasResourceTable to chasPhyResourceTable and
chasLogicalConfigTable to chasLogResourceTable for consistency (and
the objects under those branches).

Major Changes
=============
I've tried to tackle the as yet unmodified power supply and sensor MIB
groups. This is to bring them into line with the new model.

1) Removed the chasPowerSupplyTable. All the important information in
this table is available in the module table. A power supply module
is simply a module. By describing the PSU in the module table we allow
for those implementations where these is no distinction between a slot
that can accept a power supply or network card.

Things that are not in the module table should be considered for
inclusion in that table. These are:
            chasPowerSupplyHealthText,
            chasPowerSupplyWarnings,
            chasPowerSupplyFailures.
If these are useful then they are useful for any module.

2) Modified chasPowerSupplyOutputTable. In the new model each type of
output can be considered as a resource of a particular module. For
example suppose there are two PSU modules each of which have a 12V and
5V output. The model will map this as:

   Module Table              Resource Table                 Entity Table
   ======================================================================
   PSU Module 1 <------- PSU Module 1, Resource 1 -------->  5V PSU Entity
   PSU Module 1 <------- PSU Module 1, Resource 2 --------> 12V PSU Entity
   PSU Module 1 <------- PSU Module 1, Resource 1 -------->  5V PSU Entity
   PSU Module 1 <------- PSU Module 1, Resource 2 --------> 12V PSU Entity

The information in the output table then is extra information for the supply
resources. As such I've changed the index on this table to be the same
as the resource table (locationType, instance, resourceId). Note that
this is really neat in an SNMPv2 MIB because either the INDEX clause
can simply reference the resource table OR an AUGMENTS clause can be
used. Augments is probably more appropriate.

A final advantage is that the output resource is now identified by
it's location which it was not before. If a supply failed to deliver
correct voltage and there were several 5V resource there was no way to
know which had failed.

3) Sensor Table.
A sensor is also a resource of the chassis. I've changed this table in
a similar way to the power supply output table. The indices are now
locationType, instance and resource. This has the advantage again that
if there are multiple sensors of a particular type, it can be
identified by its location. This also removed the need for the OID
to identify the sensor type.

Sensors are an interesting chassis concept for the model. Every
resource should map to some entity, but individual entities are only
required to distinguish a particular agent or context. To map sensors
in a chassis simply provide a 'chassis' entity that contains all the
sensors and specifies that they are visible through the same view that
contains the chassis MIB.

ie
   Module Table              Resource Table                 Entity Table
   ======================================================================
   modularSlot.1 <---------------- 1 ----------------------> chassis
   modularSlot.2 <---------------- 1 ----------------------> chassis
   modularSlot.2 <---------------- 2 ----------------------> chassis
   ...

          CHASSIS-MIB DEFINITIONS ::= BEGIN

          IMPORTS
                  experimental, TimeTicks, IpAddress, Counter
                          FROM RFC1155-SMI
                  OBJECT-TYPE
                          FROM RFC1212
                  Party
                          FROM RFC1353-MIB;  -- SNMP Party MIB


          -- Textual Conventions

          DisplayString ::= OCTET STRING

          -- This data type is used to model textual information taken
          -- from the NVT ASCII character set.  By convention, objects
          -- with this syntax are declared as having
          --
          --      SIZE (0..255)


          AutonomousType    ::= OBJECT IDENTIFIER

          -- The object identifier is an independently extensible type
          -- identification value.  It may, for example indicate a
          -- particular sub-tree with further MIB definitions, or
          -- define something like a protocol type or type of
          -- hardware.

          chassis             OBJECT IDENTIFIER ::= { experimental 38 }

          -- Groups within the chassis MIB

          chasInfo            OBJECT IDENTIFIER ::= { chassis 1 }
          chasPhysical        OBJECT IDENTIFIER ::= { chassis 2 }
          chasEntity          OBJECT IDENTIFIER ::= { chassis 3 }
          chasResource        OBJECT IDENTIFIER ::= { chassis 4 }
          chasPowerSupply     OBJECT IDENTIFIER ::= { chassis 5 }
          chasEnviron         OBJECT IDENTIFIER ::= { chassis 6 }

          -- Chassis MIB Known Types
          chasKnownTypes      OBJECT IDENTIFIER ::= { chassis 8 }

          -- a) Values for known chasPhyLocationType. The types of
          --    location in the chassis.
          chasPubLocationTypes   OBJECT IDENTIFIER ::= { chasKnownTypes 1 }

          chasModularSlot     OBJECT IDENTIFIER ::= { chasPubLocationTypes 1 }
          chasPowerSupplyBay  OBJECT IDENTIFIER ::= { chasPubLocationTypes 2 }
          chasFanTray         OBJECT IDENTIFIER ::= { chasPubLocationTypes 3 }
          chasBackplane       OBJECT IDENTIFIER ::= { chasPubLocationTypes 4 }
          chasFrontSlot       OBJECT IDENTIFIER ::= { chasPubLocationTypes 5 }
          chasBackSlot        OBJECT IDENTIFIER ::= { chasPubLocationTypes 6 }

          -- b) Values for chasModuleType.
          chasPubModuleTypes  OBJECT IDENTIFIER ::= { chasKnownTypes 2 }
          chasLocationEmpty   OBJECT IDENTIFIER ::= { chasPubModuleTypes 1 }
          chasModuleUnknown   OBJECT IDENTIFIER ::= { chasPubModuleTypes 2 }

          -- c) Values for chasEntityObjectId.
          chasPubEntityTypes  OBJECT IDENTIFIER ::= { chasKnownTypes 3 }

             -- i) Things in the chassis, nothing to do with network.
             chasPubChassisEntities OBJECT IDENTIFIER ::= { chasPubEntityTypes 1 }

             chasPowerSupply  OBJECT IDENTIFIER ::= { chasPubChassisTypes  1 }
             chasChassis      OBJECT IDENTIFIER ::= { chasPubChassisTypes  2 }
             chasMonitors     OBJECT IDENTIFIER ::= { chasPubChassisTypes  3 }

             -- ii) Basic Network Entities
             chasPubNetEntities OBJECT IDENTIFIER ::= { chasPubEntityTypes 2 }

             chas8023Repeater OBJECT IDENTIFIER ::= { chasPubNetEntities 1 }
             chas8025Ring     OBJECT IDENTIFIER ::= { chasPubNetEntities 2 }
             chasFddiRing     OBJECT IDENTIFIER ::= { chasPubNetEntities 3 }
             chasAtmSwitch    OBJECT IDENTIFIER ::= { chasPubNetEntities 4 }
             chasFrameRelay   OBJECT IDENTIFIER ::= { chasPubNetEntities 5 }

             -- iii) Internetworking/Bridging
             chasPubConnectEntities OBJECT IDENTIFIER ::= { chasPubEntityTypes 3 }
             chasBridge    OBJECT IDENTIFIER ::= { chasPubConnectEntities 1 }
             chasRouter    OBJECT IDENTIFIER ::= { chasPubConnectEntities 2 }
             chasBrouter   OBJECT IDENTIFIER ::= { chasPubConnectEntities 3 }
             chasGateway   OBJECT IDENTIFIER ::= { chasPubConnectEntities 4 }

          -- d) Values for chasResourceType.
          chasPubResTypes  OBJECT IDENTIFIER ::= { chasKnownTypes 4 }

             -- i) Chassis type resources.
             chasPubChassisRes OBJECT IDENTIFIER ::= { chasPubResTypes 1 }

             -- ii) Basic Network Resource
             chasPubNetworkRes OBJECT IDENTIFIER ::= { chasPubResTypes 2 }

             chas8023RptrPort  OBJECT IDENTIFIER ::= { chasPubNetworkRes 1 }
             chas8025MauPort   OBJECT IDENTIFIER ::= { chasPubNetworkRes 2 }
             chasFddiPort      OBJECT IDENTIFIER ::= { chasPubNetworkRes 3 }
             chasAtmPort       OBJECT IDENTIFIER ::= { chasPubNetworkRes 4 }
             chas8023PortGroup OBJECT IDENTIFIER ::= { chasPubNetworkRes 5 }
             chas8025PortGroup OBJECT IDENTIFIER ::= { chasPubNetworkRes 6 }
             chasFddiPortGroup OBJECT IDENTIFIER ::= { chasPubNetworkRes 7 }
             chasAtmPortGroup  OBJECT IDENTIFIER ::= { chasPubNetworkRes 8 }

             -- iii) Backplane Network Resources (if required)
             chasPubBplaneRes  OBJECT IDENTIFIER ::= { chasPubResTypes 3 }

             chas8023Bplane    OBJECT IDENTIFIER ::= { chasPubBplaneRes  1 }
             chas8025Bplane    OBJECT IDENTIFIER ::= { chasPubBplaneRes  2 }
             chasFddiBplane    OBJECT IDENTIFIER ::= { chasPubBplaneRes  3 }
             chasMgmtBplane    OBJECT IDENTIFIER ::= { chasPubBplaneRes  4 }
             chasAtmBplane     OBJECT IDENTIFIER ::= { chasPubBplaneRes  5 }

             -- iv) Internetworking/bridging resources (if required)
             chasPubConnectRes OBJECT IDENTIFIER ::= { chasPubResTypes 4 }

             chasBridgeRelay   OBJECT IDENTIFIER ::= { chasPubConnectRes 1 }
             chasRouterRelay   OBJECT IDENTIFIER ::= { chasPubConnectRes 2 }
             chasBrouterRelay  OBJECT IDENTIFIER ::= { chasPubConnectRes 3 }
             chasSwitch        OBJECT IDENTIFIER ::= { chasPubConnectRes 4 }

          -- chasInfo group (chassis information group).
          -- Implementation of this group is mandatory.

          chasType  OBJECT-TYPE
              SYNTAX  OBJECT IDENTIFIER
              ACCESS  read-only
              STATUS  mandatory
              DESCRIPTION
                      "An authoritative identification of the type of
                      hub-based or standalone chassis.  By convention
                      this value is allocated within the SMI enterprises
                      subtree(1.3.6.1.4.1), and provides an easy and
                      unambiguous means for determining `what kind of
                      box' is being managed.  If this information is not
                      present or unknown, its value should be set to the
                      value: chasTypeUnknown."
              ::= { chasInfo 1 }

          chasPhysicalChanges  OBJECT-TYPE
              SYNTAX   Counter
              ACCESS   read-only
              STATUS   mandatory
              DESCRIPTION
                      "The number of physical changes that have occurred
                      in the chassis since the agent was warm/cold
                      started.  This includes additions and removal of
                      modules and entities.  Other uses are
                      implementation specific."
              ::= { chasInfo 2 }


          chasChassisSerialNumber   OBJECT-TYPE
              SYNTAX    DisplayString (SIZE (0..32))
              ACCESS    read-only
              STATUS    mandatory
              DESCRIPTION
                      "The serial number of the chassis. If no serial
                      number is available then this object should be the
                      zero length string."
              ::= { chasInfo 3 }

          -- chasPhysical group (physical configuration group).
          -- Implementation of this group is mandatory.

          chasPhyLocationTable OBJECT-TYPE
              SYNTAX SEQUENCE OF ChasPhyLocationTable
              ACCESS not-accessible
              STATUS mandatory
              DESCRIPTION
              "This table summarises the different classes of
               modular physical locations in the chassis.
               This includes but is not limited to slot
               within a chassis, power supply bay. Note that
               this table contains an entry for each type of
               location, _not_ each instance of each type of 
               location."
                     
              ::= { chasPhysical 1 }

          chasPhyLocationEntry OBJECT-TYPE
              SYNTAX ChasPhyLocationEntry
              ACCESS not-accessible
              STATUS mandatory
              DESCRIPTION
                      "An entry in the phyLocationTable"
              INDEX { chasPhyLocationTypeIndex }
              ::= { chasPhyLocationTable 1 }

          ChasPhyLocationEntry ::= SEQUENCE {
                  chasPhyLocationTypeIndex
                          INTEGER,
                  chasPhyLocationType
                          OBJECT IDENTIFIER,
                  chasPhyLocationName
                          DisplayString
                  }

          chasPhyLocationTypeIndex OBJECT-TYPE
              SYNTAX INTEGER (1..65535)
              ACCESS read-only
              STATUS mandatory
              DESCRIPTION
                      "This uniquely identifies the physical location
                      type within the chassis."
              ::= { chasPhyLocationEntry 1 }

          chasPhyLocationType OBJECT-TYPE
              SYNTAX OBJECT IDENTIFIER
              ACCESS read-only
              STATUS mandatory
              DESCRIPTION
                      " Uniquely identifies the 'type' of the physical
                      location within the chassis."
              ::= { chasPhyLocationEntry 2 }

          chasPhyLocationName OBJECT-TYPE
              SYNTAX DisplayString
              ACCESS read-only
              STATUS mandatory
              DESCRIPTION
                      "Each type of physical location within the chassis
                      is given a textual name."
              ::= { phyLocationEntry 3 }

          chasModuleTable OBJECT-TYPE
              SYNTAX SEQUENCE OF ChasModuleEntry
              ACCESS not-accessible
              STATUS mandatory
              DESCRIPTION
                      "This table defines the physical modules within a
                      chassis.  This is done by defining the type
                      physical modules and the physical location where
                      it resides.  This table also provides a mapping
                      from between physical modules and their location
                      within the chassis."
              :: { chasPhysical 2 }

          chasModuleEntry OBJECT-TYPE
              SYNTAX ChasPhyModuleEntry
              ACCESS not-accessible
              STATUS mandatory
              DESCRIPTION
                      "An entry in this table that describes a physical
                      module that resides at a given physcial location
                      within the chassis."
              INDEX { chasModuleLocationType, chasModuleLocation }
              ::= { chasModuleTable 1 }

          ChasPhyModuleEntry ::= SEQUENCE
              chasModuleLocationType
                  INTEGER,
              chasModuleLocation
                  INTEGER,
              chasModuleType
                  OBJECT IDENTIFIER,
              chasModuleSwVersion
                  DISPLAYSTRING,
              chasModuleHwVersion
                  DisplayString,
              chasModuleSerialNumber
                  DisplayString,
              chasModuleDescription
                  DisplayString,
              chasModuleLastChangeTime
                  TimeTicks,
              chasModuleAdminStatus
                  INTEGER,
              chasModuleOperStatus
                  INTEGER
              }

          chasModuleLocationType  OBJECT-TYPE
                  SYNTAX INTEGER
                  ACCESS read-only
                  STATUS mandatory
                  DESCRIPTION
                      "An instance of a module is identified by the
                      physical location which it resides.  The physical
                      location is identified by location type index and
                      location index (instance of that location type).
                      This object defines the location type. The value
                      of this index can be used to index the
                      chasPhyLocationTable to get details of this type
                      of location, for example a power supply bay or
                      a modular slot."
                  ::= { chasModuleEntry 1 }

          chasModuleLocation  OBJECT-TYPE
                  SYNTAX INTEGER
                  ACCESS read-only
                  STATUS mandatory
                  DESCRIPTION
                      "An instance of a module is identified by the
                      physical location which it resides.  The physical
                      location is identified by location type index and
                      location index (instance of that location type.
                      This object defines the instance of a particular
                      location type."
                  ::= { chasModuleEntry 2 }

          chasModuleType OBJECT-TYPE
              SYNTAX OBJECT IDENTIFIER
              ACCESS read-only
              STATUS mandatory
              DESCRIPTION
                      "An authoritative identification of the type of
                      physcial module in this physical location.  A
                      value of chasModuleUnknown indicates that the
                      type of physical module is unknown. A value of
                      chasLocationEmpty indicates that this location
                      is currently occupied by nothing, its empty."
              :== { chasModuleEntry 3 }

          -- && A cards software may not be in PROM so SW is a more
          -- && appropriate term.
          chasModuleSwVersion OBJECT-TYPE
              SYNTAX DisplayString (SIZE (0..32))
              ACCESS read-only
              STATUS mandatory
              DESCRIPTION
                      "A textual description of the version/revision
                      level for this module's software.  If not known,
                      is not appropriate or the location is empty then
                      this value should be set to the zero-length
                      string."
              :== { chasModuleEntry 4 }

          chasModuleHwVersion OBJECT-TYPE
              SYNTAX DisplayString (SIZE (0..32))
              ACCESS read-only
              STATUS mandatory
              DESCRIPTION
                      "A textual description of the version/revision
                      level for this module's firmware.  If not known,
                      is not appropriate or the location is empty then
                      this value should be set to the zero-length
                      string."
              ::= { chasModuleEntry 5 }

          chasModuleSerialNumber OBJECT-TYPE
              SYNTAX DisplayString (SIZE (0..32))
              ACCESS read-only
              STATUS mandatory
              DESCRIPTION
                      "The serial number of the physical module present
                      in this physical location.  If ths value is not known,
                      is not appropriate or the location is empty this value
                      will be the zero length string.  If no serial number 
                      is available for a physical module this value should
                      set to a zero length string."
              ::= { chasModuleEntry 6 }

          chasModuleDescription OBJECT-TYPE
              SYNTAX DisplayString (SIZE (0..32))
              ACCESS read-only
              STATUS mandatory
              DESCRIPTION
                      "A textual description of the physical module
                      plugged that resides in this physical location.
                      If this value is not available or the slot is
                      empty then this value should be set to a
                      zero length string."
              ::= { chasModuleEntry 7 }

          chasModuleLastChange OBJECT-TYPE
              Syntax TimeTicks
              ACCESS read-only
              STATUS mandatory
              DESCRIPTION
                      "The value of MIB-II's sysUpTime (in the agent
                      supporting this chassis MIB) at which a module was
                      last inserted or initialized.  If the module has
                      not changed since the last network managment
                      system reinitialized then this object has a zero
                      value."
              ::= { chasModuleEntry 8 }

          chasModuleAdminStatus OBJECT-TYPE
              Syntax INTEGER {
                  enable(2),
                  disable(3),
                  reset(4),
                  programLoad(5),
                  test(6)
              }
              ACCESS read-write
              STATUS mandatory
              DESCRIPTION
                      Provides desired state of the given physical
                      module.  Notice that not all values may be
                      supported by the specified physical module.  In
                      this case and SNMP error will be returned when the
                      set is attempted.

                      A physical module maybe activated by writting a
                      value of enable(2).

                      A physical module may be de-activated by writting
                      a value of disable(3).  In a disabled state a
                      physical module is present in the chassis but is
                      benign.

                      Writting a value of reset(4) initiates a reset
                      sequence.

                      A value of programLoad(5) initiates a software
                      load sequences.

                      Writting a vlaue of test(6) should start a self
                      test sequence within the physical module."
              ::= { chasModuleEntry 9 }

          chasModuleOperStatus OBJECT-TYPE
              Syntax INTEGER {
                  other(1),
                  invalid(2),
                  test(3),
                  operational(4),
                  resetInProgress(5),
                  warning(6),
                  nonFatalError(7),
                  fatalError(8)
              }
              ACCESS read-only
              STATUS mandatory
              DESCRIPTION
                      Provides operational status of the module.  The
                      following are possible definitions of the values.
                      The exact definition of the values is
                      implementation specific.  A value of other(1)
                      implies some undetermined state, possibly as a
                      result of setting phyAdminStatus to a value of
                      disable(3).  A value of invalid(2) could have the
                      possible meaning that the module exists but the
                      chassis manager has no direct control over the
                      module.  A value of testing(3) may be a diagnostic
                      state.  A value of operational(4) implies that the
                      entity is running with no errors or warnings.
                      State resetInProgress(5) implies equivalent of
                      setting phyAdminStatus to reset(4). The states of
                      warning(6), nonFatalError(7), fatalError(8)
                      reflect conditions detected during operation.  The
                      entity may or may not be still functional.

                      For example if a modules value of phyAdminStatus
                      is disable(3) and is set to enable(2) then
                      phyOperStatus may enter a state of testing(3) then
                      change to a value of operational(4)."
              ::= { chasModuleEntry 10 }
--
          -- The chasEntity group.
          -- This group is MANDATORY.

          -- Entity Table

          chasEntityTable OBJECT-TYPE
              SYNTAX  SEQUENCE OF ChasEntityEntry
              ACCESS  not-accessible
              STATUS  mandatory
              DESCRIPTION
                      "A table that contains information about the
                      'logical' networking devices (entities) in this
                      chassis."
              ::= { chasEntity 1 }

          chasEntityEntry OBJECT-TYPE
              SYNTAX  ChasEntityEntry
              ACCESS  not-accessible
              STATUS  mandatory
              DESCRIPTION
                      "Information concerning an entity in the chassis.
                      Conceptual rows may not be created or deleted with
                      SNMP operations."
              INDEX  { chasEntityIndex }
              ::= { chasEntityTable 1 }

          ChasEntityEntry ::=
              SEQUENCE {
                  chasEntityIndex
                      INTEGER,
                  chasEntityObjectID
                      OBJECT IDENTIFIER,
                  chasEntityDescr
                      DisplayString,
                  chasEntityAdminStatus
                      INTEGER,
                  chasEntityOperStatus
                      INTEGER,
                  chasEntityTimeStamp
                      TimeTicks,
                  chasEntityParty
                      Party,
                  chasEntityCommunity
                      OCTET STRING,
                  chasEntityIpAddress
                      IpAddress
              }

          chasEntityIndex OBJECT-TYPE
              SYNTAX  INTEGER (1..65535)
              ACCESS  read-only
              STATUS  mandatory
              DESCRIPTION
                      "A unique index for the entity for which this
                      entry contains information."
              ::= { chasEntityEntry 1 }

          chasEntityObjectID  OBJECT-TYPE
              SYNTAX  OBJECT IDENTIFIER
              ACCESS  read-only
              STATUS  mandatory
              DESCRIPTION
                      "The specific type of entity.  The value of this
                      object is analagous to MIB-II's sysObjectId.  In
                      particular, it has the same value as would be
                      returned if the SNMP Party (identified by
                      chasEntityParty) and/or the community (identified
                      by chasIpAddress and chasCommunity), were queried
                      for sysObjectId."
              ::= { chasEntityEntry 2 }


          chasEntityDescr  OBJECT-TYPE
              SYNTAX  DisplayString (SIZE (0..255))
              ACCESS  read-write
              STATUS  mandatory
              DESCRIPTION
                      "A textual description of the entity.  The value
                      of this object is analagous to MIB-II's sysDescr.
                      In particular, it has the same value as would be
                      returned if the SNMP Party (identified by
                      chasEntityParty) and/or the community (identified
                      by chasIpAddress and chasCommunity), were queried
                      for sysDescr."
              ::= { chasEntityEntry 3 }

          chasEntityAdminStatus OBJECT-TYPE
              SYNTAX  INTEGER {
                  unknown(1),             --  none of the following
                  enable(2),
                  disable(3),
                  reset(4),
                  programload(5),
                  test(6)
              }
              ACCESS  read-write
              STATUS  mandatory
              DESCRIPTION
                      "Provides the administratively desired state of
                      the given entity.

                      An entity is activated by writing a value of
                      enable(2).

                      An entity may be de-activated by writing a value
                      of disable(3).  In a disabled state, a entity does
                      exist within the given chassis, but is benign.  A
                      disabled entity is available for subsequent
                      activation.

                      Writing a value of reset(4) specifies an entity
                      should initiate a reset sequence.

                      Writing a value of programload(5) specifies an
                      entity should initiate a program load sequence.

                      Writing a value of test(6) specifies an entity
                      should initiate a testing sequence.

                      Agent support of the writing of any of the values
                      of this object is implementation-specific.  For
                      example, this object might be read only for
                      entities that disabling would compromise the
                      integrity of the chassis."
              ::= { chasEntityEntry 4 }

          chasEntityOperStatus OBJECT-TYPE
              SYNTAX  INTEGER {
                  other(1),               --  none of the following
                  invalid(2),
                  testing(3),
                  operational(4),
                  resetInProgress(5),
                  warning(6),
                  nonFatalError(7),
                  fatalError(8),
                  loading(10)
              }
              ACCESS  read-only
              STATUS  mandatory
              DESCRIPTION
                      "Provides operational status of the entity.  The
                      following are possible definitions of the values.
                      The exact definition of the values is
                      implementation specific.  A value of other(1)
                      implies some undetermined state, possibly as a
                      result of setting chasEntityAdminStatus to a value
                      of disable(3).  A value of invalid(2) could have
                      the possible meaning that the entity exists but
                      the chassis manager has no direct control of the
                      entity.  A value of testing(3) may be a diagnostic
                      state.  A value of operational(4) implies that the
                      entity is running with no errors or warnings.
                      State resetInProgress(5) implies equivalent of
                      setting chasEntityAdminStatus to reset(4). The
                      states of warning(6), nonFatalError(7),
                      fatalError(8) reflect conditions detected during
                      operation.  The entity may or may not be still
                      functional.  State loading(10) is a result of
                      asserting programload(5) in chasEntityAdminStatus.

                      For example if an entities value of
                      chasEntityAdminStatus is disable(3) and is set to
                      enable(2) then chasEntityOperStatus may enter a
                      state of testing(3) then change to a value of
                      operational(4)."
              ::= { chasEntityEntry 5 }


          chasEntityTimeStamp  OBJECT-TYPE
              SYNTAX  TimeTicks
              ACCESS  read-only
              STATUS  mandatory
              DESCRIPTION
                      "The value of MIB-II's sysUpTime (in the agent
                      supporting this MIB) at which this entity was last
                      (re-)initialized.  If the entity has not been
                      initialized then this object has a zero value."
              ::= { chasEntityEntry 6 }

          chasEntityParty  OBJECT-TYPE
              SYNTAX  Party
              ACCESS  read-only
              STATUS  mandatory
              DESCRIPTION
                      "The SNMP Party which provides access to the
                      detailed management information for this entity.
                      Note that the definition of a SNMP Party includes
                      the location at which it executes, the MIB view to
                      which it provides access, the authentication and
                      privacy algorithms and parameters required to
                      access its MIB view, and whether or not proxy is
                      performed.  In order for a SNMP manager to be able
                      to access the Party, that manager must have prior
                      knowledge of the Party.  In particular, the
                      manager must know the location at which the Party
                      executes.

                      A party is named by an OBJECT IDENTIFIER.  For a
                      entity which is not managed through access to a
                      SNMP Party, the value of this object is
                      chasEntityNoParty."
              ::= { chasEntityEntry 7 }


          chasEntityCommunity  OBJECT-TYPE
              SYNTAX  OCTET STRING (SIZE (0..256))
              ACCESS  read-only
              STATUS  mandatory
              DESCRIPTION
                      "The SNMP Community which executes at the address
                      chasEntityIpAddress, and provides access to the
                      detailed management information for this entity.

                      For a entity which is not managed through access
                      to a SNMP Community, the value of this object is
                      the zero-length string."
              ::= { chasEntityEntry 8 }

          chasEntityIpAddress  OBJECT-TYPE
              SYNTAX  IpAddress
              ACCESS  read-only
              STATUS  mandatory
              DESCRIPTION
                      "The address of the SNMP agent which responds to
                      messages for the SNMP Community identified by
                      chasEntityCommunity.  When access is via proxy,
                      this variable contains the address of the proxy
                      agent.

                      For a entity which is not managed through access
                      to a SNMP Community, the value of this object is
                      0.0.0.0."
              ::= { chasEntityEntry 9 }
--
          -- The chasResource group.
          -- This group documents the mapping of resources onto modules and
          -- of resources onto entities.

          -- && Implementation of this group is NOT optional, it is mandatory.

          chasPhyResourceTable  OBJET-TYPE
              SYNTAX  SEQUENCE of ChasResourceEntry
              ACCESS  read-only
              STATUS  mandatory
              DESCRIPTION
              "Each physical module contains a number of resources. Each
               resource is a building block for constructing functional
               entities. This table contains an entry for each resource in
               the chassis, the type of entity to which that resource may 
               belong and the entity to which that resource is currently 
               assigned."
              ::= { chasResource 1 }

          chasPhyResourceEntry  OBJECT-TYPE
              SYNTAX  ChasPhyResourceEntry
              ACCESS  read-only
              STATUS  mandatory
              DESCRIPTION
              "This entry describes one resource in the chassis at a 
               particular instant in time. Note that if the physical module on
               which this resource resides is removed then this resource
               will be destroyed.

               Resources may be neither created or destroyed through
               management. Some implementations may allow management to
               assign a resouce to different entities through management."
              INDEX { chasPhyResLocationType,
                      chasPhyResLocation,
                      chasPhyResIndex }
              ::= { chasPhyResourceTable 1 }

          ChasPhyResourceEntry ::= SEQUENCE {
              chasPhyResLocationType
                  INTEGER,
              chasPhyResLocation
                  INTEGER
              chasPhyResIndex
                  INTEGER,
              chasPhyResourceType
                  OBJECT IDENTIFIER,
              chasPhyResEntityAssignmentType
                  OBJECT IDENTIFIER,
              chasPhyResEntityAssignment
                  INTEGER,
              chasPhyResEntitySubindex
                  INTEGER
              }

          chasPhyResLocationType  OBJECT-TYPE
              SYNTAX  INTEGER
              ACCESS  read-only
              STATUS  mandatory
              DESCRIPTION
              "A resource exists on a particular module. A module is
               identified by its location type and location instance.
               This variable identifies the type part of the module on
               which this resource resides. It can be used with 
               chasPhyResourceLocation to index the module table for information
               about the module."
              ::= { chasPhyResourceEntry 1 }

          chasPhyResLocation  OBJECT-TYPE
              SYNTAX  INTEGER
              ACCESS  read-only
              STATUS  mandatory
              DESCRIPTION
              "A resource exists on a particular module. A module is
               identified by its location type and location instance.
               This variable identifies the instance part of the module
               identification on which this resource resides. It can be
               used with chasPhyResourceLocationType to index the module table 
               for information about the module."
              ::= { chasPhyResourceEntry 2 }

          chasPhyResIndex  OBJECT-TYPE
              SYNTAX  INTEGER
              ACCESS  read-only
              STATUS  mandatory
              DESCRIPTION
                      "A unique index for the resource on this
                      particular physical module."
              ::= { chasPhyResourceEntry 3 }

          chasPhyResType OBJECT-TYPE
              SYNTAX OBJECT IDENTIFIER
              ACCESS read-only
              STATUS mandatory
              DESCRIPTION
                      "The type of resource.  For example, for an
                      Ethernet segment this object would have a value of
                      dot3 as defined in RFC 1284."
              ::= { chasPhyResourceEntry 4 }

          chasPhyResEntityAssignmentType OBJECT-TYPE
              SYNTAX OBJECT IDENTIFIER
              ACCESS read-only
              STATUS mandatory
              DESCRIPTION
              "Some implementations of the chassis MIB allow a resource to
              be moved between entities through management. For example a 
              repeater module may be moved to different repeaters. This
              object acts as a 'hint' to the management card to indicate
              to which type of entity this resource may be assigned. If
              used then the value of this field can be matched to
              entities via the chasEntityObjectID object.

              Note that a value in this column does not mean that this
              resource _can_ be successfully assigned to a particular
              entity, merely that such an assignment is legal. A request
              to change assignment can be rejected due to local considerations
              such as insufficient resource."
              ::= { chasPhyResourceEntry 5 }

          chasPhyResEntityAssignment  OBJECT-TYPE
              SYNTAX  INTEGER
              access  read-write
              STATUS  mandatory
              DESCRIPTION
              "The entity to which this resource is currently assigned.
              Note that this object is read/write. Depending on the
              implementation the request to set this object to a particular
              value will be rejected under some circumstances. Examples
              are:
              1) insufficient resource, eg to assign a repeater port
                 to the specified repeater would require uavailable
                 backplane resource.
              2) invalid configuration, trying to assign a repeater
                 port to a bridge entity!
              3) no-such entity.
              4) management configuration not possible. Some implementations
                 can only be reconfigured by changing hardware straps.

              Note that changing this object has the possible side effect
              of changing the chasPhyResourceEntitySubIndex. This second object
              is merely to allow a get-next type interrogation of resource
              assigned to entity in the chasLogResourceTable."
              ::= { chasPhyResourceEntry 6 }

          chasPhyResEntitySubIndex  OBJECT-TYPE
              SYNTAX  INTEGER
              ACCESS  read-only
              STATUS  mandatory
              DESCRIPTION
                      "Provides a unique index that can be used to
                      identify the relationship in terms of the entity."
              ::= { chasPhyResourceEntry 7 }
--
          -- Logical configuration table
          -- Implementation of the chasLogResoureTable is mandatory.

          chasLogResourceTable  OBJECT-TYPE
                  SYNTAX SEQUENCE OF ChasLogicalConfigEntry
                  ACCESS not-accessible
                  STATUS mandatory
                  DESCRIPTION
                      "Defines a logical configuration relationship
                      which is a relationship between entities and
                      resources and the physical module that the
                      relationship exists on."
                  ::= { chasResource 2 }

          chasLogResourceEntry OBJECT-TYPE
                  SYNTAX ChasLogResourceEntry
                  ACCESS not-accessible
                  STATUS mandatory
                  DESCRIPTION
                      "Defines a single logical relationship."
                  INDEX { chasLogResEntity,
                          chasLogResEntitySubIndex }
                  ::= { chasLogResourceTable 1 }

          ChasLogResourceEntry  SEQUENCE {
                  chasLogResEntity
                          INTEGER,
                  chasLogResEntitySubIndex
                          INTEGER,
                  chasLogResLocationType
                          INTEGER,
                  chasLogResLocation
                          INTEGER,
                  chasLogResIndex
                          INTEGER
                  }

          chasLogResEntity  OBJECT-TYPE
                  SYNTAX INTEGER
                  ACCESS read-only
                  STATUS mandatory
                  DESCRIPTION
                      "The entity ID for which this logical
                      configuration relationship exists."
                  ::= { chasLogResourceEntry 1 }

          chasLogResEntitySubIndex  OBJECT-TYPE
                  SYNTAX INTEGER
                  ACCESS read-only
                  STATUS mandatory
                  DESCRIPTION
                      "The entity sub index for which this logical
                      configuration relationship exists.  The logical
                      relation ship is identified by a resource
                      assignment to an entity.  The sub index defines a
                      particular instance of the mapping of physical
                      configuration onto an entity."
                  ::= { chasLogResourceEntry 2 }

          chasLogResLocationType  OBJECT-TYPE
                  SYNTAX INTEGER
                  ACCESS read-only
                  STATUS mandatory
                  DESCRIPTION
                      "A module is defined by it's physical location
                      type and an instance of that physical location.
                      This object defines the physical location type
                      portion of the physical module identifier that
                      this logical configuration exists for."
                  ::= { chasLogResourceEntry 3 }

          chasLogResLocation  OBJECT-TYPE
                  SYNTAX INTEGER
                  ACCESS read-only
                  STATUS mandatory
                  DESCRIPTION
                      "A module is defined by it's physical location
                      type and an instance of that physical location.
                      This object defines the instance physical location
                      (location index) portion of the physical module
                      identifier that this logical configuration exists
                      for."
                  ::= { chasLogResourceEntry 4 }

          chasLogResResourceID  OBJECT-TYPE
                  SYNTAX INTEGER
                  ACCESS read-only
                  STATUS mandatory
                  DESCRIPTION
                      "The value of this object refers to a particular
                      instance of a resource, as defined by
                      chasPhyResourceIndex, for which this relationship is
                      defined.  This together with
                      chasLogicalConfigLocationType and
                      chasLogicalConfigLocation completes the mapping of
                      the logical configuration on to the physical
                      module and resource combination."
                  ::= { chasLogResourceEntry 5 }

--
          -- the Power Supply Output table. Note that this table contains
          -- additional information for resources that represent power 
          -- supplies. As such this table has the same index as the resource
          -- table. When the MIB is represented in an SNMPv2 manner the
          -- index columns can be removed from this table and the INDEX
          -- clause can refer to the resource table. Alternatively since
          -- this table requires exactly the same indices as the resource
          -- table it is a good candidate for the AUGMENTS clause!
          --
          -- && Note that identifying PS resouces differently here to the
          -- && resource table is confusing.
          chasPowerSupplyOutputTable OBJECT-TYPE
              SYNTAX SEQUENCE OF ChasPowerSupplyOutputEntry
              ACCESS not-accessible
              STATUS mandatory
              DESCRIPTION
              "Additional information for resource that represent source
              of power within the chassis."
              ::= { chasPowerSupply 2 }

          chasPowerSupplyOutputEntry OBJECT-TYPE
              SYNTAX ChasPowerSupplyEntry
              ACCESS not-accessible
              STATUS mandatory
              DESCRIPTION
                      "Values for a power supply output."
              INDEX { chasPSLocationType, chasPSLocationIndex,chasPSResource}
              ::= { chasPowerSupplyOutputTable 1 }

          ChasPowerSupplyOutputEntry ::=
              SEQUENCE {
                  chasPSLocationType
                      INTEGER,
                  chasPSLocationIndex
                      INTEGER,
                  chasPSUResource
                      INTEGER,
                  chasPSOutputStatus
                      INTEGER,
                  chasPSOutputNominalVoltage
                      Gauge,
                  chasPSOutputOfferedVoltage
                      Gauge,
                  chasPSOutputOfferedWattage
                      Gauge,
                  chasPSOutputWarnings
                      Counter,
                  chasPSOutputFailures
                      Counter
              }

          chasPSLocationType  OBJECT-TYPE
              SYNTAX  INTEGER
              ACCESS  read-only
              STATUS  mandatory
              DESCRIPTION
              "A Power Supply resource exists on a particular module.
               This variable identifies the type part of the module on
               which this resource resides. It can be used with 
               chasPSULocationIndex to index the module table for information
               about the module.

               The value of this object could be chasPowerSupplyBay, however
               some chassis implementations will not distinguish between
               slots that accept modular function card and those that accept
               power supplies. A slot can accept for example a power supply
               or a repeater line card."
              ::= { chasPowerSupplyOutputEntry 1 }

          chasPSLocationIndex  OBJECT-TYPE
              SYNTAX  INTEGER
              ACCESS  read-only
              STATUS  mandatory
              DESCRIPTION
              "A power supply resource exists on a particular module. A module
               is identified by its location type and location instance.
               This variable identifies the instance part of the module
               identification on which this resource resides. It can be
               used with chasPSLocationType to index the module table 
               for information about the module."
              ::= { chasPowerSupplyOutputEntry 2 }

          chasPSResource  OBJECT-TYPE
              SYNTAX  INTEGER
              ACCESS  read-only
              STATUS  mandatory
              DESCRIPTION
                      "A unique index for the power supply resource on this
                      particular physical module."
              ::= { chasPowerSupplyOutputEntry 3 }

          chasPSOutputStatus OBJECT-TYPE
              SYNTAX INTEGER {
                  unknown(1),
                  bad(2),
                  warning(3),
                  good(4) }
              ACCESS read-only
              STATUS mandatory
              DESCRIPTION
                      "Actual status of the power supply:

                      - unknown(1)     status not known
                      - bad(2)         unable to supply power due to failure
                      - warning(3)     supplying power but marginally
                      - good(4)        supplying power

                      It is an implementation specific matter whether
                      the agent keeps entries with status unknown(1) in
                      the table.  If unknown(1), offered values and
                      counters are meaningless."
                          ::= { chasPowerSupplyOutputEntry 4 }

                      chasPSOutputNominalVoltage OBJECT-TYPE
                          SYNTAX Gauge
                          ACCESS read-only
                          STATUS mandatory
                          DESCRIPTION
                                  "In hundredths of a volt, the voltage
                                  the output is supposed to supply, such
                                  as -5, +5, +12, -15, etc."
                         ::= { chasPowerSupplyOutputEntry 5 }

                     chasPSOutputOfferedVoltage OBJECT-TYPE
                         SYNTAX Gauge
                         ACCESS read-only
                         STATUS mandatory
                         DESCRIPTION
                                 "In hundredths of a volt, the voltage
                                 actually offered by the output.  If
                                 chasPowerSupplyOutputStatus is good(4),
                                 the value 0 means offered voltage is
                                 not available."
                        ::= { chasPowerSupplyOutputEntry 6 }

                    chasPSOutputOfferedWattage OBJECT-TYPE
                        SYNTAX Gauge
                        ACCESS read-only
                        STATUS mandatory
                        DESCRIPTION
                                "In hundredths of a watt, the wattage
                                actually offered by the output.  If
                                chasPowerSupplyOutputStatus is good(4),
                                the value 0 means offered wattage is not
                                available."
                       ::= { chasPowerSupplyOutputEntry 7 }

                   chasPSOutputWarnings OBJECT-TYPE
                       SYNTAX Counter
                       ACCESS read-only
                       STATUS mandatory
                       DESCRIPTION
                               "The number of times
                               chasPowerSupplyOutputStatus has gone to
                               warning(3)."
                      ::= { chasPowerSupplyOutputEntry 8 }

                  chasPSOutputFailures OBJECT-TYPE
                      SYNTAX Counter
                      ACCESS read-only
                      STATUS mandatory
                      DESCRIPTION
                              "The number of times
                              chasPowerSupplyOutputStatus has gone to
                              bad(2)."
                     ::= { chasPowerSupplyOutputEntry 9 }
--
                 -- the chasEnviron (Environment) group
                 -- Implementation of this group is optional.

                 -- && In the same way that each power supply is
                 -- && a resource, so is each environmental monitor. This
                 -- && table can also be described as an AUGMENTS or a shared
                 -- && index with the resource table. In the long run it is
                 -- && more economical on MIB objects to share the indices
                 -- && with the resource table. In preparation for this I've
                 -- && changed this table to use the location type and index
                 -- && to identify rows in this table.
                 -- &&
                 -- && Because a sensor is a resource, its can be identified
                 -- && by the OID in the resource table so chasEnvironSensor
                 -- && is no longer required.
                 chasEnvironTable OBJECT-TYPE
                     SYNTAX SEQUENCE OF ChasEnvironEntry
                     ACCESS not-accessible
                     STATUS mandatory
                     DESCRIPTION
                     "A list of environmental entries, one for
                     each environmental sensor in the chassis. This table
                     augments the resources in the resource table for those
                     entries which represent sensors."                     
                    ::= { chasEnviron 1 }

                chasEnvironEntry OBJECT-TYPE
                    SYNTAX ChasEnvironEntry
                    ACCESS not-accessible
                    STATUS mandatory
                    DESCRIPTION
                            "Values for a environmental sensor."
                   INDEX { chasEnvironLocationType,
                           chasEnvironLocationIndex,
                           chasEnvironResource }
                   ::= { chasEnvironTable 1 }

               ChasEnvironEntry ::= SEQUENCE {
                   chasEnvironLocationType
                       INTEGER,
                   chasEnvironLocationIndex
                       INTEGER,
                   chasEnvironResource
                       INTEGER,
                   chasEnvironStatus
                       INTEGER,
                   chasEnvironWarnings
                       Counter,
                   chasEnvironFailures
                       Counter,
                   }

          chasEnvironLocationType  OBJECT-TYPE
              SYNTAX  INTEGER
              ACCESS  read-only
              STATUS  mandatory
              DESCRIPTION
              "A sensor resource exists on a particular module.
               This variable identifies the type part of the module on
               which this sensor resides."
              ::= { chasEnvironEntry 1 }

          chasEnvironLocationIndex  OBJECT-TYPE
              SYNTAX  INTEGER
              ACCESS  read-only
              STATUS  mandatory
              DESCRIPTION
              "A sensor exists on a particular module. A module
               is identified by its location type and location instance.
               This variable identifies the instance part of the module
               identification on which this sensor resides."
              ::= { chasEnvironEntry 2 }

          chasEnvironResource  OBJECT-TYPE
              SYNTAX  INTEGER
              ACCESS  read-only
              STATUS  mandatory
              DESCRIPTION
                      "A unique index for the resource on this
                      particular physical module."
              ::= { chasEnvironEntry 3 }

          chasEnvironStatus OBJECT-TYPE
                  SYNTAX INTEGER {
                      unknown(1),
                      bad(2),
                      warning(3),
                      good(4) }
                  ACCESS read-only
                  STATUS mandatory
                  DESCRIPTION
                          "Actual status indicated by the sensor.  It is
                          an implementation specific matter whether the
                          agent keeps entries with status unknown(1) in
                          the table.  If unknown(1), counters are
                          meaningless."
                 ::= { chasEnvironEntry 4 }

             chasEnvironWarnings OBJECT-TYPE
                 SYNTAX Counter
                 ACCESS read-only
                 STATUS mandatory
                 DESCRIPTION
                         "The number of times chasEnvironStatus has gone
                         to warning(3)."
                ::= { chasEnvironEntry 5 }

            chasEnvironFailures OBJECT-TYPE
                SYNTAX Counter
                ACCESS read-only
                STATUS mandatory
                DESCRIPTION
                        "The number of times chasEnvironStatus has gone
                        to bad(2)."
               ::= { chasEnvironEntry 6 }


          -- Entity party types

          chasKnownParty     OBJECT IDENTIFIER ::= { chasKnownTypes 2 }
          chasEntityNoParty  OBJECT IDENTIFIER ::= { chasKnownParty 1 }


          END

---------------------------------------
Attachment: L:\MAILEXE2\MFFGET\WINMAIL.001
(This attachment contained binary characters, so it has been uuencoded.
Use a uudecode program to recreate the original file.)
---------------------------------------
begin 666 L:\MAILEXE2\MFFGET\WINMAIL.001
M>)\^(B\* @*0!@ .     0      (  @      !!  (!D 8 #    #<T,"TP
M,C N5%A4 (@" A.  P .    R0<$ !P "0 % #(    P 0(1@ 8 H D   $ 
M"0   [H$     "$$      4    ) @     %     0+___\ 90   $$+Q@"(
M "  (       (  @       H    (    "     !  $                 
M                     /___P _____/____S____\_____#X___R(?__\X
M?___(/___P8___\?!____X /___ !___X /___ !___X /___  ___X '___
M  ___X #___  ?__X '__^ !___P ?__^ '___P#___\ ____@/___\#____
MA____\?____G____]P4    ) @$    %     0(!    !0    D"      4 
M   ! O___P A!   00M& &8 (  @       @ "       "@    @    (   
M  $ "                                         "_  "_    O[\ 
MOP   +\ OP"_OP  P,#  ,#<P #PRJ8                             
M                                                            
M                                                            
M                                                            
M                                                            
M                                                            
M                                                            
M                                                            
M                                                            
M                                                            
M                                                            
M                                                            
M                                                            
M                                                            
M                                                            
M                                                            
M                                                            
M                                                            
M                                                            
M                                                            
M                                                            
M                              #P^_\ I*"@ (" @    /\  /\   #_
M_P#_    _P#_ /__  #___\                                     
M                                                            
M                                                            
M                                                            
M                                                            
M                                                            
M                                                            
M_P  ^                                       __OX            
M                            __O[_P<' P,#                    
M            __O[_P<' P,#                                __O[
M_P<' P,#                                __O[_P<' P,#        
M                        __O[_P<' P,#                        
M        __O[_P<' P                                  __O[_P< 
M                                    __O[                    
M                    ^P          ! 0                         
M    _P       /P$! 0                             _P    #\!/P$
M!                               _P#\_ 3\!/P$                
M                _/S\_ 3\!/P                               #\
M_/S\_ 3\                                 /S\__S\_ 0         
M                         /S\__S\_                           
M         /S\__S\                                     /S\_P  
M                                     /S\                    
M                     /P                                     
M          4    ) @$    %     0(!     P      !P<'!P<'!P<'!P<'
M!P<'!P<'!P<'!P<'!P<'!P<'_P<'^ <'!P<'!P<'!P> X (0@ $ #    #<T
,,"TP,C N5%A4 (@"
 
end