The below listing gives the XML structure for the builtin operation
\texttt{plus}. It contains two upper level nodes for each real and complex
numbers. Each of these have specialization nodes for the simple arrays of
different dimensions, and
the region arrays. Each of the specializations has 5 types of implementations.

\begin{lstlisting}[language=X10]
<plus>
  <real>
    <simple_array>
      <array_1>
         <type1>
          {
            val x: Double;
            x = a+b;
            return x;
          }
        </type1>
        <type2>
          {a.rank == b.rank}{
            val x = new Array[Double](a.region);
              for (p in a.indices()){
                x(p) = a(p)+ b(p);
              }
              return x;
          } 
        </type2>
        <type3>
          {
            val x = new Array[Double](b.region);
            for (p in b.region){
              x(p) = a+ b(p);
            }
            return x;
          }
        </type3>
        <type4>
          {
            val x = new Array[Double](a.region);
            for (p in a.region){
              x(p) = a(p)+ b;
            }
            return x;
          }
        </type4>
        <type5>
        </type5>
      </array_1>
      <array_2>
        <type1>
          {
            val x: Double;
            x = a+b;
            return x;
          }
        </type1>
        <type2>
          {a.rank == b.rank}{
            val x = new Array[Double](a.region);
              for (p in a.indices()){
                x(p) = a(p)+ b(p);
              }
              return x;
          } 
        </type2>
        <type3>
          {
            val x = new Array[Double](b.region);
            for (p in b.region){
              x(p) = a+ b(p);
            }
            return x;
          }
        </type3>
        <type4>
          {
            val x = new Array[Double](a.region);
            for (p in a.region){
              x(p) = a(p)+ b;
            }
            return x;
          }
        </type4>
        <type5>
        </type5>
      </array_2>
      <array_3>
        <type1>
          {
            val x: Double;
            x = a+b;
            return x;
          }
        </type1>
        <type2>
          {a.rank == b.rank}{
            val x = new Array[Double](a.region);
              for (p in a.indices()){
                x(p) = a(p)+ b(p);
              }
              return x;
          } 
        </type2>
        <type3>
          {
            val x = new Array[Double](b.region);
            for (p in b.region){
              x(p) = a+ b(p);
            }
            return x;
          }
        </type3>
        <type4>
          {
            val x = new Array[Double](a.region);
            for (p in a.region){
              x(p) = a(p)+ b;
            }
            return x;
          }
        </type4>
        <type5>
        </type5>
      </array_3>
    </simple_array>
    <region_array>
        <type1>
          {
            val x: Double;
            x = a+b;
            return x;
          }
        </type1>
        <type2>
          {a.rank == b.rank}{
            val x = new Array[Double](a.region);
              for (p in a.region){
            x(p) = a(p)+ b(p);
            }
            return x;
          } 
      </type2>
      <type3>
        {
          val x = new Array[Double](b.region);
          for (p in b.region){
            x(p) = a+ b(p);
          }
          return x;
        }
      </type3>
      <type4>
        {
          val x = new Array[Double](a.region);
          for (p in a.region){
            x(p) = a(p)+ b;
          }
          return x;
        }
      </type4>
        <type5>
        </type5>
    </region_array>
  </real>
  <complex>
    <simple_array>
      <array_1>
         <type1>
          {
            val x: Double;
            x = a+b;
            return x;
          }
        </type1>
        <type2>
          {a.rank == b.rank}{
            val x = new Array[Double](a.region);
              for (p in a.indices()){
                x(p) = a(p)+ b(p);
              }
              return x;
          } 
        </type2>
        <type3>
          {
            val x = new Array[Double](b.region);
            for (p in b.region){
              x(p) = a+ b(p);
            }
            return x;
          }
        </type3>
        <type4>
          {
            val x = new Array[Double](a.region);
            for (p in a.region){
              x(p) = a(p)+ b;
            }
            return x;
          }
        </type4>
        <type5>
        </type5>
      </array_1>
      <array_2>
        <type1>
          {
            val x: Double;
            x = a+b;
            return x;
          }
        </type1>
        <type2>
          {a.rank == b.rank}{
            val x = new Array[Double](a.region);
              for (p in a.indices()){
                x(p) = a(p)+ b(p);
              }
              return x;
          } 
        </type2>
        <type3>
          {
            val x = new Array[Double](b.region);
            for (p in b.region){
              x(p) = a+ b(p);
            }
            return x;
          }
        </type3>
        <type4>
          {
            val x = new Array[Double](a.region);
            for (p in a.region){
              x(p) = a(p)+ b;
            }
            return x;
          }
        </type4>
        <type5>
        </type5>
      </array_2>
      <array_3>
        <type1>
          {
            val x: Double;
            x = a+b;
            return x;
          }
        </type1>
        <type2>
          {a.rank == b.rank}{
            val x = new Array[Double](a.region);
              for (p in a.indices()){
                x(p) = a(p)+ b(p);
              }
              return x;
          } 
        </type2>
        <type3>
          {
            val x = new Array[Double](b.region);
            for (p in b.region){
              x(p) = a+ b(p);
            }
            return x;
          }
        </type3>
        <type4>
          {
            val x = new Array[Double](a.region);
            for (p in a.region){
              x(p) = a(p)+ b;
            }
            return x;
          }
        </type4>
        <type5>
        </type5>
      </array_3>
    </simple_array>
    <region_array>
        <type1>
          {
            val x: Double;
            x = a+b;
            return x;
          }
        </type1>
        <type2>
          {a.rank == b.rank}{
            val x = new Array[Double](a.region);
              for (p in a.region){
            x(p) = a(p)+ b(p);
            }
            return x;
          } 
      </type2>
      <type3>
        {
          val x = new Array[Double](b.region);
          for (p in b.region){
            x(p) = a+ b(p);
          }
          return x;
        }
      </type3>
      <type4>
        {
          val x = new Array[Double](a.region);
          for (p in a.region){
            x(p) = a(p)+ b;
          }
          return x;
        }
      </type4>
        <type5>
        </type5>
    </region_array>
  </complex>
</plus>
\end{lstlisting}
