View Javadoc
1   /*
2    * An XML document type.
3    * Localname: RR_SubawardBudget10_30
4    * Namespace: http://apply.grants.gov/forms/RR_SubawardBudget10_30-V1.2
5    * Java type: gov.grants.apply.forms.rrSubawardBudget1030V12.RRSubawardBudget1030Document
6    *
7    * Automatically generated - do not modify.
8    */
9   package gov.grants.apply.forms.rrSubawardBudget1030V12.impl;
10  /**
11   * A document containing one RR_SubawardBudget10_30(@http://apply.grants.gov/forms/RR_SubawardBudget10_30-V1.2) element.
12   *
13   * This is a complex type.
14   */
15  public class RRSubawardBudget1030DocumentImpl extends org.apache.xmlbeans.impl.values.XmlComplexContentImpl implements gov.grants.apply.forms.rrSubawardBudget1030V12.RRSubawardBudget1030Document
16  {
17      private static final long serialVersionUID = 1L;
18      
19      public RRSubawardBudget1030DocumentImpl(org.apache.xmlbeans.SchemaType sType)
20      {
21          super(sType);
22      }
23      
24      private static final javax.xml.namespace.QName RRSUBAWARDBUDGET1030$0 = 
25          new javax.xml.namespace.QName("http://apply.grants.gov/forms/RR_SubawardBudget10_30-V1.2", "RR_SubawardBudget10_30");
26      
27      
28      /**
29       * Gets the "RR_SubawardBudget10_30" element
30       */
31      public gov.grants.apply.forms.rrSubawardBudget1030V12.RRSubawardBudget1030Document.RRSubawardBudget1030 getRRSubawardBudget1030()
32      {
33          synchronized (monitor())
34          {
35              check_orphaned();
36              gov.grants.apply.forms.rrSubawardBudget1030V12.RRSubawardBudget1030Document.RRSubawardBudget1030 target = null;
37              target = (gov.grants.apply.forms.rrSubawardBudget1030V12.RRSubawardBudget1030Document.RRSubawardBudget1030)get_store().find_element_user(RRSUBAWARDBUDGET1030$0, 0);
38              if (target == null)
39              {
40                  return null;
41              }
42              return target;
43          }
44      }
45      
46      /**
47       * Sets the "RR_SubawardBudget10_30" element
48       */
49      public void setRRSubawardBudget1030(gov.grants.apply.forms.rrSubawardBudget1030V12.RRSubawardBudget1030Document.RRSubawardBudget1030 rrSubawardBudget1030)
50      {
51          generatedSetterHelperImpl(rrSubawardBudget1030, RRSUBAWARDBUDGET1030$0, 0, org.apache.xmlbeans.impl.values.XmlObjectBase.KIND_SETTERHELPER_SINGLETON);
52      }
53      
54      /**
55       * Appends and returns a new empty "RR_SubawardBudget10_30" element
56       */
57      public gov.grants.apply.forms.rrSubawardBudget1030V12.RRSubawardBudget1030Document.RRSubawardBudget1030 addNewRRSubawardBudget1030()
58      {
59          synchronized (monitor())
60          {
61              check_orphaned();
62              gov.grants.apply.forms.rrSubawardBudget1030V12.RRSubawardBudget1030Document.RRSubawardBudget1030 target = null;
63              target = (gov.grants.apply.forms.rrSubawardBudget1030V12.RRSubawardBudget1030Document.RRSubawardBudget1030)get_store().add_element_user(RRSUBAWARDBUDGET1030$0);
64              return target;
65          }
66      }
67      /**
68       * An XML RR_SubawardBudget10_30(@http://apply.grants.gov/forms/RR_SubawardBudget10_30-V1.2).
69       *
70       * This is a complex type.
71       */
72      public static class RRSubawardBudget1030Impl extends org.apache.xmlbeans.impl.values.XmlComplexContentImpl implements gov.grants.apply.forms.rrSubawardBudget1030V12.RRSubawardBudget1030Document.RRSubawardBudget1030
73      {
74          private static final long serialVersionUID = 1L;
75          
76          public RRSubawardBudget1030Impl(org.apache.xmlbeans.SchemaType sType)
77          {
78              super(sType);
79          }
80          
81          private static final javax.xml.namespace.QName ATT1$0 = 
82              new javax.xml.namespace.QName("http://apply.grants.gov/forms/RR_SubawardBudget10_30-V1.2", "ATT1");
83          private static final javax.xml.namespace.QName ATT2$2 = 
84              new javax.xml.namespace.QName("http://apply.grants.gov/forms/RR_SubawardBudget10_30-V1.2", "ATT2");
85          private static final javax.xml.namespace.QName ATT3$4 = 
86              new javax.xml.namespace.QName("http://apply.grants.gov/forms/RR_SubawardBudget10_30-V1.2", "ATT3");
87          private static final javax.xml.namespace.QName ATT4$6 = 
88              new javax.xml.namespace.QName("http://apply.grants.gov/forms/RR_SubawardBudget10_30-V1.2", "ATT4");
89          private static final javax.xml.namespace.QName ATT5$8 = 
90              new javax.xml.namespace.QName("http://apply.grants.gov/forms/RR_SubawardBudget10_30-V1.2", "ATT5");
91          private static final javax.xml.namespace.QName ATT6$10 = 
92              new javax.xml.namespace.QName("http://apply.grants.gov/forms/RR_SubawardBudget10_30-V1.2", "ATT6");
93          private static final javax.xml.namespace.QName ATT7$12 = 
94              new javax.xml.namespace.QName("http://apply.grants.gov/forms/RR_SubawardBudget10_30-V1.2", "ATT7");
95          private static final javax.xml.namespace.QName ATT8$14 = 
96              new javax.xml.namespace.QName("http://apply.grants.gov/forms/RR_SubawardBudget10_30-V1.2", "ATT8");
97          private static final javax.xml.namespace.QName ATT9$16 = 
98              new javax.xml.namespace.QName("http://apply.grants.gov/forms/RR_SubawardBudget10_30-V1.2", "ATT9");
99          private static final javax.xml.namespace.QName ATT10$18 = 
100             new javax.xml.namespace.QName("http://apply.grants.gov/forms/RR_SubawardBudget10_30-V1.2", "ATT10");
101         private static final javax.xml.namespace.QName ATT11$20 = 
102             new javax.xml.namespace.QName("http://apply.grants.gov/forms/RR_SubawardBudget10_30-V1.2", "ATT11");
103         private static final javax.xml.namespace.QName ATT12$22 = 
104             new javax.xml.namespace.QName("http://apply.grants.gov/forms/RR_SubawardBudget10_30-V1.2", "ATT12");
105         private static final javax.xml.namespace.QName ATT13$24 = 
106             new javax.xml.namespace.QName("http://apply.grants.gov/forms/RR_SubawardBudget10_30-V1.2", "ATT13");
107         private static final javax.xml.namespace.QName ATT14$26 = 
108             new javax.xml.namespace.QName("http://apply.grants.gov/forms/RR_SubawardBudget10_30-V1.2", "ATT14");
109         private static final javax.xml.namespace.QName ATT15$28 = 
110             new javax.xml.namespace.QName("http://apply.grants.gov/forms/RR_SubawardBudget10_30-V1.2", "ATT15");
111         private static final javax.xml.namespace.QName ATT16$30 = 
112             new javax.xml.namespace.QName("http://apply.grants.gov/forms/RR_SubawardBudget10_30-V1.2", "ATT16");
113         private static final javax.xml.namespace.QName ATT17$32 = 
114             new javax.xml.namespace.QName("http://apply.grants.gov/forms/RR_SubawardBudget10_30-V1.2", "ATT17");
115         private static final javax.xml.namespace.QName ATT18$34 = 
116             new javax.xml.namespace.QName("http://apply.grants.gov/forms/RR_SubawardBudget10_30-V1.2", "ATT18");
117         private static final javax.xml.namespace.QName ATT19$36 = 
118             new javax.xml.namespace.QName("http://apply.grants.gov/forms/RR_SubawardBudget10_30-V1.2", "ATT19");
119         private static final javax.xml.namespace.QName ATT20$38 = 
120             new javax.xml.namespace.QName("http://apply.grants.gov/forms/RR_SubawardBudget10_30-V1.2", "ATT20");
121         private static final javax.xml.namespace.QName ATT21$40 = 
122             new javax.xml.namespace.QName("http://apply.grants.gov/forms/RR_SubawardBudget10_30-V1.2", "ATT21");
123         private static final javax.xml.namespace.QName ATT22$42 = 
124             new javax.xml.namespace.QName("http://apply.grants.gov/forms/RR_SubawardBudget10_30-V1.2", "ATT22");
125         private static final javax.xml.namespace.QName ATT23$44 = 
126             new javax.xml.namespace.QName("http://apply.grants.gov/forms/RR_SubawardBudget10_30-V1.2", "ATT23");
127         private static final javax.xml.namespace.QName ATT24$46 = 
128             new javax.xml.namespace.QName("http://apply.grants.gov/forms/RR_SubawardBudget10_30-V1.2", "ATT24");
129         private static final javax.xml.namespace.QName ATT25$48 = 
130             new javax.xml.namespace.QName("http://apply.grants.gov/forms/RR_SubawardBudget10_30-V1.2", "ATT25");
131         private static final javax.xml.namespace.QName ATT26$50 = 
132             new javax.xml.namespace.QName("http://apply.grants.gov/forms/RR_SubawardBudget10_30-V1.2", "ATT26");
133         private static final javax.xml.namespace.QName ATT27$52 = 
134             new javax.xml.namespace.QName("http://apply.grants.gov/forms/RR_SubawardBudget10_30-V1.2", "ATT27");
135         private static final javax.xml.namespace.QName ATT28$54 = 
136             new javax.xml.namespace.QName("http://apply.grants.gov/forms/RR_SubawardBudget10_30-V1.2", "ATT28");
137         private static final javax.xml.namespace.QName ATT29$56 = 
138             new javax.xml.namespace.QName("http://apply.grants.gov/forms/RR_SubawardBudget10_30-V1.2", "ATT29");
139         private static final javax.xml.namespace.QName ATT30$58 = 
140             new javax.xml.namespace.QName("http://apply.grants.gov/forms/RR_SubawardBudget10_30-V1.2", "ATT30");
141         private static final javax.xml.namespace.QName BUDGETATTACHMENTS$60 = 
142             new javax.xml.namespace.QName("http://apply.grants.gov/forms/RR_SubawardBudget10_30-V1.2", "BudgetAttachments");
143         private static final javax.xml.namespace.QName FORMVERSION$62 = 
144             new javax.xml.namespace.QName("http://apply.grants.gov/forms/RR_SubawardBudget10_30-V1.2", "FormVersion");
145         
146         
147         /**
148          * Gets the "ATT1" element
149          */
150         public java.lang.String getATT1()
151         {
152             synchronized (monitor())
153             {
154                 check_orphaned();
155                 org.apache.xmlbeans.SimpleValue target = null;
156                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT1$0, 0);
157                 if (target == null)
158                 {
159                     return null;
160                 }
161                 return target.getStringValue();
162             }
163         }
164         
165         /**
166          * Gets (as xml) the "ATT1" element
167          */
168         public org.apache.xmlbeans.XmlString xgetATT1()
169         {
170             synchronized (monitor())
171             {
172                 check_orphaned();
173                 org.apache.xmlbeans.XmlString target = null;
174                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT1$0, 0);
175                 return target;
176             }
177         }
178         
179         /**
180          * True if has "ATT1" element
181          */
182         public boolean isSetATT1()
183         {
184             synchronized (monitor())
185             {
186                 check_orphaned();
187                 return get_store().count_elements(ATT1$0) != 0;
188             }
189         }
190         
191         /**
192          * Sets the "ATT1" element
193          */
194         public void setATT1(java.lang.String att1)
195         {
196             synchronized (monitor())
197             {
198                 check_orphaned();
199                 org.apache.xmlbeans.SimpleValue target = null;
200                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT1$0, 0);
201                 if (target == null)
202                 {
203                     target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(ATT1$0);
204                 }
205                 target.setStringValue(att1);
206             }
207         }
208         
209         /**
210          * Sets (as xml) the "ATT1" element
211          */
212         public void xsetATT1(org.apache.xmlbeans.XmlString att1)
213         {
214             synchronized (monitor())
215             {
216                 check_orphaned();
217                 org.apache.xmlbeans.XmlString target = null;
218                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT1$0, 0);
219                 if (target == null)
220                 {
221                     target = (org.apache.xmlbeans.XmlString)get_store().add_element_user(ATT1$0);
222                 }
223                 target.set(att1);
224             }
225         }
226         
227         /**
228          * Unsets the "ATT1" element
229          */
230         public void unsetATT1()
231         {
232             synchronized (monitor())
233             {
234                 check_orphaned();
235                 get_store().remove_element(ATT1$0, 0);
236             }
237         }
238         
239         /**
240          * Gets the "ATT2" element
241          */
242         public java.lang.String getATT2()
243         {
244             synchronized (monitor())
245             {
246                 check_orphaned();
247                 org.apache.xmlbeans.SimpleValue target = null;
248                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT2$2, 0);
249                 if (target == null)
250                 {
251                     return null;
252                 }
253                 return target.getStringValue();
254             }
255         }
256         
257         /**
258          * Gets (as xml) the "ATT2" element
259          */
260         public org.apache.xmlbeans.XmlString xgetATT2()
261         {
262             synchronized (monitor())
263             {
264                 check_orphaned();
265                 org.apache.xmlbeans.XmlString target = null;
266                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT2$2, 0);
267                 return target;
268             }
269         }
270         
271         /**
272          * True if has "ATT2" element
273          */
274         public boolean isSetATT2()
275         {
276             synchronized (monitor())
277             {
278                 check_orphaned();
279                 return get_store().count_elements(ATT2$2) != 0;
280             }
281         }
282         
283         /**
284          * Sets the "ATT2" element
285          */
286         public void setATT2(java.lang.String att2)
287         {
288             synchronized (monitor())
289             {
290                 check_orphaned();
291                 org.apache.xmlbeans.SimpleValue target = null;
292                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT2$2, 0);
293                 if (target == null)
294                 {
295                     target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(ATT2$2);
296                 }
297                 target.setStringValue(att2);
298             }
299         }
300         
301         /**
302          * Sets (as xml) the "ATT2" element
303          */
304         public void xsetATT2(org.apache.xmlbeans.XmlString att2)
305         {
306             synchronized (monitor())
307             {
308                 check_orphaned();
309                 org.apache.xmlbeans.XmlString target = null;
310                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT2$2, 0);
311                 if (target == null)
312                 {
313                     target = (org.apache.xmlbeans.XmlString)get_store().add_element_user(ATT2$2);
314                 }
315                 target.set(att2);
316             }
317         }
318         
319         /**
320          * Unsets the "ATT2" element
321          */
322         public void unsetATT2()
323         {
324             synchronized (monitor())
325             {
326                 check_orphaned();
327                 get_store().remove_element(ATT2$2, 0);
328             }
329         }
330         
331         /**
332          * Gets the "ATT3" element
333          */
334         public java.lang.String getATT3()
335         {
336             synchronized (monitor())
337             {
338                 check_orphaned();
339                 org.apache.xmlbeans.SimpleValue target = null;
340                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT3$4, 0);
341                 if (target == null)
342                 {
343                     return null;
344                 }
345                 return target.getStringValue();
346             }
347         }
348         
349         /**
350          * Gets (as xml) the "ATT3" element
351          */
352         public org.apache.xmlbeans.XmlString xgetATT3()
353         {
354             synchronized (monitor())
355             {
356                 check_orphaned();
357                 org.apache.xmlbeans.XmlString target = null;
358                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT3$4, 0);
359                 return target;
360             }
361         }
362         
363         /**
364          * True if has "ATT3" element
365          */
366         public boolean isSetATT3()
367         {
368             synchronized (monitor())
369             {
370                 check_orphaned();
371                 return get_store().count_elements(ATT3$4) != 0;
372             }
373         }
374         
375         /**
376          * Sets the "ATT3" element
377          */
378         public void setATT3(java.lang.String att3)
379         {
380             synchronized (monitor())
381             {
382                 check_orphaned();
383                 org.apache.xmlbeans.SimpleValue target = null;
384                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT3$4, 0);
385                 if (target == null)
386                 {
387                     target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(ATT3$4);
388                 }
389                 target.setStringValue(att3);
390             }
391         }
392         
393         /**
394          * Sets (as xml) the "ATT3" element
395          */
396         public void xsetATT3(org.apache.xmlbeans.XmlString att3)
397         {
398             synchronized (monitor())
399             {
400                 check_orphaned();
401                 org.apache.xmlbeans.XmlString target = null;
402                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT3$4, 0);
403                 if (target == null)
404                 {
405                     target = (org.apache.xmlbeans.XmlString)get_store().add_element_user(ATT3$4);
406                 }
407                 target.set(att3);
408             }
409         }
410         
411         /**
412          * Unsets the "ATT3" element
413          */
414         public void unsetATT3()
415         {
416             synchronized (monitor())
417             {
418                 check_orphaned();
419                 get_store().remove_element(ATT3$4, 0);
420             }
421         }
422         
423         /**
424          * Gets the "ATT4" element
425          */
426         public java.lang.String getATT4()
427         {
428             synchronized (monitor())
429             {
430                 check_orphaned();
431                 org.apache.xmlbeans.SimpleValue target = null;
432                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT4$6, 0);
433                 if (target == null)
434                 {
435                     return null;
436                 }
437                 return target.getStringValue();
438             }
439         }
440         
441         /**
442          * Gets (as xml) the "ATT4" element
443          */
444         public org.apache.xmlbeans.XmlString xgetATT4()
445         {
446             synchronized (monitor())
447             {
448                 check_orphaned();
449                 org.apache.xmlbeans.XmlString target = null;
450                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT4$6, 0);
451                 return target;
452             }
453         }
454         
455         /**
456          * True if has "ATT4" element
457          */
458         public boolean isSetATT4()
459         {
460             synchronized (monitor())
461             {
462                 check_orphaned();
463                 return get_store().count_elements(ATT4$6) != 0;
464             }
465         }
466         
467         /**
468          * Sets the "ATT4" element
469          */
470         public void setATT4(java.lang.String att4)
471         {
472             synchronized (monitor())
473             {
474                 check_orphaned();
475                 org.apache.xmlbeans.SimpleValue target = null;
476                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT4$6, 0);
477                 if (target == null)
478                 {
479                     target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(ATT4$6);
480                 }
481                 target.setStringValue(att4);
482             }
483         }
484         
485         /**
486          * Sets (as xml) the "ATT4" element
487          */
488         public void xsetATT4(org.apache.xmlbeans.XmlString att4)
489         {
490             synchronized (monitor())
491             {
492                 check_orphaned();
493                 org.apache.xmlbeans.XmlString target = null;
494                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT4$6, 0);
495                 if (target == null)
496                 {
497                     target = (org.apache.xmlbeans.XmlString)get_store().add_element_user(ATT4$6);
498                 }
499                 target.set(att4);
500             }
501         }
502         
503         /**
504          * Unsets the "ATT4" element
505          */
506         public void unsetATT4()
507         {
508             synchronized (monitor())
509             {
510                 check_orphaned();
511                 get_store().remove_element(ATT4$6, 0);
512             }
513         }
514         
515         /**
516          * Gets the "ATT5" element
517          */
518         public java.lang.String getATT5()
519         {
520             synchronized (monitor())
521             {
522                 check_orphaned();
523                 org.apache.xmlbeans.SimpleValue target = null;
524                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT5$8, 0);
525                 if (target == null)
526                 {
527                     return null;
528                 }
529                 return target.getStringValue();
530             }
531         }
532         
533         /**
534          * Gets (as xml) the "ATT5" element
535          */
536         public org.apache.xmlbeans.XmlString xgetATT5()
537         {
538             synchronized (monitor())
539             {
540                 check_orphaned();
541                 org.apache.xmlbeans.XmlString target = null;
542                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT5$8, 0);
543                 return target;
544             }
545         }
546         
547         /**
548          * True if has "ATT5" element
549          */
550         public boolean isSetATT5()
551         {
552             synchronized (monitor())
553             {
554                 check_orphaned();
555                 return get_store().count_elements(ATT5$8) != 0;
556             }
557         }
558         
559         /**
560          * Sets the "ATT5" element
561          */
562         public void setATT5(java.lang.String att5)
563         {
564             synchronized (monitor())
565             {
566                 check_orphaned();
567                 org.apache.xmlbeans.SimpleValue target = null;
568                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT5$8, 0);
569                 if (target == null)
570                 {
571                     target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(ATT5$8);
572                 }
573                 target.setStringValue(att5);
574             }
575         }
576         
577         /**
578          * Sets (as xml) the "ATT5" element
579          */
580         public void xsetATT5(org.apache.xmlbeans.XmlString att5)
581         {
582             synchronized (monitor())
583             {
584                 check_orphaned();
585                 org.apache.xmlbeans.XmlString target = null;
586                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT5$8, 0);
587                 if (target == null)
588                 {
589                     target = (org.apache.xmlbeans.XmlString)get_store().add_element_user(ATT5$8);
590                 }
591                 target.set(att5);
592             }
593         }
594         
595         /**
596          * Unsets the "ATT5" element
597          */
598         public void unsetATT5()
599         {
600             synchronized (monitor())
601             {
602                 check_orphaned();
603                 get_store().remove_element(ATT5$8, 0);
604             }
605         }
606         
607         /**
608          * Gets the "ATT6" element
609          */
610         public java.lang.String getATT6()
611         {
612             synchronized (monitor())
613             {
614                 check_orphaned();
615                 org.apache.xmlbeans.SimpleValue target = null;
616                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT6$10, 0);
617                 if (target == null)
618                 {
619                     return null;
620                 }
621                 return target.getStringValue();
622             }
623         }
624         
625         /**
626          * Gets (as xml) the "ATT6" element
627          */
628         public org.apache.xmlbeans.XmlString xgetATT6()
629         {
630             synchronized (monitor())
631             {
632                 check_orphaned();
633                 org.apache.xmlbeans.XmlString target = null;
634                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT6$10, 0);
635                 return target;
636             }
637         }
638         
639         /**
640          * True if has "ATT6" element
641          */
642         public boolean isSetATT6()
643         {
644             synchronized (monitor())
645             {
646                 check_orphaned();
647                 return get_store().count_elements(ATT6$10) != 0;
648             }
649         }
650         
651         /**
652          * Sets the "ATT6" element
653          */
654         public void setATT6(java.lang.String att6)
655         {
656             synchronized (monitor())
657             {
658                 check_orphaned();
659                 org.apache.xmlbeans.SimpleValue target = null;
660                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT6$10, 0);
661                 if (target == null)
662                 {
663                     target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(ATT6$10);
664                 }
665                 target.setStringValue(att6);
666             }
667         }
668         
669         /**
670          * Sets (as xml) the "ATT6" element
671          */
672         public void xsetATT6(org.apache.xmlbeans.XmlString att6)
673         {
674             synchronized (monitor())
675             {
676                 check_orphaned();
677                 org.apache.xmlbeans.XmlString target = null;
678                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT6$10, 0);
679                 if (target == null)
680                 {
681                     target = (org.apache.xmlbeans.XmlString)get_store().add_element_user(ATT6$10);
682                 }
683                 target.set(att6);
684             }
685         }
686         
687         /**
688          * Unsets the "ATT6" element
689          */
690         public void unsetATT6()
691         {
692             synchronized (monitor())
693             {
694                 check_orphaned();
695                 get_store().remove_element(ATT6$10, 0);
696             }
697         }
698         
699         /**
700          * Gets the "ATT7" element
701          */
702         public java.lang.String getATT7()
703         {
704             synchronized (monitor())
705             {
706                 check_orphaned();
707                 org.apache.xmlbeans.SimpleValue target = null;
708                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT7$12, 0);
709                 if (target == null)
710                 {
711                     return null;
712                 }
713                 return target.getStringValue();
714             }
715         }
716         
717         /**
718          * Gets (as xml) the "ATT7" element
719          */
720         public org.apache.xmlbeans.XmlString xgetATT7()
721         {
722             synchronized (monitor())
723             {
724                 check_orphaned();
725                 org.apache.xmlbeans.XmlString target = null;
726                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT7$12, 0);
727                 return target;
728             }
729         }
730         
731         /**
732          * True if has "ATT7" element
733          */
734         public boolean isSetATT7()
735         {
736             synchronized (monitor())
737             {
738                 check_orphaned();
739                 return get_store().count_elements(ATT7$12) != 0;
740             }
741         }
742         
743         /**
744          * Sets the "ATT7" element
745          */
746         public void setATT7(java.lang.String att7)
747         {
748             synchronized (monitor())
749             {
750                 check_orphaned();
751                 org.apache.xmlbeans.SimpleValue target = null;
752                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT7$12, 0);
753                 if (target == null)
754                 {
755                     target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(ATT7$12);
756                 }
757                 target.setStringValue(att7);
758             }
759         }
760         
761         /**
762          * Sets (as xml) the "ATT7" element
763          */
764         public void xsetATT7(org.apache.xmlbeans.XmlString att7)
765         {
766             synchronized (monitor())
767             {
768                 check_orphaned();
769                 org.apache.xmlbeans.XmlString target = null;
770                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT7$12, 0);
771                 if (target == null)
772                 {
773                     target = (org.apache.xmlbeans.XmlString)get_store().add_element_user(ATT7$12);
774                 }
775                 target.set(att7);
776             }
777         }
778         
779         /**
780          * Unsets the "ATT7" element
781          */
782         public void unsetATT7()
783         {
784             synchronized (monitor())
785             {
786                 check_orphaned();
787                 get_store().remove_element(ATT7$12, 0);
788             }
789         }
790         
791         /**
792          * Gets the "ATT8" element
793          */
794         public java.lang.String getATT8()
795         {
796             synchronized (monitor())
797             {
798                 check_orphaned();
799                 org.apache.xmlbeans.SimpleValue target = null;
800                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT8$14, 0);
801                 if (target == null)
802                 {
803                     return null;
804                 }
805                 return target.getStringValue();
806             }
807         }
808         
809         /**
810          * Gets (as xml) the "ATT8" element
811          */
812         public org.apache.xmlbeans.XmlString xgetATT8()
813         {
814             synchronized (monitor())
815             {
816                 check_orphaned();
817                 org.apache.xmlbeans.XmlString target = null;
818                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT8$14, 0);
819                 return target;
820             }
821         }
822         
823         /**
824          * True if has "ATT8" element
825          */
826         public boolean isSetATT8()
827         {
828             synchronized (monitor())
829             {
830                 check_orphaned();
831                 return get_store().count_elements(ATT8$14) != 0;
832             }
833         }
834         
835         /**
836          * Sets the "ATT8" element
837          */
838         public void setATT8(java.lang.String att8)
839         {
840             synchronized (monitor())
841             {
842                 check_orphaned();
843                 org.apache.xmlbeans.SimpleValue target = null;
844                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT8$14, 0);
845                 if (target == null)
846                 {
847                     target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(ATT8$14);
848                 }
849                 target.setStringValue(att8);
850             }
851         }
852         
853         /**
854          * Sets (as xml) the "ATT8" element
855          */
856         public void xsetATT8(org.apache.xmlbeans.XmlString att8)
857         {
858             synchronized (monitor())
859             {
860                 check_orphaned();
861                 org.apache.xmlbeans.XmlString target = null;
862                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT8$14, 0);
863                 if (target == null)
864                 {
865                     target = (org.apache.xmlbeans.XmlString)get_store().add_element_user(ATT8$14);
866                 }
867                 target.set(att8);
868             }
869         }
870         
871         /**
872          * Unsets the "ATT8" element
873          */
874         public void unsetATT8()
875         {
876             synchronized (monitor())
877             {
878                 check_orphaned();
879                 get_store().remove_element(ATT8$14, 0);
880             }
881         }
882         
883         /**
884          * Gets the "ATT9" element
885          */
886         public java.lang.String getATT9()
887         {
888             synchronized (monitor())
889             {
890                 check_orphaned();
891                 org.apache.xmlbeans.SimpleValue target = null;
892                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT9$16, 0);
893                 if (target == null)
894                 {
895                     return null;
896                 }
897                 return target.getStringValue();
898             }
899         }
900         
901         /**
902          * Gets (as xml) the "ATT9" element
903          */
904         public org.apache.xmlbeans.XmlString xgetATT9()
905         {
906             synchronized (monitor())
907             {
908                 check_orphaned();
909                 org.apache.xmlbeans.XmlString target = null;
910                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT9$16, 0);
911                 return target;
912             }
913         }
914         
915         /**
916          * True if has "ATT9" element
917          */
918         public boolean isSetATT9()
919         {
920             synchronized (monitor())
921             {
922                 check_orphaned();
923                 return get_store().count_elements(ATT9$16) != 0;
924             }
925         }
926         
927         /**
928          * Sets the "ATT9" element
929          */
930         public void setATT9(java.lang.String att9)
931         {
932             synchronized (monitor())
933             {
934                 check_orphaned();
935                 org.apache.xmlbeans.SimpleValue target = null;
936                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT9$16, 0);
937                 if (target == null)
938                 {
939                     target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(ATT9$16);
940                 }
941                 target.setStringValue(att9);
942             }
943         }
944         
945         /**
946          * Sets (as xml) the "ATT9" element
947          */
948         public void xsetATT9(org.apache.xmlbeans.XmlString att9)
949         {
950             synchronized (monitor())
951             {
952                 check_orphaned();
953                 org.apache.xmlbeans.XmlString target = null;
954                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT9$16, 0);
955                 if (target == null)
956                 {
957                     target = (org.apache.xmlbeans.XmlString)get_store().add_element_user(ATT9$16);
958                 }
959                 target.set(att9);
960             }
961         }
962         
963         /**
964          * Unsets the "ATT9" element
965          */
966         public void unsetATT9()
967         {
968             synchronized (monitor())
969             {
970                 check_orphaned();
971                 get_store().remove_element(ATT9$16, 0);
972             }
973         }
974         
975         /**
976          * Gets the "ATT10" element
977          */
978         public java.lang.String getATT10()
979         {
980             synchronized (monitor())
981             {
982                 check_orphaned();
983                 org.apache.xmlbeans.SimpleValue target = null;
984                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT10$18, 0);
985                 if (target == null)
986                 {
987                     return null;
988                 }
989                 return target.getStringValue();
990             }
991         }
992         
993         /**
994          * Gets (as xml) the "ATT10" element
995          */
996         public org.apache.xmlbeans.XmlString xgetATT10()
997         {
998             synchronized (monitor())
999             {
1000                 check_orphaned();
1001                 org.apache.xmlbeans.XmlString target = null;
1002                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT10$18, 0);
1003                 return target;
1004             }
1005         }
1006         
1007         /**
1008          * True if has "ATT10" element
1009          */
1010         public boolean isSetATT10()
1011         {
1012             synchronized (monitor())
1013             {
1014                 check_orphaned();
1015                 return get_store().count_elements(ATT10$18) != 0;
1016             }
1017         }
1018         
1019         /**
1020          * Sets the "ATT10" element
1021          */
1022         public void setATT10(java.lang.String att10)
1023         {
1024             synchronized (monitor())
1025             {
1026                 check_orphaned();
1027                 org.apache.xmlbeans.SimpleValue target = null;
1028                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT10$18, 0);
1029                 if (target == null)
1030                 {
1031                     target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(ATT10$18);
1032                 }
1033                 target.setStringValue(att10);
1034             }
1035         }
1036         
1037         /**
1038          * Sets (as xml) the "ATT10" element
1039          */
1040         public void xsetATT10(org.apache.xmlbeans.XmlString att10)
1041         {
1042             synchronized (monitor())
1043             {
1044                 check_orphaned();
1045                 org.apache.xmlbeans.XmlString target = null;
1046                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT10$18, 0);
1047                 if (target == null)
1048                 {
1049                     target = (org.apache.xmlbeans.XmlString)get_store().add_element_user(ATT10$18);
1050                 }
1051                 target.set(att10);
1052             }
1053         }
1054         
1055         /**
1056          * Unsets the "ATT10" element
1057          */
1058         public void unsetATT10()
1059         {
1060             synchronized (monitor())
1061             {
1062                 check_orphaned();
1063                 get_store().remove_element(ATT10$18, 0);
1064             }
1065         }
1066         
1067         /**
1068          * Gets the "ATT11" element
1069          */
1070         public java.lang.String getATT11()
1071         {
1072             synchronized (monitor())
1073             {
1074                 check_orphaned();
1075                 org.apache.xmlbeans.SimpleValue target = null;
1076                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT11$20, 0);
1077                 if (target == null)
1078                 {
1079                     return null;
1080                 }
1081                 return target.getStringValue();
1082             }
1083         }
1084         
1085         /**
1086          * Gets (as xml) the "ATT11" element
1087          */
1088         public org.apache.xmlbeans.XmlString xgetATT11()
1089         {
1090             synchronized (monitor())
1091             {
1092                 check_orphaned();
1093                 org.apache.xmlbeans.XmlString target = null;
1094                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT11$20, 0);
1095                 return target;
1096             }
1097         }
1098         
1099         /**
1100          * True if has "ATT11" element
1101          */
1102         public boolean isSetATT11()
1103         {
1104             synchronized (monitor())
1105             {
1106                 check_orphaned();
1107                 return get_store().count_elements(ATT11$20) != 0;
1108             }
1109         }
1110         
1111         /**
1112          * Sets the "ATT11" element
1113          */
1114         public void setATT11(java.lang.String att11)
1115         {
1116             synchronized (monitor())
1117             {
1118                 check_orphaned();
1119                 org.apache.xmlbeans.SimpleValue target = null;
1120                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT11$20, 0);
1121                 if (target == null)
1122                 {
1123                     target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(ATT11$20);
1124                 }
1125                 target.setStringValue(att11);
1126             }
1127         }
1128         
1129         /**
1130          * Sets (as xml) the "ATT11" element
1131          */
1132         public void xsetATT11(org.apache.xmlbeans.XmlString att11)
1133         {
1134             synchronized (monitor())
1135             {
1136                 check_orphaned();
1137                 org.apache.xmlbeans.XmlString target = null;
1138                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT11$20, 0);
1139                 if (target == null)
1140                 {
1141                     target = (org.apache.xmlbeans.XmlString)get_store().add_element_user(ATT11$20);
1142                 }
1143                 target.set(att11);
1144             }
1145         }
1146         
1147         /**
1148          * Unsets the "ATT11" element
1149          */
1150         public void unsetATT11()
1151         {
1152             synchronized (monitor())
1153             {
1154                 check_orphaned();
1155                 get_store().remove_element(ATT11$20, 0);
1156             }
1157         }
1158         
1159         /**
1160          * Gets the "ATT12" element
1161          */
1162         public java.lang.String getATT12()
1163         {
1164             synchronized (monitor())
1165             {
1166                 check_orphaned();
1167                 org.apache.xmlbeans.SimpleValue target = null;
1168                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT12$22, 0);
1169                 if (target == null)
1170                 {
1171                     return null;
1172                 }
1173                 return target.getStringValue();
1174             }
1175         }
1176         
1177         /**
1178          * Gets (as xml) the "ATT12" element
1179          */
1180         public org.apache.xmlbeans.XmlString xgetATT12()
1181         {
1182             synchronized (monitor())
1183             {
1184                 check_orphaned();
1185                 org.apache.xmlbeans.XmlString target = null;
1186                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT12$22, 0);
1187                 return target;
1188             }
1189         }
1190         
1191         /**
1192          * True if has "ATT12" element
1193          */
1194         public boolean isSetATT12()
1195         {
1196             synchronized (monitor())
1197             {
1198                 check_orphaned();
1199                 return get_store().count_elements(ATT12$22) != 0;
1200             }
1201         }
1202         
1203         /**
1204          * Sets the "ATT12" element
1205          */
1206         public void setATT12(java.lang.String att12)
1207         {
1208             synchronized (monitor())
1209             {
1210                 check_orphaned();
1211                 org.apache.xmlbeans.SimpleValue target = null;
1212                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT12$22, 0);
1213                 if (target == null)
1214                 {
1215                     target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(ATT12$22);
1216                 }
1217                 target.setStringValue(att12);
1218             }
1219         }
1220         
1221         /**
1222          * Sets (as xml) the "ATT12" element
1223          */
1224         public void xsetATT12(org.apache.xmlbeans.XmlString att12)
1225         {
1226             synchronized (monitor())
1227             {
1228                 check_orphaned();
1229                 org.apache.xmlbeans.XmlString target = null;
1230                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT12$22, 0);
1231                 if (target == null)
1232                 {
1233                     target = (org.apache.xmlbeans.XmlString)get_store().add_element_user(ATT12$22);
1234                 }
1235                 target.set(att12);
1236             }
1237         }
1238         
1239         /**
1240          * Unsets the "ATT12" element
1241          */
1242         public void unsetATT12()
1243         {
1244             synchronized (monitor())
1245             {
1246                 check_orphaned();
1247                 get_store().remove_element(ATT12$22, 0);
1248             }
1249         }
1250         
1251         /**
1252          * Gets the "ATT13" element
1253          */
1254         public java.lang.String getATT13()
1255         {
1256             synchronized (monitor())
1257             {
1258                 check_orphaned();
1259                 org.apache.xmlbeans.SimpleValue target = null;
1260                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT13$24, 0);
1261                 if (target == null)
1262                 {
1263                     return null;
1264                 }
1265                 return target.getStringValue();
1266             }
1267         }
1268         
1269         /**
1270          * Gets (as xml) the "ATT13" element
1271          */
1272         public org.apache.xmlbeans.XmlString xgetATT13()
1273         {
1274             synchronized (monitor())
1275             {
1276                 check_orphaned();
1277                 org.apache.xmlbeans.XmlString target = null;
1278                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT13$24, 0);
1279                 return target;
1280             }
1281         }
1282         
1283         /**
1284          * True if has "ATT13" element
1285          */
1286         public boolean isSetATT13()
1287         {
1288             synchronized (monitor())
1289             {
1290                 check_orphaned();
1291                 return get_store().count_elements(ATT13$24) != 0;
1292             }
1293         }
1294         
1295         /**
1296          * Sets the "ATT13" element
1297          */
1298         public void setATT13(java.lang.String att13)
1299         {
1300             synchronized (monitor())
1301             {
1302                 check_orphaned();
1303                 org.apache.xmlbeans.SimpleValue target = null;
1304                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT13$24, 0);
1305                 if (target == null)
1306                 {
1307                     target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(ATT13$24);
1308                 }
1309                 target.setStringValue(att13);
1310             }
1311         }
1312         
1313         /**
1314          * Sets (as xml) the "ATT13" element
1315          */
1316         public void xsetATT13(org.apache.xmlbeans.XmlString att13)
1317         {
1318             synchronized (monitor())
1319             {
1320                 check_orphaned();
1321                 org.apache.xmlbeans.XmlString target = null;
1322                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT13$24, 0);
1323                 if (target == null)
1324                 {
1325                     target = (org.apache.xmlbeans.XmlString)get_store().add_element_user(ATT13$24);
1326                 }
1327                 target.set(att13);
1328             }
1329         }
1330         
1331         /**
1332          * Unsets the "ATT13" element
1333          */
1334         public void unsetATT13()
1335         {
1336             synchronized (monitor())
1337             {
1338                 check_orphaned();
1339                 get_store().remove_element(ATT13$24, 0);
1340             }
1341         }
1342         
1343         /**
1344          * Gets the "ATT14" element
1345          */
1346         public java.lang.String getATT14()
1347         {
1348             synchronized (monitor())
1349             {
1350                 check_orphaned();
1351                 org.apache.xmlbeans.SimpleValue target = null;
1352                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT14$26, 0);
1353                 if (target == null)
1354                 {
1355                     return null;
1356                 }
1357                 return target.getStringValue();
1358             }
1359         }
1360         
1361         /**
1362          * Gets (as xml) the "ATT14" element
1363          */
1364         public org.apache.xmlbeans.XmlString xgetATT14()
1365         {
1366             synchronized (monitor())
1367             {
1368                 check_orphaned();
1369                 org.apache.xmlbeans.XmlString target = null;
1370                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT14$26, 0);
1371                 return target;
1372             }
1373         }
1374         
1375         /**
1376          * True if has "ATT14" element
1377          */
1378         public boolean isSetATT14()
1379         {
1380             synchronized (monitor())
1381             {
1382                 check_orphaned();
1383                 return get_store().count_elements(ATT14$26) != 0;
1384             }
1385         }
1386         
1387         /**
1388          * Sets the "ATT14" element
1389          */
1390         public void setATT14(java.lang.String att14)
1391         {
1392             synchronized (monitor())
1393             {
1394                 check_orphaned();
1395                 org.apache.xmlbeans.SimpleValue target = null;
1396                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT14$26, 0);
1397                 if (target == null)
1398                 {
1399                     target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(ATT14$26);
1400                 }
1401                 target.setStringValue(att14);
1402             }
1403         }
1404         
1405         /**
1406          * Sets (as xml) the "ATT14" element
1407          */
1408         public void xsetATT14(org.apache.xmlbeans.XmlString att14)
1409         {
1410             synchronized (monitor())
1411             {
1412                 check_orphaned();
1413                 org.apache.xmlbeans.XmlString target = null;
1414                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT14$26, 0);
1415                 if (target == null)
1416                 {
1417                     target = (org.apache.xmlbeans.XmlString)get_store().add_element_user(ATT14$26);
1418                 }
1419                 target.set(att14);
1420             }
1421         }
1422         
1423         /**
1424          * Unsets the "ATT14" element
1425          */
1426         public void unsetATT14()
1427         {
1428             synchronized (monitor())
1429             {
1430                 check_orphaned();
1431                 get_store().remove_element(ATT14$26, 0);
1432             }
1433         }
1434         
1435         /**
1436          * Gets the "ATT15" element
1437          */
1438         public java.lang.String getATT15()
1439         {
1440             synchronized (monitor())
1441             {
1442                 check_orphaned();
1443                 org.apache.xmlbeans.SimpleValue target = null;
1444                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT15$28, 0);
1445                 if (target == null)
1446                 {
1447                     return null;
1448                 }
1449                 return target.getStringValue();
1450             }
1451         }
1452         
1453         /**
1454          * Gets (as xml) the "ATT15" element
1455          */
1456         public org.apache.xmlbeans.XmlString xgetATT15()
1457         {
1458             synchronized (monitor())
1459             {
1460                 check_orphaned();
1461                 org.apache.xmlbeans.XmlString target = null;
1462                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT15$28, 0);
1463                 return target;
1464             }
1465         }
1466         
1467         /**
1468          * True if has "ATT15" element
1469          */
1470         public boolean isSetATT15()
1471         {
1472             synchronized (monitor())
1473             {
1474                 check_orphaned();
1475                 return get_store().count_elements(ATT15$28) != 0;
1476             }
1477         }
1478         
1479         /**
1480          * Sets the "ATT15" element
1481          */
1482         public void setATT15(java.lang.String att15)
1483         {
1484             synchronized (monitor())
1485             {
1486                 check_orphaned();
1487                 org.apache.xmlbeans.SimpleValue target = null;
1488                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT15$28, 0);
1489                 if (target == null)
1490                 {
1491                     target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(ATT15$28);
1492                 }
1493                 target.setStringValue(att15);
1494             }
1495         }
1496         
1497         /**
1498          * Sets (as xml) the "ATT15" element
1499          */
1500         public void xsetATT15(org.apache.xmlbeans.XmlString att15)
1501         {
1502             synchronized (monitor())
1503             {
1504                 check_orphaned();
1505                 org.apache.xmlbeans.XmlString target = null;
1506                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT15$28, 0);
1507                 if (target == null)
1508                 {
1509                     target = (org.apache.xmlbeans.XmlString)get_store().add_element_user(ATT15$28);
1510                 }
1511                 target.set(att15);
1512             }
1513         }
1514         
1515         /**
1516          * Unsets the "ATT15" element
1517          */
1518         public void unsetATT15()
1519         {
1520             synchronized (monitor())
1521             {
1522                 check_orphaned();
1523                 get_store().remove_element(ATT15$28, 0);
1524             }
1525         }
1526         
1527         /**
1528          * Gets the "ATT16" element
1529          */
1530         public java.lang.String getATT16()
1531         {
1532             synchronized (monitor())
1533             {
1534                 check_orphaned();
1535                 org.apache.xmlbeans.SimpleValue target = null;
1536                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT16$30, 0);
1537                 if (target == null)
1538                 {
1539                     return null;
1540                 }
1541                 return target.getStringValue();
1542             }
1543         }
1544         
1545         /**
1546          * Gets (as xml) the "ATT16" element
1547          */
1548         public org.apache.xmlbeans.XmlString xgetATT16()
1549         {
1550             synchronized (monitor())
1551             {
1552                 check_orphaned();
1553                 org.apache.xmlbeans.XmlString target = null;
1554                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT16$30, 0);
1555                 return target;
1556             }
1557         }
1558         
1559         /**
1560          * True if has "ATT16" element
1561          */
1562         public boolean isSetATT16()
1563         {
1564             synchronized (monitor())
1565             {
1566                 check_orphaned();
1567                 return get_store().count_elements(ATT16$30) != 0;
1568             }
1569         }
1570         
1571         /**
1572          * Sets the "ATT16" element
1573          */
1574         public void setATT16(java.lang.String att16)
1575         {
1576             synchronized (monitor())
1577             {
1578                 check_orphaned();
1579                 org.apache.xmlbeans.SimpleValue target = null;
1580                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT16$30, 0);
1581                 if (target == null)
1582                 {
1583                     target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(ATT16$30);
1584                 }
1585                 target.setStringValue(att16);
1586             }
1587         }
1588         
1589         /**
1590          * Sets (as xml) the "ATT16" element
1591          */
1592         public void xsetATT16(org.apache.xmlbeans.XmlString att16)
1593         {
1594             synchronized (monitor())
1595             {
1596                 check_orphaned();
1597                 org.apache.xmlbeans.XmlString target = null;
1598                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT16$30, 0);
1599                 if (target == null)
1600                 {
1601                     target = (org.apache.xmlbeans.XmlString)get_store().add_element_user(ATT16$30);
1602                 }
1603                 target.set(att16);
1604             }
1605         }
1606         
1607         /**
1608          * Unsets the "ATT16" element
1609          */
1610         public void unsetATT16()
1611         {
1612             synchronized (monitor())
1613             {
1614                 check_orphaned();
1615                 get_store().remove_element(ATT16$30, 0);
1616             }
1617         }
1618         
1619         /**
1620          * Gets the "ATT17" element
1621          */
1622         public java.lang.String getATT17()
1623         {
1624             synchronized (monitor())
1625             {
1626                 check_orphaned();
1627                 org.apache.xmlbeans.SimpleValue target = null;
1628                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT17$32, 0);
1629                 if (target == null)
1630                 {
1631                     return null;
1632                 }
1633                 return target.getStringValue();
1634             }
1635         }
1636         
1637         /**
1638          * Gets (as xml) the "ATT17" element
1639          */
1640         public org.apache.xmlbeans.XmlString xgetATT17()
1641         {
1642             synchronized (monitor())
1643             {
1644                 check_orphaned();
1645                 org.apache.xmlbeans.XmlString target = null;
1646                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT17$32, 0);
1647                 return target;
1648             }
1649         }
1650         
1651         /**
1652          * True if has "ATT17" element
1653          */
1654         public boolean isSetATT17()
1655         {
1656             synchronized (monitor())
1657             {
1658                 check_orphaned();
1659                 return get_store().count_elements(ATT17$32) != 0;
1660             }
1661         }
1662         
1663         /**
1664          * Sets the "ATT17" element
1665          */
1666         public void setATT17(java.lang.String att17)
1667         {
1668             synchronized (monitor())
1669             {
1670                 check_orphaned();
1671                 org.apache.xmlbeans.SimpleValue target = null;
1672                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT17$32, 0);
1673                 if (target == null)
1674                 {
1675                     target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(ATT17$32);
1676                 }
1677                 target.setStringValue(att17);
1678             }
1679         }
1680         
1681         /**
1682          * Sets (as xml) the "ATT17" element
1683          */
1684         public void xsetATT17(org.apache.xmlbeans.XmlString att17)
1685         {
1686             synchronized (monitor())
1687             {
1688                 check_orphaned();
1689                 org.apache.xmlbeans.XmlString target = null;
1690                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT17$32, 0);
1691                 if (target == null)
1692                 {
1693                     target = (org.apache.xmlbeans.XmlString)get_store().add_element_user(ATT17$32);
1694                 }
1695                 target.set(att17);
1696             }
1697         }
1698         
1699         /**
1700          * Unsets the "ATT17" element
1701          */
1702         public void unsetATT17()
1703         {
1704             synchronized (monitor())
1705             {
1706                 check_orphaned();
1707                 get_store().remove_element(ATT17$32, 0);
1708             }
1709         }
1710         
1711         /**
1712          * Gets the "ATT18" element
1713          */
1714         public java.lang.String getATT18()
1715         {
1716             synchronized (monitor())
1717             {
1718                 check_orphaned();
1719                 org.apache.xmlbeans.SimpleValue target = null;
1720                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT18$34, 0);
1721                 if (target == null)
1722                 {
1723                     return null;
1724                 }
1725                 return target.getStringValue();
1726             }
1727         }
1728         
1729         /**
1730          * Gets (as xml) the "ATT18" element
1731          */
1732         public org.apache.xmlbeans.XmlString xgetATT18()
1733         {
1734             synchronized (monitor())
1735             {
1736                 check_orphaned();
1737                 org.apache.xmlbeans.XmlString target = null;
1738                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT18$34, 0);
1739                 return target;
1740             }
1741         }
1742         
1743         /**
1744          * True if has "ATT18" element
1745          */
1746         public boolean isSetATT18()
1747         {
1748             synchronized (monitor())
1749             {
1750                 check_orphaned();
1751                 return get_store().count_elements(ATT18$34) != 0;
1752             }
1753         }
1754         
1755         /**
1756          * Sets the "ATT18" element
1757          */
1758         public void setATT18(java.lang.String att18)
1759         {
1760             synchronized (monitor())
1761             {
1762                 check_orphaned();
1763                 org.apache.xmlbeans.SimpleValue target = null;
1764                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT18$34, 0);
1765                 if (target == null)
1766                 {
1767                     target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(ATT18$34);
1768                 }
1769                 target.setStringValue(att18);
1770             }
1771         }
1772         
1773         /**
1774          * Sets (as xml) the "ATT18" element
1775          */
1776         public void xsetATT18(org.apache.xmlbeans.XmlString att18)
1777         {
1778             synchronized (monitor())
1779             {
1780                 check_orphaned();
1781                 org.apache.xmlbeans.XmlString target = null;
1782                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT18$34, 0);
1783                 if (target == null)
1784                 {
1785                     target = (org.apache.xmlbeans.XmlString)get_store().add_element_user(ATT18$34);
1786                 }
1787                 target.set(att18);
1788             }
1789         }
1790         
1791         /**
1792          * Unsets the "ATT18" element
1793          */
1794         public void unsetATT18()
1795         {
1796             synchronized (monitor())
1797             {
1798                 check_orphaned();
1799                 get_store().remove_element(ATT18$34, 0);
1800             }
1801         }
1802         
1803         /**
1804          * Gets the "ATT19" element
1805          */
1806         public java.lang.String getATT19()
1807         {
1808             synchronized (monitor())
1809             {
1810                 check_orphaned();
1811                 org.apache.xmlbeans.SimpleValue target = null;
1812                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT19$36, 0);
1813                 if (target == null)
1814                 {
1815                     return null;
1816                 }
1817                 return target.getStringValue();
1818             }
1819         }
1820         
1821         /**
1822          * Gets (as xml) the "ATT19" element
1823          */
1824         public org.apache.xmlbeans.XmlString xgetATT19()
1825         {
1826             synchronized (monitor())
1827             {
1828                 check_orphaned();
1829                 org.apache.xmlbeans.XmlString target = null;
1830                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT19$36, 0);
1831                 return target;
1832             }
1833         }
1834         
1835         /**
1836          * True if has "ATT19" element
1837          */
1838         public boolean isSetATT19()
1839         {
1840             synchronized (monitor())
1841             {
1842                 check_orphaned();
1843                 return get_store().count_elements(ATT19$36) != 0;
1844             }
1845         }
1846         
1847         /**
1848          * Sets the "ATT19" element
1849          */
1850         public void setATT19(java.lang.String att19)
1851         {
1852             synchronized (monitor())
1853             {
1854                 check_orphaned();
1855                 org.apache.xmlbeans.SimpleValue target = null;
1856                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT19$36, 0);
1857                 if (target == null)
1858                 {
1859                     target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(ATT19$36);
1860                 }
1861                 target.setStringValue(att19);
1862             }
1863         }
1864         
1865         /**
1866          * Sets (as xml) the "ATT19" element
1867          */
1868         public void xsetATT19(org.apache.xmlbeans.XmlString att19)
1869         {
1870             synchronized (monitor())
1871             {
1872                 check_orphaned();
1873                 org.apache.xmlbeans.XmlString target = null;
1874                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT19$36, 0);
1875                 if (target == null)
1876                 {
1877                     target = (org.apache.xmlbeans.XmlString)get_store().add_element_user(ATT19$36);
1878                 }
1879                 target.set(att19);
1880             }
1881         }
1882         
1883         /**
1884          * Unsets the "ATT19" element
1885          */
1886         public void unsetATT19()
1887         {
1888             synchronized (monitor())
1889             {
1890                 check_orphaned();
1891                 get_store().remove_element(ATT19$36, 0);
1892             }
1893         }
1894         
1895         /**
1896          * Gets the "ATT20" element
1897          */
1898         public java.lang.String getATT20()
1899         {
1900             synchronized (monitor())
1901             {
1902                 check_orphaned();
1903                 org.apache.xmlbeans.SimpleValue target = null;
1904                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT20$38, 0);
1905                 if (target == null)
1906                 {
1907                     return null;
1908                 }
1909                 return target.getStringValue();
1910             }
1911         }
1912         
1913         /**
1914          * Gets (as xml) the "ATT20" element
1915          */
1916         public org.apache.xmlbeans.XmlString xgetATT20()
1917         {
1918             synchronized (monitor())
1919             {
1920                 check_orphaned();
1921                 org.apache.xmlbeans.XmlString target = null;
1922                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT20$38, 0);
1923                 return target;
1924             }
1925         }
1926         
1927         /**
1928          * True if has "ATT20" element
1929          */
1930         public boolean isSetATT20()
1931         {
1932             synchronized (monitor())
1933             {
1934                 check_orphaned();
1935                 return get_store().count_elements(ATT20$38) != 0;
1936             }
1937         }
1938         
1939         /**
1940          * Sets the "ATT20" element
1941          */
1942         public void setATT20(java.lang.String att20)
1943         {
1944             synchronized (monitor())
1945             {
1946                 check_orphaned();
1947                 org.apache.xmlbeans.SimpleValue target = null;
1948                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT20$38, 0);
1949                 if (target == null)
1950                 {
1951                     target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(ATT20$38);
1952                 }
1953                 target.setStringValue(att20);
1954             }
1955         }
1956         
1957         /**
1958          * Sets (as xml) the "ATT20" element
1959          */
1960         public void xsetATT20(org.apache.xmlbeans.XmlString att20)
1961         {
1962             synchronized (monitor())
1963             {
1964                 check_orphaned();
1965                 org.apache.xmlbeans.XmlString target = null;
1966                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT20$38, 0);
1967                 if (target == null)
1968                 {
1969                     target = (org.apache.xmlbeans.XmlString)get_store().add_element_user(ATT20$38);
1970                 }
1971                 target.set(att20);
1972             }
1973         }
1974         
1975         /**
1976          * Unsets the "ATT20" element
1977          */
1978         public void unsetATT20()
1979         {
1980             synchronized (monitor())
1981             {
1982                 check_orphaned();
1983                 get_store().remove_element(ATT20$38, 0);
1984             }
1985         }
1986         
1987         /**
1988          * Gets the "ATT21" element
1989          */
1990         public java.lang.String getATT21()
1991         {
1992             synchronized (monitor())
1993             {
1994                 check_orphaned();
1995                 org.apache.xmlbeans.SimpleValue target = null;
1996                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT21$40, 0);
1997                 if (target == null)
1998                 {
1999                     return null;
2000                 }
2001                 return target.getStringValue();
2002             }
2003         }
2004         
2005         /**
2006          * Gets (as xml) the "ATT21" element
2007          */
2008         public org.apache.xmlbeans.XmlString xgetATT21()
2009         {
2010             synchronized (monitor())
2011             {
2012                 check_orphaned();
2013                 org.apache.xmlbeans.XmlString target = null;
2014                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT21$40, 0);
2015                 return target;
2016             }
2017         }
2018         
2019         /**
2020          * True if has "ATT21" element
2021          */
2022         public boolean isSetATT21()
2023         {
2024             synchronized (monitor())
2025             {
2026                 check_orphaned();
2027                 return get_store().count_elements(ATT21$40) != 0;
2028             }
2029         }
2030         
2031         /**
2032          * Sets the "ATT21" element
2033          */
2034         public void setATT21(java.lang.String att21)
2035         {
2036             synchronized (monitor())
2037             {
2038                 check_orphaned();
2039                 org.apache.xmlbeans.SimpleValue target = null;
2040                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT21$40, 0);
2041                 if (target == null)
2042                 {
2043                     target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(ATT21$40);
2044                 }
2045                 target.setStringValue(att21);
2046             }
2047         }
2048         
2049         /**
2050          * Sets (as xml) the "ATT21" element
2051          */
2052         public void xsetATT21(org.apache.xmlbeans.XmlString att21)
2053         {
2054             synchronized (monitor())
2055             {
2056                 check_orphaned();
2057                 org.apache.xmlbeans.XmlString target = null;
2058                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT21$40, 0);
2059                 if (target == null)
2060                 {
2061                     target = (org.apache.xmlbeans.XmlString)get_store().add_element_user(ATT21$40);
2062                 }
2063                 target.set(att21);
2064             }
2065         }
2066         
2067         /**
2068          * Unsets the "ATT21" element
2069          */
2070         public void unsetATT21()
2071         {
2072             synchronized (monitor())
2073             {
2074                 check_orphaned();
2075                 get_store().remove_element(ATT21$40, 0);
2076             }
2077         }
2078         
2079         /**
2080          * Gets the "ATT22" element
2081          */
2082         public java.lang.String getATT22()
2083         {
2084             synchronized (monitor())
2085             {
2086                 check_orphaned();
2087                 org.apache.xmlbeans.SimpleValue target = null;
2088                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT22$42, 0);
2089                 if (target == null)
2090                 {
2091                     return null;
2092                 }
2093                 return target.getStringValue();
2094             }
2095         }
2096         
2097         /**
2098          * Gets (as xml) the "ATT22" element
2099          */
2100         public org.apache.xmlbeans.XmlString xgetATT22()
2101         {
2102             synchronized (monitor())
2103             {
2104                 check_orphaned();
2105                 org.apache.xmlbeans.XmlString target = null;
2106                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT22$42, 0);
2107                 return target;
2108             }
2109         }
2110         
2111         /**
2112          * True if has "ATT22" element
2113          */
2114         public boolean isSetATT22()
2115         {
2116             synchronized (monitor())
2117             {
2118                 check_orphaned();
2119                 return get_store().count_elements(ATT22$42) != 0;
2120             }
2121         }
2122         
2123         /**
2124          * Sets the "ATT22" element
2125          */
2126         public void setATT22(java.lang.String att22)
2127         {
2128             synchronized (monitor())
2129             {
2130                 check_orphaned();
2131                 org.apache.xmlbeans.SimpleValue target = null;
2132                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT22$42, 0);
2133                 if (target == null)
2134                 {
2135                     target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(ATT22$42);
2136                 }
2137                 target.setStringValue(att22);
2138             }
2139         }
2140         
2141         /**
2142          * Sets (as xml) the "ATT22" element
2143          */
2144         public void xsetATT22(org.apache.xmlbeans.XmlString att22)
2145         {
2146             synchronized (monitor())
2147             {
2148                 check_orphaned();
2149                 org.apache.xmlbeans.XmlString target = null;
2150                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT22$42, 0);
2151                 if (target == null)
2152                 {
2153                     target = (org.apache.xmlbeans.XmlString)get_store().add_element_user(ATT22$42);
2154                 }
2155                 target.set(att22);
2156             }
2157         }
2158         
2159         /**
2160          * Unsets the "ATT22" element
2161          */
2162         public void unsetATT22()
2163         {
2164             synchronized (monitor())
2165             {
2166                 check_orphaned();
2167                 get_store().remove_element(ATT22$42, 0);
2168             }
2169         }
2170         
2171         /**
2172          * Gets the "ATT23" element
2173          */
2174         public java.lang.String getATT23()
2175         {
2176             synchronized (monitor())
2177             {
2178                 check_orphaned();
2179                 org.apache.xmlbeans.SimpleValue target = null;
2180                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT23$44, 0);
2181                 if (target == null)
2182                 {
2183                     return null;
2184                 }
2185                 return target.getStringValue();
2186             }
2187         }
2188         
2189         /**
2190          * Gets (as xml) the "ATT23" element
2191          */
2192         public org.apache.xmlbeans.XmlString xgetATT23()
2193         {
2194             synchronized (monitor())
2195             {
2196                 check_orphaned();
2197                 org.apache.xmlbeans.XmlString target = null;
2198                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT23$44, 0);
2199                 return target;
2200             }
2201         }
2202         
2203         /**
2204          * True if has "ATT23" element
2205          */
2206         public boolean isSetATT23()
2207         {
2208             synchronized (monitor())
2209             {
2210                 check_orphaned();
2211                 return get_store().count_elements(ATT23$44) != 0;
2212             }
2213         }
2214         
2215         /**
2216          * Sets the "ATT23" element
2217          */
2218         public void setATT23(java.lang.String att23)
2219         {
2220             synchronized (monitor())
2221             {
2222                 check_orphaned();
2223                 org.apache.xmlbeans.SimpleValue target = null;
2224                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT23$44, 0);
2225                 if (target == null)
2226                 {
2227                     target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(ATT23$44);
2228                 }
2229                 target.setStringValue(att23);
2230             }
2231         }
2232         
2233         /**
2234          * Sets (as xml) the "ATT23" element
2235          */
2236         public void xsetATT23(org.apache.xmlbeans.XmlString att23)
2237         {
2238             synchronized (monitor())
2239             {
2240                 check_orphaned();
2241                 org.apache.xmlbeans.XmlString target = null;
2242                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT23$44, 0);
2243                 if (target == null)
2244                 {
2245                     target = (org.apache.xmlbeans.XmlString)get_store().add_element_user(ATT23$44);
2246                 }
2247                 target.set(att23);
2248             }
2249         }
2250         
2251         /**
2252          * Unsets the "ATT23" element
2253          */
2254         public void unsetATT23()
2255         {
2256             synchronized (monitor())
2257             {
2258                 check_orphaned();
2259                 get_store().remove_element(ATT23$44, 0);
2260             }
2261         }
2262         
2263         /**
2264          * Gets the "ATT24" element
2265          */
2266         public java.lang.String getATT24()
2267         {
2268             synchronized (monitor())
2269             {
2270                 check_orphaned();
2271                 org.apache.xmlbeans.SimpleValue target = null;
2272                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT24$46, 0);
2273                 if (target == null)
2274                 {
2275                     return null;
2276                 }
2277                 return target.getStringValue();
2278             }
2279         }
2280         
2281         /**
2282          * Gets (as xml) the "ATT24" element
2283          */
2284         public org.apache.xmlbeans.XmlString xgetATT24()
2285         {
2286             synchronized (monitor())
2287             {
2288                 check_orphaned();
2289                 org.apache.xmlbeans.XmlString target = null;
2290                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT24$46, 0);
2291                 return target;
2292             }
2293         }
2294         
2295         /**
2296          * True if has "ATT24" element
2297          */
2298         public boolean isSetATT24()
2299         {
2300             synchronized (monitor())
2301             {
2302                 check_orphaned();
2303                 return get_store().count_elements(ATT24$46) != 0;
2304             }
2305         }
2306         
2307         /**
2308          * Sets the "ATT24" element
2309          */
2310         public void setATT24(java.lang.String att24)
2311         {
2312             synchronized (monitor())
2313             {
2314                 check_orphaned();
2315                 org.apache.xmlbeans.SimpleValue target = null;
2316                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT24$46, 0);
2317                 if (target == null)
2318                 {
2319                     target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(ATT24$46);
2320                 }
2321                 target.setStringValue(att24);
2322             }
2323         }
2324         
2325         /**
2326          * Sets (as xml) the "ATT24" element
2327          */
2328         public void xsetATT24(org.apache.xmlbeans.XmlString att24)
2329         {
2330             synchronized (monitor())
2331             {
2332                 check_orphaned();
2333                 org.apache.xmlbeans.XmlString target = null;
2334                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT24$46, 0);
2335                 if (target == null)
2336                 {
2337                     target = (org.apache.xmlbeans.XmlString)get_store().add_element_user(ATT24$46);
2338                 }
2339                 target.set(att24);
2340             }
2341         }
2342         
2343         /**
2344          * Unsets the "ATT24" element
2345          */
2346         public void unsetATT24()
2347         {
2348             synchronized (monitor())
2349             {
2350                 check_orphaned();
2351                 get_store().remove_element(ATT24$46, 0);
2352             }
2353         }
2354         
2355         /**
2356          * Gets the "ATT25" element
2357          */
2358         public java.lang.String getATT25()
2359         {
2360             synchronized (monitor())
2361             {
2362                 check_orphaned();
2363                 org.apache.xmlbeans.SimpleValue target = null;
2364                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT25$48, 0);
2365                 if (target == null)
2366                 {
2367                     return null;
2368                 }
2369                 return target.getStringValue();
2370             }
2371         }
2372         
2373         /**
2374          * Gets (as xml) the "ATT25" element
2375          */
2376         public org.apache.xmlbeans.XmlString xgetATT25()
2377         {
2378             synchronized (monitor())
2379             {
2380                 check_orphaned();
2381                 org.apache.xmlbeans.XmlString target = null;
2382                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT25$48, 0);
2383                 return target;
2384             }
2385         }
2386         
2387         /**
2388          * True if has "ATT25" element
2389          */
2390         public boolean isSetATT25()
2391         {
2392             synchronized (monitor())
2393             {
2394                 check_orphaned();
2395                 return get_store().count_elements(ATT25$48) != 0;
2396             }
2397         }
2398         
2399         /**
2400          * Sets the "ATT25" element
2401          */
2402         public void setATT25(java.lang.String att25)
2403         {
2404             synchronized (monitor())
2405             {
2406                 check_orphaned();
2407                 org.apache.xmlbeans.SimpleValue target = null;
2408                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT25$48, 0);
2409                 if (target == null)
2410                 {
2411                     target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(ATT25$48);
2412                 }
2413                 target.setStringValue(att25);
2414             }
2415         }
2416         
2417         /**
2418          * Sets (as xml) the "ATT25" element
2419          */
2420         public void xsetATT25(org.apache.xmlbeans.XmlString att25)
2421         {
2422             synchronized (monitor())
2423             {
2424                 check_orphaned();
2425                 org.apache.xmlbeans.XmlString target = null;
2426                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT25$48, 0);
2427                 if (target == null)
2428                 {
2429                     target = (org.apache.xmlbeans.XmlString)get_store().add_element_user(ATT25$48);
2430                 }
2431                 target.set(att25);
2432             }
2433         }
2434         
2435         /**
2436          * Unsets the "ATT25" element
2437          */
2438         public void unsetATT25()
2439         {
2440             synchronized (monitor())
2441             {
2442                 check_orphaned();
2443                 get_store().remove_element(ATT25$48, 0);
2444             }
2445         }
2446         
2447         /**
2448          * Gets the "ATT26" element
2449          */
2450         public java.lang.String getATT26()
2451         {
2452             synchronized (monitor())
2453             {
2454                 check_orphaned();
2455                 org.apache.xmlbeans.SimpleValue target = null;
2456                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT26$50, 0);
2457                 if (target == null)
2458                 {
2459                     return null;
2460                 }
2461                 return target.getStringValue();
2462             }
2463         }
2464         
2465         /**
2466          * Gets (as xml) the "ATT26" element
2467          */
2468         public org.apache.xmlbeans.XmlString xgetATT26()
2469         {
2470             synchronized (monitor())
2471             {
2472                 check_orphaned();
2473                 org.apache.xmlbeans.XmlString target = null;
2474                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT26$50, 0);
2475                 return target;
2476             }
2477         }
2478         
2479         /**
2480          * True if has "ATT26" element
2481          */
2482         public boolean isSetATT26()
2483         {
2484             synchronized (monitor())
2485             {
2486                 check_orphaned();
2487                 return get_store().count_elements(ATT26$50) != 0;
2488             }
2489         }
2490         
2491         /**
2492          * Sets the "ATT26" element
2493          */
2494         public void setATT26(java.lang.String att26)
2495         {
2496             synchronized (monitor())
2497             {
2498                 check_orphaned();
2499                 org.apache.xmlbeans.SimpleValue target = null;
2500                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT26$50, 0);
2501                 if (target == null)
2502                 {
2503                     target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(ATT26$50);
2504                 }
2505                 target.setStringValue(att26);
2506             }
2507         }
2508         
2509         /**
2510          * Sets (as xml) the "ATT26" element
2511          */
2512         public void xsetATT26(org.apache.xmlbeans.XmlString att26)
2513         {
2514             synchronized (monitor())
2515             {
2516                 check_orphaned();
2517                 org.apache.xmlbeans.XmlString target = null;
2518                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT26$50, 0);
2519                 if (target == null)
2520                 {
2521                     target = (org.apache.xmlbeans.XmlString)get_store().add_element_user(ATT26$50);
2522                 }
2523                 target.set(att26);
2524             }
2525         }
2526         
2527         /**
2528          * Unsets the "ATT26" element
2529          */
2530         public void unsetATT26()
2531         {
2532             synchronized (monitor())
2533             {
2534                 check_orphaned();
2535                 get_store().remove_element(ATT26$50, 0);
2536             }
2537         }
2538         
2539         /**
2540          * Gets the "ATT27" element
2541          */
2542         public java.lang.String getATT27()
2543         {
2544             synchronized (monitor())
2545             {
2546                 check_orphaned();
2547                 org.apache.xmlbeans.SimpleValue target = null;
2548                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT27$52, 0);
2549                 if (target == null)
2550                 {
2551                     return null;
2552                 }
2553                 return target.getStringValue();
2554             }
2555         }
2556         
2557         /**
2558          * Gets (as xml) the "ATT27" element
2559          */
2560         public org.apache.xmlbeans.XmlString xgetATT27()
2561         {
2562             synchronized (monitor())
2563             {
2564                 check_orphaned();
2565                 org.apache.xmlbeans.XmlString target = null;
2566                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT27$52, 0);
2567                 return target;
2568             }
2569         }
2570         
2571         /**
2572          * True if has "ATT27" element
2573          */
2574         public boolean isSetATT27()
2575         {
2576             synchronized (monitor())
2577             {
2578                 check_orphaned();
2579                 return get_store().count_elements(ATT27$52) != 0;
2580             }
2581         }
2582         
2583         /**
2584          * Sets the "ATT27" element
2585          */
2586         public void setATT27(java.lang.String att27)
2587         {
2588             synchronized (monitor())
2589             {
2590                 check_orphaned();
2591                 org.apache.xmlbeans.SimpleValue target = null;
2592                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT27$52, 0);
2593                 if (target == null)
2594                 {
2595                     target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(ATT27$52);
2596                 }
2597                 target.setStringValue(att27);
2598             }
2599         }
2600         
2601         /**
2602          * Sets (as xml) the "ATT27" element
2603          */
2604         public void xsetATT27(org.apache.xmlbeans.XmlString att27)
2605         {
2606             synchronized (monitor())
2607             {
2608                 check_orphaned();
2609                 org.apache.xmlbeans.XmlString target = null;
2610                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT27$52, 0);
2611                 if (target == null)
2612                 {
2613                     target = (org.apache.xmlbeans.XmlString)get_store().add_element_user(ATT27$52);
2614                 }
2615                 target.set(att27);
2616             }
2617         }
2618         
2619         /**
2620          * Unsets the "ATT27" element
2621          */
2622         public void unsetATT27()
2623         {
2624             synchronized (monitor())
2625             {
2626                 check_orphaned();
2627                 get_store().remove_element(ATT27$52, 0);
2628             }
2629         }
2630         
2631         /**
2632          * Gets the "ATT28" element
2633          */
2634         public java.lang.String getATT28()
2635         {
2636             synchronized (monitor())
2637             {
2638                 check_orphaned();
2639                 org.apache.xmlbeans.SimpleValue target = null;
2640                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT28$54, 0);
2641                 if (target == null)
2642                 {
2643                     return null;
2644                 }
2645                 return target.getStringValue();
2646             }
2647         }
2648         
2649         /**
2650          * Gets (as xml) the "ATT28" element
2651          */
2652         public org.apache.xmlbeans.XmlString xgetATT28()
2653         {
2654             synchronized (monitor())
2655             {
2656                 check_orphaned();
2657                 org.apache.xmlbeans.XmlString target = null;
2658                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT28$54, 0);
2659                 return target;
2660             }
2661         }
2662         
2663         /**
2664          * True if has "ATT28" element
2665          */
2666         public boolean isSetATT28()
2667         {
2668             synchronized (monitor())
2669             {
2670                 check_orphaned();
2671                 return get_store().count_elements(ATT28$54) != 0;
2672             }
2673         }
2674         
2675         /**
2676          * Sets the "ATT28" element
2677          */
2678         public void setATT28(java.lang.String att28)
2679         {
2680             synchronized (monitor())
2681             {
2682                 check_orphaned();
2683                 org.apache.xmlbeans.SimpleValue target = null;
2684                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT28$54, 0);
2685                 if (target == null)
2686                 {
2687                     target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(ATT28$54);
2688                 }
2689                 target.setStringValue(att28);
2690             }
2691         }
2692         
2693         /**
2694          * Sets (as xml) the "ATT28" element
2695          */
2696         public void xsetATT28(org.apache.xmlbeans.XmlString att28)
2697         {
2698             synchronized (monitor())
2699             {
2700                 check_orphaned();
2701                 org.apache.xmlbeans.XmlString target = null;
2702                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT28$54, 0);
2703                 if (target == null)
2704                 {
2705                     target = (org.apache.xmlbeans.XmlString)get_store().add_element_user(ATT28$54);
2706                 }
2707                 target.set(att28);
2708             }
2709         }
2710         
2711         /**
2712          * Unsets the "ATT28" element
2713          */
2714         public void unsetATT28()
2715         {
2716             synchronized (monitor())
2717             {
2718                 check_orphaned();
2719                 get_store().remove_element(ATT28$54, 0);
2720             }
2721         }
2722         
2723         /**
2724          * Gets the "ATT29" element
2725          */
2726         public java.lang.String getATT29()
2727         {
2728             synchronized (monitor())
2729             {
2730                 check_orphaned();
2731                 org.apache.xmlbeans.SimpleValue target = null;
2732                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT29$56, 0);
2733                 if (target == null)
2734                 {
2735                     return null;
2736                 }
2737                 return target.getStringValue();
2738             }
2739         }
2740         
2741         /**
2742          * Gets (as xml) the "ATT29" element
2743          */
2744         public org.apache.xmlbeans.XmlString xgetATT29()
2745         {
2746             synchronized (monitor())
2747             {
2748                 check_orphaned();
2749                 org.apache.xmlbeans.XmlString target = null;
2750                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT29$56, 0);
2751                 return target;
2752             }
2753         }
2754         
2755         /**
2756          * True if has "ATT29" element
2757          */
2758         public boolean isSetATT29()
2759         {
2760             synchronized (monitor())
2761             {
2762                 check_orphaned();
2763                 return get_store().count_elements(ATT29$56) != 0;
2764             }
2765         }
2766         
2767         /**
2768          * Sets the "ATT29" element
2769          */
2770         public void setATT29(java.lang.String att29)
2771         {
2772             synchronized (monitor())
2773             {
2774                 check_orphaned();
2775                 org.apache.xmlbeans.SimpleValue target = null;
2776                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT29$56, 0);
2777                 if (target == null)
2778                 {
2779                     target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(ATT29$56);
2780                 }
2781                 target.setStringValue(att29);
2782             }
2783         }
2784         
2785         /**
2786          * Sets (as xml) the "ATT29" element
2787          */
2788         public void xsetATT29(org.apache.xmlbeans.XmlString att29)
2789         {
2790             synchronized (monitor())
2791             {
2792                 check_orphaned();
2793                 org.apache.xmlbeans.XmlString target = null;
2794                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT29$56, 0);
2795                 if (target == null)
2796                 {
2797                     target = (org.apache.xmlbeans.XmlString)get_store().add_element_user(ATT29$56);
2798                 }
2799                 target.set(att29);
2800             }
2801         }
2802         
2803         /**
2804          * Unsets the "ATT29" element
2805          */
2806         public void unsetATT29()
2807         {
2808             synchronized (monitor())
2809             {
2810                 check_orphaned();
2811                 get_store().remove_element(ATT29$56, 0);
2812             }
2813         }
2814         
2815         /**
2816          * Gets the "ATT30" element
2817          */
2818         public java.lang.String getATT30()
2819         {
2820             synchronized (monitor())
2821             {
2822                 check_orphaned();
2823                 org.apache.xmlbeans.SimpleValue target = null;
2824                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT30$58, 0);
2825                 if (target == null)
2826                 {
2827                     return null;
2828                 }
2829                 return target.getStringValue();
2830             }
2831         }
2832         
2833         /**
2834          * Gets (as xml) the "ATT30" element
2835          */
2836         public org.apache.xmlbeans.XmlString xgetATT30()
2837         {
2838             synchronized (monitor())
2839             {
2840                 check_orphaned();
2841                 org.apache.xmlbeans.XmlString target = null;
2842                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT30$58, 0);
2843                 return target;
2844             }
2845         }
2846         
2847         /**
2848          * True if has "ATT30" element
2849          */
2850         public boolean isSetATT30()
2851         {
2852             synchronized (monitor())
2853             {
2854                 check_orphaned();
2855                 return get_store().count_elements(ATT30$58) != 0;
2856             }
2857         }
2858         
2859         /**
2860          * Sets the "ATT30" element
2861          */
2862         public void setATT30(java.lang.String att30)
2863         {
2864             synchronized (monitor())
2865             {
2866                 check_orphaned();
2867                 org.apache.xmlbeans.SimpleValue target = null;
2868                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ATT30$58, 0);
2869                 if (target == null)
2870                 {
2871                     target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(ATT30$58);
2872                 }
2873                 target.setStringValue(att30);
2874             }
2875         }
2876         
2877         /**
2878          * Sets (as xml) the "ATT30" element
2879          */
2880         public void xsetATT30(org.apache.xmlbeans.XmlString att30)
2881         {
2882             synchronized (monitor())
2883             {
2884                 check_orphaned();
2885                 org.apache.xmlbeans.XmlString target = null;
2886                 target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ATT30$58, 0);
2887                 if (target == null)
2888                 {
2889                     target = (org.apache.xmlbeans.XmlString)get_store().add_element_user(ATT30$58);
2890                 }
2891                 target.set(att30);
2892             }
2893         }
2894         
2895         /**
2896          * Unsets the "ATT30" element
2897          */
2898         public void unsetATT30()
2899         {
2900             synchronized (monitor())
2901             {
2902                 check_orphaned();
2903                 get_store().remove_element(ATT30$58, 0);
2904             }
2905         }
2906         
2907         /**
2908          * Gets the "BudgetAttachments" element
2909          */
2910         public gov.grants.apply.forms.rrSubawardBudget1030V12.RRSubawardBudget1030Document.RRSubawardBudget1030.BudgetAttachments getBudgetAttachments()
2911         {
2912             synchronized (monitor())
2913             {
2914                 check_orphaned();
2915                 gov.grants.apply.forms.rrSubawardBudget1030V12.RRSubawardBudget1030Document.RRSubawardBudget1030.BudgetAttachments target = null;
2916                 target = (gov.grants.apply.forms.rrSubawardBudget1030V12.RRSubawardBudget1030Document.RRSubawardBudget1030.BudgetAttachments)get_store().find_element_user(BUDGETATTACHMENTS$60, 0);
2917                 if (target == null)
2918                 {
2919                     return null;
2920                 }
2921                 return target;
2922             }
2923         }
2924         
2925         /**
2926          * True if has "BudgetAttachments" element
2927          */
2928         public boolean isSetBudgetAttachments()
2929         {
2930             synchronized (monitor())
2931             {
2932                 check_orphaned();
2933                 return get_store().count_elements(BUDGETATTACHMENTS$60) != 0;
2934             }
2935         }
2936         
2937         /**
2938          * Sets the "BudgetAttachments" element
2939          */
2940         public void setBudgetAttachments(gov.grants.apply.forms.rrSubawardBudget1030V12.RRSubawardBudget1030Document.RRSubawardBudget1030.BudgetAttachments budgetAttachments)
2941         {
2942             generatedSetterHelperImpl(budgetAttachments, BUDGETATTACHMENTS$60, 0, org.apache.xmlbeans.impl.values.XmlObjectBase.KIND_SETTERHELPER_SINGLETON);
2943         }
2944         
2945         /**
2946          * Appends and returns a new empty "BudgetAttachments" element
2947          */
2948         public gov.grants.apply.forms.rrSubawardBudget1030V12.RRSubawardBudget1030Document.RRSubawardBudget1030.BudgetAttachments addNewBudgetAttachments()
2949         {
2950             synchronized (monitor())
2951             {
2952                 check_orphaned();
2953                 gov.grants.apply.forms.rrSubawardBudget1030V12.RRSubawardBudget1030Document.RRSubawardBudget1030.BudgetAttachments target = null;
2954                 target = (gov.grants.apply.forms.rrSubawardBudget1030V12.RRSubawardBudget1030Document.RRSubawardBudget1030.BudgetAttachments)get_store().add_element_user(BUDGETATTACHMENTS$60);
2955                 return target;
2956             }
2957         }
2958         
2959         /**
2960          * Unsets the "BudgetAttachments" element
2961          */
2962         public void unsetBudgetAttachments()
2963         {
2964             synchronized (monitor())
2965             {
2966                 check_orphaned();
2967                 get_store().remove_element(BUDGETATTACHMENTS$60, 0);
2968             }
2969         }
2970         
2971         /**
2972          * Gets the "FormVersion" attribute
2973          */
2974         public java.lang.String getFormVersion()
2975         {
2976             synchronized (monitor())
2977             {
2978                 check_orphaned();
2979                 org.apache.xmlbeans.SimpleValue target = null;
2980                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(FORMVERSION$62);
2981                 if (target == null)
2982                 {
2983                     target = (org.apache.xmlbeans.SimpleValue)get_default_attribute_value(FORMVERSION$62);
2984                 }
2985                 if (target == null)
2986                 {
2987                     return null;
2988                 }
2989                 return target.getStringValue();
2990             }
2991         }
2992         
2993         /**
2994          * Gets (as xml) the "FormVersion" attribute
2995          */
2996         public gov.grants.apply.system.globalLibraryV20.FormVersionDataType xgetFormVersion()
2997         {
2998             synchronized (monitor())
2999             {
3000                 check_orphaned();
3001                 gov.grants.apply.system.globalLibraryV20.FormVersionDataType target = null;
3002                 target = (gov.grants.apply.system.globalLibraryV20.FormVersionDataType)get_store().find_attribute_user(FORMVERSION$62);
3003                 if (target == null)
3004                 {
3005                     target = (gov.grants.apply.system.globalLibraryV20.FormVersionDataType)get_default_attribute_value(FORMVERSION$62);
3006                 }
3007                 return target;
3008             }
3009         }
3010         
3011         /**
3012          * Sets the "FormVersion" attribute
3013          */
3014         public void setFormVersion(java.lang.String formVersion)
3015         {
3016             synchronized (monitor())
3017             {
3018                 check_orphaned();
3019                 org.apache.xmlbeans.SimpleValue target = null;
3020                 target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(FORMVERSION$62);
3021                 if (target == null)
3022                 {
3023                     target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(FORMVERSION$62);
3024                 }
3025                 target.setStringValue(formVersion);
3026             }
3027         }
3028         
3029         /**
3030          * Sets (as xml) the "FormVersion" attribute
3031          */
3032         public void xsetFormVersion(gov.grants.apply.system.globalLibraryV20.FormVersionDataType formVersion)
3033         {
3034             synchronized (monitor())
3035             {
3036                 check_orphaned();
3037                 gov.grants.apply.system.globalLibraryV20.FormVersionDataType target = null;
3038                 target = (gov.grants.apply.system.globalLibraryV20.FormVersionDataType)get_store().find_attribute_user(FORMVERSION$62);
3039                 if (target == null)
3040                 {
3041                     target = (gov.grants.apply.system.globalLibraryV20.FormVersionDataType)get_store().add_attribute_user(FORMVERSION$62);
3042                 }
3043                 target.set(formVersion);
3044             }
3045         }
3046         /**
3047          * An XML BudgetAttachments(@http://apply.grants.gov/forms/RR_SubawardBudget10_30-V1.2).
3048          *
3049          * This is a complex type.
3050          */
3051         public static class BudgetAttachmentsImpl extends org.apache.xmlbeans.impl.values.XmlComplexContentImpl implements gov.grants.apply.forms.rrSubawardBudget1030V12.RRSubawardBudget1030Document.RRSubawardBudget1030.BudgetAttachments
3052         {
3053             private static final long serialVersionUID = 1L;
3054             
3055             public BudgetAttachmentsImpl(org.apache.xmlbeans.SchemaType sType)
3056             {
3057                 super(sType);
3058             }
3059             
3060             private static final javax.xml.namespace.QName RRBUDGET10$0 = 
3061                 new javax.xml.namespace.QName("http://apply.grants.gov/forms/RR_Budget10-V1.1", "RR_Budget10");
3062             
3063             
3064             /**
3065              * Gets array of all "RR_Budget10" elements
3066              */
3067             public gov.grants.apply.forms.rrBudget10V11.RRBudget10Document.RRBudget10[] getRRBudget10Array()
3068             {
3069                 synchronized (monitor())
3070                 {
3071                     check_orphaned();
3072                     java.util.List targetList = new java.util.ArrayList();
3073                     get_store().find_all_element_users(RRBUDGET10$0, targetList);
3074                     gov.grants.apply.forms.rrBudget10V11.RRBudget10Document.RRBudget10[] result = new gov.grants.apply.forms.rrBudget10V11.RRBudget10Document.RRBudget10[targetList.size()];
3075                     targetList.toArray(result);
3076                     return result;
3077                 }
3078             }
3079             
3080             /**
3081              * Gets ith "RR_Budget10" element
3082              */
3083             public gov.grants.apply.forms.rrBudget10V11.RRBudget10Document.RRBudget10 getRRBudget10Array(int i)
3084             {
3085                 synchronized (monitor())
3086                 {
3087                     check_orphaned();
3088                     gov.grants.apply.forms.rrBudget10V11.RRBudget10Document.RRBudget10 target = null;
3089                     target = (gov.grants.apply.forms.rrBudget10V11.RRBudget10Document.RRBudget10)get_store().find_element_user(RRBUDGET10$0, i);
3090                     if (target == null)
3091                     {
3092                       throw new IndexOutOfBoundsException();
3093                     }
3094                     return target;
3095                 }
3096             }
3097             
3098             /**
3099              * Returns number of "RR_Budget10" element
3100              */
3101             public int sizeOfRRBudget10Array()
3102             {
3103                 synchronized (monitor())
3104                 {
3105                     check_orphaned();
3106                     return get_store().count_elements(RRBUDGET10$0);
3107                 }
3108             }
3109             
3110             /**
3111              * Sets array of all "RR_Budget10" element  WARNING: This method is not atomicaly synchronized.
3112              */
3113             public void setRRBudget10Array(gov.grants.apply.forms.rrBudget10V11.RRBudget10Document.RRBudget10[] rrBudget10Array)
3114             {
3115                 check_orphaned();
3116                 arraySetterHelper(rrBudget10Array, RRBUDGET10$0);
3117             }
3118             
3119             /**
3120              * Sets ith "RR_Budget10" element
3121              */
3122             public void setRRBudget10Array(int i, gov.grants.apply.forms.rrBudget10V11.RRBudget10Document.RRBudget10 rrBudget10)
3123             {
3124                 generatedSetterHelperImpl(rrBudget10, RRBUDGET10$0, i, org.apache.xmlbeans.impl.values.XmlObjectBase.KIND_SETTERHELPER_ARRAYITEM);
3125             }
3126             
3127             /**
3128              * Inserts and returns a new empty value (as xml) as the ith "RR_Budget10" element
3129              */
3130             public gov.grants.apply.forms.rrBudget10V11.RRBudget10Document.RRBudget10 insertNewRRBudget10(int i)
3131             {
3132                 synchronized (monitor())
3133                 {
3134                     check_orphaned();
3135                     gov.grants.apply.forms.rrBudget10V11.RRBudget10Document.RRBudget10 target = null;
3136                     target = (gov.grants.apply.forms.rrBudget10V11.RRBudget10Document.RRBudget10)get_store().insert_element_user(RRBUDGET10$0, i);
3137                     return target;
3138                 }
3139             }
3140             
3141             /**
3142              * Appends and returns a new empty value (as xml) as the last "RR_Budget10" element
3143              */
3144             public gov.grants.apply.forms.rrBudget10V11.RRBudget10Document.RRBudget10 addNewRRBudget10()
3145             {
3146                 synchronized (monitor())
3147                 {
3148                     check_orphaned();
3149                     gov.grants.apply.forms.rrBudget10V11.RRBudget10Document.RRBudget10 target = null;
3150                     target = (gov.grants.apply.forms.rrBudget10V11.RRBudget10Document.RRBudget10)get_store().add_element_user(RRBUDGET10$0);
3151                     return target;
3152                 }
3153             }
3154             
3155             /**
3156              * Removes the ith "RR_Budget10" element
3157              */
3158             public void removeRRBudget10(int i)
3159             {
3160                 synchronized (monitor())
3161                 {
3162                     check_orphaned();
3163                     get_store().remove_element(RRBUDGET10$0, i);
3164                 }
3165             }
3166         }
3167     }
3168 }