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

io.github.isotes.vs.model.impl.MIDLDocument2Impl Maven / Gradle / Ivy

Go to download

Generated XMLBeans Java classes for the XML schema of MSBuild project files

The newest version!
/*
 * An XML document type.
 * Localname: MIDL
 * Namespace: http://schemas.microsoft.com/developer/msbuild/2003
 * Java type: io.github.isotes.vs.model.MIDLDocument2
 *
 * Automatically generated - do not modify.
 */
package io.github.isotes.vs.model.impl;
/**
 * A document containing one MIDL(@http://schemas.microsoft.com/developer/msbuild/2003) element.
 *
 * This is a complex type.
 */
public class MIDLDocument2Impl extends io.github.isotes.vs.model.impl.TaskDocumentImpl implements io.github.isotes.vs.model.MIDLDocument2
{
    private static final long serialVersionUID = 1L;
    
    public MIDLDocument2Impl(org.apache.xmlbeans.SchemaType sType)
    {
        super(sType);
    }
    
    private static final javax.xml.namespace.QName MIDL$0 = 
        new javax.xml.namespace.QName("http://schemas.microsoft.com/developer/msbuild/2003", "MIDL");
    
    
    /**
     * Gets the "MIDL" element
     */
    public io.github.isotes.vs.model.MIDLDocument2.MIDL getMIDL()
    {
        synchronized (monitor())
        {
            check_orphaned();
            io.github.isotes.vs.model.MIDLDocument2.MIDL target = null;
            target = (io.github.isotes.vs.model.MIDLDocument2.MIDL)get_store().find_element_user(MIDL$0, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * Sets the "MIDL" element
     */
    public void setMIDL(io.github.isotes.vs.model.MIDLDocument2.MIDL midl)
    {
        generatedSetterHelperImpl(midl, MIDL$0, 0, org.apache.xmlbeans.impl.values.XmlObjectBase.KIND_SETTERHELPER_SINGLETON);
    }
    
    /**
     * Appends and returns a new empty "MIDL" element
     */
    public io.github.isotes.vs.model.MIDLDocument2.MIDL addNewMIDL()
    {
        synchronized (monitor())
        {
            check_orphaned();
            io.github.isotes.vs.model.MIDLDocument2.MIDL target = null;
            target = (io.github.isotes.vs.model.MIDLDocument2.MIDL)get_store().add_element_user(MIDL$0);
            return target;
        }
    }
    /**
     * An XML MIDL(@http://schemas.microsoft.com/developer/msbuild/2003).
     *
     * This is a complex type.
     */
    public static class MIDLImpl extends io.github.isotes.vs.model.impl.TaskTypeImpl implements io.github.isotes.vs.model.MIDLDocument2.MIDL
    {
        private static final long serialVersionUID = 1L;
        
        public MIDLImpl(org.apache.xmlbeans.SchemaType sType)
        {
            super(sType);
        }
        
        private static final javax.xml.namespace.QName ACCEPTABLENONZEROEXITCODES$0 = 
            new javax.xml.namespace.QName("", "AcceptableNonZeroExitCodes");
        private static final javax.xml.namespace.QName ACTIVETOOLSWITCHESVALUES$2 = 
            new javax.xml.namespace.QName("", "ActiveToolSwitchesValues");
        private static final javax.xml.namespace.QName ADDITIONALINCLUDEDIRECTORIES$4 = 
            new javax.xml.namespace.QName("", "AdditionalIncludeDirectories");
        private static final javax.xml.namespace.QName ADDITIONALOPTIONS$6 = 
            new javax.xml.namespace.QName("", "AdditionalOptions");
        private static final javax.xml.namespace.QName APPLICATIONCONFIGURATIONMODE$8 = 
            new javax.xml.namespace.QName("", "ApplicationConfigurationMode");
        private static final javax.xml.namespace.QName CLIENTSTUBFILE$10 = 
            new javax.xml.namespace.QName("", "ClientStubFile");
        private static final javax.xml.namespace.QName CPREPROCESSOPTIONS$12 = 
            new javax.xml.namespace.QName("", "CPreprocessOptions");
        private static final javax.xml.namespace.QName DEFAULTCHARTYPE$14 = 
            new javax.xml.namespace.QName("", "DefaultCharType");
        private static final javax.xml.namespace.QName DLLDATAFILENAME$16 = 
            new javax.xml.namespace.QName("", "DllDataFileName");
        private static final javax.xml.namespace.QName ENABLEERRORCHECKS$18 = 
            new javax.xml.namespace.QName("", "EnableErrorChecks");
        private static final javax.xml.namespace.QName ENVIRONMENTVARIABLES$20 = 
            new javax.xml.namespace.QName("", "EnvironmentVariables");
        private static final javax.xml.namespace.QName ERRORCHECKALLOCATIONS$22 = 
            new javax.xml.namespace.QName("", "ErrorCheckAllocations");
        private static final javax.xml.namespace.QName ERRORCHECKBOUNDS$24 = 
            new javax.xml.namespace.QName("", "ErrorCheckBounds");
        private static final javax.xml.namespace.QName ERRORCHECKENUMRANGE$26 = 
            new javax.xml.namespace.QName("", "ErrorCheckEnumRange");
        private static final javax.xml.namespace.QName ERRORCHECKREFPOINTERS$28 = 
            new javax.xml.namespace.QName("", "ErrorCheckRefPointers");
        private static final javax.xml.namespace.QName ERRORCHECKSTUBDATA$30 = 
            new javax.xml.namespace.QName("", "ErrorCheckStubData");
        private static final javax.xml.namespace.QName EXCLUDEDINPUTPATHS$32 = 
            new javax.xml.namespace.QName("", "ExcludedInputPaths");
        private static final javax.xml.namespace.QName GENERATECLIENTFILES$34 = 
            new javax.xml.namespace.QName("", "GenerateClientFiles");
        private static final javax.xml.namespace.QName GENERATESERVERFILES$36 = 
            new javax.xml.namespace.QName("", "GenerateServerFiles");
        private static final javax.xml.namespace.QName GENERATESTUBLESSPROXIES$38 = 
            new javax.xml.namespace.QName("", "GenerateStublessProxies");
        private static final javax.xml.namespace.QName GENERATETYPELIBRARY$40 = 
            new javax.xml.namespace.QName("", "GenerateTypeLibrary");
        private static final javax.xml.namespace.QName HEADERFILENAME$42 = 
            new javax.xml.namespace.QName("", "HeaderFileName");
        private static final javax.xml.namespace.QName IGNORESTANDARDINCLUDEPATH$44 = 
            new javax.xml.namespace.QName("", "IgnoreStandardIncludePath");
        private static final javax.xml.namespace.QName INTERFACEIDENTIFIERFILENAME$46 = 
            new javax.xml.namespace.QName("", "InterfaceIdentifierFileName");
        private static final javax.xml.namespace.QName LOCALEID$48 = 
            new javax.xml.namespace.QName("", "LocaleID");
        private static final javax.xml.namespace.QName LOGSTANDARDERRORASERROR$50 = 
            new javax.xml.namespace.QName("", "LogStandardErrorAsError");
        private static final javax.xml.namespace.QName MINIMALREBUILDFROMTRACKING$52 = 
            new javax.xml.namespace.QName("", "MinimalRebuildFromTracking");
        private static final javax.xml.namespace.QName MKTYPLIBCOMPATIBLE$54 = 
            new javax.xml.namespace.QName("", "MkTypLibCompatible");
        private static final javax.xml.namespace.QName OUTPUTDIRECTORY$56 = 
            new javax.xml.namespace.QName("", "OutputDirectory");
        private static final javax.xml.namespace.QName PATHOVERRIDE$58 = 
            new javax.xml.namespace.QName("", "PathOverride");
        private static final javax.xml.namespace.QName PREPROCESSORDEFINITIONS$60 = 
            new javax.xml.namespace.QName("", "PreprocessorDefinitions");
        private static final javax.xml.namespace.QName PROXYFILENAME$62 = 
            new javax.xml.namespace.QName("", "ProxyFileName");
        private static final javax.xml.namespace.QName REDIRECTOUTPUTANDERRORS$64 = 
            new javax.xml.namespace.QName("", "RedirectOutputAndErrors");
        private static final javax.xml.namespace.QName SERVERSTUBFILE$66 = 
            new javax.xml.namespace.QName("", "ServerStubFile");
        private static final javax.xml.namespace.QName SKIPPEDEXECUTION$68 = 
            new javax.xml.namespace.QName("", "SkippedExecution");
        private static final javax.xml.namespace.QName SOURCE$70 = 
            new javax.xml.namespace.QName("", "Source");
        private static final javax.xml.namespace.QName SOURCESCOMPILED$72 = 
            new javax.xml.namespace.QName("", "SourcesCompiled");
        private static final javax.xml.namespace.QName STANDARDERRORIMPORTANCE$74 = 
            new javax.xml.namespace.QName("", "StandardErrorImportance");
        private static final javax.xml.namespace.QName STANDARDOUTPUTIMPORTANCE$76 = 
            new javax.xml.namespace.QName("", "StandardOutputImportance");
        private static final javax.xml.namespace.QName STRUCTMEMBERALIGNMENT$78 = 
            new javax.xml.namespace.QName("", "StructMemberAlignment");
        private static final javax.xml.namespace.QName SUPPRESSCOMPILERWARNINGS$80 = 
            new javax.xml.namespace.QName("", "SuppressCompilerWarnings");
        private static final javax.xml.namespace.QName SUPPRESSSTARTUPBANNER$82 = 
            new javax.xml.namespace.QName("", "SuppressStartupBanner");
        private static final javax.xml.namespace.QName TARGETENVIRONMENT$84 = 
            new javax.xml.namespace.QName("", "TargetEnvironment");
        private static final javax.xml.namespace.QName TIMEOUT$86 = 
            new javax.xml.namespace.QName("", "Timeout");
        private static final javax.xml.namespace.QName TLOGREADFILES$88 = 
            new javax.xml.namespace.QName("", "TLogReadFiles");
        private static final javax.xml.namespace.QName TLOGWRITEFILES$90 = 
            new javax.xml.namespace.QName("", "TLogWriteFiles");
        private static final javax.xml.namespace.QName TOOLEXE$92 = 
            new javax.xml.namespace.QName("", "ToolExe");
        private static final javax.xml.namespace.QName TOOLPATH$94 = 
            new javax.xml.namespace.QName("", "ToolPath");
        private static final javax.xml.namespace.QName TRACKEDINPUTFILESTOIGNORE$96 = 
            new javax.xml.namespace.QName("", "TrackedInputFilesToIgnore");
        private static final javax.xml.namespace.QName TRACKEDOUTPUTFILESTOIGNORE$98 = 
            new javax.xml.namespace.QName("", "TrackedOutputFilesToIgnore");
        private static final javax.xml.namespace.QName TRACKERLOGDIRECTORY$100 = 
            new javax.xml.namespace.QName("", "TrackerLogDirectory");
        private static final javax.xml.namespace.QName TRACKFILEACCESS$102 = 
            new javax.xml.namespace.QName("", "TrackFileAccess");
        private static final javax.xml.namespace.QName TYPELIBFORMAT$104 = 
            new javax.xml.namespace.QName("", "TypeLibFormat");
        private static final javax.xml.namespace.QName TYPELIBRARYNAME$106 = 
            new javax.xml.namespace.QName("", "TypeLibraryName");
        private static final javax.xml.namespace.QName UNDEFINEPREPROCESSORDEFINITIONS$108 = 
            new javax.xml.namespace.QName("", "UndefinePreprocessorDefinitions");
        private static final javax.xml.namespace.QName VALIDATEALLPARAMETERS$110 = 
            new javax.xml.namespace.QName("", "ValidateAllParameters");
        private static final javax.xml.namespace.QName WARNASERROR$112 = 
            new javax.xml.namespace.QName("", "WarnAsError");
        private static final javax.xml.namespace.QName WARNINGLEVEL$114 = 
            new javax.xml.namespace.QName("", "WarningLevel");
        
        
        /**
         * Gets the "AcceptableNonZeroExitCodes" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getAcceptableNonZeroExitCodes()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(ACCEPTABLENONZEROEXITCODES$0);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "AcceptableNonZeroExitCodes" attribute
         */
        public boolean isSetAcceptableNonZeroExitCodes()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(ACCEPTABLENONZEROEXITCODES$0) != null;
            }
        }
        
        /**
         * Sets the "AcceptableNonZeroExitCodes" attribute
         */
        public void setAcceptableNonZeroExitCodes(org.apache.xmlbeans.XmlAnySimpleType acceptableNonZeroExitCodes)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(ACCEPTABLENONZEROEXITCODES$0);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(ACCEPTABLENONZEROEXITCODES$0);
                }
                target.set(acceptableNonZeroExitCodes);
            }
        }
        
        /**
         * Appends and returns a new empty "AcceptableNonZeroExitCodes" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewAcceptableNonZeroExitCodes()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(ACCEPTABLENONZEROEXITCODES$0);
                return target;
            }
        }
        
        /**
         * Unsets the "AcceptableNonZeroExitCodes" attribute
         */
        public void unsetAcceptableNonZeroExitCodes()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(ACCEPTABLENONZEROEXITCODES$0);
            }
        }
        
        /**
         * Gets the "ActiveToolSwitchesValues" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getActiveToolSwitchesValues()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(ACTIVETOOLSWITCHESVALUES$2);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "ActiveToolSwitchesValues" attribute
         */
        public boolean isSetActiveToolSwitchesValues()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(ACTIVETOOLSWITCHESVALUES$2) != null;
            }
        }
        
        /**
         * Sets the "ActiveToolSwitchesValues" attribute
         */
        public void setActiveToolSwitchesValues(org.apache.xmlbeans.XmlAnySimpleType activeToolSwitchesValues)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(ACTIVETOOLSWITCHESVALUES$2);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(ACTIVETOOLSWITCHESVALUES$2);
                }
                target.set(activeToolSwitchesValues);
            }
        }
        
        /**
         * Appends and returns a new empty "ActiveToolSwitchesValues" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewActiveToolSwitchesValues()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(ACTIVETOOLSWITCHESVALUES$2);
                return target;
            }
        }
        
        /**
         * Unsets the "ActiveToolSwitchesValues" attribute
         */
        public void unsetActiveToolSwitchesValues()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(ACTIVETOOLSWITCHESVALUES$2);
            }
        }
        
        /**
         * Gets the "AdditionalIncludeDirectories" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getAdditionalIncludeDirectories()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(ADDITIONALINCLUDEDIRECTORIES$4);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "AdditionalIncludeDirectories" attribute
         */
        public boolean isSetAdditionalIncludeDirectories()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(ADDITIONALINCLUDEDIRECTORIES$4) != null;
            }
        }
        
        /**
         * Sets the "AdditionalIncludeDirectories" attribute
         */
        public void setAdditionalIncludeDirectories(org.apache.xmlbeans.XmlAnySimpleType additionalIncludeDirectories)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(ADDITIONALINCLUDEDIRECTORIES$4);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(ADDITIONALINCLUDEDIRECTORIES$4);
                }
                target.set(additionalIncludeDirectories);
            }
        }
        
        /**
         * Appends and returns a new empty "AdditionalIncludeDirectories" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewAdditionalIncludeDirectories()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(ADDITIONALINCLUDEDIRECTORIES$4);
                return target;
            }
        }
        
        /**
         * Unsets the "AdditionalIncludeDirectories" attribute
         */
        public void unsetAdditionalIncludeDirectories()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(ADDITIONALINCLUDEDIRECTORIES$4);
            }
        }
        
        /**
         * Gets the "AdditionalOptions" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getAdditionalOptions()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(ADDITIONALOPTIONS$6);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "AdditionalOptions" attribute
         */
        public boolean isSetAdditionalOptions()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(ADDITIONALOPTIONS$6) != null;
            }
        }
        
        /**
         * Sets the "AdditionalOptions" attribute
         */
        public void setAdditionalOptions(org.apache.xmlbeans.XmlAnySimpleType additionalOptions)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(ADDITIONALOPTIONS$6);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(ADDITIONALOPTIONS$6);
                }
                target.set(additionalOptions);
            }
        }
        
        /**
         * Appends and returns a new empty "AdditionalOptions" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewAdditionalOptions()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(ADDITIONALOPTIONS$6);
                return target;
            }
        }
        
        /**
         * Unsets the "AdditionalOptions" attribute
         */
        public void unsetAdditionalOptions()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(ADDITIONALOPTIONS$6);
            }
        }
        
        /**
         * Gets the "ApplicationConfigurationMode" attribute
         */
        public java.lang.String getApplicationConfigurationMode()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(APPLICATIONCONFIGURATIONMODE$8);
                if (target == null)
                {
                    return null;
                }
                return target.getStringValue();
            }
        }
        
        /**
         * Gets (as xml) the "ApplicationConfigurationMode" attribute
         */
        public io.github.isotes.vs.model.Boolean xgetApplicationConfigurationMode()
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(APPLICATIONCONFIGURATIONMODE$8);
                return target;
            }
        }
        
        /**
         * True if has "ApplicationConfigurationMode" attribute
         */
        public boolean isSetApplicationConfigurationMode()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(APPLICATIONCONFIGURATIONMODE$8) != null;
            }
        }
        
        /**
         * Sets the "ApplicationConfigurationMode" attribute
         */
        public void setApplicationConfigurationMode(java.lang.String applicationConfigurationMode)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(APPLICATIONCONFIGURATIONMODE$8);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(APPLICATIONCONFIGURATIONMODE$8);
                }
                target.setStringValue(applicationConfigurationMode);
            }
        }
        
        /**
         * Sets (as xml) the "ApplicationConfigurationMode" attribute
         */
        public void xsetApplicationConfigurationMode(io.github.isotes.vs.model.Boolean applicationConfigurationMode)
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(APPLICATIONCONFIGURATIONMODE$8);
                if (target == null)
                {
                    target = (io.github.isotes.vs.model.Boolean)get_store().add_attribute_user(APPLICATIONCONFIGURATIONMODE$8);
                }
                target.set(applicationConfigurationMode);
            }
        }
        
        /**
         * Unsets the "ApplicationConfigurationMode" attribute
         */
        public void unsetApplicationConfigurationMode()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(APPLICATIONCONFIGURATIONMODE$8);
            }
        }
        
        /**
         * Gets the "ClientStubFile" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getClientStubFile()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(CLIENTSTUBFILE$10);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "ClientStubFile" attribute
         */
        public boolean isSetClientStubFile()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(CLIENTSTUBFILE$10) != null;
            }
        }
        
        /**
         * Sets the "ClientStubFile" attribute
         */
        public void setClientStubFile(org.apache.xmlbeans.XmlAnySimpleType clientStubFile)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(CLIENTSTUBFILE$10);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(CLIENTSTUBFILE$10);
                }
                target.set(clientStubFile);
            }
        }
        
        /**
         * Appends and returns a new empty "ClientStubFile" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewClientStubFile()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(CLIENTSTUBFILE$10);
                return target;
            }
        }
        
        /**
         * Unsets the "ClientStubFile" attribute
         */
        public void unsetClientStubFile()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(CLIENTSTUBFILE$10);
            }
        }
        
        /**
         * Gets the "CPreprocessOptions" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getCPreprocessOptions()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(CPREPROCESSOPTIONS$12);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "CPreprocessOptions" attribute
         */
        public boolean isSetCPreprocessOptions()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(CPREPROCESSOPTIONS$12) != null;
            }
        }
        
        /**
         * Sets the "CPreprocessOptions" attribute
         */
        public void setCPreprocessOptions(org.apache.xmlbeans.XmlAnySimpleType cPreprocessOptions)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(CPREPROCESSOPTIONS$12);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(CPREPROCESSOPTIONS$12);
                }
                target.set(cPreprocessOptions);
            }
        }
        
        /**
         * Appends and returns a new empty "CPreprocessOptions" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewCPreprocessOptions()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(CPREPROCESSOPTIONS$12);
                return target;
            }
        }
        
        /**
         * Unsets the "CPreprocessOptions" attribute
         */
        public void unsetCPreprocessOptions()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(CPREPROCESSOPTIONS$12);
            }
        }
        
        /**
         * Gets the "DefaultCharType" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getDefaultCharType()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(DEFAULTCHARTYPE$14);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "DefaultCharType" attribute
         */
        public boolean isSetDefaultCharType()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(DEFAULTCHARTYPE$14) != null;
            }
        }
        
        /**
         * Sets the "DefaultCharType" attribute
         */
        public void setDefaultCharType(org.apache.xmlbeans.XmlAnySimpleType defaultCharType)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(DEFAULTCHARTYPE$14);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(DEFAULTCHARTYPE$14);
                }
                target.set(defaultCharType);
            }
        }
        
        /**
         * Appends and returns a new empty "DefaultCharType" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewDefaultCharType()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(DEFAULTCHARTYPE$14);
                return target;
            }
        }
        
        /**
         * Unsets the "DefaultCharType" attribute
         */
        public void unsetDefaultCharType()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(DEFAULTCHARTYPE$14);
            }
        }
        
        /**
         * Gets the "DllDataFileName" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getDllDataFileName()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(DLLDATAFILENAME$16);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "DllDataFileName" attribute
         */
        public boolean isSetDllDataFileName()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(DLLDATAFILENAME$16) != null;
            }
        }
        
        /**
         * Sets the "DllDataFileName" attribute
         */
        public void setDllDataFileName(org.apache.xmlbeans.XmlAnySimpleType dllDataFileName)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(DLLDATAFILENAME$16);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(DLLDATAFILENAME$16);
                }
                target.set(dllDataFileName);
            }
        }
        
        /**
         * Appends and returns a new empty "DllDataFileName" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewDllDataFileName()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(DLLDATAFILENAME$16);
                return target;
            }
        }
        
        /**
         * Unsets the "DllDataFileName" attribute
         */
        public void unsetDllDataFileName()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(DLLDATAFILENAME$16);
            }
        }
        
        /**
         * Gets the "EnableErrorChecks" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getEnableErrorChecks()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(ENABLEERRORCHECKS$18);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "EnableErrorChecks" attribute
         */
        public boolean isSetEnableErrorChecks()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(ENABLEERRORCHECKS$18) != null;
            }
        }
        
        /**
         * Sets the "EnableErrorChecks" attribute
         */
        public void setEnableErrorChecks(org.apache.xmlbeans.XmlAnySimpleType enableErrorChecks)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(ENABLEERRORCHECKS$18);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(ENABLEERRORCHECKS$18);
                }
                target.set(enableErrorChecks);
            }
        }
        
        /**
         * Appends and returns a new empty "EnableErrorChecks" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewEnableErrorChecks()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(ENABLEERRORCHECKS$18);
                return target;
            }
        }
        
        /**
         * Unsets the "EnableErrorChecks" attribute
         */
        public void unsetEnableErrorChecks()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(ENABLEERRORCHECKS$18);
            }
        }
        
        /**
         * Gets the "EnvironmentVariables" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getEnvironmentVariables()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(ENVIRONMENTVARIABLES$20);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "EnvironmentVariables" attribute
         */
        public boolean isSetEnvironmentVariables()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(ENVIRONMENTVARIABLES$20) != null;
            }
        }
        
        /**
         * Sets the "EnvironmentVariables" attribute
         */
        public void setEnvironmentVariables(org.apache.xmlbeans.XmlAnySimpleType environmentVariables)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(ENVIRONMENTVARIABLES$20);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(ENVIRONMENTVARIABLES$20);
                }
                target.set(environmentVariables);
            }
        }
        
        /**
         * Appends and returns a new empty "EnvironmentVariables" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewEnvironmentVariables()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(ENVIRONMENTVARIABLES$20);
                return target;
            }
        }
        
        /**
         * Unsets the "EnvironmentVariables" attribute
         */
        public void unsetEnvironmentVariables()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(ENVIRONMENTVARIABLES$20);
            }
        }
        
        /**
         * Gets the "ErrorCheckAllocations" attribute
         */
        public java.lang.String getErrorCheckAllocations()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(ERRORCHECKALLOCATIONS$22);
                if (target == null)
                {
                    return null;
                }
                return target.getStringValue();
            }
        }
        
        /**
         * Gets (as xml) the "ErrorCheckAllocations" attribute
         */
        public io.github.isotes.vs.model.Boolean xgetErrorCheckAllocations()
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(ERRORCHECKALLOCATIONS$22);
                return target;
            }
        }
        
        /**
         * True if has "ErrorCheckAllocations" attribute
         */
        public boolean isSetErrorCheckAllocations()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(ERRORCHECKALLOCATIONS$22) != null;
            }
        }
        
        /**
         * Sets the "ErrorCheckAllocations" attribute
         */
        public void setErrorCheckAllocations(java.lang.String errorCheckAllocations)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(ERRORCHECKALLOCATIONS$22);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(ERRORCHECKALLOCATIONS$22);
                }
                target.setStringValue(errorCheckAllocations);
            }
        }
        
        /**
         * Sets (as xml) the "ErrorCheckAllocations" attribute
         */
        public void xsetErrorCheckAllocations(io.github.isotes.vs.model.Boolean errorCheckAllocations)
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(ERRORCHECKALLOCATIONS$22);
                if (target == null)
                {
                    target = (io.github.isotes.vs.model.Boolean)get_store().add_attribute_user(ERRORCHECKALLOCATIONS$22);
                }
                target.set(errorCheckAllocations);
            }
        }
        
        /**
         * Unsets the "ErrorCheckAllocations" attribute
         */
        public void unsetErrorCheckAllocations()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(ERRORCHECKALLOCATIONS$22);
            }
        }
        
        /**
         * Gets the "ErrorCheckBounds" attribute
         */
        public java.lang.String getErrorCheckBounds()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(ERRORCHECKBOUNDS$24);
                if (target == null)
                {
                    return null;
                }
                return target.getStringValue();
            }
        }
        
        /**
         * Gets (as xml) the "ErrorCheckBounds" attribute
         */
        public io.github.isotes.vs.model.Boolean xgetErrorCheckBounds()
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(ERRORCHECKBOUNDS$24);
                return target;
            }
        }
        
        /**
         * True if has "ErrorCheckBounds" attribute
         */
        public boolean isSetErrorCheckBounds()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(ERRORCHECKBOUNDS$24) != null;
            }
        }
        
        /**
         * Sets the "ErrorCheckBounds" attribute
         */
        public void setErrorCheckBounds(java.lang.String errorCheckBounds)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(ERRORCHECKBOUNDS$24);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(ERRORCHECKBOUNDS$24);
                }
                target.setStringValue(errorCheckBounds);
            }
        }
        
        /**
         * Sets (as xml) the "ErrorCheckBounds" attribute
         */
        public void xsetErrorCheckBounds(io.github.isotes.vs.model.Boolean errorCheckBounds)
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(ERRORCHECKBOUNDS$24);
                if (target == null)
                {
                    target = (io.github.isotes.vs.model.Boolean)get_store().add_attribute_user(ERRORCHECKBOUNDS$24);
                }
                target.set(errorCheckBounds);
            }
        }
        
        /**
         * Unsets the "ErrorCheckBounds" attribute
         */
        public void unsetErrorCheckBounds()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(ERRORCHECKBOUNDS$24);
            }
        }
        
        /**
         * Gets the "ErrorCheckEnumRange" attribute
         */
        public java.lang.String getErrorCheckEnumRange()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(ERRORCHECKENUMRANGE$26);
                if (target == null)
                {
                    return null;
                }
                return target.getStringValue();
            }
        }
        
        /**
         * Gets (as xml) the "ErrorCheckEnumRange" attribute
         */
        public io.github.isotes.vs.model.Boolean xgetErrorCheckEnumRange()
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(ERRORCHECKENUMRANGE$26);
                return target;
            }
        }
        
        /**
         * True if has "ErrorCheckEnumRange" attribute
         */
        public boolean isSetErrorCheckEnumRange()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(ERRORCHECKENUMRANGE$26) != null;
            }
        }
        
        /**
         * Sets the "ErrorCheckEnumRange" attribute
         */
        public void setErrorCheckEnumRange(java.lang.String errorCheckEnumRange)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(ERRORCHECKENUMRANGE$26);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(ERRORCHECKENUMRANGE$26);
                }
                target.setStringValue(errorCheckEnumRange);
            }
        }
        
        /**
         * Sets (as xml) the "ErrorCheckEnumRange" attribute
         */
        public void xsetErrorCheckEnumRange(io.github.isotes.vs.model.Boolean errorCheckEnumRange)
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(ERRORCHECKENUMRANGE$26);
                if (target == null)
                {
                    target = (io.github.isotes.vs.model.Boolean)get_store().add_attribute_user(ERRORCHECKENUMRANGE$26);
                }
                target.set(errorCheckEnumRange);
            }
        }
        
        /**
         * Unsets the "ErrorCheckEnumRange" attribute
         */
        public void unsetErrorCheckEnumRange()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(ERRORCHECKENUMRANGE$26);
            }
        }
        
        /**
         * Gets the "ErrorCheckRefPointers" attribute
         */
        public java.lang.String getErrorCheckRefPointers()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(ERRORCHECKREFPOINTERS$28);
                if (target == null)
                {
                    return null;
                }
                return target.getStringValue();
            }
        }
        
        /**
         * Gets (as xml) the "ErrorCheckRefPointers" attribute
         */
        public io.github.isotes.vs.model.Boolean xgetErrorCheckRefPointers()
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(ERRORCHECKREFPOINTERS$28);
                return target;
            }
        }
        
        /**
         * True if has "ErrorCheckRefPointers" attribute
         */
        public boolean isSetErrorCheckRefPointers()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(ERRORCHECKREFPOINTERS$28) != null;
            }
        }
        
        /**
         * Sets the "ErrorCheckRefPointers" attribute
         */
        public void setErrorCheckRefPointers(java.lang.String errorCheckRefPointers)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(ERRORCHECKREFPOINTERS$28);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(ERRORCHECKREFPOINTERS$28);
                }
                target.setStringValue(errorCheckRefPointers);
            }
        }
        
        /**
         * Sets (as xml) the "ErrorCheckRefPointers" attribute
         */
        public void xsetErrorCheckRefPointers(io.github.isotes.vs.model.Boolean errorCheckRefPointers)
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(ERRORCHECKREFPOINTERS$28);
                if (target == null)
                {
                    target = (io.github.isotes.vs.model.Boolean)get_store().add_attribute_user(ERRORCHECKREFPOINTERS$28);
                }
                target.set(errorCheckRefPointers);
            }
        }
        
        /**
         * Unsets the "ErrorCheckRefPointers" attribute
         */
        public void unsetErrorCheckRefPointers()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(ERRORCHECKREFPOINTERS$28);
            }
        }
        
        /**
         * Gets the "ErrorCheckStubData" attribute
         */
        public java.lang.String getErrorCheckStubData()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(ERRORCHECKSTUBDATA$30);
                if (target == null)
                {
                    return null;
                }
                return target.getStringValue();
            }
        }
        
        /**
         * Gets (as xml) the "ErrorCheckStubData" attribute
         */
        public io.github.isotes.vs.model.Boolean xgetErrorCheckStubData()
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(ERRORCHECKSTUBDATA$30);
                return target;
            }
        }
        
        /**
         * True if has "ErrorCheckStubData" attribute
         */
        public boolean isSetErrorCheckStubData()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(ERRORCHECKSTUBDATA$30) != null;
            }
        }
        
        /**
         * Sets the "ErrorCheckStubData" attribute
         */
        public void setErrorCheckStubData(java.lang.String errorCheckStubData)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(ERRORCHECKSTUBDATA$30);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(ERRORCHECKSTUBDATA$30);
                }
                target.setStringValue(errorCheckStubData);
            }
        }
        
        /**
         * Sets (as xml) the "ErrorCheckStubData" attribute
         */
        public void xsetErrorCheckStubData(io.github.isotes.vs.model.Boolean errorCheckStubData)
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(ERRORCHECKSTUBDATA$30);
                if (target == null)
                {
                    target = (io.github.isotes.vs.model.Boolean)get_store().add_attribute_user(ERRORCHECKSTUBDATA$30);
                }
                target.set(errorCheckStubData);
            }
        }
        
        /**
         * Unsets the "ErrorCheckStubData" attribute
         */
        public void unsetErrorCheckStubData()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(ERRORCHECKSTUBDATA$30);
            }
        }
        
        /**
         * Gets the "ExcludedInputPaths" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getExcludedInputPaths()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(EXCLUDEDINPUTPATHS$32);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "ExcludedInputPaths" attribute
         */
        public boolean isSetExcludedInputPaths()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(EXCLUDEDINPUTPATHS$32) != null;
            }
        }
        
        /**
         * Sets the "ExcludedInputPaths" attribute
         */
        public void setExcludedInputPaths(org.apache.xmlbeans.XmlAnySimpleType excludedInputPaths)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(EXCLUDEDINPUTPATHS$32);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(EXCLUDEDINPUTPATHS$32);
                }
                target.set(excludedInputPaths);
            }
        }
        
        /**
         * Appends and returns a new empty "ExcludedInputPaths" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewExcludedInputPaths()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(EXCLUDEDINPUTPATHS$32);
                return target;
            }
        }
        
        /**
         * Unsets the "ExcludedInputPaths" attribute
         */
        public void unsetExcludedInputPaths()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(EXCLUDEDINPUTPATHS$32);
            }
        }
        
        /**
         * Gets the "GenerateClientFiles" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getGenerateClientFiles()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(GENERATECLIENTFILES$34);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "GenerateClientFiles" attribute
         */
        public boolean isSetGenerateClientFiles()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(GENERATECLIENTFILES$34) != null;
            }
        }
        
        /**
         * Sets the "GenerateClientFiles" attribute
         */
        public void setGenerateClientFiles(org.apache.xmlbeans.XmlAnySimpleType generateClientFiles)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(GENERATECLIENTFILES$34);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(GENERATECLIENTFILES$34);
                }
                target.set(generateClientFiles);
            }
        }
        
        /**
         * Appends and returns a new empty "GenerateClientFiles" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewGenerateClientFiles()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(GENERATECLIENTFILES$34);
                return target;
            }
        }
        
        /**
         * Unsets the "GenerateClientFiles" attribute
         */
        public void unsetGenerateClientFiles()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(GENERATECLIENTFILES$34);
            }
        }
        
        /**
         * Gets the "GenerateServerFiles" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getGenerateServerFiles()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(GENERATESERVERFILES$36);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "GenerateServerFiles" attribute
         */
        public boolean isSetGenerateServerFiles()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(GENERATESERVERFILES$36) != null;
            }
        }
        
        /**
         * Sets the "GenerateServerFiles" attribute
         */
        public void setGenerateServerFiles(org.apache.xmlbeans.XmlAnySimpleType generateServerFiles)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(GENERATESERVERFILES$36);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(GENERATESERVERFILES$36);
                }
                target.set(generateServerFiles);
            }
        }
        
        /**
         * Appends and returns a new empty "GenerateServerFiles" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewGenerateServerFiles()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(GENERATESERVERFILES$36);
                return target;
            }
        }
        
        /**
         * Unsets the "GenerateServerFiles" attribute
         */
        public void unsetGenerateServerFiles()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(GENERATESERVERFILES$36);
            }
        }
        
        /**
         * Gets the "GenerateStublessProxies" attribute
         */
        public java.lang.String getGenerateStublessProxies()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(GENERATESTUBLESSPROXIES$38);
                if (target == null)
                {
                    return null;
                }
                return target.getStringValue();
            }
        }
        
        /**
         * Gets (as xml) the "GenerateStublessProxies" attribute
         */
        public io.github.isotes.vs.model.Boolean xgetGenerateStublessProxies()
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(GENERATESTUBLESSPROXIES$38);
                return target;
            }
        }
        
        /**
         * True if has "GenerateStublessProxies" attribute
         */
        public boolean isSetGenerateStublessProxies()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(GENERATESTUBLESSPROXIES$38) != null;
            }
        }
        
        /**
         * Sets the "GenerateStublessProxies" attribute
         */
        public void setGenerateStublessProxies(java.lang.String generateStublessProxies)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(GENERATESTUBLESSPROXIES$38);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(GENERATESTUBLESSPROXIES$38);
                }
                target.setStringValue(generateStublessProxies);
            }
        }
        
        /**
         * Sets (as xml) the "GenerateStublessProxies" attribute
         */
        public void xsetGenerateStublessProxies(io.github.isotes.vs.model.Boolean generateStublessProxies)
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(GENERATESTUBLESSPROXIES$38);
                if (target == null)
                {
                    target = (io.github.isotes.vs.model.Boolean)get_store().add_attribute_user(GENERATESTUBLESSPROXIES$38);
                }
                target.set(generateStublessProxies);
            }
        }
        
        /**
         * Unsets the "GenerateStublessProxies" attribute
         */
        public void unsetGenerateStublessProxies()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(GENERATESTUBLESSPROXIES$38);
            }
        }
        
        /**
         * Gets the "GenerateTypeLibrary" attribute
         */
        public java.lang.String getGenerateTypeLibrary()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(GENERATETYPELIBRARY$40);
                if (target == null)
                {
                    return null;
                }
                return target.getStringValue();
            }
        }
        
        /**
         * Gets (as xml) the "GenerateTypeLibrary" attribute
         */
        public io.github.isotes.vs.model.Boolean xgetGenerateTypeLibrary()
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(GENERATETYPELIBRARY$40);
                return target;
            }
        }
        
        /**
         * True if has "GenerateTypeLibrary" attribute
         */
        public boolean isSetGenerateTypeLibrary()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(GENERATETYPELIBRARY$40) != null;
            }
        }
        
        /**
         * Sets the "GenerateTypeLibrary" attribute
         */
        public void setGenerateTypeLibrary(java.lang.String generateTypeLibrary)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(GENERATETYPELIBRARY$40);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(GENERATETYPELIBRARY$40);
                }
                target.setStringValue(generateTypeLibrary);
            }
        }
        
        /**
         * Sets (as xml) the "GenerateTypeLibrary" attribute
         */
        public void xsetGenerateTypeLibrary(io.github.isotes.vs.model.Boolean generateTypeLibrary)
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(GENERATETYPELIBRARY$40);
                if (target == null)
                {
                    target = (io.github.isotes.vs.model.Boolean)get_store().add_attribute_user(GENERATETYPELIBRARY$40);
                }
                target.set(generateTypeLibrary);
            }
        }
        
        /**
         * Unsets the "GenerateTypeLibrary" attribute
         */
        public void unsetGenerateTypeLibrary()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(GENERATETYPELIBRARY$40);
            }
        }
        
        /**
         * Gets the "HeaderFileName" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getHeaderFileName()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(HEADERFILENAME$42);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "HeaderFileName" attribute
         */
        public boolean isSetHeaderFileName()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(HEADERFILENAME$42) != null;
            }
        }
        
        /**
         * Sets the "HeaderFileName" attribute
         */
        public void setHeaderFileName(org.apache.xmlbeans.XmlAnySimpleType headerFileName)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(HEADERFILENAME$42);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(HEADERFILENAME$42);
                }
                target.set(headerFileName);
            }
        }
        
        /**
         * Appends and returns a new empty "HeaderFileName" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewHeaderFileName()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(HEADERFILENAME$42);
                return target;
            }
        }
        
        /**
         * Unsets the "HeaderFileName" attribute
         */
        public void unsetHeaderFileName()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(HEADERFILENAME$42);
            }
        }
        
        /**
         * Gets the "IgnoreStandardIncludePath" attribute
         */
        public java.lang.String getIgnoreStandardIncludePath()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(IGNORESTANDARDINCLUDEPATH$44);
                if (target == null)
                {
                    return null;
                }
                return target.getStringValue();
            }
        }
        
        /**
         * Gets (as xml) the "IgnoreStandardIncludePath" attribute
         */
        public io.github.isotes.vs.model.Boolean xgetIgnoreStandardIncludePath()
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(IGNORESTANDARDINCLUDEPATH$44);
                return target;
            }
        }
        
        /**
         * True if has "IgnoreStandardIncludePath" attribute
         */
        public boolean isSetIgnoreStandardIncludePath()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(IGNORESTANDARDINCLUDEPATH$44) != null;
            }
        }
        
        /**
         * Sets the "IgnoreStandardIncludePath" attribute
         */
        public void setIgnoreStandardIncludePath(java.lang.String ignoreStandardIncludePath)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(IGNORESTANDARDINCLUDEPATH$44);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(IGNORESTANDARDINCLUDEPATH$44);
                }
                target.setStringValue(ignoreStandardIncludePath);
            }
        }
        
        /**
         * Sets (as xml) the "IgnoreStandardIncludePath" attribute
         */
        public void xsetIgnoreStandardIncludePath(io.github.isotes.vs.model.Boolean ignoreStandardIncludePath)
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(IGNORESTANDARDINCLUDEPATH$44);
                if (target == null)
                {
                    target = (io.github.isotes.vs.model.Boolean)get_store().add_attribute_user(IGNORESTANDARDINCLUDEPATH$44);
                }
                target.set(ignoreStandardIncludePath);
            }
        }
        
        /**
         * Unsets the "IgnoreStandardIncludePath" attribute
         */
        public void unsetIgnoreStandardIncludePath()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(IGNORESTANDARDINCLUDEPATH$44);
            }
        }
        
        /**
         * Gets the "InterfaceIdentifierFileName" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getInterfaceIdentifierFileName()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(INTERFACEIDENTIFIERFILENAME$46);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "InterfaceIdentifierFileName" attribute
         */
        public boolean isSetInterfaceIdentifierFileName()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(INTERFACEIDENTIFIERFILENAME$46) != null;
            }
        }
        
        /**
         * Sets the "InterfaceIdentifierFileName" attribute
         */
        public void setInterfaceIdentifierFileName(org.apache.xmlbeans.XmlAnySimpleType interfaceIdentifierFileName)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(INTERFACEIDENTIFIERFILENAME$46);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(INTERFACEIDENTIFIERFILENAME$46);
                }
                target.set(interfaceIdentifierFileName);
            }
        }
        
        /**
         * Appends and returns a new empty "InterfaceIdentifierFileName" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewInterfaceIdentifierFileName()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(INTERFACEIDENTIFIERFILENAME$46);
                return target;
            }
        }
        
        /**
         * Unsets the "InterfaceIdentifierFileName" attribute
         */
        public void unsetInterfaceIdentifierFileName()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(INTERFACEIDENTIFIERFILENAME$46);
            }
        }
        
        /**
         * Gets the "LocaleID" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getLocaleID()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(LOCALEID$48);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "LocaleID" attribute
         */
        public boolean isSetLocaleID()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(LOCALEID$48) != null;
            }
        }
        
        /**
         * Sets the "LocaleID" attribute
         */
        public void setLocaleID(org.apache.xmlbeans.XmlAnySimpleType localeID)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(LOCALEID$48);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(LOCALEID$48);
                }
                target.set(localeID);
            }
        }
        
        /**
         * Appends and returns a new empty "LocaleID" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewLocaleID()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(LOCALEID$48);
                return target;
            }
        }
        
        /**
         * Unsets the "LocaleID" attribute
         */
        public void unsetLocaleID()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(LOCALEID$48);
            }
        }
        
        /**
         * Gets the "LogStandardErrorAsError" attribute
         */
        public java.lang.String getLogStandardErrorAsError()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(LOGSTANDARDERRORASERROR$50);
                if (target == null)
                {
                    return null;
                }
                return target.getStringValue();
            }
        }
        
        /**
         * Gets (as xml) the "LogStandardErrorAsError" attribute
         */
        public io.github.isotes.vs.model.Boolean xgetLogStandardErrorAsError()
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(LOGSTANDARDERRORASERROR$50);
                return target;
            }
        }
        
        /**
         * True if has "LogStandardErrorAsError" attribute
         */
        public boolean isSetLogStandardErrorAsError()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(LOGSTANDARDERRORASERROR$50) != null;
            }
        }
        
        /**
         * Sets the "LogStandardErrorAsError" attribute
         */
        public void setLogStandardErrorAsError(java.lang.String logStandardErrorAsError)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(LOGSTANDARDERRORASERROR$50);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(LOGSTANDARDERRORASERROR$50);
                }
                target.setStringValue(logStandardErrorAsError);
            }
        }
        
        /**
         * Sets (as xml) the "LogStandardErrorAsError" attribute
         */
        public void xsetLogStandardErrorAsError(io.github.isotes.vs.model.Boolean logStandardErrorAsError)
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(LOGSTANDARDERRORASERROR$50);
                if (target == null)
                {
                    target = (io.github.isotes.vs.model.Boolean)get_store().add_attribute_user(LOGSTANDARDERRORASERROR$50);
                }
                target.set(logStandardErrorAsError);
            }
        }
        
        /**
         * Unsets the "LogStandardErrorAsError" attribute
         */
        public void unsetLogStandardErrorAsError()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(LOGSTANDARDERRORASERROR$50);
            }
        }
        
        /**
         * Gets the "MinimalRebuildFromTracking" attribute
         */
        public java.lang.String getMinimalRebuildFromTracking()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(MINIMALREBUILDFROMTRACKING$52);
                if (target == null)
                {
                    return null;
                }
                return target.getStringValue();
            }
        }
        
        /**
         * Gets (as xml) the "MinimalRebuildFromTracking" attribute
         */
        public io.github.isotes.vs.model.Boolean xgetMinimalRebuildFromTracking()
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(MINIMALREBUILDFROMTRACKING$52);
                return target;
            }
        }
        
        /**
         * True if has "MinimalRebuildFromTracking" attribute
         */
        public boolean isSetMinimalRebuildFromTracking()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(MINIMALREBUILDFROMTRACKING$52) != null;
            }
        }
        
        /**
         * Sets the "MinimalRebuildFromTracking" attribute
         */
        public void setMinimalRebuildFromTracking(java.lang.String minimalRebuildFromTracking)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(MINIMALREBUILDFROMTRACKING$52);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(MINIMALREBUILDFROMTRACKING$52);
                }
                target.setStringValue(minimalRebuildFromTracking);
            }
        }
        
        /**
         * Sets (as xml) the "MinimalRebuildFromTracking" attribute
         */
        public void xsetMinimalRebuildFromTracking(io.github.isotes.vs.model.Boolean minimalRebuildFromTracking)
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(MINIMALREBUILDFROMTRACKING$52);
                if (target == null)
                {
                    target = (io.github.isotes.vs.model.Boolean)get_store().add_attribute_user(MINIMALREBUILDFROMTRACKING$52);
                }
                target.set(minimalRebuildFromTracking);
            }
        }
        
        /**
         * Unsets the "MinimalRebuildFromTracking" attribute
         */
        public void unsetMinimalRebuildFromTracking()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(MINIMALREBUILDFROMTRACKING$52);
            }
        }
        
        /**
         * Gets the "MkTypLibCompatible" attribute
         */
        public java.lang.String getMkTypLibCompatible()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(MKTYPLIBCOMPATIBLE$54);
                if (target == null)
                {
                    return null;
                }
                return target.getStringValue();
            }
        }
        
        /**
         * Gets (as xml) the "MkTypLibCompatible" attribute
         */
        public io.github.isotes.vs.model.Boolean xgetMkTypLibCompatible()
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(MKTYPLIBCOMPATIBLE$54);
                return target;
            }
        }
        
        /**
         * True if has "MkTypLibCompatible" attribute
         */
        public boolean isSetMkTypLibCompatible()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(MKTYPLIBCOMPATIBLE$54) != null;
            }
        }
        
        /**
         * Sets the "MkTypLibCompatible" attribute
         */
        public void setMkTypLibCompatible(java.lang.String mkTypLibCompatible)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(MKTYPLIBCOMPATIBLE$54);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(MKTYPLIBCOMPATIBLE$54);
                }
                target.setStringValue(mkTypLibCompatible);
            }
        }
        
        /**
         * Sets (as xml) the "MkTypLibCompatible" attribute
         */
        public void xsetMkTypLibCompatible(io.github.isotes.vs.model.Boolean mkTypLibCompatible)
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(MKTYPLIBCOMPATIBLE$54);
                if (target == null)
                {
                    target = (io.github.isotes.vs.model.Boolean)get_store().add_attribute_user(MKTYPLIBCOMPATIBLE$54);
                }
                target.set(mkTypLibCompatible);
            }
        }
        
        /**
         * Unsets the "MkTypLibCompatible" attribute
         */
        public void unsetMkTypLibCompatible()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(MKTYPLIBCOMPATIBLE$54);
            }
        }
        
        /**
         * Gets the "OutputDirectory" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getOutputDirectory()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(OUTPUTDIRECTORY$56);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "OutputDirectory" attribute
         */
        public boolean isSetOutputDirectory()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(OUTPUTDIRECTORY$56) != null;
            }
        }
        
        /**
         * Sets the "OutputDirectory" attribute
         */
        public void setOutputDirectory(org.apache.xmlbeans.XmlAnySimpleType outputDirectory)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(OUTPUTDIRECTORY$56);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(OUTPUTDIRECTORY$56);
                }
                target.set(outputDirectory);
            }
        }
        
        /**
         * Appends and returns a new empty "OutputDirectory" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewOutputDirectory()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(OUTPUTDIRECTORY$56);
                return target;
            }
        }
        
        /**
         * Unsets the "OutputDirectory" attribute
         */
        public void unsetOutputDirectory()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(OUTPUTDIRECTORY$56);
            }
        }
        
        /**
         * Gets the "PathOverride" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getPathOverride()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(PATHOVERRIDE$58);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "PathOverride" attribute
         */
        public boolean isSetPathOverride()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(PATHOVERRIDE$58) != null;
            }
        }
        
        /**
         * Sets the "PathOverride" attribute
         */
        public void setPathOverride(org.apache.xmlbeans.XmlAnySimpleType pathOverride)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(PATHOVERRIDE$58);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(PATHOVERRIDE$58);
                }
                target.set(pathOverride);
            }
        }
        
        /**
         * Appends and returns a new empty "PathOverride" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewPathOverride()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(PATHOVERRIDE$58);
                return target;
            }
        }
        
        /**
         * Unsets the "PathOverride" attribute
         */
        public void unsetPathOverride()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(PATHOVERRIDE$58);
            }
        }
        
        /**
         * Gets the "PreprocessorDefinitions" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getPreprocessorDefinitions()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(PREPROCESSORDEFINITIONS$60);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "PreprocessorDefinitions" attribute
         */
        public boolean isSetPreprocessorDefinitions()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(PREPROCESSORDEFINITIONS$60) != null;
            }
        }
        
        /**
         * Sets the "PreprocessorDefinitions" attribute
         */
        public void setPreprocessorDefinitions(org.apache.xmlbeans.XmlAnySimpleType preprocessorDefinitions)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(PREPROCESSORDEFINITIONS$60);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(PREPROCESSORDEFINITIONS$60);
                }
                target.set(preprocessorDefinitions);
            }
        }
        
        /**
         * Appends and returns a new empty "PreprocessorDefinitions" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewPreprocessorDefinitions()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(PREPROCESSORDEFINITIONS$60);
                return target;
            }
        }
        
        /**
         * Unsets the "PreprocessorDefinitions" attribute
         */
        public void unsetPreprocessorDefinitions()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(PREPROCESSORDEFINITIONS$60);
            }
        }
        
        /**
         * Gets the "ProxyFileName" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getProxyFileName()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(PROXYFILENAME$62);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "ProxyFileName" attribute
         */
        public boolean isSetProxyFileName()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(PROXYFILENAME$62) != null;
            }
        }
        
        /**
         * Sets the "ProxyFileName" attribute
         */
        public void setProxyFileName(org.apache.xmlbeans.XmlAnySimpleType proxyFileName)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(PROXYFILENAME$62);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(PROXYFILENAME$62);
                }
                target.set(proxyFileName);
            }
        }
        
        /**
         * Appends and returns a new empty "ProxyFileName" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewProxyFileName()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(PROXYFILENAME$62);
                return target;
            }
        }
        
        /**
         * Unsets the "ProxyFileName" attribute
         */
        public void unsetProxyFileName()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(PROXYFILENAME$62);
            }
        }
        
        /**
         * Gets the "RedirectOutputAndErrors" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getRedirectOutputAndErrors()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(REDIRECTOUTPUTANDERRORS$64);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "RedirectOutputAndErrors" attribute
         */
        public boolean isSetRedirectOutputAndErrors()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(REDIRECTOUTPUTANDERRORS$64) != null;
            }
        }
        
        /**
         * Sets the "RedirectOutputAndErrors" attribute
         */
        public void setRedirectOutputAndErrors(org.apache.xmlbeans.XmlAnySimpleType redirectOutputAndErrors)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(REDIRECTOUTPUTANDERRORS$64);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(REDIRECTOUTPUTANDERRORS$64);
                }
                target.set(redirectOutputAndErrors);
            }
        }
        
        /**
         * Appends and returns a new empty "RedirectOutputAndErrors" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewRedirectOutputAndErrors()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(REDIRECTOUTPUTANDERRORS$64);
                return target;
            }
        }
        
        /**
         * Unsets the "RedirectOutputAndErrors" attribute
         */
        public void unsetRedirectOutputAndErrors()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(REDIRECTOUTPUTANDERRORS$64);
            }
        }
        
        /**
         * Gets the "ServerStubFile" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getServerStubFile()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(SERVERSTUBFILE$66);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "ServerStubFile" attribute
         */
        public boolean isSetServerStubFile()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(SERVERSTUBFILE$66) != null;
            }
        }
        
        /**
         * Sets the "ServerStubFile" attribute
         */
        public void setServerStubFile(org.apache.xmlbeans.XmlAnySimpleType serverStubFile)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(SERVERSTUBFILE$66);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(SERVERSTUBFILE$66);
                }
                target.set(serverStubFile);
            }
        }
        
        /**
         * Appends and returns a new empty "ServerStubFile" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewServerStubFile()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(SERVERSTUBFILE$66);
                return target;
            }
        }
        
        /**
         * Unsets the "ServerStubFile" attribute
         */
        public void unsetServerStubFile()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(SERVERSTUBFILE$66);
            }
        }
        
        /**
         * Gets the "SkippedExecution" attribute
         */
        public java.lang.String getSkippedExecution()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(SKIPPEDEXECUTION$68);
                if (target == null)
                {
                    return null;
                }
                return target.getStringValue();
            }
        }
        
        /**
         * Gets (as xml) the "SkippedExecution" attribute
         */
        public io.github.isotes.vs.model.Boolean xgetSkippedExecution()
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(SKIPPEDEXECUTION$68);
                return target;
            }
        }
        
        /**
         * True if has "SkippedExecution" attribute
         */
        public boolean isSetSkippedExecution()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(SKIPPEDEXECUTION$68) != null;
            }
        }
        
        /**
         * Sets the "SkippedExecution" attribute
         */
        public void setSkippedExecution(java.lang.String skippedExecution)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(SKIPPEDEXECUTION$68);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(SKIPPEDEXECUTION$68);
                }
                target.setStringValue(skippedExecution);
            }
        }
        
        /**
         * Sets (as xml) the "SkippedExecution" attribute
         */
        public void xsetSkippedExecution(io.github.isotes.vs.model.Boolean skippedExecution)
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(SKIPPEDEXECUTION$68);
                if (target == null)
                {
                    target = (io.github.isotes.vs.model.Boolean)get_store().add_attribute_user(SKIPPEDEXECUTION$68);
                }
                target.set(skippedExecution);
            }
        }
        
        /**
         * Unsets the "SkippedExecution" attribute
         */
        public void unsetSkippedExecution()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(SKIPPEDEXECUTION$68);
            }
        }
        
        /**
         * Gets the "Source" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getSource()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(SOURCE$70);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * Sets the "Source" attribute
         */
        public void setSource(org.apache.xmlbeans.XmlAnySimpleType source)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(SOURCE$70);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(SOURCE$70);
                }
                target.set(source);
            }
        }
        
        /**
         * Appends and returns a new empty "Source" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewSource()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(SOURCE$70);
                return target;
            }
        }
        
        /**
         * Gets the "SourcesCompiled" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getSourcesCompiled()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(SOURCESCOMPILED$72);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "SourcesCompiled" attribute
         */
        public boolean isSetSourcesCompiled()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(SOURCESCOMPILED$72) != null;
            }
        }
        
        /**
         * Sets the "SourcesCompiled" attribute
         */
        public void setSourcesCompiled(org.apache.xmlbeans.XmlAnySimpleType sourcesCompiled)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(SOURCESCOMPILED$72);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(SOURCESCOMPILED$72);
                }
                target.set(sourcesCompiled);
            }
        }
        
        /**
         * Appends and returns a new empty "SourcesCompiled" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewSourcesCompiled()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(SOURCESCOMPILED$72);
                return target;
            }
        }
        
        /**
         * Unsets the "SourcesCompiled" attribute
         */
        public void unsetSourcesCompiled()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(SOURCESCOMPILED$72);
            }
        }
        
        /**
         * Gets the "StandardErrorImportance" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getStandardErrorImportance()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(STANDARDERRORIMPORTANCE$74);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "StandardErrorImportance" attribute
         */
        public boolean isSetStandardErrorImportance()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(STANDARDERRORIMPORTANCE$74) != null;
            }
        }
        
        /**
         * Sets the "StandardErrorImportance" attribute
         */
        public void setStandardErrorImportance(org.apache.xmlbeans.XmlAnySimpleType standardErrorImportance)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(STANDARDERRORIMPORTANCE$74);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(STANDARDERRORIMPORTANCE$74);
                }
                target.set(standardErrorImportance);
            }
        }
        
        /**
         * Appends and returns a new empty "StandardErrorImportance" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewStandardErrorImportance()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(STANDARDERRORIMPORTANCE$74);
                return target;
            }
        }
        
        /**
         * Unsets the "StandardErrorImportance" attribute
         */
        public void unsetStandardErrorImportance()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(STANDARDERRORIMPORTANCE$74);
            }
        }
        
        /**
         * Gets the "StandardOutputImportance" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getStandardOutputImportance()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(STANDARDOUTPUTIMPORTANCE$76);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "StandardOutputImportance" attribute
         */
        public boolean isSetStandardOutputImportance()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(STANDARDOUTPUTIMPORTANCE$76) != null;
            }
        }
        
        /**
         * Sets the "StandardOutputImportance" attribute
         */
        public void setStandardOutputImportance(org.apache.xmlbeans.XmlAnySimpleType standardOutputImportance)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(STANDARDOUTPUTIMPORTANCE$76);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(STANDARDOUTPUTIMPORTANCE$76);
                }
                target.set(standardOutputImportance);
            }
        }
        
        /**
         * Appends and returns a new empty "StandardOutputImportance" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewStandardOutputImportance()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(STANDARDOUTPUTIMPORTANCE$76);
                return target;
            }
        }
        
        /**
         * Unsets the "StandardOutputImportance" attribute
         */
        public void unsetStandardOutputImportance()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(STANDARDOUTPUTIMPORTANCE$76);
            }
        }
        
        /**
         * Gets the "StructMemberAlignment" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getStructMemberAlignment()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(STRUCTMEMBERALIGNMENT$78);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "StructMemberAlignment" attribute
         */
        public boolean isSetStructMemberAlignment()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(STRUCTMEMBERALIGNMENT$78) != null;
            }
        }
        
        /**
         * Sets the "StructMemberAlignment" attribute
         */
        public void setStructMemberAlignment(org.apache.xmlbeans.XmlAnySimpleType structMemberAlignment)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(STRUCTMEMBERALIGNMENT$78);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(STRUCTMEMBERALIGNMENT$78);
                }
                target.set(structMemberAlignment);
            }
        }
        
        /**
         * Appends and returns a new empty "StructMemberAlignment" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewStructMemberAlignment()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(STRUCTMEMBERALIGNMENT$78);
                return target;
            }
        }
        
        /**
         * Unsets the "StructMemberAlignment" attribute
         */
        public void unsetStructMemberAlignment()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(STRUCTMEMBERALIGNMENT$78);
            }
        }
        
        /**
         * Gets the "SuppressCompilerWarnings" attribute
         */
        public java.lang.String getSuppressCompilerWarnings()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(SUPPRESSCOMPILERWARNINGS$80);
                if (target == null)
                {
                    return null;
                }
                return target.getStringValue();
            }
        }
        
        /**
         * Gets (as xml) the "SuppressCompilerWarnings" attribute
         */
        public io.github.isotes.vs.model.Boolean xgetSuppressCompilerWarnings()
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(SUPPRESSCOMPILERWARNINGS$80);
                return target;
            }
        }
        
        /**
         * True if has "SuppressCompilerWarnings" attribute
         */
        public boolean isSetSuppressCompilerWarnings()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(SUPPRESSCOMPILERWARNINGS$80) != null;
            }
        }
        
        /**
         * Sets the "SuppressCompilerWarnings" attribute
         */
        public void setSuppressCompilerWarnings(java.lang.String suppressCompilerWarnings)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(SUPPRESSCOMPILERWARNINGS$80);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(SUPPRESSCOMPILERWARNINGS$80);
                }
                target.setStringValue(suppressCompilerWarnings);
            }
        }
        
        /**
         * Sets (as xml) the "SuppressCompilerWarnings" attribute
         */
        public void xsetSuppressCompilerWarnings(io.github.isotes.vs.model.Boolean suppressCompilerWarnings)
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(SUPPRESSCOMPILERWARNINGS$80);
                if (target == null)
                {
                    target = (io.github.isotes.vs.model.Boolean)get_store().add_attribute_user(SUPPRESSCOMPILERWARNINGS$80);
                }
                target.set(suppressCompilerWarnings);
            }
        }
        
        /**
         * Unsets the "SuppressCompilerWarnings" attribute
         */
        public void unsetSuppressCompilerWarnings()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(SUPPRESSCOMPILERWARNINGS$80);
            }
        }
        
        /**
         * Gets the "SuppressStartupBanner" attribute
         */
        public java.lang.String getSuppressStartupBanner()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(SUPPRESSSTARTUPBANNER$82);
                if (target == null)
                {
                    return null;
                }
                return target.getStringValue();
            }
        }
        
        /**
         * Gets (as xml) the "SuppressStartupBanner" attribute
         */
        public io.github.isotes.vs.model.Boolean xgetSuppressStartupBanner()
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(SUPPRESSSTARTUPBANNER$82);
                return target;
            }
        }
        
        /**
         * True if has "SuppressStartupBanner" attribute
         */
        public boolean isSetSuppressStartupBanner()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(SUPPRESSSTARTUPBANNER$82) != null;
            }
        }
        
        /**
         * Sets the "SuppressStartupBanner" attribute
         */
        public void setSuppressStartupBanner(java.lang.String suppressStartupBanner)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(SUPPRESSSTARTUPBANNER$82);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(SUPPRESSSTARTUPBANNER$82);
                }
                target.setStringValue(suppressStartupBanner);
            }
        }
        
        /**
         * Sets (as xml) the "SuppressStartupBanner" attribute
         */
        public void xsetSuppressStartupBanner(io.github.isotes.vs.model.Boolean suppressStartupBanner)
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(SUPPRESSSTARTUPBANNER$82);
                if (target == null)
                {
                    target = (io.github.isotes.vs.model.Boolean)get_store().add_attribute_user(SUPPRESSSTARTUPBANNER$82);
                }
                target.set(suppressStartupBanner);
            }
        }
        
        /**
         * Unsets the "SuppressStartupBanner" attribute
         */
        public void unsetSuppressStartupBanner()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(SUPPRESSSTARTUPBANNER$82);
            }
        }
        
        /**
         * Gets the "TargetEnvironment" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getTargetEnvironment()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(TARGETENVIRONMENT$84);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "TargetEnvironment" attribute
         */
        public boolean isSetTargetEnvironment()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(TARGETENVIRONMENT$84) != null;
            }
        }
        
        /**
         * Sets the "TargetEnvironment" attribute
         */
        public void setTargetEnvironment(org.apache.xmlbeans.XmlAnySimpleType targetEnvironment)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(TARGETENVIRONMENT$84);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(TARGETENVIRONMENT$84);
                }
                target.set(targetEnvironment);
            }
        }
        
        /**
         * Appends and returns a new empty "TargetEnvironment" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewTargetEnvironment()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(TARGETENVIRONMENT$84);
                return target;
            }
        }
        
        /**
         * Unsets the "TargetEnvironment" attribute
         */
        public void unsetTargetEnvironment()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(TARGETENVIRONMENT$84);
            }
        }
        
        /**
         * Gets the "Timeout" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getTimeout()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(TIMEOUT$86);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "Timeout" attribute
         */
        public boolean isSetTimeout()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(TIMEOUT$86) != null;
            }
        }
        
        /**
         * Sets the "Timeout" attribute
         */
        public void setTimeout(org.apache.xmlbeans.XmlAnySimpleType timeout)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(TIMEOUT$86);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(TIMEOUT$86);
                }
                target.set(timeout);
            }
        }
        
        /**
         * Appends and returns a new empty "Timeout" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewTimeout()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(TIMEOUT$86);
                return target;
            }
        }
        
        /**
         * Unsets the "Timeout" attribute
         */
        public void unsetTimeout()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(TIMEOUT$86);
            }
        }
        
        /**
         * Gets the "TLogReadFiles" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getTLogReadFiles()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(TLOGREADFILES$88);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "TLogReadFiles" attribute
         */
        public boolean isSetTLogReadFiles()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(TLOGREADFILES$88) != null;
            }
        }
        
        /**
         * Sets the "TLogReadFiles" attribute
         */
        public void setTLogReadFiles(org.apache.xmlbeans.XmlAnySimpleType tLogReadFiles)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(TLOGREADFILES$88);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(TLOGREADFILES$88);
                }
                target.set(tLogReadFiles);
            }
        }
        
        /**
         * Appends and returns a new empty "TLogReadFiles" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewTLogReadFiles()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(TLOGREADFILES$88);
                return target;
            }
        }
        
        /**
         * Unsets the "TLogReadFiles" attribute
         */
        public void unsetTLogReadFiles()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(TLOGREADFILES$88);
            }
        }
        
        /**
         * Gets the "TLogWriteFiles" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getTLogWriteFiles()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(TLOGWRITEFILES$90);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "TLogWriteFiles" attribute
         */
        public boolean isSetTLogWriteFiles()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(TLOGWRITEFILES$90) != null;
            }
        }
        
        /**
         * Sets the "TLogWriteFiles" attribute
         */
        public void setTLogWriteFiles(org.apache.xmlbeans.XmlAnySimpleType tLogWriteFiles)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(TLOGWRITEFILES$90);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(TLOGWRITEFILES$90);
                }
                target.set(tLogWriteFiles);
            }
        }
        
        /**
         * Appends and returns a new empty "TLogWriteFiles" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewTLogWriteFiles()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(TLOGWRITEFILES$90);
                return target;
            }
        }
        
        /**
         * Unsets the "TLogWriteFiles" attribute
         */
        public void unsetTLogWriteFiles()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(TLOGWRITEFILES$90);
            }
        }
        
        /**
         * Gets the "ToolExe" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getToolExe()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(TOOLEXE$92);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "ToolExe" attribute
         */
        public boolean isSetToolExe()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(TOOLEXE$92) != null;
            }
        }
        
        /**
         * Sets the "ToolExe" attribute
         */
        public void setToolExe(org.apache.xmlbeans.XmlAnySimpleType toolExe)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(TOOLEXE$92);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(TOOLEXE$92);
                }
                target.set(toolExe);
            }
        }
        
        /**
         * Appends and returns a new empty "ToolExe" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewToolExe()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(TOOLEXE$92);
                return target;
            }
        }
        
        /**
         * Unsets the "ToolExe" attribute
         */
        public void unsetToolExe()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(TOOLEXE$92);
            }
        }
        
        /**
         * Gets the "ToolPath" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getToolPath()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(TOOLPATH$94);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "ToolPath" attribute
         */
        public boolean isSetToolPath()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(TOOLPATH$94) != null;
            }
        }
        
        /**
         * Sets the "ToolPath" attribute
         */
        public void setToolPath(org.apache.xmlbeans.XmlAnySimpleType toolPath)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(TOOLPATH$94);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(TOOLPATH$94);
                }
                target.set(toolPath);
            }
        }
        
        /**
         * Appends and returns a new empty "ToolPath" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewToolPath()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(TOOLPATH$94);
                return target;
            }
        }
        
        /**
         * Unsets the "ToolPath" attribute
         */
        public void unsetToolPath()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(TOOLPATH$94);
            }
        }
        
        /**
         * Gets the "TrackedInputFilesToIgnore" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getTrackedInputFilesToIgnore()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(TRACKEDINPUTFILESTOIGNORE$96);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "TrackedInputFilesToIgnore" attribute
         */
        public boolean isSetTrackedInputFilesToIgnore()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(TRACKEDINPUTFILESTOIGNORE$96) != null;
            }
        }
        
        /**
         * Sets the "TrackedInputFilesToIgnore" attribute
         */
        public void setTrackedInputFilesToIgnore(org.apache.xmlbeans.XmlAnySimpleType trackedInputFilesToIgnore)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(TRACKEDINPUTFILESTOIGNORE$96);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(TRACKEDINPUTFILESTOIGNORE$96);
                }
                target.set(trackedInputFilesToIgnore);
            }
        }
        
        /**
         * Appends and returns a new empty "TrackedInputFilesToIgnore" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewTrackedInputFilesToIgnore()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(TRACKEDINPUTFILESTOIGNORE$96);
                return target;
            }
        }
        
        /**
         * Unsets the "TrackedInputFilesToIgnore" attribute
         */
        public void unsetTrackedInputFilesToIgnore()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(TRACKEDINPUTFILESTOIGNORE$96);
            }
        }
        
        /**
         * Gets the "TrackedOutputFilesToIgnore" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getTrackedOutputFilesToIgnore()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(TRACKEDOUTPUTFILESTOIGNORE$98);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "TrackedOutputFilesToIgnore" attribute
         */
        public boolean isSetTrackedOutputFilesToIgnore()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(TRACKEDOUTPUTFILESTOIGNORE$98) != null;
            }
        }
        
        /**
         * Sets the "TrackedOutputFilesToIgnore" attribute
         */
        public void setTrackedOutputFilesToIgnore(org.apache.xmlbeans.XmlAnySimpleType trackedOutputFilesToIgnore)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(TRACKEDOUTPUTFILESTOIGNORE$98);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(TRACKEDOUTPUTFILESTOIGNORE$98);
                }
                target.set(trackedOutputFilesToIgnore);
            }
        }
        
        /**
         * Appends and returns a new empty "TrackedOutputFilesToIgnore" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewTrackedOutputFilesToIgnore()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(TRACKEDOUTPUTFILESTOIGNORE$98);
                return target;
            }
        }
        
        /**
         * Unsets the "TrackedOutputFilesToIgnore" attribute
         */
        public void unsetTrackedOutputFilesToIgnore()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(TRACKEDOUTPUTFILESTOIGNORE$98);
            }
        }
        
        /**
         * Gets the "TrackerLogDirectory" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getTrackerLogDirectory()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(TRACKERLOGDIRECTORY$100);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "TrackerLogDirectory" attribute
         */
        public boolean isSetTrackerLogDirectory()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(TRACKERLOGDIRECTORY$100) != null;
            }
        }
        
        /**
         * Sets the "TrackerLogDirectory" attribute
         */
        public void setTrackerLogDirectory(org.apache.xmlbeans.XmlAnySimpleType trackerLogDirectory)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(TRACKERLOGDIRECTORY$100);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(TRACKERLOGDIRECTORY$100);
                }
                target.set(trackerLogDirectory);
            }
        }
        
        /**
         * Appends and returns a new empty "TrackerLogDirectory" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewTrackerLogDirectory()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(TRACKERLOGDIRECTORY$100);
                return target;
            }
        }
        
        /**
         * Unsets the "TrackerLogDirectory" attribute
         */
        public void unsetTrackerLogDirectory()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(TRACKERLOGDIRECTORY$100);
            }
        }
        
        /**
         * Gets the "TrackFileAccess" attribute
         */
        public java.lang.String getTrackFileAccess()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(TRACKFILEACCESS$102);
                if (target == null)
                {
                    return null;
                }
                return target.getStringValue();
            }
        }
        
        /**
         * Gets (as xml) the "TrackFileAccess" attribute
         */
        public io.github.isotes.vs.model.Boolean xgetTrackFileAccess()
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(TRACKFILEACCESS$102);
                return target;
            }
        }
        
        /**
         * True if has "TrackFileAccess" attribute
         */
        public boolean isSetTrackFileAccess()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(TRACKFILEACCESS$102) != null;
            }
        }
        
        /**
         * Sets the "TrackFileAccess" attribute
         */
        public void setTrackFileAccess(java.lang.String trackFileAccess)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(TRACKFILEACCESS$102);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(TRACKFILEACCESS$102);
                }
                target.setStringValue(trackFileAccess);
            }
        }
        
        /**
         * Sets (as xml) the "TrackFileAccess" attribute
         */
        public void xsetTrackFileAccess(io.github.isotes.vs.model.Boolean trackFileAccess)
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(TRACKFILEACCESS$102);
                if (target == null)
                {
                    target = (io.github.isotes.vs.model.Boolean)get_store().add_attribute_user(TRACKFILEACCESS$102);
                }
                target.set(trackFileAccess);
            }
        }
        
        /**
         * Unsets the "TrackFileAccess" attribute
         */
        public void unsetTrackFileAccess()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(TRACKFILEACCESS$102);
            }
        }
        
        /**
         * Gets the "TypeLibFormat" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getTypeLibFormat()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(TYPELIBFORMAT$104);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "TypeLibFormat" attribute
         */
        public boolean isSetTypeLibFormat()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(TYPELIBFORMAT$104) != null;
            }
        }
        
        /**
         * Sets the "TypeLibFormat" attribute
         */
        public void setTypeLibFormat(org.apache.xmlbeans.XmlAnySimpleType typeLibFormat)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(TYPELIBFORMAT$104);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(TYPELIBFORMAT$104);
                }
                target.set(typeLibFormat);
            }
        }
        
        /**
         * Appends and returns a new empty "TypeLibFormat" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewTypeLibFormat()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(TYPELIBFORMAT$104);
                return target;
            }
        }
        
        /**
         * Unsets the "TypeLibFormat" attribute
         */
        public void unsetTypeLibFormat()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(TYPELIBFORMAT$104);
            }
        }
        
        /**
         * Gets the "TypeLibraryName" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getTypeLibraryName()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(TYPELIBRARYNAME$106);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "TypeLibraryName" attribute
         */
        public boolean isSetTypeLibraryName()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(TYPELIBRARYNAME$106) != null;
            }
        }
        
        /**
         * Sets the "TypeLibraryName" attribute
         */
        public void setTypeLibraryName(org.apache.xmlbeans.XmlAnySimpleType typeLibraryName)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(TYPELIBRARYNAME$106);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(TYPELIBRARYNAME$106);
                }
                target.set(typeLibraryName);
            }
        }
        
        /**
         * Appends and returns a new empty "TypeLibraryName" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewTypeLibraryName()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(TYPELIBRARYNAME$106);
                return target;
            }
        }
        
        /**
         * Unsets the "TypeLibraryName" attribute
         */
        public void unsetTypeLibraryName()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(TYPELIBRARYNAME$106);
            }
        }
        
        /**
         * Gets the "UndefinePreprocessorDefinitions" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getUndefinePreprocessorDefinitions()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(UNDEFINEPREPROCESSORDEFINITIONS$108);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "UndefinePreprocessorDefinitions" attribute
         */
        public boolean isSetUndefinePreprocessorDefinitions()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(UNDEFINEPREPROCESSORDEFINITIONS$108) != null;
            }
        }
        
        /**
         * Sets the "UndefinePreprocessorDefinitions" attribute
         */
        public void setUndefinePreprocessorDefinitions(org.apache.xmlbeans.XmlAnySimpleType undefinePreprocessorDefinitions)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(UNDEFINEPREPROCESSORDEFINITIONS$108);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(UNDEFINEPREPROCESSORDEFINITIONS$108);
                }
                target.set(undefinePreprocessorDefinitions);
            }
        }
        
        /**
         * Appends and returns a new empty "UndefinePreprocessorDefinitions" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewUndefinePreprocessorDefinitions()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(UNDEFINEPREPROCESSORDEFINITIONS$108);
                return target;
            }
        }
        
        /**
         * Unsets the "UndefinePreprocessorDefinitions" attribute
         */
        public void unsetUndefinePreprocessorDefinitions()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(UNDEFINEPREPROCESSORDEFINITIONS$108);
            }
        }
        
        /**
         * Gets the "ValidateAllParameters" attribute
         */
        public java.lang.String getValidateAllParameters()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(VALIDATEALLPARAMETERS$110);
                if (target == null)
                {
                    return null;
                }
                return target.getStringValue();
            }
        }
        
        /**
         * Gets (as xml) the "ValidateAllParameters" attribute
         */
        public io.github.isotes.vs.model.Boolean xgetValidateAllParameters()
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(VALIDATEALLPARAMETERS$110);
                return target;
            }
        }
        
        /**
         * True if has "ValidateAllParameters" attribute
         */
        public boolean isSetValidateAllParameters()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(VALIDATEALLPARAMETERS$110) != null;
            }
        }
        
        /**
         * Sets the "ValidateAllParameters" attribute
         */
        public void setValidateAllParameters(java.lang.String validateAllParameters)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(VALIDATEALLPARAMETERS$110);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(VALIDATEALLPARAMETERS$110);
                }
                target.setStringValue(validateAllParameters);
            }
        }
        
        /**
         * Sets (as xml) the "ValidateAllParameters" attribute
         */
        public void xsetValidateAllParameters(io.github.isotes.vs.model.Boolean validateAllParameters)
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(VALIDATEALLPARAMETERS$110);
                if (target == null)
                {
                    target = (io.github.isotes.vs.model.Boolean)get_store().add_attribute_user(VALIDATEALLPARAMETERS$110);
                }
                target.set(validateAllParameters);
            }
        }
        
        /**
         * Unsets the "ValidateAllParameters" attribute
         */
        public void unsetValidateAllParameters()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(VALIDATEALLPARAMETERS$110);
            }
        }
        
        /**
         * Gets the "WarnAsError" attribute
         */
        public java.lang.String getWarnAsError()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(WARNASERROR$112);
                if (target == null)
                {
                    return null;
                }
                return target.getStringValue();
            }
        }
        
        /**
         * Gets (as xml) the "WarnAsError" attribute
         */
        public io.github.isotes.vs.model.Boolean xgetWarnAsError()
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(WARNASERROR$112);
                return target;
            }
        }
        
        /**
         * True if has "WarnAsError" attribute
         */
        public boolean isSetWarnAsError()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(WARNASERROR$112) != null;
            }
        }
        
        /**
         * Sets the "WarnAsError" attribute
         */
        public void setWarnAsError(java.lang.String warnAsError)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(WARNASERROR$112);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(WARNASERROR$112);
                }
                target.setStringValue(warnAsError);
            }
        }
        
        /**
         * Sets (as xml) the "WarnAsError" attribute
         */
        public void xsetWarnAsError(io.github.isotes.vs.model.Boolean warnAsError)
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(WARNASERROR$112);
                if (target == null)
                {
                    target = (io.github.isotes.vs.model.Boolean)get_store().add_attribute_user(WARNASERROR$112);
                }
                target.set(warnAsError);
            }
        }
        
        /**
         * Unsets the "WarnAsError" attribute
         */
        public void unsetWarnAsError()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(WARNASERROR$112);
            }
        }
        
        /**
         * Gets the "WarningLevel" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getWarningLevel()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(WARNINGLEVEL$114);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "WarningLevel" attribute
         */
        public boolean isSetWarningLevel()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(WARNINGLEVEL$114) != null;
            }
        }
        
        /**
         * Sets the "WarningLevel" attribute
         */
        public void setWarningLevel(org.apache.xmlbeans.XmlAnySimpleType warningLevel)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(WARNINGLEVEL$114);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(WARNINGLEVEL$114);
                }
                target.set(warningLevel);
            }
        }
        
        /**
         * Appends and returns a new empty "WarningLevel" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewWarningLevel()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(WARNINGLEVEL$114);
                return target;
            }
        }
        
        /**
         * Unsets the "WarningLevel" attribute
         */
        public void unsetWarningLevel()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(WARNINGLEVEL$114);
            }
        }
    }
}




© 2015 - 2024 Weber Informatics LLC | Privacy Policy