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

org.openxmlformats.schemas.wordprocessingml.x2006.main.impl.CTRunTrackChangeImpl 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_RunTrackChange
 * Namespace: http://schemas.openxmlformats.org/wordprocessingml/2006/main
 * Java type: org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange
 *
 * Automatically generated - do not modify.
 */
package org.openxmlformats.schemas.wordprocessingml.x2006.main.impl;
/**
 * An XML CT_RunTrackChange(@http://schemas.openxmlformats.org/wordprocessingml/2006/main).
 *
 * This is a complex type.
 */
public class CTRunTrackChangeImpl extends org.openxmlformats.schemas.wordprocessingml.x2006.main.impl.CTTrackChangeImpl implements org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange
{
    
    public CTRunTrackChangeImpl(org.apache.xmlbeans.SchemaType sType)
    {
        super(sType);
    }
    
    private static final javax.xml.namespace.QName CUSTOMXML$0 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "customXml");
    private static final javax.xml.namespace.QName SMARTTAG$2 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "smartTag");
    private static final javax.xml.namespace.QName SDT$4 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "sdt");
    private static final javax.xml.namespace.QName R$6 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "r");
    private static final javax.xml.namespace.QName PROOFERR$8 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "proofErr");
    private static final javax.xml.namespace.QName PERMSTART$10 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "permStart");
    private static final javax.xml.namespace.QName PERMEND$12 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "permEnd");
    private static final javax.xml.namespace.QName BOOKMARKSTART$14 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "bookmarkStart");
    private static final javax.xml.namespace.QName BOOKMARKEND$16 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "bookmarkEnd");
    private static final javax.xml.namespace.QName MOVEFROMRANGESTART$18 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "moveFromRangeStart");
    private static final javax.xml.namespace.QName MOVEFROMRANGEEND$20 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "moveFromRangeEnd");
    private static final javax.xml.namespace.QName MOVETORANGESTART$22 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "moveToRangeStart");
    private static final javax.xml.namespace.QName MOVETORANGEEND$24 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "moveToRangeEnd");
    private static final javax.xml.namespace.QName COMMENTRANGESTART$26 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "commentRangeStart");
    private static final javax.xml.namespace.QName COMMENTRANGEEND$28 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "commentRangeEnd");
    private static final javax.xml.namespace.QName CUSTOMXMLINSRANGESTART$30 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "customXmlInsRangeStart");
    private static final javax.xml.namespace.QName CUSTOMXMLINSRANGEEND$32 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "customXmlInsRangeEnd");
    private static final javax.xml.namespace.QName CUSTOMXMLDELRANGESTART$34 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "customXmlDelRangeStart");
    private static final javax.xml.namespace.QName CUSTOMXMLDELRANGEEND$36 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "customXmlDelRangeEnd");
    private static final javax.xml.namespace.QName CUSTOMXMLMOVEFROMRANGESTART$38 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "customXmlMoveFromRangeStart");
    private static final javax.xml.namespace.QName CUSTOMXMLMOVEFROMRANGEEND$40 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "customXmlMoveFromRangeEnd");
    private static final javax.xml.namespace.QName CUSTOMXMLMOVETORANGESTART$42 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "customXmlMoveToRangeStart");
    private static final javax.xml.namespace.QName CUSTOMXMLMOVETORANGEEND$44 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "customXmlMoveToRangeEnd");
    private static final javax.xml.namespace.QName INS$46 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "ins");
    private static final javax.xml.namespace.QName DEL$48 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "del");
    private static final javax.xml.namespace.QName MOVEFROM$50 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "moveFrom");
    private static final javax.xml.namespace.QName MOVETO$52 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "moveTo");
    private static final javax.xml.namespace.QName OMATHPARA$54 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/officeDocument/2006/math", "oMathPara");
    private static final javax.xml.namespace.QName OMATH$56 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/officeDocument/2006/math", "oMath");
    private static final javax.xml.namespace.QName ACC$58 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/officeDocument/2006/math", "acc");
    private static final javax.xml.namespace.QName BAR$60 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/officeDocument/2006/math", "bar");
    private static final javax.xml.namespace.QName BOX$62 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/officeDocument/2006/math", "box");
    private static final javax.xml.namespace.QName BORDERBOX$64 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/officeDocument/2006/math", "borderBox");
    private static final javax.xml.namespace.QName D$66 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/officeDocument/2006/math", "d");
    private static final javax.xml.namespace.QName EQARR$68 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/officeDocument/2006/math", "eqArr");
    private static final javax.xml.namespace.QName F$70 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/officeDocument/2006/math", "f");
    private static final javax.xml.namespace.QName FUNC$72 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/officeDocument/2006/math", "func");
    private static final javax.xml.namespace.QName GROUPCHR$74 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/officeDocument/2006/math", "groupChr");
    private static final javax.xml.namespace.QName LIMLOW$76 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/officeDocument/2006/math", "limLow");
    private static final javax.xml.namespace.QName LIMUPP$78 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/officeDocument/2006/math", "limUpp");
    private static final javax.xml.namespace.QName M$80 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/officeDocument/2006/math", "m");
    private static final javax.xml.namespace.QName NARY$82 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/officeDocument/2006/math", "nary");
    private static final javax.xml.namespace.QName PHANT$84 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/officeDocument/2006/math", "phant");
    private static final javax.xml.namespace.QName RAD$86 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/officeDocument/2006/math", "rad");
    private static final javax.xml.namespace.QName SPRE$88 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/officeDocument/2006/math", "sPre");
    private static final javax.xml.namespace.QName SSUB$90 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/officeDocument/2006/math", "sSub");
    private static final javax.xml.namespace.QName SSUBSUP$92 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/officeDocument/2006/math", "sSubSup");
    private static final javax.xml.namespace.QName SSUP$94 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/officeDocument/2006/math", "sSup");
    private static final javax.xml.namespace.QName R2$96 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/officeDocument/2006/math", "r");
    
    
    /**
     * Gets a List of "customXml" elements
     */
    public java.util.List getCustomXmlList()
    {
        final class CustomXmlList extends java.util.AbstractList
        {
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTCustomXmlRun get(int i)
                { return CTRunTrackChangeImpl.this.getCustomXmlArray(i); }
            
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTCustomXmlRun set(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTCustomXmlRun o)
            {
                org.openxmlformats.schemas.wordprocessingml.x2006.main.CTCustomXmlRun old = CTRunTrackChangeImpl.this.getCustomXmlArray(i);
                CTRunTrackChangeImpl.this.setCustomXmlArray(i, o);
                return old;
            }
            
            public void add(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTCustomXmlRun o)
                { CTRunTrackChangeImpl.this.insertNewCustomXml(i).set(o); }
            
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTCustomXmlRun remove(int i)
            {
                org.openxmlformats.schemas.wordprocessingml.x2006.main.CTCustomXmlRun old = CTRunTrackChangeImpl.this.getCustomXmlArray(i);
                CTRunTrackChangeImpl.this.removeCustomXml(i);
                return old;
            }
            
            public int size()
                { return CTRunTrackChangeImpl.this.sizeOfCustomXmlArray(); }
            
        }
        
        synchronized (monitor())
        {
            check_orphaned();
            return new CustomXmlList();
        }
    }
    
    /**
     * Gets array of all "customXml" elements
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTCustomXmlRun[] getCustomXmlArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(CUSTOMXML$0, targetList);
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTCustomXmlRun[] result = new org.openxmlformats.schemas.wordprocessingml.x2006.main.CTCustomXmlRun[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "customXml" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTCustomXmlRun getCustomXmlArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTCustomXmlRun target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTCustomXmlRun)get_store().find_element_user(CUSTOMXML$0, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "customXml" element
     */
    public int sizeOfCustomXmlArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(CUSTOMXML$0);
        }
    }
    
    /**
     * Sets array of all "customXml" element
     */
    public void setCustomXmlArray(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTCustomXmlRun[] customXmlArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(customXmlArray, CUSTOMXML$0);
        }
    }
    
    /**
     * Sets ith "customXml" element
     */
    public void setCustomXmlArray(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTCustomXmlRun customXml)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTCustomXmlRun target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTCustomXmlRun)get_store().find_element_user(CUSTOMXML$0, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(customXml);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "customXml" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTCustomXmlRun insertNewCustomXml(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTCustomXmlRun target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTCustomXmlRun)get_store().insert_element_user(CUSTOMXML$0, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "customXml" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTCustomXmlRun addNewCustomXml()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTCustomXmlRun target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTCustomXmlRun)get_store().add_element_user(CUSTOMXML$0);
            return target;
        }
    }
    
    /**
     * Removes the ith "customXml" element
     */
    public void removeCustomXml(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(CUSTOMXML$0, i);
        }
    }
    
    /**
     * Gets a List of "smartTag" elements
     */
    public java.util.List getSmartTagList()
    {
        final class SmartTagList extends java.util.AbstractList
        {
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSmartTagRun get(int i)
                { return CTRunTrackChangeImpl.this.getSmartTagArray(i); }
            
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSmartTagRun set(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSmartTagRun o)
            {
                org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSmartTagRun old = CTRunTrackChangeImpl.this.getSmartTagArray(i);
                CTRunTrackChangeImpl.this.setSmartTagArray(i, o);
                return old;
            }
            
            public void add(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSmartTagRun o)
                { CTRunTrackChangeImpl.this.insertNewSmartTag(i).set(o); }
            
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSmartTagRun remove(int i)
            {
                org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSmartTagRun old = CTRunTrackChangeImpl.this.getSmartTagArray(i);
                CTRunTrackChangeImpl.this.removeSmartTag(i);
                return old;
            }
            
            public int size()
                { return CTRunTrackChangeImpl.this.sizeOfSmartTagArray(); }
            
        }
        
        synchronized (monitor())
        {
            check_orphaned();
            return new SmartTagList();
        }
    }
    
    /**
     * Gets array of all "smartTag" elements
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSmartTagRun[] getSmartTagArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(SMARTTAG$2, targetList);
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSmartTagRun[] result = new org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSmartTagRun[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "smartTag" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSmartTagRun getSmartTagArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSmartTagRun target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSmartTagRun)get_store().find_element_user(SMARTTAG$2, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "smartTag" element
     */
    public int sizeOfSmartTagArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SMARTTAG$2);
        }
    }
    
    /**
     * Sets array of all "smartTag" element
     */
    public void setSmartTagArray(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSmartTagRun[] smartTagArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(smartTagArray, SMARTTAG$2);
        }
    }
    
    /**
     * Sets ith "smartTag" element
     */
    public void setSmartTagArray(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSmartTagRun smartTag)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSmartTagRun target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSmartTagRun)get_store().find_element_user(SMARTTAG$2, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(smartTag);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "smartTag" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSmartTagRun insertNewSmartTag(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSmartTagRun target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSmartTagRun)get_store().insert_element_user(SMARTTAG$2, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "smartTag" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSmartTagRun addNewSmartTag()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSmartTagRun target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSmartTagRun)get_store().add_element_user(SMARTTAG$2);
            return target;
        }
    }
    
    /**
     * Removes the ith "smartTag" element
     */
    public void removeSmartTag(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SMARTTAG$2, i);
        }
    }
    
    /**
     * Gets a List of "sdt" elements
     */
    public java.util.List getSdtList()
    {
        final class SdtList extends java.util.AbstractList
        {
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSdtRun get(int i)
                { return CTRunTrackChangeImpl.this.getSdtArray(i); }
            
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSdtRun set(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSdtRun o)
            {
                org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSdtRun old = CTRunTrackChangeImpl.this.getSdtArray(i);
                CTRunTrackChangeImpl.this.setSdtArray(i, o);
                return old;
            }
            
            public void add(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSdtRun o)
                { CTRunTrackChangeImpl.this.insertNewSdt(i).set(o); }
            
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSdtRun remove(int i)
            {
                org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSdtRun old = CTRunTrackChangeImpl.this.getSdtArray(i);
                CTRunTrackChangeImpl.this.removeSdt(i);
                return old;
            }
            
            public int size()
                { return CTRunTrackChangeImpl.this.sizeOfSdtArray(); }
            
        }
        
        synchronized (monitor())
        {
            check_orphaned();
            return new SdtList();
        }
    }
    
    /**
     * Gets array of all "sdt" elements
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSdtRun[] getSdtArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(SDT$4, targetList);
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSdtRun[] result = new org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSdtRun[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "sdt" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSdtRun getSdtArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSdtRun target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSdtRun)get_store().find_element_user(SDT$4, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "sdt" element
     */
    public int sizeOfSdtArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SDT$4);
        }
    }
    
    /**
     * Sets array of all "sdt" element
     */
    public void setSdtArray(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSdtRun[] sdtArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(sdtArray, SDT$4);
        }
    }
    
    /**
     * Sets ith "sdt" element
     */
    public void setSdtArray(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSdtRun sdt)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSdtRun target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSdtRun)get_store().find_element_user(SDT$4, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(sdt);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "sdt" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSdtRun insertNewSdt(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSdtRun target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSdtRun)get_store().insert_element_user(SDT$4, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "sdt" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSdtRun addNewSdt()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSdtRun target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSdtRun)get_store().add_element_user(SDT$4);
            return target;
        }
    }
    
    /**
     * Removes the ith "sdt" element
     */
    public void removeSdt(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SDT$4, i);
        }
    }
    
    /**
     * Gets a List of "r" elements
     */
    public java.util.List getRList()
    {
        final class RList extends java.util.AbstractList
        {
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTR get(int i)
                { return CTRunTrackChangeImpl.this.getRArray(i); }
            
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTR set(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTR o)
            {
                org.openxmlformats.schemas.wordprocessingml.x2006.main.CTR old = CTRunTrackChangeImpl.this.getRArray(i);
                CTRunTrackChangeImpl.this.setRArray(i, o);
                return old;
            }
            
            public void add(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTR o)
                { CTRunTrackChangeImpl.this.insertNewR(i).set(o); }
            
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTR remove(int i)
            {
                org.openxmlformats.schemas.wordprocessingml.x2006.main.CTR old = CTRunTrackChangeImpl.this.getRArray(i);
                CTRunTrackChangeImpl.this.removeR(i);
                return old;
            }
            
            public int size()
                { return CTRunTrackChangeImpl.this.sizeOfRArray(); }
            
        }
        
        synchronized (monitor())
        {
            check_orphaned();
            return new RList();
        }
    }
    
    /**
     * Gets array of all "r" elements
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTR[] getRArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(R$6, targetList);
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTR[] result = new org.openxmlformats.schemas.wordprocessingml.x2006.main.CTR[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "r" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTR getRArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTR target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTR)get_store().find_element_user(R$6, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "r" element
     */
    public int sizeOfRArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(R$6);
        }
    }
    
    /**
     * Sets array of all "r" element
     */
    public void setRArray(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTR[] rArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(rArray, R$6);
        }
    }
    
    /**
     * Sets ith "r" element
     */
    public void setRArray(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTR r)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTR target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTR)get_store().find_element_user(R$6, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(r);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "r" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTR insertNewR(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTR target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTR)get_store().insert_element_user(R$6, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "r" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTR addNewR()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTR target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTR)get_store().add_element_user(R$6);
            return target;
        }
    }
    
    /**
     * Removes the ith "r" element
     */
    public void removeR(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(R$6, i);
        }
    }
    
    /**
     * Gets a List of "proofErr" elements
     */
    public java.util.List getProofErrList()
    {
        final class ProofErrList extends java.util.AbstractList
        {
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTProofErr get(int i)
                { return CTRunTrackChangeImpl.this.getProofErrArray(i); }
            
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTProofErr set(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTProofErr o)
            {
                org.openxmlformats.schemas.wordprocessingml.x2006.main.CTProofErr old = CTRunTrackChangeImpl.this.getProofErrArray(i);
                CTRunTrackChangeImpl.this.setProofErrArray(i, o);
                return old;
            }
            
            public void add(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTProofErr o)
                { CTRunTrackChangeImpl.this.insertNewProofErr(i).set(o); }
            
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTProofErr remove(int i)
            {
                org.openxmlformats.schemas.wordprocessingml.x2006.main.CTProofErr old = CTRunTrackChangeImpl.this.getProofErrArray(i);
                CTRunTrackChangeImpl.this.removeProofErr(i);
                return old;
            }
            
            public int size()
                { return CTRunTrackChangeImpl.this.sizeOfProofErrArray(); }
            
        }
        
        synchronized (monitor())
        {
            check_orphaned();
            return new ProofErrList();
        }
    }
    
    /**
     * Gets array of all "proofErr" elements
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTProofErr[] getProofErrArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(PROOFERR$8, targetList);
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTProofErr[] result = new org.openxmlformats.schemas.wordprocessingml.x2006.main.CTProofErr[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "proofErr" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTProofErr getProofErrArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTProofErr target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTProofErr)get_store().find_element_user(PROOFERR$8, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "proofErr" element
     */
    public int sizeOfProofErrArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(PROOFERR$8);
        }
    }
    
    /**
     * Sets array of all "proofErr" element
     */
    public void setProofErrArray(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTProofErr[] proofErrArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(proofErrArray, PROOFERR$8);
        }
    }
    
    /**
     * Sets ith "proofErr" element
     */
    public void setProofErrArray(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTProofErr proofErr)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTProofErr target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTProofErr)get_store().find_element_user(PROOFERR$8, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(proofErr);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "proofErr" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTProofErr insertNewProofErr(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTProofErr target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTProofErr)get_store().insert_element_user(PROOFERR$8, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "proofErr" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTProofErr addNewProofErr()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTProofErr target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTProofErr)get_store().add_element_user(PROOFERR$8);
            return target;
        }
    }
    
    /**
     * Removes the ith "proofErr" element
     */
    public void removeProofErr(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(PROOFERR$8, i);
        }
    }
    
    /**
     * Gets a List of "permStart" elements
     */
    public java.util.List getPermStartList()
    {
        final class PermStartList extends java.util.AbstractList
        {
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPermStart get(int i)
                { return CTRunTrackChangeImpl.this.getPermStartArray(i); }
            
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPermStart set(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPermStart o)
            {
                org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPermStart old = CTRunTrackChangeImpl.this.getPermStartArray(i);
                CTRunTrackChangeImpl.this.setPermStartArray(i, o);
                return old;
            }
            
            public void add(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPermStart o)
                { CTRunTrackChangeImpl.this.insertNewPermStart(i).set(o); }
            
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPermStart remove(int i)
            {
                org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPermStart old = CTRunTrackChangeImpl.this.getPermStartArray(i);
                CTRunTrackChangeImpl.this.removePermStart(i);
                return old;
            }
            
            public int size()
                { return CTRunTrackChangeImpl.this.sizeOfPermStartArray(); }
            
        }
        
        synchronized (monitor())
        {
            check_orphaned();
            return new PermStartList();
        }
    }
    
    /**
     * Gets array of all "permStart" elements
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPermStart[] getPermStartArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(PERMSTART$10, targetList);
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPermStart[] result = new org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPermStart[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "permStart" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPermStart getPermStartArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPermStart target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPermStart)get_store().find_element_user(PERMSTART$10, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "permStart" element
     */
    public int sizeOfPermStartArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(PERMSTART$10);
        }
    }
    
    /**
     * Sets array of all "permStart" element
     */
    public void setPermStartArray(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPermStart[] permStartArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(permStartArray, PERMSTART$10);
        }
    }
    
    /**
     * Sets ith "permStart" element
     */
    public void setPermStartArray(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPermStart permStart)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPermStart target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPermStart)get_store().find_element_user(PERMSTART$10, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(permStart);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "permStart" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPermStart insertNewPermStart(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPermStart target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPermStart)get_store().insert_element_user(PERMSTART$10, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "permStart" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPermStart addNewPermStart()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPermStart target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPermStart)get_store().add_element_user(PERMSTART$10);
            return target;
        }
    }
    
    /**
     * Removes the ith "permStart" element
     */
    public void removePermStart(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(PERMSTART$10, i);
        }
    }
    
    /**
     * Gets a List of "permEnd" elements
     */
    public java.util.List getPermEndList()
    {
        final class PermEndList extends java.util.AbstractList
        {
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPerm get(int i)
                { return CTRunTrackChangeImpl.this.getPermEndArray(i); }
            
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPerm set(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPerm o)
            {
                org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPerm old = CTRunTrackChangeImpl.this.getPermEndArray(i);
                CTRunTrackChangeImpl.this.setPermEndArray(i, o);
                return old;
            }
            
            public void add(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPerm o)
                { CTRunTrackChangeImpl.this.insertNewPermEnd(i).set(o); }
            
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPerm remove(int i)
            {
                org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPerm old = CTRunTrackChangeImpl.this.getPermEndArray(i);
                CTRunTrackChangeImpl.this.removePermEnd(i);
                return old;
            }
            
            public int size()
                { return CTRunTrackChangeImpl.this.sizeOfPermEndArray(); }
            
        }
        
        synchronized (monitor())
        {
            check_orphaned();
            return new PermEndList();
        }
    }
    
    /**
     * Gets array of all "permEnd" elements
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPerm[] getPermEndArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(PERMEND$12, targetList);
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPerm[] result = new org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPerm[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "permEnd" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPerm getPermEndArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPerm target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPerm)get_store().find_element_user(PERMEND$12, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "permEnd" element
     */
    public int sizeOfPermEndArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(PERMEND$12);
        }
    }
    
    /**
     * Sets array of all "permEnd" element
     */
    public void setPermEndArray(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPerm[] permEndArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(permEndArray, PERMEND$12);
        }
    }
    
    /**
     * Sets ith "permEnd" element
     */
    public void setPermEndArray(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPerm permEnd)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPerm target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPerm)get_store().find_element_user(PERMEND$12, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(permEnd);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "permEnd" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPerm insertNewPermEnd(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPerm target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPerm)get_store().insert_element_user(PERMEND$12, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "permEnd" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPerm addNewPermEnd()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPerm target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPerm)get_store().add_element_user(PERMEND$12);
            return target;
        }
    }
    
    /**
     * Removes the ith "permEnd" element
     */
    public void removePermEnd(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(PERMEND$12, i);
        }
    }
    
    /**
     * Gets a List of "bookmarkStart" elements
     */
    public java.util.List getBookmarkStartList()
    {
        final class BookmarkStartList extends java.util.AbstractList
        {
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTBookmark get(int i)
                { return CTRunTrackChangeImpl.this.getBookmarkStartArray(i); }
            
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTBookmark set(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTBookmark o)
            {
                org.openxmlformats.schemas.wordprocessingml.x2006.main.CTBookmark old = CTRunTrackChangeImpl.this.getBookmarkStartArray(i);
                CTRunTrackChangeImpl.this.setBookmarkStartArray(i, o);
                return old;
            }
            
            public void add(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTBookmark o)
                { CTRunTrackChangeImpl.this.insertNewBookmarkStart(i).set(o); }
            
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTBookmark remove(int i)
            {
                org.openxmlformats.schemas.wordprocessingml.x2006.main.CTBookmark old = CTRunTrackChangeImpl.this.getBookmarkStartArray(i);
                CTRunTrackChangeImpl.this.removeBookmarkStart(i);
                return old;
            }
            
            public int size()
                { return CTRunTrackChangeImpl.this.sizeOfBookmarkStartArray(); }
            
        }
        
        synchronized (monitor())
        {
            check_orphaned();
            return new BookmarkStartList();
        }
    }
    
    /**
     * Gets array of all "bookmarkStart" elements
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTBookmark[] getBookmarkStartArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(BOOKMARKSTART$14, targetList);
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTBookmark[] result = new org.openxmlformats.schemas.wordprocessingml.x2006.main.CTBookmark[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "bookmarkStart" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTBookmark getBookmarkStartArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTBookmark target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTBookmark)get_store().find_element_user(BOOKMARKSTART$14, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "bookmarkStart" element
     */
    public int sizeOfBookmarkStartArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(BOOKMARKSTART$14);
        }
    }
    
    /**
     * Sets array of all "bookmarkStart" element
     */
    public void setBookmarkStartArray(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTBookmark[] bookmarkStartArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(bookmarkStartArray, BOOKMARKSTART$14);
        }
    }
    
    /**
     * Sets ith "bookmarkStart" element
     */
    public void setBookmarkStartArray(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTBookmark bookmarkStart)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTBookmark target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTBookmark)get_store().find_element_user(BOOKMARKSTART$14, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(bookmarkStart);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "bookmarkStart" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTBookmark insertNewBookmarkStart(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTBookmark target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTBookmark)get_store().insert_element_user(BOOKMARKSTART$14, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "bookmarkStart" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTBookmark addNewBookmarkStart()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTBookmark target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTBookmark)get_store().add_element_user(BOOKMARKSTART$14);
            return target;
        }
    }
    
    /**
     * Removes the ith "bookmarkStart" element
     */
    public void removeBookmarkStart(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(BOOKMARKSTART$14, i);
        }
    }
    
    /**
     * Gets a List of "bookmarkEnd" elements
     */
    public java.util.List getBookmarkEndList()
    {
        final class BookmarkEndList extends java.util.AbstractList
        {
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange get(int i)
                { return CTRunTrackChangeImpl.this.getBookmarkEndArray(i); }
            
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange set(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange o)
            {
                org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange old = CTRunTrackChangeImpl.this.getBookmarkEndArray(i);
                CTRunTrackChangeImpl.this.setBookmarkEndArray(i, o);
                return old;
            }
            
            public void add(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange o)
                { CTRunTrackChangeImpl.this.insertNewBookmarkEnd(i).set(o); }
            
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange remove(int i)
            {
                org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange old = CTRunTrackChangeImpl.this.getBookmarkEndArray(i);
                CTRunTrackChangeImpl.this.removeBookmarkEnd(i);
                return old;
            }
            
            public int size()
                { return CTRunTrackChangeImpl.this.sizeOfBookmarkEndArray(); }
            
        }
        
        synchronized (monitor())
        {
            check_orphaned();
            return new BookmarkEndList();
        }
    }
    
    /**
     * Gets array of all "bookmarkEnd" elements
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange[] getBookmarkEndArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(BOOKMARKEND$16, targetList);
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange[] result = new org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "bookmarkEnd" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange getBookmarkEndArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange)get_store().find_element_user(BOOKMARKEND$16, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "bookmarkEnd" element
     */
    public int sizeOfBookmarkEndArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(BOOKMARKEND$16);
        }
    }
    
    /**
     * Sets array of all "bookmarkEnd" element
     */
    public void setBookmarkEndArray(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange[] bookmarkEndArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(bookmarkEndArray, BOOKMARKEND$16);
        }
    }
    
    /**
     * Sets ith "bookmarkEnd" element
     */
    public void setBookmarkEndArray(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange bookmarkEnd)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange)get_store().find_element_user(BOOKMARKEND$16, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(bookmarkEnd);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "bookmarkEnd" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange insertNewBookmarkEnd(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange)get_store().insert_element_user(BOOKMARKEND$16, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "bookmarkEnd" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange addNewBookmarkEnd()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange)get_store().add_element_user(BOOKMARKEND$16);
            return target;
        }
    }
    
    /**
     * Removes the ith "bookmarkEnd" element
     */
    public void removeBookmarkEnd(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(BOOKMARKEND$16, i);
        }
    }
    
    /**
     * Gets a List of "moveFromRangeStart" elements
     */
    public java.util.List getMoveFromRangeStartList()
    {
        final class MoveFromRangeStartList extends java.util.AbstractList
        {
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMoveBookmark get(int i)
                { return CTRunTrackChangeImpl.this.getMoveFromRangeStartArray(i); }
            
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMoveBookmark set(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMoveBookmark o)
            {
                org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMoveBookmark old = CTRunTrackChangeImpl.this.getMoveFromRangeStartArray(i);
                CTRunTrackChangeImpl.this.setMoveFromRangeStartArray(i, o);
                return old;
            }
            
            public void add(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMoveBookmark o)
                { CTRunTrackChangeImpl.this.insertNewMoveFromRangeStart(i).set(o); }
            
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMoveBookmark remove(int i)
            {
                org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMoveBookmark old = CTRunTrackChangeImpl.this.getMoveFromRangeStartArray(i);
                CTRunTrackChangeImpl.this.removeMoveFromRangeStart(i);
                return old;
            }
            
            public int size()
                { return CTRunTrackChangeImpl.this.sizeOfMoveFromRangeStartArray(); }
            
        }
        
        synchronized (monitor())
        {
            check_orphaned();
            return new MoveFromRangeStartList();
        }
    }
    
    /**
     * Gets array of all "moveFromRangeStart" elements
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMoveBookmark[] getMoveFromRangeStartArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(MOVEFROMRANGESTART$18, targetList);
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMoveBookmark[] result = new org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMoveBookmark[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "moveFromRangeStart" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMoveBookmark getMoveFromRangeStartArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMoveBookmark target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMoveBookmark)get_store().find_element_user(MOVEFROMRANGESTART$18, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "moveFromRangeStart" element
     */
    public int sizeOfMoveFromRangeStartArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(MOVEFROMRANGESTART$18);
        }
    }
    
    /**
     * Sets array of all "moveFromRangeStart" element
     */
    public void setMoveFromRangeStartArray(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMoveBookmark[] moveFromRangeStartArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(moveFromRangeStartArray, MOVEFROMRANGESTART$18);
        }
    }
    
    /**
     * Sets ith "moveFromRangeStart" element
     */
    public void setMoveFromRangeStartArray(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMoveBookmark moveFromRangeStart)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMoveBookmark target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMoveBookmark)get_store().find_element_user(MOVEFROMRANGESTART$18, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(moveFromRangeStart);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "moveFromRangeStart" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMoveBookmark insertNewMoveFromRangeStart(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMoveBookmark target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMoveBookmark)get_store().insert_element_user(MOVEFROMRANGESTART$18, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "moveFromRangeStart" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMoveBookmark addNewMoveFromRangeStart()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMoveBookmark target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMoveBookmark)get_store().add_element_user(MOVEFROMRANGESTART$18);
            return target;
        }
    }
    
    /**
     * Removes the ith "moveFromRangeStart" element
     */
    public void removeMoveFromRangeStart(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(MOVEFROMRANGESTART$18, i);
        }
    }
    
    /**
     * Gets a List of "moveFromRangeEnd" elements
     */
    public java.util.List getMoveFromRangeEndList()
    {
        final class MoveFromRangeEndList extends java.util.AbstractList
        {
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange get(int i)
                { return CTRunTrackChangeImpl.this.getMoveFromRangeEndArray(i); }
            
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange set(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange o)
            {
                org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange old = CTRunTrackChangeImpl.this.getMoveFromRangeEndArray(i);
                CTRunTrackChangeImpl.this.setMoveFromRangeEndArray(i, o);
                return old;
            }
            
            public void add(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange o)
                { CTRunTrackChangeImpl.this.insertNewMoveFromRangeEnd(i).set(o); }
            
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange remove(int i)
            {
                org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange old = CTRunTrackChangeImpl.this.getMoveFromRangeEndArray(i);
                CTRunTrackChangeImpl.this.removeMoveFromRangeEnd(i);
                return old;
            }
            
            public int size()
                { return CTRunTrackChangeImpl.this.sizeOfMoveFromRangeEndArray(); }
            
        }
        
        synchronized (monitor())
        {
            check_orphaned();
            return new MoveFromRangeEndList();
        }
    }
    
    /**
     * Gets array of all "moveFromRangeEnd" elements
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange[] getMoveFromRangeEndArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(MOVEFROMRANGEEND$20, targetList);
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange[] result = new org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "moveFromRangeEnd" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange getMoveFromRangeEndArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange)get_store().find_element_user(MOVEFROMRANGEEND$20, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "moveFromRangeEnd" element
     */
    public int sizeOfMoveFromRangeEndArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(MOVEFROMRANGEEND$20);
        }
    }
    
    /**
     * Sets array of all "moveFromRangeEnd" element
     */
    public void setMoveFromRangeEndArray(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange[] moveFromRangeEndArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(moveFromRangeEndArray, MOVEFROMRANGEEND$20);
        }
    }
    
    /**
     * Sets ith "moveFromRangeEnd" element
     */
    public void setMoveFromRangeEndArray(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange moveFromRangeEnd)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange)get_store().find_element_user(MOVEFROMRANGEEND$20, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(moveFromRangeEnd);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "moveFromRangeEnd" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange insertNewMoveFromRangeEnd(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange)get_store().insert_element_user(MOVEFROMRANGEEND$20, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "moveFromRangeEnd" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange addNewMoveFromRangeEnd()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange)get_store().add_element_user(MOVEFROMRANGEEND$20);
            return target;
        }
    }
    
    /**
     * Removes the ith "moveFromRangeEnd" element
     */
    public void removeMoveFromRangeEnd(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(MOVEFROMRANGEEND$20, i);
        }
    }
    
    /**
     * Gets a List of "moveToRangeStart" elements
     */
    public java.util.List getMoveToRangeStartList()
    {
        final class MoveToRangeStartList extends java.util.AbstractList
        {
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMoveBookmark get(int i)
                { return CTRunTrackChangeImpl.this.getMoveToRangeStartArray(i); }
            
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMoveBookmark set(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMoveBookmark o)
            {
                org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMoveBookmark old = CTRunTrackChangeImpl.this.getMoveToRangeStartArray(i);
                CTRunTrackChangeImpl.this.setMoveToRangeStartArray(i, o);
                return old;
            }
            
            public void add(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMoveBookmark o)
                { CTRunTrackChangeImpl.this.insertNewMoveToRangeStart(i).set(o); }
            
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMoveBookmark remove(int i)
            {
                org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMoveBookmark old = CTRunTrackChangeImpl.this.getMoveToRangeStartArray(i);
                CTRunTrackChangeImpl.this.removeMoveToRangeStart(i);
                return old;
            }
            
            public int size()
                { return CTRunTrackChangeImpl.this.sizeOfMoveToRangeStartArray(); }
            
        }
        
        synchronized (monitor())
        {
            check_orphaned();
            return new MoveToRangeStartList();
        }
    }
    
    /**
     * Gets array of all "moveToRangeStart" elements
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMoveBookmark[] getMoveToRangeStartArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(MOVETORANGESTART$22, targetList);
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMoveBookmark[] result = new org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMoveBookmark[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "moveToRangeStart" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMoveBookmark getMoveToRangeStartArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMoveBookmark target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMoveBookmark)get_store().find_element_user(MOVETORANGESTART$22, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "moveToRangeStart" element
     */
    public int sizeOfMoveToRangeStartArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(MOVETORANGESTART$22);
        }
    }
    
    /**
     * Sets array of all "moveToRangeStart" element
     */
    public void setMoveToRangeStartArray(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMoveBookmark[] moveToRangeStartArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(moveToRangeStartArray, MOVETORANGESTART$22);
        }
    }
    
    /**
     * Sets ith "moveToRangeStart" element
     */
    public void setMoveToRangeStartArray(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMoveBookmark moveToRangeStart)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMoveBookmark target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMoveBookmark)get_store().find_element_user(MOVETORANGESTART$22, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(moveToRangeStart);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "moveToRangeStart" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMoveBookmark insertNewMoveToRangeStart(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMoveBookmark target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMoveBookmark)get_store().insert_element_user(MOVETORANGESTART$22, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "moveToRangeStart" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMoveBookmark addNewMoveToRangeStart()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMoveBookmark target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMoveBookmark)get_store().add_element_user(MOVETORANGESTART$22);
            return target;
        }
    }
    
    /**
     * Removes the ith "moveToRangeStart" element
     */
    public void removeMoveToRangeStart(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(MOVETORANGESTART$22, i);
        }
    }
    
    /**
     * Gets a List of "moveToRangeEnd" elements
     */
    public java.util.List getMoveToRangeEndList()
    {
        final class MoveToRangeEndList extends java.util.AbstractList
        {
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange get(int i)
                { return CTRunTrackChangeImpl.this.getMoveToRangeEndArray(i); }
            
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange set(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange o)
            {
                org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange old = CTRunTrackChangeImpl.this.getMoveToRangeEndArray(i);
                CTRunTrackChangeImpl.this.setMoveToRangeEndArray(i, o);
                return old;
            }
            
            public void add(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange o)
                { CTRunTrackChangeImpl.this.insertNewMoveToRangeEnd(i).set(o); }
            
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange remove(int i)
            {
                org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange old = CTRunTrackChangeImpl.this.getMoveToRangeEndArray(i);
                CTRunTrackChangeImpl.this.removeMoveToRangeEnd(i);
                return old;
            }
            
            public int size()
                { return CTRunTrackChangeImpl.this.sizeOfMoveToRangeEndArray(); }
            
        }
        
        synchronized (monitor())
        {
            check_orphaned();
            return new MoveToRangeEndList();
        }
    }
    
    /**
     * Gets array of all "moveToRangeEnd" elements
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange[] getMoveToRangeEndArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(MOVETORANGEEND$24, targetList);
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange[] result = new org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "moveToRangeEnd" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange getMoveToRangeEndArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange)get_store().find_element_user(MOVETORANGEEND$24, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "moveToRangeEnd" element
     */
    public int sizeOfMoveToRangeEndArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(MOVETORANGEEND$24);
        }
    }
    
    /**
     * Sets array of all "moveToRangeEnd" element
     */
    public void setMoveToRangeEndArray(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange[] moveToRangeEndArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(moveToRangeEndArray, MOVETORANGEEND$24);
        }
    }
    
    /**
     * Sets ith "moveToRangeEnd" element
     */
    public void setMoveToRangeEndArray(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange moveToRangeEnd)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange)get_store().find_element_user(MOVETORANGEEND$24, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(moveToRangeEnd);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "moveToRangeEnd" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange insertNewMoveToRangeEnd(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange)get_store().insert_element_user(MOVETORANGEEND$24, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "moveToRangeEnd" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange addNewMoveToRangeEnd()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange)get_store().add_element_user(MOVETORANGEEND$24);
            return target;
        }
    }
    
    /**
     * Removes the ith "moveToRangeEnd" element
     */
    public void removeMoveToRangeEnd(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(MOVETORANGEEND$24, i);
        }
    }
    
    /**
     * Gets a List of "commentRangeStart" elements
     */
    public java.util.List getCommentRangeStartList()
    {
        final class CommentRangeStartList extends java.util.AbstractList
        {
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange get(int i)
                { return CTRunTrackChangeImpl.this.getCommentRangeStartArray(i); }
            
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange set(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange o)
            {
                org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange old = CTRunTrackChangeImpl.this.getCommentRangeStartArray(i);
                CTRunTrackChangeImpl.this.setCommentRangeStartArray(i, o);
                return old;
            }
            
            public void add(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange o)
                { CTRunTrackChangeImpl.this.insertNewCommentRangeStart(i).set(o); }
            
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange remove(int i)
            {
                org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange old = CTRunTrackChangeImpl.this.getCommentRangeStartArray(i);
                CTRunTrackChangeImpl.this.removeCommentRangeStart(i);
                return old;
            }
            
            public int size()
                { return CTRunTrackChangeImpl.this.sizeOfCommentRangeStartArray(); }
            
        }
        
        synchronized (monitor())
        {
            check_orphaned();
            return new CommentRangeStartList();
        }
    }
    
    /**
     * Gets array of all "commentRangeStart" elements
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange[] getCommentRangeStartArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(COMMENTRANGESTART$26, targetList);
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange[] result = new org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "commentRangeStart" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange getCommentRangeStartArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange)get_store().find_element_user(COMMENTRANGESTART$26, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "commentRangeStart" element
     */
    public int sizeOfCommentRangeStartArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(COMMENTRANGESTART$26);
        }
    }
    
    /**
     * Sets array of all "commentRangeStart" element
     */
    public void setCommentRangeStartArray(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange[] commentRangeStartArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(commentRangeStartArray, COMMENTRANGESTART$26);
        }
    }
    
    /**
     * Sets ith "commentRangeStart" element
     */
    public void setCommentRangeStartArray(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange commentRangeStart)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange)get_store().find_element_user(COMMENTRANGESTART$26, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(commentRangeStart);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "commentRangeStart" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange insertNewCommentRangeStart(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange)get_store().insert_element_user(COMMENTRANGESTART$26, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "commentRangeStart" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange addNewCommentRangeStart()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange)get_store().add_element_user(COMMENTRANGESTART$26);
            return target;
        }
    }
    
    /**
     * Removes the ith "commentRangeStart" element
     */
    public void removeCommentRangeStart(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(COMMENTRANGESTART$26, i);
        }
    }
    
    /**
     * Gets a List of "commentRangeEnd" elements
     */
    public java.util.List getCommentRangeEndList()
    {
        final class CommentRangeEndList extends java.util.AbstractList
        {
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange get(int i)
                { return CTRunTrackChangeImpl.this.getCommentRangeEndArray(i); }
            
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange set(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange o)
            {
                org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange old = CTRunTrackChangeImpl.this.getCommentRangeEndArray(i);
                CTRunTrackChangeImpl.this.setCommentRangeEndArray(i, o);
                return old;
            }
            
            public void add(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange o)
                { CTRunTrackChangeImpl.this.insertNewCommentRangeEnd(i).set(o); }
            
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange remove(int i)
            {
                org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange old = CTRunTrackChangeImpl.this.getCommentRangeEndArray(i);
                CTRunTrackChangeImpl.this.removeCommentRangeEnd(i);
                return old;
            }
            
            public int size()
                { return CTRunTrackChangeImpl.this.sizeOfCommentRangeEndArray(); }
            
        }
        
        synchronized (monitor())
        {
            check_orphaned();
            return new CommentRangeEndList();
        }
    }
    
    /**
     * Gets array of all "commentRangeEnd" elements
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange[] getCommentRangeEndArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(COMMENTRANGEEND$28, targetList);
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange[] result = new org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "commentRangeEnd" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange getCommentRangeEndArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange)get_store().find_element_user(COMMENTRANGEEND$28, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "commentRangeEnd" element
     */
    public int sizeOfCommentRangeEndArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(COMMENTRANGEEND$28);
        }
    }
    
    /**
     * Sets array of all "commentRangeEnd" element
     */
    public void setCommentRangeEndArray(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange[] commentRangeEndArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(commentRangeEndArray, COMMENTRANGEEND$28);
        }
    }
    
    /**
     * Sets ith "commentRangeEnd" element
     */
    public void setCommentRangeEndArray(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange commentRangeEnd)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange)get_store().find_element_user(COMMENTRANGEEND$28, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(commentRangeEnd);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "commentRangeEnd" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange insertNewCommentRangeEnd(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange)get_store().insert_element_user(COMMENTRANGEEND$28, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "commentRangeEnd" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange addNewCommentRangeEnd()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkupRange)get_store().add_element_user(COMMENTRANGEEND$28);
            return target;
        }
    }
    
    /**
     * Removes the ith "commentRangeEnd" element
     */
    public void removeCommentRangeEnd(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(COMMENTRANGEEND$28, i);
        }
    }
    
    /**
     * Gets a List of "customXmlInsRangeStart" elements
     */
    public java.util.List getCustomXmlInsRangeStartList()
    {
        final class CustomXmlInsRangeStartList extends java.util.AbstractList
        {
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange get(int i)
                { return CTRunTrackChangeImpl.this.getCustomXmlInsRangeStartArray(i); }
            
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange set(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange o)
            {
                org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange old = CTRunTrackChangeImpl.this.getCustomXmlInsRangeStartArray(i);
                CTRunTrackChangeImpl.this.setCustomXmlInsRangeStartArray(i, o);
                return old;
            }
            
            public void add(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange o)
                { CTRunTrackChangeImpl.this.insertNewCustomXmlInsRangeStart(i).set(o); }
            
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange remove(int i)
            {
                org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange old = CTRunTrackChangeImpl.this.getCustomXmlInsRangeStartArray(i);
                CTRunTrackChangeImpl.this.removeCustomXmlInsRangeStart(i);
                return old;
            }
            
            public int size()
                { return CTRunTrackChangeImpl.this.sizeOfCustomXmlInsRangeStartArray(); }
            
        }
        
        synchronized (monitor())
        {
            check_orphaned();
            return new CustomXmlInsRangeStartList();
        }
    }
    
    /**
     * Gets array of all "customXmlInsRangeStart" elements
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange[] getCustomXmlInsRangeStartArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(CUSTOMXMLINSRANGESTART$30, targetList);
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange[] result = new org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "customXmlInsRangeStart" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange getCustomXmlInsRangeStartArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange)get_store().find_element_user(CUSTOMXMLINSRANGESTART$30, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "customXmlInsRangeStart" element
     */
    public int sizeOfCustomXmlInsRangeStartArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(CUSTOMXMLINSRANGESTART$30);
        }
    }
    
    /**
     * Sets array of all "customXmlInsRangeStart" element
     */
    public void setCustomXmlInsRangeStartArray(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange[] customXmlInsRangeStartArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(customXmlInsRangeStartArray, CUSTOMXMLINSRANGESTART$30);
        }
    }
    
    /**
     * Sets ith "customXmlInsRangeStart" element
     */
    public void setCustomXmlInsRangeStartArray(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange customXmlInsRangeStart)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange)get_store().find_element_user(CUSTOMXMLINSRANGESTART$30, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(customXmlInsRangeStart);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "customXmlInsRangeStart" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange insertNewCustomXmlInsRangeStart(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange)get_store().insert_element_user(CUSTOMXMLINSRANGESTART$30, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "customXmlInsRangeStart" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange addNewCustomXmlInsRangeStart()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange)get_store().add_element_user(CUSTOMXMLINSRANGESTART$30);
            return target;
        }
    }
    
    /**
     * Removes the ith "customXmlInsRangeStart" element
     */
    public void removeCustomXmlInsRangeStart(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(CUSTOMXMLINSRANGESTART$30, i);
        }
    }
    
    /**
     * Gets a List of "customXmlInsRangeEnd" elements
     */
    public java.util.List getCustomXmlInsRangeEndList()
    {
        final class CustomXmlInsRangeEndList extends java.util.AbstractList
        {
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup get(int i)
                { return CTRunTrackChangeImpl.this.getCustomXmlInsRangeEndArray(i); }
            
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup set(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup o)
            {
                org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup old = CTRunTrackChangeImpl.this.getCustomXmlInsRangeEndArray(i);
                CTRunTrackChangeImpl.this.setCustomXmlInsRangeEndArray(i, o);
                return old;
            }
            
            public void add(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup o)
                { CTRunTrackChangeImpl.this.insertNewCustomXmlInsRangeEnd(i).set(o); }
            
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup remove(int i)
            {
                org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup old = CTRunTrackChangeImpl.this.getCustomXmlInsRangeEndArray(i);
                CTRunTrackChangeImpl.this.removeCustomXmlInsRangeEnd(i);
                return old;
            }
            
            public int size()
                { return CTRunTrackChangeImpl.this.sizeOfCustomXmlInsRangeEndArray(); }
            
        }
        
        synchronized (monitor())
        {
            check_orphaned();
            return new CustomXmlInsRangeEndList();
        }
    }
    
    /**
     * Gets array of all "customXmlInsRangeEnd" elements
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup[] getCustomXmlInsRangeEndArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(CUSTOMXMLINSRANGEEND$32, targetList);
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup[] result = new org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "customXmlInsRangeEnd" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup getCustomXmlInsRangeEndArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup)get_store().find_element_user(CUSTOMXMLINSRANGEEND$32, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "customXmlInsRangeEnd" element
     */
    public int sizeOfCustomXmlInsRangeEndArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(CUSTOMXMLINSRANGEEND$32);
        }
    }
    
    /**
     * Sets array of all "customXmlInsRangeEnd" element
     */
    public void setCustomXmlInsRangeEndArray(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup[] customXmlInsRangeEndArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(customXmlInsRangeEndArray, CUSTOMXMLINSRANGEEND$32);
        }
    }
    
    /**
     * Sets ith "customXmlInsRangeEnd" element
     */
    public void setCustomXmlInsRangeEndArray(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup customXmlInsRangeEnd)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup)get_store().find_element_user(CUSTOMXMLINSRANGEEND$32, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(customXmlInsRangeEnd);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "customXmlInsRangeEnd" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup insertNewCustomXmlInsRangeEnd(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup)get_store().insert_element_user(CUSTOMXMLINSRANGEEND$32, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "customXmlInsRangeEnd" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup addNewCustomXmlInsRangeEnd()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup)get_store().add_element_user(CUSTOMXMLINSRANGEEND$32);
            return target;
        }
    }
    
    /**
     * Removes the ith "customXmlInsRangeEnd" element
     */
    public void removeCustomXmlInsRangeEnd(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(CUSTOMXMLINSRANGEEND$32, i);
        }
    }
    
    /**
     * Gets a List of "customXmlDelRangeStart" elements
     */
    public java.util.List getCustomXmlDelRangeStartList()
    {
        final class CustomXmlDelRangeStartList extends java.util.AbstractList
        {
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange get(int i)
                { return CTRunTrackChangeImpl.this.getCustomXmlDelRangeStartArray(i); }
            
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange set(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange o)
            {
                org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange old = CTRunTrackChangeImpl.this.getCustomXmlDelRangeStartArray(i);
                CTRunTrackChangeImpl.this.setCustomXmlDelRangeStartArray(i, o);
                return old;
            }
            
            public void add(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange o)
                { CTRunTrackChangeImpl.this.insertNewCustomXmlDelRangeStart(i).set(o); }
            
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange remove(int i)
            {
                org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange old = CTRunTrackChangeImpl.this.getCustomXmlDelRangeStartArray(i);
                CTRunTrackChangeImpl.this.removeCustomXmlDelRangeStart(i);
                return old;
            }
            
            public int size()
                { return CTRunTrackChangeImpl.this.sizeOfCustomXmlDelRangeStartArray(); }
            
        }
        
        synchronized (monitor())
        {
            check_orphaned();
            return new CustomXmlDelRangeStartList();
        }
    }
    
    /**
     * Gets array of all "customXmlDelRangeStart" elements
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange[] getCustomXmlDelRangeStartArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(CUSTOMXMLDELRANGESTART$34, targetList);
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange[] result = new org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "customXmlDelRangeStart" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange getCustomXmlDelRangeStartArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange)get_store().find_element_user(CUSTOMXMLDELRANGESTART$34, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "customXmlDelRangeStart" element
     */
    public int sizeOfCustomXmlDelRangeStartArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(CUSTOMXMLDELRANGESTART$34);
        }
    }
    
    /**
     * Sets array of all "customXmlDelRangeStart" element
     */
    public void setCustomXmlDelRangeStartArray(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange[] customXmlDelRangeStartArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(customXmlDelRangeStartArray, CUSTOMXMLDELRANGESTART$34);
        }
    }
    
    /**
     * Sets ith "customXmlDelRangeStart" element
     */
    public void setCustomXmlDelRangeStartArray(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange customXmlDelRangeStart)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange)get_store().find_element_user(CUSTOMXMLDELRANGESTART$34, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(customXmlDelRangeStart);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "customXmlDelRangeStart" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange insertNewCustomXmlDelRangeStart(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange)get_store().insert_element_user(CUSTOMXMLDELRANGESTART$34, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "customXmlDelRangeStart" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange addNewCustomXmlDelRangeStart()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange)get_store().add_element_user(CUSTOMXMLDELRANGESTART$34);
            return target;
        }
    }
    
    /**
     * Removes the ith "customXmlDelRangeStart" element
     */
    public void removeCustomXmlDelRangeStart(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(CUSTOMXMLDELRANGESTART$34, i);
        }
    }
    
    /**
     * Gets a List of "customXmlDelRangeEnd" elements
     */
    public java.util.List getCustomXmlDelRangeEndList()
    {
        final class CustomXmlDelRangeEndList extends java.util.AbstractList
        {
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup get(int i)
                { return CTRunTrackChangeImpl.this.getCustomXmlDelRangeEndArray(i); }
            
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup set(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup o)
            {
                org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup old = CTRunTrackChangeImpl.this.getCustomXmlDelRangeEndArray(i);
                CTRunTrackChangeImpl.this.setCustomXmlDelRangeEndArray(i, o);
                return old;
            }
            
            public void add(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup o)
                { CTRunTrackChangeImpl.this.insertNewCustomXmlDelRangeEnd(i).set(o); }
            
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup remove(int i)
            {
                org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup old = CTRunTrackChangeImpl.this.getCustomXmlDelRangeEndArray(i);
                CTRunTrackChangeImpl.this.removeCustomXmlDelRangeEnd(i);
                return old;
            }
            
            public int size()
                { return CTRunTrackChangeImpl.this.sizeOfCustomXmlDelRangeEndArray(); }
            
        }
        
        synchronized (monitor())
        {
            check_orphaned();
            return new CustomXmlDelRangeEndList();
        }
    }
    
    /**
     * Gets array of all "customXmlDelRangeEnd" elements
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup[] getCustomXmlDelRangeEndArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(CUSTOMXMLDELRANGEEND$36, targetList);
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup[] result = new org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "customXmlDelRangeEnd" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup getCustomXmlDelRangeEndArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup)get_store().find_element_user(CUSTOMXMLDELRANGEEND$36, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "customXmlDelRangeEnd" element
     */
    public int sizeOfCustomXmlDelRangeEndArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(CUSTOMXMLDELRANGEEND$36);
        }
    }
    
    /**
     * Sets array of all "customXmlDelRangeEnd" element
     */
    public void setCustomXmlDelRangeEndArray(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup[] customXmlDelRangeEndArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(customXmlDelRangeEndArray, CUSTOMXMLDELRANGEEND$36);
        }
    }
    
    /**
     * Sets ith "customXmlDelRangeEnd" element
     */
    public void setCustomXmlDelRangeEndArray(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup customXmlDelRangeEnd)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup)get_store().find_element_user(CUSTOMXMLDELRANGEEND$36, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(customXmlDelRangeEnd);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "customXmlDelRangeEnd" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup insertNewCustomXmlDelRangeEnd(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup)get_store().insert_element_user(CUSTOMXMLDELRANGEEND$36, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "customXmlDelRangeEnd" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup addNewCustomXmlDelRangeEnd()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup)get_store().add_element_user(CUSTOMXMLDELRANGEEND$36);
            return target;
        }
    }
    
    /**
     * Removes the ith "customXmlDelRangeEnd" element
     */
    public void removeCustomXmlDelRangeEnd(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(CUSTOMXMLDELRANGEEND$36, i);
        }
    }
    
    /**
     * Gets a List of "customXmlMoveFromRangeStart" elements
     */
    public java.util.List getCustomXmlMoveFromRangeStartList()
    {
        final class CustomXmlMoveFromRangeStartList extends java.util.AbstractList
        {
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange get(int i)
                { return CTRunTrackChangeImpl.this.getCustomXmlMoveFromRangeStartArray(i); }
            
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange set(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange o)
            {
                org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange old = CTRunTrackChangeImpl.this.getCustomXmlMoveFromRangeStartArray(i);
                CTRunTrackChangeImpl.this.setCustomXmlMoveFromRangeStartArray(i, o);
                return old;
            }
            
            public void add(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange o)
                { CTRunTrackChangeImpl.this.insertNewCustomXmlMoveFromRangeStart(i).set(o); }
            
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange remove(int i)
            {
                org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange old = CTRunTrackChangeImpl.this.getCustomXmlMoveFromRangeStartArray(i);
                CTRunTrackChangeImpl.this.removeCustomXmlMoveFromRangeStart(i);
                return old;
            }
            
            public int size()
                { return CTRunTrackChangeImpl.this.sizeOfCustomXmlMoveFromRangeStartArray(); }
            
        }
        
        synchronized (monitor())
        {
            check_orphaned();
            return new CustomXmlMoveFromRangeStartList();
        }
    }
    
    /**
     * Gets array of all "customXmlMoveFromRangeStart" elements
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange[] getCustomXmlMoveFromRangeStartArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(CUSTOMXMLMOVEFROMRANGESTART$38, targetList);
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange[] result = new org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "customXmlMoveFromRangeStart" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange getCustomXmlMoveFromRangeStartArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange)get_store().find_element_user(CUSTOMXMLMOVEFROMRANGESTART$38, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "customXmlMoveFromRangeStart" element
     */
    public int sizeOfCustomXmlMoveFromRangeStartArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(CUSTOMXMLMOVEFROMRANGESTART$38);
        }
    }
    
    /**
     * Sets array of all "customXmlMoveFromRangeStart" element
     */
    public void setCustomXmlMoveFromRangeStartArray(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange[] customXmlMoveFromRangeStartArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(customXmlMoveFromRangeStartArray, CUSTOMXMLMOVEFROMRANGESTART$38);
        }
    }
    
    /**
     * Sets ith "customXmlMoveFromRangeStart" element
     */
    public void setCustomXmlMoveFromRangeStartArray(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange customXmlMoveFromRangeStart)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange)get_store().find_element_user(CUSTOMXMLMOVEFROMRANGESTART$38, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(customXmlMoveFromRangeStart);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "customXmlMoveFromRangeStart" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange insertNewCustomXmlMoveFromRangeStart(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange)get_store().insert_element_user(CUSTOMXMLMOVEFROMRANGESTART$38, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "customXmlMoveFromRangeStart" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange addNewCustomXmlMoveFromRangeStart()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange)get_store().add_element_user(CUSTOMXMLMOVEFROMRANGESTART$38);
            return target;
        }
    }
    
    /**
     * Removes the ith "customXmlMoveFromRangeStart" element
     */
    public void removeCustomXmlMoveFromRangeStart(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(CUSTOMXMLMOVEFROMRANGESTART$38, i);
        }
    }
    
    /**
     * Gets a List of "customXmlMoveFromRangeEnd" elements
     */
    public java.util.List getCustomXmlMoveFromRangeEndList()
    {
        final class CustomXmlMoveFromRangeEndList extends java.util.AbstractList
        {
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup get(int i)
                { return CTRunTrackChangeImpl.this.getCustomXmlMoveFromRangeEndArray(i); }
            
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup set(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup o)
            {
                org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup old = CTRunTrackChangeImpl.this.getCustomXmlMoveFromRangeEndArray(i);
                CTRunTrackChangeImpl.this.setCustomXmlMoveFromRangeEndArray(i, o);
                return old;
            }
            
            public void add(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup o)
                { CTRunTrackChangeImpl.this.insertNewCustomXmlMoveFromRangeEnd(i).set(o); }
            
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup remove(int i)
            {
                org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup old = CTRunTrackChangeImpl.this.getCustomXmlMoveFromRangeEndArray(i);
                CTRunTrackChangeImpl.this.removeCustomXmlMoveFromRangeEnd(i);
                return old;
            }
            
            public int size()
                { return CTRunTrackChangeImpl.this.sizeOfCustomXmlMoveFromRangeEndArray(); }
            
        }
        
        synchronized (monitor())
        {
            check_orphaned();
            return new CustomXmlMoveFromRangeEndList();
        }
    }
    
    /**
     * Gets array of all "customXmlMoveFromRangeEnd" elements
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup[] getCustomXmlMoveFromRangeEndArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(CUSTOMXMLMOVEFROMRANGEEND$40, targetList);
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup[] result = new org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "customXmlMoveFromRangeEnd" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup getCustomXmlMoveFromRangeEndArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup)get_store().find_element_user(CUSTOMXMLMOVEFROMRANGEEND$40, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "customXmlMoveFromRangeEnd" element
     */
    public int sizeOfCustomXmlMoveFromRangeEndArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(CUSTOMXMLMOVEFROMRANGEEND$40);
        }
    }
    
    /**
     * Sets array of all "customXmlMoveFromRangeEnd" element
     */
    public void setCustomXmlMoveFromRangeEndArray(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup[] customXmlMoveFromRangeEndArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(customXmlMoveFromRangeEndArray, CUSTOMXMLMOVEFROMRANGEEND$40);
        }
    }
    
    /**
     * Sets ith "customXmlMoveFromRangeEnd" element
     */
    public void setCustomXmlMoveFromRangeEndArray(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup customXmlMoveFromRangeEnd)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup)get_store().find_element_user(CUSTOMXMLMOVEFROMRANGEEND$40, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(customXmlMoveFromRangeEnd);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "customXmlMoveFromRangeEnd" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup insertNewCustomXmlMoveFromRangeEnd(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup)get_store().insert_element_user(CUSTOMXMLMOVEFROMRANGEEND$40, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "customXmlMoveFromRangeEnd" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup addNewCustomXmlMoveFromRangeEnd()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup)get_store().add_element_user(CUSTOMXMLMOVEFROMRANGEEND$40);
            return target;
        }
    }
    
    /**
     * Removes the ith "customXmlMoveFromRangeEnd" element
     */
    public void removeCustomXmlMoveFromRangeEnd(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(CUSTOMXMLMOVEFROMRANGEEND$40, i);
        }
    }
    
    /**
     * Gets a List of "customXmlMoveToRangeStart" elements
     */
    public java.util.List getCustomXmlMoveToRangeStartList()
    {
        final class CustomXmlMoveToRangeStartList extends java.util.AbstractList
        {
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange get(int i)
                { return CTRunTrackChangeImpl.this.getCustomXmlMoveToRangeStartArray(i); }
            
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange set(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange o)
            {
                org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange old = CTRunTrackChangeImpl.this.getCustomXmlMoveToRangeStartArray(i);
                CTRunTrackChangeImpl.this.setCustomXmlMoveToRangeStartArray(i, o);
                return old;
            }
            
            public void add(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange o)
                { CTRunTrackChangeImpl.this.insertNewCustomXmlMoveToRangeStart(i).set(o); }
            
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange remove(int i)
            {
                org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange old = CTRunTrackChangeImpl.this.getCustomXmlMoveToRangeStartArray(i);
                CTRunTrackChangeImpl.this.removeCustomXmlMoveToRangeStart(i);
                return old;
            }
            
            public int size()
                { return CTRunTrackChangeImpl.this.sizeOfCustomXmlMoveToRangeStartArray(); }
            
        }
        
        synchronized (monitor())
        {
            check_orphaned();
            return new CustomXmlMoveToRangeStartList();
        }
    }
    
    /**
     * Gets array of all "customXmlMoveToRangeStart" elements
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange[] getCustomXmlMoveToRangeStartArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(CUSTOMXMLMOVETORANGESTART$42, targetList);
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange[] result = new org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "customXmlMoveToRangeStart" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange getCustomXmlMoveToRangeStartArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange)get_store().find_element_user(CUSTOMXMLMOVETORANGESTART$42, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "customXmlMoveToRangeStart" element
     */
    public int sizeOfCustomXmlMoveToRangeStartArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(CUSTOMXMLMOVETORANGESTART$42);
        }
    }
    
    /**
     * Sets array of all "customXmlMoveToRangeStart" element
     */
    public void setCustomXmlMoveToRangeStartArray(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange[] customXmlMoveToRangeStartArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(customXmlMoveToRangeStartArray, CUSTOMXMLMOVETORANGESTART$42);
        }
    }
    
    /**
     * Sets ith "customXmlMoveToRangeStart" element
     */
    public void setCustomXmlMoveToRangeStartArray(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange customXmlMoveToRangeStart)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange)get_store().find_element_user(CUSTOMXMLMOVETORANGESTART$42, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(customXmlMoveToRangeStart);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "customXmlMoveToRangeStart" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange insertNewCustomXmlMoveToRangeStart(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange)get_store().insert_element_user(CUSTOMXMLMOVETORANGESTART$42, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "customXmlMoveToRangeStart" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange addNewCustomXmlMoveToRangeStart()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrackChange)get_store().add_element_user(CUSTOMXMLMOVETORANGESTART$42);
            return target;
        }
    }
    
    /**
     * Removes the ith "customXmlMoveToRangeStart" element
     */
    public void removeCustomXmlMoveToRangeStart(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(CUSTOMXMLMOVETORANGESTART$42, i);
        }
    }
    
    /**
     * Gets a List of "customXmlMoveToRangeEnd" elements
     */
    public java.util.List getCustomXmlMoveToRangeEndList()
    {
        final class CustomXmlMoveToRangeEndList extends java.util.AbstractList
        {
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup get(int i)
                { return CTRunTrackChangeImpl.this.getCustomXmlMoveToRangeEndArray(i); }
            
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup set(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup o)
            {
                org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup old = CTRunTrackChangeImpl.this.getCustomXmlMoveToRangeEndArray(i);
                CTRunTrackChangeImpl.this.setCustomXmlMoveToRangeEndArray(i, o);
                return old;
            }
            
            public void add(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup o)
                { CTRunTrackChangeImpl.this.insertNewCustomXmlMoveToRangeEnd(i).set(o); }
            
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup remove(int i)
            {
                org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup old = CTRunTrackChangeImpl.this.getCustomXmlMoveToRangeEndArray(i);
                CTRunTrackChangeImpl.this.removeCustomXmlMoveToRangeEnd(i);
                return old;
            }
            
            public int size()
                { return CTRunTrackChangeImpl.this.sizeOfCustomXmlMoveToRangeEndArray(); }
            
        }
        
        synchronized (monitor())
        {
            check_orphaned();
            return new CustomXmlMoveToRangeEndList();
        }
    }
    
    /**
     * Gets array of all "customXmlMoveToRangeEnd" elements
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup[] getCustomXmlMoveToRangeEndArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(CUSTOMXMLMOVETORANGEEND$44, targetList);
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup[] result = new org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "customXmlMoveToRangeEnd" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup getCustomXmlMoveToRangeEndArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup)get_store().find_element_user(CUSTOMXMLMOVETORANGEEND$44, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "customXmlMoveToRangeEnd" element
     */
    public int sizeOfCustomXmlMoveToRangeEndArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(CUSTOMXMLMOVETORANGEEND$44);
        }
    }
    
    /**
     * Sets array of all "customXmlMoveToRangeEnd" element
     */
    public void setCustomXmlMoveToRangeEndArray(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup[] customXmlMoveToRangeEndArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(customXmlMoveToRangeEndArray, CUSTOMXMLMOVETORANGEEND$44);
        }
    }
    
    /**
     * Sets ith "customXmlMoveToRangeEnd" element
     */
    public void setCustomXmlMoveToRangeEndArray(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup customXmlMoveToRangeEnd)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup)get_store().find_element_user(CUSTOMXMLMOVETORANGEEND$44, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(customXmlMoveToRangeEnd);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "customXmlMoveToRangeEnd" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup insertNewCustomXmlMoveToRangeEnd(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup)get_store().insert_element_user(CUSTOMXMLMOVETORANGEEND$44, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "customXmlMoveToRangeEnd" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup addNewCustomXmlMoveToRangeEnd()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTMarkup)get_store().add_element_user(CUSTOMXMLMOVETORANGEEND$44);
            return target;
        }
    }
    
    /**
     * Removes the ith "customXmlMoveToRangeEnd" element
     */
    public void removeCustomXmlMoveToRangeEnd(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(CUSTOMXMLMOVETORANGEEND$44, i);
        }
    }
    
    /**
     * Gets a List of "ins" elements
     */
    public java.util.List getInsList()
    {
        final class InsList extends java.util.AbstractList
        {
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange get(int i)
                { return CTRunTrackChangeImpl.this.getInsArray(i); }
            
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange set(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange o)
            {
                org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange old = CTRunTrackChangeImpl.this.getInsArray(i);
                CTRunTrackChangeImpl.this.setInsArray(i, o);
                return old;
            }
            
            public void add(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange o)
                { CTRunTrackChangeImpl.this.insertNewIns(i).set(o); }
            
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange remove(int i)
            {
                org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange old = CTRunTrackChangeImpl.this.getInsArray(i);
                CTRunTrackChangeImpl.this.removeIns(i);
                return old;
            }
            
            public int size()
                { return CTRunTrackChangeImpl.this.sizeOfInsArray(); }
            
        }
        
        synchronized (monitor())
        {
            check_orphaned();
            return new InsList();
        }
    }
    
    /**
     * Gets array of all "ins" elements
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange[] getInsArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(INS$46, targetList);
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange[] result = new org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "ins" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange getInsArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange)get_store().find_element_user(INS$46, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "ins" element
     */
    public int sizeOfInsArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(INS$46);
        }
    }
    
    /**
     * Sets array of all "ins" element
     */
    public void setInsArray(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange[] insArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(insArray, INS$46);
        }
    }
    
    /**
     * Sets ith "ins" element
     */
    public void setInsArray(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange ins)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange)get_store().find_element_user(INS$46, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(ins);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "ins" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange insertNewIns(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange)get_store().insert_element_user(INS$46, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "ins" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange addNewIns()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange)get_store().add_element_user(INS$46);
            return target;
        }
    }
    
    /**
     * Removes the ith "ins" element
     */
    public void removeIns(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(INS$46, i);
        }
    }
    
    /**
     * Gets a List of "del" elements
     */
    public java.util.List getDelList()
    {
        final class DelList extends java.util.AbstractList
        {
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange get(int i)
                { return CTRunTrackChangeImpl.this.getDelArray(i); }
            
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange set(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange o)
            {
                org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange old = CTRunTrackChangeImpl.this.getDelArray(i);
                CTRunTrackChangeImpl.this.setDelArray(i, o);
                return old;
            }
            
            public void add(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange o)
                { CTRunTrackChangeImpl.this.insertNewDel(i).set(o); }
            
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange remove(int i)
            {
                org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange old = CTRunTrackChangeImpl.this.getDelArray(i);
                CTRunTrackChangeImpl.this.removeDel(i);
                return old;
            }
            
            public int size()
                { return CTRunTrackChangeImpl.this.sizeOfDelArray(); }
            
        }
        
        synchronized (monitor())
        {
            check_orphaned();
            return new DelList();
        }
    }
    
    /**
     * Gets array of all "del" elements
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange[] getDelArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(DEL$48, targetList);
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange[] result = new org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "del" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange getDelArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange)get_store().find_element_user(DEL$48, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "del" element
     */
    public int sizeOfDelArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(DEL$48);
        }
    }
    
    /**
     * Sets array of all "del" element
     */
    public void setDelArray(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange[] delArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(delArray, DEL$48);
        }
    }
    
    /**
     * Sets ith "del" element
     */
    public void setDelArray(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange del)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange)get_store().find_element_user(DEL$48, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(del);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "del" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange insertNewDel(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange)get_store().insert_element_user(DEL$48, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "del" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange addNewDel()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange)get_store().add_element_user(DEL$48);
            return target;
        }
    }
    
    /**
     * Removes the ith "del" element
     */
    public void removeDel(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(DEL$48, i);
        }
    }
    
    /**
     * Gets a List of "moveFrom" elements
     */
    public java.util.List getMoveFromList()
    {
        final class MoveFromList extends java.util.AbstractList
        {
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange get(int i)
                { return CTRunTrackChangeImpl.this.getMoveFromArray(i); }
            
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange set(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange o)
            {
                org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange old = CTRunTrackChangeImpl.this.getMoveFromArray(i);
                CTRunTrackChangeImpl.this.setMoveFromArray(i, o);
                return old;
            }
            
            public void add(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange o)
                { CTRunTrackChangeImpl.this.insertNewMoveFrom(i).set(o); }
            
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange remove(int i)
            {
                org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange old = CTRunTrackChangeImpl.this.getMoveFromArray(i);
                CTRunTrackChangeImpl.this.removeMoveFrom(i);
                return old;
            }
            
            public int size()
                { return CTRunTrackChangeImpl.this.sizeOfMoveFromArray(); }
            
        }
        
        synchronized (monitor())
        {
            check_orphaned();
            return new MoveFromList();
        }
    }
    
    /**
     * Gets array of all "moveFrom" elements
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange[] getMoveFromArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(MOVEFROM$50, targetList);
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange[] result = new org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "moveFrom" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange getMoveFromArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange)get_store().find_element_user(MOVEFROM$50, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "moveFrom" element
     */
    public int sizeOfMoveFromArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(MOVEFROM$50);
        }
    }
    
    /**
     * Sets array of all "moveFrom" element
     */
    public void setMoveFromArray(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange[] moveFromArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(moveFromArray, MOVEFROM$50);
        }
    }
    
    /**
     * Sets ith "moveFrom" element
     */
    public void setMoveFromArray(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange moveFrom)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange)get_store().find_element_user(MOVEFROM$50, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(moveFrom);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "moveFrom" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange insertNewMoveFrom(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange)get_store().insert_element_user(MOVEFROM$50, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "moveFrom" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange addNewMoveFrom()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange)get_store().add_element_user(MOVEFROM$50);
            return target;
        }
    }
    
    /**
     * Removes the ith "moveFrom" element
     */
    public void removeMoveFrom(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(MOVEFROM$50, i);
        }
    }
    
    /**
     * Gets a List of "moveTo" elements
     */
    public java.util.List getMoveToList()
    {
        final class MoveToList extends java.util.AbstractList
        {
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange get(int i)
                { return CTRunTrackChangeImpl.this.getMoveToArray(i); }
            
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange set(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange o)
            {
                org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange old = CTRunTrackChangeImpl.this.getMoveToArray(i);
                CTRunTrackChangeImpl.this.setMoveToArray(i, o);
                return old;
            }
            
            public void add(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange o)
                { CTRunTrackChangeImpl.this.insertNewMoveTo(i).set(o); }
            
            public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange remove(int i)
            {
                org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange old = CTRunTrackChangeImpl.this.getMoveToArray(i);
                CTRunTrackChangeImpl.this.removeMoveTo(i);
                return old;
            }
            
            public int size()
                { return CTRunTrackChangeImpl.this.sizeOfMoveToArray(); }
            
        }
        
        synchronized (monitor())
        {
            check_orphaned();
            return new MoveToList();
        }
    }
    
    /**
     * Gets array of all "moveTo" elements
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange[] getMoveToArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(MOVETO$52, targetList);
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange[] result = new org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "moveTo" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange getMoveToArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange)get_store().find_element_user(MOVETO$52, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "moveTo" element
     */
    public int sizeOfMoveToArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(MOVETO$52);
        }
    }
    
    /**
     * Sets array of all "moveTo" element
     */
    public void setMoveToArray(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange[] moveToArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(moveToArray, MOVETO$52);
        }
    }
    
    /**
     * Sets ith "moveTo" element
     */
    public void setMoveToArray(int i, org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange moveTo)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange)get_store().find_element_user(MOVETO$52, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(moveTo);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "moveTo" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange insertNewMoveTo(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange)get_store().insert_element_user(MOVETO$52, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "moveTo" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange addNewMoveTo()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRunTrackChange)get_store().add_element_user(MOVETO$52);
            return target;
        }
    }
    
    /**
     * Removes the ith "moveTo" element
     */
    public void removeMoveTo(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(MOVETO$52, i);
        }
    }
    
    /**
     * Gets a List of "oMathPara" elements
     */
    public java.util.List getOMathParaList()
    {
        final class OMathParaList extends java.util.AbstractList
        {
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTOMathPara get(int i)
                { return CTRunTrackChangeImpl.this.getOMathParaArray(i); }
            
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTOMathPara set(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTOMathPara o)
            {
                org.openxmlformats.schemas.officeDocument.x2006.math.CTOMathPara old = CTRunTrackChangeImpl.this.getOMathParaArray(i);
                CTRunTrackChangeImpl.this.setOMathParaArray(i, o);
                return old;
            }
            
            public void add(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTOMathPara o)
                { CTRunTrackChangeImpl.this.insertNewOMathPara(i).set(o); }
            
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTOMathPara remove(int i)
            {
                org.openxmlformats.schemas.officeDocument.x2006.math.CTOMathPara old = CTRunTrackChangeImpl.this.getOMathParaArray(i);
                CTRunTrackChangeImpl.this.removeOMathPara(i);
                return old;
            }
            
            public int size()
                { return CTRunTrackChangeImpl.this.sizeOfOMathParaArray(); }
            
        }
        
        synchronized (monitor())
        {
            check_orphaned();
            return new OMathParaList();
        }
    }
    
    /**
     * Gets array of all "oMathPara" elements
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTOMathPara[] getOMathParaArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(OMATHPARA$54, targetList);
            org.openxmlformats.schemas.officeDocument.x2006.math.CTOMathPara[] result = new org.openxmlformats.schemas.officeDocument.x2006.math.CTOMathPara[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "oMathPara" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTOMathPara getOMathParaArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTOMathPara target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTOMathPara)get_store().find_element_user(OMATHPARA$54, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "oMathPara" element
     */
    public int sizeOfOMathParaArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(OMATHPARA$54);
        }
    }
    
    /**
     * Sets array of all "oMathPara" element
     */
    public void setOMathParaArray(org.openxmlformats.schemas.officeDocument.x2006.math.CTOMathPara[] oMathParaArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(oMathParaArray, OMATHPARA$54);
        }
    }
    
    /**
     * Sets ith "oMathPara" element
     */
    public void setOMathParaArray(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTOMathPara oMathPara)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTOMathPara target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTOMathPara)get_store().find_element_user(OMATHPARA$54, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(oMathPara);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "oMathPara" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTOMathPara insertNewOMathPara(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTOMathPara target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTOMathPara)get_store().insert_element_user(OMATHPARA$54, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "oMathPara" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTOMathPara addNewOMathPara()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTOMathPara target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTOMathPara)get_store().add_element_user(OMATHPARA$54);
            return target;
        }
    }
    
    /**
     * Removes the ith "oMathPara" element
     */
    public void removeOMathPara(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(OMATHPARA$54, i);
        }
    }
    
    /**
     * Gets a List of "oMath" elements
     */
    public java.util.List getOMathList()
    {
        final class OMathList extends java.util.AbstractList
        {
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTOMath get(int i)
                { return CTRunTrackChangeImpl.this.getOMathArray(i); }
            
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTOMath set(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTOMath o)
            {
                org.openxmlformats.schemas.officeDocument.x2006.math.CTOMath old = CTRunTrackChangeImpl.this.getOMathArray(i);
                CTRunTrackChangeImpl.this.setOMathArray(i, o);
                return old;
            }
            
            public void add(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTOMath o)
                { CTRunTrackChangeImpl.this.insertNewOMath(i).set(o); }
            
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTOMath remove(int i)
            {
                org.openxmlformats.schemas.officeDocument.x2006.math.CTOMath old = CTRunTrackChangeImpl.this.getOMathArray(i);
                CTRunTrackChangeImpl.this.removeOMath(i);
                return old;
            }
            
            public int size()
                { return CTRunTrackChangeImpl.this.sizeOfOMathArray(); }
            
        }
        
        synchronized (monitor())
        {
            check_orphaned();
            return new OMathList();
        }
    }
    
    /**
     * Gets array of all "oMath" elements
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTOMath[] getOMathArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(OMATH$56, targetList);
            org.openxmlformats.schemas.officeDocument.x2006.math.CTOMath[] result = new org.openxmlformats.schemas.officeDocument.x2006.math.CTOMath[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "oMath" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTOMath getOMathArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTOMath target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTOMath)get_store().find_element_user(OMATH$56, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "oMath" element
     */
    public int sizeOfOMathArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(OMATH$56);
        }
    }
    
    /**
     * Sets array of all "oMath" element
     */
    public void setOMathArray(org.openxmlformats.schemas.officeDocument.x2006.math.CTOMath[] oMathArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(oMathArray, OMATH$56);
        }
    }
    
    /**
     * Sets ith "oMath" element
     */
    public void setOMathArray(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTOMath oMath)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTOMath target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTOMath)get_store().find_element_user(OMATH$56, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(oMath);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "oMath" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTOMath insertNewOMath(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTOMath target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTOMath)get_store().insert_element_user(OMATH$56, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "oMath" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTOMath addNewOMath()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTOMath target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTOMath)get_store().add_element_user(OMATH$56);
            return target;
        }
    }
    
    /**
     * Removes the ith "oMath" element
     */
    public void removeOMath(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(OMATH$56, i);
        }
    }
    
    /**
     * Gets a List of "acc" elements
     */
    public java.util.List getAccList()
    {
        final class AccList extends java.util.AbstractList
        {
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTAcc get(int i)
                { return CTRunTrackChangeImpl.this.getAccArray(i); }
            
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTAcc set(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTAcc o)
            {
                org.openxmlformats.schemas.officeDocument.x2006.math.CTAcc old = CTRunTrackChangeImpl.this.getAccArray(i);
                CTRunTrackChangeImpl.this.setAccArray(i, o);
                return old;
            }
            
            public void add(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTAcc o)
                { CTRunTrackChangeImpl.this.insertNewAcc(i).set(o); }
            
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTAcc remove(int i)
            {
                org.openxmlformats.schemas.officeDocument.x2006.math.CTAcc old = CTRunTrackChangeImpl.this.getAccArray(i);
                CTRunTrackChangeImpl.this.removeAcc(i);
                return old;
            }
            
            public int size()
                { return CTRunTrackChangeImpl.this.sizeOfAccArray(); }
            
        }
        
        synchronized (monitor())
        {
            check_orphaned();
            return new AccList();
        }
    }
    
    /**
     * Gets array of all "acc" elements
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTAcc[] getAccArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(ACC$58, targetList);
            org.openxmlformats.schemas.officeDocument.x2006.math.CTAcc[] result = new org.openxmlformats.schemas.officeDocument.x2006.math.CTAcc[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "acc" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTAcc getAccArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTAcc target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTAcc)get_store().find_element_user(ACC$58, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "acc" element
     */
    public int sizeOfAccArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(ACC$58);
        }
    }
    
    /**
     * Sets array of all "acc" element
     */
    public void setAccArray(org.openxmlformats.schemas.officeDocument.x2006.math.CTAcc[] accArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(accArray, ACC$58);
        }
    }
    
    /**
     * Sets ith "acc" element
     */
    public void setAccArray(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTAcc acc)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTAcc target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTAcc)get_store().find_element_user(ACC$58, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(acc);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "acc" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTAcc insertNewAcc(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTAcc target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTAcc)get_store().insert_element_user(ACC$58, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "acc" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTAcc addNewAcc()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTAcc target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTAcc)get_store().add_element_user(ACC$58);
            return target;
        }
    }
    
    /**
     * Removes the ith "acc" element
     */
    public void removeAcc(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(ACC$58, i);
        }
    }
    
    /**
     * Gets a List of "bar" elements
     */
    public java.util.List getBarList()
    {
        final class BarList extends java.util.AbstractList
        {
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTBar get(int i)
                { return CTRunTrackChangeImpl.this.getBarArray(i); }
            
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTBar set(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTBar o)
            {
                org.openxmlformats.schemas.officeDocument.x2006.math.CTBar old = CTRunTrackChangeImpl.this.getBarArray(i);
                CTRunTrackChangeImpl.this.setBarArray(i, o);
                return old;
            }
            
            public void add(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTBar o)
                { CTRunTrackChangeImpl.this.insertNewBar(i).set(o); }
            
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTBar remove(int i)
            {
                org.openxmlformats.schemas.officeDocument.x2006.math.CTBar old = CTRunTrackChangeImpl.this.getBarArray(i);
                CTRunTrackChangeImpl.this.removeBar(i);
                return old;
            }
            
            public int size()
                { return CTRunTrackChangeImpl.this.sizeOfBarArray(); }
            
        }
        
        synchronized (monitor())
        {
            check_orphaned();
            return new BarList();
        }
    }
    
    /**
     * Gets array of all "bar" elements
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTBar[] getBarArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(BAR$60, targetList);
            org.openxmlformats.schemas.officeDocument.x2006.math.CTBar[] result = new org.openxmlformats.schemas.officeDocument.x2006.math.CTBar[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "bar" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTBar getBarArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTBar target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTBar)get_store().find_element_user(BAR$60, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "bar" element
     */
    public int sizeOfBarArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(BAR$60);
        }
    }
    
    /**
     * Sets array of all "bar" element
     */
    public void setBarArray(org.openxmlformats.schemas.officeDocument.x2006.math.CTBar[] barArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(barArray, BAR$60);
        }
    }
    
    /**
     * Sets ith "bar" element
     */
    public void setBarArray(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTBar bar)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTBar target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTBar)get_store().find_element_user(BAR$60, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(bar);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "bar" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTBar insertNewBar(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTBar target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTBar)get_store().insert_element_user(BAR$60, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "bar" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTBar addNewBar()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTBar target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTBar)get_store().add_element_user(BAR$60);
            return target;
        }
    }
    
    /**
     * Removes the ith "bar" element
     */
    public void removeBar(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(BAR$60, i);
        }
    }
    
    /**
     * Gets a List of "box" elements
     */
    public java.util.List getBoxList()
    {
        final class BoxList extends java.util.AbstractList
        {
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTBox get(int i)
                { return CTRunTrackChangeImpl.this.getBoxArray(i); }
            
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTBox set(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTBox o)
            {
                org.openxmlformats.schemas.officeDocument.x2006.math.CTBox old = CTRunTrackChangeImpl.this.getBoxArray(i);
                CTRunTrackChangeImpl.this.setBoxArray(i, o);
                return old;
            }
            
            public void add(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTBox o)
                { CTRunTrackChangeImpl.this.insertNewBox(i).set(o); }
            
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTBox remove(int i)
            {
                org.openxmlformats.schemas.officeDocument.x2006.math.CTBox old = CTRunTrackChangeImpl.this.getBoxArray(i);
                CTRunTrackChangeImpl.this.removeBox(i);
                return old;
            }
            
            public int size()
                { return CTRunTrackChangeImpl.this.sizeOfBoxArray(); }
            
        }
        
        synchronized (monitor())
        {
            check_orphaned();
            return new BoxList();
        }
    }
    
    /**
     * Gets array of all "box" elements
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTBox[] getBoxArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(BOX$62, targetList);
            org.openxmlformats.schemas.officeDocument.x2006.math.CTBox[] result = new org.openxmlformats.schemas.officeDocument.x2006.math.CTBox[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "box" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTBox getBoxArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTBox target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTBox)get_store().find_element_user(BOX$62, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "box" element
     */
    public int sizeOfBoxArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(BOX$62);
        }
    }
    
    /**
     * Sets array of all "box" element
     */
    public void setBoxArray(org.openxmlformats.schemas.officeDocument.x2006.math.CTBox[] boxArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(boxArray, BOX$62);
        }
    }
    
    /**
     * Sets ith "box" element
     */
    public void setBoxArray(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTBox box)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTBox target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTBox)get_store().find_element_user(BOX$62, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(box);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "box" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTBox insertNewBox(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTBox target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTBox)get_store().insert_element_user(BOX$62, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "box" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTBox addNewBox()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTBox target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTBox)get_store().add_element_user(BOX$62);
            return target;
        }
    }
    
    /**
     * Removes the ith "box" element
     */
    public void removeBox(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(BOX$62, i);
        }
    }
    
    /**
     * Gets a List of "borderBox" elements
     */
    public java.util.List getBorderBoxList()
    {
        final class BorderBoxList extends java.util.AbstractList
        {
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTBorderBox get(int i)
                { return CTRunTrackChangeImpl.this.getBorderBoxArray(i); }
            
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTBorderBox set(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTBorderBox o)
            {
                org.openxmlformats.schemas.officeDocument.x2006.math.CTBorderBox old = CTRunTrackChangeImpl.this.getBorderBoxArray(i);
                CTRunTrackChangeImpl.this.setBorderBoxArray(i, o);
                return old;
            }
            
            public void add(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTBorderBox o)
                { CTRunTrackChangeImpl.this.insertNewBorderBox(i).set(o); }
            
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTBorderBox remove(int i)
            {
                org.openxmlformats.schemas.officeDocument.x2006.math.CTBorderBox old = CTRunTrackChangeImpl.this.getBorderBoxArray(i);
                CTRunTrackChangeImpl.this.removeBorderBox(i);
                return old;
            }
            
            public int size()
                { return CTRunTrackChangeImpl.this.sizeOfBorderBoxArray(); }
            
        }
        
        synchronized (monitor())
        {
            check_orphaned();
            return new BorderBoxList();
        }
    }
    
    /**
     * Gets array of all "borderBox" elements
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTBorderBox[] getBorderBoxArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(BORDERBOX$64, targetList);
            org.openxmlformats.schemas.officeDocument.x2006.math.CTBorderBox[] result = new org.openxmlformats.schemas.officeDocument.x2006.math.CTBorderBox[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "borderBox" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTBorderBox getBorderBoxArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTBorderBox target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTBorderBox)get_store().find_element_user(BORDERBOX$64, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "borderBox" element
     */
    public int sizeOfBorderBoxArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(BORDERBOX$64);
        }
    }
    
    /**
     * Sets array of all "borderBox" element
     */
    public void setBorderBoxArray(org.openxmlformats.schemas.officeDocument.x2006.math.CTBorderBox[] borderBoxArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(borderBoxArray, BORDERBOX$64);
        }
    }
    
    /**
     * Sets ith "borderBox" element
     */
    public void setBorderBoxArray(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTBorderBox borderBox)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTBorderBox target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTBorderBox)get_store().find_element_user(BORDERBOX$64, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(borderBox);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "borderBox" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTBorderBox insertNewBorderBox(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTBorderBox target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTBorderBox)get_store().insert_element_user(BORDERBOX$64, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "borderBox" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTBorderBox addNewBorderBox()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTBorderBox target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTBorderBox)get_store().add_element_user(BORDERBOX$64);
            return target;
        }
    }
    
    /**
     * Removes the ith "borderBox" element
     */
    public void removeBorderBox(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(BORDERBOX$64, i);
        }
    }
    
    /**
     * Gets a List of "d" elements
     */
    public java.util.List getDList()
    {
        final class DList extends java.util.AbstractList
        {
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTD get(int i)
                { return CTRunTrackChangeImpl.this.getDArray(i); }
            
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTD set(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTD o)
            {
                org.openxmlformats.schemas.officeDocument.x2006.math.CTD old = CTRunTrackChangeImpl.this.getDArray(i);
                CTRunTrackChangeImpl.this.setDArray(i, o);
                return old;
            }
            
            public void add(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTD o)
                { CTRunTrackChangeImpl.this.insertNewD(i).set(o); }
            
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTD remove(int i)
            {
                org.openxmlformats.schemas.officeDocument.x2006.math.CTD old = CTRunTrackChangeImpl.this.getDArray(i);
                CTRunTrackChangeImpl.this.removeD(i);
                return old;
            }
            
            public int size()
                { return CTRunTrackChangeImpl.this.sizeOfDArray(); }
            
        }
        
        synchronized (monitor())
        {
            check_orphaned();
            return new DList();
        }
    }
    
    /**
     * Gets array of all "d" elements
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTD[] getDArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(D$66, targetList);
            org.openxmlformats.schemas.officeDocument.x2006.math.CTD[] result = new org.openxmlformats.schemas.officeDocument.x2006.math.CTD[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "d" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTD getDArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTD target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTD)get_store().find_element_user(D$66, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "d" element
     */
    public int sizeOfDArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(D$66);
        }
    }
    
    /**
     * Sets array of all "d" element
     */
    public void setDArray(org.openxmlformats.schemas.officeDocument.x2006.math.CTD[] dArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(dArray, D$66);
        }
    }
    
    /**
     * Sets ith "d" element
     */
    public void setDArray(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTD d)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTD target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTD)get_store().find_element_user(D$66, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(d);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "d" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTD insertNewD(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTD target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTD)get_store().insert_element_user(D$66, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "d" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTD addNewD()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTD target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTD)get_store().add_element_user(D$66);
            return target;
        }
    }
    
    /**
     * Removes the ith "d" element
     */
    public void removeD(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(D$66, i);
        }
    }
    
    /**
     * Gets a List of "eqArr" elements
     */
    public java.util.List getEqArrList()
    {
        final class EqArrList extends java.util.AbstractList
        {
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTEqArr get(int i)
                { return CTRunTrackChangeImpl.this.getEqArrArray(i); }
            
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTEqArr set(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTEqArr o)
            {
                org.openxmlformats.schemas.officeDocument.x2006.math.CTEqArr old = CTRunTrackChangeImpl.this.getEqArrArray(i);
                CTRunTrackChangeImpl.this.setEqArrArray(i, o);
                return old;
            }
            
            public void add(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTEqArr o)
                { CTRunTrackChangeImpl.this.insertNewEqArr(i).set(o); }
            
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTEqArr remove(int i)
            {
                org.openxmlformats.schemas.officeDocument.x2006.math.CTEqArr old = CTRunTrackChangeImpl.this.getEqArrArray(i);
                CTRunTrackChangeImpl.this.removeEqArr(i);
                return old;
            }
            
            public int size()
                { return CTRunTrackChangeImpl.this.sizeOfEqArrArray(); }
            
        }
        
        synchronized (monitor())
        {
            check_orphaned();
            return new EqArrList();
        }
    }
    
    /**
     * Gets array of all "eqArr" elements
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTEqArr[] getEqArrArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(EQARR$68, targetList);
            org.openxmlformats.schemas.officeDocument.x2006.math.CTEqArr[] result = new org.openxmlformats.schemas.officeDocument.x2006.math.CTEqArr[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "eqArr" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTEqArr getEqArrArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTEqArr target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTEqArr)get_store().find_element_user(EQARR$68, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "eqArr" element
     */
    public int sizeOfEqArrArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(EQARR$68);
        }
    }
    
    /**
     * Sets array of all "eqArr" element
     */
    public void setEqArrArray(org.openxmlformats.schemas.officeDocument.x2006.math.CTEqArr[] eqArrArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(eqArrArray, EQARR$68);
        }
    }
    
    /**
     * Sets ith "eqArr" element
     */
    public void setEqArrArray(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTEqArr eqArr)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTEqArr target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTEqArr)get_store().find_element_user(EQARR$68, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(eqArr);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "eqArr" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTEqArr insertNewEqArr(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTEqArr target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTEqArr)get_store().insert_element_user(EQARR$68, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "eqArr" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTEqArr addNewEqArr()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTEqArr target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTEqArr)get_store().add_element_user(EQARR$68);
            return target;
        }
    }
    
    /**
     * Removes the ith "eqArr" element
     */
    public void removeEqArr(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(EQARR$68, i);
        }
    }
    
    /**
     * Gets a List of "f" elements
     */
    public java.util.List getFList()
    {
        final class FList extends java.util.AbstractList
        {
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTF get(int i)
                { return CTRunTrackChangeImpl.this.getFArray(i); }
            
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTF set(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTF o)
            {
                org.openxmlformats.schemas.officeDocument.x2006.math.CTF old = CTRunTrackChangeImpl.this.getFArray(i);
                CTRunTrackChangeImpl.this.setFArray(i, o);
                return old;
            }
            
            public void add(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTF o)
                { CTRunTrackChangeImpl.this.insertNewF(i).set(o); }
            
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTF remove(int i)
            {
                org.openxmlformats.schemas.officeDocument.x2006.math.CTF old = CTRunTrackChangeImpl.this.getFArray(i);
                CTRunTrackChangeImpl.this.removeF(i);
                return old;
            }
            
            public int size()
                { return CTRunTrackChangeImpl.this.sizeOfFArray(); }
            
        }
        
        synchronized (monitor())
        {
            check_orphaned();
            return new FList();
        }
    }
    
    /**
     * Gets array of all "f" elements
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTF[] getFArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(F$70, targetList);
            org.openxmlformats.schemas.officeDocument.x2006.math.CTF[] result = new org.openxmlformats.schemas.officeDocument.x2006.math.CTF[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "f" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTF getFArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTF target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTF)get_store().find_element_user(F$70, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "f" element
     */
    public int sizeOfFArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(F$70);
        }
    }
    
    /**
     * Sets array of all "f" element
     */
    public void setFArray(org.openxmlformats.schemas.officeDocument.x2006.math.CTF[] fArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(fArray, F$70);
        }
    }
    
    /**
     * Sets ith "f" element
     */
    public void setFArray(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTF f)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTF target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTF)get_store().find_element_user(F$70, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(f);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "f" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTF insertNewF(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTF target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTF)get_store().insert_element_user(F$70, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "f" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTF addNewF()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTF target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTF)get_store().add_element_user(F$70);
            return target;
        }
    }
    
    /**
     * Removes the ith "f" element
     */
    public void removeF(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(F$70, i);
        }
    }
    
    /**
     * Gets a List of "func" elements
     */
    public java.util.List getFuncList()
    {
        final class FuncList extends java.util.AbstractList
        {
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTFunc get(int i)
                { return CTRunTrackChangeImpl.this.getFuncArray(i); }
            
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTFunc set(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTFunc o)
            {
                org.openxmlformats.schemas.officeDocument.x2006.math.CTFunc old = CTRunTrackChangeImpl.this.getFuncArray(i);
                CTRunTrackChangeImpl.this.setFuncArray(i, o);
                return old;
            }
            
            public void add(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTFunc o)
                { CTRunTrackChangeImpl.this.insertNewFunc(i).set(o); }
            
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTFunc remove(int i)
            {
                org.openxmlformats.schemas.officeDocument.x2006.math.CTFunc old = CTRunTrackChangeImpl.this.getFuncArray(i);
                CTRunTrackChangeImpl.this.removeFunc(i);
                return old;
            }
            
            public int size()
                { return CTRunTrackChangeImpl.this.sizeOfFuncArray(); }
            
        }
        
        synchronized (monitor())
        {
            check_orphaned();
            return new FuncList();
        }
    }
    
    /**
     * Gets array of all "func" elements
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTFunc[] getFuncArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(FUNC$72, targetList);
            org.openxmlformats.schemas.officeDocument.x2006.math.CTFunc[] result = new org.openxmlformats.schemas.officeDocument.x2006.math.CTFunc[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "func" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTFunc getFuncArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTFunc target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTFunc)get_store().find_element_user(FUNC$72, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "func" element
     */
    public int sizeOfFuncArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(FUNC$72);
        }
    }
    
    /**
     * Sets array of all "func" element
     */
    public void setFuncArray(org.openxmlformats.schemas.officeDocument.x2006.math.CTFunc[] funcArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(funcArray, FUNC$72);
        }
    }
    
    /**
     * Sets ith "func" element
     */
    public void setFuncArray(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTFunc func)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTFunc target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTFunc)get_store().find_element_user(FUNC$72, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(func);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "func" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTFunc insertNewFunc(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTFunc target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTFunc)get_store().insert_element_user(FUNC$72, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "func" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTFunc addNewFunc()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTFunc target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTFunc)get_store().add_element_user(FUNC$72);
            return target;
        }
    }
    
    /**
     * Removes the ith "func" element
     */
    public void removeFunc(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(FUNC$72, i);
        }
    }
    
    /**
     * Gets a List of "groupChr" elements
     */
    public java.util.List getGroupChrList()
    {
        final class GroupChrList extends java.util.AbstractList
        {
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTGroupChr get(int i)
                { return CTRunTrackChangeImpl.this.getGroupChrArray(i); }
            
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTGroupChr set(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTGroupChr o)
            {
                org.openxmlformats.schemas.officeDocument.x2006.math.CTGroupChr old = CTRunTrackChangeImpl.this.getGroupChrArray(i);
                CTRunTrackChangeImpl.this.setGroupChrArray(i, o);
                return old;
            }
            
            public void add(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTGroupChr o)
                { CTRunTrackChangeImpl.this.insertNewGroupChr(i).set(o); }
            
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTGroupChr remove(int i)
            {
                org.openxmlformats.schemas.officeDocument.x2006.math.CTGroupChr old = CTRunTrackChangeImpl.this.getGroupChrArray(i);
                CTRunTrackChangeImpl.this.removeGroupChr(i);
                return old;
            }
            
            public int size()
                { return CTRunTrackChangeImpl.this.sizeOfGroupChrArray(); }
            
        }
        
        synchronized (monitor())
        {
            check_orphaned();
            return new GroupChrList();
        }
    }
    
    /**
     * Gets array of all "groupChr" elements
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTGroupChr[] getGroupChrArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(GROUPCHR$74, targetList);
            org.openxmlformats.schemas.officeDocument.x2006.math.CTGroupChr[] result = new org.openxmlformats.schemas.officeDocument.x2006.math.CTGroupChr[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "groupChr" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTGroupChr getGroupChrArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTGroupChr target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTGroupChr)get_store().find_element_user(GROUPCHR$74, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "groupChr" element
     */
    public int sizeOfGroupChrArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(GROUPCHR$74);
        }
    }
    
    /**
     * Sets array of all "groupChr" element
     */
    public void setGroupChrArray(org.openxmlformats.schemas.officeDocument.x2006.math.CTGroupChr[] groupChrArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(groupChrArray, GROUPCHR$74);
        }
    }
    
    /**
     * Sets ith "groupChr" element
     */
    public void setGroupChrArray(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTGroupChr groupChr)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTGroupChr target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTGroupChr)get_store().find_element_user(GROUPCHR$74, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(groupChr);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "groupChr" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTGroupChr insertNewGroupChr(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTGroupChr target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTGroupChr)get_store().insert_element_user(GROUPCHR$74, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "groupChr" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTGroupChr addNewGroupChr()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTGroupChr target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTGroupChr)get_store().add_element_user(GROUPCHR$74);
            return target;
        }
    }
    
    /**
     * Removes the ith "groupChr" element
     */
    public void removeGroupChr(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(GROUPCHR$74, i);
        }
    }
    
    /**
     * Gets a List of "limLow" elements
     */
    public java.util.List getLimLowList()
    {
        final class LimLowList extends java.util.AbstractList
        {
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTLimLow get(int i)
                { return CTRunTrackChangeImpl.this.getLimLowArray(i); }
            
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTLimLow set(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTLimLow o)
            {
                org.openxmlformats.schemas.officeDocument.x2006.math.CTLimLow old = CTRunTrackChangeImpl.this.getLimLowArray(i);
                CTRunTrackChangeImpl.this.setLimLowArray(i, o);
                return old;
            }
            
            public void add(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTLimLow o)
                { CTRunTrackChangeImpl.this.insertNewLimLow(i).set(o); }
            
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTLimLow remove(int i)
            {
                org.openxmlformats.schemas.officeDocument.x2006.math.CTLimLow old = CTRunTrackChangeImpl.this.getLimLowArray(i);
                CTRunTrackChangeImpl.this.removeLimLow(i);
                return old;
            }
            
            public int size()
                { return CTRunTrackChangeImpl.this.sizeOfLimLowArray(); }
            
        }
        
        synchronized (monitor())
        {
            check_orphaned();
            return new LimLowList();
        }
    }
    
    /**
     * Gets array of all "limLow" elements
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTLimLow[] getLimLowArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(LIMLOW$76, targetList);
            org.openxmlformats.schemas.officeDocument.x2006.math.CTLimLow[] result = new org.openxmlformats.schemas.officeDocument.x2006.math.CTLimLow[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "limLow" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTLimLow getLimLowArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTLimLow target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTLimLow)get_store().find_element_user(LIMLOW$76, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "limLow" element
     */
    public int sizeOfLimLowArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(LIMLOW$76);
        }
    }
    
    /**
     * Sets array of all "limLow" element
     */
    public void setLimLowArray(org.openxmlformats.schemas.officeDocument.x2006.math.CTLimLow[] limLowArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(limLowArray, LIMLOW$76);
        }
    }
    
    /**
     * Sets ith "limLow" element
     */
    public void setLimLowArray(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTLimLow limLow)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTLimLow target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTLimLow)get_store().find_element_user(LIMLOW$76, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(limLow);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "limLow" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTLimLow insertNewLimLow(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTLimLow target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTLimLow)get_store().insert_element_user(LIMLOW$76, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "limLow" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTLimLow addNewLimLow()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTLimLow target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTLimLow)get_store().add_element_user(LIMLOW$76);
            return target;
        }
    }
    
    /**
     * Removes the ith "limLow" element
     */
    public void removeLimLow(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(LIMLOW$76, i);
        }
    }
    
    /**
     * Gets a List of "limUpp" elements
     */
    public java.util.List getLimUppList()
    {
        final class LimUppList extends java.util.AbstractList
        {
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTLimUpp get(int i)
                { return CTRunTrackChangeImpl.this.getLimUppArray(i); }
            
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTLimUpp set(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTLimUpp o)
            {
                org.openxmlformats.schemas.officeDocument.x2006.math.CTLimUpp old = CTRunTrackChangeImpl.this.getLimUppArray(i);
                CTRunTrackChangeImpl.this.setLimUppArray(i, o);
                return old;
            }
            
            public void add(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTLimUpp o)
                { CTRunTrackChangeImpl.this.insertNewLimUpp(i).set(o); }
            
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTLimUpp remove(int i)
            {
                org.openxmlformats.schemas.officeDocument.x2006.math.CTLimUpp old = CTRunTrackChangeImpl.this.getLimUppArray(i);
                CTRunTrackChangeImpl.this.removeLimUpp(i);
                return old;
            }
            
            public int size()
                { return CTRunTrackChangeImpl.this.sizeOfLimUppArray(); }
            
        }
        
        synchronized (monitor())
        {
            check_orphaned();
            return new LimUppList();
        }
    }
    
    /**
     * Gets array of all "limUpp" elements
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTLimUpp[] getLimUppArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(LIMUPP$78, targetList);
            org.openxmlformats.schemas.officeDocument.x2006.math.CTLimUpp[] result = new org.openxmlformats.schemas.officeDocument.x2006.math.CTLimUpp[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "limUpp" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTLimUpp getLimUppArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTLimUpp target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTLimUpp)get_store().find_element_user(LIMUPP$78, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "limUpp" element
     */
    public int sizeOfLimUppArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(LIMUPP$78);
        }
    }
    
    /**
     * Sets array of all "limUpp" element
     */
    public void setLimUppArray(org.openxmlformats.schemas.officeDocument.x2006.math.CTLimUpp[] limUppArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(limUppArray, LIMUPP$78);
        }
    }
    
    /**
     * Sets ith "limUpp" element
     */
    public void setLimUppArray(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTLimUpp limUpp)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTLimUpp target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTLimUpp)get_store().find_element_user(LIMUPP$78, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(limUpp);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "limUpp" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTLimUpp insertNewLimUpp(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTLimUpp target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTLimUpp)get_store().insert_element_user(LIMUPP$78, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "limUpp" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTLimUpp addNewLimUpp()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTLimUpp target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTLimUpp)get_store().add_element_user(LIMUPP$78);
            return target;
        }
    }
    
    /**
     * Removes the ith "limUpp" element
     */
    public void removeLimUpp(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(LIMUPP$78, i);
        }
    }
    
    /**
     * Gets a List of "m" elements
     */
    public java.util.List getMList()
    {
        final class MList extends java.util.AbstractList
        {
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTM get(int i)
                { return CTRunTrackChangeImpl.this.getMArray(i); }
            
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTM set(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTM o)
            {
                org.openxmlformats.schemas.officeDocument.x2006.math.CTM old = CTRunTrackChangeImpl.this.getMArray(i);
                CTRunTrackChangeImpl.this.setMArray(i, o);
                return old;
            }
            
            public void add(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTM o)
                { CTRunTrackChangeImpl.this.insertNewM(i).set(o); }
            
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTM remove(int i)
            {
                org.openxmlformats.schemas.officeDocument.x2006.math.CTM old = CTRunTrackChangeImpl.this.getMArray(i);
                CTRunTrackChangeImpl.this.removeM(i);
                return old;
            }
            
            public int size()
                { return CTRunTrackChangeImpl.this.sizeOfMArray(); }
            
        }
        
        synchronized (monitor())
        {
            check_orphaned();
            return new MList();
        }
    }
    
    /**
     * Gets array of all "m" elements
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTM[] getMArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(M$80, targetList);
            org.openxmlformats.schemas.officeDocument.x2006.math.CTM[] result = new org.openxmlformats.schemas.officeDocument.x2006.math.CTM[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "m" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTM getMArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTM target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTM)get_store().find_element_user(M$80, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "m" element
     */
    public int sizeOfMArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(M$80);
        }
    }
    
    /**
     * Sets array of all "m" element
     */
    public void setMArray(org.openxmlformats.schemas.officeDocument.x2006.math.CTM[] mArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(mArray, M$80);
        }
    }
    
    /**
     * Sets ith "m" element
     */
    public void setMArray(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTM m)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTM target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTM)get_store().find_element_user(M$80, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(m);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "m" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTM insertNewM(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTM target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTM)get_store().insert_element_user(M$80, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "m" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTM addNewM()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTM target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTM)get_store().add_element_user(M$80);
            return target;
        }
    }
    
    /**
     * Removes the ith "m" element
     */
    public void removeM(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(M$80, i);
        }
    }
    
    /**
     * Gets a List of "nary" elements
     */
    public java.util.List getNaryList()
    {
        final class NaryList extends java.util.AbstractList
        {
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTNary get(int i)
                { return CTRunTrackChangeImpl.this.getNaryArray(i); }
            
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTNary set(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTNary o)
            {
                org.openxmlformats.schemas.officeDocument.x2006.math.CTNary old = CTRunTrackChangeImpl.this.getNaryArray(i);
                CTRunTrackChangeImpl.this.setNaryArray(i, o);
                return old;
            }
            
            public void add(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTNary o)
                { CTRunTrackChangeImpl.this.insertNewNary(i).set(o); }
            
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTNary remove(int i)
            {
                org.openxmlformats.schemas.officeDocument.x2006.math.CTNary old = CTRunTrackChangeImpl.this.getNaryArray(i);
                CTRunTrackChangeImpl.this.removeNary(i);
                return old;
            }
            
            public int size()
                { return CTRunTrackChangeImpl.this.sizeOfNaryArray(); }
            
        }
        
        synchronized (monitor())
        {
            check_orphaned();
            return new NaryList();
        }
    }
    
    /**
     * Gets array of all "nary" elements
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTNary[] getNaryArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(NARY$82, targetList);
            org.openxmlformats.schemas.officeDocument.x2006.math.CTNary[] result = new org.openxmlformats.schemas.officeDocument.x2006.math.CTNary[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "nary" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTNary getNaryArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTNary target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTNary)get_store().find_element_user(NARY$82, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "nary" element
     */
    public int sizeOfNaryArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(NARY$82);
        }
    }
    
    /**
     * Sets array of all "nary" element
     */
    public void setNaryArray(org.openxmlformats.schemas.officeDocument.x2006.math.CTNary[] naryArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(naryArray, NARY$82);
        }
    }
    
    /**
     * Sets ith "nary" element
     */
    public void setNaryArray(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTNary nary)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTNary target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTNary)get_store().find_element_user(NARY$82, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(nary);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "nary" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTNary insertNewNary(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTNary target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTNary)get_store().insert_element_user(NARY$82, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "nary" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTNary addNewNary()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTNary target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTNary)get_store().add_element_user(NARY$82);
            return target;
        }
    }
    
    /**
     * Removes the ith "nary" element
     */
    public void removeNary(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(NARY$82, i);
        }
    }
    
    /**
     * Gets a List of "phant" elements
     */
    public java.util.List getPhantList()
    {
        final class PhantList extends java.util.AbstractList
        {
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTPhant get(int i)
                { return CTRunTrackChangeImpl.this.getPhantArray(i); }
            
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTPhant set(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTPhant o)
            {
                org.openxmlformats.schemas.officeDocument.x2006.math.CTPhant old = CTRunTrackChangeImpl.this.getPhantArray(i);
                CTRunTrackChangeImpl.this.setPhantArray(i, o);
                return old;
            }
            
            public void add(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTPhant o)
                { CTRunTrackChangeImpl.this.insertNewPhant(i).set(o); }
            
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTPhant remove(int i)
            {
                org.openxmlformats.schemas.officeDocument.x2006.math.CTPhant old = CTRunTrackChangeImpl.this.getPhantArray(i);
                CTRunTrackChangeImpl.this.removePhant(i);
                return old;
            }
            
            public int size()
                { return CTRunTrackChangeImpl.this.sizeOfPhantArray(); }
            
        }
        
        synchronized (monitor())
        {
            check_orphaned();
            return new PhantList();
        }
    }
    
    /**
     * Gets array of all "phant" elements
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTPhant[] getPhantArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(PHANT$84, targetList);
            org.openxmlformats.schemas.officeDocument.x2006.math.CTPhant[] result = new org.openxmlformats.schemas.officeDocument.x2006.math.CTPhant[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "phant" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTPhant getPhantArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTPhant target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTPhant)get_store().find_element_user(PHANT$84, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "phant" element
     */
    public int sizeOfPhantArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(PHANT$84);
        }
    }
    
    /**
     * Sets array of all "phant" element
     */
    public void setPhantArray(org.openxmlformats.schemas.officeDocument.x2006.math.CTPhant[] phantArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(phantArray, PHANT$84);
        }
    }
    
    /**
     * Sets ith "phant" element
     */
    public void setPhantArray(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTPhant phant)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTPhant target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTPhant)get_store().find_element_user(PHANT$84, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(phant);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "phant" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTPhant insertNewPhant(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTPhant target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTPhant)get_store().insert_element_user(PHANT$84, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "phant" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTPhant addNewPhant()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTPhant target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTPhant)get_store().add_element_user(PHANT$84);
            return target;
        }
    }
    
    /**
     * Removes the ith "phant" element
     */
    public void removePhant(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(PHANT$84, i);
        }
    }
    
    /**
     * Gets a List of "rad" elements
     */
    public java.util.List getRadList()
    {
        final class RadList extends java.util.AbstractList
        {
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTRad get(int i)
                { return CTRunTrackChangeImpl.this.getRadArray(i); }
            
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTRad set(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTRad o)
            {
                org.openxmlformats.schemas.officeDocument.x2006.math.CTRad old = CTRunTrackChangeImpl.this.getRadArray(i);
                CTRunTrackChangeImpl.this.setRadArray(i, o);
                return old;
            }
            
            public void add(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTRad o)
                { CTRunTrackChangeImpl.this.insertNewRad(i).set(o); }
            
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTRad remove(int i)
            {
                org.openxmlformats.schemas.officeDocument.x2006.math.CTRad old = CTRunTrackChangeImpl.this.getRadArray(i);
                CTRunTrackChangeImpl.this.removeRad(i);
                return old;
            }
            
            public int size()
                { return CTRunTrackChangeImpl.this.sizeOfRadArray(); }
            
        }
        
        synchronized (monitor())
        {
            check_orphaned();
            return new RadList();
        }
    }
    
    /**
     * Gets array of all "rad" elements
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTRad[] getRadArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(RAD$86, targetList);
            org.openxmlformats.schemas.officeDocument.x2006.math.CTRad[] result = new org.openxmlformats.schemas.officeDocument.x2006.math.CTRad[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "rad" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTRad getRadArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTRad target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTRad)get_store().find_element_user(RAD$86, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "rad" element
     */
    public int sizeOfRadArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(RAD$86);
        }
    }
    
    /**
     * Sets array of all "rad" element
     */
    public void setRadArray(org.openxmlformats.schemas.officeDocument.x2006.math.CTRad[] radArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(radArray, RAD$86);
        }
    }
    
    /**
     * Sets ith "rad" element
     */
    public void setRadArray(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTRad rad)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTRad target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTRad)get_store().find_element_user(RAD$86, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(rad);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "rad" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTRad insertNewRad(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTRad target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTRad)get_store().insert_element_user(RAD$86, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "rad" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTRad addNewRad()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTRad target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTRad)get_store().add_element_user(RAD$86);
            return target;
        }
    }
    
    /**
     * Removes the ith "rad" element
     */
    public void removeRad(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(RAD$86, i);
        }
    }
    
    /**
     * Gets a List of "sPre" elements
     */
    public java.util.List getSPreList()
    {
        final class SPreList extends java.util.AbstractList
        {
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTSPre get(int i)
                { return CTRunTrackChangeImpl.this.getSPreArray(i); }
            
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTSPre set(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTSPre o)
            {
                org.openxmlformats.schemas.officeDocument.x2006.math.CTSPre old = CTRunTrackChangeImpl.this.getSPreArray(i);
                CTRunTrackChangeImpl.this.setSPreArray(i, o);
                return old;
            }
            
            public void add(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTSPre o)
                { CTRunTrackChangeImpl.this.insertNewSPre(i).set(o); }
            
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTSPre remove(int i)
            {
                org.openxmlformats.schemas.officeDocument.x2006.math.CTSPre old = CTRunTrackChangeImpl.this.getSPreArray(i);
                CTRunTrackChangeImpl.this.removeSPre(i);
                return old;
            }
            
            public int size()
                { return CTRunTrackChangeImpl.this.sizeOfSPreArray(); }
            
        }
        
        synchronized (monitor())
        {
            check_orphaned();
            return new SPreList();
        }
    }
    
    /**
     * Gets array of all "sPre" elements
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTSPre[] getSPreArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(SPRE$88, targetList);
            org.openxmlformats.schemas.officeDocument.x2006.math.CTSPre[] result = new org.openxmlformats.schemas.officeDocument.x2006.math.CTSPre[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "sPre" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTSPre getSPreArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTSPre target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTSPre)get_store().find_element_user(SPRE$88, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "sPre" element
     */
    public int sizeOfSPreArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SPRE$88);
        }
    }
    
    /**
     * Sets array of all "sPre" element
     */
    public void setSPreArray(org.openxmlformats.schemas.officeDocument.x2006.math.CTSPre[] sPreArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(sPreArray, SPRE$88);
        }
    }
    
    /**
     * Sets ith "sPre" element
     */
    public void setSPreArray(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTSPre sPre)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTSPre target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTSPre)get_store().find_element_user(SPRE$88, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(sPre);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "sPre" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTSPre insertNewSPre(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTSPre target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTSPre)get_store().insert_element_user(SPRE$88, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "sPre" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTSPre addNewSPre()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTSPre target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTSPre)get_store().add_element_user(SPRE$88);
            return target;
        }
    }
    
    /**
     * Removes the ith "sPre" element
     */
    public void removeSPre(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SPRE$88, i);
        }
    }
    
    /**
     * Gets a List of "sSub" elements
     */
    public java.util.List getSSubList()
    {
        final class SSubList extends java.util.AbstractList
        {
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTSSub get(int i)
                { return CTRunTrackChangeImpl.this.getSSubArray(i); }
            
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTSSub set(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTSSub o)
            {
                org.openxmlformats.schemas.officeDocument.x2006.math.CTSSub old = CTRunTrackChangeImpl.this.getSSubArray(i);
                CTRunTrackChangeImpl.this.setSSubArray(i, o);
                return old;
            }
            
            public void add(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTSSub o)
                { CTRunTrackChangeImpl.this.insertNewSSub(i).set(o); }
            
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTSSub remove(int i)
            {
                org.openxmlformats.schemas.officeDocument.x2006.math.CTSSub old = CTRunTrackChangeImpl.this.getSSubArray(i);
                CTRunTrackChangeImpl.this.removeSSub(i);
                return old;
            }
            
            public int size()
                { return CTRunTrackChangeImpl.this.sizeOfSSubArray(); }
            
        }
        
        synchronized (monitor())
        {
            check_orphaned();
            return new SSubList();
        }
    }
    
    /**
     * Gets array of all "sSub" elements
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTSSub[] getSSubArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(SSUB$90, targetList);
            org.openxmlformats.schemas.officeDocument.x2006.math.CTSSub[] result = new org.openxmlformats.schemas.officeDocument.x2006.math.CTSSub[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "sSub" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTSSub getSSubArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTSSub target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTSSub)get_store().find_element_user(SSUB$90, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "sSub" element
     */
    public int sizeOfSSubArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SSUB$90);
        }
    }
    
    /**
     * Sets array of all "sSub" element
     */
    public void setSSubArray(org.openxmlformats.schemas.officeDocument.x2006.math.CTSSub[] sSubArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(sSubArray, SSUB$90);
        }
    }
    
    /**
     * Sets ith "sSub" element
     */
    public void setSSubArray(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTSSub sSub)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTSSub target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTSSub)get_store().find_element_user(SSUB$90, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(sSub);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "sSub" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTSSub insertNewSSub(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTSSub target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTSSub)get_store().insert_element_user(SSUB$90, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "sSub" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTSSub addNewSSub()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTSSub target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTSSub)get_store().add_element_user(SSUB$90);
            return target;
        }
    }
    
    /**
     * Removes the ith "sSub" element
     */
    public void removeSSub(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SSUB$90, i);
        }
    }
    
    /**
     * Gets a List of "sSubSup" elements
     */
    public java.util.List getSSubSupList()
    {
        final class SSubSupList extends java.util.AbstractList
        {
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTSSubSup get(int i)
                { return CTRunTrackChangeImpl.this.getSSubSupArray(i); }
            
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTSSubSup set(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTSSubSup o)
            {
                org.openxmlformats.schemas.officeDocument.x2006.math.CTSSubSup old = CTRunTrackChangeImpl.this.getSSubSupArray(i);
                CTRunTrackChangeImpl.this.setSSubSupArray(i, o);
                return old;
            }
            
            public void add(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTSSubSup o)
                { CTRunTrackChangeImpl.this.insertNewSSubSup(i).set(o); }
            
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTSSubSup remove(int i)
            {
                org.openxmlformats.schemas.officeDocument.x2006.math.CTSSubSup old = CTRunTrackChangeImpl.this.getSSubSupArray(i);
                CTRunTrackChangeImpl.this.removeSSubSup(i);
                return old;
            }
            
            public int size()
                { return CTRunTrackChangeImpl.this.sizeOfSSubSupArray(); }
            
        }
        
        synchronized (monitor())
        {
            check_orphaned();
            return new SSubSupList();
        }
    }
    
    /**
     * Gets array of all "sSubSup" elements
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTSSubSup[] getSSubSupArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(SSUBSUP$92, targetList);
            org.openxmlformats.schemas.officeDocument.x2006.math.CTSSubSup[] result = new org.openxmlformats.schemas.officeDocument.x2006.math.CTSSubSup[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "sSubSup" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTSSubSup getSSubSupArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTSSubSup target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTSSubSup)get_store().find_element_user(SSUBSUP$92, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "sSubSup" element
     */
    public int sizeOfSSubSupArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SSUBSUP$92);
        }
    }
    
    /**
     * Sets array of all "sSubSup" element
     */
    public void setSSubSupArray(org.openxmlformats.schemas.officeDocument.x2006.math.CTSSubSup[] sSubSupArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(sSubSupArray, SSUBSUP$92);
        }
    }
    
    /**
     * Sets ith "sSubSup" element
     */
    public void setSSubSupArray(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTSSubSup sSubSup)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTSSubSup target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTSSubSup)get_store().find_element_user(SSUBSUP$92, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(sSubSup);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "sSubSup" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTSSubSup insertNewSSubSup(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTSSubSup target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTSSubSup)get_store().insert_element_user(SSUBSUP$92, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "sSubSup" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTSSubSup addNewSSubSup()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTSSubSup target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTSSubSup)get_store().add_element_user(SSUBSUP$92);
            return target;
        }
    }
    
    /**
     * Removes the ith "sSubSup" element
     */
    public void removeSSubSup(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SSUBSUP$92, i);
        }
    }
    
    /**
     * Gets a List of "sSup" elements
     */
    public java.util.List getSSupList()
    {
        final class SSupList extends java.util.AbstractList
        {
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTSSup get(int i)
                { return CTRunTrackChangeImpl.this.getSSupArray(i); }
            
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTSSup set(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTSSup o)
            {
                org.openxmlformats.schemas.officeDocument.x2006.math.CTSSup old = CTRunTrackChangeImpl.this.getSSupArray(i);
                CTRunTrackChangeImpl.this.setSSupArray(i, o);
                return old;
            }
            
            public void add(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTSSup o)
                { CTRunTrackChangeImpl.this.insertNewSSup(i).set(o); }
            
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTSSup remove(int i)
            {
                org.openxmlformats.schemas.officeDocument.x2006.math.CTSSup old = CTRunTrackChangeImpl.this.getSSupArray(i);
                CTRunTrackChangeImpl.this.removeSSup(i);
                return old;
            }
            
            public int size()
                { return CTRunTrackChangeImpl.this.sizeOfSSupArray(); }
            
        }
        
        synchronized (monitor())
        {
            check_orphaned();
            return new SSupList();
        }
    }
    
    /**
     * Gets array of all "sSup" elements
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTSSup[] getSSupArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(SSUP$94, targetList);
            org.openxmlformats.schemas.officeDocument.x2006.math.CTSSup[] result = new org.openxmlformats.schemas.officeDocument.x2006.math.CTSSup[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "sSup" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTSSup getSSupArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTSSup target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTSSup)get_store().find_element_user(SSUP$94, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "sSup" element
     */
    public int sizeOfSSupArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SSUP$94);
        }
    }
    
    /**
     * Sets array of all "sSup" element
     */
    public void setSSupArray(org.openxmlformats.schemas.officeDocument.x2006.math.CTSSup[] sSupArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(sSupArray, SSUP$94);
        }
    }
    
    /**
     * Sets ith "sSup" element
     */
    public void setSSupArray(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTSSup sSup)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTSSup target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTSSup)get_store().find_element_user(SSUP$94, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(sSup);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "sSup" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTSSup insertNewSSup(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTSSup target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTSSup)get_store().insert_element_user(SSUP$94, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "sSup" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTSSup addNewSSup()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTSSup target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTSSup)get_store().add_element_user(SSUP$94);
            return target;
        }
    }
    
    /**
     * Removes the ith "sSup" element
     */
    public void removeSSup(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SSUP$94, i);
        }
    }
    
    /**
     * Gets a List of "r" elements
     */
    public java.util.List getR2List()
    {
        final class R2List extends java.util.AbstractList
        {
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTR get(int i)
                { return CTRunTrackChangeImpl.this.getR2Array(i); }
            
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTR set(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTR o)
            {
                org.openxmlformats.schemas.officeDocument.x2006.math.CTR old = CTRunTrackChangeImpl.this.getR2Array(i);
                CTRunTrackChangeImpl.this.setR2Array(i, o);
                return old;
            }
            
            public void add(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTR o)
                { CTRunTrackChangeImpl.this.insertNewR2(i).set(o); }
            
            public org.openxmlformats.schemas.officeDocument.x2006.math.CTR remove(int i)
            {
                org.openxmlformats.schemas.officeDocument.x2006.math.CTR old = CTRunTrackChangeImpl.this.getR2Array(i);
                CTRunTrackChangeImpl.this.removeR2(i);
                return old;
            }
            
            public int size()
                { return CTRunTrackChangeImpl.this.sizeOfR2Array(); }
            
        }
        
        synchronized (monitor())
        {
            check_orphaned();
            return new R2List();
        }
    }
    
    /**
     * Gets array of all "r" elements
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTR[] getR2Array()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(R2$96, targetList);
            org.openxmlformats.schemas.officeDocument.x2006.math.CTR[] result = new org.openxmlformats.schemas.officeDocument.x2006.math.CTR[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "r" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTR getR2Array(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTR target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTR)get_store().find_element_user(R2$96, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "r" element
     */
    public int sizeOfR2Array()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(R2$96);
        }
    }
    
    /**
     * Sets array of all "r" element
     */
    public void setR2Array(org.openxmlformats.schemas.officeDocument.x2006.math.CTR[] r2Array)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(r2Array, R2$96);
        }
    }
    
    /**
     * Sets ith "r" element
     */
    public void setR2Array(int i, org.openxmlformats.schemas.officeDocument.x2006.math.CTR r2)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTR target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTR)get_store().find_element_user(R2$96, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(r2);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "r" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTR insertNewR2(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTR target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTR)get_store().insert_element_user(R2$96, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "r" element
     */
    public org.openxmlformats.schemas.officeDocument.x2006.math.CTR addNewR2()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.math.CTR target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.math.CTR)get_store().add_element_user(R2$96);
            return target;
        }
    }
    
    /**
     * Removes the ith "r" element
     */
    public void removeR2(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(R2$96, i);
        }
    }
}




© 2015 - 2024 Weber Informatics LLC | Privacy Policy