/*
 * SDK Pullenti Unitext, version 4.33, fabruary 2026. Copyright (c) 2013-2026, Pullenti. All rights reserved. 
 * Non-Commercial Freeware and Commercial Software. 
 * This class is generated using the converter Unisharping (www.unisharping.ru) from Pullenti C# project. 
 * The latest version of the code is available on the site www.pullenti.ru
 */

package com.pullenti.unitext.internal.word;

public class SinglePropertyValue {

    public static Object parseValue(int sprm, byte[] value) throws Exception, UnsupportedOperationException, java.io.IOException {
        switch (sprm) { 
        case SinglePropertyModifiers.sprmCFRMarkDel:
            return parseToggleOperand(value);
        case SinglePropertyModifiers.sprmCFRMarkIns:
            return parseToggleOperand(value);
        case SinglePropertyModifiers.sprmCFFldVanish:
            return parseToggleOperand(value);
        case SinglePropertyModifiers.sprmCPicLocation:
            return parseInt32(value);
        case SinglePropertyModifiers.sprmCIbstRMark:
            return parseInt16(value);
        case SinglePropertyModifiers.sprmCDttmRMark:
            return parseDTTM(value);
        case SinglePropertyModifiers.sprmCFData:
            return parseBool(value);
        case SinglePropertyModifiers.sprmCIdslRMark:
            return parseUInt16(value);
        case SinglePropertyModifiers.sprmCSymbol:
            return parseCSymbolOperand(value);
        case SinglePropertyModifiers.sprmCFOle2:
            return parseBool(value);
        case SinglePropertyModifiers.sprmCHighlight:
            return parseIco(value);
        case SinglePropertyModifiers.sprmCFWebHidden:
            return parseToggleOperand(value);
        case SinglePropertyModifiers.sprmCRsidProp:
            return parseInt32(value);
        case SinglePropertyModifiers.sprmCRsidText:
            return parseInt32(value);
        case SinglePropertyModifiers.sprmCRsidRMDel:
            return parseInt32(value);
        case SinglePropertyModifiers.sprmCFSpecVanish:
            return parseToggleOperand(value);
        case SinglePropertyModifiers.sprmCFMathPr:
            return parseMathPrOperand(value);
        case SinglePropertyModifiers.sprmCIstd:
            return parseUInt16(value);
        case SinglePropertyModifiers.sprmCIstdPermute:
            return parseSPPOperand(value);
        case SinglePropertyModifiers.sprmCPlain:
            return parseByte(value);
        case SinglePropertyModifiers.sprmCKcd:
            return parseByte(value);
        case SinglePropertyModifiers.sprmCFBold:
            return parseToggleOperand(value);
        case SinglePropertyModifiers.sprmCFItalic:
            return parseToggleOperand(value);
        case SinglePropertyModifiers.sprmCFStrike:
            return parseToggleOperand(value);
        case SinglePropertyModifiers.sprmCFOutline:
            return parseToggleOperand(value);
        case SinglePropertyModifiers.sprmCFShadow:
            return parseToggleOperand(value);
        case SinglePropertyModifiers.sprmCFSmallCaps:
            return parseToggleOperand(value);
        case SinglePropertyModifiers.sprmCFCaps:
            return parseToggleOperand(value);
        case SinglePropertyModifiers.sprmCFVanish:
            return parseToggleOperand(value);
        case SinglePropertyModifiers.sprmCKul:
            return parseKul(value);
        case SinglePropertyModifiers.sprmCDxaSpace:
            return parseXAS(value);
        case SinglePropertyModifiers.sprmCIco:
            return parseIco(value);
        case SinglePropertyModifiers.sprmCHps:
            return parseUInt16(value);
        case SinglePropertyModifiers.sprmCHpsPos:
            return parseInt16(value);
        case SinglePropertyModifiers.sprmCMajority:
            return parseCMajorityOperand(value);
        case SinglePropertyModifiers.sprmCIss:
            return parseByte(value);
        case SinglePropertyModifiers.sprmCHpsKern:
            return parseInt16(value);
        case SinglePropertyModifiers.sprmCHresi:
            return parseHresiOperand(value);
        case SinglePropertyModifiers.sprmCRgFtc0:
            return parseInt16(value);
        case SinglePropertyModifiers.sprmCRgFtc1:
            return parseInt16(value);
        case SinglePropertyModifiers.sprmCRgFtc2:
            return parseInt16(value);
        case SinglePropertyModifiers.sprmCCharScale:
            return parseUInt16(value);
        case SinglePropertyModifiers.sprmCFDStrike:
            return parseToggleOperand(value);
        case SinglePropertyModifiers.sprmCFImprint:
            return parseToggleOperand(value);
        case SinglePropertyModifiers.sprmCFSpec:
            return parseToggleOperand(value);
        case SinglePropertyModifiers.sprmCFObj:
            return parseBool(value);
        case SinglePropertyModifiers.sprmCPropRMark90:
            return parsePropRMarkOperand(value);
        case SinglePropertyModifiers.sprmCFEmboss:
            return parseToggleOperand(value);
        case SinglePropertyModifiers.sprmCSfxText:
            return parseByte(value);
        case SinglePropertyModifiers.sprmCFBiDi:
            return parseToggleOperand(value);
        case SinglePropertyModifiers.sprmCFBoldBi:
            return parseToggleOperand(value);
        case SinglePropertyModifiers.sprmCFItalicBi:
            return parseToggleOperand(value);
        case SinglePropertyModifiers.sprmCFtcBi:
            return parseInt16(value);
        case SinglePropertyModifiers.sprmCLidBi:
            return parseLID(value);
        case SinglePropertyModifiers.sprmCIcoBi:
            return parseIco(value);
        case SinglePropertyModifiers.sprmCHpsBi:
            return parseUInt16(value);
        case SinglePropertyModifiers.sprmCDispFldRMark:
            return parseDispFldRmOperand(value);
        case SinglePropertyModifiers.sprmCIbstRMarkDel:
            return parseInt16(value);
        case SinglePropertyModifiers.sprmCDttmRMarkDel:
            return parseDTTM(value);
        case SinglePropertyModifiers.sprmCBrc80:
            return parseBrc80(value);
        case SinglePropertyModifiers.sprmCShd80:
            return parseShd80(value);
        case SinglePropertyModifiers.sprmCIdslRMarkDel:
            return parseUInt16(value);
        case SinglePropertyModifiers.sprmCFUsePgsuSettings:
            return parseToggleOperand(value);
        case SinglePropertyModifiers.sprmCRgLid0_80:
            return parseLID(value);
        case SinglePropertyModifiers.sprmCRgLid1_80:
            return parseLID(value);
        case SinglePropertyModifiers.sprmCIdctHint:
            return parseByte(value);
        case SinglePropertyModifiers.sprmCCv:
            return parseCOLORREF(value);
        case SinglePropertyModifiers.sprmCShd:
            return parseSHDOperand(value);
        case SinglePropertyModifiers.sprmCBrc:
            return parseBrcOperand(value);
        case SinglePropertyModifiers.sprmCRgLid0:
            return parseLID(value);
        case SinglePropertyModifiers.sprmCRgLid1:
            return parseLID(value);
        case SinglePropertyModifiers.sprmCFNoProof:
            return parseToggleOperand(value);
        case SinglePropertyModifiers.sprmCFitText:
            return parseCFitTextOperand(value);
        case SinglePropertyModifiers.sprmCCvUl:
            return parseCOLORREF(value);
        case SinglePropertyModifiers.sprmCFELayout:
            return parseFarEastLayoutOperand(value);
        case SinglePropertyModifiers.sprmCLbcCRJ:
            return parseLBCOperand(value);
        case SinglePropertyModifiers.sprmCFComplexScripts:
            return parseToggleOperand(value);
        case SinglePropertyModifiers.sprmCWall:
            return parseBool(value);
        case SinglePropertyModifiers.sprmCCnf:
            return parseCNFOperand(value);
        case SinglePropertyModifiers.sprmCNeedFontFixup:
            return parseFFM(value);
        case SinglePropertyModifiers.sprmCPbiIBullet:
            return parseCP(value);
        case SinglePropertyModifiers.sprmCPbiGrf:
            return parsePbiGrfOperand(value);
        case SinglePropertyModifiers.sprmCPropRMark:
            return parsePropRMarkOperand(value);
        case SinglePropertyModifiers.sprmCFSdtVanish:
            return parseBool(value);
        case SinglePropertyModifiers.sprmPIstd:
            return parseUInt16(value);
        case SinglePropertyModifiers.sprmPIstdPermute:
            return parseSPPOperand(value);
        case SinglePropertyModifiers.sprmPIncLvl:
            return parseSByte(value);
        case SinglePropertyModifiers.sprmPJc80:
            return parseByte(value);
        case SinglePropertyModifiers.sprmPFKeep:
            return parseBool(value);
        case SinglePropertyModifiers.sprmPFKeepFollow:
            return parseBool(value);
        case SinglePropertyModifiers.sprmPFPageBreakBefore:
            return parseBool(value);
        case SinglePropertyModifiers.sprmPIlvl:
            return parseByte(value);
        case SinglePropertyModifiers.sprmPIlfo:
            return parseInt16(value);
        case SinglePropertyModifiers.sprmPFNoLineNumb:
            return parseBool(value);
        case SinglePropertyModifiers.sprmPChgTabsPapx:
            return parsePChgTabsPapxOperand(value);
        case SinglePropertyModifiers.sprmPDxaRight80:
            return parseXAS(value);
        case SinglePropertyModifiers.sprmPDxaLeft80:
            return parseXAS(value);
        case SinglePropertyModifiers.sprmPNest80:
            return parseXAS(value);
        case SinglePropertyModifiers.sprmPDxaLeft180:
            return parseXAS(value);
        case SinglePropertyModifiers.sprmPDyaLine:
            return parseLSPD(value);
        case SinglePropertyModifiers.sprmPDyaBefore:
            return parseUInt16(value);
        case SinglePropertyModifiers.sprmPDyaAfter:
            return parseUInt16(value);
        case SinglePropertyModifiers.sprmPChgTabs:
            return parsePChgTabsOperand(value);
        case SinglePropertyModifiers.sprmPFInTable:
            return parseBool(value);
        case SinglePropertyModifiers.sprmPFTtp:
            return parseBool(value);
        case SinglePropertyModifiers.sprmPDxaAbs:
            return parseXAS_plusOne(value);
        case SinglePropertyModifiers.sprmPDyaAbs:
            return parseYAS_plusOne(value);
        case SinglePropertyModifiers.sprmPDxaWidth:
            return parseXAS_nonNeg(value);
        case SinglePropertyModifiers.sprmPPc:
            return parsePositionCodeOperand(value);
        case SinglePropertyModifiers.sprmPWr:
            return parseByte(value);
        case SinglePropertyModifiers.sprmPBrcTop80:
            return parseBrc80(value);
        case SinglePropertyModifiers.sprmPBrcLeft80:
            return parseBrc80(value);
        case SinglePropertyModifiers.sprmPBrcBottom80:
            return parseBrc80(value);
        case SinglePropertyModifiers.sprmPBrcRight80:
            return parseBrc80(value);
        case SinglePropertyModifiers.sprmPBrcBetween80:
            return parseBrc80(value);
        case SinglePropertyModifiers.sprmPBrcBar80:
            return parseBrc80(value);
        case SinglePropertyModifiers.sprmPFNoAutoHyph:
            return parseBool(value);
        case SinglePropertyModifiers.sprmPWHeightAbs:
            return parseWHeightAbs(value);
        case SinglePropertyModifiers.sprmPDcs:
            return parseDCS(value);
        case SinglePropertyModifiers.sprmPShd80:
            return parseShd80(value);
        case SinglePropertyModifiers.sprmPDyaFromText:
            return parseYAS_nonNeg(value);
        case SinglePropertyModifiers.sprmPDxaFromText:
            return parseXAS_nonNeg(value);
        case SinglePropertyModifiers.sprmPFLocked:
            return parseBool(value);
        case SinglePropertyModifiers.sprmPFWidowControl:
            return parseBool(value);
        case SinglePropertyModifiers.sprmPFKinsoku:
            return parseBool(value);
        case SinglePropertyModifiers.sprmPFWordWrap:
            return parseBool(value);
        case SinglePropertyModifiers.sprmPFOverflowPunct:
            return parseBool(value);
        case SinglePropertyModifiers.sprmPFTopLinePunct:
            return parseBool(value);
        case SinglePropertyModifiers.sprmPFAutoSpaceDE:
            return parseBool(value);
        case SinglePropertyModifiers.sprmPFAutoSpaceDN:
            return parseBool(value);
        case SinglePropertyModifiers.sprmPWAlignFont:
            return parseUInt16(value);
        case SinglePropertyModifiers.sprmPFrameTextFlow:
            return parseFrameTextFlowOperand(value);
        case SinglePropertyModifiers.sprmPOutLvl:
            return parseByte(value);
        case SinglePropertyModifiers.sprmPFBiDi:
            return parseBool(value);
        case SinglePropertyModifiers.sprmPFNumRMIns:
            return parseBool(value);
        case SinglePropertyModifiers.sprmPNumRM:
            return parseNumRMOperand(value);
        case SinglePropertyModifiers.sprmPHugePapx:
            return parseUInt32(value);
        case SinglePropertyModifiers.sprmPFUsePgsuSettings:
            return parseBool(value);
        case SinglePropertyModifiers.sprmPFAdjustRight:
            return parseBool(value);
        case SinglePropertyModifiers.sprmPItap:
            return parseInt32(value);
        case SinglePropertyModifiers.sprmPDtap:
            return parseInt32(value);
        case SinglePropertyModifiers.sprmPFInnerTableCell:
            return parseBool(value);
        case SinglePropertyModifiers.sprmPFInnerTtp:
            return parseBool(value);
        case SinglePropertyModifiers.sprmPShd:
            return parseSHDOperand(value);
        case SinglePropertyModifiers.sprmPBrcTop:
            return parseBrcOperand(value);
        case SinglePropertyModifiers.sprmPBrcLeft:
            return parseBrcOperand(value);
        case SinglePropertyModifiers.sprmPBrcBottom:
            return parseBrcOperand(value);
        case SinglePropertyModifiers.sprmPBrcRight:
            return parseBrcOperand(value);
        case SinglePropertyModifiers.sprmPBrcBetween:
            return parseBrcOperand(value);
        case SinglePropertyModifiers.sprmPBrcBar:
            return parseBrcOperand(value);
        case SinglePropertyModifiers.sprmPDxcRight:
            return parseInt16(value);
        case SinglePropertyModifiers.sprmPDxcLeft:
            return parseInt16(value);
        case SinglePropertyModifiers.sprmPDxcLeft1:
            return parseInt16(value);
        case SinglePropertyModifiers.sprmPDylBefore:
            return parseInt16(value);
        case SinglePropertyModifiers.sprmPDylAfter:
            return parseInt16(value);
        case SinglePropertyModifiers.sprmPFOpenTch:
            return parseBool(value);
        case SinglePropertyModifiers.sprmPFDyaBeforeAuto:
            return parseBool(value);
        case SinglePropertyModifiers.sprmPFDyaAfterAuto:
            return parseBool(value);
        case SinglePropertyModifiers.sprmPDxaRight:
            return parseXAS(value);
        case SinglePropertyModifiers.sprmPDxaLeft:
            return parseXAS(value);
        case SinglePropertyModifiers.sprmPNest:
            return parseXAS(value);
        case SinglePropertyModifiers.sprmPDxaLeft1:
            return parseXAS(value);
        case SinglePropertyModifiers.sprmPJc:
            return parseByte(value);
        case SinglePropertyModifiers.sprmPFNoAllowOverlap:
            return parseBool(value);
        case SinglePropertyModifiers.sprmPWall:
            return parseBool(value);
        case SinglePropertyModifiers.sprmPIpgp:
            return parseUInt32(value);
        case SinglePropertyModifiers.sprmPCnf:
            return parseCNFOperand(value);
        case SinglePropertyModifiers.sprmPRsid:
            return parseInt32(value);
        case SinglePropertyModifiers.sprmPIstdListPermute:
            return parseSPPOperand(value);
        case SinglePropertyModifiers.sprmPTableProps:
            return parseUInt32(value);
        case SinglePropertyModifiers.sprmPTIstdInfo:
            return parsePTIstdInfoOperand(value);
        case SinglePropertyModifiers.sprmPFContextualSpacing:
            return parseBool(value);
        case SinglePropertyModifiers.sprmPPropRMark:
            return parsePropRMarkOperand(value);
        case SinglePropertyModifiers.sprmPFMirrorIndents:
            return parseBool(value);
        case SinglePropertyModifiers.sprmPTtwo:
            return parseByte(value);
        case SinglePropertyModifiers.sprmTJc90:
            return parseUInt16(value);
        case SinglePropertyModifiers.sprmTDxaLeft:
            return parseXAS(value);
        case SinglePropertyModifiers.sprmTDxaGapHalf:
            return parseXAS(value);
        case SinglePropertyModifiers.sprmTFCantSplit90:
            return parseBool(value);
        case SinglePropertyModifiers.sprmTTableHeader:
            return parseBool(value);
        case SinglePropertyModifiers.sprmTTableBorders80:
            return parseTableBordersOperand80(value);
        case SinglePropertyModifiers.sprmTDyaRowHeight:
            return parseYAS(value);
        case SinglePropertyModifiers.sprmTDefTable:
            return parseTDefTableOperand(value);
        case SinglePropertyModifiers.sprmTDefTableShd80:
            return parseDefTableShd80Operand(value);
        case SinglePropertyModifiers.sprmTTlp:
            return parseTLP(value);
        case SinglePropertyModifiers.sprmTFBiDi:
            return parseBool(value);
        case SinglePropertyModifiers.sprmTDefTableShd3rd:
            return parseDefTableShdOperand(value);
        case SinglePropertyModifiers.sprmTPc:
            return parsePositionCodeOperand(value);
        case SinglePropertyModifiers.sprmTDxaAbs:
            return parseXAS_plusOne(value);
        case SinglePropertyModifiers.sprmTDyaAbs:
            return parseYAS_plusOne(value);
        case SinglePropertyModifiers.sprmTDxaFromText:
            return parseXAS_nonNeg(value);
        case SinglePropertyModifiers.sprmTDyaFromText:
            return parseYAS_nonNeg(value);
        case SinglePropertyModifiers.sprmTDefTableShd:
            return parseDefTableShdOperand(value);
        case SinglePropertyModifiers.sprmTTableBorders:
            return parseTableBordersOperand(value);
        case SinglePropertyModifiers.sprmTTableWidth:
            return parseFtsWWidth_Table(value);
        case SinglePropertyModifiers.sprmTFAutofit:
            return parseBool(value);
        case SinglePropertyModifiers.sprmTDefTableShd2nd:
            return parseDefTableShdOperand(value);
        case SinglePropertyModifiers.sprmTWidthBefore:
            return parseFtsWWidth_TablePart(value);
        case SinglePropertyModifiers.sprmTWidthAfter:
            return parseFtsWWidth_TablePart(value);
        case SinglePropertyModifiers.sprmTFKeepFollow:
            return parseBool(value);
        case SinglePropertyModifiers.sprmTBrcTopCv:
            return parseBrcCvOperand(value);
        case SinglePropertyModifiers.sprmTBrcLeftCv:
            return parseBrcCvOperand(value);
        case SinglePropertyModifiers.sprmTBrcBottomCv:
            return parseBrcCvOperand(value);
        case SinglePropertyModifiers.sprmTBrcRightCv:
            return parseBrcCvOperand(value);
        case SinglePropertyModifiers.sprmTDxaFromTextRight:
            return parseXAS_nonNeg(value);
        case SinglePropertyModifiers.sprmTDyaFromTextBottom:
            return parseYAS_nonNeg(value);
        case SinglePropertyModifiers.sprmTSetBrc80:
            return parseTableBrc80Operand(value);
        case SinglePropertyModifiers.sprmTInsert:
            return parseTInsertOperand(value);
        case SinglePropertyModifiers.sprmTDelete:
            return parseItcFirstLim(value);
        case SinglePropertyModifiers.sprmTDxaCol:
            return parseTDxaColOperand(value);
        case SinglePropertyModifiers.sprmTMerge:
            return parseItcFirstLim(value);
        case SinglePropertyModifiers.sprmTSplit:
            return parseItcFirstLim(value);
        case SinglePropertyModifiers.sprmTTextFlow:
            return parseCellRangeTextFlow(value);
        case SinglePropertyModifiers.sprmTVertMerge:
            return parseVertMergeOperand(value);
        case SinglePropertyModifiers.sprmTVertAlign:
            return parseCellRangeVertAlign(value);
        case SinglePropertyModifiers.sprmTSetShd:
            return parseTableShadeOperand(value);
        case SinglePropertyModifiers.sprmTSetShdOdd:
            return parseTableShadeOperand(value);
        case SinglePropertyModifiers.sprmTSetBrc:
            return parseTableBrcOperand(value);
        case SinglePropertyModifiers.sprmTCellPadding:
            return parseCSSAOperand(value);
        case SinglePropertyModifiers.sprmTCellSpacingDefault:
            return parseCSSAOperand(value);
        case SinglePropertyModifiers.sprmTCellPaddingDefault:
            return parseCSSAOperand(value);
        case SinglePropertyModifiers.sprmTCellWidth:
            return parseTableCellWidthOperand(value);
        case SinglePropertyModifiers.sprmTFitText:
            return parseCellRangeFitText(value);
        case SinglePropertyModifiers.sprmTFCellNoWrap:
            return parseCellRangeNoWrap(value);
        case SinglePropertyModifiers.sprmTIstd:
            return parseUInt16(value);
        case SinglePropertyModifiers.sprmTCellPaddingStyle:
            return parseCSSAOperand(value);
        case SinglePropertyModifiers.sprmTCellFHideMark:
            return parseCellHideMarkOperand(value);
        case SinglePropertyModifiers.sprmTSetShdTable:
            return parseSHDOperand(value);
        case SinglePropertyModifiers.sprmTWidthIndent:
            return parseFtsWWidth_Indent(value);
        case SinglePropertyModifiers.sprmTCellBrcType:
            return parseTCellBrcTypeOperand(value);
        case SinglePropertyModifiers.sprmTFBiDi90:
            return parseBool(value);
        case SinglePropertyModifiers.sprmTFNoAllowOverlap:
            return parseBool(value);
        case SinglePropertyModifiers.sprmTFCantSplit:
            return parseBool(value);
        case SinglePropertyModifiers.sprmTPropRMark:
            return parsePropRMarkOperand(value);
        case SinglePropertyModifiers.sprmTWall:
            return parseBool(value);
        case SinglePropertyModifiers.sprmTIpgp:
            return parseUInt32(value);
        case SinglePropertyModifiers.sprmTCnf:
            return parseCNFOperand(value);
        case SinglePropertyModifiers.sprmTDefTableShdRaw:
            return parseDefTableShdOperand(value);
        case SinglePropertyModifiers.sprmTDefTableShdRaw2nd:
            return parseDefTableShdOperand(value);
        case SinglePropertyModifiers.sprmTDefTableShdRaw3rd:
            return parseDefTableShdOperand(value);
        case SinglePropertyModifiers.sprmTRsid:
            return parseInt32(value);
        case SinglePropertyModifiers.sprmTCellVertAlignStyle:
            return parseVerticalAlign(value);
        case SinglePropertyModifiers.sprmTCellNoWrapStyle:
            return parseBool(value);
        case SinglePropertyModifiers.sprmTCellBrcTopStyle:
            return parseBrcOperand(value);
        case SinglePropertyModifiers.sprmTCellBrcBottomStyle:
            return parseBrcOperand(value);
        case SinglePropertyModifiers.sprmTCellBrcLeftStyle:
            return parseBrcOperand(value);
        case SinglePropertyModifiers.sprmTCellBrcRightStyle:
            return parseBrcOperand(value);
        case SinglePropertyModifiers.sprmTCellBrcInsideHStyle:
            return parseBrcOperand(value);
        case SinglePropertyModifiers.sprmTCellBrcInsideVStyle:
            return parseBrcOperand(value);
        case SinglePropertyModifiers.sprmTCellBrcTL2BRStyle:
            return parseBrcOperand(value);
        case SinglePropertyModifiers.sprmTCellBrcTR2BLStyle:
            return parseBrcOperand(value);
        case SinglePropertyModifiers.sprmTCellShdStyle:
            return parseSHDOperand(value);
        case SinglePropertyModifiers.sprmTCHorzBands:
            return parseByte(value);
        case SinglePropertyModifiers.sprmTCVertBands:
            return parseByte(value);
        case SinglePropertyModifiers.sprmTJc:
            return parseUInt16(value);
        case SinglePropertyModifiers.sprmScnsPgn:
            return parseCNS(value);
        case SinglePropertyModifiers.sprmSiHeadingPgn:
            return parseByte(value);
        case SinglePropertyModifiers.sprmSDxaColWidth:
            return parseSDxaColWidthOperand(value);
        case SinglePropertyModifiers.sprmSDxaColSpacing:
            return parseSDxaColSpacingOperand(value);
        case SinglePropertyModifiers.sprmSFEvenlySpaced:
            return parseBool(value);
        case SinglePropertyModifiers.sprmSFProtected:
            return parseBool(value);
        case SinglePropertyModifiers.sprmSDmBinFirst:
            return parseSDmBinOperand(value);
        case SinglePropertyModifiers.sprmSDmBinOther:
            return parseSDmBinOperand(value);
        case SinglePropertyModifiers.sprmSBkc:
            return parseSBkcOperand(value);
        case SinglePropertyModifiers.sprmSFTitlePage:
            return parseBool(value);
        case SinglePropertyModifiers.sprmSCcolumns:
            return parseUInt16(value);
        case SinglePropertyModifiers.sprmSDxaColumns:
            return parseXAS_nonNeg(value);
        case SinglePropertyModifiers.sprmSNfcPgn:
            return parseMSONFC(value);
        case SinglePropertyModifiers.sprmSFPgnRestart:
            return parseBool(value);
        case SinglePropertyModifiers.sprmSFEndnote:
            return parseBool(value);
        case SinglePropertyModifiers.sprmSLnc:
            return parseSLncOperand(value);
        case SinglePropertyModifiers.sprmSNLnnMod:
            return parseUInt16(value);
        case SinglePropertyModifiers.sprmSDxaLnn:
            return parseXAS_nonNeg(value);
        case SinglePropertyModifiers.sprmSDyaHdrTop:
            return parseYAS_nonNeg(value);
        case SinglePropertyModifiers.sprmSDyaHdrBottom:
            return parseYAS_nonNeg(value);
        case SinglePropertyModifiers.sprmSLBetween:
            return parseBool(value);
        case SinglePropertyModifiers.sprmSVjc:
            return parseVic(value);
        case SinglePropertyModifiers.sprmSLnnMin:
            return parseUInt16(value);
        case SinglePropertyModifiers.sprmSPgnStart97:
            return parseUInt16(value);
        case SinglePropertyModifiers.sprmSBOrientation:
            return parseSBOrientationOperan(value);
        case SinglePropertyModifiers.sprmSXaPage:
            return parseUInt16(value);
        case SinglePropertyModifiers.sprmSYaPage:
            return parseUInt16(value);
        case SinglePropertyModifiers.sprmSDxaLeft:
            return parseXAS_nonNeg(value);
        case SinglePropertyModifiers.sprmSDxaRight:
            return parseXAS_nonNeg(value);
        case SinglePropertyModifiers.sprmSDyaTop:
            return parseYAS(value);
        case SinglePropertyModifiers.sprmSDyaBottom:
            return parseYAS(value);
        case SinglePropertyModifiers.sprmSDzaGutter:
            return parseUInt16(value);
        case SinglePropertyModifiers.sprmSDmPaperReq:
            return parseUInt16(value);
        case SinglePropertyModifiers.sprmSFBiDi:
            return parseBool(value);
        case SinglePropertyModifiers.sprmSFRTLGutter:
            return parseBool(value);
        case SinglePropertyModifiers.sprmSBrcTop80:
            return parseBrc80(value);
        case SinglePropertyModifiers.sprmSBrcLeft80:
            return parseBrc80(value);
        case SinglePropertyModifiers.sprmSBrcBottom80:
            return parseBrc80(value);
        case SinglePropertyModifiers.sprmSBrcRight80:
            return parseBrc80(value);
        case SinglePropertyModifiers.sprmSPgbProp:
            return parseSPgbPropOperand(value);
        case SinglePropertyModifiers.sprmSDxtCharSpace:
            return parseInt32(value);
        case SinglePropertyModifiers.sprmSDyaLinePitch:
            return parseYAS(value);
        case SinglePropertyModifiers.sprmSClm:
            return parseSClmOperand(value);
        case SinglePropertyModifiers.sprmSTextFlow:
            return parseMSOTXFL(value);
        case SinglePropertyModifiers.sprmSBrcTop:
            return parseBrcOperand(value);
        case SinglePropertyModifiers.sprmSBrcLeft:
            return parseBrcOperand(value);
        case SinglePropertyModifiers.sprmSBrcBottom:
            return parseBrcOperand(value);
        case SinglePropertyModifiers.sprmSBrcRight:
            return parseBrcOperand(value);
        case SinglePropertyModifiers.sprmSWall:
            return parseBool(value);
        case SinglePropertyModifiers.sprmSRsid:
            return parseInt32(value);
        case SinglePropertyModifiers.sprmSFpc:
            return parseSFpcOperand(value);
        case SinglePropertyModifiers.sprmSRncFtn:
            return parseRnc(value);
        case SinglePropertyModifiers.sprmSRncEdn:
            return parseRnc(value);
        case SinglePropertyModifiers.sprmSNFtn:
            return parseUInt16(value);
        case SinglePropertyModifiers.sprmSNfcFtnRef:
            return parseMSONFC(value);
        case SinglePropertyModifiers.sprmSNEdn:
            return parseUInt16(value);
        case SinglePropertyModifiers.sprmSNfcEdnRef:
            return parseMSONFC(value);
        case SinglePropertyModifiers.sprmSPropRMark:
            return parsePropRMarkOperand(value);
        case SinglePropertyModifiers.sprmSPgnStart:
            return parseUInt32(value);
        case SinglePropertyModifiers.sprmPicBrcTop80:
            return parseBrc80(value);
        case SinglePropertyModifiers.sprmPicBrcLeft80:
            return parseBrc80(value);
        case SinglePropertyModifiers.sprmPicBrcBottom80:
            return parseBrc80(value);
        case SinglePropertyModifiers.sprmPicBrcRight80:
            return parseBrc80(value);
        case SinglePropertyModifiers.sprmPicBrcTop:
            return parseBrcOperand(value);
        case SinglePropertyModifiers.sprmPicBrcLeft:
            return parseBrcOperand(value);
        case SinglePropertyModifiers.sprmPicBrcBottom:
            return parseBrcOperand(value);
        default: 
            throw new Exception("Unknow sprm value");
    }
    }

    private static final float dptConstant = 0.125f;

    private static final float dxaConstant = 0.125f;

    private static Object parseBool(byte[] value) {
        return value[0] != ((byte)0);
    }

    private static Object parseBrc80(byte[] value) {
        java.util.HashMap<String, Object> result = new java.util.HashMap<String, Object>();
        result.put("LineWidth", ((float)value[0]) * dptConstant);
        result.put("BorderType", Byte.toUnsignedInt(value[1]));
        result.put("Color", Byte.toUnsignedInt(value[2]));
        result.put("Space", ((float)(((Byte.toUnsignedInt(value[3])) & 0x1F))) * dptConstant);
        result.put("Shadow", (((Byte.toUnsignedInt(value[3])) & 0x20)) != 0);
        result.put("Frame", (((Byte.toUnsignedInt(value[3])) & 0x40)) != 0);
        return result;
    }

    private static Object parseBrcCvOperand(byte[] value) {
        return new ColorRef[] {ColorRef.fromBytes(value, 0), ColorRef.fromBytes(value, 4), ColorRef.fromBytes(value, 8), ColorRef.fromBytes(value, 12)};
    }

    private static Object parseBrcOperand(byte[] value) {
        java.util.HashMap<String, Object> result = new java.util.HashMap<String, Object>();
        result.put("Color", ColorRef.fromBytes(value, 0));
        result.put("LineWidth", ((float)value[4]) * dptConstant);
        result.put("BorderType", Byte.toUnsignedInt(value[5]));
        result.put("Space", ((float)(((Byte.toUnsignedInt(value[6])) & 0x1F))) * dptConstant);
        result.put("Shadow", (((Byte.toUnsignedInt(value[6])) & 0x20)) != 0);
        result.put("Frame", (((Byte.toUnsignedInt(value[6])) & 0x40)) != 0);
        return result;
    }

    private static Object parseByte(byte[] value) {
        return value[0];
    }

    private static Object parseCellHideMarkOperand(byte[] value) {
        java.util.HashMap<String, Object> result = new java.util.HashMap<String, Object>();
        result.put("Range", new int[] {value[0], value[1]});
        result.put("NoHeight", value[2] != ((byte)0));
        return result;
    }

    private static Object parseCellRangeFitText(byte[] value) {
        java.util.HashMap<String, Object> result = new java.util.HashMap<String, Object>();
        result.put("Range", new int[] {value[0], value[1]});
        result.put("FitText", value[2] != ((byte)0));
        return result;
    }

    private static Object parseCellRangeNoWrap(byte[] value) {
        java.util.HashMap<String, Object> result = new java.util.HashMap<String, Object>();
        result.put("Range", new int[] {value[0], value[1]});
        result.put("NoWrap", value[2] != ((byte)0));
        return result;
    }

    private static Object parseCellRangeTextFlow(byte[] value) {
        java.util.HashMap<String, Object> result = new java.util.HashMap<String, Object>();
        result.put("Range", new int[] {value[0], value[1]});
        result.put("TextFlow", java.nio.ByteBuffer.wrap(value, 2, 2).order(java.nio.ByteOrder.LITTLE_ENDIAN).getShort());
        return result;
    }

    private static Object parseCellRangeVertAlign(byte[] value) {
        java.util.HashMap<String, Object> result = new java.util.HashMap<String, Object>();
        result.put("Range", new int[] {value[0], value[1]});
        result.put("VertAlign", Byte.toUnsignedInt(value[2]));
        return result;
    }

    private static Object parseCFitTextOperand(byte[] value) {
        java.util.HashMap<String, Object> result = new java.util.HashMap<String, Object>();
        result.put("FitText", ((float)java.nio.ByteBuffer.wrap(value, 0, 4).order(java.nio.ByteOrder.LITTLE_ENDIAN).getInt()) * dxaConstant);
        result.put("FitTextID", java.nio.ByteBuffer.wrap(value, 2, 4).order(java.nio.ByteOrder.LITTLE_ENDIAN).getInt());
        return result;
    }

    private static Object parseCMajorityOperand(byte[] value) throws Exception, UnsupportedOperationException {
        try (com.pullenti.unisharp.MemoryStream ms = new com.pullenti.unisharp.MemoryStream(value)) {
            int read = 0;
            com.pullenti.unisharp.Outargwrapper<Integer> wrapread533 = new com.pullenti.unisharp.Outargwrapper<Integer>(read);
            Prl[] prls = BasicTypesReader.readPrls(ms, value.length, wrapread533);
            read = (wrapread533.value != null ? wrapread533.value : 0);
            java.util.HashMap<String, Object> result = new java.util.HashMap<String, Object>();
            for (Prl prl : prls) {
                String name = SinglePropertyModifiers.map.get(prl.sprm.sprm);
                result.put(name.substring(4), parseValue(Short.toUnsignedInt(prl.sprm.sprm), prl.operand));
            }
            return result;
        }
    }

    private static Object parseCNFOperand(byte[] value) throws Exception, java.io.IOException, UnsupportedOperationException {
        try (com.pullenti.unisharp.MemoryStream ms = new com.pullenti.unisharp.MemoryStream(value)) {
            int read = 0;
            java.util.HashMap<String, Object> result = new java.util.HashMap<String, Object>();
            com.pullenti.unisharp.Outargwrapper<Integer> wrapread535 = new com.pullenti.unisharp.Outargwrapper<Integer>(read);
            result.put("$FormattingCondition", Short.toUnsignedInt(java.nio.ByteBuffer.wrap(ReadUtils.readExactRef(ms, ReadUtils.wordSize, wrapread535), 0, 2).order(java.nio.ByteOrder.LITTLE_ENDIAN).getShort()));
            read = (wrapread535.value != null ? wrapread535.value : 0);
            com.pullenti.unisharp.Outargwrapper<Integer> wrapread534 = new com.pullenti.unisharp.Outargwrapper<Integer>(read);
            Prl[] prls = BasicTypesReader.readPrls(ms, value.length - read, wrapread534);
            read = (wrapread534.value != null ? wrapread534.value : 0);
            for (Prl prl : prls) {
                String name = SinglePropertyModifiers.map.get(prl.sprm.sprm);
                result.put(name.substring(4), parseValue(Short.toUnsignedInt(prl.sprm.sprm), prl.operand));
            }
            return result;
        }
    }

    private static Object parseCNS(byte[] value) {
        return Byte.toUnsignedInt(value[0]);
    }

    private static Object parseCOLORREF(byte[] value) {
        return ColorRef.fromBytes(value, 0);
    }

    private static Object parseCP(byte[] value) {
        return java.nio.ByteBuffer.wrap(value, 0, 4).order(java.nio.ByteOrder.LITTLE_ENDIAN).getInt();
    }

    private static Object parseCSSAOperand(byte[] value) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    private static Object parseCSymbolOperand(byte[] value) {
        java.util.HashMap<String, Object> result = new java.util.HashMap<String, Object>();
        result.put("FontIndex", Short.toUnsignedInt(java.nio.ByteBuffer.wrap(value, 0, 2).order(java.nio.ByteOrder.LITTLE_ENDIAN).getShort()));
        result.put("Symbol", (char)java.nio.ByteBuffer.wrap(value, 2, 2).order(java.nio.ByteOrder.LITTLE_ENDIAN).getShort());
        return result;
    }

    private static Object parseDCS(byte[] value) {
        java.util.HashMap<String, Object> result = new java.util.HashMap<String, Object>();
        result.put("DropCap", ((Byte.toUnsignedInt(value[0])) & 0x1F));
        result.put("DropLines", ((Byte.toUnsignedInt(value[0])) >>> 5));
        return result;
    }

    private static Object parseDefTableShd80Operand(byte[] value) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    private static Object parseDefTableShdOperand(byte[] value) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    private static Object parseDispFldRmOperand(byte[] value) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    private static Object parseDTTM(byte[] value) {
        return BasicTypesReader.parseDTTM(java.nio.ByteBuffer.wrap(value, 0, 4).order(java.nio.ByteOrder.LITTLE_ENDIAN).getInt());
    }

    private static Object parseFarEastLayoutOperand(byte[] value) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    private static Object parseFFM(byte[] value) {
        return Byte.toUnsignedInt(value[0]);
    }

    private static Object parseFrameTextFlowOperand(byte[] value) {
        java.util.HashMap<String, Object> result = new java.util.HashMap<String, Object>();
        result.put("Vertical", (((Byte.toUnsignedInt(value[0])) & 0x01)) != 0);
        result.put("Backwards", (((Byte.toUnsignedInt(value[0])) & 0x02)) != 0);
        result.put("RotateFont", (((Byte.toUnsignedInt(value[0])) & 0x04)) != 0);
        return result;
    }

    private static Object parseFtsWWidth_Indent(byte[] value) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    private static Object parseFtsWWidth_Table(byte[] value) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    private static Object parseFtsWWidth_TablePart(byte[] value) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    private static Object parseHresiOperand(byte[] value) {
        java.util.HashMap<String, Object> result = new java.util.HashMap<String, Object>();
        result.put("WordBreakingMethod", Byte.toUnsignedInt(value[0]));
        result.put("Character", (char)value[1]);
        return result;
    }

    private static Object parseIco(byte[] value) {
        return Byte.toUnsignedInt(value[0]);
    }

    private static Object parseInt16(byte[] value) {
        return java.nio.ByteBuffer.wrap(value, 0, 2).order(java.nio.ByteOrder.LITTLE_ENDIAN).getShort();
    }

    private static Object parseInt32(byte[] value) {
        return java.nio.ByteBuffer.wrap(value, 0, 4).order(java.nio.ByteOrder.LITTLE_ENDIAN).getInt();
    }

    private static Object parseItcFirstLim(byte[] value) {
        return new int[] {value[0], value[1]};
    }

    private static Object parseKul(byte[] value) {
        return Byte.toUnsignedInt(value[0]);
    }

    private static Object parseLBCOperand(byte[] value) {
        return Byte.toUnsignedInt(value[0]);
    }

    private static Object parseLID(byte[] value) {
        return Short.toUnsignedInt(java.nio.ByteBuffer.wrap(value, 0, 2).order(java.nio.ByteOrder.LITTLE_ENDIAN).getShort());
    }

    private static Object parseLSPD(byte[] value) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    private static Object parseMathPrOperand(byte[] value) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    private static Object parseMSONFC(byte[] value) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    private static Object parseMSOTXFL(byte[] value) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    private static Object parseNumRMOperand(byte[] value) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    private static Object parsePbiGrfOperand(byte[] value) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    private static Object parsePChgTabsOperand(byte[] value) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    private static Object parsePChgTabsPapxOperand(byte[] value) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    private static Object parsePositionCodeOperand(byte[] value) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    private static Object parsePropRMarkOperand(byte[] value) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    private static Object parsePTIstdInfoOperand(byte[] value) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    private static Object parseRnc(byte[] value) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    private static Object parseSBkcOperand(byte[] value) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    private static Object parseSBOrientationOperan(byte[] value) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    private static Object parseSByte(byte[] value) {
        return (byte)value[0];
    }

    private static Object parseSClmOperand(byte[] value) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    private static Object parseSDmBinOperand(byte[] value) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    private static Object parseSDxaColSpacingOperand(byte[] value) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    private static Object parseSDxaColWidthOperand(byte[] value) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    private static Object parseSFpcOperand(byte[] value) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    private static Object parseShd80(byte[] value) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    private static Object parseSHDOperand(byte[] value) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    private static Object parseSLncOperand(byte[] value) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    private static Object parseSPgbPropOperand(byte[] value) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    private static Object parseSPPOperand(byte[] value) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    private static Object parseTableBordersOperand(byte[] value) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    private static Object parseTableBordersOperand80(byte[] value) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    private static Object parseTableBrc80Operand(byte[] value) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    private static Object parseTableBrcOperand(byte[] value) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    private static Object parseTableCellWidthOperand(byte[] value) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    private static Object parseTableShadeOperand(byte[] value) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    private static Object parseTCellBrcTypeOperand(byte[] value) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    private static Object parseTDefTableOperand(byte[] value) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    private static Object parseTDxaColOperand(byte[] value) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    private static Object parseTInsertOperand(byte[] value) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    private static Object parseTLP(byte[] value) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    private static Object parseToggleOperand(byte[] value) {
        return ToggleOperand.of(Byte.toUnsignedInt(value[0]));
    }

    private static Object parseUInt16(byte[] value) {
        return java.nio.ByteBuffer.wrap(value, 0, 2).order(java.nio.ByteOrder.LITTLE_ENDIAN).getShort();
    }

    private static Object parseUInt32(byte[] value) {
        return java.nio.ByteBuffer.wrap(value, 0, 4).order(java.nio.ByteOrder.LITTLE_ENDIAN).getInt();
    }

    private static Object parseVerticalAlign(byte[] value) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    private static Object parseVertMergeOperand(byte[] value) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    private static Object parseVic(byte[] value) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    private static Object parseWHeightAbs(byte[] value) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    private static Object parseXAS(byte[] value) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    private static Object parseXAS_nonNeg(byte[] value) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    private static Object parseXAS_plusOne(byte[] value) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    private static Object parseYAS(byte[] value) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    private static Object parseYAS_nonNeg(byte[] value) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    private static Object parseYAS_plusOne(byte[] value) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }
    public SinglePropertyValue() {
    }
}
