MODULE F2x_Emulation
      USE Precision
      USE ISO_C_BINDING
      IMPLICIT NONE
      PRIVATE
      PUBLIC :: AssignArrayPointer, ReshapeArrayPointer
      TYPE, PUBLIC :: Procedure_Pointer
         INTEGER (KIND=C_ADDRESS) :: c_pointer = C_NULL_PTR
         INTEGER (KIND=C_ADDRESS), POINTER :: f_pointer => NULL ()
      END TYPE
      INTERFACE AssignArrayPointer
         MODULE PROCEDURE AssignArrayPointer_i_sp1
         MODULE PROCEDURE AssignArrayPointer_i_dp1
         MODULE PROCEDURE AssignArrayPointer_r_sp1
         MODULE PROCEDURE AssignArrayPointer_r_dp1
         MODULE PROCEDURE AssignArrayPointer_l_word1
         MODULE PROCEDURE AssignArrayPointer_i_sp2
         MODULE PROCEDURE AssignArrayPointer_i_dp2
         MODULE PROCEDURE AssignArrayPointer_r_sp2
         MODULE PROCEDURE AssignArrayPointer_r_dp2
         MODULE PROCEDURE AssignArrayPointer_l_word2
         MODULE PROCEDURE AssignArrayPointer_i_sp3
         MODULE PROCEDURE AssignArrayPointer_i_dp3
         MODULE PROCEDURE AssignArrayPointer_r_sp3
         MODULE PROCEDURE AssignArrayPointer_r_dp3
         MODULE PROCEDURE AssignArrayPointer_l_word3
         MODULE PROCEDURE AssignArrayPointer_i_sp4
         MODULE PROCEDURE AssignArrayPointer_i_dp4
         MODULE PROCEDURE AssignArrayPointer_r_sp4
         MODULE PROCEDURE AssignArrayPointer_r_dp4
         MODULE PROCEDURE AssignArrayPointer_l_word4
         MODULE PROCEDURE AssignArrayPointer_i_sp5
         MODULE PROCEDURE AssignArrayPointer_i_dp5
         MODULE PROCEDURE AssignArrayPointer_r_sp5
         MODULE PROCEDURE AssignArrayPointer_r_dp5
         MODULE PROCEDURE AssignArrayPointer_l_word5
      END INTERFACE
      INTERFACE ReshapeArrayPointer
         MODULE PROCEDURE ReshapeArrayPointer_i_sp1
         MODULE PROCEDURE ReshapeArrayPointer_i_dp1
         MODULE PROCEDURE ReshapeArrayPointer_r_sp1
         MODULE PROCEDURE ReshapeArrayPointer_r_dp1
         MODULE PROCEDURE ReshapeArrayPointer_l_word1
         MODULE PROCEDURE ReshapeArrayPointer_i_sp2
         MODULE PROCEDURE ReshapeArrayPointer_i_dp2
         MODULE PROCEDURE ReshapeArrayPointer_r_sp2
         MODULE PROCEDURE ReshapeArrayPointer_r_dp2
         MODULE PROCEDURE ReshapeArrayPointer_l_word2
         MODULE PROCEDURE ReshapeArrayPointer_i_sp3
         MODULE PROCEDURE ReshapeArrayPointer_i_dp3
         MODULE PROCEDURE ReshapeArrayPointer_r_sp3
         MODULE PROCEDURE ReshapeArrayPointer_r_dp3
         MODULE PROCEDURE ReshapeArrayPointer_l_word3
         MODULE PROCEDURE ReshapeArrayPointer_i_sp4
         MODULE PROCEDURE ReshapeArrayPointer_i_dp4
         MODULE PROCEDURE ReshapeArrayPointer_r_sp4
         MODULE PROCEDURE ReshapeArrayPointer_r_dp4
         MODULE PROCEDURE ReshapeArrayPointer_l_word4
         MODULE PROCEDURE ReshapeArrayPointer_i_sp5
         MODULE PROCEDURE ReshapeArrayPointer_i_dp5
         MODULE PROCEDURE ReshapeArrayPointer_r_sp5
         MODULE PROCEDURE ReshapeArrayPointer_r_dp5
         MODULE PROCEDURE ReshapeArrayPointer_l_word5
      END INTERFACE
CONTAINS
      SUBROUTINE ReshapeArrayPointer_i_sp1 (array_pointer, array_target, lower_bounds, upper_bounds)
         INTEGER (KIND=i_wp), DIMENSION (1), INTENT (IN) :: lower_bounds, upper_bounds
         INTEGER (KIND=i_sp), DIMENSION (:), POINTER :: array_pointer
         INTEGER (KIND=i_sp), DIMENSION (:), INTENT (IN), TARGET :: array_target
         INTEGER (KIND=C_ADDRESS) :: base_address
         INTEGER (KIND=i_wp), DIMENSION (1) :: pointer_shape
         INTEGER (KIND=C_INT), DIMENSION (1) :: strides
         pointer_shape = upper_bounds - lower_bounds + 1
         IF (Int(SIZE(array_target), KIND=i_wp) < PRODUCT(pointer_shape)) THEN
            NULLIFY (array_pointer)
            RETURN
         END IF
         strides = 1
         IF (Int(SIZE(array_target), KIND=i_wp) > 1) THEN
            strides (1) = C_STRIDE (array_target(1), array_target(2))
         END IF
         pointer_shape = pointer_shape * (strides)
         base_address = C_LOC (array_target)
         CALL C_F_POINTER (CPTR=base_address, FPTR=array_pointer, SHAPE=pointer_shape)
         CALL AssignArrayPointer (array_pointer=array_pointer, array_target=array_pointer(::strides(1)), &
        & lower_bounds=lower_bounds)
      END SUBROUTINE
      SUBROUTINE ReshapeArrayPointer_i_dp1 (array_pointer, array_target, lower_bounds, upper_bounds)
         INTEGER (KIND=i_wp), DIMENSION (1), INTENT (IN) :: lower_bounds, upper_bounds
         INTEGER (KIND=i_dp), DIMENSION (:), POINTER :: array_pointer
         INTEGER (KIND=i_dp), DIMENSION (:), INTENT (IN), TARGET :: array_target
         INTEGER (KIND=C_ADDRESS) :: base_address
         INTEGER (KIND=i_wp), DIMENSION (1) :: pointer_shape
         INTEGER (KIND=C_INT), DIMENSION (1) :: strides
         pointer_shape = upper_bounds - lower_bounds + 1
         IF (Int(SIZE(array_target), KIND=i_wp) < PRODUCT(pointer_shape)) THEN
            NULLIFY (array_pointer)
            RETURN
         END IF
         strides = 1
         IF (Int(SIZE(array_target), KIND=i_wp) > 1) THEN
            strides (1) = C_STRIDE (array_target(1), array_target(2))
         END IF
         pointer_shape = pointer_shape * (strides)
         base_address = C_LOC (array_target)
         CALL C_F_POINTER (CPTR=base_address, FPTR=array_pointer, SHAPE=pointer_shape)
         CALL AssignArrayPointer (array_pointer=array_pointer, array_target=array_pointer(::strides(1)), &
        & lower_bounds=lower_bounds)
      END SUBROUTINE
      SUBROUTINE ReshapeArrayPointer_r_sp1 (array_pointer, array_target, lower_bounds, upper_bounds)
         INTEGER (KIND=i_wp), DIMENSION (1), INTENT (IN) :: lower_bounds, upper_bounds
         REAL (KIND=r_sp), DIMENSION (:), POINTER :: array_pointer
         REAL (KIND=r_sp), DIMENSION (:), INTENT (IN), TARGET :: array_target
         INTEGER (KIND=C_ADDRESS) :: base_address
         INTEGER (KIND=i_wp), DIMENSION (1) :: pointer_shape
         INTEGER (KIND=C_INT), DIMENSION (1) :: strides
         pointer_shape = upper_bounds - lower_bounds + 1
         IF (Int(SIZE(array_target), KIND=i_wp) < PRODUCT(pointer_shape)) THEN
            NULLIFY (array_pointer)
            RETURN
         END IF
         strides = 1
         IF (Int(SIZE(array_target), KIND=i_wp) > 1) THEN
            strides (1) = C_STRIDE (array_target(1), array_target(2))
         END IF
         pointer_shape = pointer_shape * (strides)
         base_address = C_LOC (array_target)
         CALL C_F_POINTER (CPTR=base_address, FPTR=array_pointer, SHAPE=pointer_shape)
         CALL AssignArrayPointer (array_pointer=array_pointer, array_target=array_pointer(::strides(1)), &
        & lower_bounds=lower_bounds)
      END SUBROUTINE
      SUBROUTINE ReshapeArrayPointer_r_dp1 (array_pointer, array_target, lower_bounds, upper_bounds)
         INTEGER (KIND=i_wp), DIMENSION (1), INTENT (IN) :: lower_bounds, upper_bounds
         REAL (KIND=r_dp), DIMENSION (:), POINTER :: array_pointer
         REAL (KIND=r_dp), DIMENSION (:), INTENT (IN), TARGET :: array_target
         INTEGER (KIND=C_ADDRESS) :: base_address
         INTEGER (KIND=i_wp), DIMENSION (1) :: pointer_shape
         INTEGER (KIND=C_INT), DIMENSION (1) :: strides
         pointer_shape = upper_bounds - lower_bounds + 1
         IF (Int(SIZE(array_target), KIND=i_wp) < PRODUCT(pointer_shape)) THEN
            NULLIFY (array_pointer)
            RETURN
         END IF
         strides = 1
         IF (Int(SIZE(array_target), KIND=i_wp) > 1) THEN
            strides (1) = C_STRIDE (array_target(1), array_target(2))
         END IF
         pointer_shape = pointer_shape * (strides)
         base_address = C_LOC (array_target)
         CALL C_F_POINTER (CPTR=base_address, FPTR=array_pointer, SHAPE=pointer_shape)
         CALL AssignArrayPointer (array_pointer=array_pointer, array_target=array_pointer(::strides(1)), &
        & lower_bounds=lower_bounds)
      END SUBROUTINE
      SUBROUTINE ReshapeArrayPointer_l_word1 (array_pointer, array_target, lower_bounds, upper_bounds)
         INTEGER (KIND=i_wp), DIMENSION (1), INTENT (IN) :: lower_bounds, upper_bounds
         LOGICAL (KIND=l_word), DIMENSION (:), POINTER :: array_pointer
         LOGICAL (KIND=l_word), DIMENSION (:), INTENT (IN), TARGET :: array_target
         INTEGER (KIND=C_ADDRESS) :: base_address
         INTEGER (KIND=i_wp), DIMENSION (1) :: pointer_shape
         INTEGER (KIND=C_INT), DIMENSION (1) :: strides
         pointer_shape = upper_bounds - lower_bounds + 1
         IF (Int(SIZE(array_target), KIND=i_wp) < PRODUCT(pointer_shape)) THEN
            NULLIFY (array_pointer)
            RETURN
         END IF
         strides = 1
         IF (Int(SIZE(array_target), KIND=i_wp) > 1) THEN
            strides (1) = C_STRIDE (array_target(1), array_target(2))
         END IF
         pointer_shape = pointer_shape * (strides)
         base_address = C_LOC (array_target)
         CALL C_F_POINTER (CPTR=base_address, FPTR=array_pointer, SHAPE=pointer_shape)
         CALL AssignArrayPointer (array_pointer=array_pointer, array_target=array_pointer(::strides(1)), &
        & lower_bounds=lower_bounds)
      END SUBROUTINE
      SUBROUTINE ReshapeArrayPointer_i_sp2 (array_pointer, array_target, lower_bounds, upper_bounds)
         INTEGER (KIND=i_wp), DIMENSION (2), INTENT (IN) :: lower_bounds, upper_bounds
         INTEGER (KIND=i_sp), DIMENSION (:, :), POINTER :: array_pointer
         INTEGER (KIND=i_sp), DIMENSION (:), INTENT (IN), TARGET :: array_target
         INTEGER (KIND=C_ADDRESS) :: base_address
         INTEGER (KIND=i_wp), DIMENSION (2) :: pointer_shape
         INTEGER (KIND=C_INT), DIMENSION (2) :: strides
         pointer_shape = upper_bounds - lower_bounds + 1
         IF (Int(SIZE(array_target), KIND=i_wp) < PRODUCT(pointer_shape)) THEN
            NULLIFY (array_pointer)
            RETURN
         END IF
         strides = 1
         IF (Int(SIZE(array_target), KIND=i_wp) > 1) THEN
            strides (1) = C_STRIDE (array_target(1), array_target(2))
         END IF
         pointer_shape = pointer_shape * (strides)
         base_address = C_LOC (array_target)
         CALL C_F_POINTER (CPTR=base_address, FPTR=array_pointer, SHAPE=pointer_shape)
         CALL AssignArrayPointer (array_pointer=array_pointer, array_target=array_pointer(::strides(1), ::strides(2)), &
        & lower_bounds=lower_bounds)
      END SUBROUTINE
      SUBROUTINE ReshapeArrayPointer_i_dp2 (array_pointer, array_target, lower_bounds, upper_bounds)
         INTEGER (KIND=i_wp), DIMENSION (2), INTENT (IN) :: lower_bounds, upper_bounds
         INTEGER (KIND=i_dp), DIMENSION (:, :), POINTER :: array_pointer
         INTEGER (KIND=i_dp), DIMENSION (:), INTENT (IN), TARGET :: array_target
         INTEGER (KIND=C_ADDRESS) :: base_address
         INTEGER (KIND=i_wp), DIMENSION (2) :: pointer_shape
         INTEGER (KIND=C_INT), DIMENSION (2) :: strides
         pointer_shape = upper_bounds - lower_bounds + 1
         IF (Int(SIZE(array_target), KIND=i_wp) < PRODUCT(pointer_shape)) THEN
            NULLIFY (array_pointer)
            RETURN
         END IF
         strides = 1
         IF (Int(SIZE(array_target), KIND=i_wp) > 1) THEN
            strides (1) = C_STRIDE (array_target(1), array_target(2))
         END IF
         pointer_shape = pointer_shape * (strides)
         base_address = C_LOC (array_target)
         CALL C_F_POINTER (CPTR=base_address, FPTR=array_pointer, SHAPE=pointer_shape)
         CALL AssignArrayPointer (array_pointer=array_pointer, array_target=array_pointer(::strides(1), ::strides(2)), &
        & lower_bounds=lower_bounds)
      END SUBROUTINE
      SUBROUTINE ReshapeArrayPointer_r_sp2 (array_pointer, array_target, lower_bounds, upper_bounds)
         INTEGER (KIND=i_wp), DIMENSION (2), INTENT (IN) :: lower_bounds, upper_bounds
         REAL (KIND=r_sp), DIMENSION (:, :), POINTER :: array_pointer
         REAL (KIND=r_sp), DIMENSION (:), INTENT (IN), TARGET :: array_target
         INTEGER (KIND=C_ADDRESS) :: base_address
         INTEGER (KIND=i_wp), DIMENSION (2) :: pointer_shape
         INTEGER (KIND=C_INT), DIMENSION (2) :: strides
         pointer_shape = upper_bounds - lower_bounds + 1
         IF (Int(SIZE(array_target), KIND=i_wp) < PRODUCT(pointer_shape)) THEN
            NULLIFY (array_pointer)
            RETURN
         END IF
         strides = 1
         IF (Int(SIZE(array_target), KIND=i_wp) > 1) THEN
            strides (1) = C_STRIDE (array_target(1), array_target(2))
         END IF
         pointer_shape = pointer_shape * (strides)
         base_address = C_LOC (array_target)
         CALL C_F_POINTER (CPTR=base_address, FPTR=array_pointer, SHAPE=pointer_shape)
         CALL AssignArrayPointer (array_pointer=array_pointer, array_target=array_pointer(::strides(1), ::strides(2)), &
        & lower_bounds=lower_bounds)
      END SUBROUTINE
      SUBROUTINE ReshapeArrayPointer_r_dp2 (array_pointer, array_target, lower_bounds, upper_bounds)
         INTEGER (KIND=i_wp), DIMENSION (2), INTENT (IN) :: lower_bounds, upper_bounds
         REAL (KIND=r_dp), DIMENSION (:, :), POINTER :: array_pointer
         REAL (KIND=r_dp), DIMENSION (:), INTENT (IN), TARGET :: array_target
         INTEGER (KIND=C_ADDRESS) :: base_address
         INTEGER (KIND=i_wp), DIMENSION (2) :: pointer_shape
         INTEGER (KIND=C_INT), DIMENSION (2) :: strides
         pointer_shape = upper_bounds - lower_bounds + 1
         IF (Int(SIZE(array_target), KIND=i_wp) < PRODUCT(pointer_shape)) THEN
            NULLIFY (array_pointer)
            RETURN
         END IF
         strides = 1
         IF (Int(SIZE(array_target), KIND=i_wp) > 1) THEN
            strides (1) = C_STRIDE (array_target(1), array_target(2))
         END IF
         pointer_shape = pointer_shape * (strides)
         base_address = C_LOC (array_target)
         CALL C_F_POINTER (CPTR=base_address, FPTR=array_pointer, SHAPE=pointer_shape)
         CALL AssignArrayPointer (array_pointer=array_pointer, array_target=array_pointer(::strides(1), ::strides(2)), &
        & lower_bounds=lower_bounds)
      END SUBROUTINE
      SUBROUTINE ReshapeArrayPointer_l_word2 (array_pointer, array_target, lower_bounds, upper_bounds)
         INTEGER (KIND=i_wp), DIMENSION (2), INTENT (IN) :: lower_bounds, upper_bounds
         LOGICAL (KIND=l_word), DIMENSION (:, :), POINTER :: array_pointer
         LOGICAL (KIND=l_word), DIMENSION (:), INTENT (IN), TARGET :: array_target
         INTEGER (KIND=C_ADDRESS) :: base_address
         INTEGER (KIND=i_wp), DIMENSION (2) :: pointer_shape
         INTEGER (KIND=C_INT), DIMENSION (2) :: strides
         pointer_shape = upper_bounds - lower_bounds + 1
         IF (Int(SIZE(array_target), KIND=i_wp) < PRODUCT(pointer_shape)) THEN
            NULLIFY (array_pointer)
            RETURN
         END IF
         strides = 1
         IF (Int(SIZE(array_target), KIND=i_wp) > 1) THEN
            strides (1) = C_STRIDE (array_target(1), array_target(2))
         END IF
         pointer_shape = pointer_shape * (strides)
         base_address = C_LOC (array_target)
         CALL C_F_POINTER (CPTR=base_address, FPTR=array_pointer, SHAPE=pointer_shape)
         CALL AssignArrayPointer (array_pointer=array_pointer, array_target=array_pointer(::strides(1), ::strides(2)), &
        & lower_bounds=lower_bounds)
      END SUBROUTINE
      SUBROUTINE ReshapeArrayPointer_i_sp3 (array_pointer, array_target, lower_bounds, upper_bounds)
         INTEGER (KIND=i_wp), DIMENSION (3), INTENT (IN) :: lower_bounds, upper_bounds
         INTEGER (KIND=i_sp), DIMENSION (:, :, :), POINTER :: array_pointer
         INTEGER (KIND=i_sp), DIMENSION (:), INTENT (IN), TARGET :: array_target
         INTEGER (KIND=C_ADDRESS) :: base_address
         INTEGER (KIND=i_wp), DIMENSION (3) :: pointer_shape
         INTEGER (KIND=C_INT), DIMENSION (3) :: strides
         pointer_shape = upper_bounds - lower_bounds + 1
         IF (Int(SIZE(array_target), KIND=i_wp) < PRODUCT(pointer_shape)) THEN
            NULLIFY (array_pointer)
            RETURN
         END IF
         strides = 1
         IF (Int(SIZE(array_target), KIND=i_wp) > 1) THEN
            strides (1) = C_STRIDE (array_target(1), array_target(2))
         END IF
         pointer_shape = pointer_shape * (strides)
         base_address = C_LOC (array_target)
         CALL C_F_POINTER (CPTR=base_address, FPTR=array_pointer, SHAPE=pointer_shape)
         CALL AssignArrayPointer (array_pointer=array_pointer, array_target=array_pointer(::strides(1), ::strides(2), &
        & ::strides(3)), lower_bounds=lower_bounds)
      END SUBROUTINE
      SUBROUTINE ReshapeArrayPointer_i_dp3 (array_pointer, array_target, lower_bounds, upper_bounds)
         INTEGER (KIND=i_wp), DIMENSION (3), INTENT (IN) :: lower_bounds, upper_bounds
         INTEGER (KIND=i_dp), DIMENSION (:, :, :), POINTER :: array_pointer
         INTEGER (KIND=i_dp), DIMENSION (:), INTENT (IN), TARGET :: array_target
         INTEGER (KIND=C_ADDRESS) :: base_address
         INTEGER (KIND=i_wp), DIMENSION (3) :: pointer_shape
         INTEGER (KIND=C_INT), DIMENSION (3) :: strides
         pointer_shape = upper_bounds - lower_bounds + 1
         IF (Int(SIZE(array_target), KIND=i_wp) < PRODUCT(pointer_shape)) THEN
            NULLIFY (array_pointer)
            RETURN
         END IF
         strides = 1
         IF (Int(SIZE(array_target), KIND=i_wp) > 1) THEN
            strides (1) = C_STRIDE (array_target(1), array_target(2))
         END IF
         pointer_shape = pointer_shape * (strides)
         base_address = C_LOC (array_target)
         CALL C_F_POINTER (CPTR=base_address, FPTR=array_pointer, SHAPE=pointer_shape)
         CALL AssignArrayPointer (array_pointer=array_pointer, array_target=array_pointer(::strides(1), ::strides(2), &
        & ::strides(3)), lower_bounds=lower_bounds)
      END SUBROUTINE
      SUBROUTINE ReshapeArrayPointer_r_sp3 (array_pointer, array_target, lower_bounds, upper_bounds)
         INTEGER (KIND=i_wp), DIMENSION (3), INTENT (IN) :: lower_bounds, upper_bounds
         REAL (KIND=r_sp), DIMENSION (:, :, :), POINTER :: array_pointer
         REAL (KIND=r_sp), DIMENSION (:), INTENT (IN), TARGET :: array_target
         INTEGER (KIND=C_ADDRESS) :: base_address
         INTEGER (KIND=i_wp), DIMENSION (3) :: pointer_shape
         INTEGER (KIND=C_INT), DIMENSION (3) :: strides
         pointer_shape = upper_bounds - lower_bounds + 1
         IF (Int(SIZE(array_target), KIND=i_wp) < PRODUCT(pointer_shape)) THEN
            NULLIFY (array_pointer)
            RETURN
         END IF
         strides = 1
         IF (Int(SIZE(array_target), KIND=i_wp) > 1) THEN
            strides (1) = C_STRIDE (array_target(1), array_target(2))
         END IF
         pointer_shape = pointer_shape * (strides)
         base_address = C_LOC (array_target)
         CALL C_F_POINTER (CPTR=base_address, FPTR=array_pointer, SHAPE=pointer_shape)
         CALL AssignArrayPointer (array_pointer=array_pointer, array_target=array_pointer(::strides(1), ::strides(2), &
        & ::strides(3)), lower_bounds=lower_bounds)
      END SUBROUTINE
      SUBROUTINE ReshapeArrayPointer_r_dp3 (array_pointer, array_target, lower_bounds, upper_bounds)
         INTEGER (KIND=i_wp), DIMENSION (3), INTENT (IN) :: lower_bounds, upper_bounds
         REAL (KIND=r_dp), DIMENSION (:, :, :), POINTER :: array_pointer
         REAL (KIND=r_dp), DIMENSION (:), INTENT (IN), TARGET :: array_target
         INTEGER (KIND=C_ADDRESS) :: base_address
         INTEGER (KIND=i_wp), DIMENSION (3) :: pointer_shape
         INTEGER (KIND=C_INT), DIMENSION (3) :: strides
         pointer_shape = upper_bounds - lower_bounds + 1
         IF (Int(SIZE(array_target), KIND=i_wp) < PRODUCT(pointer_shape)) THEN
            NULLIFY (array_pointer)
            RETURN
         END IF
         strides = 1
         IF (Int(SIZE(array_target), KIND=i_wp) > 1) THEN
            strides (1) = C_STRIDE (array_target(1), array_target(2))
         END IF
         pointer_shape = pointer_shape * (strides)
         base_address = C_LOC (array_target)
         CALL C_F_POINTER (CPTR=base_address, FPTR=array_pointer, SHAPE=pointer_shape)
         CALL AssignArrayPointer (array_pointer=array_pointer, array_target=array_pointer(::strides(1), ::strides(2), &
        & ::strides(3)), lower_bounds=lower_bounds)
      END SUBROUTINE
      SUBROUTINE ReshapeArrayPointer_l_word3 (array_pointer, array_target, lower_bounds, upper_bounds)
         INTEGER (KIND=i_wp), DIMENSION (3), INTENT (IN) :: lower_bounds, upper_bounds
         LOGICAL (KIND=l_word), DIMENSION (:, :, :), POINTER :: array_pointer
         LOGICAL (KIND=l_word), DIMENSION (:), INTENT (IN), TARGET :: array_target
         INTEGER (KIND=C_ADDRESS) :: base_address
         INTEGER (KIND=i_wp), DIMENSION (3) :: pointer_shape
         INTEGER (KIND=C_INT), DIMENSION (3) :: strides
         pointer_shape = upper_bounds - lower_bounds + 1
         IF (Int(SIZE(array_target), KIND=i_wp) < PRODUCT(pointer_shape)) THEN
            NULLIFY (array_pointer)
            RETURN
         END IF
         strides = 1
         IF (Int(SIZE(array_target), KIND=i_wp) > 1) THEN
            strides (1) = C_STRIDE (array_target(1), array_target(2))
         END IF
         pointer_shape = pointer_shape * (strides)
         base_address = C_LOC (array_target)
         CALL C_F_POINTER (CPTR=base_address, FPTR=array_pointer, SHAPE=pointer_shape)
         CALL AssignArrayPointer (array_pointer=array_pointer, array_target=array_pointer(::strides(1), ::strides(2), &
        & ::strides(3)), lower_bounds=lower_bounds)
      END SUBROUTINE
      SUBROUTINE ReshapeArrayPointer_i_sp4 (array_pointer, array_target, lower_bounds, upper_bounds)
         INTEGER (KIND=i_wp), DIMENSION (4), INTENT (IN) :: lower_bounds, upper_bounds
         INTEGER (KIND=i_sp), DIMENSION (:, :, :, :), POINTER :: array_pointer
         INTEGER (KIND=i_sp), DIMENSION (:), INTENT (IN), TARGET :: array_target
         INTEGER (KIND=C_ADDRESS) :: base_address
         INTEGER (KIND=i_wp), DIMENSION (4) :: pointer_shape
         INTEGER (KIND=C_INT), DIMENSION (4) :: strides
         pointer_shape = upper_bounds - lower_bounds + 1
         IF (Int(SIZE(array_target), KIND=i_wp) < PRODUCT(pointer_shape)) THEN
            NULLIFY (array_pointer)
            RETURN
         END IF
         strides = 1
         IF (Int(SIZE(array_target), KIND=i_wp) > 1) THEN
            strides (1) = C_STRIDE (array_target(1), array_target(2))
         END IF
         pointer_shape = pointer_shape * (strides)
         base_address = C_LOC (array_target)
         CALL C_F_POINTER (CPTR=base_address, FPTR=array_pointer, SHAPE=pointer_shape)
         CALL AssignArrayPointer (array_pointer=array_pointer, array_target=array_pointer(::strides(1), ::strides(2), &
        & ::strides(3), ::strides(4)), lower_bounds=lower_bounds)
      END SUBROUTINE
      SUBROUTINE ReshapeArrayPointer_i_dp4 (array_pointer, array_target, lower_bounds, upper_bounds)
         INTEGER (KIND=i_wp), DIMENSION (4), INTENT (IN) :: lower_bounds, upper_bounds
         INTEGER (KIND=i_dp), DIMENSION (:, :, :, :), POINTER :: array_pointer
         INTEGER (KIND=i_dp), DIMENSION (:), INTENT (IN), TARGET :: array_target
         INTEGER (KIND=C_ADDRESS) :: base_address
         INTEGER (KIND=i_wp), DIMENSION (4) :: pointer_shape
         INTEGER (KIND=C_INT), DIMENSION (4) :: strides
         pointer_shape = upper_bounds - lower_bounds + 1
         IF (Int(SIZE(array_target), KIND=i_wp) < PRODUCT(pointer_shape)) THEN
            NULLIFY (array_pointer)
            RETURN
         END IF
         strides = 1
         IF (Int(SIZE(array_target), KIND=i_wp) > 1) THEN
            strides (1) = C_STRIDE (array_target(1), array_target(2))
         END IF
         pointer_shape = pointer_shape * (strides)
         base_address = C_LOC (array_target)
         CALL C_F_POINTER (CPTR=base_address, FPTR=array_pointer, SHAPE=pointer_shape)
         CALL AssignArrayPointer (array_pointer=array_pointer, array_target=array_pointer(::strides(1), ::strides(2), &
        & ::strides(3), ::strides(4)), lower_bounds=lower_bounds)
      END SUBROUTINE
      SUBROUTINE ReshapeArrayPointer_r_sp4 (array_pointer, array_target, lower_bounds, upper_bounds)
         INTEGER (KIND=i_wp), DIMENSION (4), INTENT (IN) :: lower_bounds, upper_bounds
         REAL (KIND=r_sp), DIMENSION (:, :, :, :), POINTER :: array_pointer
         REAL (KIND=r_sp), DIMENSION (:), INTENT (IN), TARGET :: array_target
         INTEGER (KIND=C_ADDRESS) :: base_address
         INTEGER (KIND=i_wp), DIMENSION (4) :: pointer_shape
         INTEGER (KIND=C_INT), DIMENSION (4) :: strides
         pointer_shape = upper_bounds - lower_bounds + 1
         IF (Int(SIZE(array_target), KIND=i_wp) < PRODUCT(pointer_shape)) THEN
            NULLIFY (array_pointer)
            RETURN
         END IF
         strides = 1
         IF (Int(SIZE(array_target), KIND=i_wp) > 1) THEN
            strides (1) = C_STRIDE (array_target(1), array_target(2))
         END IF
         pointer_shape = pointer_shape * (strides)
         base_address = C_LOC (array_target)
         CALL C_F_POINTER (CPTR=base_address, FPTR=array_pointer, SHAPE=pointer_shape)
         CALL AssignArrayPointer (array_pointer=array_pointer, array_target=array_pointer(::strides(1), ::strides(2), &
        & ::strides(3), ::strides(4)), lower_bounds=lower_bounds)
      END SUBROUTINE
      SUBROUTINE ReshapeArrayPointer_r_dp4 (array_pointer, array_target, lower_bounds, upper_bounds)
         INTEGER (KIND=i_wp), DIMENSION (4), INTENT (IN) :: lower_bounds, upper_bounds
         REAL (KIND=r_dp), DIMENSION (:, :, :, :), POINTER :: array_pointer
         REAL (KIND=r_dp), DIMENSION (:), INTENT (IN), TARGET :: array_target
         INTEGER (KIND=C_ADDRESS) :: base_address
         INTEGER (KIND=i_wp), DIMENSION (4) :: pointer_shape
         INTEGER (KIND=C_INT), DIMENSION (4) :: strides
         pointer_shape = upper_bounds - lower_bounds + 1
         IF (Int(SIZE(array_target), KIND=i_wp) < PRODUCT(pointer_shape)) THEN
            NULLIFY (array_pointer)
            RETURN
         END IF
         strides = 1
         IF (Int(SIZE(array_target), KIND=i_wp) > 1) THEN
            strides (1) = C_STRIDE (array_target(1), array_target(2))
         END IF
         pointer_shape = pointer_shape * (strides)
         base_address = C_LOC (array_target)
         CALL C_F_POINTER (CPTR=base_address, FPTR=array_pointer, SHAPE=pointer_shape)
         CALL AssignArrayPointer (array_pointer=array_pointer, array_target=array_pointer(::strides(1), ::strides(2), &
        & ::strides(3), ::strides(4)), lower_bounds=lower_bounds)
      END SUBROUTINE
      SUBROUTINE ReshapeArrayPointer_l_word4 (array_pointer, array_target, lower_bounds, upper_bounds)
         INTEGER (KIND=i_wp), DIMENSION (4), INTENT (IN) :: lower_bounds, upper_bounds
         LOGICAL (KIND=l_word), DIMENSION (:, :, :, :), POINTER :: array_pointer
         LOGICAL (KIND=l_word), DIMENSION (:), INTENT (IN), TARGET :: array_target
         INTEGER (KIND=C_ADDRESS) :: base_address
         INTEGER (KIND=i_wp), DIMENSION (4) :: pointer_shape
         INTEGER (KIND=C_INT), DIMENSION (4) :: strides
         pointer_shape = upper_bounds - lower_bounds + 1
         IF (Int(SIZE(array_target), KIND=i_wp) < PRODUCT(pointer_shape)) THEN
            NULLIFY (array_pointer)
            RETURN
         END IF
         strides = 1
         IF (Int(SIZE(array_target), KIND=i_wp) > 1) THEN
            strides (1) = C_STRIDE (array_target(1), array_target(2))
         END IF
         pointer_shape = pointer_shape * (strides)
         base_address = C_LOC (array_target)
         CALL C_F_POINTER (CPTR=base_address, FPTR=array_pointer, SHAPE=pointer_shape)
         CALL AssignArrayPointer (array_pointer=array_pointer, array_target=array_pointer(::strides(1), ::strides(2), &
        & ::strides(3), ::strides(4)), lower_bounds=lower_bounds)
      END SUBROUTINE
      SUBROUTINE ReshapeArrayPointer_i_sp5 (array_pointer, array_target, lower_bounds, upper_bounds)
         INTEGER (KIND=i_wp), DIMENSION (5), INTENT (IN) :: lower_bounds, upper_bounds
         INTEGER (KIND=i_sp), DIMENSION (:, :, :, :, :), POINTER :: array_pointer
         INTEGER (KIND=i_sp), DIMENSION (:), INTENT (IN), TARGET :: array_target
         INTEGER (KIND=C_ADDRESS) :: base_address
         INTEGER (KIND=i_wp), DIMENSION (5) :: pointer_shape
         INTEGER (KIND=C_INT), DIMENSION (5) :: strides
         pointer_shape = upper_bounds - lower_bounds + 1
         IF (Int(SIZE(array_target), KIND=i_wp) < PRODUCT(pointer_shape)) THEN
            NULLIFY (array_pointer)
            RETURN
         END IF
         strides = 1
         IF (Int(SIZE(array_target), KIND=i_wp) > 1) THEN
            strides (1) = C_STRIDE (array_target(1), array_target(2))
         END IF
         pointer_shape = pointer_shape * (strides)
         base_address = C_LOC (array_target)
         CALL C_F_POINTER (CPTR=base_address, FPTR=array_pointer, SHAPE=pointer_shape)
         CALL AssignArrayPointer (array_pointer=array_pointer, array_target=array_pointer(::strides(1), ::strides(2), &
        & ::strides(3), ::strides(4), ::strides(5)), lower_bounds=lower_bounds)
      END SUBROUTINE
      SUBROUTINE ReshapeArrayPointer_i_dp5 (array_pointer, array_target, lower_bounds, upper_bounds)
         INTEGER (KIND=i_wp), DIMENSION (5), INTENT (IN) :: lower_bounds, upper_bounds
         INTEGER (KIND=i_dp), DIMENSION (:, :, :, :, :), POINTER :: array_pointer
         INTEGER (KIND=i_dp), DIMENSION (:), INTENT (IN), TARGET :: array_target
         INTEGER (KIND=C_ADDRESS) :: base_address
         INTEGER (KIND=i_wp), DIMENSION (5) :: pointer_shape
         INTEGER (KIND=C_INT), DIMENSION (5) :: strides
         pointer_shape = upper_bounds - lower_bounds + 1
         IF (Int(SIZE(array_target), KIND=i_wp) < PRODUCT(pointer_shape)) THEN
            NULLIFY (array_pointer)
            RETURN
         END IF
         strides = 1
         IF (Int(SIZE(array_target), KIND=i_wp) > 1) THEN
            strides (1) = C_STRIDE (array_target(1), array_target(2))
         END IF
         pointer_shape = pointer_shape * (strides)
         base_address = C_LOC (array_target)
         CALL C_F_POINTER (CPTR=base_address, FPTR=array_pointer, SHAPE=pointer_shape)
         CALL AssignArrayPointer (array_pointer=array_pointer, array_target=array_pointer(::strides(1), ::strides(2), &
        & ::strides(3), ::strides(4), ::strides(5)), lower_bounds=lower_bounds)
      END SUBROUTINE
      SUBROUTINE ReshapeArrayPointer_r_sp5 (array_pointer, array_target, lower_bounds, upper_bounds)
         INTEGER (KIND=i_wp), DIMENSION (5), INTENT (IN) :: lower_bounds, upper_bounds
         REAL (KIND=r_sp), DIMENSION (:, :, :, :, :), POINTER :: array_pointer
         REAL (KIND=r_sp), DIMENSION (:), INTENT (IN), TARGET :: array_target
         INTEGER (KIND=C_ADDRESS) :: base_address
         INTEGER (KIND=i_wp), DIMENSION (5) :: pointer_shape
         INTEGER (KIND=C_INT), DIMENSION (5) :: strides
         pointer_shape = upper_bounds - lower_bounds + 1
         IF (Int(SIZE(array_target), KIND=i_wp) < PRODUCT(pointer_shape)) THEN
            NULLIFY (array_pointer)
            RETURN
         END IF
         strides = 1
         IF (Int(SIZE(array_target), KIND=i_wp) > 1) THEN
            strides (1) = C_STRIDE (array_target(1), array_target(2))
         END IF
         pointer_shape = pointer_shape * (strides)
         base_address = C_LOC (array_target)
         CALL C_F_POINTER (CPTR=base_address, FPTR=array_pointer, SHAPE=pointer_shape)
         CALL AssignArrayPointer (array_pointer=array_pointer, array_target=array_pointer(::strides(1), ::strides(2), &
        & ::strides(3), ::strides(4), ::strides(5)), lower_bounds=lower_bounds)
      END SUBROUTINE
      SUBROUTINE ReshapeArrayPointer_r_dp5 (array_pointer, array_target, lower_bounds, upper_bounds)
         INTEGER (KIND=i_wp), DIMENSION (5), INTENT (IN) :: lower_bounds, upper_bounds
         REAL (KIND=r_dp), DIMENSION (:, :, :, :, :), POINTER :: array_pointer
         REAL (KIND=r_dp), DIMENSION (:), INTENT (IN), TARGET :: array_target
         INTEGER (KIND=C_ADDRESS) :: base_address
         INTEGER (KIND=i_wp), DIMENSION (5) :: pointer_shape
         INTEGER (KIND=C_INT), DIMENSION (5) :: strides
         pointer_shape = upper_bounds - lower_bounds + 1
         IF (Int(SIZE(array_target), KIND=i_wp) < PRODUCT(pointer_shape)) THEN
            NULLIFY (array_pointer)
            RETURN
         END IF
         strides = 1
         IF (Int(SIZE(array_target), KIND=i_wp) > 1) THEN
            strides (1) = C_STRIDE (array_target(1), array_target(2))
         END IF
         pointer_shape = pointer_shape * (strides)
         base_address = C_LOC (array_target)
         CALL C_F_POINTER (CPTR=base_address, FPTR=array_pointer, SHAPE=pointer_shape)
         CALL AssignArrayPointer (array_pointer=array_pointer, array_target=array_pointer(::strides(1), ::strides(2), &
        & ::strides(3), ::strides(4), ::strides(5)), lower_bounds=lower_bounds)
      END SUBROUTINE
      SUBROUTINE ReshapeArrayPointer_l_word5 (array_pointer, array_target, lower_bounds, upper_bounds)
         INTEGER (KIND=i_wp), DIMENSION (5), INTENT (IN) :: lower_bounds, upper_bounds
         LOGICAL (KIND=l_word), DIMENSION (:, :, :, :, :), POINTER :: array_pointer
         LOGICAL (KIND=l_word), DIMENSION (:), INTENT (IN), TARGET :: array_target
         INTEGER (KIND=C_ADDRESS) :: base_address
         INTEGER (KIND=i_wp), DIMENSION (5) :: pointer_shape
         INTEGER (KIND=C_INT), DIMENSION (5) :: strides
         pointer_shape = upper_bounds - lower_bounds + 1
         IF (Int(SIZE(array_target), KIND=i_wp) < PRODUCT(pointer_shape)) THEN
            NULLIFY (array_pointer)
            RETURN
         END IF
         strides = 1
         IF (Int(SIZE(array_target), KIND=i_wp) > 1) THEN
            strides (1) = C_STRIDE (array_target(1), array_target(2))
         END IF
         pointer_shape = pointer_shape * (strides)
         base_address = C_LOC (array_target)
         CALL C_F_POINTER (CPTR=base_address, FPTR=array_pointer, SHAPE=pointer_shape)
         CALL AssignArrayPointer (array_pointer=array_pointer, array_target=array_pointer(::strides(1), ::strides(2), &
        & ::strides(3), ::strides(4), ::strides(5)), lower_bounds=lower_bounds)
      END SUBROUTINE
      SUBROUTINE AssignArrayPointer_i_sp1 (array_pointer, array_target, lower_bounds)
         INTEGER (KIND=i_wp), DIMENSION (1), INTENT (IN) :: lower_bounds
         INTEGER (KIND=i_sp), DIMENSION (:), POINTER :: array_pointer
         INTEGER (KIND=i_sp), DIMENSION (lower_bounds(1) :), INTENT (IN), TARGET :: array_target
         array_pointer => array_target
      END SUBROUTINE
      SUBROUTINE AssignArrayPointer_i_dp1 (array_pointer, array_target, lower_bounds)
         INTEGER (KIND=i_wp), DIMENSION (1), INTENT (IN) :: lower_bounds
         INTEGER (KIND=i_dp), DIMENSION (:), POINTER :: array_pointer
         INTEGER (KIND=i_dp), DIMENSION (lower_bounds(1) :), INTENT (IN), TARGET :: array_target
         array_pointer => array_target
      END SUBROUTINE
      SUBROUTINE AssignArrayPointer_r_sp1 (array_pointer, array_target, lower_bounds)
         INTEGER (KIND=i_wp), DIMENSION (1), INTENT (IN) :: lower_bounds
         REAL (KIND=r_sp), DIMENSION (:), POINTER :: array_pointer
         REAL (KIND=r_sp), DIMENSION (lower_bounds(1) :), INTENT (IN), TARGET :: array_target
         array_pointer => array_target
      END SUBROUTINE
      SUBROUTINE AssignArrayPointer_r_dp1 (array_pointer, array_target, lower_bounds)
         INTEGER (KIND=i_wp), DIMENSION (1), INTENT (IN) :: lower_bounds
         REAL (KIND=r_dp), DIMENSION (:), POINTER :: array_pointer
         REAL (KIND=r_dp), DIMENSION (lower_bounds(1) :), INTENT (IN), TARGET :: array_target
         array_pointer => array_target
      END SUBROUTINE
      SUBROUTINE AssignArrayPointer_l_word1 (array_pointer, array_target, lower_bounds)
         INTEGER (KIND=i_wp), DIMENSION (1), INTENT (IN) :: lower_bounds
         LOGICAL (KIND=l_word), DIMENSION (:), POINTER :: array_pointer
         LOGICAL (KIND=l_word), DIMENSION (lower_bounds(1) :), INTENT (IN), TARGET :: array_target
         array_pointer => array_target
      END SUBROUTINE
      SUBROUTINE AssignArrayPointer_i_sp2 (array_pointer, array_target, lower_bounds)
         INTEGER (KIND=i_wp), DIMENSION (2), INTENT (IN) :: lower_bounds
         INTEGER (KIND=i_sp), DIMENSION (:, :), POINTER :: array_pointer
         INTEGER (KIND=i_sp), DIMENSION (lower_bounds(1) :, lower_bounds(2) :), INTENT (IN), TARGET :: array_target
         array_pointer => array_target
      END SUBROUTINE
      SUBROUTINE AssignArrayPointer_i_dp2 (array_pointer, array_target, lower_bounds)
         INTEGER (KIND=i_wp), DIMENSION (2), INTENT (IN) :: lower_bounds
         INTEGER (KIND=i_dp), DIMENSION (:, :), POINTER :: array_pointer
         INTEGER (KIND=i_dp), DIMENSION (lower_bounds(1) :, lower_bounds(2) :), INTENT (IN), TARGET :: array_target
         array_pointer => array_target
      END SUBROUTINE
      SUBROUTINE AssignArrayPointer_r_sp2 (array_pointer, array_target, lower_bounds)
         INTEGER (KIND=i_wp), DIMENSION (2), INTENT (IN) :: lower_bounds
         REAL (KIND=r_sp), DIMENSION (:, :), POINTER :: array_pointer
         REAL (KIND=r_sp), DIMENSION (lower_bounds(1) :, lower_bounds(2) :), INTENT (IN), TARGET :: array_target
         array_pointer => array_target
      END SUBROUTINE
      SUBROUTINE AssignArrayPointer_r_dp2 (array_pointer, array_target, lower_bounds)
         INTEGER (KIND=i_wp), DIMENSION (2), INTENT (IN) :: lower_bounds
         REAL (KIND=r_dp), DIMENSION (:, :), POINTER :: array_pointer
         REAL (KIND=r_dp), DIMENSION (lower_bounds(1) :, lower_bounds(2) :), INTENT (IN), TARGET :: array_target
         array_pointer => array_target
      END SUBROUTINE
      SUBROUTINE AssignArrayPointer_l_word2 (array_pointer, array_target, lower_bounds)
         INTEGER (KIND=i_wp), DIMENSION (2), INTENT (IN) :: lower_bounds
         LOGICAL (KIND=l_word), DIMENSION (:, :), POINTER :: array_pointer
         LOGICAL (KIND=l_word), DIMENSION (lower_bounds(1) :, lower_bounds(2) :), INTENT (IN), TARGET :: array_target
         array_pointer => array_target
      END SUBROUTINE
      SUBROUTINE AssignArrayPointer_i_sp3 (array_pointer, array_target, lower_bounds)
         INTEGER (KIND=i_wp), DIMENSION (3), INTENT (IN) :: lower_bounds
         INTEGER (KIND=i_sp), DIMENSION (:, :, :), POINTER :: array_pointer
         INTEGER (KIND=i_sp), DIMENSION (lower_bounds(1) :, lower_bounds(2) :, lower_bounds(3) :), INTENT (IN), TARGET :: &
        & array_target
         array_pointer => array_target
      END SUBROUTINE
      SUBROUTINE AssignArrayPointer_i_dp3 (array_pointer, array_target, lower_bounds)
         INTEGER (KIND=i_wp), DIMENSION (3), INTENT (IN) :: lower_bounds
         INTEGER (KIND=i_dp), DIMENSION (:, :, :), POINTER :: array_pointer
         INTEGER (KIND=i_dp), DIMENSION (lower_bounds(1) :, lower_bounds(2) :, lower_bounds(3) :), INTENT (IN), TARGET :: &
        & array_target
         array_pointer => array_target
      END SUBROUTINE
      SUBROUTINE AssignArrayPointer_r_sp3 (array_pointer, array_target, lower_bounds)
         INTEGER (KIND=i_wp), DIMENSION (3), INTENT (IN) :: lower_bounds
         REAL (KIND=r_sp), DIMENSION (:, :, :), POINTER :: array_pointer
         REAL (KIND=r_sp), DIMENSION (lower_bounds(1) :, lower_bounds(2) :, lower_bounds(3) :), INTENT (IN), TARGET :: &
        & array_target
         array_pointer => array_target
      END SUBROUTINE
      SUBROUTINE AssignArrayPointer_r_dp3 (array_pointer, array_target, lower_bounds)
         INTEGER (KIND=i_wp), DIMENSION (3), INTENT (IN) :: lower_bounds
         REAL (KIND=r_dp), DIMENSION (:, :, :), POINTER :: array_pointer
         REAL (KIND=r_dp), DIMENSION (lower_bounds(1) :, lower_bounds(2) :, lower_bounds(3) :), INTENT (IN), TARGET :: &
        & array_target
         array_pointer => array_target
      END SUBROUTINE
      SUBROUTINE AssignArrayPointer_l_word3 (array_pointer, array_target, lower_bounds)
         INTEGER (KIND=i_wp), DIMENSION (3), INTENT (IN) :: lower_bounds
         LOGICAL (KIND=l_word), DIMENSION (:, :, :), POINTER :: array_pointer
         LOGICAL (KIND=l_word), DIMENSION (lower_bounds(1) :, lower_bounds(2) :, lower_bounds(3) :), INTENT (IN), TARGET :: &
        & array_target
         array_pointer => array_target
      END SUBROUTINE
      SUBROUTINE AssignArrayPointer_i_sp4 (array_pointer, array_target, lower_bounds)
         INTEGER (KIND=i_wp), DIMENSION (4), INTENT (IN) :: lower_bounds
         INTEGER (KIND=i_sp), DIMENSION (:, :, :, :), POINTER :: array_pointer
         INTEGER (KIND=i_sp), DIMENSION (lower_bounds(1) :, lower_bounds(2) :, lower_bounds(3) :, lower_bounds(4) :), INTENT &
        & (IN), TARGET :: array_target
         array_pointer => array_target
      END SUBROUTINE
      SUBROUTINE AssignArrayPointer_i_dp4 (array_pointer, array_target, lower_bounds)
         INTEGER (KIND=i_wp), DIMENSION (4), INTENT (IN) :: lower_bounds
         INTEGER (KIND=i_dp), DIMENSION (:, :, :, :), POINTER :: array_pointer
         INTEGER (KIND=i_dp), DIMENSION (lower_bounds(1) :, lower_bounds(2) :, lower_bounds(3) :, lower_bounds(4) :), INTENT &
        & (IN), TARGET :: array_target
         array_pointer => array_target
      END SUBROUTINE
      SUBROUTINE AssignArrayPointer_r_sp4 (array_pointer, array_target, lower_bounds)
         INTEGER (KIND=i_wp), DIMENSION (4), INTENT (IN) :: lower_bounds
         REAL (KIND=r_sp), DIMENSION (:, :, :, :), POINTER :: array_pointer
         REAL (KIND=r_sp), DIMENSION (lower_bounds(1) :, lower_bounds(2) :, lower_bounds(3) :, lower_bounds(4) :), INTENT (IN), &
        & TARGET :: array_target
         array_pointer => array_target
      END SUBROUTINE
      SUBROUTINE AssignArrayPointer_r_dp4 (array_pointer, array_target, lower_bounds)
         INTEGER (KIND=i_wp), DIMENSION (4), INTENT (IN) :: lower_bounds
         REAL (KIND=r_dp), DIMENSION (:, :, :, :), POINTER :: array_pointer
         REAL (KIND=r_dp), DIMENSION (lower_bounds(1) :, lower_bounds(2) :, lower_bounds(3) :, lower_bounds(4) :), INTENT (IN), &
        & TARGET :: array_target
         array_pointer => array_target
      END SUBROUTINE
      SUBROUTINE AssignArrayPointer_l_word4 (array_pointer, array_target, lower_bounds)
         INTEGER (KIND=i_wp), DIMENSION (4), INTENT (IN) :: lower_bounds
         LOGICAL (KIND=l_word), DIMENSION (:, :, :, :), POINTER :: array_pointer
         LOGICAL (KIND=l_word), DIMENSION (lower_bounds(1) :, lower_bounds(2) :, lower_bounds(3) :, lower_bounds(4) :), INTENT &
        & (IN), TARGET :: array_target
         array_pointer => array_target
      END SUBROUTINE
      SUBROUTINE AssignArrayPointer_i_sp5 (array_pointer, array_target, lower_bounds)
         INTEGER (KIND=i_wp), DIMENSION (5), INTENT (IN) :: lower_bounds
         INTEGER (KIND=i_sp), DIMENSION (:, :, :, :, :), POINTER :: array_pointer
         INTEGER (KIND=i_sp), DIMENSION (lower_bounds(1) :, lower_bounds(2) :, lower_bounds(3) :, lower_bounds(4) :, &
        & lower_bounds(5) :), INTENT (IN), TARGET :: array_target
         array_pointer => array_target
      END SUBROUTINE
      SUBROUTINE AssignArrayPointer_i_dp5 (array_pointer, array_target, lower_bounds)
         INTEGER (KIND=i_wp), DIMENSION (5), INTENT (IN) :: lower_bounds
         INTEGER (KIND=i_dp), DIMENSION (:, :, :, :, :), POINTER :: array_pointer
         INTEGER (KIND=i_dp), DIMENSION (lower_bounds(1) :, lower_bounds(2) :, lower_bounds(3) :, lower_bounds(4) :, &
        & lower_bounds(5) :), INTENT (IN), TARGET :: array_target
         array_pointer => array_target
      END SUBROUTINE
      SUBROUTINE AssignArrayPointer_r_sp5 (array_pointer, array_target, lower_bounds)
         INTEGER (KIND=i_wp), DIMENSION (5), INTENT (IN) :: lower_bounds
         REAL (KIND=r_sp), DIMENSION (:, :, :, :, :), POINTER :: array_pointer
         REAL (KIND=r_sp), DIMENSION (lower_bounds(1) :, lower_bounds(2) :, lower_bounds(3) :, lower_bounds(4) :, lower_bounds(5) &
        & :), INTENT (IN), TARGET :: array_target
         array_pointer => array_target
      END SUBROUTINE
      SUBROUTINE AssignArrayPointer_r_dp5 (array_pointer, array_target, lower_bounds)
         INTEGER (KIND=i_wp), DIMENSION (5), INTENT (IN) :: lower_bounds
         REAL (KIND=r_dp), DIMENSION (:, :, :, :, :), POINTER :: array_pointer
         REAL (KIND=r_dp), DIMENSION (lower_bounds(1) :, lower_bounds(2) :, lower_bounds(3) :, lower_bounds(4) :, lower_bounds(5) &
        & :), INTENT (IN), TARGET :: array_target
         array_pointer => array_target
      END SUBROUTINE
      SUBROUTINE AssignArrayPointer_l_word5 (array_pointer, array_target, lower_bounds)
         INTEGER (KIND=i_wp), DIMENSION (5), INTENT (IN) :: lower_bounds
         LOGICAL (KIND=l_word), DIMENSION (:, :, :, :, :), POINTER :: array_pointer
         LOGICAL (KIND=l_word), DIMENSION (lower_bounds(1) :, lower_bounds(2) :, lower_bounds(3) :, lower_bounds(4) :, &
        & lower_bounds(5) :), INTENT (IN), TARGET :: array_target
         array_pointer => array_target
      END SUBROUTINE
END MODULE F2x_Emulation