/*							-- DO NOT EDIT --
 * This file has been generated by smidump
 * version 0.3.1 for the scli package.
 *
 * Derived from Printer-MIB:
 *   The MIB module for management of printers.
 *
 * Revision 2001-08-30 00:00:
 *   Printer MIB v2.
 *   Five new OBJECT-GROUPs: prtAuxilliarySheetGroup,
 *      prtInputSwitchingGroup, prtGeneralV2Group,
 *      prtAlertTableV2Group, prtChannelV2Group.
 *   Nine new objects added to those groups:
 *      prtAuxiliarySheetStartupPage, prtAuxiliarySheetBannerPage,
 *      prtGeneralPrinterName, prtGeneralSerialNumber,
 *      prtAlertCriticalEvents, prtAlertAllEvents,
 *      prtInputMediaLoadTimeout, prtInputNextIndex,
 *      prtChannelInformation.
 *   One new NOTIFICATION-GROUP: prtAlertTrapGroup which contains
 *      printerV2Alert.
 *   In MODULE-COMPLIANCE prtMIBCompliance, new OBJECT-GROUPs and
 *      the NOTIFICATION_GROUP, all in GROUP (not MANDATORY-GROUP)
 *      clauses.  The nine new objects are optional, i.e., this draft
 *      is backward compatible with RFC 1759.
 *
 * Revision 1994-11-25 00:00:
 *   The original version of this MIB, published as RFC1759.
 *
 * $Id: printer-mib.c,v 1.9 2002/03/27 13:48:22 schoenw Exp $
 */

#include "printer-mib.h"

GSnmpEnum const printer_mib_enums_prtGeneralReset[] = {
    { PRINTER_MIB_PRTGENERALRESET_NOTRESETTING,           "notResetting" },
    { PRINTER_MIB_PRTGENERALRESET_POWERCYCLERESET,        "powerCycleReset" },
    { PRINTER_MIB_PRTGENERALRESET_RESETTONVRAM,           "resetToNVRAM" },
    { PRINTER_MIB_PRTGENERALRESET_RESETTOFACTORYDEFAULTS, "resetToFactoryDefaults" },
    { 0, NULL }
};

GSnmpEnum const printer_mib_enums_prtConsoleDisable[] = {
    { PRINTER_MIB_PRTCONSOLEDISABLE_OPERATORCONSOLEENABLED,  "operatorConsoleEnabled" },
    { PRINTER_MIB_PRTCONSOLEDISABLE_OPERATORCONSOLEDISABLED, "operatorConsoleDisabled" },
    { 0, NULL }
};

GSnmpEnum const printer_mib_enums_prtAuxiliarySheetStartupPage[] = {
    { PRINTER_MIB_PRTAUXILIARYSHEETSTARTUPPAGE_OTHER,      "other" },
    { PRINTER_MIB_PRTAUXILIARYSHEETSTARTUPPAGE_ON,         "on" },
    { PRINTER_MIB_PRTAUXILIARYSHEETSTARTUPPAGE_OFF,        "off" },
    { PRINTER_MIB_PRTAUXILIARYSHEETSTARTUPPAGE_NOTPRESENT, "notPresent" },
    { 0, NULL }
};

GSnmpEnum const printer_mib_enums_prtAuxiliarySheetBannerPage[] = {
    { PRINTER_MIB_PRTAUXILIARYSHEETBANNERPAGE_OTHER,      "other" },
    { PRINTER_MIB_PRTAUXILIARYSHEETBANNERPAGE_ON,         "on" },
    { PRINTER_MIB_PRTAUXILIARYSHEETBANNERPAGE_OFF,        "off" },
    { PRINTER_MIB_PRTAUXILIARYSHEETBANNERPAGE_NOTPRESENT, "notPresent" },
    { 0, NULL }
};

GSnmpEnum const printer_mib_enums_prtCoverStatus[] = {
    { PRINTER_MIB_PRTCOVERSTATUS_OTHER,           "other" },
    { PRINTER_MIB_PRTCOVERSTATUS_COVEROPEN,       "coverOpen" },
    { PRINTER_MIB_PRTCOVERSTATUS_COVERCLOSED,     "coverClosed" },
    { PRINTER_MIB_PRTCOVERSTATUS_INTERLOCKOPEN,   "interlockOpen" },
    { PRINTER_MIB_PRTCOVERSTATUS_INTERLOCKCLOSED, "interlockClosed" },
    { 0, NULL }
};

GSnmpEnum const printer_mib_enums_prtLocalizationCharacterSet[] = {
    { PRINTER_MIB_PRTLOCALIZATIONCHARACTERSET_OTHER, "other" },
    { 0, NULL }
};

GSnmpEnum const printer_mib_enums_prtInputType[] = {
    { PRINTER_MIB_PRTINPUTTYPE_OTHER,                         "other" },
    { PRINTER_MIB_PRTINPUTTYPE_UNKNOWN,                       "unknown" },
    { PRINTER_MIB_PRTINPUTTYPE_SHEETFEEDAUTOREMOVABLETRAY,    "sheetFeedAutoRemovableTray" },
    { PRINTER_MIB_PRTINPUTTYPE_SHEETFEEDAUTONONREMOVABLETRAY, "sheetFeedAutoNonRemovableTray" },
    { PRINTER_MIB_PRTINPUTTYPE_SHEETFEEDMANUAL,               "sheetFeedManual" },
    { PRINTER_MIB_PRTINPUTTYPE_CONTINUOUSROLL,                "continuousRoll" },
    { PRINTER_MIB_PRTINPUTTYPE_CONTINUOUSFANFOLD,             "continuousFanFold" },
    { 0, NULL }
};

GSnmpEnum const printer_mib_enums_prtInputDimUnit[] = {
    { PRINTER_MIB_PRTINPUTDIMUNIT_TENTHOUSANDTHSOFINCHES, "tenThousandthsOfInches" },
    { PRINTER_MIB_PRTINPUTDIMUNIT_MICROMETERS,            "micrometers" },
    { 0, NULL }
};

GSnmpEnum const printer_mib_enums_prtInputCapacityUnit[] = {
    { PRINTER_MIB_PRTINPUTCAPACITYUNIT_OTHER,                  "other" },
    { PRINTER_MIB_PRTINPUTCAPACITYUNIT_UNKNOWN,                "unknown" },
    { PRINTER_MIB_PRTINPUTCAPACITYUNIT_TENTHOUSANDTHSOFINCHES, "tenThousandthsOfInches" },
    { PRINTER_MIB_PRTINPUTCAPACITYUNIT_MICROMETERS,            "micrometers" },
    { PRINTER_MIB_PRTINPUTCAPACITYUNIT_SHEETS,                 "sheets" },
    { PRINTER_MIB_PRTINPUTCAPACITYUNIT_FEET,                   "feet" },
    { PRINTER_MIB_PRTINPUTCAPACITYUNIT_METERS,                 "meters" },
    { PRINTER_MIB_PRTINPUTCAPACITYUNIT_ITEMS,                  "items" },
    { PRINTER_MIB_PRTINPUTCAPACITYUNIT_PERCENT,                "percent" },
    { 0, NULL }
};

GSnmpEnum const printer_mib_enums_prtInputSecurity[] = {
    { PRINTER_MIB_PRTINPUTSECURITY_OTHER,      "other" },
    { PRINTER_MIB_PRTINPUTSECURITY_ON,         "on" },
    { PRINTER_MIB_PRTINPUTSECURITY_OFF,        "off" },
    { PRINTER_MIB_PRTINPUTSECURITY_NOTPRESENT, "notPresent" },
    { 0, NULL }
};

GSnmpEnum const printer_mib_enums_prtOutputType[] = {
    { PRINTER_MIB_PRTOUTPUTTYPE_OTHER,                "other" },
    { PRINTER_MIB_PRTOUTPUTTYPE_UNKNOWN,              "unknown" },
    { PRINTER_MIB_PRTOUTPUTTYPE_REMOVABLEBIN,         "removableBin" },
    { PRINTER_MIB_PRTOUTPUTTYPE_UNREMOVABLEBIN,       "unRemovableBin" },
    { PRINTER_MIB_PRTOUTPUTTYPE_CONTINUOUSROLLDEVICE, "continuousRollDevice" },
    { PRINTER_MIB_PRTOUTPUTTYPE_MAILBOX,              "mailBox" },
    { PRINTER_MIB_PRTOUTPUTTYPE_CONTINUOUSFANFOLD,    "continuousFanFold" },
    { 0, NULL }
};

GSnmpEnum const printer_mib_enums_prtOutputCapacityUnit[] = {
    { PRINTER_MIB_PRTOUTPUTCAPACITYUNIT_OTHER,                  "other" },
    { PRINTER_MIB_PRTOUTPUTCAPACITYUNIT_UNKNOWN,                "unknown" },
    { PRINTER_MIB_PRTOUTPUTCAPACITYUNIT_TENTHOUSANDTHSOFINCHES, "tenThousandthsOfInches" },
    { PRINTER_MIB_PRTOUTPUTCAPACITYUNIT_MICROMETERS,            "micrometers" },
    { PRINTER_MIB_PRTOUTPUTCAPACITYUNIT_SHEETS,                 "sheets" },
    { PRINTER_MIB_PRTOUTPUTCAPACITYUNIT_FEET,                   "feet" },
    { PRINTER_MIB_PRTOUTPUTCAPACITYUNIT_METERS,                 "meters" },
    { PRINTER_MIB_PRTOUTPUTCAPACITYUNIT_ITEMS,                  "items" },
    { PRINTER_MIB_PRTOUTPUTCAPACITYUNIT_PERCENT,                "percent" },
    { 0, NULL }
};

GSnmpEnum const printer_mib_enums_prtOutputSecurity[] = {
    { PRINTER_MIB_PRTOUTPUTSECURITY_OTHER,      "other" },
    { PRINTER_MIB_PRTOUTPUTSECURITY_ON,         "on" },
    { PRINTER_MIB_PRTOUTPUTSECURITY_OFF,        "off" },
    { PRINTER_MIB_PRTOUTPUTSECURITY_NOTPRESENT, "notPresent" },
    { 0, NULL }
};

GSnmpEnum const printer_mib_enums_prtOutputDimUnit[] = {
    { PRINTER_MIB_PRTOUTPUTDIMUNIT_TENTHOUSANDTHSOFINCHES, "tenThousandthsOfInches" },
    { PRINTER_MIB_PRTOUTPUTDIMUNIT_MICROMETERS,            "micrometers" },
    { 0, NULL }
};

GSnmpEnum const printer_mib_enums_prtOutputStackingOrder[] = {
    { PRINTER_MIB_PRTOUTPUTSTACKINGORDER_UNKNOWN,     "unknown" },
    { PRINTER_MIB_PRTOUTPUTSTACKINGORDER_FIRSTTOLAST, "firstToLast" },
    { PRINTER_MIB_PRTOUTPUTSTACKINGORDER_LASTTOFIRST, "lastToFirst" },
    { 0, NULL }
};

GSnmpEnum const printer_mib_enums_prtOutputPageDeliveryOrientation[] = {
    { PRINTER_MIB_PRTOUTPUTPAGEDELIVERYORIENTATION_FACEUP,   "faceUp" },
    { PRINTER_MIB_PRTOUTPUTPAGEDELIVERYORIENTATION_FACEDOWN, "faceDown" },
    { 0, NULL }
};

GSnmpEnum const printer_mib_enums_prtOutputBursting[] = {
    { PRINTER_MIB_PRTOUTPUTBURSTING_OTHER,      "other" },
    { PRINTER_MIB_PRTOUTPUTBURSTING_ON,         "on" },
    { PRINTER_MIB_PRTOUTPUTBURSTING_OFF,        "off" },
    { PRINTER_MIB_PRTOUTPUTBURSTING_NOTPRESENT, "notPresent" },
    { 0, NULL }
};

GSnmpEnum const printer_mib_enums_prtOutputDecollating[] = {
    { PRINTER_MIB_PRTOUTPUTDECOLLATING_OTHER,      "other" },
    { PRINTER_MIB_PRTOUTPUTDECOLLATING_ON,         "on" },
    { PRINTER_MIB_PRTOUTPUTDECOLLATING_OFF,        "off" },
    { PRINTER_MIB_PRTOUTPUTDECOLLATING_NOTPRESENT, "notPresent" },
    { 0, NULL }
};

GSnmpEnum const printer_mib_enums_prtOutputPageCollated[] = {
    { PRINTER_MIB_PRTOUTPUTPAGECOLLATED_OTHER,      "other" },
    { PRINTER_MIB_PRTOUTPUTPAGECOLLATED_ON,         "on" },
    { PRINTER_MIB_PRTOUTPUTPAGECOLLATED_OFF,        "off" },
    { PRINTER_MIB_PRTOUTPUTPAGECOLLATED_NOTPRESENT, "notPresent" },
    { 0, NULL }
};

GSnmpEnum const printer_mib_enums_prtOutputOffsetStacking[] = {
    { PRINTER_MIB_PRTOUTPUTOFFSETSTACKING_OTHER,      "other" },
    { PRINTER_MIB_PRTOUTPUTOFFSETSTACKING_ON,         "on" },
    { PRINTER_MIB_PRTOUTPUTOFFSETSTACKING_OFF,        "off" },
    { PRINTER_MIB_PRTOUTPUTOFFSETSTACKING_NOTPRESENT, "notPresent" },
    { 0, NULL }
};

GSnmpEnum const printer_mib_enums_prtMarkerMarkTech[] = {
    { PRINTER_MIB_PRTMARKERMARKTECH_OTHER,                          "other" },
    { PRINTER_MIB_PRTMARKERMARKTECH_UNKNOWN,                        "unknown" },
    { PRINTER_MIB_PRTMARKERMARKTECH_ELECTROPHOTOGRAPHICLED,         "electrophotographicLED" },
    { PRINTER_MIB_PRTMARKERMARKTECH_ELECTROPHOTOGRAPHICLASER,       "electrophotographicLaser" },
    { PRINTER_MIB_PRTMARKERMARKTECH_ELECTROPHOTOGRAPHICOTHER,       "electrophotographicOther" },
    { PRINTER_MIB_PRTMARKERMARKTECH_IMPACTMOVINGHEADDOTMATRIX9PIN,  "impactMovingHeadDotMatrix9pin" },
    { PRINTER_MIB_PRTMARKERMARKTECH_IMPACTMOVINGHEADDOTMATRIX24PIN, "impactMovingHeadDotMatrix24pin" },
    { PRINTER_MIB_PRTMARKERMARKTECH_IMPACTMOVINGHEADDOTMATRIXOTHER, "impactMovingHeadDotMatrixOther" },
    { PRINTER_MIB_PRTMARKERMARKTECH_IMPACTMOVINGHEADFULLYFORMED,    "impactMovingHeadFullyFormed" },
    { PRINTER_MIB_PRTMARKERMARKTECH_IMPACTBAND,                     "impactBand" },
    { PRINTER_MIB_PRTMARKERMARKTECH_IMPACTOTHER,                    "impactOther" },
    { PRINTER_MIB_PRTMARKERMARKTECH_INKJETAQUEOUS,                  "inkjetAqueous" },
    { PRINTER_MIB_PRTMARKERMARKTECH_INKJETSOLID,                    "inkjetSolid" },
    { PRINTER_MIB_PRTMARKERMARKTECH_INKJETOTHER,                    "inkjetOther" },
    { PRINTER_MIB_PRTMARKERMARKTECH_PEN,                            "pen" },
    { PRINTER_MIB_PRTMARKERMARKTECH_THERMALTRANSFER,                "thermalTransfer" },
    { PRINTER_MIB_PRTMARKERMARKTECH_THERMALSENSITIVE,               "thermalSensitive" },
    { PRINTER_MIB_PRTMARKERMARKTECH_THERMALDIFFUSION,               "thermalDiffusion" },
    { PRINTER_MIB_PRTMARKERMARKTECH_THERMALOTHER,                   "thermalOther" },
    { PRINTER_MIB_PRTMARKERMARKTECH_ELECTROEROSION,                 "electroerosion" },
    { PRINTER_MIB_PRTMARKERMARKTECH_ELECTROSTATIC,                  "electrostatic" },
    { PRINTER_MIB_PRTMARKERMARKTECH_PHOTOGRAPHICMICROFICHE,         "photographicMicrofiche" },
    { PRINTER_MIB_PRTMARKERMARKTECH_PHOTOGRAPHICIMAGESETTER,        "photographicImagesetter" },
    { PRINTER_MIB_PRTMARKERMARKTECH_PHOTOGRAPHICOTHER,              "photographicOther" },
    { PRINTER_MIB_PRTMARKERMARKTECH_IONDEPOSITION,                  "ionDeposition" },
    { PRINTER_MIB_PRTMARKERMARKTECH_EBEAM,                          "eBeam" },
    { PRINTER_MIB_PRTMARKERMARKTECH_TYPESETTER,                     "typesetter" },
    { 0, NULL }
};

GSnmpEnum const printer_mib_enums_prtMarkerCounterUnit[] = {
    { PRINTER_MIB_PRTMARKERCOUNTERUNIT_TENTHOUSANDTHSOFINCHES, "tenThousandthsOfInches" },
    { PRINTER_MIB_PRTMARKERCOUNTERUNIT_MICROMETERS,            "micrometers" },
    { PRINTER_MIB_PRTMARKERCOUNTERUNIT_CHARACTERS,             "characters" },
    { PRINTER_MIB_PRTMARKERCOUNTERUNIT_LINES,                  "lines" },
    { PRINTER_MIB_PRTMARKERCOUNTERUNIT_IMPRESSIONS,            "impressions" },
    { PRINTER_MIB_PRTMARKERCOUNTERUNIT_SHEETS,                 "sheets" },
    { PRINTER_MIB_PRTMARKERCOUNTERUNIT_DOTROW,                 "dotRow" },
    { PRINTER_MIB_PRTMARKERCOUNTERUNIT_HOURS,                  "hours" },
    { PRINTER_MIB_PRTMARKERCOUNTERUNIT_FEET,                   "feet" },
    { PRINTER_MIB_PRTMARKERCOUNTERUNIT_METERS,                 "meters" },
    { 0, NULL }
};

GSnmpEnum const printer_mib_enums_prtMarkerAddressabilityUnit[] = {
    { PRINTER_MIB_PRTMARKERADDRESSABILITYUNIT_TENTHOUSANDTHSOFINCHES, "tenThousandthsOfInches" },
    { PRINTER_MIB_PRTMARKERADDRESSABILITYUNIT_MICROMETERS,            "micrometers" },
    { 0, NULL }
};

GSnmpEnum const printer_mib_enums_prtMarkerSuppliesClass[] = {
    { PRINTER_MIB_PRTMARKERSUPPLIESCLASS_OTHER,                  "other" },
    { PRINTER_MIB_PRTMARKERSUPPLIESCLASS_SUPPLYTHATISCONSUMED,   "supplyThatIsConsumed" },
    { PRINTER_MIB_PRTMARKERSUPPLIESCLASS_RECEPTACLETHATISFILLED, "receptacleThatIsFilled" },
    { 0, NULL }
};

GSnmpEnum const printer_mib_enums_prtMarkerSuppliesType[] = {
    { PRINTER_MIB_PRTMARKERSUPPLIESTYPE_OTHER,             "other" },
    { PRINTER_MIB_PRTMARKERSUPPLIESTYPE_UNKNOWN,           "unknown" },
    { PRINTER_MIB_PRTMARKERSUPPLIESTYPE_TONER,             "toner" },
    { PRINTER_MIB_PRTMARKERSUPPLIESTYPE_WASTETONER,        "wasteToner" },
    { PRINTER_MIB_PRTMARKERSUPPLIESTYPE_INK,               "ink" },
    { PRINTER_MIB_PRTMARKERSUPPLIESTYPE_INKCARTRIDGE,      "inkCartridge" },
    { PRINTER_MIB_PRTMARKERSUPPLIESTYPE_INKRIBBON,         "inkRibbon" },
    { PRINTER_MIB_PRTMARKERSUPPLIESTYPE_WASTEINK,          "wasteInk" },
    { PRINTER_MIB_PRTMARKERSUPPLIESTYPE_OPC,               "opc" },
    { PRINTER_MIB_PRTMARKERSUPPLIESTYPE_DEVELOPER,         "developer" },
    { PRINTER_MIB_PRTMARKERSUPPLIESTYPE_FUSEROIL,          "fuserOil" },
    { PRINTER_MIB_PRTMARKERSUPPLIESTYPE_SOLIDWAX,          "solidWax" },
    { PRINTER_MIB_PRTMARKERSUPPLIESTYPE_RIBBONWAX,         "ribbonWax" },
    { PRINTER_MIB_PRTMARKERSUPPLIESTYPE_WASTEWAX,          "wasteWax" },
    { PRINTER_MIB_PRTMARKERSUPPLIESTYPE_FUSER,             "fuser" },
    { PRINTER_MIB_PRTMARKERSUPPLIESTYPE_CORONAWIRE,        "coronaWire" },
    { PRINTER_MIB_PRTMARKERSUPPLIESTYPE_FUSEROILWICK,      "fuserOilWick" },
    { PRINTER_MIB_PRTMARKERSUPPLIESTYPE_CLEANERUNIT,       "cleanerUnit" },
    { PRINTER_MIB_PRTMARKERSUPPLIESTYPE_FUSERCLEANINGPAD,  "fuserCleaningPad" },
    { PRINTER_MIB_PRTMARKERSUPPLIESTYPE_TRANSFERUNIT,      "transferUnit" },
    { PRINTER_MIB_PRTMARKERSUPPLIESTYPE_TONERCARTRIDGE,    "tonerCartridge" },
    { PRINTER_MIB_PRTMARKERSUPPLIESTYPE_FUSEROILER,        "fuserOiler" },
    { PRINTER_MIB_PRTMARKERSUPPLIESTYPE_WATER,             "water" },
    { PRINTER_MIB_PRTMARKERSUPPLIESTYPE_WASTEWATER,        "wasteWater" },
    { PRINTER_MIB_PRTMARKERSUPPLIESTYPE_GLUEWATERADDITIVE, "glueWaterAdditive" },
    { PRINTER_MIB_PRTMARKERSUPPLIESTYPE_WASTEPAPER,        "wastePaper" },
    { PRINTER_MIB_PRTMARKERSUPPLIESTYPE_BINDINGSUPPLY,     "bindingSupply" },
    { PRINTER_MIB_PRTMARKERSUPPLIESTYPE_BANDINGSUPPLY,     "bandingSupply" },
    { PRINTER_MIB_PRTMARKERSUPPLIESTYPE_STITCHINGWIRE,     "stitchingWire" },
    { PRINTER_MIB_PRTMARKERSUPPLIESTYPE_SHRINKWRAP,        "shrinkWrap" },
    { PRINTER_MIB_PRTMARKERSUPPLIESTYPE_PAPERWRAP,         "paperWrap" },
    { PRINTER_MIB_PRTMARKERSUPPLIESTYPE_STAPLES,           "staples" },
    { PRINTER_MIB_PRTMARKERSUPPLIESTYPE_INSERTS,           "inserts" },
    { PRINTER_MIB_PRTMARKERSUPPLIESTYPE_COVERS,            "covers" },
    { 0, NULL }
};

GSnmpEnum const printer_mib_enums_prtMarkerSuppliesSupplyUnit[] = {
    { PRINTER_MIB_PRTMARKERSUPPLIESSUPPLYUNIT_OTHER,                  "other" },
    { PRINTER_MIB_PRTMARKERSUPPLIESSUPPLYUNIT_UNKNOWN,                "unknown" },
    { PRINTER_MIB_PRTMARKERSUPPLIESSUPPLYUNIT_TENTHOUSANDTHSOFINCHES, "tenThousandthsOfInches" },
    { PRINTER_MIB_PRTMARKERSUPPLIESSUPPLYUNIT_MICROMETERS,            "micrometers" },
    { PRINTER_MIB_PRTMARKERSUPPLIESSUPPLYUNIT_IMPRESSIONS,            "impressions" },
    { PRINTER_MIB_PRTMARKERSUPPLIESSUPPLYUNIT_SHEETS,                 "sheets" },
    { PRINTER_MIB_PRTMARKERSUPPLIESSUPPLYUNIT_HOURS,                  "hours" },
    { PRINTER_MIB_PRTMARKERSUPPLIESSUPPLYUNIT_THOUSANDTHSOFOUNCES,    "thousandthsOfOunces" },
    { PRINTER_MIB_PRTMARKERSUPPLIESSUPPLYUNIT_TENTHSOFGRAMS,          "tenthsOfGrams" },
    { PRINTER_MIB_PRTMARKERSUPPLIESSUPPLYUNIT_HUNDRETHSOFFLUIDOUNCES, "hundrethsOfFluidOunces" },
    { PRINTER_MIB_PRTMARKERSUPPLIESSUPPLYUNIT_TENTHSOFMILLILITERS,    "tenthsOfMilliliters" },
    { PRINTER_MIB_PRTMARKERSUPPLIESSUPPLYUNIT_FEET,                   "feet" },
    { PRINTER_MIB_PRTMARKERSUPPLIESSUPPLYUNIT_METERS,                 "meters" },
    { PRINTER_MIB_PRTMARKERSUPPLIESSUPPLYUNIT_ITEMS,                  "items" },
    { PRINTER_MIB_PRTMARKERSUPPLIESSUPPLYUNIT_PERCENT,                "percent" },
    { 0, NULL }
};

GSnmpEnum const printer_mib_enums_prtMarkerColorantRole[] = {
    { PRINTER_MIB_PRTMARKERCOLORANTROLE_OTHER,   "other" },
    { PRINTER_MIB_PRTMARKERCOLORANTROLE_PROCESS, "process" },
    { PRINTER_MIB_PRTMARKERCOLORANTROLE_SPOT,    "spot" },
    { 0, NULL }
};

GSnmpEnum const printer_mib_enums_prtMediaPathMaxSpeedPrintUnit[] = {
    { PRINTER_MIB_PRTMEDIAPATHMAXSPEEDPRINTUNIT_TENTHOUSANDTHSOFINCHESPERHOUR, "tenThousandthsOfInchesPerHour" },
    { PRINTER_MIB_PRTMEDIAPATHMAXSPEEDPRINTUNIT_MICROMETERSPERHOUR,            "micrometersPerHour" },
    { PRINTER_MIB_PRTMEDIAPATHMAXSPEEDPRINTUNIT_CHARACTERSPERHOUR,             "charactersPerHour" },
    { PRINTER_MIB_PRTMEDIAPATHMAXSPEEDPRINTUNIT_LINESPERHOUR,                  "linesPerHour" },
    { PRINTER_MIB_PRTMEDIAPATHMAXSPEEDPRINTUNIT_IMPRESSIONSPERHOUR,            "impressionsPerHour" },
    { PRINTER_MIB_PRTMEDIAPATHMAXSPEEDPRINTUNIT_SHEETSPERHOUR,                 "sheetsPerHour" },
    { PRINTER_MIB_PRTMEDIAPATHMAXSPEEDPRINTUNIT_DOTROWPERHOUR,                 "dotRowPerHour" },
    { PRINTER_MIB_PRTMEDIAPATHMAXSPEEDPRINTUNIT_FEETPERHOUR,                   "feetPerHour" },
    { PRINTER_MIB_PRTMEDIAPATHMAXSPEEDPRINTUNIT_METERSPERHOUR,                 "metersPerHour" },
    { 0, NULL }
};

GSnmpEnum const printer_mib_enums_prtMediaPathMediaSizeUnit[] = {
    { PRINTER_MIB_PRTMEDIAPATHMEDIASIZEUNIT_TENTHOUSANDTHSOFINCHES, "tenThousandthsOfInches" },
    { PRINTER_MIB_PRTMEDIAPATHMEDIASIZEUNIT_MICROMETERS,            "micrometers" },
    { 0, NULL }
};

GSnmpEnum const printer_mib_enums_prtMediaPathType[] = {
    { PRINTER_MIB_PRTMEDIAPATHTYPE_OTHER,                  "other" },
    { PRINTER_MIB_PRTMEDIAPATHTYPE_UNKNOWN,                "unknown" },
    { PRINTER_MIB_PRTMEDIAPATHTYPE_LONGEDGEBINDINGDUPLEX,  "longEdgeBindingDuplex" },
    { PRINTER_MIB_PRTMEDIAPATHTYPE_SHORTEDGEBINDINGDUPLEX, "shortEdgeBindingDuplex" },
    { PRINTER_MIB_PRTMEDIAPATHTYPE_SIMPLEX,                "simplex" },
    { 0, NULL }
};

GSnmpEnum const printer_mib_enums_prtChannelType[] = {
    { PRINTER_MIB_PRTCHANNELTYPE_OTHER,                 "other" },
    { PRINTER_MIB_PRTCHANNELTYPE_CHSERIALPORT,          "chSerialPort" },
    { PRINTER_MIB_PRTCHANNELTYPE_CHPARALLELPORT,        "chParallelPort" },
    { PRINTER_MIB_PRTCHANNELTYPE_CHIEEE1284PORT,        "chIEEE1284Port" },
    { PRINTER_MIB_PRTCHANNELTYPE_CHSCSIPORT,            "chSCSIPort" },
    { PRINTER_MIB_PRTCHANNELTYPE_CHAPPLETALKPAP,        "chAppleTalkPAP" },
    { PRINTER_MIB_PRTCHANNELTYPE_CHLPDSERVER,           "chLPDServer" },
    { PRINTER_MIB_PRTCHANNELTYPE_CHNETWARERPRINTER,     "chNetwareRPrinter" },
    { PRINTER_MIB_PRTCHANNELTYPE_CHNETWAREPSERVER,      "chNetwarePServer" },
    { PRINTER_MIB_PRTCHANNELTYPE_CHPORT9100,            "chPort9100" },
    { PRINTER_MIB_PRTCHANNELTYPE_CHAPPSOCKET,           "chAppSocket" },
    { PRINTER_MIB_PRTCHANNELTYPE_CHFTP,                 "chFTP" },
    { PRINTER_MIB_PRTCHANNELTYPE_CHTFTP,                "chTFTP" },
    { PRINTER_MIB_PRTCHANNELTYPE_CHDLCLLCPORT,          "chDLCLLCPort" },
    { PRINTER_MIB_PRTCHANNELTYPE_CHIBM3270,             "chIBM3270" },
    { PRINTER_MIB_PRTCHANNELTYPE_CHIBM5250,             "chIBM5250" },
    { PRINTER_MIB_PRTCHANNELTYPE_CHFAX,                 "chFax" },
    { PRINTER_MIB_PRTCHANNELTYPE_CHIEEE1394,            "chIEEE1394" },
    { PRINTER_MIB_PRTCHANNELTYPE_CHTRANSPORT1,          "chTransport1" },
    { PRINTER_MIB_PRTCHANNELTYPE_CHCPAP,                "chCPAP" },
    { PRINTER_MIB_PRTCHANNELTYPE_CHDCEREMOTEPROCCALL,   "chDCERemoteProcCall" },
    { PRINTER_MIB_PRTCHANNELTYPE_CHONCREMOTEPROCCALL,   "chONCRemoteProcCall" },
    { PRINTER_MIB_PRTCHANNELTYPE_CHOLE,                 "chOLE" },
    { PRINTER_MIB_PRTCHANNELTYPE_CHNAMEDPIPE,           "chNamedPipe" },
    { PRINTER_MIB_PRTCHANNELTYPE_CHPCPRINT,             "chPCPrint" },
    { PRINTER_MIB_PRTCHANNELTYPE_CHSERVERMESSAGEBLOCK,  "chServerMessageBlock" },
    { PRINTER_MIB_PRTCHANNELTYPE_CHPSM,                 "chPSM" },
    { PRINTER_MIB_PRTCHANNELTYPE_CHDLLAPI,              "chDLLAPI" },
    { PRINTER_MIB_PRTCHANNELTYPE_CHVXDAPI,              "chVxDAPI" },
    { PRINTER_MIB_PRTCHANNELTYPE_CHSYSTEMOBJECTMANAGER, "chSystemObjectManager" },
    { PRINTER_MIB_PRTCHANNELTYPE_CHDECLAT,              "chDECLAT" },
    { PRINTER_MIB_PRTCHANNELTYPE_CHNPAP,                "chNPAP" },
    { PRINTER_MIB_PRTCHANNELTYPE_CHUSB,                 "chUSB" },
    { PRINTER_MIB_PRTCHANNELTYPE_CHIRDA,                "chIRDA" },
    { PRINTER_MIB_PRTCHANNELTYPE_CHPRINTXCHANGE,        "chPrintXChange" },
    { PRINTER_MIB_PRTCHANNELTYPE_CHPORTTCP,             "chPortTCP" },
    { PRINTER_MIB_PRTCHANNELTYPE_CHBIDIRPORTTCP,        "chBidirPortTCP" },
    { PRINTER_MIB_PRTCHANNELTYPE_CHUNPP,                "chUNPP" },
    { PRINTER_MIB_PRTCHANNELTYPE_CHAPPLETALKADSP,       "chAppleTalkADSP" },
    { PRINTER_MIB_PRTCHANNELTYPE_CHPORTSPX,             "chPortSPX" },
    { PRINTER_MIB_PRTCHANNELTYPE_CHPORTHTTP,            "chPortHTTP" },
    { PRINTER_MIB_PRTCHANNELTYPE_CHNDPS,                "chNDPS" },
    { PRINTER_MIB_PRTCHANNELTYPE_CHIPP,                 "chIPP" },
    { 0, NULL }
};

GSnmpEnum const printer_mib_enums_prtChannelState[] = {
    { PRINTER_MIB_PRTCHANNELSTATE_OTHER,             "other" },
    { PRINTER_MIB_PRTCHANNELSTATE_PRINTDATAACCEPTED, "printDataAccepted" },
    { PRINTER_MIB_PRTCHANNELSTATE_NODATAACCEPTED,    "noDataAccepted" },
    { 0, NULL }
};

GSnmpEnum const printer_mib_enums_prtInterpreterLangFamily[] = {
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_OTHER,                 "other" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_UNKNOWN,               "unknown" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGPCL,               "langPCL" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGHPGL,              "langHPGL" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGPJL,               "langPJL" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGPS,                "langPS" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGIPDS,              "langIPDS" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGPPDS,              "langPPDS" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGESCAPEP,           "langEscapeP" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGEPSON,             "langEpson" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGDDIF,              "langDDIF" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGINTERPRESS,        "langInterpress" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGISO6429,           "langISO6429" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGLINEDATA,          "langLineData" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGMODCA,             "langMODCA" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGREGIS,             "langREGIS" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGSCS,               "langSCS" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGSPDL,              "langSPDL" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGTEK4014,           "langTEK4014" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGPDS,               "langPDS" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGIGP,               "langIGP" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGCODEV,             "langCodeV" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGDSCDSE,            "langDSCDSE" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGWPS,               "langWPS" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGLN03,              "langLN03" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGCCITT,             "langCCITT" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGQUIC,              "langQUIC" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGCPAP,              "langCPAP" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGDECPPL,            "langDecPPL" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGSIMPLETEXT,        "langSimpleText" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGNPAP,              "langNPAP" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGDOC,               "langDOC" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGIMPRESS,           "langimPress" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGPINWRITER,         "langPinwriter" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGNPDL,              "langNPDL" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGNEC201PL,          "langNEC201PL" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGAUTOMATIC,         "langAutomatic" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGPAGES,             "langPages" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGLIPS,              "langLIPS" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGTIFF,              "langTIFF" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGDIAGNOSTIC,        "langDiagnostic" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGPSPRINTER,         "langPSPrinter" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGCAPSL,             "langCaPSL" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGEXCL,              "langEXCL" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGLCDS,              "langLCDS" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGXES,               "langXES" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGPCLXL,             "langPCLXL" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGART,               "langART" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGTIPSI,             "langTIPSI" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGPRESCRIBE,         "langPrescribe" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGLINEPRINTER,       "langLinePrinter" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGIDP,               "langIDP" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGXJCL,              "langXJCL" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGPDF,               "langPDF" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGRPDL,              "langRPDL" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGINTERMECIPL,       "langIntermecIPL" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGUBIFINGERPRINT,    "langUBIFingerprint" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGUBIDIRECTPROTOCOL, "langUBIDirectProtocol" },
    { PRINTER_MIB_PRTINTERPRETERLANGFAMILY_LANGFUJITSU,           "langFujitsu" },
    { 0, NULL }
};

GSnmpEnum const printer_mib_enums_prtInterpreterDefaultOrientation[] = {
    { PRINTER_MIB_PRTINTERPRETERDEFAULTORIENTATION_OTHER,     "other" },
    { PRINTER_MIB_PRTINTERPRETERDEFAULTORIENTATION_PORTRAIT,  "portrait" },
    { PRINTER_MIB_PRTINTERPRETERDEFAULTORIENTATION_LANDSCAPE, "landscape" },
    { 0, NULL }
};

GSnmpEnum const printer_mib_enums_prtInterpreterDefaultCharSetIn[] = {
    { PRINTER_MIB_PRTINTERPRETERDEFAULTCHARSETIN_OTHER, "other" },
    { 0, NULL }
};

GSnmpEnum const printer_mib_enums_prtInterpreterDefaultCharSetOut[] = {
    { PRINTER_MIB_PRTINTERPRETERDEFAULTCHARSETOUT_OTHER, "other" },
    { 0, NULL }
};

GSnmpEnum const printer_mib_enums_prtInterpreterTwoWay[] = {
    { PRINTER_MIB_PRTINTERPRETERTWOWAY_YES, "yes" },
    { PRINTER_MIB_PRTINTERPRETERTWOWAY_NO,  "no" },
    { 0, NULL }
};

GSnmpEnum const printer_mib_enums_prtConsoleColor[] = {
    { PRINTER_MIB_PRTCONSOLECOLOR_OTHER,   "other" },
    { PRINTER_MIB_PRTCONSOLECOLOR_UNKNOWN, "unknown" },
    { PRINTER_MIB_PRTCONSOLECOLOR_WHITE,   "white" },
    { PRINTER_MIB_PRTCONSOLECOLOR_RED,     "red" },
    { PRINTER_MIB_PRTCONSOLECOLOR_GREEN,   "green" },
    { PRINTER_MIB_PRTCONSOLECOLOR_BLUE,    "blue" },
    { PRINTER_MIB_PRTCONSOLECOLOR_CYAN,    "cyan" },
    { PRINTER_MIB_PRTCONSOLECOLOR_MAGENTA, "magenta" },
    { PRINTER_MIB_PRTCONSOLECOLOR_YELLOW,  "yellow" },
    { PRINTER_MIB_PRTCONSOLECOLOR_ORANGE,  "orange" },
    { 0, NULL }
};

GSnmpEnum const printer_mib_enums_prtAlertSeverityLevel[] = {
    { PRINTER_MIB_PRTALERTSEVERITYLEVEL_OTHER,                    "other" },
    { PRINTER_MIB_PRTALERTSEVERITYLEVEL_CRITICAL,                 "critical" },
    { PRINTER_MIB_PRTALERTSEVERITYLEVEL_WARNING,                  "warning" },
    { PRINTER_MIB_PRTALERTSEVERITYLEVEL_WARNINGBINARYCHANGEEVENT, "warningBinaryChangeEvent" },
    { 0, NULL }
};

GSnmpEnum const printer_mib_enums_prtAlertTrainingLevel[] = {
    { PRINTER_MIB_PRTALERTTRAININGLEVEL_OTHER,                  "other" },
    { PRINTER_MIB_PRTALERTTRAININGLEVEL_UNKNOWN,                "unknown" },
    { PRINTER_MIB_PRTALERTTRAININGLEVEL_UNTRAINED,              "untrained" },
    { PRINTER_MIB_PRTALERTTRAININGLEVEL_TRAINED,                "trained" },
    { PRINTER_MIB_PRTALERTTRAININGLEVEL_FIELDSERVICE,           "fieldService" },
    { PRINTER_MIB_PRTALERTTRAININGLEVEL_MANAGEMENT,             "management" },
    { PRINTER_MIB_PRTALERTTRAININGLEVEL_NOINTERVENTIONREQUIRED, "noInterventionRequired" },
    { 0, NULL }
};

GSnmpEnum const printer_mib_enums_prtAlertGroup[] = {
    { PRINTER_MIB_PRTALERTGROUP_OTHER,                        "other" },
    { PRINTER_MIB_PRTALERTGROUP_HOSTRESOURCESMIBSTORAGETABLE, "hostResourcesMIBStorageTable" },
    { PRINTER_MIB_PRTALERTGROUP_HOSTRESOURCESMIBDEVICETABLE,  "hostResourcesMIBDeviceTable" },
    { PRINTER_MIB_PRTALERTGROUP_GENERALPRINTER,               "generalPrinter" },
    { PRINTER_MIB_PRTALERTGROUP_COVER,                        "cover" },
    { PRINTER_MIB_PRTALERTGROUP_LOCALIZATION,                 "localization" },
    { PRINTER_MIB_PRTALERTGROUP_INPUT,                        "input" },
    { PRINTER_MIB_PRTALERTGROUP_OUTPUT,                       "output" },
    { PRINTER_MIB_PRTALERTGROUP_MARKER,                       "marker" },
    { PRINTER_MIB_PRTALERTGROUP_MARKERSUPPLIES,               "markerSupplies" },
    { PRINTER_MIB_PRTALERTGROUP_MARKERCOLORANT,               "markerColorant" },
    { PRINTER_MIB_PRTALERTGROUP_MEDIAPATH,                    "mediaPath" },
    { PRINTER_MIB_PRTALERTGROUP_CHANNEL,                      "channel" },
    { PRINTER_MIB_PRTALERTGROUP_INTERPRETER,                  "interpreter" },
    { PRINTER_MIB_PRTALERTGROUP_CONSOLEDISPLAYBUFFER,         "consoleDisplayBuffer" },
    { PRINTER_MIB_PRTALERTGROUP_CONSOLELIGHTS,                "consoleLights" },
    { PRINTER_MIB_PRTALERTGROUP_ALERT,                        "alert" },
    { PRINTER_MIB_PRTALERTGROUP_FINDEVICE,                    "finDevice" },
    { PRINTER_MIB_PRTALERTGROUP_FINSUPPLY,                    "finSupply" },
    { PRINTER_MIB_PRTALERTGROUP_FINSUPPLYMEDIAINPUT,          "finSupplyMediaInput" },
    { PRINTER_MIB_PRTALERTGROUP_FINATTRIBUTETABLE,            "finAttributeTable" },
    { 0, NULL }
};

GSnmpEnum const printer_mib_enums_prtAlertCode[] = {
    { PRINTER_MIB_PRTALERTCODE_OTHER,                                "other" },
    { PRINTER_MIB_PRTALERTCODE_UNKNOWN,                              "unknown" },
    { PRINTER_MIB_PRTALERTCODE_COVEROPEN,                            "coverOpen" },
    { PRINTER_MIB_PRTALERTCODE_COVERCLOSED,                          "coverClosed" },
    { PRINTER_MIB_PRTALERTCODE_INTERLOCKOPEN,                        "interlockOpen" },
    { PRINTER_MIB_PRTALERTCODE_INTERLOCKCLOSED,                      "interlockClosed" },
    { PRINTER_MIB_PRTALERTCODE_CONFIGURATIONCHANGE,                  "configurationChange" },
    { PRINTER_MIB_PRTALERTCODE_JAM,                                  "jam" },
    { PRINTER_MIB_PRTALERTCODE_SUBUNITMISSING,                       "subunitMissing" },
    { PRINTER_MIB_PRTALERTCODE_SUBUNITLIFEALMOSTOVER,                "subunitLifeAlmostOver" },
    { PRINTER_MIB_PRTALERTCODE_SUBUNITLIFEOVER,                      "subunitLifeOver" },
    { PRINTER_MIB_PRTALERTCODE_SUBUNITALMOSTEMPTY,                   "subunitAlmostEmpty" },
    { PRINTER_MIB_PRTALERTCODE_SUBUNITEMPTY,                         "subunitEmpty" },
    { PRINTER_MIB_PRTALERTCODE_SUBUNITALMOSTFULL,                    "subunitAlmostFull" },
    { PRINTER_MIB_PRTALERTCODE_SUBUNITFULL,                          "subunitFull" },
    { PRINTER_MIB_PRTALERTCODE_SUBUNITNEARLIMIT,                     "subunitNearLimit" },
    { PRINTER_MIB_PRTALERTCODE_SUBUNITATLIMIT,                       "subunitAtLimit" },
    { PRINTER_MIB_PRTALERTCODE_SUBUNITOPENED,                        "subunitOpened" },
    { PRINTER_MIB_PRTALERTCODE_SUBUNITCLOSED,                        "subunitClosed" },
    { PRINTER_MIB_PRTALERTCODE_SUBUNITTURNEDON,                      "subunitTurnedOn" },
    { PRINTER_MIB_PRTALERTCODE_SUBUNITTURNEDOFF,                     "subunitTurnedOff" },
    { PRINTER_MIB_PRTALERTCODE_SUBUNITOFFLINE,                       "subunitOffline" },
    { PRINTER_MIB_PRTALERTCODE_SUBUNITPOWERSAVER,                    "subunitPowerSaver" },
    { PRINTER_MIB_PRTALERTCODE_SUBUNITWARMINGUP,                     "subunitWarmingUp" },
    { PRINTER_MIB_PRTALERTCODE_SUBUNITADDED,                         "subunitAdded" },
    { PRINTER_MIB_PRTALERTCODE_SUBUNITREMOVED,                       "subunitRemoved" },
    { PRINTER_MIB_PRTALERTCODE_SUBUNITRESOURCEADDED,                 "subunitResourceAdded" },
    { PRINTER_MIB_PRTALERTCODE_SUBUNITRESOURCEREMOVED,               "subunitResourceRemoved" },
    { PRINTER_MIB_PRTALERTCODE_SUBUNITRECOVERABLEFAILURE,            "subunitRecoverableFailure" },
    { PRINTER_MIB_PRTALERTCODE_SUBUNITUNRECOVERABLEFAILURE,          "subunitUnrecoverableFailure" },
    { PRINTER_MIB_PRTALERTCODE_SUBUNITRECOVERABLESTORAGEERROR,       "subunitRecoverableStorageError" },
    { PRINTER_MIB_PRTALERTCODE_SUBUNITUNRECOVERABLESTORAGEERROR,     "subunitUnrecoverableStorageError" },
    { PRINTER_MIB_PRTALERTCODE_SUBUNITMOTORFAILURE,                  "subunitMotorFailure" },
    { PRINTER_MIB_PRTALERTCODE_SUBUNITMEMORYEXHAUSTED,               "subunitMemoryExhausted" },
    { PRINTER_MIB_PRTALERTCODE_SUBUNITUNDERTEMPERATURE,              "subunitUnderTemperature" },
    { PRINTER_MIB_PRTALERTCODE_SUBUNITOVERTEMPERATURE,               "subunitOverTemperature" },
    { PRINTER_MIB_PRTALERTCODE_SUBUNITTIMINGFAILURE,                 "subunitTimingFailure" },
    { PRINTER_MIB_PRTALERTCODE_SUBUNITTHERMISTORFAILURE,             "subunitThermistorFailure" },
    { PRINTER_MIB_PRTALERTCODE_DOOROPEN,                             "doorOpen" },
    { PRINTER_MIB_PRTALERTCODE_DOORCLOSED,                           "doorClosed" },
    { PRINTER_MIB_PRTALERTCODE_POWERUP,                              "powerUp" },
    { PRINTER_MIB_PRTALERTCODE_POWERDOWN,                            "powerDown" },
    { PRINTER_MIB_PRTALERTCODE_PRINTERNMSRESET,                      "printerNMSReset" },
    { PRINTER_MIB_PRTALERTCODE_PRINTERMANUALRESET,                   "printerManualReset" },
    { PRINTER_MIB_PRTALERTCODE_PRINTERREADYTOPRINT,                  "printerReadyToPrint" },
    { PRINTER_MIB_PRTALERTCODE_INPUTMEDIATRAYMISSING,                "inputMediaTrayMissing" },
    { PRINTER_MIB_PRTALERTCODE_INPUTMEDIASIZECHANGE,                 "inputMediaSizeChange" },
    { PRINTER_MIB_PRTALERTCODE_INPUTMEDIAWEIGHTCHANGE,               "inputMediaWeightChange" },
    { PRINTER_MIB_PRTALERTCODE_INPUTMEDIATYPECHANGE,                 "inputMediaTypeChange" },
    { PRINTER_MIB_PRTALERTCODE_INPUTMEDIACOLORCHANGE,                "inputMediaColorChange" },
    { PRINTER_MIB_PRTALERTCODE_INPUTMEDIAFORMPARTSCHANGE,            "inputMediaFormPartsChange" },
    { PRINTER_MIB_PRTALERTCODE_INPUTMEDIASUPPLYLOW,                  "inputMediaSupplyLow" },
    { PRINTER_MIB_PRTALERTCODE_INPUTMEDIASUPPLYEMPTY,                "inputMediaSupplyEmpty" },
    { PRINTER_MIB_PRTALERTCODE_INPUTMEDIACHANGEREQUEST,              "inputMediaChangeRequest" },
    { PRINTER_MIB_PRTALERTCODE_INPUTMANUALINPUTREQUEST,              "inputManualInputRequest" },
    { PRINTER_MIB_PRTALERTCODE_INPUTTRAYPOSITIONFAILURE,             "inputTrayPositionFailure" },
    { PRINTER_MIB_PRTALERTCODE_INPUTTRAYELEVATIONFAILURE,            "inputTrayElevationFailure" },
    { PRINTER_MIB_PRTALERTCODE_INPUTCANNOTFEEDSIZESELECTED,          "inputCannotFeedSizeSelected" },
    { PRINTER_MIB_PRTALERTCODE_OUTPUTMEDIATRAYMISSING,               "outputMediaTrayMissing" },
    { PRINTER_MIB_PRTALERTCODE_OUTPUTMEDIATRAYALMOSTFULL,            "outputMediaTrayAlmostFull" },
    { PRINTER_MIB_PRTALERTCODE_OUTPUTMEDIATRAYFULL,                  "outputMediaTrayFull" },
    { PRINTER_MIB_PRTALERTCODE_OUTPUTMAILBOXSELECTFAILURE,           "outputMailboxSelectFailure" },
    { PRINTER_MIB_PRTALERTCODE_MARKERFUSERUNDERTEMPERATURE,          "markerFuserUnderTemperature" },
    { PRINTER_MIB_PRTALERTCODE_MARKERFUSEROVERTEMPERATURE,           "markerFuserOverTemperature" },
    { PRINTER_MIB_PRTALERTCODE_MARKERFUSERTIMINGFAILURE,             "markerFuserTimingFailure" },
    { PRINTER_MIB_PRTALERTCODE_MARKERFUSERTHERMISTORFAILURE,         "markerFuserThermistorFailure" },
    { PRINTER_MIB_PRTALERTCODE_MARKERADJUSTINGPRINTQUALITY,          "markerAdjustingPrintQuality" },
    { PRINTER_MIB_PRTALERTCODE_MARKERTONEREMPTY,                     "markerTonerEmpty" },
    { PRINTER_MIB_PRTALERTCODE_MARKERINKEMPTY,                       "markerInkEmpty" },
    { PRINTER_MIB_PRTALERTCODE_MARKERPRINTRIBBONEMPTY,               "markerPrintRibbonEmpty" },
    { PRINTER_MIB_PRTALERTCODE_MARKERTONERALMOSTEMPTY,               "markerTonerAlmostEmpty" },
    { PRINTER_MIB_PRTALERTCODE_MARKERINKALMOSTEMPTY,                 "markerInkAlmostEmpty" },
    { PRINTER_MIB_PRTALERTCODE_MARKERPRINTRIBBONALMOSTEMPTY,         "markerPrintRibbonAlmostEmpty" },
    { PRINTER_MIB_PRTALERTCODE_MARKERWASTETONERRECEPTACLEALMOSTFULL, "markerWasteTonerReceptacleAlmostFull" },
    { PRINTER_MIB_PRTALERTCODE_MARKERWASTEINKRECEPTACLEALMOSTFULL,   "markerWasteInkReceptacleAlmostFull" },
    { PRINTER_MIB_PRTALERTCODE_MARKERWASTETONERRECEPTACLEFULL,       "markerWasteTonerReceptacleFull" },
    { PRINTER_MIB_PRTALERTCODE_MARKERWASTEINKRECEPTACLEFULL,         "markerWasteInkReceptacleFull" },
    { PRINTER_MIB_PRTALERTCODE_MARKEROPCLIFEALMOSTOVER,              "markerOpcLifeAlmostOver" },
    { PRINTER_MIB_PRTALERTCODE_MARKEROPCLIFEOVER,                    "markerOpcLifeOver" },
    { PRINTER_MIB_PRTALERTCODE_MARKERDEVELOPERALMOSTEMPTY,           "markerDeveloperAlmostEmpty" },
    { PRINTER_MIB_PRTALERTCODE_MARKERDEVELOPEREMPTY,                 "markerDeveloperEmpty" },
    { PRINTER_MIB_PRTALERTCODE_MARKERTONERCARTRIDGEMISSING,          "markerTonerCartridgeMissing" },
    { PRINTER_MIB_PRTALERTCODE_MEDIAPATHMEDIATRAYMISSING,            "mediaPathMediaTrayMissing" },
    { PRINTER_MIB_PRTALERTCODE_MEDIAPATHMEDIATRAYALMOSTFULL,         "mediaPathMediaTrayAlmostFull" },
    { PRINTER_MIB_PRTALERTCODE_MEDIAPATHMEDIATRAYFULL,               "mediaPathMediaTrayFull" },
    { PRINTER_MIB_PRTALERTCODE_MEDIAPATHCANNOTDUPLEXMEDIASELECTED,   "mediaPathcannotDuplexMediaSelected" },
    { PRINTER_MIB_PRTALERTCODE_INTERPRETERMEMORYINCREASE,            "interpreterMemoryIncrease" },
    { PRINTER_MIB_PRTALERTCODE_INTERPRETERMEMORYDECREASE,            "interpreterMemoryDecrease" },
    { PRINTER_MIB_PRTALERTCODE_INTERPRETERCARTRIDGEADDED,            "interpreterCartridgeAdded" },
    { PRINTER_MIB_PRTALERTCODE_INTERPRETERCARTRIDGEDELETED,          "interpreterCartridgeDeleted" },
    { PRINTER_MIB_PRTALERTCODE_INTERPRETERRESOURCEADDED,             "interpreterResourceAdded" },
    { PRINTER_MIB_PRTALERTCODE_INTERPRETERRESOURCEDELETED,           "interpreterResourceDeleted" },
    { PRINTER_MIB_PRTALERTCODE_INTERPRETERRESOURCEUNAVAILABLE,       "interpreterResourceUnavailable" },
    { PRINTER_MIB_PRTALERTCODE_INTERPRETERCOMPLEXPAGEENCOUNTERED,    "interpreterComplexPageEncountered" },
    { PRINTER_MIB_PRTALERTCODE_ALERTREMOVALOFBINARYCHANGEENTRY,      "alertRemovalOfBinaryChangeEntry" },
    { 0, NULL }
};


static guint32 const printerV1Alert[]
	= { PRINTER_MIB_PRINTERV1ALERT };

GSnmpIdentity const printer_mib_identities[] = {
    { printerV1Alert,
      sizeof(printerV1Alert)/sizeof(guint32),
      "printerV1Alert" },
    { 0, 0, NULL }
};


static guint32 prtGeneralCurrentLocalization_constraints[] = {1L, 65535L, 0, 0};
static guint16 prtGeneralCurrentOperator_constraints[] = {0, 127, 0, 0};
static guint16 prtGeneralServicePerson_constraints[] = {0, 127, 0, 0};
static guint32 prtMarkerDefaultIndex_constraints[] = {1L, 65535L, 0, 0};
static guint32 prtMediaPathDefaultIndex_constraints[] = {1L, 65535L, 0, 0};
static guint32 prtConsoleLocalization_constraints[] = {1L, 65535L, 0, 0};
static guint32 prtConsoleNumberOfDisplayLines_constraints[] = {0L, 65535L, 0, 0};
static guint32 prtConsoleNumberOfDisplayChars_constraints[] = {0L, 65535L, 0, 0};
static guint16 prtGeneralPrinterName_constraints[] = {0, 127, 0, 0};
static guint16 prtGeneralSerialNumber_constraints[] = {0, 255, 0, 0};
static guint32 prtStorageRefIndex_constraints[] = {0L, 65535L, 0, 0};
static guint32 prtDeviceRefIndex_constraints[] = {0L, 65535L, 0, 0};
static guint16 prtCoverDescription_constraints[] = {0, 255, 0, 0};
static guint16 prtLocalizationLanguage_constraints[] = {0, 2, 0, 0};
static guint16 prtLocalizationCountry_constraints[] = {0, 2, 0, 0};
static guint32 prtInputStatus_constraints[] = {0L, 126L, 0, 0};
static guint16 prtInputMediaName_constraints[] = {0, 63, 0, 0};
static guint16 prtInputName_constraints[] = {0, 63, 0, 0};
static guint16 prtInputVendorName_constraints[] = {0, 63, 0, 0};
static guint16 prtInputModel_constraints[] = {0, 63, 0, 0};
static guint16 prtInputVersion_constraints[] = {0, 63, 0, 0};
static guint16 prtInputSerialNumber_constraints[] = {0, 32, 0, 0};
static guint16 prtInputDescription_constraints[] = {0, 255, 0, 0};
static guint16 prtInputMediaType_constraints[] = {0, 63, 0, 0};
static guint16 prtInputMediaColor_constraints[] = {0, 63, 0, 0};
static guint32 prtOutputStatus_constraints[] = {0L, 126L, 0, 0};
static guint16 prtOutputName_constraints[] = {0, 63, 0, 0};
static guint16 prtOutputVendorName_constraints[] = {0, 63, 0, 0};
static guint16 prtOutputModel_constraints[] = {0, 63, 0, 0};
static guint16 prtOutputVersion_constraints[] = {0, 63, 0, 0};
static guint16 prtOutputSerialNumber_constraints[] = {0, 63, 0, 0};
static guint16 prtOutputDescription_constraints[] = {0, 255, 0, 0};
static guint32 prtMarkerProcessColorants_constraints[] = {0L, 65535L, 0, 0};
static guint32 prtMarkerSpotColorants_constraints[] = {0L, 65535L, 0, 0};
static guint32 prtMarkerStatus_constraints[] = {0L, 126L, 0, 0};
static guint32 prtMarkerSuppliesMarkerIndex_constraints[] = {0L, 65535L, 0, 0};
static guint32 prtMarkerSuppliesColorantIndex_constraints[] = {0L, 65535L, 0, 0};
static guint16 prtMarkerSuppliesDescription_constraints[] = {0, 255, 0, 0};
static guint32 prtMarkerColorantMarkerIndex_constraints[] = {0L, 65535L, 0, 0};
static guint16 prtMarkerColorantValue_constraints[] = {0, 255, 0, 0};
static guint16 prtMediaPathDescription_constraints[] = {0, 255, 0, 0};
static guint32 prtMediaPathStatus_constraints[] = {0L, 126L, 0, 0};
static guint16 prtChannelProtocolVersion_constraints[] = {0, 63, 0, 0};
static guint32 prtChannelStatus_constraints[] = {0L, 126L, 0, 0};
static guint16 prtChannelInformation_constraints[] = {0, 255, 0, 0};
static guint16 prtInterpreterLangLevel_constraints[] = {0, 31, 0, 0};
static guint16 prtInterpreterLangVersion_constraints[] = {0, 31, 0, 0};
static guint16 prtInterpreterDescription_constraints[] = {0, 255, 0, 0};
static guint16 prtInterpreterVersion_constraints[] = {0, 31, 0, 0};
static guint16 prtConsoleDisplayBufferText_constraints[] = {0, 255, 0, 0};
static guint16 prtConsoleDescription_constraints[] = {0, 255, 0, 0};
static guint16 prtAlertDescription_constraints[] = {0, 255, 0, 0};


static guint32 const prtGeneralEntry_oid[] = {1, 3, 6, 1, 2, 1, 43, 5, 1, 1};

static GSnmpAttribute prtGeneralEntry_attr[] = {
    { 1, G_SNMP_COUNTER32,
      PRINTER_MIB_PRTGENERALCONFIGCHANGES, "prtGeneralConfigChanges",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtGeneralEntry_t, prtGeneralConfigChanges),
      0,
      0 },
    { 2, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTGENERALCURRENTLOCALIZATION, "prtGeneralCurrentLocalization",
       prtGeneralCurrentLocalization_constraints,
      G_STRUCT_OFFSET(printer_mib_prtGeneralEntry_t, prtGeneralCurrentLocalization),
      0,
      GSNMP_ATTR_FLAG_WRITABLE },
    { 3, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTGENERALRESET, "prtGeneralReset",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtGeneralEntry_t, prtGeneralReset),
      0,
      GSNMP_ATTR_FLAG_WRITABLE },
    { 4, G_SNMP_OCTETSTRING,
      PRINTER_MIB_PRTGENERALCURRENTOPERATOR, "prtGeneralCurrentOperator",
       prtGeneralCurrentOperator_constraints,
      G_STRUCT_OFFSET(printer_mib_prtGeneralEntry_t, prtGeneralCurrentOperator),
      G_STRUCT_OFFSET(printer_mib_prtGeneralEntry_t, _prtGeneralCurrentOperatorLength),
      GSNMP_ATTR_FLAG_WRITABLE },
    { 5, G_SNMP_OCTETSTRING,
      PRINTER_MIB_PRTGENERALSERVICEPERSON, "prtGeneralServicePerson",
       prtGeneralServicePerson_constraints,
      G_STRUCT_OFFSET(printer_mib_prtGeneralEntry_t, prtGeneralServicePerson),
      G_STRUCT_OFFSET(printer_mib_prtGeneralEntry_t, _prtGeneralServicePersonLength),
      GSNMP_ATTR_FLAG_WRITABLE },
    { 6, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTINPUTDEFAULTINDEX, "prtInputDefaultIndex",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtGeneralEntry_t, prtInputDefaultIndex),
      0,
      GSNMP_ATTR_FLAG_WRITABLE },
    { 7, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTOUTPUTDEFAULTINDEX, "prtOutputDefaultIndex",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtGeneralEntry_t, prtOutputDefaultIndex),
      0,
      GSNMP_ATTR_FLAG_WRITABLE },
    { 8, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTMARKERDEFAULTINDEX, "prtMarkerDefaultIndex",
       prtMarkerDefaultIndex_constraints,
      G_STRUCT_OFFSET(printer_mib_prtGeneralEntry_t, prtMarkerDefaultIndex),
      0,
      GSNMP_ATTR_FLAG_WRITABLE },
    { 9, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTMEDIAPATHDEFAULTINDEX, "prtMediaPathDefaultIndex",
       prtMediaPathDefaultIndex_constraints,
      G_STRUCT_OFFSET(printer_mib_prtGeneralEntry_t, prtMediaPathDefaultIndex),
      0,
      GSNMP_ATTR_FLAG_WRITABLE },
    { 10, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTCONSOLELOCALIZATION, "prtConsoleLocalization",
       prtConsoleLocalization_constraints,
      G_STRUCT_OFFSET(printer_mib_prtGeneralEntry_t, prtConsoleLocalization),
      0,
      GSNMP_ATTR_FLAG_WRITABLE },
    { 11, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTCONSOLENUMBEROFDISPLAYLINES, "prtConsoleNumberOfDisplayLines",
       prtConsoleNumberOfDisplayLines_constraints,
      G_STRUCT_OFFSET(printer_mib_prtGeneralEntry_t, prtConsoleNumberOfDisplayLines),
      0,
      0 },
    { 12, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTCONSOLENUMBEROFDISPLAYCHARS, "prtConsoleNumberOfDisplayChars",
       prtConsoleNumberOfDisplayChars_constraints,
      G_STRUCT_OFFSET(printer_mib_prtGeneralEntry_t, prtConsoleNumberOfDisplayChars),
      0,
      0 },
    { 13, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTCONSOLEDISABLE, "prtConsoleDisable",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtGeneralEntry_t, prtConsoleDisable),
      0,
      GSNMP_ATTR_FLAG_WRITABLE },
    { 14, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTAUXILIARYSHEETSTARTUPPAGE, "prtAuxiliarySheetStartupPage",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtGeneralEntry_t, prtAuxiliarySheetStartupPage),
      0,
      GSNMP_ATTR_FLAG_WRITABLE },
    { 15, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTAUXILIARYSHEETBANNERPAGE, "prtAuxiliarySheetBannerPage",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtGeneralEntry_t, prtAuxiliarySheetBannerPage),
      0,
      GSNMP_ATTR_FLAG_WRITABLE },
    { 16, G_SNMP_OCTETSTRING,
      PRINTER_MIB_PRTGENERALPRINTERNAME, "prtGeneralPrinterName",
       prtGeneralPrinterName_constraints,
      G_STRUCT_OFFSET(printer_mib_prtGeneralEntry_t, prtGeneralPrinterName),
      G_STRUCT_OFFSET(printer_mib_prtGeneralEntry_t, _prtGeneralPrinterNameLength),
      GSNMP_ATTR_FLAG_WRITABLE },
    { 17, G_SNMP_OCTETSTRING,
      PRINTER_MIB_PRTGENERALSERIALNUMBER, "prtGeneralSerialNumber",
       prtGeneralSerialNumber_constraints,
      G_STRUCT_OFFSET(printer_mib_prtGeneralEntry_t, prtGeneralSerialNumber),
      G_STRUCT_OFFSET(printer_mib_prtGeneralEntry_t, _prtGeneralSerialNumberLength),
      GSNMP_ATTR_FLAG_WRITABLE },
    { 18, G_SNMP_COUNTER32,
      PRINTER_MIB_PRTALERTCRITICALEVENTS, "prtAlertCriticalEvents",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtGeneralEntry_t, prtAlertCriticalEvents),
      0,
      0 },
    { 19, G_SNMP_COUNTER32,
      PRINTER_MIB_PRTALERTALLEVENTS, "prtAlertAllEvents",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtGeneralEntry_t, prtAlertAllEvents),
      0,
      0 },
    { 0, 0, 0, NULL }
};

static guint32 const prtStorageRefEntry_oid[] = {1, 3, 6, 1, 2, 1, 43, 5, 2, 1};

static GSnmpAttribute prtStorageRefEntry_attr[] = {
    { 2, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTSTORAGEREFINDEX, "prtStorageRefIndex",
       prtStorageRefIndex_constraints,
      G_STRUCT_OFFSET(printer_mib_prtStorageRefEntry_t, prtStorageRefIndex),
      0,
      0 },
    { 0, 0, 0, NULL }
};

static guint32 const prtDeviceRefEntry_oid[] = {1, 3, 6, 1, 2, 1, 43, 5, 3, 1};

static GSnmpAttribute prtDeviceRefEntry_attr[] = {
    { 2, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTDEVICEREFINDEX, "prtDeviceRefIndex",
       prtDeviceRefIndex_constraints,
      G_STRUCT_OFFSET(printer_mib_prtDeviceRefEntry_t, prtDeviceRefIndex),
      0,
      0 },
    { 0, 0, 0, NULL }
};

static guint32 const prtCoverEntry_oid[] = {1, 3, 6, 1, 2, 1, 43, 6, 1, 1};

static GSnmpAttribute prtCoverEntry_attr[] = {
    { 2, G_SNMP_OCTETSTRING,
      PRINTER_MIB_PRTCOVERDESCRIPTION, "prtCoverDescription",
       prtCoverDescription_constraints,
      G_STRUCT_OFFSET(printer_mib_prtCoverEntry_t, prtCoverDescription),
      G_STRUCT_OFFSET(printer_mib_prtCoverEntry_t, _prtCoverDescriptionLength),
      0 },
    { 3, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTCOVERSTATUS, "prtCoverStatus",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtCoverEntry_t, prtCoverStatus),
      0,
      0 },
    { 0, 0, 0, NULL }
};

static guint32 const prtLocalizationEntry_oid[] = {1, 3, 6, 1, 2, 1, 43, 7, 1, 1};

static GSnmpAttribute prtLocalizationEntry_attr[] = {
    { 2, G_SNMP_OCTETSTRING,
      PRINTER_MIB_PRTLOCALIZATIONLANGUAGE, "prtLocalizationLanguage",
       prtLocalizationLanguage_constraints,
      G_STRUCT_OFFSET(printer_mib_prtLocalizationEntry_t, prtLocalizationLanguage),
      G_STRUCT_OFFSET(printer_mib_prtLocalizationEntry_t, _prtLocalizationLanguageLength),
      0 },
    { 3, G_SNMP_OCTETSTRING,
      PRINTER_MIB_PRTLOCALIZATIONCOUNTRY, "prtLocalizationCountry",
       prtLocalizationCountry_constraints,
      G_STRUCT_OFFSET(printer_mib_prtLocalizationEntry_t, prtLocalizationCountry),
      G_STRUCT_OFFSET(printer_mib_prtLocalizationEntry_t, _prtLocalizationCountryLength),
      0 },
    { 4, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTLOCALIZATIONCHARACTERSET, "prtLocalizationCharacterSet",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtLocalizationEntry_t, prtLocalizationCharacterSet),
      0,
      0 },
    { 0, 0, 0, NULL }
};

static guint32 const prtInputEntry_oid[] = {1, 3, 6, 1, 2, 1, 43, 8, 2, 1};

static GSnmpAttribute prtInputEntry_attr[] = {
    { 2, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTINPUTTYPE, "prtInputType",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtInputEntry_t, prtInputType),
      0,
      0 },
    { 3, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTINPUTDIMUNIT, "prtInputDimUnit",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtInputEntry_t, prtInputDimUnit),
      0,
      0 },
    { 4, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTINPUTMEDIADIMFEEDDIRDECLARED, "prtInputMediaDimFeedDirDeclared",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtInputEntry_t, prtInputMediaDimFeedDirDeclared),
      0,
      GSNMP_ATTR_FLAG_WRITABLE },
    { 5, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTINPUTMEDIADIMXFEEDDIRDECLARED, "prtInputMediaDimXFeedDirDeclared",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtInputEntry_t, prtInputMediaDimXFeedDirDeclared),
      0,
      GSNMP_ATTR_FLAG_WRITABLE },
    { 6, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTINPUTMEDIADIMFEEDDIRCHOSEN, "prtInputMediaDimFeedDirChosen",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtInputEntry_t, prtInputMediaDimFeedDirChosen),
      0,
      0 },
    { 7, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTINPUTMEDIADIMXFEEDDIRCHOSEN, "prtInputMediaDimXFeedDirChosen",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtInputEntry_t, prtInputMediaDimXFeedDirChosen),
      0,
      0 },
    { 8, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTINPUTCAPACITYUNIT, "prtInputCapacityUnit",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtInputEntry_t, prtInputCapacityUnit),
      0,
      0 },
    { 9, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTINPUTMAXCAPACITY, "prtInputMaxCapacity",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtInputEntry_t, prtInputMaxCapacity),
      0,
      GSNMP_ATTR_FLAG_WRITABLE },
    { 10, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTINPUTCURRENTLEVEL, "prtInputCurrentLevel",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtInputEntry_t, prtInputCurrentLevel),
      0,
      GSNMP_ATTR_FLAG_WRITABLE },
    { 11, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTINPUTSTATUS, "prtInputStatus",
       prtInputStatus_constraints,
      G_STRUCT_OFFSET(printer_mib_prtInputEntry_t, prtInputStatus),
      0,
      0 },
    { 12, G_SNMP_OCTETSTRING,
      PRINTER_MIB_PRTINPUTMEDIANAME, "prtInputMediaName",
       prtInputMediaName_constraints,
      G_STRUCT_OFFSET(printer_mib_prtInputEntry_t, prtInputMediaName),
      G_STRUCT_OFFSET(printer_mib_prtInputEntry_t, _prtInputMediaNameLength),
      GSNMP_ATTR_FLAG_WRITABLE },
    { 13, G_SNMP_OCTETSTRING,
      PRINTER_MIB_PRTINPUTNAME, "prtInputName",
       prtInputName_constraints,
      G_STRUCT_OFFSET(printer_mib_prtInputEntry_t, prtInputName),
      G_STRUCT_OFFSET(printer_mib_prtInputEntry_t, _prtInputNameLength),
      GSNMP_ATTR_FLAG_WRITABLE },
    { 14, G_SNMP_OCTETSTRING,
      PRINTER_MIB_PRTINPUTVENDORNAME, "prtInputVendorName",
       prtInputVendorName_constraints,
      G_STRUCT_OFFSET(printer_mib_prtInputEntry_t, prtInputVendorName),
      G_STRUCT_OFFSET(printer_mib_prtInputEntry_t, _prtInputVendorNameLength),
      0 },
    { 15, G_SNMP_OCTETSTRING,
      PRINTER_MIB_PRTINPUTMODEL, "prtInputModel",
       prtInputModel_constraints,
      G_STRUCT_OFFSET(printer_mib_prtInputEntry_t, prtInputModel),
      G_STRUCT_OFFSET(printer_mib_prtInputEntry_t, _prtInputModelLength),
      0 },
    { 16, G_SNMP_OCTETSTRING,
      PRINTER_MIB_PRTINPUTVERSION, "prtInputVersion",
       prtInputVersion_constraints,
      G_STRUCT_OFFSET(printer_mib_prtInputEntry_t, prtInputVersion),
      G_STRUCT_OFFSET(printer_mib_prtInputEntry_t, _prtInputVersionLength),
      0 },
    { 17, G_SNMP_OCTETSTRING,
      PRINTER_MIB_PRTINPUTSERIALNUMBER, "prtInputSerialNumber",
       prtInputSerialNumber_constraints,
      G_STRUCT_OFFSET(printer_mib_prtInputEntry_t, prtInputSerialNumber),
      G_STRUCT_OFFSET(printer_mib_prtInputEntry_t, _prtInputSerialNumberLength),
      0 },
    { 18, G_SNMP_OCTETSTRING,
      PRINTER_MIB_PRTINPUTDESCRIPTION, "prtInputDescription",
       prtInputDescription_constraints,
      G_STRUCT_OFFSET(printer_mib_prtInputEntry_t, prtInputDescription),
      G_STRUCT_OFFSET(printer_mib_prtInputEntry_t, _prtInputDescriptionLength),
      0 },
    { 19, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTINPUTSECURITY, "prtInputSecurity",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtInputEntry_t, prtInputSecurity),
      0,
      GSNMP_ATTR_FLAG_WRITABLE },
    { 20, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTINPUTMEDIAWEIGHT, "prtInputMediaWeight",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtInputEntry_t, prtInputMediaWeight),
      0,
      GSNMP_ATTR_FLAG_WRITABLE },
    { 21, G_SNMP_OCTETSTRING,
      PRINTER_MIB_PRTINPUTMEDIATYPE, "prtInputMediaType",
       prtInputMediaType_constraints,
      G_STRUCT_OFFSET(printer_mib_prtInputEntry_t, prtInputMediaType),
      G_STRUCT_OFFSET(printer_mib_prtInputEntry_t, _prtInputMediaTypeLength),
      GSNMP_ATTR_FLAG_WRITABLE },
    { 22, G_SNMP_OCTETSTRING,
      PRINTER_MIB_PRTINPUTMEDIACOLOR, "prtInputMediaColor",
       prtInputMediaColor_constraints,
      G_STRUCT_OFFSET(printer_mib_prtInputEntry_t, prtInputMediaColor),
      G_STRUCT_OFFSET(printer_mib_prtInputEntry_t, _prtInputMediaColorLength),
      GSNMP_ATTR_FLAG_WRITABLE },
    { 23, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTINPUTMEDIAFORMPARTS, "prtInputMediaFormParts",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtInputEntry_t, prtInputMediaFormParts),
      0,
      GSNMP_ATTR_FLAG_WRITABLE },
    { 24, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTINPUTMEDIALOADTIMEOUT, "prtInputMediaLoadTimeout",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtInputEntry_t, prtInputMediaLoadTimeout),
      0,
      GSNMP_ATTR_FLAG_WRITABLE },
    { 25, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTINPUTNEXTINDEX, "prtInputNextIndex",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtInputEntry_t, prtInputNextIndex),
      0,
      GSNMP_ATTR_FLAG_WRITABLE },
    { 0, 0, 0, NULL }
};

static guint32 const prtOutputEntry_oid[] = {1, 3, 6, 1, 2, 1, 43, 9, 2, 1};

static GSnmpAttribute prtOutputEntry_attr[] = {
    { 2, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTOUTPUTTYPE, "prtOutputType",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtOutputEntry_t, prtOutputType),
      0,
      0 },
    { 3, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTOUTPUTCAPACITYUNIT, "prtOutputCapacityUnit",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtOutputEntry_t, prtOutputCapacityUnit),
      0,
      0 },
    { 4, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTOUTPUTMAXCAPACITY, "prtOutputMaxCapacity",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtOutputEntry_t, prtOutputMaxCapacity),
      0,
      GSNMP_ATTR_FLAG_WRITABLE },
    { 5, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTOUTPUTREMAININGCAPACITY, "prtOutputRemainingCapacity",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtOutputEntry_t, prtOutputRemainingCapacity),
      0,
      GSNMP_ATTR_FLAG_WRITABLE },
    { 6, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTOUTPUTSTATUS, "prtOutputStatus",
       prtOutputStatus_constraints,
      G_STRUCT_OFFSET(printer_mib_prtOutputEntry_t, prtOutputStatus),
      0,
      0 },
    { 7, G_SNMP_OCTETSTRING,
      PRINTER_MIB_PRTOUTPUTNAME, "prtOutputName",
       prtOutputName_constraints,
      G_STRUCT_OFFSET(printer_mib_prtOutputEntry_t, prtOutputName),
      G_STRUCT_OFFSET(printer_mib_prtOutputEntry_t, _prtOutputNameLength),
      GSNMP_ATTR_FLAG_WRITABLE },
    { 8, G_SNMP_OCTETSTRING,
      PRINTER_MIB_PRTOUTPUTVENDORNAME, "prtOutputVendorName",
       prtOutputVendorName_constraints,
      G_STRUCT_OFFSET(printer_mib_prtOutputEntry_t, prtOutputVendorName),
      G_STRUCT_OFFSET(printer_mib_prtOutputEntry_t, _prtOutputVendorNameLength),
      0 },
    { 9, G_SNMP_OCTETSTRING,
      PRINTER_MIB_PRTOUTPUTMODEL, "prtOutputModel",
       prtOutputModel_constraints,
      G_STRUCT_OFFSET(printer_mib_prtOutputEntry_t, prtOutputModel),
      G_STRUCT_OFFSET(printer_mib_prtOutputEntry_t, _prtOutputModelLength),
      0 },
    { 10, G_SNMP_OCTETSTRING,
      PRINTER_MIB_PRTOUTPUTVERSION, "prtOutputVersion",
       prtOutputVersion_constraints,
      G_STRUCT_OFFSET(printer_mib_prtOutputEntry_t, prtOutputVersion),
      G_STRUCT_OFFSET(printer_mib_prtOutputEntry_t, _prtOutputVersionLength),
      0 },
    { 11, G_SNMP_OCTETSTRING,
      PRINTER_MIB_PRTOUTPUTSERIALNUMBER, "prtOutputSerialNumber",
       prtOutputSerialNumber_constraints,
      G_STRUCT_OFFSET(printer_mib_prtOutputEntry_t, prtOutputSerialNumber),
      G_STRUCT_OFFSET(printer_mib_prtOutputEntry_t, _prtOutputSerialNumberLength),
      0 },
    { 12, G_SNMP_OCTETSTRING,
      PRINTER_MIB_PRTOUTPUTDESCRIPTION, "prtOutputDescription",
       prtOutputDescription_constraints,
      G_STRUCT_OFFSET(printer_mib_prtOutputEntry_t, prtOutputDescription),
      G_STRUCT_OFFSET(printer_mib_prtOutputEntry_t, _prtOutputDescriptionLength),
      0 },
    { 13, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTOUTPUTSECURITY, "prtOutputSecurity",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtOutputEntry_t, prtOutputSecurity),
      0,
      GSNMP_ATTR_FLAG_WRITABLE },
    { 14, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTOUTPUTDIMUNIT, "prtOutputDimUnit",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtOutputEntry_t, prtOutputDimUnit),
      0,
      0 },
    { 15, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTOUTPUTMAXDIMFEEDDIR, "prtOutputMaxDimFeedDir",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtOutputEntry_t, prtOutputMaxDimFeedDir),
      0,
      GSNMP_ATTR_FLAG_WRITABLE },
    { 16, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTOUTPUTMAXDIMXFEEDDIR, "prtOutputMaxDimXFeedDir",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtOutputEntry_t, prtOutputMaxDimXFeedDir),
      0,
      GSNMP_ATTR_FLAG_WRITABLE },
    { 17, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTOUTPUTMINDIMFEEDDIR, "prtOutputMinDimFeedDir",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtOutputEntry_t, prtOutputMinDimFeedDir),
      0,
      GSNMP_ATTR_FLAG_WRITABLE },
    { 18, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTOUTPUTMINDIMXFEEDDIR, "prtOutputMinDimXFeedDir",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtOutputEntry_t, prtOutputMinDimXFeedDir),
      0,
      GSNMP_ATTR_FLAG_WRITABLE },
    { 19, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTOUTPUTSTACKINGORDER, "prtOutputStackingOrder",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtOutputEntry_t, prtOutputStackingOrder),
      0,
      GSNMP_ATTR_FLAG_WRITABLE },
    { 20, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTOUTPUTPAGEDELIVERYORIENTATION, "prtOutputPageDeliveryOrientation",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtOutputEntry_t, prtOutputPageDeliveryOrientation),
      0,
      GSNMP_ATTR_FLAG_WRITABLE },
    { 21, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTOUTPUTBURSTING, "prtOutputBursting",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtOutputEntry_t, prtOutputBursting),
      0,
      GSNMP_ATTR_FLAG_WRITABLE },
    { 22, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTOUTPUTDECOLLATING, "prtOutputDecollating",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtOutputEntry_t, prtOutputDecollating),
      0,
      GSNMP_ATTR_FLAG_WRITABLE },
    { 23, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTOUTPUTPAGECOLLATED, "prtOutputPageCollated",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtOutputEntry_t, prtOutputPageCollated),
      0,
      GSNMP_ATTR_FLAG_WRITABLE },
    { 24, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTOUTPUTOFFSETSTACKING, "prtOutputOffsetStacking",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtOutputEntry_t, prtOutputOffsetStacking),
      0,
      GSNMP_ATTR_FLAG_WRITABLE },
    { 0, 0, 0, NULL }
};

static guint32 const prtMarkerEntry_oid[] = {1, 3, 6, 1, 2, 1, 43, 10, 2, 1};

static GSnmpAttribute prtMarkerEntry_attr[] = {
    { 2, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTMARKERMARKTECH, "prtMarkerMarkTech",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtMarkerEntry_t, prtMarkerMarkTech),
      0,
      0 },
    { 3, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTMARKERCOUNTERUNIT, "prtMarkerCounterUnit",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtMarkerEntry_t, prtMarkerCounterUnit),
      0,
      0 },
    { 4, G_SNMP_COUNTER32,
      PRINTER_MIB_PRTMARKERLIFECOUNT, "prtMarkerLifeCount",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtMarkerEntry_t, prtMarkerLifeCount),
      0,
      0 },
    { 5, G_SNMP_COUNTER32,
      PRINTER_MIB_PRTMARKERPOWERONCOUNT, "prtMarkerPowerOnCount",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtMarkerEntry_t, prtMarkerPowerOnCount),
      0,
      0 },
    { 6, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTMARKERPROCESSCOLORANTS, "prtMarkerProcessColorants",
       prtMarkerProcessColorants_constraints,
      G_STRUCT_OFFSET(printer_mib_prtMarkerEntry_t, prtMarkerProcessColorants),
      0,
      0 },
    { 7, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTMARKERSPOTCOLORANTS, "prtMarkerSpotColorants",
       prtMarkerSpotColorants_constraints,
      G_STRUCT_OFFSET(printer_mib_prtMarkerEntry_t, prtMarkerSpotColorants),
      0,
      0 },
    { 8, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTMARKERADDRESSABILITYUNIT, "prtMarkerAddressabilityUnit",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtMarkerEntry_t, prtMarkerAddressabilityUnit),
      0,
      0 },
    { 9, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTMARKERADDRESSABILITYFEEDDIR, "prtMarkerAddressabilityFeedDir",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtMarkerEntry_t, prtMarkerAddressabilityFeedDir),
      0,
      0 },
    { 10, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTMARKERADDRESSABILITYXFEEDDIR, "prtMarkerAddressabilityXFeedDir",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtMarkerEntry_t, prtMarkerAddressabilityXFeedDir),
      0,
      0 },
    { 11, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTMARKERNORTHMARGIN, "prtMarkerNorthMargin",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtMarkerEntry_t, prtMarkerNorthMargin),
      0,
      0 },
    { 12, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTMARKERSOUTHMARGIN, "prtMarkerSouthMargin",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtMarkerEntry_t, prtMarkerSouthMargin),
      0,
      0 },
    { 13, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTMARKERWESTMARGIN, "prtMarkerWestMargin",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtMarkerEntry_t, prtMarkerWestMargin),
      0,
      0 },
    { 14, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTMARKEREASTMARGIN, "prtMarkerEastMargin",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtMarkerEntry_t, prtMarkerEastMargin),
      0,
      0 },
    { 15, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTMARKERSTATUS, "prtMarkerStatus",
       prtMarkerStatus_constraints,
      G_STRUCT_OFFSET(printer_mib_prtMarkerEntry_t, prtMarkerStatus),
      0,
      0 },
    { 0, 0, 0, NULL }
};

static guint32 const prtMarkerSuppliesEntry_oid[] = {1, 3, 6, 1, 2, 1, 43, 11, 1, 1};

static GSnmpAttribute prtMarkerSuppliesEntry_attr[] = {
    { 2, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTMARKERSUPPLIESMARKERINDEX, "prtMarkerSuppliesMarkerIndex",
       prtMarkerSuppliesMarkerIndex_constraints,
      G_STRUCT_OFFSET(printer_mib_prtMarkerSuppliesEntry_t, prtMarkerSuppliesMarkerIndex),
      0,
      0 },
    { 3, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTMARKERSUPPLIESCOLORANTINDEX, "prtMarkerSuppliesColorantIndex",
       prtMarkerSuppliesColorantIndex_constraints,
      G_STRUCT_OFFSET(printer_mib_prtMarkerSuppliesEntry_t, prtMarkerSuppliesColorantIndex),
      0,
      0 },
    { 4, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTMARKERSUPPLIESCLASS, "prtMarkerSuppliesClass",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtMarkerSuppliesEntry_t, prtMarkerSuppliesClass),
      0,
      0 },
    { 5, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTMARKERSUPPLIESTYPE, "prtMarkerSuppliesType",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtMarkerSuppliesEntry_t, prtMarkerSuppliesType),
      0,
      0 },
    { 6, G_SNMP_OCTETSTRING,
      PRINTER_MIB_PRTMARKERSUPPLIESDESCRIPTION, "prtMarkerSuppliesDescription",
       prtMarkerSuppliesDescription_constraints,
      G_STRUCT_OFFSET(printer_mib_prtMarkerSuppliesEntry_t, prtMarkerSuppliesDescription),
      G_STRUCT_OFFSET(printer_mib_prtMarkerSuppliesEntry_t, _prtMarkerSuppliesDescriptionLength),
      0 },
    { 7, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTMARKERSUPPLIESSUPPLYUNIT, "prtMarkerSuppliesSupplyUnit",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtMarkerSuppliesEntry_t, prtMarkerSuppliesSupplyUnit),
      0,
      0 },
    { 8, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTMARKERSUPPLIESMAXCAPACITY, "prtMarkerSuppliesMaxCapacity",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtMarkerSuppliesEntry_t, prtMarkerSuppliesMaxCapacity),
      0,
      GSNMP_ATTR_FLAG_WRITABLE },
    { 9, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTMARKERSUPPLIESLEVEL, "prtMarkerSuppliesLevel",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtMarkerSuppliesEntry_t, prtMarkerSuppliesLevel),
      0,
      GSNMP_ATTR_FLAG_WRITABLE },
    { 0, 0, 0, NULL }
};

static guint32 const prtMarkerColorantEntry_oid[] = {1, 3, 6, 1, 2, 1, 43, 12, 1, 1};

static GSnmpAttribute prtMarkerColorantEntry_attr[] = {
    { 2, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTMARKERCOLORANTMARKERINDEX, "prtMarkerColorantMarkerIndex",
       prtMarkerColorantMarkerIndex_constraints,
      G_STRUCT_OFFSET(printer_mib_prtMarkerColorantEntry_t, prtMarkerColorantMarkerIndex),
      0,
      0 },
    { 3, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTMARKERCOLORANTROLE, "prtMarkerColorantRole",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtMarkerColorantEntry_t, prtMarkerColorantRole),
      0,
      0 },
    { 4, G_SNMP_OCTETSTRING,
      PRINTER_MIB_PRTMARKERCOLORANTVALUE, "prtMarkerColorantValue",
       prtMarkerColorantValue_constraints,
      G_STRUCT_OFFSET(printer_mib_prtMarkerColorantEntry_t, prtMarkerColorantValue),
      G_STRUCT_OFFSET(printer_mib_prtMarkerColorantEntry_t, _prtMarkerColorantValueLength),
      0 },
    { 5, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTMARKERCOLORANTTONALITY, "prtMarkerColorantTonality",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtMarkerColorantEntry_t, prtMarkerColorantTonality),
      0,
      0 },
    { 0, 0, 0, NULL }
};

static guint32 const prtMediaPathEntry_oid[] = {1, 3, 6, 1, 2, 1, 43, 13, 4, 1};

static GSnmpAttribute prtMediaPathEntry_attr[] = {
    { 2, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTMEDIAPATHMAXSPEEDPRINTUNIT, "prtMediaPathMaxSpeedPrintUnit",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtMediaPathEntry_t, prtMediaPathMaxSpeedPrintUnit),
      0,
      0 },
    { 3, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTMEDIAPATHMEDIASIZEUNIT, "prtMediaPathMediaSizeUnit",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtMediaPathEntry_t, prtMediaPathMediaSizeUnit),
      0,
      0 },
    { 4, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTMEDIAPATHMAXSPEED, "prtMediaPathMaxSpeed",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtMediaPathEntry_t, prtMediaPathMaxSpeed),
      0,
      0 },
    { 5, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTMEDIAPATHMAXMEDIAFEEDDIR, "prtMediaPathMaxMediaFeedDir",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtMediaPathEntry_t, prtMediaPathMaxMediaFeedDir),
      0,
      0 },
    { 6, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTMEDIAPATHMAXMEDIAXFEEDDIR, "prtMediaPathMaxMediaXFeedDir",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtMediaPathEntry_t, prtMediaPathMaxMediaXFeedDir),
      0,
      0 },
    { 7, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTMEDIAPATHMINMEDIAFEEDDIR, "prtMediaPathMinMediaFeedDir",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtMediaPathEntry_t, prtMediaPathMinMediaFeedDir),
      0,
      0 },
    { 8, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTMEDIAPATHMINMEDIAXFEEDDIR, "prtMediaPathMinMediaXFeedDir",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtMediaPathEntry_t, prtMediaPathMinMediaXFeedDir),
      0,
      0 },
    { 9, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTMEDIAPATHTYPE, "prtMediaPathType",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtMediaPathEntry_t, prtMediaPathType),
      0,
      0 },
    { 10, G_SNMP_OCTETSTRING,
      PRINTER_MIB_PRTMEDIAPATHDESCRIPTION, "prtMediaPathDescription",
       prtMediaPathDescription_constraints,
      G_STRUCT_OFFSET(printer_mib_prtMediaPathEntry_t, prtMediaPathDescription),
      G_STRUCT_OFFSET(printer_mib_prtMediaPathEntry_t, _prtMediaPathDescriptionLength),
      0 },
    { 11, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTMEDIAPATHSTATUS, "prtMediaPathStatus",
       prtMediaPathStatus_constraints,
      G_STRUCT_OFFSET(printer_mib_prtMediaPathEntry_t, prtMediaPathStatus),
      0,
      0 },
    { 0, 0, 0, NULL }
};

static guint32 const prtChannelEntry_oid[] = {1, 3, 6, 1, 2, 1, 43, 14, 1, 1};

static GSnmpAttribute prtChannelEntry_attr[] = {
    { 2, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTCHANNELTYPE, "prtChannelType",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtChannelEntry_t, prtChannelType),
      0,
      0 },
    { 3, G_SNMP_OCTETSTRING,
      PRINTER_MIB_PRTCHANNELPROTOCOLVERSION, "prtChannelProtocolVersion",
       prtChannelProtocolVersion_constraints,
      G_STRUCT_OFFSET(printer_mib_prtChannelEntry_t, prtChannelProtocolVersion),
      G_STRUCT_OFFSET(printer_mib_prtChannelEntry_t, _prtChannelProtocolVersionLength),
      0 },
    { 4, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTCHANNELCURRENTJOBCNTLLANGINDEX, "prtChannelCurrentJobCntlLangIndex",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtChannelEntry_t, prtChannelCurrentJobCntlLangIndex),
      0,
      GSNMP_ATTR_FLAG_WRITABLE },
    { 5, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTCHANNELDEFAULTPAGEDESCLANGINDEX, "prtChannelDefaultPageDescLangIndex",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtChannelEntry_t, prtChannelDefaultPageDescLangIndex),
      0,
      GSNMP_ATTR_FLAG_WRITABLE },
    { 6, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTCHANNELSTATE, "prtChannelState",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtChannelEntry_t, prtChannelState),
      0,
      GSNMP_ATTR_FLAG_WRITABLE },
    { 7, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTCHANNELIFINDEX, "prtChannelIfIndex",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtChannelEntry_t, prtChannelIfIndex),
      0,
      GSNMP_ATTR_FLAG_WRITABLE },
    { 8, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTCHANNELSTATUS, "prtChannelStatus",
       prtChannelStatus_constraints,
      G_STRUCT_OFFSET(printer_mib_prtChannelEntry_t, prtChannelStatus),
      0,
      0 },
    { 9, G_SNMP_OCTETSTRING,
      PRINTER_MIB_PRTCHANNELINFORMATION, "prtChannelInformation",
       prtChannelInformation_constraints,
      G_STRUCT_OFFSET(printer_mib_prtChannelEntry_t, prtChannelInformation),
      G_STRUCT_OFFSET(printer_mib_prtChannelEntry_t, _prtChannelInformationLength),
      0 },
    { 0, 0, 0, NULL }
};

static guint32 const prtInterpreterEntry_oid[] = {1, 3, 6, 1, 2, 1, 43, 15, 1, 1};

static GSnmpAttribute prtInterpreterEntry_attr[] = {
    { 2, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTINTERPRETERLANGFAMILY, "prtInterpreterLangFamily",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtInterpreterEntry_t, prtInterpreterLangFamily),
      0,
      0 },
    { 3, G_SNMP_OCTETSTRING,
      PRINTER_MIB_PRTINTERPRETERLANGLEVEL, "prtInterpreterLangLevel",
       prtInterpreterLangLevel_constraints,
      G_STRUCT_OFFSET(printer_mib_prtInterpreterEntry_t, prtInterpreterLangLevel),
      G_STRUCT_OFFSET(printer_mib_prtInterpreterEntry_t, _prtInterpreterLangLevelLength),
      0 },
    { 4, G_SNMP_OCTETSTRING,
      PRINTER_MIB_PRTINTERPRETERLANGVERSION, "prtInterpreterLangVersion",
       prtInterpreterLangVersion_constraints,
      G_STRUCT_OFFSET(printer_mib_prtInterpreterEntry_t, prtInterpreterLangVersion),
      G_STRUCT_OFFSET(printer_mib_prtInterpreterEntry_t, _prtInterpreterLangVersionLength),
      0 },
    { 5, G_SNMP_OCTETSTRING,
      PRINTER_MIB_PRTINTERPRETERDESCRIPTION, "prtInterpreterDescription",
       prtInterpreterDescription_constraints,
      G_STRUCT_OFFSET(printer_mib_prtInterpreterEntry_t, prtInterpreterDescription),
      G_STRUCT_OFFSET(printer_mib_prtInterpreterEntry_t, _prtInterpreterDescriptionLength),
      0 },
    { 6, G_SNMP_OCTETSTRING,
      PRINTER_MIB_PRTINTERPRETERVERSION, "prtInterpreterVersion",
       prtInterpreterVersion_constraints,
      G_STRUCT_OFFSET(printer_mib_prtInterpreterEntry_t, prtInterpreterVersion),
      G_STRUCT_OFFSET(printer_mib_prtInterpreterEntry_t, _prtInterpreterVersionLength),
      0 },
    { 7, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTINTERPRETERDEFAULTORIENTATION, "prtInterpreterDefaultOrientation",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtInterpreterEntry_t, prtInterpreterDefaultOrientation),
      0,
      GSNMP_ATTR_FLAG_WRITABLE },
    { 8, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTINTERPRETERFEEDADDRESSABILITY, "prtInterpreterFeedAddressability",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtInterpreterEntry_t, prtInterpreterFeedAddressability),
      0,
      0 },
    { 9, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTINTERPRETERXFEEDADDRESSABILITY, "prtInterpreterXFeedAddressability",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtInterpreterEntry_t, prtInterpreterXFeedAddressability),
      0,
      0 },
    { 10, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTINTERPRETERDEFAULTCHARSETIN, "prtInterpreterDefaultCharSetIn",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtInterpreterEntry_t, prtInterpreterDefaultCharSetIn),
      0,
      GSNMP_ATTR_FLAG_WRITABLE },
    { 11, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTINTERPRETERDEFAULTCHARSETOUT, "prtInterpreterDefaultCharSetOut",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtInterpreterEntry_t, prtInterpreterDefaultCharSetOut),
      0,
      GSNMP_ATTR_FLAG_WRITABLE },
    { 12, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTINTERPRETERTWOWAY, "prtInterpreterTwoWay",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtInterpreterEntry_t, prtInterpreterTwoWay),
      0,
      0 },
    { 0, 0, 0, NULL }
};

static guint32 const prtConsoleDisplayBufferEntry_oid[] = {1, 3, 6, 1, 2, 1, 43, 16, 5, 1};

static GSnmpAttribute prtConsoleDisplayBufferEntry_attr[] = {
    { 2, G_SNMP_OCTETSTRING,
      PRINTER_MIB_PRTCONSOLEDISPLAYBUFFERTEXT, "prtConsoleDisplayBufferText",
       prtConsoleDisplayBufferText_constraints,
      G_STRUCT_OFFSET(printer_mib_prtConsoleDisplayBufferEntry_t, prtConsoleDisplayBufferText),
      G_STRUCT_OFFSET(printer_mib_prtConsoleDisplayBufferEntry_t, _prtConsoleDisplayBufferTextLength),
      GSNMP_ATTR_FLAG_WRITABLE },
    { 0, 0, 0, NULL }
};

static guint32 const prtConsoleLightEntry_oid[] = {1, 3, 6, 1, 2, 1, 43, 17, 6, 1};

static GSnmpAttribute prtConsoleLightEntry_attr[] = {
    { 2, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTCONSOLEONTIME, "prtConsoleOnTime",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtConsoleLightEntry_t, prtConsoleOnTime),
      0,
      GSNMP_ATTR_FLAG_WRITABLE },
    { 3, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTCONSOLEOFFTIME, "prtConsoleOffTime",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtConsoleLightEntry_t, prtConsoleOffTime),
      0,
      GSNMP_ATTR_FLAG_WRITABLE },
    { 4, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTCONSOLECOLOR, "prtConsoleColor",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtConsoleLightEntry_t, prtConsoleColor),
      0,
      0 },
    { 5, G_SNMP_OCTETSTRING,
      PRINTER_MIB_PRTCONSOLEDESCRIPTION, "prtConsoleDescription",
       prtConsoleDescription_constraints,
      G_STRUCT_OFFSET(printer_mib_prtConsoleLightEntry_t, prtConsoleDescription),
      G_STRUCT_OFFSET(printer_mib_prtConsoleLightEntry_t, _prtConsoleDescriptionLength),
      0 },
    { 0, 0, 0, NULL }
};

static guint32 const prtAlertEntry_oid[] = {1, 3, 6, 1, 2, 1, 43, 18, 1, 1};

static GSnmpAttribute prtAlertEntry_attr[] = {
    { 2, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTALERTSEVERITYLEVEL, "prtAlertSeverityLevel",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtAlertEntry_t, prtAlertSeverityLevel),
      0,
      0 },
    { 3, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTALERTTRAININGLEVEL, "prtAlertTrainingLevel",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtAlertEntry_t, prtAlertTrainingLevel),
      0,
      0 },
    { 4, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTALERTGROUP, "prtAlertGroup",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtAlertEntry_t, prtAlertGroup),
      0,
      0 },
    { 5, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTALERTGROUPINDEX, "prtAlertGroupIndex",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtAlertEntry_t, prtAlertGroupIndex),
      0,
      0 },
    { 6, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTALERTLOCATION, "prtAlertLocation",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtAlertEntry_t, prtAlertLocation),
      0,
      0 },
    { 7, G_SNMP_INTEGER32,
      PRINTER_MIB_PRTALERTCODE, "prtAlertCode",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtAlertEntry_t, prtAlertCode),
      0,
      0 },
    { 8, G_SNMP_OCTETSTRING,
      PRINTER_MIB_PRTALERTDESCRIPTION, "prtAlertDescription",
       prtAlertDescription_constraints,
      G_STRUCT_OFFSET(printer_mib_prtAlertEntry_t, prtAlertDescription),
      G_STRUCT_OFFSET(printer_mib_prtAlertEntry_t, _prtAlertDescriptionLength),
      0 },
    { 9, G_SNMP_TIMETICKS,
      PRINTER_MIB_PRTALERTTIME, "prtAlertTime",
       NULL,
      G_STRUCT_OFFSET(printer_mib_prtAlertEntry_t, prtAlertTime),
      0,
      0 },
    { 0, 0, 0, NULL }
};


printer_mib_prtGeneralEntry_t *
printer_mib_new_prtGeneralEntry()
{
    printer_mib_prtGeneralEntry_t *prtGeneralEntry;

    prtGeneralEntry = (printer_mib_prtGeneralEntry_t *) g_malloc0(sizeof(printer_mib_prtGeneralEntry_t) + sizeof(gpointer));
    return prtGeneralEntry;
}

static int
unpack_prtGeneralEntry(GSnmpVarBind *vb, printer_mib_prtGeneralEntry_t *prtGeneralEntry)
{
    guint8 idx = 11;

    if (vb->id_len < idx) return -1;
    prtGeneralEntry->hrDeviceIndex = vb->id[idx++];
    if (vb->id_len > idx) return -1;
    return 0;
}

static int
pack_prtGeneralEntry(guint32 *base, gint32 hrDeviceIndex)
{
    guint8 idx = 11;

    base[idx++] = hrDeviceIndex;
    return idx;
}

static printer_mib_prtGeneralEntry_t *
assign_prtGeneralEntry(GSList *vbl)
{
    printer_mib_prtGeneralEntry_t *prtGeneralEntry;
    char *p;

    prtGeneralEntry = printer_mib_new_prtGeneralEntry();
    if (! prtGeneralEntry) {
        return NULL;
    }

    p = (char *) prtGeneralEntry + sizeof(printer_mib_prtGeneralEntry_t);
    * (GSList **) p = vbl;

    if (unpack_prtGeneralEntry((GSnmpVarBind *) vbl->data, prtGeneralEntry) < 0) {
        g_warning("%s: invalid instance identifier", "prtGeneralEntry");
        g_free(prtGeneralEntry);
        return NULL;
    }

    gsnmp_attr_assign(vbl, prtGeneralEntry_oid, sizeof(prtGeneralEntry_oid)/sizeof(guint32),
                      prtGeneralEntry_attr, prtGeneralEntry);

    return prtGeneralEntry;
}

void
printer_mib_get_prtGeneralTable(GSnmpSession *s, printer_mib_prtGeneralEntry_t ***prtGeneralEntry, gint mask)
{
    GSList *in = NULL, *out = NULL;
    GSList *row;
    int i;
    static guint32 base[] = {1, 3, 6, 1, 2, 1, 43, 5, 1, 1, 0};

    *prtGeneralEntry = NULL;

    gsnmp_attr_get(s, &in, base, 11, 10, prtGeneralEntry_attr, mask);

    out = gsnmp_gettable(s, in);
    /* g_snmp_vbl_free(in); */

    if (out) {
        *prtGeneralEntry = (printer_mib_prtGeneralEntry_t **) g_malloc0((g_slist_length(out) + 1) * sizeof(printer_mib_prtGeneralEntry_t *));
        if (! *prtGeneralEntry) {
            s->error_status = G_SNMP_ERR_INTERNAL;
            g_snmp_vbl_free(out);
            return;
        }
        for (row = out, i = 0; row; row = g_slist_next(row), i++) {
            (*prtGeneralEntry)[i] = assign_prtGeneralEntry(row->data);
        }
    }
}

void
printer_mib_get_prtGeneralEntry(GSnmpSession *s, printer_mib_prtGeneralEntry_t **prtGeneralEntry, gint32 hrDeviceIndex, gint mask)
{
    GSList *in = NULL, *out = NULL;
    guint32 base[128];
    gint8 len;

    memset(base, 0, sizeof(base));
    memcpy(base, prtGeneralEntry_oid, sizeof(prtGeneralEntry_oid));
    len = pack_prtGeneralEntry(base, hrDeviceIndex);
    if (len < 0) {
        g_warning("%s: invalid index values", "prtGeneralEntry");
        s->error_status = G_SNMP_ERR_INTERNAL;
        return;
    }

    *prtGeneralEntry = NULL;

    gsnmp_attr_get(s, &in, base, len, 10, prtGeneralEntry_attr, mask);

    out = g_snmp_session_sync_get(s, in);
    g_snmp_vbl_free(in);
    if (out) {
        if (s->error_status != G_SNMP_ERR_NOERROR) {
            g_snmp_vbl_free(out);
            return;
        }
        *prtGeneralEntry = assign_prtGeneralEntry(out);
    }
}

void
printer_mib_set_prtGeneralEntry(GSnmpSession *s, printer_mib_prtGeneralEntry_t *prtGeneralEntry, gint mask)
{
    GSList *in = NULL, *out = NULL;
    guint32 base[128];
    gint8 len;

    memset(base, 0, sizeof(base));
    memcpy(base, prtGeneralEntry_oid, sizeof(prtGeneralEntry_oid));
    len = pack_prtGeneralEntry(base, prtGeneralEntry->hrDeviceIndex);
    if (len < 0) {
        g_warning("%s: invalid index values", "prtGeneralEntry");
        s->error_status = G_SNMP_ERR_INTERNAL;
        return;
    }

    gsnmp_attr_set(s, &in, base, len, 10, prtGeneralEntry_attr, mask, prtGeneralEntry);

    out = g_snmp_session_sync_set(s, in);
    g_snmp_vbl_free(in);
    if (out) {
        g_snmp_vbl_free(out);
    }
}

void
printer_mib_free_prtGeneralEntry(printer_mib_prtGeneralEntry_t *prtGeneralEntry)
{
    GSList *vbl;
    char *p;

    if (prtGeneralEntry) {
        p = (char *) prtGeneralEntry + sizeof(printer_mib_prtGeneralEntry_t);
        vbl = * (GSList **) p;
        g_snmp_vbl_free(vbl);
        g_free(prtGeneralEntry);
    }
}

void
printer_mib_free_prtGeneralTable(printer_mib_prtGeneralEntry_t **prtGeneralEntry)
{
    int i;

    if (prtGeneralEntry) {
        for (i = 0; prtGeneralEntry[i]; i++) {
            printer_mib_free_prtGeneralEntry(prtGeneralEntry[i]);
        }
        g_free(prtGeneralEntry);
    }
}

printer_mib_prtStorageRefEntry_t *
printer_mib_new_prtStorageRefEntry()
{
    printer_mib_prtStorageRefEntry_t *prtStorageRefEntry;

    prtStorageRefEntry = (printer_mib_prtStorageRefEntry_t *) g_malloc0(sizeof(printer_mib_prtStorageRefEntry_t) + sizeof(gpointer));
    return prtStorageRefEntry;
}

static int
unpack_prtStorageRefEntry(GSnmpVarBind *vb, printer_mib_prtStorageRefEntry_t *prtStorageRefEntry)
{
    guint8 idx = 11;

    if (vb->id_len < idx) return -1;
    prtStorageRefEntry->hrStorageIndex = vb->id[idx++];
    if (vb->id_len < idx) return -1;
    prtStorageRefEntry->prtStorageRefSeqNumber = vb->id[idx++];
    if (vb->id_len > idx) return -1;
    return 0;
}

static int
pack_prtStorageRefEntry(guint32 *base, gint32 hrStorageIndex, gint32 prtStorageRefSeqNumber)
{
    guint8 idx = 11;

    base[idx++] = hrStorageIndex;
    base[idx++] = prtStorageRefSeqNumber;
    return idx;
}

static printer_mib_prtStorageRefEntry_t *
assign_prtStorageRefEntry(GSList *vbl)
{
    printer_mib_prtStorageRefEntry_t *prtStorageRefEntry;
    char *p;

    prtStorageRefEntry = printer_mib_new_prtStorageRefEntry();
    if (! prtStorageRefEntry) {
        return NULL;
    }

    p = (char *) prtStorageRefEntry + sizeof(printer_mib_prtStorageRefEntry_t);
    * (GSList **) p = vbl;

    if (unpack_prtStorageRefEntry((GSnmpVarBind *) vbl->data, prtStorageRefEntry) < 0) {
        g_warning("%s: invalid instance identifier", "prtStorageRefEntry");
        g_free(prtStorageRefEntry);
        return NULL;
    }

    gsnmp_attr_assign(vbl, prtStorageRefEntry_oid, sizeof(prtStorageRefEntry_oid)/sizeof(guint32),
                      prtStorageRefEntry_attr, prtStorageRefEntry);

    return prtStorageRefEntry;
}

void
printer_mib_get_prtStorageRefTable(GSnmpSession *s, printer_mib_prtStorageRefEntry_t ***prtStorageRefEntry, gint mask)
{
    GSList *in = NULL, *out = NULL;
    GSList *row;
    int i;
    static guint32 base[] = {1, 3, 6, 1, 2, 1, 43, 5, 2, 1, 0};

    *prtStorageRefEntry = NULL;

    gsnmp_attr_get(s, &in, base, 11, 10, prtStorageRefEntry_attr, mask);

    out = gsnmp_gettable(s, in);
    /* g_snmp_vbl_free(in); */

    if (out) {
        *prtStorageRefEntry = (printer_mib_prtStorageRefEntry_t **) g_malloc0((g_slist_length(out) + 1) * sizeof(printer_mib_prtStorageRefEntry_t *));
        if (! *prtStorageRefEntry) {
            s->error_status = G_SNMP_ERR_INTERNAL;
            g_snmp_vbl_free(out);
            return;
        }
        for (row = out, i = 0; row; row = g_slist_next(row), i++) {
            (*prtStorageRefEntry)[i] = assign_prtStorageRefEntry(row->data);
        }
    }
}

void
printer_mib_get_prtStorageRefEntry(GSnmpSession *s, printer_mib_prtStorageRefEntry_t **prtStorageRefEntry, gint32 hrStorageIndex, gint32 prtStorageRefSeqNumber, gint mask)
{
    GSList *in = NULL, *out = NULL;
    guint32 base[128];
    gint8 len;

    memset(base, 0, sizeof(base));
    memcpy(base, prtStorageRefEntry_oid, sizeof(prtStorageRefEntry_oid));
    len = pack_prtStorageRefEntry(base, hrStorageIndex, prtStorageRefSeqNumber);
    if (len < 0) {
        g_warning("%s: invalid index values", "prtStorageRefEntry");
        s->error_status = G_SNMP_ERR_INTERNAL;
        return;
    }

    *prtStorageRefEntry = NULL;

    gsnmp_attr_get(s, &in, base, len, 10, prtStorageRefEntry_attr, mask);

    out = g_snmp_session_sync_get(s, in);
    g_snmp_vbl_free(in);
    if (out) {
        if (s->error_status != G_SNMP_ERR_NOERROR) {
            g_snmp_vbl_free(out);
            return;
        }
        *prtStorageRefEntry = assign_prtStorageRefEntry(out);
    }
}

void
printer_mib_free_prtStorageRefEntry(printer_mib_prtStorageRefEntry_t *prtStorageRefEntry)
{
    GSList *vbl;
    char *p;

    if (prtStorageRefEntry) {
        p = (char *) prtStorageRefEntry + sizeof(printer_mib_prtStorageRefEntry_t);
        vbl = * (GSList **) p;
        g_snmp_vbl_free(vbl);
        g_free(prtStorageRefEntry);
    }
}

void
printer_mib_free_prtStorageRefTable(printer_mib_prtStorageRefEntry_t **prtStorageRefEntry)
{
    int i;

    if (prtStorageRefEntry) {
        for (i = 0; prtStorageRefEntry[i]; i++) {
            printer_mib_free_prtStorageRefEntry(prtStorageRefEntry[i]);
        }
        g_free(prtStorageRefEntry);
    }
}

printer_mib_prtDeviceRefEntry_t *
printer_mib_new_prtDeviceRefEntry()
{
    printer_mib_prtDeviceRefEntry_t *prtDeviceRefEntry;

    prtDeviceRefEntry = (printer_mib_prtDeviceRefEntry_t *) g_malloc0(sizeof(printer_mib_prtDeviceRefEntry_t) + sizeof(gpointer));
    return prtDeviceRefEntry;
}

static int
unpack_prtDeviceRefEntry(GSnmpVarBind *vb, printer_mib_prtDeviceRefEntry_t *prtDeviceRefEntry)
{
    guint8 idx = 11;

    if (vb->id_len < idx) return -1;
    prtDeviceRefEntry->hrDeviceIndex = vb->id[idx++];
    if (vb->id_len < idx) return -1;
    prtDeviceRefEntry->prtDeviceRefSeqNumber = vb->id[idx++];
    if (vb->id_len > idx) return -1;
    return 0;
}

static int
pack_prtDeviceRefEntry(guint32 *base, gint32 hrDeviceIndex, gint32 prtDeviceRefSeqNumber)
{
    guint8 idx = 11;

    base[idx++] = hrDeviceIndex;
    base[idx++] = prtDeviceRefSeqNumber;
    return idx;
}

static printer_mib_prtDeviceRefEntry_t *
assign_prtDeviceRefEntry(GSList *vbl)
{
    printer_mib_prtDeviceRefEntry_t *prtDeviceRefEntry;
    char *p;

    prtDeviceRefEntry = printer_mib_new_prtDeviceRefEntry();
    if (! prtDeviceRefEntry) {
        return NULL;
    }

    p = (char *) prtDeviceRefEntry + sizeof(printer_mib_prtDeviceRefEntry_t);
    * (GSList **) p = vbl;

    if (unpack_prtDeviceRefEntry((GSnmpVarBind *) vbl->data, prtDeviceRefEntry) < 0) {
        g_warning("%s: invalid instance identifier", "prtDeviceRefEntry");
        g_free(prtDeviceRefEntry);
        return NULL;
    }

    gsnmp_attr_assign(vbl, prtDeviceRefEntry_oid, sizeof(prtDeviceRefEntry_oid)/sizeof(guint32),
                      prtDeviceRefEntry_attr, prtDeviceRefEntry);

    return prtDeviceRefEntry;
}

void
printer_mib_get_prtDeviceRefTable(GSnmpSession *s, printer_mib_prtDeviceRefEntry_t ***prtDeviceRefEntry, gint mask)
{
    GSList *in = NULL, *out = NULL;
    GSList *row;
    int i;
    static guint32 base[] = {1, 3, 6, 1, 2, 1, 43, 5, 3, 1, 0};

    *prtDeviceRefEntry = NULL;

    gsnmp_attr_get(s, &in, base, 11, 10, prtDeviceRefEntry_attr, mask);

    out = gsnmp_gettable(s, in);
    /* g_snmp_vbl_free(in); */

    if (out) {
        *prtDeviceRefEntry = (printer_mib_prtDeviceRefEntry_t **) g_malloc0((g_slist_length(out) + 1) * sizeof(printer_mib_prtDeviceRefEntry_t *));
        if (! *prtDeviceRefEntry) {
            s->error_status = G_SNMP_ERR_INTERNAL;
            g_snmp_vbl_free(out);
            return;
        }
        for (row = out, i = 0; row; row = g_slist_next(row), i++) {
            (*prtDeviceRefEntry)[i] = assign_prtDeviceRefEntry(row->data);
        }
    }
}

void
printer_mib_get_prtDeviceRefEntry(GSnmpSession *s, printer_mib_prtDeviceRefEntry_t **prtDeviceRefEntry, gint32 hrDeviceIndex, gint32 prtDeviceRefSeqNumber, gint mask)
{
    GSList *in = NULL, *out = NULL;
    guint32 base[128];
    gint8 len;

    memset(base, 0, sizeof(base));
    memcpy(base, prtDeviceRefEntry_oid, sizeof(prtDeviceRefEntry_oid));
    len = pack_prtDeviceRefEntry(base, hrDeviceIndex, prtDeviceRefSeqNumber);
    if (len < 0) {
        g_warning("%s: invalid index values", "prtDeviceRefEntry");
        s->error_status = G_SNMP_ERR_INTERNAL;
        return;
    }

    *prtDeviceRefEntry = NULL;

    gsnmp_attr_get(s, &in, base, len, 10, prtDeviceRefEntry_attr, mask);

    out = g_snmp_session_sync_get(s, in);
    g_snmp_vbl_free(in);
    if (out) {
        if (s->error_status != G_SNMP_ERR_NOERROR) {
            g_snmp_vbl_free(out);
            return;
        }
        *prtDeviceRefEntry = assign_prtDeviceRefEntry(out);
    }
}

void
printer_mib_free_prtDeviceRefEntry(printer_mib_prtDeviceRefEntry_t *prtDeviceRefEntry)
{
    GSList *vbl;
    char *p;

    if (prtDeviceRefEntry) {
        p = (char *) prtDeviceRefEntry + sizeof(printer_mib_prtDeviceRefEntry_t);
        vbl = * (GSList **) p;
        g_snmp_vbl_free(vbl);
        g_free(prtDeviceRefEntry);
    }
}

void
printer_mib_free_prtDeviceRefTable(printer_mib_prtDeviceRefEntry_t **prtDeviceRefEntry)
{
    int i;

    if (prtDeviceRefEntry) {
        for (i = 0; prtDeviceRefEntry[i]; i++) {
            printer_mib_free_prtDeviceRefEntry(prtDeviceRefEntry[i]);
        }
        g_free(prtDeviceRefEntry);
    }
}

printer_mib_prtCoverEntry_t *
printer_mib_new_prtCoverEntry()
{
    printer_mib_prtCoverEntry_t *prtCoverEntry;

    prtCoverEntry = (printer_mib_prtCoverEntry_t *) g_malloc0(sizeof(printer_mib_prtCoverEntry_t) + sizeof(gpointer));
    return prtCoverEntry;
}

static int
unpack_prtCoverEntry(GSnmpVarBind *vb, printer_mib_prtCoverEntry_t *prtCoverEntry)
{
    guint8 idx = 11;

    if (vb->id_len < idx) return -1;
    prtCoverEntry->hrDeviceIndex = vb->id[idx++];
    if (vb->id_len < idx) return -1;
    prtCoverEntry->prtCoverIndex = vb->id[idx++];
    if (vb->id_len > idx) return -1;
    return 0;
}

static int
pack_prtCoverEntry(guint32 *base, gint32 hrDeviceIndex, gint32 prtCoverIndex)
{
    guint8 idx = 11;

    base[idx++] = hrDeviceIndex;
    base[idx++] = prtCoverIndex;
    return idx;
}

static printer_mib_prtCoverEntry_t *
assign_prtCoverEntry(GSList *vbl)
{
    printer_mib_prtCoverEntry_t *prtCoverEntry;
    char *p;

    prtCoverEntry = printer_mib_new_prtCoverEntry();
    if (! prtCoverEntry) {
        return NULL;
    }

    p = (char *) prtCoverEntry + sizeof(printer_mib_prtCoverEntry_t);
    * (GSList **) p = vbl;

    if (unpack_prtCoverEntry((GSnmpVarBind *) vbl->data, prtCoverEntry) < 0) {
        g_warning("%s: invalid instance identifier", "prtCoverEntry");
        g_free(prtCoverEntry);
        return NULL;
    }

    gsnmp_attr_assign(vbl, prtCoverEntry_oid, sizeof(prtCoverEntry_oid)/sizeof(guint32),
                      prtCoverEntry_attr, prtCoverEntry);

    return prtCoverEntry;
}

void
printer_mib_get_prtCoverTable(GSnmpSession *s, printer_mib_prtCoverEntry_t ***prtCoverEntry, gint mask)
{
    GSList *in = NULL, *out = NULL;
    GSList *row;
    int i;
    static guint32 base[] = {1, 3, 6, 1, 2, 1, 43, 6, 1, 1, 0};

    *prtCoverEntry = NULL;

    gsnmp_attr_get(s, &in, base, 11, 10, prtCoverEntry_attr, mask);

    out = gsnmp_gettable(s, in);
    /* g_snmp_vbl_free(in); */

    if (out) {
        *prtCoverEntry = (printer_mib_prtCoverEntry_t **) g_malloc0((g_slist_length(out) + 1) * sizeof(printer_mib_prtCoverEntry_t *));
        if (! *prtCoverEntry) {
            s->error_status = G_SNMP_ERR_INTERNAL;
            g_snmp_vbl_free(out);
            return;
        }
        for (row = out, i = 0; row; row = g_slist_next(row), i++) {
            (*prtCoverEntry)[i] = assign_prtCoverEntry(row->data);
        }
    }
}

void
printer_mib_get_prtCoverEntry(GSnmpSession *s, printer_mib_prtCoverEntry_t **prtCoverEntry, gint32 hrDeviceIndex, gint32 prtCoverIndex, gint mask)
{
    GSList *in = NULL, *out = NULL;
    guint32 base[128];
    gint8 len;

    memset(base, 0, sizeof(base));
    memcpy(base, prtCoverEntry_oid, sizeof(prtCoverEntry_oid));
    len = pack_prtCoverEntry(base, hrDeviceIndex, prtCoverIndex);
    if (len < 0) {
        g_warning("%s: invalid index values", "prtCoverEntry");
        s->error_status = G_SNMP_ERR_INTERNAL;
        return;
    }

    *prtCoverEntry = NULL;

    gsnmp_attr_get(s, &in, base, len, 10, prtCoverEntry_attr, mask);

    out = g_snmp_session_sync_get(s, in);
    g_snmp_vbl_free(in);
    if (out) {
        if (s->error_status != G_SNMP_ERR_NOERROR) {
            g_snmp_vbl_free(out);
            return;
        }
        *prtCoverEntry = assign_prtCoverEntry(out);
    }
}

void
printer_mib_free_prtCoverEntry(printer_mib_prtCoverEntry_t *prtCoverEntry)
{
    GSList *vbl;
    char *p;

    if (prtCoverEntry) {
        p = (char *) prtCoverEntry + sizeof(printer_mib_prtCoverEntry_t);
        vbl = * (GSList **) p;
        g_snmp_vbl_free(vbl);
        g_free(prtCoverEntry);
    }
}

void
printer_mib_free_prtCoverTable(printer_mib_prtCoverEntry_t **prtCoverEntry)
{
    int i;

    if (prtCoverEntry) {
        for (i = 0; prtCoverEntry[i]; i++) {
            printer_mib_free_prtCoverEntry(prtCoverEntry[i]);
        }
        g_free(prtCoverEntry);
    }
}

printer_mib_prtLocalizationEntry_t *
printer_mib_new_prtLocalizationEntry()
{
    printer_mib_prtLocalizationEntry_t *prtLocalizationEntry;

    prtLocalizationEntry = (printer_mib_prtLocalizationEntry_t *) g_malloc0(sizeof(printer_mib_prtLocalizationEntry_t) + sizeof(gpointer));
    return prtLocalizationEntry;
}

static int
unpack_prtLocalizationEntry(GSnmpVarBind *vb, printer_mib_prtLocalizationEntry_t *prtLocalizationEntry)
{
    guint8 idx = 11;

    if (vb->id_len < idx) return -1;
    prtLocalizationEntry->hrDeviceIndex = vb->id[idx++];
    if (vb->id_len < idx) return -1;
    prtLocalizationEntry->prtLocalizationIndex = vb->id[idx++];
    if (vb->id_len > idx) return -1;
    return 0;
}

static int
pack_prtLocalizationEntry(guint32 *base, gint32 hrDeviceIndex, gint32 prtLocalizationIndex)
{
    guint8 idx = 11;

    base[idx++] = hrDeviceIndex;
    base[idx++] = prtLocalizationIndex;
    return idx;
}

static printer_mib_prtLocalizationEntry_t *
assign_prtLocalizationEntry(GSList *vbl)
{
    printer_mib_prtLocalizationEntry_t *prtLocalizationEntry;
    char *p;

    prtLocalizationEntry = printer_mib_new_prtLocalizationEntry();
    if (! prtLocalizationEntry) {
        return NULL;
    }

    p = (char *) prtLocalizationEntry + sizeof(printer_mib_prtLocalizationEntry_t);
    * (GSList **) p = vbl;

    if (unpack_prtLocalizationEntry((GSnmpVarBind *) vbl->data, prtLocalizationEntry) < 0) {
        g_warning("%s: invalid instance identifier", "prtLocalizationEntry");
        g_free(prtLocalizationEntry);
        return NULL;
    }

    gsnmp_attr_assign(vbl, prtLocalizationEntry_oid, sizeof(prtLocalizationEntry_oid)/sizeof(guint32),
                      prtLocalizationEntry_attr, prtLocalizationEntry);

    return prtLocalizationEntry;
}

void
printer_mib_get_prtLocalizationTable(GSnmpSession *s, printer_mib_prtLocalizationEntry_t ***prtLocalizationEntry, gint mask)
{
    GSList *in = NULL, *out = NULL;
    GSList *row;
    int i;
    static guint32 base[] = {1, 3, 6, 1, 2, 1, 43, 7, 1, 1, 0};

    *prtLocalizationEntry = NULL;

    gsnmp_attr_get(s, &in, base, 11, 10, prtLocalizationEntry_attr, mask);

    out = gsnmp_gettable(s, in);
    /* g_snmp_vbl_free(in); */

    if (out) {
        *prtLocalizationEntry = (printer_mib_prtLocalizationEntry_t **) g_malloc0((g_slist_length(out) + 1) * sizeof(printer_mib_prtLocalizationEntry_t *));
        if (! *prtLocalizationEntry) {
            s->error_status = G_SNMP_ERR_INTERNAL;
            g_snmp_vbl_free(out);
            return;
        }
        for (row = out, i = 0; row; row = g_slist_next(row), i++) {
            (*prtLocalizationEntry)[i] = assign_prtLocalizationEntry(row->data);
        }
    }
}

void
printer_mib_get_prtLocalizationEntry(GSnmpSession *s, printer_mib_prtLocalizationEntry_t **prtLocalizationEntry, gint32 hrDeviceIndex, gint32 prtLocalizationIndex, gint mask)
{
    GSList *in = NULL, *out = NULL;
    guint32 base[128];
    gint8 len;

    memset(base, 0, sizeof(base));
    memcpy(base, prtLocalizationEntry_oid, sizeof(prtLocalizationEntry_oid));
    len = pack_prtLocalizationEntry(base, hrDeviceIndex, prtLocalizationIndex);
    if (len < 0) {
        g_warning("%s: invalid index values", "prtLocalizationEntry");
        s->error_status = G_SNMP_ERR_INTERNAL;
        return;
    }

    *prtLocalizationEntry = NULL;

    gsnmp_attr_get(s, &in, base, len, 10, prtLocalizationEntry_attr, mask);

    out = g_snmp_session_sync_get(s, in);
    g_snmp_vbl_free(in);
    if (out) {
        if (s->error_status != G_SNMP_ERR_NOERROR) {
            g_snmp_vbl_free(out);
            return;
        }
        *prtLocalizationEntry = assign_prtLocalizationEntry(out);
    }
}

void
printer_mib_free_prtLocalizationEntry(printer_mib_prtLocalizationEntry_t *prtLocalizationEntry)
{
    GSList *vbl;
    char *p;

    if (prtLocalizationEntry) {
        p = (char *) prtLocalizationEntry + sizeof(printer_mib_prtLocalizationEntry_t);
        vbl = * (GSList **) p;
        g_snmp_vbl_free(vbl);
        g_free(prtLocalizationEntry);
    }
}

void
printer_mib_free_prtLocalizationTable(printer_mib_prtLocalizationEntry_t **prtLocalizationEntry)
{
    int i;

    if (prtLocalizationEntry) {
        for (i = 0; prtLocalizationEntry[i]; i++) {
            printer_mib_free_prtLocalizationEntry(prtLocalizationEntry[i]);
        }
        g_free(prtLocalizationEntry);
    }
}

printer_mib_prtInputEntry_t *
printer_mib_new_prtInputEntry()
{
    printer_mib_prtInputEntry_t *prtInputEntry;

    prtInputEntry = (printer_mib_prtInputEntry_t *) g_malloc0(sizeof(printer_mib_prtInputEntry_t) + sizeof(gpointer));
    return prtInputEntry;
}

static int
unpack_prtInputEntry(GSnmpVarBind *vb, printer_mib_prtInputEntry_t *prtInputEntry)
{
    guint8 idx = 11;

    if (vb->id_len < idx) return -1;
    prtInputEntry->hrDeviceIndex = vb->id[idx++];
    if (vb->id_len < idx) return -1;
    prtInputEntry->prtInputIndex = vb->id[idx++];
    if (vb->id_len > idx) return -1;
    return 0;
}

static int
pack_prtInputEntry(guint32 *base, gint32 hrDeviceIndex, gint32 prtInputIndex)
{
    guint8 idx = 11;

    base[idx++] = hrDeviceIndex;
    base[idx++] = prtInputIndex;
    return idx;
}

static printer_mib_prtInputEntry_t *
assign_prtInputEntry(GSList *vbl)
{
    printer_mib_prtInputEntry_t *prtInputEntry;
    char *p;

    prtInputEntry = printer_mib_new_prtInputEntry();
    if (! prtInputEntry) {
        return NULL;
    }

    p = (char *) prtInputEntry + sizeof(printer_mib_prtInputEntry_t);
    * (GSList **) p = vbl;

    if (unpack_prtInputEntry((GSnmpVarBind *) vbl->data, prtInputEntry) < 0) {
        g_warning("%s: invalid instance identifier", "prtInputEntry");
        g_free(prtInputEntry);
        return NULL;
    }

    gsnmp_attr_assign(vbl, prtInputEntry_oid, sizeof(prtInputEntry_oid)/sizeof(guint32),
                      prtInputEntry_attr, prtInputEntry);

    return prtInputEntry;
}

void
printer_mib_get_prtInputTable(GSnmpSession *s, printer_mib_prtInputEntry_t ***prtInputEntry, gint mask)
{
    GSList *in = NULL, *out = NULL;
    GSList *row;
    int i;
    static guint32 base[] = {1, 3, 6, 1, 2, 1, 43, 8, 2, 1, 0};

    *prtInputEntry = NULL;

    gsnmp_attr_get(s, &in, base, 11, 10, prtInputEntry_attr, mask);

    out = gsnmp_gettable(s, in);
    /* g_snmp_vbl_free(in); */

    if (out) {
        *prtInputEntry = (printer_mib_prtInputEntry_t **) g_malloc0((g_slist_length(out) + 1) * sizeof(printer_mib_prtInputEntry_t *));
        if (! *prtInputEntry) {
            s->error_status = G_SNMP_ERR_INTERNAL;
            g_snmp_vbl_free(out);
            return;
        }
        for (row = out, i = 0; row; row = g_slist_next(row), i++) {
            (*prtInputEntry)[i] = assign_prtInputEntry(row->data);
        }
    }
}

void
printer_mib_get_prtInputEntry(GSnmpSession *s, printer_mib_prtInputEntry_t **prtInputEntry, gint32 hrDeviceIndex, gint32 prtInputIndex, gint mask)
{
    GSList *in = NULL, *out = NULL;
    guint32 base[128];
    gint8 len;

    memset(base, 0, sizeof(base));
    memcpy(base, prtInputEntry_oid, sizeof(prtInputEntry_oid));
    len = pack_prtInputEntry(base, hrDeviceIndex, prtInputIndex);
    if (len < 0) {
        g_warning("%s: invalid index values", "prtInputEntry");
        s->error_status = G_SNMP_ERR_INTERNAL;
        return;
    }

    *prtInputEntry = NULL;

    gsnmp_attr_get(s, &in, base, len, 10, prtInputEntry_attr, mask);

    out = g_snmp_session_sync_get(s, in);
    g_snmp_vbl_free(in);
    if (out) {
        if (s->error_status != G_SNMP_ERR_NOERROR) {
            g_snmp_vbl_free(out);
            return;
        }
        *prtInputEntry = assign_prtInputEntry(out);
    }
}

void
printer_mib_set_prtInputEntry(GSnmpSession *s, printer_mib_prtInputEntry_t *prtInputEntry, gint mask)
{
    GSList *in = NULL, *out = NULL;
    guint32 base[128];
    gint8 len;

    memset(base, 0, sizeof(base));
    memcpy(base, prtInputEntry_oid, sizeof(prtInputEntry_oid));
    len = pack_prtInputEntry(base, prtInputEntry->hrDeviceIndex, prtInputEntry->prtInputIndex);
    if (len < 0) {
        g_warning("%s: invalid index values", "prtInputEntry");
        s->error_status = G_SNMP_ERR_INTERNAL;
        return;
    }

    gsnmp_attr_set(s, &in, base, len, 10, prtInputEntry_attr, mask, prtInputEntry);

    out = g_snmp_session_sync_set(s, in);
    g_snmp_vbl_free(in);
    if (out) {
        g_snmp_vbl_free(out);
    }
}

void
printer_mib_free_prtInputEntry(printer_mib_prtInputEntry_t *prtInputEntry)
{
    GSList *vbl;
    char *p;

    if (prtInputEntry) {
        p = (char *) prtInputEntry + sizeof(printer_mib_prtInputEntry_t);
        vbl = * (GSList **) p;
        g_snmp_vbl_free(vbl);
        g_free(prtInputEntry);
    }
}

void
printer_mib_free_prtInputTable(printer_mib_prtInputEntry_t **prtInputEntry)
{
    int i;

    if (prtInputEntry) {
        for (i = 0; prtInputEntry[i]; i++) {
            printer_mib_free_prtInputEntry(prtInputEntry[i]);
        }
        g_free(prtInputEntry);
    }
}

printer_mib_prtOutputEntry_t *
printer_mib_new_prtOutputEntry()
{
    printer_mib_prtOutputEntry_t *prtOutputEntry;

    prtOutputEntry = (printer_mib_prtOutputEntry_t *) g_malloc0(sizeof(printer_mib_prtOutputEntry_t) + sizeof(gpointer));
    return prtOutputEntry;
}

static int
unpack_prtOutputEntry(GSnmpVarBind *vb, printer_mib_prtOutputEntry_t *prtOutputEntry)
{
    guint8 idx = 11;

    if (vb->id_len < idx) return -1;
    prtOutputEntry->hrDeviceIndex = vb->id[idx++];
    if (vb->id_len < idx) return -1;
    prtOutputEntry->prtOutputIndex = vb->id[idx++];
    if (vb->id_len > idx) return -1;
    return 0;
}

static int
pack_prtOutputEntry(guint32 *base, gint32 hrDeviceIndex, gint32 prtOutputIndex)
{
    guint8 idx = 11;

    base[idx++] = hrDeviceIndex;
    base[idx++] = prtOutputIndex;
    return idx;
}

static printer_mib_prtOutputEntry_t *
assign_prtOutputEntry(GSList *vbl)
{
    printer_mib_prtOutputEntry_t *prtOutputEntry;
    char *p;

    prtOutputEntry = printer_mib_new_prtOutputEntry();
    if (! prtOutputEntry) {
        return NULL;
    }

    p = (char *) prtOutputEntry + sizeof(printer_mib_prtOutputEntry_t);
    * (GSList **) p = vbl;

    if (unpack_prtOutputEntry((GSnmpVarBind *) vbl->data, prtOutputEntry) < 0) {
        g_warning("%s: invalid instance identifier", "prtOutputEntry");
        g_free(prtOutputEntry);
        return NULL;
    }

    gsnmp_attr_assign(vbl, prtOutputEntry_oid, sizeof(prtOutputEntry_oid)/sizeof(guint32),
                      prtOutputEntry_attr, prtOutputEntry);

    return prtOutputEntry;
}

void
printer_mib_get_prtOutputTable(GSnmpSession *s, printer_mib_prtOutputEntry_t ***prtOutputEntry, gint mask)
{
    GSList *in = NULL, *out = NULL;
    GSList *row;
    int i;
    static guint32 base[] = {1, 3, 6, 1, 2, 1, 43, 9, 2, 1, 0};

    *prtOutputEntry = NULL;

    gsnmp_attr_get(s, &in, base, 11, 10, prtOutputEntry_attr, mask);

    out = gsnmp_gettable(s, in);
    /* g_snmp_vbl_free(in); */

    if (out) {
        *prtOutputEntry = (printer_mib_prtOutputEntry_t **) g_malloc0((g_slist_length(out) + 1) * sizeof(printer_mib_prtOutputEntry_t *));
        if (! *prtOutputEntry) {
            s->error_status = G_SNMP_ERR_INTERNAL;
            g_snmp_vbl_free(out);
            return;
        }
        for (row = out, i = 0; row; row = g_slist_next(row), i++) {
            (*prtOutputEntry)[i] = assign_prtOutputEntry(row->data);
        }
    }
}

void
printer_mib_get_prtOutputEntry(GSnmpSession *s, printer_mib_prtOutputEntry_t **prtOutputEntry, gint32 hrDeviceIndex, gint32 prtOutputIndex, gint mask)
{
    GSList *in = NULL, *out = NULL;
    guint32 base[128];
    gint8 len;

    memset(base, 0, sizeof(base));
    memcpy(base, prtOutputEntry_oid, sizeof(prtOutputEntry_oid));
    len = pack_prtOutputEntry(base, hrDeviceIndex, prtOutputIndex);
    if (len < 0) {
        g_warning("%s: invalid index values", "prtOutputEntry");
        s->error_status = G_SNMP_ERR_INTERNAL;
        return;
    }

    *prtOutputEntry = NULL;

    gsnmp_attr_get(s, &in, base, len, 10, prtOutputEntry_attr, mask);

    out = g_snmp_session_sync_get(s, in);
    g_snmp_vbl_free(in);
    if (out) {
        if (s->error_status != G_SNMP_ERR_NOERROR) {
            g_snmp_vbl_free(out);
            return;
        }
        *prtOutputEntry = assign_prtOutputEntry(out);
    }
}

void
printer_mib_set_prtOutputEntry(GSnmpSession *s, printer_mib_prtOutputEntry_t *prtOutputEntry, gint mask)
{
    GSList *in = NULL, *out = NULL;
    guint32 base[128];
    gint8 len;

    memset(base, 0, sizeof(base));
    memcpy(base, prtOutputEntry_oid, sizeof(prtOutputEntry_oid));
    len = pack_prtOutputEntry(base, prtOutputEntry->hrDeviceIndex, prtOutputEntry->prtOutputIndex);
    if (len < 0) {
        g_warning("%s: invalid index values", "prtOutputEntry");
        s->error_status = G_SNMP_ERR_INTERNAL;
        return;
    }

    gsnmp_attr_set(s, &in, base, len, 10, prtOutputEntry_attr, mask, prtOutputEntry);

    out = g_snmp_session_sync_set(s, in);
    g_snmp_vbl_free(in);
    if (out) {
        g_snmp_vbl_free(out);
    }
}

void
printer_mib_free_prtOutputEntry(printer_mib_prtOutputEntry_t *prtOutputEntry)
{
    GSList *vbl;
    char *p;

    if (prtOutputEntry) {
        p = (char *) prtOutputEntry + sizeof(printer_mib_prtOutputEntry_t);
        vbl = * (GSList **) p;
        g_snmp_vbl_free(vbl);
        g_free(prtOutputEntry);
    }
}

void
printer_mib_free_prtOutputTable(printer_mib_prtOutputEntry_t **prtOutputEntry)
{
    int i;

    if (prtOutputEntry) {
        for (i = 0; prtOutputEntry[i]; i++) {
            printer_mib_free_prtOutputEntry(prtOutputEntry[i]);
        }
        g_free(prtOutputEntry);
    }
}

printer_mib_prtMarkerEntry_t *
printer_mib_new_prtMarkerEntry()
{
    printer_mib_prtMarkerEntry_t *prtMarkerEntry;

    prtMarkerEntry = (printer_mib_prtMarkerEntry_t *) g_malloc0(sizeof(printer_mib_prtMarkerEntry_t) + sizeof(gpointer));
    return prtMarkerEntry;
}

static int
unpack_prtMarkerEntry(GSnmpVarBind *vb, printer_mib_prtMarkerEntry_t *prtMarkerEntry)
{
    guint8 idx = 11;

    if (vb->id_len < idx) return -1;
    prtMarkerEntry->hrDeviceIndex = vb->id[idx++];
    if (vb->id_len < idx) return -1;
    prtMarkerEntry->prtMarkerIndex = vb->id[idx++];
    if (vb->id_len > idx) return -1;
    return 0;
}

static int
pack_prtMarkerEntry(guint32 *base, gint32 hrDeviceIndex, gint32 prtMarkerIndex)
{
    guint8 idx = 11;

    base[idx++] = hrDeviceIndex;
    base[idx++] = prtMarkerIndex;
    return idx;
}

static printer_mib_prtMarkerEntry_t *
assign_prtMarkerEntry(GSList *vbl)
{
    printer_mib_prtMarkerEntry_t *prtMarkerEntry;
    char *p;

    prtMarkerEntry = printer_mib_new_prtMarkerEntry();
    if (! prtMarkerEntry) {
        return NULL;
    }

    p = (char *) prtMarkerEntry + sizeof(printer_mib_prtMarkerEntry_t);
    * (GSList **) p = vbl;

    if (unpack_prtMarkerEntry((GSnmpVarBind *) vbl->data, prtMarkerEntry) < 0) {
        g_warning("%s: invalid instance identifier", "prtMarkerEntry");
        g_free(prtMarkerEntry);
        return NULL;
    }

    gsnmp_attr_assign(vbl, prtMarkerEntry_oid, sizeof(prtMarkerEntry_oid)/sizeof(guint32),
                      prtMarkerEntry_attr, prtMarkerEntry);

    return prtMarkerEntry;
}

void
printer_mib_get_prtMarkerTable(GSnmpSession *s, printer_mib_prtMarkerEntry_t ***prtMarkerEntry, gint mask)
{
    GSList *in = NULL, *out = NULL;
    GSList *row;
    int i;
    static guint32 base[] = {1, 3, 6, 1, 2, 1, 43, 10, 2, 1, 0};

    *prtMarkerEntry = NULL;

    gsnmp_attr_get(s, &in, base, 11, 10, prtMarkerEntry_attr, mask);

    out = gsnmp_gettable(s, in);
    /* g_snmp_vbl_free(in); */

    if (out) {
        *prtMarkerEntry = (printer_mib_prtMarkerEntry_t **) g_malloc0((g_slist_length(out) + 1) * sizeof(printer_mib_prtMarkerEntry_t *));
        if (! *prtMarkerEntry) {
            s->error_status = G_SNMP_ERR_INTERNAL;
            g_snmp_vbl_free(out);
            return;
        }
        for (row = out, i = 0; row; row = g_slist_next(row), i++) {
            (*prtMarkerEntry)[i] = assign_prtMarkerEntry(row->data);
        }
    }
}

void
printer_mib_get_prtMarkerEntry(GSnmpSession *s, printer_mib_prtMarkerEntry_t **prtMarkerEntry, gint32 hrDeviceIndex, gint32 prtMarkerIndex, gint mask)
{
    GSList *in = NULL, *out = NULL;
    guint32 base[128];
    gint8 len;

    memset(base, 0, sizeof(base));
    memcpy(base, prtMarkerEntry_oid, sizeof(prtMarkerEntry_oid));
    len = pack_prtMarkerEntry(base, hrDeviceIndex, prtMarkerIndex);
    if (len < 0) {
        g_warning("%s: invalid index values", "prtMarkerEntry");
        s->error_status = G_SNMP_ERR_INTERNAL;
        return;
    }

    *prtMarkerEntry = NULL;

    gsnmp_attr_get(s, &in, base, len, 10, prtMarkerEntry_attr, mask);

    out = g_snmp_session_sync_get(s, in);
    g_snmp_vbl_free(in);
    if (out) {
        if (s->error_status != G_SNMP_ERR_NOERROR) {
            g_snmp_vbl_free(out);
            return;
        }
        *prtMarkerEntry = assign_prtMarkerEntry(out);
    }
}

void
printer_mib_free_prtMarkerEntry(printer_mib_prtMarkerEntry_t *prtMarkerEntry)
{
    GSList *vbl;
    char *p;

    if (prtMarkerEntry) {
        p = (char *) prtMarkerEntry + sizeof(printer_mib_prtMarkerEntry_t);
        vbl = * (GSList **) p;
        g_snmp_vbl_free(vbl);
        g_free(prtMarkerEntry);
    }
}

void
printer_mib_free_prtMarkerTable(printer_mib_prtMarkerEntry_t **prtMarkerEntry)
{
    int i;

    if (prtMarkerEntry) {
        for (i = 0; prtMarkerEntry[i]; i++) {
            printer_mib_free_prtMarkerEntry(prtMarkerEntry[i]);
        }
        g_free(prtMarkerEntry);
    }
}

printer_mib_prtMarkerSuppliesEntry_t *
printer_mib_new_prtMarkerSuppliesEntry()
{
    printer_mib_prtMarkerSuppliesEntry_t *prtMarkerSuppliesEntry;

    prtMarkerSuppliesEntry = (printer_mib_prtMarkerSuppliesEntry_t *) g_malloc0(sizeof(printer_mib_prtMarkerSuppliesEntry_t) + sizeof(gpointer));
    return prtMarkerSuppliesEntry;
}

static int
unpack_prtMarkerSuppliesEntry(GSnmpVarBind *vb, printer_mib_prtMarkerSuppliesEntry_t *prtMarkerSuppliesEntry)
{
    guint8 idx = 11;

    if (vb->id_len < idx) return -1;
    prtMarkerSuppliesEntry->hrDeviceIndex = vb->id[idx++];
    if (vb->id_len < idx) return -1;
    prtMarkerSuppliesEntry->prtMarkerSuppliesIndex = vb->id[idx++];
    if (vb->id_len > idx) return -1;
    return 0;
}

static int
pack_prtMarkerSuppliesEntry(guint32 *base, gint32 hrDeviceIndex, gint32 prtMarkerSuppliesIndex)
{
    guint8 idx = 11;

    base[idx++] = hrDeviceIndex;
    base[idx++] = prtMarkerSuppliesIndex;
    return idx;
}

static printer_mib_prtMarkerSuppliesEntry_t *
assign_prtMarkerSuppliesEntry(GSList *vbl)
{
    printer_mib_prtMarkerSuppliesEntry_t *prtMarkerSuppliesEntry;
    char *p;

    prtMarkerSuppliesEntry = printer_mib_new_prtMarkerSuppliesEntry();
    if (! prtMarkerSuppliesEntry) {
        return NULL;
    }

    p = (char *) prtMarkerSuppliesEntry + sizeof(printer_mib_prtMarkerSuppliesEntry_t);
    * (GSList **) p = vbl;

    if (unpack_prtMarkerSuppliesEntry((GSnmpVarBind *) vbl->data, prtMarkerSuppliesEntry) < 0) {
        g_warning("%s: invalid instance identifier", "prtMarkerSuppliesEntry");
        g_free(prtMarkerSuppliesEntry);
        return NULL;
    }

    gsnmp_attr_assign(vbl, prtMarkerSuppliesEntry_oid, sizeof(prtMarkerSuppliesEntry_oid)/sizeof(guint32),
                      prtMarkerSuppliesEntry_attr, prtMarkerSuppliesEntry);

    return prtMarkerSuppliesEntry;
}

void
printer_mib_get_prtMarkerSuppliesTable(GSnmpSession *s, printer_mib_prtMarkerSuppliesEntry_t ***prtMarkerSuppliesEntry, gint mask)
{
    GSList *in = NULL, *out = NULL;
    GSList *row;
    int i;
    static guint32 base[] = {1, 3, 6, 1, 2, 1, 43, 11, 1, 1, 0};

    *prtMarkerSuppliesEntry = NULL;

    gsnmp_attr_get(s, &in, base, 11, 10, prtMarkerSuppliesEntry_attr, mask);

    out = gsnmp_gettable(s, in);
    /* g_snmp_vbl_free(in); */

    if (out) {
        *prtMarkerSuppliesEntry = (printer_mib_prtMarkerSuppliesEntry_t **) g_malloc0((g_slist_length(out) + 1) * sizeof(printer_mib_prtMarkerSuppliesEntry_t *));
        if (! *prtMarkerSuppliesEntry) {
            s->error_status = G_SNMP_ERR_INTERNAL;
            g_snmp_vbl_free(out);
            return;
        }
        for (row = out, i = 0; row; row = g_slist_next(row), i++) {
            (*prtMarkerSuppliesEntry)[i] = assign_prtMarkerSuppliesEntry(row->data);
        }
    }
}

void
printer_mib_get_prtMarkerSuppliesEntry(GSnmpSession *s, printer_mib_prtMarkerSuppliesEntry_t **prtMarkerSuppliesEntry, gint32 hrDeviceIndex, gint32 prtMarkerSuppliesIndex, gint mask)
{
    GSList *in = NULL, *out = NULL;
    guint32 base[128];
    gint8 len;

    memset(base, 0, sizeof(base));
    memcpy(base, prtMarkerSuppliesEntry_oid, sizeof(prtMarkerSuppliesEntry_oid));
    len = pack_prtMarkerSuppliesEntry(base, hrDeviceIndex, prtMarkerSuppliesIndex);
    if (len < 0) {
        g_warning("%s: invalid index values", "prtMarkerSuppliesEntry");
        s->error_status = G_SNMP_ERR_INTERNAL;
        return;
    }

    *prtMarkerSuppliesEntry = NULL;

    gsnmp_attr_get(s, &in, base, len, 10, prtMarkerSuppliesEntry_attr, mask);

    out = g_snmp_session_sync_get(s, in);
    g_snmp_vbl_free(in);
    if (out) {
        if (s->error_status != G_SNMP_ERR_NOERROR) {
            g_snmp_vbl_free(out);
            return;
        }
        *prtMarkerSuppliesEntry = assign_prtMarkerSuppliesEntry(out);
    }
}

void
printer_mib_set_prtMarkerSuppliesEntry(GSnmpSession *s, printer_mib_prtMarkerSuppliesEntry_t *prtMarkerSuppliesEntry, gint mask)
{
    GSList *in = NULL, *out = NULL;
    guint32 base[128];
    gint8 len;

    memset(base, 0, sizeof(base));
    memcpy(base, prtMarkerSuppliesEntry_oid, sizeof(prtMarkerSuppliesEntry_oid));
    len = pack_prtMarkerSuppliesEntry(base, prtMarkerSuppliesEntry->hrDeviceIndex, prtMarkerSuppliesEntry->prtMarkerSuppliesIndex);
    if (len < 0) {
        g_warning("%s: invalid index values", "prtMarkerSuppliesEntry");
        s->error_status = G_SNMP_ERR_INTERNAL;
        return;
    }

    gsnmp_attr_set(s, &in, base, len, 10, prtMarkerSuppliesEntry_attr, mask, prtMarkerSuppliesEntry);

    out = g_snmp_session_sync_set(s, in);
    g_snmp_vbl_free(in);
    if (out) {
        g_snmp_vbl_free(out);
    }
}

void
printer_mib_free_prtMarkerSuppliesEntry(printer_mib_prtMarkerSuppliesEntry_t *prtMarkerSuppliesEntry)
{
    GSList *vbl;
    char *p;

    if (prtMarkerSuppliesEntry) {
        p = (char *) prtMarkerSuppliesEntry + sizeof(printer_mib_prtMarkerSuppliesEntry_t);
        vbl = * (GSList **) p;
        g_snmp_vbl_free(vbl);
        g_free(prtMarkerSuppliesEntry);
    }
}

void
printer_mib_free_prtMarkerSuppliesTable(printer_mib_prtMarkerSuppliesEntry_t **prtMarkerSuppliesEntry)
{
    int i;

    if (prtMarkerSuppliesEntry) {
        for (i = 0; prtMarkerSuppliesEntry[i]; i++) {
            printer_mib_free_prtMarkerSuppliesEntry(prtMarkerSuppliesEntry[i]);
        }
        g_free(prtMarkerSuppliesEntry);
    }
}

printer_mib_prtMarkerColorantEntry_t *
printer_mib_new_prtMarkerColorantEntry()
{
    printer_mib_prtMarkerColorantEntry_t *prtMarkerColorantEntry;

    prtMarkerColorantEntry = (printer_mib_prtMarkerColorantEntry_t *) g_malloc0(sizeof(printer_mib_prtMarkerColorantEntry_t) + sizeof(gpointer));
    return prtMarkerColorantEntry;
}

static int
unpack_prtMarkerColorantEntry(GSnmpVarBind *vb, printer_mib_prtMarkerColorantEntry_t *prtMarkerColorantEntry)
{
    guint8 idx = 11;

    if (vb->id_len < idx) return -1;
    prtMarkerColorantEntry->hrDeviceIndex = vb->id[idx++];
    if (vb->id_len < idx) return -1;
    prtMarkerColorantEntry->prtMarkerColorantIndex = vb->id[idx++];
    if (vb->id_len > idx) return -1;
    return 0;
}

static int
pack_prtMarkerColorantEntry(guint32 *base, gint32 hrDeviceIndex, gint32 prtMarkerColorantIndex)
{
    guint8 idx = 11;

    base[idx++] = hrDeviceIndex;
    base[idx++] = prtMarkerColorantIndex;
    return idx;
}

static printer_mib_prtMarkerColorantEntry_t *
assign_prtMarkerColorantEntry(GSList *vbl)
{
    printer_mib_prtMarkerColorantEntry_t *prtMarkerColorantEntry;
    char *p;

    prtMarkerColorantEntry = printer_mib_new_prtMarkerColorantEntry();
    if (! prtMarkerColorantEntry) {
        return NULL;
    }

    p = (char *) prtMarkerColorantEntry + sizeof(printer_mib_prtMarkerColorantEntry_t);
    * (GSList **) p = vbl;

    if (unpack_prtMarkerColorantEntry((GSnmpVarBind *) vbl->data, prtMarkerColorantEntry) < 0) {
        g_warning("%s: invalid instance identifier", "prtMarkerColorantEntry");
        g_free(prtMarkerColorantEntry);
        return NULL;
    }

    gsnmp_attr_assign(vbl, prtMarkerColorantEntry_oid, sizeof(prtMarkerColorantEntry_oid)/sizeof(guint32),
                      prtMarkerColorantEntry_attr, prtMarkerColorantEntry);

    return prtMarkerColorantEntry;
}

void
printer_mib_get_prtMarkerColorantTable(GSnmpSession *s, printer_mib_prtMarkerColorantEntry_t ***prtMarkerColorantEntry, gint mask)
{
    GSList *in = NULL, *out = NULL;
    GSList *row;
    int i;
    static guint32 base[] = {1, 3, 6, 1, 2, 1, 43, 12, 1, 1, 0};

    *prtMarkerColorantEntry = NULL;

    gsnmp_attr_get(s, &in, base, 11, 10, prtMarkerColorantEntry_attr, mask);

    out = gsnmp_gettable(s, in);
    /* g_snmp_vbl_free(in); */

    if (out) {
        *prtMarkerColorantEntry = (printer_mib_prtMarkerColorantEntry_t **) g_malloc0((g_slist_length(out) + 1) * sizeof(printer_mib_prtMarkerColorantEntry_t *));
        if (! *prtMarkerColorantEntry) {
            s->error_status = G_SNMP_ERR_INTERNAL;
            g_snmp_vbl_free(out);
            return;
        }
        for (row = out, i = 0; row; row = g_slist_next(row), i++) {
            (*prtMarkerColorantEntry)[i] = assign_prtMarkerColorantEntry(row->data);
        }
    }
}

void
printer_mib_get_prtMarkerColorantEntry(GSnmpSession *s, printer_mib_prtMarkerColorantEntry_t **prtMarkerColorantEntry, gint32 hrDeviceIndex, gint32 prtMarkerColorantIndex, gint mask)
{
    GSList *in = NULL, *out = NULL;
    guint32 base[128];
    gint8 len;

    memset(base, 0, sizeof(base));
    memcpy(base, prtMarkerColorantEntry_oid, sizeof(prtMarkerColorantEntry_oid));
    len = pack_prtMarkerColorantEntry(base, hrDeviceIndex, prtMarkerColorantIndex);
    if (len < 0) {
        g_warning("%s: invalid index values", "prtMarkerColorantEntry");
        s->error_status = G_SNMP_ERR_INTERNAL;
        return;
    }

    *prtMarkerColorantEntry = NULL;

    gsnmp_attr_get(s, &in, base, len, 10, prtMarkerColorantEntry_attr, mask);

    out = g_snmp_session_sync_get(s, in);
    g_snmp_vbl_free(in);
    if (out) {
        if (s->error_status != G_SNMP_ERR_NOERROR) {
            g_snmp_vbl_free(out);
            return;
        }
        *prtMarkerColorantEntry = assign_prtMarkerColorantEntry(out);
    }
}

void
printer_mib_free_prtMarkerColorantEntry(printer_mib_prtMarkerColorantEntry_t *prtMarkerColorantEntry)
{
    GSList *vbl;
    char *p;

    if (prtMarkerColorantEntry) {
        p = (char *) prtMarkerColorantEntry + sizeof(printer_mib_prtMarkerColorantEntry_t);
        vbl = * (GSList **) p;
        g_snmp_vbl_free(vbl);
        g_free(prtMarkerColorantEntry);
    }
}

void
printer_mib_free_prtMarkerColorantTable(printer_mib_prtMarkerColorantEntry_t **prtMarkerColorantEntry)
{
    int i;

    if (prtMarkerColorantEntry) {
        for (i = 0; prtMarkerColorantEntry[i]; i++) {
            printer_mib_free_prtMarkerColorantEntry(prtMarkerColorantEntry[i]);
        }
        g_free(prtMarkerColorantEntry);
    }
}

printer_mib_prtMediaPathEntry_t *
printer_mib_new_prtMediaPathEntry()
{
    printer_mib_prtMediaPathEntry_t *prtMediaPathEntry;

    prtMediaPathEntry = (printer_mib_prtMediaPathEntry_t *) g_malloc0(sizeof(printer_mib_prtMediaPathEntry_t) + sizeof(gpointer));
    return prtMediaPathEntry;
}

static int
unpack_prtMediaPathEntry(GSnmpVarBind *vb, printer_mib_prtMediaPathEntry_t *prtMediaPathEntry)
{
    guint8 idx = 11;

    if (vb->id_len < idx) return -1;
    prtMediaPathEntry->hrDeviceIndex = vb->id[idx++];
    if (vb->id_len < idx) return -1;
    prtMediaPathEntry->prtMediaPathIndex = vb->id[idx++];
    if (vb->id_len > idx) return -1;
    return 0;
}

static int
pack_prtMediaPathEntry(guint32 *base, gint32 hrDeviceIndex, gint32 prtMediaPathIndex)
{
    guint8 idx = 11;

    base[idx++] = hrDeviceIndex;
    base[idx++] = prtMediaPathIndex;
    return idx;
}

static printer_mib_prtMediaPathEntry_t *
assign_prtMediaPathEntry(GSList *vbl)
{
    printer_mib_prtMediaPathEntry_t *prtMediaPathEntry;
    char *p;

    prtMediaPathEntry = printer_mib_new_prtMediaPathEntry();
    if (! prtMediaPathEntry) {
        return NULL;
    }

    p = (char *) prtMediaPathEntry + sizeof(printer_mib_prtMediaPathEntry_t);
    * (GSList **) p = vbl;

    if (unpack_prtMediaPathEntry((GSnmpVarBind *) vbl->data, prtMediaPathEntry) < 0) {
        g_warning("%s: invalid instance identifier", "prtMediaPathEntry");
        g_free(prtMediaPathEntry);
        return NULL;
    }

    gsnmp_attr_assign(vbl, prtMediaPathEntry_oid, sizeof(prtMediaPathEntry_oid)/sizeof(guint32),
                      prtMediaPathEntry_attr, prtMediaPathEntry);

    return prtMediaPathEntry;
}

void
printer_mib_get_prtMediaPathTable(GSnmpSession *s, printer_mib_prtMediaPathEntry_t ***prtMediaPathEntry, gint mask)
{
    GSList *in = NULL, *out = NULL;
    GSList *row;
    int i;
    static guint32 base[] = {1, 3, 6, 1, 2, 1, 43, 13, 4, 1, 0};

    *prtMediaPathEntry = NULL;

    gsnmp_attr_get(s, &in, base, 11, 10, prtMediaPathEntry_attr, mask);

    out = gsnmp_gettable(s, in);
    /* g_snmp_vbl_free(in); */

    if (out) {
        *prtMediaPathEntry = (printer_mib_prtMediaPathEntry_t **) g_malloc0((g_slist_length(out) + 1) * sizeof(printer_mib_prtMediaPathEntry_t *));
        if (! *prtMediaPathEntry) {
            s->error_status = G_SNMP_ERR_INTERNAL;
            g_snmp_vbl_free(out);
            return;
        }
        for (row = out, i = 0; row; row = g_slist_next(row), i++) {
            (*prtMediaPathEntry)[i] = assign_prtMediaPathEntry(row->data);
        }
    }
}

void
printer_mib_get_prtMediaPathEntry(GSnmpSession *s, printer_mib_prtMediaPathEntry_t **prtMediaPathEntry, gint32 hrDeviceIndex, gint32 prtMediaPathIndex, gint mask)
{
    GSList *in = NULL, *out = NULL;
    guint32 base[128];
    gint8 len;

    memset(base, 0, sizeof(base));
    memcpy(base, prtMediaPathEntry_oid, sizeof(prtMediaPathEntry_oid));
    len = pack_prtMediaPathEntry(base, hrDeviceIndex, prtMediaPathIndex);
    if (len < 0) {
        g_warning("%s: invalid index values", "prtMediaPathEntry");
        s->error_status = G_SNMP_ERR_INTERNAL;
        return;
    }

    *prtMediaPathEntry = NULL;

    gsnmp_attr_get(s, &in, base, len, 10, prtMediaPathEntry_attr, mask);

    out = g_snmp_session_sync_get(s, in);
    g_snmp_vbl_free(in);
    if (out) {
        if (s->error_status != G_SNMP_ERR_NOERROR) {
            g_snmp_vbl_free(out);
            return;
        }
        *prtMediaPathEntry = assign_prtMediaPathEntry(out);
    }
}

void
printer_mib_free_prtMediaPathEntry(printer_mib_prtMediaPathEntry_t *prtMediaPathEntry)
{
    GSList *vbl;
    char *p;

    if (prtMediaPathEntry) {
        p = (char *) prtMediaPathEntry + sizeof(printer_mib_prtMediaPathEntry_t);
        vbl = * (GSList **) p;
        g_snmp_vbl_free(vbl);
        g_free(prtMediaPathEntry);
    }
}

void
printer_mib_free_prtMediaPathTable(printer_mib_prtMediaPathEntry_t **prtMediaPathEntry)
{
    int i;

    if (prtMediaPathEntry) {
        for (i = 0; prtMediaPathEntry[i]; i++) {
            printer_mib_free_prtMediaPathEntry(prtMediaPathEntry[i]);
        }
        g_free(prtMediaPathEntry);
    }
}

printer_mib_prtChannelEntry_t *
printer_mib_new_prtChannelEntry()
{
    printer_mib_prtChannelEntry_t *prtChannelEntry;

    prtChannelEntry = (printer_mib_prtChannelEntry_t *) g_malloc0(sizeof(printer_mib_prtChannelEntry_t) + sizeof(gpointer));
    return prtChannelEntry;
}

static int
unpack_prtChannelEntry(GSnmpVarBind *vb, printer_mib_prtChannelEntry_t *prtChannelEntry)
{
    guint8 idx = 11;

    if (vb->id_len < idx) return -1;
    prtChannelEntry->hrDeviceIndex = vb->id[idx++];
    if (vb->id_len < idx) return -1;
    prtChannelEntry->prtChannelIndex = vb->id[idx++];
    if (vb->id_len > idx) return -1;
    return 0;
}

static int
pack_prtChannelEntry(guint32 *base, gint32 hrDeviceIndex, gint32 prtChannelIndex)
{
    guint8 idx = 11;

    base[idx++] = hrDeviceIndex;
    base[idx++] = prtChannelIndex;
    return idx;
}

static printer_mib_prtChannelEntry_t *
assign_prtChannelEntry(GSList *vbl)
{
    printer_mib_prtChannelEntry_t *prtChannelEntry;
    char *p;

    prtChannelEntry = printer_mib_new_prtChannelEntry();
    if (! prtChannelEntry) {
        return NULL;
    }

    p = (char *) prtChannelEntry + sizeof(printer_mib_prtChannelEntry_t);
    * (GSList **) p = vbl;

    if (unpack_prtChannelEntry((GSnmpVarBind *) vbl->data, prtChannelEntry) < 0) {
        g_warning("%s: invalid instance identifier", "prtChannelEntry");
        g_free(prtChannelEntry);
        return NULL;
    }

    gsnmp_attr_assign(vbl, prtChannelEntry_oid, sizeof(prtChannelEntry_oid)/sizeof(guint32),
                      prtChannelEntry_attr, prtChannelEntry);

    return prtChannelEntry;
}

void
printer_mib_get_prtChannelTable(GSnmpSession *s, printer_mib_prtChannelEntry_t ***prtChannelEntry, gint mask)
{
    GSList *in = NULL, *out = NULL;
    GSList *row;
    int i;
    static guint32 base[] = {1, 3, 6, 1, 2, 1, 43, 14, 1, 1, 0};

    *prtChannelEntry = NULL;

    gsnmp_attr_get(s, &in, base, 11, 10, prtChannelEntry_attr, mask);

    out = gsnmp_gettable(s, in);
    /* g_snmp_vbl_free(in); */

    if (out) {
        *prtChannelEntry = (printer_mib_prtChannelEntry_t **) g_malloc0((g_slist_length(out) + 1) * sizeof(printer_mib_prtChannelEntry_t *));
        if (! *prtChannelEntry) {
            s->error_status = G_SNMP_ERR_INTERNAL;
            g_snmp_vbl_free(out);
            return;
        }
        for (row = out, i = 0; row; row = g_slist_next(row), i++) {
            (*prtChannelEntry)[i] = assign_prtChannelEntry(row->data);
        }
    }
}

void
printer_mib_get_prtChannelEntry(GSnmpSession *s, printer_mib_prtChannelEntry_t **prtChannelEntry, gint32 hrDeviceIndex, gint32 prtChannelIndex, gint mask)
{
    GSList *in = NULL, *out = NULL;
    guint32 base[128];
    gint8 len;

    memset(base, 0, sizeof(base));
    memcpy(base, prtChannelEntry_oid, sizeof(prtChannelEntry_oid));
    len = pack_prtChannelEntry(base, hrDeviceIndex, prtChannelIndex);
    if (len < 0) {
        g_warning("%s: invalid index values", "prtChannelEntry");
        s->error_status = G_SNMP_ERR_INTERNAL;
        return;
    }

    *prtChannelEntry = NULL;

    gsnmp_attr_get(s, &in, base, len, 10, prtChannelEntry_attr, mask);

    out = g_snmp_session_sync_get(s, in);
    g_snmp_vbl_free(in);
    if (out) {
        if (s->error_status != G_SNMP_ERR_NOERROR) {
            g_snmp_vbl_free(out);
            return;
        }
        *prtChannelEntry = assign_prtChannelEntry(out);
    }
}

void
printer_mib_set_prtChannelEntry(GSnmpSession *s, printer_mib_prtChannelEntry_t *prtChannelEntry, gint mask)
{
    GSList *in = NULL, *out = NULL;
    guint32 base[128];
    gint8 len;

    memset(base, 0, sizeof(base));
    memcpy(base, prtChannelEntry_oid, sizeof(prtChannelEntry_oid));
    len = pack_prtChannelEntry(base, prtChannelEntry->hrDeviceIndex, prtChannelEntry->prtChannelIndex);
    if (len < 0) {
        g_warning("%s: invalid index values", "prtChannelEntry");
        s->error_status = G_SNMP_ERR_INTERNAL;
        return;
    }

    gsnmp_attr_set(s, &in, base, len, 10, prtChannelEntry_attr, mask, prtChannelEntry);

    out = g_snmp_session_sync_set(s, in);
    g_snmp_vbl_free(in);
    if (out) {
        g_snmp_vbl_free(out);
    }
}

void
printer_mib_free_prtChannelEntry(printer_mib_prtChannelEntry_t *prtChannelEntry)
{
    GSList *vbl;
    char *p;

    if (prtChannelEntry) {
        p = (char *) prtChannelEntry + sizeof(printer_mib_prtChannelEntry_t);
        vbl = * (GSList **) p;
        g_snmp_vbl_free(vbl);
        g_free(prtChannelEntry);
    }
}

void
printer_mib_free_prtChannelTable(printer_mib_prtChannelEntry_t **prtChannelEntry)
{
    int i;

    if (prtChannelEntry) {
        for (i = 0; prtChannelEntry[i]; i++) {
            printer_mib_free_prtChannelEntry(prtChannelEntry[i]);
        }
        g_free(prtChannelEntry);
    }
}

printer_mib_prtInterpreterEntry_t *
printer_mib_new_prtInterpreterEntry()
{
    printer_mib_prtInterpreterEntry_t *prtInterpreterEntry;

    prtInterpreterEntry = (printer_mib_prtInterpreterEntry_t *) g_malloc0(sizeof(printer_mib_prtInterpreterEntry_t) + sizeof(gpointer));
    return prtInterpreterEntry;
}

static int
unpack_prtInterpreterEntry(GSnmpVarBind *vb, printer_mib_prtInterpreterEntry_t *prtInterpreterEntry)
{
    guint8 idx = 11;

    if (vb->id_len < idx) return -1;
    prtInterpreterEntry->hrDeviceIndex = vb->id[idx++];
    if (vb->id_len < idx) return -1;
    prtInterpreterEntry->prtInterpreterIndex = vb->id[idx++];
    if (vb->id_len > idx) return -1;
    return 0;
}

static int
pack_prtInterpreterEntry(guint32 *base, gint32 hrDeviceIndex, gint32 prtInterpreterIndex)
{
    guint8 idx = 11;

    base[idx++] = hrDeviceIndex;
    base[idx++] = prtInterpreterIndex;
    return idx;
}

static printer_mib_prtInterpreterEntry_t *
assign_prtInterpreterEntry(GSList *vbl)
{
    printer_mib_prtInterpreterEntry_t *prtInterpreterEntry;
    char *p;

    prtInterpreterEntry = printer_mib_new_prtInterpreterEntry();
    if (! prtInterpreterEntry) {
        return NULL;
    }

    p = (char *) prtInterpreterEntry + sizeof(printer_mib_prtInterpreterEntry_t);
    * (GSList **) p = vbl;

    if (unpack_prtInterpreterEntry((GSnmpVarBind *) vbl->data, prtInterpreterEntry) < 0) {
        g_warning("%s: invalid instance identifier", "prtInterpreterEntry");
        g_free(prtInterpreterEntry);
        return NULL;
    }

    gsnmp_attr_assign(vbl, prtInterpreterEntry_oid, sizeof(prtInterpreterEntry_oid)/sizeof(guint32),
                      prtInterpreterEntry_attr, prtInterpreterEntry);

    return prtInterpreterEntry;
}

void
printer_mib_get_prtInterpreterTable(GSnmpSession *s, printer_mib_prtInterpreterEntry_t ***prtInterpreterEntry, gint mask)
{
    GSList *in = NULL, *out = NULL;
    GSList *row;
    int i;
    static guint32 base[] = {1, 3, 6, 1, 2, 1, 43, 15, 1, 1, 0};

    *prtInterpreterEntry = NULL;

    gsnmp_attr_get(s, &in, base, 11, 10, prtInterpreterEntry_attr, mask);

    out = gsnmp_gettable(s, in);
    /* g_snmp_vbl_free(in); */

    if (out) {
        *prtInterpreterEntry = (printer_mib_prtInterpreterEntry_t **) g_malloc0((g_slist_length(out) + 1) * sizeof(printer_mib_prtInterpreterEntry_t *));
        if (! *prtInterpreterEntry) {
            s->error_status = G_SNMP_ERR_INTERNAL;
            g_snmp_vbl_free(out);
            return;
        }
        for (row = out, i = 0; row; row = g_slist_next(row), i++) {
            (*prtInterpreterEntry)[i] = assign_prtInterpreterEntry(row->data);
        }
    }
}

void
printer_mib_get_prtInterpreterEntry(GSnmpSession *s, printer_mib_prtInterpreterEntry_t **prtInterpreterEntry, gint32 hrDeviceIndex, gint32 prtInterpreterIndex, gint mask)
{
    GSList *in = NULL, *out = NULL;
    guint32 base[128];
    gint8 len;

    memset(base, 0, sizeof(base));
    memcpy(base, prtInterpreterEntry_oid, sizeof(prtInterpreterEntry_oid));
    len = pack_prtInterpreterEntry(base, hrDeviceIndex, prtInterpreterIndex);
    if (len < 0) {
        g_warning("%s: invalid index values", "prtInterpreterEntry");
        s->error_status = G_SNMP_ERR_INTERNAL;
        return;
    }

    *prtInterpreterEntry = NULL;

    gsnmp_attr_get(s, &in, base, len, 10, prtInterpreterEntry_attr, mask);

    out = g_snmp_session_sync_get(s, in);
    g_snmp_vbl_free(in);
    if (out) {
        if (s->error_status != G_SNMP_ERR_NOERROR) {
            g_snmp_vbl_free(out);
            return;
        }
        *prtInterpreterEntry = assign_prtInterpreterEntry(out);
    }
}

void
printer_mib_set_prtInterpreterEntry(GSnmpSession *s, printer_mib_prtInterpreterEntry_t *prtInterpreterEntry, gint mask)
{
    GSList *in = NULL, *out = NULL;
    guint32 base[128];
    gint8 len;

    memset(base, 0, sizeof(base));
    memcpy(base, prtInterpreterEntry_oid, sizeof(prtInterpreterEntry_oid));
    len = pack_prtInterpreterEntry(base, prtInterpreterEntry->hrDeviceIndex, prtInterpreterEntry->prtInterpreterIndex);
    if (len < 0) {
        g_warning("%s: invalid index values", "prtInterpreterEntry");
        s->error_status = G_SNMP_ERR_INTERNAL;
        return;
    }

    gsnmp_attr_set(s, &in, base, len, 10, prtInterpreterEntry_attr, mask, prtInterpreterEntry);

    out = g_snmp_session_sync_set(s, in);
    g_snmp_vbl_free(in);
    if (out) {
        g_snmp_vbl_free(out);
    }
}

void
printer_mib_free_prtInterpreterEntry(printer_mib_prtInterpreterEntry_t *prtInterpreterEntry)
{
    GSList *vbl;
    char *p;

    if (prtInterpreterEntry) {
        p = (char *) prtInterpreterEntry + sizeof(printer_mib_prtInterpreterEntry_t);
        vbl = * (GSList **) p;
        g_snmp_vbl_free(vbl);
        g_free(prtInterpreterEntry);
    }
}

void
printer_mib_free_prtInterpreterTable(printer_mib_prtInterpreterEntry_t **prtInterpreterEntry)
{
    int i;

    if (prtInterpreterEntry) {
        for (i = 0; prtInterpreterEntry[i]; i++) {
            printer_mib_free_prtInterpreterEntry(prtInterpreterEntry[i]);
        }
        g_free(prtInterpreterEntry);
    }
}

printer_mib_prtConsoleDisplayBufferEntry_t *
printer_mib_new_prtConsoleDisplayBufferEntry()
{
    printer_mib_prtConsoleDisplayBufferEntry_t *prtConsoleDisplayBufferEntry;

    prtConsoleDisplayBufferEntry = (printer_mib_prtConsoleDisplayBufferEntry_t *) g_malloc0(sizeof(printer_mib_prtConsoleDisplayBufferEntry_t) + sizeof(gpointer));
    return prtConsoleDisplayBufferEntry;
}

static int
unpack_prtConsoleDisplayBufferEntry(GSnmpVarBind *vb, printer_mib_prtConsoleDisplayBufferEntry_t *prtConsoleDisplayBufferEntry)
{
    guint8 idx = 11;

    if (vb->id_len < idx) return -1;
    prtConsoleDisplayBufferEntry->hrDeviceIndex = vb->id[idx++];
    if (vb->id_len < idx) return -1;
    prtConsoleDisplayBufferEntry->prtConsoleDisplayBufferIndex = vb->id[idx++];
    if (vb->id_len > idx) return -1;
    return 0;
}

static int
pack_prtConsoleDisplayBufferEntry(guint32 *base, gint32 hrDeviceIndex, gint32 prtConsoleDisplayBufferIndex)
{
    guint8 idx = 11;

    base[idx++] = hrDeviceIndex;
    base[idx++] = prtConsoleDisplayBufferIndex;
    return idx;
}

static printer_mib_prtConsoleDisplayBufferEntry_t *
assign_prtConsoleDisplayBufferEntry(GSList *vbl)
{
    printer_mib_prtConsoleDisplayBufferEntry_t *prtConsoleDisplayBufferEntry;
    char *p;

    prtConsoleDisplayBufferEntry = printer_mib_new_prtConsoleDisplayBufferEntry();
    if (! prtConsoleDisplayBufferEntry) {
        return NULL;
    }

    p = (char *) prtConsoleDisplayBufferEntry + sizeof(printer_mib_prtConsoleDisplayBufferEntry_t);
    * (GSList **) p = vbl;

    if (unpack_prtConsoleDisplayBufferEntry((GSnmpVarBind *) vbl->data, prtConsoleDisplayBufferEntry) < 0) {
        g_warning("%s: invalid instance identifier", "prtConsoleDisplayBufferEntry");
        g_free(prtConsoleDisplayBufferEntry);
        return NULL;
    }

    gsnmp_attr_assign(vbl, prtConsoleDisplayBufferEntry_oid, sizeof(prtConsoleDisplayBufferEntry_oid)/sizeof(guint32),
                      prtConsoleDisplayBufferEntry_attr, prtConsoleDisplayBufferEntry);

    return prtConsoleDisplayBufferEntry;
}

void
printer_mib_get_prtConsoleDisplayBufferTable(GSnmpSession *s, printer_mib_prtConsoleDisplayBufferEntry_t ***prtConsoleDisplayBufferEntry, gint mask)
{
    GSList *in = NULL, *out = NULL;
    GSList *row;
    int i;
    static guint32 base[] = {1, 3, 6, 1, 2, 1, 43, 16, 5, 1, 0};

    *prtConsoleDisplayBufferEntry = NULL;

    gsnmp_attr_get(s, &in, base, 11, 10, prtConsoleDisplayBufferEntry_attr, mask);

    out = gsnmp_gettable(s, in);
    /* g_snmp_vbl_free(in); */

    if (out) {
        *prtConsoleDisplayBufferEntry = (printer_mib_prtConsoleDisplayBufferEntry_t **) g_malloc0((g_slist_length(out) + 1) * sizeof(printer_mib_prtConsoleDisplayBufferEntry_t *));
        if (! *prtConsoleDisplayBufferEntry) {
            s->error_status = G_SNMP_ERR_INTERNAL;
            g_snmp_vbl_free(out);
            return;
        }
        for (row = out, i = 0; row; row = g_slist_next(row), i++) {
            (*prtConsoleDisplayBufferEntry)[i] = assign_prtConsoleDisplayBufferEntry(row->data);
        }
    }
}

void
printer_mib_get_prtConsoleDisplayBufferEntry(GSnmpSession *s, printer_mib_prtConsoleDisplayBufferEntry_t **prtConsoleDisplayBufferEntry, gint32 hrDeviceIndex, gint32 prtConsoleDisplayBufferIndex, gint mask)
{
    GSList *in = NULL, *out = NULL;
    guint32 base[128];
    gint8 len;

    memset(base, 0, sizeof(base));
    memcpy(base, prtConsoleDisplayBufferEntry_oid, sizeof(prtConsoleDisplayBufferEntry_oid));
    len = pack_prtConsoleDisplayBufferEntry(base, hrDeviceIndex, prtConsoleDisplayBufferIndex);
    if (len < 0) {
        g_warning("%s: invalid index values", "prtConsoleDisplayBufferEntry");
        s->error_status = G_SNMP_ERR_INTERNAL;
        return;
    }

    *prtConsoleDisplayBufferEntry = NULL;

    gsnmp_attr_get(s, &in, base, len, 10, prtConsoleDisplayBufferEntry_attr, mask);

    out = g_snmp_session_sync_get(s, in);
    g_snmp_vbl_free(in);
    if (out) {
        if (s->error_status != G_SNMP_ERR_NOERROR) {
            g_snmp_vbl_free(out);
            return;
        }
        *prtConsoleDisplayBufferEntry = assign_prtConsoleDisplayBufferEntry(out);
    }
}

void
printer_mib_set_prtConsoleDisplayBufferEntry(GSnmpSession *s, printer_mib_prtConsoleDisplayBufferEntry_t *prtConsoleDisplayBufferEntry, gint mask)
{
    GSList *in = NULL, *out = NULL;
    guint32 base[128];
    gint8 len;

    memset(base, 0, sizeof(base));
    memcpy(base, prtConsoleDisplayBufferEntry_oid, sizeof(prtConsoleDisplayBufferEntry_oid));
    len = pack_prtConsoleDisplayBufferEntry(base, prtConsoleDisplayBufferEntry->hrDeviceIndex, prtConsoleDisplayBufferEntry->prtConsoleDisplayBufferIndex);
    if (len < 0) {
        g_warning("%s: invalid index values", "prtConsoleDisplayBufferEntry");
        s->error_status = G_SNMP_ERR_INTERNAL;
        return;
    }

    gsnmp_attr_set(s, &in, base, len, 10, prtConsoleDisplayBufferEntry_attr, mask, prtConsoleDisplayBufferEntry);

    out = g_snmp_session_sync_set(s, in);
    g_snmp_vbl_free(in);
    if (out) {
        g_snmp_vbl_free(out);
    }
}

void
printer_mib_free_prtConsoleDisplayBufferEntry(printer_mib_prtConsoleDisplayBufferEntry_t *prtConsoleDisplayBufferEntry)
{
    GSList *vbl;
    char *p;

    if (prtConsoleDisplayBufferEntry) {
        p = (char *) prtConsoleDisplayBufferEntry + sizeof(printer_mib_prtConsoleDisplayBufferEntry_t);
        vbl = * (GSList **) p;
        g_snmp_vbl_free(vbl);
        g_free(prtConsoleDisplayBufferEntry);
    }
}

void
printer_mib_free_prtConsoleDisplayBufferTable(printer_mib_prtConsoleDisplayBufferEntry_t **prtConsoleDisplayBufferEntry)
{
    int i;

    if (prtConsoleDisplayBufferEntry) {
        for (i = 0; prtConsoleDisplayBufferEntry[i]; i++) {
            printer_mib_free_prtConsoleDisplayBufferEntry(prtConsoleDisplayBufferEntry[i]);
        }
        g_free(prtConsoleDisplayBufferEntry);
    }
}

printer_mib_prtConsoleLightEntry_t *
printer_mib_new_prtConsoleLightEntry()
{
    printer_mib_prtConsoleLightEntry_t *prtConsoleLightEntry;

    prtConsoleLightEntry = (printer_mib_prtConsoleLightEntry_t *) g_malloc0(sizeof(printer_mib_prtConsoleLightEntry_t) + sizeof(gpointer));
    return prtConsoleLightEntry;
}

static int
unpack_prtConsoleLightEntry(GSnmpVarBind *vb, printer_mib_prtConsoleLightEntry_t *prtConsoleLightEntry)
{
    guint8 idx = 11;

    if (vb->id_len < idx) return -1;
    prtConsoleLightEntry->hrDeviceIndex = vb->id[idx++];
    if (vb->id_len < idx) return -1;
    prtConsoleLightEntry->prtConsoleLightIndex = vb->id[idx++];
    if (vb->id_len > idx) return -1;
    return 0;
}

static int
pack_prtConsoleLightEntry(guint32 *base, gint32 hrDeviceIndex, gint32 prtConsoleLightIndex)
{
    guint8 idx = 11;

    base[idx++] = hrDeviceIndex;
    base[idx++] = prtConsoleLightIndex;
    return idx;
}

static printer_mib_prtConsoleLightEntry_t *
assign_prtConsoleLightEntry(GSList *vbl)
{
    printer_mib_prtConsoleLightEntry_t *prtConsoleLightEntry;
    char *p;

    prtConsoleLightEntry = printer_mib_new_prtConsoleLightEntry();
    if (! prtConsoleLightEntry) {
        return NULL;
    }

    p = (char *) prtConsoleLightEntry + sizeof(printer_mib_prtConsoleLightEntry_t);
    * (GSList **) p = vbl;

    if (unpack_prtConsoleLightEntry((GSnmpVarBind *) vbl->data, prtConsoleLightEntry) < 0) {
        g_warning("%s: invalid instance identifier", "prtConsoleLightEntry");
        g_free(prtConsoleLightEntry);
        return NULL;
    }

    gsnmp_attr_assign(vbl, prtConsoleLightEntry_oid, sizeof(prtConsoleLightEntry_oid)/sizeof(guint32),
                      prtConsoleLightEntry_attr, prtConsoleLightEntry);

    return prtConsoleLightEntry;
}

void
printer_mib_get_prtConsoleLightTable(GSnmpSession *s, printer_mib_prtConsoleLightEntry_t ***prtConsoleLightEntry, gint mask)
{
    GSList *in = NULL, *out = NULL;
    GSList *row;
    int i;
    static guint32 base[] = {1, 3, 6, 1, 2, 1, 43, 17, 6, 1, 0};

    *prtConsoleLightEntry = NULL;

    gsnmp_attr_get(s, &in, base, 11, 10, prtConsoleLightEntry_attr, mask);

    out = gsnmp_gettable(s, in);
    /* g_snmp_vbl_free(in); */

    if (out) {
        *prtConsoleLightEntry = (printer_mib_prtConsoleLightEntry_t **) g_malloc0((g_slist_length(out) + 1) * sizeof(printer_mib_prtConsoleLightEntry_t *));
        if (! *prtConsoleLightEntry) {
            s->error_status = G_SNMP_ERR_INTERNAL;
            g_snmp_vbl_free(out);
            return;
        }
        for (row = out, i = 0; row; row = g_slist_next(row), i++) {
            (*prtConsoleLightEntry)[i] = assign_prtConsoleLightEntry(row->data);
        }
    }
}

void
printer_mib_get_prtConsoleLightEntry(GSnmpSession *s, printer_mib_prtConsoleLightEntry_t **prtConsoleLightEntry, gint32 hrDeviceIndex, gint32 prtConsoleLightIndex, gint mask)
{
    GSList *in = NULL, *out = NULL;
    guint32 base[128];
    gint8 len;

    memset(base, 0, sizeof(base));
    memcpy(base, prtConsoleLightEntry_oid, sizeof(prtConsoleLightEntry_oid));
    len = pack_prtConsoleLightEntry(base, hrDeviceIndex, prtConsoleLightIndex);
    if (len < 0) {
        g_warning("%s: invalid index values", "prtConsoleLightEntry");
        s->error_status = G_SNMP_ERR_INTERNAL;
        return;
    }

    *prtConsoleLightEntry = NULL;

    gsnmp_attr_get(s, &in, base, len, 10, prtConsoleLightEntry_attr, mask);

    out = g_snmp_session_sync_get(s, in);
    g_snmp_vbl_free(in);
    if (out) {
        if (s->error_status != G_SNMP_ERR_NOERROR) {
            g_snmp_vbl_free(out);
            return;
        }
        *prtConsoleLightEntry = assign_prtConsoleLightEntry(out);
    }
}

void
printer_mib_set_prtConsoleLightEntry(GSnmpSession *s, printer_mib_prtConsoleLightEntry_t *prtConsoleLightEntry, gint mask)
{
    GSList *in = NULL, *out = NULL;
    guint32 base[128];
    gint8 len;

    memset(base, 0, sizeof(base));
    memcpy(base, prtConsoleLightEntry_oid, sizeof(prtConsoleLightEntry_oid));
    len = pack_prtConsoleLightEntry(base, prtConsoleLightEntry->hrDeviceIndex, prtConsoleLightEntry->prtConsoleLightIndex);
    if (len < 0) {
        g_warning("%s: invalid index values", "prtConsoleLightEntry");
        s->error_status = G_SNMP_ERR_INTERNAL;
        return;
    }

    gsnmp_attr_set(s, &in, base, len, 10, prtConsoleLightEntry_attr, mask, prtConsoleLightEntry);

    out = g_snmp_session_sync_set(s, in);
    g_snmp_vbl_free(in);
    if (out) {
        g_snmp_vbl_free(out);
    }
}

void
printer_mib_free_prtConsoleLightEntry(printer_mib_prtConsoleLightEntry_t *prtConsoleLightEntry)
{
    GSList *vbl;
    char *p;

    if (prtConsoleLightEntry) {
        p = (char *) prtConsoleLightEntry + sizeof(printer_mib_prtConsoleLightEntry_t);
        vbl = * (GSList **) p;
        g_snmp_vbl_free(vbl);
        g_free(prtConsoleLightEntry);
    }
}

void
printer_mib_free_prtConsoleLightTable(printer_mib_prtConsoleLightEntry_t **prtConsoleLightEntry)
{
    int i;

    if (prtConsoleLightEntry) {
        for (i = 0; prtConsoleLightEntry[i]; i++) {
            printer_mib_free_prtConsoleLightEntry(prtConsoleLightEntry[i]);
        }
        g_free(prtConsoleLightEntry);
    }
}

printer_mib_prtAlertEntry_t *
printer_mib_new_prtAlertEntry()
{
    printer_mib_prtAlertEntry_t *prtAlertEntry;

    prtAlertEntry = (printer_mib_prtAlertEntry_t *) g_malloc0(sizeof(printer_mib_prtAlertEntry_t) + sizeof(gpointer));
    return prtAlertEntry;
}

static int
unpack_prtAlertEntry(GSnmpVarBind *vb, printer_mib_prtAlertEntry_t *prtAlertEntry)
{
    guint8 idx = 11;

    if (vb->id_len < idx) return -1;
    prtAlertEntry->hrDeviceIndex = vb->id[idx++];
    if (vb->id_len < idx) return -1;
    prtAlertEntry->prtAlertIndex = vb->id[idx++];
    if (vb->id_len > idx) return -1;
    return 0;
}

static int
pack_prtAlertEntry(guint32 *base, gint32 hrDeviceIndex, gint32 prtAlertIndex)
{
    guint8 idx = 11;

    base[idx++] = hrDeviceIndex;
    base[idx++] = prtAlertIndex;
    return idx;
}

static printer_mib_prtAlertEntry_t *
assign_prtAlertEntry(GSList *vbl)
{
    printer_mib_prtAlertEntry_t *prtAlertEntry;
    char *p;

    prtAlertEntry = printer_mib_new_prtAlertEntry();
    if (! prtAlertEntry) {
        return NULL;
    }

    p = (char *) prtAlertEntry + sizeof(printer_mib_prtAlertEntry_t);
    * (GSList **) p = vbl;

    if (unpack_prtAlertEntry((GSnmpVarBind *) vbl->data, prtAlertEntry) < 0) {
        g_warning("%s: invalid instance identifier", "prtAlertEntry");
        g_free(prtAlertEntry);
        return NULL;
    }

    gsnmp_attr_assign(vbl, prtAlertEntry_oid, sizeof(prtAlertEntry_oid)/sizeof(guint32),
                      prtAlertEntry_attr, prtAlertEntry);

    return prtAlertEntry;
}

void
printer_mib_get_prtAlertTable(GSnmpSession *s, printer_mib_prtAlertEntry_t ***prtAlertEntry, gint mask)
{
    GSList *in = NULL, *out = NULL;
    GSList *row;
    int i;
    static guint32 base[] = {1, 3, 6, 1, 2, 1, 43, 18, 1, 1, 0};

    *prtAlertEntry = NULL;

    gsnmp_attr_get(s, &in, base, 11, 10, prtAlertEntry_attr, mask);

    out = gsnmp_gettable(s, in);
    /* g_snmp_vbl_free(in); */

    if (out) {
        *prtAlertEntry = (printer_mib_prtAlertEntry_t **) g_malloc0((g_slist_length(out) + 1) * sizeof(printer_mib_prtAlertEntry_t *));
        if (! *prtAlertEntry) {
            s->error_status = G_SNMP_ERR_INTERNAL;
            g_snmp_vbl_free(out);
            return;
        }
        for (row = out, i = 0; row; row = g_slist_next(row), i++) {
            (*prtAlertEntry)[i] = assign_prtAlertEntry(row->data);
        }
    }
}

void
printer_mib_get_prtAlertEntry(GSnmpSession *s, printer_mib_prtAlertEntry_t **prtAlertEntry, gint32 hrDeviceIndex, gint32 prtAlertIndex, gint mask)
{
    GSList *in = NULL, *out = NULL;
    guint32 base[128];
    gint8 len;

    memset(base, 0, sizeof(base));
    memcpy(base, prtAlertEntry_oid, sizeof(prtAlertEntry_oid));
    len = pack_prtAlertEntry(base, hrDeviceIndex, prtAlertIndex);
    if (len < 0) {
        g_warning("%s: invalid index values", "prtAlertEntry");
        s->error_status = G_SNMP_ERR_INTERNAL;
        return;
    }

    *prtAlertEntry = NULL;

    gsnmp_attr_get(s, &in, base, len, 10, prtAlertEntry_attr, mask);

    out = g_snmp_session_sync_get(s, in);
    g_snmp_vbl_free(in);
    if (out) {
        if (s->error_status != G_SNMP_ERR_NOERROR) {
            g_snmp_vbl_free(out);
            return;
        }
        *prtAlertEntry = assign_prtAlertEntry(out);
    }
}

void
printer_mib_free_prtAlertEntry(printer_mib_prtAlertEntry_t *prtAlertEntry)
{
    GSList *vbl;
    char *p;

    if (prtAlertEntry) {
        p = (char *) prtAlertEntry + sizeof(printer_mib_prtAlertEntry_t);
        vbl = * (GSList **) p;
        g_snmp_vbl_free(vbl);
        g_free(prtAlertEntry);
    }
}

void
printer_mib_free_prtAlertTable(printer_mib_prtAlertEntry_t **prtAlertEntry)
{
    int i;

    if (prtAlertEntry) {
        for (i = 0; prtAlertEntry[i]; i++) {
            printer_mib_free_prtAlertEntry(prtAlertEntry[i]);
        }
        g_free(prtAlertEntry);
    }
}


