All Downloads are FREE. Search and download functionalities are using the official Maven repository.

org.openxmlformats.schemas.wordprocessingml.x2006.main.impl.CTCompatImpl Maven / Gradle / Ivy

Go to download

XmlBeans generated from the Ecma supplied xsds: http://www.ecma-international.org/publications/files/ECMA-ST/Office%20Open%20XML%20Part%204%20(DOCX).zip

There is a newer version: 1.4
Show newest version
/*
 * XML Type:  CT_Compat
 * Namespace: http://schemas.openxmlformats.org/wordprocessingml/2006/main
 * Java type: org.openxmlformats.schemas.wordprocessingml.x2006.main.CTCompat
 *
 * Automatically generated - do not modify.
 */
package org.openxmlformats.schemas.wordprocessingml.x2006.main.impl;
/**
 * An XML CT_Compat(@http://schemas.openxmlformats.org/wordprocessingml/2006/main).
 *
 * This is a complex type.
 */
public class CTCompatImpl extends org.apache.xmlbeans.impl.values.XmlComplexContentImpl implements org.openxmlformats.schemas.wordprocessingml.x2006.main.CTCompat
{
    
    public CTCompatImpl(org.apache.xmlbeans.SchemaType sType)
    {
        super(sType);
    }
    
    private static final javax.xml.namespace.QName USESINGLEBORDERFORCONTIGUOUSCELLS$0 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "useSingleBorderforContiguousCells");
    private static final javax.xml.namespace.QName WPJUSTIFICATION$2 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "wpJustification");
    private static final javax.xml.namespace.QName NOTABHANGIND$4 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "noTabHangInd");
    private static final javax.xml.namespace.QName NOLEADING$6 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "noLeading");
    private static final javax.xml.namespace.QName SPACEFORUL$8 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "spaceForUL");
    private static final javax.xml.namespace.QName NOCOLUMNBALANCE$10 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "noColumnBalance");
    private static final javax.xml.namespace.QName BALANCESINGLEBYTEDOUBLEBYTEWIDTH$12 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "balanceSingleByteDoubleByteWidth");
    private static final javax.xml.namespace.QName NOEXTRALINESPACING$14 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "noExtraLineSpacing");
    private static final javax.xml.namespace.QName DONOTLEAVEBACKSLASHALONE$16 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "doNotLeaveBackslashAlone");
    private static final javax.xml.namespace.QName ULTRAILSPACE$18 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "ulTrailSpace");
    private static final javax.xml.namespace.QName DONOTEXPANDSHIFTRETURN$20 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "doNotExpandShiftReturn");
    private static final javax.xml.namespace.QName SPACINGINWHOLEPOINTS$22 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "spacingInWholePoints");
    private static final javax.xml.namespace.QName LINEWRAPLIKEWORD6$24 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "lineWrapLikeWord6");
    private static final javax.xml.namespace.QName PRINTBODYTEXTBEFOREHEADER$26 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "printBodyTextBeforeHeader");
    private static final javax.xml.namespace.QName PRINTCOLBLACK$28 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "printColBlack");
    private static final javax.xml.namespace.QName WPSPACEWIDTH$30 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "wpSpaceWidth");
    private static final javax.xml.namespace.QName SHOWBREAKSINFRAMES$32 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "showBreaksInFrames");
    private static final javax.xml.namespace.QName SUBFONTBYSIZE$34 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "subFontBySize");
    private static final javax.xml.namespace.QName SUPPRESSBOTTOMSPACING$36 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "suppressBottomSpacing");
    private static final javax.xml.namespace.QName SUPPRESSTOPSPACING$38 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "suppressTopSpacing");
    private static final javax.xml.namespace.QName SUPPRESSSPACINGATTOPOFPAGE$40 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "suppressSpacingAtTopOfPage");
    private static final javax.xml.namespace.QName SUPPRESSTOPSPACINGWP$42 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "suppressTopSpacingWP");
    private static final javax.xml.namespace.QName SUPPRESSSPBFAFTERPGBRK$44 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "suppressSpBfAfterPgBrk");
    private static final javax.xml.namespace.QName SWAPBORDERSFACINGPAGES$46 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "swapBordersFacingPages");
    private static final javax.xml.namespace.QName CONVMAILMERGEESC$48 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "convMailMergeEsc");
    private static final javax.xml.namespace.QName TRUNCATEFONTHEIGHTSLIKEWP6$50 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "truncateFontHeightsLikeWP6");
    private static final javax.xml.namespace.QName MWSMALLCAPS$52 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "mwSmallCaps");
    private static final javax.xml.namespace.QName USEPRINTERMETRICS$54 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "usePrinterMetrics");
    private static final javax.xml.namespace.QName DONOTSUPPRESSPARAGRAPHBORDERS$56 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "doNotSuppressParagraphBorders");
    private static final javax.xml.namespace.QName WRAPTRAILSPACES$58 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "wrapTrailSpaces");
    private static final javax.xml.namespace.QName FOOTNOTELAYOUTLIKEWW8$60 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "footnoteLayoutLikeWW8");
    private static final javax.xml.namespace.QName SHAPELAYOUTLIKEWW8$62 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "shapeLayoutLikeWW8");
    private static final javax.xml.namespace.QName ALIGNTABLESROWBYROW$64 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "alignTablesRowByRow");
    private static final javax.xml.namespace.QName FORGETLASTTABALIGNMENT$66 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "forgetLastTabAlignment");
    private static final javax.xml.namespace.QName ADJUSTLINEHEIGHTINTABLE$68 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "adjustLineHeightInTable");
    private static final javax.xml.namespace.QName AUTOSPACELIKEWORD95$70 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "autoSpaceLikeWord95");
    private static final javax.xml.namespace.QName NOSPACERAISELOWER$72 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "noSpaceRaiseLower");
    private static final javax.xml.namespace.QName DONOTUSEHTMLPARAGRAPHAUTOSPACING$74 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "doNotUseHTMLParagraphAutoSpacing");
    private static final javax.xml.namespace.QName LAYOUTRAWTABLEWIDTH$76 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "layoutRawTableWidth");
    private static final javax.xml.namespace.QName LAYOUTTABLEROWSAPART$78 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "layoutTableRowsApart");
    private static final javax.xml.namespace.QName USEWORD97LINEBREAKRULES$80 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "useWord97LineBreakRules");
    private static final javax.xml.namespace.QName DONOTBREAKWRAPPEDTABLES$82 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "doNotBreakWrappedTables");
    private static final javax.xml.namespace.QName DONOTSNAPTOGRIDINCELL$84 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "doNotSnapToGridInCell");
    private static final javax.xml.namespace.QName SELECTFLDWITHFIRSTORLASTCHAR$86 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "selectFldWithFirstOrLastChar");
    private static final javax.xml.namespace.QName APPLYBREAKINGRULES$88 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "applyBreakingRules");
    private static final javax.xml.namespace.QName DONOTWRAPTEXTWITHPUNCT$90 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "doNotWrapTextWithPunct");
    private static final javax.xml.namespace.QName DONOTUSEEASTASIANBREAKRULES$92 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "doNotUseEastAsianBreakRules");
    private static final javax.xml.namespace.QName USEWORD2002TABLESTYLERULES$94 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "useWord2002TableStyleRules");
    private static final javax.xml.namespace.QName GROWAUTOFIT$96 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "growAutofit");
    private static final javax.xml.namespace.QName USEFELAYOUT$98 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "useFELayout");
    private static final javax.xml.namespace.QName USENORMALSTYLEFORLIST$100 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "useNormalStyleForList");
    private static final javax.xml.namespace.QName DONOTUSEINDENTASNUMBERINGTABSTOP$102 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "doNotUseIndentAsNumberingTabStop");
    private static final javax.xml.namespace.QName USEALTKINSOKULINEBREAKRULES$104 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "useAltKinsokuLineBreakRules");
    private static final javax.xml.namespace.QName ALLOWSPACEOFSAMESTYLEINTABLE$106 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "allowSpaceOfSameStyleInTable");
    private static final javax.xml.namespace.QName DONOTSUPPRESSINDENTATION$108 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "doNotSuppressIndentation");
    private static final javax.xml.namespace.QName DONOTAUTOFITCONSTRAINEDTABLES$110 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "doNotAutofitConstrainedTables");
    private static final javax.xml.namespace.QName AUTOFITTOFIRSTFIXEDWIDTHCELL$112 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "autofitToFirstFixedWidthCell");
    private static final javax.xml.namespace.QName UNDERLINETABINNUMLIST$114 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "underlineTabInNumList");
    private static final javax.xml.namespace.QName DISPLAYHANGULFIXEDWIDTH$116 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "displayHangulFixedWidth");
    private static final javax.xml.namespace.QName SPLITPGBREAKANDPARAMARK$118 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "splitPgBreakAndParaMark");
    private static final javax.xml.namespace.QName DONOTVERTALIGNCELLWITHSP$120 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "doNotVertAlignCellWithSp");
    private static final javax.xml.namespace.QName DONOTBREAKCONSTRAINEDFORCEDTABLE$122 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "doNotBreakConstrainedForcedTable");
    private static final javax.xml.namespace.QName DONOTVERTALIGNINTXBX$124 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "doNotVertAlignInTxbx");
    private static final javax.xml.namespace.QName USEANSIKERNINGPAIRS$126 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "useAnsiKerningPairs");
    private static final javax.xml.namespace.QName CACHEDCOLBALANCE$128 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "cachedColBalance");
    
    
    /**
     * Gets the "useSingleBorderforContiguousCells" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getUseSingleBorderforContiguousCells()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(USESINGLEBORDERFORCONTIGUOUSCELLS$0, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "useSingleBorderforContiguousCells" element
     */
    public boolean isSetUseSingleBorderforContiguousCells()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(USESINGLEBORDERFORCONTIGUOUSCELLS$0) != 0;
        }
    }
    
    /**
     * Sets the "useSingleBorderforContiguousCells" element
     */
    public void setUseSingleBorderforContiguousCells(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff useSingleBorderforContiguousCells)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(USESINGLEBORDERFORCONTIGUOUSCELLS$0, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(USESINGLEBORDERFORCONTIGUOUSCELLS$0);
            }
            target.set(useSingleBorderforContiguousCells);
        }
    }
    
    /**
     * Appends and returns a new empty "useSingleBorderforContiguousCells" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewUseSingleBorderforContiguousCells()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(USESINGLEBORDERFORCONTIGUOUSCELLS$0);
            return target;
        }
    }
    
    /**
     * Unsets the "useSingleBorderforContiguousCells" element
     */
    public void unsetUseSingleBorderforContiguousCells()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(USESINGLEBORDERFORCONTIGUOUSCELLS$0, 0);
        }
    }
    
    /**
     * Gets the "wpJustification" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getWpJustification()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(WPJUSTIFICATION$2, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "wpJustification" element
     */
    public boolean isSetWpJustification()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(WPJUSTIFICATION$2) != 0;
        }
    }
    
    /**
     * Sets the "wpJustification" element
     */
    public void setWpJustification(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff wpJustification)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(WPJUSTIFICATION$2, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(WPJUSTIFICATION$2);
            }
            target.set(wpJustification);
        }
    }
    
    /**
     * Appends and returns a new empty "wpJustification" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewWpJustification()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(WPJUSTIFICATION$2);
            return target;
        }
    }
    
    /**
     * Unsets the "wpJustification" element
     */
    public void unsetWpJustification()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(WPJUSTIFICATION$2, 0);
        }
    }
    
    /**
     * Gets the "noTabHangInd" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getNoTabHangInd()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(NOTABHANGIND$4, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "noTabHangInd" element
     */
    public boolean isSetNoTabHangInd()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(NOTABHANGIND$4) != 0;
        }
    }
    
    /**
     * Sets the "noTabHangInd" element
     */
    public void setNoTabHangInd(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff noTabHangInd)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(NOTABHANGIND$4, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(NOTABHANGIND$4);
            }
            target.set(noTabHangInd);
        }
    }
    
    /**
     * Appends and returns a new empty "noTabHangInd" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewNoTabHangInd()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(NOTABHANGIND$4);
            return target;
        }
    }
    
    /**
     * Unsets the "noTabHangInd" element
     */
    public void unsetNoTabHangInd()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(NOTABHANGIND$4, 0);
        }
    }
    
    /**
     * Gets the "noLeading" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getNoLeading()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(NOLEADING$6, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "noLeading" element
     */
    public boolean isSetNoLeading()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(NOLEADING$6) != 0;
        }
    }
    
    /**
     * Sets the "noLeading" element
     */
    public void setNoLeading(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff noLeading)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(NOLEADING$6, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(NOLEADING$6);
            }
            target.set(noLeading);
        }
    }
    
    /**
     * Appends and returns a new empty "noLeading" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewNoLeading()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(NOLEADING$6);
            return target;
        }
    }
    
    /**
     * Unsets the "noLeading" element
     */
    public void unsetNoLeading()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(NOLEADING$6, 0);
        }
    }
    
    /**
     * Gets the "spaceForUL" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getSpaceForUL()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(SPACEFORUL$8, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "spaceForUL" element
     */
    public boolean isSetSpaceForUL()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SPACEFORUL$8) != 0;
        }
    }
    
    /**
     * Sets the "spaceForUL" element
     */
    public void setSpaceForUL(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff spaceForUL)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(SPACEFORUL$8, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(SPACEFORUL$8);
            }
            target.set(spaceForUL);
        }
    }
    
    /**
     * Appends and returns a new empty "spaceForUL" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewSpaceForUL()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(SPACEFORUL$8);
            return target;
        }
    }
    
    /**
     * Unsets the "spaceForUL" element
     */
    public void unsetSpaceForUL()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SPACEFORUL$8, 0);
        }
    }
    
    /**
     * Gets the "noColumnBalance" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getNoColumnBalance()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(NOCOLUMNBALANCE$10, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "noColumnBalance" element
     */
    public boolean isSetNoColumnBalance()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(NOCOLUMNBALANCE$10) != 0;
        }
    }
    
    /**
     * Sets the "noColumnBalance" element
     */
    public void setNoColumnBalance(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff noColumnBalance)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(NOCOLUMNBALANCE$10, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(NOCOLUMNBALANCE$10);
            }
            target.set(noColumnBalance);
        }
    }
    
    /**
     * Appends and returns a new empty "noColumnBalance" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewNoColumnBalance()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(NOCOLUMNBALANCE$10);
            return target;
        }
    }
    
    /**
     * Unsets the "noColumnBalance" element
     */
    public void unsetNoColumnBalance()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(NOCOLUMNBALANCE$10, 0);
        }
    }
    
    /**
     * Gets the "balanceSingleByteDoubleByteWidth" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getBalanceSingleByteDoubleByteWidth()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(BALANCESINGLEBYTEDOUBLEBYTEWIDTH$12, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "balanceSingleByteDoubleByteWidth" element
     */
    public boolean isSetBalanceSingleByteDoubleByteWidth()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(BALANCESINGLEBYTEDOUBLEBYTEWIDTH$12) != 0;
        }
    }
    
    /**
     * Sets the "balanceSingleByteDoubleByteWidth" element
     */
    public void setBalanceSingleByteDoubleByteWidth(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff balanceSingleByteDoubleByteWidth)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(BALANCESINGLEBYTEDOUBLEBYTEWIDTH$12, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(BALANCESINGLEBYTEDOUBLEBYTEWIDTH$12);
            }
            target.set(balanceSingleByteDoubleByteWidth);
        }
    }
    
    /**
     * Appends and returns a new empty "balanceSingleByteDoubleByteWidth" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewBalanceSingleByteDoubleByteWidth()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(BALANCESINGLEBYTEDOUBLEBYTEWIDTH$12);
            return target;
        }
    }
    
    /**
     * Unsets the "balanceSingleByteDoubleByteWidth" element
     */
    public void unsetBalanceSingleByteDoubleByteWidth()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(BALANCESINGLEBYTEDOUBLEBYTEWIDTH$12, 0);
        }
    }
    
    /**
     * Gets the "noExtraLineSpacing" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getNoExtraLineSpacing()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(NOEXTRALINESPACING$14, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "noExtraLineSpacing" element
     */
    public boolean isSetNoExtraLineSpacing()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(NOEXTRALINESPACING$14) != 0;
        }
    }
    
    /**
     * Sets the "noExtraLineSpacing" element
     */
    public void setNoExtraLineSpacing(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff noExtraLineSpacing)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(NOEXTRALINESPACING$14, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(NOEXTRALINESPACING$14);
            }
            target.set(noExtraLineSpacing);
        }
    }
    
    /**
     * Appends and returns a new empty "noExtraLineSpacing" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewNoExtraLineSpacing()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(NOEXTRALINESPACING$14);
            return target;
        }
    }
    
    /**
     * Unsets the "noExtraLineSpacing" element
     */
    public void unsetNoExtraLineSpacing()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(NOEXTRALINESPACING$14, 0);
        }
    }
    
    /**
     * Gets the "doNotLeaveBackslashAlone" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getDoNotLeaveBackslashAlone()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(DONOTLEAVEBACKSLASHALONE$16, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "doNotLeaveBackslashAlone" element
     */
    public boolean isSetDoNotLeaveBackslashAlone()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(DONOTLEAVEBACKSLASHALONE$16) != 0;
        }
    }
    
    /**
     * Sets the "doNotLeaveBackslashAlone" element
     */
    public void setDoNotLeaveBackslashAlone(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff doNotLeaveBackslashAlone)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(DONOTLEAVEBACKSLASHALONE$16, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(DONOTLEAVEBACKSLASHALONE$16);
            }
            target.set(doNotLeaveBackslashAlone);
        }
    }
    
    /**
     * Appends and returns a new empty "doNotLeaveBackslashAlone" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewDoNotLeaveBackslashAlone()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(DONOTLEAVEBACKSLASHALONE$16);
            return target;
        }
    }
    
    /**
     * Unsets the "doNotLeaveBackslashAlone" element
     */
    public void unsetDoNotLeaveBackslashAlone()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(DONOTLEAVEBACKSLASHALONE$16, 0);
        }
    }
    
    /**
     * Gets the "ulTrailSpace" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getUlTrailSpace()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(ULTRAILSPACE$18, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "ulTrailSpace" element
     */
    public boolean isSetUlTrailSpace()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(ULTRAILSPACE$18) != 0;
        }
    }
    
    /**
     * Sets the "ulTrailSpace" element
     */
    public void setUlTrailSpace(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff ulTrailSpace)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(ULTRAILSPACE$18, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(ULTRAILSPACE$18);
            }
            target.set(ulTrailSpace);
        }
    }
    
    /**
     * Appends and returns a new empty "ulTrailSpace" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewUlTrailSpace()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(ULTRAILSPACE$18);
            return target;
        }
    }
    
    /**
     * Unsets the "ulTrailSpace" element
     */
    public void unsetUlTrailSpace()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(ULTRAILSPACE$18, 0);
        }
    }
    
    /**
     * Gets the "doNotExpandShiftReturn" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getDoNotExpandShiftReturn()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(DONOTEXPANDSHIFTRETURN$20, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "doNotExpandShiftReturn" element
     */
    public boolean isSetDoNotExpandShiftReturn()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(DONOTEXPANDSHIFTRETURN$20) != 0;
        }
    }
    
    /**
     * Sets the "doNotExpandShiftReturn" element
     */
    public void setDoNotExpandShiftReturn(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff doNotExpandShiftReturn)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(DONOTEXPANDSHIFTRETURN$20, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(DONOTEXPANDSHIFTRETURN$20);
            }
            target.set(doNotExpandShiftReturn);
        }
    }
    
    /**
     * Appends and returns a new empty "doNotExpandShiftReturn" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewDoNotExpandShiftReturn()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(DONOTEXPANDSHIFTRETURN$20);
            return target;
        }
    }
    
    /**
     * Unsets the "doNotExpandShiftReturn" element
     */
    public void unsetDoNotExpandShiftReturn()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(DONOTEXPANDSHIFTRETURN$20, 0);
        }
    }
    
    /**
     * Gets the "spacingInWholePoints" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getSpacingInWholePoints()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(SPACINGINWHOLEPOINTS$22, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "spacingInWholePoints" element
     */
    public boolean isSetSpacingInWholePoints()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SPACINGINWHOLEPOINTS$22) != 0;
        }
    }
    
    /**
     * Sets the "spacingInWholePoints" element
     */
    public void setSpacingInWholePoints(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff spacingInWholePoints)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(SPACINGINWHOLEPOINTS$22, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(SPACINGINWHOLEPOINTS$22);
            }
            target.set(spacingInWholePoints);
        }
    }
    
    /**
     * Appends and returns a new empty "spacingInWholePoints" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewSpacingInWholePoints()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(SPACINGINWHOLEPOINTS$22);
            return target;
        }
    }
    
    /**
     * Unsets the "spacingInWholePoints" element
     */
    public void unsetSpacingInWholePoints()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SPACINGINWHOLEPOINTS$22, 0);
        }
    }
    
    /**
     * Gets the "lineWrapLikeWord6" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getLineWrapLikeWord6()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(LINEWRAPLIKEWORD6$24, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "lineWrapLikeWord6" element
     */
    public boolean isSetLineWrapLikeWord6()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(LINEWRAPLIKEWORD6$24) != 0;
        }
    }
    
    /**
     * Sets the "lineWrapLikeWord6" element
     */
    public void setLineWrapLikeWord6(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff lineWrapLikeWord6)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(LINEWRAPLIKEWORD6$24, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(LINEWRAPLIKEWORD6$24);
            }
            target.set(lineWrapLikeWord6);
        }
    }
    
    /**
     * Appends and returns a new empty "lineWrapLikeWord6" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewLineWrapLikeWord6()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(LINEWRAPLIKEWORD6$24);
            return target;
        }
    }
    
    /**
     * Unsets the "lineWrapLikeWord6" element
     */
    public void unsetLineWrapLikeWord6()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(LINEWRAPLIKEWORD6$24, 0);
        }
    }
    
    /**
     * Gets the "printBodyTextBeforeHeader" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getPrintBodyTextBeforeHeader()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(PRINTBODYTEXTBEFOREHEADER$26, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "printBodyTextBeforeHeader" element
     */
    public boolean isSetPrintBodyTextBeforeHeader()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(PRINTBODYTEXTBEFOREHEADER$26) != 0;
        }
    }
    
    /**
     * Sets the "printBodyTextBeforeHeader" element
     */
    public void setPrintBodyTextBeforeHeader(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff printBodyTextBeforeHeader)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(PRINTBODYTEXTBEFOREHEADER$26, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(PRINTBODYTEXTBEFOREHEADER$26);
            }
            target.set(printBodyTextBeforeHeader);
        }
    }
    
    /**
     * Appends and returns a new empty "printBodyTextBeforeHeader" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewPrintBodyTextBeforeHeader()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(PRINTBODYTEXTBEFOREHEADER$26);
            return target;
        }
    }
    
    /**
     * Unsets the "printBodyTextBeforeHeader" element
     */
    public void unsetPrintBodyTextBeforeHeader()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(PRINTBODYTEXTBEFOREHEADER$26, 0);
        }
    }
    
    /**
     * Gets the "printColBlack" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getPrintColBlack()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(PRINTCOLBLACK$28, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "printColBlack" element
     */
    public boolean isSetPrintColBlack()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(PRINTCOLBLACK$28) != 0;
        }
    }
    
    /**
     * Sets the "printColBlack" element
     */
    public void setPrintColBlack(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff printColBlack)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(PRINTCOLBLACK$28, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(PRINTCOLBLACK$28);
            }
            target.set(printColBlack);
        }
    }
    
    /**
     * Appends and returns a new empty "printColBlack" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewPrintColBlack()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(PRINTCOLBLACK$28);
            return target;
        }
    }
    
    /**
     * Unsets the "printColBlack" element
     */
    public void unsetPrintColBlack()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(PRINTCOLBLACK$28, 0);
        }
    }
    
    /**
     * Gets the "wpSpaceWidth" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getWpSpaceWidth()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(WPSPACEWIDTH$30, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "wpSpaceWidth" element
     */
    public boolean isSetWpSpaceWidth()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(WPSPACEWIDTH$30) != 0;
        }
    }
    
    /**
     * Sets the "wpSpaceWidth" element
     */
    public void setWpSpaceWidth(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff wpSpaceWidth)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(WPSPACEWIDTH$30, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(WPSPACEWIDTH$30);
            }
            target.set(wpSpaceWidth);
        }
    }
    
    /**
     * Appends and returns a new empty "wpSpaceWidth" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewWpSpaceWidth()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(WPSPACEWIDTH$30);
            return target;
        }
    }
    
    /**
     * Unsets the "wpSpaceWidth" element
     */
    public void unsetWpSpaceWidth()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(WPSPACEWIDTH$30, 0);
        }
    }
    
    /**
     * Gets the "showBreaksInFrames" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getShowBreaksInFrames()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(SHOWBREAKSINFRAMES$32, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "showBreaksInFrames" element
     */
    public boolean isSetShowBreaksInFrames()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SHOWBREAKSINFRAMES$32) != 0;
        }
    }
    
    /**
     * Sets the "showBreaksInFrames" element
     */
    public void setShowBreaksInFrames(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff showBreaksInFrames)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(SHOWBREAKSINFRAMES$32, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(SHOWBREAKSINFRAMES$32);
            }
            target.set(showBreaksInFrames);
        }
    }
    
    /**
     * Appends and returns a new empty "showBreaksInFrames" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewShowBreaksInFrames()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(SHOWBREAKSINFRAMES$32);
            return target;
        }
    }
    
    /**
     * Unsets the "showBreaksInFrames" element
     */
    public void unsetShowBreaksInFrames()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SHOWBREAKSINFRAMES$32, 0);
        }
    }
    
    /**
     * Gets the "subFontBySize" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getSubFontBySize()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(SUBFONTBYSIZE$34, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "subFontBySize" element
     */
    public boolean isSetSubFontBySize()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SUBFONTBYSIZE$34) != 0;
        }
    }
    
    /**
     * Sets the "subFontBySize" element
     */
    public void setSubFontBySize(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff subFontBySize)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(SUBFONTBYSIZE$34, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(SUBFONTBYSIZE$34);
            }
            target.set(subFontBySize);
        }
    }
    
    /**
     * Appends and returns a new empty "subFontBySize" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewSubFontBySize()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(SUBFONTBYSIZE$34);
            return target;
        }
    }
    
    /**
     * Unsets the "subFontBySize" element
     */
    public void unsetSubFontBySize()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SUBFONTBYSIZE$34, 0);
        }
    }
    
    /**
     * Gets the "suppressBottomSpacing" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getSuppressBottomSpacing()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(SUPPRESSBOTTOMSPACING$36, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "suppressBottomSpacing" element
     */
    public boolean isSetSuppressBottomSpacing()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SUPPRESSBOTTOMSPACING$36) != 0;
        }
    }
    
    /**
     * Sets the "suppressBottomSpacing" element
     */
    public void setSuppressBottomSpacing(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff suppressBottomSpacing)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(SUPPRESSBOTTOMSPACING$36, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(SUPPRESSBOTTOMSPACING$36);
            }
            target.set(suppressBottomSpacing);
        }
    }
    
    /**
     * Appends and returns a new empty "suppressBottomSpacing" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewSuppressBottomSpacing()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(SUPPRESSBOTTOMSPACING$36);
            return target;
        }
    }
    
    /**
     * Unsets the "suppressBottomSpacing" element
     */
    public void unsetSuppressBottomSpacing()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SUPPRESSBOTTOMSPACING$36, 0);
        }
    }
    
    /**
     * Gets the "suppressTopSpacing" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getSuppressTopSpacing()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(SUPPRESSTOPSPACING$38, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "suppressTopSpacing" element
     */
    public boolean isSetSuppressTopSpacing()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SUPPRESSTOPSPACING$38) != 0;
        }
    }
    
    /**
     * Sets the "suppressTopSpacing" element
     */
    public void setSuppressTopSpacing(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff suppressTopSpacing)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(SUPPRESSTOPSPACING$38, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(SUPPRESSTOPSPACING$38);
            }
            target.set(suppressTopSpacing);
        }
    }
    
    /**
     * Appends and returns a new empty "suppressTopSpacing" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewSuppressTopSpacing()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(SUPPRESSTOPSPACING$38);
            return target;
        }
    }
    
    /**
     * Unsets the "suppressTopSpacing" element
     */
    public void unsetSuppressTopSpacing()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SUPPRESSTOPSPACING$38, 0);
        }
    }
    
    /**
     * Gets the "suppressSpacingAtTopOfPage" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getSuppressSpacingAtTopOfPage()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(SUPPRESSSPACINGATTOPOFPAGE$40, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "suppressSpacingAtTopOfPage" element
     */
    public boolean isSetSuppressSpacingAtTopOfPage()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SUPPRESSSPACINGATTOPOFPAGE$40) != 0;
        }
    }
    
    /**
     * Sets the "suppressSpacingAtTopOfPage" element
     */
    public void setSuppressSpacingAtTopOfPage(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff suppressSpacingAtTopOfPage)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(SUPPRESSSPACINGATTOPOFPAGE$40, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(SUPPRESSSPACINGATTOPOFPAGE$40);
            }
            target.set(suppressSpacingAtTopOfPage);
        }
    }
    
    /**
     * Appends and returns a new empty "suppressSpacingAtTopOfPage" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewSuppressSpacingAtTopOfPage()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(SUPPRESSSPACINGATTOPOFPAGE$40);
            return target;
        }
    }
    
    /**
     * Unsets the "suppressSpacingAtTopOfPage" element
     */
    public void unsetSuppressSpacingAtTopOfPage()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SUPPRESSSPACINGATTOPOFPAGE$40, 0);
        }
    }
    
    /**
     * Gets the "suppressTopSpacingWP" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getSuppressTopSpacingWP()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(SUPPRESSTOPSPACINGWP$42, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "suppressTopSpacingWP" element
     */
    public boolean isSetSuppressTopSpacingWP()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SUPPRESSTOPSPACINGWP$42) != 0;
        }
    }
    
    /**
     * Sets the "suppressTopSpacingWP" element
     */
    public void setSuppressTopSpacingWP(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff suppressTopSpacingWP)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(SUPPRESSTOPSPACINGWP$42, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(SUPPRESSTOPSPACINGWP$42);
            }
            target.set(suppressTopSpacingWP);
        }
    }
    
    /**
     * Appends and returns a new empty "suppressTopSpacingWP" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewSuppressTopSpacingWP()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(SUPPRESSTOPSPACINGWP$42);
            return target;
        }
    }
    
    /**
     * Unsets the "suppressTopSpacingWP" element
     */
    public void unsetSuppressTopSpacingWP()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SUPPRESSTOPSPACINGWP$42, 0);
        }
    }
    
    /**
     * Gets the "suppressSpBfAfterPgBrk" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getSuppressSpBfAfterPgBrk()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(SUPPRESSSPBFAFTERPGBRK$44, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "suppressSpBfAfterPgBrk" element
     */
    public boolean isSetSuppressSpBfAfterPgBrk()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SUPPRESSSPBFAFTERPGBRK$44) != 0;
        }
    }
    
    /**
     * Sets the "suppressSpBfAfterPgBrk" element
     */
    public void setSuppressSpBfAfterPgBrk(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff suppressSpBfAfterPgBrk)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(SUPPRESSSPBFAFTERPGBRK$44, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(SUPPRESSSPBFAFTERPGBRK$44);
            }
            target.set(suppressSpBfAfterPgBrk);
        }
    }
    
    /**
     * Appends and returns a new empty "suppressSpBfAfterPgBrk" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewSuppressSpBfAfterPgBrk()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(SUPPRESSSPBFAFTERPGBRK$44);
            return target;
        }
    }
    
    /**
     * Unsets the "suppressSpBfAfterPgBrk" element
     */
    public void unsetSuppressSpBfAfterPgBrk()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SUPPRESSSPBFAFTERPGBRK$44, 0);
        }
    }
    
    /**
     * Gets the "swapBordersFacingPages" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getSwapBordersFacingPages()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(SWAPBORDERSFACINGPAGES$46, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "swapBordersFacingPages" element
     */
    public boolean isSetSwapBordersFacingPages()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SWAPBORDERSFACINGPAGES$46) != 0;
        }
    }
    
    /**
     * Sets the "swapBordersFacingPages" element
     */
    public void setSwapBordersFacingPages(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff swapBordersFacingPages)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(SWAPBORDERSFACINGPAGES$46, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(SWAPBORDERSFACINGPAGES$46);
            }
            target.set(swapBordersFacingPages);
        }
    }
    
    /**
     * Appends and returns a new empty "swapBordersFacingPages" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewSwapBordersFacingPages()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(SWAPBORDERSFACINGPAGES$46);
            return target;
        }
    }
    
    /**
     * Unsets the "swapBordersFacingPages" element
     */
    public void unsetSwapBordersFacingPages()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SWAPBORDERSFACINGPAGES$46, 0);
        }
    }
    
    /**
     * Gets the "convMailMergeEsc" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getConvMailMergeEsc()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(CONVMAILMERGEESC$48, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "convMailMergeEsc" element
     */
    public boolean isSetConvMailMergeEsc()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(CONVMAILMERGEESC$48) != 0;
        }
    }
    
    /**
     * Sets the "convMailMergeEsc" element
     */
    public void setConvMailMergeEsc(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff convMailMergeEsc)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(CONVMAILMERGEESC$48, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(CONVMAILMERGEESC$48);
            }
            target.set(convMailMergeEsc);
        }
    }
    
    /**
     * Appends and returns a new empty "convMailMergeEsc" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewConvMailMergeEsc()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(CONVMAILMERGEESC$48);
            return target;
        }
    }
    
    /**
     * Unsets the "convMailMergeEsc" element
     */
    public void unsetConvMailMergeEsc()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(CONVMAILMERGEESC$48, 0);
        }
    }
    
    /**
     * Gets the "truncateFontHeightsLikeWP6" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getTruncateFontHeightsLikeWP6()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(TRUNCATEFONTHEIGHTSLIKEWP6$50, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "truncateFontHeightsLikeWP6" element
     */
    public boolean isSetTruncateFontHeightsLikeWP6()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(TRUNCATEFONTHEIGHTSLIKEWP6$50) != 0;
        }
    }
    
    /**
     * Sets the "truncateFontHeightsLikeWP6" element
     */
    public void setTruncateFontHeightsLikeWP6(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff truncateFontHeightsLikeWP6)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(TRUNCATEFONTHEIGHTSLIKEWP6$50, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(TRUNCATEFONTHEIGHTSLIKEWP6$50);
            }
            target.set(truncateFontHeightsLikeWP6);
        }
    }
    
    /**
     * Appends and returns a new empty "truncateFontHeightsLikeWP6" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewTruncateFontHeightsLikeWP6()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(TRUNCATEFONTHEIGHTSLIKEWP6$50);
            return target;
        }
    }
    
    /**
     * Unsets the "truncateFontHeightsLikeWP6" element
     */
    public void unsetTruncateFontHeightsLikeWP6()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(TRUNCATEFONTHEIGHTSLIKEWP6$50, 0);
        }
    }
    
    /**
     * Gets the "mwSmallCaps" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getMwSmallCaps()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(MWSMALLCAPS$52, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "mwSmallCaps" element
     */
    public boolean isSetMwSmallCaps()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(MWSMALLCAPS$52) != 0;
        }
    }
    
    /**
     * Sets the "mwSmallCaps" element
     */
    public void setMwSmallCaps(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff mwSmallCaps)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(MWSMALLCAPS$52, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(MWSMALLCAPS$52);
            }
            target.set(mwSmallCaps);
        }
    }
    
    /**
     * Appends and returns a new empty "mwSmallCaps" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewMwSmallCaps()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(MWSMALLCAPS$52);
            return target;
        }
    }
    
    /**
     * Unsets the "mwSmallCaps" element
     */
    public void unsetMwSmallCaps()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(MWSMALLCAPS$52, 0);
        }
    }
    
    /**
     * Gets the "usePrinterMetrics" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getUsePrinterMetrics()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(USEPRINTERMETRICS$54, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "usePrinterMetrics" element
     */
    public boolean isSetUsePrinterMetrics()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(USEPRINTERMETRICS$54) != 0;
        }
    }
    
    /**
     * Sets the "usePrinterMetrics" element
     */
    public void setUsePrinterMetrics(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff usePrinterMetrics)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(USEPRINTERMETRICS$54, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(USEPRINTERMETRICS$54);
            }
            target.set(usePrinterMetrics);
        }
    }
    
    /**
     * Appends and returns a new empty "usePrinterMetrics" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewUsePrinterMetrics()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(USEPRINTERMETRICS$54);
            return target;
        }
    }
    
    /**
     * Unsets the "usePrinterMetrics" element
     */
    public void unsetUsePrinterMetrics()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(USEPRINTERMETRICS$54, 0);
        }
    }
    
    /**
     * Gets the "doNotSuppressParagraphBorders" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getDoNotSuppressParagraphBorders()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(DONOTSUPPRESSPARAGRAPHBORDERS$56, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "doNotSuppressParagraphBorders" element
     */
    public boolean isSetDoNotSuppressParagraphBorders()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(DONOTSUPPRESSPARAGRAPHBORDERS$56) != 0;
        }
    }
    
    /**
     * Sets the "doNotSuppressParagraphBorders" element
     */
    public void setDoNotSuppressParagraphBorders(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff doNotSuppressParagraphBorders)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(DONOTSUPPRESSPARAGRAPHBORDERS$56, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(DONOTSUPPRESSPARAGRAPHBORDERS$56);
            }
            target.set(doNotSuppressParagraphBorders);
        }
    }
    
    /**
     * Appends and returns a new empty "doNotSuppressParagraphBorders" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewDoNotSuppressParagraphBorders()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(DONOTSUPPRESSPARAGRAPHBORDERS$56);
            return target;
        }
    }
    
    /**
     * Unsets the "doNotSuppressParagraphBorders" element
     */
    public void unsetDoNotSuppressParagraphBorders()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(DONOTSUPPRESSPARAGRAPHBORDERS$56, 0);
        }
    }
    
    /**
     * Gets the "wrapTrailSpaces" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getWrapTrailSpaces()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(WRAPTRAILSPACES$58, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "wrapTrailSpaces" element
     */
    public boolean isSetWrapTrailSpaces()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(WRAPTRAILSPACES$58) != 0;
        }
    }
    
    /**
     * Sets the "wrapTrailSpaces" element
     */
    public void setWrapTrailSpaces(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff wrapTrailSpaces)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(WRAPTRAILSPACES$58, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(WRAPTRAILSPACES$58);
            }
            target.set(wrapTrailSpaces);
        }
    }
    
    /**
     * Appends and returns a new empty "wrapTrailSpaces" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewWrapTrailSpaces()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(WRAPTRAILSPACES$58);
            return target;
        }
    }
    
    /**
     * Unsets the "wrapTrailSpaces" element
     */
    public void unsetWrapTrailSpaces()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(WRAPTRAILSPACES$58, 0);
        }
    }
    
    /**
     * Gets the "footnoteLayoutLikeWW8" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getFootnoteLayoutLikeWW8()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(FOOTNOTELAYOUTLIKEWW8$60, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "footnoteLayoutLikeWW8" element
     */
    public boolean isSetFootnoteLayoutLikeWW8()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(FOOTNOTELAYOUTLIKEWW8$60) != 0;
        }
    }
    
    /**
     * Sets the "footnoteLayoutLikeWW8" element
     */
    public void setFootnoteLayoutLikeWW8(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff footnoteLayoutLikeWW8)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(FOOTNOTELAYOUTLIKEWW8$60, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(FOOTNOTELAYOUTLIKEWW8$60);
            }
            target.set(footnoteLayoutLikeWW8);
        }
    }
    
    /**
     * Appends and returns a new empty "footnoteLayoutLikeWW8" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewFootnoteLayoutLikeWW8()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(FOOTNOTELAYOUTLIKEWW8$60);
            return target;
        }
    }
    
    /**
     * Unsets the "footnoteLayoutLikeWW8" element
     */
    public void unsetFootnoteLayoutLikeWW8()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(FOOTNOTELAYOUTLIKEWW8$60, 0);
        }
    }
    
    /**
     * Gets the "shapeLayoutLikeWW8" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getShapeLayoutLikeWW8()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(SHAPELAYOUTLIKEWW8$62, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "shapeLayoutLikeWW8" element
     */
    public boolean isSetShapeLayoutLikeWW8()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SHAPELAYOUTLIKEWW8$62) != 0;
        }
    }
    
    /**
     * Sets the "shapeLayoutLikeWW8" element
     */
    public void setShapeLayoutLikeWW8(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff shapeLayoutLikeWW8)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(SHAPELAYOUTLIKEWW8$62, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(SHAPELAYOUTLIKEWW8$62);
            }
            target.set(shapeLayoutLikeWW8);
        }
    }
    
    /**
     * Appends and returns a new empty "shapeLayoutLikeWW8" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewShapeLayoutLikeWW8()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(SHAPELAYOUTLIKEWW8$62);
            return target;
        }
    }
    
    /**
     * Unsets the "shapeLayoutLikeWW8" element
     */
    public void unsetShapeLayoutLikeWW8()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SHAPELAYOUTLIKEWW8$62, 0);
        }
    }
    
    /**
     * Gets the "alignTablesRowByRow" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getAlignTablesRowByRow()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(ALIGNTABLESROWBYROW$64, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "alignTablesRowByRow" element
     */
    public boolean isSetAlignTablesRowByRow()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(ALIGNTABLESROWBYROW$64) != 0;
        }
    }
    
    /**
     * Sets the "alignTablesRowByRow" element
     */
    public void setAlignTablesRowByRow(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff alignTablesRowByRow)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(ALIGNTABLESROWBYROW$64, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(ALIGNTABLESROWBYROW$64);
            }
            target.set(alignTablesRowByRow);
        }
    }
    
    /**
     * Appends and returns a new empty "alignTablesRowByRow" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewAlignTablesRowByRow()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(ALIGNTABLESROWBYROW$64);
            return target;
        }
    }
    
    /**
     * Unsets the "alignTablesRowByRow" element
     */
    public void unsetAlignTablesRowByRow()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(ALIGNTABLESROWBYROW$64, 0);
        }
    }
    
    /**
     * Gets the "forgetLastTabAlignment" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getForgetLastTabAlignment()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(FORGETLASTTABALIGNMENT$66, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "forgetLastTabAlignment" element
     */
    public boolean isSetForgetLastTabAlignment()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(FORGETLASTTABALIGNMENT$66) != 0;
        }
    }
    
    /**
     * Sets the "forgetLastTabAlignment" element
     */
    public void setForgetLastTabAlignment(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff forgetLastTabAlignment)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(FORGETLASTTABALIGNMENT$66, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(FORGETLASTTABALIGNMENT$66);
            }
            target.set(forgetLastTabAlignment);
        }
    }
    
    /**
     * Appends and returns a new empty "forgetLastTabAlignment" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewForgetLastTabAlignment()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(FORGETLASTTABALIGNMENT$66);
            return target;
        }
    }
    
    /**
     * Unsets the "forgetLastTabAlignment" element
     */
    public void unsetForgetLastTabAlignment()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(FORGETLASTTABALIGNMENT$66, 0);
        }
    }
    
    /**
     * Gets the "adjustLineHeightInTable" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getAdjustLineHeightInTable()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(ADJUSTLINEHEIGHTINTABLE$68, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "adjustLineHeightInTable" element
     */
    public boolean isSetAdjustLineHeightInTable()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(ADJUSTLINEHEIGHTINTABLE$68) != 0;
        }
    }
    
    /**
     * Sets the "adjustLineHeightInTable" element
     */
    public void setAdjustLineHeightInTable(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff adjustLineHeightInTable)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(ADJUSTLINEHEIGHTINTABLE$68, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(ADJUSTLINEHEIGHTINTABLE$68);
            }
            target.set(adjustLineHeightInTable);
        }
    }
    
    /**
     * Appends and returns a new empty "adjustLineHeightInTable" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewAdjustLineHeightInTable()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(ADJUSTLINEHEIGHTINTABLE$68);
            return target;
        }
    }
    
    /**
     * Unsets the "adjustLineHeightInTable" element
     */
    public void unsetAdjustLineHeightInTable()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(ADJUSTLINEHEIGHTINTABLE$68, 0);
        }
    }
    
    /**
     * Gets the "autoSpaceLikeWord95" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getAutoSpaceLikeWord95()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(AUTOSPACELIKEWORD95$70, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "autoSpaceLikeWord95" element
     */
    public boolean isSetAutoSpaceLikeWord95()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(AUTOSPACELIKEWORD95$70) != 0;
        }
    }
    
    /**
     * Sets the "autoSpaceLikeWord95" element
     */
    public void setAutoSpaceLikeWord95(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff autoSpaceLikeWord95)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(AUTOSPACELIKEWORD95$70, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(AUTOSPACELIKEWORD95$70);
            }
            target.set(autoSpaceLikeWord95);
        }
    }
    
    /**
     * Appends and returns a new empty "autoSpaceLikeWord95" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewAutoSpaceLikeWord95()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(AUTOSPACELIKEWORD95$70);
            return target;
        }
    }
    
    /**
     * Unsets the "autoSpaceLikeWord95" element
     */
    public void unsetAutoSpaceLikeWord95()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(AUTOSPACELIKEWORD95$70, 0);
        }
    }
    
    /**
     * Gets the "noSpaceRaiseLower" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getNoSpaceRaiseLower()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(NOSPACERAISELOWER$72, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "noSpaceRaiseLower" element
     */
    public boolean isSetNoSpaceRaiseLower()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(NOSPACERAISELOWER$72) != 0;
        }
    }
    
    /**
     * Sets the "noSpaceRaiseLower" element
     */
    public void setNoSpaceRaiseLower(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff noSpaceRaiseLower)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(NOSPACERAISELOWER$72, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(NOSPACERAISELOWER$72);
            }
            target.set(noSpaceRaiseLower);
        }
    }
    
    /**
     * Appends and returns a new empty "noSpaceRaiseLower" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewNoSpaceRaiseLower()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(NOSPACERAISELOWER$72);
            return target;
        }
    }
    
    /**
     * Unsets the "noSpaceRaiseLower" element
     */
    public void unsetNoSpaceRaiseLower()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(NOSPACERAISELOWER$72, 0);
        }
    }
    
    /**
     * Gets the "doNotUseHTMLParagraphAutoSpacing" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getDoNotUseHTMLParagraphAutoSpacing()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(DONOTUSEHTMLPARAGRAPHAUTOSPACING$74, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "doNotUseHTMLParagraphAutoSpacing" element
     */
    public boolean isSetDoNotUseHTMLParagraphAutoSpacing()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(DONOTUSEHTMLPARAGRAPHAUTOSPACING$74) != 0;
        }
    }
    
    /**
     * Sets the "doNotUseHTMLParagraphAutoSpacing" element
     */
    public void setDoNotUseHTMLParagraphAutoSpacing(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff doNotUseHTMLParagraphAutoSpacing)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(DONOTUSEHTMLPARAGRAPHAUTOSPACING$74, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(DONOTUSEHTMLPARAGRAPHAUTOSPACING$74);
            }
            target.set(doNotUseHTMLParagraphAutoSpacing);
        }
    }
    
    /**
     * Appends and returns a new empty "doNotUseHTMLParagraphAutoSpacing" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewDoNotUseHTMLParagraphAutoSpacing()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(DONOTUSEHTMLPARAGRAPHAUTOSPACING$74);
            return target;
        }
    }
    
    /**
     * Unsets the "doNotUseHTMLParagraphAutoSpacing" element
     */
    public void unsetDoNotUseHTMLParagraphAutoSpacing()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(DONOTUSEHTMLPARAGRAPHAUTOSPACING$74, 0);
        }
    }
    
    /**
     * Gets the "layoutRawTableWidth" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getLayoutRawTableWidth()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(LAYOUTRAWTABLEWIDTH$76, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "layoutRawTableWidth" element
     */
    public boolean isSetLayoutRawTableWidth()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(LAYOUTRAWTABLEWIDTH$76) != 0;
        }
    }
    
    /**
     * Sets the "layoutRawTableWidth" element
     */
    public void setLayoutRawTableWidth(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff layoutRawTableWidth)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(LAYOUTRAWTABLEWIDTH$76, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(LAYOUTRAWTABLEWIDTH$76);
            }
            target.set(layoutRawTableWidth);
        }
    }
    
    /**
     * Appends and returns a new empty "layoutRawTableWidth" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewLayoutRawTableWidth()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(LAYOUTRAWTABLEWIDTH$76);
            return target;
        }
    }
    
    /**
     * Unsets the "layoutRawTableWidth" element
     */
    public void unsetLayoutRawTableWidth()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(LAYOUTRAWTABLEWIDTH$76, 0);
        }
    }
    
    /**
     * Gets the "layoutTableRowsApart" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getLayoutTableRowsApart()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(LAYOUTTABLEROWSAPART$78, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "layoutTableRowsApart" element
     */
    public boolean isSetLayoutTableRowsApart()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(LAYOUTTABLEROWSAPART$78) != 0;
        }
    }
    
    /**
     * Sets the "layoutTableRowsApart" element
     */
    public void setLayoutTableRowsApart(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff layoutTableRowsApart)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(LAYOUTTABLEROWSAPART$78, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(LAYOUTTABLEROWSAPART$78);
            }
            target.set(layoutTableRowsApart);
        }
    }
    
    /**
     * Appends and returns a new empty "layoutTableRowsApart" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewLayoutTableRowsApart()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(LAYOUTTABLEROWSAPART$78);
            return target;
        }
    }
    
    /**
     * Unsets the "layoutTableRowsApart" element
     */
    public void unsetLayoutTableRowsApart()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(LAYOUTTABLEROWSAPART$78, 0);
        }
    }
    
    /**
     * Gets the "useWord97LineBreakRules" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getUseWord97LineBreakRules()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(USEWORD97LINEBREAKRULES$80, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "useWord97LineBreakRules" element
     */
    public boolean isSetUseWord97LineBreakRules()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(USEWORD97LINEBREAKRULES$80) != 0;
        }
    }
    
    /**
     * Sets the "useWord97LineBreakRules" element
     */
    public void setUseWord97LineBreakRules(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff useWord97LineBreakRules)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(USEWORD97LINEBREAKRULES$80, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(USEWORD97LINEBREAKRULES$80);
            }
            target.set(useWord97LineBreakRules);
        }
    }
    
    /**
     * Appends and returns a new empty "useWord97LineBreakRules" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewUseWord97LineBreakRules()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(USEWORD97LINEBREAKRULES$80);
            return target;
        }
    }
    
    /**
     * Unsets the "useWord97LineBreakRules" element
     */
    public void unsetUseWord97LineBreakRules()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(USEWORD97LINEBREAKRULES$80, 0);
        }
    }
    
    /**
     * Gets the "doNotBreakWrappedTables" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getDoNotBreakWrappedTables()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(DONOTBREAKWRAPPEDTABLES$82, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "doNotBreakWrappedTables" element
     */
    public boolean isSetDoNotBreakWrappedTables()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(DONOTBREAKWRAPPEDTABLES$82) != 0;
        }
    }
    
    /**
     * Sets the "doNotBreakWrappedTables" element
     */
    public void setDoNotBreakWrappedTables(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff doNotBreakWrappedTables)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(DONOTBREAKWRAPPEDTABLES$82, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(DONOTBREAKWRAPPEDTABLES$82);
            }
            target.set(doNotBreakWrappedTables);
        }
    }
    
    /**
     * Appends and returns a new empty "doNotBreakWrappedTables" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewDoNotBreakWrappedTables()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(DONOTBREAKWRAPPEDTABLES$82);
            return target;
        }
    }
    
    /**
     * Unsets the "doNotBreakWrappedTables" element
     */
    public void unsetDoNotBreakWrappedTables()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(DONOTBREAKWRAPPEDTABLES$82, 0);
        }
    }
    
    /**
     * Gets the "doNotSnapToGridInCell" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getDoNotSnapToGridInCell()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(DONOTSNAPTOGRIDINCELL$84, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "doNotSnapToGridInCell" element
     */
    public boolean isSetDoNotSnapToGridInCell()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(DONOTSNAPTOGRIDINCELL$84) != 0;
        }
    }
    
    /**
     * Sets the "doNotSnapToGridInCell" element
     */
    public void setDoNotSnapToGridInCell(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff doNotSnapToGridInCell)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(DONOTSNAPTOGRIDINCELL$84, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(DONOTSNAPTOGRIDINCELL$84);
            }
            target.set(doNotSnapToGridInCell);
        }
    }
    
    /**
     * Appends and returns a new empty "doNotSnapToGridInCell" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewDoNotSnapToGridInCell()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(DONOTSNAPTOGRIDINCELL$84);
            return target;
        }
    }
    
    /**
     * Unsets the "doNotSnapToGridInCell" element
     */
    public void unsetDoNotSnapToGridInCell()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(DONOTSNAPTOGRIDINCELL$84, 0);
        }
    }
    
    /**
     * Gets the "selectFldWithFirstOrLastChar" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getSelectFldWithFirstOrLastChar()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(SELECTFLDWITHFIRSTORLASTCHAR$86, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "selectFldWithFirstOrLastChar" element
     */
    public boolean isSetSelectFldWithFirstOrLastChar()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SELECTFLDWITHFIRSTORLASTCHAR$86) != 0;
        }
    }
    
    /**
     * Sets the "selectFldWithFirstOrLastChar" element
     */
    public void setSelectFldWithFirstOrLastChar(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff selectFldWithFirstOrLastChar)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(SELECTFLDWITHFIRSTORLASTCHAR$86, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(SELECTFLDWITHFIRSTORLASTCHAR$86);
            }
            target.set(selectFldWithFirstOrLastChar);
        }
    }
    
    /**
     * Appends and returns a new empty "selectFldWithFirstOrLastChar" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewSelectFldWithFirstOrLastChar()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(SELECTFLDWITHFIRSTORLASTCHAR$86);
            return target;
        }
    }
    
    /**
     * Unsets the "selectFldWithFirstOrLastChar" element
     */
    public void unsetSelectFldWithFirstOrLastChar()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SELECTFLDWITHFIRSTORLASTCHAR$86, 0);
        }
    }
    
    /**
     * Gets the "applyBreakingRules" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getApplyBreakingRules()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(APPLYBREAKINGRULES$88, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "applyBreakingRules" element
     */
    public boolean isSetApplyBreakingRules()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(APPLYBREAKINGRULES$88) != 0;
        }
    }
    
    /**
     * Sets the "applyBreakingRules" element
     */
    public void setApplyBreakingRules(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff applyBreakingRules)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(APPLYBREAKINGRULES$88, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(APPLYBREAKINGRULES$88);
            }
            target.set(applyBreakingRules);
        }
    }
    
    /**
     * Appends and returns a new empty "applyBreakingRules" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewApplyBreakingRules()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(APPLYBREAKINGRULES$88);
            return target;
        }
    }
    
    /**
     * Unsets the "applyBreakingRules" element
     */
    public void unsetApplyBreakingRules()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(APPLYBREAKINGRULES$88, 0);
        }
    }
    
    /**
     * Gets the "doNotWrapTextWithPunct" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getDoNotWrapTextWithPunct()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(DONOTWRAPTEXTWITHPUNCT$90, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "doNotWrapTextWithPunct" element
     */
    public boolean isSetDoNotWrapTextWithPunct()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(DONOTWRAPTEXTWITHPUNCT$90) != 0;
        }
    }
    
    /**
     * Sets the "doNotWrapTextWithPunct" element
     */
    public void setDoNotWrapTextWithPunct(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff doNotWrapTextWithPunct)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(DONOTWRAPTEXTWITHPUNCT$90, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(DONOTWRAPTEXTWITHPUNCT$90);
            }
            target.set(doNotWrapTextWithPunct);
        }
    }
    
    /**
     * Appends and returns a new empty "doNotWrapTextWithPunct" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewDoNotWrapTextWithPunct()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(DONOTWRAPTEXTWITHPUNCT$90);
            return target;
        }
    }
    
    /**
     * Unsets the "doNotWrapTextWithPunct" element
     */
    public void unsetDoNotWrapTextWithPunct()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(DONOTWRAPTEXTWITHPUNCT$90, 0);
        }
    }
    
    /**
     * Gets the "doNotUseEastAsianBreakRules" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getDoNotUseEastAsianBreakRules()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(DONOTUSEEASTASIANBREAKRULES$92, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "doNotUseEastAsianBreakRules" element
     */
    public boolean isSetDoNotUseEastAsianBreakRules()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(DONOTUSEEASTASIANBREAKRULES$92) != 0;
        }
    }
    
    /**
     * Sets the "doNotUseEastAsianBreakRules" element
     */
    public void setDoNotUseEastAsianBreakRules(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff doNotUseEastAsianBreakRules)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(DONOTUSEEASTASIANBREAKRULES$92, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(DONOTUSEEASTASIANBREAKRULES$92);
            }
            target.set(doNotUseEastAsianBreakRules);
        }
    }
    
    /**
     * Appends and returns a new empty "doNotUseEastAsianBreakRules" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewDoNotUseEastAsianBreakRules()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(DONOTUSEEASTASIANBREAKRULES$92);
            return target;
        }
    }
    
    /**
     * Unsets the "doNotUseEastAsianBreakRules" element
     */
    public void unsetDoNotUseEastAsianBreakRules()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(DONOTUSEEASTASIANBREAKRULES$92, 0);
        }
    }
    
    /**
     * Gets the "useWord2002TableStyleRules" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getUseWord2002TableStyleRules()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(USEWORD2002TABLESTYLERULES$94, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "useWord2002TableStyleRules" element
     */
    public boolean isSetUseWord2002TableStyleRules()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(USEWORD2002TABLESTYLERULES$94) != 0;
        }
    }
    
    /**
     * Sets the "useWord2002TableStyleRules" element
     */
    public void setUseWord2002TableStyleRules(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff useWord2002TableStyleRules)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(USEWORD2002TABLESTYLERULES$94, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(USEWORD2002TABLESTYLERULES$94);
            }
            target.set(useWord2002TableStyleRules);
        }
    }
    
    /**
     * Appends and returns a new empty "useWord2002TableStyleRules" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewUseWord2002TableStyleRules()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(USEWORD2002TABLESTYLERULES$94);
            return target;
        }
    }
    
    /**
     * Unsets the "useWord2002TableStyleRules" element
     */
    public void unsetUseWord2002TableStyleRules()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(USEWORD2002TABLESTYLERULES$94, 0);
        }
    }
    
    /**
     * Gets the "growAutofit" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getGrowAutofit()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(GROWAUTOFIT$96, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "growAutofit" element
     */
    public boolean isSetGrowAutofit()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(GROWAUTOFIT$96) != 0;
        }
    }
    
    /**
     * Sets the "growAutofit" element
     */
    public void setGrowAutofit(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff growAutofit)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(GROWAUTOFIT$96, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(GROWAUTOFIT$96);
            }
            target.set(growAutofit);
        }
    }
    
    /**
     * Appends and returns a new empty "growAutofit" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewGrowAutofit()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(GROWAUTOFIT$96);
            return target;
        }
    }
    
    /**
     * Unsets the "growAutofit" element
     */
    public void unsetGrowAutofit()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(GROWAUTOFIT$96, 0);
        }
    }
    
    /**
     * Gets the "useFELayout" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getUseFELayout()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(USEFELAYOUT$98, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "useFELayout" element
     */
    public boolean isSetUseFELayout()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(USEFELAYOUT$98) != 0;
        }
    }
    
    /**
     * Sets the "useFELayout" element
     */
    public void setUseFELayout(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff useFELayout)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(USEFELAYOUT$98, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(USEFELAYOUT$98);
            }
            target.set(useFELayout);
        }
    }
    
    /**
     * Appends and returns a new empty "useFELayout" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewUseFELayout()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(USEFELAYOUT$98);
            return target;
        }
    }
    
    /**
     * Unsets the "useFELayout" element
     */
    public void unsetUseFELayout()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(USEFELAYOUT$98, 0);
        }
    }
    
    /**
     * Gets the "useNormalStyleForList" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getUseNormalStyleForList()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(USENORMALSTYLEFORLIST$100, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "useNormalStyleForList" element
     */
    public boolean isSetUseNormalStyleForList()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(USENORMALSTYLEFORLIST$100) != 0;
        }
    }
    
    /**
     * Sets the "useNormalStyleForList" element
     */
    public void setUseNormalStyleForList(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff useNormalStyleForList)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(USENORMALSTYLEFORLIST$100, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(USENORMALSTYLEFORLIST$100);
            }
            target.set(useNormalStyleForList);
        }
    }
    
    /**
     * Appends and returns a new empty "useNormalStyleForList" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewUseNormalStyleForList()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(USENORMALSTYLEFORLIST$100);
            return target;
        }
    }
    
    /**
     * Unsets the "useNormalStyleForList" element
     */
    public void unsetUseNormalStyleForList()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(USENORMALSTYLEFORLIST$100, 0);
        }
    }
    
    /**
     * Gets the "doNotUseIndentAsNumberingTabStop" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getDoNotUseIndentAsNumberingTabStop()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(DONOTUSEINDENTASNUMBERINGTABSTOP$102, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "doNotUseIndentAsNumberingTabStop" element
     */
    public boolean isSetDoNotUseIndentAsNumberingTabStop()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(DONOTUSEINDENTASNUMBERINGTABSTOP$102) != 0;
        }
    }
    
    /**
     * Sets the "doNotUseIndentAsNumberingTabStop" element
     */
    public void setDoNotUseIndentAsNumberingTabStop(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff doNotUseIndentAsNumberingTabStop)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(DONOTUSEINDENTASNUMBERINGTABSTOP$102, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(DONOTUSEINDENTASNUMBERINGTABSTOP$102);
            }
            target.set(doNotUseIndentAsNumberingTabStop);
        }
    }
    
    /**
     * Appends and returns a new empty "doNotUseIndentAsNumberingTabStop" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewDoNotUseIndentAsNumberingTabStop()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(DONOTUSEINDENTASNUMBERINGTABSTOP$102);
            return target;
        }
    }
    
    /**
     * Unsets the "doNotUseIndentAsNumberingTabStop" element
     */
    public void unsetDoNotUseIndentAsNumberingTabStop()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(DONOTUSEINDENTASNUMBERINGTABSTOP$102, 0);
        }
    }
    
    /**
     * Gets the "useAltKinsokuLineBreakRules" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getUseAltKinsokuLineBreakRules()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(USEALTKINSOKULINEBREAKRULES$104, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "useAltKinsokuLineBreakRules" element
     */
    public boolean isSetUseAltKinsokuLineBreakRules()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(USEALTKINSOKULINEBREAKRULES$104) != 0;
        }
    }
    
    /**
     * Sets the "useAltKinsokuLineBreakRules" element
     */
    public void setUseAltKinsokuLineBreakRules(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff useAltKinsokuLineBreakRules)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(USEALTKINSOKULINEBREAKRULES$104, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(USEALTKINSOKULINEBREAKRULES$104);
            }
            target.set(useAltKinsokuLineBreakRules);
        }
    }
    
    /**
     * Appends and returns a new empty "useAltKinsokuLineBreakRules" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewUseAltKinsokuLineBreakRules()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(USEALTKINSOKULINEBREAKRULES$104);
            return target;
        }
    }
    
    /**
     * Unsets the "useAltKinsokuLineBreakRules" element
     */
    public void unsetUseAltKinsokuLineBreakRules()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(USEALTKINSOKULINEBREAKRULES$104, 0);
        }
    }
    
    /**
     * Gets the "allowSpaceOfSameStyleInTable" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getAllowSpaceOfSameStyleInTable()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(ALLOWSPACEOFSAMESTYLEINTABLE$106, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "allowSpaceOfSameStyleInTable" element
     */
    public boolean isSetAllowSpaceOfSameStyleInTable()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(ALLOWSPACEOFSAMESTYLEINTABLE$106) != 0;
        }
    }
    
    /**
     * Sets the "allowSpaceOfSameStyleInTable" element
     */
    public void setAllowSpaceOfSameStyleInTable(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff allowSpaceOfSameStyleInTable)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(ALLOWSPACEOFSAMESTYLEINTABLE$106, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(ALLOWSPACEOFSAMESTYLEINTABLE$106);
            }
            target.set(allowSpaceOfSameStyleInTable);
        }
    }
    
    /**
     * Appends and returns a new empty "allowSpaceOfSameStyleInTable" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewAllowSpaceOfSameStyleInTable()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(ALLOWSPACEOFSAMESTYLEINTABLE$106);
            return target;
        }
    }
    
    /**
     * Unsets the "allowSpaceOfSameStyleInTable" element
     */
    public void unsetAllowSpaceOfSameStyleInTable()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(ALLOWSPACEOFSAMESTYLEINTABLE$106, 0);
        }
    }
    
    /**
     * Gets the "doNotSuppressIndentation" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getDoNotSuppressIndentation()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(DONOTSUPPRESSINDENTATION$108, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "doNotSuppressIndentation" element
     */
    public boolean isSetDoNotSuppressIndentation()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(DONOTSUPPRESSINDENTATION$108) != 0;
        }
    }
    
    /**
     * Sets the "doNotSuppressIndentation" element
     */
    public void setDoNotSuppressIndentation(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff doNotSuppressIndentation)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(DONOTSUPPRESSINDENTATION$108, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(DONOTSUPPRESSINDENTATION$108);
            }
            target.set(doNotSuppressIndentation);
        }
    }
    
    /**
     * Appends and returns a new empty "doNotSuppressIndentation" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewDoNotSuppressIndentation()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(DONOTSUPPRESSINDENTATION$108);
            return target;
        }
    }
    
    /**
     * Unsets the "doNotSuppressIndentation" element
     */
    public void unsetDoNotSuppressIndentation()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(DONOTSUPPRESSINDENTATION$108, 0);
        }
    }
    
    /**
     * Gets the "doNotAutofitConstrainedTables" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getDoNotAutofitConstrainedTables()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(DONOTAUTOFITCONSTRAINEDTABLES$110, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "doNotAutofitConstrainedTables" element
     */
    public boolean isSetDoNotAutofitConstrainedTables()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(DONOTAUTOFITCONSTRAINEDTABLES$110) != 0;
        }
    }
    
    /**
     * Sets the "doNotAutofitConstrainedTables" element
     */
    public void setDoNotAutofitConstrainedTables(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff doNotAutofitConstrainedTables)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(DONOTAUTOFITCONSTRAINEDTABLES$110, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(DONOTAUTOFITCONSTRAINEDTABLES$110);
            }
            target.set(doNotAutofitConstrainedTables);
        }
    }
    
    /**
     * Appends and returns a new empty "doNotAutofitConstrainedTables" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewDoNotAutofitConstrainedTables()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(DONOTAUTOFITCONSTRAINEDTABLES$110);
            return target;
        }
    }
    
    /**
     * Unsets the "doNotAutofitConstrainedTables" element
     */
    public void unsetDoNotAutofitConstrainedTables()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(DONOTAUTOFITCONSTRAINEDTABLES$110, 0);
        }
    }
    
    /**
     * Gets the "autofitToFirstFixedWidthCell" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getAutofitToFirstFixedWidthCell()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(AUTOFITTOFIRSTFIXEDWIDTHCELL$112, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "autofitToFirstFixedWidthCell" element
     */
    public boolean isSetAutofitToFirstFixedWidthCell()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(AUTOFITTOFIRSTFIXEDWIDTHCELL$112) != 0;
        }
    }
    
    /**
     * Sets the "autofitToFirstFixedWidthCell" element
     */
    public void setAutofitToFirstFixedWidthCell(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff autofitToFirstFixedWidthCell)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(AUTOFITTOFIRSTFIXEDWIDTHCELL$112, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(AUTOFITTOFIRSTFIXEDWIDTHCELL$112);
            }
            target.set(autofitToFirstFixedWidthCell);
        }
    }
    
    /**
     * Appends and returns a new empty "autofitToFirstFixedWidthCell" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewAutofitToFirstFixedWidthCell()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(AUTOFITTOFIRSTFIXEDWIDTHCELL$112);
            return target;
        }
    }
    
    /**
     * Unsets the "autofitToFirstFixedWidthCell" element
     */
    public void unsetAutofitToFirstFixedWidthCell()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(AUTOFITTOFIRSTFIXEDWIDTHCELL$112, 0);
        }
    }
    
    /**
     * Gets the "underlineTabInNumList" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getUnderlineTabInNumList()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(UNDERLINETABINNUMLIST$114, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "underlineTabInNumList" element
     */
    public boolean isSetUnderlineTabInNumList()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(UNDERLINETABINNUMLIST$114) != 0;
        }
    }
    
    /**
     * Sets the "underlineTabInNumList" element
     */
    public void setUnderlineTabInNumList(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff underlineTabInNumList)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(UNDERLINETABINNUMLIST$114, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(UNDERLINETABINNUMLIST$114);
            }
            target.set(underlineTabInNumList);
        }
    }
    
    /**
     * Appends and returns a new empty "underlineTabInNumList" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewUnderlineTabInNumList()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(UNDERLINETABINNUMLIST$114);
            return target;
        }
    }
    
    /**
     * Unsets the "underlineTabInNumList" element
     */
    public void unsetUnderlineTabInNumList()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(UNDERLINETABINNUMLIST$114, 0);
        }
    }
    
    /**
     * Gets the "displayHangulFixedWidth" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getDisplayHangulFixedWidth()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(DISPLAYHANGULFIXEDWIDTH$116, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "displayHangulFixedWidth" element
     */
    public boolean isSetDisplayHangulFixedWidth()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(DISPLAYHANGULFIXEDWIDTH$116) != 0;
        }
    }
    
    /**
     * Sets the "displayHangulFixedWidth" element
     */
    public void setDisplayHangulFixedWidth(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff displayHangulFixedWidth)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(DISPLAYHANGULFIXEDWIDTH$116, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(DISPLAYHANGULFIXEDWIDTH$116);
            }
            target.set(displayHangulFixedWidth);
        }
    }
    
    /**
     * Appends and returns a new empty "displayHangulFixedWidth" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewDisplayHangulFixedWidth()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(DISPLAYHANGULFIXEDWIDTH$116);
            return target;
        }
    }
    
    /**
     * Unsets the "displayHangulFixedWidth" element
     */
    public void unsetDisplayHangulFixedWidth()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(DISPLAYHANGULFIXEDWIDTH$116, 0);
        }
    }
    
    /**
     * Gets the "splitPgBreakAndParaMark" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getSplitPgBreakAndParaMark()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(SPLITPGBREAKANDPARAMARK$118, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "splitPgBreakAndParaMark" element
     */
    public boolean isSetSplitPgBreakAndParaMark()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SPLITPGBREAKANDPARAMARK$118) != 0;
        }
    }
    
    /**
     * Sets the "splitPgBreakAndParaMark" element
     */
    public void setSplitPgBreakAndParaMark(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff splitPgBreakAndParaMark)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(SPLITPGBREAKANDPARAMARK$118, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(SPLITPGBREAKANDPARAMARK$118);
            }
            target.set(splitPgBreakAndParaMark);
        }
    }
    
    /**
     * Appends and returns a new empty "splitPgBreakAndParaMark" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewSplitPgBreakAndParaMark()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(SPLITPGBREAKANDPARAMARK$118);
            return target;
        }
    }
    
    /**
     * Unsets the "splitPgBreakAndParaMark" element
     */
    public void unsetSplitPgBreakAndParaMark()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SPLITPGBREAKANDPARAMARK$118, 0);
        }
    }
    
    /**
     * Gets the "doNotVertAlignCellWithSp" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getDoNotVertAlignCellWithSp()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(DONOTVERTALIGNCELLWITHSP$120, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "doNotVertAlignCellWithSp" element
     */
    public boolean isSetDoNotVertAlignCellWithSp()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(DONOTVERTALIGNCELLWITHSP$120) != 0;
        }
    }
    
    /**
     * Sets the "doNotVertAlignCellWithSp" element
     */
    public void setDoNotVertAlignCellWithSp(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff doNotVertAlignCellWithSp)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(DONOTVERTALIGNCELLWITHSP$120, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(DONOTVERTALIGNCELLWITHSP$120);
            }
            target.set(doNotVertAlignCellWithSp);
        }
    }
    
    /**
     * Appends and returns a new empty "doNotVertAlignCellWithSp" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewDoNotVertAlignCellWithSp()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(DONOTVERTALIGNCELLWITHSP$120);
            return target;
        }
    }
    
    /**
     * Unsets the "doNotVertAlignCellWithSp" element
     */
    public void unsetDoNotVertAlignCellWithSp()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(DONOTVERTALIGNCELLWITHSP$120, 0);
        }
    }
    
    /**
     * Gets the "doNotBreakConstrainedForcedTable" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getDoNotBreakConstrainedForcedTable()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(DONOTBREAKCONSTRAINEDFORCEDTABLE$122, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "doNotBreakConstrainedForcedTable" element
     */
    public boolean isSetDoNotBreakConstrainedForcedTable()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(DONOTBREAKCONSTRAINEDFORCEDTABLE$122) != 0;
        }
    }
    
    /**
     * Sets the "doNotBreakConstrainedForcedTable" element
     */
    public void setDoNotBreakConstrainedForcedTable(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff doNotBreakConstrainedForcedTable)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(DONOTBREAKCONSTRAINEDFORCEDTABLE$122, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(DONOTBREAKCONSTRAINEDFORCEDTABLE$122);
            }
            target.set(doNotBreakConstrainedForcedTable);
        }
    }
    
    /**
     * Appends and returns a new empty "doNotBreakConstrainedForcedTable" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewDoNotBreakConstrainedForcedTable()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(DONOTBREAKCONSTRAINEDFORCEDTABLE$122);
            return target;
        }
    }
    
    /**
     * Unsets the "doNotBreakConstrainedForcedTable" element
     */
    public void unsetDoNotBreakConstrainedForcedTable()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(DONOTBREAKCONSTRAINEDFORCEDTABLE$122, 0);
        }
    }
    
    /**
     * Gets the "doNotVertAlignInTxbx" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getDoNotVertAlignInTxbx()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(DONOTVERTALIGNINTXBX$124, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "doNotVertAlignInTxbx" element
     */
    public boolean isSetDoNotVertAlignInTxbx()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(DONOTVERTALIGNINTXBX$124) != 0;
        }
    }
    
    /**
     * Sets the "doNotVertAlignInTxbx" element
     */
    public void setDoNotVertAlignInTxbx(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff doNotVertAlignInTxbx)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(DONOTVERTALIGNINTXBX$124, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(DONOTVERTALIGNINTXBX$124);
            }
            target.set(doNotVertAlignInTxbx);
        }
    }
    
    /**
     * Appends and returns a new empty "doNotVertAlignInTxbx" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewDoNotVertAlignInTxbx()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(DONOTVERTALIGNINTXBX$124);
            return target;
        }
    }
    
    /**
     * Unsets the "doNotVertAlignInTxbx" element
     */
    public void unsetDoNotVertAlignInTxbx()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(DONOTVERTALIGNINTXBX$124, 0);
        }
    }
    
    /**
     * Gets the "useAnsiKerningPairs" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getUseAnsiKerningPairs()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(USEANSIKERNINGPAIRS$126, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "useAnsiKerningPairs" element
     */
    public boolean isSetUseAnsiKerningPairs()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(USEANSIKERNINGPAIRS$126) != 0;
        }
    }
    
    /**
     * Sets the "useAnsiKerningPairs" element
     */
    public void setUseAnsiKerningPairs(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff useAnsiKerningPairs)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(USEANSIKERNINGPAIRS$126, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(USEANSIKERNINGPAIRS$126);
            }
            target.set(useAnsiKerningPairs);
        }
    }
    
    /**
     * Appends and returns a new empty "useAnsiKerningPairs" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewUseAnsiKerningPairs()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(USEANSIKERNINGPAIRS$126);
            return target;
        }
    }
    
    /**
     * Unsets the "useAnsiKerningPairs" element
     */
    public void unsetUseAnsiKerningPairs()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(USEANSIKERNINGPAIRS$126, 0);
        }
    }
    
    /**
     * Gets the "cachedColBalance" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getCachedColBalance()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(CACHEDCOLBALANCE$128, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "cachedColBalance" element
     */
    public boolean isSetCachedColBalance()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(CACHEDCOLBALANCE$128) != 0;
        }
    }
    
    /**
     * Sets the "cachedColBalance" element
     */
    public void setCachedColBalance(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff cachedColBalance)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(CACHEDCOLBALANCE$128, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(CACHEDCOLBALANCE$128);
            }
            target.set(cachedColBalance);
        }
    }
    
    /**
     * Appends and returns a new empty "cachedColBalance" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewCachedColBalance()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(CACHEDCOLBALANCE$128);
            return target;
        }
    }
    
    /**
     * Unsets the "cachedColBalance" element
     */
    public void unsetCachedColBalance()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(CACHEDCOLBALANCE$128, 0);
        }
    }
}




© 2015 - 2024 Weber Informatics LLC | Privacy Policy