! 
! File:          ArrayTest_ArrayOps_Impl.F90
! Symbol:        ArrayTest.ArrayOps-v1.3
! Symbol Type:   class
! Babel Version: 0.10.2
! Description:   Server-side implementation for ArrayTest.ArrayOps
! 
! WARNING: Automatically generated; only changes within splicers preserved
! 
! babel-version = 0.10.2
! 


! 
! Symbol "ArrayTest.ArrayOps" (version 1.3)
! 


#include "ArrayTest_ArrayOps_fAbbrev.h"
#include "sidl_ClassInfo_fAbbrev.h"
#include "sidl_BaseInterface_fAbbrev.h"
#include "sidl_BaseClass_fAbbrev.h"
#include "sidl_char_fAbbrev.h"
#include "sidl_double_fAbbrev.h"
#include "sidl_string_fAbbrev.h"
#include "sidl_long_fAbbrev.h"
#include "sidl_int_fAbbrev.h"
#include "sidl_bool_fAbbrev.h"
#include "sidl_float_fAbbrev.h"
#include "sidl_fcomplex_fAbbrev.h"
#include "sidl_dcomplex_fAbbrev.h"
! DO-NOT-DELETE splicer.begin(_miscellaneous_code_start)
#include "babel_config.h"

subroutine output(tex)
  use synch_RegOut
  implicit none
  character (len=*) :: tex
  type(synch_RegOut_t) :: tracker
  call getInstance(tracker)
  call writecomment(tracker, tex)

end subroutine output


logical function isprime(num)
  implicit none
  integer (selected_int_kind(18)) :: num
  integer (selected_int_kind(18)) :: i
  i = 3
  do while (i*i .le. num)
     if (mod(num,i) .eq. 0) then
        isprime = .false.
        return
     endif
     i = i + 1
  enddo
  isprime = .true.
  return
end function isprime


integer (selected_int_kind(18)) function nextprime(prev)
  implicit none
  integer (selected_int_kind(18)) :: prev
  logical :: isprime
  if (prev .le. 1) then
     nextprime = 2
     return
  endif
  if (prev .eq. 2) then
     nextprime = 3
     return
  endif
  prev = prev + 2
  do while (.not. isprime(prev))
     prev = prev + 2
  enddo
  nextprime = prev
  return
end function nextprime

subroutine force_float(f)
  real(selected_real_kind(6,37)) :: f
  return
end subroutine force_float

subroutine force_fcomplex(f)
  complex(selected_real_kind(6,37)) :: f
  return
end subroutine force_fcomplex

logical function iseven(num)
  integer (selected_int_kind(9))  :: num
  iseven = (mod(num, 2) .eq. 0)
  return
end function iseven

integer (selected_int_kind(9)) function arrayValue(dim, ind)
  implicit none
  integer (selected_int_kind(9)) :: dim, result, i
  integer (selected_int_kind(9)) :: ind(dim)
  result = 1
  do i = 1, dim
     result = result * (ind(i) + i)
  enddo
  arrayValue = result
end function arrayValue

integer (selected_int_kind(9)) function intFunc(dim, ind)
  implicit none
  integer (selected_int_kind(9)) :: dim, ind(dim), i, result
  result = 1
  do i = 1, dim
    result = result * (ind(i) + i)
  enddo
  intFunc = result
  return
end

logical function hasElements(dim, low, up)
  implicit none
  integer (selected_int_kind(9)) :: dim, low(dim), up(dim)
  integer (selected_int_kind(9)) :: i
  hasElements = .true.
  do i = 1, dim
     if (low(i) .gt. up(i)) then
        hasElements = .false.
     endif
  enddo
end function hasElements

logical function nextElem(dim, ind, low, up)
  implicit none
  integer (selected_int_kind(9)) :: dim
  integer (selected_int_kind(9)) :: ind(dim), low(dim), up(dim)
  integer (selected_int_kind(9)) :: i
  i = 1
  ind(i) = ind(i) + 1
  do while ((i .le. dim) .and. (ind(i) .gt. up(i)))
     ind(i) = low(i)
     i = i + 1
     if (i .le. dim) then
        ind(i) = ind(i) + 1
     endif
  enddo
  nextElem = (i .le. dim)
end function nextElem

subroutine createarraybytype(tp, dmn, lw, up, a)
  use sidl_array_array
  use sidl_BaseInterface_type
  use sidl_BaseInterface_array
  use sidl_ClassInfo_type
  use sidl_char_array
  use sidl_double_array
  use sidl_string_array
  use sidl_long_array
  use sidl_int_array
  use sidl_bool_array
  use sidl_float_array
  use sidl_opaque_array
  use sidl_fcomplex_array
  use sidl_dcomplex_array
  implicit none
  type(sidl__array), intent(out) :: a
  integer (selected_int_kind(9)) :: tp, dmn, lw(7), up(7)
  
  type(sidl_bool_1d) :: b1
  type(sidl_bool_2d) :: b2
  type(sidl_bool_3d) :: b3
  type(sidl_bool_4d) :: b4
  type(sidl_bool_5d) :: b5
  type(sidl_bool_6d) :: b6
  type(sidl_bool_7d) :: b7

  type(sidl_char_1d) :: c1
  type(sidl_char_2d) :: c2
  type(sidl_char_3d) :: c3
  type(sidl_char_4d) :: c4
  type(sidl_char_5d) :: c5
  type(sidl_char_6d) :: c6
  type(sidl_char_7d) :: c7

  type(sidl_dcomplex_1d) :: dc1
  type(sidl_dcomplex_2d) :: dc2
  type(sidl_dcomplex_3d) :: dc3
  type(sidl_dcomplex_4d) :: dc4
  type(sidl_dcomplex_5d) :: dc5
  type(sidl_dcomplex_6d) :: dc6
  type(sidl_dcomplex_7d) :: dc7

  type(sidl_double_1d) :: d1
  type(sidl_double_2d) :: d2
  type(sidl_double_3d) :: d3
  type(sidl_double_4d) :: d4
  type(sidl_double_5d) :: d5
  type(sidl_double_6d) :: d6
  type(sidl_double_7d) :: d7

  type(sidl_fcomplex_1d) :: fc1
  type(sidl_fcomplex_2d) :: fc2
  type(sidl_fcomplex_3d) :: fc3
  type(sidl_fcomplex_4d) :: fc4
  type(sidl_fcomplex_5d) :: fc5
  type(sidl_fcomplex_6d) :: fc6
  type(sidl_fcomplex_7d) :: fc7

  type(sidl_float_1d) :: f1
  type(sidl_float_2d) :: f2
  type(sidl_float_3d) :: f3
  type(sidl_float_4d) :: f4
  type(sidl_float_5d) :: f5
  type(sidl_float_6d) :: f6
  type(sidl_float_7d) :: f7

  type(sidl_int_1d) :: i1
  type(sidl_int_2d) :: i2
  type(sidl_int_3d) :: i3
  type(sidl_int_4d) :: i4
  type(sidl_int_5d) :: i5
  type(sidl_int_6d) :: i6
  type(sidl_int_7d) :: i7

  type(sidl_long_1d) :: l1
  type(sidl_long_2d) :: l2
  type(sidl_long_3d) :: l3
  type(sidl_long_4d) :: l4
  type(sidl_long_5d) :: l5
  type(sidl_long_6d) :: l6
  type(sidl_long_7d) :: l7

  type(sidl_opaque_1d) :: o1
  type(sidl_opaque_2d) :: o2
  type(sidl_opaque_3d) :: o3
  type(sidl_opaque_4d) :: o4
  type(sidl_opaque_5d) :: o5
  type(sidl_opaque_6d) :: o6
  type(sidl_opaque_7d) :: o7

  type(sidl_string_1d) :: s1
  type(sidl_string_2d) :: s2
  type(sidl_string_3d) :: s3
  type(sidl_string_4d) :: s4
  type(sidl_string_5d) :: s5
  type(sidl_string_6d) :: s6
  type(sidl_string_7d) :: s7

  type(sidl_baseinterface_1d) :: bi1
  type(sidl_baseinterface_2d) :: bi2
  type(sidl_baseinterface_3d) :: bi3
  type(sidl_baseinterface_4d) :: bi4
  type(sidl_baseinterface_5d) :: bi5
  type(sidl_baseinterface_6d) :: bi6
  type(sidl_baseinterface_7d) :: bi7

  select case(tp)
  case (1)
     select case(dmn)
     case(1)
        call createRow(lw,up,b1)
        call cast(b1, a)
        return
     case(2)
        call createCol(lw,up,b2)
        call cast(b2, a)
        return
     case(3)
        call createRow(lw,up,b3)
        call cast(b3, a)
        return
     case(4)
        call createRow(lw,up,b4)
        call cast(b4, a)
        return
     case(5)
        call createRow(lw,up,b5)
        call cast(b5, a)
        return
     case(6)        
        call createRow(lw,up,b6)
        call cast(b6, a)
        return
     case(7)
        call createRow(lw,up,b7)
        call cast(b7, a)
        return
     end select
  case (2)
     select case(dmn)
     case(1)
        call createRow(lw,up,c1)
        call cast(c1, a)
        return
     case(2)
        call createRow(lw,up,c2)
        call cast(c2, a)
        return
     case(3)
        call createRow(lw,up,c3)
        call cast(c3, a)
        return
     case(4)
        call createRow(lw,up,c4)
        call cast(c4, a)
        return
     case(5)
        call createRow(lw,up,c5)
        call cast(c5, a)
        return
     case(6)        
        call createRow(lw,up,c6)
        call cast(c6, a)
        return
     case(7)
        call createRow(lw,up,c7)
        call cast(c7, a)
        return
     end select
  case (3)
     select case(dmn)
     case(1)
        call createRow(lw,up,dc1)
        call cast(dc1, a)
        return
     case(2)
        call createRow(lw,up,dc2)
        call cast(dc2, a)
        return
     case(3)
        call createRow(lw,up,dc3)
        call cast(dc3, a)
        return
     case(4)
        call createRow(lw,up,dc4)
        call cast(dc4, a)
        return
     case(5)
        call createRow(lw,up,dc5)
        call cast(dc5, a)
        return
     case(6)        
        call createRow(lw,up,dc6)
        call cast(dc6, a)
        return
     case(7)
        call createRow(lw,up,dc7)
        call cast(dc7, a)
        return
     end select
  case (4)
     select case(dmn)
     case(1)
        call createRow(lw,up,d1)
        call cast(d1, a)
        return
     case(2)
        call createRow(lw,up,d2)
        call cast(d2, a)
        return
     case(3)
        call createRow(lw,up,d3)
        call cast(d3, a)
        return
     case(4)
        call createRow(lw,up,d4)
        call cast(d4, a)
        return
     case(5)
        call createRow(lw,up,d5)
        call cast(d5, a)
        return
     case(6)        
        call createRow(lw,up,d6)
        call cast(d6, a)
        return
     case(7)
        call createRow(lw,up,d7)
        call cast(d7, a)
        return
     end select
  case (5)
     select case(dmn)
     case(1)
        call createRow(lw,up,fc1)
        call cast(fc1, a)
        return
     case(2)
        call createRow(lw,up,fc2)
        call cast(fc2, a)
        return
     case(3)
        call createRow(lw,up,fc3)
        call cast(fc3, a)
        return
     case(4)
        call createRow(lw,up,fc4)
        call cast(fc4, a)
        return
     case(5)
        call createRow(lw,up,fc5)
        call cast(fc5, a)
        return
     case(6)        
        call createRow(lw,up,fc6)
        call cast(fc6, a)
        return
     case(7)
        call createRow(lw,up,fc7)
        call cast(fc7, a)
        return
     end select

  case (6)
     select case(dmn)
     case(1)
        call createRow(lw,up,f1)
        call cast(f1, a)
        return
     case(2)
        call createRow(lw,up,f2)
        call cast(f2, a)
        return
     case(3)
        call createRow(lw,up,f3)
        call cast(f3, a)
        return
     case(4)
        call createRow(lw,up,f4)
        call cast(f4, a)
        return
     case(5)
        call createRow(lw,up,f5)
        call cast(f5, a)
        return
     case(6)        
        call createRow(lw,up,f6)
        call cast(f6, a)
        return
     case(7)
        call createRow(lw,up,f7)
        call cast(f7, a)
        return
     end select

  case (7)
     select case(dmn)
     case(1)
        call createRow(lw,up,i1)
        call cast(i1, a)
        return
     case(2)
        call createRow(lw,up,i2)
        call cast(i2, a)
        return
     case(3)
        call createRow(lw,up,i3)
        call cast(i3, a)
        return
     case(4)
        call createRow(lw,up,i4)
        call cast(i4, a)
        return
     case(5)
        call createRow(lw,up,i5)
        call cast(i5, a)
        return
     case(6)        
        call createRow(lw,up,i6)
        call cast(i6, a)
        return
     case(7)
        call createRow(lw,up,i7)
        call cast(i7, a)
        return
     end select
  case (8)
    select case(dmn)
     case(1)
        call createRow(lw,up,l1)
        call cast(l1, a)
        return
     case(2)
        call createRow(lw,up,l2)
        call cast(l2, a)
        return
     case(3)
        call createRow(lw,up,l3)
        call cast(l3, a)
        return
     case(4)
        call createRow(lw,up,l4)
        call cast(l4, a)
        return
     case(5)
        call createRow(lw,up,l5)
        call cast(l5, a)
        return
     case(6)        
        call createRow(lw,up,l6)
        call cast(l6, a)
        return
     case(7)
        call createRow(lw,up,l7)
        call cast(l7, a)
        return
     end select
  case (9)
     select case(dmn)
     case(1)
        call createRow(lw,up,o1)
        call cast(o1, a)
        return
     case(2)
        call createRow(lw,up,o2)
        call cast(o2, a)
        return
     case(3)
        call createRow(lw,up,o3)
        call cast(o3, a)
        return
     case(4)
        call createRow(lw,up,o4)
        call cast(o4, a)
        return
     case(5)
        call createRow(lw,up,o5)
        call cast(o5, a)
        return
     case(6)        
        call createRow(lw,up,o6)
        call cast(o6, a)
        return
     case(7)
        call createRow(lw,up,o7)
        call cast(o7, a)
        return
     end select

  case (10)
     select case(dmn)
     case(1)
        call createRow(lw,up,s1)
        call cast(s1, a)
        return
     case(2)
        call createRow(lw,up,s2)
        call cast(s2, a)
        return
     case(3)
        call createRow(lw,up,s3)
        call cast(s3, a)
        return
     case(4)
        call createRow(lw,up,s4)
        call cast(s4, a)
        return
     case(5)
        call createRow(lw,up,s5)
        call cast(s5, a)
        return
     case(6)        
        call createRow(lw,up,s6)
        call cast(s6, a)
        return
     case(7)
        call createRow(lw,up,s7)
        call cast(s7, a)
        return
     end select

  case (11)
     select case(dmn)
     case(1)
        call createRow(lw,up,bi1)
        call cast(bi1, a)
        return
     case(2)
        call createRow(lw,up,bi2)
        call cast(bi2, a)
        return
     case(3)
        call createRow(lw,up,bi3)
        call cast(bi3, a)
        return
     case(4)
        call createRow(lw,up,bi4)
        call cast(bi4, a)
        return
     case(5)
        call createRow(lw,up,bi5)
        call cast(bi5, a)
        return
     case(6)        
        call createRow(lw,up,bi6)
        call cast(bi6, a)
        return
     case(7)
        call createRow(lw,up,bi7)
        call cast(bi7, a)
        return
     end select
 
  case default
     !set_null(a)
  end select

end subroutine createarraybytype

subroutine copyarraybytype(src, lw, up, dest)
  use sidl_array_array
  use sidl_BaseInterface_type
  use sidl_BaseInterface_array
  use sidl_ClassInfo_type
  use sidl_char_array
  use sidl_double_array
  use sidl_string_array
  use sidl_long_array
  use sidl_int_array
  use sidl_bool_array
  use sidl_float_array
  use sidl_opaque_array
  use sidl_fcomplex_array
  use sidl_dcomplex_array
  implicit none
  type(sidl__array) :: src, dest
  integer (selected_int_kind(9)) :: tp, dmn, lw(7), up(7), i
  
  type(sidl_bool_1d) :: b1
  type(sidl_bool_2d) :: b2
  type(sidl_bool_3d) :: b3
  type(sidl_bool_4d) :: b4
  type(sidl_bool_5d) :: b5
  type(sidl_bool_6d) :: b6
  type(sidl_bool_7d) :: b7

  type(sidl_char_1d) :: c1
  type(sidl_char_2d) :: c2
  type(sidl_char_3d) :: c3
  type(sidl_char_4d) :: c4
  type(sidl_char_5d) :: c5
  type(sidl_char_6d) :: c6
  type(sidl_char_7d) :: c7

  type(sidl_dcomplex_1d) :: dc1
  type(sidl_dcomplex_2d) :: dc2
  type(sidl_dcomplex_3d) :: dc3
  type(sidl_dcomplex_4d) :: dc4
  type(sidl_dcomplex_5d) :: dc5
  type(sidl_dcomplex_6d) :: dc6
  type(sidl_dcomplex_7d) :: dc7

  type(sidl_double_1d) :: d1
  type(sidl_double_2d) :: d2
  type(sidl_double_3d) :: d3
  type(sidl_double_4d) :: d4
  type(sidl_double_5d) :: d5
  type(sidl_double_6d) :: d6
  type(sidl_double_7d) :: d7

  type(sidl_fcomplex_1d) :: fc1
  type(sidl_fcomplex_2d) :: fc2
  type(sidl_fcomplex_3d) :: fc3
  type(sidl_fcomplex_4d) :: fc4
  type(sidl_fcomplex_5d) :: fc5
  type(sidl_fcomplex_6d) :: fc6
  type(sidl_fcomplex_7d) :: fc7

  type(sidl_float_1d) :: f1
  type(sidl_float_2d) :: f2
  type(sidl_float_3d) :: f3
  type(sidl_float_4d) :: f4
  type(sidl_float_5d) :: f5
  type(sidl_float_6d) :: f6
  type(sidl_float_7d) :: f7

  type(sidl_int_1d) :: i1
  type(sidl_int_2d) :: i2
  type(sidl_int_3d) :: i3
  type(sidl_int_4d) :: i4
  type(sidl_int_5d) :: i5
  type(sidl_int_6d) :: i6
  type(sidl_int_7d) :: i7

  type(sidl_long_1d) :: l1
  type(sidl_long_2d) :: l2
  type(sidl_long_3d) :: l3
  type(sidl_long_4d) :: l4
  type(sidl_long_5d) :: l5
  type(sidl_long_6d) :: l6
  type(sidl_long_7d) :: l7

  type(sidl_opaque_1d) :: o1
  type(sidl_opaque_2d) :: o2
  type(sidl_opaque_3d) :: o3
  type(sidl_opaque_4d) :: o4
  type(sidl_opaque_5d) :: o5
  type(sidl_opaque_6d) :: o6
  type(sidl_opaque_7d) :: o7

  type(sidl_string_1d) :: s1
  type(sidl_string_2d) :: s2
  type(sidl_string_3d) :: s3
  type(sidl_string_4d) :: s4
  type(sidl_string_5d) :: s5
  type(sidl_string_6d) :: s6
  type(sidl_string_7d) :: s7

  type(sidl_baseinterface_1d) :: bi1
  type(sidl_baseinterface_2d) :: bi2
  type(sidl_baseinterface_3d) :: bi3
  type(sidl_baseinterface_4d) :: bi4
  type(sidl_baseinterface_5d) :: bi5
  type(sidl_baseinterface_6d) :: bi6
  type(sidl_baseinterface_7d) :: bi7

  type(sidl_bool_1d) :: b1d
  type(sidl_bool_2d) :: b2d
  type(sidl_bool_3d) :: b3d
  type(sidl_bool_4d) :: b4d
  type(sidl_bool_5d) :: b5d
  type(sidl_bool_6d) :: b6d
  type(sidl_bool_7d) :: b7d

  type(sidl_char_1d) :: c1d
  type(sidl_char_2d) :: c2d
  type(sidl_char_3d) :: c3d
  type(sidl_char_4d) :: c4d
  type(sidl_char_5d) :: c5d
  type(sidl_char_6d) :: c6d
  type(sidl_char_7d) :: c7d

  type(sidl_dcomplex_1d) :: dc1d
  type(sidl_dcomplex_2d) :: dc2d
  type(sidl_dcomplex_3d) :: dc3d
  type(sidl_dcomplex_4d) :: dc4d
  type(sidl_dcomplex_5d) :: dc5d
  type(sidl_dcomplex_6d) :: dc6d
  type(sidl_dcomplex_7d) :: dc7d

  type(sidl_double_1d) :: d1d
  type(sidl_double_2d) :: d2d
  type(sidl_double_3d) :: d3d
  type(sidl_double_4d) :: d4d
  type(sidl_double_5d) :: d5d
  type(sidl_double_6d) :: d6d
  type(sidl_double_7d) :: d7d

  type(sidl_fcomplex_1d) :: fc1d
  type(sidl_fcomplex_2d) :: fc2d
  type(sidl_fcomplex_3d) :: fc3d
  type(sidl_fcomplex_4d) :: fc4d
  type(sidl_fcomplex_5d) :: fc5d
  type(sidl_fcomplex_6d) :: fc6d
  type(sidl_fcomplex_7d) :: fc7d

  type(sidl_float_1d) :: f1d
  type(sidl_float_2d) :: f2d
  type(sidl_float_3d) :: f3d
  type(sidl_float_4d) :: f4d
  type(sidl_float_5d) :: f5d
  type(sidl_float_6d) :: f6d
  type(sidl_float_7d) :: f7d

  type(sidl_int_1d) :: i1d
  type(sidl_int_2d) :: i2d
  type(sidl_int_3d) :: i3d
  type(sidl_int_4d) :: i4d
  type(sidl_int_5d) :: i5d
  type(sidl_int_6d) :: i6d
  type(sidl_int_7d) :: i7d

  type(sidl_long_1d) :: l1d
  type(sidl_long_2d) :: l2d
  type(sidl_long_3d) :: l3d
  type(sidl_long_4d) :: l4d
  type(sidl_long_5d) :: l5d
  type(sidl_long_6d) :: l6d
  type(sidl_long_7d) :: l7d

  type(sidl_opaque_1d) :: o1d
  type(sidl_opaque_2d) :: o2d
  type(sidl_opaque_3d) :: o3d
  type(sidl_opaque_4d) :: o4d
  type(sidl_opaque_5d) :: o5d
  type(sidl_opaque_6d) :: o6d
  type(sidl_opaque_7d) :: o7d

  type(sidl_string_1d) :: s1d
  type(sidl_string_2d) :: s2d
  type(sidl_string_3d) :: s3d
  type(sidl_string_4d) :: s4d
  type(sidl_string_5d) :: s5d
  type(sidl_string_6d) :: s6d
  type(sidl_string_7d) :: s7d

  type(sidl_baseinterface_1d) :: bi1d
  type(sidl_baseinterface_2d) :: bi2d
  type(sidl_baseinterface_3d) :: bi3d
  type(sidl_baseinterface_4d) :: bi4d
  type(sidl_baseinterface_5d) :: bi5d
  type(sidl_baseinterface_6d) :: bi6d
  type(sidl_baseinterface_7d) :: bi7d

  tp = type(src)
  dmn = dimen(src)
  select case(tp)
  case (1)
     select case(dmn)
     case(1)
        call set_null(b1)
        call cast(src, b1)
        call createRow(lw, up, b1d)
        call copy(b1, b1d)
        call cast(b1d, dest)
        return
     case(2)
        call set_null( b2)
        call cast(src, b2)
        call createRow(lw,up, b2d)
        call copy(b2, b2d)
        call cast(b2d, dest)
        return
     case(3)
        call set_null( b3)
        call cast(src, b3)
        call createRow(lw,up, b3d)
        call copy(b3, b3d)
        call cast(b3d, dest)
        return
     case(4)
        call set_null( b4)
        call cast(src, b4)
        call createRow(lw,up, b4d)
        call copy(b4, b4d)
        call cast(b4d, dest)
        return
     case(5)
        call set_null( b5)
        call cast(src, b5)
        call createRow(lw,up, b5d)
        call copy(b5, b5d)
        call cast(b5d, dest)
        return
     case(6)   
        call set_null( b6)
        call cast(src, b6)
        call createRow(lw,up, b6d)
        call copy(b6, b6d)
        call cast(b6d, dest)
        return
     case(7)
        call set_null( b7)
        call cast(src, b7)
        call createRow(lw,up, b7d)
        call copy(b7, b7d)
        call cast(b7d, dest)
        return
     end select

   case (2)

     select case(dmn)
     case(1)
        call set_null( c1)
        call cast(src, c1)
        call createRow(lw,up, c1d)
        call copy(c1, c1d)
        call cast(c1d, dest)
        return
     case(2)
        call set_null( c2)
        call cast(src, c2)
        call createRow(lw,up, c2d)
        call copy(c2, c2d)
        call cast(c2d, dest)
        return
     case(3)
        call set_null( c3)
        call cast(src, c3)
        call createRow(lw,up, c3d)
        call copy(c3, c3d)
        call cast(c3d, dest)
        return
     case(4)
        call set_null( c4)
        call cast(src, c4)
        call createRow(lw,up, c4d)
        call copy(c4, c4d)
        call cast(c4d, dest)
        return
     case(5)
        call set_null( c5)
        call cast(src, c5)
        call createRow(lw,up, c5d)
        call copy(c5, c5d)
        call cast(c5d, dest)
        return
     case(6)        
        call set_null( c6)
        call cast(src, c6)
        call createRow(lw,up, c6d)
        call copy(c6, c6d)
        call cast(c6d, dest)
        return
     case(7)
        call set_null( c7)
        call cast(src, c7)
        call createRow(lw,up, c7d)
        call copy(c7, c7d)
        call cast(c7d, dest)
        return
     end select
  case (3)
     select case(dmn)
     case(1)
        call set_null( dc1)
        call cast(src, dc1)
        call createRow(lw,up, dc1d)
        call copy(dc1, dc1d)
        call cast(dc1d, dest)
        return
     case(2)
        call set_null( dc2)
        call cast(src, dc2)
        call createRow(lw,up, dc2d)
        call copy(dc2, dc2d)
        call cast(dc2d, dest)
        return
     case(3)
        call set_null( dc3)
        call cast(src, dc3)
        call createRow(lw,up, dc3d)
        call copy(dc3, dc3d)
        call cast(dc3d, dest)
        return
     case(4)
        call set_null( dc4)
        call cast(src, dc4)
        call createRow(lw,up, dc4d)
        call copy(dc4, dc4d)
        call cast(dc4d, dest)
        return
     case(5)
        call set_null( dc5)
        call cast(src, dc5)
        call createRow(lw,up, dc5d)
        call copy(dc5, dc5d)
        call cast(dc5d, dest)
        return
     case(6)   
        call set_null( dc6)
        call cast(src, dc6)
        call createRow(lw,up, dc6d)
        call copy(dc6, dc6d)
        call cast(dc6d, dest)
        return
     case(7)
        call set_null( dc7)
        call cast(src, dc7)
        call createRow(lw,up, dc7d)
        call copy(dc7, dc7d)
        call cast(dc7d, dest)
        return
     end select
  case (4)
     select case(dmn)
     case(1)
        call set_null( d1)
        call cast(src, d1)
        call createRow(lw,up, d1d)
        call copy(d1, d1d)
        call cast(d1d, dest)
        return
     case(2)
        call set_null( d2)
        call cast(src, d2)
        call createRow(lw,up, d2d)
        call copy(d2, d2d)
        call cast(d2d, dest)
        return
     case(3)
        call set_null( d3)
        call cast(src, d3)
        call createRow(lw,up, d3d)
        call copy(d3, d3d)
        call cast(d3d, dest)
        return
     case(4)
        call set_null( d4)
        call cast(src, d4)
        call createRow(lw,up, d4d)
        call copy(d4, d4d)
        call cast(d4d, dest)
        return
     case(5)
        call set_null( d5)
        call cast(src, d5)
        call createRow(lw,up, d5d)
        call copy(d5, d5d)
        call cast(d5d, dest)
        return
     case(6)   
        call set_null( d6)
        call cast(src, d6)
        call createRow(lw,up, d6d)
        call copy(d6, d6d)
        call cast(d6d, dest)
        return
     case(7)
        call set_null( d7)
        call cast(src, d7)
        call createRow(lw,up, d7d)
        call copy(d7, d7d)
        call cast(d7d, dest)
        return
     end select
     
  case (5)
     select case(dmn)
     case(1)
        call set_null( fc1)
        call cast(src, fc1)
        call createRow(lw,up, fc1d)
        call copy(fc1, fc1d)
        call cast(fc1d, dest)
        return
     case(2)
        call set_null( fc2)
        call cast(src, fc2)
        call createRow(lw,up, fc2d)
        call copy(fc2, fc2d)
        call cast(fc2d, dest)
        return
     case(3)
        call set_null( fc3)
        call cast(src, fc3)
        call createRow(lw,up, fc3d)
        call copy(fc3, fc3d)
        call cast(fc3d, dest)
        return
     case(4)
        call set_null( fc4)
        call cast(src, fc4)
        call createRow(lw,up, fc4d)
        call copy(fc4, fc4d)
        call cast(fc4d, dest)
        return
     case(5)
        call set_null( fc5)
        call cast(src, fc5)
        call createRow(lw,up, fc5d)
        call copy(fc5, fc5d)
        call cast(fc5d, dest)
        return
     case(6)   
        call set_null( fc6)
        call cast(src, fc6)
        call createRow(lw,up, fc6d)
        call copy(fc6, fc6d)
        call cast(fc6d, dest)
        return
     case(7)
        call set_null( fc7)
        call cast(src, fc7)
        call createRow(lw,up, fc7d)
        call copy(fc7, fc7d)
        call cast(fc7d, dest)
        return
     end select

  case (6)
     select case(dmn)
     case(1)
        call set_null( f1)
        call cast(src, f1)
        call createRow(lw,up, f1d)
        call copy(f1, f1d)
        call cast(f1d, dest)
        return
     case(2)
        call set_null( f2)
        call cast(src, f2)
        call createRow(lw,up, f2d)
        call copy(f2, f2d)
        call cast(f2d, dest)
        return
     case(3)
        call set_null( f3)
        call cast(src, f3)
        call createRow(lw,up, f3d)
        call copy(f3, f3d)
        call cast(f3d, dest)
        return
     case(4)
        call set_null( f4)
        call cast(src, f4)
        call createRow(lw,up, f4d)
        call copy(f4, f4d)
        call cast(f4d, dest)
        return
     case(5)
        call set_null( f5)
        call cast(src, f5)
        call createRow(lw,up, f5d)
        call copy(f5, f5d)
        call cast(f5d, dest)
        return
     case(6)   
        call set_null( f6)
        call cast(src, f6)
        call createRow(lw,up, f6d)
        call copy(f6, f6d)
        call cast(f6d, dest)
        return
     case(7)
        call set_null( f7)
        call cast(src, f7)
        call createRow(lw,up, f7d)
        call copy(f7, f7d)
        call cast(f7d, dest)
        return
     end select
  case (7)
     select case(dmn)
     case(1)
        call set_null( i1)
        call cast(src, i1)
        call createRow(lw,up, i1d)
        call copy(i1, i1d)
        call cast(i1d, dest)
        return
     case(2)
        call set_null( i2)
        call cast(src, i2)
        call createRow(lw,up, i2d)
        call copy(i2, i2d)
        call cast(i2d, dest)
        return
     case(3)
        call set_null( i3)
        call cast(src, i3)
        call createRow(lw,up, i3d)
        call copy(i3, i3d)
        call cast(i3d, dest)
        return
     case(4)
        call set_null( i4)
        call cast(src, i4)
        call createRow(lw,up, i4d)
        call copy(i4, i4d)
        call cast(i4d, dest)
        return
     case(5)
        call set_null( i5)
        call cast(src, i5)
        call createRow(lw,up, i5d)
        call copy(i5, i5d)
        call cast(i5d, dest)
        return
     case(6)   
        call set_null( i6)
        call cast(src, i6)
        call createRow(lw,up, i6d)
        call copy(i6, i6d)
        call cast(i6d, dest)
        return
     case(7)
        call set_null( i7)
        call cast(src, i7)
        call createRow(lw,up, i7d)
        call copy(i7, i7d)
        call cast(i7d, dest)
        return
     end select

  case (8)

     select case(dmn)
     case(1)
        call set_null( l1)
        call cast(src, l1)
        call createRow(lw,up, l1d)
        call copy(l1, l1d)
        call cast(l1d, dest)
        return
     case(2)
        call set_null( l2)
        call cast(src, l2)
        call createRow(lw,up, l2d)
        call copy(l2, l2d)
        call cast(l2d, dest)
        return
     case(3)
        call set_null( l3)
        call cast(src, l3)
        call createRow(lw,up, l3d)
        call copy(l3, l3d)
        call cast(l3d, dest)
        return
     case(4)
        call set_null( l4)
        call cast(src, l4)
        call createRow(lw,up, l4d)
        call copy(l4, l4d)
        call cast(l4d, dest)
        return
     case(5)
        call set_null( l5)
        call cast(src, l5)
        call createRow(lw,up, l5d)
        call copy(l5, l5d)
        call cast(l5d, dest)
        return
     case(6)   
        call set_null( l6)
        call cast(src, l6)
        call createRow(lw,up, l6d)
        call copy(l6, l6d)
        call cast(l6d, dest)
        return
     case(7)
        call set_null( l7)
        call cast(src, l7)
        call createRow(lw,up, l7d)
        call copy(l7, l7d)
        call cast(l7d, dest)
        return
     end select

  case (9)

     select case(dmn)
     case(1)
        call set_null( o1)
        call cast(src, o1)
        call createRow(lw,up, o1d)
        call copy(o1, o1d)
        call cast(o1d, dest)
        return
     case(2)
        call set_null( o2)
        call cast(src, o2)
        call createRow(lw,up, o2d)
        call copy(o2, o2d)
        call cast(o2d, dest)
        return
     case(3)
        call set_null( o3)
        call cast(src, o3)
        call createRow(lw,up, o3d)
        call copy(o3, o3d)
        call cast(o3d, dest)
        return
     case(4)
        call set_null( o4)
        call cast(src, o4)
        call createRow(lw,up, o4d)
        call copy(o4, o4d)
        call cast(o4d, dest)
        return
     case(5)
        call set_null( o5)
        call cast(src, o5)
        call createRow(lw,up, o5d)
        call copy(o5, o5d)
        call cast(o5d, dest)
        return
     case(6)   
        call set_null( o6)
        call cast(src, o6)
        call createRow(lw,up, o6d)
        call copy(o6, o6d)
        call cast(o6d, dest)
        return
     case(7)
        call set_null( o7)
        call cast(src, o7)
        call createRow(lw,up, o7d)
        call copy(o7, o7d)
        call cast(o7d, dest)
        return
     end select

  case (10)
     select case(dmn)
     case(1)
        call set_null( s1)
        call cast(src, s1)
        call createRow(lw,up, s1d)
        call copy(s1, s1d)
        call cast(s1d, dest)
        return
     case(2)
        call set_null( s2)
        call cast(src, s2)
        call createRow(lw,up, s2d)
        call copy(s2, s2d)
        call cast(s2d, dest)
        return
     case(3)
        call set_null( s3)
        call cast(src, s3)
        call createRow(lw,up, s3d)
        call copy(s3, s3d)
        call cast(s3d, dest)
        return
     case(4)
        call set_null( s4)
        call cast(src, s4)
        call createRow(lw,up, s4d)
        call copy(s4, s4d)
        call cast(s4d, dest)
        return
     case(5)
        call set_null( s5)
        call cast(src, s5)
        call createRow(lw,up, s5d)
        call copy(s5, s5d)
        call cast(s5d, dest)
        return
     case(6)   
        call set_null( s6)
        call cast(src, s6)
        call createRow(lw,up, s6d)
        call copy(s6, s6d)
        call cast(s6d, dest)
        return
     case(7)
        call set_null( s7)
        call cast(src, s7)
        call createRow(lw,up, s7d)
        call copy(s7, s7d)
        call cast(s7d, dest)
        return
     end select

  case (11)
     select case(dmn)
     case(1)
        call set_null( bi1)
        call cast(src, bi1)
        call createRow(lw,up, bi1d)
        call copy(bi1, bi1d)
        call cast(bi1d, dest)
        return
     case(2)
        call set_null( bi2)
        call cast(src, bi2)
        call createRow(lw,up, bi2d)
        call copy(bi2, bi2d)
        call cast(bi2d, dest)
        return
     case(3)
        call set_null( bi3)
        call cast(src, bi3)
        call createRow(lw,up, bi3d)
        call copy(bi3, bi3d)
        call cast(bi3d, dest)
        return
     case(4)
        call set_null( bi4)
        call cast(src, bi4)
        call createRow(lw,up, bi4d)
        call copy(bi4, bi4d)
        call cast(bi4d, dest)
        return
     case(5)
        call set_null( bi5)
        call cast(src, bi5)
        call createRow(lw,up, bi5d)
        call copy(bi5, bi5d)
        call cast(bi5d, dest)
        return
     case(6)   
        call set_null( bi6)
        call cast(src, bi6)
        call createRow(lw,up, bi6d)
        call copy(bi6, bi6d)
        call cast(bi6d, dest)
        return
     case(7)
        call set_null( bi7)
        call cast(src, bi7)
        call createRow(lw,up, bi7d)
        call copy(bi7, bi7d)
        call cast(bi7d, dest)
        return
     end select



  case default
     dest%d_array = 0
  end select

end subroutine copyarraybytype

! DO-NOT-DELETE splicer.end(_miscellaneous_code_start)




! 
! Class constructor called when the class is created.
! 

recursive subroutine ArrayTest_ArrayOps__ctor_mi(self)
  use ArrayTest_ArrayOps
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps._ctor.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps._ctor.use)
  implicit none
  type(ArrayTest_ArrayOps_t) :: self ! in

  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps._ctor)
  ! Insert the implementation here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps._ctor)
end subroutine ArrayTest_ArrayOps__ctor_mi


! 
! Class destructor called when the class is deleted.
! 

recursive subroutine ArrayTest_ArrayOps__dtor_mi(self)
  use ArrayTest_ArrayOps
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps._dtor.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps._dtor.use)
  implicit none
  type(ArrayTest_ArrayOps_t) :: self ! in

  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps._dtor)
  ! Insert the implementation here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps._dtor)
end subroutine ArrayTest_ArrayOps__dtor_mi


! 
! Static class initializer called exactly once before any user-defined method is dispatched
! 

recursive subroutine ArrayTest_ArrayOps__load_mi()
  use ArrayTest_ArrayOps
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps._load.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps._load.use)
  implicit none

  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps._load)
  ! Insert the implementation here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps._load)
end subroutine ArrayTest_ArrayOps__load_mi


! 
! Return <code>true</code> iff the even elements are true and
! the odd elements are false.
! 

recursive subroutine ArrayTest_ArrayOps_checkBool_mi(a, retval)
  use ArrayTest_ArrayOps
  use sidl_bool_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.checkBool.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.checkBool.use)
  implicit none
  type(sidl_bool_1d) :: a ! in
  logical :: retval ! out

  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.checkBool)
  logical :: value1, value2
  integer (selected_int_kind(9)) :: low, up, dim, len, i, index(1)
  integer (selected_int_kind(9)) :: testind
  logical :: isEven
  retval = .false.
  if (not_null(a)) then
     dim = dimen(a)
     if (dim .eq. 1) then
        low = lower(a, 0)
        up = upper(a, 0)
        len = (up - low) + 1
        do i = 0, len - 1
           index(1) = low + i
           call get(a, index(1), value1)
           call get(a, index, value2)
           if ((value1 .neqv. value2) &
                .or. (value1 .neqv. isEven(low + i))) then
              return
           endif
        enddo
        retval = .true.
     endif
  endif
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.checkBool)
end subroutine ArrayTest_ArrayOps_checkBool_mi


! 
! Method:  checkChar[]
! 

recursive subroutine ArrayTest_ArrayOps_checkChar_mi(a, retval)
  use ArrayTest_ArrayOps
  use sidl_char_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.checkChar.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.checkChar.use)
  implicit none
  type(sidl_char_1d) :: a ! in
  logical :: retval ! out

  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.checkChar)
  character (len=64) :: testtext
  character :: value1, value2
  integer (selected_int_kind(9)) :: low, up, dim, len, i, index(1)
  integer (selected_int_kind(9)) :: testind
  data testtext / 'I''d rather write programs to write programs than write programs' /
  retval = .false.
  if (not_null(a)) then
     dim = dimen(a)
     if (dim .eq. 1) then
        low = lower(a, 0)
        up = upper(a, 0)
        len = (up - low) + 1
        do i = 0, len - 1
           index(1) = low + i
           call get(a, low+i, value1)
           call get(a, index, value2)
           testind = mod(i, 64) + 1
           if ((value1 .ne. value2) &
                .or. (value1 .ne. testtext(testind:testind))) then
              return
           endif
        enddo
        retval = .true.
     endif
  endif
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.checkChar)
end subroutine ArrayTest_ArrayOps_checkChar_mi


! 
! Method:  checkInt[]
! 

recursive subroutine ArrayTest_ArrayOps_checkInt_mi(a, retval)
  use ArrayTest_ArrayOps
  use sidl_int_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.checkInt.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.checkInt.use)
  implicit none
  type(sidl_int_1d) :: a ! in
  logical :: retval ! out

  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.checkInt)
  integer (selected_int_kind(9)) :: dim, low, up, i, index(1), prime
  integer (selected_int_kind(9)) :: value1, value2, value4
  integer (selected_int_kind(18)) :: nextprime, tmp
  retval = .false.
  if (not_null(a)) then
     dim = dimen(a)
     if (dim .eq. 1) then
        low = lower(a, 0)
        up = upper(a, 0)
        prime = 0
        do i = low, up
           tmp = prime
           prime = nextprime(tmp)
           index(1) = i
           call get(a, i, value1)
           call get(a, index, value2)
           value4 = a%d_data(i)
           if ((value1 .ne. value2) &
                .or. (value2 .ne. value4) &
                .or. (value1 .ne. prime)) then
              retval = .false.
              return
           endif
        enddo
        retval = .true.
     endif
  endif
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.checkInt)
end subroutine ArrayTest_ArrayOps_checkInt_mi


! 
! Method:  checkLong[]
! 

recursive subroutine ArrayTest_ArrayOps_checkLong_mi(a, retval)
  use ArrayTest_ArrayOps
  use sidl_long_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.checkLong.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.checkLong.use)
  implicit none
  type(sidl_long_1d) :: a ! in
  logical :: retval ! out

  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.checkLong)
  integer (selected_int_kind(9)) :: dim, low, up, i, index(1)
  integer (selected_int_kind(18)) :: prime
  integer (selected_int_kind(18)) :: value1, value2, nextprime, value3
  retval = .false.
  if (not_null(a)) then
     dim = dimen(a)
     if (dim .eq. 1) then
        low = lower(a, 0)
        up = upper(a, 0)
        prime = 0
        do i = low, up
           prime = nextprime(prime)
           index(1) = i
           call get(a, i, value1)
           call get(a, index, value2)
           value3 = a%d_data(i)
           if ((value1 .ne. value2) &
                .or. (value1 .ne. value3) &
                .or. (value1 .ne. prime)) then
              retval = .false.
              return
           endif
        enddo
        retval = .true.
     endif
  endif
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.checkLong)
end subroutine ArrayTest_ArrayOps_checkLong_mi


! 
! Method:  checkString[]
! 

recursive subroutine ArrayO_checkStringqtpwhw66ji_mi(a, retval)
  use ArrayTest_ArrayOps
  use sidl_string_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.checkString.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.checkString.use)
  implicit none
  type(sidl_string_1d) :: a ! in
  logical :: retval ! out

  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.checkString)
  character (len=9) :: testtext(10)
  character (len=2048) :: value1
  character (len=2048) :: value2
  integer (selected_int_kind(9)) :: low, up, dim, len, i, index(1), testind
  data testtext / 'I''d', 'rather', 'write', 'programs', 'to', 'write', 'programs', 'than', 'write', 'programs.'/
  retval = .false.
  if (not_null(a)) then
     dim = dimen(a)
     if (dim .eq. 1) then
        low = lower(a, 0)
        up = upper(a, 0)
        len = (up - low) + 1
        do i = 0, len - 1
           index(1) = low + i
           call get(a, low+i, value1)
           call get(a, index, value2)
           testind = mod(i, 10) + 1
           if ((value1 .ne. value2) & 
                .or. (value1 .ne. testtext(testind))) then
              return
           endif
        enddo
        retval = .true.
     endif
  endif
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.checkString)
end subroutine ArrayO_checkStringqtpwhw66ji_mi


! 
! Method:  checkDouble[]
! 

recursive subroutine ArrayO_checkDoubleht03bd1cj8_mi(a, retval)
  use ArrayTest_ArrayOps
  use sidl_double_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.checkDouble.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.checkDouble.use)
  implicit none
  type(sidl_double_1d) :: a ! in
  logical :: retval ! out

  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.checkDouble)
  real(selected_real_kind(15,307)) :: value1, value2, value3, expectedvalue
  integer (selected_int_kind(9)) :: low, up, dim, len, i, index(1)
  retval = .false.
  if (not_null(a)) then
     dim = dimen(a)
     if (dim .eq. 1) then
        low = lower(a, 0)
        up = upper(a, 0)
        len = (up - low) + 1
        do i = 0, len - 1
           expectedvalue = (2.0d0 ** (-i))
           index(1) = low + i
           call get(a,low+i,value1)
           call get(a,index,value2)
           value3 = a%d_data(low+i)
           if ((value1 .ne. value2) &
                .or. (value1 .ne. value3) &
                .or. (value1 .ne. expectedvalue)) then
              return
           endif
        enddo
        retval = .true.
     endif
  endif
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.checkDouble)
end subroutine ArrayO_checkDoubleht03bd1cj8_mi


! 
! Method:  checkFloat[]
! 

recursive subroutine ArrayOp_checkFloat81idm2qyci_mi(a, retval)
  use ArrayTest_ArrayOps
  use sidl_float_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.checkFloat.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.checkFloat.use)
  implicit none
  type(sidl_float_1d) :: a ! in
  logical :: retval ! out

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.checkFloat)
  real(selected_real_kind(6,37)) :: value1, value2, expectedvalue, value3
  integer (selected_int_kind(9)) :: low, up, dim, len, i, index(1)
  retval = .false.
  if (not_null(a)) then
      dim = dimen(a)
     if (dim .eq. 1) then
        low = lower(a, 0)
        up = upper(a, 0)
        len = (up - low) + 1
        do i = 0, len - 1
           expectedvalue = (2.0 ** (-i))
           call force_float(expectedvalue)
           index(1) = low + i
           call get(a,low+i,value1)
           call get(a,index,value2)
           value3 = a%d_data(low+i)
           if ((value1 .ne. value2) &
                .or. (value1 .ne. value3) &
                .or. (value1 .ne. expectedvalue)) then
              return
           endif
        enddo
        retval = .true.
     endif
  endif
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.checkFloat)
end subroutine ArrayOp_checkFloat81idm2qyci_mi


! 
! Method:  checkFcomplex[]
! 

recursive subroutine Arra_checkFcomplexpmjhp5xo5y_mi(a, retval)
  use ArrayTest_ArrayOps
  use sidl_fcomplex_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.checkFcomplex.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.checkFcomplex.use)
  implicit none
  type(sidl_fcomplex_1d) :: a ! in
  logical :: retval ! out

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.checkFcomplex)
  complex(selected_real_kind(6,37)) :: value1, value2, expectedvalue, value3
  integer (selected_int_kind(9)) :: low, up, dim, len, i, index(1)
  retval = .false.
  if (not_null(a)) then
      dim = dimen(a)
     if (dim .eq. 1) then
        low = lower(a, 0)
        up = upper(a, 0)
        len = (up - low) + 1
        do i = 0, len - 1
           call force_fcomplex(expectedvalue)
           expectedvalue = cmplx(2.0 ** i, 2.0 ** (-i))
           index(1) = low + i
           call get(a,low+i,value1)
           call get(a,index,value2)
           value3 = a%d_data(low+i)
           if ((value1 .ne. value2) &
                .or. (value1 .ne. value3) &
                .or.  (value1 .ne. expectedvalue)) then
              return
           endif
        enddo
        retval = .true.
     endif
  endif
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.checkFcomplex)
end subroutine Arra_checkFcomplexpmjhp5xo5y_mi


! 
! Method:  checkDcomplex[]
! 

recursive subroutine Arra_checkDcomplexjn5f7v75je_mi(a, retval)
  use ArrayTest_ArrayOps
  use sidl_dcomplex_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.checkDcomplex.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.checkDcomplex.use)
  implicit none
  type(sidl_dcomplex_1d) :: a ! in
  logical :: retval ! out

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.checkDcomplex)
  complex(selected_real_kind(15,307)) :: value1, value2, expectedvalue, value3
  integer (selected_int_kind(9)) :: low, up, dim, len, i, index(1)
  retval = .false.
  if (not_null(a)) then
      dim = dimen(a)
     if (dim .eq. 1) then
        low = lower(a, 0)
        up = upper(a, 0)
        len = (up - low) + 1
        do i = 0, len - 1
           expectedvalue = cmplx(2.0d0 ** i, 2.0d0 ** (-i))
           index(1) = low + i
           call get(a,low+i,value1)
           call get(a,index,value2)
           value3 = a%d_data(low+i)
           if ((value1 .ne. value2) &
                .or. (value1 .ne. value3) &
                .or. (value1 .ne. expectedvalue)) then
              return
           endif
        enddo
        retval = .true.
     endif
  endif
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.checkDcomplex)
end subroutine Arra_checkDcomplexjn5f7v75je_mi


! 
! Method:  check2Int[]
! 

recursive subroutine ArrayTest_ArrayOps_check2Int_mi(a, retval)
  use ArrayTest_ArrayOps
  use sidl_int_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.check2Int.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.check2Int.use)
  implicit none
  type(sidl_int_2d) :: a ! in
  logical :: retval ! out

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.check2Int)
  integer (selected_int_kind(9)) :: dim, low(2), up(2), ind(2), i, j
  integer (selected_int_kind(9)) :: len(2)
  integer (selected_int_kind(9)) :: value1, value2, expectedvalue, value3
  retval = .false.
  if (not_null(a)) then
     dim = dimen(a)
    if (dim .eq. 2) then
      do i = 1, dim
         low(i) = lower(a, i-1)
         up(i) = upper(a, i-1)
         len(i) = up(i) - low(i)
      enddo
      do i = 0, len(1)
        ind(1) = low(1) + i
        do j = 0, len(2)
          expectedvalue = (2.0d0 ** abs(i-j))
          ind(2) = low(2) + j
          call get(a, ind(1), ind(2), value1)
          call get(a, ind, value2)
          value3 = a%d_data(ind(1), ind(2))
          if ((value1 .ne. value2) .or. &
               (value1 .ne. value3) .or. &
               (value1 .ne. expectedvalue)) then
            return
          endif
        enddo
      enddo
      retval = .true.
    endif
  endif
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.check2Int)
end subroutine ArrayTest_ArrayOps_check2Int_mi


! 
! Method:  check2Double[]
! 

recursive subroutine Array_check2Double7081y8i9gp_mi(a, retval)
  use ArrayTest_ArrayOps
  use sidl_double_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.check2Double.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.check2Double.use)
  implicit none
  type(sidl_double_2d) :: a ! in
  logical :: retval ! out

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.check2Double)
  integer (selected_int_kind(9))   :: dim, low(2), up(2), index(2), i, j
  integer (selected_int_kind(9))   :: len(2)
  real(selected_real_kind(15,307)) :: value1, value2, expectedvalue, value3
  retval = .false.
  if (not_null(a)) then
      dim = dimen(a)
     if (dim .eq. 2) then
        do i = 1, 2
           low(i) = lower(a, i-1)
           up(i) = upper(a, i-1)
           len(i) = up(i) - low(i)
        enddo
        do i = 0, len(1)
           index(1) = low(1) + i
           do j = 0, len(2)
              expectedvalue = (2.0d0 ** (i-j))
              index(2) = low(2) + j
              call get(a, index(1), index(2), value1)
              call get(a, index, value2)
              value3 = a%d_data(index(1), index(2))
              if ((value1 .ne. value2) &
                   .or. (value1 .ne. value3) &
                   .or.  (value1 .ne. expectedvalue)) then
                 return
              endif
           enddo
        enddo
        retval = .true.
     endif
  endif
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.check2Double)
end subroutine Array_check2Double7081y8i9gp_mi


! 
! Method:  check2Float[]
! 

recursive subroutine ArrayO_check2Floatme7av9ys4q_mi(a, retval)
  use ArrayTest_ArrayOps
  use sidl_float_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.check2Float.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.check2Float.use)
  implicit none
  type(sidl_float_2d) :: a ! in
  logical :: retval ! out

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.check2Float)
  integer (selected_int_kind(9))  :: dim, low(2), up(2), index(2), i, j
  integer (selected_int_kind(9))  :: len(2)
  real (selected_real_kind(6,37)) :: value1, value2, expectedvalue, value3
  retval = .false.
  if (not_null(a)) then
      dim = dimen(a)
     if (dim .eq. 2) then
        do i = 1, 2
           low(i) = lower(a, i-1)
           up(i) = upper(a, i-1)
           len(i) = up(i) - low(i)
        enddo
        do i = 0, len(1)
           index(1) = low(1) + i
           do j = 0, len(2)
              expectedvalue = (2.0 ** (i-j))
              index(2) = low(2) + j
              call get(a, index(1), index(2), value1)
              call get(a, index, value2)
              value3 = a%d_data(index(1), index(2))
              if ((value1 .ne. value2) &
                   .or. (value1 .ne. value3) &
                   .or. (value1 .ne. expectedvalue)) then
                 return
              endif
           enddo
        enddo
        retval = .true.
     endif
  endif
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.check2Float)
end subroutine ArrayO_check2Floatme7av9ys4q_mi


! 
! Method:  check2Fcomplex[]
! 

recursive subroutine Arr_check2Fcomplexiayu9iwvsb_mi(a, retval)
  use ArrayTest_ArrayOps
  use sidl_fcomplex_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.check2Fcomplex.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.check2Fcomplex.use)
  implicit none
  type(sidl_fcomplex_2d) :: a ! in
  logical :: retval ! out

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.check2Fcomplex)
  integer (selected_int_kind(9))     :: dim, low(2), up(2), index(2), i, j
  integer (selected_int_kind(9))     :: len(2)
  complex (selected_real_kind(6,37)) :: value1, value2, expectedvalue, value3
  retval = .false.
  if (not_null(a)) then
      dim = dimen(a)
     if (dim .eq. 2) then
        do i = 1, 2
           low(i) = lower(a, i-1)
           up(i) = upper(a, i-1)
           len(i) = up(i) - low(i)
        enddo
        do i = 0, len(1)
           do j = 0, len(2)
              expectedvalue = cmplx(2.0 ** i, 2.0 ** (-j))
              index(1) = low(1) + i
              index(2) = low(2) + j
              call get(a, index(1), index(2), value1)
              call get(a, index, value2)
              value3 = a%d_data(index(1), index(2))
              if ((value1 .ne. value2) &
                   .or. (value1 .ne. value2) &
                   .or.  (value1 .ne. expectedvalue)) then
                 return
              endif
           enddo
        enddo
        retval = .true.
     endif
  endif
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.check2Fcomplex)
end subroutine Arr_check2Fcomplexiayu9iwvsb_mi


! 
! Method:  check2Dcomplex[]
! 

recursive subroutine Arr_check2Dcomplexvwom7ctsrx_mi(a, retval)
  use ArrayTest_ArrayOps
  use sidl_dcomplex_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.check2Dcomplex.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.check2Dcomplex.use)
  implicit none
  type(sidl_dcomplex_2d) :: a ! in
  logical :: retval ! out

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.check2Dcomplex)
  integer (selected_int_kind(9))       :: dim, low(2), up(2), index(2), i, j
  integer (selected_int_kind(9))       :: len(2)
  complex (selected_real_kind(15,307)) :: value1, value2, expectedvalue, value3
  retval = .false.
  if (not_null(a)) then
      dim = dimen(a)
     if (dim .eq. 2) then
        do i = 1, 2
           low(i) = lower(a, i-1)
           up(i) = upper(a, i-1)
           len(i) = up(i) - low(i)
        enddo
        do i = 0, len(1)
           do j = low(2), up(2)
              expectedvalue = cmplx(2.0d0 ** i, 2.0d0 ** (-j))
              index(1) = low(1) + i
              index(2) = low(2) + j
              call get(a, index(1), index(2), value1)
              call get(a, index, value2)
              value3 = a%d_data(index(1), index(2))
              if ((value1 .ne. value2) &
                   .or. (value1 .ne. value3) &
                   .or. (value1 .ne. expectedvalue)) then
                 return
              endif
           enddo
        enddo
        retval = .true.
     endif
  endif
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.check2Dcomplex)
end subroutine Arr_check2Dcomplexvwom7ctsrx_mi


! 
! Method:  check3Int[]
! 

recursive subroutine ArrayTest_ArrayOps_check3Int_mi(a, retval)
  use ArrayTest_ArrayOps
  use sidl_int_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.check3Int.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.check3Int.use)
  implicit none
  type(sidl_int_3d) :: a ! in
  logical :: retval ! out

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.check3Int)
  integer (selected_int_kind(9)) :: dim, len(3), ind(3), low(3), up(3)
  integer (selected_int_kind(9)) :: i, j, k
  integer (selected_int_kind(9)) :: value1, value2, expectedvalue, value3
  integer (selected_int_kind(9)) :: intFunc
  retval = .false.
  if (not_null(a)) then
     dim = dimen(a)
     if (dim .eq. 3) then
        do i = 1, dim
            low(i) = lower(a, i-1)
            up(i) = upper(a, i-1)
            len(i) = up(i) - low(i)
        enddo
        do i = 0, len(1)
           ind(1) = low(1) + i
           do j = 0, len(2)
              ind(2) = low(2) + j
              do k = 0, len(3)
                 ind(3) = low(3) + k
                 expectedvalue = intFunc(dim, ind)
                 call get(a, ind(1), ind(2), ind(3), value1)
                 call get(a, ind, value2)
                 value3 = a%d_data(ind(1), ind(2), ind(3))
                 if (    (value1 .ne. value2) &
                      .or. (value1 .ne. value3) &
                      .or. (value1 .ne. expectedvalue)) then
                    return
                 endif
              enddo
           enddo
        enddo
        retval = .true.
     endif
  endif
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.check3Int)
end subroutine ArrayTest_ArrayOps_check3Int_mi


! 
! Method:  check4Int[]
! 

recursive subroutine ArrayTest_ArrayOps_check4Int_mi(a, retval)
  use ArrayTest_ArrayOps
  use sidl_int_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.check4Int.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.check4Int.use)
  implicit none
  type(sidl_int_4d) :: a ! in
  logical :: retval ! out

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.check4Int)
  integer (selected_int_kind(9)) :: dim, len(4), ind(4), low(4), up(4)
  integer (selected_int_kind(9)) :: i, j, k, l
  integer (selected_int_kind(9)) :: value1, value2, expectedvalue, value3
  integer (selected_int_kind(9)) :: intFunc
  retval = .false.
  if (not_null(a)) then
     dim = dimen(a)
     if (dim .eq. 4) then
        do i = 1, dim
            low(i) = lower(a, i-1)
            up(i) = upper(a, i-1)
            len(i) = up(i) - low(i)
        enddo
        do i = 0, len(1)
           ind(1) = low(1) + i
           do j = 0, len(2)
              ind(2) = low(2) + j
              do k = 0, len(3)
                 ind(3) = low(3) + k
                 do l = 0, len(4)
                    ind(4) = low(4) + l
                    expectedvalue = intFunc(dim, ind)
                    call get(a, ind(1), ind(2), ind(3), ind(4), value1)
                    call get(a, ind, value2)
                    value3 = a%d_data(ind(1), ind(2), ind(3), ind(4))
                    if (    (value1 .ne. value2) &
                         .or. (value1 .ne. value3) &
                         .or. (value1 .ne. expectedvalue)) then
                       return
                    endif
                 enddo
              enddo
           enddo
        enddo
        retval = .true.
     endif
  endif
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.check4Int)
end subroutine ArrayTest_ArrayOps_check4Int_mi


! 
! Method:  check5Int[]
! 

recursive subroutine ArrayTest_ArrayOps_check5Int_mi(a, retval)
  use ArrayTest_ArrayOps
  use sidl_int_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.check5Int.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.check5Int.use)
  implicit none
  type(sidl_int_5d) :: a ! in
  logical :: retval ! out

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.check5Int)
  integer (selected_int_kind(9)) :: dim, len(5), ind(5), low(5), up(5)
  integer (selected_int_kind(9)) :: i, j, k, l, m
  integer (selected_int_kind(9)) :: value1, value2, expectedvalue, value3
  integer (selected_int_kind(9)) :: intFunc
  retval = .false.
  if (not_null(a)) then
     dim = dimen(a)
     if (dim .eq. 5) then
        do i = 1, dim
            low(i) = lower(a, i-1)
            up(i) = upper(a, i-1)
            len(i) = up(i) - low(i)
        enddo
        do i = 0, len(1)
           ind(1) = low(1) + i
           do j = 0, len(2)
              ind(2) = low(2) + j
              do k = 0, len(3)
                 ind(3) = low(3) + k
                 do l = 0, len(4)
                    ind(4) = low(4) + l
                    do m = 0, len(5)
                       ind(5) = low(5) + m
                       expectedvalue = intFunc(dim, ind)
                       call get(a, ind(1), ind(2), ind(3), ind(4), ind(5), value1)
                       call get(a, ind, value2)
                       value3 = a%d_data(ind(1), ind(2), ind(3), ind(4), ind(5))
                       if (    (value1 .ne. value2) &
                         .or. (value1 .ne. value3) &
                         .or. (value1 .ne. expectedvalue)) then
                          return
                       endif
                    enddo
                 enddo
              enddo
           enddo
        enddo
        retval = .true.
     endif
  endif
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.check5Int)
end subroutine ArrayTest_ArrayOps_check5Int_mi


! 
! Method:  check6Int[]
! 

recursive subroutine ArrayTest_ArrayOps_check6Int_mi(a, retval)
  use ArrayTest_ArrayOps
  use sidl_int_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.check6Int.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.check6Int.use)
  implicit none
  type(sidl_int_6d) :: a ! in
  logical :: retval ! out

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.check6Int)
  integer (selected_int_kind(9)) :: dim, len(6), ind(6), low(6), up(6)
  integer (selected_int_kind(9)) :: i, j, k, l, m, n
  integer (selected_int_kind(9)) :: value1, value2, expectedvalue, value3
  integer (selected_int_kind(9)) :: intFunc
  retval = .false.
  if (not_null(a)) then
     dim = dimen(a)
     if (dim .eq. 6) then
        do i = 1, dim
            low(i) = lower(a, i-1)
            up(i) = upper(a, i-1)
            len(i) = up(i) - low(i)
        enddo
        do i = 0, len(1)
           ind(1) = low(1) + i
           do j = 0, len(2)
              ind(2) = low(2) + j
              do k = 0, len(3)
                 ind(3) = low(3) + k
                 do l = 0, len(4)
                    ind(4) = low(4) + l
                    do m = 0, len(5)
                       ind(5) = low(5) + m
                       do n = 0, len(6)
                          ind(6) = low(6) + n
                          expectedvalue = intFunc(dim, ind)
                          call get(a, ind(1), ind(2), ind(3), ind(4), ind(5), ind(6), value1)
                          call get(a, ind, value2)
                          value3 = a%d_data(ind(1), ind(2), ind(3), ind(4), ind(5), ind(6))
                          if (    (value1 .ne. value2) &
                               .or. (value1 .ne. value3) &
                               .or. (value1 .ne. expectedvalue)) then
                             return
                          endif
                       enddo
                    enddo
                 enddo
              enddo
           enddo
        enddo
        retval = .true.
     endif
  endif
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.check6Int)
end subroutine ArrayTest_ArrayOps_check6Int_mi


! 
! Method:  check7Int[]
! 

recursive subroutine ArrayTest_ArrayOps_check7Int_mi(a, retval)
  use ArrayTest_ArrayOps
  use sidl_int_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.check7Int.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.check7Int.use)
  implicit none
  type(sidl_int_7d) :: a ! in
  logical :: retval ! out

  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.check7Int)
  integer (selected_int_kind(9)) :: dim, len(7), ind(7), low(7), up(7)
  integer (selected_int_kind(9)) :: i, j, k, l, m, n, o
  integer (selected_int_kind(9)) :: value1, value2, expectedvalue, value3
  integer (selected_int_kind(9)) :: intFunc
  retval = .false.
  if (not_null(a)) then
     dim = dimen(a)
     if (dim .eq. 7) then
        do i = 1, dim
           low(i) = lower(a, i-1)
           up(i) = upper(a, i-1)
           len(i) = up(i) - low(i)
        enddo
        do i = 0, len(1)
           ind(1) = low(1) + i
           do j = 0, len(2)
              ind(2) = low(2) + j
              do k = 0, len(3)
                 ind(3) = low(3) + k
                 do l = 0, len(4)
                    ind(4) = low(4) + l
                    do m = 0, len(5)
                       ind(5) = low(5) + m
                       do n = 0, len(6)
                          ind(6) = low(6) + n
                          do o = 0, len(7)
                             ind(7) = low(7) + o
                             expectedvalue = intFunc(dim, ind)
                             call get(a, ind(1), ind(2), ind(3), ind(4), ind(5), ind(6), ind(7), value1)
                             call get(a, ind, value2)
                             value3 = a%d_data(ind(1), ind(2), ind(3), ind(4), ind(5), ind(6), ind(7))
                             if (    (value1 .ne. value2) &
                                  .or. (value1 .ne. value3) &
                                  .or. (value1 .ne. expectedvalue)) then
                                return
                             endif
                          enddo
                       enddo
                    enddo
                 enddo
              enddo
           enddo
        enddo
        retval = .true.
     endif
  endif
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.check7Int)
end subroutine ArrayTest_ArrayOps_check7Int_mi


! 
! Method:  checkObject[]
! 

recursive subroutine ArrayO_checkObject275yd2pmke_mi(a, retval)
  use ArrayTest_ArrayOps
  use ArrayTest_ArrayOps_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.checkObject.use)
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.checkObject.use)
  implicit none
  type(ArrayTest_ArrayOps_1d) :: a ! in
  integer (selected_int_kind(9)) :: retval ! out

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.checkObject)
  integer (selected_int_kind(9)) :: dim, low, up, i, index(1), prime
  type(ArrayTest_ArrayOps_t) :: value1, value2
  logical isone
  retval = 0
  if (not_null(a)) then
     dim = dimen(a)
     if (dim .eq. 1) then
        low = lower(a, 0)
        up = upper(a,0)
        prime = 0
        do i = low, up
           index(1) = i
           call get(a, i, value1)
           call get(a, index, value2)
           if (value1%d_ior .ne. value2%d_ior) then
              retval = -32000
           else
              if (not_null(value1)) then
                 call isType(value1, 'ArrayTest.ArrayOps', isone)
                 if (isone) then
                    retval = retval + 1
                 endif
              endif
           endif
           if (not_null(value1)) then
              call deleteRef(value1)
           endif
           if (not_null(value2)) then
              call deleteRef(value2)
           endif
        enddo
     endif
  endif
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.checkObject)
end subroutine ArrayO_checkObject275yd2pmke_mi


! 
! Method:  reverseBool[]
! 

recursive subroutine ArrayO_reverseBoolgymo0nngeh_mi(a, newArray, retval)
  use ArrayTest_ArrayOps
  use sidl_bool_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.reverseBool.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.reverseBool.use)
  implicit none
  type(sidl_bool_1d) :: a ! inout
  logical :: newArray ! in
  logical :: retval ! out

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.reverseBool)
  integer (selected_int_kind(9)) :: dim, low(1), up(1), i, len
  type(sidl_bool_1d) :: destarray
  logical buffer, extra
  if (not_null(a)) then
      dim = dimen(a)
     if (dim .eq. 1) then
        low(1) = lower(a, 0)
        up(1) = upper(a, 0)
        call checkBool(a, retval)
        if (newarray) then
           call createRow(low, up, destarray)
           do i = low(1), up(1)
              call get(a, i, buffer)
              call set(destarray, &
                   up(1) + low(1) - i, buffer)
           enddo
           call deleteRef(a)
           a = destarray
        else
           len = ((up(1) - low(1) + 1) / 2) - 1
           do i = 0, len
              call get(a, low(1) + i, buffer)
              call get(a, up(1) - i, extra)

              call set(a, low(1) + i, extra)
              call set(a, up(1) - i, buffer)
           enddo
        endif
     endif
  endif
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.reverseBool)
end subroutine ArrayO_reverseBoolgymo0nngeh_mi


! 
! Method:  reverseChar[]
! 

recursive subroutine ArrayO_reverseCharlkg8mhipko_mi(a, newArray, retval)
  use ArrayTest_ArrayOps
  use sidl_char_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.reverseChar.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.reverseChar.use)
  implicit none
  type(sidl_char_1d) :: a ! inout
  logical :: newArray ! in
  logical :: retval ! out

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.reverseChar)
  integer (selected_int_kind(9)) :: dim, low(1), up(1), i, len
  type(sidl_char_1d) :: destarray
  character :: buffer, extra
  if (not_null(a)) then
      dim = dimen(a)
     if (dim .eq. 1) then
        low(1) = lower(a, 0)
        up(1) = upper(a, 0)
        call checkChar(a, retval)
        if (newarray) then
           call createRow(low, up, destarray)
           do i = low(1), up(1)
              call get(a, i, buffer)
              call set(destarray,up(1) + low(1) - i, buffer)
           enddo
           call deleteRef(a)
           a = destarray
        else
           len = ((up(1) - low(1) + 1) / 2) - 1
           do i = 0, len
              call get(a, low(1) + i, buffer)
              call get(a, up(1) - i, extra)

              call set(a, low(1) + i, extra)
              call set(a, up(1) - i, buffer)
           enddo
        endif
     endif
  endif
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.reverseChar)
end subroutine ArrayO_reverseCharlkg8mhipko_mi


! 
! Method:  reverseInt[]
! 

recursive subroutine ArrayOp_reverseIntkxwfbbpb16_mi(a, newArray, retval)
  use ArrayTest_ArrayOps
  use sidl_int_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.reverseInt.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.reverseInt.use)
  implicit none
  type(sidl_int_1d) :: a ! inout
  logical :: newArray ! in
  logical :: retval ! out

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.reverseInt)
  integer (selected_int_kind(9)) :: dim, low(1), up(1), i, len
  type(sidl_int_1d) :: destarray
  integer (selected_int_kind(9)) :: buffer, extra
  if (not_null(a)) then
      dim = dimen(a)
     if (dim .eq. 1) then
        low(1) = lower(a, 0)
        up(1) = upper(a, 0)
        call checkInt(a, retval)
        if (newarray) then
           call createRow(low, up, destarray)
           do i = low(1), up(1)
              call get(a, i, buffer)
              call set(destarray, up(1) + low(1) - i, buffer)
           enddo
           call deleteRef(a)
           a = destarray
        else
           len = ((up(1) - low(1) + 1) / 2) - 1
           do i = 0, len
              call get(a, low(1) + i, buffer)
              call get(a, up(1) - i, extra)

              call set(a, low(1) + i, extra)
              call set(a, up(1) - i, buffer)
           enddo
        endif
     endif
  endif
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.reverseInt)
end subroutine ArrayOp_reverseIntkxwfbbpb16_mi


! 
! Method:  reverseLong[]
! 

recursive subroutine ArrayO_reverseLongnxvgf_63g6_mi(a, newArray, retval)
  use ArrayTest_ArrayOps
  use sidl_long_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.reverseLong.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.reverseLong.use)
  implicit none
  type(sidl_long_1d) :: a ! inout
  logical :: newArray ! in
  logical :: retval ! out

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.reverseLong)
  integer (selected_int_kind(9)) :: dim, low(1), up(1), i, len
  type(sidl_long_1d) :: destarray
  integer (selected_int_kind(18)) :: buffer, extra
  if (not_null(a)) then
      dim = dimen(a)
     if (dim .eq. 1) then
        low(1) = lower(a, 0)
        up(1) = upper(a, 0)
        call checkLong(a, retval)
        if (newarray) then
           call createRow(low, up, destarray)
           do i = low(1), up(1)
              call get(a, i, buffer)
              call set(destarray, up(1) + low(1) - i, buffer)
           enddo
           call deleteRef(a)
           a = destarray
        else
           len = ((up(1) - low(1) + 1) / 2) - 1
           do i = 0, len
              call get(a, low(1) + i, buffer)
              call get(a, up(1) - i, extra)

              call set(a, low(1) + i, extra)
              call set(a, up(1) - i, buffer)
           enddo
        endif
     endif
  endif
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.reverseLong)
end subroutine ArrayO_reverseLongnxvgf_63g6_mi


! 
! Method:  reverseString[]
! 

recursive subroutine Arra_reverseStringgoh6ljf81q_mi(a, newArray, retval)
  use ArrayTest_ArrayOps
  use sidl_string_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.reverseString.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.reverseString.use)
  implicit none
  type(sidl_string_1d) :: a ! inout
  logical :: newArray ! in
  logical :: retval ! out

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.reverseString)
  integer (selected_int_kind(9)) :: dim, low(1), up(1), i, len
  type(sidl_string_1d) :: destarray
  character (len=2048):: buffer
  character (len=2048) :: extra
  if (not_null(a)) then
      dim = dimen(a)
     if (dim .eq. 1) then
        low(1) = lower(a, 0)
        up(1) = upper(a, 0)
        call checkString(a, retval)
        if (newarray) then
           call createRow(low, up, destarray)
           do i = low(1), up(1)
              call get(a, i, buffer)
              call set(destarray, up(1) + low(1) - i, buffer)
           enddo
           call deleteRef(a)
           a = destarray
        else
           len = ((up(1) - low(1) + 1) / 2) - 1
           do i = 0, len
              call get(a, low(1) + i, buffer)
              call get(a, up(1) - i, extra)

              call set(a, low(1) + i, extra)
              call set(a, up(1) - i, buffer)
           enddo
        endif
     endif
  endif
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.reverseString)
end subroutine Arra_reverseStringgoh6ljf81q_mi


! 
! Method:  reverseDouble[]
! 

recursive subroutine Arra_reverseDoubletak4ebvws0_mi(a, newArray, retval)
  use ArrayTest_ArrayOps
  use sidl_double_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.reverseDouble.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.reverseDouble.use)
  implicit none
  type(sidl_double_1d) :: a ! inout
  logical :: newArray ! in
  logical :: retval ! out

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.reverseDouble)
  integer (selected_int_kind(9)) :: dim, low(1), up(1), i, len
  type(sidl_double_1d) :: destarray
  real(selected_real_kind(15,307)) :: buffer, extra
  if (not_null(a)) then
      dim = dimen(a)
     if (dim .eq. 1) then
        low(1) = lower(a, 0)
        up(1) = upper(a, 0)
        call checkDouble(a, retval)
        if (newarray) then
           call createRow(low, up, destarray)
           do i = low(1), up(1)
              call get(a, i, buffer)
              call set(destarray, up(1) + low(1) - i, buffer)
           enddo
           call deleteRef(a)
           a = destarray
        else
           len = ((up(1) - low(1) + 1) / 2) - 1
           do i = 0, len
              call get(a, low(1) + i, buffer)
              call get(a, up(1) - i, extra)

              call set(a, low(1) + i, extra)
              call set(a, up(1) - i, buffer)
           enddo
        endif
     endif
  endif
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.reverseDouble)
end subroutine Arra_reverseDoubletak4ebvws0_mi


! 
! Method:  reverseFloat[]
! 

recursive subroutine Array_reverseFloatznhcr92afl_mi(a, newArray, retval)
  use ArrayTest_ArrayOps
  use sidl_float_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.reverseFloat.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.reverseFloat.use)
  implicit none
  type(sidl_float_1d) :: a ! inout
  logical :: newArray ! in
  logical :: retval ! out

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.reverseFloat)
  integer (selected_int_kind(9)) :: dim, low(1), up(1), i, len
  type(sidl_float_1d) :: destarray
  real buffer, extra
  if (not_null(a)) then
      dim = dimen(a)
     if (dim .eq. 1) then
        low(1) = lower(a, 0)
        up(1) = upper(a, 0)
        call checkFloat(a, retval)
        if (newarray) then
           call createRow(low, up, destarray)
           do i = low(1), up(1)
              call get(a, i, buffer)
              call set(destarray, up(1) + low(1) - i, buffer)
           enddo
           call deleteRef(a)
           a = destarray
        else
           len = ((up(1) - low(1) + 1) / 2) - 1
           do i = 0, len
              call get(a, low(1) + i, buffer)
              call get(a, up(1) - i, extra)

              call set(a, low(1) + i, extra)
              call set(a, up(1) - i, buffer)
           enddo
        endif
     endif
  endif
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.reverseFloat)
end subroutine Array_reverseFloatznhcr92afl_mi


! 
! Method:  reverseFcomplex[]
! 

recursive subroutine Ar_reverseFcomplex3ygx3y26n0_mi(a, newArray, retval)
  use ArrayTest_ArrayOps
  use sidl_fcomplex_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.reverseFcomplex.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.reverseFcomplex.use)
  implicit none
  type(sidl_fcomplex_1d) :: a ! inout
  logical :: newArray ! in
  logical :: retval ! out

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.reverseFcomplex)
  integer (selected_int_kind(9)) :: dim, low(1), up(1), i, len
  type(sidl_fcomplex_1d) :: destarray
  complex(selected_real_kind(6,37)) :: buffer, extra
  if (not_null(a)) then
      dim = dimen(a)
     if (dim .eq. 1) then
        low(1) = lower(a, 0)
        up(1) = upper(a, 0)
        call checkFcomplex(a, retval)
        if (newarray) then
           call createRow(low, up, destarray)
           do i = low(1), up(1)
              call get(a, i, buffer)
              call set(destarray, up(1) + low(1) - i, buffer)
           enddo
           call deleteRef(a)
           a = destarray
        else
           len = ((up(1) - low(1) + 1) / 2) - 1
           do i = 0, len
              call get(a, low(1) + i, buffer)
              call get(a, up(1) - i, extra)

              call set(a, low(1) + i, extra)
              call set(a, up(1) - i, buffer)
           enddo
        endif
     endif
  endif
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.reverseFcomplex)
end subroutine Ar_reverseFcomplex3ygx3y26n0_mi


! 
! Method:  reverseDcomplex[]
! 

recursive subroutine Ar_reverseDcomplex27ddkoywyz_mi(a, newArray, retval)
  use ArrayTest_ArrayOps
  use sidl_dcomplex_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.reverseDcomplex.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.reverseDcomplex.use)
  implicit none
  type(sidl_dcomplex_1d) :: a ! inout
  logical :: newArray ! in
  logical :: retval ! out

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.reverseDcomplex)
  integer (selected_int_kind(9)) :: dim, low(1), up(1), i, len
  type(sidl_dcomplex_1d) :: destarray
  complex(selected_real_kind(15,307)) :: buffer, extra
  if (not_null(a)) then
      dim = dimen(a)
     if (dim .eq. 1) then
        low(1) = lower(a, 0)
        up(1) = upper(a, 0)
        call checkDcomplex(a, retval)
        if (newarray) then
           call createRow(low, up, destarray)
           do i = low(1), up(1)
              call get(a, i, buffer)
              call set(destarray, up(1) + low(1) - i, buffer)
           enddo
           call deleteRef(a)
           a = destarray
        else
           len = ((up(1) - low(1) + 1) / 2) - 1
           do i = 0, len
              call get(a, low(1) + i, buffer)
              call get(a, up(1) - i, extra)

              call set(a, low(1) + i, extra)
              call set(a, up(1) - i, buffer)
           enddo
        endif
     endif
  endif
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.reverseDcomplex)
end subroutine Ar_reverseDcomplex27ddkoywyz_mi


! 
! Method:  createBool[]
! 

recursive subroutine ArrayOp_createBoolqh7dzxxaoi_mi(len, retval)
  use ArrayTest_ArrayOps
  use sidl_bool_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.createBool.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.createBool.use)
  implicit none
  integer (selected_int_kind(9)) :: len ! in
  type(sidl_bool_1d) :: retval ! out

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.createBool)
  integer (selected_int_kind(9)) :: low(1), up(1), i, index(1), testind
  logical :: isEven
  call set_null(retval)
  if (len .ge. 0) then
     low(1) = 0
     up(1) = len - 1
     call createRow(low, up, retval)
     do i = 0, len - 1
        testind = mod(i, 64) + 1
        if (mod(i, 2) .eq. 0) then
           call set(retval, i, isEven(i))
        else
           index(1) = i
           call set(retval, index, isEven(i))
        endif
     enddo
  endif
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.createBool)
end subroutine ArrayOp_createBoolqh7dzxxaoi_mi


! 
! Method:  createChar[]
! 

recursive subroutine ArrayOp_createChargrqa0qqx35_mi(len, retval)
  use ArrayTest_ArrayOps
  use sidl_char_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.createChar.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.createChar.use)
  implicit none
  integer (selected_int_kind(9)) :: len ! in
  type(sidl_char_1d) :: retval ! out

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.createChar)
  character (len=64) :: testtext
  integer (selected_int_kind(9)) :: low(1), up(1), i, index(1), testind
  data testtext / 'I''d rather write programs to write programs than write programs' /
  call set_null(retval)
  if (len .ge. 0) then
     low(1) = 0
     up(1) = len - 1
     call createRow(low, up, retval)
     do i = 0, len - 1
        testind = mod(i, 64) + 1
        if (mod(i, 2) .eq. 0) then
           call set(retval, i, testtext(testind:testind))
        else
           index(1) = i
           call set(retval, index, testtext(testind:testind))
        endif
     enddo
  endif
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.createChar)
end subroutine ArrayOp_createChargrqa0qqx35_mi


! 
! Method:  createInt[]
! 

recursive subroutine ArrayTest_ArrayOps_createInt_mi(len, retval)
  use ArrayTest_ArrayOps
  use sidl_int_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.createInt.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.createInt.use)
  implicit none
  integer (selected_int_kind(9)) :: len ! in
  type(sidl_int_1d) :: retval ! out

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.createInt)
  integer (selected_int_kind(9)) :: i, low(1), up(1), index(1)
  integer (selected_int_kind(9)) :: value, modval
  integer (selected_int_kind(18)) :: nextprime, tmp
  call set_null(retval)
  if (len .ge. 0) then
     low(1) = 0
     value = 0
     up(1) = len - 1
     call createRow(low, up, retval)
     do i = 0, len - 1
        tmp = value
        value = nextprime(tmp)
        modval = mod(i, 3)
        if (modval .eq. 0) then
           call set(retval, i, value)
        else
           if (modval .eq. 1) then
              index(1) = i
              call set(retval, index, value)
           else
	      retval%d_data(i) = value
           endif
        endif
     enddo
  endif
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.createInt)
end subroutine ArrayTest_ArrayOps_createInt_mi


! 
! Method:  createLong[]
! 

recursive subroutine ArrayOp_createLongau7gsrji_x_mi(len, retval)
  use ArrayTest_ArrayOps
  use sidl_long_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.createLong.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.createLong.use)
  implicit none
  integer (selected_int_kind(9)) :: len ! in
  type(sidl_long_1d) :: retval ! out

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.createLong)
  integer (selected_int_kind(9)) :: low(1), up(1), i, index(1), modval
  integer (selected_int_kind(18)) :: value, nextprime
  call set_null(retval)
  if (len .ge. 0) then
     low(1) = 0
     value = 0
     up(1) = len - 1
     call createRow(low, up, retval)
     do i = 0, len - 1
        value = nextprime(value)
        modval = mod(i, 3)
        if (modval .eq. 0) then
           call set(retval, i, value)
        else
           if (modval .eq. 1) then
              index(1) = i
              call set(retval, index, value)
           else
              retval%d_data(i) = value
           endif
        endif
     enddo
  endif
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.createLong)
end subroutine ArrayOp_createLongau7gsrji_x_mi


! 
! Method:  createString[]
! 

recursive subroutine Array_createStringgncdbm9unz_mi(len, retval)
  use ArrayTest_ArrayOps
  use sidl_string_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.createString.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.createString.use)
  implicit none
  integer (selected_int_kind(9)) :: len ! in
  type(sidl_string_1d) :: retval ! out

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.createString)
  character (len=9) :: testtext(10)
  integer (selected_int_kind(9)) :: low(1), up(1), i, index(1), testind
  data testtext / 'I''d', 'rather', 'write', 'programs', 'to', 'write', &
       'programs', 'than', 'write', 'programs.'/
  call set_null(retval)
  if (len .ge. 0) then
     low(1) = 0
     up(1) = len - 1
     call createRow(low, up, retval)
     do i = 0, len - 1
        testind = mod(i, 10) + 1
        if (mod(i, 2) .eq. 0) then
           call set(retval, i, testtext(testind))
        else
           index(1) = i
           call set(retval, index, testtext(testind))
        endif
     enddo
  endif
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.createString)
end subroutine Array_createStringgncdbm9unz_mi


! 
! Method:  createDouble[]
! 

recursive subroutine Array_createDoubleocanws5yj__mi(len, retval)
  use ArrayTest_ArrayOps
  use sidl_double_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.createDouble.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.createDouble.use)
  implicit none
  integer (selected_int_kind(9)) :: len ! in
  type(sidl_double_1d) :: retval ! out

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.createDouble)
  integer (selected_int_kind(9)) :: low(1), up(1), i, index(1), modval
  real(selected_real_kind(15,307)) :: value
  call set_null(retval)
  if (len .ge. 0) then
     low(1) = 0
     up(1) = len - 1
     call createRow(low, up, retval)
     do i = 0, len - 1
        value = 2.0d0 ** (-i)
        modval = mod(i, 3)
        if (modval .eq. 0) then
           call set(retval, i, value)
        else
           if (modval .eq. 1) then
              index(1) = i
              call set(retval, index, value)
           else
              retval%d_data(i) = value
           endif
        endif
     enddo
  endif
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.createDouble)
end subroutine Array_createDoubleocanws5yj__mi


! 
! Method:  createFloat[]
! 

recursive subroutine ArrayO_createFloatbxvfxabr56_mi(len, retval)
  use ArrayTest_ArrayOps
  use sidl_float_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.createFloat.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.createFloat.use)
  implicit none
  integer (selected_int_kind(9)) :: len ! in
  type(sidl_float_1d) :: retval ! out

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.createFloat)
  integer (selected_int_kind(9)) :: low(1), up(1), i, index(1), modval
  real(selected_real_kind(6,37)) :: value
  call set_null(retval)
  if (len .ge. 0) then
     low(1) = 0
     up(1) = len - 1
     call createRow(low, up, retval)
     do i = 0, len - 1
        value = 2.0 ** (-i)
        modval = mod(i, 3)
        if (modval .eq. 0) then
           call set(retval, i, value)
        else
           if (modval .eq. 1) then
              index(1) = i
              call set(retval, index, value)
           else
              retval%d_data(i) = value
           endif
        endif
     enddo
  endif
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.createFloat)
end subroutine ArrayO_createFloatbxvfxabr56_mi


! 
! Method:  createFcomplex[]
! 

recursive subroutine Arr_createFcomplex6h5qchwr1t_mi(len, retval)
  use ArrayTest_ArrayOps
  use sidl_fcomplex_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.createFcomplex.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.createFcomplex.use)
  implicit none
  integer (selected_int_kind(9)) :: len ! in
  type(sidl_fcomplex_1d) :: retval ! out

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.createFcomplex)
  integer (selected_int_kind(9)) :: low(1), up(1), i, index(1), modval
  complex(selected_real_kind(6,37)) :: value
  call set_null(retval)
  if (len .ge. 0) then
     low(1) = 0
     up(1) = len - 1
     call createRow(low, up, retval)
     do i = 0, len - 1
        value = cmplx(2.0 ** i, 2.0 ** (-i))
        modval = mod(i, 3)
        if (modval .eq. 0) then
           call set(retval, i, value)
        else
           if (modval .eq. 1) then
              index(1) = i
              call set(retval, index, value)
           else
              retval%d_data(i) = value
           endif
        endif
     enddo
  endif
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.createFcomplex)
end subroutine Arr_createFcomplex6h5qchwr1t_mi


! 
! Method:  createDcomplex[]
! 

recursive subroutine Arr_createDcomplex2117rrwnvr_mi(len, retval)
  use ArrayTest_ArrayOps
  use sidl_dcomplex_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.createDcomplex.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.createDcomplex.use)
  implicit none
  integer (selected_int_kind(9)) :: len ! in
  type(sidl_dcomplex_1d) :: retval ! out

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.createDcomplex)
  integer (selected_int_kind(9))  :: low(1), up(1), i, index(1), modval
  complex(selected_real_kind(15,307)) :: value
  call set_null(retval)
  if (len .ge. 0) then
     low(1) = 0
     up(1) = len - 1
     call createRow(low, up, retval)
     do i = 0, len - 1
        value = cmplx(2.0d0 ** i, 2.0d0 ** (-i))
        modval = mod(i, 3)
        if (modval .eq. 0) then
           call set(retval, i, value)
        else
           if (modval .eq. 1) then
              index(1) = i
              call set(retval, index, value)
           else
              retval%d_data(i) = value
           endif
        endif
     enddo
  endif
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.createDcomplex)
end subroutine Arr_createDcomplex2117rrwnvr_mi


! 
! Method:  createObject[]
! 

recursive subroutine Array_createObject4cnhf0d9y2_mi(len, retval)
  use ArrayTest_ArrayOps
  use ArrayTest_ArrayOps_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.createObject.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.createObject.use)
  implicit none
  integer (selected_int_kind(9)) :: len ! in
  type(ArrayTest_ArrayOps_1d) :: retval ! out

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.createObject)
  integer (selected_int_kind(9)) :: low(1), up(1), i, index(1)
  type(ArrayTest_ArrayOps_t) :: object
  call set_null(retval)
  if (len .ge. 0) then
     low(1) = 0
     up(1) = len - 1
     call createRow(low, up, retval)
     do i = 0, len - 1
        call new(object)
        if (mod(i, 2) .eq. 0) then
           call set(retval, i, object)
        else
           index(1) = i
           call set(retval, index, object)
        endif

        call deleteRef(object)
     enddo
  endif
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.createObject)
end subroutine Array_createObject4cnhf0d9y2_mi


! 
! Method:  create2Int[]
! 

recursive subroutine ArrayOp_create2Intmumtywacyp_mi(d1, d2, retval)
  use ArrayTest_ArrayOps
  use sidl_int_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.create2Int.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.create2Int.use)
  implicit none
  integer (selected_int_kind(9)) :: d1 ! in
  integer (selected_int_kind(9)) :: d2 ! in
  type(sidl_int_2d) :: retval ! out

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.create2Int)
  integer (selected_int_kind(9)) :: low(2), up(2), index(2), i, j
  integer (selected_int_kind(9)) :: value, modval
  call set_null(retval)
  if ((d1 .ge. 0) .and. (d2 .ge. 0)) then
     low(1) = 0
     up(1) = d1 - 1
     low(2) = 0
     up(2) = d2 - 1
     value = 0
     call createRow(low, up, retval)
     do i = 0, up(1)
        index(1) = i
        do j = 0, up(2)
           index(2) = j
           value = (2.0d0 ** abs(i-j))
           modval = mod(i + j, 3)
           if (modval .eq. 0) then
              call set(retval, index(1), index(2), value)
           else
              if (modval .eq. 1) then
                 call set(retval, index, value)
              else
                 retval%d_data(i, j) = value
              endif
           endif
        enddo
     enddo
  endif
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.create2Int)
end subroutine ArrayOp_create2Intmumtywacyp_mi


! 
! Method:  create2Double[]
! 

recursive subroutine Arra_create2Doublewgvbfvoevx_mi(d1, d2, retval)
  use ArrayTest_ArrayOps
  use sidl_double_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.create2Double.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.create2Double.use)
  implicit none
  integer (selected_int_kind(9)) :: d1 ! in
  integer (selected_int_kind(9)) :: d2 ! in
  type(sidl_double_2d) :: retval ! out

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.create2Double)
  integer (selected_int_kind(9)) :: low(2), up(2), index(2), i, j
  integer (selected_int_kind(9)) :: modval
  double precision value
  call set_null(retval)
  if ((d1 .ge. 0) .and. (d2 .ge. 0)) then
     low(1) = 0
     up(1) = d1 - 1
     low(2) = 0
     up(2) = d2 - 1
     value = 0
     call createRow(low, up, retval)
     do i = 0, up(1)
        index(1) = i
        do j = 0, up(2)
           index(2) = j
           value = (2.0d0 ** (i-j))
           modval = mod(i + j, 3)
           if (modval .eq. 0) then
              call set(retval, index(1), index(2), value)
           else
              if (modval .eq. 1) then
                 call set(retval, index, value)
              else
                 retval%d_data(i, j) = value
              endif
           endif
        enddo
     enddo
  endif
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.create2Double)
end subroutine Arra_create2Doublewgvbfvoevx_mi


! 
! Method:  create2Float[]
! 

recursive subroutine Array_create2Floatxtc5m3ogpa_mi(d1, d2, retval)
  use ArrayTest_ArrayOps
  use sidl_float_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.create2Float.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.create2Float.use)
  implicit none
  integer (selected_int_kind(9)) :: d1 ! in
  integer (selected_int_kind(9)) :: d2 ! in
  type(sidl_float_2d) :: retval ! out

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.create2Float)
  integer (selected_int_kind(9))  :: low(2), up(2), index(2), i, j
  integer (selected_int_kind(9))  :: modval
  real (selected_real_kind(6,37)) :: value
  call set_null(retval)
  if ((d1 .ge. 0) .and. (d2 .ge. 0)) then
     low(1) = 0
     up(1) = d1 - 1
     low(2) = 0
     up(2) = d2 - 1
     value = 0
     call createRow(low, up, retval)
     do i = 0, up(1)
        index(1) = i
        do j = 0, up(2)
           index(2) = j
           value = (2.0d0 ** (i-j))
           modval = mod(i+j, 3)
           if (modval .eq. 0) then
              call set(retval, index(1), index(2), value)
           else
              if (modval .eq. 1) then
                 call set(retval, index, value)
              else
                 retval%d_data(i, j) = value
              endif
           endif
        enddo
     enddo
  endif
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.create2Float)
end subroutine Array_create2Floatxtc5m3ogpa_mi


! 
! Method:  create2Dcomplex[]
! 

recursive subroutine Ar_create2Dcomplexe22dd91s69_mi(d1, d2, retval)
  use ArrayTest_ArrayOps
  use sidl_dcomplex_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.create2Dcomplex.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.create2Dcomplex.use)
  implicit none
  integer (selected_int_kind(9)) :: d1 ! in
  integer (selected_int_kind(9)) :: d2 ! in
  type(sidl_dcomplex_2d) :: retval ! out

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.create2Dcomplex)
  integer (selected_int_kind(9))       :: low(2), up(2), index(2), i, j
  integer (selected_int_kind(9))       :: modval
  complex (selected_real_kind(15,307)) :: value
  call set_null(retval)
  if ((d1 .ge. 0) .and. (d2 .ge. 0)) then
     low(1) = 0
     up(1) = d1 - 1
     low(2) = 0
     up(2) = d2 - 1
     value = 0
     call createRow(low, up, retval)
     do i = 0, up(1)
        index(1) = i
        do j = 0, up(2)
           index(2) = j
           value = cmplx(2.0d0 ** i, 2.0d0 ** (-j))
           modval = mod(i + j, 3)
           if (modval .eq. 0) then
              call set(retval, index(1), index(2), value)
           else
              if (modval .eq. 1) then
                 call set(retval, index, value)
              else
                 retval%d_data(i, j) = value
              endif
           endif
        enddo
     enddo
  endif
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.create2Dcomplex)
end subroutine Ar_create2Dcomplexe22dd91s69_mi


! 
! Method:  create2Fcomplex[]
! 

recursive subroutine Ar_create2Fcomplexb8gunt105c_mi(d1, d2, retval)
  use ArrayTest_ArrayOps
  use sidl_fcomplex_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.create2Fcomplex.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.create2Fcomplex.use)
  implicit none
  integer (selected_int_kind(9)) :: d1 ! in
  integer (selected_int_kind(9)) :: d2 ! in
  type(sidl_fcomplex_2d) :: retval ! out

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.create2Fcomplex)
  integer (selected_int_kind(9))     :: low(2), up(2), index(2), i, j
  integer (selected_int_kind(9))     :: modval
  complex (selected_real_kind(6,37)) :: value
  call set_null(retval)
  if ((d1 .ge. 0) .and. (d2 .ge. 0)) then
     low(1) = 0
     up(1) = d1 - 1
     low(2) = 0
     up(2) = d2 - 1
     value = 0
     call createRow(low, up, retval)
     do i = 0, up(1)
        index(1) = i
        do j = 0, up(2)
           index(2) = j
           value = cmplx(2.0d0 ** i, 2.0d0 ** (-j))
           modval = mod(i + j, 3)
           if (modval .eq. 0) then
              call set(retval, index(1), index(2), value)
           else
              if (modval .eq. 1) then
                 call set(retval, index, value)
              else
                 retval%d_data(i,j) = value
              endif
           endif
        enddo
     enddo
  endif
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.create2Fcomplex)
end subroutine Ar_create2Fcomplexb8gunt105c_mi


! 
! Method:  create3Int[]
! 

recursive subroutine ArrayOp_create3Int4ikxjsbhe8_mi(retval)
  use ArrayTest_ArrayOps
  use sidl_int_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.create3Int.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.create3Int.use)
  implicit none
  type(sidl_int_3d) :: retval ! out

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.create3Int)
  integer (selected_int_kind(9))  :: dim, low(3), up(3), ind(3)
  integer (selected_int_kind(9))  :: value, modval, i, j, k, intFunc
  dim = 3
  do i = 1, dim
    low(i) = 0
    if (i .le. 2) then
      up(i) = 3
    else
      up(i) = 2
    endif
  enddo
  call createRow(low, up, retval)
  do i = 0, up(1)
    ind(1) = i
    do j = 0, up(2)
      ind(2) = j
      do k = 0, up(3)
        ind(3) = k
        value = intFunc(dim, ind)
        modval = mod(i+j+k, 3)
        if (modval .eq. 0) then
          call set(retval, ind(1), ind(2), ind(3), value)
        else
           if (modval .eq. 1) then
              call set(retval, ind, value)
           else
              retval%d_data(i,j,k) = value
           endif
        endif
      enddo
    enddo
  enddo
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.create3Int)
end subroutine ArrayOp_create3Int4ikxjsbhe8_mi


! 
! Method:  create4Int[]
! 

recursive subroutine ArrayOp_create4Inten8imvrfau_mi(retval)
  use ArrayTest_ArrayOps
  use sidl_int_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.create4Int.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.create4Int.use)
  implicit none
  type(sidl_int_4d) :: retval ! out

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.create4Int)
  integer (selected_int_kind(9))  :: dim, low(4), up(4), ind(4)
  integer (selected_int_kind(9))  :: value, modval, i, j, k, l, intFunc
  dim = 4
  do i = 1, dim
    low(i) = 0
    if (i .le. 2) then
      up(i) = 3
    else
      up(i) = 2
    endif
  enddo
  call createRow(low, up, retval)
  do i = 0, up(1)
    ind(1) = i
    do j = 0, up(2)
      ind(2) = j
      do k = 0, up(3)
        ind(3) = k
        do l = 0, up(4)
          ind(4) = l
          value = intFunc(dim, ind)
          modval = mod(i+j+k+l, 3)
          if (modval .eq. 0) then
            call set(retval, ind(1), ind(2), ind(3), ind(4), value)
          else
             if (modval .eq. 1) then
                call set(retval, ind, value)
             else
                retval%d_data(i,j,k,l) = value
             endif
          endif
        enddo
      enddo
    enddo
  enddo
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.create4Int)
end subroutine ArrayOp_create4Inten8imvrfau_mi


! 
! Method:  create5Int[]
! 

recursive subroutine ArrayOp_create5Intezrd12u4cz_mi(retval)
  use ArrayTest_ArrayOps
  use sidl_int_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.create5Int.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.create5Int.use)
  implicit none
  type(sidl_int_5d) :: retval ! out

  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.create5Int)
  integer (selected_int_kind(9))  :: dim, low(5), up(5), ind(5)
  integer (selected_int_kind(9))  :: value, modval, i, j, k, l, m, intFunc
  dim = 5
  do i = 1, dim
     low(i) = 0
     if (i .le. 2) then
        up(i) = 3
     else
        up(i) = 2
     endif
  enddo
  call createRow(low, up, retval)
  do i = 0, up(1)
     ind(1) = i
     do j = 0, up(2)
        ind(2) = j
        do k = 0, up(3)
           ind(3) = k
           do l = 0, up(4)
              ind(4) = l
              do m = 0, up(5)
                 ind(5) = m
                 value = intFunc(dim, ind)
                 modval = mod(i+j+k+l+m, 3)
                 if (modval .eq. 0) then
                    call set(retval, ind(1), ind(2), ind(3), ind(4), ind(5), value)
                 else
                    if (modval .eq. 1) then
                       call set(retval, ind, value)
                    else
                       retval%d_data(i,j,k,l,m) = value
                    endif
                 endif
              enddo
           enddo
        enddo
     enddo
  enddo
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.create5Int)
end subroutine ArrayOp_create5Intezrd12u4cz_mi


! 
! Method:  create6Int[]
! 

recursive subroutine ArrayOp_create6Intfsnv4mqvwk_mi(retval)
  use ArrayTest_ArrayOps
  use sidl_int_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.create6Int.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.create6Int.use)
  implicit none
  type(sidl_int_6d) :: retval ! out

  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.create6Int)
  integer (selected_int_kind(9))  :: dim, low(6), up(6), ind(6)
  integer (selected_int_kind(9))  :: value, modval, i, j, k, l, m, n, intFunc
  dim = 6
  do i = 1, dim
     low(i) = 0
     if (i .le. 2) then
        up(i) = 3
     else
        up(i) = 2
     endif
  enddo
  call createRow(low, up, retval)
  do i = 0, up(1)
     ind(1) = i
     do j = 0, up(2)
        ind(2) = j
        do k = 0, up(3)
           ind(3) = k
           do l = 0, up(4)
              ind(4) = l
              do m = 0, up(5)
                 ind(5) = m
                 do n = 0, up(6)
                    ind(6) = n
                    value = intFunc(dim, ind)
                    modval = mod(i+j+k+l+m+n, 3)
                    if (modval .eq. 0) then
                       call set(retval, ind(1), ind(2), ind(3), ind(4), ind(5), ind(6), value)
                    else
                       if (modval .eq. 1) then
                          call set(retval, ind, value)
                       else
                          retval%d_data(i,j,k,l,m,n) = value
                       endif
                    endif
                 enddo
              enddo
           enddo
        enddo
     enddo
  enddo
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.create6Int)
end subroutine ArrayOp_create6Intfsnv4mqvwk_mi


! 
! Method:  create7Int[]
! 

recursive subroutine ArrayOp_create7Intv3xup3rl7f_mi(retval)
  use ArrayTest_ArrayOps
  use sidl_int_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.create7Int.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.create7Int.use)
  implicit none
  type(sidl_int_7d) :: retval ! out

  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.create7Int)
  integer (selected_int_kind(9))  :: dim, low(7), up(7), ind(7)
  integer (selected_int_kind(9))  :: value, modval, i, j, k, l, m, n, o, intFunc
  dim = 7
  do i = 1, dim
     low(i) = 0
     if (i .le. 2) then
        up(i) = 3
     else
        up(i) = 2
     endif
  enddo
  call createRow(low, up, retval)
  do i = 0, up(1)
     ind(1) = i
     do j = 0, up(2)
        ind(2) = j
        do k = 0, up(3)
           ind(3) = k
           do l = 0, up(4)
              ind(4) = l
              do m = 0, up(5)
                 ind(5) = m
                 do n = 0, up(6)
                    ind(6) = n
                    do o = 0, up(7)
                       ind(7) = o
                       value = intFunc(dim, ind)
                       modval = mod(i+j+k+l+m+n+o, 3)
                       if (modval .eq. 0) then
                          call set(retval, ind(1), ind(2), ind(3), ind(4), ind(5), ind(6), ind(7), value)
                       else
                          if (modval .eq. 1) then
                             call set(retval, ind, value)
                          else
                             retval%d_data(i,j,k,l,m,n,o) = value
                          endif
                       endif
                    enddo
                 enddo
              enddo
           enddo
        enddo
     enddo
  enddo
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.create7Int)
end subroutine ArrayOp_create7Intv3xup3rl7f_mi


! 
! Method:  makeBool[]
! 

recursive subroutine ArrayTest_ArrayOps_makeBool_mi(len, a)
  use ArrayTest_ArrayOps
  use sidl_bool_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.makeBool.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.makeBool.use)
  implicit none
  integer (selected_int_kind(9)) :: len ! in
  type(sidl_bool_1d) :: a ! out

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.makeBool)
  call createBool(len, a)
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.makeBool)
end subroutine ArrayTest_ArrayOps_makeBool_mi


! 
! Method:  makeChar[]
! 

recursive subroutine ArrayTest_ArrayOps_makeChar_mi(len, a)
  use ArrayTest_ArrayOps
  use sidl_char_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.makeChar.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.makeChar.use)
  implicit none
  integer (selected_int_kind(9)) :: len ! in
  type(sidl_char_1d) :: a ! out

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.makeChar)
  call createChar(len, a)
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.makeChar)
end subroutine ArrayTest_ArrayOps_makeChar_mi


! 
! Method:  makeInt[]
! 

recursive subroutine ArrayTest_ArrayOps_makeInt_mi(len, a)
  use ArrayTest_ArrayOps
  use sidl_int_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.makeInt.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.makeInt.use)
  implicit none
  integer (selected_int_kind(9)) :: len ! in
  type(sidl_int_1d) :: a ! out

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.makeInt)
  call createInt(len, a)
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.makeInt)
end subroutine ArrayTest_ArrayOps_makeInt_mi


! 
! Method:  makeLong[]
! 

recursive subroutine ArrayTest_ArrayOps_makeLong_mi(len, a)
  use ArrayTest_ArrayOps
  use sidl_long_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.makeLong.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.makeLong.use)
  implicit none
  integer (selected_int_kind(9)) :: len ! in
  type(sidl_long_1d) :: a ! out

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.makeLong)
  call createLong(len, a)
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.makeLong)
end subroutine ArrayTest_ArrayOps_makeLong_mi


! 
! Method:  makeString[]
! 

recursive subroutine ArrayOp_makeStringucptewb9ad_mi(len, a)
  use ArrayTest_ArrayOps
  use sidl_string_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.makeString.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.makeString.use)
  implicit none
  integer (selected_int_kind(9)) :: len ! in
  type(sidl_string_1d) :: a ! out

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.makeString)
  call createString(len, a)
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.makeString)
end subroutine ArrayOp_makeStringucptewb9ad_mi


! 
! Method:  makeDouble[]
! 

recursive subroutine ArrayOp_makeDouble7j4r5nh156_mi(len, a)
  use ArrayTest_ArrayOps
  use sidl_double_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.makeDouble.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.makeDouble.use)
  implicit none
  integer (selected_int_kind(9)) :: len ! in
  type(sidl_double_1d) :: a ! out

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.makeDouble)
  call createDouble(len, a)
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.makeDouble)
end subroutine ArrayOp_makeDouble7j4r5nh156_mi


! 
! Method:  makeFloat[]
! 

recursive subroutine ArrayTest_ArrayOps_makeFloat_mi(len, a)
  use ArrayTest_ArrayOps
  use sidl_float_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.makeFloat.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.makeFloat.use)
  implicit none
  integer (selected_int_kind(9)) :: len ! in
  type(sidl_float_1d) :: a ! out

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.makeFloat)
  call createFloat(len, a)
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.makeFloat)
end subroutine ArrayTest_ArrayOps_makeFloat_mi


! 
! Method:  makeFcomplex[]
! 

recursive subroutine Array_makeFcomplexv0425q5_2o_mi(len, a)
  use ArrayTest_ArrayOps
  use sidl_fcomplex_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.makeFcomplex.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.makeFcomplex.use)
  implicit none
  integer (selected_int_kind(9)) :: len ! in
  type(sidl_fcomplex_1d) :: a ! out

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.makeFcomplex)
  call createFcomplex(len,a)
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.makeFcomplex)
end subroutine Array_makeFcomplexv0425q5_2o_mi


! 
! Method:  makeDcomplex[]
! 

recursive subroutine Array_makeDcomplexp093yr7xy7_mi(len, a)
  use ArrayTest_ArrayOps
  use sidl_dcomplex_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.makeDcomplex.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.makeDcomplex.use)
  implicit none
  integer (selected_int_kind(9)) :: len ! in
  type(sidl_dcomplex_1d) :: a ! out

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.makeDcomplex)
  call createDcomplex(len, a)
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.makeDcomplex)
end subroutine Array_makeDcomplexp093yr7xy7_mi


! 
! Method:  makeInOutBool[]
! 

recursive subroutine Arra_makeInOutBool5jfcbo_ube_mi(a, len)
  use ArrayTest_ArrayOps
  use sidl_bool_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.makeInOutBool.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.makeInOutBool.use)
  implicit none
  type(sidl_bool_1d) :: a ! inout
  integer (selected_int_kind(9)) :: len ! in

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.makeInOutBool)
  if (not_null(a)) then
     call deleteRef(a)
  endif
  call createBool(len, a)
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.makeInOutBool)
end subroutine Arra_makeInOutBool5jfcbo_ube_mi


! 
! Method:  makeInOutChar[]
! 

recursive subroutine Arra_makeInOutChartpjt62yvqd_mi(a, len)
  use ArrayTest_ArrayOps
  use sidl_char_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.makeInOutChar.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.makeInOutChar.use)
  implicit none
  type(sidl_char_1d) :: a ! inout
  integer (selected_int_kind(9)) :: len ! in

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.makeInOutChar)
  if (not_null(a)) then
     call deleteRef(a)
  endif
  call createChar(len, a)
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.makeInOutChar)
end subroutine Arra_makeInOutChartpjt62yvqd_mi


! 
! Method:  makeInOutInt[]
! 

recursive subroutine Array_makeInOutIntyo69yq7z9p_mi(a, len)
  use ArrayTest_ArrayOps
  use sidl_int_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.makeInOutInt.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.makeInOutInt.use)
  implicit none
  type(sidl_int_1d) :: a ! inout
  integer (selected_int_kind(9)) :: len ! in

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.makeInOutInt)
  if (not_null(a)) then
     call deleteRef(a)
  endif
  call createInt(len, a)
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.makeInOutInt)
end subroutine Array_makeInOutIntyo69yq7z9p_mi


! 
! Method:  makeInOutLong[]
! 

recursive subroutine Arra_makeInOutLonghy687ifd8__mi(a, len)
  use ArrayTest_ArrayOps
  use sidl_long_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.makeInOutLong.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.makeInOutLong.use)
  implicit none
  type(sidl_long_1d) :: a ! inout
  integer (selected_int_kind(9)) :: len ! in

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.makeInOutLong)
  if (not_null(a)) then
     call deleteRef(a)
  endif
  call createLong(len, a)
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.makeInOutLong)
end subroutine Arra_makeInOutLonghy687ifd8__mi


! 
! Method:  makeInOutString[]
! 

recursive subroutine Ar_makeInOutString_uzdlcqlye_mi(a, len)
  use ArrayTest_ArrayOps
  use sidl_string_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.makeInOutString.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.makeInOutString.use)
  implicit none
  type(sidl_string_1d) :: a ! inout
  integer (selected_int_kind(9)) :: len ! in

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.makeInOutString)
  if (not_null(a)) then
     call deleteRef(a)
  endif
  call createString(len, a)
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.makeInOutString)
end subroutine Ar_makeInOutString_uzdlcqlye_mi


! 
! Method:  makeInOutDouble[]
! 

recursive subroutine Ar_makeInOutDouble045y36r_il_mi(a, len)
  use ArrayTest_ArrayOps
  use sidl_double_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.makeInOutDouble.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.makeInOutDouble.use)
  implicit none
  type(sidl_double_1d) :: a ! inout
  integer (selected_int_kind(9)) :: len ! in

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.makeInOutDouble)
  if (not_null(a)) then
     call deleteRef(a)
  endif
  call createDouble(len, a)
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.makeInOutDouble)
end subroutine Ar_makeInOutDouble045y36r_il_mi


! 
! Method:  makeInOutFloat[]
! 

recursive subroutine Arr_makeInOutFloati3hp8_tmhu_mi(a, len)
  use ArrayTest_ArrayOps
  use sidl_float_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.makeInOutFloat.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.makeInOutFloat.use)
  implicit none
  type(sidl_float_1d) :: a ! inout
  integer (selected_int_kind(9)) :: len ! in

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.makeInOutFloat)
  if (not_null(a)) then
     call deleteRef(a)
  endif
  call createFloat(len, a)
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.makeInOutFloat)
end subroutine Arr_makeInOutFloati3hp8_tmhu_mi


! 
! Method:  makeInOutDcomplex[]
! 

recursive subroutine makeInOutDcomplexuq8uzvc62wd_mi(a, len)
  use ArrayTest_ArrayOps
  use sidl_dcomplex_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.makeInOutDcomplex.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.makeInOutDcomplex.use)
  implicit none
  type(sidl_dcomplex_1d) :: a ! inout
  integer (selected_int_kind(9)) :: len ! in

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.makeInOutDcomplex)
  if (not_null(a)) then
     call deleteRef(a)
  endif
  call createDcomplex(len, a)
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.makeInOutDcomplex)
end subroutine makeInOutDcomplexuq8uzvc62wd_mi


! 
! Method:  makeInOutFcomplex[]
! 

recursive subroutine makeInOutFcomplexnnmei919ckr_mi(a, len)
  use ArrayTest_ArrayOps
  use sidl_fcomplex_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.makeInOutFcomplex.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.makeInOutFcomplex.use)
  implicit none
  type(sidl_fcomplex_1d) :: a ! inout
  integer (selected_int_kind(9)) :: len ! in

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.makeInOutFcomplex)
  if (not_null(a)) then
     call deleteRef(a)
  endif
  call createFcomplex(len, a)
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.makeInOutFcomplex)
end subroutine makeInOutFcomplexnnmei919ckr_mi


! 
! Method:  makeInOut2Int[]
! 

recursive subroutine Arra_makeInOut2Intar5f7eylp9_mi(a, d1, d2)
  use ArrayTest_ArrayOps
  use sidl_int_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.makeInOut2Int.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.makeInOut2Int.use)
  implicit none
  type(sidl_int_2d) :: a ! inout
  integer (selected_int_kind(9)) :: d1 ! in
  integer (selected_int_kind(9)) :: d2 ! in

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.makeInOut2Int)
  if (not_null(a)) then
     call deleteRef(a)
  endif
  call create2Int(d1, d2, a)
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.makeInOut2Int)
end subroutine Arra_makeInOut2Intar5f7eylp9_mi


! 
! Method:  makeInOut2Double[]
! 

recursive subroutine A_makeInOut2Doublebgpvhq3prh_mi(a, d1, d2)
  use ArrayTest_ArrayOps
  use sidl_double_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.makeInOut2Double.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.makeInOut2Double.use)
  implicit none
  type(sidl_double_2d) :: a ! inout
  integer (selected_int_kind(9)) :: d1 ! in
  integer (selected_int_kind(9)) :: d2 ! in

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.makeInOut2Double)
  if (not_null(a)) then
     call deleteRef(a)
  endif
  call create2Double(d1, d2, a)
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.makeInOut2Double)
end subroutine A_makeInOut2Doublebgpvhq3prh_mi


! 
! Method:  makeInOut2Float[]
! 

recursive subroutine Ar_makeInOut2Floatq670n4ukao_mi(a, d1, d2)
  use ArrayTest_ArrayOps
  use sidl_float_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.makeInOut2Float.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.makeInOut2Float.use)
  implicit none
  type(sidl_float_2d) :: a ! inout
  integer (selected_int_kind(9)) :: d1 ! in
  integer (selected_int_kind(9)) :: d2 ! in

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.makeInOut2Float)
  if (not_null(a)) then
     call deleteRef(a)
  endif
  call create2Float(d1, d2, a)
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.makeInOut2Float)
end subroutine Ar_makeInOut2Floatq670n4ukao_mi


! 
! Method:  makeInOut2Dcomplex[]
! 

recursive subroutine makeInOut2Dcomplexckhu3osbep_mi(a, d1, d2)
  use ArrayTest_ArrayOps
  use sidl_dcomplex_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.makeInOut2Dcomplex.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.makeInOut2Dcomplex.use)
  implicit none
  type(sidl_dcomplex_2d) :: a ! inout
  integer (selected_int_kind(9)) :: d1 ! in
  integer (selected_int_kind(9)) :: d2 ! in

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.makeInOut2Dcomplex)
  if (not_null(a)) then
     call deleteRef(a)
  endif
  call create2Dcomplex(d1, d2, a)
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.makeInOut2Dcomplex)
end subroutine makeInOut2Dcomplexckhu3osbep_mi


! 
! Method:  makeInOut2Fcomplex[]
! 

recursive subroutine makeInOut2Fcomplexxh7zrwg3ge_mi(a, d1, d2)
  use ArrayTest_ArrayOps
  use sidl_fcomplex_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.makeInOut2Fcomplex.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.makeInOut2Fcomplex.use)
  implicit none
  type(sidl_fcomplex_2d) :: a ! inout
  integer (selected_int_kind(9)) :: d1 ! in
  integer (selected_int_kind(9)) :: d2 ! in

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.makeInOut2Fcomplex)
  if (not_null(a)) then
     call deleteRef(a)
  endif
  call create2Fcomplex(d1, d2, a)
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.makeInOut2Fcomplex)
end subroutine makeInOut2Fcomplexxh7zrwg3ge_mi


! 
! Method:  makeInOut3Int[]
! 

recursive subroutine Arra_makeInOut3Intxzlzgrsum3_mi(a)
  use ArrayTest_ArrayOps
  use sidl_int_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.makeInOut3Int.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.makeInOut3Int.use)
  implicit none
  type(sidl_int_3d) :: a ! inout

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.makeInOut3Int)
  if (not_null(a)) then
     call deleteRef(a)
  endif
  call create3Int(a)
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.makeInOut3Int)
end subroutine Arra_makeInOut3Intxzlzgrsum3_mi


! 
! Method:  makeInOut4Int[]
! 

recursive subroutine Arra_makeInOut4Intiw_x5vq0ti_mi(a)
  use ArrayTest_ArrayOps
  use sidl_int_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.makeInOut4Int.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.makeInOut4Int.use)
  implicit none
  type(sidl_int_4d) :: a ! inout

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.makeInOut4Int)
  if (not_null(a)) then
     call deleteRef(a)
  endif
  call create4Int(a)
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.makeInOut4Int)
end subroutine Arra_makeInOut4Intiw_x5vq0ti_mi


! 
! Method:  makeInOut5Int[]
! 

recursive subroutine Arra_makeInOut5Intz0fj9a5vg8_mi(a)
  use ArrayTest_ArrayOps
  use sidl_int_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.makeInOut5Int.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.makeInOut5Int.use)
  implicit none
  type(sidl_int_5d) :: a ! inout

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.makeInOut5Int)
  if (not_null(a)) then
     call deleteRef(a)
  endif
  call create5Int(a)
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.makeInOut5Int)
end subroutine Arra_makeInOut5Intz0fj9a5vg8_mi


! 
! Method:  makeInOut6Int[]
! 

recursive subroutine Arra_makeInOut6Intxec69frccs_mi(a)
  use ArrayTest_ArrayOps
  use sidl_int_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.makeInOut6Int.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.makeInOut6Int.use)
  implicit none
  type(sidl_int_6d) :: a ! inout

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.makeInOut6Int)
  if (not_null(a)) then
     call deleteRef(a)
  endif
  call create6Int(a)
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.makeInOut6Int)
end subroutine Arra_makeInOut6Intxec69frccs_mi


! 
! Method:  makeInOut7Int[]
! 

recursive subroutine Arra_makeInOut7Int6u8dj9s6ad_mi(a)
  use ArrayTest_ArrayOps
  use sidl_int_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.makeInOut7Int.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.makeInOut7Int.use)
  implicit none
  type(sidl_int_7d) :: a ! inout

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.makeInOut7Int)
  if (not_null(a)) then
     call deleteRef(a)
  endif
  call create7Int(a)
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.makeInOut7Int)
end subroutine Arra_makeInOut7Int6u8dj9s6ad_mi


! 
! Return as out parameters the type and dimension of the 
! array passed in. If a is NULL, dimen == type == 0 on exit.
! The contents of the array have the default values for a 
! newly created array.
! 

recursive subroutine Array_checkGenericd1y8aqvsz6_mi(a, dmn, tp)
  use ArrayTest_ArrayOps
  use sidl_array_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.checkGeneric.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.checkGeneric.use)
  implicit none
  type(sidl__array) :: a ! in
  integer (selected_int_kind(9)) :: dmn ! out
  integer (selected_int_kind(9)) :: tp ! out

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.checkGeneric)
! Insert the implementation here...

  if (not_null(a)) then
     dmn = dimen(a)
     tp = type(a)
  else 
     dmn = 0
     tp = 0
  end if
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.checkGeneric)
end subroutine Array_checkGenericd1y8aqvsz6_mi


! 
! Create an array of the type and dimension specified and
! return it. A type of 0 causes a NULL array to be returned.
! 

recursive subroutine Arra_createGenericza7tz4ksso_mi(dmn, tp, retval)
  use ArrayTest_ArrayOps
  use sidl_array_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.createGeneric.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.createGeneric.use)
  implicit none
  integer (selected_int_kind(9)) :: dmn ! in
  integer (selected_int_kind(9)) :: tp ! in
  type(sidl__array) :: retval ! out

  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.createGeneric)
  ! Insert the implementation here...
  integer (selected_int_kind(9)) :: lw(7), up(7) 
  integer (selected_int_kind(9)) :: i
  type(sidl_bool_2d) :: x
  do i=1,7
     lw(i)=0
     up(i)=2
  enddo
  !  call createRow(lw,up,x)
  !  call cast(x,retval)
  call createarraybytype(tp, dmn, lw, up, retval);
  
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.createGeneric)
end subroutine Arra_createGenericza7tz4ksso_mi


! 
! Testing passing generic arrays using every possible mode.
! The returned array is a copy of inArg, so if inArg != NULL,
! the return value should != NULL. outArg is also a copy of
! inArg.
! If inOutArg is NULL on entry, a 2-D array of int that should
! pass check2Int is returned.
! If inOutArg is not NULL on entry and its dimension is even,
! it is returned unchanged; otherwise, NULL is returned.
! 

recursive subroutine ArrayO_passGenericwdjmxoh8x1_mi(inArg, inOutArg, outArg,  &
  retval)
  use ArrayTest_ArrayOps
  use sidl_array_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.passGeneric.use)
  use sidl_int_array
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.passGeneric.use)
  implicit none
  type(sidl__array) :: inArg ! in
  type(sidl__array) :: inOutArg ! inout
  type(sidl__array) :: outArg ! out
  type(sidl__array) :: retval ! out

  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.passGeneric)
  ! Insert the implementation here...

  type(sidl_int_2d) :: i2array
  integer (selected_int_kind(9)) :: lw(7), up(7), i, tp, dmn, outdimen

  tp = type(inArg) 
  if (not_null(inArg)) then    
     dmn = 0
     dmn = dimen(inArg);
     do i=1, dmn+1 
        lw(i) = lower(inArg, i-1)
        up(i) = upper(inArg, i-1)
     enddo
  end if
  
  call createarraybytype(tp, dmn, lw, up, retval);
  call createarraybytype(tp, dmn, lw, up, outArg);
  call addref(inarg)
  call set_null(retval)
  call copyarraybytype(inArg, lw, up, retval);
  call set_null(outArg)
  call copyarraybytype(inArg, lw, up, outArg);
  if (not_null(inOutArg)) then
     outdimen = dimen(inOutArg)
     if (mod(outdimen, 2) .eq. 1) then
        call deleteref(inOutArg);
        call set_null(inOutArg);
     end if
  else 
     call create2Int(3, 3, i2array);
     call cast(i2array, inOutArg);
  end if
  
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.passGeneric)
end subroutine ArrayO_passGenericwdjmxoh8x1_mi


! 
! Method:  initRarray1Int[]
! 

recursive subroutine Arr_initRarray1Intr5gikmh2h0_mi(a, n)
  use ArrayTest_ArrayOps
  use sidl_int_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.initRarray1Int.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.initRarray1Int.use)
  implicit none
  integer (selected_int_kind(9)) :: n ! in
  integer (selected_int_kind(9)), dimension(0:n-1) :: a ! inout

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.initRarray1Int)
  integer (selected_int_kind(9)) :: value, i
  integer (selected_int_kind(18)) :: nextprime, tmp
  if (n .ge. 0) then
     value = 0
     do i = 0, n - 1
        tmp = value
        value = nextprime(tmp)
        a(i) = value
     enddo
  endif
! Insert the implementation here...
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.initRarray1Int)
end subroutine Arr_initRarray1Intr5gikmh2h0_mi


! 
! Method:  initRarray3Int[]
! 

recursive subroutine Arr_initRarray3Intjwja9lszfc_mi(a, n, m, o)
  use ArrayTest_ArrayOps
  use sidl_int_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.initRarray3Int.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.initRarray3Int.use)
  implicit none
  integer (selected_int_kind(9)) :: n ! in
  integer (selected_int_kind(9)) :: m ! in
  integer (selected_int_kind(9)) :: o ! in
  integer (selected_int_kind(9)), dimension(0:n-1, 0:m-1, 0:o-1) :: a ! inout

  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.initRarray3Int)

  integer (selected_int_kind(9)) :: ind(3)
  integer (selected_int_kind(9)) :: value, modval, i, j, k, intFunc

  do i = 0, n-1
     ind(1) = i
     do j = 0, m-1
        ind(2) = j
        do k = 0, o-1
           ind(3) = k
           value = intFunc(3, ind)
           a(i,j,k)=value
        enddo
     enddo
  enddo
  ! Insert the implementation here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.initRarray3Int)
end subroutine Arr_initRarray3Intjwja9lszfc_mi


! 
! Method:  initRarray7Int[]
! 

recursive subroutine Arr_initRarray7Intkao7vazq6m_mi(a, n, m, o, p, q, r, s)
  use ArrayTest_ArrayOps
  use sidl_int_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.initRarray7Int.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.initRarray7Int.use)
  implicit none
  integer (selected_int_kind(9)) :: n ! in
  integer (selected_int_kind(9)) :: m ! in
  integer (selected_int_kind(9)) :: o ! in
  integer (selected_int_kind(9)) :: p ! in
  integer (selected_int_kind(9)) :: q ! in
  integer (selected_int_kind(9)) :: r ! in
  integer (selected_int_kind(9)) :: s ! in
  integer (selected_int_kind(9)), dimension(0:n-1, 0:m-1, 0:o-1, 0:p-1, 0:q-1, &
    0:r-1, 0:s-1) :: a ! inout

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.initRarray7Int)
  integer (selected_int_kind(9)) :: ind(7)
  integer (selected_int_kind(9)) :: value, modval, d, e, f, g, h, i, j, intFunc
  do d = 0, n-1
     ind(1) = d
     do e = 0, m-1
        ind(2) = e
        do f = 0, o-1
           ind(3) = f
           do g = 0, p-1
              ind(4) = g
              do h = 0, q-1
                 ind(5) = h
                 do i = 0, r-1
                    ind(6) = i
                    do j = 0, s-1
                       ind(7) = j
                       value = intFunc(7, ind)
                       a(d,e,f,g,h,i,j) = value
                    enddo
                 enddo
              enddo
           enddo
        enddo
     enddo
  enddo
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.initRarray7Int)
end subroutine Arr_initRarray7Intkao7vazq6m_mi


! 
! Method:  initRarray1Double[]
! 

recursive subroutine initRarray1Doublen5sxxzsz_c8_mi(a, n)
  use ArrayTest_ArrayOps
  use sidl_double_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.initRarray1Double.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.initRarray1Double.use)
  implicit none
  integer (selected_int_kind(9)) :: n ! in
  real (selected_real_kind(15, 307)), dimension(0:n-1) :: a ! inout

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.initRarray1Double)

  integer (selected_int_kind(9)) :: i
  real (selected_real_kind(15, 307)) :: value

  if (n .ge. 0) then
     do i = 0, n - 1
        value = 2.0d0 ** (-i*1.0)
        a(i) = value
     enddo
  endif
! Insert the implementation here...
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.initRarray1Double)
end subroutine initRarray1Doublen5sxxzsz_c8_mi


! 
! Method:  initRarray1Dcomplex[]
! 

recursive subroutine initRarray1Dcomplevs7rtjmqbl_mi(a, n)
  use ArrayTest_ArrayOps
  use sidl_dcomplex_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.initRarray1Dcomplex.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.initRarray1Dcomplex.use)
  implicit none
  integer (selected_int_kind(9)) :: n ! in
  complex (selected_real_kind(15, 307)), dimension(0:n-1) :: a ! inout

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.initRarray1Dcomplex)
 
  integer (selected_int_kind(9)) :: i
  complex (selected_real_kind(15, 307)) :: value

  if (n .ge. 0) then
     do i = 0, n - 1
        value = cmplx(2.0d0 ** i, 2.0d0 ** (-i))
        a(i) = value
     enddo
  endif
  
! Insert the implementation here...
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.initRarray1Dcomplex)
end subroutine initRarray1Dcomplevs7rtjmqbl_mi


! 
! Method:  checkRarray1Int[]
! 

recursive subroutine Ar_checkRarray1Int9vwqpxnxpn_mi(a, n, retval)
  use ArrayTest_ArrayOps
  use sidl_int_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.checkRarray1Int.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.checkRarray1Int.use)
  implicit none
  integer (selected_int_kind(9)) :: n ! in
  logical :: retval ! out
  integer (selected_int_kind(9)), dimension(0:n-1) :: a ! in

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.checkRarray1Int)
  integer (selected_int_kind(9)) :: i, prime
  integer (selected_int_kind(18)) :: nextprime, tmp

  retval = .false.
  prime = 0
  do i = 0, n-1
     tmp = prime
     prime = nextprime(tmp)
     if (a(i) .ne. prime) then
        retval = .false.
        return
     endif
  enddo
  retval = .true.
! Insert the implementation here...
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.checkRarray1Int)
end subroutine Ar_checkRarray1Int9vwqpxnxpn_mi


! 
! Method:  checkRarray3Int[]
! 

recursive subroutine Ar_checkRarray3Inteky23o1ltn_mi(a, n, m, o, retval)
  use ArrayTest_ArrayOps
  use sidl_int_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.checkRarray3Int.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.checkRarray3Int.use)
  implicit none
  integer (selected_int_kind(9)) :: n ! in
  integer (selected_int_kind(9)) :: m ! in
  integer (selected_int_kind(9)) :: o ! in
  logical :: retval ! out
  integer (selected_int_kind(9)), dimension(0:n-1, 0:m-1, 0:o-1) :: a ! in

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.checkRarray3Int)
  integer (selected_int_kind(9)) :: i, j, k, expectedvalue, ind(3)
  integer (selected_int_kind(9)) :: intFunc
  retval = .false.
  
  do i = 0, n-1
     ind(1) = i
     do j = 0, m-1
        ind(2) = j
        do k = 0, o-1
           ind(3) = k
           expectedvalue = intFunc(3, ind)
           if (a(i,j,k) .ne. expectedvalue) then
              return
           endif
        enddo
     enddo
  enddo
  retval = .true.
! Insert the implementation here...
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.checkRarray3Int)
end subroutine Ar_checkRarray3Inteky23o1ltn_mi


! 
! Method:  checkRarray7Int[]
! 

recursive subroutine Ar_checkRarray7Int1glebxan93_mi(a, n, m, o, p, q, r, s,   &
  retval)
  use ArrayTest_ArrayOps
  use sidl_int_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.checkRarray7Int.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.checkRarray7Int.use)
  implicit none
  integer (selected_int_kind(9)) :: n ! in
  integer (selected_int_kind(9)) :: m ! in
  integer (selected_int_kind(9)) :: o ! in
  integer (selected_int_kind(9)) :: p ! in
  integer (selected_int_kind(9)) :: q ! in
  integer (selected_int_kind(9)) :: r ! in
  integer (selected_int_kind(9)) :: s ! in
  logical :: retval ! out
  integer (selected_int_kind(9)), dimension(0:n-1, 0:m-1, 0:o-1, 0:p-1, 0:q-1, &
    0:r-1, 0:s-1) :: a ! in

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.checkRarray7Int)
  integer (selected_int_kind(9)) ::  d,e,f,g,h,i,j
  integer (selected_int_kind(9)) :: value
  integer (selected_int_kind(9)) :: ind(7), alow(7), aup(7)
  integer (selected_int_kind(9)) :: intFunc
  retval = .false.
  
  do d = 0, n-1
     ind(1) = d
     do e = 0, m-1
        ind(2) = e
        do f = 0, o-1
           ind(3) = f
           do g = 0, p-1
              ind(4) = g
              do h = 0, q-1
                 ind(5) = h
                 do i = 0, r-1
                    ind(6) = i
                    do j = 0, s-1
                       ind(7) = j
                       value=intFunc(7,ind)
                       if (value .ne. a(d,e,f,g,h,i,j)) then
                          return
                       endif
                    enddo
                 enddo
              enddo
           enddo
        enddo
     enddo
  enddo
  retval = .true.
! Insert the implementation here...
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.checkRarray7Int)
end subroutine Ar_checkRarray7Int1glebxan93_mi


! 
! Method:  checkRarray1Double[]
! 

recursive subroutine checkRarray1Doubleznjn8hgixv_mi(a, n, retval)
  use ArrayTest_ArrayOps
  use sidl_double_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.checkRarray1Double.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.checkRarray1Double.use)
  implicit none
  integer (selected_int_kind(9)) :: n ! in
  logical :: retval ! out
  real (selected_real_kind(15, 307)), dimension(0:n-1) :: a ! in

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.checkRarray1Double)

  real (selected_real_kind(15, 307)) :: expectedvalue
  integer (selected_int_kind(9)) ::  i
  retval = .false.
  
  do i = 0, n - 1
     expectedvalue = (2.0d0 ** (-i))
     if (a(i) .ne. expectedvalue) then
        return
     endif
  enddo
  retval = .true.
  
! Insert the implementation here...
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.checkRarray1Double)
end subroutine checkRarray1Doubleznjn8hgixv_mi


! 
! Method:  checkRarray1Dcomplex[]
! 

recursive subroutine checkRarray1Dcompljc_853ps4k_mi(a, n, retval)
  use ArrayTest_ArrayOps
  use sidl_dcomplex_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.checkRarray1Dcomplex.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.checkRarray1Dcomplex.use)
  implicit none
  integer (selected_int_kind(9)) :: n ! in
  logical :: retval ! out
  complex (selected_real_kind(15, 307)), dimension(0:n-1) :: a ! in

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.checkRarray1Dcomplex)

  complex (selected_real_kind(15, 307)) :: expectedvalue
  integer (selected_int_kind(9)) :: i
  retval = .false.
  do i = 0, n - 1
     expectedvalue = cmplx(2.0d0 ** i, 2.0d0 ** (-i))
     if (a(i) .ne. expectedvalue) then
        return
     endif
  enddo
  retval = .true.
! Insert the implementation here...
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.checkRarray1Dcomplex)
end subroutine checkRarray1Dcompljc_853ps4k_mi


! 
! Method:  matrixMultiply[]
! 

recursive subroutine Arr_matrixMultiply419jg3a5yu_mi(a, b, res, n, m, o)
  use ArrayTest_ArrayOps
  use sidl_int_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.matrixMultiply.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.matrixMultiply.use)
  implicit none
  integer (selected_int_kind(9)) :: n ! in
  integer (selected_int_kind(9)) :: m ! in
  integer (selected_int_kind(9)) :: o ! in
  integer (selected_int_kind(9)), dimension(0:n-1, 0:m-1) :: a ! in
  integer (selected_int_kind(9)), dimension(0:m-1, 0:o-1) :: b ! in
  integer (selected_int_kind(9)), dimension(0:n-1, 0:o-1) :: res ! inout

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.matrixMultiply)
! Insert the implementation here...
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.matrixMultiply)
end subroutine Arr_matrixMultiply419jg3a5yu_mi


! 
! Method:  checkMatrixMultiply[]
! 

recursive subroutine checkMatrixMultiplpuxdl07ngd_mi(a, b, res, n, m, o,       &
  retval)
  use ArrayTest_ArrayOps
  use sidl_int_array
  use ArrayTest_ArrayOps_impl
  ! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.checkMatrixMultiply.use)
  ! Insert use statements here...
  ! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.checkMatrixMultiply.use)
  implicit none
  integer (selected_int_kind(9)) :: n ! in
  integer (selected_int_kind(9)) :: m ! in
  integer (selected_int_kind(9)) :: o ! in
  logical :: retval ! out
  integer (selected_int_kind(9)), dimension(0:n-1, 0:m-1) :: a ! in
  integer (selected_int_kind(9)), dimension(0:m-1, 0:o-1) :: b ! in
  integer (selected_int_kind(9)), dimension(0:n-1, 0:o-1) :: res ! in

! DO-NOT-DELETE splicer.begin(ArrayTest.ArrayOps.checkMatrixMultiply)
! Insert the implementation here...
! DO-NOT-DELETE splicer.end(ArrayTest.ArrayOps.checkMatrixMultiply)
end subroutine checkMatrixMultiplpuxdl07ngd_mi


! DO-NOT-DELETE splicer.begin(_miscellaneous_code_end)
! Insert extra code here...
! DO-NOT-DELETE splicer.end(_miscellaneous_code_end)
